Spring 高级笔记

@Configuration
class WebConfig {

    // 内嵌容器
    @Bean
    public ServletWebServerFactory servletWebServerFactory() {
        return new TomcatServletWebServerFactory();
    }
    
    @Bean
    public DispatcherServlet dispatchrServlet() {
        return new DispatcherServlet();
    }
    
    @Bean
    public DispatcherServletRegistrationBean registrationBean(DispatcherServlet dispatcherServlet) {
        return new DispatcherServletRegistrationBean(dispatcherServlet, "/");
    }
}

@Component
class LifeCycleBean {
    
    public LifeCycleBean() {
        System.out.println("Construction");
    }

    @Autowired
    public void autowire(@Value("${JAVA_HOME}") String javaHome) {
        System.out.println("注入: " + javaHome);
    }
    
    @PostConstruct
    public void init() {
        System.out.println("Init");
    }
    
    @PreDestroy
    public void destroy() {
        System.out.println("Destroy");
    }

}

Construction
注入：D:\Java\jdk-17.0.6
Init
...
{dataSource-1} closed
...
Destroy

AutowiredAnnotationBeanPostProcessor processor = new AutoWiredAnnotationBeanPostProcessor();

processor.setBeanFactory(beanFactory);

processor.postProcessProperties(null, bean1, "bean1");

// 模拟内部反射
Field bean3 = Bean1.class.getDeclaredField("bean3");

// 第二个形参用于找不到对应的bean时是否报错，false不报错
DependencyDescriptor dd = new DependencyDescriptor(bean3, false);

// null为beanName和别名，可以为null
beanFactory.doResolveDependency(dd, null, null, null);

@Autowired
private ObjectFactory<F3> f3;

public F3 getF3() {
    return f3.getObject();
}

@Autowired
private ApplicationContext context;

public F4 getF4() {
    return context.getBean(F4.class);
}

public class AlthleteProxy {
    public Skill AlthleteProxy(Althletes obj) {
        return (Skill) Proxy.newProxyInstance(
            // 代理类没有源码，在加载时使用asm生成字节码，需要类加载器来加载它
            obj.getClass().getClassLoader(),
            // 实现同一接口
             obj.getClass().getInterfaces(),
            // 封装行为
             ((proxy, method, args) ->  {
                System.out.println("Start");
                Object result = method.invoke(proxy, args);
                System.out.println("Finish");
                return result;
             };)
        );
    }
}

interface InvocationHandler {
    Object invoke(Object proxy, Method method, Object[] args) throws Throwable;
}

final class $Proxy0 extends Proxy implements Foo {
    private static final Method m0;
    
    // 父类Proxy中声明了该成员变量，用于invoke回调
    public $Proxy0(InvocationHandler invocationHandler) {
        super(invocationHandler);
    }
    
    static {
        try {
            // 通过反射获取方法对象
            m0 = Class.forName("ski.mashiro.JdkProxyDemo$Foo").getMethod("foo", new Class[0]);
        } catch (NoSuchMethodExpection e) {
            throw new NoSuchMethodError(e.getMessage());
        } catch (ClassNotFoundException e) {
            throw new NoClassDefFoundError(e.getMessage());
        }
    }
    
    public final void foo() {
        try {
            // 通过父类中的成员 InvocationHandler h，调用 invoke
            this.h.invoke(this, m0, null);
        } catch (Error | RuntimeException throwable) {
            throw throwable;
        } catch (Throwable throwable) {
            throw new UndeclaredThrowableException(throwable);
        }
    }
}

public class CglibProxyDemo {
    class Target {
        public void foo() {
            System.out.println("target foo");
        }
    }
    
    public static void main(String...args) {
        Target target = new Target();
        Target proxy = (Target) Enhancer.create(
//                指定父类型，代理对象为其子类型，因此父类不能为final，方法也不能为final，因为使用重写实现
                Target.class,
//                new MethodInterceptor() {
//                    @Override
//                    public Object interceptor(Object proxy, Method method, Object[] args, MethodProxy methodProxy) {}
//                }
//				 methodProxy可以避免反射调用，内部直接调用
//                Object result = methodProxy.invoke(target, args); 需要目标对象(Spring使用)
//                Object result = methodProxy.invokeSuper(proxy, args); 需要代理对象
                (proxy, method, args, methodProxy) -> {
                    System.out.println("Before...");
                    Object result = method.invoke(target, args);
                    System.out.println("After...");
                    return result;
                }
        );
        proxy.foo();
    }
}

