Javassist实现动态代理

最新推荐文章于 2024-07-08 21:02:47 发布
最新推荐文章于 2024-07-08 21:02:47 发布
阅读量232 收藏
点赞数
分类专栏： javassist

动态代理模式简述：之所以会出现代理这种模式就是因为我们常有这么一种需求：在被代理类的方法调用前后执行一些其它的逻辑，这些逻辑不适合由被代理类来实现，那这些逻辑谁来实现？当然是代理类。那代理类是谁？从哪里来？代理类是我们利用字节码生成工具动态创建的，然后利用反射实例化而得到代理对象。

tips:这篇文章讲的不是动态代理模式的思想而是怎么实现(简单实现)一个和java.lang.reflect.Proxy类相似的类。

按照JDK动态代理的套路来，先定义一个InvocationHandler来给客户端添加代理的逻辑(这个类和JDK中的一模一样)：

package cc.lixiaohui.demo.javassist.proxy;  

import java.lang.reflect.Method;  

/** 
 * @author lixiaohui 
 * @date 2016年9月27日 下午9:53:59 
 *  
 */  
public interface InvocationHandler {  

    /** 
     * 业务逻辑填充 
     *  
     * @param proxy 生成的代理对象 
     * @param method 调用的方法 
     * @param args 调用该方法的参数 
     * @return 调用该方法的返回值 
     * @throws Throwable throws if any exception 
     */  
    Object invoke(Object proxy, Method method, Object[] args) throws Throwable;  

}

接下来是Proxy类，代理类由该类动态生成并且都继承自该类,和JDK的一样，这也是为什么JDK的动态代理只能代理接口而不能代理父类，这里我就按照JDK的套路来，当然理解了这个后要实现代理父类也没什么难度了。Proxy类是怎么生成类的呢？首先代理的是接口，所以先遍历所有接口，再遍历接口的所有方法，为代理类生成与这些方法同签名同返回值的方法，也就是相当于实现(implement)这些接口的方法，至于生成过程具体是怎么样的我们不用管这也是用javassist的好处（字节码是怎么生成的是javassist的事，我们只需要用它的API即可）。

package cc.lixiaohui.demo.javassist.proxy;  

import java.util.Objects;  
import java.util.concurrent.atomic.AtomicInteger;  

import javassist.CannotCompileException;  
import javassist.ClassPool;  
import javassist.CtClass;  
import javassist.CtConstructor;  
import javassist.CtField;  
import javassist.CtMethod;  
import javassist.Modifier;  
import javassist.NotFoundException;  

import org.slf4j.Logger;  
import org.slf4j.LoggerFactory;  

import cc.lixiaohui.demo.javassist.proxy.util.CompoundKeyWeakHashMap;  

/** 
 * 负责代理类类的生成 
 *  
 * <ul> 
 * 生成的代理类: 
 * <li>public final 修饰(和JDK动态代理不同的是:JDK生成的代理类也是final的, 但不一定是public的, 当所代理的接口中有至少一个以上的接口不是public时生成的代理就不是public的)</li> 
 *  
 * <li>类名以$Proxy为前缀, 后缀为数字, 如cc.lixiaohui.$Proxy0, cc.lixiaohui.$Proxy1...</li> 
 *  
 * <li>生成的代理类继承自{@link Proxy}</li> 
 *  
 * <li>生成的代理类所在package只有一种情况下才是确定的: 当所有接口中有且只有一个接口是non-public时.其他情况所在package不确定</li> 
 * </ul> 
 *   
 * @author lixiaohui 
 * @date 2016年9月27日 下午9:51:24 
 *  
 */  
public class Proxy {  

    private static final Logger logger = LoggerFactory.getLogger(Proxy.class);  

    /** 
     * 生成的代理类名前缀 
     */  
    private static final String PROXY_CLASSNAME_PREFIX = "$Proxy";  

    /** 
     * 类后缀数字生成器 
     */  
    private static final AtomicInteger SUFFIX_GENERATOR = new AtomicInteger();   

    private static final boolean SHOULD_BE_FINAL = true;  
    private static final boolean SHOULD_BE_ABSTRACT = false;  
    private static final boolean SHOULD_BE_PUBLIC = true;  

    protected InvocationHandler invocationHandler;  

