• Github地址：https://github.com/andyslin/spring-ext
• 编译、运行环境：JDK 8 + Maven 3 + IDEA + Lombok
• spring-boot：2.1.0.RELEASE(Spring：5.1.2.RELEASE)
• 如要本地运行github上的项目，需要安装lombok插件

在上篇文章从SpringMVC获取用户信息谈起中，由一个典型的应用场景说起，通过分析SpringMVC的源码，引入新接口PropertyValuesProvider，我们给SpringMVC的参数绑定提供了一种新的机制，姑且称之为PropertyValuesProvider机制。在这篇文章中，就来说一下这种新机制的几个应用，这些应用都是我在实际工作中曾经遇到的。

一、准备工作

为了后面的测试，先做一些准备工作：

1. 创建一个SpringBoot应用，添加maven依赖：
   ```xml
   
   org.springframework.boot
   spring-boot-starter-web
   

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
    </dependency>

   ```

2. 添加启动类
   ```java
   @SpringBootApplication
   public class ArgsBindApplication {

    public static void main(String[] args) {
        SpringApplication.run(ArgsBindApplication.class, args);
    }

   }
   ```

3. 添加测试类，启用MockMvc：

    @RunWith(SpringRunner.class)
    @SpringBootTest
    @AutoConfigureMockMvc
    public class ArgsBindApplicationTests {
   
        @Autowired
        private MockMvc mvc;
    }

二、验证PropertyValuesProvider机制

先纯粹的验证一下PropertyValuesProvider机制，不预设具体的应用场景。添加一个PropertyValuesProvider的实现类，并注册为Spring容器中的Bean：

@Component
public class TestPropertyValuesProvider implements PropertyValuesProvider {

    @Override
    public void addBindValues(MutablePropertyValues mpvs, ServletRequest request, Object target, String name) {
        mpvs.add("beforeBindProperty", "beforeBindPropertyValue");
    }

    @Override
    public void afterBindValues(PropertyAccessor accessor, ServletRequest request, Object target, String name) {
        if (target instanceof TestForm) {
            accessor.setPropertyValue("afterBindProperty", "afterBindPropertyValue");
        }
    }
}

这个实现类逻辑非常简单，就是在SpringMVC原生的参数绑定和验证之前，提供了一个候选的属性beforeBindProperty，在参数绑定和验证之后，又修改了目标对象的属性afterBindProperty。当然，为了确保有afterBindProperty这个属性，实现类中先对目标对象做了一个类型判断，在实际应用中，可以做更灵活的处理。目标类型TestForm就是一个简单的POJO:

@Getter
@Setter
@ToString
public class TestForm {

    private String beforeBindProperty;

    private String afterBindProperty;
}

这里没有直接使用@Data注解，是因为@Data功能太多，会生成很多方法，而我只是需要getter、setter和toString就可以了。
然后控制器定义如下：

@RestController
public class TestController {

    @GetMapping("/test")
    public TestForm test(TestForm form) {
        return form;
    }
}

最后，在测试类ArgsBindApplicationTests中添加测试方法：

@RunWith(SpringRunner.class)
@SpringBootTest
@AutoConfigureMockMvc
public class ArgsBindApplicationTests {

    @Autowired
    private MockMvc mvc;

    // 添加的测试方法
    @Test
    public void test() throws Exception {
        MvcResult result = mvc.perform(MockMvcRequestBuilders.get("/test")).andReturn();
        MockHttpServletResponse response = result.getResponse();
        Assert.assertEquals(200, response.getStatus());

        JSONObject json = new JSONObject(response.getContentAsString());
        Assert.assertEquals("beforeBindPropertyValue", json.getString("beforeBindProperty"));
        Assert.assertEquals("afterBindPropertyValue", json.getString("afterBindProperty"));
    }
}

通过运行测试案例，可以发现实现类PropertyValuesProviderTest已经生效。如果不熟悉使用MockMVC，也可以本地启动应用后，在浏览器或Postman中手工发起请求。

三、实际应用

（一）公共的BaseForm

很多时候，后端的控制器需要根据会话上下文获取一些公共属性（上篇文章中的用户信息就是一种会话上下文信息），如果在每个控制器中去获取，虽然思路简单，但是编写麻烦，更重要的是不便于维护。这时候，我们可以把需要提取的信息定义一个公共的BaseForm，然后具体的业务Form添加一个类型为BaseForm的属性（或者直接继承BaseForm），具体步骤如下：

1. 定义公共的BaseForm和业务Form
   ```java
   @Getter
   @Setter
   @ToString
   public class BaseForm {

    private String userId;
   
    private String orgId;

   }
   java
   @Getter
   @Setter
   @ToString
   public class BusinessForm {

    private BaseForm base;

   }
   ```

