登录 注册

设计模式学习笔记之代理模式

本贴最后更新于 1737 天前，其中的信息可能已经时移世易

前言

这是一篇学习笔记，内容很多是来源于网上的资料，然后按照自己学习情况进行的总结，有些是自身的感受，有些是网上比较好的资料的引用。

如果有人看到我写的笔记有不对的地方欢迎留言指出来，是真的欢迎指出来，因为我可能会错很久，然后才发现。学习技术不能闭门造车，要多交流，多讨论，多思考才能成长的快，学的快。

我的个人博客：海加尔金鹰

什么是代理模式

代理模式的定义：

代理模式的定义：为其他对象提供一种代理以控制对这个对象的访问。

根据代理类的创建时机和创建方式的不同，可以将其分为静态代理和动态代理两种形式：在程序运行前就已经存在的编译好的代理类是为静态代理，在程序运行期间根据需要动态创建代理类及其实例来完成具体的功能是为动态代理。代理模式的目的就是为真实业务对象提供一个代理对象以控制对真实业务对象的访问，代理对象的作用有：
代理对象存在的价值主要用于拦截对真实业务对象的访问；
代理对象具有和目标对象(真实业务对象)实现共同的接口或继承于同一个类；
代理对象是对目标对象的增强，以便对消息进行预处理和后处理。1

静态代理

说明及主要结构

说明：
静态代理需要先定义一个公共接口，然后被代理对象和代理对象一起实现公共接口。
结构图：

graph LR 被代理对象 --> 代理对象 代理对象 -.实现.-> 公共接口 被代理对象 -.实现.->公共接口

代码实现

第一步：创建公共接口

public interface StaticProxy {
    //具体要做的事情
    void dosomething();
}

第二步：创建目标对象

public class StaticProxyTarget implements StaticProxy {
    @Override
    public void dosomething() {
        System.out.println("我要打10个");
    }
}

第三步：创建代理对象（代理对象需要持有目标对象，并且真正做事的是目标对象）

public class StaticProxyImpl implements StaticProxy {

    //代理对象需要持有目标对象
    private StaticProxy staticProxy;

    //通过构造器的方式传入目标对象
    public StaticProxyImpl(StaticProxy staticProxy) {
        this.staticProxy = staticProxy;
    }

    @Override
    public void dosomething() {
        System.out.println("我是代理做的事，可有可无");
        //必须要有，并且真正做事的还是目标对象。
        this.staticProxy.dosomething();
        System.out.println("目标对象做完之后做的事，可有可无");
    }
}

第四部：测试验证结果

public class StaticProxyTest {
    public static void main(String[] args) {
        System.out.println("--------使用代理模式之前---------");
        StaticProxyTarget target = new StaticProxyTarget();
        target.dosomething();
        System.out.println("--------使用代理模式之后---------");
        StaticProxy staticProxy = new StaticProxyImpl(target);
        staticProxy.dosomething();
    }
}

结果如下：

--------使用代理模式之前---------
我要打10个
--------使用代理模式之后---------
我是代理做的事，可有可无
我要打10个
目标对象做完之后做的事，可有可无

优缺点及作用

优点： 符合开闭原则，添加代理类就可以在原来的基础上增加功能，不必修改源代码
缺点：一个类一个代理，如果需要代理的类很多怎么办？就会显得不是很方便。
作用：可以进行业务逻辑上的增强，比如日志，消息处理等。

动态代理

什么是动态代理？

对代理模式而言，一般来说，具体主题类与其代理类是一一对应的，这也是静态代理的特点。但是，也存在这样的情况：有 N 个主题类，但是代理类中的“预处理、后处理”都是相同的，仅仅是调用主题不同。那么，若采用静态代理，那么必然需要手动创建 N 个代理类，这显然让人相当不爽。动态代理则可以简单地为各个主题类分别生成代理类，共享“预处理，后处理”功能，这样可以大大减小程序规模，这也是动态代理的一大亮点。
在动态代理中，代理类是在运行时期生成的。因此，相比静态代理，动态代理可以很方便地对委托类的相关方法进行统一增强处理，如添加方法调用次数、添加日志功能等等。动态代理主要分为 JDK 动态代理和 cglib 动态代理两大类。1

