动态代理-jdk、cglib、javassist

代理

• 静态代理 (不做说明)
• 动态代理

动态代理

• jdk
• cglib
• javassist

项目截图

源码下载，源码中包含代理后的.class类

spring源码环境搭建

jdk

代码如下 :

• JdkClient.java : 代理测试类
• JdkUserProxy.java : 代理实现类
• UserService.java : 测试-接口类
• UserServiceImpl.java : 测试-实现类

JdkClient

package com.proxy.jdk;

import java.lang.reflect.Proxy;

/**
 * 代理测试类
 *
 * JDK动态代理，通过实现接口实现动态代理，目标类必须实现的某个接口，如果某个类没有实现接口则不能生成代理对象。
 *
 *  JDK6及JDK7 :
 *  	不涉及大量调用的情况下，cglib代理性能优于jdk代理
 *  JDK8后 :
 *       jdk代理性能优于cglib代理
 *
 * 动态代理使用步骤 :
 * 		1.创建被代理的类以及接口
 * 		2.创建一个实现接口InvocationHandler的类，并实现invoke方法
 * 		3.通过Proxy的静态方法 newProxyInstance(ClassLoaderloader, Class[] interfaces, InvocationHandler h)创建一个代理
 * 		4.通过代理调用方法
 *
 */
public class JdkClient {

	public static void main(String[] args) {

		/**
		 * 配置参数，可以将jdk动态代理的类输出到文件中，输出到项目根目录下
		 */
		System.setProperty("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");

		/**
		 * lassLoader loader : classLoader
		 * Class<?>[] interfaces : 要代理的接口
		 * InvocationHandler h : 代理实现类
		 */
		UserService userService = (UserService)Proxy.newProxyInstance(UserService.class.getClassLoader(), new Class[]{UserService.class}, new JdkUserProxy(new UserServiceImpl()));
		System.err.println(userService.sayHello("zhangsan"));
	}

}

JdkUserProxy

package com.proxy.jdk;

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

/**
 * 代理实现类
 */
public class JdkUserProxy implements InvocationHandler {

	/**
	 * 目标对象
	 */
	private Object target;
	private JdkUserProxy() { }
	/**
	 * 要代理的目标对象
	 */
	public JdkUserProxy(Object target) {
		this.target = target;
	}

	/**
	 * 代理实现
	 * proxy  : 代理类
	 * method : 被代理的方法
	 * args   : 该方法的参数数组
	 */
	@Override
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
		System.err.println(" jdk proxy ");
		if ("toString".equals(method.getName())) {
			return proxy;
		}
		return method.invoke(target, args);
	}

}

UserService

package com.proxy.jdk;

/**
 * 测试-接口类
 */
public interface UserService {

	String sayHello(String name);

	String sayThinks(String name);

}

UserServiceImpl

package com.proxy.jdk;

/**
 * 测试-实现类
 */
public class UserServiceImpl implements UserService{

	@Override
	public String sayHello(String name) {
		return "sayHello : " + name;
	}

	@Override
	public String sayThinks(String name) {
		return "sayThinks : " + name;
	}

}

cglib

代码如下 :

• CglibClient.java : 代理测试类
• CglibProxy.java : cglib代理实现类
• OrderService.java : 被代理类-非接口形式
• UserService.java : 被代理类-接口形式
• UserServiceImpl.java : 被代理类-接口形式

CglibClient

package com.proxy.cglib;

import net.sf.cglib.core.DebuggingClassWriter;

/**
 * 代理测试类
 *
 * Cglib原理是针对目标类生成一个子类，覆盖其中的所有方法，所以目标类和方法不能声明为final类型。
 * 		若目标类使用final修饰，则抛出异常
 * 		若目标方法使用final修饰，则不抛异常，但也不进行代理
 *
 * gradle :
 *  	cglib-nodep : 内置了ASM代码，不会引入ASM包
 *  	cglib       : 未内置ASM代码，会引入ASM包
 */
public class CglibClient {

	public static void main(String[] args) {

		/**
		 * 配置参数，可以将cglib动态代理的类输出到文件中
		 */
		System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, "D:\\code");

		CglibProxy cglibProxy = new CglibProxy();
		/**
		 * 对类做代理
		 */
		OrderService orderService = cglibProxy.createProxy(OrderService.class);
		System.err.println(orderService.sayHello("zhangsan"));
		/**
		 * 方法被final修饰，不会被代理
		 */
		System.err.println(orderService.finalMethod("zhangsan"));

