Spring 概览

Spring概览

核心类

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

生命周期

• Bean 生命周期
  spring生命周期.png

• 循环依赖

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

AbstractAutowireCapableBeanFactory.doCreateBean

1. 创建对象A，并放入缓存
2. 发现A依赖B且B不存在
3. 创建对象B
4. 发现B依赖A
5. 从一级缓存取A，取不到就去二级缓存，还取不到就去三级缓存
6. 取到A后完成B的创建
7. 继续A的初始化，完成对象创建
8. 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

• 启动流程示例图