代理模式是常用的java设计模式，他的特征是代理类与委托类有同样的接口。

代理类主要负责为委托类预处理消息、过滤消息、把消息转发给委托类，以及事后处理消息等。

代理类与委托类之间通常会存在关联关系，一个代理类的对象与一个委托类的对象关联，代理类的对象本身并不真正实现服务，而是通过调用委托类的对象的相关方法，来提供特定的服务。

按照代理的创建时期，代理类可以分为两种。
静态代理：由程序员创建或特定工具自动生成源代码，再对其编译。在程序运行前，代理类的.class文件就已经存在了。
动态代理：在程序运行时，运用反射机制动态创建而成。

一、动态代理

1、样例一：

接口Book

package org.ccnt.learn.dynamicproxy;

public interface Book {
    
    public void addBook();
    
}

BookImpl实现类

package org.ccnt.learn.dynamicproxy;

public class BookImpl implements Book {

    @Override
    public void addBook() {
        System.out.println("add books");
    }
}

动态代理的handler：DynamicProxyHandler类

package org.ccnt.learn.dynamicproxy;

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

public class DynamicProxyHandler implements InvocationHandler {
    
    private Object target;
    
    public DynamicProxyHandler(Object target) {
        this.target = target;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        System.out.println("before invoke");
        Object result = method.invoke(target, args);
        System.out.println("after invoke");
        return result;
    }

}

测试main

package org.ccnt.learn.dynamicproxy;

import java.lang.reflect.Proxy;

public class App2 {
    
    public static Object getProxy(Object target) {
        return Proxy.newProxyInstance(target.getClass().getClassLoader(),
                target.getClass().getInterfaces(),
                new DynamicProxyHandler(target));
    }

    public static void main(String[] args) {
        Book proxy = (Book)getProxy(new BookImpl());
        proxy.addBook();
    }
}

说明：

InvocationHandler接口：

public interface InvocationHandler { 
　　public Object invoke(Object proxy,Method method,Object[] args) throws Throwable; 
}

参数说明：
Object proxy：指被代理的对象。
Method method：要调用的方法
Object[] args：方法调用时所需要的参数

Proxy类：
Proxy类是专门完成代理的操作类，可以通过此类为一个或多个接口动态地生成实现类，此类提供了如下的操作方法：

public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) 
　　　　throws IllegalArgumentException

参数说明：
ClassLoader loader：类加载器，用于创建类（会创建一个类$Proxy0）
Class<?>[] interfaces：被代理的类实现的全部的接口（创建类$Proxy0需要给类添加方法，就是从这些接口得知需要添加哪些方法。）

　　这也是为什么java原生的动态代理是基于接口的。而不能基于类。

InvocationHandler h：InvocationHandler接口的子类实例的invoke方法具体完成了需要代理类做的额外的事情（相对于原始类的方法）。

类加载器
在Proxy类中的newProxyInstance（）方法中需要一个ClassLoader类的实例，ClassLoader实际上对应的是类加载器，在Java中主要有一下三种类加载器;
Booststrap ClassLoader：此加载器采用C++编写，一般开发中是看不到的；
Extendsion ClassLoader：用来进行扩展类的加载，一般对应的是jrelibext目录中的类;
AppClassLoader：(默认)加载classpath指定的类，是最常使用的是一种加载器。

2、样例二，深入理解，生成怎样一个代理类$Proxy0

相关类及其方法:

java.lang.reflect.Proxy,
Proxy 提供用于创建动态代理类和实例的静态方法.
newProxyInstance()
返回一个指定接口的代理类实例，该接口可以将方法调用指派到指定的调用处理程序

被代理对象的接口及实现类:

package com.ml.test;
public interface Manager {
　　public void modify();
　　}
}
package com.ml.test;
public class ManagerImpl implements Manager {
　　@Override
　　public void modify() {
   　　System.out.println("*******modify()方法被调用");
　　}
}

业务代理类:

package com.ml.test;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
public class BusinessHandler implements InvocationHandler {
　　private Object object = null;
　　public BusinessHandler(Object object) {
   　　this.object = object;
　　}
　　@Override
　　public Object invoke(Object proxy, Method method, Object[] args)
   　　 throws Throwable {
   　　System.out.println("do something before method");
   　　Object ret = method.invoke(this.object, args);
   　　System.out.println("do something after method");
   　　return ret;
　　}
}

