java proxy机制

    一直听说java反射，也使用过一些基本的反射机制。其实就是基本的根据类名，从系统的classloader中加载出类来使用。
    这几天看到一段代码，使用了proxy，当时没有看太懂，所以借今天又周末，来找一篇blog看看，到底这proxy是怎么回事儿。

    首先这里涉及到三个类
    A (接口)
    B (A的实现)
    C (InvocationHandler类的实现)
    
    使用java的 Proxy 类，调用它的方法：
    public static Object newProxyInstance(ClassLoader loader,
                      Class[] interfaces,
                      InvocationHandler h)

    classloader是 B 的classloader
    interface 是 B 实现的 interface
    hander 是 C

    现在得说说 newProxyInstance 干了点什么
    其实，它是构造了一个 代理类，这个代理类实现了 interface A 并继承自 InvocationHander
    当调用 newProxyInstance 返回的实例的对象的方法的时候，被这个 代理类实现的interface方法转到 hander 的 invoke 方法
    这样就可以在 invoke 方法中做一下准备和扫尾的工作，并可以相应的参数调用真正的方法

    例子如下，这个例子是抄别人的 ：）

1. interface A

public interface BusinessProcessor {
    public void processBusiness();
}

2. 实现类 B

public class BusinessProcessorImpl implements BusinessProcessor {
    public void processBusiness() {
        System.out.println("processing business.....");
    }
}

3. hander类 C

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

public class BusinessProcessorHandler implements InvocationHandler {

    private Object target = null;

    BusinessProcessorHandler(Object target) {
        this.target = target;
    }

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("You can do something here before process your business");
        Object result = method.invoke(target, args);
        System.out.println("You can do something here after process your business");
        return result;
    }
}

4. test，该实现打印出了Proxy动态实现的类 $Proxy0

public class Test {
    public static void main(String[] args) {
        BusinessProcessorImpl bpimpl = new BusinessProcessorImpl();
        BusinessProcessorHandler handler = new BusinessProcessorHandler(bpimpl);
        BusinessProcessor bp = (BusinessProcessor) Proxy.newProxyInstance(bpimpl.getClass().getClassLoader(), bpimpl
                .getClass().getInterfaces(), handler);

        System.out.println("-------------- start -------------");
        bp.processBusiness();

        System.out.println(bp.getClass().getName());
        Class<?> clz = bp.getClass();
        printClassDefinition(clz);
    }

    public static String getModifier(int modifier) {
        String result = "";
        switch (modifier) {
        case Modifier.PRIVATE:
            result = "private";
        case Modifier.PUBLIC:
            result = "public";
        case Modifier.PROTECTED:
            result = "protected";
        case Modifier.ABSTRACT:
            result = "abstract";
        case Modifier.FINAL:
            result = "final";
        case Modifier.NATIVE:
            result = "native";
        case Modifier.STATIC:
            result = "static";
        case Modifier.SYNCHRONIZED:
            result = "synchronized";
        case Modifier.STRICT:
            result = "strict";
        case Modifier.TRANSIENT:
            result = "transient";
        case Modifier.VOLATILE:
            result = "volatile";
        case Modifier.INTERFACE:
            result = "interface";
        }
        return result;
    }

    public static void printClassDefinition(Class<?> clz) {

        String clzModifier = getModifier(clz.getModifiers());
        if (clzModifier != null && !clzModifier.equals("")) {
            clzModifier = clzModifier + " ";
        }
        String superClz = clz.getSuperclass().getName();
        if (superClz != null && !superClz.equals("")) {
            superClz = "extends " + superClz;
        }

        Class<?>[] interfaces = clz.getInterfaces();

        String inters = "";
        for (int i = 0; i < interfaces.length; i++) {
            if (i == 0) {
                inters += "implements ";
            }
            inters += interfaces[i].getName();
        }

        System.out.println(clzModifier + clz.getName() + " " + superClz + " " + inters);
        System.out.println("{");

        Field[] fields = clz.getDeclaredFields();
        for (int i = 0; i < fields.length; i++) {
            String modifier = getModifier(fields[i].getModifiers());
            if (modifier != null && !modifier.equals("")) {
                modifier = modifier + " ";
            }
            String fieldName = fields[i].getName();
            String fieldType = fields[i].getType().getName();
            System.out.println("    " + modifier + fieldType + " " + fieldName + ";");
        }

        System.out.println();

        Method[] methods = clz.getDeclaredMethods();
        for (int i = 0; i < methods.length; i++) {
            Method method = methods[i];

            String modifier = getModifier(method.getModifiers());
            if (modifier != null && !modifier.equals("")) {
                modifier = modifier + " ";
            }

            String methodName = method.getName();

            Class<?> returnClz = method.getReturnType();
            String retrunType = returnClz.getName();

            Class<?>[] clzs = method.getParameterTypes();
            String paraList = "(";
            for (int j = 0; j < clzs.length; j++) {
                paraList += clzs[j].getName();
                if (j != clzs.length - 1) {
                    paraList += ", ";
                }
            }
            paraList += ")";

            clzs = method.getExceptionTypes();
            String exceptions = "";
            for (int j = 0; j < clzs.length; j++) {
                if (j == 0) {
                    exceptions += "throws ";
                }

                exceptions += clzs[j].getName();

                if (j != clzs.length - 1) {
                    exceptions += ", ";
                }
            }

            exceptions += ";";

            String methodPrototype = modifier + retrunType + " " + methodName + paraList + exceptions;

            System.out.println("    " + methodPrototype);

        }
        System.out.println("}");
    }
}

输出如下：
-------------- start -------------
You can do something here before process your business
processing business.....
You can do something here after process your business
$Proxy0
$Proxy0 extends java.lang.reflect.Proxy implements proxy.BusinessProcessor
{
    java.lang.reflect.Method m2;
    java.lang.reflect.Method m0;
    java.lang.reflect.Method m3;
    java.lang.reflect.Method m1;

    int hashCode();
    boolean equals(java.lang.Object);
    java.lang.String toString();
    void processBusiness();
}