public class Proxy extends Target {
    private static Method m0;
    private static MethodProxy mp0;
    
    private MethodInterceptor methodInterceptor;
    
    public void setMethodInterceptor(MethodInterceptor methodInterceptor) {
        this.methodInterceptor = methodInterceptor;
    }
    
    static {
        try {
            // 通过反射获取方法对象
            m0 = Class.forName("ski.mashiro.CglibProxyDemo").getMethod("foo", new Class[0]);
            // 获取 MethodProxy 对象，第3,4个形参即为签名Signature的参数
            // 首次使用MethodProxy时底层会创建 FastClass 的子类，本质是代理类，目的是避免反射调用
            mp0 = MethodProxy.create(Target.class, Proxy.class, "()V", "foo", "fooSuper");
        } catch (NoSuchMethodExpection e) {
            throw new NoSuchMethodError(e.getMessage());
        } catch (ClassNotFoundException e) {
            throw new NoClassDefFoundError(e.getMessage());
        }
    }
    
    
    public void fooSuper() {
        super.foo();
    }
    
    @Override
    public void foo() {
        try {
            methodInterceptor.intercept(this, m0, new Object[0], mp0);
        } catch (Error | RuntimeException throwable) {
            throw throwable;
        } catch (Throwable throwable) {
            throw new UndeclaredThrowableException(throwable);
        }
        super.foo();
    }
}

// 这个类也是直接生成字节码的，其父类是 FastClass，是抽象类，这里仅做部分实现
// 一个代理目标对应两个 FastClass，一个作用于目标，一个作用于代理
public class TargetFastClass {
    private static Signature s0 = new Signature("foo", "()V");
    
    /**
     * signature 方法特征签名
     * @return 索引
     * 给每个方法一个索引
     */
    public int getIndex(Signature signature) {
        if (signature.equals(s0)) {
            return 0;
        }
        return -1;
    }
    
    public Object invoke(int index, Object target, Object[] args) {
        if (index == 0) {
            ((Target) target).foo();
            return null;
        } else {
            throw new RuntimeException("Err");
        }
    }
}

class Target implements T1 {
    public void foo() {
        System.out.println("foo");
    }
}

class AopDemo {
    public static void main(String...args) {

        // 切点
        var pointcut = new AspectJExpressionPointcut();
        pointcut.setExpression("execution(* foo())");

        // 通知, 非CGLib的接口
        MethodInterceptor advice = invocation -> {
            System.out.println("before");
            // 调用目标
            Object result = invocation.proceed();
            System.out.println("after");
            return result;
        };

        // 切面
        var advisor = new DefaultPointcutAdvisor(pointcut, advice);

        // 创建代理, ProxyFactory是用来创建代理的核心实现
        ProxyFactory factory = new ProxyFactory();
        factory.setTarget(target);
        factory.addAdvisor(advisor);
        /*
         规则：
         proxyTargetClass = false, 目标类实现了接口, 用JDK实现
         proxyTargetClass = false, 目标类未实现接口，用CGLib实现
         proxyTargetClass = true,  用CGLib实现

         factory.setProxyTargetClass(false);
         
         其内部又用了 AopProxyFactory 选择具体的代理实现
             - JdkDynamicAopProxy
             - ObjenesisCglibAopProxy
        */
        I1 proxy = (I1) factory.getProxy();
        proxy.foo();
    }
}

var pointcut = new AspectJExpressionPointcut();
    // 方法名判断
    pointcut.setExpression("execution(* foo())");
    
    // 代理也这样做检查，判断是否符合
    pointcut.matches(T1.class.getMethod("foo"), T1.class);
    
    // 注解判断
    pointcut.setExpression("@annotation(org.springframework.transaction.annotation.Transactional)");

    pointcut.matches(T1.class.getMethod("foo"), T1.class);

