代理模式：一个委托类，一个代理类，实现相同的接口，通常是在代理类中有一个委托类的对象，代理类并不会真正的执行方法，只是在委托类执行方法之前或之后提供一些服务。比如账户验证，权限查看啥的。

静态代理

// Car.java
package com.codeliu.dao;

public interface Car {
    // 预订车
    public void revCar();
    // vip客户可以直接买车
    public void buyCar();
} 

// CarImpl.java
package com.codeliu.dao.impl;

import com.codeliu.dao.Car;
/**
 * 委托类
 */
public class CarImpl implements Car {
    public void revCar() {
        System.out.println("我要去预订一辆车咯");
    }

    public void buyCar() {
        System.out.println("我要买车咯");
    }
}

/ CarProxy.java
package com.codeliu.dao.impl;

import com.codeliu.dao.Car;
/**
 * 代理类
 */
public class CarProxy implement Car {
    private CarImpl ci;
    public CarProxy(CarImpl ci) {
        this.ci = ci;
    }

    public void revCar() {
        System.out.println("该客户是否有足够的钱预订车");
        ci.revCar();
        System.out.println("该客户预订完成");
    }

    public void buyCar() {
        System.out.println("该客户是否是vip客户");
        ci.buyCar();
        System.out.println("该客户买车完成");
    }
}

package com.codeliu.test;

import com.codeliu.dao.impl.CarImpl;
import com.codeliu.dao.impl.CarProxy;
public class TestProxy {
    public static void main(String[] args) {
        CarImpl ci = new CarImpl();
        CarProxy cp = new CarProxy(ci);
        cp.revCar();
        cp.buyCar();
    }
}

静态代理是一个代理类只能为一个委托类服务，如果有多个委托类实现了同一个接口，则就要有多个代理类，除了委托类调用的方法不一样，
其他操作都一样，这样势必就会产生很多重复代码。这时就是动态代理类上场的时候了。

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

nvocationHandler接口接口中只有一个invoke方法，所有动态代理类都要实现这个接口，并实现invoke方法。
关于该方法的三个参数
proxy表示被代理的对象
method表示被代理对象的方法
args表示方法的参数

// Proxy类的newProxyInstance方法
public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)

loader表示委托类的类加载器
interfaces表示委托类实现的接口（这就说明委托类一定要实现了接口才能使用）
h表示InvocationHandler接口的子实例，也就是动态代理类的实例

// Car.java
package com.codeliu.dao;

public interface Car {
    // vip客户可以直接买车
    public void buyCar();
} 

// CarImp1.java
package com.codeliu.dao.impl;
import com.codeliu.dao.Car;
/**
 * 委托类1
 */
public class CarImp1 implements Car {
    public void buyCar() {
        System.out.println("我是vip1");
    }
}

// CarImp2.java
package com.codeliu.dao.impl;
import com.codeliu.dao.Car;
/**
 * 委托类2
 */
public class CarImp2 implements Car {
    public void buyCar() {
        System.out.println("我是vip2");
    }
}

// CarProxy.java
package com.codeliu.dao.impl;

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

/**
 * 动态代理类
 */
public class CarProxy implements InvocationHandler {
    private Object target;
    /**
     * 绑定一个委托对象并获得一个代理类对象
     * @param  target [description]
     * @return        [description]
     */
    public Object bind(Object target) {
        this.target = target;
        // 取得代理对象
        return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), 
                                       this);
    }

    @Override
    //这个方法并不是我们自己去调用
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        System.out.println("该客户是否是vip客户");
        // 执行委托类的方法
        Object result = method.invoke(target,args);
        System.out.println("该客户买车完成");
        return result;
    }
}

package com.codeliu.test;

import com.codeliu.dao.impl.CarImp1;
import com.codeliu.dao.impl.CarImp2;
import com.codeliu.dao.impl.CarProxy;
import com.codeliu.dao.Car;
public class TestProxy {
    public static void main(String[] args) {
        CarProxy cp = new CarProxy();
        // 传入一个实现了该接口的实例就行
        Car car = (Car)cp.bind(new CarImp1());
        // Car car = (Car)cp.bind(new CarImp2());
        car.buyCar();
    }
} 

输出

该客户是否是vip客户
我是vip1
该客户买车完成

以上就是一个JDK动态代理的例子，但我们可以看到，如果委托类没有实现接口的话，就不能使用newProxyInstance方法，进而不能使用JDK动态代理。这时候，Cglib动态代理上场了。

要使用Cglib，首先的下载jar包。

package com.codeliu.cglibproxy;
public class Train {
    public void move() {
        System.out.println("火车行驶中。。。。");
    }
}

package com.codeliu.cglibproxy;

import java.lang.reflect.Method;

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
public class CglibProxy implements MethodInterceptor {
    
    private Enhancer enhancer = new Enhancer();
    
    /**
     * 获得代理类
     * @return
     */
    public Object getProxy(Class<?> c) {
        // 设置创建子类的类
        enhancer.setSuperclass(c);
        // 回调方法
        enhancer.setCallback(this);
        // 返回代理对象
        return enhancer.create();
    }

    @Override
    /**
     * 拦截所有目标方法的调用
     * obj 目标类的实例
     * m 目标方法的反射对象
     * args 方法的参数
     * proxy 代理类的实例
     */
    public Object intercept(Object obj, Method m, Object[] args,
            MethodProxy proxy) throws Throwable {
        System.out.println("火车启动啦！！");
        // 代理类调用父类的方法
        Object result = proxy.invokeSuper(obj, args);
        System.out.println("火车停止啦！！");
        return result;
    }

}

package com.codeliu.cglibproxy;
public class Test {
    public static void main(String[] args) {
        CglibProxy proxy = new CglibProxy();
        Train t = (Train)proxy.getProxy(Train.class);
        t.move();
    }
}

输出

火车启动啦！！
火车行驶中。。。。
火车停止啦！！