动态代理理解

最新推荐文章于 2024-05-14 00:33:46 发布
最新推荐文章于 2024-05-14 00:33:46 发布
阅读量185 收藏
点赞数
分类专栏： java 文章标签： 代理模式 java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Tt5802/article/details/124537664
版权

动态代理

在这里插入图片描述

一、CGLIB动态代理

1、原理：利用asm开源包，对代理对象类的class文件加载进来，通过修改其字节码生成子类来处理,CGLIB 通过动态生成一个需要被代理类的子类(即被代理类作为父类),该子类重写被代理类的所有不是 final 修饰的方法,并在子类中采用方法拦截的技术拦截父类所有的方法调用,进而织入横切逻辑。

package com.onlymark.proxy;

import com.onlymark.service.UserService;
import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

/**
 * @auther Onlymark
 * @date 2021/5/7 上午6:05
 */
public class JavaProxyFactory1 implements MethodInterceptor {
	private UserService userService;

	public JavaProxyFactory1(UserService userService) {
		this.userService = userService;
	}

	//cglib
	public UserService createUserServiceProxy(){

		Enhancer enhancer = new Enhancer();
		//设置Enhancer对象的父类
		enhancer.setSuperclass(UserService.class);
		//设置回调方法
		enhancer.setCallback(this);
		//创建代理对象
		UserService service = (UserService)enhancer.create();
		//返回代理对象
		return service;
	}

	/**
	 * obj：cglib生成的代理对象 obj表示增强的对象，即实现这个接口类的一个对象；
	 * method：被代理对象方法 method表示要被拦截的方法；
	 * args：方法入参 args表示要被拦截方法的参数；
	 * methodProxy: 代理方法 proxy表示要触发父类的方法对象；
	 */
	@Override
	public Object intercept(Object obj, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
		System.out.println("开启事务");
		Object object = method.invoke(userService, args);
		System.out.println("关闭事务");
		return object;
	}

	public static void main(String[] args) {
		JavaProxyFactory1 javaProxyFactory1 = new JavaProxyFactory1(new UserService());
		UserService userServiceProxy = javaProxyFactory1.createUserServiceProxy();
		userServiceProxy.adduser();

		userServiceProxy.deleteuser();
	}
}

一、动态代理

1.增强方法增强方法

package cn.tt.trendsProxy.JDKproxy;

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


/**
 * @author Tzc
 * 这个类可以（自动生成代理类）
 * 实现方式：
 * 				 	1. 静态代理：有一个类文件描述代理模式
 * 				 	2. 动态代理：在内存中形成代理类
 * 						* 实现步骤：
 * 							1. 代理对象和真实对象实现相同的接口
 * 							2. 代理对象 = Proxy.newProxyInstance();
 * 							3. 使用代理对象调用方法。
 * 							4. 增强方法
 *
 * 						* 增强方式：
 * 							1. 增强参数列表
 * 							2. 增强返回值类型
 * 							3. 增强方法体执行逻辑
 */
@SuppressWarnings("all")
public class ProxyInvocationHandler implements InvocationHandler {
    //被代理的接口
    private Rent rent;
    public void setRent(Rent rent) {
        this.rent = rent;
    }

    //实现接口（抽象角色）生成得到代理类（处理程序方法生成我们要调用的接口对象）
   /*  public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)
       newProxyInstance，方法有三个参数：
       loader: 用哪个类加载器去加载代理对象
       interfaces:动态代理类需要实现的接口
       h:动态代理方法在执行时，会调用h里面的invoke方法去执行*/
   /*
     getClass()取得当前对象所属的Class对象,通过getClass()方法得到该对象类Class后，可以通过Class获取这个类中的相关属性和方法
     getClassLoader()取得该Class对象的类装载器类装载器负责从Java字符文件将字符流读入内存，并构造Class类对象
     getClassLoader()把Class文件加载进内存封装为类对象
     getInterfaces()方法和Java的反射机制有关。它能够获得这个对象所实现的所有接口。

     三个参数：
                1. 类加载器：真实对象.getClass().getClassLoader()
                2. 接口数组：真实对象.getClass().getInterfaces()
                3. 处理器：new InvocationHandler()
   */
    public Object getProxy() {
        return Proxy.newProxyInstance(this.getClass().getClassLoader(), rent.getClass().getInterfaces(), this);
    }


