Spring注解开发+源码分析

文章概要

• 起因和概述
• 常用注解解析
  • 控制反转IOC，容器的作用
  • 依赖注入DI，获取对象的作用
  • 面象切面AOP
  • 声明式事务Tx
  • 扩展原理
• 源码分析，分析为什么有这些注解
• web开发 servlet3.0和SpringMvc注解

起因

从来没学过spring，也没看过源码，但是并不耽误我开发，别问我为什么 :) 我都是面向Google编程，手动狗头，so 今天来补一下sb（SpringBoot）基础知识

附带视频讲解百度云地址：

链接：https://pan.baidu.com/s/1YOPRjBl_25VnuWLnV3lrQA
提取码：ybx4
QQ群：317896269 点击链接加入群聊【数据爬取技术群】：https://jq.qq.com/?_wv=1027&k=5H2Y1Tg
群文件有很多分享的数据，需要的可以去下载，另外入群费2元，老有人来发广告，没办法了，收费。

特殊说明：虽然我不懂spring的源码和原理，但是不影响我开发，这可能就是spring做的伟大的地方。但是，我看过spring原理后开发会更高效、优质。
为什么说上边两句话，因为有这个前提，所以我学习spring原理的途径是找一个好的视频，简明扼要，快速精炼的了解一遍，然后在实践。
在看了官方文档之后，我选择了找个视频，文档说的太全了，简直浪费生命。
所以我google了这段视频，并简单整理后发到了百度云，视频来源是某培训机构的，网上随便搜的，使用开发工具eclipse，比较老旧，但是不影响观看思想，总的来说讲的很好，讲师水平很高，建议1.5倍速度播放视频观看，我用了1天半，总计大概8个小时的时间观看视频、做笔记、coding部分代码加这篇文章整理。受益良多。
加这段废话的原因是：告诉你怎么快速掌握这段知识，and，少走弯路。

感谢原视频作者，感谢spring框架，感谢google

起头

SpringBoot起源于Spring，意在简化Spring的配置和使用，Spring源于EJB，其源远流长，更古不变的两点核心，DI和IOC，即依赖注入和控制反转

先看容器Spring首先是容器。

• 海纳百川，有容奶大，对，奶大！

容器的配置一开始是使用xml配置文件的，现在用注解更方便了。故对照着来看，如下：

配置容器 @Configuration

标记一个类为配置类，这个类等同于配置文件beans.xml

注入组件 @Bean

标记配置类中的某个方法为注入的bean对象，被标记的方法等同于beans.xml 文件中的 标签

Bean的生命周期

指定初始化和销毁方法

1. @Bean(initMethod="初始化方法名",destroyMethod="销毁方法名")
2. 让Bean实现InitializingBean接口（定义初始化逻辑），DisposableBean（定义销毁逻辑）
3. 可以使用JSR250；
 *      @PostConstruct：在bean创建完成并且属性赋值完成；来执行初始化方法
 *      @PreDestroy：在容器销毁bean之前通知我们进行清理工作
-- 备注：JCP（Java Community Process）成立于1998年，是使有兴趣的各方参与定义Java的特征和未来版本的正式过程。
4. BeanPostProcessor【interface】：bean的后置处理器；在bean初始化前后进行一些处理工作；
 *      postProcessBeforeInitialization:在初始化之前工作
 *      postProcessAfterInitialization:在初始化之后工作

包扫描 @ComponentScans

标记在配置类上，指明要扫描的包。等同于xml配置文件中的 标签

包扫描时的过滤规则 @Filter

包扫描时@ComponentScans需要一些过滤规则，由注解@Filter标注。

组件的作用域 @Scope

用在@Bean注解的方法上，标注bean的作用域，Srping的bean默认是单例的，如果更改作用域使用这个注解

• singleton：单实例的（默认值）：ioc容器启动会调用方法创建对象放到ioc容器中。以后每次获取就是直接从容器中取（map.get()）

• prototype：多实例的：ioc容器启动并不会去调用方法创建对象放在容器中。每次获取的时候才会调用方法创建对象；

• request：同一次请求创建一个实例

• session：同一个session创建一个实例

组件懒加载 @Lazy

用在@Bean标注的方法上，指定bean懒加载，或者说延时加载，启动的时候不加载，bean被第一次调用的时候加载。

组件按条件注入 @Conditional

注入bean时，指定一些条件@Conditional，标记在配置类或bean方法上

给容器快速导入一个组件 @Import

给容器导入组件的方式：