    /** 
     * 弱引用已生成的Class的缓存, ClassLoader和被代理Class都相同时生成的代理Class才是相同的(这个类自己实现的,简单扩展一下java.util.Map就可以实现) 
     * <类加载器, 被代理Class, 生成的代理Class> 
     */  
    private static CompoundKeyWeakHashMap<ClassLoader, Class<?>, Class<?>> proxyClassCache = new CompoundKeyWeakHashMap<ClassLoader, Class<?>, Class<?>>();  

    protected Proxy(InvocationHandler invocationHandler) {  
        this.invocationHandler = invocationHandler;  
    }  

    public static Object newProxyInstance(ClassLoader classLoader, Class<?> targetClass, InvocationHandler invocationHandler)   
            throws Exception {  
        // check not null  
        classLoader = Objects.requireNonNull(classLoader, "classLoader cannot be null");  
        targetClass = Objects.requireNonNull(targetClass, "targetClass cannot be null");  
        invocationHandler = Objects.requireNonNull(invocationHandler, "invocationHandler cannot be null");  

        Class<?> proxyClass = proxyClassCache.get(classLoader, targetClass);  
        // 有缓存  
        if (proxyClass != null) {  
            logger.debug("get proxy from cache");  
            return proxyClass.getConstructor(InvocationHandler.class).newInstance(invocationHandler);  
        }  

        // singleton instance of classpool   
        ClassPool pool = ClassPool.getDefault();  
        //生成代理类的全限定名  
        String qualifiedName = generateQualifiedName(targetClass);  
        // 创建代理类  
        CtClass proxy = pool.makeClass(qualifiedName);  
        // 设被代理类继承自Proxy  
        setSuperClass(pool, proxy);  
        // 获取被代理类的所有接口  
        CtClass[] interfaces = pool.get(targetClass.getName()).getInterfaces();  

        int methodIndex = 0;  
        // 遍历这些接口  
        for (CtClass parent : interfaces) {  
            proxy.addInterface(parent);  

            // 获取该接口的所有方法  
            CtMethod[] methods = parent.getDeclaredMethods();  
            for (int j = 0; j < methods.length; ++j) {  
                CtMethod method = methods[j];  
                String fieldSrc = String.format("private static java.lang.reflect.Method method%d = Class.forName(\"%s\").getDeclaredMethods()[%d];"  
                        , methodIndex, parent.getName(), j);  
                logger.debug("field src for method {}: {}", method.getName(), fieldSrc);  
                // 生成字段  
                CtField ctField = CtField.make(fieldSrc, proxy);  
                // 添加字段  
                proxy.addField(ctField);  
                // 生成对应的Method  
                generateMethod(pool, proxy, method, methodIndex);  

                ++methodIndex;  
            }  
        }  
        // 设置代理类的类修饰符  
        setModifiers(proxy, SHOULD_BE_PUBLIC, SHOULD_BE_FINAL, SHOULD_BE_ABSTRACT);  
        // 生成构造方法  
        generateConstructor(pool, proxy);  
        // 持久化class到硬盘, for use of debug  
        proxy.writeFile(".");  
        // to java.lang.Class  
        proxyClass = proxy.toClass(classLoader, null);  
        // 缓存  
        proxyClassCache.put(classLoader, targetClass, proxyClass);  
        return proxyClass.getConstructor(InvocationHandler.class).newInstance(invocationHandler);  
    }  

    /** 
     * 生成代理类的全限定名  
     */  
    private static String generateQualifiedName(Class<?> targetClass) throws Exception {  
        CtClass theInterface = null;  
        for (CtClass parent : ClassPool.getDefault().get(targetClass.getName()).getInterfaces()) {  
            if (theInterface == null) {  
                theInterface = parent;  
            }  
            if (!Modifier.isPublic(parent.getModifiers())) {  
                theInterface = parent;  
                break;  
            }  
        }  
        String name = theInterface.getPackageName() + "." + PROXY_CLASSNAME_PREFIX + SUFFIX_GENERATOR.getAndIncrement();  
        return name;  
    }  


    /** 
     * 设置类的修饰符 
     */  
    private static void setModifiers(CtClass proxy, boolean shouldBePublic, boolean shouldBeFinal, boolean shouldBeAbstract) {  
        int modifier = 0;  
        modifier = shouldBePublic ? modifier | Modifier.PUBLIC : modifier;  
        modifier = shouldBeFinal ? modifier | Modifier.FINAL : modifier;  
        modifier = shouldBeAbstract ? modifier | Modifier.ABSTRACT : modifier;  
        logger.error(Modifier.toString(modifier));  
        proxy.setModifiers(modifier);  
    }  

