文章出自:
http://rejoy.iteye.com/blog/1627405?page=2#comments
http://langyu.iteye.com/blog/410071
和动态代理有关的有两个类
1.interface InvocationHandler
Object invoke(Object proxy, Method method, Object[] args)
2.class Proxy
真正表示动态代理的类,提供两个静态方法:
Class<?> getProxyClass(ClassLoader loader, Class<?>[] interface)
用来产生代理类,参数要提供interface数组,它会生成这些interface的“虚拟实现”,
用来冒充真实的对象。
Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)
产生代理对象,多了InvocationHandler参数(只是InvocationHandler接口的实现类),
它与代理对象关联,当请求分发到代理对象后,会自动执行h.invoke(...)方法,
invoke方法就是我们用来做N多事情的地方 -_-。
利用JDK实现动态代理的例子如下:
Hello.java
package com.yusj.service; /** * 目标对象实现的接口,用JDK来生成代理对象一定要实现一个接口 * @author yushaojian * */ public interface Hello { /** * 目标方法sayHello * @param say */ public abstract void sayHello(String say) ; /** * 目标方法pring * @param str */ public abstract void pring(String str) ; }
HelloImpl.java
package com.yusj.service.impl; import com.yusj.service.Hello; /** * 目标对象 * @author yushaojian * */ public class HelloImpl implements Hello { /** * @see com.yusj.service.Hello#sayHello(String) */ @Override public void sayHello(String say) { System.out.println("Say hello to "+say) ; } /** * @see com.yusj.service.Hello#pring(String) */ @Override public void pring(String str) { System.out.println("pring : "+str) ; } }
MyInvocationHandler.java
package com.yusj.proxy; import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; import java.lang.reflect.Proxy; /** * 实现自己的InvocationHandler * @author yushaojian * */ public class MyInvocationHandler implements InvocationHandler { // 目标对象 private Object target ; /** * 构造方法 * @param target 目标对象 */ public MyInvocationHandler(Object target) { super() ; this.target = target ; } /** * 重写执行目标对象的方法 */ @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { // 在目标对象的方法执行之前做一些操作 doBefore(); // 执行目标对象方法 Object result = method.invoke(target, args) ; // 在目标对象的方法执行之后做一些操作 after(); return result; } /** * 获取目标对象的代理对象 * @return 代理对象 */ public Object getProxy(){ return Proxy.newProxyInstance(Hello.getClass().getClassLoader(), target.getClass().getInterfaces(), this); } private void doBefore() { System.out.println("before...."); } private void after() { System.out.println("after...."); } }
Test.java
package com.yusj.test; import com.yusj.proxy.MyInvocationHandler; import com.yusj.service.Hello; import com.yusj.service.impl.HelloImpl; /** * 动态代理测试类 * @author yushaojian * */ public class Test { public static void main(String[] args) { // 实例化目标对象 Hello h = new HelloImpl() ; // 实例化InvocationHandler MyInvocationHandler myInvocationHandler = new MyInvocationHandler(h); // 根据目标对象生成代理对象 Hello proxy = (Hello)myInvocationHandler.getProxy(); // 通过代理对象调用目标方法(这里无论访问哪个方法,都是会把请求转发到myInvocationHandler.invoke) proxy.sayHello("张三"); proxy.pring("大家好"); /** * 输出结果: * before.... * Say hello to 张三 * after.... * before.... * pring : 大家好 * after.... * */ } }
用起来是很简单吧,其实这里基本上就是AOP的一个简单实现了,在目标对象的方法执行之前和执行之后进行了增强。Spring的AOP实现其实也是用了Proxy和InvocationHandler这两个东西的。
用起来是比较简单,但是如果能知道它背后做了些什么手脚,那就更好不过了。首先来看一下JDK是怎样生成代理对象的。既然生成代理对象是用的Proxy类的静态方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; }
进去ProxyGenerator类的静态方法generateProxyClass,这里是真正生成代理类class字节码的地方。
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是怎样动态生成代理类的字节的原理已经一目了然了。
相关推荐
Jdk动态代理,基于接口的代理示例 InovactionHandler Proxy
动态代理是使用jdk的反射机制,创建对象的...jdk动态代理,必须有接口,目标类必须实现接口, 没有接口时,需要使用cglib动态代理。 动态代理可以在不改变原来目标方法功能的前提下, 可以在代理中增强自己的功能代码。
AOP的意思就是面向切面编程。本文主要是通过梳理JDK中自带的反射机制,实现 AOP动态代理模式,这也是Spring AOP 的实现原理
Spring Aop的底层实现技术 --- Jdk动态代理原理 很不错的一篇文章
代理模式及手实现动态代理(aop原理)一、代理模式1. 定义2. 示例(1)静态代理(2)动态代理3. 通用类图4. 代理模式的优点二、jdk动态代理实现原理1. jdk动态代理源码分析(通过该示例学会阅读源码的方法)2.jdk动态...
spring中动态代理机制的实现原理及AOP实现原理,JDK的反射,cglib类。
为了说明Spring的AOP原理,本人使用代理模式中的动态代理完成演示AOP编程的原理的演示。相信,如果你耐心看完整个程序(几乎一行注释一行代码),那么你对Spring这个东西就不是觉得有什么神秘了! 阅读对象:凡是喜爱...
JDK动态代理: 我们将详细介绍JDK动态代理的概念和工作原理。您将了解如何使用Java的反射机制来创建代理对象,以及如何将横切逻辑注入到目标方法中。我们还提供了实际示例,演示如何在Spring AOP中使用JDK动态代理。...
如果一个类实现了一个或多个接口,那么Spring就会使用默认的JDK动态代理,如果没有实现任何接口,就会使用cglib来代理。当然我们也可以手动改变这些设置。这也是比较容易掉坑的部分,如果设置错了代理方式,那么在...
该思维导图主要讲解了代理模式的具体实现,包括...其中jdk代理主要讲解了其具体的实现方式、原理、缺点、缓存机制等。Cglib代理主要讲解了其原理、与JDK代理的对比、Enhancer源码解析、methodProxy和Fastclass源码等。
通过代码了解springaop原理,代码采用jdk的动态代理相关类Proxy、InvocationHandler解释动态代理模式
Spring框架是一个开放源代码的J2EE应用程序框架,是对bean的生命周期进行管理的轻量...Spring框架主要由七部分组成,分别是Spring Core,Spring AOP,Spring ORM,Spring DAO,Spring Context,Spring Web和Spring Web MVC。
动态代理在 Java 中有着广泛的应用,比如 AOP 的实现原理、RPC远程调用、Java 注解对象获取、日志框架、全局性异常处理、事务处理等。 在了解动态代理前,我们需要先了解一下什么是代理模式。 代理模式 代理模式...
6. 搞清楚cglib和jdk动态代理的区别 7. 掌握cglib和jdk产生代理对象的方式 8. 掌握cglib和jdk产生代理对象的底层原理 9. 掌握cglib和jdk如何动态添加代理对象的增强功能。 课程目标 1. 可以自主完成阅读Spring框架中...
1.jdk动态代理:使用jdk中的Proxy,Method,InvocaitonHanderl创建代理对象,jdk动态代理要求目标类必须实现接口 2.cglib动态代理:第三方的工具库,创建代理对象,原理是继承。 通过继承目标类,创建子类,子类就是...
jdk和cglib实现的AOP实际上会在内存生成动态代理对象,还有什么其他办法实现AOP?经提示答出AspectJ以及实现原理 Spring中的对象的作用域 Singleton对象引用Prototype会发生什么 项目中怎样使用微服务? 两个服务...
7. 重点掌握aop底层的原理之动态代理机制的概述及差别 8. 重点掌握JDK代理技术之产生代理对象和代理对象执行逻辑分析 9. 重点掌握Cglib代理技术之产生代理对象和代理对象执行逻辑分析 10. 认识Spring AOP中底层常用...
为什么jdk动态代理是必须是接口 两种动态代理的区别 AOP实现方式:aop注解或者xml配置;后来工具jar包aspects; aop的属性 事务 事务编码方式: 事务注意事项; 为什么同一个类A调用b方法事务,A方法一定要有事务...
它为没有实现接口的类提供代理,为JDK的动态代理提供了很好的补充。通常可以使用Java的动态代理创建代理,但当要代理的类没有实现接口或者为了更好的性能,CGLIB是一个好的选择。 二、CGLIB原理 CGLIB原理:动态...
深入理解JDK动态代理本质 企业级高并发缓存解决方案 性能优化之Oracle语句优化雾区 前后台数据验证架构源码级解析 session跨域共享 JAVANIO原理详解 高并发数据库(Mysql数据库性能优化) 软件质量管控 企业常用框架...