从坦克聊聊代理模式之动态代理2

最新推荐文章于 2021-07-17 11:01:38 发布

程序员小董

最新推荐文章于 2021-07-17 11:01:38 发布

阅读量1k

点赞数

分类专栏：设计模式文章标签： spring jdk 设计模式 Java

本文链接：https://blog.csdn.net/dlf123321/article/details/38170325

版权

设计模式专栏收录该内容

16 篇文章 1 订阅

订阅专栏

本文可作为北京尚学堂设计模式的学习笔记
在上一节文章里我们能让Proxy类代理Imoveable接口但是也只有这一个接口别的还不行

今天我们让它能代理所有接口

(在看这篇文章之前请一定先看看上一篇)

先看看项目目录

那第一步就是分析接口逻辑在上一篇文章里我们要在坦克移动前后记录时间把硬代码写到了字符串里这个就不可以改变了

为了做出在被代理对象前后做操作的逻辑我们写出下面这个类

package proxy;

import java.lang.reflect.Method;

public class TimeInvHan implements InvocationHandler {

	public TimeInvHan(Object object) {
		super();
		this.obj = object;
	}

	Object obj;

	@Override
	public void invoke(Method m, Object o) {

		long start = System.currentTimeMillis();
		System.out.println("starttime:" + start);
		try {
			m.invoke(obj, new Object[]{});
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		
		}
		long end = System.currentTimeMillis();
		System.out.println("end time:" + end);
		System.out.println("expend time:" + (end - start));

	}
}

TimeInvHan 里面有个Object类型的属性obj 它所代表的就是被代理的对象 (就是最原始的那个坦克)
再看invoke 这个方法
Method m 这是我们被代理对象的方法 (在说简单点就是 move方法)
Object o 这个参数我们类里没有用到 (我们所讨论的情况比较简单但是在复杂的情况下这个o就会用到了)
m.invoke(obj, new Object[]{});
这行代码就更简单了就是调用obj的m方法其参数为new Object[]{} ----(就是为空)
然后我们在这个核心代码前后加上我们要的逻辑 --记录时间

InvocationHandler 这个接口也很简单如下

package proxy;

import java.lang.reflect.Method;

public interface InvocationHandler {

    void invoke(Method m,Object o);
}

(大家肯定还很疑惑这个InvocationHandler到底是干什么的先别急往下看)

那第二步就是修改Proxy里面的那个字符串改接口

newInstance 里面的参数Class 就是接口在上面的例子中就是Imoveable

public static Object newInstance(Class h,InvocationHandler in) throws Exception{
		String rt = "\r\n";
		String methodstr="";
		Method[] methods=h.getMethods();
		for(Method m:methods){
			methodstr+="@Override"+rt;
			methodstr+="public "+m.getReturnType()+" "+m.getName()+"() { "+rt 
					+"   try{" + rt
					+"      Method md = " + h.getName() + ".class.getMethod(\"" + m.getName() + "\");" + rt
					+"      h.invoke(md,"+"this);" +rt
					+"      }catch(NoSuchMethodException | SecurityException e){"+rt
					+"         e.printStackTrace();" +rt
					+"   }" + rt
			        +"  }";
		}
				String src = "package proxy.compiler.test;" + rt
				+ "import proxy.InvocationHandler;"+rt
				+ " import java.lang.reflect.Method;"+rt
				+ "public class Proxy1 implements "+ h.getName() + "{" + rt
				+ "    public Proxy1(InvocationHandler t) {" + rt
				+ "        super();" + rt 
				+"        this.h = t;" + rt
				+ "    }" + rt +

				
				"    InvocationHandler h;" + rt +
                 methodstr+rt+
				"}";
				
	}
	........
}

String methodstr="";
       Method[] methods=h.getMethods();
       for(Method m:methods){
           methodstr+="@Override"+rt;
           methodstr+="public "+m.getReturnType()+" "+m.getName()+"() { "+rt
                   +"   try{" + rt
                   +"      Method md = " + h.getName() + ".class.getMethod(\"" + m.getName() + "\");" + rt
                   +"      h.invoke(md,"+"this);" +rt
                   +"      }catch(NoSuchMethodException | SecurityException e){"+rt
                   +"         e.printStackTrace();" +rt
                   +"   }" + rt
                    +" }";
       }

上面这部分就是将h这个接口里面的所有方法都放入字符串中

下面是proxy的全部代码

