• 8.1 自定义`EncryptablePropertyDetector`
• 8.2 自定义加密属性前缀和后缀
• 8.3 自定义`EncryptablePropertyResolver`

• 9.1 `DefaultPropertyFilter`类的属性
• 9.2 自定义`EncryptablePropertyFilter`

• 11.1 Encryption
• 11.2 Decryption
• 11.3 Re-encryption
• 11.4 Upgrade
• 11.5 Load
• 11.6 加密并改变属性文件路径
• 11.7 加密Spring属性文件

• 12.1 配置属性
• 12.2 配置实例
• • 12.2.1 以字符串格式配置DER编码的秘钥
  • 12.2.2 配置项指定DER编码的秘钥文件路径
  • 12.2.3 以字符串格式配置PEM编码的秘钥
  • 12.2.4 配置项指定PEM编码的秘钥文件路径
• 12.3 Java代码加密属性
• • 12.3.1 DER格式
  • 12.3.2 PEM格式
• 13.Demo App
• 14.其它 demo app
• 15.参考

1. 简介

2. 如何整合

@Configuration
@EncryptablePropertySources({@EncryptablePropertySource("classpath:encrypted.properties"),@EncryptablePropertySource("classpath:encrypted2.properties")})
public class MyApplication {
	...
​ 另外，需要注意的是从1.8版本开始，@EncryptablePropertySource支持YAML文件.
 
3. 自定义环境
 
从版本1.15开始，支持使用第4种方法启用加密属性. 自定义一个ConfigurableEnvironment类，比如：EncryptableEnvironment、StandardEncryptableEnvironment、StandardEncryptableServletEnvironment，与SpringApplicationBuilder类一起使用，以这种方式自定义使用环境:
 
new SpringApplicationBuilder()
    .environment(new StandardEncryptableEnvironment())
    .sources(YourApplicationClass.class).run(args);
这个方法只需要使用jasypt-spring-boot的依赖. 不需要starter jar依赖项. 这种方法对于在启动过程中访问加密属性非常有用. 虽然在大多数场景中不是必需的，但在定制Spring Boot的初始化行为或整合某些初始化配置的功能时可能很有用(如日志配置)。举个具体的例子，在logback-spring.xml文件中，我们如果要对springProperty 标签的属性启用加密，这是唯一一种方法。例如:
 
<springProperty name="user" source="db.user"/>
<springProperty name="password" source="db.password"/>
<appender name="db" class="ch.qos.logback.classic.db.DBAppender">
    <connectionSource
        class="ch.qos.logback.core.db.DriverManagerConnectionSource">
        <driverClass>org.postgresql.Driver</driverClass>
        <url>jdbc:postgresql://localhost:5432/simple</url>
        <user>${user}</user>
        <password>${password}</password>
    </connectionSource>
</




    
appender>
使用这种机制可以用来初始化需要传递敏感凭证的数据库日志记录Appender（Database Logging Appender）。另外，我们需要提供一个自定义的StringEncryptor，以及一个静态构建器方法StandardEncryptableEnvironment#builder 来进行操作:
 
StandardEncryptableEnvironment
    .builder()
    .encryptor(new MyEncryptor())
    .build()
4. 工作原理
 
SpringBoot启用jasypt加密解密配置机制，会做如下2件事：
 
注册一个Spring post处理器，该处理器装饰了Spring环境中包含的所有PropertySource对象，使它们具有“加密标识”，当属性按照jasypt的约定进行加密时，注册的处理器可以检测到。
定义了一个默认的StringEncryptor，可以通过常规属性、系统属性或命令行参数配置。
 
5. 加密的属性如何处理
 
使用上文中提到的整合方法1和方法2时，可以在任何包含于spring环境的配置文件中定义加密的属性。例如，使用@PropertySource注释:
 
    @SpringBootApplication
    @EnableEncryptableProperties
    @PropertySource(name="EncryptedProperties", value = "classpath:encrypted.properties")
    public class MyApplication {
        ...
然后，配置文件中定义的属性使用如下标识定义：
 
