代理就是被代理者没有能力或者不愿意去完成某件事情，需要找个人代替自己去完成这件事 ，这才是 “ 代理 ” 存在的原因。例如，我现在需要出国，但是我不愿意自己 去办签证、预定机票和酒店（觉得麻烦 ，那么就可以找旅行社去帮我办，这时候旅行社就是代理，而我自己就是被 代理了。
1.什么是代理？
相信大家都有购买过火车票或者机票的经历，有的人在携程买，也有的在微信上买等等，这里的携程飞猪微信也好都是受铁路部的委托代理售卖火车票，这里的携程飞猪就是代理类，铁路部就是委托类，这就是代理
在比如：假设客户带着需求去找公司，显然不会直接和软件工程师谈，而是和商务谈，此时客户会认为商务就代表公司，客户是通过商务去访问软件工程师的。我们就可以认为商务（代理对象）代理了软件工程师（真实对象），因此，代理的作用就是，在真实对象访问之前或者之后加入对应的逻辑，或者根据其他规则控制是否使用真实对象。
商务和软件工程师是代理和被代理的关系，客户是通过商务去访问软件工程师的。此时客户就是程序中的调用者，商务就是代理对象，软件工程师就是真实对象。我们需要在调用者调用对象之前产生一个代理对象，而这个代理对象需要和真实对象建立代理关系，所以代理必须分为两个步骤：
- 代理对象和真实对象建立代理关系
- 实现代理对象的代理逻辑方法
在Java中有多种动态代理技术，比如JDK、CGLIB、Javassist、ASM，其中最常用的动态代理技术有两种：一种是JDK动态代理，这是JDK自带的功能；另一种是CGLIB，这是第三方提供的一个技术。目前，Spring常用JDK和CGLIB，而MyBatis还使用了Javassist。（CGLIB的底层原理是ASM）
2.静态代理
所谓的静态代理就是在代码运行之前，代理类就已经存在，通常情况下， 静态代理中的代理类和委托类会实现同一接口或是派生自相同的父类
代理对象：起到中介作用，连接客户端和目标对象
静态代理的作用：通过引入代理对象的方式来间接访问目标对象
解决的问题：防止直接访问目标对象给系统带来的不必要复杂性。
优点：
- 协调调用者和被调用者，降低了系统的耦合度
- 代理对象作为客户端和目标对象之间的中介，起到了保护目标对象的作用
缺点：
- 由于在客户端和真实主题之间增加了代理对象，因此会造成请求的处理速度变慢；
- 实现代理模式需要额外的工作（有些代理模式的实现非常复杂），从而增加了系统实现的复杂度。
应用场景：
2.1 案例：
a.用户登录到我们的系统后，我们的系统会为其产生一个ArrayList集合对象，内部存储了一些用户信息
b.这个对象需要被传给后面的很多其它对象，但要求其它对象不能对这个ArrayList对象执行添加、删除、修改操作，只能get()获取元素
c.分析: 我们无法控制用户如何操作集合,我们可以给这个集合找一个代理,判断他会判断方法,如果是和增删改有关的直接抛出异常(不让操作),如果是获取相关的找到真正得被代理集合,获取数据即可
/**
* 此类就是普通ArrayList类的代理
*/
//1.让代理对象实现被代理对象一样的接口,目的是让代理对象和被代理对象具有一样的方法
public class ArrayListProxy implements List<String>{
//2.要在代理对象中保存一个被代理对象
private ArrayList<String> list;
public ArrayListProxy(ArrayList<String> list) {
this.list = list;
}
//3.下面的一堆方法中,如果是不修改集合数据的方法,就调用list的方法
//如果是修改集合的方法,直接抛出异常
@Override
public boolean add(String s) {
//直接抛出异常
throw new UnsupportedOperationException("不允许调用add方法");
}
@Override
public String get(int index) {
return list.get(index);
}
@Override
public String set(int index, String element) {
//直接抛出异常
throw new UnsupportedOperationException("不允许调用set方法");
}
@Override
public String remove(int index) {
//直接抛出异常
throw new UnsupportedOperationException("不允许调用remove方法");
}
}
public class TestProxyDemo {
public static void main(String[] args) {
//1.创建一个ArrayList
ArrayList<String> arr = new ArrayList<String>();
//保存用户的信息
arr.add("张三");
arr.add("18");
arr.add("北京中村");
arr.add("1888块");
//2.要集合arr先交给代理对象
List<String> list = getArrayListProxy(arr);
//3.操作
// list.add("李四"); 抛出异常!
// list.remove(1); 抛出异常!
// list.set(1, "28"); 抛出异常!
System.out.println(list.get(2)); //OK 正常操作
}
public static List<String> getArrayListProxy(ArrayList<String> arr) {
//创建一个ArrayList的代理
ArrayListProxy arrayListProxy = new ArrayListProxy(arr);
//返回代理对象
return arrayListProxy;
}
}3.动态代理
所谓动态代理 就是代理类在程序运行时创建的代理方式被成为动态代理，也就是说，这种情况下，代理类并不是在Java代码中定义的，而是在运行时根据我们在Java代码中的“指令”动态生成的。相比于静态代理， 动态代理的优势在于可以很方便的对代理类的函数进行统一的处理，而不用修改每个代理类的函数，
动态代理,它的代理类在运行时期通过代码动态生成!!!
动态代理的作用:
拦截对真实对象(被代理对象)方法的直接访问，增强真实对象(被代理对象)方法的功能进行增强(减弱)
3.1 为什么要使用动态代理？
在目标对象较多的情况下，若采用静态代理，则会出现 静态代理对象量多、代码量大，从而导致代码复杂的问题
所以要采用动态代理
3.2 Java已经实现的动态代理：
java . util . Collections : 操作集合的工具类static < T > List < T > unmodifiableList ( List <? extends T > list )返回指定列表的不可修改视图。此方法允许模块为用户提供对内部列表的 “ 只读 ” 访问。在返回的列表上执行的查询操作将 “ 读完 ” 指定的列表。试图修改返回的列表（不管是直接修改还是通过其迭代器进行修改）将导致抛出UnsupportedOperationException : 不支持操作异常unmodifiableList 作用 : 传递 List 接口 , 方法内部对 List 接口进行代理 , 返回一个被代理后的 List 接口对 List 进行代理之后 , 调用 List 接口的方法会被拦截如果使用的 size , get 方法 , 没有对集合进行修改 , 则允许执行如果使用的 add , remove , set 方法 , 对集合进行了修改 , 则抛出运行时异常
案例：
public class DynamicProxy {
public static void main(String[] args) {
//1.创建一个ArrayList
ArrayList<String> arr = new ArrayList<String>();
//保存用户的信息
arr.add("张三");
arr.add("18");
arr.add("北京中村");
arr.add("188块");
//2.使用arr这个集合,生成一个它的代理
List<String> list = Collections.unmodifiableList(arr);
//unmodifiableList 该方法返回的就是arr的代理对象,类似于我们自己的ArraylistProxy对象
//但是unmodifiableList生成的代理对象,是通过动态方式在运行时期创建出来
//3.调用方法
// list.add("李四");
// list.remove(1);
// list.set(1, "28");
System.out.println(list.get(2));
}
}3.3 重点类和方法
newProxyInstance 方法的三个参数的详解 :该方法用于为指定类装载器、一组接口及调用处理器生成动态代理类实例public static Object newProxyInstance ( ClassLoader loader , Class [] interfaces ,InvocationHandler h )1 、 obj . getClass (). getClassLoader () 目标对象通过 getClass 方法获取类的所有信息后，调用getClassLoader () 方法来获取类加载器。获取类加载器后，可以通过这个类型的加载器，在程序运行时，将生成的代理类加载到 JVM 即 Java 虚拟机中，以便运行时需要！2 、 obj . getClass (). getInterfaces () 获取被代理类的所有接口信息，以便于生成的代理类可以具有代理类接口中的所有方法。3 、 InvocationHandler 这是调用处理器接口，它自定义了一个 invoke 方法，用于集中处理在动态代理类对象上的方法调用，通常在该方法中实现对委托类方法的处理以及访问 .InvocationHandler 接口的 invoke 方法及参数详解public Object invoke ( Object proxy , Method method , Object [] args )1 、 Object proxy : 方法内部创建的代理人对象。2 、 Method method ：方法内部会使用反射技术 , 自动被代理人使用的方法。3 、 Object [] args ：被代理方法中的参数。这里因为参数个数不定，所以用一个对象数组来表示。
1.java.lang.reflect.Proxy类 他可以为我们动态生成一个对象的代理对象
public static Object newProxyInstance(
ClassLoader classLoader, //类加载器,一般我们使用和被代理对象一样类加载器
Class[] interfaces, // 被代理对象实现的所有接口的字节码文件数组
InvocationHandler h);//处理类对象,用于拦截我们调用的所有方法,判断到底是否应该被代理对象的真实方法
2.InvocationHandler处理类,实际上它是一个接口
//invoke方法就是用于拦截我们调用的真实方法
public Object invoke(Object proxy, Method method, Object[] args)
Object proxy 代理对象
Method method 被拦截到的方法
Object[] args 被拦截到方法的参数,如果没有就是null3.4动态代理综合案例
public class DynamicProxy {
public static void main(String[] args) {
//1.创建一个ArrayList
ArrayList<String> arr = new ArrayList<String>();
//保存用户的信息
arr.add("张三");
arr.add("18");
arr.add("北京中村");
arr.add("188块");
//2.调用unmodifiableList
List<String> list = unmodifiableList(arr);
// list.add("aaa");
// list.set(1, "28");
// list.remove(1);
// System.out.println(list.get(1));
System.out.println(list.indexOf("18"));
}
//要求该方法和Collections的unmodifiableList一样,接收一个集合,返回一个该集合的代理对象(是动态代理对象)
public static List<String> unmodifiableList(List<String> arr){
//1.使用API 创建一个动态代理对象
List<String> list = (List<String>) Proxy.newProxyInstance(DynamicProxy.class.getClassLoader(), arr.getClass().getInterfaces(), new InvocationHandler() {
//该方法就是用来拦截真实对象方法
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//获取方法名字
String name = method.getName();
//需要拦截 add set remove 开头的哪些方法
if (name.startsWith("add")) {
throw new UnsupportedOperationException("add相关方法不让执行!");
}
if (name.startsWith("set")) {
throw new UnsupportedOperationException("set相关方法不让执行!");
}
if (name.startsWith("remove")) {
throw new UnsupportedOperationException("remove相关方法不让执行!");
}
//其他方法正常执行
Object result = method.invoke(arr, args);
return result;
}
});
return list;
}
}3.5动态代理的优缺点：
Proxy创建动态代理的优点:
a,可以为任意接口的实现类做动态代理
b.极大提高了我们的开发效率
c.不会改变被代理对象的代码
Proxy创建动态代理的缺点:
java的Proxy创建动态代理必须有接口,没有接口不行(以后的CGLib可以)
4.JDK的动态代理
JDK下动态代理的实现，看看JDK下Proxy.newInstance方法，有三个参数：
1、Classloader：类加载器，我们可以使用自定义的类加载器；上述手动实现示例中，直接在Proxy写死了；
2、Class<?>[]：接口类数组，这个其实很容易理解，我们应该允许我们自己实现的代理类同时实现多个接口。我们上述手动实现中只传入一个接口，是为了简化实现；
3、InvocationHandler：这个没什么好说的，与我们的实现一致，用于自定义代理逻辑4.1.动态代理的使用场景
java动态代码的实现机制，那它到底可以用在哪些使用场景呢，如下：
a，Spring的AOP机制就是采用动态代理的机制来实现切面编程
b，我们在使用RPC框架的时候，框架本身并不能提前知道各个业务方要调用哪些接口的哪些方法 ,那么这个时候，就可用通过动态代理的方式来建立一个中间人给客户端使用
c，以及其他一下需要对方法进行增强而又不想修改源码的情况下
4.2 动态代理的自定义使用：
JDK动态代理是java.lang.reflect.*包提供的方式。它必须借助一个接口才能产生代理对象，所以先定义接口HelloWorld：
public interface HelloWorld {
void sayHelloWorld();
}然后提供实现类HelloWorldImpl来实现接口：
public class HelloWorldImpl implements HelloWorld {
@Override
public void sayHelloWorld(){
System.out.println("Hello World");
}
}这是最简答的Java接口和实现类的关系，此时可以开始动态代理了。按照我们之前的分析，先要建立代理对象和真实对象的关系，然后实现代理逻辑，所以一共分为两个步骤。在JDK动态代理中，代理逻辑类必须去实现java.lang.reflect.InvocationHandler接口，它定义了一个invoke方法，并提供接口数组用于下挂代理对象。
我们自己定义一个JDK动态代理的类：
public class MyJdkProxyExample implements InvocationHandler{
/**
* @description 真实对象
**/
private Object target = null;
/**
* @param target 真实对象
* @return 代理对象
* @throws
* @description 建立代理对象和真实对象的代理关系，并返回代理对象
**/
public Object getProxy(Object target) {
this.target = target;
return Proxy.newProxyInstance(target.getClass().getClassLoader(),target.getClass().getInterfaces(),this);
}
/**
* @param proxy 代理对象
* @param method 当前调度方法
* @param args 当前方法参数
* @return 代理结果
* @throws Throwable 异常
* @description 代理方法逻辑
**/
@Override
public Object invoke(Object proxy, Method method,Object [] args) throws Throwable{
System.out.println("进入代理逻辑方法");
System.out.println("在调度真实对象之前的服务");
Object obj = method.invoke(target,args);//相当于调用sayHelloWorld方法
System.out.println("在调度真实对象之后的服务");
return obj;
}
}第一步，通过getProxy()方法建立代理对象和真实对象的关系，并返回代理对象。首先用类的属性target保存了真实对象，然后通过Proxy.newProxyInstance()方法建立并生成代理对象，该方法中包含3个参数：
- 第1个是类加载器，这里采用了target本身的类加载器；
- 第2个是把生成的动态代理对象下挂在哪些接口下，这个写法就是放在target实现的接口下。HelloWorldImpl对象的接口显然就是HelloWorld，代理对象可以这样声明：HelloWorld proxy = xxxx;；
- 第3个是定义实现方法逻辑的代理类，this表示当前对象，它必须实现InvocationHandler接口的invoke方法，它就是代理逻辑方法的现实方法。
第二步，通过invoke方法实现代理逻辑方法。invoke方法的3个参数：
- proxy，代理对象，就是getProxy方法生成的对象；
- method，当前调度的方法；
- args，当前调度方法的参数。
当我们使用了代理对象调度方法后，它就会进入到invoke方法里面。
Object obj = method.invoke(target,args);这行代码相当于调度真实对象的方法，只是通过反射实现。类比前面的例子，proxy相当于商务，target相当于软件工程师，getProxy方法就是建立商务和软件工程师之间的代理关系，invoke方法就是商务逻辑。
测试JDK动态代理：
@Test
public void testJdkProxy(){
MyJdkProxyExample jdkProxy = new MyJdkProxyExample();
//绑定关系，因为挂在接口HelloWorld下，所以声明代理对象HelloWorld proxy
HelloWorld proxy = (HelloWorld) jdkProxy.getProxy(new HelloWorldImpl());
//此时HelloWorld对象已经是一个代理对象，它会进入代理的逻辑方法invoke里
proxy.sayHelloWorld();
}首先通过getProxy方法绑定了代理关系，然后在代理对象调度sayHelloWorld方法时进入了代理的逻辑，测试结果如下：
进入代理逻辑方法
在调度真实对象之前的服务
Hello World
在调度真实对象之后的服务
此时，在调度打印Hello World之前和之后都可以加入相关的逻辑，甚至可以不调度Hello World的打印。
总结：JDK动态代理要求真实对象和代理对象之间是实现类和接口的关系，创建一个代理逻辑类实现InvocationHandler接口，其中getProxy方法用于生成代理对象，然后重写invoke方法。
5. CGLIB代理：
对cglib不做深入研究了，使用方式与JDK的动态代理类似，实现的效果也基本一致，但是实现原理上还是有差别的
JDK的动态代理有一个限制，就是使用动态代理的对象必须实现一个或多个接口，而CGLIB没有这个限制
动态代理的作用，使用动态代理我们可以在不改变源码的情况下，对目标对象的目标方法进行前置或后置增强处理。这有点不太符合我们的一条线走到底的编程逻辑，这种编程模型有一个专业名称叫AOP，面向切面编程，具体案例有如下：
1、spring的事务，事务的开启可以作为前置增强，事务的提交或回滚作为后置增强，数据库的操作处在两者之间（目标对象需要完成的事）；
2、日志记录，我们可以在不改变原有实现的基础上，对目标对象进行日志的输出，可以前置处理，记录参数情况，也可以后置处理，记录返回的结果；
3、web编程，传入参数的校验；
4、web编程，权限的控制也可以用aop来实现；
JDK动态代理必须提供接口才能使用，在一些不能提供接口的环境中，只能采用其他第三方技术，比如CGLIB动态代理，这里提供CGLIB动态代理的相关jar包，供学习和测试使用。它的优势在于不需要提供接口，只要一个非抽象类就能实现动态代理。
CGLIB原理：动态生成一个要代理类的子类，子类重写要代理的类的所有不是final的方法。在子类中采用方法拦截的技术拦截所有父类方法的调用，顺势织入横切逻辑。它比使用java反射的JDK动态代理要快。CGLIB底层：使用字节码处理框架ASM，来转换字节码并生成新的类。不鼓励直接使用ASM，因为它要求你必须对JVM内部结构包括class文件的格式和指令集都很熟悉。CGLIB缺点：对于final方法，无法进行代理。CGLIB广泛地被许多AOP的框架使用，例如Spring AOP和dynaop。Hibernate使用CGLIB来代理单端single-ended(多对一和一对一)关联。
举例：
public class ReflectServiceImpl {
public void sayHello(String name){
System.out.println("Hello "+name);
}
}它不存在实现任何接口，所以不能使用JDK动态代理，这里采用CGLIB动态代理技术：
public class MyCglibProxyExample implements MethodInterceptor{
/**
* @param cls Class类
* @return Class类的CGLIB对象
* @throws
* @description 生成CGLIB代理对象
**/
public Object getProxy(Class cls){
//CGLIB增强类对象
Enhancer enhancer = new Enhancer();
//设置增强类型
enhancer.setSuperclass(cls);
//定义代理逻辑对象为当前对象，要求当前对象实现MethodInterceptor方法
enhancer.setCallback(this);
//生成并返回代理对象
return enhancer.create();
}
/**
* @param proxy 代理对象
* @param method 目标方法
* @param args 目标方法参数
* @param methodProxy 方法代理
* @return 代理逻辑返回
* @throws Throwable 异常
* @description 代理逻辑方法
**/
@Override
public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy)throws Throwable{
System.out.println("调用真实对象前");
//CGLIB反射调用真实对象方法
Object result = methodProxy.invokeSuper(proxy,args);
System.out.println("调用真实对象后");
return result;
}
}这里用了CGLIB的加强者Enhancer（net.sf.sglib.proxy.Enhancer），通过设置超类的方法（setSuperclass），然后通过setCallback方法设置哪个类为它的代理类。其中，参数this表示当前对象，那就要求用this这个对象实现接口MethodInterceptor（net.sf.sglib.proxy.MethodInterceptor）的方法intercept，然后返回代理对象。那么此时当前类的intercept方法就是其代理逻辑方法，其参数内容见代码注解，我们在反射真实对象方法前后进行了打印，CGLIB是通过如下代码完成的：
Object result = methodProxy.invokeSuper(proxy,args);测试一下CGLIB动态代理：
@Test
public void testCglibProxy(){
MyCglibProxyExample cglibProxy = new MyCglibProxyExample();
ReflectServiceImpl obj = (ReflectServiceImpl) cglibProxy.getProxy(ReflectServiceImpl.class);
obj.sayHello("haoya");
}得到结果：
调用真实对象前
Hello haoya
调用真实对象后
总结：CGLIB动态代理相对简单一些，通过字节码技术为需要代理的类生成一个子类，它不需要提供接口，只需写一个代理逻辑类并实现MethodInterceptor接口，其中getProxy方法用于生成代理对象，然后重写intercept方法即可。
参考：
