设计模式五（代理模式-下篇）

最新推荐文章于 2024-06-12 11:59:04 发布
最新推荐文章于 2024-06-12 11:59:04 发布
阅读量97 收藏
点赞数 1
分类专栏： 设计模式 文章标签： java 设计模式 proxy
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_20315217/article/details/114442334
版权

上一篇学习了静态代理与动态代理的实现及业务场景应用，对代理模式有了初步认识，本篇将从源码的角度对代理模式进行深度剖析，加深对动态代理的理解，做到知其然，知其所以然。

手写 JDK 动态代理实现原理

既然知道了动态代理的强大，那么我们来研究一下原理，看看它是如何实现的？并模仿 JDK动态代理手写一个属于自己的动态代理。

我们都知道JDK 动态代理采用字节重组，重新生成对象来替代原始对象，以达到动态代理的目的。JDK 动态代理生成对象的步骤如下：

  1. 获取被代理对象的引用，并且获取它的所有接口，反射获取；
  2. JDK 动态代理类重新生成一个新的类，同时新的类要实现被代理类实现的所有接口；
  3. 动态生成 Java 代码，新加的业务逻辑方法由一定的逻辑代码调用（在代码中体现）；
  4. 编译新生成的 Java 代码 .class 文件；
  5. 重新加载到 JVM 中运行；

以上过程就叫字节码重组。JDK 中有一个规范，在 ClassPath 下只要是$开头的.class 文件，一般都是自动生成的。那么我们有没有办法看到代替后的对象的“真容”呢？来做一个这样的测试，将内存中的对象字节码通过文件流输出到一个新的.class 文件，然后利用反编译工具进行查看源代码。

