为什么要有方法注入：
假设有一个Bean 依赖于另一个Bean，两个的生命周期却不一样的时候，光靠配置和注解不能很好地解决。
如：一个单例的Bean A和一个非单例的bean B, A 依赖 B，每次容器只会初始化一次 A，B却每次都需要重新创建，当 B成为A的属性时，A内的B就无法每次重新创建，这样要么放弃控制反转，要么得想新办法解决这个问题。
所以，Spring 通过方法注入，来实现动态改变A内的B，注入利用了容器的覆盖受容器管理的bean方法的能力，从而返回指定名字的bean实例。
介绍两个方法注入的方式，分别是查找注入，和方法替换
查找注入
Spring的方法注入依赖于CGLIB，需要添加Jar包com.springsource.cn.sf.cglib-2.2.0.jar，Spring通过CGLib动态修改字节码，所以可以用配置方式，使用代理覆盖或拦截指定的方法动态生成子类，可分为查找方法注入和替换方法注入。
用于注入方法返回结果，也就是说能通过配置方式替换方法返回结果。
CGLib，一个操作字节码的库，玩的溜的话是不是可以写动态病毒？
查找注入的方法必须符合下面的规则
- 必须有返回值
- 可以是抽象的，但必须是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对象一直是单例的，没有变化。
坑：class字节码的组成，ps：还没看懂，提供给想了解的小伙伴
方法替换
这个是利用自己的方法去替换另一个bean的方法，适用场景未知，目前没用过。
我们尝试玩一下，用明星来演电影，把配角换成主角。还是用到了上面的BuityPeople类
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());
}
大家看到了，方法被替换了，演员也换了，角色也换了。侵入性很强！所以一般不使用方法替换，只是使用第一种，查找注入。
