Java设计模式之结构型-代理模式 (Proxy)

已于 2024-02-05 11:22:54 修改
阅读量462 收藏
点赞数
分类专栏： 设计模式 文章标签： 设计模式
于 2020-02-26 23:31:08 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Dh_Chao/article/details/104527723
版权

👉文章示例代码👈

附链

你也可以在这些平台阅读本文：

定义

为其他对象提供一种代理用来控制对这个对象的访问。

在代理模式中，代理对象作为访问对象和目标对象之间的中介。

场景示例

笔者这里以购买火车票为例。我们购买火车票不一定要去火车站购买，我们可以通过12306网站或者去火车票代售点购买。

基于继承的静态代理实现

创建目标对象

/**
 * @author zhh
 * @description 火车站(目标对象)
 * @date 2020-02-26 21:44
 */
public class Station {

    /**
     * 姓名
     */
    private String username;

    /**
     * 始发站
     */
    private String start;

    /**
     * 终点站
     */
    private String end;

    public Station(String username, String start, String end) {
        this.username = username;
        this.start = start;
        this.end = end;
    }

    // 此处省略getter、setter方法

    public void buy() {
        System.out.println(String.format("%s购买了从%s至%s的火车票", username, start, end));
    }
}

创建代理对象

/**
 * @author zhh
 * @description 12306网站类(代理对象)
 * @date 2020-02-26 21:47
 */
public class Website12306 extends Station {

    public Website12306(String username, String start, String end) {
        super(username, start, end);
    }

    @Override
    public void buy() {
        // 模拟日志打印
        System.out.println(String.format("【打印日志】 %s在12306平台上购买从%s至%s的火车票", getUsername(), getStart(), getEnd()));
        super.buy();
    }
}

测试类及输出

/**
 * @author zhh
 * @description 测试类
 * @date 2020-02-26 21:54
 */
public class Test {

    public static void main(String[] args) {
        Station station = new Website12306("海豪", "诸暨", "杭州");
        station.buy();
    }
}

测试类的输出结果如下：

【打印日志】 海豪在12306平台上购买从诸暨至杭州的火车票
海豪购买了从诸暨至杭州的火车票

类结构图

以上示例类的结构图如下所示

从上述示例代码中，我们可以看到，代理对象中的 buy() 方法实际上最终调用的是目标对象的 buy() 方法，同时我们也可以在代理对象中对方法进行增强。

基于接口的静态代理实现

创建抽象接口

可以是接口也可以是抽象类。

/**
 * @author zhh
 * @description 抽象接口
 * @date 2020-02-26 21:44
 */
public interface Station {

    void buy();
}

创建目标对象

/**
 * @author zhh
 * @description 诸暨火车站(目标对象)
 * @date 2020-02-26 22:10
 */
public class ZhuJiStation implements Station {

    /**
     * 姓名
     */
    private String username;

    /**
     * 始发站
     */
    private String start;

    /**
     * 终点站
     */
    private String end;

    public ZhuJiStation(String username, String start, String end) {
        this.username = username;
        this.start = start;
        this.end = end;
    }

    // 此处省略getter、setter方法

    public void buy() {
        System.out.println(String.format("%s购买了从%s至%s的火车票", username, start, end));
    }
}

创建代理对象

/**
 * @author zhh
 * @description 12306网站类(代理对象)
 * @date 2020-02-26 21:47
 */
public class Website12306 implements Station {

    /**
     * 姓名
     */
    private String username;

    /**
     * 始发站
     */
    private String start;

    /**
     * 终点站
     */
    private String end;

    private Station station;

    public Website12306(String username, String start, String end) {
        this.username = username;
        this.start = start;
        this.end = end;
    }

    public void buy() {
        // 模拟日志打印
        System.out.println(String.format("【打印日志】 %s在12306平台上购买从%s至%s的火车票", username, start, end));
        if (station == null) {
            station = new ZhuJiStation(username, start, end);
        }
        station.buy();
    }
}

测试类及输出

/**
 * @author zhh
 * @description 测试类
 * @date 2020-02-26 21:54
 */
public class Test {

    public static void main(String[] args) {
        Station station = new Website12306("海豪", "诸暨", "杭州");
        station.buy();
    }
}

测试类的输出结果如下：

