Spring当中循环依赖不多有人讲，今天一块儿来学习！

时间  2020-07-20
标签 spring 当中 循环 依赖 不多 今天 一块儿 学习 栏目 Spring 繁體版
原文   原文链接

网上关于Spring循环依赖的博客太多了，有不少都分析的很深刻，写的很用心，甚至还画了时序图、流程图帮助读者理解，我看了后，感受本身是懂了，可是闭上眼睛，总以为尚未彻底理解，总以为还有一两个坎过不去，对我这种有点笨的人来讲，真的好难。当时，我就在想，若是哪一天，我理解了Spring循环依赖，必定要用本身的方式写篇博客，帮助你们更好的理解，等我理解后，一直在构思，到底怎么应该写，才能更通俗易懂，就在前几天，我想通了，这么写应该更通俗易懂。在写本篇博客以前，我翻阅了好多关于Spring循环依赖的博客，网上应该尚未像我这样讲解的，如今就让咱们开始把。java

什么是循环依赖

一言以蔽之：二者相互依赖。面试

在开发中，可能常常出现这种状况，只是咱们平时并无注意到原来咱们写的两个类、甚至多个类相互依赖了，为何注意不到呢？固然是由于没有报错，并且一点问题都木有，若是报错了，或者产生了问题，咱们还会注意不到吗？这一切都是Spring的功劳，它在后面默默的为咱们解决了循环依赖的问题。算法

以下所示：spring

@Configuration
@ComponentScan
public class AppConfig {
}
@Service
public class AuthorService {
    @Autowired
    BookService bookService;
}
@Service
public class BookService {
    @Autowired
    AuthorService authorService;
}
public class Main {
    public static void main(String[] args) {
        ApplicationContext annotationConfigApplicationContext = new AnnotationConfigApplicationContext(AppConfig.class);

        BookService bookService = (BookService) annotationConfigApplicationContext.getBean("bookService");
        System.out.println(bookService.authorService);

        AuthorService authorService = (AuthorService) annotationConfigApplicationContext.getBean("authorService");
        System.out.println(authorService.bookService);
    }
}

运行结果：数据库

com.codebear.springcycle.AuthorService@63376bed
com.codebear.springcycle.BookService@4145bad8

能够看到BookService中须要AuthorService，AuthorService中须要BookService，相似于这样的就叫循环依赖，可是神奇的是居然一点问题没有。设计模式

固然有些小伙伴可能get不到它的神奇之处，至于它的神奇之处在哪里，咱们放到后面再说。缓存

任何循环依赖，Spring都能解决吗

不行。数据结构

若是是原型 bean的循环依赖，Spring没法解决：多线程

@Service
@Scope(BeanDefinition.SCOPE_PROTOTYPE)
public class BookService {
    @Autowired
    AuthorService authorService;
}
@Service
@Scope(BeanDefinition.SCOPE_PROTOTYPE)
public class AuthorService {
    @Autowired
    BookService bookService;
}

启动后，使人恐惧的红色字体在控制台出现了：并发

image.png

若是是构造参数注入的循环依赖，Spring没法解决：

@Service
public class AuthorService {
    BookService bookService;

    public AuthorService(BookService bookService) {
        this.bookService = bookService;
    }
}
@Service
public class BookService {

    AuthorService authorService;

    public BookService(AuthorService authorService) {
        this.authorService = authorService;
    }
}

仍是讨厌的红色字体：

image.png

循环依赖能够关闭吗
能够，Spring提供了这个功能，咱们须要这么写：

public class Main {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext();
        applicationContext.setAllowCircularReferences(false);
        applicationContext.register(AppConfig.class);
        applicationContext.refresh();
    }
}

再次运行，就报错了：

image.png

须要注意的是，咱们不能这么写：

AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(AppConfig.class);
applicationContext.setAllowCircularReferences(false);

若是你这么写，程序执行完第一行代码，整个Spring容器已经初始化完成了，你再设置不容许循环依赖，也于事无补了。

能够循环依赖的神奇之处在哪

有不少小伙伴可能并不以为能够循环依赖有多么神奇，那是由于不知道矛盾点在哪，接下来就来讲说这个问题：
当beanA，beanB循环依赖：

