什么是代理？

代理模式在 Java 开发中是一种比较常见的设计模式。设计目的旨在为服务类与客户类之间插入其他功能，插入的功能对于调用者是透明的，起到伪装控制的作用。如租房的例子: 房客、中介、房东。对应于代理模式中即:客户类、代理类 、委托类 (被代理类)
为某一个对象(委托类)提供一个代理 (代理类)，用来控制对这个对象的访问。委托类和代理类有个共同的父类或父接口。代理类会对请求做预处理、过滤，将请求分配给指定对象。

两个设计原则

• 代理类与委托类有共同的行为
• 代理类能够增强委托类的行为

三要素

1. 共同的行为-定义接口
2. 目标对象/真实角色-实现接口
3. 代理对象-实现接口 增强用户行为

静态代理

某个对象提供一个代理，代理角色固定，以控制对这个对象的访问。代理类和委托类有共同的父类或父接口，这样在任何使用委托类对象的地方都可以用代理对象替代。代理类负责请求的预处理、过滤、将请求分派给委托类处理、以及委托类执行完请求后的后续处理。

静态代理的实现

定义接口-定义行为

public interface Marry {public void toMarry();
}

静态代理 -> 目标角色

实现行为

public class You implements Marry {@Overridepublic void toMarry() {System.out.println("你要结婚了...");}
}

静态代理-> 代理角色

1.实现行为
2.增强用户行为

public class MarryCompanyProxy implements Marry{//目标对象private Marry target;//多态//通过带参构造器传递目标对象public MarryCompanyProxy(Marry target) {this.target = target;}//实现行为@Overridepublic void toMarry() {//用户行为增强before();//调用目标对象中的方法target.toMarry();//用户行为增强after();}/*** 用户行为增强*/private void after() {System.out.println("新婚快乐...");}private void before() {System.out.println("婚礼现场正在布置...");}
}

静态代理测试

