代理模式

最新推荐文章于 2022-07-24 17:54:16 发布
最新推荐文章于 2022-07-24 17:54:16 发布
阅读量229 收藏
点赞数
分类专栏： SpringFramework 文章标签： proxy
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42242898/article/details/104974338
版权

语雀链接：https://www.yuque.com/nlwrno/xfkcgp/vcw1u4

代理模式

什么是代理

代理名词

代理对象：增强后的对象
目标对象：被增强的对象
他们不是绝对的，是根据情况变化的

静态代理

继承

// 目标对象
public class IndexDaoImpl {
    public void query(){
        System.out.println("select db...");
    }
}

//代理对象，代理打印日志

public class IndexDaoLogImpl extends IndexDaoImpl {
    @Override
    public void query() {
        System.out.println("console log...");
        super.query();
    }
}

// 代理验证
public class IndexDaoPowerImpl extends IndexDaoImpl {
    @Override
    public void query() {
        System.out.println("power...");
        super.query();
    }
}

/*

*   模拟查询加日志
*   1、加在查询方法处，但有可能IndexDao是引入class文件，不能直接添加
*   2、加在调用方法处，但调用可能调用很多次，代码侵入性/冗余度太高
*   3、静态代理
*        继承：代理对象继承目标对象
*        聚合：
*   4、动态代理
* */
* 
// 继承方式
public class Test {
    public static void main(String[] args) {
        IndexDaoLogImpl log = new IndexDaoLogImpl();
        log.query();
        //IndexDaoImpl indexDao = new IndexDaoImpl();
        //indexDao.query();
    }
}

聚合

public interface IndexDao {
    public void query();
}

// 目标对象
public class IndexDaoImpl implements IndexDao {
    public void query(){
        System.out.println("select db...");
    }
}

// 代理对象
public class IndexDaoLogImpl implements IndexDao {
    private IndexDao dao;

    public IndexDaoLogImpl(IndexDao dao){
        this.dao = dao;
    }
    public void query() {
        System.out.println("console log...");
        dao.query();
    }
}
// 代理对象
public class IndexDaoPowerImpl implements IndexDao {

   private IndexDao dao;

   public IndexDaoPowerImpl(IndexDao dao){
        this.dao = dao;
    }
    @Override
    public void query() {
        System.out.println("power...");
        dao.query();
    }
}

public class Test {
    public static void main(String[] args) {
        IndexDao dao = new IndexDaoImpl();
        IndexDao dao1 = new IndexDaoLogImpl(dao);
        dao1.query();
    }
}

这时候就会出现一个问题，是继承好还是聚合好，为什么？
在这里插入图片描述
在这里插入图片描述
从两幅图种可以观察到，如果我们的代理需要增加，比如，我们即需要log代理，又需要power代理，这个时候，继承和聚合是怎么实现的呢？

**继承：**我们不能修改原先的代理，如果又修改了，我们只需要power代理时，则又要改动，所以只能增加一个新的代理。可以说是链式代理。
在这里插入图片描述
**聚合：**只需要将log代理传入到log代理中即可
在这里插入图片描述
那如果这时候来了个变态需求，需要log代理和power代理顺序也又要求，继承/类又要增加，这时候就要疯了。这时候还会出现类爆炸，一直增加类。相对来说，聚合就好很多，但如果要求又很多代理，依然会产生类爆炸，只是相对继承来说好一点。

总结：如果在不确定的情况下，尽量不去使用静态代理。因为一旦写代码就会产生类，一直产生类就会发生类爆炸。所谓不确定，就是不知道后续要不要进行扩展，就像需求中所说的，log代理之后有没有可能会出来power不确定。所以这种情况最好不要使用静态代理，从而引出了动态代理。

手动实现代理

那我们知道了上面的缺点，我们自己实现代理的话会如何去做呢？

  1. 生成java文件
  2. 编译Java文件，生成.class
  3. 通过.class创建Proxy代理对象
    在这里插入图片描述

