zoukankan html css js c++ java

动态代理详解（二）原理解析

确定目标问题

在上一篇博文动态代理详解（一）应用示例中，读完代码之后存在的主要困惑有两点：

1.MyInvocationHandler 的 invoke 方法是什么时候调用的？

2.Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(), target.getClass().getInterfaces(), this)做了些什么？

解答

newProxyInstance

/** 
 * loader:类加载器 
 * interfaces:目标对象实现的接口 
 * h:InvocationHandler的实现类 
 */  
public static Object newProxyInstance(ClassLoader loader,  
                      Class<?>[] interfaces,  
                      InvocationHandler h)  
    throws IllegalArgumentException  
    {  
    if (h == null) {  
        throw new NullPointerException();  
    }  

    /* 
     * Look up or generate the designated proxy class. 
     */  
    Class cl = getProxyClass(loader, interfaces);  

    /* 
     * Invoke its constructor with the designated invocation handler. 
     */  
    try {  
            // 调用代理对象的构造方法（也就是$Proxy0(InvocationHandler h)）  
        Constructor cons = cl.getConstructor(constructorParams);  
            // 生成代理类的实例并把MyInvocationHandler的实例传给它的构造方法  
        return (Object) cons.newInstance(new Object[] { h });  
    } catch (NoSuchMethodException e) {  
        throw new InternalError(e.toString());  
    } catch (IllegalAccessException e) {  
        throw new InternalError(e.toString());  
    } catch (InstantiationException e) {  
        throw new InternalError(e.toString());  
    } catch (InvocationTargetException e) {  
        throw new InternalError(e.toString());  
    }  
    }

getProxyClass

public static Class<?> getProxyClass(ClassLoader loader,   
                                         Class<?>... interfaces)  
    throws IllegalArgumentException  
    {  
    // 如果目标类实现的接口数大于65535个则抛出异常（我XX，谁会写这么NB的代码啊？）  
    if (interfaces.length > 65535) {  
        throw new IllegalArgumentException("interface limit exceeded");  
    }  

    // 声明代理对象所代表的Class对象（有点拗口）  
    Class proxyClass = null;  

    String[] interfaceNames = new String[interfaces.length];  

    Set interfaceSet = new HashSet();   // for detecting duplicates  

    // 遍历目标类所实现的接口  
    for (int i = 0; i < interfaces.length; i++) {  

        // 拿到目标类实现的接口的名称  
        String interfaceName = interfaces[i].getName();  
        Class interfaceClass = null;  
        try {  
        // 加载目标类实现的接口到内存中  
        interfaceClass = Class.forName(interfaceName, false, loader);  
        } catch (ClassNotFoundException e) {  
        }  
        if (interfaceClass != interfaces[i]) {  
        throw new IllegalArgumentException(  
            interfaces[i] + " is not visible from class loader");  
        }  

        // 中间省略了一些无关紧要的代码 .......  

        // 把目标类实现的接口代表的Class对象放到Set中  
        interfaceSet.add(interfaceClass);  

        interfaceNames[i] = interfaceName;  
    }  

    // 把目标类实现的接口名称作为缓存（Map）中的key  
    Object key = Arrays.asList(interfaceNames);  

    Map cache;  

    synchronized (loaderToCache) {  
        // 从缓存中获取cache  
        cache = (Map) loaderToCache.get(loader);  
        if (cache == null) {  
        // 如果获取不到，则新建地个HashMap实例  
        cache = new HashMap();  
        // 把HashMap实例和当前加载器放到缓存中  
        loaderToCache.put(loader, cache);  
        }  

    }  

    synchronized (cache) {  

        do {  
        // 根据接口的名称从缓存中获取对象  
        Object value = cache.get(key);  
        if (value instanceof Reference) {  
            proxyClass = (Class) ((Reference) value).get();  
        }  
        if (proxyClass != null) {  
            // 如果代理对象的Class实例已经存在，则直接返回  
            return proxyClass;  
        } else if (value == pendingGenerationMarker) {  
            try {  
            cache.wait();  
            } catch (InterruptedException e) {  
            }  
            continue;  
        } else {  
            cache.put(key, pendingGenerationMarker);  
            break;  
        }  
        } while (true);  
    }  

    try {  
        // 中间省略了一些代码 .......  

        // 这里就是动态生成代理对象的最关键的地方  
        byte[] proxyClassFile = ProxyGenerator.generateProxyClass(  
            proxyName, interfaces);  
        try {  
            // 根据代理类的字节码生成代理类的实例  
            proxyClass = defineClass0(loader, proxyName,  
            proxyClassFile, 0, proxyClassFile.length);  
        } catch (ClassFormatError e) {  
            throw new IllegalArgumentException(e.toString());  
        }  
        }  
        // add to set of all generated proxy classes, for isProxyClass  
        proxyClasses.put(proxyClass, null);  

    }   
    // 中间省略了一些代码 .......  

    return proxyClass;  
    }

