通俗易懂详解Java代理及代码实战

一、概述

代理模式是Java常用的设计模式之一,实现代理模式要求代理类和委托类(被代理的类)具有相同的方法(提供相同的服务),代理类对象自身并不实现真正的核心逻辑,而是通过调用委托类对象的相关方法来处理核心逻辑,而代理类对象主要负责为委托类对象过滤消息、预处理消息、转发消息给委托类、事后处理消息等等。通常代理类会与委托类存在关联关系。

  按照代理的创建时期,代理可分为:静态代理和动态代理。静态代理由开发者手动创建,在程序运行前,已经存在;而动态代理不需要手动创建,它是在程序运行时动态的创建代理类。

二、静态代理

我们直接用代码来说明什么叫静态代理,场景是我要卖掉我的车子,但是由于我很忙,所以卖掉车子的过程中不想每天被电话骚扰,于是我就在附近找了一个二手车交易的中介,希望在他的帮助下很轻松的卖掉车子。

1.卖车子接口

public interface SaleCar {
    void sale();
}

2.hafiz真正卖车子实现类

public class HafizSaleCar implements SaleCar {
    @Override
    public void sale() {
        System.out.println("hafiz sale his car...");
    }
}

3.二手车交易中介类

public class CarTradeProxy implements SaleCar {
    private HafizSaleCar owner;
    public CarTradeProxy(HafizSaleCar owner) {
        this.owner = owner;
    }
    @Override
    public void sale() {
        System.out.println("proxy add price...");
        owner.sale();
    }
}

4.测试类

public class Client {
    public static void main(String[] args) {
        HafizSaleCar owner = new HafizSaleCar();
        CarTradeProxy proxy = new CarTradeProxy(owner);
        proxy.sale();
    }
}

5.测试结果

从上面的代码中,我们可以看出,其实代理类(CarTradeProxy)和委托类(HafizSaleCar)好像区别并不大,我们直接创建一个HafizSaleCar对象,然后调用它的sale()方法不就好了?细心的同学你会发现,其实代理在真正调用委托类的方法之前做了中介加价的操作,这也就意味着我们使用代理模式实现在委托类的基础上增加额外的逻辑操作。

  以上就是一个很简单的静态代理的实现过程。但是这个时候我又有了一个新需求,我想用我手里的存款以及买车子赚的钱来给自己买一套新房子,那我又不想东奔西跑找房源,于是我又把买房这件事委托给了房产中介,下面我们就来实现这个逻辑。

1.再定义一个买房的接口

public interface BuyHouse {
    void buy();
}

2.重写委托类,实现卖车和买房两个接口

public class HafizTrade implements SaleCar, BuyHouse {
    @Override
    public void buy() {
        System.out.println("hafiz buy house...");
    }
    @Override
    public void sale() {
        System.out.println("hafiz sale car...");
    }
}

可以看到,我现在既要卖掉我的车子,又要购买新的房子。

3.再创建一个买房子的中介代理类

public class HouseTradeProxy implements BuyHouse {
    private HafizTrade customer;
    public HouseTradeProxy(HafizTrade customer) {
        this.customer = customer;
    }
    @Override
    public void buy() {
        System.out.println("proxy add price...");
        customer.buy();
    }
}

4.卖车子的代理类修改如下

public class CarTradeProxy implements SaleCar {
    private HafizTrade owner;
    public CarTradeProxy(HafizTrade owner) {
        this.owner = owner;
    }
    @Override
    public void sale() {
        System.out.println("proxy add price...");
        owner.sale();
    }
}

5.新的测试类

public class Client {
    public static void main(String[] args) {
        HafizTrade trader = new HafizTrade();
        CarTradeProxy carTradeProxy = new CarTradeProxy(trader);
        carTradeProxy.sale();
        System.out.println("-----------------------------------------------");
        HouseTradeProxy houseTradeProxy = new HouseTradeProxy(trader);
        houseTradeProxy.buy();
        System.out.println("-----------------------------------------------");
    }
}

6.测试结果

这样通过静态代理的方式,我们的确也可以很完美的解决我们的问题,但当我们有越来越多的委托类需要代理,而且代理做的工作又一样,那是不是会多出来很多的代理类,我们开发者会疯掉的,这时候我们就想:如果我们可以只做一次,就能代理一类委托类该多好啊?那么这个时候,动态代理就应运而生了,它可以使得我们只定义一次就能为一类委托类做代理。

三、动态代理

  静态代理要求我们在程序发布上线运行之前,就要开发好对应委托类的代理类,而动态代理是我们在程序发布之前,并没有创建好对应的代理类,而是在运行的时候动态的创建代理类。   动态代理实现方式有两种:jdk自带动态代理实现以及cglib实现。jdk代理只适合代理实现接口的目标对象,cglib可以代理没有实现接口的目标对象。

四、基于JDK实现动态代理

1.实现步骤

  1).通过实现 InvocationHandler 接口创建自己的调用处理器

  2).通过为 Proxy 类指定 ClassLoader 对象和一组 interface 来创建动态代理类

  3).通过反射机制获得动态代理类的构造函数(jdk自带,不需手动处理)

  4).通过构造函数创建动态代理类实例,构造时调用处理器对象作为参数被传入(jdk自带,不需手动处理)

2.创建代理处理器

public class ProxyHandler implements InvocationHandler {
    private Object target;
    public ProxyHandler(Object target) {
        this.target = target;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("proxy add price...");
        Object result = method.invoke(target, args);
        return result;
    }
}