    /** 
     * 生成构造函数 
     */  
    private static void generateConstructor(ClassPool pool, CtClass proxy) throws NotFoundException, CannotCompileException {  
        CtConstructor ctConstructor = new CtConstructor(new CtClass[]{pool.get(InvocationHandler.class.getName())}, proxy);  
        String methodBodySrc = String.format("super(%s);", "$1");  
        logger.debug("constructor body for constructor {}: {}", ctConstructor.getName(), methodBodySrc);  
        ctConstructor.setBody(methodBodySrc);  
        proxy.addConstructor(ctConstructor);  
    }  


    /** 
     * 生成代理方法 
     */  
    private static void generateMethod(ClassPool pool, CtClass proxy, CtMethod method, int methodIndex) throws NotFoundException, CannotCompileException {  
        CtMethod ctMethod = new CtMethod(method.getReturnType(), method.getName(), method.getParameterTypes(), proxy);  
        String methodBodySrc = String.format("return super.invocationHandler.invoke(this, method%d, $args);", methodIndex);  
        logger.debug("method body for method {}: {}", method.getName(), methodBodySrc);  
        ctMethod.setBody(methodBodySrc);  
        proxy.addMethod(ctMethod);  
    }  

    /** 
     * 把proxy类的父类设置为Proxy 
     *  
     */  
    private static void setSuperClass(ClassPool pool, CtClass proxy) throws CannotCompileException, NotFoundException {  
        proxy.setSuperclass(pool.get(Proxy.class.getName()));  
    }  

}

使用测试

使用方式和JDK的没啥区别

先定义两个被代理的接口：

package cc.lixiaohui.demo.javassist.proxy.example;  

public interface Talkable {   
    Object talk(String words) throws Exception;   
}  
package cc.lixiaohui.demo.javassist.proxy.example;  

interface Smileable {  
    Object smile() throws Exception;  
}

Person实现上面两接口：

package cc.lixiaohui.demo.javassist.proxy.example;  

public class Person implements Smileable, Talkable {  

    private String name;  

    public Person(String name) {  
        this.name = name;  
    }  

    public Object talk(String words) throws Exception {  
        System.out.println(name + " says: " + words);  
        return words;  
    }  

    public Object smile() throws Exception {  
        System.out.println(name + " start smiling");  
        System.out.println(name + " stop smiling");  
        return null;  
    }  

}

代理逻辑的实现：

package cc.lixiaohui.demo.javassist.proxy.example;  

import java.lang.reflect.Method;  

import cc.lixiaohui.demo.javassist.proxy.InvocationHandler;  
import cc.lixiaohui.demo.javassist.proxy.Proxy;  

public class JavassistProxyFactory implements InvocationHandler{  

    //被代理类的对象  
    private Object target;  

    public JavassistProxyFactory(Object target) {  
        this.target = target;  
    }  

    /*  
     * @see cc.lixiaohui.demo.javassist.proxy.InvocationHandler#invoke(java.lang.Object, java.lang.reflect.Method, java.lang.Object[]) 
     */  
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {  
        System.out.println("------- intercept before --------");  
                // 调用原来的方法  
        Object result = method.invoke(target, args);  
        System.out.println("--------intercept after ---------");  
        return result;  
    }  
    // 获取代理类的对象  
    public Object getProxy() throws Exception {  
        return Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(), target.getClass(), this);  
    }  

}

测试主程序：

package cc.lixiaohui.demo.javassist.proxy.example;  

import java.lang.reflect.Modifier;  

import org.junit.Test;  

public class Tester {  

    @Test  
    public void testJavassist() throws Exception {  
        Person person = new Person("小明");  
        Object proxy = new JavassistProxyFactory(person).getProxy();  
                // System.gc(); // 主动触发gc  
        Object proxy1 = new JavassistProxyFactory(person).getProxy();  
        ((Talkable) proxy).talk("hello world");  
        ((Smileable) proxy).smile();  

        System.out.println("package: " + proxy.getClass().getPackage().getName());  
        System.out.println("classname: " + proxy.getClass().getName());  
        System.out.println("modifiers: " + Modifier.toString(proxy.getClass().getModifiers()));  
                System.out.println(proxy.getClass() == proxy1.getClass()); // 测试缓存是否起作用  
    }  

}

