使用Spring方法注入不同步调的Bean

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">

<beans>

  <bean id="chinese" class="Bean.lookupbean.Chinese">
    <property name="axe">
      <ref local="axe"/>
    </property>
    <!-- 指定lookup注入方法，该方法用来保证每次产生的non-singleton bean都是新的实例，使用bean属性确定lookup方法的返回值 -->
    <lookup-method name="createAxe" bean="axe"/>
  </bean>
  <bean id="axe" class="Bean.lookupbean.SteelAxe" singleton="false"></bean>
</beans>

      spring bean有两种状态，singleton和non-singleton,区别是singletom在整个生命周期中只实例化一次，由spring进行管理，而non-singleton可以实例化多次，spring不负责进行管理，当有依赖关系存在是，会有这样一个问题，当singleton bean依赖non-singleton时，由于singleton bean只初始化一次，而non-singleton可以初始化多次，这样就会造成不同步的想象，解决办法是使用spring提供的lookup方法注入 

定义接口：

package Bean.lookupbean;

public interface Person ...{
    public Axe getAxe();
    public void useAxe();
    public abstract Axe createAxe();
} 

    


package Bean.lookupbean;

public interface Axe ...{
   public String chop();
}

实现类：

注意，方法注入所需要的方法，必须是abstract的

 

package Bean.lookupbean;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;

import Bean.lookupbean.Person;

public abstract class Chinese implements Person ...{
    private Axe axe;
    public void useAxe() ...{
        axe.chop();
        
    }
    public Axe getAxe() ...{
        return axe;
    }
    public void setAxe(Axe axe) ...{
        this.axe = axe;
    }
    //方法注入所需要的方法，由spring提供实现
    public abstract Axe createAxe();

  
}


package Bean.lookupbean;

public class SteelAxe implements Axe ...{
    private int count=0;
    public String chop() ...{
        
        return "这是一把铁斧子"+ ++count;

    }

}

配置文件；

这里要把axe bean设置成singleton=false否则，由于容器内只有一个目标bean实例，即使采用lookup注入，每次依然返回同一个实例，lookup方法不仅适用于设值注入，也适用于构造注入

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">

<beans>

  <bean id="chinese" class="Bean.lookupbean.Chinese">
    <property name="axe">
      <ref local="axe"/>
    </property>
    <!-- 指定lookup注入方法，该方法用来保证每次产生的non-singleton bean都是新的实例，使用bean属性确定lookup方法的返回值 -->
    <lookup-method name="createAxe" bean="axe"/>
  </bean>
  <bean id="axe" class="Bean.lookupbean.SteelAxe" singleton="false"></bean>
</beans>

 

测试代码：

 

public static void main(String[] args) throws Exception ...{
        
        String path=new Test().getClass().getResource("/").getPath();
        String realpath=path.substring(1, path.length());
        ApplicationContext context=new FileSystemXmlApplicationContext(realpath+"/lookupbean.xml");
        System.out.println("不使用lookup");
        Person p=(Person)context.getBean("chinese");
        System.out.println(p.getAxe());
        System.out.println(p.getAxe());
        System.out.println(p.getAxe().chop());
        System.out.println(p.getAxe().chop());
        System.out.println("使用lookup");
        System.out.println(p.createAxe());
        System.out.println(p.createAxe());
        System.out.println(p.createAxe().chop());
        System.out.println(p.createAxe().chop());
        
       
       
    }

运行结构：

不使用lookup
Bean.lookupbean.SteelAxe@1e87719
Bean.lookupbean.SteelAxe@1e87719
这是一把铁斧子1
这是一把铁斧子2
使用lookup
Bean.lookupbean.SteelAxe@e32802
Bean.lookupbean.SteelAxe@b23210
这是一把铁斧子1
这是一把铁斧子1

可以看到，不使用lookup，spring返回同一个实例（由于不同步的原因），使用lookup,每次返回一个新的实例