import org.jasypt.util.text.TextEncryptor; //导入依赖的package包/类
private PasswordManager(Optional<String> masterPassword, boolean useStrongEncryptor) {
  if (masterPassword.isPresent()) {
    this.encryptor = useStrongEncryptor ? Optional.of((TextEncryptor) new StrongTextEncryptor())
        : Optional.of((TextEncryptor) new BasicTextEncryptor());
    try {

      // setPassword() needs to be called via reflection since the TextEncryptor interface doesn't have this method.
      this.encryptor.get().getClass().getMethod("setPassword", String.class).invoke(this.encryptor.get(),
          masterPassword.get());
    } catch (Exception e) {
      LOG.error("Failed to set master password for encryptor", e);
      this.encryptor = Optional.absent();
    }
  } else {
    this.encryptor = Optional.absent();
  }
}
 

import org.jasypt.util.text.TextEncryptor; //导入依赖的package包/类
protected FindConfigFileService(final FilterProvider filterProvider,
                                final TextEncryptor textEncryptor,
                                final JsonSerializer<FieldPath> fieldPathSerializer,
                                final JsonDeserializer<FieldPath> fieldPathDeserializer) {

    final ObjectMapper objectMapper = new Jackson2ObjectMapperBuilder()
        .featuresToEnable(SerializationFeature.INDENT_OUTPUT)
        .mixIns(customMixins())
        .serializersByType(ImmutableMap.of(FieldPath.class, fieldPathSerializer))
        .deserializersByType(ImmutableMap.of(FieldPath.class, fieldPathDeserializer))
        .createXmlMapper(false)
        .build();

    setConfigFileLocation(CONFIG_FILE_LOCATION);
    setConfigFileName(CONFIG_FILE_NAME);
    setDefaultConfigFile(getDefaultConfigFile());
    setMapper(objectMapper);
    setTextEncryptor(textEncryptor);
    setFilterProvider(filterProvider);
}
 

import org.jasypt.util.text.TextEncryptor; //导入依赖的package包/类
public static void main(String[] args) throws ParseException {
  CommandLine cl = parseArgs(args);
  if (shouldPrintUsageAndExit(cl)) {
    printUsage();
    return;
  }
  String masterPassword = getMasterPassword(cl);
  TextEncryptor encryptor = getEncryptor(cl, masterPassword);

  if (cl.hasOption(ENCRYPTED_PWD_OPTION)) {
    Matcher matcher = ENCRYPTED_PATTERN.matcher(cl.getOptionValue(ENCRYPTED_PWD_OPTION));
    if (matcher.find()) {
      String encrypted = matcher.group(1);
      System.out.println(encryptor.decrypt(encrypted));
    } else {
      throw new RuntimeException("Input encrypted password does not match pattern \"ENC(...)\"");
    }
  } else if (cl.hasOption(PLAIN_PWD_OPTION)){
    System.out.println("ENC(" + encryptor.encrypt(cl.getOptionValue(PLAIN_PWD_OPTION)) + ")");
  } else {
    printUsage();
    throw new RuntimeException(String.format("Must provide -%s or -%s option.", PLAIN_PWD_OPTION, ENCRYPTED_PWD_OPTION));
  }
}
 

import org.jasypt.util.text.TextEncryptor; //导入依赖的package包/类
private synchronized String decode(final String encodedValue) {
    
    if (!PropertyValueEncryptionUtils.isEncryptedValue(encodedValue)) {
        return encodedValue;
    }
    final EncryptablePropertiesEncryptorRegistry registry =
        EncryptablePropertiesEncryptorRegistry.getInstance();
    final StringEncryptor stringEncryptor = registry.getStringEncryptor(this);
    if (stringEncryptor != null) {
        return PropertyValueEncryptionUtils.decrypt(encodedValue, stringEncryptor);
        
    }
    final TextEncryptor textEncryptor = registry.getTextEncryptor(this);
    if (textEncryptor != null) {
        return PropertyValueEncryptionUtils.decrypt(encodedValue, textEncryptor);
    }
    
    /*
     * If neither a StringEncryptor nor a TextEncryptor can be retrieved
     * from the registry, this means that this EncryptableProperties
     * object has been serialized and then deserialized in a different
     * classloader and virtual machine, which is an unsupported behaviour. 
     */
    throw new EncryptionOperationNotPossibleException(
            "Neither a string encryptor nor a text encryptor exist " +
            "for this instance of EncryptableProperties. This is usually " +
            "caused by the instance having been serialized and then " +
            "de-serialized in a different classloader or virtual machine, " +
            "which is an unsupported behaviour (as encryptors cannot be " +
            "serialized themselves)");
    
}
 

import org.jasypt.util.text.TextEncryptor; //导入依赖的package包/类
public static String encrypt(
        final String decodedValue, final TextEncryptor encryptor) {
    return 
        ENCRYPTED_VALUE_PREFIX + 
        encryptor.encrypt(decodedValue) +
        ENCRYPTED_VALUE_SUFFIX;
}
 

