HandlerMethodArgumentResolver 自定义使用

1.HandlerMethodArgumentResolver 的应用场景

HandlerMethodArgumentResolver 是Spring提供的一个请求参数解析接口，用于对一个request进行解析并且对方法的入参进行赋值，对于这个接口Spring提供了非常多的内置实现。摘抄HandlerMethodArgumentResolver 类上的注释如下：

  Strategy interface for resolving method parameters into argument values in the context of a given request.

翻译一下就是：用于在给定请求的上下文中将方法参数解析为参数值的策略接口。这么说可能有点绕口，举个Spring内置实现的类例子RequestResponseBodyMethodProcessor，该类用于处理加了@RequestBody注解的参数。@RequestBody注解的使用应该非常的广泛，项目里经常可以看到这种形式的代码：

    @RequestMapping("/update")

    public ResponseResult<User> update(@RequestBody User user){

        System.out.println("当前操作的用户为: " + user.toString());

        // update...

        return ResponseResult.success(user,"更新用户成功！");

    }

@RequestBody用于处理接收一个对象类型的参数，这个注解会把属性注入到对象里，并且传进我们的方法。如果不加这个注解，user参数为null，对于刚接触的人来说这是非常头疼的。可见Spring一个简单的注解为我们省去了非常多的烦恼，一个注解就能实现这个功能，是不是十分神奇。这里面Spring替我们做了很多操作，对于我们是透明的，下面再展开叙述原理。果然，好用的东西总是朴实无华的。

这里先模仿一下Spring的实现，自己定义一个类实现HandlerMethodArgumentResolver 。

2.HandlerMethodArgumentResolver 的简单应用

假设有一个业务场景，在每个方法执行前，需要获取当前用户的信息，在每个方法自定义去解析似乎是个不错的办法，但是如果方法很多，那么就会出现非常多的冗余代码，这时候我们可以通过参数直接注入，即可实现获取用户的信息，这就是HandlerMethodArgumentResolver 的经典应用场景了。HandlerMethodArgumentResolver 的使用非常简单。先定义一个类UserLoginArgumentResolver实现HandlerMethodArgumentResolver ，该接口只有两个待实现的方法，boolean supportsParameter()方法表示该resolver是否支持该类型的参数解析和Object resolveArgument() throws Exception返回解析后的参数值。

自定义实现如下：其中InjectUser是自定义注解，标识该参数由UserLoginArgumentResolver解析。

/**

 * @author Codegitz

 * @date 2021/11/24 19:46

 **/

public class UserLoginArgumentResolver implements HandlerMethodArgumentResolver {

    @Override

    public boolean supportsParameter(MethodParameter parameter) {

        // 标识如果参数上标有InjectUser注解，则可以处理

        return parameter.hasMethodAnnotation(InjectUser.class) || parameter.hasParameterAnnotation(InjectUser.class);

    }

    @Override

    public Object resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer, NativeWebRequest webRequest, WebDataBinderFactory binderFactory) throws Exception {

        // 自定义的处理逻辑，这里逻辑为简单获取request中的Authorization，解析出用户信息，返回一个User对象

        System.out.println("UserLoginArgumentResolver work....");

        String token = webRequest.getHeader(ReqRespConstants.AUTHORIZATION);

        // 该方法由JwtTokenUtils类提供

        return checkToken(token);

    }

}

@InjectUser的定义如下，该注解可以标识在参数上。

/**

 * @author Codegitz

 * @date 2021/11/24 19:48

 **/

@Target({ElementType.PARAMETER})

@Retention(RetentionPolicy.RUNTIME)

@Documented

public @interface InjectUser {

}

自定义的解析器UserLoginArgumentResolver已经准备好，接下来的工作就是把它注入到原有的逻辑里，让它生效，简而言之，就是注入到Spring的WebMvcConfigurationSupport的List<HandlerMethodArgumentResolver> argumentResolvers里。WebMvcConfigurationSupport类提供了一个addArgumentResolvers()抽象方法，摘取方法以及注解，可以看到这里就是为了自定义注入而设定的。看到这里不由得感慨，这种设计真的是太友好了，在当前写的时候已经考虑到以后的扩展，这是非常值得我们学习的点。所以我们只需要新建一个配置类继承WebMvcConfigurationSupport，把自定义的UserLoginArgumentResolver加入就行。

	/**

	 * Add custom {@link HandlerMethodArgumentResolver HandlerMethodArgumentResolvers}

	 * to use in addition to the ones registered by default.

	 * <p>Custom argument resolvers are invoked before built-in resolvers except for

	 * those that rely on the presence of annotations (e.g. {@code @RequestParameter},

	 * {@code @PathVariable}, etc). The latter can be customized by configuring the

	 * {@link RequestMappingHandlerAdapter} directly.

	 * @param argumentResolvers the list of custom converters (initially an empty list)

	 */

	protected void addArgumentResolvers(List<HandlerMethodArgumentResolver> argumentResolvers) {

	}

自定义的配置类如下：

/**

 * @author Codegitz

 * @date 2021/11/24 21:43

 **/

