代理对象的方法到目标对象的方法过程：
自定义类加载器：
package myjdkproxy;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
public class MyClassLoader extends ClassLoader{
private File classPathFile;
public MyClassLoader(){
//获得classFile路径
String classPath = MyClassLoader.class.getResource("").getPath();
this.classPathFile = new File(classPath);
}
protected Class<?> findClass(String name) throws ClassNotFoundException {
//String className = MyClassLoader.class.getPackage().getName() + "." + name;
if(classPathFile == null){
return null;
}
/*
* classFile="class文件绝对路径"
* eg:D:\java_space\Test2\bin\myjdkproxy\$MyProxy0.class
*/
File classFile = new File(classPathFile,name.replaceAll("\\.","/") + ".class");
byte[] classData=getClassData(classFile);
//name:类名
return defineClass(name,classData,0,classData.length);
}
//获取class文件的byte流
private byte[] getClassData(File classFile) {
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 out.toByteArray();
}catch (Exception e){
e.printStackTrace();
}finally {
if(null != in){
try {
in.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if(out != null){
try {
out.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
return null;
}
}
自定义InvocationHandler接口及其实现：
package myjdkproxy;
import java.lang.reflect.Method;
public interface MyInvocationHandler {
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable;
}
package myjdkproxy;
import java.lang.reflect.Method;
class MyInvoke implements MyInvocationHandler {
//被代理的对象，把引用保存下来
private Object target;
public Object getInstance(Object target) throws Exception{
this.target = target;
Class<?> cls = target.getClass();
return MyProxy.newProxyInstance(new MyClassLoader(),cls.getInterfaces(),this);
}
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("before---");
method.invoke(this.target,args);//执行目标对象的方法
System.out.println("after---");
//此处的返回值可以执行设置，不过类型要与目标对象方法返回值一致，代理对象的方法返回值就是这个
return null;
}
}
代理类：
package myjdkproxy;
import java.io.File;
import java.io.FileWriter;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;
import javax.tools.JavaCompiler;
import javax.tools.JavaFileObject;
import javax.tools.StandardJavaFileManager;
import javax.tools.ToolProvider;
//动态产生的代理类示例：
//import myjdkproxy.MyProxy;
//import myjdkproxy.Human;
//import myjdkproxy.MyInvocationHandler;
//import java.lang.reflect.*;
//public class $MyProxy0 implements myjdkproxy.IHuman{
//MyInvocationHandler h;
//public $MyProxy0(MyInvocationHandler h) {
//this.h = h;}
//public void talk() {
//try{
//Method m = myjdkproxy.IHuman.class.getMethod ("talk",new Class[]{});
//this.h.invoke(this,m,new Object[]{});
//}catch(Error _ex) { }catch(Throwable e){
//throw new UndeclaredThrowableException(e);
//}}}
public class MyProxy {
public static final String ln = "\r\n";
//产生代理对象
public static Object newProxyInstance(MyClassLoader classLoader, Class<?> [] interfaces, MyInvocationHandler h){
try {
/*
* 动态生成源代码.java文件
* 这个java文件中的类就是代理类
* 实现传入的接口 ，ps:这个(些)接口也就是委托类的接口
* ps：这里应该只实现第一个接口
* -----------
* 构造方法传入一个MyInvocationHandler参数handler
* 实现接口中的所有方法：m1,m2,m3...
* 注意实现的接口与委托类实现的接口相同，
* 所以委托类中也有这些方法:m1,m2,m3...
* 执行$MyProxy0的方法时会调用handler的invoke(arg0,arg1,arg2)方法
* arg0为$MyProxy0对象
* arg1为与当前方法相同的方法
* arg2为arg1方法的参数
* if:代理对象为proxy,m1参数为args
* then:proxy.m1(args)->handler.invoke(proxy,m1.class,args)
*
*/
String src = generateSrc(interfaces);
//Java文件输出磁盘
String filePath = MyProxy.class.getResource("").getPath();
File f = new File(filePath + "$MyProxy0.java");
FileWriter fw = new FileWriter(f);
fw.write(src);
fw.flush();
fw.close();
//把生成的.java文件编译成.class文件
JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
StandardJavaFileManager manager = compiler.getStandardFileManager(null,null,null);
Iterable<? extends JavaFileObject> iterable = manager.getJavaFileObjects(f);
JavaCompiler.CompilationTask task = compiler.getTask(null,manager,null,null,null, iterable);
task.call();
manager.close();
//把编译生成的.class文件加载到JVM中
Class<?> proxyClass = classLoader.findClass("$MyProxy0");
Constructor<?> c = proxyClass.getConstructor(MyInvocationHandler.class);
f.delete();//如果想要看代理类的话，把这行注释掉即可
//返回字节码重组以后的新的代理对象
return c.newInstance(h);
}catch (Exception e){
e.printStackTrace();
}
return null;
}
//以字符串的形式返回一个java源代码
private static String generateSrc(Class<?>[] interfaces){
StringBuffer sb = new StringBuffer();
//引入相关的类
sb.append("import myjdkproxy.MyProxy;" + ln);
sb.append("import myjdkproxy.Human;" + ln);
sb.append("import myjdkproxy.MyInvocationHandler;"+ln);
sb.append("import java.lang.reflect.*;" + ln);
//代理类的类名，及其实现的接口
sb.append("public class $MyProxy0 implements " + interfaces[0].getName() + "{" + ln);
/*
* 添加1个MyInvocationHandler的对象
*/
sb.append("MyInvocationHandler h;" + ln);
/*
* 代理类的构造方法，接收一个MyInvocationHandler对象，并将其保存起来
* 在这个MyInvocationHandler对象的invoke方法完成对目标方法的增强与调用
*/
sb.append("public $MyProxy0(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<?> cls = params[i];
String type = cls.getName();
String paramName = toLowerFirstCase(cls.getSimpleName());
paramNames.append(type + " " + paramName);
paramValues.append(paramName);
paramClasses.append(cls.getName() + ".class");
if(i > 0 && i < params.length-1){
paramNames.append(",");
paramClasses.append(",");
paramValues.append(",");
}
}
/*
* 实现当前方法，其方法头由方法的返回类型、方法名、参数构成
* 在方法体的逻辑里，首先获得目标对象中与当前方法同名的方法
* 然后调用MyInvocationHandler对象的invoke()方法，参数为代理对象本身、目标对象的方法、目标对象的方法的参数
* 将这些信息传递进去，就可以在invoke()内调用目标对象的方法
* 当然，在invoke()内也可以添加别的逻辑
*/
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);
/*
* 调用invoke()方法，并将该方法的返回值作为当前方法的返回值返回
* 该返回值类型要求与目标对象该方法返回值一致
* 我觉得，invoke()中目标对象方法的返回值作为invoke()的返回值即可
* 这样代理对象该方法的返回值就是目标对象该方法的返回值
* 当然也可以不这样处理，不过返回值类型要一样
*/
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("}");
/*
* 判断当前方法的返回值类型，这一部分是在try-catch之外加上的
* void，那么就不添加任何语句
* int，那么就添加return 0;
* 其他，那么就添加return null;
*/
sb.append(getReturnEmptyCode(m.getReturnType()));
sb.append("}");
}
sb.append("}" + ln);
return sb.toString();
}
//HashMap，并添加一个entry,key="int.class",value="Integer.class"
private static Map<Class<?>,Class<?>> mappings = new HashMap<Class<?>, Class<?>>();
static {
mappings.put(int.class,Integer.class);
}
/*
* 判断类型
* 如果是int类，返回"return 0;"
* 如果是void类，返回""
* 如果是其他类型，返回"return null;"
*/
private static String getReturnEmptyCode(Class<?> returnClass){
if(mappings.containsKey(returnClass)){
return "return 0;";
}else if(returnClass == void.class){
return "";
}else {
return "return null;";
}
}
/*
* 如果返回类型是int，那么将invoke()返回值转化成Integer，然后再转化成int
* 如果返回值不是 int，就不处理
*/
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<?> cls){
return cls != void.class;
}
//首字母小写
private static String toLowerFirstCase(String src){
char [] chars = src.toCharArray();
chars[0] += 32;
return String.valueOf(chars);
}
}
委托类的接口及实现：
package myjdkproxy;
public interface IHuman {
public void talk();
}
package myjdkproxy;
public class Human implements IHuman{
public void talk() {
System.out.println("Hello World");
}
}
测试代码：
package myjdkproxy;
public class Test {
public static void main(String[] args) {
try {
Human human=new Human();
IHuman proxy=(IHuman)new MyInvoke().getInstance(human);
proxy.talk();
}catch (Exception e) {
e.printStackTrace();
}
}
}
扫一扫
3万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
