循环依赖的解决

刺骨的言语ヽ痛彻心扉 2022-12-30 01:20 149阅读 0赞

## 是什么 ##

循环依赖，也就是两个或者两个以上的bean互相持有对方，最终形成闭环。  
比如A依赖于B，B依赖于C，C又依赖于A。如下图：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dzZGZ5bQ_size_16_color_FFFFFF_t_70]

## 代码中的体现 ##

@Component
    public class A { 
        // A中注入了B
        @Autowired
        private B b;
    }
    
    @Component
    public class B { 
        // B中也注入了A
        @Autowired
        private A a;
    }

## 解决循环依赖的本质 ##

**先去缓存Map里找Bean，没有则实例化当前的Bean放到Map，如果有需要依赖当前Bean的，就能从Map取到。**  
可以这么理解，当调用A的构造函数后，放入缓存Map中，在要注入属性B时。就去创建属性B，发现要注入属性A，从缓存中已经可以获取到创建好的A（虽然只是调用了构造函数，暴露了A的引用）。B创建好后返回创建A。这个时候循环依赖就解决了。

## 代码体现 ##

public class Main { 
        private static Map<String, Object> cacheMap = new HashMap<>(4);
    
        public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException { 
            // 假装扫描出来的对象
            Class[] classes = { A.class, B.class};
            // 假装项目初始化实例化所有bean
            for (Class aClass : classes) { 
                getBean(aClass);
            }
            // check
            System.out.println(getBean(B.class).getA() == getBean(A.class));
            System.out.println(getBean(A.class).getB() == getBean(B.class));
            //在调用链可以是main->A->B
            //不可以是main->A->B->A->....比如直接输出B
            System.out.println(getBean(A.class).helllo());
        }
    
        private static <T> T getBean(Class<T> beanClass) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException { 
            // 本文用类名小写 简单代替bean的命名规则
            String beanName = beanClass.getSimpleName().toLowerCase();
            // 如果已经是一个bean，则直接返回
            if (cacheMap.containsKey(beanName)) { 
                return (T) cacheMap.get(beanName);
            }
            // 将对象本身实例化
            Object object = beanClass.getDeclaredConstructor().newInstance();
            // 放入缓存
            cacheMap.put(beanName, object);
            // 把所有字段当成需要注入的bean，创建并注入到当前bean中
            Field[] fields = object.getClass().getDeclaredFields();
            for (Field field : fields) { 
                field.setAccessible(true);
                // 获取需要注入字段的class
                Class<?> fieldClass = field.getType();
                String fieldBeanName = fieldClass.getSimpleName().toLowerCase();
                // 如果需要注入的bean，已经在缓存Map中，那么把缓存Map中的值注入到该field即可
                // 如果缓存没有 继续创建
                if (cacheMap.containsKey(fieldBeanName)){ 
                    field.set(object,cacheMap.get(fieldBeanName));
                }else { 
                    field.set(object,getBean(fieldClass));
                }
            }
            // 属性填充完成，返回
            return (T) object;
        }
    }
    /** * @author shunda wu * @date 2020/8/10 **/
    public class A { 
        private B b;
        public A() { 
        }
        public B getB() { 
            return b;
        }
        public void setB(B b) { 
            this.b = b;
        }
        public String helllo(){ 
            return b.helllo();
        }
        @Override
        public String toString() { 
            return "A{" +
                    "b=" + b +
                    '}';
        }
    }
    /** * @author shunda wu * @date 2020/8/10 **/
    public class B { 
        private A a;
        public B() { 
        }
        public A getA() { 
            return a;
        }
        public void setA(A a) { 
            this.a = a;
        }
        public String helllo(){ 
            return "hello";
        }
        @Override
        public String toString() { 
            return "B{" +
                    "a=" + a +
                    '}';
        }
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dzZGZ5bQ_size_16_color_FFFFFF_t_70]: /images/20221120/bb580df1897248bc956a78abd1fa98e8.png