Spring 概览

Spring概览

核心类

精简版实现
源码分析
BeanFactory 实例工厂类，get的时候才实例化bean
BeanDefinition 实例的各种配置信息，如是否单例、引用依赖等
ApplicationContext 内部引用了 BeanFactory ，通过 refresh 方法自动实例化bean
- BeanDefinitionReader 读取扫描到的描述文件
- BeanDefinitionScanner 获取扫描范围
BeanPostProcessor 对bean实例进行增强，如实现AOP功能

生命周期

Bean 生命周期

spring生命周期.png

循环依赖

为什么要用三级缓存，一是并发可能获得半成品的实例，二是AOP需要生成代理对象

AbstractAutowireCapableBeanFactory.doCreateBean

创建对象A，并放入缓存
发现A依赖B且B不存在
创建对象B
发现B依赖A
从一级缓存取A，取不到就去二级缓存，还取不到就去三级缓存
取到A后完成B的创建
继续A的初始化，完成对象创建
B引用的A已经是完整对象了

AOP

AOP联盟
AOP发展
Advice 目标方法的插入位置
MethodInterceptor 在方法前后定义调用模板，就是Advice组合
Joinpoint、Invocation、MethodInvocation 目标方法的包装
Pointcut 指定拦截的方法，表达式等
Advisor 将拦截规则与增强的方法建立关联，就是哪种规则进行哪些增强
AspectJAwareAdvisorAutoProxyCreator 通过实现BeanPostProcessor接口自动初始化AOP

AOP流程.png

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

@Component
@Aspect
public class AopAspect {

    //定义切点
    @Pointcut("execution(* example.aop.*.*(..))")
    public void aopPointcut() {
    }

    //前置通知
    @Before("aopPointcut()")
    public void before() {
        System.out.println("前置通知");
    }

    //后置通知
    @After("aopPointcut()")
    public void after() {
        System.out.println("后置通知");
    }

    //环绕通知
    @Around("aopPointcut()")
    public void around(ProceedingJoinPoint pjp) throws Throwable{
        System.out.println("环绕通知：环绕前");
        pjp.proceed();//执行方法
        System.out.println("环绕通知：环绕后");
    }
}

Spring 事务

参考地址

Spring MVC

整体流程

Controller 定义URL请求地址，Handler可以理解为Controller方法生成的bean
HandlerMapping URL映射bean
HandlerInterceptor 拦截处理请求
HandlerAdapter 统一拦截器的请求方式

Spring 扩展点

异常处理

@ExceptionHandler + @ControllerAdvice

/**
 * 统一错误处理入口
 */
@ControllerAdvice(basePackages = "com.finup.coffee.controller")
public class ErrorAdvice {
    private static final Logger LOGGER = LoggerFactory.getLogger(ErrorAdvice.class);

    @ExceptionHandler(Exception.class)
    @ResponseBody
    public ResponseVo<String> handleControllerException(Exception ex) {
        LOGGER.error("接口错误统一处理：", ex);
        String errorCode = "";
        String errorMessage = "";
        if (ex instanceof BusinessException) {
            errorCode = ((BusinessException) ex).getErrorCode();
            errorMessage = ex.getMessage();
        } else if (ex instanceof IllegalArgumentException) {
            errorCode = ResponseCode.PARAMETER_ERROR.getValue();
            errorMessage = ex.getMessage();
        } else {
            errorCode = ResponseCode.SERVER_ERROR.getValue();
            errorMessage = ResponseCode.SERVER_ERROR.getMessage();
        }
        return ResponseVo.ofError(errorCode, errorMessage);
    }
}

过滤器 Filter

Filter前处理 --> Interceptor前处理 --> controller--> Interceptor后处理 --> Filter后处理

拦截器 HandlerInterceptor

拦截器只能处理mapping映射

AOP切面

xxxAware接口

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.BeanNameAware;
import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;

//Bean层面执行
public class LifeCircleService implements BeanNameAware, ApplicationContextAware, InitializingBean, DisposableBean {
    @Override
    public void setBeanName(String name) {
        System.out.println("BeanNameAware.setBeanName");
    }

    @Override
    public void destroy() throws Exception {
        System.out.println("DisposableBean.destroy");
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("InitializingBean.afterPropertiesSet");
    }

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        System.out.println("ApplicationContextAware.setApplicationContext");
    }
}

xxxPostProcessor

import org.springframework.beans.BeansException;
import org.springframework.beans.PropertyValues;
import org.springframework.beans.factory.config.InstantiationAwareBeanPostProcessor;

//容器层面执行
public class CustomInstantiationAwareBeanPostProcessor implements InstantiationAwareBeanPostProcessor {
    @Override
    public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
        return null;
    }

    @Override
    public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
        return false;
    }

    @Override
    public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) throws BeansException {
        return null;
    }

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        return null;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        return null;
    }
}

导入实例 @import

导入普通类
导入 @Configuration 类
导入 ImportBeanDefinitionRegistrar 接口类，批量注册bean
导入 ImportSelector 接口过滤的类

Spring Boot

运行器 Runner

SpringApplication.run(ApplicationBoot.class,args)通过构造方法初始化，加载resource(main方法类)，判断当前是否是web环境并初始化 ConfigurableApplicationContext，并在refresh的时候启动tomcat

启动流程示例图