public static void main(String[] args) {
     
		byte[] b = ProxyGenerator.generateProxyClass("$Proxy0", new Class[]{IPerson.class});
		FileOutputStream os = null;
		try {
			os = new FileOutputStream("$Proxy0.class");
			os.write(b);
			os.close();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

运行代码，并找到$Proxy0.class文件，进行反编译查看，如下：
在这里插入图片描述我们发现，新生成的代理对象，继承了 Proxy类，同时还实现了 IPerson接口，而且重写的了 findLove()方法。在静态块中利用反射查找到了目标对象的所有方法，而且保存了所有方法的引用，重写的方法利用反射调用目标方法对象。此时，小伙伴们肯定好奇，这些代码是哪里来的，其实是JDK 自动帮我们生成的。现在我们不依赖 JDK，自己来动态生成源代码、动态完成编译，然后替代目标对象并执行。
首先创建MyInvocationHandler接口：

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

创建自己的 MyClassLoader 类:

public class MyClassLoader extends ClassLoader {

    private File classPathFile;
    public MyClassLoader(){
        String classPath = MyClassLoader.class.getResource("").getPath();
        this.classPathFile = new File(classPath);
    }

    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {

        String className = MyClassLoader.class.getPackage().getName() + "." + name;
        if(classPathFile  != null){
            File classFile = new File(classPathFile,name.replaceAll("\\.","/") + ".class");
            if(classFile.exists()){
                FileInputStream in = null;
                ByteArrayOutputStream out = null;
                try{
                    in = new FileInputStream(classFile);
                    out = new ByteArrayOutputStream();
                    byte [] buff = new byte[1024];
                    int len;
                    while ((len = in.read(buff)) != -1){
                        out.write(buff,0,len);
                    }
                    return defineClass(className,out.toByteArray(),0,out.size());
                }catch (Exception e){
                    e.printStackTrace();
                }
            }
        }
        return null;
    }
}

创建生成代理类的工具类 MyProxy 类：

public class MyProxy {

	public static final String ln = "\r\n";

	public static Object newProxyInstance(MyClassLoader classLoader, Class<?>[] interfaces, MyInvocationHandler h) {
		try {
			//1、动态生成源代码.java文件
			String src = generateSrc(interfaces);

			//2、Java文件输出磁盘
			String filePath = MyProxy.class.getResource("").getPath();
			File f = new File(filePath + "$Proxy0.java");
			FileWriter fw = new FileWriter(f);
			fw.write(src);
			fw.flush();
			fw.close();

			//3、把生成的.java文件编译成.class文件
			JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
			StandardJavaFileManager manage = compiler.getStandardFileManager(null, null, null);
			Iterable iterable = manage.getJavaFileObjects(f);

			JavaCompiler.CompilationTask task = compiler.getTask(null, manage, null, null, null, iterable);
			task.call();
			manage.close();

			//4、编译生成的.class文件加载到JVM中来
			Class proxyClass = classLoader.findClass("$Proxy0");
			Constructor c = proxyClass.getConstructor(MyInvocationHandler.class);
			f.delete();

			//5、返回字节码重组以后的新的代理对象
			return c.newInstance(h);
		} catch (Exception e) {
			e.printStackTrace();
		}
		return null;
	}

	/**
	 * 根据需要代理的接口，动态生成源文件
	 * @param interfaces
	 * @return
	 */
	private static String generateSrc(Class<?>[] interfaces) {
		StringBuffer sb = new StringBuffer();
		sb.append(MyProxy.class.getPackage() + ";" + ln);
		sb.append("import " + interfaces[0].getName() + ";" + ln);
		sb.append("import java.lang.reflect.*;" + ln);
		//自定义生成的文件名字，暂且先叫它 $Proxy0
		sb.append("public class $Proxy0 implements " + interfaces[0].getName() + "{" + ln);
		sb.append("MyInvocationHandler h;" + ln);
		sb.append("public $Proxy0(MyInvocationHandler h) { " + ln);
		sb.append("this.h = h;");
		sb.append("}" + ln);
		for (Method m : interfaces[0].getMethods()) {
			Class<?>[] params = m.getParameterTypes();

			StringBuffer paramNames = new StringBuffer();
			StringBuffer paramValues = new StringBuffer();
			StringBuffer paramClasses = new StringBuffer();

			for (int i = 0; i < params.length; i++) {
				Class clazz = params[i];
				String type = clazz.getName();
				String paramName = toLowerFirstCase(clazz.getSimpleName());
				paramNames.append(type + " " + paramName);
				paramValues.append(paramName);
				paramClasses.append(clazz.getName() + ".class");
				if (i > 0 && i < params.length - 1) {
					paramNames.append(",");
					paramClasses.append(",");
					paramValues.append(",");
				}
			}

			sb.append("public " + m.getReturnType().getName() + " " + m.getName() + "(" + paramNames.toString() + ") {" + ln);
			sb.append("try{" + ln);
			sb.append("Method m = " + interfaces[0].getName() + ".class.getMethod(\"" + m.getName() + "\",new Class[]{" + paramClasses.toString() + "});" + ln);
			sb.append((hasReturnValue(m.getReturnType()) ? "return " : "") + getCaseCode("this.h.invoke(this,m,new Object[]{" + paramValues + "})", m.getReturnType()) + ";" + ln);
			sb.append("}catch(Error _ex) { }");
			sb.append("catch(Throwable e){" + ln);
			sb.append("throw new UndeclaredThrowableException(e);" + ln);
			sb.append("}");
			sb.append(getReturnEmptyCode(m.getReturnType()));
			sb.append("}");
		}
		sb.append("}" + ln);
		return sb.toString();
	}


	private static Map<Class, Class> mappings = new HashMap<Class, Class>();

	static {
		mappings.put(int.class, Integer.class);
	}

	private static String getReturnEmptyCode(Class<?> returnClass) {
		if (mappings.containsKey(returnClass)) {
			return "return 0;";
		} else if (returnClass == void.class) {
			return "";
		} else {
			return "return null;";
		}
	}

	private static String getCaseCode(String code, Class<?> returnClass) {
		if (mappings.containsKey(returnClass)) {
			return "((" + mappings.get(returnClass).getName() + ")" + code + ")." + returnClass.getSimpleName() + "Value()";
		}
		return code;
	}

	private static boolean hasReturnValue(Class<?> clazz) {
		return clazz != void.class;
	}

	/**
	 * 首字母小写
	 * @param src
	 * @return
	 */
	private static String toLowerFirstCase(String src) {
		char[] chars = src.toCharArray();
		chars[0] += 32;
		return String.valueOf(chars);
	}

}

创建 MyMeipo 类，实现自己刚才写的MyInvocationHandler接口：

public class MyMeipo implements MyInvocationHandler {

	private IPerson target;
    public IPerson getInstance(IPerson target){
        this.target = target;
        Class<?> clazz =  target.getClass();
        return (IPerson) MyProxy.newProxyInstance(new MyClassLoader(),clazz.getInterfaces(),this);
    }

    @Override
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        before();
        Object result = method.invoke(this.target,args);
        after();
        return result;
    }

    private void after() {
        System.out.println("双方同意，开始交往");
    }

    private void before() {
        System.out.println("我是媒婆，已经收集到你的需求，开始物色");
    }
}

测试代码：

public static void main(String[] args) {
		MyMeipo myProxyMeipo = new MyMeipo();
		IPerson zhangsan = myProxyMeipo.getInstance(new Zhangsan());
		zhangsan.findLove();
	}

至此，完成了我们自己定义的仿 JDK 动态代理源码。

CGLib代理调用API 及原理分析

简单看一下CGLib代理的使用，还是以媒婆为例，创建CglibMeipo 类：

public class CGlibMeipo implements MethodInterceptor {


	public Object getInstance(Class<?> clazz) throws Exception {
		//相当于Proxy，代理的工具类
		Enhancer enhancer = new Enhancer();
		enhancer.setSuperclass(clazz);
		enhancer.setCallback(this);
		return enhancer.create();
	}

	@Override
	public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
		before();
		Object obj = methodProxy.invokeSuper(o, objects);
		after();
		return obj;
	}

	private void before() {
		System.out.println("我是媒婆，我要给你找对象，现在已经确认你的需求");
		System.out.println("开始物色");
	}

	private void after() {
		System.out.println("OK的话，准备办事");
	}
}

