代理模式-JDK动态代理
关注公众号 JavaStorm 获取更多技术。
为另一个对象提供代表，以便控制客户对对象的访问。其定义为：为另一个对象提供替身或占位符以访问这个对象。具体地吗可以浏览 github.com/UniqueDong/…
什么是代理
官话上讲是一种设计模式，目的是希望代码重用。跟我们以往访问对象的方式不同，代理模式不是直接通过目标对象，而是通过代理访问我们的目标对象以及方法。因为有的时候我们无法直接与目标对象建立联系或者，我们要控制客户端访问。所以便通过代理来访问我们的真实对象。
就好比「客户」-> 「明星经纪人」-> 「明星」。我们不是直接与明星联系，明星很忙的，要唱歌跳舞烫头拍电影，给的价格足够好，经纪人才告知明星接下这个任务。
主要角色
- Subject ：被代理类与代理类都要实现的主题接口。
- ConcreteSubject ：被代理类，也叫委托类，也就是真实对象，真正干活的。
- Proxy ：代理类，扮演者中介的角色，控制客户端对真实对象的访问、生成代理对象让客户端透明调用，通过代理我们可以屏蔽或者加工针对真实对象。
使用场景
- 通常更多出现在我们常用的开源框架里面，比如 Mybatis 中我们 通过Mapper 接口就能调用到真正执行 SQL 的逻辑，其本质就是利用了动态代理，定位到真实的Statement执行。
- Spring AOP 也是利用了动态代理，比如 Spring 事务，当调用的方法是被 Spring 事务管理的时候，其实他会生成一个代理类，封装我们的事务处理逻辑从而实现了事务增强，代码复用。解放我们开启事务、执行逻辑 、提交事务或者回滚事务的模板代码，我们只要安心的编写路基代码即可。在这里一共用到了 「模版方法模式」、动态代理模式。关于「模版方法」模式可以参考历史文章。
- 还有 Dubbo RPC 框架，也是有使用动态代理。对于消费者我们只是通过接口就能调用提供者所实现的功能，就像本地调用一样。它为我们封装了网络传输、序列化、解码编码的繁琐细节。就是生成了一个代理类为屏蔽了底层细节。使得我们可以透明调用。
我们根据加载被代理类的时机不同，将代理分为静态代理和动态代理。如果我们在代码编译时就确定了被代理的类是哪一个，那么就可以直接使用静态代理；如果不能确定，那么可以使用类的动态加载机制，在代码运行期间加载被代理的类这就是动态代理，比如RPC框架和Spring AOP机制。
静态代理代码示例
我们按照 UML 类图来实现一个简单的静态代理模式，首先先创建一个 Subject 接口。
public interface Subject {
public void request();
}
复制代码
创建一个真实对象去实现该接口
public class RealSubjbect implements Subject {
@Override
public void request() {
System.out.println("this is RealSubjbect.request()");
}
}
复制代码
创建我们的代理类，持有真实对象的引用，同时实现了 Subject 接口。
public class ProxySubject implements Subject {
private Subject realSubjbect = null;
/**
* 除了代理真实角色做该做的事，代理角色提供附加操作
* 如
*/
@Override
public void request() {
preRequest(); //真实角色操作前的附加操作
if (realSubjbect == null) {
realSubjbect = new RealSubjbect();
}
realSubjbect.request();
postRequest();//真实角色操作后的附加操作
}
/**
* 真实角色操作前的附加操作
*/
private void postRequest() {
System.out.println("真实角色操作后的附加操作");
}
/**
* 真实角色操作后的附加操作
*/
private void preRequest() {
System.out.println("真实角色操作前的附加操作");
}
}
复制代码
编写我们的客户端接口，通过代理类调用。
public class Client {
public static void main(String[] args) {
Subject subject = new ProxySubject();
subject.request(); //代理者代替真实者做事情
}
}
复制代码
打印的结果如下所示，我们实现了对真实对象的控制，并且新增一些操作。就像Spring的AOP实现的功能一样。
真实角色操作前的附加操作 this is RealSubjbect.request() 真实角色操作后的附加操作 复制代码
缺点
- 代理对象的一个接口只服务于一种类型的对象，如果要代理的方法很多，势必要为每一种方法都进行代理，静态代理在程序规模稍大时就无法胜任了。
- 如果接口增加一个方法，除了所有实现类需要实现这个方法外，所有代理类也需要实现此方法。增加了代码维护的复杂度。
另外，如果要按照上述的方法使用代理模式，那么真实角色(委托类)必须是事先已经存在的，并将其作为代理对象的内部属性。但是实际使用时，一个真实角色必须对应一个代理角色，如果大量使用会导致类的急剧膨胀；此外，如果事先并不知道真实角色（委托类），该如何使用代理呢？这个问题可以通过Java的动态代理类来解决。
动态代理
概念
动态代理类的源码是在程序运行期间 JVM 根据反射机制动态生成的，所以不存在代理类的字节码文件。代理类和委托类的关系是在程序运行时确定。
实现方式
主要有两种实现方式：
- 使用 JDK 实现。委托类逆序有接口。
- 使用 CGLIB 实现。不能是final修饰的类，只能修饰 public 方法。
JDK 动态代理
UML 类图如下所示
- 创建一个自己
Handler实现InvocationHandler，同时持有真实对象的引用，会依赖我们的业务类。 - 代理对象通过
Proxy.newProxyInstance()生成,而该方法以来于Handler对象和 真实对象 。
通过类图其实我们也可以知道，当通过动态代理生成的代理字节码调用的时候就会委托到 Handler 的 invoke 方法。同时 Handler 又持有真正的业务对象。所以能在执行调用真实的对象之前控制其行为以及访问。主要优点：
- 隐藏委托类的实现，调用者只需要和代理类进行交互。
- 解耦合，在不改变委托类代码情况下做额外处理。比如添加 Dubbo 客户端调用时的序列化、网络传输细节。
代码实现
通过类图，创建 JDK 动态代理我们可以分为三步。
InvocationHandler Proxy.newProxyInstance()
现在我们有一个需求，为我们的业务逻辑统一记录调用日志，或者事务控制，在这里我们那就编写一个日志记录为我们的被代理类记录日志。模拟类似 Spring AOP功能，一个简化版的例子让大家明白其使用场景以及原理。
第一步：我们定义自己的业务接口 OrderService 跟 ProductService
public interface OrderService {
String createOder(String no);
}
public interface ProductService {
String getProduct(String no);
}
复制代码
业务逻辑的实现类
public class OrderServiceImpl implements OrderService {
@Override
public String createOder(String no) {
return "生成订单" + no + "成功";
}
}
public class ProductServiceImpl implements ProductService {
@Override
public String getProduct(String no) {
return "获取商品" + no + "成功";
}
}
复制代码
第二步：定义我们的 Handler 实现 JDK 的 Invocationhandler,将持有的委托引用定义 Object 类型，这样可以代理所有需要日志记录的委托类，同时我们有一个 bind() 方法，用于设置 target 同时返回 对应的代理类让客户端调用。第三步的 Proxy.newProxyInstance() 我们放在 bind 方法里。代码更加简洁。
public class LoggerInterceptor implements InvocationHandler {
/**
* 持有委托类的引用
*/
private Object target;
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
long start = System.currentTimeMillis();
System.out.println(proxy.getClass().getInterfaces()[0]);
//通过反射调用
System.out.println("Entered " + target.getClass().getName() + "-" + method.getName() + ",with arguments{" + args[0] + "}");
//调用目标对象的方法
Object result = method.invoke(target, args);
long end = System.currentTimeMillis();
System.out.println("执行结果：" + result.toString());
System.out.println("共耗时：" + (end - start));
return result;
}
/**
* 获取代理类：并将 target 委托类绑定到 我们定义的Targe中
* @param target 真实的委托类
* @return
*/
public synchronized Object bind(Object target) {
this.target = target;
return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
}
}
复制代码
最后我们新建启动类看效果,分别有两个业务逻辑类需要日志记录。具体可看代码注释
public class BootStrap {
public static void main(String[] args) {
// 新建业务逻辑
OrderService orderService = new OrderServiceImpl();
ProductService productService = new ProductServiceImpl();
// 新建我们的 日志 Handler
LoggerInterceptor loggerInterceptor = new LoggerInterceptor();
//绑定 委托类同时生产代理类调用 。
OrderService orderServiceProxy = (OrderService) loggerInterceptor.bind(orderService);
orderServiceProxy.createOder("12927381");
ProductService productServiceProxy = (ProductService) loggerInterceptor.bind(productService);
productServiceProxy.getProduct("34010234");
}
}
复制代码
结果打印如下所示：我们可以看到，每个我们所代理的接口执行方法前后都打印了日志以及返回结果。其实 Spring AOP 就是通过动态代理实现。
nterface com.zero.headfirst.proxy.service.OrderService
Entered com.zero.headfirst.proxy.service.OrderServiceImpl-createOder,with arguments{12927381}
执行结果：生成订单12927381成功
共耗时：2
interface com.zero.headfirst.proxy.service.ProductService
Entered com.zero.headfirst.proxy.service.ProductServiceImpl-getProduct,with arguments{34010234}
执行结果：获取商品34010234成功
共耗时：1
复制代码
CGLIB 动态代理
CGLIB是一个强大的高性能的代码生成包。它广泛的被许多AOP的框架使用，例如Spring AOP为他们提供方法的interception（拦截）。CGLIB包的底层是通过使用一个小而快的字节码处理框架ASM，来转换字节码并生成新的类。
不能是 final 修饰的类，以及final方法，可以不定义接口。
使用方式很简单：我们要先添加cglib 依赖 ，新建一个类实现 MethodInterceptor 。
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
import java.lang.reflect.Method;
public class LoggerProxy implements MethodInterceptor {
/**
* 创建代理类
* @param targetClass 委托类
* @return
*/
public Object bind(Class targetClass) {
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(targetClass);
//设置回调方，当客户端通过代理调用方法的时候会会调用我们重写的 intercept() 方法
enhancer.setCallback(this);
//创建代理类
return enhancer.create();
}
@Override
public Object intercept(Object o, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
long start = System.currentTimeMillis();
//通过反射调用
System.out.println("Entered " + o.getClass().getName() + "-" + method.getName() + ",with arguments{" + args[0] + "}");
Object result = methodProxy.invokeSuper(o, args);
long end = System.currentTimeMillis();
System.out.println("执行结果：" + result.toString());
System.out.println("共耗时：" + (end - start));
return result;
}
}
复制代码
是不是很简单？新建 Enhancer ，只要设置好 委托类以及回调类。在这里我们可以利用工厂模式 创建不同的代理类对应的回调。这里简单实例就不写了。
接下来看我们的测试类以及结果
public class CglibBootStrap {
public static void main(String[] args) {
LoggerProxy loggerProxy = new LoggerProxy();
OrderService orderService = (OrderService) loggerProxy.bind(OrderServiceImpl.class);
orderService.createOder("12873051209g");
ProductService productProxy = (ProductService) loggerProxy.bind(ProductServiceImpl.class);
productProxy.getProduct("2780935782309");
}
}
复制代码
打印结果如下所示
Entered com.zero.headfirst.proxy.service.OrderServiceImpl$$EnhancerByCGLIB$$54d983a1-createOder,with arguments{12873051209g}
执行结果：生成订单12873051209g成功
共耗时：14
Entered com.zero.headfirst.proxy.service.ProductServiceImpl$$EnhancerByCGLIB$$4e2c7c36-getProduct,with arguments{2780935782309}
执行结果：获取商品2780935782309成功
共耗时：5
复制代码
正文到此结束
- 本文标签： newProxyInstance java tar 管理 实例 src AOP Statement spring Bootstrap 代码注释 lib IO synchronized https IDE App client mapper 字节码 git UI 设计模式 dubbo ORM 源码 map 注释 开源 Service JVM 类图 测试 sql 需求 final 文章 本质 cglib 编译 人才 代码 mybatis ACE id Proxy ssl cat GitHub 快的 http 希望
- 版权声明： 本文为互联网转载文章，出处已在文章中说明(部分除外)。如果侵权，请联系本站长删除，谢谢。
- 本文海报： 生成海报一 生成海报二
热门推荐
相关文章
近期评论
-
文章和留言都翻到11页了 没有OOM
-
-
朋友，翻页到11页，及以后，会出现OOM，无法访问
-
-
搞个gitee的项目
-
-
版本号是多少，你可以下载哪个代码仓库，jdk选1.8 直接跑就行
-
-
-
Loading...
![[HBLOG]公众号](https://www.liuhaihua.cn/img/qrcode_gzh.jpg)
