Spring5学习08:循环依赖

梦里梦外; 2022-10-21 11:54 186阅读 0赞

## 1.AOP执行顺序(s4和s5的区别,boot1(s4)和boot2(s5)的区别)IOC,AOP,tx(事务) ##

### 1 AOP ###

#### 1.常用注解 ####

![image][]

//增强的类
    @Component
    @Aspect  //生成代理对象
    @Order(2)
    public class UserProxy {
    
        //相同切入点抽取
        @Pointcut(value = "execution(* cn.zj.aop.an.User.add(..))")
        public void pointdemo() {
          System.out.println("相同切入点point");
        }
    
        //前置通知
        //@Before(value = "execution(* cn.zj.aop.an.User.add(..))")
        @Before(value = "pointdemo()")
        public void before() {
            System.out.println("前置通知before.........");
        }
    
        //返回通知
        @AfterReturning(value = "execution(* cn.zj.aop.an.User.add(..))")
        public void afterReturning() {
            System.out.println("返回通知afterReturning.........");
        }
    
        //后置通知
        @After(value = "execution(* cn.zj.aop.an.User.add(..))")
        public void after() {
            System.out.println("后置after.........");
        }
    
        //异常通知
        @AfterThrowing(value = "execution(* cn.zj.aop.an.User.add(..))")
        public void afterThrowing() {
            System.out.println("异常通知afterThrowing.........");
        }
    
        //环绕通知
        @Around(value = "execution(* cn.zj.aop.an.User.add(..))")
        public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
            System.out.println("环绕之前.........");
    
            //被增强的方法执行
            proceedingJoinPoint.proceed();
    
            System.out.println("环绕之后.........");
        }
    }

#### 2.AOP通知顺序: ####

先看Order,Order值小的先运行,现在讲的同一个Order中

正常情况:

spring5

环绕之前…

前置通知before…

执行方法add…

返回后通知afterReturning…

后置通知after…

环绕之后…

spring4

环绕之前…

前置通知before…

执行方法add…

环绕之后…

后置通知after…

返回通知afterReturning…

s5和s4,执行目标方法后的通知顺序颠倒,:

s4是环绕后–after—afterReturning

s5是afterReturning–after–环绕后

异常情况:

spring5

环绕之前…

前置通知before…

异常通知afterThrowing…

后置通知after…

spring4

环绕之前…

前置通知before…

后置通知after…

异常通知afterThrowing…

s5和s4,执行目标方法后的通知顺序颠倒,:

s4是after—afterThrowing

s5是afterThrowing–after

### 2.spring的循环依赖 ###

#### 1.什么是循环依赖 ####

多个bean之间相互依赖，形成了一个闭环。

一般默认在单例模式中，属性相互影响的场景。

#### 2.依赖注入 ####

1.构造方法注入【不适合解决循环依赖】

2.set方法注入,并且是单例,spring底层解决循环依赖

#### 3.代码演示 ####

1.构造

@Component
    public class ServiceA {
    
        private ServiceB serviceB;
    
        public ServiceA(ServiceB serviceB) {
            super();
            this.serviceB = serviceB;
        }
    
        
    }
    
    @Component
    public class ServiceB {
    
        private ServiceA serviceA;
    
        public ServiceB(ServiceA serviceA) {
            super();
            this.serviceA = serviceA;
        }
    
    }
    
    测试结果报错

2.set注入单例

public class ServiceA2 {
    
        @Autowired
        private ServiceB2 serviceB2;
    
        public ServiceB2 getServiceB2() {
            return serviceB2;
        }
    