【打印日志】 海豪在12306平台上购买从诸暨至杭州的火车票
海豪购买了从诸暨至杭州的火车票

类结构图

以上示例类的结构图如下所示

这种方式需要目标对象和代理对象实现同一个接口或者继承同一个抽象类。

基于JDK动态代理实现

基于JDK动态代理的实现，主要依赖的是 Proxy 类的 newProxyInstance() 方法和 InvocationHandler 类的 invoke() 方法。

而且JDK动态代理不能够代理类，只能够基于接口实现。

创建抽象接口

这个地方只能是接口。

/**
 * @author zhh
 * @description 抽象接口
 * @date 2020-02-26 21:44
 */
public interface Station {

    void buy();
}

创建目标对象

/**
 * @author zhh
 * @description 诸暨火车站(目标对象)
 * @date 2020-02-26 22:10
 */
public class ZhuJiStation implements Station {

    /**
     * 姓名
     */
    private String username;

    /**
     * 始发站
     */
    private String start;

    /**
     * 终点站
     */
    private String end;

    public ZhuJiStation(String username, String start, String end) {
        this.username = username;
        this.start = start;
        this.end = end;
    }

    // 此处省略getter、setter方法

    public void buy() {
        System.out.println(String.format("%s购买了从%s至%s的火车票", username, start, end));
    }
}

创建动态代理类

/**
 * @author zhh
 * @description 动态代理类
 * @date 2020-02-26 22:32
 */
public class StationDynamicProxy implements InvocationHandler {

    private Object target;

    public StationDynamicProxy(Object target) {
        this.target = target;
    }

    public Object bind() {
        Class clazz = target.getClass();
        return Proxy.newProxyInstance(clazz.getClassLoader(), clazz.getInterfaces(), this);
    }

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 模拟日志打印
        System.out.println("【日志打印】真实操作之前进行日志打印");
        return method.invoke(target, args);
    }
}

测试类及输出

/**
 * @author zhh
 * @description 测试类
 * @date 2020-02-26 21:54
 */
public class Test {

    public static void main(String[] args) {
        Station station = (Station) new StationDynamicProxy(new ZhuJiStation("海豪", "诸暨", "杭州")).bind();
        station.buy();
    }
}

测试类的输出结果如下：

【日志打印】真实操作之前进行日志打印
海豪购买了从诸暨至杭州的火车票

类结构图

以上示例类的结构图如下所示

基于CGLib动态代理实现

CGLib是针对于类的代理模式，使用CGLib就必须实现 MethodInterceptor 接口。

创建目标对象

/**
 * @author zhh
 * @description 诸暨火车站(目标对象)
 * @date 2020-02-26 22:10
 */
public class ZhuJiStation {

    /**
     * 姓名
     */
    private String username;

    /**
     * 始发站
     */
    private String start;

    /**
     * 终点站
     */
    private String end;

    // 此处忽略getter、setter方法

    public void buy() {
        System.out.println(String.format("%s购买了从%s至%s的火车票", username, start, end));
    }
}

创建动态代理类

/**
 * @author zhh
 * @description 动态代理类
 * @date 2020-02-26 22:32
 */
public class StationDynamicProxy implements MethodInterceptor {

    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        // 模拟日志打印
        System.out.println("【日志打印】真实操作之前进行日志打印");
        return methodProxy.invokeSuper(o, objects);
    }
}

测试类及输出

/**
 * @author zhh
 * @description 测试类
 * @date 2020-02-26 21:54
 */
public class Test {

    public static void main(String[] args) {
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(ZhuJiStation.class);
        enhancer.setCallback(new StationDynamicProxy());
        ZhuJiStation proxy = (ZhuJiStation) enhancer.create();
        proxy.setUsername("海豪");
        proxy.setStart("诸暨");
        proxy.setEnd("杭州");
        proxy.buy();
    }
}

测试类的输出结果如下：

【日志打印】真实操作之前进行日志打印
【日志打印】真实操作之前进行日志打印
【日志打印】真实操作之前进行日志打印
【日志打印】真实操作之前进行日志打印
海豪购买了从诸暨至杭州的火车票

类结构图

以上示例类的结构图如下所示

CGLib摆脱了对于 Proxy 的依赖，从而避免了创建代理类必须继承 Proxy 的限制。

总结

适用场景

访问对象不适合或者不能直接引用目标对象。

