设计模式-代理模式

最新推荐文章于 2024-02-27 15:46:00 发布
最新推荐文章于 2024-02-27 15:46:00 发布
阅读量100 收藏
点赞数
分类专栏： 笔记 Java学习心得
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hfx_fmxd/article/details/112253366
版权

目录

说明

在代理模式(Proxy Pattern)中，我们创建具有现有对象的对象，以便向外界提供功能接口。一个类代表另一个类的功能。这种类型的设计模式属于结构型模式。

问题来源

在直接访问对象时带来的问题，比如说：要访问的对象在远程的机器上。在面向对象系统中，有些对象由于某些原因（比如对象创建开销很大，或者某些操作需要安全控制，或者需要进程外的访问），直接访问会给使用者或者系统结构带来很多麻烦，我们可以在访问此对象时加上一个对此对象的访问层。

解决方案

增加中间层，实现与被代理类组合。

优点
  1. 代理模式在客户端与目标对象之间起到一个中介作用和保护目标对象的作用；
  2. 代理对象可以扩展目标对象的功能
  3. 代理模式能将客户端与目标对象分离，在一定程度上降低了系统的耦合度，增加了程序的可扩展性
缺点
  1. 代理模式会造成系统设计中类的数量增加
  2. 在客户端和目标对象之间增加一个代理对象，会造成请求处理速度变慢
  3. 增加了系统的复杂度
模式结构
  1. 抽象主题（Subject）类：通过接口或抽象类声明真实主题和代理对象实现的业务方法。
  2. 真实主题（Real Subject）类：实现了抽象主题中的具体业务，是代理对象所代表的真实对象，是最终要引用的对象。
  3. 代理（Proxy）类：提供了与真实主题相同的接口，其内部含有对真实主题的引用，它可以访问、控制或扩展真实主题的功能。
应用场景
  1. 远程代理，这种方式通常是为了隐藏目标对象存在于不同地址空间的事实，方便客户端访问。例如，用户申请某些网盘空间时，会在用户的文件系统中建立一个虚拟的硬盘，用户访问虚拟硬盘时实际访问的是网盘空间。
  2. 虚拟代理，这种方式通常用于要创建的目标对象开销很大时。例如，下载一幅很大的图像需要很长时间，因某种计算比较复杂而短时间无法完成，这时可以先用小比例的虚拟代理替换真实的对象，消除用户对服务器慢的感觉。
  3. 安全代理，这种方式通常用于控制不同种类客户对真实对象的访问权限。
  4. 智能指引，主要用于调用目标对象时，代理附加一些额外的处理功能。例如，增加计算真实对象的引用次数的功能，这样当该对象没有被引用时，就可以自动释放它。
  5. 延迟加载，指为了提高系统的性能，延迟对目标的加载。例如，Hibernate 中就存在属性的延迟加载和关联表的延时加载。

示例

现在有两家工厂，生产不同的东西。现在有个人来考察，需要知道生产时间。但是又不能直接控制工厂进行生产，这时，就需要引入代理人。

工厂
工厂接口
package com.designpattern.proxy.objects;

public interface Factory {
    void create();
}
食品工厂
package com.designpattern.proxy.objects.factory;

import com.designpattern.proxy.objects.Factory;

import java.util.Random;

public class FoodFactory implements Factory {
    @Override
    public void create() {
        System.out.println("[FoodFactory] Start to create food.");
        try {
            Thread.sleep(new Random().nextInt(10000));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("[FoodFactory] Food is created.");
    }

    @Override
    public String toString() {
        return "FoodFactory";
    }
}
饮料工厂
package com.designpattern.proxy.objects.factory;

import com.designpattern.proxy.objects.Factory;

import java.util.Random;

public class DrinkFactory implements Factory {
    @Override
    public void create() {
        System.out.println("[DrinkFactory] Start to create drink.");
        try {
            Thread.sleep(new Random().nextInt(10000));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("[DrinkFactory] Drink is created.");
    }

    @Override
    public String toString() {
        return "DrinkFactory";
    }
}

代理模式一般有两种，静态代理和动态代理。

静态代理

静态代理其实就是实现和被代理对象相同的接口，并把被代理对象作为自身的类属性添加进来。在实现接口的方法是，除了自身的一些内容外，必须有被代理对象来执行自己的实现方法。

条件：

  1. 实现和被代理对象一致的接口
  2. 被代理对象作为自身的类属性
  3. 调用被代理对象的实现方法
代理工厂
package com.designpattern.proxy.staticproxy;

import com.designpattern.proxy.objects.Factory;

public class FactoryProxy implements Factory {
    private Factory factory;

    public FactoryProxy() {
    }

    public FactoryProxy(Factory factory) {
        this.factory = factory;
    }