		/**
		 * 对接口做代理，传入接口的实现类 : 可正常代理实现
		 */
		UserService userService = cglibProxy.createProxy(UserServiceImpl.class);
		System.err.println(userService.sayThinks("zhangsan"));

		/**
		 * 对接口做代理，传入接口 : 不可正常代理实现 : java.lang.NoSuchMethodError: java.lang.Object.sayThinks(Ljava/lang/String;)Ljava/lang/String;
		 * 		可通过修改com.proxy.cglib.CglibProxy#intercept来对接口做下处理，具体可参考方法体说明
		 */
		UserService userService1 = cglibProxy.createProxy(UserService.class);
		System.err.println(userService1.sayThinks("zhangsan"));
	}

}

CglibProxy

package com.proxy.cglib;

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

/**
 * cglib代理实现类
 * 		cglib 可以代理类，也可以代理接口
 */
public class CglibProxy implements MethodInterceptor {

	/**
	 * 获取代理类
	 */
	public <T> T createProxy(Class clazz){
		/**
		 * 字节码增强的一个类
		 */
		Enhancer enhancer = new Enhancer();
		/**
		 * 设置父类，设置需要创建子类的类
		 */
		enhancer.setSuperclass(clazz);
		/**
		 * 设置回调类
		 */
		enhancer.setCallback(this);
		/**
		 * 通过字节码技术动态创建子类实例
		 */
		return (T) enhancer.create();
	}


	@Override
	public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
		System.err.println(" cglib proxy ");
		/**
		 * 如果是代理的为类 : 通过代理类调用父类中的方法
		 */
		return methodProxy.invokeSuper(o, objects);
		/**
		 * 如果是代理的为接口(指createProxy传递的为接口而非接口的实现类)
		 * 		需要首先去获取接口的实现类，然后调用方法 : 使用 methodProxy.invoke(o, objects);
		 * 接口的代理实现建议使用JDK代理，故这里不做实现说明
		 */
		// return methodProxy.invoke(实现类, objects);
	}

}

OrderService

package com.proxy.cglib;

/**
 * 被代理类-非接口形式
 * 		若类被final修饰，则代理时会报错
 */
public class OrderService {

	public String sayHello(String name) {
		return "sayHello : " + name;
	}

	public String sayThinks(String name) {
		return "sayThinks : " + name;
	}

	/**
	 * 方法被final修饰，则不会被代理，但可正常执行
	 */
	public final String finalMethod(String name) {
		return "finelMethod : " + name;
	}

}

UserService

package com.proxy.cglib;

/**
 * 被代理类-接口形式
 */
public interface UserService {

	String sayHello(String name);

	String sayThinks(String name);

}

UserServiceImpl

package com.proxy.cglib;

/**
 * 被代理类-接口形式
 */
public class UserServiceImpl implements UserService {

	@Override
	public String sayHello(String name) {
		return "sayHello : " + name;
	}

	@Override
	public String sayThinks(String name) {
		return "sayThinks : " + name;
	}

}

javassist

代码如下 :

• SsistClient.java : javassist测试类
• Student.java : 测试类

SsistClient

package com.proxy.javassist;

import org.apache.ibatis.javassist.*;

import java.lang.reflect.Method;
import java.lang.reflect.Modifier;

/**
 *
 * javassist测试类
 *
 * Javassist是一个开源的分析、编辑和创建Java字节码的类库，可以直接编辑和生成Java生成的字节码。
 * 相对于bcel, asm等这些工具，开发者不需要了解虚拟机指令，就能动态改变类的结构，或者动态生成类。javassist简单易用， 快速。
 *
 * 重要的类 :
 * 		ClassPool：javassist的类池，使用ClassPool 类可以跟踪和控制所操作的类，它的工作方式与 JVM 类装载器非常相似
 * 		CtClass： CtClass提供了类的操作，如在类中动态添加新字段、方法和构造函数、以及改变类、父类和接口的方法。
 * 		CtField：类的属性，通过它可以给类创建新的属性，还可以修改已有的属性的类型，访问修饰符等
 * 		CtMethod：类中的方法，通过它可以给类创建新的方法，还可以修改返回类型，访问修饰符等， 甚至还可以修改方法体内容代码
 * 		CtConstructor：与CtMethod类似
 *
 * javassist被用于struts2和hibernate中，都用来做动态字节码修改使用。一般开发中不会用到，但在封装框架时比较有用。
 *
 * 虽然javassist提供了一套简单易用的API，但如果用于平常的开发，会有如下几点不好的地方 :
 * 		1> 所引用的类型，必须通过ClassPool获取后才可以使用
 * 		2> 代码块中所用到的引用类型，使用时必须写全量类名
 * 		3> 即使代码块内容写错了，它也不会像eclipse等开发工具一样有提示，它只有在运行时才报错
 * 		4> 动态修改的类，必须在修改之前，jvm中不存在这个类的实例对象。修改方法的实现必须在修改的类加载之前进行。 (否则需要使用新的classloader重新加载)
 *
 * javassist使用的不多，仅做简单说明，不进行详细案例说明
 * 		详细了解可参考 : https://github.com/jboss-javassist/javassist
 *
 * 异常自行查看官方API解决即可 : Exception in thread "main" java.lang.RuntimeException: com.proxy.javassist.Student class is frozen
 *
 */