@Configuration

public class MyWebMvcConfiguration extends WebMvcConfigurationSupport {

    @Bean

    public UserLoginArgumentResolver userLoginArgumentResolver(){

        return new UserLoginArgumentResolver();

    }

    @Override

    protected void addArgumentResolvers(List<HandlerMethodArgumentResolver> argumentResolvers) {

        UserLoginArgumentResolver userLoginArgumentResolver = userLoginArgumentResolver();

        argumentResolvers.add(userLoginArgumentResolver);

        super.addArgumentResolvers(argumentResolvers);

    }

}

到这里已经把基础设施搭建完成，接下来就可以写个测试代码进行测试。新建一个Controller，写下测试方法如下:/login方法用于获取用户的token，这里用个简单的缓存实现，获取token后，后续的请求会带上token，/doSomething方法展示了通过@InjectUser注解注入一个User参数。

    @RequestMapping("/login")

    public ResponseResult<String> login(@RequestBody User request){

        try {

            String user = resolverService.login(request);

            return ResponseResult.success(user);

        } catch (ExecutionException e) {

            return ResponseResult.fail("获取token失败！" + e.getMessage());

        }

    }

    @RequestMapping("/doSomething")

    public ResponseResult<User> doSomething(@InjectUser User user){

        System.out.println("当前操作的用户为: " + user.toString());

        return ResponseResult.success(user,"通过UserLoginArgumentResolver解析参数成功！");

    }

接下来启动项目，先获取token，然后request请求头里带上token去请求后续接口。

获取token后，将token放入请求头里。

可以看到。仅仅通过传入token，我们获取到了一个User对象，并且返回给了响应，那么这一切到底是如何发生的呢？我们是在哪一步将token解析成User，并且把它赋值给我们的方法入参呢？下面就来剖析一下它的原理。

3.HandlerMethodArgumentResolver 的底层实现

本着言简意赅的原则，这里不会给出一个请求到底是怎么进入到spring的详细过程，但是会贴出一个调用链。解析的过程我会先给出spring处理请求参数的地方，然后给出spring是怎么选择适合的resolver的，然后是自定义解析器的执行过程。

首先来看一下调用链：

DispatcherServlet#doDispatch() ->

AbstractHandlerMethodAdapter#handle() ->

RequestMappingHandlerAdapter#handleInternal() ->

RequestMappingHandlerAdapter#invokeHandlerMethod() ->

ServletInvocableHandlerMethod#invokeAndHandle() ->

InvocableHandlerMethod#invokeForRequest()

从这个InvocableHandlerMethod#invokeForRequest()方法开始我们的解析过程，这里调用了Object[] args = getMethodArgumentValues(request, mavContainer, providedArgs)方法，获取了方法参数，随后通过doInvoke(args)调用ResolverController#doSomething(User)方法。

这里的getMethodArgumentValues()显然就是获取参数的方法，进入里面看一下实现逻辑。可以看到逻辑很简单，获取该方法的所有参数，然后循环去给参数赋值，赋值的操作是this.resolvers.resolveArgument()。

可以看到这里的resolvers的类型为HandlerMethodArgumentResolverComposite，这里应用了组合模式HandlerMethodArgumentResolverComposite对象里维护了两个属性，这里面保存了spring容器里所有的HandlerMethodArgumentResolver实现类。

private final List<HandlerMethodArgumentResolver> argumentResolvers = new LinkedList<>();

private final Map<MethodParameter, HandlerMethodArgumentResolver> argumentResolverCache =      new ConcurrentHashMap<>(256);

进入到HandlerMethodArgumentResolverComposite#resolveArgument()里面。

首先会调用getArgumentResolver(parameter)获取适合的resolver，对于这个方法，这里会获取我们自定义的UserLoginArgumentResolver解析器。

该方法会遍历所有的resolvers，找出第一个能够处理该参数的resolver。自定义的resolver这里的supportsParameter()会返回true，跟进会看到这里会进入到自定义的resolver里面。

这里判断参数是否有@InjectUser注解，这里返回true。

这里返回的就是自定义的UserLoginArgumentResolver。

进入自定义resolveArgument()逻辑，返回了获取的user对象。

至此，解析过程已经完成。原理就这么简单。

回到最开始的入口，这个参数会传入doInvoke(args),反射去调用doSomething(user)方法，获取结果返回。

4.总结

这一个过程还是比较简单明了的，应用起来也非常简单。看到这里，最让我深思的问题是，spring为什么能把一个比较复杂的功能写得这么简单明了，且随时可以扩展，这里面的代码功力绝非一朝一夕能习得。首先HandlerMethodArgumentResolver应用了策略模式，不同的实现提供不同的处理逻辑，通过supportsParameter()方法区分。其次，在选择合适的resolver时候，运用了组合模式，里面维护了所有的HandlerMethodArgumentResolver实现，还维护了一个缓存，减少了寻找resolvers时遍历的消耗。细微之处的消耗节省，扣得让人发指。

冰冻三尺非一日之寒，还需要好好学习。

最后附上一个工具代码。完整代码见github。

