方法注入在是为了实现在单例类中取得不同的实例类对象。
当一个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注入。