客户端类:

package com.ml.test;
import java.lang.reflect.Proxy;
public class Client {
public static void main(String[] args) {
   // 元对象(被代理对象)
   ManagerImpl managerImpl = new ManagerImpl();
   // 业务代理类
   BusinessHandler securityHandler = new BusinessHandler(managerImpl);
   // 获得代理类($Proxy0 extends Proxy implements Manager)的实例.
   Manager managerProxy = (Manager) Proxy.newProxyInstance(managerImpl
     .getClass().getClassLoader(), managerImpl.getClass()
     .getInterfaces(), securityHandler);
   managerProxy.modify();
}
}

执行结果:
do something before method
*******modify()方法被调用
do something after method

机制分析:

Proxy.(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)做了以下几件事.
(1)根据参数loader和interfaces调用方法 getProxyClass(loader, interfaces)创建代理类$Proxy0.
　　$Proxy0类实现了interfaces的接口,并继承了Proxy类.
(2)实例化$Proxy0并在构造方法中把BusinessHandler传过去,接着$Proxy0调用父类Proxy的构造器,为h赋值,如下:

class Proxy{
   InvocationHandler h=null;
   protected Proxy(InvocationHandler h) {
    this.h = h;
   }
   ...
}

$Proxy0类：

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

public final class $Proxy0 extends Proxy implements Manager {

    private static Method m1;
    private static Method m0;
    private static Method m3;
    private static Method m2;

    static {
       try {
        m1 = Class.forName("java.lang.Object").getMethod("equals",
          new Class[] { Class.forName("java.lang.Object") });
        m0 = Class.forName("java.lang.Object").getMethod("hashCode",
          new Class[0]);
        m3 = Class.forName("com.ml.test.Manager").getMethod("modify",
          new Class[0]);
        m2 = Class.forName("java.lang.Object").getMethod("toString",
          new Class[0]);
       } catch (NoSuchMethodException nosuchmethodexception) {
        throw new NoSuchMethodError(nosuchmethodexception.getMessage());
       } catch (ClassNotFoundException classnotfoundexception) {
        throw new NoClassDefFoundError(classnotfoundexception.getMessage());
       }
    }

    public $Proxy0(InvocationHandler invocationhandler) {
       super(invocationhandler);
    }
    @Override
    public final boolean equals(Object obj) {
       try {
        return ((Boolean) super.h.invoke(this, m1, new Object[] { obj }))
          .booleanValue();
       } catch (Throwable throwable) {
        throw new UndeclaredThrowableException(throwable);
       }
    }
    @Override
    public final int hashCode() {
       try {
        return ((Integer) super.h.invoke(this, m0, null)).intValue();
       } catch (Throwable throwable) {
        throw new UndeclaredThrowableException(throwable);
       }
    }
    public final void modify() {
       try {
        super.h.invoke(this, m3, null);
        return;
       } catch (Error e) {
       } catch (Throwable throwable) {
        throw new UndeclaredThrowableException(throwable);
       }
    }
    @Override
    public final String toString() {
       try {
        return (String) super.h.invoke(this, m2, null);
       } catch (Throwable throwable) {
        throw new UndeclaredThrowableException(throwable);
       }
    }
}

接着把得到的$Proxy0实例强制转换成Manager.
当执行managerProxy.modify()方法时,就调用了$Proxy0类中的modify()方法.
在modify方法中,调用父类Proxy中的h的invoke()方法.
即InvocationHandler.invoke();

3、样例三：

/**
 * 相亲接口
 * 
 * @author zhengt
 * @time Jun 3, 2095 3:13:03 PM
 */
public interface XiangQinInterface {
    /**
     * 相亲方法
     */
    public void xiangQin();
}
/**
 * 张三相亲实现类
 * 
 * @author zhengt
 * @time Jun 3, 2095 3:14:48 PM
 */
public class ZhangSanXiangQinInterfaceImpl implements XiangQinInterface {
    public void xiangQin() {
        System.out.println("张三去相亲，娶个漂亮老婆。");
    }
}
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

/**
 * 相亲可是一辈子的大事，相亲前要准备一下，打扮得帅气些。
 * 
 * @author zhengt
 * @time Jun 3, 2095 3:15:48 PM
 */
public class ReadyInvocationHandler implements InvocationHandler {
    //相亲接口的实现类，也就是张三相亲类
    private Object zhangSan = null;