generateProxyClass

public static byte[] generateProxyClass(final String name,  
                                           Class[] interfaces)  
   {  
       ProxyGenerator gen = new ProxyGenerator(name, interfaces);  
    // 这里动态生成代理类的字节码，由于比较复杂就不进去看了  
       final byte[] classFile = gen.generateClassFile();  

    // 如果saveGeneratedFiles的值为true，则会把所生成的代理类的字节码保存到硬盘上  
       if (saveGeneratedFiles) {  
           java.security.AccessController.doPrivileged(  
           new java.security.PrivilegedAction<Void>() {  
               public Void run() {  
                   try {  
                       FileOutputStream file =  
                           new FileOutputStream(dotToSlash(name) + ".class");  
                       file.write(classFile);  
                       file.close();  
                       return null;  
                   } catch (IOException e) {  
                       throw new InternalError(  
                           "I/O exception saving generated file: " + e);  
                   }  
               }  
           });  
       }  

    // 返回代理类的字节码  
       return classFile;  
   }

JDK生成的字节码（invoke的调用位置）

import dynamic.proxy.UserService;  
import java.lang.reflect.*;  

public final class $Proxy11 extends Proxy  
    implements UserService  
{  

    // 构造方法，参数就是刚才传过来的MyInvocationHandler类的实例  
    public $Proxy11(InvocationHandler invocationhandler)  
    {  
        super(invocationhandler);  
    }  

    public final boolean equals(Object obj)  
    {  
        try  
        {  
            return ((Boolean)super.h.invoke(this, m1, new Object[] {  
                obj  
            })).booleanValue();  
        }  
        catch(Error _ex) { }  
        catch(Throwable throwable)  
        {  
            throw new UndeclaredThrowableException(throwable);  
        }  
    }  

    /** 
     * 这个方法是关键部分 
     */  
    public final void add()  
    {  
        try  
        {  
            // 实际上就是调用MyInvocationHandler的public Object invoke(Object proxy, Method method, Object[] args)方法，第二个问题就解决了  
            super.h.invoke(this, m3, null);  
            return;  
        }  
        catch(Error _ex) { }  
        catch(Throwable throwable)  
        {  
            throw new UndeclaredThrowableException(throwable);  
        }  
    }  

    public final int hashCode()  
    {  
        try  
        {  
            return ((Integer)super.h.invoke(this, m0, null)).intValue();  
        }  
        catch(Error _ex) { }  
        catch(Throwable throwable)  
        {  
            throw new UndeclaredThrowableException(throwable);  
        }  
    }  

    public final String toString()  
    {  
        try  
        {  
            return (String)super.h.invoke(this, m2, null);  
        }  
        catch(Error _ex) { }  
        catch(Throwable throwable)  
        {  
            throw new UndeclaredThrowableException(throwable);  
        }  
    }  

    private static Method m1;  
    private static Method m3;  
    private static Method m0;  
    private static Method m2;  

    // 在静态代码块中获取了4个方法：Object中的equals方法、UserService中的add方法、Object中的hashCode方法、Object中toString方法  
    static   
    {  
        try  
        {  
            m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[] {  
                Class.forName("java.lang.Object")  
            });  
            m3 = Class.forName("dynamic.proxy.UserService").getMethod("add", new Class[0]);  
            m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);  
            m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);  
        }  
        catch(NoSuchMethodException nosuchmethodexception)  
        {  
            throw new NoSuchMethodError(nosuchmethodexception.getMessage());  
        }  
        catch(ClassNotFoundException classnotfoundexception)  
        {  
            throw new NoClassDefFoundError(classnotfoundexception.getMessage());  
        }  
    }  
}

标签：
jdk /
动态代理 /

0条评论

: gaojiyinhang2

Java设计模式-代理模式之动态代理(附源码分析)

Java设计模式-代理模式之动态代理(附源码分析) 动态代理概念及类图上一篇中介绍了静态代理，动态代理跟静态代理一个最大的区别就是：动态代理是在运行时刻动态的创建出代理类及其对...

yujin753
2015-06-26 17:37
1595

Java动态代理的实现

动态代理作为代理模式的一种扩展形式，广泛应用于框架（尤其是基于AOP的框架）的设计与开发，本文将通过实例来讲解Java动态代理的实现过程。友情提示：本文略有难度，读者需具备代理模式相关基...

LoveLion
2012-10-26 19:09
21308

: Linux老难题解决了！

Linux工程师很多，甚至有很多有多年工作经验，但是对一些关键概念的理解非常模糊，比如不理解CPU、内存资源等的真正分布，具体的工作机制，这使得他们对很多问题的分析都摸不到方向。比如进程的调度延时是多少？linux能否硬实时？多核下多线程如何执行？