Proxy生成

/**
 * @Description TODO
 * @ClassName ProxyUtil.java
 * @Author yangkai
 * @CreateTime 2020年03月19日 14:09:00
 * @Version 1.0
 * @History
 **/

package com.proxy.util;

import javax.tools.JavaCompiler;
import javax.tools.StandardJavaFileManager;
import javax.tools.ToolProvider;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.net.URL;
import java.net.URLClassLoader;

public class ProxyUtil {
    /*
    *  content ----> string
    *  .java   io
    *  .class
    *   new
    *   return
    * */
    public static Object newInstance(Class clazz, MineInvocationHandler h) throws IOException, ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {

        Object proxy = null;
       // Class<?> clazz = clz.getInterfaces()[0];
        Method[] methods = clazz.getDeclaredMethods();
        String line = "\r\n";
        String tab = "\t";
        String infName = clazz.getSimpleName();
        String content = "";
        String packageContent = "package com.google;"+line;
        String importContent = "import "+clazz.getName()+";"+line
                             + "import com.proxy.util.MineInvocationHandler;"+line
                             + "import java.lang.reflect.Method;"+line;

        String clazzFirstLineContent = "public class $Proxy implements "+infName+"{"+line;
        String fileContent = tab+"private MineInvocationHandler h;"+line;
        String constructContent  = tab+"public $Proxy(MineInvocationHandler h){"+line
                                    +tab + tab + "this.h = h;"+line
                                    +tab + tab +"}"+line;
        String methodContent = "";
        for (Method method : methods) {
            String returnTypeName = method.getReturnType().getName();
            String methodName = method.getName();
            Object args[] = method.getParameterTypes();
            String argsContents ="";
            String paramsContents = "";
            String argNames="";
            for (int i=0;i<args.length;i++) {
                String argName = ((Class) args[0]).getName();
                argNames = argName+".class,";
                argsContents += argName+" p"+i+",";
                paramsContents+="p"+i+",";
            }

            if(argsContents.length()>0){
                argNames = ","+argNames.substring(0,argNames.length()-1);
                argsContents = argsContents.substring(0,argsContents.length()-1);
                paramsContents = ",new Object[]{"+paramsContents.substring(0,paramsContents.length()-1)+"}";
            }else{
                paramsContents=",null";
            }

            methodContent += tab+"public "+returnTypeName+" "+methodName +"("+argsContents+"){"+line
                            +tab+tab+"try{"+line
                            +tab+tab+tab + "Method method = Class.forName(\""+clazz.getName()+"\").getDeclaredMethod(\""+methodName+"\""+argNames+");"+line;
            if ("void".equals(returnTypeName)){
                methodContent+=tab+tab+tab +"h.invoke(new $Proxy(h),method"+paramsContents+");"+line
                            +tab+tab+"}catch ( Throwable e){"+line
                            +tab+tab+tab+"e.printStackTrace();"+line
                            +tab+tab+"}"+line
                            +tab+"}"+line;
            }else{
                methodContent+=tab+tab+tab +"return ("+returnTypeName+")h.invoke(new $Proxy(h),method"+paramsContents+");"+line
                            +tab+tab+"}catch ( Throwable e){"+line
                            +tab+tab+tab+"e.printStackTrace();"+line
                            +tab+tab+"}"+line
                            +tab+tab+"return null;"+line
                            +tab+"}"+line;
            }

        }
        content=packageContent+importContent+clazzFirstLineContent+fileContent+constructContent+methodContent+"}";

         File file = new File("G:/com/google");
         if(!file.exists()){
            file.mkdirs();
         }
        file = new File("G:/com/google/$Proxy.java");
        FileWriter fileWriter = new FileWriter(file);
        fileWriter.write(content);
        fileWriter.flush();
        fileWriter.close();
        JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
        StandardJavaFileManager standardFileManager = compiler.getStandardFileManager(null,null,null);
        Iterable utils = standardFileManager.getJavaFileObjects(file);
        JavaCompiler.CompilationTask task = compiler.getTask(null, standardFileManager, null, null, null,utils);
        task.call(); // 这里仅使用jre会抛异常，使用jdk
        standardFileManager.close();
       // compiler.run(null,null,null,"G:/com/google/$Proxy.java");

        URL[] urls = new URL[]{new URL("file:G:\\\\")};
        URLClassLoader urlClassLoader = new URLClassLoader(urls);
        Class claz = urlClassLoader.loadClass("com.google.$Proxy");
        Constructor constructor = claz.getConstructor(MineInvocationHandler.class);
        proxy = constructor.newInstance(h);

        return proxy;
    }
}