2. 编写PropertyValuesProvider的实现类，并添加@Component注入到Spring容器中：
   ```java
   @Component
   public class BaseFormPropertyValuesProvider implements PropertyValuesProvider {

    @Override
    public void addBindValues(MutablePropertyValues mpvs, ServletRequest request, Object target, String name) {
        mpvs.add("base", obtainBaseForm());
    }
   
    /**
    * 获取BaseForm，这里直接返回，实际应用可能会获取session、解密jwt或者其它逻辑
    *
    * @return
    */
    private BaseForm obtainBaseForm() {
        BaseForm form = new BaseForm();
        form.setUserId("admin");
        form.setOrgId("0000");
        return form;
    }

   ``> 当然，这里只是演示。实际应用中不宜写死base`名称，可以根据Type反过来获取属性名称（可以参考后面的案例），并缓存这些元信息。

3. 编写控制器Controller

    @RestController
    public class BaseFormController {
   
        @GetMapping("/baseform")
        public BusinessForm test(BusinessForm form) {
            return form;
        }
    }

4. 添加测试方法

   @Test
    public void baseform() throws Exception {
        MvcResult result = mvc.perform(MockMvcRequestBuilders.get("/baseform")).andReturn();
        MockHttpServletResponse response = result.getResponse();
        Assert.assertEquals(200, response.getStatus());
   
        JSONObject json = new JSONObject(response.getContentAsString());
        JSONObject base = json.getJSONObject("base");
   
        Assert.assertEquals("admin", base.getString("userId"));
        Assert.assertEquals("0000", base.getString("orgId"));
    }

   测试案例通过，说明已经按预期设置公共属性了。

### （二）配置属性

除了从会话上下文中获取信息之外，在实际工作中还遇到过一种情况，就是需要根据请求从DB中加载配置，当然，这些逻辑可以放在service层，但是放到service层，除了代码散落各处之外，也不能享有SpringMVC中便利的参数校验机制了。而通过PropertyValuesProvider机制，可以将这些代码像AOP一样收敛到一起（我始终以为，AOP不只是提供了一种实用功能，更重要的还是一种编程思想，学习AOP，除了学习怎么使用，还要学习怎么思考）。

我们来一起处理这种情形：

1. 添加用于设别特殊属性的注解：

   @Target({ElementType.FIELD})
   @Retention(RetentionPolicy.RUNTIME)
   public @interface ConfigProperty {
   
       String value();
   }

   为了简单，这里做了一些简化，没有区分配置的类型(文件、DB、环境变量等)，也没有添加属性前缀匹配等。

2. 在业务Form的属性中添加注解：

   @Getter
   @Setter
   @ToString
   public class ConfigPropertyForm {
   
       @ConfigProperty("configName")
       private String configProperty;
   }

3. 编写PropertyValuesProvider实现类，实现属性注入逻辑：

   @Component
   public class ConfigPropertyPropertyValuesProvider implements PropertyValuesProvider {
   
       @Override
       public void addBindValues(MutablePropertyValues mpvs, ServletRequest request, Object target, String name) {
           for (Class<?> cls = target.getClass(); !cls.equals(Object.class); cls = cls.getSuperclass()) {
               for (Field field : cls.getDeclaredFields()) {
                   // 实际应用中可以将是否包括@ConfigProperty注解等元信息缓存起来
                   if (field.isAnnotationPresent(ConfigProperty.class)) {
                       mpvs.add(field.getName(), obtainConfigProperty(field.getAnnotation(ConfigProperty.class), field));
                   }
               }
           }
       }
   
       /**
       * 根据注解和Field获取属性
       */
       private Object obtainConfigProperty(ConfigProperty configProperty, Field field) {
           String propertyName = configProperty.value();
           // 这里直接返回属性值，实际应用中可以根据注解从环境变量、DB或者缓存中获取
           return propertyName + "Value";
       }
   }

   属性是否包含@ConfigProperty注解的元信息可以缓存起来

4. 添加控制器，在测试类ArgsBindApplicationTests中添加测试方法，运行测试案例：

   @RestController
   public class ConfigPropertyController {
   
       @GetMapping("/configProperty")
       public ConfigPropertyForm test(ConfigPropertyForm form) {
           return form;
       }
   }

   @Test
   public void configProperty() throws Exception {
       MvcResult result = mvc.perform(MockMvcRequestBuilders.get("/configProperty")).andReturn();
       MockHttpServletResponse response = result.getResponse();
       Assert.assertEquals(200, response.getStatus());
   
       JSONObject json = new JSONObject(response.getContentAsString());
   
       Assert.assertEquals("configNameValue", json.getString("configProperty"));
   }

可能有朋友会说，要使用环境属性或者配置，不是直接可以使用Spring提供的@Value注解吗？的确，在Controller或Service等Spring容器中的Bean，可以直接使用@Value注解，但是我们这里是在Form中使用配置。

回想一下这个案例，这实际上是一种新的模式：定义一种用于设别的注解，在Form对象的属性中使用注解，然后根据注解、属性、请求等设置属性值。 下面再看一个这种模式的应用场景：

### （三）RSA解密