JwtTokenUtils代码。

/**

 * @author Codegitz

 * @date 2021/11/24 19:58

 **/

public class JwtTokenUtils {

    //用于签名的私钥

    private static final String PRIVATE_KEY = "EDCYHNMYTRESXCVBNMKL";

    //签发者

    private static final String ISS = "Codegitz";

    //过期时间1小时

    private static final long EXPIRATION_ONE_HOUR = 3600L;

    //过期时间1天

    private static final long EXPIRATION_ONE_DAY = 604800L;

    /**

     * 生成Token

     * @param user

     * @return

     */

    public static String createToken(User user, ExpireTimeType type){

        //过期时间

        long expireTime = 0;

        if (type == ExpireTimeType.HOUR){

            expireTime = EXPIRATION_ONE_HOUR;

        }else {

            expireTime = EXPIRATION_ONE_DAY;

        }

        //Jwt头

        Map<String,Object> header = new HashMap<>();

        header.put("typ","JWT");

        header.put("alg","HS256");

        Map<String,Object> claims = new HashMap<>();

        //自定义有效载荷部分

        claims.put("id",user.getId());

        claims.put("userName",user.getUserName());

        claims.put("password",user.getPassword());

        claims.put("address",user.getAddress());

        claims.put("token",user.getToken());

        return Jwts.builder()

                //发证人

                .setIssuer(ISS)

                //Jwt头

                .setHeader(header)

                //有效载荷

                .setClaims(claims)

                //设定签发时间

                .setIssuedAt(new Date())

                //设定过期时间

                .setExpiration(new Date(System.currentTimeMillis() + expireTime * 1000))

                //使用HS256算法签名，PRIVATE_KEY为签名**

                .signWith(SignatureAlgorithm.HS256,PRIVATE_KEY)

                .compact();

    }

    /**

     * 验证Token，组装对象

     * @param token

     * @return

     */

    public static User checkToken(String token){

        //解析token后，从有效载荷取出值

        Claims claimsFromToken = getClaimsFromToken(token);

        String id = (String) claimsFromToken.get("id");

        String userName = (String) claimsFromToken.get("userName");

        String address = (String) claimsFromToken.get("address");

        //封装为User对象

        User user = new User();

        user.setId(id);

        user.setUserName(userName);

        user.setAddress(address);

        user.setToken(token);

        return user;

    }

    /**

     * 获取有效载荷

     * @param token

     * @return

     */

    public static Claims getClaimsFromToken(String token){

        Claims claims = null;

        try {

            claims = Jwts.parser()

                    //设定解密私钥

                    .setSigningKey(PRIVATE_KEY)

                    //传入Token

                    .parseClaimsJws(token)

                    //获取载荷类

                    .getBody();

        }catch (Exception e){

            return null;

        }

        return claims;

    }

}

缓存实现`TokenCache`类。这里默认给个`admin`用户。

/**

 * @author Codegitz

 * @date 2021/11/24 22:11

 **/

@Component

public class TokenCache {

    private static final String CACHEKEY = "cacheKey";

    LoadingCache<String,HashMap<String, User>> cache;

    private void initCache(){

        cache = CacheBuilder.newBuilder()

                .expireAfterAccess(12, TimeUnit.HOURS)

                .maximumSize(100)

                .build(new CacheLoader<String, HashMap<String, User>>() {

                    @Override

                    public HashMap<String, User> load(String token) throws Exception {

                        HashMap<String, User> map = new HashMap<>();

                        User admin = new User();

                        admin.setId("1");

                        admin.setUserName("admin");

                        admin.setAddress("GZ");

                        admin.setPassword("123456");

                        map.put("admin",admin);

                        return map;

                    }

                });

    }

    public User getUser(String userName) throws ExecutionException {

        if (cache == null){

            initCache();

        }

        HashMap<String, User> map = cache.get(CACHEKEY);

        return map.get(userName);

    }

    public void setUser(User user){

        if (cache == null){

            initCache();

        }

        HashMap<String, User> map = new HashMap<>();

        map.put(user.getUserName(),user);

        cache.put(CACHEKEY,map);

    }

}

简单的`ResolverService`类。

/**

 * @author Codegitz

 * @date 2021/11/24 21:52

 **/

@Component

public class ResolverService {

    @Autowired

    private TokenCache tokenCache;

    public String login(User user) throws ExecutionException {

        User exist = tokenCache.getUser(user.getUserName());

        if (exist != null){

            String token = exist.getToken();

            token = token == null ? createToken(exist,ExpireTimeType.HOUR) : token;

            exist.setToken(token);

            return token;

        }

        String token = createToken(user, ExpireTimeType.HOUR);

        user.setToken(token);

        tokenCache.setUser(user);

        return token;

    }

}

巴特西

HandlerMethodArgumentResolver 自定义使用

HandlerMethodArgumentResolver 自定义使用

1.HandlerMethodArgumentResolver 的应用场景

2.HandlerMethodArgumentResolver 的简单应用

3.HandlerMethodArgumentResolver 的底层实现

4.总结

最新文章

热门文章