创建单身客户类：

public class Customer {

    public void findLove(){
        System.out.println("肤白貌美大长腿");
    }
}

有个小细节，不知道小伙伴们有没有发现，CGLib代理的对象不需要实现任何接口，它是通过继承目标对象实现动态代理的。下面来看测试代码：

public static void main(String[] args) {

        try {
            Customer obj = (Customer) new CGlibMeipo().getInstance(Customer.class);
            System.out.println(obj);
            obj.findLove();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

CGLib代理的实现原理又是怎样的呢？我们依然采用将代理后的.class 文件输出，进行反编译查看，一探究竟：

public static void main(String[] args) {

        //利用CGLib的代理类可以将内存中的.class 文件写入本地磁盘
        System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY,"cglib_proxy_classes");
    }

执行后发现，在cglib_proxy_classes 文件夹下多了三个.class 文件：
在这里插入图片描述
经过调试跟踪发现，CustomerEnhancerByCGLIB$$dce8aedb就是 CGLib代理生成的代理类，继承了Customer类。
在这里插入图片描述CGLib代理执行代理方法的效率之所以比 JDK 高，是因为CGLib采用了FastClass机制，它的原理简单来说就是：为代理类和被代理类各生成一个类，这个类会为代理类或被代理类的方法分配一个index(int 类型)；这个 index当做一个入参，FastClass就可以直接定位到要调用的的方法并直接进行调用，省去了反射调用，所以调用效率比JDK 代理通过反射调用高。

CGLib 和 JDK 动态代理对比
  1. JDK 代理实现了被代理类对象的接口，CGLib 代理继承了被代理类；
  2. JDK动态代理和 CGLib代理都在运行期生成字节码，JDK 动态代理直接写Class字节码，CGLib代理使用 ASM框架写Class字节码，CGLib 代理实现更复杂，生成代理类比 JDK动态代理效率低；
  3. JDK 动态代理调用代理方法是通过反射机制调用，CGLib 代理是通过 FastClass机制直接调用方法，CGLib 代理的执行效率更高
代理模式于 Spring 生态
代理模式在 Spring 中的应用

Spring 利用动态代理实现的AOP时有两个非常重要的类：JdkDynamicAopProxy和CglibAopProxy，看一下类图：
在这里插入图片描述

Spring 中的代理选择原则
  1. 当 Bean 有实现接口时，Spring 会选择 JDK 动态代理；
  2. 当 Bean 没有接口时，Spring 会选择 CGLib 动态代理；
  3. Spring 可以通过配置强制使用 CGLib动态代理，只需要在Spring 的配置文件中加入如下代码：
    <aop:aspectj-autoproxy proxy-target-class="true"/>
静态代理和动态代理的本质区别
  1. 静态代理只能通过手动完成代理操作，如果被代理类增加了新的方法，代理类需要同步修改，违背开闭原则；
  2. 动态代理采用在运行时动态生成代码的方法，取消了被代理类的扩展限制，遵循开闭原则；
  3. 若动态代理要对目标类的增强逻辑进行扩展，结合策略模式，只需要新增策略类便可完成，无须修改代理类的代码。
代理模式的优缺点

代理模式具有以下优点：

  1. 代理模式能将代理对象与真实被调用目标对象分离；
  2. 在一定程度上降低了系统的耦合性，扩展性好；
  3. 可以起到保护目标对象的作用；
  4. 可以增强目标对象的功能；

当然也有其缺点：

  1. 代理模式会造成系统设计中类的数量增加；
  2. 在客户端和目标对象中增加一个代理对象，会导致请求处理速度变慢；
  3. 增加了系统的复杂度。

上一篇： 代理模式-上篇 https://blog.csdn.net/qq_20315217/article/details/114294246
下一篇： 门面模式

搬运Gong
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
前端开发中常用设计模式-总结篇
weixin_43805705的博客
08-29 1962
本文是向大家介绍前端开发中常用的设计模式，它使我们编写的代码更容易被复用，也更容易被人理解，并且保证代码的稳定可靠性。
Java设计模式之代理模式篇上
03-05
在软件工程中，代理模式（ProxyPattern）在很多情况下都非常有用。例如在JavaXML保重，开发人员可以利用代理来访问Web服务。例1中演示了经典的HelloWorldWeb服务的例子：例1一个SOAP代理的例子...
代理模式分析使用
热门推荐
张彦峰的博客
05-21 164万+
代理模式原理和使用分析总结
设计模式23模式介绍
学Java，找哪吒
01-18 13万+
设计模式精品专栏。
瑞_23种设计模式_代理模式
阿瑞——从事Java后端，喜欢研读源码、自研框架、分享经验
02-19 1780
本文章为瑞_系列专栏之《23种设计模式》的代理模式篇。在代理模式（Proxy Pattern）中，一个类代表另一个类的功能。这种类型的设计模式属于结构型模式。在代理模式中，我们创建具有现有对象的对象，以便向外界提供功能接口。结构型模式描述如何将类或对象按某种布局组成更大的结构。它分为类结构型模式和对象结构型模式，前者采用继承机制来组织接口和类，后者釆用组合或聚合来组合对象。由于组合关系或聚合关系比继承关系耦合度低，满足“合成复用原则”，所以对象结构型模式比类结构型模式具有更大的灵活性。
14. 设计模式-代理模式
weixin_45267102的博客
06-30 1600
为一个对象提供一个替身，以控制对这个对象的访问。即通过代理对象访问目标对象，这样做的好处是---可以在目标对象实现的基础上，增强额外的功能操作，即扩展目标对象的功能。
设计模式-代理模式
Silas 蝈蝈 博客
11-30 4508
本文由老王出租房子引出——代理设计模式，将从最简单的静态代理实现开始，后延伸使用jdk实现动态代理，最后扩展到Cglib实现动态代理。为了更深入理解代理模式，我们会对实际应用中的典型案例进行介绍，包括在Spring和Mybatis中的应用。读者可以拉取完整代码到本地进行学习，实现代码均测试通过后上传到。
JavaSE 高级【反射-动态代理-设计模式-JVM】篇
xinyi_java的博客
08-29 1394
目录 一、 Java 中的反射 1-1 .说说你对 Java 中反射的理解 二、 Java 中的动态代理 2-1 写一个 ArrayList 的动态代理类 2-2 动静态代理的区别，什么场景使用？ 三、 Java 中的设计模式&回收机制 3-1.你所知道的设计模式有哪些？ 3-2 单例设计模式 3-3 工厂设计模式 四、 JDK7 和 JDK8 区别 JDK8: JDK7: 五、 Jvm 虚拟机原理 概述 垃圾回收器（又称为 gc） 1.程序技术器 2.虚..
JAVA 23种设计模式【入门篇】
只有登上山顶，才能看到那边的风光
07-22 1万+
😹 作者: 爱摸鱼的小凯 😻 爱摸鱼的小凯的博客 😽 觉得博主文章写的不错的话，希望大家三连（✌关注，✌点赞，✌评论），多多支持一下！！！
JavaScript 设计模式学习第十八篇－发布－订阅模式
越陌度阡
12-04 2361
在众多设计模式中，可能最常见、最有名的就是发布 - 订阅模式了，本篇我们一起来学习这个模式。 发布 - 订阅模式（Publish-Subscribe Pattern, pub-sub）又叫观察者模式（Observer Pattern），它定义了一种一对多的关系，让多个订阅者对象同时监听某一个发布者，或者叫主题对象，这个主题对象的状态发生变化时就会通知所有订阅自己的订阅者对象，使得它们能够自动更新............
设计模式8：代理模式-动态代理
知道这个有什么用？
09-04 2024
动态代理的核心优势就在于，一个代理类，可以代理多个接口。动态代理只能把代理对象，赋值给接口，如上面的例子。不能把代理对象直接赋值一个普通类。而Cglib代理可以做到。具体怎么做的，下篇文章再讲。，其实就是用java或kotlin代码申请权限，而不是在AndroidManifest.xml文件里面。，静态代理中一个代理类只能代理一个接口，其他不同的接口，就需要再手写不同的代理类，这就很。都是我们手写的代理类。动态代理可以自动生成代理类。动态代理类似于在安卓里面，我们常说的。动态代理需要jdk中提供的两个类。
六种微服务架构的设计模式.pdf
10-02
在这篇文章中，我们将探讨六种常见的微服务架构设计模式：聚合器微服务设计模式、代理微服务设计模式、链式微服务设计模式、分支微服务设计模式、数据共享微服务设计模式和异步消息传递微服务设计模式。 聚合器...
设计模式 GOF 23
08-02
本书分类描述了一组设计良好，表达清楚的软件设计模式，这些模式在实用环境下有特别有用。 前 言 本书并不是一本介绍面向对象技术或设计的书，目前已有不少好书介绍面向对象技术或设计。本书假设你至少已经比较...
设计模式：可复用面向对象软件的基础--详细书签版
03-07
　另外，这也不是一篇高级专题技术论文，而是一本关于设计模式的书，它描述了在面向对象软件设计过程中针对特定问题的简洁而优雅的解决方案。设计模式捕获了随时间进化与发展的问题的求解方法，因此它们并不是人们从...
java-design-patterns:java 学习模式
04-30
结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。 行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、...
简单的项目部署脚本（转载）
u010230019的博客
06-09 625
有些项目团队喜欢使用docker启动java服务,那么我们同样可以将上述脚本稍做改造,来实现基于shell+docker的简单项目部署能力。可以将核心节点的错误或者失败内容通过webhook发送到对应的告警平台,比如钉钉、飞书机器人等。把~/.ssh/id_rsa.pub内容添加到远程仓库的ssh秘钥中。执行start.sh脚本打包部署。start.sh脚本内容。
Java——简单图书管理系统
m0_74100417的博客
06-09 1282
数据类型变量iffor数组方法类和对象封装继承多态抽象类和接口今天就是把上述知识点全部都用起来 图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理
修改菜品——后端Java
weixin_53717695的博客
06-09 427
修改菜品——后端Java
（Javascript）AI数字人mp4转canvas播放并去除背景绿幕
最新发布
lx_nhs的博客
06-12 422
去除前：去除后： 3、可能会出现的报错 （1）视频路径跨域问题：解决：vue开启代理
设计模式-行为型模式-观察者模式
05-13
观察者模式是一种行为型设计模式，用于在对象之间建立一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都会自动收到通知并更新。这种模式的核心是观察者和被观察者两个角色，被观察者维护一组观察者，当自己的状态改变时，会通知所有观察者进行相应的更新操作。 在观察者模式中，被观察者通常会提供注册、删除和通知观察者的方法，而观察者通常会提供一个更新方法，用于接收被观察者的通知并进行相应的处理。这种模式可以提高系统的灵活性和可扩展性，因为观察者和被观察者可以在运行时动态地添加或删除，同时也可以实现松耦合的对象间通信。 观察者模式常用于GUI开发、事件驱动系统和消息队列等场景，例如在GUI中，一个按钮的点击事件会通知所有绑定了该事件的监听器进行相应的处理。在消息队列中，生产者可以向一组消费者发送消息，消费者只需要注册到消息队列中即可接收到生产者发送的消息。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值