    /*
        InvocationHandler 是代理实例的调用处理程序 实现的接口。
        每个代理实例都具有一个关联的调用处理程序。
        对代理实例调用方法时，将对方法调用进行编码并将其指派到它的调用处理程序的 invoke 方法。
    */
    /*
        proxy - 在其上调用方法的代理实例
        method - 对应于在代理实例上调用的接口方法的 Method 实例。Method 对象的声明类将是在其中声明方法的接口，该接口可以是代理类赖以继承方法的代理接口的超接口。
        args - 包含传入代理实例上方法调用的参数值的对象数组，如果接口方法不使用参数，则为 null。基本类型的参数被包装在适当基本包装器类（如 java.lang.Integer 或 java.lang.Boolean）的实例中。

        代理逻辑编写的方法：代理对象调用的所有方法都会触发该方法执行
            参数：
                1. proxy:代理对象
                2. method：代理对象调用的方法，被封装为的对象
                3. args:代理对象调用的方法时，传递的实际参数

    */
    //执行生成的代理类的方法，并返回结果
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //动态代理的本质就是使用反射机制实现
             /* invoke方法参数：
                        obj - 从中调用底层方法的对象
                        args - 用于方法调用的参数
             */
        Object result = method.invoke(rent, args);
        //增强方法体执行逻辑
        seeHouse();
        hetong();
        fare();
        return result;

    }


    //看房
    public void seeHouse(){
        System.out.println("中介带我看房");
    }

    //签合同
    public void hetong(){
        System.out.println("签租赁合同");
    }

    //收中介费
    public void fare(){
        System.out.println("收中介费");
    }
}

2.增强参数

package cn.itcast.proxy;

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

public class ProxyTest {

    public static void main(String[] args) {
        //1.创建真实对象
        Lenovo lenovo = new Lenovo();
        
        //2.动态代理增强lenovo对象
        /*
            三个参数：
                1. 类加载器：真实对象.getClass().getClassLoader()
                2. 接口数组：真实对象.getClass().getInterfaces()
                3. 处理器：new InvocationHandler()
         */
        SaleComputer proxy_lenovo = (SaleComputer) Proxy.newProxyInstance(lenovo.getClass().getClassLoader(), lenovo.getClass().getInterfaces(), new InvocationHandler() {

            /*
                代理逻辑编写的方法：代理对象调用的所有方法都会触发该方法执行
                    参数：
                        1. proxy:代理对象
                        2. method：代理对象调用的方法，被封装为的对象
                        3. args:代理对象调用的方法时，传递的实际参数
             */
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                /*System.out.println("该方法执行了....");
                System.out.println(method.getName());
                System.out.println(args[0]);




*/
                //判断是否是sale方法
                if(method.getName().equals("sale")){
                    //1.增强参数
                    double money = (double) args[0];
                    money = money * 0.85;
                    System.out.println("专车接你....");
                    //使用真实对象调用该方法
                    String obj = (String) method.invoke(lenovo, money);
                    System.out.println("免费送货...");
                    //2.增强返回值
                    return obj+"_鼠标垫";
                }else{
                    Object obj = method.invoke(lenovo, args);
                    return obj;
                }



            }
        });

        //3.调用方法

       /* String computer = proxy_lenovo.sale(8000);
        System.out.println(computer);*/

        proxy_lenovo.show();
    }
}

3.增强返回值

package cn.itcast.web.filter;

import javax.servlet.*;
import javax.servlet.annotation.WebFilter;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.ArrayList;
import java.util.List;

/**
 * 敏感词汇过滤器
 */
@WebFilter("/*")
public class SensitiveWordsFilter implements Filter {


