什么是静态代理、JDK动态代理、cglib动态代理？

静态代理

package com;
/**
 * @author jiaxinxiao
 * @date 2020年2月18日
 * 静态代理类的缺点：
 * 一个代理类只能对一个业务接口的实现类进行包装
 * 如果有多个业务接口的话就要定义很多实现类和代理类才行
 * 如果代理类对业务方法的预处理、调用后操作都是一样的（比如：调用前输出提示、调用后自动关闭连接），则多个代理类就会有很多重复代码。
 * 所以需要动态代理：
 * 这时我们可以定义这样一个代理类，它能代理所有实现类的方法调用：根据传进来的业务实现类和方法名进行具体调用。——那就是动态代理。
 */
public class GenerateProxy {
	//静态代理测试
	public static void main(String[] args) {
		CountImpl countImpl = new CountImpl();
		ProxyCount countProxy = new ProxyCount(countImpl);
		countProxy.queryCount();
		countProxy.updateCount();
	}
}
/**
 * 定义账户接口
 * 说明业务逻辑
 * @author jiaxinxiao
 * @date 2020年2月18日
 */
interface Count{
	//查询
	public void queryCount();
	//修改
	public void updateCount();
}
/**
 * 定义业务实现类，实现业务逻辑接口
 * @author jiaxinxiao
 * @date 2020年2月18日
 */
class CountImpl implements Count{

	@Override
	public void queryCount() {
		// TODO Auto-generated method stub
		System.out.println("查看账户");
	}

	@Override
	public void updateCount() {
		// TODO Auto-generated method stub
		System.out.println("修改账户");
	}
}
/**
 * 通过组合，在代理类中创建一个业务实现类对象来调用具体的业务方法
 * 通过实现业务逻辑接口，来统一业务方法
 * 在代理类中实现业务逻辑接口中的方法时，进行预处理操作、通过业务实现类对象调用真正的业务方法、进行调用后操作的定义。
 * @author jiaxinxiao
 * @date 2020年2月18日
 */
class ProxyCount implements Count{
	//组合一个业务实现类对象来进行真正的业务方法的调用
	private CountImpl countImpl;
	public ProxyCount(CountImpl countImpl){
		this.countImpl = countImpl;
	}
	@Override
	public void queryCount() {
		System.out.println("预处理");
		countImpl.queryCount();
		System.out.println("查询之后");
	}

	@Override
	public void updateCount() {
		System.out.println("预处理");
		countImpl.updateCount();
		System.out.println("查询之后");
	}
	
}

静态代理的缺点很明显：一个代理类只能对一个业务接口的实现类进行包装，如果有多个业务接口的话就要定义很多实现类和代理类才行。而且，如果代理类对业务方法的预处理、调用后操作都是一样的（比如：调用前输出提示、调用后自动关闭连接），则多个代理类就会有很多重复代码。这时我们可以定义这样一个代理类，它能代理所有实现类的方法调用：根据传进来的业务实现类和方法名进行具体调用。——那就是动态代理。

JDK动态代理

JDK动态代理所用到的代理类在程序调用到代理类对象时才由JVM真正创建，JVM根据传进来的 业务实现类对象 以及 方法名 ，动态地创建了一个代理类的class文件并被字节码引擎执行，然后通过该代理类对象进行方法调用。我们需要做的，只需指定代理类的预处理、调用后操作即可。

package com;

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

public class JDKProxy {
	//测试
	public static void main(String[] args) {
		/**
		 * 在使用时，首先创建一个业务实现类对象和一个代理类对象，然后定义接口引用（这里使用向上转型）并用代理对象.bind(业务实现类对象)的返回值进行赋值。
		 * 最后通过接口引用调用业务方法即可。（接口引用真正指向的是一个绑定了业务类的代理类对象，所以通过接口方法名调用的是被代理的方法们
		 */
		BooKFacade bf = new BookFacadeImpl();
		BookFacadeProxy bfp = new BookFacadeProxy();
		BooKFacade handler = (BooKFacade)bfp.bind(bf);
		handler.addBook();
		
	}
}
interface BooKFacade{
	public void addBook();
}
class BookFacadeImpl implements BooKFacade{

	@Override
	public void addBook() {
		System.out.println("add book...");
	}
}
class BookFacadeProxy implements InvocationHandler{
	//这其实业务实现类对象，用来调用具体的业务方法 
	private Object target;
	public Object bind(Object target){
		this.target = target;
		//通过反射机制，创建一个代理类对象实例并返回。用户进行方法调用时使用
		//创建代理对象时，需要传递该业务类的类加载器（用来获取业务实现类的元数据，在包装方法是调用真正的业务方法）、接口、handler实现类
		return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
	}
	@Override
	public Object invoke(Object arg0, Method arg1, Object[] arg2)
			throws Throwable {
		Object result = null;
		System.out.println("预处理操作----");
		result = arg1.invoke(target, arg2);
		System.out.println("调用后处理----");
		return result;
	}
	
}

JDK动态代理的代理对象在创建时，需要使用业务实现类所实现的接口作为参数（因为在后面代理方法时需要根据接口内的方法名进行调用）。如果业务实现类是没有实现接口而是直接定义业务方法的话，就无法使用JDK动态代理了。并且，如果业务实现类中新增了接口中没有的方法，这些方法是无法被代理的（因为无法被调用）。

cglib动态代理

package com;

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 {
	public static void main(String[] args) {
		/**
		 * 创建业务类和代理类对象，然后通过  代理类对象.getInstance(业务类对象)  
		 * 返回一个动态代理类对象（它是业务类的子类，可以用业务类引用指向它）。
		 * 最后通过动态代理类对象进行方法调用。
		 */
		BookFacadeImpl2 bf2 = new BookFacadeImpl2();
		BookFacadeCglibProxy bfcp = new BookFacadeCglibProxy();
		BookFacadeImpl2 cglib = (BookFacadeImpl2)bfcp.getInstance(bf2);
		cglib.addBook();
	}
}
//首先定义业务类，无需实现接口
class BookFacadeImpl2{
	public void addBook(){
		System.out.println("新增图书...");
	}
}
class BookFacadeCglibProxy implements MethodInterceptor{
	//业务类对象，供代理方法中进行真正的业务方法调用
	private Object target;
	//相当于JDK动态代理中的绑定
	public Object getInstance(Object target){
		//给业务对象赋值
		this.target = target;
		//创建加强器，用来创建动态代理类
		Enhancer enhancer = new Enhancer();
		//为加强器指定要代理的业务类（即：为下面生成的代理类指定父类）
		enhancer.setSuperclass(this.target.getClass());
		//设置回调：对于代理类上所有方法的调用，都会调用CallBack，而Callback则需要实现intercept()方法进行拦
		enhancer.setCallback(this);
		return enhancer.create();
	}
	// 实现回调方法 
	@Override
	public Object intercept(Object paramObject, Method paramMethod,
			Object[] paramArrayOfObject, MethodProxy paramMethodProxy)
			throws Throwable {
		System.out.println("预处理---");
		Object result = paramMethodProxy.invokeSuper(paramObject, paramArrayOfObject);
		System.out.println("调用后操作---");
		return result;
	}
	
}

三种代理比较

• 静态代理是通过在代码中显式定义一个业务实现类一个代理，在代理类中对同名的业务方法进行包装，用户通过代理类调用被包装过的业务方法；
• JDK动态代理是通过接口中的方法名，在动态生成的代理类中调用业务实现类的同名方法；
• CGlib动态代理是通过继承业务类，生成的动态代理类是业务类的子类，通过重写业务方法进行代理；