var pt = new StaticMethodMatcherPointcut() {
        @Override
        public boolean matches(Method method, Class<?> targetClass) {
            var annotations = MergedAnnotations.from(method);
            // 检查方法上是否有 Transactional 注解
            if (annotations.isPresent(Transactional.class)) {
                return true;
            }
            // 检查类及其接口上是否有 Transactional 注解
            annotations = MergedAnnotations.from(targetClass, SearchStrategy.TYPE_HIERARCHY);
            if (annotations.isPresent(Transactional.class)) {
                return true;
            }
            return false;
        }
    }

protected void initStrategies(ApplicationContext context) {
    // 文件上传解析
    this.initMultipartResolver(context);
    // i18n支持
    this.initLocaleResolver(context);
    this.initThemeResolver(context);
    // 路径映射处理
    this.initHandlerMappings(context);
    // 适配不同形式的Controller方法
    this.initHandlerAdapters(context);
    // 异常解析
    this.initHandlerExceptionResolvers(context);
    this.initRequestToViewNameTranslator(context);
    this.initViewResolvers(context);
    this.initFlashMapManager(context);
}

- 路径：默认映射路径为 `/`，即会匹配到所有请求URL，可作为请求的统一入口，也被称之为前控制器
    - 例外：JSP不会匹配到 DispatcherServlet
- 创建：在 Boot 中，由 DispatcherServletAutoConfiguration 这个自动配置类提供 DispatcherServlet 的 bean
- 初始化：DispatcherServlet 初始化时会优先到容器里寻找各种组件，作为它的成员变量
    - HandlerMapping：初始化时记录映射关系
    - HandlerAdapter：初始化时准备参数解析器、返回值处理器、消息转换器
    - HandlerExceptionResolver：初始化时准备参数解析器、返回值处理器、消息转换器
    - ViewResolverDispatcherServlet 会利用 HandlerMapping 进行路径匹配，找到 @RequestMapping("/hello") 对应的控制器方法

- 控制器方法会被封装为 HandlerMethod 对象，并结合匹配到的拦截器一起返回给 DispatcherServlet
- HandlerMethod 和拦截器合在一起称为 HandlerExecutionChain （调用链）对象DispatcherServlet 接下来会：

1. 调用拦截器的 preHandler 方法

2. RequestMappingHandlerAdapter 调用 handle 方法，准备数据绑定工厂、模型工厂、将 HandlerMethod 完善为 ServletInvocableHandlerMethod

    - @ControllerAdvice：补充模型数据、自定义类型转换器，@RequestBody 增强，@ResponseBody 增强，@ExceptionHandler 异常处理
    - 使用 HandlerMethodArgumentResolver 准备参数
    - 调用 ServletInvocableHandlerMethod
    - 使用 HandlerMethodReturnValueHandler 处理返回值
        - 如果返回的 ModelAndView 为 null，不走第 4 步视图解析及渲染流程 如标注了 @ResponseBody 的控制器方法，调用 HttpMessageConverter 来将结果转换为 Json，这时返回的 ModelAndView 就为 null
        - 如果返回的 ModelAndView 不为 null，会在第 4 步走视图解析渲染流程
3. 调用拦截器的 postHandle 方法

4. 处理异常或视图渲染

    - 如果 1~3 出现异常，走 ExceptionHandlerExceptionResolver 处理异常流程
    - 正常，走视图解析渲染流程
5. 调用拦截器的 afterCompletion 方法

- 发布 application starting 事件封装启动 args

- 发布 application environment 已准备事件通过 EnvironmentPostProcessorApplicationListener 进行 env 后处理

- application.properties，由 StandardConfigDataLocationResolver 解析
- spring.application.json绑定 spring.main 到 SpringApplication 对象

- 发布 application context 已初始化事件加载 bean 定义

- 发布 application prepared 事件refresh 容器

- 发布 application started 事件执行 runner

- 发布 application ready 事件
- 有异常则发布 application failed 事件