package reflection.example;

public interface Speakable {
    void sayEnglish();

    void sayChinese();
}

package reflection.example;

public class Translater implements Speakable {

    public void sayEnglish() {
        System.out.println("Hello,i am robbie");

    }

    public void sayChinese() {
        System.out.println("你好，我是饺子");

    }

}

package reflection.example;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

public class LoggingInvoktionHandler implements InvocationHandler {
    private Object target = null;

    public LoggingInvoktionHandler(Object target) {
        this.target = target;
    }

    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        logging(method);
        return method.invoke(target, args);
    }

    private void logging(Method method) {
        if ("sayChinese".equals(method.getName())) {
            System.out.println("翻译开始");
        }

        if ("sayEnglish".equals(method.getName())) {
            System.out.println("Tranlation beginning");
        }
    }

}

这个LoggingInvocationHandler实现了InvocationHandler接中。方法的代理调用在invoke(……)中，可以如我添加logging()功能一样，加入其它的任何想要的功能，然后再进行 real target的方法调用。

如果将logging(Method method)中的逻辑抽出来，放到外部文件(XML)中进行配置读取。再对方法名采用正则表达式。是不是更为通用了呢？

下面是客户端调用：

package reflection.example;

import java.lang.reflect.Proxy;

public class Main {

    /**//**
     * @param args
     */
    public static void main(String[] args) {
        Speakable speaker = new Translater();

        Speakable loggingSpeaker = (Speakable) Proxy.newProxyInstance(
                speaker.getClass().getClassLoader(),
                new Class[] { Speakable.class },
                new LoggingInvoktionHandler(speaker));

        loggingSpeaker.sayChinese();
        loggingSpeaker.sayEnglish();
    }
}

是不是非常简单呢？：)

如果到此为止，还是看不出Dynamic在哪儿的，想想我这儿给出的示例与spring的AOP的不同，呵呵，区别在于我这儿给出的Main亦是spring AOP的一部分，在spring里， 对某个Interface的target的代理，采用了Reflection，以达到普遍适用的，不用象我这样直接显式地给出类名而已。若我把Main做成一个Helper类，同时，把配置接口及他的实现类都放到外部XML中配置，是不是就有点象一个超级简化的spring AOP了？

当然spring不是完全用Java Dynamic Proxy的，因为Java Dynamic Proxy的前提——针对接口编程！，针对普通的类的AOP，Spring采用了字节码增强来实现。