动态代理类的实现和解析

 静态代理类：

　　由程序员创建或由特定工具自动生成源代码，再对其编译。在程序运行前，代理类的.class文件就已经存在了

动态代理类:
　　　与静态代理类对照的是动态代理类，动态代理类的字节码在程序运行时由Java反射机制动态生成，无需程序员手工编写它的源代码。动态代理类不仅简化了编程工作，而且提高了软件系统的可扩展性，因为Java 反射机制可以生成任意类型的动态代理类。java.lang.reflect 包中的Proxy类和InvocationHandler 接口提供了生成动态代理类的能力。

话不多说看代码。。。

package proxyBase;

import java.io.IOException;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.InvocationTargetException;
import java.net.MalformedURLException;
import java.util.Arrays;

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

public class MyProxy {
    static Class<?>[] parameterTypes = { InvocationHandler.class };
    protected InvocationHandler h;

    protected MyProxy(InvocationHandler h) {
        this.h = h;
    }

    public static Object newInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) {
        // ：产生一个代理类的字节码对象
        Class<?> c1 = null;
        try {
            // ：通过getClass0方法可以得到一个代理类的字节码对象
            c1 = getClass0(loader, interfaces);
        } catch (MalformedURLException e1) {
            e1.printStackTrace();
        }
        Constructor<?> constructor = null;
        try {
            /**
             * 调用子类$Proxy0(InvocationHandler h)构造函数，由于继承了MyProxy类，
             * 所以又会继续调用父类的MyProxy(InvocationHandler h)构造函数给 h初始化一个值；
             */
            constructor = c1.getDeclaredConstructor(InvocationHandler.class);
            /**
             * 返回一个生成的代理类对象，并将InvocationHandler 的实现类对象传入进去。从而达到给h赋值的目的
             * 
             */
            return constructor.newInstance(h);
        } catch (NoSuchMethodException | SecurityException | InstantiationException | IllegalAccessException
                | IllegalArgumentException | InvocationTargetException e) {
            e.printStackTrace();
        }
        return null;
    }

    // ：用来生成一个代理类对象
    private static Class<?> getClass0(ClassLoader loader, Class<?>[] interfaces) throws MalformedURLException {
        Class<?> forName = null;
        try {
            GennerateClass.generate(interfaces[0]);
            // ：动态编译
            JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
            StandardJavaFileManager fileMgr = compiler.getStandardFileManager(null, null, null);
            Iterable units = fileMgr.getJavaFileObjects(System.getProperty("user.dir") + "/src/"
                    + interfaces[0].getPackage().getName() + "/" + interfaces[0].getSimpleName() + "$proxy0.java");
            // ："-d", System.getProperty("user.dir")+"/bin/" 用来指定java文件编译后存放的地方
            Iterable<String> options = Arrays.asList("-d", System.getProperty("user.dir") + "/bin/");
            CompilationTask t = compiler.getTask(null, fileMgr, null, options, null, units);
            t.call();
            try {
                fileMgr.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            // ：得到代码自动生成代理类的实例对象
            forName = Class.forName(interfaces[0].getName() + "$proxy0");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        return forName;
    }
}

 这个GennerateClass类是用来生成代理类的Java文件的，是通过字符串拼接而成，仅供参考.

package proxyBase;

import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.lang.reflect.Method;

public class GennerateClass {
    public static void generate(Class<?> clazz) {
        String methodStr = "";  //：方法字符串的拼接
        String classStr = "";    //：类名的拼接
        String packageStr = "";    //：导入包名的拼接
        String classParamStr = ""; //：
        String staticCodeStr = "static {
try {";//：静态代码块的拼接
        String member_var = "";  //：成员变量的拼接
        String package1 = clazz.getPackage().getName();
        String simpleName = clazz.getSimpleName(); //：获得简单类名
        String className = clazz.getName();    //：获得权限定类名
        //：构造函数的拼接
        String counstructStr = "public " + simpleName + "$proxy0(InvocationHandler h) {
" + "        super(h);
"
                + "    }
";
        // ：导包
        packageStr = "package " + package1 + ";
"
                + "import proxyBase.MyProxy;
 import java.lang.reflect.InvocationHandler;
"
                + "import java.lang.reflect.Method;
";
        // ：构建类名
        classStr += "public class " + simpleName + "$proxy0 extends MyProxy implements " + simpleName + "{
" + "";
        // ：构建代理类的方法
        Method[] methods = clazz.getMethods();
        int i = 0;
        for (Method method : methods) {
            String paramStr = "";//：参数变量拼接
            int paramCount = 0; //：参数个数计数用来生成参数变量
            i += 1;
            member_var += "private static Method m" + i + ";
";//成员变量的拼接
            String tempStr = "";  //：参数列表
            String methodName = method.getName();// 方法名
            Class<?>[] parameterTypes = method.getParameterTypes();// 参数列表的class类型
            Class<?> returnType = method.getReturnType();// 返回值类型
            methodStr += "public final " + returnType.getName() + " " + methodName + "(";
            // ：参数列表名字符串
            for (Class<?> type : parameterTypes) {
                paramCount += 1;
                tempStr += "," + type.getName() + " param" + paramCount;
                paramStr += ",param" + paramCount;
                classParamStr += "," + type.getName() + ".class";
            }
            //：
            if (!paramStr.isEmpty()) {
                paramStr = paramStr.substring(1);
            }
            if (!tempStr.isEmpty()) {
                tempStr = tempStr.substring(1);
            }
            if (classParamStr.isEmpty()) {
                classParamStr = "null";
            } else {
                classParamStr = classParamStr.substring(1);
            }
            //：判断返回值是否时void，是则不需要return
            //方法的拼接
            if (returnType.getName().equals("void")) {
                methodStr = methodStr + tempStr + ")
{
" + "	try{
	this.h.invoke(this,m" + i + ",new Object[]{"
                        + paramStr + "});" + "} catch (Throwable e) {
" + "            e.printStackTrace();
"
                        + "        }
}
";
            } else {
                methodStr = methodStr + tempStr + ")
{
Object result=null;
	try{
	result=this.h.invoke(this,m" + i
                        + ",new Object[]{" + paramStr + "});" + "} catch (Throwable e) {
"
                        + "            e.printStackTrace();
" + "}
return (" + returnType.getName() + ")result;}
";
            }
            // ：构建静态代码块
            if (!classParamStr.equals("null")) {
                staticCodeStr += "m" + i + " = Class.forName("" + className + "").getMethod("" + methodName
                        + "",new Class<?>[]{" + classParamStr + "});";
            } else {
                staticCodeStr += "m" + i + " = Class.forName("" + className + "").getMethod("" + methodName + "");";
            }
            classParamStr = "";
        }
        //静态代码块的拼接
        staticCodeStr += "} catch (NoSuchMethodException e) {
" + "            e.printStackTrace();
"
                + "        } catch (SecurityException e) {
" + "            e.printStackTrace();
"
                + "        } catch (ClassNotFoundException e) {
" + "            e.printStackTrace();
" + "        }}";
        //总和成Java文件的内容
        packageStr = packageStr + classStr + member_var + counstructStr + methodStr + staticCodeStr + "
}";
        //通过流写入成文件
        FileWriter fout = null;
        try {
            fout = new FileWriter(new File("src/" + package1 + "/" + simpleName + "$proxy0.java"));
        } catch (IOException e) {

            e.printStackTrace();
        }
        BufferedWriter out = new BufferedWriter(fout);
        try {
            out.write(packageStr);
        } catch (IOException e) {
            e.printStackTrace();
        }
        try {
            out.close();
            fout.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

/***
　*这个类是用来制定你的代理对象，在调用方法时需要进行哪些前置处理和后置处理
　*
  */
 1 package proxyBase;

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

public class Hadler<T> implements InvocationHandler {
    private T target;
    //通过new Hadler将被代理的那个对象传入，
    public Hadler(T target) {
        super();
        this.target = target;
    }
    private void before() {
        System.out.println("先吃饭");
    }
    private void after() {
        System.out.println("再睡觉");
    }
    //这里根据自己的逻辑来制定相应的invoke方法，视情况而定，此处的写法只是来简单测试代理对象。
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        before();
        Object invoke = method.invoke(target,args);
        after();
        return invoke;
    }
}

这里时生成后的代理类文件Person$proxy0.java

package proxyBase;

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

public class Hadler<T> implements InvocationHandler {
    private T target;
    //通过new Hadler将被代理的那个对象传入，
    public Hadler(T target) {
        super();
        this.target = target;
    }
    private void before() {
        System.out.println("先吃饭");
    }
    private void after() {
        System.out.println("再睡觉");
    }
    //这里根据自己的逻辑来制定相应的invoke方法，视情况而定，此处的写法只是来简单测试代理对象。
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        before();
        Object invoke = method.invoke(target,args);
        after();
        return invoke;
    }
}

接下来是写一个接口，jdk中的动态代理是针对接口代理的，而cglib是针对类进行代理的，这个接口将会被代理，分别写了四个方法来测试，无参，一参，两参，和一个有返回值

的方法，都是用来测试GennerateClass类生成的是否正确，（目前只测试了这几种，如果大神发现有误，还望联系斧正）

package proxy;


public interface Person {
    void study2();
    void study2(int a);
    void study3(int b ,String a);
    int returnInt(int a);
}

接下来写一个Person的实现类，然后通过代理类来代理这个实现类对象，进行一些前置处理和后置处理。

package proxy;

public class Student implements Person {
    public void study2() {
        System.out.println("正在考试中");
    }

    @Override
    public void study2(int a) {
        System.out.println(a);
    }

    @Override
    public void study3(int b, String a) {
        System.out.println(a+b);
    }

    @Override
    public int returnInt(int a) {
        
        return a;
    }
}

最后就是测试和使用所写的代理类了

第一步，创建一个Person类型的对象student，

第二步，创建一个InvocationHandler的实现类对象，并将student传入进去，这个student会将生成实现类中的成员变量target进行赋值初始化。

第三步，调用MyProxy中的newInstance方法来获得代理类对象(注意：newInstance 中的参数要是实现类的类类型来获得他的实现Interface接口的类类型，即Person，生成代理类的Java文件就是依据该接口生成的)

第四步, 测试生成的代理类对象，结果如下，通过原生student和代理类对象stu调用相同方法进行对比

public static void main(String[] args) {
        Person student = new Student();
        
        InvocationHandler h = new Hadler<Person>(student);
        Person stu = (Person) MyProxy.newInstance(Person.class.getClassLoader(), Student.class.getInterfaces(), h);
        stu.study2();
        System.out.println("-------");
        student.study2();
        stu.study2(4);
        stu.study3(4, "A");
        int a = stu.returnInt(2015);
        System.out.println(a);
    }

运行结果：

先吃饭
正在考试中
再睡觉
-------
正在考试中
先吃饭
4
再睡觉
先吃饭
A4
再睡觉
先吃饭
再睡觉
2015