首页 > 其他分享 >Springcloud学习笔记61---Spring MVC的拦截器HandlerInterceptor

Springcloud学习笔记61---Spring MVC的拦截器HandlerInterceptor

时间:2024-01-26 15:37:27浏览次数:31  
标签:拦截器 Springcloud private public --- bean HandlerMethod 方法 method

1. HandlerMethod 介绍

HandlerMethod它作为Spring MVC的非公开API,可能绝大多数小伙伴都对它比较陌生,但我相信你对它又不是那么的生疏,因为你可能没用过但肯定见过。比如Spring MVC的拦截器HandlerInterceptor的拦截方法的第三个入参Object handler,虽然它是Object类型,但其实绝大部分情况下我们都会当作HandlerMethod来使用;又比如我之前的这篇讲RequestMappingHandlerMapping的文章也大量的提到过HandlerMethod这个类。

经由我这么“忽悠”,你是否觉得它还是相对比较重要的一个类了呢?不管你信不信,反正我是这么认为的:HandlerMethod它是理解Spring MVC不可或缺的一个类,甚至可以说是你希望参与到Spring MVC的定制化里面来不可忽略的一个关键API。

2.HandlerMethod详解

我们知道在 SpringMVC 中 控制器(Controller)负责对请求路径进行匹配并调用相应地执行方法。

而 HandlerMethod 就表示这个方法, 但它一般也被称作处理器,即 handler。因为它身上包含了控制器信息、控制器的指定方法信息。

下面来看它的构造函数,需要关注的是它的几个成员变量:

public HandlerMethod(Object bean, Method method) {
    // 省略部分代码...

    // 控制器名称
    this.bean = bean;

    // 所在容器,这里指 SpringMVC 容器
    this.beanFactory = null;

    // 控制器类型
    this.beanType = ClassUtils.getUserClass(bean);

    // 路径匹配的执行方法
    this.method = method;

    // 方法参数
    this.parameters = initMethodParameters();

    // 桥方法,一般情况与 method 值一样
    this.bridgedMethod = BridgeMethodResolver.findBridgedMethod(method);

    this.resolvedFromHandlerMethod = null;

}

 

HandlerMethod它不是一个接口,也不是个抽象类,且还是public的。HandlerMethod封装了很多属性,在访问请求方法的时候可以方便的访问到方法、方法参数、方法上的注解、所属类等并且对方法参数封装处理,也可以方便的访问到方法参数的注解等信息。

// @since 3.1
public class HandlerMethod {

    // Object类型,既可以是个Bean,也可以是个BeanName
    private final Object bean;
    // 如果是BeanName,拿就靠它拿出Bean实例了~
    @Nullable
    private final BeanFactory beanFactory;
    private final Class<?> beanType; // 该方法所属的类
    private final Method method; // 该方法本身
    private final Method bridgedMethod; // 被桥接的方法,如果method是原生的,它的值同method
    // 封装方法参数的类实例,**一个MethodParameter就是一个入参**
    // MethodParameter也是Spring抽象出来的一个非常重要的概念
    private final MethodParameter[] parameters;
    @Nullable
    private HttpStatus responseStatus; // http状态码(毕竟它要负责处理和返回)
    @Nullable
    private String responseStatusReason; // 如果状态码里还要复数原因,就是这个字段  可以为null


    // 通过createWithResolvedBean()解析此handlerMethod实例的handlerMethod。
    @Nullable
    private HandlerMethod resolvedFromHandlerMethod;
    // 标注在**接口入参**上的注解们(此处数据结构复杂,List+二维数组)
    @Nullable
    private volatile List<Annotation[][]> interfaceParameterAnnotations;