JDK 动态代理

看名字就知道 JDK 动态代理是 JDK 里面自带的一种代理模式实现方式。主要有 3 个比较重要的接口和类。

  1. java.lang.reflect.Proxy ：该类用于动态生成代理类，只需传入目标接口、目标接口的类加载器以及 InvocationHandler 便可为目标接口生成代理类及代理对象。
  2. java.lang.reflect.InvocationHandler ：该接口包含一个 invoke 方法，通过该方法实现对委托类的代理的访问，是代理类完整逻辑的集中体现，包括要切入的增强逻辑和进行反射执行的真实业务逻辑。
  3. java.lang.ClassLoader ：加载器类，负责将类的字节码装载到 Java 虚拟机中并为其定义类对象，然后该类才能被使用。Proxy 静态方法生成动态代理类同样需要通过类加载器来进行加载才能使用，它与普通类的唯一区别就是其字节码是由 JVM 在运行时动态生成的而非预存在于任何一个.class 文件中

代码实现：
第一步：创建公共接口以及被代理对象

/**
*  公共接口
*/
public interface PhoneService {
    //具体要做的事情
    void dosomething2();
}

/**
*被代理的对象
*/
public class PhoneServiceImpl implements PhoneService {
    @Override
    public void dosomething2() {
        System.out.println("用手机看电影");
    }
}

第二步：创建动态代理处理器

/**
*动态代理处理器，需要实现接口InvocationHandler   在invoke里面进行业务逻辑的书写
*/
public class DynamicProxyHandler implements InvocationHandler {

    //被代理对象
    private Object target;

    //传入被代理对象
    public DynamicProxyHandler(Object target) {
        this.target = target;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //这里在调用前可以进行逻辑增强操作
        System.out.println("----调用前先吃个饭----");
        //调用被代理对象的方法
        Object invoke = method.invoke(target, args);
        //在掉用后也可以进行逻辑增强操作
        System.out.println("----调用后在洗个澡----");
        //返回调用的结果，这里是根据InvocationHandler接口的invoke方法说明进行的返回
        return invoke;
    }
}

第三步：测试以及结果

public class DynamicProxyHandlerTest {
    public static void main(String[] args) {
        //获取类加载器，获取到的是AppClassLoader类加载器
        ClassLoader classLoader = PhoneService.class.getClassLoader();
        //获取接口
        Class<?>[] interfaces = PhoneServiceImpl.class.getInterfaces();
        //创建动态代理处理器
        DynamicProxyHandler dynamicProxyHandler = new DynamicProxyHandler(new PhoneServiceImpl());
        //通过Proxy创建代理类
        PhoneService proxyInstance =(PhoneService) Proxy.newProxyInstance(classLoader,interfaces ,dynamicProxyHandler );
        //执行方法查看结果
        proxyInstance.dosomething2();
    }
}

----调用前先吃个饭----
用手机看电影
----调用后在洗个澡----

JDK 动态代理原理及源码分析

详见：深入理解代理模式：静态代理与 JDK 动态代理

JDK 动态代理小结

  1. 基于反射技术实现。
  2. 只能代理接口不能代理类，因为最后生成的代理类都继承了 Proxy，在 java 当中只支持单继承。
  3. InvocationHandler 中的 invoke()方法是代理类完整逻辑的集中体现。
  4. JDK 动态代理生成的代理类也代理了三个 Object 类的方法：equals()方法、hashCode()方法和 toString()方法。

cglib 动态代理

在 Spring AOP 当中还有一个 cglib 动态代理，它相比 jdk 动态代理只能代理接口来说，通过字节码技术，实现了对类的代理。