优点

  • 将访问对象和目标对象分离，降低了系统的耦合度。
  • 扩展性好，可以扩展目标对象的功能。
  • 可以保护、增强目标对象。

缺点

  • 增加了系统的复杂度。
  • 在客户端和目标对象之间增加一个代理对象，会造成请求处理速度变慢。

扩展

代理方式

  • 静态代理：通过在代码中显示地定义一个业务实现类的一个代理，在代理类中对同名的业务方法进行包装，用户通过调用代理类的被包装过的业务方法来调用目标对象的业务方法。同时对目标对象的业务方法进行增强。
  • JDK动态代理：是通过接口中的方法名，在动态生成的代理类中调用业务实现类的同名方法。
  • CGLib动态代理：是通过继承来实现的，生成的动态代理类是业务类的子类，通过重写业务方法进行代理。

Spring代理选择

  • 当Spring中的Bean有实现接口时，Spring会用JDK的动态代理。
  • 当Spring中的Bean没有实现接口时，Spring会使用CGLib动态代理。

可以强制Spring使用CGLib动态代理(在Spring的配置中添加 <aop:aspectj-autoproxy proxy-target-class="true" )。

参考

黑豪Horace
关注
专栏目录
Java结构型设计模式-代理模式
欢迎拜读我的作品，喜欢的领域请给我留言
08-12 1026
代理模式（）是常用的结构型设计模式之一，其定义如下：Provide a surrogate or placeholder for another object to control access to it.（为其他对象提供一种代理以控制对这个对象的访问。关于代理模式介绍就到这里，通过本文的学习，我们清楚知道代理设计模式的主要用途是控制访问或提供包装器实现以获得更好的性能。
java的代理模式
qq_40820916的博客
10-29 1891
java的三种代理模式简介静态代理jdk动态代理cglib实现动态代理 简介 代理模式的定义： 为其他对象提供一种代理以控制对这个对象的访问。在某些情况下，一个对象不适合或者不能直接引用另一个对象，而代理对象可以在客户端和目标对象之间起到中介的作用。 以上为百度百科对代理模式的定义；通俗一点讲，java中的代理模式就是你想要访问一个目标对象，但是不直接访问它，而是通过它的代理对象访问（因为代理对象可以对目标对象做增强操作），这就是java的代理模式。示意图如下： 在java中，有三种代理模式，分别为静态代
JavaWeb工程下，基于代理模式的两种层次结构比较分析
各研发管理
12-11 89
对于JavaWeb工程，个人认为很多人后台处理是非常高深的事情，其实通过这段时间的理解与实践，我个人感觉要想把后台写的漂亮，无非需要注意两点：一是对于javase的编程理解，二是对框架搭建的理解。在这两点之上我认为贯穿整个后台设计之中的是编程人员时刻清晰的思路。下面是我对近期发现的两个web框架搭建方法的一些感悟，其实本人也是菜鸟一只，理解比较肤浅，不过对于刚刚入门的同僚，我相信还是有帮助的。 ...
java动态代理Proxy.newProxyInstance
追逐消失的记忆
12-03 2771
利用Java的反射技术(Java Reflection)，在运行时创建一个实现某些给定接口的新类（也称“动态代理类”）及其实例（对象）,代理的是接口(Interfaces)，不是类(Class)，也不是抽象类。在运行时才知道具体的实现，spring aop就是此原理。 在spring中主要处理业务思路的两种方式， 一、通过动态代理的原理，使需要进行切面处理的业务。通过代理技术将需要切入的业务前...
java代理学习
王举
11-26 4601
基于接口的动态代理，实际上是在内存中生成了一个对象，该对象实现了指定的目标类对象拥有的接口，所以代理类和目标类对象是兄弟关系。
《Java设计模式》课后答案-刘伟.rar
07-29
结构型设计模式包括适配器（Adapter）、桥接（Bridge）、装饰（Decorator）、外观（Facade）、享元（Flyweight）、组合（Composite）和代理（Proxy）。这些模式帮助我们更好地组织类和对象之间的关系，实现松耦合，...
java 设计模式之代理模式（Proxy Pattern）实现代码及设计详解：动态代理模式、静态代理模式
最新发布
03-13
在这些模式中，代理模式（Proxy Pattern）是一种常用的结构型设计模式，它允许我们为一个对象创建一个代理，该代理对象在客户端和目标对象之间起到中介的作用，可以增加额外的功能或控制访问。 代理模式分为两种...
详解设计模式中的proxy代理模式及在Java程序中的实现
10-31
代理模式是一种结构型设计模式，它创建了对象的一个代理以控制对这个对象的访问。代理对象在客户端和目标对象之间起到中介的作用，它可以添加额外的职责或者增强原有功能，同时不影响目标对象的原有行为。 2. **...
软件体系结构---设计模式的java运行代码案例
07-16
结构型模式如适配器（Adapter）、装饰器（Decorator）、代理（Proxy）和桥接（Bridge）等，关注如何组合和组装对象，使不同组件之间可以协同工作，增强系统的结构。 行为型模式如观察者（Observer）、策略...
【Java】代理模式（Proxy模式）详解
Passer_hua的博客
01-21 2万+
Java代理模式详解
Java进阶 | Proxy动态代理机制详解
【积累】，是一个长期持续的过程。
06-28 3381
在说Java动态代理之前，还是要说一下Jvm加载对象的过程，这个依旧是理解动态代理的基础性原理Java类即源代码程序.java类型文件，经过编译器编译之后就被转换成字节代码.class类型文件，类加载器负责读取字节代码，并转换成java.lang.Class对象，描述类在元数据空间的数据结构，类被实例化时，堆中存储实例化的对象信息，并且通过对象类型数据的指针找到类。所以通过New创建对象，独断其背后很多实现细节，理解上述过程之后，再了解一个常用的设计模式，即代理模式。...
java代理的使用尝试过程Proxy.newProxyInstance
正在飞翔的猫的
07-17 4126
Proxy.newProxyInstance是实现java对象的动态代理的方法，他的三个参数loader、 interfaces、h分别代表是需求代理的接口的加载器、 代理接口列表、this。注意，只能代理接口，不能代理类或者抽象类。 @CallerSensitive public static Object newProxyInstance(ClassLoader loader, ...
Java的动态代理机制详解
chuifuhuo6864的博客
03-03 309
学习Java的同学注意了！！！ 学习过程中遇到什么问题或者想获取学习资源的话，欢迎加入Java学习交流群，群号码：183993990 我们一起学Java！ 在学习Spring的时候，我们知道Spring主要有两大思想，一个是Io...
从Proxy.newProxyInstance说起
热门推荐
dan_xp的专栏
10-11 4万+
  最近一直在看java的设计模式 ,感觉印象最深刻的就是"面向接口编程",在java中,尽量多定义接口,因为设计的最重要的目的就是应对各种变化,而接口本身就是一种变化着的Class的直接反映,通过实现特定接口的各种具体类,达到应对变化的目的,下面以Proxy模式为例:Proxy的模式最主要的目的,原有的类对象由于某种原因不能访问,需要通过一个新的类来间接地去实现,这个新的类就称为代理类,举个
Java-动态代理Proxy.newProxyInstance
qq_43563885的博客
10-22 360
动态代理(dynamic proxy) 利用Java反射(reflection),在创建一个实现某些给定接口的新类（动态代理类）及其实例对象，代理的是接口（interfaces）,不是类,也不是抽象类，在运行时才知道具体的实现，spring AOP就是此原理。 例子：定义一个接口 /** * * @author WangHeng * */ public interface Target...
使用Proxy.newProxyInstance()代理时，报错java.lang.ClassCastException: com.sun.proxy.$Proxy61
追梦
11-26 4264
Proxy.newProxyInstance()做动态代理，只能是代理接口和实现类。不能代理抽象类和实现类。不然就会报转换异常错误。
Java - 动态代理机制讲解（Proxy.newProxyInstance）
活在梦里
04-12 608
转：https://blog.csdn.net/Dream_Weave/article/details/84183247
java对于接口和抽象类的代理实现，不需要有具体实现类
我的技术旅程
06-12 1058
原文链接：http://www.javaarch.net/jiagoushi/835.htm   java对于接口和抽象类的代理实现，不需要有具体实现类 在某些场景下，可能我们只需要定义接口或者抽象类，而具体实现或者可以从接口的annotation就可以知道具体实现，后者具体实现由其他动态语言实现，或者需要实现AOP的一些其他功能，我们不需要具体实现，那么我们有哪些方法可以来实现这样的功能...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值