3.测试类

public class Client {
    public static void main(String[] args) {
        HafizTrade trader = new HafizTrade();
        ProxyHandler handler = new ProxyHandler(trader);
        Class<? extends HafizTrade> clazz = trader.getClass();
        ClassLoader classLoader = clazz.getClassLoader();
        Class<?>[] interfaces = clazz.getInterfaces();
        SaleCar carProxy = (SaleCar)Proxy.newProxyInstance(classLoader, interfaces, handler);
        carProxy.sale();
        System.out.println("+++++++++++++++++++++++++++++++++++++++++++++++++");
        BuyHouse houseProxy = (BuyHouse)Proxy.newProxyInstance(classLoader, interfaces, handler);
        houseProxy.buy();
        System.out.println("+++++++++++++++++++++++++++++++++++++++++++++++++");

    }
}

4.测试结果

5.原理

  生成一个代理类,这个代理类继承Proxy类并且实现了我们定义的接口,代理对象调用方法的时候,调用这个代理对象的一个成员InvocationHandler(上面我们传入了一个InvocationHandler实现对象)的方法,也就是我们包装了委托类后的方法。

五、基于cglib实现动态代理

1.实现步骤

  1).通过实现CGLib包提供的MethodInterceptor接口,重写intercept方法,创建自己的方法拦截器

  2).通过CGLib中的Enhancer的creat方法创建动态代理对象

2.添加cglib的maven依赖

 <dependency>
    <groupId>cglib</groupId>
    <artifactId>cglib</artifactId>
    <version>2.2.2</version>
</dependency>

3.自定义ProxyInterceptor

public class ProxyInterceptor implements MethodInterceptor {
    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("Trade proxy add price...");
        Object result = methodProxy.invokeSuper(o, objects);
        return result;
    }
}

4.测试client

public class Client {
    public static void main(String[] args) {
        ProxyInterceptor proxy = new ProxyInterceptor();
        HafizTrade tradeProxy = (HafizTrade)Enhancer.create(HafizTrade.class, proxy);
        tradeProxy.sale();
        System.out.println("+++++++++++++++++++++++++++++++++++++++++++++++++");
        tradeProxy.buy();
    }
}

5.测试结果

6.原理

  首先通过asm字节码生成框架生成代理类Class的二进制字节码,然后通过Class.forName加载二进制字节码,生成Class对象,最后通过反射机制获取实例构造,并初始化代理类对象。

六、总结

  动态代理可以使得我们一次可以解决一批需要创建代理的问题,使得代码更加灵活,提高了程序的扩展性。动态代理在主流java框架中也非常常用,比如最著名的spring,它在AOP的功能就是使用动态代理实现,还有Dubbo等这样的RPC服务框架,在客户端都是通过代理完成服务的真正调用。了解和学会代理以及实现方式能帮助我们更好地理解主流框架。

  关于动态代理的实现细节,可以参考:http://www.360doc.com/content/14/0801/14/1073512_398598312.shtml#

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏北京马哥教育

Python错误及异常总结汇总

程序员的一生中,错误几乎每天都在发生。在过去的一个时期, 错误要么对程序(可能还有机器)是致命的,要么产生一大堆无意义的输出,无法被其他计算机或程序识别,连程...

440110
来自专栏Python

python编码问题一点通

一、了解字符编码的知识储备   1. 文本编辑器存取文件的原理(nodepad++,pycharm,word)      打开编辑器就打开了启动了一个进程,是...

26680
来自专栏PHP在线

PHP底层的运行机制与原理

PHP说简单,但是要精通也不是一件简单的事。我们除了会使用之外,还得知道它底层的工作原理。 PHP是一种适用于web开发的动态语言。具体点说,就是一个用C语言实...

1.3K60
来自专栏极客编程

ECMAScript 6教程 (一)

本文版权归作者和博客园共有,欢迎转载,但未经作者同意必须保留此段声明,且在文章页面明显位置给出 原文连接,博客地址为 http://www.cnblogs.co...

9720
来自专栏从零开始学 Web 前端

C/C++练习题(三)

分析:在我们看来,虽然使用字符数组和字符指针差不多,printf都可以打印出字符串出来,但是编译器对他们的处理完全不同。 对于字符指针,编译器看到后,...

91040
来自专栏我的博客

if和else匹配问题以及switch问题

$b = 1; $a = 2; if ($a > 1) { echo ‘1’; if ($b > 2) { echo ‘2’; } } else ...

362110
来自专栏程序员宝库

48 条高效率的 PHP 优化写法

能用PHP内部字符串操作函数的情况下,尽量用他们,不要用正则表达式, 因为其效率高于正则。

25440
来自专栏微信终端开发团队的专栏

C# 内存管理机制及 WP 内存泄漏定位方法

C#内存管理机制及WP内存泄漏定位方法 一、C#的内存管理机制 1. 托管资源与非托管资源 什么是托管资源?托管资源通俗的理解就是,把资源交给.net去管理,这...

43870
来自专栏编程

Go中defer的5 个坑-第一部分

首发于:https://studygolang.com/articles/12061 Go 中 defer 的 5 个坑 - 第一部分 通过本节的学习以避免掉入...

26150
来自专栏Python专栏

Python | 19个优雅的Python编程技巧

http://lovesoo.org/pythonic-python-programming.html

33230

扫码关注云+社区

领取腾讯云代金券