一、代理模式的概念
就是为目标对象提供另外一种访问方式，通过访问代理对象来间接访问目标对象。
优点是：
- 降低了系统的耦合度（将客户端与目标对象分离，在一定程度上降低了系统的耦合度）
- 扩展目标对象的功能（在不修改原来方法的情况下，给现有的对象中的方法追加额外的功能）
- 保护目标对象（在客户端与目标对象之间起到一个中介作用和保护目标对象的作用）
缺点是：
- 请求处理速度变慢(在客户端和目标对象之间增加一个代理对象，会造成请求处理速度变慢）
- 增加了系统的复杂度
二、代理模式的分类
image.png
- 作用：其实就是在我们目标方法之前和之后实现增强/限制/修改
- 代理模式分类：静态代理模式（需要自己编写代理类）和动态代理模式（使用反射或者字节码技术生成代理类）
- 动态代理分类：JDK动态代理（采用反射机制回调、必须依赖于接口）、CGLIB动态代理（采用字节码技术调用、采用重写（覆盖）的形式）
三、静态代理
需要定义三个类（接口、目标对象、代理对象），目标对象和代理对象同时实现接口，代理对象中维护一个目标对象的引用，并追加额外的功能
3.1、静态代理的UML图
image.png
3.2、静态代理的简单DEMO
- 接口类
/**
* @author lichunlan
* @description 接口
* @since 2020-03-09
*/
public interface Subject {
void request();
}
- 目标对象
/**
* @author lichunlan
* @description 目标对象
* @since 2020-03-09
*/
public class RealSubject implements Subject {
public void request() {
System.out.println("这个是真实目标对象要处理的事情.......");
}
}
- 代理类
/**
* @author lichunlan
* @description 代理对象
* @since 2020-03-09
*/
public class Proxy implements Subject {
public RealSubject realSubject;
public Proxy(RealSubject realSubject) {
this.realSubject = realSubject;
}
public void request() {
preRequest();
//目标对象的逻辑
realSubject.request();
postRequest();
}
public void preRequest(){
System.out.println("目标方法之前追加的功能.......");
}
public void postRequest(){
System.out.println("目标方法之后追加的功能.......");
}
}
- Client
public class Main {
public static void main(String[] args) {
Proxy proxy = new Proxy(new RealSubject());
proxy.request();
}
}
-
结果
image.png
优点：可以在不修改目标对象的情况下追加新的功能。
缺点：当接口中添加新的方法之后，目标对象和代理对象都要进行维护。
当代理方法越多，重复逻辑越多，前后执行的逻辑可能大部分都是一样的，于是就有了动态代理
四、动态代理
动态代理就是动态的创建代理类的技术，这样代理类就不需要手动实现接口了。
动态代理又分为JDK动态代理和CGLIB动态代理。
4.1、JDK动态代理
4.1.1 JDK动态代理主要点
- 通过java.lang.reflect.Proxy类，动态生成代理类
- 代理类实现的植入的逻辑，需要实现接口InvocationHandler
- 代理类中维护一个目标对象的引用
- 只能基于接口进行动态代理
4.1.2 JDK动态代理简单DEMO
- 接口类
/**
* @author lichunlan
* @description 接口
* @since 2020-03-09
*/
public interface Subject {
void request();
}
- 目标对象
/**
* @author lichunlan
* @description 目标对象
* @since 2020-03-09
*/
public class RealSubject implements Subject {
public void request() {
System.out.println("这个是真实目标对象要处理的事情.......");
}
}
- JDK代理类
/**
* @author lichunlan
* @description JDK动态代理
* @since 2020-03-09
*/
public class JDKProxySubject implements InvocationHandler {
private RealSubject realSubject;
public JDKProxySubject(RealSubject realSubject) {
this.realSubject = realSubject;
}
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
preRequest();
Object result = null;
//动态反射方法
result = method.invoke(realSubject, args);
postRequest();
return result;
}
public void preRequest(){
System.out.println("JDK动态代理目标方法之前追加的功能.......");
}
public void postRequest(){
System.out.println("JDK动态代理目标方法之后追加的功能.......");
}
}
- Client
public class Main {
public static void main(String[] args) {
//目标对象
RealSubject realSubject = new RealSubject();
JDKProxySubject jdkProxySubject = new JDKProxySubject(realSubject);
//给目标对象创建代理对象
Subject subject = (Subject) Proxy.newProxyInstance(Subject.class.getClassLoader(), new Class[]{Subject.class}, jdkProxySubject);
subject.request();
}
}
-
结果
image.png
-
接口类有多个目标方法就很容易了，假设我在接口类中，再添加8个目标方法，这个时候，只需要在RealSubject中实现方法，在Client中直接调用即可
/**
* @author lichunlan
* @description 接口
* @since 2020-03-09
*/
public interface Subject {
void request();
void request1();
void request2();
void request3();
void request4();
void request5();
void request6();
void request7();
void request8();
}
/**
* @author lichunlan
* @description 目标对象
* @since 2020-03-09
*/
public class RealSubject implements Subject {
public void request() {
System.out.println("这个是真实目标对象要处理的事情.......");
}
public void request1() {
System.out.println("这个是真实目标对象1要处理的事情.......");
}
public void request2() {
System.out.println("这个是真实目标对象2要处理的事情.......");
}
public void request3() {
System.out.println("这个是真实目标对象3要处理的事情.......");
}
public void request4() {
System.out.println("这个是真实目标对象4要处理的事情.......");
}
public void request5() {
System.out.println("这个是真实目标对象5要处理的事情.......");
}
public void request6() {
System.out.println("这个是真实目标对象6要处理的事情.......");
}
public void request7() {
System.out.println("这个是真实目标对象7要处理的事情.......");
}
public void request8() {
System.out.println("这个是真实目标对象8要处理的事情.......");
}
}
/**
* @author lichunlan
* @description
* @since 2020-02-26
*/
public class Main {
public static void main(String[] args) {
//目标对象
RealSubject realSubject = new RealSubject();
//JDK代理对象
JDKProxySubject jdkProxySubject = new JDKProxySubject(realSubject);
//给目标对象创建代理对象
Subject subject = (Subject) Proxy.newProxyInstance(Subject.class.getClassLoader(), new Class[]{Subject.class}, jdkProxySubject);
subject.request();
subject.request1();
subject.request2();
subject.request3();
subject.request4();
subject.request5();
subject.request6();
subject.request7();
subject.request8();
}
}
4.2、CGLIB动态代理
4.2.1 CGLIB动态代理主要点
- 需要实现接口MethodInterceptor
- 目标对象是没有接口的
- 采用字节码（其原理是通过字节码技术为一个类创建子类，并在子类中采用方法拦截的技术拦截所有父类方法的调用，顺势织入横切逻辑）
4.2.2 CGLIB动态代理简单DEMO
这种代理方式是为了解决目标对象并没有实现任何接口的时候，使用这种方式生成一个子类对象从而实现对目标对象功能的扩展
- 目标对象(在CGLIB中可以称为父类)
/**
* @author lichunlan
* @description 目标对象
* @since 2020-03-09
*/
public class RealSubject{
public void request() {
System.out.println("这个是真实目标对象要处理的事情.......");
}
}
- CGLIB动态代理
/**
* @author lichunlan
* @description CGLIB动态代理(自定义MethodInterceptor)
* @since 2020-03-09
*/
public class CglibProxySubject implements MethodInterceptor {
private Enhancer enhancer = new Enhancer();
/**
* 通过字节码技术生成CGLIB动态代理的代理对象
* @param clazz 目标对象
* @return
*/
public Object getProxy(Class clazz){
//继承被代理类
enhancer.setSuperclass(clazz);
enhancer.setCallback(this);
//通过字节码技术动态生成代理对象
return enhancer.create();
}
/**
*
* @param o cglib生成的代理对象
* @param method 被代理对象方法
* @param objects 方法入参
* @param methodProxy 代理方法
* @return
* @throws Throwable
*/
public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
preRequest();
Object object = null;
object = methodProxy.invokeSuper(o, objects);
postRequest();
return object;
}
public void preRequest(){
System.out.println("CGLIB动态代理目标方法之前追加的功能.......");
}
public void postRequest(){
System.out.println("CGLIB动态代理目标方法之后追加的功能.......");
}
}
- Client
/**
* @author lichunlan
* @description
* @since 2020-02-26
*/
public class Main {
public static void main(String[] args) {
CglibProxySubject proxy = new CglibProxySubject();
//通过生成子类的方式创建代理类
RealSubject realSubject = (RealSubject)proxy.getProxy(RealSubject.class);
realSubject .request();
}
}
-
结果
image.png
五、CGLIB动态代理和JDK动态代理的比较
- JDK采用反射机制回调 ，CGLIB采用字节码技术调用
- JDK反射和CGLIB字节码生成的区别？
1)JDK必须依赖于接口，不能针对类
2)CGLIB是针对类，主要是为目标类生成一个子类，覆盖其中的方法实现增强，目标类不能声明成final，因为final类不能被继承，无法生成代理。
目标方法也不能声明成final，final方法不能被重写，无法得到处理。 - 在Spring中到底是采用JDK还是采用CGLIB代理呢???
1)目标类（被代理类）实现过接口默认情况下用JDK动态代理
2)目标类（被代理类）实现了接口，可以强制使用CGLIB动态代理
3)目标类（被代理类）没有实现接口就必须采用CGLIB动态代理 - JDK和CGLIB哪个应用得广泛些
相比来说，JDK比CGLIB广泛，但是CGLIB效率比JDK高 - 为什么CGLIB效率比JDK效率高，还用JDK呢？？？
1)JDK支持原生
2)项目中大多数都采用面向接口编程
所以JDK使用得比CGLIB多
六 、应用场景
- Aop
- mybats mapper对象
- RPC远程调用
- 事务
- 日志
- 权限控制
既然动态代理模式是采用的反射或者字节码动态生成代理类，那下篇文章我将把反射的原理和字节码的原理学习一遍，并进行记录。因为反射在源码中是一个非常重要的概率
参考
慕课网课程"探秘Spring AOP"
网友评论