    // 它的构造方法众多  此处我只写出关键的步骤
    public HandlerMethod(Object bean, Method method) {
        ...
        this.beanType = ClassUtils.getUserClass(bean);
        this.bridgedMethod = BridgeMethodResolver.findBridgedMethod(method);
        this.parameters = initMethodParameters();
        ...
        evaluateResponseStatus();
    }
    // 这个构造方法抛出了一个异常NoSuchMethodException 
    public HandlerMethod(Object bean, String methodName, Class<?>... parameterTypes) throws NoSuchMethodException {
        ...
        this.method = bean.getClass().getMethod(methodName, parameterTypes);
        this.parameters = initMethodParameters();
        ...
        evaluateResponseStatus();
    }
    // 此处传的是BeanName
    public HandlerMethod(String beanName, BeanFactory beanFactory, Method method) {
        ...
        // 这部判断:这个BeanName是必须存在的
        Class<?> beanType = beanFactory.getType(beanName);
        if (beanType == null) {
            throw new IllegalStateException("Cannot resolve bean type for bean with name '" + beanName + "'");
        }
        this.parameters = initMethodParameters();
        ...
        evaluateResponseStatus();
    }

    // 供给子类copy使用的
    protected HandlerMethod(HandlerMethod handlerMethod) { ... }
    
    // 所有构造都执行了两个方法:initMethodParameters和evaluateResponseStatus

    // 初始化该方法所有的入参,此处使用的是内部类HandlerMethodParameter
    // 注意:处理了泛型的~~~
    private MethodParameter[] initMethodParameters() {
        int count = this.bridgedMethod.getParameterCount();
        MethodParameter[] result = new MethodParameter[count];
        for (int i = 0; i < count; i++) {
            HandlerMethodParameter parameter = new HandlerMethodParameter(i);
            GenericTypeResolver.resolveParameterType(parameter, this.beanType);
            result[i] = parameter;
        }
        return result;
    }

    // 看看方法上是否有标注了@ResponseStatus注解(接口上或者父类 组合注解上都行)
    // 若方法上没有,还会去所在的类上去看看有没有标注此注解
    // 主要只解析这个注解,把它的两个属性code和reason拿过来,最后就是返回它俩了~~~
    // code状态码默认是HttpStatus.INTERNAL_SERVER_ERROR-->(500, "Internal Server Error")
    private void evaluateResponseStatus() {
        ResponseStatus annotation = getMethodAnnotation(ResponseStatus.class);
        if (annotation == null) {
            annotation = AnnotatedElementUtils.findMergedAnnotation(getBeanType(), ResponseStatus.class);
        }
        if (annotation != null) {
            this.responseStatus = annotation.code();
            this.responseStatusReason = annotation.reason();
        }
    }
    ... // 省略所有属性的get方法(无set方法)

    // 返回方法返回值的类型  此处也使用的MethodParameter 
    public MethodParameter getReturnType() {
        return new HandlerMethodParameter(-1);
    }
    // 注意和上面的区别。举个列子:比如方法返回的是Object,但实际return “fsx”字符串
    // 那么上面返回永远是Object.class,下面你实际的值是什么类型就是什么类型
    public MethodParameter getReturnValueType(@Nullable Object returnValue) {
        return new ReturnValueMethodParameter(returnValue);
    }

    // 该方法的返回值是否是void
    public boolean isVoid() {
        return Void.TYPE.equals(getReturnType().getParameterType());
    }
    // 返回标注在方法上的指定类型的注解   父方法也成
    // 子类ServletInvocableHandlerMethod对下面两个方法都有复写~~~
    @Nullable
    public <A extends Annotation> A getMethodAnnotation(Class<A> annotationType) {
        return AnnotatedElementUtils.findMergedAnnotation(this.method, annotationType);
    }
    public <A extends Annotation> boolean hasMethodAnnotation(Class<A> annotationType) {
        return AnnotatedElementUtils.hasAnnotation(this.method, annotationType);
    }


