为什么要有方法注入：

假设有一个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：还没看懂，提供给想了解的小伙伴

方法替换

写不下去了啊！OMG

这个是利用自己的方法去替换另一个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());
}

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

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