java的代理模式有两种，一种是jdk自带的动态代理，一种是cglib动态代理。

1、jdk动态代理：

/**
* 1.创建接口
*/
public interface Subject {
int sellBook();

String speak();
}
/**
* 2.创建真实对象
*/
public class RealSubject implements Subject {
@Override
public int sellBook() {
System.out.println("卖书");
return 1;
}

@Override
public String speak() {
System.out.println("说话");
return "张三";
}
}
/**
* 3.创建真实对象的代理类，代理类要实现InvocationHandler接口，表示使用jdk动态代理
* 代理模式的重要作用是用于在被代理类的方法执行前后切入代码
*/
public class JdkProty implements InvocationHandler {
/**
* 因为需要处理真实对象，所以需要将真实对象传过来,通过构造方法赋值
*/
private Subject subject;

public JdkProty(Subject subject) {
this.subject = subject;
}

/**
* @param proxy 被代理的对象
* @param method 正在调用的方法
* @param args 方法的参数
* @return
* @throws Throwable
*/
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("调用代理类");
if (method.getName().equals("sellBook")) {
int invoke = (int) method.invoke(subject, args);
System.out.println("调用了卖书的方法");
return invoke;
} else if (method.getName().equals("speak")) {
String string = (String) method.invoke(subject, args);
System.out.println("调用的是说话的方法");
return string;
}
return null;
}
}/***测试方法*/
public class TestDemo {
public static void main(String[] args) {
Subject subject = new RealSubject();
JdkProty jdkProty = new JdkProty(subject);

/**
* 代理对象（本方法可以封装入代理类中，被代理类对象作为obj参数传递）
*subject.getClass().getClassLoader()：被代理类对象的加载器
* subject.getClass().getInterfaces():得到被代理类对象的所有接口
* jdkProty:与被代理类对象相关的代理类对象
*/
Subject proxyInstance = (Subject) Proxy.newProxyInstance(subject.getClass().getClassLoader(), subject.getClass().getInterfaces(), jdkProty);
proxyInstance.sellBook();
proxyInstance.speak();
}
}

 使用jdk动态代理的前提条件：被代理的类一定要有实现的接口

/*** java.lang.reflect包下提供了一个Proxy类和一个InvocationHandler接口用来完成动态代理。* InvocationHandler接口：* 当我们通过代理对象调用一个方法时，这个方法的调用就会被转发为由InvocationHandler这个接口的invoke方法进行调用* Proxy类* 该类提供了一个创建动态代理对象的方法*/

　2、cglib动态代理

​​Cglib​​ 动态代理是针对代理的类, 动态生成一个子类, 然后子类覆盖被代理类中的方法, 如果是private或是final类修饰的方法,则不会被重写。

CGLIB是一个功能强大，高性能的代码生成包。它为没有实现接口的类提供代理，为JDK的动态代理提供了很好的补充。通常可以使用Java的动态代理创建代理，但当要代理的类没有实现接口或者为了更好的性能，CGLIB是一个好的选择。

使用cglib动态代理需要导包：cglib-nodep-2.2.2.jar

/**
* 1.创建真实类对象
*/
public class Ennigeer {

//可以被代理的方法
public int eat() {
System.out.println("工程师在吃饭");
return 1;
}

//final修饰的方法不会被cglib生成的子类覆盖，可以通过代理类调用，但是不能执行代理类的方法
public final String work() {
System.out.println("工程师在工作");
return "hello";
}

//private修饰的方法不会被生成的子类覆盖，不能通过代理类调用
private void play() {
System.out.println("工程师在玩");
}
}
public class CglibProxy implements MethodInterceptor {

/**
* 该intercept方法类似于jdk的invoke方法发
* @param o 被代理类对象
* @param method 被代理类的方法对象
* @param objects 传进去的参数
* @param methodProxy 代理方法的代理对象
* @return
* @throws Throwable
*/
@Override
public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
System.out.println("方法调用之前");
Object invoke = methodProxy.invokeSuper(o, objects);
System.out.println("方法调用之后");
return invoke;
}

/**
* 得到代理类
* @param obj 被代理类对象
* @return 代理类对象
*/
public Object getProxy(Object obj) {
//创建加强器，用来创建被代理类的对象
Enhancer enhancer = new Enhancer();
//为加强器指定要代理的业务类（即：为下面生成的代理类指定父类）
enhancer.setSuperclass(obj.getClass());
//设置回调，对代理类上所有方法的调用，都会调用CallBack(),而CallBack()方法则需要intercept方法进行拦截
enhancer.setCallback(this);
//创建被代理类对象的特殊格式的对象
return enhancer.create();
}
}
public class TestDemo {
public static void main(String[] args) {
Ennigeer ennigeer = new Ennigeer();
CglibProxy cglibProxy = new CglibProxy();
Ennigeer proxy = (Ennigeer) cglibProxy.getProxy(ennigeer);
int eat = proxy.eat();//可以被代理的方法
String work = proxy.work();//不能被代理的方法,可以调用该方法，但是不能代理
System.out.println(eat);
System.out.println(work);
}
}/*** net.sf.cglib.proxy.MethodInterceptor接口：是最通用的回调（callback）类型，* 它经常被AOP用来实现拦截（intercept）方法的调用。这个接口只定义了一个方法。* public Object intercept(Object proxy, Method method, Object[] params, MethodProxy methodProxy)* proxy：代理的对象；* method：委托类执行的方法；* params：方法中的参数；* methodProxy：代理的方法* 由于性能的原因，对原始方法的调用我们使用CGLIB的net.sf.cglib.proxy.MethodProxy对象，而不是反射中一般使用java.lang.reflect.Method对象*/

两种代理方式的比较：

　　CGLib动态代理创建代理实例速度慢，但是运行速度快；JDK动态代理创建实例速度快，但是运行速度慢。如果实例是单例的，推荐使用CGLib方式动态代理，反之则使用JDK方式进行动态代理。Spring的实例默认是单例，所以这时候使用CGLib性能高。 

　　JDK动态代理是通过接口中的方法名，在动态生成的代理类中调用业务实现类的同名方法；

　　CGlib动态代理是通过继承业务类，生成的动态代理类是业务类的子类，通过重写业务方法进行代理；

 　　静态代理是通过在代码中显式定义一个业务实现类一个代理，在代理类中对同名的业务方法进行包装，用户通过代理类调用被包装过的业务方法；