方法注入主要是用在Singleton的Object中使用非Singleton的Bean时，通过lookup-method的那个方法来取得非Singleton的Bean。一般用的不多，在用这种定义之前最好想明白你的需求。
1 使用Java代码实现方法注入
1.1 用法示例
// a class that uses a stateful Command-style class to perform some processing
package fiona.apple;
// Spring-API imports
import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
public class CommandManager implements ApplicationContextAware {
private ApplicationContext applicationContext;
public Object process(Map commandState) {
// grab a new instance of the appropriate Command
Command command = createCommand();
// set the state on the (hopefully brand new) Command instance
command.setState(commandState);
return command.execute();
}
protected Command createCommand() {
// notice the Spring API dependency!
return this.applicationContext.getBean("command", Command.class);
}
public void setApplicationContext(
ApplicationContext applicationContext) throws BeansException {
this.applicationContext = applicationContext;
}
}上面的例子并没有达到期望的效果，因为业务代码和Spring框架产生的耦合。方法注入，作为Spring Ioc容器的高级特性，可以以一种 干净的方法来处理这种情况。
1.2 代码示例
1.2.1 准备Bean
package com.ws.edu.spring;
public class Game {
}
package com.ws.edu.spring;
import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
public class Person implements ApplicationContextAware{
private ApplicationContext applicationContext;
@Override
public void setApplicationContext(ApplicationContext applicationContext)
throws BeansException {
this.applicationContext = applicationContext;
}
private Game createGame(){
return applicationContext.getBean(Game.class);
}
public void playGame(){
Game game = this.createGame();
System.out.println("playing game:"+game);
}
}
1.2.2 配置XML
1.2.3 配置启动类
package com.ws.edu.spring;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class App {
@SuppressWarnings("resource")
public static void main(String[] args) {
ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
Person person = context.getBean(Person.class);
person.playGame();
}
}
1.2.4 输出结果
2 使用Lookup实现方法注入
Lookup方法注入的内部机制是Spring利用了CGLIB库在运行时生成二进制代码的功能，通过动态创建Lookup方法bean的子类从而达到复写Lookup方法的目的。
为了使动态子类起作用，Spring容器要子类化的类不能是
final，并且需要复写的方法也不能是final。同样的，要测试一个包含抽象方法的类也稍微有些不同，你需要子集编写它的子类提供该抽象方法的实现。最后，作为方法注入目标的bean不能是序列化的。 在Spring 3.2之后再也没必要添加CGLIB到classpath，因为CGLIB的类打包在了org.springframework下并且在Spring核心JAR中有所描述。 这样做既方便，又避免了与其他使用了不同版本CGLIB的项目的冲突。
2.1 用法示例
package fiona.apple;
// no more Spring imports!
public abstract class CommandManager {
public Object process(Object commandState) {
// grab a new instance of the appropriate Command interface
Command command = createCommand();
// set the state on the (hopefully brand new) Command instance
command.setState(commandState);
return command.execute();
}
// okay... but where is the implementation of this method?
protected abstract Command createCommand();
} 在包含被注入方法的客户类中（这个例子中是CommandManager），此方法的定义需要按以下形式进行：
[abstract] theMethodName(no-arguments); public|protected要求方法必须是可以被子类重写和调用的；
abstract可选，如果是抽象方法，CGLIB的动态代理类就会实现这个方法，如果不是抽象方法，就会覆盖这个方法，所以没什么影响；
return-type就是non-singleton-bean的类型咯，当然可以是它的父类或者接口。
no-arguments不允许有参数。
如果方法是抽象，动态生成的子类会实现该方法。沟则，动态生成的子类会覆盖类里的具体方法。譬如：
标识为commandManager的bean在需要一个新的command bean实例时会调用createCommand()方法。你必须将`command`bean部署为 原型（prototype）类型，如果这是实际需要的话。如果部署为singleton。那么每次将返回相同的 `command`bean。
2.2 代码示例
2.2.1 准备Bean
package com.ws.edu.spring;
public class Game {
}
package com.ws.edu.spring;
public class Person{
public Game createGame(){
return null;
}
public void playGame(){
Game game = this.createGame();
System.out.println("playing game:"+game);
}
}
2.2.2 配置Xml
2.2.3 编写启动类
package com.ws.edu.spring;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class App {
@SuppressWarnings("resource")
public static void main(String[] args) {
ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
Person person = context.getBean(Person.class);
person.playGame();
}
}
2.2.4 输出结果
3 自定义方法的替代方案
3.1 用法示例
使用基于XML配置文件时，你可以使用replaced-method元素来达到用另一个方法来取代已有方法的目的。考虑下面的类，我们将覆盖 computeValue方法。
public class MyValueCalculator {
public String computeValue(String input) {
// some real code...
}
// some other methods...
} 实现org.springframework.beans.factory.support.MethodReplacer接口的类提供了新的方法定义。
/**
* meant to be used to override the existing computeValue(String)
* implementation in MyValueCalculator
*/
public class ReplacementComputeValue implements MethodReplacer {
public Object reimplement(Object o, Method m, Object[] args) throws Throwable {
// get the input value, work with it, and return a computed result
String input = (String) args[0];
...
return ...;
}
}下面的bean定义中指定了要配置的原始类和将要复写的方法：
String
你可以在java.lang.String：
java.lang.String String Str
因为参数的数目通常足够用来区别每个可能的选择，这个结晶能减少很多键盘输入的工作，它允许你只输入最短的匹配参数类型的字符串。
3.2 代码示例
3.2.1 准备Bean
package com.ws.edu.spring;
import java.lang.reflect.Method;
import org.springframework.beans.factory.support.MethodReplacer;
public class Game implements MethodReplacer{
@Override
public Object reimplement(Object obj, Method method, Object[] args)
throws Throwable {
String gameName = (String)args[0];
System.out.println("playing game:" + gameName);
return null;
}
}
package com.ws.edu.spring;
public class Person{
public void playGame(String gameName){}
}
3.2.2 配置xml
String
3.2.3 编写启动类
package com.ws.edu.spring;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class App {
@SuppressWarnings("resource")
public static void main(String[] args) {
ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
Person person = context.getBean(Person.class);
person.playGame("篮球");
}
}
3.2.4 输出结果
