JDK的动态(静态)代理机制(转载并整理修改)

动态代理代码如下:

package proxy.myproxy.dynamicProxy;public interface UserDao {    void save();}

package proxy.myproxy.dynamicProxy;public class UserDaoImpl implements UserDao {    public void save() {        System.out.println("UserDao save()");    }}

package proxy.myproxy.dynamicProxy;import java.lang.reflect.InvocationHandler;import java.lang.reflect.Method;public class InvocationHandlerImpl implements InvocationHandler {            //表明被代理对象    private Object target;        public InvocationHandlerImpl(Object target){        this.target = target;    }        public Object invoke(Object proxy, Method method, Object[] args)//args是那个你执行的那个方法的参数            throws Throwable {　　     System.out.println(proxy.getClass());//这里输出:class $Proxy0,可以看出proxy是什么        System.out.println(target.getClass());//这里输出:class proxy.myproxy.dynamicProxy.UserDaoImpl,可以看出target是什么        System.out.println("开始记录日志");               //调用被代理对象的对应方法        Object obj = method.invoke(target, args);//obj是方法执行完之后的返回值        System.out.println("结束记录日志");        return obj;    }}

package proxy.myproxy.dynamicProxy;import java.lang.reflect.Proxy;public class Test {    public static void main(String[] args) {        UserDao userDao = new UserDaoImpl();        //产生代理对象，采用组合方式，因此代理对象与被代理对象须实现相同接口        UserDao userDaoProxy = (UserDao) Proxy.newProxyInstance(userDao.getClass().getClassLoader(), userDao.getClass().getInterfaces(), new InvocationHandlerImpl(userDao));       //方法调用时都会将自身传递给InvocationHandler，顺带将代理对象与参数一并传过来，       //使用invoke(Object proxy, Method method, Object[] args)方法        userDaoProxy.save();            }}

解释：

1.     Proxy即动态代理类；

2.     Static Object newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h)：返回代理类的一个实例，返回后的代理类可以当作被代理类使用；

它有三个参数：

ClassLoader loader    ----指定被代理对象的类加载器，我们产生的代理对象中实际上包含了被代理对象

Class[] Interfaces    ----指定被代理对象所以事项的接口

InvocationHandler h  ----指定需要调用的InvocationHandler对象

3.     实现InVocationHandler接口的InvocationHandlerImpl对象

这个对象的invoke()方法就是Proxy这个动态代理类所代理的接口类的抽象方法的真实实现；

它有三个参数：

Object proxy          -----代理类对象

Method method         -----被代理对象的方法（这里不是接口的抽象方法了，是具体的实现类中的方法）

Object[] args         -----该方法的参数数组

userDaoProxy.save();的实现可以这样理解：

/*class $Proxy0  * { *   //上边的方法写是无参的，这个是有参 *   save(User u){ *   Method m = UserDAO.getclass.getmethod  *   li.invoke(this,m,u); *   } * } */

JDK中具体的动态代理类是怎么产生的呢？

1.产生代理类$Proxy0类

执行了Proxy.newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h)

将产生$Proxy0类，它继承Proxy对象，并根据第二个参数，实现了被代理类的所有接口，自然就可以生成接口要实现的所有方法了（这时候会重写hashcode，toString和equals三个方法），但是还没有具体的实现体；

2.    将代理类$Proxy0类加载到JVM中

这时候是根据Proxy.newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h)它的第一个参数----就是被代理类的类加载器，把当前的代理类加载到JVM中

3.    创建代理类$Proxy0类的对象

调用的$Proxy0类的$Proxy0（InvocationHandler）构造函数，生成$Proxy0类的对象

参数就是Proxy.newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h)它的第三个参数

这个参数就是我们自己实现的InvocationHandler对象，我们知道InvocationHandler对象中组合加入了代理类代理的接口类的实现类；所以，$Proxy0对象调用所有要实现的接口的方法，都会调用InvocationHandler对象的invoke（）方法实现；

4.    生成代理类的class byte

动态代理生成的都是二进制class字节码

静态代理代码如下：

package proxy.myproxy.staticProxy;public interface UserDao {    void save();}

package proxy.myproxy.staticProxy;public class UserDaoImpl implements UserDao {    public void save() {        System.out.println("UserDao save()");    }}

package proxy.myproxy.staticProxy;public class UserDaoImplProxy implements UserDao {        private UserDao userDao = new UserDaoImpl();//合成   也可以传个引用过来                public void save() {                System.out.println("开始记录日志。。。");                userDao.save();                System.out.println("结束记录日志。。。。");            }}

package proxy.myproxy.staticProxy;public class Test {    public static void main(String[] args) {        UserDao userDao =  new UserDaoImplProxy();        System.out.println("test123");        userDao.save();         }}

参考：http://www.cnblogs.com/fuckqq/archive/2012/10/04/jdk_proxy.html

&&  http://hi.baidu.com/wolf55/item/7f39971451f9ed4ee75e068f