public class SsistClient {

	public static void main(String[] args) throws Exception {

//		modifyMethod();
//		addMethod();
		createClass();

	}

	/**
	 * 动态创建类
	 */
	public static void createClass() throws Exception{
		// 获取 ClassPool
		ClassPool pool = ClassPool.getDefault();
		// 创建teacher类
		CtClass teacherClass = pool.makeClass("com.proxy.javassist.Teacher");
		// 设置为公有类
		teacherClass.setModifiers(Modifier.PUBLIC);
		// 获取String类型
		CtClass stringClass = pool.get("java.lang.String");
		// 获取list类型
		CtClass listClass = pool.get("java.util.List");
		// 获取学生的类型
		CtClass studentClass = pool.get("com.proxy.javassist.Student");
		// 给teacher添加name属性
		CtField nameField = new CtField(stringClass, "name", teacherClass);
		nameField.setModifiers(Modifier.PUBLIC);
		teacherClass.addField(nameField);
		// 给teacher类添加students属性
		CtField studentList = new CtField(listClass, "students",teacherClass);
		studentList.setModifiers(Modifier.PUBLIC);
		teacherClass.addField(studentList);
		// 给teacher类添加无参构造方法
		CtConstructor ctConstructor = CtNewConstructor.make("public Teacher() {this.name=\"abc\";this.students = new java.util.ArrayList();}", teacherClass);
		teacherClass.addConstructor(ctConstructor);
		// 给teacher类添加addStudent方法
		CtMethod m = new CtMethod(CtClass.voidType, "addStudent", new CtClass[]{studentClass}, teacherClass);
		m.setModifiers(Modifier.PUBLIC);
		// 添加学生对象到students属性中, $1代表参数1
		m.setBody("this.students.add($1);");
		teacherClass.addMethod(m);
		// 给teacher类添加sayHello方法
		m = new CtMethod(CtClass.voidType, "sayHello", new CtClass[]{}, teacherClass);
		m.setModifiers(Modifier.PUBLIC);
		m.setBody("System.out.println(\"Hello, My name is \" + this.name);");
		m.insertAfter("System.out.println(\"I have \" + this.students.size() + \" students\");");
		teacherClass.addMethod(m);
		// 加载修改后的类
		Class<?> cls = teacherClass.toClass();

		/**
		 * 测试方法是否可执行
		 */
		// 实例teacher对象
		Object obj = cls.newInstance();
		// 获取addStudent方法，并添加学生信息
		Method method = cls.getDeclaredMethod("addStudent", Student.class);
		Student student = new Student();
		student.setAge(30);
		student.setName("zhangsan");
		method.invoke(obj, student);
		// 获取sayHello，并执行方法
		Method methodSay = cls.getDeclaredMethod("sayHello");
		methodSay.invoke(obj, null);

	}

	/**
	 * 动态添加方法
	 * 		给Student类添加一个计算的方法，但不是直接在Student类中添加，而是使用javassist
	 */
	public static void addMethod() throws Exception{
		// 类库池, jvm中所加载的class
		ClassPool pool = ClassPool.getDefault();
		// 获取指定的Student类
		CtClass ctClass = pool.get("com.proxy.javassist.Student");
		// 创建calc方法, 带两个参数，参数的类型都为int类型
		CtMethod ctMethod = new CtMethod(CtClass.intType,"calc", new CtClass[]{CtClass.intType,CtClass.intType}, ctClass);
		// 设置方法的访问修饰
		ctMethod.setModifiers(Modifier.PUBLIC);
		// 设置方法体代码
		ctMethod.setBody("return $1 + $2;");
		// 添加新建的方法到原有的类中
		ctClass.addMethod(ctMethod);
		// 加载修改后的类
		ctClass.toClass();
		// 创建对象
		Student stu = new Student();
		// 获取calc方法
		Method dMethod = Student.class.getDeclaredMethod("calc", new Class[]{int.class,int.class});
		// 反射调用 方法
		Object result = dMethod.invoke(stu, 10,20);
		// 打印结果
		System.out.println(String.format("调用calc方法，传入参数：%d,%d", 10,20));
		System.out.println("返回结果：" + (int)result);
	}

