深入理解Java Proxy机制

最新推荐文章于 2024-08-09 13:32:40 发布

MR_XKS

最新推荐文章于 2024-08-09 13:32:40 发布

阅读量230

点赞数 1

分类专栏： Java高级文章标签： java

Java高级专栏收录该内容

2 篇文章 0 订阅

订阅专栏

动态代理其实就是java.lang.reflect.Proxy类动态的根据您指定的所有接口生成一个class byte，该class会继承Proxy类，并实现所有你指定的接口（您在参数中传入的接口数组）；然后再利用您指定的classloader将 class byte加载进系统，最后生成这样一个类的对象，并初始化该对象的一些值，如invocationHandler,以即所有的接口对应的Method成员。初始化之后将对象返回给调用的客户端。这样客户端拿到的就是一个实现你所有的接口的Proxy对象。请看实例分析：

一业务接口类

    public interface BusinessProcessor {
        public void processBusiness();
    }

二业务实现类

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

三业务代理类

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

    }

四客户端应用类

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

现在我们看一下打印结果：
You can do something here before process your business
processing business…..
You can do something here after process your business

通过结果我们就能够很简单的看出Proxy的作用了，它能够在你的核心业务方法前后做一些你所想做的辅助工作，如log日志，安全机制等等。

现在我们来分析一下上面的类的工作原理。

类一二没什么好说的。先看看类三吧。实现了InvocationHandler接口的invoke方法。其实这个类就是最终Proxy调用的固定接口方法。Proxy不管客户端的业务方法是怎么实现的。当客户端调用Proxy时，它只

会调用InvocationHandler的invoke接口，所以我们的真正实现的方法就必须在invoke方法中去调用。关系如下：

    BusinessProcessorImpl bpimpl = new BusinessProcessorImpl();
    BusinessProcessorHandler handler = new BusinessProcessorHandler(bpimpl);

    BusinessProcessor bp = (BusinessProcessor)Proxy.newProxyInstance(....);

    bp.processBusiness()-->invocationHandler.invoke()-->bpimpl.processBusiness();

那么bp到底是怎么样一个对象呢。我们改一下main方法看一下就知道了：

    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);
        bp.processBusiness();
        System.out.println(bp.getClass().getName());
    }

输出结果：

You can do something here before process your business
processing business…..
You can do something here after process your business
$Proxy0

bp原来是个$Proxy0这个类的对象。那么这个类到底是长什么样子呢？好的。我们再写二个方法去把这个类打印出来看个究竟，是什么三头六臂呢？我们在main下面写如下两个静态方法。

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) {

        Constructor[] cons = clz.getConstructors();

        if (null != cons && cons.length > 0) {

            for (Constructor con : cons) {

                System.out.println(con);

            }

        }

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


    //再改写main方法

    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);
        bp.processBusiness();
        System.out.println(bp.getClass().getName());
        Class clz = bp.getClass();
        printClassDefinition(clz);
    }

现在我们再看看输出结果：

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
{
java.lang.reflect.Method m4;
java.lang.reflect.Method m2;
java.lang.reflect.Method m0;
java.lang.reflect.Method m3;
java.lang.reflect.Method m1;

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

很明显，Proxy.newProxyInstance方法会做如下几件事：

根据传入的第二个参数interfaces动态生成一个类，实现interfaces中的接口，该例中即BusinessProcessor接口的processBusiness方法。并且继承了Proxy类，重写了hashcode,toString,equals等三个方法。具体实现可参看 ProxyGenerator.generateProxyClass(…); 该例中生成了$Proxy0类
通过传入的第一个参数classloder将刚生成的类加载到jvm中。即将$Proxy0类load
利用第三个参数，调用$Proxy0的$Proxy0(InvocationHandler)构造函数创建$Proxy0的对象，并且用interfaces参数遍历其所有接口的方法，并生成Method对象初始化对象的几个Method成员变量
将$Proxy0的实例返回给客户端。

现在好了。我们再看客户端怎么调就清楚了。

客户端拿到的是$Proxy0的实例对象，由于$Proxy0实现了BusinessProcessor，因此转化为BusinessProcessor没任何问题。

BusinessProcessor bp = (BusinessProcessor)Proxy.newProxyInstance(....);

bp.processBusiness()；

实际上调用的是$Proxy0.processBusiness();那么$Proxy0.processBusiness()的实现就是通过InvocationHandler去调用invoke方法啦!

MR_XKS

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录

深入理解Java Proxy机制

一 业务接口类

二 业务实现类

三 业务代理类

四 客户端应用类

一业务接口类

二业务实现类

三业务代理类

四客户端应用类