前言

大家在開發中有沒有遇到過因回圈依賴導致專案啟動失敗？在排查回圈依賴的程序中有沒困難？如何避免寫出回圈依賴的代碼？

我沒寫過回圈依賴的代碼，作為穩定性負責人，我排查過多次，

有些邏輯簡單的代碼，回圈依賴很容易排查，但是，我們的業務超級復雜，絕大多數回圈依賴，一整天都查不出來，

起初我們遇到一個回圈依賴處理一個，作為穩定性負責人，技術能干的事，不會讓人做第二次，為此，我寫了一段回圈依賴巡檢代碼，把回圈依賴扼殺在測驗環境，

下面介紹下場景及處理思路，未必最優，歡迎交流，

背景

SpringCloud服務在上線時出現BeanCurrentlyInCreationException例外（服務本地啟動無例外，測驗環境啟動也無例外，上線就偶爾例外），

1，本地模擬如下：

Caused by: org.springframework.beans.factory.BeanCurrentlyInCreationException: Error creating bean with name 'studentA': Bean with name 'studentA'

has been injected into other beans [studentC] in its raw version as part of a circular reference, but has eventually been wrapped.

This means that said other beans do not use the final version of the bean. This is often the result of over-eager type matching - consider using 'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.

2，生產場景如下圖：

例外排查&模擬

經過生產排查和本地測驗，產生此例外的場景如下：

1，如果類方法有@Async注解，則可能出現如上例外

2，如果存在回圈依賴，并且類方法上有@Async注解，則必然會出現如上例外，

1，場景演示：

在spring中，基于field屬性的回圈依賴是可以的:

示例代碼：

@Service
@Slf4j
public class StudentA {

    @Autowired
    private StudentB studentB;
    public String test(){
        return studentB.test();
    }
    public String test1(){
        return "Studenta1";
    }
}

@Slf4j
@Service
public class StudentB {

    @Autowired
    private StudentC studentC;

    public String test() {
        return "Studentb";
    }

    public String test1() {
        return studentC.test1();
    }
}

@Slf4j
@Service
public class StudentC {

    @Autowired
    private StudentA studentA;

    public String test() {
        return studentA.test();
    }

    public String test1() {
        return "Studentc1";
    }
}

@Autowired
private StudentA studentA ;
@Test
public void testA(){
    String v= studentA.test();
    log.info("testa={}",v);
}

以上代碼輸出正常

2，例外演示

如果我們的方法加上了@Async 注解，則拋出例外：

@Service
@Slf4j
public class StudentA {

    @Autowired
    private StudentB studentB;
    @Async
    public String test(){
        return studentB.test();
    }
    @Async
    public String test1(){
        return "Studenta1";
    }
}

@Slf4j
@Service
public class StudentB {

    @Autowired
    private StudentC studentC;
    @Async
    public String test() {
        return "Studentb";
    }
    @Async
    public String test1() {
        return studentC.test1();
    }
}

@Slf4j
@Service
public class StudentC {

    @Autowired
    private StudentA studentA;
    @Async
    public String test() {
        return studentA.test();
    }
    @Async
    public String test1() {
        return "Studentc1";
    }
}

@Autowired
private StudentA studentA ;
@Test
public void testA(){
    String v= studentA.test();
    log.info("testa={}",v);
}
Caused by: org.springframework.beans.factory.BeanCurrentlyInCreationException: 
Error creating bean with name 'studentA': Bean with name 'studentA' has been injected into other beans [studentC] in its raw version as part of a circular reference, but has eventually been wrapped. 
This means that said other beans do not use the final version of the bean. 
This is often the result of over-eager type matching - consider using 'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.

3，解決例外

A,B,C三個類中，至少一個類的field 必須加@Lazy

@Service
@Slf4j
public class StudentA {

    @Autowired
    @Lazy
    private StudentB studentB;
    @Async
    public String test(){
        return studentB.test();
    }
    @Async
    public String test1(){
        return "Studenta1";
    }
}

@Slf4j
@Service
public class StudentB {

    @Autowired
    @Lazy
    private StudentC studentC;
    @Async
    public String test() {
        return "Studentb";
    }
    @Async
    public String test1() {
        return studentC.test1();
    }
}

@Slf4j
@Service
public class StudentC {

    @Autowired
    @Lazy
    private StudentA studentA;
    @Async
    public String test() {
        return studentA.test();
    }
    @Async
    public String test1() {
        return "Studentc1";
    }
}

參考：https://my.oschina.net/tridays/blog/805111

杜絕回圈依賴的解決方案

這里根據我司的服務架構介紹一下如何避免回圈依賴，我司用的spring cloud 全家桶，注冊中心用的consul，配置中心有config 和apollo，

1，查看bean的依賴

spring-cloud 提供了bean資訊查看功能,通過ip:埠+/actuator/beans可查看(如何配置actuator這里不詳細討論)，如下圖，我們可以看到每個bean依賴的bean

2，決議bean及其依賴beans

如上，我們可以查看某個bean的依賴項，由此，我們可以遞回查找bean是否存在回圈參考，

bean 資訊模型

@Data
public class ApplicationBeans {

    private Map<String, ContextBeans> contexts;
}



@Data
public class ContextBeans {

    private Map<String, BeanDescriptor> beans;
    private String parentId;
}