Spring AOP 中的代理使用逻辑了：如果目标对象实现了接口，默认情况下会采用 JDK 的动态代理实现 AOP；如果目标对象没有实现了接口，则采用 CGLIB 库，Spring 会自动在 JDK 动态代理和 CGLIB 动态代理之间转换2

SpringAOP 源码分析

版本：spring-aop:5.1.2.RELEASE
位置：org.springframework.aop.framework 包下
主要类：

  1. AopProxy
public interface AopProxy {
	//获取代理类
    Object getProxy();
	
    Object getProxy(@Nullable ClassLoader var1);
}
  1. AopProxyFactory
public interface AopProxyFactory {
	//获取AopProxy  
    AopProxy createAopProxy(AdvisedSupport var1) throws AopConfigException;
}
  1. DefaultAopProxyFactory
//默认Aop代理工厂类
public class DefaultAopProxyFactory implements AopProxyFactory, Serializable {
    public DefaultAopProxyFactory() {
    }

    public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
    	//判断是否是实现了接口
        if (!config.isOptimize() && !config.isProxyTargetClass() && !this.hasNoUserSuppliedProxyInterfaces(config)) {
        	//返回JDK代理类
            return new JdkDynamicAopProxy(config);
        } else {
            Class<?> targetClass = config.getTargetClass();
            if (targetClass == null) {
                throw new AopConfigException("TargetSource cannot determine target class: Either an interface or a target is required for proxy creation.");
            } else {
            	//如果不是接口并且没有代理类，返回cglib代理类
                return (AopProxy)(!targetClass.isInterface() && !Proxy.isProxyClass(targetClass) ? new ObjenesisCglibAopProxy(config) : new JdkDynamicAopProxy(config));
            }
        }
    }

    private boolean hasNoUserSuppliedProxyInterfaces(AdvisedSupport config) {
        Class<?>[] ifcs = config.getProxiedInterfaces();
        return ifcs.length == 0 || ifcs.length == 1 && SpringProxy.class.isAssignableFrom(ifcs[0]);
    }
}

实现原理及代码

原理说明：

CGLIB 动态代理的原理就是用 Enhancer 生成一个原有类的子类，并且设置好 callback 到 proxy， 则原有类的每个方法调用都会转为调用实现了 MethodInterceptor 接口的 proxy 的 intercept() 函数3

代码实现：

class MethodInterceptorImpl implements MethodInterceptor {

    @Override    

    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {

        System.out.println("Before invoke " + method);

        Object result = proxy.invokeSuper(obj, args);
		
        System.out.println("After invoke" + method);

        return result;

    }

}

详情见资料：CGLIB 学习笔记
在进行代码实现时需要下载对于的 CGLIBjar 包，Maven 中央库下载很慢，难受哎。

额外知识点

类加载器:ClassLoader
在 JDK 动态代理当中，我发现在代码获取类加载器这一步当中：

   		//获取类加载器，获取到的是AppClassLoader类加载器
        ClassLoader classLoader = PhoneService.class.getClassLoader();

如果我新建一个接口：PhoneService2 然后将上诉代码转换成：

 		 //获取类加载器，获取到的是AppClassLoader类加载器
        //ClassLoader classLoader = PhoneService.class.getClassLoader();
         ClassLoader classLoader = PhoneService2.class.getClassLoader();

程序也是可以正常运行并得出正确结果，但是如果将接口变成 JDK 自带的例如 List 就会报错： interface dynamic_proxy.PhoneService is not visible from class loader

 		//获取类加载器，获取到的是AppClassLoader类加载器
        //ClassLoader classLoader = PhoneService.class.getClassLoader();
        //正常运行
       	//ClassLoader classLoader = PhoneService2.class.getClassLoader();
        // 报错 ： interface dynamic_proxy.PhoneService is not visible from class loader
         ClassLoader classLoader = List.class.getClassLoader();

