最新公告
  • 欢迎您光临立业阁,本站秉承服务宗旨 履行“站长”责任,销售只是起点 服务永无止境!立即加入我们
  • Java动态代理的原理_Java教程


    Java动态代理机制的出现,使得 Java 开发人员不用手工编写代理类,只要简单地指定一组接口及委托类对象,便能动态地获得代理类。(推荐:java视频教程

    代理类会负责将所有的方法调用分派到委托对象上反射执行,在分派执行的过程中,开发人员还可以按需调整委托类对象及其功能,这是一套非常灵活有弹性的代理框架。下面我们开始动态代理的学习。

    动态代理的简要说明

    在java的动态代理机制中,有两个重要的类或接口,一个是 InvocationHandler(Interface)、另一个则是 Proxy(Class)。

    一、 InvocationHandler(interface)的描述:

    InvocationHandler is the interface implemented by the invocation handler of a proxy instance. 
    
    Each proxy instance has an associated invocation handler. When a method is invoked on a proxy instance, the method invocation is encoded and dispatched to the invoke method of its invocation handler.

    每一个动态代理类都必须要实现InvocationHandler这个接口,并且每个代理类的实例都关联到了一个handler,当我们通过代理对象调用 一个方法的时候,这个方法的调用就会被转发为由InvocationHandler这个接口的 invoke 方法来进行调用。我们来看看InvocationHandler这个接口的唯一一个方法 invoke 方法:

    Object invoke(Object proxy, Method method, Object[] args) throws Throwable

    这个方法接收三个参数和返回一个Object类型,它们分别代表的意思如下:

    proxy: 指代我们所代理的那个真实对象

    method: 指代的是我们所要调用真实对象的方法的Method对象

    args: 指代的是调用真实对象某个方法时接受的参数

    返回的Object是指真实对象方法的返回类型,以上会在接下来的例子中加以深入理解。

    the value to return from the method invocation on the proxy instance.

    二、 Proxy(Class)的描述:

    Proxy provides static methods for creating dynamic proxy classes and instances, and it is also the superclass of all dynamic proxy classes created by those methods.

    Proxy这个类的作用就是用来动态创建一个代理对象。我们经常使用的是newProxyInstance这个方法:

    public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces,  InvocationHandler h)  throws IllegalArgumentException

    参数的理解:

    // 一个ClassLoader对象,定义了由哪个ClassLoader对象来对生成的代理对象进行加载
    loader - the class loader to define the proxy class  
    // 一个Interface对象的数组,表示的是我将要给我需要代理的对象提供一组什么接口
    interfaces - the list of interfaces for the proxy class to implement 
    // 一个InvocationHandler对象,表示的是当我这个动态代理对象在调用方法的时候,会关联到哪一个InvocationHandler对象上
    h - the invocation handler to dispatch method invocations to

    返回结果的理解: 一个代理对象的实例

    a proxy instance with the specified invocation handler of a proxy class that is defined by the specified class loader and that implements the specified interfaces

    简单的Java代理

    我们创建一个Java项目用于对动态代理的测试与理解,项目结构如下:

    1.jpg

    一、 先定义一个接口Interface,添加两个方法。

    package com.huhx.proxy;
    
    public interface Interface {
        void getMyName();
    
        String getNameById(String id);
    }

    二、 定义一个真实的实现上述接口的类,RealObject:

    package com.huhx.proxy;
    
    public class RealObject implements Interface {
        @Override
        public void getMyName() {
            System.out.println("my name is huhx");
        }
    
        @Override
        public String getNameById(String id) {
            System.out.println("argument id: " + id);
            return "huhx";
        }
    }

    三、 定义一个代理对象,也实现了上述的Interface接口:

    package com.huhx.proxy;
    
    public class SimpleProxy implements Interface {
        private Interface proxied;
    
        public SimpleProxy(Interface proxied) {
            this.proxied = proxied;
        }
    
        @Override
        public void getMyName() {
            System.out.println("proxy getmyname");
            proxied.getMyName();
        }
    
        @Override
        public String getNameById(String id) {
            System.out.println("proxy getnamebyid");
            return proxied.getNameById(id);
        }
    }

    四、 SimpleMain在Main方法中,测试上述的结果:

    package com.huhx.proxy;
    
    public class SimpleMain {
        private static void consume(Interface iface) {
            iface.getMyName();
            String name = iface.getNameById("1");
            System.out.println("name: " + name);
        }
    
        public static void main(String[] args) {
            consume(new RealObject());
            System.out.println("========================================================");
            consume(new SimpleProxy(new RealObject()));
        }
    }

    五、 运行的结果如下:

    my name is huhx
    argument id: 1
    name: huhx
    ========================================================
    proxy getmyname
    my name is huhx
    proxy getnamebyid
    argument id: 1
    name: huhx

    Java的动态代理

    完成了上述简单的Java代理,现在我们开始学习Java的动态代理,它比代理的思想更向前一步,因为它可以动态地创建代理并动态的处理对所代理方法的调用。在动态代理上所做的所有调用都会被重定向到单一的调用处理器上,它的工作是揭示调用的类型并确定相应的对策。下面我们通过案例来加深Java动态代理的理解:

    一、 创建一个继承了InvocationHandler的处理器:DynamicProxyHandler

    package com.huhx.dynamicproxy;
    
    import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Method;
    import java.util.Arrays;
    
    public class DynamicProxyHandler implements InvocationHandler {
        private Object proxied;
    
        public DynamicProxyHandler(Object proxied) {
            System.out.println("dynamic proxy handler constuctor: " + proxied.getClass());
            this.proxied = proxied;
        }
    
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            System.out.println("dynamic proxy name: " + proxy.getClass());
            System.out.println("method: " + method.getName());
            System.out.println("args: " + Arrays.toString(args));
            
            Object invokeObject = method.invoke(proxied, args);
            if (invokeObject != null) {
                System.out.println("invoke object: " + invokeObject.getClass());
            } else {
                System.out.println("invoke object is null");
            }
            return invokeObject;
        }
    }

    二、 我们写一个测试的Main方法,DynamicProxyMain:

    package com.huhx.dynamicproxy;
    
    import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Proxy;
    
    import com.huhx.proxy.Interface;
    import com.huhx.proxy.RealObject;
    
    public class DynamicProxyMain {
        public static void consumer(Interface iface) {
            iface.getMyName();
            String name = iface.getNameById("1");
            System.out.println("name: " + name);
        }
    
        public static void main(String[] args) throws Exception, SecurityException, Throwable {
            RealObject realObject = new RealObject();
            consumer(realObject);
            System.out.println("==============================");
    
            // 动态代理
            ClassLoader classLoader = Interface.class.getClassLoader();
            Class<?>[] interfaces = new Class[] { Interface.class };
            InvocationHandler handler = new DynamicProxyHandler(realObject);
            Interface proxy = (Interface) Proxy.newProxyInstance(classLoader, interfaces, handler);
    
            System.out.println("in dynamicproxyMain proxy: " + proxy.getClass());
            consumer(proxy);
        }
    }

    三、 运行结果如下:

    my name is huhx
    argument id: 1
    name: huhx
    ==============================
    dynamic proxy handler constuctor: class com.huhx.proxy.RealObject
    in dynamicproxyMain proxy: class com.sun.proxy.$Proxy0
    dynamic proxy name: class com.sun.proxy.$Proxy0
    method: getMyName
    args: null
    my name is huhx
    invoke object is null
    dynamic proxy name: class com.sun.proxy.$Proxy0
    method: getNameById
    args: [1]
    argument id: 1
    invoke object: class java.lang.String
    name: huhx

    从以上输出结果,我们可以得出以下结论:

    与代理对象相关联的InvocationHandler,只有在代理对象调用方法时,才会执行它的invoke方法

    invoke的三个参数的理解:Object proxy是代理的对象, Method method是真实对象中调用方法的Method类, Object[] args是真实对象中调用方法的参数

    Java动态代理的原理

    一、 动态代理的关键代码就是Proxy.newProxyInstance(classLoader, interfaces, handler),我们跟进源代码看看:

    public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) throws IllegalArgumentException {
      // handler不能为空
        if (h == null) {
            throw new NullPointerException();
        }
    
        final Class<?>[] intfs = interfaces.clone();
        final SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
            checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
        }
    
        /*
         * Look up or generate the designated proxy class.
         */
      // 通过loader和接口,得到代理的Class对象
        Class<?> cl = getProxyClass0(loader, intfs);
    
        /*
         * Invoke its constructor with the designated invocation handler.
         */
        try {
            final Constructor<?> cons = cl.getConstructor(constructorParams);
            final InvocationHandler ih = h;
            if (sm != null && ProxyAccessHelper.needsNewInstanceCheck(cl)) {
                // create proxy instance with doPrivilege as the proxy class may
                // implement non-public interfaces that requires a special permission
                return AccessController.doPrivileged(new PrivilegedAction<Object>() {
                    public Object run() {
                        return newInstance(cons, ih);
                    }
                });
            } else {
           // 创建代理对象的实例
                return newInstance(cons, ih);
            }
        } catch (NoSuchMethodException e) {
            throw new InternalError(e.toString());
        }
    }

    二、 我们看一下newInstance方法的源代码:

    private static Object newInstance(Constructor<?> cons, InvocationHandler h) {
        try {
            return cons.newInstance(new Object[] {h} );
        } catch (IllegalAccessException | InstantiationException e) {
            throw new InternalError(e.toString());
        } catch (InvocationTargetException e) {
            Throwable t = e.getCause();
            if (t instanceof RuntimeException) {
                throw (RuntimeException) t;
            } else {
                throw new InternalError(t.toString());
            }
        }
    }

    三、 当我们通过代理对象调用 一个方法的时候,这个方法的调用就会被转发为由InvocationHandler这个接口的 invoke 方法来进行调用。

    体现这句话的代码,我在源码中没有找到,于是我在测试类的main方法中加入以下代码:

    if (proxy instanceof Proxy) {
        InvocationHandler invocationHandler = Proxy.getInvocationHandler(proxy);
        invocationHandler.invoke(proxy, realObject.getClass().getMethod("getMyName"), null);
        System.out.println("--------------------------------------");
    }

    这段代码的输出结果如下,与上述中调用代理对象中的getMyName方法输出是一样的,不知道Jvm底层是否是这样判断的:

    dynamic proxy handler constuctor: class com.huhx.proxy.RealObject
    dynamic proxy name: class com.sun.proxy.$Proxy0
    method: getMyName
    args: null
    my name is huhx
    invoke object is null
    --------------------------------------

    更多java知识请关注java基础教程栏目。

    以上就是Java动态代理的原理的详细内容,更多请关注liyege.cn其它相关文章!

    常见问题FAQ

    免费下载或者VIP会员专享资源能否直接商用?
    本站所有资源版权均属于原作者所有,这里所提供资源均只能用于参考学习用,请勿直接商用。若由于商用引起版权纠纷,一切责任均由使用者承担。更多说明请参考 VIP介绍。
    提示下载完但解压或打开不了?
    最常见的情况是下载不完整: 可对比下载完压缩包的与网盘上的容量,若小于网盘提示的容量则是这个原因。这是浏览器下载的bug,建议用百度网盘软件或迅雷下载。若排除这种情况,可在对应资源底部留言,或 联络我们.。
    找不到素材资源介绍文章里的示例图片?
    对于PPT,KEY,Mockups,APP,网页模版等类型的素材,文章内用于介绍的图片通常并不包含在对应可供下载素材包内。这些相关商业图片需另外购买,且本站不负责(也没有办法)找到出处。 同样地一些字体文件也是这种情况,但部分素材会在素材包内有一份字体下载链接清单。
    • 1168会员总数(位)
    • 111858资源总数(个)
    • 2本周发布(个)
    • 0 今日发布(个)
    • 244稳定运行(天)

    提供最优质的资源集合

    立即查看 了解详情
    冀ICP备19022365号-1 百度地图

    侵权联系邮箱[email protected]

    立业阁(www.liyege.cn)免费提供wordpress主题模板、dedecms模板、帝国cms模板、小说网站源码、电影网站源码以及网络技术分享,建站源码,小说模板,电影模板,网赚教程,VPS推荐