Spring循环依赖的解决办法,你真的懂了吗

@Component
public class ConstructorA {

 private ConstructorB constructorB;

 @Autowired
 public ConstructorA(ConstructorB constructorB) {
 this.cOnstructorB= constructorB;
 }
}

@Component
public class ConstructorB {

 private ConstructorA constructorA;

 @Autowired
 public ConstructorB(ConstructorA constructorA) {
 this.cOnstructorA= constructorA;
 }
}

@Configuration
@ComponentScan("com.javashitang.dependency.constructor")
public class ConstructorConfig {
}
public class ConstructorMain {

 public static void main(String[] args) {
 AnnotationConfigApplicationContext cOntext=
 new AnnotationConfigApplicationContext(ConstructorConfig.class);
 System.out.println(context.getBean(ConstructorA.class));
 System.out.println(context.getBean(ConstructorB.class));
 }
}

@Autowired
public ConstructorB(@Lazy ConstructorA constructorA) {
	this.cOnstructorA= constructorA;
}

@Component
public class FieldA {

 @Autowired
 private FieldB fieldB;
}

@Component
public class FieldB {

 @Autowired
 private FieldA fieldA;
}

@Configuration
@ComponentScan("com.javashitang.dependency.field")
public class FieldConfig {
}

public class FieldMain {

 public static void main(String[] args) {
 AnnotationConfigApplicationContext cOntext=
 new AnnotationConfigApplicationContext(FieldConfig.class);
 // com.javashitang.dependency.field.FieldA@3aa9e816
 System.out.println(context.getBean(FieldA.class));
 // com.javashitang.dependency.field.FieldB@17d99928
 System.out.println(context.getBean(FieldB.class));
 }
}

public interface ObjectFactory {
 T getObject();
}

public class DependencyDemo {

 // 初始化完毕的Bean
 private final Map singletOnObjects=
 new ConcurrentHashMap<>(256);

 // 正在初始化的Bean对应的工厂，此时对象已经被实例化
 private final Map> singletOnFactories=
 new HashMap<>(16);

 // 存放正在初始化的Bean，对象还没有被实例化之前就放进来了
 private final Set singletOnsCurrentlyInCreation=
 Collections.newSetFromMap(new ConcurrentHashMap<>(16));

 public  T getBean(Class beanClass) throws Exception {
 // 类名为Bean的名字
 String beanName = beanClass.getSimpleName();
 // 已经初始化好了，或者正在初始化
 Object initObj = getSingleton(beanName, true);
 if (initObj != null) {
 return (T) initObj;
 }
 // bean正在被初始化
 singletonsCurrentlyInCreation.add(beanName);
 // 实例化bean
 Object object = beanClass.getDeclaredConstructor().newInstance();
 singletonFactories.put(beanName, () -> {
 return object;
 });
 // 开始初始化bean，即填充属性
 Field[] fields = object.getClass().getDeclaredFields();
 for (Field field : fields) {
 field.setAccessible(true);
 // 获取需要注入字段的class
 Class<&＃63;> fieldClass = field.getType();
 field.set(object, getBean(fieldClass));
 }
 // 初始化完毕
 singletonObjects.put(beanName, object);
 singletonsCurrentlyInCreation.remove(beanName);
 return (T) object;
 }

 /**
 * allowEarlyReference参数的含义是Spring是否允许循环依赖，默认为true
 * 所以当allowEarlyReference设置为false的时候，当项目存在循环依赖，会启动失败
 */
 public Object getSingleton(String beanName, boolean allowEarlyReference) {
 Object singletOnObject= this.singletonObjects.get(beanName);
 if (singletOnObject== null 
 && isSingletonCurrentlyInCreation(beanName)) {
 synchronized (this.singletonObjects) {
 if (singletOnObject== null && allowEarlyReference) {
  ObjectFactory<&＃63;> singletOnFactory=
  this.singletonFactories.get(beanName);
  if (singletonFactory != null) {
  singletOnObject= singletonFactory.getObject();
  }
 }
 }
 }
 return singletonObject;
 }

 /**
 * 判断bean是否正在被初始化
 */
 public boolean isSingletonCurrentlyInCreation(String beanName) {
 return this.singletonsCurrentlyInCreation.contains(beanName);
 }

}

public static void main(String[] args) throws Exception {
	DependencyDemo dependencyDemo = new DependencyDemo();
	// 假装扫描出来的对象
	Class[] classes = {A.class, B.class};
	// 假装项目初始化所有bean
	for (Class aClass : classes) {
		dependencyDemo.getBean(aClass);
	}
	// true
	System.out.println(
			dependencyDemo.getBean(B.class).getA() == dependencyDemo.getBean(A.class));
	// true
	System.out.println(
			dependencyDemo.getBean(A.class).getB() == dependencyDemo.getBean(B.class));
}

public class DependencyDemo {

	// 初始化完毕的Bean
	private final Map singletOnObjects=
			new ConcurrentHashMap<>(256);

	// 正在初始化的Bean对应的工厂，此时对象已经被实例化
	private final Map> singletOnFactories=
			new HashMap<>(16);

	// 缓存Bean对应的工厂生产好的Bean
	private final Map earlySingletOnObjects=
			new HashMap<>(16);

	// 存放正在初始化的Bean，对象还没有被实例化之前就放进来了
	private final Set singletOnsCurrentlyInCreation=
			Collections.newSetFromMap(new ConcurrentHashMap<>(16));

	public  T getBean(Class beanClass) throws Exception {
		// 类名为Bean的名字
		String beanName = beanClass.getSimpleName();
		// 已经初始化好了，或者正在初始化
		Object initObj = getSingleton(beanName, true);
		if (initObj != null) {
			return (T) initObj;
		}
		// bean正在被初始化
		singletonsCurrentlyInCreation.add(beanName);
		// 实例化bean
		Object object = beanClass.getDeclaredConstructor().newInstance();
		singletonFactories.put(beanName, () -> {
			return object;
		});
		// 开始初始化bean，即填充属性
		Field[] fields = object.getClass().getDeclaredFields();
		for (Field field : fields) {
			field.setAccessible(true);
			// 获取需要注入字段的class
			Class<&＃63;> fieldClass = field.getType();
			field.set(object, getBean(fieldClass));
		}
		singletonObjects.put(beanName, object);
		singletonsCurrentlyInCreation.remove(beanName);
		earlySingletonObjects.remove(beanName);
		return (T) object;
	}

	/**
	 * allowEarlyReference参数的含义是Spring是否允许循环依赖，默认为true
	 */
	public Object getSingleton(String beanName, boolean allowEarlyReference) {
		Object singletOnObject= this.singletonObjects.get(beanName);
		if (singletOnObject== null
				&& isSingletonCurrentlyInCreation(beanName)) {
			synchronized (this.singletonObjects) {
				singletOnObject= this.earlySingletonObjects.get(beanName);
				if (singletOnObject== null && allowEarlyReference) {
					ObjectFactory<&＃63;> singletOnFactory=
							this.singletonFactories.get(beanName);
					if (singletonFactory != null) {
						singletOnObject= singletonFactory.getObject();
						this.earlySingletonObjects.put(beanName, singletonObject);
						this.singletonFactories.remove(beanName);
					}
				}
			}
		}
		return singletonObject;
	}
}