Spring 三种方式的循环依赖

Posted 2023-05-15

参考技术A 循环依赖是指多个类循环嵌套引用，如：A类引用B类，B类引用C类，C类引用A类。

Spring容器会将每一个正在创建的Bean标识放在一个“当前创建Bean池中，Bean标识符在创建过程中将一直保持在这个池中。
如果在创建Bean过程中发现自己已经在“当前创建Bean池”里时将抛出BeanCurrentlyInCreationException异常表示循环依赖；而创建完成的Bean将从“当前创建Bean池”中清除掉。

看如下实例：

看配置文件的构造器参数配置：
<bean id="a" class="com.soecode.lyf.test.StudentA" >
   <constructor-arg index="0" ref="b"/>
</bean>

<bean id="b" class="com.soecode.lyf.test.StudentB" >
     <constructor-arg index="0" ref="c" >
</bean>

<bean id="c" class="com.soecode.lyf.test.StudentC" >
     <constructor-arg index="0" ref="a" >
</bean>

这三个就是StudentA类中有StudentB类，StudentB类中有StudentC类，StudentC类中有StudentA类。

看如下实例:

setter 方式注入 scope默认为singleton
<bean id="a" class="com.soecode.lyf.test.StudentA" >
    <property name="studentB" ref="b">
</bean>

<bean id="b" class="com.soecode.lyf.test.StudentB" >
    <property name="studentC" ref="c" >
</bean>

<bean id="c" class="com.soecode.lyf.test.StudentC" >
    <property name="studentA" ref="a" >
</bean>
执行结果：

为什么用setter方式就不报错了呢？
/** Cache of singleton factories: bean name --> ObjectFactory（单例的工厂Bean缓存集合） */、privatefinalMap singletonFactories =newHashMap(16);

1.创建StudentA a单列时，首先无参构造创建，并暴露到singletonFactories中，并将a 标志符放到当前正在创建Bean池, 然后进行setter出入StudentB b。
2.创建StudentB b单列时，首先无参构造创建，并暴露到singletonFactories中，并将b 标志符放到当前正在创建Bean池, 然后进行setter出入StudentC c。
3.创建StudentC c单列时，首先无参构造创建，并暴露到singletonFactories中，并将b 标志符放到当前正在创建Bean池, 然后进行setter出入StudentA a。在注入 a 时，由于提前暴露在singletonFactories集合中了，利用它就可以取到 a 正在创建的Bean对象。
4. 最后依赖注入StudentB、StudentA

看配置文件：

scope=”property“ 意思是每一次请求都会创建一个实例对象。
两者的区别是：有状态的bean都使用property作用域，无状态的一般都使用singleton单列作用域。

看运行之后的控制台输出：

因为单列的时候，会将bean放在缓存中，可以提前暴露此接口。
而property原型不会放入缓存中，无法提前暴露。

Spring依赖注入（DI）的三种方式

Spring依赖注入（DI）的三种方式 Spring依赖注入（DI）的三种方式，分别为：

1． 接口注入

2． Setter方法注入

3． 构造方法注入

下面介绍一下这三种依赖注入在Spring中是怎么样实现的。

首先我们需要以下几个类：

接口 Logic.java

接口实现类 LogicImpl.java

一个处理类 LoginAction.java

还有一个测试类 TestMain.java

Logic.java如下：

package com.spring.test.di?

public interface Logic

public String getName()?

LogicImpl.java如下：

package com.spring.test.di?

public class LogicImpl implements Logic

public String getName()

return "fengyun"?

TestMain.java

package com.spring.test.di?

import org.springframework.context.ApplicationContext?

import org.springframework.context.support.FileSystemXmlApplicationContext?

public class TestMain

/**

* @param args

*/

public static void main(String[] args) // 得到ApplicationContext对象

ApplicationContext ctx = new FileSystemXmlApplicationContext(

"applicationContext.xml")?

// 得到Bean

LoginAction loginAction = (LoginAction) ctx.getBean("loginAction")?

loginAction.execute()?

LoginAction.java 会根据使用不同的注入方法而稍有不同

下面按照注入的方法来看LoginAction.java类

Setter方法注入：

package com.spring.test.di?

public class LoginAction

private Logic logic?

public void execute()

String name = logic.getName()?

System.out.print("My Name Is " + name)?

/**

* @return the logic

*/

public Logic getLogic()

return logic?

/**

* @param logic

* the logic to set

*/

public void setLogic(Logic logic)

this.logic = logic?

定义了一个Logic 类型的变量 logic, 在LoginAction并没有对logic 进行实例化，而只有他对应的

setter/getter方法，因为我们这里使用的是Spring的依赖注入的方式

applicationContext.xml配置文件如下:

<bean id="logic" class="com.spring.test.di.LogicImpl"/>

<bean id="loginAction" class="com.spring.test.di.LoginAction">

<property name="logic" ref="logic"></property>

</bean>

现在可以运行testMain.java了，我们可以看到控制台打出了 My Name Is fengyun

OK了，这就是spring的setter方法注入，非常简单

下面我们来看看构造方法注入

顾名思义，构造方法注入，就是我们依靠LoginAction的构造方法来达到DI的目的，如下所示：

LoginAction.java

package com.spring.test.di?

public class LoginAction

private Logic logic?

public LoginAction(Logic logic)

this.logic = logic?

public void execute()

String name = logic.getName()?

System.out.print("My Name Is " + name)?

这里我们添加了一个LoginAction的构造方法

applicationContext.xml配置文件如下:

<bean id="logic" class="com.spring.test.di.LogicImpl"/>

<bean id="loginAction" class="com.spring.test.di.LoginAction">

<constructor­arg index="0" ref="logic"></constructor­arg>

</bean>

我们使用constructor­arg来进行配置, index属性是用来表示构造方法中参数的顺序的，如果有多

个参数，则按照顺序，从 0,1...来配置

我们现在可以运行testMain.java了,结果跟使用Setter方法注入完全一样.其中需要注意一点有：构造函数有多个参数的话，如：参数1，参数2，而参数2依赖于参数1，这

中情况则要注意构造函数的顺序，必须将参数1放在参数2之前。

下面继续说说我们不常用到的接口注入，还是以LogicAction为例，我们对他进行了修改，如下所

示：

LogicAction.java

package com.spring.test.di?

public class LoginAction

private Logic logic?

public void execute()

try

Object obj = Class.forName("com.spring.test.di.LogicImpl")

.newInstance()?

logic = (Logic) obj?

String name = logic.getName()?

System.out.print("My Name Is " + name)?

catch (Exception e)

e.printStackTrace()?

配置文件：

<bean id="logic" class="com.spring.test.di.LogicImpl"/>

<bean id="loginAction" class="com.spring.test.di.LoginAction">

</bean>

我们最常用就是Setter和构造函数这两种注入方法

对于Spring的依赖注入，最重要的就是理解他的，一旦理解了，将会觉得非常的简单。无非就是让

容器来给我们实例化那些类，我们要做的就是给容器提供这个接口，这个接口就我们的set方法或

者构造函数了。