import org.jasypt.util.text.TextEncryptor; //导入依赖的package包/类
@Autowired
public HodFindConfigFileService(
        final FilterProvider filterProvider,
        final TextEncryptor textEncryptor,
        final JsonSerializer<FieldPath> fieldPathSerializer,
        final JsonDeserializer<FieldPath> fieldPathDeserializer) {
    super(filterProvider, textEncryptor, fieldPathSerializer, fieldPathDeserializer);
}
 

import org.jasypt.util.text.TextEncryptor; //导入依赖的package包/类
@Autowired
public IdolFindConfigFileService(
        final FilterProvider filterProvider,
        final TextEncryptor textEncryptor,
        final JsonSerializer<FieldPath> fieldPathSerializer,
        final JsonDeserializer<FieldPath> fieldPathDeserializer,
        final IdolConfigUpdateHandler idolConfigUpdateHandler
) {
    super(filterProvider, textEncryptor, fieldPathSerializer, fieldPathDeserializer);

    this.idolConfigUpdateHandler = idolConfigUpdateHandler;
}
 

import org.jasypt.util.text.TextEncryptor; //导入依赖的package包/类
@Bean
public TextEncryptor textEncryptor() {
    final FactoryBean<String> passwordFactory = new TextEncryptorPasswordFactory();

    final BasicTextEncryptor basicTextEncryptor = new BasicTextEncryptor();

    try {
        basicTextEncryptor.setPassword(passwordFactory.getObject());
    } catch(final Exception e) {
        throw new BeanInitializationException("Failed to initialize TextEncryptor for some reason", e);
    }

    return basicTextEncryptor;
}
 

import org.jasypt.util.text.TextEncryptor; //导入依赖的package包/类
public static String decrypt(
        final String encodedValue, final TextEncryptor encryptor) {
    return encryptor.decrypt(getInnerEncryptedValue(encodedValue.trim()));
}
 

import org.jasypt.util.text.TextEncryptor; //导入依赖的package包/类
TextEncryptor getTextEncryptor(final EncryptableProperties prop) {
    return (TextEncryptor) this.textEncryptors.get(prop.getIdent());
}
 

import org.jasypt.util.text.TextEncryptor; //导入依赖的package包/类
void setTextEncryptor(final EncryptableProperties prop, final TextEncryptor encryptor) {
    this.textEncryptors.put(prop.getIdent(), encryptor);
}
 

import org.jasypt.util.text.TextEncryptor; //导入依赖的package包/类
@Override
public HodFindConfig withEncryptedPasswords(final TextEncryptor encryptor) {
    return this;
}
 

import org.jasypt.util.text.TextEncryptor; //导入依赖的package包/类
@Override
public HodFindConfig withDecryptedPasswords(final TextEncryptor encryptor) {
    return this;
}
 

import org.jasypt.util.text.TextEncryptor; //导入依赖的package包/类
/**
 * <p>
 * Creates an <tt>EncryptableProperties</tt> instance which will use
 * the passed {@link TextEncryptor} object to decrypt encrypted values,
 * and the passed defaults as default values (may contain encrypted values).
 * </p>
 * 
 * @param defaults default values for properties (may be encrypted).
 * @param textEncryptor the {@link TextEncryptor} to be used do decrypt
 *                      values. It can not be null.
 */
public EncryptableProperties(final Properties defaults, final TextEncryptor textEncryptor) {
    super(defaults);
    CommonUtils.validateNotNull(textEncryptor, "Encryptor cannot be null");
    final EncryptablePropertiesEncryptorRegistry registry =
        EncryptablePropertiesEncryptorRegistry.getInstance();
    registry.setTextEncryptor(this, textEncryptor);
}
 

import org.jasypt.util.text.TextEncryptor; //导入依赖的package包/类
/**
 * If {@link T} is not a {@link PasswordsConfig}, this property need not be set.
 *
 * @param textEncryptor The {@link TextEncryptor} used to encrypt passwords.
 */
public void setTextEncryptor(final TextEncryptor textEncryptor) {
    this.textEncryptor = textEncryptor;
}
 

import org.jasypt.util.text.TextEncryptor; //导入依赖的package包/类
/**
 * @param encryptor object responsible for password encryption
 * @return A copy of this config with passwords encrypted by the supplied {@link TextEncryptor},
 * or this if the config has no passwords
 */
T withEncryptedPasswords(TextEncryptor encryptor);
 

import org.jasypt.util.text.TextEncryptor; //导入依赖的package包/类
/**
 * @param encryptor object responsible for password encryption
 * @return A copy of this config with passwords decrypted by the supplied {@link TextEncryptor},
 * or this if the config has no passwords
 */
T withDecryptedPasswords(TextEncryptor encryptor);