    // resolvedFromHandlerMethod虽然它只能被构造进来,但是它实际是铜鼓调用下面方法赋值
    @Nullable
    public HandlerMethod getResolvedFromHandlerMethod() {
        return this.resolvedFromHandlerMethod;
    }
    // 根据string类型的BeanName把Bean拿出来,再new一个HandlerMethod出来~~~这才靠谱嘛
    public HandlerMethod createWithResolvedBean() {
        Object handler = this.bean;
        if (this.bean instanceof String) {
            Assert.state(this.beanFactory != null, "Cannot resolve bean name without BeanFactory");
            String beanName = (String) this.bean;
            handler = this.beanFactory.getBean(beanName);
        }
        return new HandlerMethod(this, handler);
    }

    public String getShortLogMessage() {
        return getBeanType().getName() + "#" + this.method.getName() + "[" + this.method.getParameterCount() + " args]";
    }


    // 这个方法是提供给内部类HandlerMethodParameter来使用的~~ 它使用的数据结构还是蛮复杂的
    private List<Annotation[][]> getInterfaceParameterAnnotations() {
        List<Annotation[][]> parameterAnnotations = this.interfaceParameterAnnotations;
        if (parameterAnnotations == null) {
            parameterAnnotations = new ArrayList<>();

            // 遍历该方法所在的类所有的实现的接口们(可以实现N个接口嘛)
            for (Class<?> ifc : this.method.getDeclaringClass().getInterfaces()) {
            
                // getMethods:拿到所有的public的方法,包括父接口的  接口里的私有方法可不会获取来
                for (Method candidate : ifc.getMethods()) {
                    // 判断这个接口方法是否正好是当前method复写的这个~~~
                    // 刚好是复写的方法,那就添加进来,标记为接口上的注解们~~~
                    if (isOverrideFor(candidate)) {
                        // getParameterAnnotations返回的是个二维数组~~~~
                        // 因为参数有多个,且每个参数前可以有多个注解
                        parameterAnnotations.add(candidate.getParameterAnnotations());
                    }
                }
            }
            this.interfaceParameterAnnotations = parameterAnnotations;
        }
        return parameterAnnotations;
    }

    
    // 看看内部类的关键步骤
    protected class HandlerMethodParameter extends SynthesizingMethodParameter {
        @Nullable
        private volatile Annotation[] combinedAnnotations;
        ...

        // 父类只会在本方法拿,这里支持到了接口级别~~~
        @Override
        public Annotation[] getParameterAnnotations() {
            Annotation[] anns = this.combinedAnnotations;
            if (anns == null) { // 都只需要解析一次
                anns = super.getParameterAnnotations();
                int index = getParameterIndex();
                if (index >= 0) { // 有入参才需要去分析嘛
                    for (Annotation[][] ifcAnns : getInterfaceParameterAnnotations()) {
                        if (index < ifcAnns.length) {
                            Annotation[] paramAnns = ifcAnns[index];
                            if (paramAnns.length > 0) {
                                List<Annotation> merged = new ArrayList<>(anns.length + paramAnns.length);
                                merged.addAll(Arrays.asList(anns));
                                for (Annotation paramAnn : paramAnns) {
                                    boolean existingType = false;
                                    for (Annotation ann : anns) {
                                        if (ann.annotationType() == paramAnn.annotationType()) {
                                            existingType = true;
                                            break;
                                        }
                                    }
                                    if (!existingType) {
                                        merged.add(adaptAnnotation(paramAnn));
                                    }
                                }
                                anns = merged.toArray(new Annotation[0]);
                            }
                        }
                    }
                }
                this.combinedAnnotations = anns;
            }
            return anns;
        }
    }

    // 返回值的真正类型~~~
    private class ReturnValueMethodParameter extends HandlerMethodParameter {
        @Nullable
        private final Object returnValue;
        public ReturnValueMethodParameter(@Nullable Object returnValue) {
            super(-1); // 此处传的-1哦~~~~ 比0小是很有意义的
            this.returnValue = returnValue;
        }
        ...
        // 返回值类型使用returnValue就行了~~~
        @Override
        public Class<?> getParameterType() {
            return (this.returnValue != null ? this.returnValue.getClass() : super.getParameterType());
        }
    }
}

 