    public void doFilter(ServletRequest req, ServletResponse resp, FilterChain chain) throws ServletException, IOException {
        //1.创建代理对象，增强getParameter方法

        ServletRequest proxy_req = (ServletRequest) Proxy.newProxyInstance(req.getClass().getClassLoader(), req.getClass().getInterfaces(), new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                //增强getParameter方法
                //判断是否是getParameter方法
                if(method.getName().equals("getParameter")){
                    //增强返回值
                    //获取返回值
                    String value = (String) method.invoke(req,args);
                    if(value != null){
                        for (String str : list) {
                            if(value.contains(str)){
                                value = value.replaceAll(str,"***");
                            }
                        }
                    }
                    
                    return  value;
                }

                //判断方法名是否是 getParameterMap

                //判断方法名是否是 getParameterValue

                return method.invoke(req,args);
            }
        });

        //2.放行
        chain.doFilter(proxy_req, resp);
    }
    private List<String> list = new ArrayList<String>();//敏感词汇集合
    public void init(FilterConfig config) throws ServletException {

        try{
            //1.获取文件真实路径
            ServletContext servletContext = config.getServletContext();
            String realPath = servletContext.getRealPath("/WEB-INF/classes/敏感词汇.txt");
            //2.读取文件
            BufferedReader br = new BufferedReader(new FileReader(realPath));
            //3.将文件的每一行数据添加到list中
            String line = null;
            while((line = br.readLine())!=null){
                list.add(line);
            }

            br.close();

            System.out.println(list);

        }catch (Exception e){
            e.printStackTrace();
        }

    }

    public void destroy() {
    }

}
Cc_shell
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
使用ASM实现动态代理
lightj1996的博客
07-12 1400
目录 demo场景介绍 准备工作 代码演示 本章节演示如何用字节码编织技术实现动态代理，阅读之前请先了解字节码原理。如果了解JVM更加容易理解 动态代理的底层实现有两种方法，javasist和ASM，一般情况下，JDK和CGlib都是用的ASM，今天代码演示一下ASM如何实现动态代理。 demo场景介绍 目标类：TargetService 前面类：AspectService 生成代理类 ：TargetServiceProxy 目标：希望生成这样一个类TargetServicePro.
asm-3.3.1.jar详解
zwj1030711290的CSDN
06-22 7145
ASM是一个Java字节码操纵框架。它可以直接以二进制形式动态地生成stub类或其他代理类，或者在装载时动态地修改类。ASM提供类似于BCEL和SERP之类的工具包的功能，但是被设计得更小巧、更快速，这使它适用于实时代码插装。 比如CGLIB利用它生成代理类 http://blog.csdn.net/liyangbing315/article/details/5472862 你可以利用A
用大白话从宏观的角度聊一聊asm技术和class字节码文件和动态代理的关系，绝对通俗易懂
曹举的个人博客
10-31 3879
大家知道方法区(1.7之前的实现是永久代，1.8之后的实现是元空间)里放的基本上都是加载到内存里的各个类的class字节码内容，那有人肯定会问，我项目里用到的java类，生成的class字节码文件，在我写完项目后，不都确定了吗，能有多少个啊，怎么会多到把我的方法区的内存撑爆呢？还有另外一种情况就是，某些场景下你可能会需要自己用动态代理来处理一些业务上的东西，如果你自己使用动态代理不当的时候，也会导致产生大量的字节码，这些大量在运行期间动态生成的class字节码都被放进了方法区，从而导致你的方法区内存溢出。
动态代理 JDK和CGLib的区别？
qq_42582773的博客
12-23 1361
动态代理 JDK和CGlib区别
asm-cglib开发包
03-04
asm-3.3.1.jar cglib-nodep-3.1.jar cglib动态代理所需jar包
JDK动态代理理解
04-16
里面 jdk动态代理详细的讲解了 希望对你们有所帮助
动态代理例子
05-17
是一个描述动态代理的实例，用的是反射的方法，感觉还是比较容易理解得
动态代理，JDK实现动态代理，springAOP初学理解动态代理。代码实现
12-20
实现动态代理的两种方式： 第一种是JDK提供的基于接口的动态代理，要求被代理的类必须至少实现一个接口。 2. 第二种是第三方cglib提供的基于子类的动态代理，。至少要继承一个类。 我们这里 来讲解，动态代理，以及...
详细分析java 动态代理
08-19
主要介绍了java 动态代理的的相关资料，文中讲解非常细致，代码帮助大家更好的理解和学习，感兴趣的朋友可以了解下
Java动态代理示例代码.rar
05-19
使用java完成动态代理的演示代码，适合初学者理解动态代理的功能，进行参考，本代码是简单的demo代码，仅用于学习参考。
asm-7.1（jar以及源码）.rar
05-28
Asm 的工具，里面有两个Jar包，以及asm-7.1版本的源代码
java 版本 asm 架包
04-04
ASM设计用于字节码的改写、生成。其有两套API一套基于访问者模式、一套基于树的数据结构。
ASM（active shape model）算法学习总结
skyshu的博客
10-24 6246
引言     大二利用ASM算法做完项目后，一直没有进行总结。时至今日读了ASM原始论文，以及多篇ASM算法介绍的博客，做以下总结。     ASM（active shape model）大多地方译作 ：主动（主观）形状模型，我个人认为如果译作：动态形状模型 更为合适，原始论文指出ASM是形状可变的图像结构模型。（new methods of building and using flexible...
Java中Asm包有什么用？
aigan8070的博客
05-08 538
ASM能做什么 我们都知道，一般情况下，Class文件是通过javac编译器产生的，然后通过类加载器加载到虚拟机内，再通过执行引擎去执行。 　　现在我们可以通过ASM的API直接生成符合Java虚拟机规范的Class字节流，这样，ASM做的事情一定程度上正是javac解释器做的工作。 可以说ASM分析一个类、从字节码角度创建一个类、修改一个已经被编译过的类...
Cglib,asm,Aspect，JDK原生的代理模式这四种有哪些差别，原理各是什么？
u014651643的博客
07-11 2690
1.jdk是内部生成了一个实现了被代理类所有接口的代理类，用反射来调用InvocationHandler的invoke方法来代理所有类，生成速度最快，执行速度最慢。 2.asm直接操作字节码，然后用classload加载如jvm里，生成速度慢，执行速度较快。 3.感觉cglib是对asm的封装啊，不用了解那么多class类结构就可以用了。由于封装性能比asm差点，但是比JDK快。 4.asp
深入ASM源码之ClassReader、ClassVisitor、ClassWriter
李博/Alex的技术海洋
04-05 759
深入ASM源码之ClassReader、ClassVisitor、ClassWriter 概述 ASM是Java中比较流行的用来读写字节码的类库，用来基于字节码层面对代码进行分析和转换。在读写的过程中可以加入自定义的逻辑以增强或修改原来已编译好的字节码，比如CGLIB用它来实现动态代理。ASM被设计用于在运行时对Java类进行生成和转换，当然也包括离线处理。ASM短小精悍、且速度很快，从而避...
ASM框架使用（一）--初识
热门推荐
ljz2016的博客
08-02 3万+
ASM框架是一个致力于字节码操作和分析的框架，它可以用来修改一个已存在的类或者动态产生一个新的类。ASM提供了一些通用的字节码转换和分析算法，通过这些算法可以定制更复杂的工具。ASM提供了其它字节码工具相同的功能，但是它更关注执行效率，它被设计的更小更快，它被用于以下项目： openjdk，实现lambda表达式调用， Nashorn编译器 Groovy和Kotlin编译器 Cobertura...
spring源码学习 spring-core（一）ASM包
weixin_28845281的博客
05-25 1252
目录1. spring-core 包概况1. spring-core 包概况1.1 ASM 包概述： ASM: a very small and fast Java bytecode manipulation framework ASM: 一款非常小且快的java字节码操作框架ASM包内结构： Class-1. AnnotationVisitor (1).Class简介：
kubernetes集群svc的代理模式-iptables修改为ipvs
最新发布
weixin_39941298的博客
05-14 872
我们都知道，k8s集群的外部网络分发，借助kube-proxy组件来完成；我们为什么要将代理模式修改为ipvs而不继续使用iptables呐？1，iptables底层使用四表五链完成网络代理，效率比较低，而ipvs是采用了iphash的方式实现代理的，效率比较高，因此才会采用ipvs作为生产环境中的网络代理；2，iptables不太适合【读】，可读性太低，很乱；通过一层一层的路由查询，我们就知道了目标地址的终点ip是什么；
java aop 动态代理
07-29
Java的AOP（面向切面编程）是一种编程范式，它允许开发者通过在程序运行时动态地将额外的行为织入到现有的代码中。...希望这个例子能帮助你理解Java AOP中动态代理的基本概念和用法。如有任何疑问，请随时提问！

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值