建立beanA，发现依赖beanB；
建立beanB，发现依赖beanA；
建立beanA，发现依赖beanB；
建立beanB，发现依赖beanA。
...
好了，死循环了。
循环依赖的矛盾点就在于要建立beanA，它须要beanB，而建立beanB，又须要beanA，而后两个bean都建立不出来。

如何简单的解决循环依赖

若是你曾经看过Spring解决循环依赖的博客，应该知道它其中有好几个Map，一个Map放的是最完整的对象，称为singletonObjects，一个Map放的是提早暴露出来的对象，称为earlySingletonObjects。

在这里，先要解释下这两个东西：

singletonObjects：单例池，其中存放的是经历了Spring完整生命周期的bean，这里面的bean的依赖都已经填充完毕了。
earlySingletonObjects：提早暴露出来的对象的map，其中存放的是刚刚建立出来的对象，没有经历Spring完整生命周期的bean，这里面的bean的依赖还未填充完毕。
咱们能够这么作：

当咱们建立完beanA，就把本身放到earlySingletonObjects，发现本身须要beanB，而后就去屁颠屁颠建立beanB；
当咱们建立完beanB，就把本身放到earlySingletonObjects，发现本身须要beanA，而后就去屁颠屁颠建立beanA；
建立beanA前，先去earlySingletonObjects看一下，发现本身已经被建立出来了，把本身返回出去；
beanB拿到了beanA，beanB建立完毕，把本身放入singletonObjects；
beanA能够去singletonObjects拿到beanB了，beanA也建立完毕，把本身放到singletonObjects。
整个过程结束。
下面让咱们来实现这个功能：
首先，自定义一个注解，字段上打上这个注解的，说明须要被Autowired：

@Retention(RetentionPolicy.RUNTIME)
public @interface CodeBearAutowired {
}

再建立两个循环依赖的类：

public class OrderService {
    @CodeBearAutowired
    public UserService userService;
}
public class UserService {
    @CodeBearAutowired
    public OrderService orderService;
}

而后就是核心，建立对象，填充属性，并解决Spring循环依赖的问题：

public class Cycle {
    // 单例池，里面放的是完整的bean，已完成填充属性
    private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>();

    // 存放的是提早暴露出来的bean，没有经历过spring完整的生命周期，没有填充属性
    private final Map<String, Object> earlySingletonObjects = new HashMap<>();

    // 在Spring中，这个map存放的是beanNam和beanDefinition的映射关系
    static Map<String, Class<?>> map = new HashMap<>();
    static {
        map.put("orderService", OrderService.class);
        map.put("userService", UserService.class);
    }
    // 若是先调用init方法，就是预加载，若是直接调用getBean就是懒加载，二者的循环依赖问题都解决了
    public void init() {
        for (Map.Entry<String, Class<?>> stringClassEntry : map.entrySet()) {
            createBean(stringClassEntry.getKey());
        }
    }

    public Object getBean(String beanName) {
        // 尝试从singletonObjects中取，
        Object singletonObject = this.singletonObjects.get(beanName);
        if (singletonObject != null) {
            return singletonObject;
        }

        // 尝试从earlySingletonObjects取
        singletonObject = this.earlySingletonObjects.get(beanName);
        if (singletonObject != null) {
            return singletonObject;
        }

        return createBean(beanName);
    }

    private Object createBean(String beanName) {
        Object singletonObject;

        try {
            // 建立对象
            singletonObject = map.get(beanName).getConstructor().newInstance();

            // 把没有完成填充属性的半成品 bean 放入earlySingletonObjects
            earlySingletonObjects.put(beanName, singletonObject);

            // 填充属性
            populateBean(singletonObject);

            // bean建立成功，放入singletonObjects
            this.singletonObjects.put(beanName, singletonObject);

            return singletonObject;
        } catch (Exception ignore) {
        }
        return null;
    }

    private void populateBean(Object object) {
        Field[] fields = object.getClass().getDeclaredFields();
        for (Field field : fields) {
            if (field.getAnnotation(CodeBearAutowired.class) != null) {
                Object value = getBean(field.getName());
                try {
                    field.setAccessible(true);
                    field.set(object, value);
                } catch (IllegalAccessException ignored) {
                }
            }
        }
    }
}

预加载调用：