        public void setServiceB2(ServiceB2 serviceB2) {
            this.serviceB2 = serviceB2;
            System.out.println("A2注入B2");
        }
    
    }
    
    
    public class ServiceB2 {
    
        private ServiceA2 serviceA2;
    
        public ServiceA2 getServiceA2() {
            return serviceA2;
        }
    
        public void setServiceA2(ServiceA2 serviceA2) {
            this.serviceA2 = serviceA2;
            System.out.println("B2注入A2");
        }
    
    
    }
    
    
    @Test
        public void test2() {
            ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
            ServiceA2 serviceA2 = context.getBean("serviceA2", ServiceA2.class);
            ServiceB2 serviceB2 = context.getBean("serviceB2", ServiceB2.class);
            System.out.println(serviceA2);
            System.out.println(serviceB2);
        }
        <bean id="serviceA2" class="cn.zj.service.ServiceA2"> 
        <property name="serviceB2" ref="serviceB2"></property>
        </bean>
        <bean id="serviceB2" class="cn.zj.service.ServiceB2"> 
        <property name="serviceA2" ref="serviceA2"></property>
        </bean>

结果打印

A2注入B2
    B2注入A2
    cn.zj.service.ServiceA2@4b8d604b
    cn.zj.service.ServiceB2@5e7cd6cc

如果配置了Scope=“prototype”,测试报错

**spring内部通过三级缓存来解决循环依赖**

\*\*  
\*\*

#### 4.三级缓存 DefaultSingleBeanRegistry ####

用来解决循环依赖的三个map

/** Cache of singleton objects: bean name to bean instance. */
        //一级缓存
        private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);
    
        //三级缓存 
        /** Cache of singleton factories: bean name to ObjectFactory. */
        private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);
    
        //二级缓存
        /** Cache of early singleton objects: bean name to bean instance. */
        private final Map<String, Object> earlySingletonObjects = new ConcurrentHashMap<>(16);

一级缓存singletonObjects(单例池):存放已经经历完整生命周期的Bean对象,已经初始化了的bean

二级缓存earlySingletonObjects:存放早起暴露出来的Bean对象,Bean的生命周期未结束(属性还未填充完成),实例化未初始化的bean

三级缓存singletonFactories:存放可以生成Bean的工厂 FactoryBean,假如A类实现了FactoryBean,那么依赖注入时不时A类,而是A类产生的Bean

只有单例的bean会通过三级缓存提前暴露来解决循环依赖的问题,而非单例的bean,每次从容器中获取都是一个新的对象,所以非单例的bean是没有缓存的,不会将其放到三级缓存中.

#### 5.源码相关基础知识: ####

\*\*\*实例化\*\*\**:内存中申请一块内存空间,类似于网上租了个空房,还未搬东西进去*

\*\*\*初始化\*\*\**:属性填充,完成各属性的赋值,类似于将自己的东西搬入租房*

***三个map***\*:三个缓存,singletonObjects,earlySingletonObjects,singletonFactories\*

***四大方法***\*:getSingleton,doCreateBean,populateBean,addSingleton\*

> getSingleton()：从容器里面获得单例的bean，没有的话则会创建 bean
> 
> doCreateBean()：执行创建 bean 的操作（在 Spring 中以 do 开头的方法都是干实事的方法）
> 
> populateBean()：创建完 bean 之后，对 bean 的属性进行填充
> 
> addSingleton()：bean 初始化完成之后，添加到单例容器池中，下次执行 getSingleton() 方法时就能获取到

\*![image][image 1]

*  
 *

*过程:*

*1.A创建过程中需要B,于是A将自己放到三级缓存,去实例化B*

*2.B实例化的时候发现需要A,于是B先查一级缓存,无,再查二级缓存,无,最后查三级缓存,找到A,将三级缓存中的A放到二级缓存中,并删除三级缓存中的*A

3.B顺利初始化完毕,将自己放到一级缓存,此时B中的A依然是创建状态.然后再回来接着创建A,此时B已经创建结束,直接从一级缓存中找到B,完后完成A的创建且存放到一级缓存中

#### 6.源码debug ####

##### 1.打断点 new ClassPathXmlApplicationContext(“bean1.xml”); #####

![image.png][]

##### 2.refresh方法,加载容器初始化的方法 #####

![image.png][image.png 1]

