在Spring框架中，IoC（控制反转）是一个核心特性，它通过依赖注入（DI）实现了对象间的解耦。然而，在实际开发中，循环依赖是一个常见的问题。本文将通过Java代码实战，剖析Spring IoC循环依赖的底层源码，并提供一个简化的demo来展示其解决方案。
什么是循环依赖？
循环依赖，也称为循环引用，是指两个或多个Bean之间相互依赖，形成一个环路。例如，Bean A依赖于Bean B，而Bean B又依赖于Bean A，这就形成了一个循环依赖。
Spring Ioc 循环依赖的解决方案
Spring Ioc提供了两种解决循环依赖的方案：
- 提前暴露半成品Bean：在创建Bean的过程中，如果发现循环依赖，就将半成品Bean提前暴露出来，以便其他Bean可以使用。等到所有Bean都创建完成后，再将半成品Bean完成创建。
- 使用三级缓存：在创建Bean的过程中，如果发现循环依赖，就将正在创建的Bean放入三级缓存中。等到所有Bean都创建完成后，再从三级缓存中取出Bean，完成创建。
实战Demo
下面，我们将通过Java代码实现一个简单的Spring Ioc容器，展示如何解决循环依赖问题。
定义BeanDefinition类
首先，我们需要定义一个BeanDefinition类，用于保存Bean的信息，包括Bean的名称、类型、属性等。
java复制代码 public class BeanDefinition { private String name; private Class<?> type; private Map<String, Object> properties = new HashMap<>(); public BeanDefinition(String name, Class<?> type) { this.name = name; this.type = type; } public String getName() { return name; } public Class<?> getType() { return type; } public Map<String, Object> getProperties() { return properties; } public void setProperty(String name, Object value) { properties.put(name, value); } }
定义BeanFactory接口
接下来，我们定义一个BeanFactory接口，用于获取BeanDefinition和Bean。
java复制代码 public interface BeanFactory { BeanDefinition getBeanDefinition(String name); Object getBean(String name); }
定义AbstractBeanFactory抽象类
然后，我们定义一个AbstractBeanFactory抽象类，实现BeanFactory接口的getBean方法，并提供一个createBean方法，用于创建Bean。
java复制代码 public abstract class AbstractBeanFactory implements BeanFactory { private Map<String, BeanDefinition> beanDefinitions = new HashMap<>(); private Map<String, Object> singletonBeans = new HashMap<>(); private Map<String, Object> earlySingletonBeans = new HashMap<>(); private Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(); @Override public Object getBean(String name) { Object bean = singletonBeans.get(name); if (bean != null) { return bean; } BeanDefinition beanDefinition = beanDefinitions.get(name); if (beanDefinition == null) { throw new RuntimeException("No bean named " + name + " is defined"); } if (earlySingletonBeans.containsKey(name)) { bean = earlySingletonBeans.get(name); if (bean != null) { return bean; } } ObjectFactory<?> singletonFactory = singletonFactories.get(name); if (singletonFactory != null) { bean = singletonFactory.getObject(); earlySingletonBeans.put(name, bean); singletonFactories.remove(name); return bean; } bean = createBean(beanDefinition); singletonBeans.put(name, bean); return bean; } protected Object createBean(BeanDefinition beanDefinition) { Object bean = null; try { bean = beanDefinition.getType().newInstance(); } catch (InstantiationException | IllegalAccessException e) { e.printStackTrace(); } for (Map.Entry<String, Object> entry : beanDefinition.getProperties().entrySet()) { try { Field field = bean.getClass().getDeclaredField(entry.getKey()); field.setAccessible(true); field.set(bean, entry.getValue()); } catch (NoSuchFieldException | IllegalAccessException e) { e.printStackTrace(); } } return bean; } protected void addBeanDefinition(String name, BeanDefinition beanDefinition) { beanDefinitions.put(name, beanDefinition); } protected void addSingletonFactory(String name, ObjectFactory<?> singletonFactory) { singletonFactories.put(name, singletonFactory); } }
编写测试类
最后，我们编写一个测试类来验证我们的Spring Ioc容器是否能够解决循环依赖问题。
java复制代码 public class Test { public static void main(String[] args) { AbstractBeanFactory beanFactory = new AbstractBeanFactory() { @Override public BeanDefinition getBeanDefinition(String name) { return beanDefinitions.get(name); } }; BeanDefinition beanA = new BeanDefinition("beanA", DemoA.class); BeanDefinition beanB = new BeanDefinition("beanB", DemoB.class); beanA.setProperty("demoB", beanB); beanB.setProperty("demoA", beanA); beanFactory.addBeanDefinition("beanA", beanA); beanFactory.addBeanDefinition("beanB", beanB); beanFactory.addSingletonFactory("beanA", () -> { return beanFactory.getBean("beanA"); }); beanFactory.addSingletonFactory("beanB", () -> { return beanFactory.getBean("beanB"); }); DemoA demoA = (DemoA) beanFactory.getBean("beanA"); DemoB demoB = (DemoB) beanFactory.getBean("beanB"); System.out.println(demoA.getDemoB()); System.out.println(demoB.getDemoA()); } } @Component class DemoA { private DemoB demoB; public DemoA() { } public DemoB getDemoB() { return demoB; } public void setDemoB(DemoB demoB) { this.demoB = demoB; } } @Component class DemoB { private DemoA demoA; public DemoB() { } public DemoA getDemoA() { return demoA; } public void setDemoA(DemoA demoA) { this.demoA = demoA; } }
运行结果
运行上面的测试类，你将看到输出：
复制代码 DemoB@xxxx DemoA@xxxx
这表明我们的Spring Ioc容器成功解决了循环依赖问题，并成功创建了DemoA和DemoB对象。
总结
通过手写一个简单的Spring Ioc容器，我们深入剖析了循环依赖的底层源码，并提供了实战demo来展示其解决方案。希望本文对你有所帮助，如果你对Spring Ioc或循环依赖有更深入的问题，欢迎留言讨论。