3，代碼實作

這里檢測專案起名alarm-center，檢測類為CheckCyclicDependenceService

@Slf4j
@RefreshScope
@Service
public class CheckCyclicDependenceService {

    // 服務發現
    @Autowired
    private DiscoveryClient discoveryClient;

    //默認檢測 api,admin兩個專案，如果想檢測其它專案，可在config配置
    @Value("${check-serviceids-value:api,admin}")
    private String checkServiceIds;

 
    //入口
    public void checkCyclicDependence() {
        if (Strings.isNullOrEmpty(checkServiceIds)) {
            return;
        }
        List<String> serviceIds = Arrays.asList(checkServiceIds.split(","));
        for (String serviceId : serviceIds) {
            long start = System.currentTimeMillis();
            RestTemplate restTemplate = new RestTemplate();
            //根據服務名去consul找一個服務實體
            ServiceInstance instance = discoveryClient.getInstances(serviceId).get(0);
            String url = instance.getUri() + "/actuator/beans";
            //所有的beans資訊
            String applicationBeansStr = restTemplate.getForObject(url, String.class);
            ApplicationBeans applicationBeans = JSONObject.parseObject(applicationBeansStr, ApplicationBeans.class);
            long end = System.currentTimeMillis();
            log.info("checkCyclicDependence get applicationBeans end,serviceid={},coust={}", serviceId, (end - start));
            Map<String, ContextBeans> contexts = applicationBeans.getContexts();
            Map<String, BeanDescriptor> qualifiedBeans = new HashMap<>();
            for (Map.Entry<String, ContextBeans> conEntry : contexts.entrySet()) {
                if (!conEntry.getKey().startsWith(serviceId)) {
                    continue;
                }
                ContextBeans contextBeans = conEntry.getValue();
                Map<String, BeanDescriptor> beans = contextBeans.getBeans();

                for (Map.Entry<String, BeanDescriptor> entry1 : beans.entrySet()) {
                    String beanName = entry1.getKey().toLowerCase();
                    BeanDescriptor beanDescriptor = entry1.getValue();
                    if (!beanDescriptor.getType().startsWith("com.shuidihuzhu") || beanName.endsWith("aspect") || beanName.endsWith("controller")
                            || beanName.endsWith("dao") || beanName.endsWith("datasource")
                            || beanName.endsWith("fallback") || beanDescriptor.getDependencies().length == 0) {
                        continue;
                    }
                    qualifiedBeans.put(entry1.getKey(), beanDescriptor);
                }
            }
            StringBuilder sb = new StringBuilder();
            cyclicDependence(qualifiedBeans, sb);
            if (sb.length() > 0) {
                sb.append(System.getProperty("line.separator"));
                sb.append("重注代碼質量,盡量做到無回圈依賴");
                sb.append(System.getProperty("line.separator"));
                sb.append("所屬服務:" + serviceId);
                //alarmClient.sendByUser(Lists.newArrayList("zhangzhi"), sb.toString());
                alarmClient.sendByGroup("cf-server-alarm", sb.toString());
                end = System.currentTimeMillis();
            }
            log.info("checkCyclicDependence end,serviceid={},coust={}", serviceId, (end - start));
        }

    }

    public void cyclicDependence(Map<String, BeanDescriptor> beans, StringBuilder sb) {

        for (Map.Entry<String, BeanDescriptor> bean : beans.entrySet()) {
            String beanName = bean.getKey();
            check(beans, beanName, beanName, 0, sb);
        }
    }


    public void check(Map<String, BeanDescriptor> beans, String beanName, String dependenceName, int depth, StringBuilder sb) {
        if (depth == 4) {//這里可以指定深度，層級過多，容易堆疊溢位
            return;
        }
        depth++;
        BeanDescriptor bean = beans.get(dependenceName);//依賴項的依賴項
        if (bean != null) {
            String[] deps = bean.getDependencies();//依賴項
            for (String dep : deps) {
                if (dep.equals(beanName)) {
                    sb.append(System.getProperty("line.separator"));
                    String str = String.format("%s和%s存在回圈依賴;", beanName, dependenceName);
                    sb.append(str);
                    log.info(str);
                } else {
                    check(beans, beanName, dep, depth, sb);
                }
            }
        }

    }
}

效果

我們在測驗環境有個job 每隔幾分鐘巡檢，有回圈依賴就企業微信報警，這里截取一段日志，如下：

最后

水滴保險商城-架構組招java實習生(本人直招)

要求：
1、具備較強的編程基本功，熟練掌握JAVA編程語言，熟悉常用資料結構與演算法，
2、了解常用的開源框架和開源服務(Spring，Netty，MySQL，Redis，Tomcat，Nginx 等)，
3、熟悉網路編程、多執行緒編程、分布式等優先，
4、閱讀過spring家族原始碼優先，有技術博客優先，熟悉spring-cloud技術堆疊優先，
5、做事積極主動，有較強的執行能力和和較好的溝通能力，

對水滴感興趣的同學可找我內推，java 后端和QA 都可以，我找負責人評估合適的話，推給HR聯系您，

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/210723.html

標籤：其他

上一篇：執行緒池是怎么回事(附面試題)

下一篇：Java學習路線，小白進來必有識訓

SpringCloud BeanCurrentlyInCreationException 例外解決方案

前言

背景