Java动态代理的两种实现方法

1、定义接口和实现 package com.meituan.hyt.test3.service; /** * Created by heyutao on 15/11/9. */ public i...

HEYUTAO007
2015-11-09 15:24
56150

java动态代理原理及解析

java动态代理, jdk反射与代理模式

Scplove
2016-09-06 17:25
22512

动态代理详解（二）原理解析

确定目标问题解答 newProxyInstance getProxyClass generateProxyClass JDK生成的字节码invoke的调用位置确定目标问题在上一篇博文动态代理详解（...

u012216366
2017-04-15 16:28
226

JDK动态代理的实现和原理解析（基于JDK1.7）

一、什么是代理代理是一种常用的设计模式，其目的就是为其他对象提供一个代理以控制对某个对象的访问。代理类负责为委托类预处理消息，过滤消息并转发消息，以及进行消息被委托类执行后的后续处理。详细介绍请参考：...

xiaokang123456kao
2017-08-29 20:18
35

设计模式--JDK动态代理的实现与原理解析(1)

代理模式是一种很重要很有用的设计模式。被应用到很多著名的框架中，其中Spring Aop的底层就是通过JDK动态代理和CGLib动态代理实现的。其中，JDK动态代理是其默认实现。动态代理的作用就是在不...

u013679744
2017-06-29 16:21
93

java动态代理原理及解析

代理：设计模式代理模式是一种常用的设计模式，其目的就是为其他对象提供一个代理以控制对某个真实对象的访问。代理类负责为委托类预处理消息，过滤消息并转发消息，以及进行消息被委托类执行后的后续处理。 ...

liyanlei5858
2017-08-15 15:32
35

Spring AOP之动态代理原理解析

首先声明，这篇文是看马士兵老师的spring动态代理视频后写出来的。我是初学者，欢迎指正！本示例模拟的是为一个接口的实现类的每个方法执行前和执行后各加一个日志。 Spring AOP就是使用了j...

u012516166
2017-07-25 09:34
52

设计模式--JDK动态代理的实现与原理解析(2)

在上一篇博客中，实现了JDK的动态代理。但是，我们不仅要学会如何使用，更要理解其内部的具体实现。我们是通过此方法获得对目标对象的代理类： public Object getProxy() {...

u013679744
2017-06-29 20:25
73

Android插件化原理解析——Hook机制之动态代理

使用代理机制进行API Hook进而达到方法增强是框架的常用手段，比如J2EE框架Spring通过动态代理优雅地实现了AOP编程，极大地提升了Web开发效率；同样，插件框架也广泛使用了代理机制来增强系...

parallelyk
2016-06-29 16:16
484

基于cglib实现的动态代理原理与源码解析

CGLIB(Code Generation Library)是一个开源项目！是一个强大的，高性能，高质量的Code生成类库，它可以在运行期扩展Java类与实现Java接口。Hibernate用...

tiandesheng111
2014-10-06 22:21
1428

解析动态代理模式与跟自定义注解配合使用以及事务注解原理

动态代理:用来修改已经具有的对象的方法,控制方法是否执行,或在方法执行之前和执行之后做一些额外的操作 Proxy.newProxyInstance(ClassLoader loader, Class[...

danmoo1
2017-08-07 23:17
31

jdk动态代理模式的原理解析

近期一直在学习Mybatis，接触到了拦截器，接口式编程的知识，通过mybatis的学习，对于动态代理和责任链模式有了新的理解，所以决定写些文章以加深自己的印象。这篇文章中先记录一下我理解的java...

skywatercomputer
2015-05-19 14:49
336

java 动态代理原理详解

一，具体实现接口 package proxy_pattern.move_proxy_sun; public interface Ticket { public void getTicket();...

mylikejava
2013-02-04 17:42
247

: Devin__Yang

查看全文

相关阅读:
结合中断上下文切换和进程上下文切换分析Linux内核的一般执行过程
 深入理解系统调用
 基于mykernel2.0编写一个操作系统内核
 如何评测一个软件工程师的计算机网络知识水平与网络编程技能水平？
如何评测软件工程知识技能水平？
深入理解TCP协议及其源代码
 Socket与系统调用深度分析
 创新产品的需求分析：未来的图书会是什么样子？
构建调试Linux内核网络代码的环境MenuOS系统
 解决npm ERR! code ELIFECYCLE npm ERR! errno 1问题

原文地址：https://www.cnblogs.com/zhimingxin/p/7509663.html

动态代理详解（二）原理解析

确定目标问题

解答

newProxyInstance

getProxyClass

generateProxyClass

JDK生成的字节码（invoke的调用位置）

0条评论

相关文章推荐

Linux老难题解决了！