在网上查找了一下资料：发现有三种类加载器，

BootStrap ClassLoader：称为启动类加载器，是 Java 类加载层次中最顶层的类加载器，负责加载 JDK 中的核心类库，如：rt.jar、resources.jar、charsets.jar 等。

Extension ClassLoader：称为扩展类加载器，负责加载 Java 的扩展类库，默认加载 JAVA_HOME/jre/lib/ext/目下的所有 jar。

AppClassLoader：称为系统类加载器，负责加载应用程序 classpath 目录下的所有 jar 和 class 文件。（在程序当中获取到的加载器就是这个加载器）

报错原因：猜测可能就是因为使用的类加载器不同导致的。
  • 设计模式

    设计模式（Design pattern）代表了最佳的实践，通常被有经验的面向对象的软件开发人员所采用。设计模式是软件开发人员在软件开发过程中面临的一般问题的解决方案。这些解决方案是众多软件开发人员经过相当长的一段时间的试验和错误总结出来的。

    198 引用 • 120 回帖
成都 位置
326 10 57 81 20 23 42 82

相关帖子

回帖
设计模式学习笔记之代理模式

欢迎来到这里！

我们正在构建一个小众社区，大家在这里相互信任，以平等 • 自由 • 奔放的价值观进行分享交流。最终，希望大家能够找到与自己志同道合的伙伴，共同成长。

注册 关于
请输入回帖内容 ...
hjljy
成都
回帖
332
 帖子
92
 积分
9827

近期热议

