黑马程序员---基础加强---10代理

---------------------- <a href="http://edu.csdn.net"target="blank">ASP.Net+Android+IOS开发</a>、<a href="http://edu.csdn.net"target="blank">.Net培训</a>、期待与您交流！ ----------------------

java.lang.reflect.Proxy：这是 Java 动态代理机制的主类，它提供了一组静态方法来为一组接口动态地生成代理类及其对象。
 
Proxy 的静态方法
 
方法 1: 该方法用于获取指定代理对象所关联的调用处理器
 static InvocationHandler getInvocationHandler(Object proxy)
 
方法 2：该方法用于获取关联于指定类装载器和一组接口的动态代理类的类对象
 static Class getProxyClass(ClassLoader loader, Class[] interfaces)
 
方法 3：该方法用于判断指定类对象是否是一个动态代理类
 static boolean isProxyClass(Class cl)
 
方法 4：该方法用于为指定类装载器、一组接口及调用处理器生成动态代理类实例
 static Object newProxyInstance(ClassLoader loader, Class[] interfaces, 
    InvocationHandler h)
 
java.lang.reflect.InvocationHandler：这是调用处理器接口，它自定义了一个 invoke 方法，用于集中处理在动态代理类对象上的方法调用，通常在该方法中实现对委托类的代理访问。
 
InvocationHandler 的核心方法
 
该方法负责集中处理动态代理类上的所有方法调用。第一个参数既是代理类实例，第二个参数是被调用的方法对象
 第三个方法是调用参数。调用处理器根据这三个参数进行预处理或分派到委托类实例上发射执行
 Object invoke(Object proxy, Method method, Object[] args)    

每次生成动态代理类对象时都需要指定一个实现了该接口的调用处理器对象（参见 Proxy 静态方法 4 的第三个参数）。
 java.lang.ClassLoader：这是类装载器类，负责将类的字节码装载到 Java 
虚拟机（JVM）中并为其定义类对象，然后该类才能被使用。Proxy 
静态方法生成动态代理类同样需要通过类装载器来进行装载才能使用，它与普通类的唯一区别就是其字节码是由 JVM 
在运行时动态生成的而非预存在于任何一个 .class 文件中。
 每次生成动态代理类对象时都需要指定一个类装载器对象（参见 Proxy 静态方法 4 的第一个参数）
InvocationHandler 的核心方法                        
 // 该方法负责集中处理动态代理类上的所有方法调用。第一个参数既是代理类实例，第二个参数是被调用的方法对象
 // 第三个方法是调用参数。调用处理器根据这三个参数进行预处理或分派到委托类实例上发射执行
 Object invoke(Object proxy, Method method, Object[] args)  
 · java.lang.ClassLoader：这是类装载器类，负责将类的字节码装载到 Java 虚拟机（JVM）中并为其定义类对象，然后该类才能被使用。Proxy 静态方法生成动态代理类同样需要通过类装载器来进行装载才能使用，它与普通类的唯一区别就是其字节码是由 JVM 在运行时动态生成的而非预存在于任何一个 .class 文件中。 
清单 3. 动态代理对象创建过程
 // InvocationHandlerImpl 实现了 InvocationHandler 接口，并能实现方法调用从代理类到委托类的分派转发
 // 其内部通常包含指向委托类实例的引用，用于真正执行分派转发过来的方法调用
 InvocationHandler handler = new InvocationHandlerImpl(..); 
// 通过 Proxy 为包括 Interface 接口在内的一组接口动态创建代理类的类对象
 Class clazz = Proxy.getProxyClass(classLoader, new Class[] { Interface.class, ... }); 
// 通过反射从生成的类对象获得构造函数对象
 Constructor constructor = clazz.getConstructor(new Class[] { InvocationHandler.class }); 
// 通过构造函数对象创建动态代理类实例
 Interface Proxy = (Interface)constructor.newInstance(new Object[] { handler });  
 实际使用过程更加简单，因为 Proxy 的静态方法 newProxyInstance 已经为我们封装了步骤 2 到步骤 4 的过程，所以简化后的过程如下
 清单 4. 简化的动态代理对象创建过程             
// InvocationHandlerImpl 实现了 InvocationHandler 接口，并能实现方法调用从代理类到委托类的分派转发
 InvocationHandler handler = new InvocationHandlerImpl(..); 