    public ReadyInvocationHandler(Object realSubject) {
        this.zhangSan = realSubject;
    }

    public Object invoke(Object proxy, Method m, Object[] args) {
        Object result = null;
        try {
            /**
             * 动态代理类$Proxy0调用xiangQin方法时会调用它自己的xiangQin方法，
             * 而它自己的xiangQin方法里面调用的是super.h.invoke(this, , )，也就是父类Proxy的h的invoke方法，
             * 也就是ReadyInvocationHandler类的invoke方法。
             * 所以，invoke(Object proxy, Method m, Object[] args)种的proxy实际上就是动态代理类$Proxy0，
             * 如果你将其强转成XiangQinInterface然后调用它的xiangQin方法，然后它就会调用super.h.invoke(this, , )，这样就会死循环。
             */
            /**
             * 网上关于这里最多问题就是Object proxy放在这里用来做什么呢？这个我也不知道，
             * 不过至少我们知道它到底是个什么东西，具体做什么用嘛就不得而知了
             */
            System.out.println(proxy.getClass().getSimpleName());
            System.out.println("张三相亲前，代理人给他打扮了打扮。");
            result = m.invoke(zhangSan, args);
        } catch (Exception ex) {
            System.exit(1);
        }
        return result;
    }
}
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

/**
 * 张三来到了婚介所(相亲现场)，开始相亲。
 * 
 * @author zhengt
 * @time Jun 3, 2095 3:17:16 PM
 */
public class HunJieSuo {
    public static void main(String args[]) {
        //先将张三相亲这个相亲的实现类实例化，也就是得到XiangQinInterface接口的一个实例对象
        XiangQinInterface zhangSan = new ZhangSanXiangQinInterfaceImpl();
        /**
         * 得到ZhangSanXiangQinInterfaceImpl这个类的一个代理类，同时为代理类绑定了一个处理类ReadyInvocationHandler。
         * 听着很绕口，其实就是每次调用ZhangSanXiangQinInterfaceImpl这个子类的xiangQin方法时，
         * 不是zhangSan这个ZhangSanXiangQinInterfaceImpl类的实例去调用，
         * 而是这个ZhangSanXiangQinInterfaceImpl的代理类ReadyInvocationHandler去调用它自己的invoke方法,
         * 这个invoke方法里呢可以调用zhangSan这个实例的xiangQin方法
         */
        /**
         * 在java种怎样实现动态代理呢
         * 第一步，我们要有一个接口，还要有一个接口的实现类，而这个实现类呢就是我们要代理的对象，
         * 所谓代理呢也就是在调用实现类的方法时，可以在方法执行前后做额外的工作，这个就是代理。
         * 第二步，我们要自己写一个在要代理类的方法执行时，能够做额外工作的类，而这个类必须继承InvocationHandler接口，
         * 为什么要继承它呢？因为代理类的实例在调用实现类的方法的时候，不会调真正的实现类的这个方法，
         * 而是转而调用这个类的invoke方法（继承时必须实现的方法），在这个方法中你可以调用真正的实现类的这个方法。
         * 第三步，在要用代理类的实例去调用实现类的方法的时候，写出下面两段代码。
         */
        XiangQinInterface proxy = (XiangQinInterface) Proxy.newProxyInstance(
                zhangSan.getClass().getClassLoader(),
                zhangSan.getClass().getInterfaces(),
                new ReadyInvocationHandler(zhangSan));
        proxy.xiangQin();
        /**
         * 这里要解释下中部那段长长的代码的意思，以及具体做了哪些工作？
         * 第一，根据zhangSan.getClass().getClassLoader()这个要代理类的类加载器和
         * zhangSan.getClass().getInterfaces()要代理类所实现的所有的接口
         * 作为参数调用Proxy.getProxyClass(ClassLoader loader, Class<?>... interfaces)
         * 的方法返回代理类的java.lang.Class对象，也就是得到了java动态生成的代理类$Proxy0的Class对象。
         * 同时，java还让这个动态生成的$Proxy0类实现了要代理类的实现的所有接口，并继承了Proxy接口。
         * 第二，实例化这个动态生成的$Proxy0类的一个实例，实例化代理类的构造函数为Proxy(InvocationHandler h)，
         * 也就是说要实例化这个动态生成的$Proxy0类，必须给它一个InvocationHandler参数，也就是我们自己实现的用来在代理类
         * 方法执行前后做额外工作的类ReadyInvocationHandler。
         * 这段代码Proxy.newProxyInstance(zhangSan.getClass().getClassLoader(),zhangSan.getClass().getInterfaces(),new ReadyInvocationHandler(zhangSan))
         * 得到的其实是一个类名叫$Proxy0 extends Proxy implements XiangQinInterface的类。
         * 第三，将这个$Proxy0类强制转型成XiangQinInterface类型，调用xiangQin方法。
         */
    }
}