推荐标签 标签

  • RIP

    愿逝者安息！

    8 引用 • 92 回帖 • 292 关注
  • 钉钉

    钉钉，专为中国企业打造的免费沟通协同多端平台， 阿里巴巴出品。

    15 引用 • 67 回帖 • 370 关注
  • V2EX

    V2EX 是创意工作者们的社区。这里目前汇聚了超过 400,000 名主要来自互联网行业、游戏行业和媒体行业的创意工作者。V2EX 希望能够成为创意工作者们的生活和事业的一部分。

    17 引用 • 236 回帖 • 418 关注
  • FFmpeg

    FFmpeg 是一套可以用来记录、转换数字音频、视频，并能将其转化为流的开源计算机程序。

    22 引用 • 31 回帖 • 3 关注
  • 酷鸟浏览器

    安全 · 稳定 · 快速
    为跨境从业人员提供专业的跨境浏览器

    3 引用 • 59 回帖 • 23 关注
  • RESTful

    一种软件架构设计风格而不是标准，提供了一组设计原则和约束条件，主要用于客户端和服务器交互类的软件。基于这个风格设计的软件可以更简洁，更有层次，更易于实现缓存等机制。

    30 引用 • 114 回帖
  • 坑

    一些有用的避坑指南。

    69 引用 • 93 回帖
  • Sillot

    Sillot （汐洛）孵化自思源笔记，致力于服务智慧新彖乄，具有彖乄驱动、极致优雅、开发者友好的特点
    Github 地址：https://github.com/Hi-Windom/Sillot

    17 引用 • 6 回帖 • 26 关注
  • Docker

    Docker 是一个开源的应用容器引擎，让开发者可以打包他们的应用以及依赖包到一个可移植的容器中，然后发布到任何流行的操作系统上。容器完全使用沙箱机制，几乎没有性能开销，可以很容易地在机器和数据中心中运行。

    476 引用 • 899 回帖
  • CodeMirror
    1 引用 • 2 回帖 • 121 关注
  • Webswing

    Webswing 是一个能将任何 Swing 应用通过纯 HTML5 运行在浏览器中的 Web 服务器，详细介绍请看 将 Java Swing 应用变成 Web 应用 。

    1 引用 • 15 回帖 • 635 关注
  • 锤子科技

    锤子科技（Smartisan）成立于 2012 年 5 月，是一家制造移动互联网终端设备的公司，公司的使命是用完美主义的工匠精神，打造用户体验一流的数码消费类产品（智能手机为主），改善人们的生活质量。

    4 引用 • 31 回帖 • 7 关注
  • 七牛云

    七牛云是国内领先的企业级公有云服务商，致力于打造以数据为核心的场景化 PaaS 服务。围绕富媒体场景，七牛先后推出了对象存储，融合 CDN 加速，数据通用处理，内容反垃圾服务，以及直播云服务等。

    25 引用 • 217 回帖 • 159 关注
  • Spark

    Spark 是 UC Berkeley AMP lab 所开源的类 Hadoop MapReduce 的通用并行框架。Spark 拥有 Hadoop MapReduce 所具有的优点；但不同于 MapReduce 的是 Job 中间输出结果可以保存在内存中，从而不再需要读写 HDFS，因此 Spark 能更好地适用于数据挖掘与机器学习等需要迭代的 MapReduce 的算法。

    74 引用 • 46 回帖 • 547 关注
  • 机器学习

    机器学习（Machine Learning）是一门多领域交叉学科，涉及概率论、统计学、逼近论、凸分析、算法复杂度理论等多门学科。专门研究计算机怎样模拟或实现人类的学习行为，以获取新的知识或技能，重新组织已有的知识结构使之不断改善自身的性能。

    76 引用 • 37 回帖
  • etcd

    etcd 是一个分布式、高可用的 key-value 数据存储，专门用于在分布式系统中保存关键数据。

    5 引用 • 26 回帖 • 495 关注
  • 旅游

    希望你我能在旅途中找到人生的下一站。

    85 引用 • 895 回帖
  • jsoup

    jsoup 是一款 Java 的 HTML 解析器，可直接解析某个 URL 地址、HTML 文本内容。它提供了一套非常省力的 API，可通过 DOM，CSS 以及类似于 jQuery 的操作方法来取出和操作数据。

    6 引用 • 1 回帖 • 462 关注
  • 脑图

    脑图又叫思维导图，是表达发散性思维的有效图形思维工具 ，它简单却又很有效，是一种实用性的思维工具。

    21 引用 • 58 回帖
  • sts
    2 引用 • 2 回帖 • 152 关注
  • WebClipper

    Web Clipper 是一款浏览器剪藏扩展，它可以帮助你把网页内容剪藏到本地。

    3 引用 • 9 回帖 • 5 关注
  • 创业

    你比 99% 的人都优秀么？

    82 引用 • 1398 回帖 • 1 关注
  • Ngui

    Ngui 是一个 GUI 的排版显示引擎和跨平台的 GUI 应用程序开发框架，基于
    Node.js / OpenGL。目标是在此基础上开发 GUI 应用程序可拥有开发 WEB 应用般简单与速度同时兼顾 Native 应用程序的性能与体验。

    7 引用 • 9 回帖 • 345 关注
  • 知乎

    知乎是网络问答社区，连接各行各业的用户。用户分享着彼此的知识、经验和见解，为中文互联网源源不断地提供多种多样的信息。

    10 引用 • 66 回帖
  • 国际化

    i18n（其来源是英文单词 internationalization 的首末字符 i 和 n，18 为中间的字符数）是“国际化”的简称。对程序来说，国际化是指在不修改代码的情况下，能根据不同语言及地区显示相应的界面。

    7 引用 • 26 回帖 • 2 关注
  • DNSPod

    DNSPod 建立于 2006 年 3 月份，是一款免费智能 DNS 产品。 DNSPod 可以为同时有电信、网通、教育网服务器的网站提供智能的解析，让电信用户访问电信的服务器，网通的用户访问网通的服务器，教育网的用户访问教育网的服务器，达到互联互通的效果。

    6 引用 • 26 回帖 • 521 关注
  • Scala

    Scala 是一门多范式的编程语言，集成面向对象编程和函数式编程的各种特性。

    13 引用 • 11 回帖 • 109 关注

最新标签