开涛spring3(3.3) - DI 之 3.3 更多DI的知识

3.3.1  延迟初始化Bean

延迟初始化也叫做惰性初始化，指不提前初始化Bean，而是只有在真正使用时才创建及初始化Bean。

配置方式很简单只需在<bean>标签上指定 “lazy-init” 属性值为“true”即可延迟初始化Bean。

Spring容器会在创建容器时提前初始化“singleton”作用域的Bean，“singleton”就是单例的意思即整个容器每个Bean只有一 个实例，后边会详细介绍。Spring容器预先初始化Bean通常能帮助我们提前发现配置错误，所以如果没有什么情况建议开启，除非有某个Bean可能需 要加载很大资源，而且很可能在整个应用程序生命周期中很可能使用不到，可以设置为延迟初始化。

延迟初始化的Bean通常会在第一次使用时被初始化；或者在被非延迟初始化Bean作为依赖对象注入时在会随着初始化该Bean时被初始化，因为在这时使用了延迟初始化Bean。

容器管理初始化Bean消除了编程实现延迟初始化，完全由容器控制，只需在需要延迟初始化的Bean定义上配置即可，比编程方式更简单，而且是无侵入代码的。

具体配置如下：

<bean id="helloApi"
    class="cn.javass.spring.chapter2.helloworld.HelloImpl"
    lazy-init="true"/>  

---

3.3.2  使用depends-on

depends-on是指指定Bean初始化及销毁时的顺序，使用depends-on属性指定的Bean要先初始化完毕后才初始化当前Bean，由于只 有“singleton”Bean能被Spring管理销毁，所以当指定的Bean都是“singleton”时，使用depends-on属性指定的 Bean要在指定的Bean之后销毁。

配置方式如下：

    <bean id="helloApi" class="cn.javass.spring.chapter2.helloworld.HelloImpl"/>
    <bean id="decorator"
        class="cn.javass.spring.chapter3.bean.HelloApiDecorator"
        depends-on="helloApi">
        <property name="helloApi"><ref bean="helloApi"/></property>
    </bean>  

“decorator”指定了“depends-on”属性为“helloApi”，所以在“decorator”Bean初始化之前要先初始化 “helloApi”，而在销毁“helloApi”之前先要销毁“decorator”，大家注意一下销毁顺序，与文档上的不符。

“depends-on”属性可以指定多个Bean，若指定多个Bean可以用“;”、“,”、空格分割。

那“depends-on”有什么好处呢？主要是给出明确的初始化及销毁顺序，比如要初始化“decorator”时要确保“helloApi”Bean 的资源准备好了，否则使用“decorator”时会看不到准备的资源；而在销毁时要先在“decorator”Bean的把对“helloApi”资源 的引用释放掉才能销毁“helloApi”，否则可能销毁 “helloApi”时而“decorator”还保持着资源访问，造成资源不能释放或释放错误。

让我们看个例子吧，在平常开发中我们可能需要访问文件系统，而文件打开、关闭是必须配对的，不能打开后不关闭，从而造成其他程序不能访问该文件。让我们来看具体配置吧：

具体代码如下：

1.ResourceBean