InvocationHandler

/**
 * @Description TODO
 * @ClassName InvocatetionHandler.java
 * @Author yangkai
 * @CreateTime 2020年03月20日 15:03:00
 * @Version 1.0
 * @History
 **/

package com.proxy.util;

import java.lang.reflect.Method;

public interface MineInvocationHandler {
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable;
}

测试动态代理

/**
 * @Description TODO
 * @ClassName IndexDao.java
 * @Author yangkai
 * @CreateTime 2020年03月19日 11:50:00
 * @Version 1.0
 * @History
 **/

package com.proxy.proxy1;

public interface IndexDao {
    public void query();

    public String selectStr();

    public String queryName(String name);
}

/**
 * @Description TODO
 * @ClassName IndexDao.java
 * @Author yangkai
 * @CreateTime 2020年03月19日 11:28:00
 * @Version 1.0
 * @History
 **/

package com.proxy.dao;

import com.proxy.proxy1.IndexDao;

public class IndexDaoImpl implements IndexDao {

    public void query(){
        System.out.println("select db...");
    }


    public String selectStr() {
        System.out.println("IndexDaoImpl selectStr");
        return "IndexDaoImpl";
    }

    @Override
    public String queryName(String name) {
        return name;
    }
}

/**
 * @Description TODO
 * @ClassName TestInvokeHandle.java
 * @Author yangkai
 * @CreateTime 2020年03月20日 15:05:00
 * @Version 1.0
 * @History
 **/

package com.proxy.util;

import java.lang.reflect.Method;

public class TestInvokeHandle implements MineInvocationHandler {
    Object target;

    public TestInvokeHandle(Object target){
        this.target= target;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("代理");
        return method.invoke(target,args);
    }
}

public class Test {
    public static void main(String[] args) throws Exception {
        IndexDao proxy = (IndexDao) ProxyUtil.newInstance(IndexDao.class,new TestInvokeHandle(new IndexDaoImpl()));
        proxy.query();
        proxy.selectStr();
        String s = proxy.queryName("测试....");
        System.out.println(s);
    }
}

在这里插入图片描述

JDK动态代理

流程图

在这里插入图片描述

测试JDK动态代理

public interface IndexDao {
    public void query();

    public String selectStr();

    public String queryName(String name);
}

/**
 * @Description TODO
 * @ClassName IndexDao.java
 * @Author yangkai
 * @CreateTime 2020年03月19日 11:28:00
 * @Version 1.0
 * @History
 **/

package com.proxy.dao;

import com.proxy.proxy1.IndexDao;

public class IndexDaoImpl implements IndexDao {

    public void query(){
        System.out.println("select db...");
    }


    public String selectStr() {
        System.out.println("IndexDaoImpl selectStr");
        return "IndexDaoImpl";
    }

    @Override
    public String queryName(String name) {
        return name;
    }
}

/**
 * @Description TODO
 * @ClassName MyInvoketionHandle.java
 * @Author yangkai
 * @CreateTime 2020年03月20日 14:37:00
 * @Version 1.0
 * @History
 **/