##### 3.finishBeanFactoryInitialization(beanFactory);方法 #####

![image.png][image.png 2]

##### 4.beanFactory.preInstantiateSingletons(); #####

![image.png][image.png 3]

##### 5.getBean(beanName);进去是doGetBean #####

![image.png][image.png 4]

##### 6.getSingleton(beanName),从容器中拿bean #####

![image.png][image.png 5]

##### 7.DefaultSingletonBeanRegistry.singletonObjects.get(beanName),从一级缓存拿bean,首次获取bean,一级缓存中没有 #####

![image.png][image.png 6]

##### 8.getSingleton #####

![image.png][image.png 7]

##### 9.singletonFactory.getObject(); #####

![image.png][image.png 8]

##### 10. return createBean(beanName, mbd, args); #####

![image.png][image.png 9]

######  ######

##### 11.doCreateBean(beanName, mbdToUse, args) #####

![image.png][image.png 10]

##### 12.createBeanInstance(beanName, mbd, args);创建bean的实例,里面是利用反射 #####

![image.png][image.png 11]

##### 13.addSingletonFactory #####

![image.png][image.png 12]

protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {
            Assert.notNull(singletonFactory, "Singleton factory must not be null");
            synchronized (this.singletonObjects) {
                if (!this.singletonObjects.containsKey(beanName)) {//一级缓存中没有
                    this.singletonFactories.put(beanName, singletonFactory);//放到三级缓存中,什么都没有先从三级缓存中造,三级缓存工厂
                    this.earlySingletonObjects.remove(beanName);//删除二级缓存中的
                    this.registeredSingletons.add(beanName);//注册bean
                }
            }
        }

##### 此时的A已在三级缓存中,k:a,v:lambda #####

##### 14.populateBean(beanName, mbd, instanceWrapper);属性填充 #####

![image.png][image.png 13]

##### 15.applyPropertyValues(beanName, mbd, bw, pvs); #####

![image.png][image.png 14]

##### 16.valueResolver.resolveValueIfNecessary(pv, originalValue);开始寻找B #####

![image.png][image.png 15]

##### 17.resolveReference(argName, ref); #####

![image.png][image.png 16]

##### 18.this.beanFactory.getBean(resolvedName);从容器中找B #####

![image.png][image.png 17]

##### 19.重复getBean,createBean,完成B的实例化,并放到三级缓存中,k:b,v:lambda #####

![image.png][image.png 18]

##### 20.对B的属性填充 #####

![image.png][image.png 19]

##### 21.为B填充A #####

![image.png][image.png 20]

![image.png][image.png 21]

![image.png][image.png 22]

protected Object getSingleton(String beanName, boolean allowEarlyReference) {
            // Quick check for existing instance without full singleton lock
            Object singletonObject = this.singletonObjects.get(beanName);//先查一级缓存,看看有没有A
            if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
                singletonObject = this.earlySingletonObjects.get(beanName);//一级缓存没有,再查二级缓存,
                if (singletonObject == null && allowEarlyReference) {
                    synchronized (this.singletonObjects) {
                        // Consistent creation of early reference within full singleton lock
                        singletonObject = this.singletonObjects.get(beanName);
                        if (singletonObject == null) {
                            singletonObject = this.earlySingletonObjects.get(beanName);
                            if (singletonObject == null) {
                                ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);//一级二级都没有后,最后去三级寻找
                                if (singletonFactory != null) {
                                    singletonObject = singletonFactory.getObject();//从三级缓存中拿出A对象
                                    this.earlySingletonObjects.put(beanName, singletonObject);//将A放到二级缓存中
                                    this.singletonFactories.remove(beanName);//将A从三级缓存删除
                                }
                            }
                        }
                    }
                }
            }
            return singletonObject;
        }

##### 22.对B初始化 #####

![image.png][image.png 23]

protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
            if (System.getSecurityManager() != null) {
                AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
                    invokeAwareMethods(beanName, bean);
                    return null;
                }, getAccessControlContext());
            }
            else {
                invokeAwareMethods(beanName, bean);
            }
    
            Object wrappedBean = bean;
            if (mbd == null || !mbd.isSynthetic()) {
                wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);//后置器before方法
            }
    
            try {
                invokeInitMethods(beanName, wrappedBean, mbd);//初始化
            }
            catch (Throwable ex) {
                throw new BeanCreationException(
                        (mbd != null ? mbd.getResourceDescription() : null),
                        beanName, "Invocation of init method failed", ex);
            }
            if (mbd == null || !mbd.isSynthetic()) {
                wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);//后置器after方法
            }
    
            return wrappedBean;
        }

##### 23. 去一二级缓存找B,没有 #####

![image.png][image.png 24]

##### 24.新创建的B加到容器中,将B加到一级缓存中,b从三级缓存直接到一级缓存,B的创建完全完成 #####

![image.png][image.png 25]

protected void addSingleton(String beanName, Object singletonObject) {
            synchronized (this.singletonObjects) {
                this.singletonObjects.put(beanName, singletonObject);//加到一级缓存
                this.singletonFactories.remove(beanName);//从三级缓存中删除
                this.earlySingletonObjects.remove(beanName);//二级缓存删除
                this.registeredSingletons.add(beanName);//注册
            }
        }

25.B完成后,开始继续完成A的初始化,最后去找A,allowEarlyReference==false,不去三级缓存找,只去一二级缓存找,最后在二级缓存中找到A,

最后创造出A后,将A添加到一级缓存中,并从二级缓存中删除

protected Object getSingleton(String beanName, boolean allowEarlyReference) {
            // Quick check for existing instance without full singleton lock
            Object singletonObject = this.singletonObjects.get(beanName);
            if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
                singletonObject = this.earlySingletonObjects.get(beanName);
                if (singletonObject == null && allowEarlyReference) {
                    synchronized (this.singletonObjects) {
                        // Consistent creation of early reference within full singleton lock
                        singletonObject = this.singletonObjects.get(beanName);
                        if (singletonObject == null) {
                            singletonObject = this.earlySingletonObjects.get(beanName);
                            if (singletonObject == null) {
                                ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
                                if (singletonFactory != null) {
                                    singletonObject = singletonFactory.getObject();
                                    this.earlySingletonObjects.put(beanName, singletonObject);
                                    this.singletonFactories.remove(beanName);
                                }
                            }
                        }
                    }
                }
            }
            return singletonObject;
        }

![image][image 2]

#### 7.总结 ####

1.  调用doGetBean()方法，想要获取beanA，于是调用getSingleton()方法从缓存中查找beanA
2.  在getSingleton()方法中，从一级缓存中查找，没有，返回null
3.  doGetBean()方法中获取到的beanA为null，于是走对应的处理逻辑，调用getSingleton()的重载方法（参数为ObjectFactory的)
4.  在getSingleton()方法中，先将beanA\_name添加到一个集合中，用于标记该bean正在创建中。然后回调匿名内部类的creatBean()方法
5.  进入AbstractAutowireCapableBeanFactory\#doCreateBean()，先反射调用构造器创建出beanA的实例，然后判断。是否为单例、是否允许提前暴露引用(对于单例一般为true)、是否正在创建中〈即是否在第四步的集合中)。判断为true则将beanA添加到【三级缓存】中
6.  对beanA进行属性填充，此时检测到beanA依赖于beanB，于是开始查找beanB
7.  调用doGetBean()方法，和上面beanA的过程一样，到缓存中查找beanB，没有则创建，然后给beanB填充属性
8.  此时beanB依赖于beanA，调用getsingleton()获取beanA，依次从一级、二级、三级缓存中找，此时从三级缓存中获取到beanA的创建工厂，通过创建工厂获取到singletonObject，此时这个singletonObject指向的就是上面在doCreateBean()方法中实例化的beanA
9.  这样beanB就获取到了beanA的依赖，于是beanB顺利完成实例化，并将beanA从三级缓存移动到二级缓存中
10. 随后beanA继续他的属性填充工作，此时也获取到了beanB，beanA也随之完成了创建，回到getsingleton()方法中继续向下执行，将beanA从二级缓存移动到一级缓存中