package lqy.springh5;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class ResourceBean {
    private FileOutputStream fos;
    private File file;
    //初始化方法
    public void init() {
        System.out.println("ResourceBean:========初始化");
        //加载资源,在此只是演示
        System.out.println("ResourceBean:========加载资源，执行一些预操作");
        try {
            this.fos = new FileOutputStream(file);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }
    //销毁资源方法
    public void destroy() {
        System.out.println("ResourceBean:========销毁");
        //释放资源
        System.out.println("ResourceBean:========释放资源，执行一些清理操作");
        try {
            fos.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    public FileOutputStream getFos() {
        return fos;
    }
    public void setFile(File file) {
        this.file = file;
    }
}  

2.DependentBean

package lqy.springh5;

import java.io.IOException;
public class DependentBean {
    ResourceBean resourceBean;
    public void write(String ss) throws IOException {
        System.out.println("DependentBean:=======写资源");
        resourceBean.getFos().write(ss.getBytes());
    }
    //初始化方法
    public void init() throws IOException {
        System.out.println("DependentBean:=======初始化");
resourceBean.getFos().write("DependentBean:=======初始化=====".getBytes());
    }
    //销毁方法
    public void destroy() throws IOException {
        System.out.println("DependentBean:=======销毁");
        //在销毁之前需要往文件中写销毁内容
        resourceBean.getFos().write("DependentBean:=======销毁=====".getBytes());
    }  

    public void setResourceBean(ResourceBean resourceBean) {
        this.resourceBean = resourceBean;
    }
}  

3.springh5.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans
xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="
http://www.springframework.org/schema/beans        http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/context                http://www.springframework.org/schema/context/spring-context-3.0.xsd">  

    <bean id="resourceBean"
        class="lqy.springh5.ResourceBean"
        init-method="init" destroy-method="destroy">
        <property name="file" value="D:/test.txt"/>
    </bean>
    <bean id="dependentBean"
        class="lqy.springh5.DependentBean"
        init-method="init" destroy-method="destroy" depends-on="resourceBean">
        <property name="resourceBean" ref="resourceBean"/>
    </bean>
</beans>

<property name="file" value="D:/test.txt"/>配置：Spring容器能自动把字符串转换为java.io.File。

init-method="init" ：指定初始化方法，在构造器注入和setter注入完毕后执行。    

destroy-method="destroy"：指定销毁方法，只有“singleton”作用域能销毁，“prototype”作用域的一定不能，其他作用域不一定能；后边再介绍。

在此配置中，resourceBean初始化在dependentBean之前被初始化，resourceBean销毁会在dependentBean销毁之后执行。

测试一下吧：

package lqy.springh5;

import org.springframework.context.support.ClassPathXmlApplicationContext;

public class App5
{
    public static void main( String[] args ) throws Exception
    {
        ClassPathXmlApplicationContext context =  new ClassPathXmlApplicationContext("springh5.xml");
        //一点要注册销毁回调，否则我们定义的销毁方法不执行
        context.registerShutdownHook();
        DependentBean dependentBean =  context.getBean("dependentBean", DependentBean.class);
        dependentBean.write("aaa");  

    }
}

测试跟其他测试完全一样，只是在此我们一定要注册销毁方法回调，否则销毁方法不会执行。

aaarticlea/png;base64,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" alt="" />

test.txt的文本

aaarticlea/png;base64,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" alt="" />

注意：context.registerShutdownHook(); 若注释，则destroy方法不执行，不回调了

---

3.3.3  自动装配

自动装配就是指由Spring来自动地注入依赖对象，无需人工参与。

目前Spring3.0支持“no”、“byName ”、“byType”、“constructor”四种自动装配，默认是“no”指不支持自动装配的，其中Spring3.0已不推荐使用之前版本的 “autodetect”自动装配，推荐使用Java 5+支持的（@Autowired）注解方式代替；如果想支持“autodetect”自动装配，请将schema改为“spring-beans- 2.5.xsd”或去掉。

自动装配的好处是减少构造器注入和setter注入配置，减少配置文件的长度。自动装配通过配置<bean>标签的“autowire”属性来改变自动装配方式。接下来让我们挨着看下配置的含义。

一、default：表示使用默认的自动装配，默认的自动装配需要在<beans>标签中使用default-autowire属性指定，其支持“no”、“byName ”、“byType”、“constructor”四种自动装配，如果需要覆盖默认自动装配，请继续往下看；

       二、no：意思是不支持自动装配，必须明确指定依赖。

       三、byName：通 过设置Bean定义属性autowire="byName"，意思是根据名字进行自动装配，只能用于setter注入。比如我们有方法 “setHelloApi”，则“byName”方式Spring容器将查找名字为helloApi的Bean并注入，如果找不到指定的Bean，将什么 也不注入。

例如如下Bean定义配置：

    <bean id="helloApi" class="cn.javass.spring.chapter2.helloworld.HelloImpl"/>
    <bean id="bean" class="cn.javass.spring.chapter3.bean.HelloApiDecorator"
         autowire="byName"/>  

测试

package cn.javass.spring.chapter3;
import java.io.IOException;
import org.junit.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import cn.javass.spring.chapter2.helloworld.HelloApi;
public class AutowireBeanTest {
   @Test
    public void testAutowireByName() throws IOException {
ClassPathXmlApplicationContext context =
new ClassPathXmlApplicationContext("chapter3/autowire-byName.xml");
        HelloApi helloApi = context.getBean("bean", HelloApi.class);
        helloApi.sayHello();
    }
}  

是不是不要配置<property>了，如果一个bean有很多setter注入，通过“byName”方式是不是能减少很多<property>配置。此处注意了，在根据名字注入时，将把当前Bean自己排除在外：比如“hello”Bean类定义了“setHello”方法，则hello是不能注入到“setHello”的。

四、“byType”：通 过设置Bean定义属性autowire="byType"，意思是指根据类型注入，用于setter注入，比如如果指定自动装配方式为 “byType”，而“setHelloApi”方法需要注入HelloApi类型数据，则Spring容器将查找HelloApi类型数据，如果找到一 个则注入该Bean，如果找不到将什么也不注入，如果找到多个Bean将优先注入<bean>标签“primary”属性为true的 Bean，否则抛出异常来表明有个多个Bean发现但不知道使用哪个。让我们用例子来讲解一下这几种情况吧。

1）根据类型只找到一个Bean，此处注意了，在根据类型注入时，将把当前Bean自己排除在外，即如下配置中helloApi和bean都是HelloApi接口的实现，而“bean”通过类型进行注入“HelloApi”类型数据时自己是排除在外的，配置如下（具体测试请参考AutowireBeanTest.testAutowireByType1方法）：

    <bean class="cn.javass.spring.chapter2.helloworld.HelloImpl"/>
    <bean id="bean" class="cn.javass.spring.chapter3.bean.HelloApiDecorator"
         autowire="byType"/>  

2）根据类型找到多个Bean时，对于集合类型（如List、Set）将注入所有匹配的候选者，而对于其他类型遇到这种情况可能需要使用 “autowire-candidate”属性为false来让指定的Bean放弃作为自动装配的候选者，或使用“primary”属性为true来指定 某个Bean为首选Bean：

2.1）通过设置Bean定义的“autowire-candidate”属性为false来把指定Bean后自动装配候选者中移除：

    <bean class="cn.javass.spring.chapter2.helloworld.HelloImpl"/>
    <!-- 从自动装配候选者中去除 -->
    <bean class="cn.javass.spring.chapter2.helloworld.HelloImpl"
    autowire-candidate="false"/>
    <bean id="bean1" class="cn.javass.spring.chapter3.bean.HelloApiDecorator"
         autowire="byType"/>
       

2.2）通过设置Bean定义的“primary”属性为true来把指定自动装配时候选者中首选Bean：

    <bean class="cn.javass.spring.chapter2.helloworld.HelloImpl"/>
    <!-- 自动装配候选者中的首选Bean-->
    <bean class="cn.javass.spring.chapter2.helloworld.HelloImpl" primary="true"/>
    <bean id="bean" class="cn.javass.spring.chapter3.bean.HelloApiDecorator"
         autowire="byType"/>  

具体测试请参考AutowireBeanTest类的testAutowireByType***方法。

       五、“constructor”：通过设置Bean定义属性autowire="constructor"，功能和“byType”功能一样，根据类型注入构造器参数，只是用于构造器注入方式，直接看例子吧：

    <bean class="cn.javass.spring.chapter2.helloworld.HelloImpl"/>
    <!-- 自动装配候选者中的首选Bean-->
    <bean class="cn.javass.spring.chapter2.helloworld.HelloImpl" primary="true"/>
    <bean id="bean"
         class="cn.javass.spring.chapter3.bean.HelloApiDecorator"
         autowire="constructor"/>  

Test
public void testAutowireByConstructor() throws IOException {
ClassPathXmlApplicationContext context =
 new ClassPathXmlApplicationContext("chapter3/autowire-byConstructor.xml");
HelloApi helloApi = context.getBean("bean", HelloApi.class);
helloApi.sayHello();
}  

 六、autodetect：自动检测是使用“constructor”还是“byType”自动装配方式，已不推荐使用。如果Bean有空构造器那么将采用“byType”自动装配方式，否则使用“constructor”自动装配方式。此处要把3.0的xsd替换为2.5的xsd，否则会报错。

<?xml version="1.0" encoding="UTF-8"?>
<beans  xmlns="http://www.springframework.org/schema/beans"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xmlns:context="http://www.springframework.org/schema/context"
        xsi:schemaLocation="
           http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
           http://www.springframework.org/schema/context
           http://www.springframework.org/schema/context/spring-context-2.5.xsd">
<bean class="cn.javass.spring.chapter2.helloworld.HelloImpl"/>
  <!-- 自动装配候选者中的首选Bean-->
  <bean class="cn.javass.spring.chapter2.helloworld.HelloImpl" primary="true"/>
  <bean id="bean"
        class="cn.javass.spring.chapter3.bean.HelloApiDecorator"
        autowire="autodetect"/>
</beans>  

可以采用在“<beans>”标签中通过“default-autowire”属性指定全局的自动装配方式，即如果default-autowire=”byName”，将对所有Bean进行根据名字进行自动装配。

不是所有类型都能自动装配：

• 不能自动装配的数据类型：Object、基本数据类型（Date、CharSequence、Number、URI、URL、Class、int）等；
• 通过“<beans>”标签default-autowire-candidates属性指定的匹配模式，不匹配的将不能作为自动装配的候选者，例如指定“*Service，*Dao”，将只把匹配这些模式的Bean作为候选者，而不匹配的不会作为候选者；
• 通过将“<bean>”标签的autowire-candidate属性可被设为false，从而该Bean将不会作为依赖注入的候选者。

数组、集合、字典类型的根据类型自动装配和普通类型的自动装配是有区别的：

• 数组类型、集合（Set、Collection、List）接口类型： 将根据泛型获取匹配的所有候选者并注入到数组或集合中，如“List<HelloApi> list”将选择所有的HelloApi类型Bean并注入到list中，而对于集合的具体类型将只选择一个候选者，“如 ArrayList<HelloApi> list”将选择一个类型为ArrayList的Bean注入，而不是选择所有的HelloApi类型Bean进行注入；
• 字典（Map）接口类型：同 样根据泛型信息注入，键必须为String类型的Bean名字，值根据泛型信息获取，如“Map<String, HelloApi> map” 将选择所有的HelloApi类型Bean并注入到map中，而对于具体字典类型如“HashMap<String, HelloApi> map”将只选择类型为HashMap的Bean注入，而不是选择所有的HelloApi类型Bean进行注入。

自动装配我们已经介绍完了，自动装配能带给我们什么好处呢？首先，自动装配确实减少了配置文件的量；其次， “byType”自动装配能在相应的Bean更改了字段类型时自动更新，即修改Bean类不需要修改配置，确实简单了。

自动装配也是有缺点的，最重要的缺点就是没有了配置，在查找注入错误时非常麻烦，还有比如基本类型没法完成自动装配，所以可能经常发生一些莫名其妙的错 误，在此我推荐大家不要使用该方式，最好是指定明确的注入方式，或者采用最新的Java5+注解注入方式。所以大家在使用自动装配时应该考虑自己负责项目 的复杂度来进行衡量是否选择自动装配方式。

自动装配注入方式能和配置注入方式一同工作吗？当然可以，大家只需记住配置注入的数据会覆盖自动装配注入的数据。

大家是否注意到对于采用自动装配方式时如果没找到合适的的Bean时什么也不做，这样在程序中总会莫名其妙的发生一些空指针异常，而且是在程序运行期间才能发现，有没有办法能在提前发现这些错误呢？接下来就让我来看下依赖检查吧。

---

3.3.4  依赖检查

上一节介绍的自动装配，很可能发生没有匹配的Bean进行自动装配，如果此种情况发生，只有在程序运行过程中发生了空指针异常才能发现错误，如果能提前发现该多好啊，这就是依赖检查的作用。

依赖检查：用于检查Bean定义的属性都注入数据了，不管是自动装配的还是配置方式注入的都能检查，如果没有注入数据将报错，从而提前发现注入错误，只检查具有setter方法的属性。

Spring3+也不推荐配置方式依赖检查了，建议采用Java5+ @Required注解方式，测试时请将XML schema降低为2.5版本的，和自动装配中“autodetect”配置方式的xsd一样。

<?xml version="1.0" encoding="UTF-8"?>
<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-2.5.xsd
</beans> 

依赖检查有none、simple、object、all四种方式，接下来让我们详细介绍一下：

       一、none：默认方式，表示不检查；

       二、objects：检查除基本类型外的依赖对象，配置方式为：dependency-check="objects"，此处我们为HelloApiDecorator添加一个String类型属性“message”，来测试如果有简单数据类型的属性为null，也不报错；

<bean id="helloApi" class="cn.javass.spring.chapter2.helloworld.HelloImpl"/>
<!-- 注意我们没有注入helloApi，所以测试时会报错 -->
<bean id="bean"
     class="cn.javass.spring.chapter3.bean.HelloApiDecorator"
     dependency-check="objects">
<property name="message" value="Haha"/>
</bean> 

注意由于我们没有注入bean需要的依赖“helloApi”，所以应该抛出异常UnsatisfiedDependencyException，表示没有发现满足的依赖：

    package cn.javass.spring.chapter3;
    import java.io.IOException;
    import org.junit.Test;
    import org.springframework.beans.factory.UnsatisfiedDependencyException;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    public class DependencyCheckTest {
    @Test(expected = UnsatisfiedDependencyException.class)
    public void testDependencyCheckByObject() throws IOException {
    //将抛出异常
        new ClassPathXmlApplicationContext("chapter3/dependency-check-object.xml");
        }
    }  

三、simple：对基本类型进行依赖检查，包括数组类型，其他依赖不报错；配置方式为：dependency-check="simple"，以下配置中没有注入message属性，所以会抛出异常：

    <bean id="helloApi" class="cn.javass.spring.chapter2.helloworld.HelloImpl"/>
    <!-- 注意我们没有注入message属性，所以测试时会报错 -->
    <bean id="bean"
    class="cn.javass.spring.chapter3.bean.HelloApiDecorator"
         dependency-check="simple">
       <property name="helloApi" ref="helloApi"/>
    </bean>  

四、all：对所以类型进行依赖检查，配置方式为：dependency-check="all"，如下配置方式中如果两个属性其中一个没配置将报错。

    <bean id="helloApi" class="cn.javass.spring.chapter2.helloworld.HelloImpl"/>
    <bean id="bean"
    class="cn.javass.spring.chapter3.bean.HelloApiDecorator"
         dependency-check="all">
      <property name="helloApi" ref="helloApi"/>
    <property name="message" value="Haha"/>
    </bean>  

 依赖检查也可以通过“<beans>”标签中default-dependency-check属性来指定全局依赖检查配置。

---

3.3.5 方法注入

所谓方法注入其实就是通过配置方式覆盖或拦截指定的方法，通常通过代理模式实现。Spring提供两种方法注入：查找方法注入和方法替换注入。

因为Spring是通过CGLIB动态代理方式实现方法注入，也就是通过动态修改类的字节码来实现的，本质就是生成需方法注入的类的子类方式实现。

在进行测试之前，我们需要确保将“com.springsource.cn.sf.cglib-2.2.0.jar”放到lib里并添加到“Java Build Path”中的Libararies中。否则报错，异常中包含“nested exception is java.lang.NoClassDefFoundError: cn/sf/cglib/proxy/CallbackFilter”。

aaarticlea/png;base64,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" alt="" />

传统方式和Spring容器管理方式唯一不同的是不需要我们手动生成子类，而是通过配置方式来实现；其中如果要替换createPrinter()方法的 返回值就使用查找方法注入；如果想完全替换sayHello()方法体就使用方法替换注入。       接下来让我们看看具体实现吧。

一、查找方法注入：又 称为Lookup方法注入，用于注入方法返回结果，也就是说能通过配置方式替换方法返回结果。使用<lookup-method name="方法名" bean="bean名字"/>配置；其中name属性指定方法名，bean属性指定方法需返回的Bean。

方法定义格式：访问级别必须是public或protected，保证能被子类重载，可以是抽象方法，必须有返回值，必须是无参数方法，查找方法的类和被重载的方法必须为非final：

<public|protected> [abstract] <return-type> theMethodName(no-arguments);

因 为“singleton”Bean在容器中只有一个实例，而“prototype”Bean是每次获取容器都返回一个全新的实例，所以如果 “singleton”Bean在使用“prototype” Bean情况时，那么“prototype”Bean由于是“singleton”Bean的一个字段属性，所以获取的这个 “prototype”Bean就和它所在的“singleton”Bean具有同样的生命周期，所以不是我们所期待的结果。因此查找方法注入就是用于解 决这个问题。

1）  首先定义我们需要的类，Printer类是一个有状态的类，counter字段记录访问次数：

    package cn.javass.spring.chapter3.bean;
    public class Printer {
        private int counter = 0;
        public void print(String type) {
            System.out.println(type + " printer: " + counter++);
        }
    }  

HelloImpl5类用于打印欢迎信息，其中包括setter注入和方法注入，此处特别需要注意的是该类是抽象的，充分说明了需要容器对其进行子类化处 理，还定义了一个抽象方法createPrototypePrinter用于创建 “prototype”Bean，createSingletonPrinter方法用于创建“singleton”Bean，此处注意方法会被 Spring拦截，不会执行方法体代码：

    package cn.javass.spring.chapter3;
    import cn.javass.spring.chapter2.helloworld.HelloApi;
    import cn.javass.spring.chapter3.bean.Printer;
    public abstract class HelloImpl5 implements HelloApi {
        private Printer printer;
        public void sayHello() {
            printer.print("setter");
            createPrototypePrinter().print("prototype");
            createSingletonPrinter().print("singleton");
        }
        public abstract Printer createPrototypePrinter();
        public Printer createSingletonPrinter() {
            System.out.println("该方法不会被执行，如果输出就错了");
            return new Printer();
        }
        public void setPrinter(Printer printer) {
            this.printer = printer;
        }
    }  

2）  开始配置了，配置文件在（resources/chapter3/lookupMethodInject.xml），其中 “prototypePrinter”是“prototype”Printer，“singletonPrinter”是 “singleton”Printer，“helloApi1”是“singleton”Bean，而“helloApi2”注入了 “prototype”Bean：

<bean id="prototypePrinter"
class="cn.javass.spring.chapter3.bean.Printer" scope="prototype"/>
<bean id="singletonPrinter"
class="cn.javass.spring.chapter3.bean.Printer" scope="singleton"/>
<bean id="helloApi1" class="cn.javass.spring.chapter3.HelloImpl5" scope="singleton">
<property name="printer" ref="prototypePrinter"/>
<lookup-method name="createPrototypePrinter" bean="prototypePrinter"/>
<lookup-method name="createSingletonPrinter" bean="singletonPrinter"/>
</bean>
<bean id="helloApi2" class="cn.javass.spring.chapter3.HelloImpl5" scope="prototype">
<property name="printer" ref="prototypePrinter"/>
<lookup-method name="createPrototypePrinter" bean="prototypePrinter"/>
<lookup-method name="createSingletonPrinter" bean="singletonPrinter"/>
</bean>  

3）测试代码如下：

    package cn.javass.spring.chapter3;
    import org.junit.Test;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    import cn.javass.spring.chapter2.helloworld.HelloApi;
    public class MethodInjectTest {
    @Test
    public void testLookup() {
    ClassPathXmlApplicationContext context =
    new ClassPathXmlApplicationContext("chapter3/lookupMethodInject.xml");
            System.out.println("=======singleton sayHello======");
            HelloApi helloApi1 = context.getBean("helloApi1", HelloApi.class);
            helloApi1.sayHello();
            helloApi1 = context.getBean("helloApi1", HelloApi.class);
            helloApi1.sayHello();
            System.out.println("=======prototype sayHello======");
            HelloApi helloApi2 = context.getBean("helloApi2", HelloApi.class);
            helloApi2.sayHello();
            helloApi2 = context.getBean("helloApi2", HelloApi.class);
            helloApi2.sayHello();
    }}  

其中“helloApi1”测试中，其输出结果如下：

=======singleton sayHello======
setter printer: 0
prototype printer: 0
singleton printer: 0
setter printer: 1
prototype printer: 0
singleton printer: 1 

首 先“helloApi1”是“singleton”，通过setter注入的“printer”是“prototypePrinter”，所以它应该输出 “setter printer:0”和“setter printer:1”；而“createPrototypePrinter”方法注入了“prototypePrinter”，所以应该输出两次 “prototype printer:0”；而“createSingletonPrinter”注入了“singletonPrinter”，所以应该输出 “singleton printer:0”和“singleton printer:1”。

而“helloApi2”测试中，其输出结果如下：

=======prototype sayHello======
setter printer: 0
prototype printer: 0
singleton printer: 2
setter printer: 0
prototype printer: 0
singleton printer: 3  

首 先“helloApi2”是“prototype”，通过setter注入的“printer”是“prototypePrinter”，所以它应该输出 两次“setter printer:0”；而“createPrototypePrinter”方法注入了“prototypePrinter”，所以应该输出两次 “prototype printer:0”；而“createSingletonPrinter”注入了“singletonPrinter”，所以应该输出 “singleton printer:2”和“singleton printer:3”。

大家是否注意到“createSingletonPrinter”方法应该输出“该方法不会被执行，如果输出就错了”，而实际是没输出的，这说明Spring拦截了该方法并使用注入的Bean替换了返回结果。

方法注入主要用于处理“singleton”作用域的Bean需要其他作用域的Bean时，采用Spring查找方法注入方式无需修改任何代码即能获取需要的其他作用域的Bean。

二、替换方法注入：也叫“MethodReplacer”注入，和查找注入方法不一样的是，他主要用来替换方法体。通过首先定义一个MethodReplacer接口实现，然后如下配置来实现：

<replaced-method name="方法名" replacer="MethodReplacer实现">
<arg-type>参数类型</arg-type>
</replaced-method>”  

1）首先定义MethodReplacer实现，完全替换掉被替换方法的方法体及返回值，其中reimplement方法重定义方法 功能，参数obj为被替换方法的对象，method为被替换方法，args为方法参数；最需要注意的是不能再 通过“method.invoke(obj, new String[]{"hehe"});” 反射形式再去调用原来方法，这样会产生循环调用；如果返回值类型为Void，请在实现中返回null：

    package cn.javass.spring.chapter3.bean;
    import java.lang.reflect.Method;
    import org.springframework.beans.factory.support.MethodReplacer;
    public class PrinterReplacer implements MethodReplacer {
        @Override
        public Object reimplement(Object obj, Method method, Object[] args)   throws Throwable {
            System.out.println("Print Replacer");
            //注意此处不能再通过反射调用了,否则会产生循环调用，知道内存溢出
            //method.invoke(obj, new String[]{"hehe"});
            return null;
        }
    }  

2）配置如下，首先定义MethodReplacer实现，使用< replaced-method >标签来指定要进行替换方法，属性name指定替换的方法名字，replacer指定该方法的重新实现者，子标签< arg-type >用来指定原来方法参数的类型，必须指定否则找不到原方法：

    <bean id="replacer" class="cn.javass.spring.chapter3.bean.PrinterReplacer"/>
    <bean id="printer" class="cn.javass.spring.chapter3.bean.Printer">
    <replaced-method name="print" replacer="replacer">
            <arg-type>java.lang.String</arg-type>
        </replaced-method>
    </bean>
       

3）测试代码将输出“Print Replacer ”，说明方法体确实被替换了：

    @Test
    public void testMethodReplacer() {
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("chapter3/methodReplacerInject.xml");
        Printer printer = context.getBean("printer", Printer.class);
        printer.print("我将被替换");
    }