	secret.property=ENC(nrmZtkF7T0kjG/VodDvBw93Ct8EgjCA+)
现在，当你使用environment.getProperty("secret.property")或使用@Value("${secret.property}")时，你得到的是secret.property的解密版本。
 
当使用整合方法3(@EncryptablePropertySource)时，获取加密属性的方式是相同的，唯一的区别是，Java配置类中要使用@EncryptablePropertySource注解。
 
6. 基于密码的加密配置
 
Jasypt 使用 StringEncryptor类来加密属性资源. 在上文提到的3种整合方法中, 如果Spring上下文中没有自定义的 StringEncryptor 类, 则会使用Jasypt默认的类，通过在配置文件中配置如下表格中的属性来起到加密解密的作用:
 
配置项
是否必须
默认值
jasypt.encryptor.password
True
-
jasypt.encryptor.algorithm
False
PBEWITHHMACSHA512ANDAES_256
jasypt.encryptor.key-obtention-iterations
False
1000
jasypt.encryptor.pool-size
False
1
jasypt.encryptor.provider-name
False
SunJCE
jasypt.encryptor.provider-class-name
False
null
jasypt.encryptor.salt-generator-classname
False
org.jasypt.salt.RandomSaltGenerator
jasypt.encryptor.iv-generator-classname
False
org.jasypt.iv.RandomIvGenerator
jasypt.encryptor.string-output-type
False
base64
jasypt.encryptor.proxy-property-sources
False
false
jasypt.encryptor.skip-property-sources
False
empty list
 
唯一必须的加密属性是加密密码，其余的配置项都可以使用默认值。虽然所有这些属性都可以在属性文件中声明，但加密器密码不应该存储在属性文件中，它应该作为系统属性、命令行参数或环境变量传递，只要它的名称是’ jasypt.encryptor '。
 
最后一个属性，jasypt.encryptor.proxyPropertySources用于标识jasypt -spring-boot如何截获属性值以进行解密。默认值为false时，使用PropertySource 、EnumerablePropertySource和MapPropertySource自定义的包装器实现。当为该属性指定true 时，拦截机制将在每个PropertySource标识的属性类上实现上使用CGLib代理。在必须保留原始“PropertySource”类型的某些场景中，这可能很有用。
 
7. 使用自定义的加密程序
 
当在spring上下文中使用自定义的StringEncryptor类时，默认的加密器将被忽略，我们可以自定义相关配置，比如：
 
