深入分析动态代理

最新推荐文章于 2025-01-31 16:49:25 发布

原创最新推荐文章于 2025-01-31 16:49:25 发布 · 583 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#动态代理

java 专栏收录该内容

36 篇文章

订阅专栏

Java作为动态语言的特点，这里要做的就是，通过代码来把一个存有java代码的简单的小程序写入到一个java文件中，然后调用java的CompilationTask对其进行编译，然后实例化，接下来自然就是调用运行了。

大体流程：

1）组织字符串，也就是要生成的java的代码

2）写入到文件中去，名字暂时定为：TankTimeProxy.java，package为dhp.proxy.com

3）获取jdk编译器

4）拿到编译任务，进行编译

5）找到编译之后的类，加载这个class类文件到内存

6）通过反射对这个类实例化，并调用。

简单代理

首先定一个接口，这里是Moveable接口，里面有一个Move()方法。接下来会有一个已经定义好的类实现这个接口，并假设这个类是不能修改的了，可是他的功能不能够完全胜任现在的工作，比如要测试他的运行时间。那么怎么给他添加功能呢。
方法1：对这个类写一个继承类，在覆盖父类的这个方法，
Move(){
//do something before ，here is count the start time
Super().move()
//do something after , here is count the end time and calculate the time spend
}
但这样的话，要对每个需要添加新功能的，都需要计算时间的话，要每一个都继承出一个子类
这里就用到了开始的动态编译功能，我要根据他们公共的接口，生成一个新的类，这个类实现了Moveable接口，在其内部的move方法前后添加计算时间的代码，中间是调用要测试的类（当然这些类也实现了Moveable接口）
Moveable接口

package dhp.proxy.com;

public interface Moveable {
	void move();
}

Tank 类-Moveable接口的实现类

package dhp.proxy.com;

import java.util.Random;

public class Tank implements Moveable{