结果输出：
这里写图片描述

在 Proxy类中生成代理Class时把这个Class持久化了到硬盘中，通过反编译工具查看生成的代理类的源码：

/*** Eclipse Class Decompiler plugin, copyright (c) 2016 Chen Chao (cnfree2000@hotmail.com) ***/  
package cc.lixiaohui.demo.javassist.proxy.example;  

import cc.lixiaohui.demo.javassist.proxy.InvocationHandler;  
import cc.lixiaohui.demo.javassist.proxy.Proxy;  
import java.lang.reflect.Method;  

public final class $Proxy0 extends Proxy implements Smileable, Talkable {  
    private static Method method0 = java.lang.Class.forName("cc.lixiaohui.demo.javassist.proxy.example.Smileable").getDeclaredMethods()[0];  
    private static Method method1 = java.lang.Class.forName("cc.lixiaohui.demo.javassist.proxy.example.Talkable").getDeclaredMethods()[0];  

    public Object smile() {  
        return this.invocationHandler.invoke(this, method0, new Object[0]);  
    }  

    public Object talk(String paramString) {  
        return this.invocationHandler.invoke(this, method1, new Object[] { paramString });  
    }  

    public $Proxy0(InvocationHandler paramInvocationHandler) {  
        super(paramInvocationHandler);  
    }  
}

转载自http://lixiaohui.iteye.com/blog/2328182