package com.proxy.util;

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

public class MyInvoketionHandle implements InvocationHandler {
    Object target;

    public MyInvoketionHandle(Object target){
        this.target = target;
    }
    /**
     *
     * @param proxy 代理对象
     * @param method 目标对象的方法
     * @param args 目标方法的参数
     * @return
     * @throws Throwable
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("proxy invoke...");
        return method.invoke(target,args);
    }

}

/**
 * @Description TODO
 * @ClassName Test.java
 * @Author yangkai
 * @CreateTime 2020年03月19日 11:29:00
 * @Version 1.0
 * @History
 **/

package com.proxy.test;
//开闭原则
// 单一职责

import com.proxy.dao.IndexDaoImpl;
import com.proxy.proxy.IndexDaoLogImpl;
import com.proxy.proxy1.IndexDao;
import com.proxy.util.MyInvoketionHandle;
import com.proxy.util.ProxyUtil;
import com.proxy.util.TestInvokeHandle;

import java.io.IOException;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

/*
*   模拟查询加日志
*   1、加在查询方法处，但有可能IndexDao是引入class文件，不能直接添加
*   2、加在调用方法处，但调用可能调用很多次，代码侵入性/冗余度太高
*   3、静态代理
*        继承：代理对象继承目标对象
*        聚合：
*   4、动态代理
* */
public class Test {
    public static void main(String[] args) throws Exception {
        IndexDao proxy1 = (IndexDao)Proxy.newProxyInstance(Test.class.getClassLoader(),
                new Class[]{IndexDao.class}, new MyInvoketionHandle(new IndexDaoImpl()));
        proxy1.query();
        proxy1.selectStr();
        String s = proxy1.queryName("测试....");
        System.out.println(s);
    }

}

/*
 *  代理对象  增强后的对象
 *  目标对象  被代理的对象
 * */

在这里插入图片描述

源码解析

后续增加…

____影
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【设计模式】--代理模式 （Proxy模式）
十年磨一剑，沉淀……
01-21 1842
在软件系统中，我们无时不在跨越障碍，当我们访问网络上一台计算机的资源时，我们正在跨越网络障碍；当我们去访问服务器上数据库时，我们又在跨越数据库访问障碍，同时还有网络障碍。跨越这些障碍有时候是非常复杂的，如果我们更多的去关注处理这些障碍问题，可能就会忽视了本来应该关注的业务逻辑问题，Proxy模式有助于我们去解决这些问题。 生活中的例子：       代理模式提供一个中介以控制对这个对象
代理模式(Proxy)
xxxxx
05-14 324
代理模式 通过代理，控制对对象的访问。 可以详细控制某个或某类对象的方法，在调用这个方法前做前置处理，调用这个方法后做后置处理。 举个例子：用户邀请明星唱歌，可以通过经纪人作为代理。那么经纪人完成面谈合同安排等等，明星只负责前置处理技术后唱歌，如果经纪人负责多个明星，它可以为多个明星提供前置服务。 核心角色 抽象角色：定义代理角色和真实角色的公共对外方法。 真实角色：实现抽象角色，定义真实角色所要...
设计模式之代理模式
weixin_30463341的博客
12-27 80
转载请标明出处：http://blog.csdn.net/shensky711/article/details/53891127 本文出自: 【HansChen的博客】 概述 代理模式 UML图 代码 远程代理 延迟加载 保护代理 额外功能 静态代理和动态代理 概述 我们执行一个功能的函数时，经常需要在其中写入与功能不是直接相关但很有必要的...
图解代理模式
shangshanzixu的博客
07-08 559
代理模式 代理模式是我们在开发过程中常见的设计模式之一，同时也是各个大厂笔试面试常见考点之一。 代理(Proxy)是一种设计模式,提供了间接对目标对象进行访问的方式;即通过代理对象访问目标对象.这样做的好处是:可以在目标对象实现的功能上,增加额外的功能补充,即扩展目标对象的功能. 这就符合了设计模式的开闭原则，即在对既有代码不改动的情况下进行功能的扩展。 举个例子来说明代理的作用:明星与经纪人之间就是被代理和代理的关系,明星出演活动的时候，明星就是一个目标对象,他只要负责活动中的节目,而其他琐碎的事情就交给
Java 代理模式详解
12-22
代理模式是我们比较常用的设计模式之一。其中新思想是为了提供额外的处理或者不同的操作而在实际对象与调用者之间插入一个代理对象。这些额外的操作通常需要与实际对象进行通信，代理模式一般涉及到的角色有： 　...
代理模式1
08-08
介绍代理，顾名思义就是帮助别人做事，GoF对代理模式的定义如下：代理模式（Proxy），为其他对象提供一种代理以控制对这个对象的访问。代理模式使得代理对象控制具
java代理模式
02-06
java代理模式
代理模式代码
09-20
为其他对象提供一种代理以控制对这个对象的访问。这里的代码示例使保护代理的代码，再其中使用的Java的动态代理。
代理模式详解
shadowfall的博客
07-21 378
什么是代理模式 代理模式是为一个对象提供一个代用品或占位符,以便控制对它的访问。 代理模式的关键是，当客户不方便直接访问一个对象或者不满足需要的时候，提供一个替身来控制对这个对象的访问，客户实际上访问的是替身对象。替身对象对请求做出一些处理之后，再把请求转交给本体对象。（例如：vue3 的双向数据绑定） 保护代理和虚拟代理 先举个例子：   现在我们假设小明对女生A进行表白,当A在心情好的时候收到花,小明表白的成功率为60%,当A心情差的时候收到花,小明表白的成功率无限接近于零。   小明和A刚认识2天
6.1 代理模式(Proxy Pattern)
NorthStar的博客
07-24 142
代理模式
设计模式学习笔记(12)--代理设计模式
为梦想而奋斗，无悔_一叶扁舟的点滴成长！
02-18 281
1.定义        代理模式(Proxy Pattern) ：给某一个对象提供一个代理，并由代理对象控制对原对象的引用。代理模式的英文叫做Proxy或Surrogate，它是一种对象结构型模式。 2.uml图 3.代码 上图简单代码实现（静态代理）: package com.wuhuiskiff.www.proxy.code.simple; /** * @Auther: 一...
图解Java设计模式之代理模式
不一样的花朵的博客
03-26 382
图解Java设计模式之代理模式代理模式的基本介绍静态代理模式的基本介绍应用实例静态代理优缺点动态代理模式的基本介绍JDK中生成代理对象的API动态代理应用实例 代理模式的基本介绍 1）代理模式 ：为一个对象提供一个替身，以控制对这个对象的访问。即通过代理对象访问目标对象。这样做的好处是 ：可以在目标对象实现的基础上，增强额外的功能操作，即扩展目标对象的功能。 2）被代理的对象可以是远程对象、创建开...
一文彻底搞懂代理模式(Proxy)
m0_51380306的博客
08-25 4751
代理模式 引言 代理模式的定义与特点 代理模式的结构 模式实现 静态代理 动态代理 总结 与装饰者模式 文章已收录我的仓库：Java学习笔记与免费书籍分享 代理模式 引言 代理模式是非常常见的模式，在生活中的例子也非常多，例如你不好意思向你关系不太好朋友帮个忙，这时需要找一个和它关系好的应一个朋友帮忙转达，这个中间朋友就是代理对象。例如购买火车票不一定要去火车站买，可以通过12306网站或者去火车票代售点买。又如找女朋友、找保姆、找工作等都可以通过找中介完成。 代理模式的定义与特点 代理模.
三十八：代理模式
zhenyaoMilenfan的专栏
11-11 137
一：什么是代理 代理模式给某一个对象提供一个代理对象，并由代理对象控制原对象的引用. 中国人是一个含蓄的民族，讲求微妙和间接的交流方式，对象间的间接通信也同样是面向对象的设计中一条重要的"审美观"。间接性的通信可以给出较低的耦合关系，较强的合作关系，以及微妙的结构和易于复用的设计架构。 代理模式的英文叫做Proxy，所谓代理，就是一个人或者一个机构代表另一个人或者另一个机构采取行动，在一...
设计模式之代理模式Proxy
Yangshaobing123的博客
09-03 188
1.问题引入 租房问题: 房东想要把房子租出去,那么他需要做两件事:1.带人去看房子;2.签合同收租金,把房子交出去. 租客想要租房子:那么他需要做两件事:1.去看房子;2.签合同交租金,拿到房子. 但是现在,房东嫌麻烦,不想带人去看房子,只想签合同收租金,把房子交出去.但是对租客来说,肯定只有看了房子之后才知道满不满意,才能确定要不要签合同交租金. 所以自然而然就有了一种行业:中介.房东把房子交给中介,有租客想要租房的时候,中介带领租客去看房子,租客想要签合同拿房子的时候,中介把房东叫过来,签合同交房子.
基于JDK和CGLib的链式动态代理
思念
12-29 1071
动态代理与链式动态代理　　链式代理就是将多个代理串链在一起，一个一个的去执行，执行的顺序取决于链上的先后顺序。JDK的动态代理只能代理实现了接口的类实例，而CGLib则可以代理普通的类实例。执行链式代理的样子大概如下图所示：这很像Spring Aop的前后增强，实际上我也是基于这个想到，如果增强有多个，那么就是链式动态代理的样子了。好像Filter也是这样的，Node.js中如Express的中间件
语雀JMeter系列（二）--脚本生成
demonill的博客
05-30 613
上一节我们介绍了JMeter的一些基本的知识，接下来就是如何去使用JMeter了。 对于新手来说，第一件事情就是怎么在JMeter中去实现我们的测试脚本。通常来说，JMeter生成脚本的方式有三种： 第三方工具录制 JMeter自带的代理服务器录制 抓包手写 第三方工具录制 目前来说，可以用于JMeter脚本录制生成的工具主要有: badboy BlazeMeter 其它 badboy作为一款老牌的web自动化测试工具，一直支持JMeter脚本的录制生成。但是因为Badboy是基于内置的浏
使用“链式代理”实现 AOP
maikelsong的专栏
12-11 978
本文是《轻量级 Java Web 框架架构设计》的系列博文。 大家是否还记得《Proxy 那点事儿》中提到的 CGLib 动态代理吗？我就是使用这个工具来实现了 Smart AOP 的，原以为这样 AOP 就轻松搞定了，但万万没想到的是，自己太傻太天真。 昨天刚发现 Smart AOP 的 AOPHelper 类有个严重的 Bug，导致同一个目标类不能同时被多个切面类横切，运行时会
设计模式 代理模式
最新发布
06-09
代理模式是一种软件设计模式，它允许你创建一个对象的“代理”来控制对原对象的访问。这个代理对象可以在不影响原对象的情况下，增加额外的功能、延迟操作执行、修改行为或者控制对原对象的访问权限。在许多场景中，代理模式可以用来实现远程方法调用、资源管理、安全控制或性能优化。 代理模式的主要组件包括： 1. **真实对象（Real Object）**：原始的、被代理的对象。 2. **代理对象（Proxy Object）**：在客户端和真实对象之间起中介作用的类或对象。 3. **代理的行为**：代理对象通常会封装额外的方法或者修改原有方法的行为。 应用场景有： - **性能优化**：如在网络应用中，代理可以缓存数据或请求，减少网络延迟。 - **安全管理**：代理可以检查权限，限制对敏感资源的操作。 - **远程调用**：在分布式系统中，代理用于处理请求转发和通信细节。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值