深度模拟java动态代理实现机制系类之三

这里的内容就比较复杂了，要实现的是对任意的接口，对任意指定的方法，以及对任意指定的代理类型进行代理，就更真实的模拟出java虚拟机的动态代理机制

罗列一下这里涉及的类、接口之间的关系，方便大家学习。
1、InvocationHandler接口，用来处理指定的方法，即对特定方法的代理，处理的具体实现交由子类实现
2、TimeHandler类，实现了InvocationHandler接口的子类，具体的代理实现是进行时间代理
3、Proxy类，用于产生代理类的类
4、Moveable接口，举例过程中各类要实现的统一接口
5、Tank类，实现了Moveable接口，即被代理的类
6、Cilent，操作客户端

先把整个的思路理一下:
首先在Client端，new一个被代理的对象Tank，Tank对象作为构造参数传入代理处理类TimeHandler，new出一个TimeHandler对象，
Tank的接口Moveable和TimeHandler对象作为参数传入Proxy,Proxy调用newProxyInstance方法，该方法中对接口的所有的方法，利用TimeHandler对象进行代理，（可以简单理解为将接口方法与TimeHandler代理方法结合），生成新的代理对象的java文件、class文件、然后加载进入内存，利用反射获得一个代理对象，返回该代理对象，在Client端调用则调用了代理对象方法；

1、InvocationHandler接口

package com.csu.proxy;

import java.lang.reflect.Method;
//对任意方法自定义处理
//方法调用的处理器
public interface InvocationHandler {   //定义一个接口，用来处理方法，处理的具体实现交由子类实现

    public void invoke(Object o, Method m);  //对某个指定方法的处理
}

 

2、TimeHandler类

package com.csu.proxy;

import java.lang.reflect.Method;
public class TimeHandler implements InvocationHandler {
   private Object target;//被代理的对象

    public Object getT() {
        return target;
    }

    public void setT(Object t) {
        this.target = t;
    }

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

    @Override
    public void invoke(Object o,Method m){  //必须指定具体对象对具体的方法的调用
        long start = System.currentTimeMillis();
        System.out.println("start time is " + start);
        System.out.println(o.getClass().getName());
        //m 调用方法
        try {
            m.invoke(target);  
        } catch (Exception e) {e.printStackTrace();}


        long end = System.currentTimeMillis();
        System.out.println("end time is "+end);
        System.out.println("time is "+(end - start));
    }
}

 

3、Moveable接口

package com.csu.proxy;

public interface Moveable {
    void move();
}

 

4、Tank类

package com.csu.proxy;

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();
        }
        
    }    
    
}

 

5、Proxy类

package com.csu.proxy;

import javax.tools.JavaCompiler;
import javax.tools.StandardJavaFileManager;
import javax.tools.ToolProvider;
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;

/**
方便大家阅读，关注主要的逻辑思路，将在前面博客的已经写过的注释代码清除，因为这是一系列，有很多代码引用
有想要看的，去上几篇文章看吧
**/

//该类要实现对任意接口，任意方法，以及任意的代理 的实现
public class ProxyG3 {
    public static Object newProxyInstance(Class intf, InvocationHandler h) throws Exception{
    //invocationHandler当成参数，指定代理的类型，即指定对方法要进行什么处理

        //*****************1、获得java文件**********************************
    String methodsString = "";  
        String rt = "\r\n";

        Method[] methods = intf.getMethods();
        for(Method m : methods) {
            methodsString += "@Override" + rt +
                    "public void " + m.getName() + "() {" + rt +
                    "    try {" + rt +
                    "    Method md = " + intf.getName() + ".class.getMethod(\"" + m.getName() + "\");" + rt +
                    "    h.invoke(this, md);" + rt +
                    "    }catch(Exception e) {e.printStackTrace();}" + rt +

                    "}";
        }

        String src =
                        "package com.csu.proxy;" +  rt +
                        "import java.lang.reflect.Method;" + rt +
                        "public class TankTimeProxy implements " + intf.getName() + "{" + rt +
                        "    public TankTimeProxy(InvocationHandler h) {" + rt +
                        "        this.h = h;" + rt +
                        "    }" + rt +


                        "    com.csu.proxy.InvocationHandler h;" + rt +

                        methodsString +
                        "}";
        String fileName = "g:/src/com/csu/proxy/TankTimeProxy.java";//放在指定的地方
        File f = new File(fileName);
        FileWriter fw = new FileWriter(f);
        fw.write(src);
        fw.flush();
        fw.close();
    /**
    这里重点说一下：用于存放代理对象TankTimeProxy的java和class文件的包名要工程中的其他java文件的包名一致，查看代码你会发现
    工程的java文件和生成的代理对象的java文件的包名都是 com.csu.proxy;
    **/

        //****************2、获得class文件****************************************

    　//获得编译器对象
        JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
        
        //管理动态生成的文件
        StandardJavaFileManager fileManager = compiler.getStandardFileManager(null,null,null);
        Iterable units = fileManager.getJavaFileObjects(fileName);

        //“编译任务”对象
        JavaCompiler.CompilationTask task = compiler.getTask(null,fileManager,null,null,null,units);
        task.call();
        fileManager.close();

        //*****************3、加载至内存******************************************

        //通过Url引入本地文件
        URL[] urls = new URL[]{new URL("file:/"+"g:/src/")}; //访问本地文件   指定class文件存放的位置
        URLClassLoader urlClassLoader = new URLClassLoader(urls);
        Class c = urlClassLoader.loadClass("com.csu.proxy.TankTimeProxy");

        //******************4、执行class文件，返回代理对象***************************************

        //获得构造方法
        Constructor constructor = c.getConstructor(InvocationHandler.class);  //getConstructor的参数为Class类型，是原构造方法的参数的Class类型

        //产生新对象
        Object m =  constructor.newInstance(h);

        return m;
    }
}

6、Cilent客户端

package com.csu.proxy;

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

        Tank t = new Tank();
        InvocationHandler h = new TimeHandler(t);

        Moveable m =(Moveable) ProxyG3.newProxyInstance(Moveable.class, h);

        m.move();


    }
}

 

 

7、执行结果

（1）生成的java和class文件

（2）查看生成的java文件代码

（3）运行结果