在Web应用中，为了安全考虑，在客户端使用JS库jsencrypt将用户输入的密码通过RSA加密，然后传输到服务端，服务端使用SpringMVC的机制接受参数，但是服务端有一个校验（密码长度在6到16位），这样，使用原生的校验机制，被校验的值是RSA加密后的值（很长），因而通不过校验，我们看看这种场景：

1. 为了使用SpringMVC的校验机制，先在pom.xml中添加依赖:

   <dependency>
       <groupId>org.springframework.boot</groupId>
       <artifactId>spring-boot-starter-validation</artifactId>
   </dependency>

2. 添加识别需要RSA解密的标志注解:

   @Target({ElementType.FIELD})
   @Retention(RetentionPolicy.RUNTIME)
   public @interface RsaDecrypt {
   }

3. 定义Form

   @Getter
   @Setter
   @ToString
   public class RsaDecryptForm {
   
       @Length(min = 6, max = 16, message = "长度只能在6-16位")
       @RsaDecrypt
       private String rsa;
   }

4. 编写Controller，添加校验注解@Validated:

   @RestController
   public class RsaDecryptController {
   
       @GetMapping("/rsaDecrypt")
       public RsaDecryptForm test(@Validated RsaDecryptForm form) {
           return form;
       }
   }

5. 在测试类ArgsBindApplicationTests中添加测试方法，运行测试案例：

   @Test
   public void rsa() throws Exception {
       String src = "abadewew";//原始值
       // 模拟客户端使用RSA加密
       String encrypt = RSAUtils.encryptByPublicKey(src, RSA_PAIR[0]);
       MvcResult result = mvc.perform(MockMvcRequestBuilders.get("/rsaDecrypt").param("rsa", encrypt)).andReturn();
       MockHttpServletResponse response = result.getResponse();
       Assert.assertEquals(200, response.getStatus());
   
       JSONObject json = new JSONObject(response.getContentAsString());
       Assert.assertEquals(src, json.getString("rsa"));
   }

   结果发现，第一个断言已经失败，从日志中可以看出抛出了BindException异常，因为没有通过校验：

   MockHttpServletRequest:
       HTTP Method = GET
       Request URI = /rsaDecrypt
       Parameters = {rsa=[envr8Rm72k5c2FxkMjhhPxeHCyvh+IENKTAFO30z6c/dUn8Z3rMv1gyqCAYmaSIy09KH4kFdO90Gsz4uJhzi/riM4bOOBwCcXBvq6J1Md9yiZOgdl/XuDVf7V4IJsE2NUQnhmtfFFJhSOuPzeMJ7HntC1J/CrDUBaL5n40tWW6I=]}
           Headers = {}
               Body = null
       Session Attrs = {}
   
   Handler:
               Type = org.autumn.spring.argsbind.rsa.RsaDecryptController
           Method = public org.autumn.spring.argsbind.rsa.RsaDecryptForm org.autumn.spring.argsbind.rsa.RsaDecryptController.test(org.autumn.spring.argsbind.rsa.RsaDecryptForm)
   
   Async:
       Async started = false
       Async result = null
   
   Resolved Exception:
               Type = org.springframework.validation.BindException
   
   ModelAndView:
           View name = null
               View = null
               Model = null
   
   FlashMap:
       Attributes = null
   
   MockHttpServletResponse:
           Status = 400
       Error message = null
           Headers = {}
       Content type = null
               Body = 
       Forwarded URL = null
   Redirected URL = null
           Cookies = []

   为什么会这样呢？这是因为客户端RSA加密之后，传递到服务端的值是加密后的值，长度远远超过16，因而校验失败。现在，我们添加一个PropertyValuesProvider实现类做一下预处理：

6. 添加RsaDecryptPropertyValuesProvider实现类：

   @Component
   public class RsaDecryptPropertyValuesProvider implements PropertyValuesProvider {
   
       @Override
       public void addBindValues(MutablePropertyValues mpvs, ServletRequest request, Object target, String name) {
           for (Class<?> cls = target.getClass(); !cls.equals(Object.class); cls = cls.getSuperclass()) {
               for (Field field : cls.getDeclaredFields()) {
                   if (field.isAnnotationPresent(RsaDecrypt.class)) {
                       mpvs.add(field.getName(), obtainConfigProperty(field.getName(), request));
                   }
               }
           }
       }
   
       /**
       * 根据注解和Field获取属性
       */
       private Object obtainConfigProperty(String name, ServletRequest request) {
           String encrypt = request.getParameter(name);
           if (StringUtils.hasText(encrypt)) {
               return RSAUtils.decryptByPrivateKey(encrypt, RSA_PAIR[1]);
           }
           return encrypt;
       }
   }

7. 再次运行测试案例，发现已经通过测试，说明将加密传输和原生校验完美结合了！

   这个案例使用了一个工具类RSAUtils,可以从github上查看相关源码，没有任何依赖，只依赖JDK。

好了，PropertyValuesProvider机制先聊到这，希望对大家有一点点启发，如果你有遇到新的应用场景，也希望能够不惜赐教。