1. 包扫描+内置注解 （@Controller/@Service/@Repository/@Component）[自己写的类]
2. 导入第三方组件 @Bean[导入的第三方包里面的组件]
3. @Import[快速给容器中导入一个组件]
   *1）、@Import(要导入到容器中的组件)；容器中就会自动注册这个组件，id默认是全类名
   *2）、ImportSelector:返回需要导入的组件的全类名数组；
   *3）、ImportBeanDefinitionRegistrar:手动注册bean到容器中
   4.使用Spring提供的 FactoryBean（工厂Bean）;
   • 1）、默认获取到的是工厂bean调用getObject创建的对象
   • 2）、要获取工厂Bean本身，我们需要给id前面加一个& &colorFactoryBean

属性注入 @Value

给属性赋值，等同于xml中的 的

• 1、基本数值
• 2、可以写SpEL； #{}
• 3、可以写${}；取出配置文件【properties】中的值（在运行环境变量里面的值）

加载配置文件@PropertySource

使用@PropertySource读取外部配置文件中的k/v保存到运行的环境变量中;加载完外部的配置文件以后使用${}取出配置文件的值@PropertySource(value={"classpath:/person.properties"})

• 多个配置文件可以适用多个@PropertySource或者适用@PropertySources

再看自动注入

@Autowired注入

• 默认优先按照类型去容器中找bean，applicationContext.getBean(BookDao.class)，找到就赋值，找不到时再按id去容器中找applicationContext.getBean("bookDao")，还找不到就报错了。自动装配默认一定要将属性赋值好，没有就会报错；可以使用@Autowired(required=false)标注为找不到时注入null并不报错;

• 1）、默认优先按照类型去容器中找对应的组件:applicationContext.getBean(BookDao.class);找到就赋值

• 2）、如果找到多个相同类型的组件，再将属性的名称作为组件的id去容器中查找applicationContext.getBean("bookDao")

• 3）、@Qualifier("bookDao")：使用@Qualifier指定需要装配的组件的id，而不是使用属性名

• 4）、自动装配默认一定要将属性赋值好，没有就会报错；可以使用@Autowired(required=false);

• 5）、@Primary：让Spring进行自动装配的时候，默认使用首选的bean；
  也可以继续使用@Qualifier指定需要装配的bean的名字

Spring还支持使用@Resource(JSR250)和@Inject(JSR330)[java规范的注解]

• @Autowired:Spring定义的； @Resource、@Inject都是java规范
• @Resource:可以和@Autowired一样实现自动装配功能；默认是按照组件名称进行装配的；没有能支持@Primary功能；没有支持@Autowired（reqiured=false）;
• @Inject:需要导入javax.inject的包，和Autowired的功能一样。没有required=false的功能；
• 源码使用后置处理器实现自动注入的，工作原理看下边源码分析：AutowiredAnnotationBeanPostProcessor:解析完成自动装配功能；

自动注入注意事项

• @Autowired:可以标注在 造器，参数，方法，属性；都是从容器中获取参数组件的值

 *      1）、[标注在方法位置]：@Bean+方法参数；参数从容器中获取;默认不写@Autowired效果是一样的；都能自动装配
 *      2）、[标在构造器上]：如果组件只有一个有参构造器，这个有参构造器的@Autowired可以省略，参数位置的组件还是可以自动从容器中获取
 *      3）、放在参数位置：

• 自定义组件想要使用Spring容器底层的一些组件（ApplicationContext，BeanFactory，xxx）；

 *      自定义组件实现xxxAware；在创建对象的时候，会调用接口规定的方法注入相关组件；Aware；
 *      把Spring底层一些组件注入到自定义的Bean中；
 *      xxxAware：功能使用xxxProcessor；
 *          ApplicationContextAware==》ApplicationContextAwareProcessor；

不同环境注入不同组件@Profile

指定组件在哪个环境的情况下才能被注册到容器中，不指定，任何环境下都能注册这个组件

• 1）、加了环境标识的bean，只有这个环境被激活的时候才能注册到容器中。默认是default环境
• 2）、写在配置类上，只有是指定的环境的时候，整个配置类里面的所有配置才能开始生效
• 3）、没有标注环境标识的bean在，任何环境下都是加载的；
  切换环境的方式

• //1、使用命令行动态参数: 在虚拟机参数位置加载 -Dspring.profiles.active=test
• //2、代码的方式激活某种环境；

AOP面象切面编程