参考：

java 动态代理学习(Proxy,InvocationHandler)——自己的理解

http://hi.baidu.com/malecu/item/9e0edc115cb597a1feded5a0

java动态代理（JDK和cglib）

《Java编程思想》学习笔记6——Java动态代理

二、Cglib动态代理

JDK的动态代理机制只能代理实现了接口的类，而不能实现接口的类就不能实现JDK的动态代理，cglib是针对类来实现代理的，他的原理是对指定的目标类生成一个子类，并覆盖其中方法实现增强，但因为采用的是继承，所以不能对final修饰的类进行代理。
示例

package net.battier.dao;  
  
public interface BookFacade {  
    public void addBook();  
}

package net.battier.dao.impl;  
  
/** 
 * 这个是没有实现接口的实现类 
 *  
 * @author student 
 *  
 */  
public class BookFacadeImpl1 {  
    public void addBook() {  
        System.out.println("增加图书的普通方法...");  
    }  
}

package net.battier.proxy;  
  
import java.lang.reflect.Method;  
  
import net.sf.cglib.proxy.Enhancer;  
import net.sf.cglib.proxy.MethodInterceptor;  
import net.sf.cglib.proxy.MethodProxy;  
  
/** 
 * 使用cglib动态代理 
 *  
 * @author student 
 *  
 */  
public class BookFacadeCglib implements MethodInterceptor {  
    private Object target;  
  
    /** 
     * 创建代理对象 
     *  
     * @param target 
     * @return 
     */  
    public Object getInstance(Object target) {  
        this.target = target;  
        Enhancer enhancer = new Enhancer();  
        enhancer.setSuperclass(this.target.getClass());  
        // 回调方法  
        enhancer.setCallback(this);  
        // 创建代理对象  
        return enhancer.create();  
    }  
  
    @Override  
    // 回调方法  
    public Object intercept(Object obj, Method method, Object[] args,  
            MethodProxy proxy) throws Throwable {  
        System.out.println("事物开始");  
        proxy.invokeSuper(obj, args);  
        System.out.println("事物结束");  
        return null;  
  
  
    }  
  
}

package net.battier.test;  
  
import net.battier.dao.impl.BookFacadeImpl1;  
import net.battier.proxy.BookFacadeCglib;  
  
public class TestCglib {  
      
    public static void main(String[] args) {  
        BookFacadeCglib cglib=new BookFacadeCglib();  
        BookFacadeImpl1 bookCglib=(BookFacadeImpl1)cglib.getInstance(new BookFacadeImpl1());  
        bookCglib.addBook();  
    }  
}

三、静态代理

package org.ccnt.learn.staticproxy;

public interface Count {

    public void queryCount();
    
    public void updateCount();
    
}

package org.ccnt.learn.staticproxy;

public class CountImpl implements Count {

    @Override
    public void queryCount() {
        System.out.println("query count");
    }

    @Override
    public void updateCount() {
        System.out.println("update count");
    }

}

package org.ccnt.learn.staticproxy;

public class CountProxy implements Count {
    
    private Count proxy;
    
    public CountProxy(Count count) {
        this.proxy = count;
    }

    @Override
    public void queryCount() {
        System.out.println("before query");
        proxy.queryCount();
        System.out.println("after query");
    }

    @Override
    public void updateCount() {
        System.out.println("before query");
        proxy.updateCount();
        System.out.println("after query");
    }

}

package org.ccnt.learn.staticproxy;

public class App {

    public static void main(String[] args) {
        Count count = new CountImpl();
        CountProxy proxy = new CountProxy(count);
        proxy.queryCount();
        proxy.updateCount();
    }
}

java 笔记(3) —— 动态代理，静态代理，cglib代理 0、代理模式 一、动态代理 二、Cglib动态代理 三、静态代理