// 通过 Proxy 直接创建动态代理类实例
 Interface proxy = (Interface)Proxy.newProxyInstance( classLoader, 
     new Class[] { Interface.class }, 
     handler );  
 Java 动态代理机制的特点。
 动态生成的代理类本身的特点。
   1）包：如果所代理的接口都是 public 的，那么它将被定义在顶层包（即包路径为空），如果所代理的接口中有非 public 的接口（因为接口不能被定义为 protect 或 private，所以除 public 之外就是默认的 package 访问级别），那么它将被定义在该接口所在包（假设代理了 com.ibm.developerworks 包中的某非 public 接口 A，那么新生成的代理类所在的包就是 com.ibm.developerworks），这样设计的目的是为了最大程度的保证动态代理类不会因为包管理的问题而无法被成功定义并访问；
   2）类修饰符：该代理类具有 final 和 public 修饰符，意味着它可以被所有的类访问，但是不能被再度继承；
   3）类名：格式是“$ProxyN”，其中 N 是一个逐一递增的阿拉伯数字，代表 Proxy 类第 N 次生成的动态代理类，值得注意的一点是，并不是每次调用 Proxy 的静态方法创建动态代理类都会使得 N 值增加，原因是如果对同一组接口（包括接口排列的顺序相同）试图重复创建动态代理类，它会很聪明地返回先前已经创建好的代理类的类对象，而不会再尝试去创建一个全新的代理类，这样可以节省不必要的代码重复生成，提高了代理类的创建效率。
   4）类继承关系：该类的继承关系如图：
 清单 5. Proxy 的重要静态变量
 // 映射表：用于维护类装载器对象到其对应的代理类缓存
 private static Map loaderToCache = new WeakHashMap(); 
// 标记：用于标记一个动态代理类正在被创建中
 private static Object pendingGenerationMarker = new Object(); 
// 同步表：记录已经被创建的动态代理类类型，主要被方法 isProxyClass 进行相关的判断
 private static Map proxyClasses = Collections.synchronizedMap(new WeakHashMap()); 
// 关联的调用处理器引用
 protected InvocationHandler h;  
 然后，来看一下 Proxy 的构造方法：
 清单 6. Proxy 构造方法
 // 由于 Proxy 内部从不直接调用构造函数，所以 private 类型意味着禁止任何调用
 private Proxy() {} 
// 由于 Proxy 内部从不直接调用构造函数，所以 protected 意味着只有子类可以调用
 protected Proxy(InvocationHandler h) {this.h = h;}  
 接着，可以快速浏览一下 newProxyInstance 方法
 清单 7. Proxy 静态方法 newProxyInstance
 public static Object newProxyInstance(ClassLoader loader, 
            Class<?>[] interfaces, 
            InvocationHandler h) 
            throws IllegalArgumentException { 
    // 检查 h 不为空，否则抛异常
     if (h == null) { 
        throw new NullPointerException(); 
    } 
    // 获得与制定类装载器和一组接口相关的代理类类型对象
     Class cl = getProxyClass(loader, interfaces); 
    // 通过反射获取构造函数对象并生成代理类实例
     try { 
        Constructor cons = cl.getConstructor(constructorParams); 
        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 方法，该方法负责为一组接口动态地生成代理类类型对象。在该方法内部，您将能看到 Proxy 内的静态变量。
 清单 8. 通过 Class.forName 方法判接口的可见性                     
 try { 
    // 指定接口名字、类装载器对象，同时制定 initializeBoolean 为 false 表示无须初始化类
     // 如果方法返回正常这表示可见，否则会抛出 ClassNotFoundException 异常表示不可见
     interfaceClass = Class.forName(interfaceName, false, loader); 
} catch (ClassNotFoundException e) { 
}  
 清单 9. 缓存表的使用                    
 do { 
    // 以接口名字列表作为关键字获得对应 cache 值
     Object value = cache.get(key); 
    if (value instanceof Reference) { 
        proxyClass = (Class) ((Reference) value).get(); 
    } 
    if (proxyClass != null) { 
        // 如果已经创建，直接返回
         return proxyClass; 
    } else if (value == pendingGenerationMarker) { 
       // 代理类正在被创建，保持等待
         try { 
            cache.wait(); 
        } catch (InterruptedException e) { 
        } 
        // 等待被唤醒，继续循环并通过二次检查以确保创建完成，否则重新等待
         continue; 
    } else { 
        // 标记代理类正在被创建
         cache.put(key, pendingGenerationMarker); 
        // break 跳出循环已进入创建过程
         break; 
} while (true);  
 动态创建代理类的类对象。
 清单 10. 动态生成代理类                        
 // 动态地生成代理类的字节码数组
 byte[] proxyClassFile = ProxyGenerator.generateProxyClass( proxyName, interfaces); 
try { 
    // 动态地定义新生成的代理类
     proxyClass = defineClass0(loader, proxyName, proxyClassFile, 0, 
        proxyClassFile.length); 
} catch (ClassFormatError e) { 
    throw new IllegalArgumentException(e.toString()); 
} 
// 把生成的代理类的类对象记录进 proxyClasses 表
 proxyClasses.put(proxyClass, null);  
 

---------------------- <a href="http://edu.csdn.net"target="blank">ASP.Net+Android+IOS开发</a>、<a href="http://edu.csdn.net"target="blank">.Net培训</a>、期待与您交流！ ----------------------