《Spring》（七）---- 方法注入

转载自 http://www.jianshu.com/p/e27df48a6c7c & http://www.kancloud.cn/evankaka/springlearning/119663

　　方法注入在是为了实现在单例类中取得不同的实例类对象。

当一个Bean依赖的Bean和自己生命周期不同的时候:如Bean A依赖Bean B,Bean A 是singleton,如果需要在Bean A每次用到Bean B的时候都用一个Bean B的新的实例（注意是新的）,即使通过在配置文件设置Bean B的 property或者 contructor-arg是不能实现的.这时候只能在Bean A中用Bean B的时候动态得到。

或者可以这么说，调用一个singleton类型bean A的某个方法时，需要引用另一个非singleton（prototype）类型的bean B，对于bean A来说，容器只会创建一次，这样就没法在需要的时候每次让容器为bean A提供一个新的的bean B实例。幸运的是，Spring提供了如下三种解决的方案：

　　1 放弃控制反转：通过实现ApplicationContextAware接口让bean A能够感知bean 容器，并且在需要的时候通过使用getBean("B")方式向容器请求一个新的bean B实例。　　

　　2 Lookup方法注入：Lookup方法注入利用了容器的覆盖受容器管理的bean方法的能力，从而返回指定名字的bean实例。

　　3 自定义方法的替代方案：该注入能使用bean的另一个方法实现去替换自定义的方法

　　放弃控制反转的方法比较不方便，一般都不会这么做，下面介绍一下lookup方法和replace方法吧！

　　1. Lookup方法注入

注入的方法必须符合下面的规则

必须有返回值
可以是抽象的，但必须是public或protected修饰可以被子类访问的
必须是无参的
不能是final修饰的

适用情况
Bean是有生命周期的，方法注入是为了使方法独立于Bean。
比如一个单例（singleton）的Bean，依赖了一个非单例的（prototype）普通Bean，当单例模式的Bean被销毁时，会导致这个普通Bean也会销毁，为了解决，可以使不被销毁，使用方法注入。

看个例子

一个bean,非单例模式的

package com.zing.method_injection;
/**
 * Created by zing on 16/5/18.
 */
public class BuityPeople {
    private static int ID = 0;
    private String name;
    private String cast;
    public BuityPeople() {
        ID++;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name + ID;
    }
    public String getCast() {
        return cast;
    }
    public void setCast(String cast) {
        this.cast = cast + ID;
    }
    @Override
    public String toString() {
        return "BuityPeople{" +
                "name='" + name + '\'' +
                ", cast='" + cast + '\'' +
                '}';
    }
}

另一个bean，单例模式的

package com.zing.method_injection;
/**
 * Created by zing on 16/5/18.
 */
public interface Movie {
    public BuityPeople getActor();
}

现在是Movie依赖BuityPeople,
写好配置，这里p 需要加头

<bean id="buityPeople" class="com.zing.method_injection.BuityPeople" 
    p:name="群演"      p:cast="路人"      scope="prototype"></bean>
<bean id="movie" class="com.zing.method_injection.Movie" scope="singleton">
    <lookup-method name="getActor" bean="buityPeople"></lookup-method>
</bean>

这样方法注入的例子就配置好了，我们写一段代码，测试一下

public class TestLookupMethod {
    @Test
    public void getMovieStar() {
        ApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml");
        Movie movie = context.getBean("movie", Movie.class);
        BuityPeople p1 = movie.getActor();
        BuityPeople p2 = movie.getActor();
        System.out.println(p1.toString());
        System.out.println(p2.toString());
    }
}

测试结果

看出来演员是两个不同的人，但是Movie对象一直是单例的，没有变化。

　　2. 方法替换

package com.zing.method_injection;
/**
 * Created by zing on 16/5/18.
 */
public class MovieStar {
    private BuityPeople getActor() {
        BuityPeople p = new BuityPeople();
        p.setName("普通明星");
        p.setCast("配角");
        return p;
    }
}

package com.zing.method_injection;
/**
 * Created by zing on 16/5/18.
 */
//一定要实现MethodReplacer接口
public class  SuperStar implements MethodReplacer{
    @Override
    public Object reimplement(Object o, Method method, Object[] objects) throws Throwable {
        BuityPeople p = new BuityPeople();
        p.setName("超级明星");
        p.setCast("主角");
        return p;
    }
}

添加配置

<bean id="movieStar" class="com.zing.method_injection.MovieStar">
    <replaced-method name="getActor" replacer="superStarMovie"></replaced-method>
</bean>
<bean id="superStarMovie" class="com.zing.method_injection.SuperStar"></bean>

配置完成写一段代码测试一下

@Test
public void goodMovieStar() {
    ApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml");
    System.out.println("测试前的演员————————————————————————");
    MovieStar movieStar1 = new MovieStar();
    System.out.println(movieStar1.getActor().toString());
    System.out.println("测试后的演员————————————————————————");
    MovieStar movieStar2 = context.getBean("movieStar", MovieStar.class);
    System.out.println(movieStar2.getActor().toString());
}

测试结果，getActor()被SuperStarMovie内的方法替换了

大家看到了，方法被替换了，演员也换了，角色也换了。侵入性很强！所以一般不使用方法替换，只是使用第一种，Lookup注入。

《Spring》（七）---- 方法注入

推荐阅读