面象切面编程：指在程序运行期间动态的将某段代码切入到指定方法指定位置进行运行的编程方式；底层使用动态代理实现。

AOP：【动态代理】
        指在程序运行期间动态的将某段代码切入到指定方法指定位置进行运行的编程方式；

1、导入aop模块；Spring AOP：(spring-aspects)
2、定义一个业务逻辑类（MathCalculator）；在业务逻辑运行的时候将日志进行打印（方法之前、方法运行结束、方法出现异常，xxx）
3、定义一个日志切面类（LogAspects）：切面类里面的方法需要动态感知MathCalculator.div运行到哪里然后执行；
        通知方法：
            前置通知(@Before)：logStart：在目标方法(div)运行之前运行
            后置通知(@After)：logEnd：在目标方法(div)运行结束之后运行（无论方法正常结束还是异常结束）
            返回通知(@AfterReturning)：logReturn：在目标方法(div)正常返回之后运行
            异常通知(@AfterThrowing)：logException：在目标方法(div)出现异常以后运行
            环绕通知(@Around)：动态代理，手动推进目标方法运行（joinPoint.procced()）
4、给切面类的目标方法标注何时何地运行（通知注解）；
5、将切面类和业务逻辑类（目标方法所在类）都加入到容器中;
6、必须告诉Spring哪个类是切面类(给切面类上加一个注解：@Aspect)
[7]、给配置类中加 @EnableAspectJAutoProxy 【开启基于注解的aop模式】
        在Spring中很多的 @EnableXXX;

AOP总结 三步：

• 1）、将业务逻辑组件和切面类都加入到容器中；告诉Spring哪个是切面类（@Aspect）
• 2）、在切面类上的每一个通知方法上标注通知注解，告诉Spring何时何地运行（切入点表达式）
• 3）、开启基于注解的aop模式；@EnableAspectJAutoProxy

AOP原理

看给容器中注册了什么组件，这个组件什么时候工作，这个组件的功能是什么？

AOP原理：【看给容器中注册了什么组件，这个组件什么时候工作，这个组件的功能是什么？】
        @EnableAspectJAutoProxy；
1、@EnableAspectJAutoProxy是什么？
        @Import(AspectJAutoProxyRegistrar.class)：给容器中导入AspectJAutoProxyRegistrar
            利用AspectJAutoProxyRegistrar自定义给容器中注册bean；BeanDefinetion
            internalAutoProxyCreator=AnnotationAwareAspectJAutoProxyCreator

        给容器中注册一个AnnotationAwareAspectJAutoProxyCreator；

2、 AnnotationAwareAspectJAutoProxyCreator：
        AnnotationAwareAspectJAutoProxyCreator
            ->AspectJAwareAdvisorAutoProxyCreator
                ->AbstractAdvisorAutoProxyCreator
                    ->AbstractAutoProxyCreator
                            implements SmartInstantiationAwareBeanPostProcessor, BeanFactoryAware
                        关注后置处理器（在bean初始化完成前后做事情）、自动装配BeanFactory

AbstractAutoProxyCreator.setBeanFactory()
AbstractAutoProxyCreator.有后置处理器的逻辑；

AbstractAdvisorAutoProxyCreator.setBeanFactory()-》initBeanFactory()

AnnotationAwareAspectJAutoProxyCreator.initBeanFactory()
 *
 *
流程：
        1）、传入配置类，创建ioc容器
        2）、注册配置类，调用refresh（）刷新容器；
        3）、registerBeanPostProcessors(beanFactory);注册bean的后置处理器来方便拦截bean的创建；
            1）、先获取ioc容器已经定义了的需要创建对象的所有BeanPostProcessor
            2）、给容器中加别的BeanPostProcessor
            3）、优先注册实现了PriorityOrdered接口的BeanPostProcessor；
            4）、再给容器中注册实现了Ordered接口的BeanPostProcessor；
            5）、注册没实现优先级接口的BeanPostProcessor；
            6）、注册BeanPostProcessor，实际上就是创建BeanPostProcessor对象，保存在容器中；
                创建internalAutoProxyCreator的BeanPostProcessor【AnnotationAwareAspectJAutoProxyCreator】
                1）、创建Bean的实例
                2）、populateBean；给bean的各种属性赋值
                3）、initializeBean：初始化bean；
                        1）、invokeAwareMethods()：处理Aware接口的方法回调
                        2）、applyBeanPostProcessorsBeforeInitialization()：应用后置处理器的postProcessBeforeInitialization（）
                        3）、invokeInitMethods()；执行自定义的初始化方法
                        4）、applyBeanPostProcessorsAfterInitialization()；执行后置处理器的postProcessAfterInitialization（）；
                4）、BeanPostProcessor(AnnotationAwareAspectJAutoProxyCreator)创建成功；--》aspectJAdvisorsBuilder
            7）、把BeanPostProcessor注册到BeanFactory中；
                beanFactory.addBeanPostProcessor(postProcessor);