package proxy;

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 newInstance(Class h,InvocationHandler in) throws Exception{
        String rt = "\r\n";
        String methodstr="";
        Method[] methods=h.getMethods();
        for(Method m:methods){
            methodstr+="@Override"+rt;
            methodstr+="public "+m.getReturnType()+" "+m.getName()+"() { "+rt
                    +"   try{" + rt
                    +"      Method md = " + h.getName() + ".class.getMethod(\"" + m.getName() + "\");" + rt
                    +"      h.invoke(md,"+"this);" +rt
                    +"      }catch(NoSuchMethodException | SecurityException e){"+rt
                    +"         e.printStackTrace();" +rt
                    +"   }" + rt
                    +"  }";
            
        }
                String src = "package proxy.compiler.test;" + rt
                + "import proxy.InvocationHandler;"+rt
                + " import java.lang.reflect.Method;"+rt
                + "public class Proxy1 implements "+ h.getName() + "{" + rt
                + "    public Proxy1(InvocationHandler t) {" + rt
                + "        super();" + rt
                +"        this.h = t;" + rt
                + "    }" + rt +

                
                "    InvocationHandler h;" + rt +
                 methodstr+rt+
                "}";
                
        
        String fileName ="d:/src/proxy/compiler/test/Proxy1.java";

        File f = new File(fileName);
        FileWriter fw = new FileWriter(f);
        fw.write(src);
        fw.flush();
        fw.close();

        //compoler
        JavaCompiler javaCompiler = ToolProvider.getSystemJavaCompiler();
        StandardJavaFileManager fileManager = javaCompiler
                .getStandardFileManager(null, null, null);
        Iterable units = fileManager.getJavaFileObjects(fileName);
        CompilationTask task = javaCompiler.getTask(null, fileManager, null,
                null, null, units);
        task.call();
        fileManager.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("proxy.compiler.test.Proxy1");

        
        Constructor cons= c.getConstructor(InvocationHandler.class);
        Object m=cons.newInstance(in);
        return m;
    }
}

//这是测试代码
package proxy;

public class Client {
    public static void main(String[] args) throws Exception {
        Say a=new SayHelloOrCurse();                
        InvocationHandler in= new HelloLogInvHan(a);
        
        Say s=(Say)Proxy.newInstance(Say.class, in);
        s.hello();
        }
}
package proxy;

public class SayHelloOrCurse implements Say {

    @Override
    public void hello() {
        // TODO Auto-generated method stub
        System.out.println("hello world");
        
    }

    @Override
    public void curse() {
        // TODO Auto-generated method stub
        System.out.println("i curse you");
    }
}
package proxy;

public interface Say {
    void hello();
    void curse();
}

 测试结果如下
start log:
hello world
end log:

在Proxy.newInstance中
我们把类保存到了如下的位置
String fileName ="d:/src/proxy/compiler/test/Proxy1.java";
在相应位置可以找到Proxy1 如下

package proxy.compiler.test;
import proxy.InvocationHandler;
 import java.lang.reflect.Method;
public class Proxy1 implements proxy.Say{
    public Proxy1(InvocationHandler t) {
        super();
        this.h = t;
    }
    InvocationHandler h;
@Override
public void hello() { 
   try{
      Method md = proxy.Say.class.getMethod("hello");
      h.invoke(md,this);
      }catch(NoSuchMethodException | SecurityException e){
         e.printStackTrace();
   }
  }@Override
public void curse() { 
   try{
      Method md = proxy.Say.class.getMethod("curse");
      h.invoke(md,this);
      }catch(NoSuchMethodException | SecurityException e){
         e.printStackTrace();
   }
  }
}

这下大家应该明白了吧
在client测试时
Say s=(Say)Proxy.newInstance(Say.class, in);
这个s实际上就是Proxy1的一个实例对象
而相应的InvocationHandler在Proxy.newinstance的最后几行代码里已经注入了
至于InvocationHandler的invoke方法在文章上面已经给出
这下大家应该明白InvocationHandler的作用了吧

写到这里我们其实就已经模拟了jdk动态代理的机理当然我们这只是最原始的模拟很多细节方面还没有考虑到
但最核心的原理就是上面所说的那个

现在我们用一次真实的jdk动态代理

package JDKProxy;

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

public class LogInvHan implements InvocationHandler {

	public LogInvHan(Object object) {
		super();
		this.obj = object;
	}

	Object obj;

	@Override
	public Object invoke(Object proxy, Method method, Object[] args)throws Throwable {
		System.out.println("start log:" );
		try {
			method.invoke(obj, new Object[]{});
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		System.out.println("end log:" );
		return null;
	}
}

很疑惑public Object invoke(Object proxy, Method method, Object[] args)
这个proxy参数似乎没有用我们的被代理对象在构造函数里已经传进来了
那它有什么用我自己也没搞清楚哪位朋友清楚的请告诉我一声

package JDKProxy;

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

public class JdkProxyTest {
    
    public static void main(String[] args) {
        Imoveable t=new Tank();
        InvocationHandler h=new LogInvHan(t);
        
        Imoveable m=(Imoveable)Proxy.newProxyInstance(t.getClass().getClassLoader(),
                t.getClass().getInterfaces(), h);
        
        InvocationHandler ha=new TimeInvHan(m);
        Imoveable m2=(Imoveable)Proxy.newProxyInstance(t.getClass().getClassLoader(),
                t.getClass().getInterfaces(), ha);
        m2.move();
    }
}

这是多重代理
测试结果
starttime:1406365283656
start log:
i can move...
end log:
end time:1406365284343
expend time:687
其实这个多重代理之前我是这样写的

   Imoveable t=new Tank();
        InvocationHandler h=new LogInvHan(t);
        InvocationHandler ha=new TimeInvHan(h);
        
        Imoveable m=(Imoveable)Proxy.newProxyInstance(t.getClass().getClassLoader(),
                t.getClass().getInterfaces(), ha);
        m.move();

在TimeInvHan的invoke方法里面
method.invoke(obj, new Object[]{});
这句代码里报这个错误
java.lang.IllegalArgumentException: object is not an instance of declaring class
改成如上那个才ok了
大家对这个错误怎么看?