    public Factory getFactory() {
        return factory;
    }

    public void setFactory(Factory factory) {
        this.factory = factory;
    }

    @Override
    public void create() {
        long start = System.currentTimeMillis();
        factory.create();
        long end = System.currentTimeMillis();
        System.out.println(factory + " costs time is " + (end - start) / 1000 + " seconds");
    }
}
调用检查
package com.designpattern.proxy.staticproxy;

import com.designpattern.proxy.objects.factory.DrinkFactory;
import com.designpattern.proxy.objects.factory.FoodFactory;

public class Application {
    public static void main(String[] args) {
        FactoryProxy proxy = new FactoryProxy();
        //需要代理谁，就把谁放进去
        proxy.setFactory(new FoodFactory());
        proxy.create();
        proxy.setFactory(new DrinkFactory());
        proxy.create();
    }
}
动态代理

动态代理使用java jdk自身的Proxy类来完成，需要满足三个条件：

  1. 实例化被代理类
  2. 获取被代理类的类加载器和接口
  3. 实现代理处理方案接口InvocationHandler
代理处理方案

也可以使用匿名内部类来实现。

package com.designpattern.proxy.proxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

public class ProxyFactoryHandler implements InvocationHandler {
    private Object factory;

    public ProxyFactoryHandler(Object factory) {
        this.factory = factory;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        long start = System.currentTimeMillis();
        proxy = method.invoke(factory, args);//使用需要被代理的对象
        long end = System.currentTimeMillis();
        System.out.println(method + " costs time is " + (end - start) / 1000 + " seconds");
        return proxy;
    }
}
调用检查
package com.designpattern.proxy.proxy;

import com.designpattern.proxy.objects.Factory;
import com.designpattern.proxy.objects.factory.DrinkFactory;
import com.designpattern.proxy.objects.factory.FoodFactory;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class Application {
    public static void main(String[] args) {
        //Save the generate files
        System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles","true");
        //abstract Inner Class
        final Factory food = new FoodFactory();
        Factory foodProxy = (Factory) Proxy.newProxyInstance(food.getClass().getClassLoader(), food.getClass().getInterfaces(), new InvocationHandler() {

            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                long start = System.currentTimeMillis();
                proxy = method.invoke(food, args);//使用需要被代理的对象
                long end = System.currentTimeMillis();
                System.out.println(method + " costs time is " + (end - start) / 1000 + " seconds");
                return proxy;
            }
        });
        foodProxy.create();
        //Outer Class
        Factory drink = new DrinkFactory();
        Factory drinkProxy = (Factory) Proxy.newProxyInstance(drink.getClass().getClassLoader(), drink.getClass().getInterfaces(), new ProxyFactoryHandler(drink));
        drinkProxy.create();
    }
}

总结

代理模式主要的实际应用还是在Spring的框架中使用的比较多。使用的时候可以通过注解或者配置使用。

Spring中的代理

引入jar包：

<dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.2.9.RELEASE</version>
        </dependency>
<!--AOP需要引入的基类-->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.6</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjrt</artifactId>
            <version>1.9.6</version>
        </dependency>
        <dependency>
            <groupId>aopalliance</groupId>
            <artifactId>aopalliance</artifactId>
            <version>1.0</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjlib</artifactId>
            <version>1.6.2</version>
        </dependency>
<!--AOP需要引入的基类-->
第一种方式，使用xml配置
<?xml version="1.0" encoding="UTF-8" ?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:aop="http://www.springframework.org/schema/aop" xsi:schemaLocation="
        http://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd">

<!--bean-->
    <bean id="food" class="com.designpattern.proxy.objects.factory.FoodFactory"/>
    <bean id="drink" class="com.designpattern.proxy.objects.factory.DrinkFactory"/>
    <bean id="proxy" class="com.designpattern.proxy.springproxy.FactoryProxy"/>

<!--AOP-->
    <!-- 设置AOP使用JDK自己的方式来自动生成代理 -->
    <aop:aspectj-autoproxy proxy-target-class="true"/>
    <aop:config>
        <aop:aspect id="proxyFactory" ref="proxy">
            <!--execution的参数：(返回值 方法路径(..) 参数配置)-->
            <aop:pointcut id="foodCreate" expression="execution(* com.designpattern.proxy.objects.factory.FoodFactory.create(..))"/>
            <aop:before method="before" pointcut-ref="foodCreate"/>
            <aop:after method="after" pointcut-ref="foodCreate"/>
        </aop:aspect>
    </aop:config>