weixin_39663628
关注
专栏目录
JDK、CGLib、Javassist实现动态代理
Think In JAVA—Max
05-22 2110
一、类加载1.类加载过程模拟public class Programmer { public void code() { System.out.println("I'm a Programmer,Just Coding....."); } }/** * 自定义一个类加载器，用于将字节码转换为class对象 */ public class MyClassLoad...
FeignClient原理解析，100行代码实现feign功能，mybatis的mapper、dubbo、feign实现原理模拟。spring扫描自定义注解原理。Javassist实现动态代理原理
qq_33990603的博客
01-15 889
本片文章重在理解spring的扩展机制。理解了扩展机制。今后可以自行灵活对spring进行扩展。 Fegin的功能需要有一定的认识，简单的说Fegin承担的责任就是让服务A去调用服务B的接口，比如服务B写了一个controler，服务A想要调用这个controller，就可以通过fegin直接调用，大部分使用场景是在 现象：在使用feign，或者mybatis等框架的时候，都有一个特点就是会先定义一个接口，比如：mybaits的mapper, feign的 client。但是我们知道，spring的在帮我们
Javassist实现JDK动态代理
二进制之路
08-12 293
提到JDK动态代理，相信很多人并不陌生。然而，对于动态代理的实现原理，以及如何编码实现动态代理功能，可能知道的人就比较少了。接下一来，我们就一起来看看JDK动态代理的基本原理，以及如何通过Javassist进行模拟实现。 JDK动态代理 示例 以下是一个基于JDK动态代理的hello world示例，在很多地方都可以看到类似的版本。 public class DynamicProxyT...
Java实现动态代理
最新发布
ZHI_YUE的博客
07-08 573
JAVA动态代理一种结构型设计模式，它为其他对象提供一种代理以控制对这个对象的访问。代理模式在客户端和目标对象之间起到一个中介的作用（1）功能增强: 基于某个功能，再增加一些功能。（目标类只负责核心功能，其他附属功能通过代理类完成。代理类的方法名与目标类的方法相同，内容不同，在核心功能外加了一些额外逻辑）（2）控制访问: 防止直接访问目标这种模式广泛应用于软件设计中，尤其是在需要延迟加载、访问控制、缓存实现、日志记录、事务管理、远程调用等场景中。
代理模式-Javassist动态代理
Leon_Jinhai_Sun的博客
12-24 224
代理模式-Javassist动态代理
Java Javassist动态代理
Excellent999的博客
09-27 182
【代码】Java Javassist动态代理。
代理模式：静态代理与动态代理（JDK、CGLIB、javassist动态代理）
头好重好重的博客
08-24 901
介绍代理模式中的静态代理与动态代理（JDK、CGLIB、javassist动态代理）
动态代理-jdk、cglib、javassist.zip
05-19
本压缩包包含关于三种主要的动态代理实现方式：JDK动态代理、CGLIB以及javassist的相关资料。 首先，JDK动态代理是Java标准库提供的一种动态代理机制，它依赖于java.lang.reflect包中的Proxy和InvocationHandler...
Java动态代理机制详解（JDK 和CGLIB，Javassist，ASM）
04-24
NULL 博文链接：https://bijian1013.iteye.com/blog/2382393
利用Javassist 实现动态代理
shizhan1881的专栏
11-15 1981
一提到jdk中的java.lang.reflect.Proxy，用过spring，hibernate等框架的人应该都有所了解，对！就是动态代理。AOP - 面向切面编程 - 就是基于动态代理实现的。 平日里项目中用spring aop框架进行日志拦截和声明式事务处理确实很方便好用，从另一种角度将代码解耦，极大的提高了代码的灵活性和可扩展性，在获益的同时我们不得不惊叹aop框架的神奇，但是
Javassist的动态代理实现。
mingxin95的博客
07-02 8249
一提到jdk中的java.lang.reflect.Proxy，用过spring，hibernate等框架的人应该都有所了解，对！就是动态代理。AOP - 面向切面编程 - 就是基于动态代理实现的。 为什么要提代理模式。因为AOP的广泛实现都是通过动态代理，而动态代理又不得不说代理模式。 代理模式，顾名思义，就是对一个类的访问，变为访问这个类的代理人。经由代理再访问这个类。（代理与被代理的类实
静态代理与动态代理
weixin_45354445的博客
02-17 196
静态代理 静态代理就是我们自己手写代理类； aspectJ静态代理（编译期生成代理类） 静态代理可以实现在不修改目标对象代码的前提下，对目标对象的功能进行扩展； 静态代理：（目标接口、目标接口实现、代理类） 优点：可以实现不对目标对象进行修改的前提下，对目标对象进行功能的扩展和增强，也就是扩展原功能，不污染原代码。 缺点：因为代理对象，需要实现与目标对象一样的接口，如果目标接口类繁多，也会导致代理类繁多，另外一旦目标接口增加新方法，则代理类也需要维护； 实现方式 /** * 目标接口 * */ pub
Javassist 使用,动态生成类，动态代理
weixin_34101229的博客
06-08 259
最近学习了javassist的使用方法。 javassist是一个字节码类库，可以用他来动态生成类，动态修改类等等。 下面是如果用javassist来动态创建一个类的demol 我们需要创建的目标类，如下： Java代码 publicclassJavassistClass{ privateStringname="default"; ...
用javassist实现简单的动态代理
liuwenjie517333813的专栏
08-05 1687
  网上有网友已经实现了该功能，我只是把我的理解说出来，希望对大家有帮助！       主要思路：创建一个拦截器接口，里面有有一个invoke方法,再创建一个能够生成代理的类，该类的主要作用是生成了一个新类，该新类实现了被代理类接口的每个方法(生成新类的实例时是用javassist)。这个新类里每个方法都通过反射去调用拦截器中的invoke方法，（而invoke方法中我们会去调用被代理类的方法
javassist使用并生成动态代理
skh2015java的博客
09-06 918
Javaassist 就是一个用来 处理 Java 字节码的类库。它可以在一个已经编译好的类中添加新的方法，或者是修改已有的方法，并且不需要对字节码方面有深入的了解。同时也可以去生成一个新的类对象，通过完全手动的方式。 首先需要引入jar包： <dependency> <groupId>org.javassist</groupId> <artifactId>javassist</artifactId> &lt...
深入理解JDK动态代理原理，使用javassist动手写一个动态代理框架
秃了也弱了
03-05 734
vm options参数设置-Dsun.misc.ProxyGenerator.saveGeneratedFiles=true，就可以把生成的代理类的源码保存在com.sun.proxy目录下面，或者用arthas来查看运行中的类信息。
Java动态编程：Javassist深度解析
通过Javassist，开发者可以方便地在运行时创建或修改类，实现动态代理、AOP（面向切面编程）等功能，或者根据配置文件动态调整程序行为。 在Java中使用Javassist的步骤通常包括： 1. 导入Javassist库。 2. 创建...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值