spring循环依赖和设计模式
# 1 循环依赖循环依赖就是 在 A中引用了B，在B中引用了C，在C中引用了A。
导致无限循环的一个场景。 循环依赖通常是有`糟糕的编程`引起的。
循环依赖会导致`内存的溢出`，因为会不停的创建 A B C，同时，内存也不会回收，因为相互引用。
# 2 解决办法
## 单例
如果在`A B C中有一个是单例`，则不会出现问题，因为单例在全局只会有一个，假如A是单例的，那么A创建好之后，C再去引用A时，不会再去创建一个新的A，所以并不会出现问题。
## spring 帮助我们解决属性上的循环依赖问题
spring只能解决属性的循环依赖问题，不能解决构造器的循环依赖问题。
`spring通过三级缓存实现了 属性循环依赖的问题，一级缓存：里面存放了初始化好的实例。三级缓存：里面存放了没有初始化好的实例。spring通过可以返回三级缓存中的实例，然后从三级缓存中移除，存入到二级缓存中，使得属性的循环依赖问题得到解决。`
这里参考了这篇文章写的案例：链接: (https://www.jianshu.com/p/b07862d4824c)
>演示代码 重点，编写一个类-SimpleContainer，模仿Spring底层处理循环依赖。如果理解这个代码，再去看Spring处理循环依赖的逻辑就会很简单。
```java
package com.tech.ioc;
import java.beans.Introspector;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
/**
* 演示Spring中循环依赖是如何处理的，只是个简版，真实的Spring依赖处理远比这个复杂。
* 但大体思路都相同。另外这个Demo很多情况都未考虑，例如线程安全问题，仅供参考。
* @AuThor wang hai xin
*
* **/
public class SimpleContainer {
/***
* 用于存放完全初始化好的Bean，Bean处于可状态
* 这个Map定义和Spring中一级缓存命名一致
* */
private Map<String, Object> singletonObjects = new ConcurrentHashMap<>();
/***
* 用于存放刚创建出来的Bean，其属性还没有处理，因此存放在该缓存中的Bean还不可用。
* 这个Map定义和Spring中三级缓存命名一致
* */
private final Map<String, Object> singletonFactories = new HashMap<>(16);
public static void main(String[] args) {
SimpleContainer container = new SimpleContainer();
ComponentA componentA = container.getBean(ComponentA.class);
componentA.say();
}
public <T> T getBean(Class<T> beanClass) {
String beanName = this.getBeanName(beanClass);
// 首先根据beanName从缓存中获取Bean实例
Object bean = this.getSingleton(beanName);
if (bean == null) {
// 如果未获取到Bean实例，则创建Bean实例
return createBean(beanClass, beanName);
}
return (T) bean;
}
/***
* 从一级缓存和二级缓存中根据beanName来获取Bean实例，可能为空
* */
private Object getSingleton(String beanName) {
// 首先尝试从一级缓存中获取
Object instance = singletonObjects.get(beanName);
if (instance == null) { // Spring 之所以能解决循环依赖问题，也是靠着这个singletonFactories
instance = singletonFactories.get(beanName);
}
return instance;
}
/***
* 创建指定Class的实例，返回完全状态的Bean(属性可用)
*
* */
private <T> T createBean(Class<T> beanClass, String beanName) {
try {
Constructor<T> constructor = beanClass.getDeclaredConstructor();
T instance = constructor.newInstance();
// 先将刚创建好的实例存放到三级缓存中，如果没有这一步，Spring 也无法解决三级缓存
singletonFactories.put(beanName, instance);
Field[] fields = beanClass.getDeclaredFields();
for (Field field : fields) {
Class<?> fieldType = field.getType();
field.setAccessible(true);
// 精髓是这里又调用了getBean方法，例如正在处理ComponentA.componentB属性，
// 执行到这里时就会去实例化ComponentB。因为在getBean方法首先去查缓存，
// 而一级缓存和三级缓存中没有ComponentB实例数据，所以又会调用到当前方法，
// 而在处理ComponentB.componentA属性时，又去调用getBean方法去缓存中查找，
// 因为在前面我们将ComponentA实例放入到了三级缓存，因此可以找到。
// 所以ComponentB的实例化结束，方法出栈，返回到实例化ComponentA的方法栈中，
// 这时ComponentB已经初始化完成，因此ComponentA.componentB属性赋值成功！
field.set(instance, this.getBean(fieldType));
}
// 最后再将初始化好的Bean设置到一级缓存中。
singletonObjects.put(beanName, instance);
return instance;
} catch (Exception e) {
e.printStackTrace();
}
throw new IllegalArgumentException();
}
/**
* 将类名小写作为beanName，Spring底层实现和这个差不多，也是使用javaBeans的
* {@linkplain Introspector#decapitalize(String)}
**/
private String getBeanName(Class<?> clazz) {
String clazzName = clazz.getName();
int index = clazzName.lastIndexOf(".");
String className = clazzName.substring(index);
return Introspector.decapitalize(className);
}
}
```
当然 spring的源码要比这个案例复杂，考虑更多的场景，不过思路是一样的。
# 原型模式
原型模式：旨在创建重复对象，又能保证性能。
实现克隆操作：通过实现clonebale接口，可以实现浅克隆。通过序列化和反序列化，可以实现深克隆。
优点：1.性能提高 2.逃避构造函数的约束
缺点：1.对于克隆方法要对类的功能进行通盘考虑，对于全新类可能比较简单，但是对于已有类，特别类引用不支持串行化的间接对象或者含有循环结构的时候
2.必须实现cloneable接口
如果不是单例模式，使用了原型模式，就会出现循环依赖的死循环中。
原型模式会检查引用，如果引用对象没有实例化，去实例化引用对象，导致死循环。
# 单例模式
单例模式：全局只有一个
分为饿汉式和懒汉式
饿汉式则是在项目初始化时就初始化这个类，并保证全局只有一个
> 饿汉式：演示代码
```java
/**
* @program: solution
* @description: 单例 懒汉式
* @author: Wang Hai Xin
* @create: 2022-12-19 10:22
**/
public class T1 {
/*懒汉式，则是声明一个私有化的变量，然后直接实例化对象给到这个变量*/
private static T1 t = new T1();
/*将构造方法私有化*/
private T1(){
}
/*获取唯一可用对象*/
public static T1 init(){
return t;
}
// 这里忽略功能代码
}
```
> 问题： 如果这个`类的内容特别多，使用也不是很多的情况下，使用饿汉式会消耗性能。`
懒汉式则可以一定程度上解决这个问题
> 懒汉式汉式：演示代码
```java
/**
* @program: solution
* @description: 单例模式 懒汉式
* 解决问题： 如果这个类的内容特别多，使用也不是很多的情况下，使用饿汉式会消耗性能。
* 懒汉式则可以一定程度上解决这个问题
* @author: Wang Hai Xin
* @create: 2022-11-03 18:34
**/
public class T {
/*懒汉式，并不会直接将这个私有变量赋值，而是在确实需要使用的时候才会去赋值
* 同时，使用volatile关键字 防止指令的重排序，防止在new对象的时候，对象还没有初始化完成
* 但是已经将t指向了实例化对象空间
* */
private staticvolatile T t;
public T init(){
/*这里写init的其它逻辑*/
/*双重锁，最大程度上减少被锁住的线程*/
if (t == null) {
synchronized (T.class){
if (t == null) {
t =new T();
}
}
}
return t;
}
}
```
页:
[1]