    <aop:config>
        <aop:aspect id="proxyFactory" ref="proxy">
            <aop:pointcut id="drinkCreate" expression="execution(* com.designpattern.proxy.objects.factory.DrinkFactory.create(..))"/>
            <aop:before method="before" pointcut-ref="drinkCreate"/>
            <aop:after method="after" pointcut-ref="drinkCreate"/>
        </aop:aspect>
    </aop:config>

</beans>

代理类修改如下：

package com.designpattern.proxy.springproxy;

public class FactoryProxy {
    long time;
    public void before() {
        time = System.currentTimeMillis();
    }

    public void after() {
        System.out.println("Cost time is " + (System.currentTimeMillis() - time));
    }
}

调用

package com.designpattern.proxy.springproxy;

import com.designpattern.proxy.objects.Factory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Application {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("/proxy/spring/spring.xml");
        Factory food = (Factory) context.getBean("food");
        food.create();
        Factory drink = (Factory) context.getBean("drink");
        drink.create();
    }
}
第二种方式，使用注解
<?xml version="1.0" encoding="UTF-8" ?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:aop="http://www.springframework.org/schema/aop" xsi:schemaLocation="
        http://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd">

<!--bean-->
    <bean id="food" class="com.designpattern.proxy.objects.factory.FoodFactory"/>
    <bean id="drink" class="com.designpattern.proxy.objects.factory.DrinkFactory"/>
    <bean id="proxy" class="com.designpattern.proxy.springbootproxy.ProxyFactory"/>

    <aop:aspectj-autoproxy proxy-target-class="true"/>
</beans>

代理类修改

package com.designpattern.proxy.springbootproxy;

import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;

@Aspect
public class ProxyFactory {
    long time;
    @Before("pointCut()")
    public void before() {
        time = System.currentTimeMillis();
    }

    @After("pointCut()")
    public void after() {
        System.out.println("Cost time is " + (System.currentTimeMillis() - time));
    }

    @Pointcut("execution(** com.designpattern.proxy.objects.factory.*.create(..))")
    public void pointCut() {

    }
}

调用

package com.designpattern.proxy.springbootproxy;