	@Override
	public void move() {
		System.out.println("Tank Moving...");
		try {
			Thread.sleep(new Random().nextInt(10000));
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}

}

ProxySecond 代理类的生成类

package dhp.proxy.test;

import java.io.File;
import java.io.FileWriter;
import java.lang.reflect.Constructor;
import java.net.URL;
import java.net.URLClassLoader;

import javax.tools.JavaCompiler;
import javax.tools.StandardJavaFileManager;
import javax.tools.ToolProvider;

import dhp.proxy.com.Moveable;
import dhp.proxy.com.Tank;

import javax.tools.JavaCompiler.CompilationTask;

public class Test {
	public static void main(String[] args) throws Exception{
		String rt = "\r\n";
		String src = 
			"package dhp.proxy.com;" +  rt +
			"public class TankTimeProxy implements Moveable {" + rt +
			"    public TankTimeProxy(Moveable t) {" + rt +
			"        super();" + rt +
			"        this.t = t;" + rt +
			"    }" + rt +
			
			"    Moveable t;" + rt +
							
			"    @Override" + rt +
			"    public void move() {" + rt +
			"        long start = System.currentTimeMillis();" + rt +
			"        System.out.println(\"starttime:\" + start);" + rt +
			"        t.move();" + rt +
			"        long end = System.currentTimeMillis();" + rt +
			"        System.out.println(\"time:\" + (end-start));" + rt +
			"    }" + rt +
			"}";
		//这个是为了得到这个工程所在的目录
		//String filePath = System.getProperty("user.dir");  
		//放到本地磁盘，这样不会报异常，因为会和bin目录下的.class冲突
		String fileName = "d:/src/dhp/proxy/com/TankTimeProxy.java";
		//这里是通过这个来写入到java文件的，会出现中文乱码。如果为了可移植的话，最好采用DataInputStream这个是跟操作系统无关的文件流实现  
		File f = new File(fileName);
		FileWriter fw = new FileWriter(f);
		fw.write(src);
		fw.flush();
		fw.close();
		
		//获取jdk编译器  
		JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
		StandardJavaFileManager fileMgr = compiler.getStandardFileManager(null, null, null);
		Iterable units = fileMgr.getJavaFileObjects(fileName);
		//拿到编译任务  
		CompilationTask t = compiler.getTask(null, fileMgr, null, null, null, units);
		t.call();//编译  
		fileMgr.close();
		
		//加载类到内存  
		//加载某个class类文件  
		/*URL[] urls = new URL[] {new URL("file:/" + System.getProperty("user.dir") +"/src")};*/
		URL[] urls = new URL[] {new URL("file:/" + "d:/src/")};
		URLClassLoader ul = new URLClassLoader(urls);
		Class c = ul.loadClass("dhp.proxy.com.TankTimeProxy");
		System.out.println(c);//输出: class dhp.proxy.com.TankTimeProxy
		
		//通过构造方法对其进行实例化  
		//操作这个加载到内存的类  
        //拿到构造方法参数为moveable的构造方法  
		Constructor ctr = c.getConstructor(Moveable.class);
		Moveable m = (Moveable)ctr.newInstance(new Tank());
		m.move();
		
	}
}

上面字符串就是生成的代理类，有一个Moveable参数的构造方法，将要测试的Moveable实现类（这里是tank类）的实例对象传到代理类中，代理类中为m，由于代理类也实现了Moveable方法，我们可以通过实例化代理类来调用Move()方法，也是因为这样，我们在代理类的Move()方法中调用m.move(),这就相当于间接调用了tank的move方法，我们在m.move()前后添加计算运行时间的代码，就可以对这个tank运行时间的测试，若是要测试其他所有实现了Moveable接口的类的运行时间，只需要在对代理类实例化时调用的构造方法中传递个实例进去就行了。

动态代理的实现
接下来还有什么？恩，我们假如要修改需求呢，我们不做运行时间的测试了，我们要做日志、我还要做事务、我还想事务+日志+时间测试。。任意组合。这样的话，我们就需要把生成代理类的业务实现代码拿到外边来实现，那么这些代码拿到哪里好呢？？
先不做探索放在哪里好，到这里也是动态代理要实现的功能了。我们看动态代理的选择。我们通过上边的代码可以发现，
a.代理类里边实现的是接口的方法
b.方法里面调用的是被代理类的接口方法
c.被调用的时候也是接口的方法，
我们可不可以在(b)实现了接口的方法里面不去调用被代理类的接口，而是(d)调用一个中间过程的类（或接口）的方法，这个中间过程来调用被代理类。

为了简单，这个中间过程只做一件具体的业务,接口中只有一个方法，比如处理时间，只做时间；处理日志，只做日志。

import java.lang.reflect.Method;

public interface InvocationHandler {
	public void invoke(Object o, Method m);
}

中间类（处理时间）

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class TimeHandler implements InvocationHandler{
	
	private Object target;//要被代理的对象 



	public TimeHandler(Object target) {
		super();
		this.target = target;
	}



	@Override
	public void invoke(Object o, Method m) {
		long start = System.currentTimeMillis();
		System.out.println("starttime:" + start);
		System.out.println(o.getClass().getName());
		try {
			m.invoke(target);
		} catch (Exception e) {
			e.printStackTrace();
		}
		long end = System.currentTimeMillis();
		System.out.println("time:" + (end-start));
	}

}

代理类

import java.io.File;
import java.io.FileWriter;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.net.URL;
import java.net.URLClassLoader;

import javax.tools.JavaCompiler;
import javax.tools.StandardJavaFileManager;
import javax.tools.ToolProvider;
import javax.tools.JavaCompiler.CompilationTask;

public class Proxy {
	public static Object newProxyInstance(Class infce, InvocationHandler h) throws Exception { //JDK6 Complier API, CGLib, ASM
		String methodStr = "";
		String rt = "\r\n";
		
		Method[] methods = infce.getMethods();
		/*
		for(Method m : methods) {
			methodStr += "@Override" + rt + 
						 "public void " + m.getName() + "() {" + rt +
						 	"   long start = System.currentTimeMillis();" + rt +
							"   System.out.println(\"starttime:\" + start);" + rt +
							"   t." + m.getName() + "();" + rt +
							"   long end = System.currentTimeMillis();" + rt +
							"   System.out.println(\"time:\" + (end-start));" + rt +
						 "}";
		}
		*/
		for(Method m : methods) {
			methodStr += "@Override" + rt + 
						 "public void " + m.getName() + "() {" + rt +
						 "    try {" + rt +
						 "    Method md = " + infce.getName() + ".class.getMethod(\"" + m.getName() + "\");" + rt +
						 "    h.invoke(this, md);" + rt +
						 "    }catch(Exception e) {e.printStackTrace();}" + rt +
						
						 "}";
		}
		
		String src = 
			"package com.bjsxt.proxy;" +  rt +
			"import java.lang.reflect.Method;" + rt +
			"public class $Proxy1 implements " + infce.getName() + "{" + rt +
			"    public $Proxy1(InvocationHandler h) {" + rt +
			"        this.h = h;" + rt +
			"    }" + rt +
			
			
			"    com.bjsxt.proxy.InvocationHandler h;" + rt +
							
			methodStr +
			"}";
		String fileName = 
			"d:/src/dhp/proxy/com/$Proxy1.java";
		File f = new File(fileName);
		FileWriter fw = new FileWriter(f);
		fw.write(src);
		fw.flush();
		fw.close();
		
		//compile
		JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
		StandardJavaFileManager fileMgr = compiler.getStandardFileManager(null, null, null);
		Iterable units = fileMgr.getJavaFileObjects(fileName);
		CompilationTask t = compiler.getTask(null, fileMgr, null, null, null, units);
		t.call();
		fileMgr.close();
		
		//load into memory and create an instance
		URL[] urls = new URL[] {new URL("file:/" + "d:/src/")};
		URLClassLoader ul = new URLClassLoader(urls);
		Class c = ul.loadClass("dhp.proxy.com.$Proxy1");
		System.out.println(c);
		
		Constructor ctr = c.getConstructor(InvocationHandler.class);
		Object m = ctr.newInstance(h);
		//m.move();

		return m;
	}
}

测试类

public class Client {
	public static void main(String[] args) throws Exception {
		Tank t = new Tank();
		InvocationHandler h = new TimeHandler(t);
		
		Moveable m = (Moveable)Proxy.newProxyInstance(Moveable.class, h);
		
		m.move();
	}
}

在代理类中，添加一个参数，这个参数就是中间部分接口。因为我们要在生成的代理类中实现的接口move方法里面调用被代理类的方法,所以要实例化一个中间类,即InvocationHandler的实现类，这里打算要通过构造方法来引入InvocationHandler的实现类,而我们这个TimeHandler 的实例化是过动态编译来进行的，动态编译的代码部分就要传入InvocationHandler，这就是我们开始传的参数。