	/**
	 * 修改方法
	 * 		通过动态修改sayHello方法，当调用sayHello时，除了输出默认输出的方法外，再输出当前学生的age信息
	 */
	public static void modifyMethod() throws Exception{
		// 类库池, jvm中所加载的class
		ClassPool pool = ClassPool.getDefault();
		// 获取指定的Student类
		CtClass ctClass = pool.get("com.proxy.javassist.Student");
		// 获取sayHello方法
		CtMethod ctMethod = ctClass.getDeclaredMethod("sayHello");
		// 在方法的代码后追加 一段代码
		ctMethod.insertAfter("System.out.println(\"I'm \" + this.age + \" years old.\");");
		// 使用当前的ClassLoader加载被修改后的类
		Class<Student> newClass = ctClass.toClass();
		Student stu = newClass.newInstance();
		stu.setName("张三");
		stu.setAge(18);
		stu.sayHello();
	}

	/**
	 * API运用
	 */
	public static void api() throws NotFoundException, CannotCompileException {
		// 类库, jvm中所加载的class
		ClassPool pool = ClassPool.getDefault();
		// 加载一个已知的类, 注：参数必须为全量类名
		CtClass ctClass = pool.get("com.itheima.Student");
		// 创建一个新的类, 类名必须为全量类名
		CtClass tClass = pool.makeClass("com.itheima.Calculator");

		// 获取已知类的属性
		CtField ctField = ctClass.getDeclaredField("name");
		// 构建新的类的成员变量
		CtField ctFieldNew = new CtField(CtClass.intType,"age",ctClass);
		// 设置类的访问修饰符为public
		ctFieldNew.setModifiers(Modifier.PUBLIC);
		// 将属性添加到类中
		ctClass.addField(ctFieldNew);

		// 获取已有方法
		// 创建新的方法, 参数1:方法的返回类型，参数2：名称，参数3：方法的参数，参数4：方法所属的类
		CtMethod ctMethod = new CtMethod(CtClass.intType, "calc", new CtClass[]{CtClass.intType,CtClass.intType}, tClass);
		// 设置方法的访问修饰
		ctMethod.setModifiers(Modifier.PUBLIC);
		// 将新建的方法添加到类中
		ctClass.addMethod(ctMethod);
		// 方法体内容代码 $1代表第一个参数，$2代表第二个参数
		ctMethod.setBody("return $1 + $2;");
		CtMethod ctMethod1 = ctClass.getDeclaredMethod("sayHello");

		// 获取已有的构造方法, 参数为构建方法的参数类型数组
		CtConstructor ctConstructor = ctClass.getDeclaredConstructor(new CtClass[]{});
		// 创建新的构造方法
		CtConstructor ctConstructor1 = new CtConstructor(new CtClass[]{CtClass.intType},ctClass); ctConstructor.setModifiers(Modifier.PUBLIC);
		ctConstructor1.setBody("this.age = $1;");
		ctClass.addConstructor(ctConstructor1);
		// 也可直接创建
		ctConstructor = CtNewConstructor.make("public Student(int age){this.age=age;}", ctClass);
	}

}

Student

package com.proxy.javassist;

/**
 * 测试类
 */
public class Student {
	private int age;
	private String name;

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public void sayHello() {
		System.out.println("Hello, My name is " + this.name);
	}

}

gradle

plugins {
    id 'java'
}

group 'org.springframework'
version '5.1.9.RELEASE'

sourceCompatibility = 1.8

repositories {
    mavenCentral()
}

dependencies {
    compile(project(":spring-context"))
    compile(project(":spring-web"))
    compile(project(":spring-webmvc"))

    optional("cglib:cglib-nodep:3.3.0")
    optional("org.javassist:javassist:3.27.0-GA")
    testCompile group: 'junit', name: 'junit', version: '4.12'
}