public class Main {
    public static void main(String[] args) {
        Cycle cycle = new Cycle();
        cycle.init();
        UserService userService = (UserService) cycle.getBean("userService");
        OrderService orderService = (OrderService) cycle.getBean("orderService");
        System.out.println(userService.orderService);
        System.out.println(orderService.userService);
    }
}

运行结果：

com.codebear.cycleeasy.OrderService@61baa894
com.codebear.cycleeasy.UserService@b065c63

懒加载调用：

public class Main {
    public static void main(String[] args) {
        Cycle cycle = new Cycle();
        UserService userService = (UserService) cycle.getBean("userService");
        OrderService orderService = (OrderService) cycle.getBean("orderService");
        System.out.println(userService.orderService);
        System.out.println(orderService.userService);
    }
}

运行结果：

com.codebear.cycleeasy.OrderService@61baa894
com.codebear.cycleeasy.UserService@b065c63

为何没法解决原型、构造方法注入的循环依赖

在上面，咱们本身手写了解决循环依赖的代码，能够看到，核心是利用一个map，来解决这个问题的，这个map就至关于缓存。

为何能够这么作，由于咱们的bean是单例的，并且是字段注入（setter注入）的，单例意味着只须要建立一次对象，后面就能够从缓存中取出来，字段注入，意味着咱们无需调用构造方法进行注入。

若是是原型bean，那么就意味着每次都要去建立对象，没法利用缓存；
若是是构造方法注入，那么就意味着须要调用构造方法注入，也没法利用缓存。

须要aop怎么办？

咱们上面的方案看起来很美好，可是还有一个问题，若是咱们的bean建立出来，还要作一点加工，怎么办？也许，你没有理解这句话的意思，再说的明白点，若是beanA和【beanB的代理对象】循环依赖，或者【beanA的代理对象】和beanB循环依赖，再或者【beanA的代理对象】和【beanB的代理对象】循环依赖，怎么办？

这里说的建立代理对象仅仅是“加工”的其中一种可能。

遇到这种状况，咱们总不能把建立完的对象直接扔到缓存把？咱们这么作的话，若是【beanA的代理对象】和【beanB的代理对象】循环依赖，咱们最终获取的beanA中的beanB仍是beanB，并不是是beanB的代理对象。

聪明的你，必定在想，这还不简单吗：
咱们建立完对象后，判断这个对象是否须要代理，若是须要代理，建立代理对象，而后把代理对象放到earlySingletonObjects不就OJ8K了？
就像这样：

private Object createBean(String beanName) {
Object singletonObject;

try {
    // 建立对象
    singletonObject = map.get(beanName).getConstructor().newInstance();

    // 建立bean的代理对象
    /**
     * if( 须要代理){
     *     singletonObject=建立代理对象;
     *
     * }
     */

    // 把没有完成填充属性的半成品 bean 放入earlySingletonObjects
    earlySingletonObjects.put(beanName, singletonObject);

    // 填充属性
    populateBean(singletonObject);

    // bean建立成功，放入singletonObjects
    this.singletonObjects.put(beanName, singletonObject);

    return singletonObject;
} catch (Exception ignore) {
}
return null;

}

这确实能够，可是，这违反了Spring的初衷，Spring的初衷是但愿在bean生命周期的最后几步才去aop，若是像上面说的这么作，就意味着一旦建立完对象，Spring就会去aop了，这就违反了Spring的初衷，因此Spring并无这么作。

可是若是真的出现了aop bean循环依赖，就没办法了，只能先去aop，可是若是没有出现循环依赖，Spring并不但愿在这里就进行aop，因此Spring引入了Map<String, ObjectFactory<?>>，ObjectFactory是一个函数式接口，能够理解为工厂方法，当建立完对象后，把【得到这个对象的工厂方法】放入这个map，等真的发生循环依赖，就去执行这个【得到这个对象的工厂方法】，获取加工完成的对象。

下面直接放出代码：

public class Cycle {
    // 单例池，里面放的是完整的bean，已完成填充属性
    private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>();

    // 存放的是 加工bean的工厂方法
    private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>();

    // 存放的是提早暴露出来的bean，没有经历过spring完整的生命周期，没有填充属性
    private final Map<String, Object> earlySingletonObjects = new HashMap<>();

    private final Set<String> singletonsCurrentlyInCreation = new HashSet<>();