标签:拦截器,Springcloud,private,public,---,bean,HandlerMethod,方法,method
From: https://www.cnblogs.com/luckyplj/p/17989510

相关文章

  • python之常用标准库-时间
    1.time时间戳:它代表了从格林尼治时间1970年01月01日00时00分00秒(即北京时间的1970年01月01日08时00分00秒)开始到现在经过的总秒数。struct_time:用一个包含9个序列的元组组成(tm_year=2024,tm_mon=1,tm_mday=26,tm_hour=2,tm_min=49,tm_sec=56,tm_wday=4,tm_yday=26,......
  • 无涯教程-Scala - 模式匹配
    在函数值和闭包之后,模式匹配是Scala第二广泛使用的函数,Scala在处理消息时为模式匹配提供了强大的支持。Pattern-示例objectDemo{defmain(args:Array[String]){println(matchTest(3))}defmatchTest(x:Int):String=xmatch{case1=>......
  • 设计模式-工厂模式
    前言工厂模式,顾名思义就是我们可以通过一个指定的“工厂”获得需要的“产品”,在设计模式中主要用于抽象对象的创建过程,让用户可以指定自己想要的对象而不必关心对象的实例化过程,这样做的好处是:用户只需通过固定的接口而不是直接去调用类的实例化方法来获得一个对象的实例隐藏......
  • 京东广告算法架构体系建设--在线模型系统分布式异构计算演变 | 京东零售广告技术团队
    一、现状介绍 算法策略在广告行业中起着重要的作用,它可以帮助广告主和广告平台更好地理解用户行为和兴趣,从而优化广告投放策略,提高广告点击率和转化率。模型系统作为承载算法策略的载体,目前承载搜索、推荐、首焦、站外等众多广告业务和全链路的深度学习建模,是广告算法算法创新......
  • 29-数据结构介绍
          ......
  • 无涯教程-Scala - 特性(Traits)
    Traits封装了方法和字段定义,然后可以通过混合到类中来重用它们。与类继承不同,一个类可以混合任意数量的traits。traits定义看起来类似于类定义,只是它使用关键字trait。以下是trait的基本示例语法。Traits-语法traitEqual{defisEqual(x:Any):BooleandefisNot......
  • Mysteel参考丨浅述工业线材重要下游-紧固件行业发展概况
    概述:作为工业线材最重要的下游产业之一,紧固件行业发展状况对工业线材品种有其直接影响。目前螺纹紧固件如螺栓、螺母的母材以冷镦钢为主;拉丝材Q195、Q235以生产铁丝、铁钉、铆钉等小五金标准件流入市场。据Mysteel统计,2022年全国样本工业线材冷镦钢钢厂产量为5361.4万吨,较2021年增......
  • 读论文-基于自监督学习的序列推荐算法
    前言今天读的文章为一篇名叫《基于自监督学习的序列推荐算法》的期刊论文,文章于2023年8月15日发表在自然科学报上,这篇论文的引用为:[1]闫猛猛,汪海涛,贺建峰等.基于自监督学习的序列推荐算法[J].重庆邮电大学学报(自然科学版),2023,35(04):722-731.摘要原文如下:针对现有序列......
  • audio currentTime 设置后,重置成0,解决方案(流文件-下载文件)
    audiocurrentTime设置后,重置成0,解决方案第一步-流文件-下载文件:先查看你的mp3文件是流文件,还是下载文件。检测方式,就是放到浏览器回车。在线播放就是流文件,直接下载了,就是下载文件。是需要流文件,才可以拖拽进度条。第二步:currentTimeseekTo方法针对不同浏览器,做下兼容......
  • .NET 8 的新增功能-数据验证
    1.概要在.NET8中C#的新增特性,System.ComponentModel.DataAnnotations命名空间包括用于云原生服务中的验证场景的新数据验证特性。虽然预先存在的 DataAnnotations 验证程序适用于典型的UI数据输入验证(例如窗体上的字段),但新特性旨在验证非用户输入数据,例如配置选项。除了新......