#### 8.扩展:为什么一定要使用三级缓存,一级缓存,二级缓存不行吗? ####

##### 1.只使用一级缓存 #####

> 创建A,初始化A需要注入B,容器中没有B,
> 
> 创建B,初始化B,需要注入A,容器中没有A,容器中没有A
> 
> 创建A,初始化A,需要注入B…

死循环,无法解决循环依赖

##### 2.两级级缓存 #####

> 创建A,将A放入二级缓存,初始化A,注入B,容器中没有B
> 
> 创建B,B放入二级缓存,初始化B,注入A,二级缓存有A,取出注入,初始化B,B放入一级缓存
> 
> 继续A的初始化,注入B,A初始化完成,放入一级缓存

可以解决循环依赖,解决不了AOP的循环依赖

[image]: /images/20221021/45bc2b93b706403f98eaf34702822cb1.png
[image 1]: /images/20221021/c0cec4ebe9cc4aee941dcfe5e3b332a1.png
[image.png]: /images/20221021/7ad10d258a4644088e143ced4daf3499.png
[image.png 1]: /images/20221021/71a7a2cca3d74dae864f8230673c1d25.png
[image.png 2]: /images/20221021/16e7fe6f51bf44678941b99b317249e5.png
[image.png 3]: /images/20221021/fd2e08a8c535471183cff10817d3f30e.png
[image.png 4]: /images/20221021/fed67e397818468493ba9c5a3d58864b.png
[image.png 5]: /images/20221021/56175338792b4f82913a064eeea5aa27.png
[image.png 6]: /images/20221021/3c905de19c074eb3923874d644519bac.png
[image.png 7]: /images/20221021/f014847fc27f4ad88bcb0fbf4ced2f1f.png
[image.png 8]: /images/20221021/fdf225da55bf451e9efd225e9e173000.png
[image.png 9]: /images/20221021/8ba1d8223c244b69bf02f2f14ad83c17.png
[image.png 10]: /images/20221021/cc13e26ae9d84d28b068ba990fc9250d.png
[image.png 11]: /images/20221021/0f0885fc418f4efcb9bec945f691af0b.png
[image.png 12]: /images/20221021/405e073dffca448989e5b067010443e5.png
[image.png 13]: /images/20221021/7ed33e0d2f1e474bb62dbe0e6d9888ea.png
[image.png 14]: /images/20221021/1b100ec427d34b0eab195038eb1ab110.png
[image.png 15]: /images/20221021/61cfa6d3530543f3aec134c88c8a88e7.png
[image.png 16]: /images/20221021/9df22e3bd621449ba77e226294847156.png
[image.png 17]: /images/20221021/70456c067f464891bdee4d3e991f6727.png
[image.png 18]: /images/20221021/7cbd458557774162bd1ade4b730e6354.png
[image.png 19]: /images/20221021/d49bb57d552d4a6d8fa8a5f801478327.png
[image.png 20]: /images/20221021/43a4f1881a6c4d059b1ff1132f48c6aa.png
[image.png 21]: /images/20221021/882942d9a6f34320b03f9141e51389bb.png
[image.png 22]: /images/20221021/a2cd5d94c064464ba712f37836bce670.png
[image.png 23]: /images/20221021/e5b5a5501c3e4660811ea9d4231758ca.png
[image.png 24]: /images/20221021/332458d20501464fbc153051fd2cc14e.png
[image.png 25]: /images/20221021/8d9fd64e1112428ebe06cc6ce62bbd08.png
[image 2]: /images/20221021/1168721c0a2849a582f63f152b262b05.png