JDK实现动态代理的例子-proxy

JDK实现动态代理的例子-proxy

给出个JDK实现动态代理的例子。

/**
* Created by IntelliJ IDEA.<br>
* <b>User</b>: leizhimin<br>
* <b>Date</b>: 2008-5-9 14:16:18<br>
* <b>Note</b>: 目标抽象接口
*/
public interface ITarget {
    public void doSomething();
}

/**
* Created by IntelliJ IDEA.<br>
* <b>User</b>: leizhimin<br>
* <b>Date</b>: 2008-5-9 14:17:03<br>
* <b>Note</b>: 目标类
*/
public class Target implements ITarget {

    public void doSomething() {
        System.out.println(">>>正在调用Targer.doSomething()方法！");
    }
}

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

/**
* Created by IntelliJ IDEA.<br>
* <b>User</b>: leizhimin<br>
* <b>Date</b>: 2008-5-9 14:23:07<br>
* <b>Note</b>: 代理处理器实现
*/
public class MyInvocationHandler implements InvocationHandler {
    private Target target;

    public MyInvocationHandler(Object obj) {
        target = (Target) obj;
    }

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println(">>>代理处理器start...");
        Object result = method.invoke(target, args);
        System.out.println(">>>代理处理器end...");
        return result;
    }
}


import java.lang.reflect.Proxy;

/**
* Created by IntelliJ IDEA.<br>
* <b>User</b>: leizhimin<br>
* <b>Date</b>: 2008-5-9 14:27:20<br>
* <b>Note</b>: 客户端
*/
public class Test {
    public static void main(String args[]) {
        //创建目标对象
        Target target = new Target();
        //创建代理实例调用处理程序（相当于SpringAOP中切面）
        MyInvocationHandler myInvocationHandler = new MyInvocationHandler(target);
        //通过Proxy生成一个代理对象obj，obj可以宣称实现了目标对象所实现的接口ITarget
        ITarget proxyTarget = (ITarget) Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), myInvocationHandler);
        //从代理对象上调用目标对象的方法
        proxyTarget.doSomething();
    }
}

运行结果：
>>>代理处理器start...
>>>正在调用Targer.doSomething()方法！
>>>代理处理器end...

Process finished with exit code 0



不明白点：
1）红色结果部分，是何时，什么流程调用的？
2）method.invoke的作用？
3）动态代理的原理是什么？


---------------------------------
以下内容，可以解决疑惑点：
---------------------------------

1、普通代理的原理：
一个接口类、接口实现类、以及代理类。
代理类和类相同接口，并实现于接口类，在代理类中封装具体实现类。
具体的作用： 可以对某个方法增加功能，却不改动实现类代码。
原理图，如下附件一：


2、动态代理的原理：
动态代理和普通的代理模式的区别，就是动态代理中的代理类是由java.lang.reflect.Proxy类在运行期时根据接口定义，采用Java反射功能动态生成的。和java.lang.reflect.InvocationHandler结合，可以加强现有类的方法实现。如图2，图中的自定义Handler实现InvocationHandler接口，自定义Handler实例化时，将实现类传入自定义Handler对象。自定义Handler需要实现invoke方法，该方法可以使用Java反射调用实现类的实现的方法，同时当然可以实现其他功能，例如在调用实现类方法前后加入Log。而Proxy类根据Handler和需要代理的接口动态生成一个接口实现类的对象。当用户调用这个动态生成的实现类时，实际上是调用了自定义Handler的invoke方法。

原理图：附件2