=======以上是创建和注册AnnotationAwareAspectJAutoProxyCreator的过程========

            AnnotationAwareAspectJAutoProxyCreator => InstantiationAwareBeanPostProcessor
        4）、finishBeanFactoryInitialization(beanFactory);完成BeanFactory初始化工作；创建剩下的单实例bean
            1）、遍历获取容器中所有的Bean，依次创建对象getBean(beanName);
                getBean->doGetBean()->getSingleton()->
            2）、创建bean
                【AnnotationAwareAspectJAutoProxyCreator在所有bean创建之前会有一个拦截，InstantiationAwareBeanPostProcessor，会调用postProcessBeforeInstantiation()】
                1）、先从缓存中获取当前bean，如果能获取到，说明bean是之前被创建过的，直接使用，否则再创建；
                    只要创建好的Bean都会被缓存起来
                2）、createBean（）;创建bean；
                    AnnotationAwareAspectJAutoProxyCreator 会在任何bean创建之前先尝试返回bean的实例
                    【BeanPostProcessor是在Bean对象创建完成初始化前后调用的】
                    【InstantiationAwareBeanPostProcessor是在创建Bean实例之前先尝试用后置处理器返回对象的】
                    1）、resolveBeforeInstantiation(beanName, mbdToUse);解析BeforeInstantiation
                        希望后置处理器在此能返回一个代理对象；如果能返回代理对象就使用，如果不能就继续
                        1）、后置处理器先尝试返回对象；
                            bean = applyBeanPostProcessorsBeforeInstantiation（）：
                                拿到所有后置处理器，如果是InstantiationAwareBeanPostProcessor;
                                就执行postProcessBeforeInstantiation
                            if (bean != null) {
                                bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
                            }

                    2）、doCreateBean(beanName, mbdToUse, args);真正的去创建一个bean实例；和3.6流程一样；
                    3）、
            
        
AnnotationAwareAspectJAutoProxyCreator【InstantiationAwareBeanPostProcessor】 的作用：
1）、每一个bean创建之前，调用postProcessBeforeInstantiation()；
        关心MathCalculator和LogAspect的创建
        1）、判断当前bean是否在advisedBeans中（保存了所有需要增强bean）
        2）、判断当前bean是否是基础类型的Advice、Pointcut、Advisor、AopInfrastructureBean，
            或者是否是切面（@Aspect）
        3）、是否需要跳过
            1）、获取候选的增强器（切面里面的通知方法）【List candidateAdvisors】
                每一个封装的通知方法的增强器是 InstantiationModelAwarePointcutAdvisor；
                判断每一个增强器是否是 AspectJPointcutAdvisor 类型的；返回true
            2）、永远返回false

2）、创建对象
postProcessAfterInitialization；
        return wrapIfNecessary(bean, beanName, cacheKey);//包装如果需要的情况下
        1）、获取当前bean的所有增强器（通知方法）  Object[]  specificInterceptors
            1、找到候选的所有的增强器（找哪些通知方法是需要切入当前bean方法的）
            2、获取到能在bean使用的增强器。
            3、给增强器排序
        2）、保存当前bean在advisedBeans中；
        3）、如果当前bean需要增强，创建当前bean的代理对象；
            1）、获取所有增强器（通知方法）
            2）、保存到proxyFactory
            3）、创建代理对象：Spring自动决定
                JdkDynamicAopProxy(config);jdk动态代理；
                ObjenesisCglibAopProxy(config);cglib的动态代理；
        4）、给容器中返回当前组件使用cglib增强了的代理对象；
        5）、以后容器中获取到的就是这个组件的代理对象，执行目标方法的时候，代理对象就会执行通知方法的流程；
        
    
    3）、目标方法执行   ；
        容器中保存了组件的代理对象（cglib增强后的对象），这个对象里面保存了详细信息（比如增强器，目标对象，xxx）；
        1）、CglibAopProxy.intercept();拦截目标方法的执行
        2）、根据ProxyFactory对象获取将要执行的目标方法拦截器链；
            List