    @Bean("jasyptStringEncryptor")
    public StringEncryptor stringEncryptor() {
        PooledPBEStringEncryptor encryptor = new PooledPBEStringEncryptor();
        SimpleStringPBEConfig config = new SimpleStringPBEConfig();
        config.setPassword("password");
        config.setAlgorithm("PBEWITHHMACSHA512ANDAES_256");
        config.setKeyObtentionIterations("1000");
        config.setPoolSize("1");
        config.setProviderName("SunJCE");
        config.setSaltGeneratorClassName("org.jasypt.salt.RandomSaltGenerator");
        config.setIvGeneratorClassName("org.jasypt.iv.RandomIvGenerator");
        config.setStringOutputType("base64");
        encryptor.setConfig(config);
        return encryptor;
注意，加密器的类名是一般是固定的，因为jasypt-spring-boot从1.5版本开始，是根据名称来检测自定义字符串加密器的。默认的类名是:
 
jasyptStringEncryptor
但是可以通过如下配置项来重写：
 
jasypt.encryptor.bean
举个例子, 如果 jasypt.encryptor.bean=encryptorBean ，那么，就可以使用encryptorBean这个名称来定义加密器:
 
    @Bean("encryptorBean")
    public StringEncryptor stringEncryptor() {
        ...
8. 自定义Property Detector, Prefix, Suffix 和 Resolver
 
在jasypt-spring-boot-1.10中有新的扩展，使用EncryptablePropertyResolver来解析所有的属性:
 
public interface EncryptablePropertyResolver {
    String resolvePropertyValue(String value);
8.1 自定义EncryptablePropertyDetector
 
定义一个名称为encryptablePropertyDetector的Java类，实现并重写EncryptablePropertyDetector接口。也可以通过配置项jasypt.encryptor.property.detector-bean 自己定义Java类的名称，而这样做后，则由定义的类来负责检测加密属性，如下例子:
 
private static class MyEncryptablePropertyDetector implements EncryptablePropertyDetector {
    @Override
    public boolean isEncrypted(String value) {
        if (value != null) {
            return value.startsWith("ENC@");
        return false;
    @Override
    public String unwrapEncryptedValue(String value) {
        return value.substring("ENC@".length());
@Bean(name = "encryptablePropertyDetector")
    public EncryptablePropertyDetector encryptablePropertyDetector() {
        return new MyEncryptablePropertyDetector();
8.2 自定义加密属性前缀和后缀
 
如果想为加密的属性添加不同的前缀/后缀，所有的默认实现可以继续沿用，而只是覆盖application.properties (或 application.yml)中的以下属性:
 
jasypt:
  encryptor:
    property:
      prefix: "ENC@["
      suffix: "]"
8.3 自定义EncryptablePropertyResolver
 
定义一个名称为encryptablePropertyResolver的Java类，实现并重写EncryptablePropertyResolver接口。也可以通过配置项jasypt.encryptor.property.resolver-bean 自己定义Java类的名称，而这样做后，则由定义的类来负责检测和解密已加密的属性，如下例子:
 
    class MyEncryptablePropertyResolver implements EncryptablePropertyResolver {
        private final PooledPBEStringEncryptor encryptor;
        public MyEncryptablePropertyResolver(char[] password) {
            this.encryptor = new PooledPBEStringEncryptor();
            SimpleStringPBEConfig config = new SimpleStringPBEConfig();
            config.setPasswordCharArray(password);
            config.setAlgorithm("PBEWITHHMACSHA512ANDAES_256");
            config.setKeyObtentionIterations("1000");
            config.setPoolSize(1);
            config.setProviderName("SunJCE");
            config.




    
setSaltGeneratorClassName("org.jasypt.salt.RandomSaltGenerator");
            config.setIvGeneratorClassName("org.jasypt.iv.RandomIvGenerator");
            config.setStringOutputType("base64");
            encryptor.setConfig(config);
        @Override
        public String resolvePropertyValue(String value) {
            if (value != null && value.startsWith("{cipher}")) {
                return encryptor.decrypt(value.substring("{cipher}".length()));
            return value;
	  @Bean(name="encryptablePropertyResolver")
    EncryptablePropertyResolver encryptablePropertyResolver(@Value("${jasypt.encryptor.password}") String password) {
        return new MyEncryptablePropertyResolver(password.toCharArray());
注意，通过覆盖EncryptablePropertyResolver，修改任何其他配置都可能有自定义的前缀，后缀，那么EncryptablePropertyDetector and StringEncryptor将停止解析检测工作，因为使用它们的是默认的解析器。需要自己把这些配置项组装起来。幸运的是，在大多数情况下不必重写这个bean，默认的配置选项应该就足够了。
 
但是，在这个实例中可以看到，对于加密属性的检测和解密工作是在自定义的MyEncryptablePropertyResolver类中实现的。
 
9. 使用过滤器
 
jasypt-spring-boot:2.1.0引入了一个新特性来指定属性过滤器。这个过滤器是EncryptablePropertyResolverAPI的一部分，允许指定哪些属性要进行解密。这项工作是在检查搜索或尝试解密实际属性值之前进行的。例如，默认情况下，所有名称以jasypt开头的属性。不在检查范围内。
 
9.1 DefaultPropertyFilter类的属性
 
默认情况下，DefaultPropertyResolver 使用DefaultPropertyFilter，允许指定以下列表中的字符串模式:
 
jasypt.encryptor.property.filter.include-sources: 指定要包含用于解密的属性源名称模式
jasypt.encryptor.property.filter.exclude-sources: 指定要排除用于解密的属性源名称模式
jasypt.encryptor.property.filter.include-names: 指定要包含用于解密的属性名称模式
jasypt.encryptor.property.filter.exclude-names: 指定要排除用于解密的属性名称模式
 
9.2 自定义EncryptablePropertyFilter
 
通过定义名称为encryptablePropertyFilter ，类型为EncryptablePropertyFilter的Bean来覆盖默认实现，或者如果定义自己的Bean名称，则覆盖属性jasypt.encryptor.property.filter-bean。然后指定bean的名称。这样做时，您将负责检测用于解密的属性和/或属性源。例子:
 
    class MyEncryptablePropertyFilter implements EncryptablePropertyFilter {
        public boolean shouldInclude(PropertySource<?> source, String name) {
            return name.startsWith('encrypted.');
	  @Bean(name="encryptablePropertyFilter")
    EncryptablePropertyFilter encryptablePropertyFilter() {
        return new MyEncryptablePropertyFilter();
注意，如果自定义EncryptablePropertyFilter，那就不应该提供自定义的EncryptablePropertyResolver，而应该使用默认的解析器。如果提供自定义解析器，则需要负责检测和解密属性的整个过程。
 
10. 过滤不需要加密/解密的属性类
 
定义一个属性名称为jasypt.encryptor.skip-property-sources，属性值为用逗号分隔的全限定类名列表，这些类将从加载过程中跳过。并且将不会被这个插件包装/代理，因此其中包含的属性将不会被加密/解密:
 
jasypt.encryptor.skip-property-sources=org.springframework.boot.env.RandomValuePropertySource,org.springframework.boot.ansi.AnsiPropertySource
11. Maven 插件使用
 
Maven插件提供了许多有用的实用程序，要使用这个插件，只需将以下内容添加到你的pom.xml中:
 
<build>
  <plugins>
    <plugin>
      <groupId>com.github.ulisesbocchio</groupId>
      <artifactId>jasypt-maven-plugin</artifactId>
      <version>3.0.3</version>
    </plugin>
  </plugins>
</build>
当使用这个插件时，最简单的方式是通过一个系统属性提供你的加密密码，即-Djasypt.encryptor.password=“自定义的密码”.
 
默认情况下，插件会在./src/main/resources下的标准Spring启动配置文件中检测加密配置。还可以使用系统属性或环境变量来提供此配置。注意，其余的应用程序代码和资源对插件是不可用的，因为Maven插件不与项目共享类路径。如果应用程序通过StringEncryptor bean提供加密配置，那么将不会起作用，一般来说，建议只依赖默认配置。
 
11.1 Encryption
 
加密单个值:
 
mvn jasypt:encrypt-value -Djasypt.encryptor.password="the password" -Djasypt.plugin.value="theValueYouWantToEncrypt"
在 src/main/resources/application.properties配置文件中, 用 DEC(...)标识括起来的任何内容都可以加密，包括空格. 示例:
 
sensitive.password=DEC(secret value)
regular.property=example
然后运行命令：
 
mvn jasypt:encrypt -Djasypt.encryptor.password="the password"
文件加密结果将以如下形式展示:
 
sensitive.password=ENC(encrypted)
regular.property=example
可以自定义配置文件名和位置.
 
11.2 Decryption
 
解密单个值，运行以下命令：
 
mvn jasypt:decrypt-value -Djasypt.encryptor.password="the password" -Djasypt.plugin.value="DbG1GppXOsFa2G69PnmADvQFI3esceEhJYbaEIKCcEO5C85JEqGAhfcjFMGnoRFf"
在 src/main/resources/application.properties配置文件中, 用 ENC(...)标识括起来的任何内容都可以解密，包括空格. 示例:
 
sensitive.password=ENC(encrypted)
regular.property=example
通过如下命令会达到解密效果:
 
mvn jasypt:decrypt -Djasypt.encryptor.password="the password"
解密内容将会输出到屏幕上：
 
sensitive.password=DEC(decrypted)
regular.property=example
注意，将数据输出到屏幕，而不是在适当的地方重新编辑文件，是为了减少意外地将解密后的值提交给版本控制。在解密时，您很可能只想检查已加密的值，而不是永久地解密该值。
 
11.3 Re-encryption
 
使用加密/解密目标更改现有加密属性的配置有点困难。必须使用旧配置运行解密目标，然后将解密后的输出复制回原始文件，最后再使用新配置运行加密目标。
 
重新加密的目标通过在适当的地方重新加密文件来达成。但是必须提供2套配置，提供新配置的方式与配置其他maven目标的方式相同。旧的配置是通过带"jasypt.plugin "前缀的系统属性提供的。
 
例如，重新加密应用程序之前，应当用旧密码先加密，然后再用新密码加密:
 
mvn jasypt:reencrypt -Djasypt.plugin.old.password=OLD -Djasypt.encryptor.password=NEW
注意:所有旧的配置必须作为系统属性传递。不支持环境变量和Spring引导配置文件。
 
11.4 Upgrade
 
有时，默认的加密配置可能会在jasypt-spring-boot的不同版本之间发生变化。您可以根据升级目标自动将加密的属性升级到新的默认值。这将解密您的应用程序。属性文件使用旧的默认配置，并使用新的默认配置重新加密。
 
mvn jasypt:upgrade -Djasypt.encryptor.password=EXAMPLE
11.5 Load
 
当想让加密的属性对其他Maven插件可用时，可以将属性文件中所有属性加载到内存中，使Maven可以访问它们。
 
可以将其它插件的目标直接连接到这个插件之后。例如，使用flyway:
 
mvn jasypt:load flyway:migrate -Djasypt.encryptor.password="the password"
你也可以用-Djasypt.plugin.keyPrefix=example. 为每个属性指定一个前缀。这有助于避免与其他Maven属性发生潜在的冲突。
 
11.6 加密并改变属性文件路径
 
对于上述所有内容，要加密/解密的文件的路径默认为file:src/main/resources/application.properties,
 
相对而言，我们可以使用-Djasypt.plugin.path来指定文件路径，并且还有其他特性，如下：
 
可以加密test resources目录中的文件
 
mvn jasypt:encrypt -Djasypt.plugin.path="file:src/main/test/application.properties" -Djasypt.encryptor.password="the password"
也可以加密非application.properties名称的配置文件:
 
mvn jasypt:encrypt -Djasypt.plugin.path="file:src/main/resources/flyway.properties" -Djasypt.encryptor.password="the password"
同样支持.yaml格式的配置文件:
 
mvn jasypt:encrypt -Djasypt.plugin.path="file:src/main/resources/application.yaml" -Djasypt.encryptor.password="the password"
注意 load模块只支持 .property 格式的文件
 
11.7 加密Spring属性文件
 
当运行这个插件时，你可以覆盖你在应用程序中支持的任何spring配置，例如选择一个给定的spring配置文件:
 
mvn jasypt:encrypt -Dspring.profiles.active=




    
cloud -Djasypt.encryptor.password="the password" 
12. 非对称加密
 
jasypt-spring-boot:2.1.1 引入了一个新特性，使用一对DER或PEM格式的私钥/公钥非对称加密对属性进行加密/解密。
 
12.1 配置属性
 
以下是可用于配置属性的非对称解密的配置属性;
 
属性名
默认值
描述
jasypt.encryptor.privateKeyString
null
用于解密的字符串格式的私钥
jasypt.encryptor.privateKeyLocation
null
用于以spring资源格式解密的私钥的位置
jasypt.encryptor.privateKeyFormat
DER
秘钥编码格式 DER 或者 PEM
 
可以使用字符串或者秘钥路径来定义key，若是直接以字符串格式定义秘钥，应当先base64编码
 
注意 以jasypt.encryptor.password 方式配置加密优先于非对称加密配置
 
12.2 配置实例
 
12.2.1 以字符串格式配置DER编码的秘钥
 
jasypt:
    encryptor:
      privateKeyString: MIIEvAIBADANBgkqhkiG9w0BAQEFAASCBKYwggSiAgEAAoIBAQCtB/IYK8E52CYMZTpyIY9U0HqMewyKnRvSo6s+9VNIn/HSh9+MoBGiADa2MaPKvetS3CD3CgwGq/+LIQ1HQYGchRrSORizOcIp7KBx+Wc1riatV/tcpcuFLC1j6QJ7d2I+T7RA98Sx8X39orqlYFQVysTw/aTawX/yajx0UlTW3rNAY+ykeQ0CBHowtTxKM9nGcxLoQbvbYx1iG9JgAqye7TYejOpviOH+BpD8To2S8zcOSojIhixEfayay0gURv0IKJN2LP86wkpAuAbL+mohUq1qLeWdTEBrIRXjlnrWs1M66w0l/6JwaFnGOqEB6haMzE4JWZULYYpr2yKyoGCRAgMBAAECggEAQxURhs1v3D0wgx27ywO3zeoFmPEbq6G9Z6yMd5wk7cMUvcpvoNVuAKCUlY4pMjDvSvCM1znN78g/CnGF9FoxJb106Iu6R8HcxOQ4T/ehS+54kDvL999PSBIYhuOPUs62B/Jer9FfMJ2veuXb9sGh19EFCWlMwILEV/dX+MDyo1qQaNzbzyyyaXP8XDBRDsvPL6fPxL4r6YHywfcPdBfTc71/cEPksG8ts6um8uAVYbLIDYcsWopjVZY/nUwsz49xBCyRcyPnlEUJedyF8HANfVEO2zlSyRshn/F+rrjD6aKBV/yVWfTEyTSxZrBPl4I4Tv89EG5CwuuGaSagxfQpAQKBgQDXEe7FqXSaGk9xzuPazXy8okCX5pT6545EmqTP7/JtkMSBHh/xw8GPp+JfrEJEAJJl/ISbdsOAbU+9KAXuPmkicFKbodBtBa46wprGBQ8XkR4JQoBFj1SJf7Gj9ozmDycozO2Oy8a1QXKhHUPkbPQ0+w3efwoYdfE67ZodpFNhswKBgQDN9eaYrEL7YyD7951WiK0joq0BVBLK3rwO5+4g9IEEQjhP8jSo1DP+zS495t5ruuuuPsIeodA79jI8Ty+lpYqqCGJTE6muqLMJDiy7KlMpe0NZjXrdSh6edywSz3YMX1eAP5U31pLk0itMDTf2idGcZfrtxTLrpRffumowdJ5qqwKBgF+XZ+JRHDN2aEM0atAQr1WEZGNfqG4Qx4o0lfaaNs1+H+knw5kIohrAyvwtK1LgUjGkWChlVCXb8CoqBODMupwFAqKL/IDImpUhc/t5uiiGZqxE85B3UWK/7+vppNyIdaZL13a1mf9sNI/p2whHaQ+3WoW/P3R5z5uaifqM1EbDAoGAN584JnUnJcLwrnuBx1PkBmKxfFFbPeSHPzNNsSK3ERJdKOINbKbaX+7DlT4bRVbWvVj/jcw/c2Ia0QTFpmOdnivjefIuehffOgvU8rsMeIBsgOvfiZGx0TP3+CCFDfRVqjIBt3HAfAFyZfiP64nuzOERslL2XINafjZW5T0pZz8CgYAJ3UbEMbKdvIuK+uTl54R1Vt6FO9T5bgtHR4luPKoBv1ttvSC6BlalgxA0Ts/AQ9tCsUK2JxisUcVgMjxBVvG0lfq/EHpL0Wmn59SHvNwtHU2qx3Ne6M0nQtneCCfR78OcnqQ7+L+3YCMqYGJHNFSard+dewfKoPnWw0WyGFEWCg==
12.2.2 配置项指定DER编码的秘钥文件路径
 
jasypt:
    encryptor:
      privateKeyLocation: classpath:private_key.der
12.2.3 以字符串格式配置PEM编码的秘钥
 
jasypt:
    encryptor:
      privateKeyFormat: PEM
      privateKeyString: |-
          -----BEGIN PRIVATE KEY-----
          MIIEvAIBADANBgkqhkiG9w0BAQEFAASCBKYwggSiAgEAAoIBAQCtB/IYK8E52CYM
          ZTpyIY9U0HqMewyKnRvSo6s+9VNIn/HSh9+MoBGiADa2MaPKvetS3CD3CgwGq/+L
          IQ1HQYGchRrSORizOcIp7KBx+Wc1riatV/tcpcuFLC1j6QJ7d2I+T7RA98Sx8X39
          orqlYFQVysTw/aTawX/yajx0UlTW3rNAY+ykeQ0CBHowtTxKM9nGcxLoQbvbYx1i
          G9JgAqye7TYejOpviOH+BpD8To2S8zcOSojIhixEfayay0gURv0IKJN2LP86wkpA
          uAbL+mohUq1qLeWdTEBrIRXjlnrWs1M66w0l/6JwaFnGOqEB6haMzE4JWZULYYpr
          2yKyoGCRAgMBAAECggEAQxURhs1v3D0wgx27ywO3zeoFmPEbq6G9Z6yMd5wk7cMU
          vcpvoNVuAKCUlY4pMjDvSvCM1znN78g/CnGF9FoxJb106Iu6R8HcxOQ4T/ehS+54
          kDvL999PSBIYhuOPUs62B/Jer9FfMJ2veuXb9sGh19EFCWlMwILEV/dX+MDyo1qQ
          aNzbzyyyaXP8XDBRDsvPL6fPxL4r6YHywfcPdBfTc71/cEPksG8ts6um8uAVYbLI
          DYcsWopjVZY/nUwsz49xBCyRcyPnlEUJedyF8HANfVEO2zlSyRshn/F+rrjD6aKB
          V/yVWfTEyTSxZrBPl4I4Tv89EG5CwuuGaSagxfQpAQKBgQDXEe7FqXSaGk9xzuPa
          zXy8okCX5pT6545EmqTP7/JtkMSBHh/xw8GPp+JfrEJEAJJl/ISbdsOAbU+9KAXu
          PmkicFKbodBtBa46wprGBQ8XkR4JQoBFj1SJf7Gj9ozmDycozO2Oy8a1QXKhHUPk
          bPQ0+w3efwoYdfE67ZodpFNhswKBgQDN9eaYrEL7YyD7951WiK0joq0BVBLK3rwO
          5+4g9IEEQjhP8jSo1DP+zS495t5ruuuuPsIeodA79jI8Ty+lpYqqCGJTE6muqLMJ
          Diy7KlMpe0NZjXrdSh6edywSz3YMX1eAP5U31pLk0itMDTf2idGcZfrtxTLrpRff
          umowdJ5qqwKBgF+XZ+JRHDN2aEM0atAQr1WEZGNfqG4Qx4o0lfaaNs1+H+knw5kI
          ohrAyvwtK1LgUjGkWChlVCXb8CoqBODMupwFAqKL/IDImpUhc/t5uiiGZqxE85B3
          UWK/7+vppNyIdaZL13a1mf9sNI/p2whHaQ+3WoW/P3R5z5uaifqM1EbDAoGAN584
          JnUnJcLwrnuBx1PkBmKxfFFbPeSHPzNNsSK3ERJdKOINbKbaX+7DlT4bRVbWvVj/
          jcw/c2Ia0QTFpmOdnivjefIuehffOgvU8rsMeIBsgOvfiZGx0TP3+CCFDfRVqjIB
          t3HAfAFyZfiP64nuzOERslL2XINafjZW5T0pZz8CgYAJ3UbEMbKdvIuK+uTl54R1
          Vt6FO9T5bgtHR4luPKoBv1ttvSC6BlalgxA0Ts/AQ9tCsUK2JxisUcVgMjxBVvG0
          lfq/EHpL0Wmn59SHvNwtHU2qx3Ne6M0nQtneCCfR78OcnqQ7+L+3YCMqYGJHNFSa
          rd+dewfKoPnWw0WyGFEWCg==
          -----END PRIVATE KEY-----
12.2.4 配置项指定PEM编码的秘钥文件路径
 
jasypt:
    encryptor:
      privateKeyFormat: PEM
      privateKeyLocation: classpath:private_key.pem
12.3 Java代码加密属性
 
12.3.1 DER格式
 
import com.ulisesbocchio.jasyptspringboot.encryptor.SimpleAsymmetricConfig;
import com.ulisesbocchio.jasyptspringboot.encryptor.SimpleAsymmetricStringEncryptor;
import org.jasypt.encryption.StringEncryptor;
public class PropertyEncryptor {
    public static void main(String[] args) {
        SimpleAsymmetricConfig config = new SimpleAsymmetricConfig();
        config.setPublicKey("MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEArQfyGCvBOdgmDGU6ciGPVNB6jHsMip0b0qOrPvVTSJ/x0offjKARogA2tjGjyr3rUtwg9woMBqv/iyENR0GBnIUa0jkYsznCKeygcflnNa4mrVf7XKXLhSwtY+kCe3diPk+0QPfEsfF9/aK6pWBUFcrE8P2k2sF/8mo8dFJU1t6zQGPspHkNAgR6MLU8SjPZxnMS6EG722MdYhvSYAKsnu02Hozqb4jh/gaQ/E6NkvM3DkqIyIYsRH2smstIFEb9CCiTdiz/OsJKQLgGy/pqIVKtai3lnUxAayEV45Z61rNTOusNJf+icGhZxjqhAeoWjMxOCVmVC2GKa9sisqBgkQIDAQAB");
        StringEncryptor encryptor = new SimpleAsymmetricStringEncryptor(config);
        String message = "chupacabras";
        String encrypted = encryptor.encrypt(message);
        System.out.printf("Encrypted message %s\n", encrypted);
12.3.2 PEM格式
 
import com.ulisesbocchio.jasyptspringboot.encryptor.SimpleAsymmetricConfig;
import com.ulisesbocchio.jasyptspringboot.encryptor.SimpleAsymmetricStringEncryptor;
import org.jasypt.encryption.StringEncryptor;
import static com.ulisesbocchio.jasyptspringboot.util.AsymmetricCryptography.KeyFormat.PEM;
public class PropertyEncryptor {
    public static void main(String[] args) {
        SimpleAsymmetricConfig config = new SimpleAsymmetricConfig();
        config.setKeyFormat(PEM);
        config.setPublicKey("-----BEGIN PUBLIC KEY-----\n" +
                "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEArQfyGCvBOdgmDGU6ciGP\n" +
                "VNB6jHsMip0b0qOrPvVTSJ/x0offjKARogA2tjGjyr3rUtwg9woMBqv/iyENR0GB\n" +
                "nIUa0jkYsznCKeygcflnNa4mrVf7XKXLhSwtY+kCe3diPk+0QPfEsfF9/aK6pWBU\n" +
                "FcrE8P2k2sF/8mo8dFJU1t6zQGPspHkNAgR6MLU8SjPZxnMS6EG722MdYhvSYAKs\n" +
                "nu02Hozqb4jh/gaQ/E6NkvM3DkqIyIYsRH2smstIFEb9CCiTdiz/OsJKQLgGy/pq\n" +
                "IVKtai3lnUxAayEV45Z61rNTOusNJf+icGhZxjqhAeoWjMxOCVmVC2GKa9sisqBg\n" +
                "kQIDAQAB\n" +
                "-----END PUBLIC KEY-----\n");
        StringEncryptor encryptor = new SimpleAsymmetricStringEncryptor(config);
        String message = "chupacabras";
        String encrypted = encryptor.encrypt(message);
        System.out.printf("Encrypted message %s\n", encrypted);
13.Demo App
 
jasypt-spring-boot-demo-samples 仓库包含了Spring Boot应用的示例。主要的jasypt-spring-boot-demo应用程序在运行之前显式地设置了一个带有加密密码的系统属性。为了有一个更真实的场景，建议尝试删除设置了system属性的行，用maven构建应用程序，然后运行:
 
	java -jar target/jasypt-spring-boot-demo-0.0.1-SNAPSHOT.jar --jasypt.encryptor.password=password
把加密密码作为命令行参数传递:
 
	java -Djasypt.encryptor.password=password -jar target/jasypt-spring-boot-demo-0.0.1-SNAPSHOT.jar
也可以通过创建application.properties 或者 application.yml文件，并且添加如下配置项：
 
jasypt.encryptor.password=${JASYPT_ENCRYPTOR_PASSWORD:}
jasypt:
    encryptor:
        password: ${JASYPT_ENCRYPTOR_PASSWORD:}
定义jasypt.encryptor.password属性是基础做法，也可以指向另一个属性JASYPT_ENCRYPTOR_PASSWORD，既可以通过环境变量设置，也可以通过系统属性重写它。这种方式还可以用于为您需要的任何其他库翻译属性名/值，demo中也有涉及:
 
JASYPT_ENCRYPTOR_PASSWORD=password java -jar target/jasypt-spring-boot-demo-1.5-SNAPSHOT.jar
注意:当使用Gradle作为构建工具时，processResources任务会因为$字符而失败，要解决这个问题，需要替换掉$这样的变量。
 
14.其它 demo app
 
jasypt-spring-boot-demo是一个综合的演示demo，它展示了加密/解密属性的所有可能方法，但还有其他多个demo演示了独立特性的使用场景。
 
15.参考
 
翻译自：jasypt-spring-boot.README.md
                    文章目录1. 简介2. 如何整合3. 自定义环境4. 工作原理5. 加密的属性如何处理6. 基于密码的加密配置7. 使用自定义的加密程序8. 自定义`Property Detector`, `Prefix`, `Suffix` 和 `Resolver`8.1 自定义`EncryptablePropertyDetector`8.2 自定义加密属性前缀和后缀8.3 自定义`EncryptablePropertyResolver`9. 使用过滤器9.1 `DefaultPropertyFilter`类的属性9.2
				
jasypt-spring-boot-starter实现加解密和数据返显
一、jasypt-spring-boot-starter在springboot中的加解密（默认加密法）
  <!--实现自动 加密解密-->
        <dependency>
            <groupId>com.github.ulisesbocchio</groupId>
            <artifactId>jasypt-sprin
				
jasypt-spring-boot
 用于Spring Boot 1.4.X，1.5.X和2.0.X的集成
 Jasypt Spring Boot为Spring Boot应用程序中的属性源提供了加密支持。 有3种方法可以将jasypt-spring-boot集成到您的项目中：
 如果使用@SpringBootApplication或@EnableAutoConfiguration只需将启动程序jar jasypt-spring-boot-starter到您的类路径中， @SpringBootApplication在整个Spring环境中启用可加密属性
将jasypt-spring-boot添加到您的类路径中，并将@EnableEncryptableProperties添加到您的主Configuration类中，以在整个Spring环境中启用可加密属性
将jasypt-spring-boot添加到您的类路径中，并使用@EncrytablePropertySource声明各个可加密的属性源
什么是新的？
更新05/31/2020：版本3.0.3发行版包括
修正了一些小错误
				
目录1. 简介2. 引入依赖3. 自定义加解密的方式4. 获取密文5. 编写配置文件6. 验证结果
1. 简介
在项目开发的过程中，经常会需要在配置文件中存储一些敏感的信息，如数据库的账号密码，支付相关信息，密钥等等，这些信息在开发的过程中一般是以明文的方式存储在配置文件中。这种方式的存储会存在非常大的安全隐患。jasypt能够很好的解决这一类的问题，特此记录，一遍后面学习使用。
2. 引入依赖
<!--springboot整合jasypt-->
  <dependency>
				
赠送jar包：jasypt-spring-boot-3.0.4.jar；
赠送原API文档：jasypt-spring-boot-3.0.4-javadoc.jar；
赠送源代码：jasypt-spring-boot-3.0.4-sources.jar；
赠送Maven依赖信息文件：jasypt-spring-boot-3.0.4.pom；
包含翻译后的API文档：jasypt-spring-boot-3.0.4-javadoc-API文档-中文(简体)-英语-对照版.zip；
Maven坐标：com.github.ulisesbocchio:jasypt-spring-boot:3.0.4；
标签：github、ulisesbocchio、jasypt、spring、boot、中英对照文档、jar包、java；
使用方法：解压翻译后的API文档，用浏览器打开“index.html”文件，即可纵览文档内容。
人性化翻译，文档中的代码和结构保持不变，注释和说明精准翻译，请放心使用。
双语对照，边学技术、边学英语。
				
在上一篇文章《springboot + jasypt实现配置文件application.yaml敏感数据加密》中，我们已阐述jasypt工具的集成，上一期用的是2.x.x版本，
jasypt-spring-boot-starter从3.x.x版本开始，使用有些许变化了，当然这两个版本的starter对应的核心包版本同样是jasypt-1.9.3，下面开始实践一下，没看过上一篇文章的道友可以快速去阅览一下。（阅读本文耗时不足1分钟）1、将jasypt-spring-boot-starter版本从2.1.2 改
				
赠送jar包：jasypt-spring-boot-3.0.4.jar；
赠送原API文档：jasypt-spring-boot-3.0.4-javadoc.jar；
赠送源代码：jasypt-spring-boot-3.0.4-sources.jar；
赠送Maven依赖信息文件：jasypt-spring-boot-3.0.4.pom；
包含翻译后的API文档：jasypt-spring-boot-3.0.4-javadoc-API文档-中文(简体)版.zip；
Maven坐标：com.github.ulisesbocchio:jasypt-spring-boot:3.0.4；
标签：github、ulisesbocchio、jasypt、spring、boot、中文文档、jar包、java；
使用方法：解压翻译后的API文档，用浏览器打开“index.html”文件，即可纵览文档内容。
人性化翻译，文档中的代码和结构保持不变，注释和说明精准翻译，请放心使用。
				
为了回答这个问题，首先需要了解jasypt-spring-boot-starter是什么。jasypt-spring-boot-starter是一个用于Spring Boot的开源库，它提供了对加密和解密功能的支持。它基于Jasypt（Java Simplified Encryption）库，并与Spring Boot框架集成，使加密和解密配置变得容易。
要下载jasypt-spring-boot-starter，可以按照以下步骤进行操作：
1. 打开您的项目的pom.xml文件。
2. 在<dependencies>节点中添加以下内容：
```xml
<dependency>
    <groupId>com.github.ulisesbocchio</groupId>
    <artifactId>jasypt-spring-boot-starter</artifactId>
    <version>2.1.2</version>
</dependency>
3. 保存pom.xml文件，并等待Maven自动下载所需的库文件。
这样，您就成功地将jasypt-spring-boot-starter库添加到了您的项目中。现在，您可以在Spring Boot应用程序中使用jasypt库的功能，例如配置加密和解密属性文件、加密数据库密码等。
请确保您的项目已经配置了正确的Maven中央仓库，以便下载所需的库文件。此外，还应确保您的项目的依赖管理工具（如Maven或Gradle）已正确配置，以便从仓库或存储库中下载所需的库文件。
希望这个回答能对您有所帮助！