public class StaticProxy {public static void main(String[] args) {//目标对象You you = new You();//代理对象MarryCompanyProxy marryCompanyProxy = new MarryCompanyProxy(you);//通过代理对象调用目标对象中的方法marryCompanyProxy.toMarry();}
}

静态代理对于代理的角色是固定的，如dao层有20个dao类，如果要对方法的访问权限进行代理，此时需要创建20个静态代理角色，引起类爆炸，无法满足生产上的需要，于是就催生了动态代理的思想。

特点

1. 目标对象固定
2. 在程序运行前已经得到目标对象
3. 代理对象对目标对象进行增强
4. 有可能存在多个代理，产生"类爆炸"（缺点）

JDK动态代理

JDK动态代理的目标对象必须有接口实现
可以根据需要，通过反射机制在程序运行期，动态的为目标对象创建代理对象

newProxyInstance

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

/*Loader:类加载器interfaces：接口数组target.getClass().getInterfaces():目标对象的接口数组h:InvocationHandler接口（传入InvocationHandler接口的实现类）*/public static Object newProxyInstance(ClassLoader loader,Class<?>[] interfacesInvocationHandler h)

获取代理对象

/*** JDK动态代理类*      每一个代理类都需要实现InvocationHandler接口*/
public class JdkHandler implements InvocationHandler {//目标对象private Object target;//类型不固定，创建时动态生成//通过带参构造器传递目标对象public JdkHandler(Object target) {this.target = target;}/*** 1.调用目标对象的方法（返回object）* 2.增强目标对象的行为** @param proxy 调用该方法的代理实例* @param method 目标对象的方法* @param args 目标对象的方法所需要的参数* @return* @throws Throwable*/@Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {//前后都可能会有增强行为，不一定都要有，只是可能会有//用户的增强行为System.out.println("============方法执行前");// 调用目标对象中的方法（返回object）Object object=method.invoke(target,args);//用户的增强行为System.out.println("方法执行后============");return object;//调用方法中返回的值}/*** 获取代理对象* public static Object newProxyInstance(ClassLoader loader,*                                       Class<?>[] interfaces,*                                       InvocationHandler h)*  Loader:类加载器*  interfaces：接口数组*      target.getClass().getInterfaces():目标对象的接口数组*  h:InvocationHandler接口（传入InvocationHandler接口的实现类）* @return*/public Object getProxy(){Object object= Proxy.newProxyInstance(this.getClass().getClassLoader(),target.getClass().getInterfaces(),this);return object;}
}

通过代理对象实现目标对象的功能

public class JdkHandlerTest {public static void main(String[] args) {//目标对象You you = new You();//得到代理类JdkHandler jdkHandler = new JdkHandler(you);//得到代理对象Marry marry = (Marry) jdkHandler.getProxy();//通过代理对象调用目标对象的方法marry.toMarry();}
}

特点

1.目标对象不固定
2.在程序运行时，动态创建目标对象
3.代理对象会增强目标对象的行为

Java动态代理类中的invoke是怎么调用的?

在生成的动态代理类$Proxy9.class中，构造方法调用了父类Proxy.class的构造方法，给成员变量invocationHandler赋值，$Proxy9.class的static模块中创建了被代理类的方法，调用相应方法时方法体中调用了父类中的成员变量InvocationHandler的invoke()方法。

CGLIB动态代理

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

添加依赖

在pom.xml文件中引入cglib的相关依赖，可以上maven官网下载，也可以复制下面的依赖

<!-- https://mvnrepository.com/artifact/cglib/cglib -->
<dependency>
<groupId>cglib</groupId>
<artifactId>cglib</artifactId>
<version>2.2.2</version>
</dependency>
public class CglibInterceptor implements MethodInte

定义类实现MethodInterceptor接口

public class CglibInterceptor implements MethodInterceptor {//目标对象private Object target;//通过构造器传入目标对象public CglibInterceptor(Object target) {this.target = target;}/*** 获取代理对象* @return*/public Object getProxy(){//通过Enhancer对象中的create()方法生成一个类，用于生产代理对象Enhancer enhancer = new Enhancer();//设置父类（将目标类作为代理类的父类）enhancer.setSuperclass(target.getClass());//CglibInterceptor implements MethodInterceptor extends Callback//设置拦截器（回调对象为本身对象）enhancer.setCallback(this);//生成代理类对象，并返回给调用者return enhancer.create();}/*** 拦截器* 1.目标对象的方法调用* 2.行为增强* @param o cglib动态生成的代理类的实例* @param method 实体类所调用的都被代理的方法的引用* @param objects 参数列表* @param methodProxy 生成的代理类对方法的代理引用* @return* @throws Throwable*/@Overridepublic Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {//用户的增强行为System.out.println("============方法执行前");//调用目标类中的方法Object object=methodProxy.invoke(target,objects);//用户的增强行为System.out.println("方法执行后============");return null;}
}

调用方法进行测试

public class CglibInterceptorTest {
public static void main(String[] args) {
//得到目标对象
You you = new You();
//得到拦截器
CglibInterceptor cglibInterceptor = new CglibInterceptor(you);
//得到代理对象
Marry marry= (Marry) cglibInterceptor.getProxy();
//通过代理对象调用目标对象中的方法
marry.toMarry();
}
}

使用的还是一开始静态代理写的方法

JDK和CGLIB动态代理的区别是什么？

• JDK动态代理实现接口，Cglib动态代理继承思想
• JDK动态代理 (目标对象存在接口时) 执行效率高于Ciglib
• 如果目标对象有接口实现，选择JDK代理，如果没有接口实现选择Cglib代理

基于CGLIB动态代理的实现代码实现一下没有接口实现的类分别是怎样的结果

先写一个没有接口实现的类User

public class User {public void test(){System.out.println("cglib动态代理...");}
}

通过Cglib动态代理实现：没有接口实现的类

        User user = new User();CglibInterceptor cglibInterceptor02 = new CglibInterceptor(user);User u = (User) cglibInterceptor02.getProxy();u.test();

实现结果

通过JDK动态代理实现：没有接口实现的类

User user = new User();JdkHandler jdkHandler = new JdkHandler(user);User u= (User) jdkHandler.getProxy();u.test();

实现结果