import com.designpattern.proxy.objects.Factory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Application {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("/proxy/springboot/spring.xml");
        Factory food = (Factory) context.getBean("food");
        food.create();
        Factory drink = (Factory) context.getBean("drink");
        drink.create();
    }
}
风之轩墨
关注
专栏目录
设计模式 - 代理模式
菜鸟小码的博客
08-15 696
代理模式（Proxy Pattern）是一种常用的设计模式，它为另一个对象提供一个代理以控制对这个对象的访问。代理模式可以实现延迟加载、访问控制、日志记录等功能。本文将详细介绍代理模式的概念，并通过具体的Java代码示例来说明如何实现这一模式。
proxy connect abort处理方法_跨域浅谈处理办法
weixin_39746869的博客
11-23 1221
一.跨域简述 JavaScript出于安全方面的考虑，不允许跨域调用其他页面的对象。 首先什么是跨域，简单地理解就是因为JavaScript同源策略的限制，http://a.com 域名下的js无法操作http://b.com或是http://c.a.com域名下的对象。引用自:跨域访问 | IWEN 半仙儿​www.wwtliu.com二.React环境中跨域分类1.开发环境跨域处理2.生产环境...
设计模式之代理设计模式(Proxy)之 (2)动态代理(JDK)
MrLiar的博客
03-28 166
动态代理：在实现阶段不用关心代理类的具体实现，而是在运行时才生成代理对象（JAVA中是通过反射实现，具体见下文）平台或者三方库有提供。动态代理的扩展性更高，所以一般一些开源框架都会使用。 /* * 接口 */ public interface ISinger { void sing(); } /** * 目标对象Singer1 实现了某一接口 */ public class ...
反射应用：动态代理
闰土的博客
11-21 188
package com.atguigu.dynamicProxies; import java.lang.reflect.InvocationHandler; import java.lang.reflect.Proxy; /** * @author 杜润伍 * @version 1.0 */ //动态代理举例 interface interfaceTest{ String getBelief(); void Object(String name); } //创建被代理类 cl
反射的应用动态代理【Java】
qq_56402474的博客
04-19 650
讲解了动态代理已经详细代码。 动态代理是指客户通过代理类来调用其它对象的方法，并且是在程序运行时根据需要动态创建目标类的代理对象。
深入理解ngx_http_proxy_connect_module模块(上）
一个致力于开源代码学习、分析和交流的博客
02-27 2356
本文详细对ngx_http_proxy_connect_module的使用和源码进行了分析。
Proxy-Connection 和 Connection 有什么区别
ip16yun的博客
05-08 655
比如，如果代理是 1.0 的，但是服务器是 1.1 的，那么服务器可能会发送 Connection: keep-alive 给代理，但是代理不认识这个头，所以会转发给浏览器。如果浏览器发送的请求是 HTTP/1.1 版本，那么默认是保持连接的，所以不需要发送 Proxy-Connection: keep-alive。如果浏览器发送的请求是 HTTP/1.0 版本，那么默认是关闭连接的，所以需要发送 Proxy-Connection: keep-alive 来告诉代理希望保持连接。
java常用设计模式-代理模式
08-26
Java 设计模式 - 代理模式 代理模式（Proxy Pattern）是一种常用的设计模式，提供了间接访问目标对象的一种方式，即通过代理对象访问目标对象。这样做的好处是，可以在不改变原有目标对象的基础上，对目标对象增加...
基于Java的设计模式-代理模式demo的实现（高分课设）
最新发布
05-29
基于Java的设计模式——代理模式demo的实现（高分课设）个人经导师指导并认可通过的98分大作业设计项目，适用人群：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业或毕业设计，作为“参考资料”使用...
c++设计模式-结构型模式-代理模式
06-12
代理模式是一种在面向对象设计中广泛应用的结构型设计模式，它提供了一种对目标对象进行间接访问的方式，使得客户端可以通过代理对象与真实对象进行交互，而无需直接接触真实对象。这样做的好处包括增加灵活性、控制...
proxy connect abort处理方法_InfoQ 技术大会 | 腾讯基于 Proxy 的代码执行监听上报实践...
weixin_39521068的博客
12-18 137
作者 | 樊东东 编辑 | 冉叶兰 随着移动设备的普及，兼容性和性能测试正在逐渐成为前端测试面临的两大挑战，再加上前端代码主要运行在客户设备上的特性，各种安全性挑战又层出不穷，我们该如何应对和解决？腾讯高级 Web 前端工程师樊东东在 GMTC 全球大前端技术大会（深圳站）2019 分享了 《基于 Proxy 的代码执行监听上报》，介绍了前端 SDK 基于 ES6 Proxy 的深度日志收集以及...
Java动态代理Proxy类
斯文~
06-30 924
Java中代理的代表类是：java.lang.reflect.Proxy 提供了一个静态方法，用于为对象产生一个代理对象返回。建议阅读Proxy的文档说明。代理主要是对对象的行为额外做一些辅助操作，以实现对原有方法的扩展。关键步骤 1.必须有接口，实现类要实现接口（代理通常是基于接口实现的）； 2.创建一个实现类的对象，该对象为业务对象，紧接着为业务对象做一个代理对象；动态代理的优点通过代理调用方法的执行流程代码示例Test.java ......
Nginx proxy_connect代理模块
haodayizhizhuzhu的博客
02-10 2155
个人看着有意思，简单留个记号。
nginx(六十三)proxy模块(四)与上游服务器建立连接
wzj_110的博客
11-24 1497
proxy模块与上游服务器建立连接
帮你彻底搞懂JS中的prototype、__proto__与constructor（图解）
热门推荐
码飞_CC的博客
07-25 18万+
  作为一名前端工程师，必须搞懂JS中的prototype、__proto__与constructor属性，相信很多初学者对这些属性存在许多困惑，容易把它们混淆，本文旨在帮助大家理清它们之间的关系并彻底搞懂它们。这里说明一点，__proto__属性的两边是各由两个下划线构成（这里为了方便大家看清，在两下划线之间加入了一个空格：_ _proto_ _）。   现在正式开始！让我们从如下一个简单的例...
proxyconnect refused
cheru9250的博客
07-12 3796
Post http://192.168.3.2:8080: proxyconnect tcp: dial tcp 127.0.0.1:41390: connect: connection refused 开了代理，关闭即可 ...
Nginx之ngx_http_proxy_connect_module模块
小米bb的博客
03-31 2万+
近期由于项目需要使用到https正向代理，而nginx官方模块仅支持做http正向代理，一番百度学习后发现了该模块，故今日记录下此笔记供大家一起学习交流 ngx_http_proxy_connect_module模块主要用于隧道SSL请求的代理服务器 GitHub地址：http://www.github.com/chobits/ngx_http_proxy_connect_module ngi...
git pull 时遇到proxyconnect tcp: tls: oversized record received with length 20527
缘外有缘的专栏
01-07 3951
错误原因：      https_proxy中错误使用了https的地址 1. 检查https_proxy设置： echo $https_proxy 如果输出的结果中是https开头的url地址 2. 解决办法 export https_proxy=http://agent.youwebsite.com:port 3.再次重试git pull即可 注意：设置https_prox...
Java设计模式：代理模式详解
"Java设计模式之代理模式篇上" 在软件开发中，代理模式是一种常用的设计模式，它允许我们创建一个代表另一个对象的对象，这个代表对象（代理）可以在调用真实对象的方法之前或之后添加额外的功能，或者控制对真实...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值