转载自 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()); }
大家看到了,方法被替换了,演员也换了,角色也换了。侵入性很强!所以一般不使用方法替换,只是使用第一种,Lookup注入。