    static Map<String, Class<?>> map = new HashMap<>();

    static {
        map.put("orderService", OrderService.class);
        map.put("userService", UserService.class);
    }

    public void init() {
        for (Map.Entry<String, Class<?>> stringClassEntry : map.entrySet()) {
            createBean(stringClassEntry.getKey());
        }
    }

    private Object createBean(String beanName) {
        Object instance = null;
        try {
            instance = map.get(beanName).getConstructor().newInstance();
        } catch (Exception ex) {
        }


        Object finalInstance = instance;
        this.singletonFactories.put(beanName, () -> {
            // 建立代理对象
            return finalInstance;
        });

        populateBean(instance);

        this.singletonObjects.put(beanName, instance);
        return instance;
    }

    public Object getBean(String beanName) {
        // 尝试从singletonObjects中取，
        Object singletonObject = this.singletonObjects.get(beanName);
        if (singletonObject != null) {
            return singletonObject;
        }

        // 尝试从earlySingletonObjects取
        singletonObject = this.earlySingletonObjects.get(beanName);
        if (singletonObject != null) {
            return singletonObject;
        }

        // 尝试从singletonFactories取出工厂方法
        ObjectFactory<?> objectFactory = this.singletonFactories.get(beanName);
        if (objectFactory != null) {
            singletonObject = objectFactory.getObject();
            this.earlySingletonObjects.put(beanName, singletonObject);
            return singletonObject;
        }

        return createBean(beanName);
    }

    private void populateBean(Object object) {
        Field[] fields = object.getClass().getDeclaredFields();
        for (Field field : fields) {
            if (field.getAnnotation(CodeBearAutowired.class) != null) {
                Object value = getBean(field.getName());
                try {
                    field.setAccessible(true);
                    field.set(object, value);
                } catch (IllegalAccessException ignored) {
                }
            }
        }
    }
}

调用方法：

public static void main(String[] args) {
        Cycle cycle = new Cycle();
        cycle.init();
        System.out.println(((UserService) cycle.getBean("userService")).orderService);
        System.out.println(((OrderService) cycle.getBean("orderService")).userService);
    }

运行结果：

com.codebear.cycles.OrderService@49e4cb85
com.codebear.cycles.UserService@2133c8f8

二级缓存能不能解决循环依赖，三级循环到底有什么用？

个人观点可能和网上的主流观点有很大的出入，至于个人观点是对是错，请各位自行判断。

二级缓存能够解决循环依赖，哪怕aop bean循环依赖，上面咱们已经提到了，咱们能够建立完对象，直接建立代理对象，把代理对象放入二级缓存，这样咱们从二级缓存得到的必定是aop bean，并不是是bean自己。

三级缓存有什么用？网上的主流观点是为了解决循环依赖，还有就是为了效率，为了解决循环依赖，咱们上面已经讨论过了，个人观点是二级缓存已经能够解决循环依赖了，下面就让咱们想一想，和效率是否有关系？

个人观点是没有关系，理由以下：
咱们把【得到对象的工厂方法】放入了map

  • 若是没有循环依赖，这个map根本没有用到，和效率没有关系；
  • 若是是普通bean循环依赖，三级缓存直接返回了bean，和效率仍是没有关系；
  • 若是是aop bean循环依赖，若是没有三级缓存，直接建立代理对象，放入二级缓存，若是有三级缓存，仍是须要建立代理对象，只是二者的时机不一样，和效率仍是没有关系。

有了这篇博客的基础，当你再看其余关于Spring循环依赖的博客，应该会轻松的多，由于咱们毕竟本身解决了循环依赖，Spring的循环依赖只是在咱们之上作了进一步的封装与改进。

最后

私信回复 资料 领取一线大厂Java面试题总结+阿里巴巴泰山手册+各知识点学习思惟导+一份300页pdf文档的Java核心知识点总结！

这些资料的内容都是面试时面试官必问的知识点，篇章包括了不少知识点，其中包括了有基础知识、Java集合、JVM、多线程并发、spring原理、微服务、Netty 与RPC 、Kafka、日记、设计模式、Java算法、数据库、Zookeeper、分布式缓存、数据结构等等。

做者： CodeBear
原文：https://0x9.me/EL7No

file

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程