spring 循环依赖，构造函数注入与setter注入（属性注入）有什么优劣，三种注入方式又有什么优劣

https://blog.csdn.net/u010853261/article/details/77940767

做了一些实践：

一 注解方式注入时，循环依赖

@Component("ioca")              // 该句对IOCC的注入是必要的
@Qualifier("ioca2")             // 此句同样有效
//@Component("iocaerror")       // 该句对IOCC的注入失败
public class IOCA {

    /**
     * 这会造成循环依赖
     */
    // 循环依赖, Autowired非必须，spring会自己去找bean factory中类型为IOCB的bean
//    public IOCA(@Autowired IOCB iocb) {
//
//    }
}

@Component
public class IOCB {

    /**
     * 这会造成循环依赖
     */
    // 循环依赖，Autowired非必须，spring会自己去找bean factory中类型为IOCA的bean
//    public IOCB(@Autowired IOCA ioca) {
//
//    }
}

注意点：

1 构造函数中，Autowired注解不是必须的，spring会自己按类型去找

二 java bean方式注入时，循环依赖

@Configuration
@ImportResource("testspringxml.xml")
public class TestConfig {

    /**
     * 这会造成循环依赖，autowired非必须，spring会自己去找bean factory中类型为xxx的bean
     */
//    @Bean
//    public IOCA getA(@Autowired IOCB iocb) {
//        return new IOCA(null);
//    }
//
//    @Bean
//    public IOCB getB(@Autowired IOCA ioca) {
//        return new IOCB(null);
//    }

}

注意点：

1 本例中，请忽视Importresource注解，它用于案例三

2 autowired非必须

三 xml方式注入

@Component("ioca")              // 该句对IOCC的注入是必要的
@Qualifier("ioca2")             // 此句同样有效
//@Component("iocaerror")       // 该句对IOCC的注入失败
public class IOCA {

    /**
     * 这会造成循环依赖
     */
    // 循环依赖, Autowired非必须，spring会自己去找bean factory中类型为IOCB的bean
//    public IOCA(@Autowired IOCB iocb) {
//
//    }
}

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="iocc" class="com.example.demo.ioc.IOCC">

    </bean>
</beans>

public class IOCC {

    /**
     * Autowired非必须，spring会自己去找bean factory中类型为IOCA，名称为ioca的bean
     * 
     * 此处如果ioca3，或IOCA那边注解使用iocaerror等进行注入，则会报错
     * Parameter 0 of constructor in com.example.demo.ioc.IOCC required 
     * a bean of type 'com.example.demo.ioc.IOCA' that could not be found.
     * 
     */
    public IOCC(@Autowired @Qualifier("ioca") IOCA ioca) {

    }

    public void run() {
        System.out.println("被xml，importresource注入的ioc类运行");
    }
}

@Configuration
@ImportResource("testspringxml.xml")
public class TestConfig {

IOCC iocc = (IOCC)SpringContextUtil.getBean(IOCC.class);
		iocc.run();

注意点：

1 xml方式=@Configuration + @ImportResource + xml

bean方式=@Configuration+@bean

2 

@Component("ioca")              // 该句对IOCC的注入是必要的
@Qualifier("ioca2") 

两个注入名称都有效

3 

若使用

@Component("iocaerror") 

注入IOCA，或者不注入IOCA，

public IOCC(@Autowired @Qualifier("ioca") IOCA ioca)

此句将报错，找不到bean(类型、名称双重寻找)

4 

若使用

public IOCC(@Autowired @Qualifier("ioca3") IOCA ioca)

同样会与3一样报错，因为类型、名称双重寻找

5

2020.2.18补充

@Configuration
//@ImportResource("testspringxml.xml")  跑testcase junit时提示找不到testspringxml.xml
@ImportResource("classpath:testspringxml.xml")
public class TestConfig {

既然有构造函数注入和setter注入（属性注入）方式，各自有什么优劣

1 使用构造器注入的方法，可以明确成员变量的加载顺序，用于成员变量inicialize相互依赖的情况。

public class TestController {

        @Autowired

        private TestService testService;

        private String testname;

                 public TestController(){

                         this.testname = testService.getTestName();

                 }

 }

　　

https://blog.csdn.net/uaucome/article/details/85259654

https://www.cnblogs.com/acm-bingzi/p/springAutowired.html

2 使用构造函数注入，会导致循环依赖，setter注入（属性注入）不会

那么注解、java bean、xml三种注入方式有什么优劣

1 注解方式显然，不能用于那种源文件不在手上的类

2 java bean方式和xml方式本质一样，但java bean方式可在实例化注入时，提供更丰富的代码级的修饰和扩展，比如——

注入一个别人写的tcpClient，这个client在注入时，除了实例化并装配进spring bean factory，还要实打实的建立一条tcp连接，这个过程如果对方代码没有封装好，使用xml的方式是办不到的，xml只能实例化装配，不能建立连接；至于源文件在自己手上，随便怎么搞

（1）java bean:

new

建立tcp连接

return 装配完成

（2）xml：

new

装配完成