Spring之方法注入（lookup method）

Spring使用CGLIB的动态字节码增强功能，所以，必须要加入CGLIB包

当Bean依赖另一个生命周期不同的bean，尤其是当singleton依赖一个non-singleton时，常会遇到不少问题，Lookup Method Injection正是对付这些问题而出现的，在上述情况中，setter和构造注入都会导致singleton去维护一个non-singleton bean的单个实例，某些情况下，我们希望让singleton bean每次要求获得bean时候都返回一个non-singleton bean的新实例

当一个singleton bean A 在每次方法调用的时候都需要一个non-singleton bean B，此时就会产生这样一个问题，因为A为singleton，所以容器只会创建一次A，那么也只有一次机会来创建A的属性，Bean B也只能被初始化一次，但是我们调用每个方法的时候又都需要一个新的B的实例。通常的时候我们只要new一个就可以，但在Spring中这不符合整体性的设计，这样就有了方法注入。
       让我们开始一个简单的测试。
       在你的工程的根目录中分别建立一个src,classes,lib文件夹。此次我们将采用Ant来进行部署。
       在src中建立Random.java，HelloRandom.java，HelloAbstract.java，Test.java。代码如下。
       Random.java这是一个可以产生随机数的类，很简单。

    package com.testspring.basic.lookup;
       public class Random {
               private int num = (int)(100*Math.random());
               public void printRandom(){
                   System.out.println("随机数是"+num);
               }
        }
     
    HelloRandom.java一个代理接口。

     package com.testspring.basic.lookup;
    public interface HelloRandom {
        public Random getRandom();
        public abstract Random createRandom();    //这个方法最为重要，是方法注入的关键
    }
     
    HelloAbstract.java

     package com.testspring.basic.lookup;
    public abstract class HelloAbstract implements HelloRandom{
        private Random random;
        public void setRandom(Random random){
              this.random = random;
        }
        public Random getRandom(){
            return this.random;
         }
        public abstract Random createRandom();
    }
     
       Test.java用于测试

    package com.testspring;
       import org.springframework.context.ApplicationContext;
       import com.testspring.basic.lookup.*;
       public class Test {
           public static void main(String[] args) {
             try{
                  ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
                  HelloRandom helloRandom = (HelloRandom)context.getBean("helloRandom");
                    System.out.println("下面两个实例没有采用方法注入");
                    Random r1 = helloRandom.getRandom();
                    Random r2 = helloRandom.getRandom();
                    System.out.println("Random 的两个实例是否指向同一个引用：" + (r1 == r2));
                    r1.printRandom();
                    r2.printRandom();
                  System.out.println();
                  System.out.println("下面两个实例采用方法注入");
                    Random r3 = helloRandom.createRandom();
                    Random r4 = helloRandom.createRandom();
                  System.out.println("Random 的两个实例是否指向同一个引用：" + (r3 == r4));
                  r3.printRandom();
                    r4.printRandom();
                 }catch(Exception e){
                     e.printStackTrace();
               }
          }
      }


      在src中建立一个bean.xml文件
    <?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="myRandom" class="com.testspring.basic.lookup.Random" scope="prototype" />
              <bean id="helloRandom" class="com.testspring.basic.lookup.HelloAbstract">
                   <lookup-method name="createRandom" bean="myRandom"/>
                       <property name="random">
                               <ref local="myRandom" />  
                       </property>
             </bean>
     </beans>
     在根目录中建立一个build.xml文件
     <?xml version="1.0" encoding="UTF-8"?>
     <project name="MySpring" default="run" basedir=".">
                       <!-- 全局变量的定义 -->
           <property name="src.dir" value="src" />                       <!-- 源文件位置 -->
           <property name="classes.dir" value="classes" />     <!-- class文件位置 -->
           <property name="lib.dir" value="lib" />                          <!-- 引用的jar文件位置 -->
                      <!--当前工程环境变量-->
           <path id="Project-Classpath">
                  <pathelement path="${classes.dir}"/>
                <fileset dir="${lib.dir}">
                       <include name="*.jar"/>
                   </fileset>
           </path>
                      <!--编译-->
          <target name="compile" depends="clean">
                   <javac srcdir="${src.dir}" destdir="${classes.dir}">
                           <classpath refid="Project-Classpath" />
                   </javac>
          </target>
                      <!--复制除了java文件以外的文件-->
          <target name="copy-resources" depends="compile">
              <copy todir="${classes.dir}">
                    <fileset dir="${src.dir}">
                        <exclude name="**/*.java"/>
                    </fileset>
                   </copy>
        </target>
          <!--运行-->
        <target name="run">
                <java fork="true" classname="com.testspring.Test">
                        <classpath refid="Project-Classpath" />
                </java>
        </target>
     </project>
     将spring.jar，cglib-nodep-2.1_3.jar放入lib中。
     运行build命令就可以看到我们的结果了
    ----------------------------------------------------------------------------------------------
   下面两个实例没有采用方法注入
     Random 的两个实例是否指向同一个引用：true
     随机数是99
   随机数是99

    下面两个实例采用方法注入
    Random 的两个实例是否指向同一个引用：false
    随机数是98
    随机数是17

注意事项：

1.应用场合：一个singleton的Bean需要引用一个prototype的Bean; 一个无状态的Bean需要引用一个有状态的Bean; ... ; 等等情景下.
2.假定你有三个singleton,公用一个依赖，希望每个singleton有自己的实例依赖，所以将依赖设置成singleton,但
   实际上每个singleton在其生命周期中使用协作着的同一个实例足以，这种情况下，setter是最好的选择，使用方
   法查找注入会增加不必要的开销
3.我们也可以使用实现BeanFactoryAware的方式代替Lookup Method Injection

    public void setBeanFactory(Beanfactory factory){
         this.factory=factory;
   }
   public Random createRandom(){
      return (Random)factory.getBean("myRandom");
   }

   使用上述方法在效率上和使用本例的方法，相差无几（100000次差别在几毫秒），所以，建议使用本里的方法，减少和spring api的耦合

4.尽管可以不把查找方法定义成abstract,但还是建议这样做，可以防止不小心忘了配置查找方法而留一个空方法在代码中
5. 记住在任何时候只要定义了一个Bean的Lookup方法，那么这个Bean的实例将是一个CGLIB动态生成的实例而不是原来类的实例。
6.Spring允许在一个Bean中定义多个Lookup方法。
7.Spring还允许Lookup方法中定义的方法带有参数，但是Sping不会处理这些参数。
8.Spring对Lookup方法也存在一些限制：
方法不能是private的，但可以是protected的。
方法不能是静态的。