`

JDK动态代理实现原理(转)_AOP简介

    博客分类:
  • java
阅读更多

 

文章出自:

    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动态代理 spring aop 的原理

    Jdk动态代理,基于接口的代理示例 InovactionHandler Proxy

    JDK动态代理(AOP)使用及原理分析视频教程课件

    动态代理是使用jdk的反射机制,创建对象的...jdk动态代理,必须有接口,目标类必须实现接口, 没有接口时,需要使用cglib动态代理。 动态代理可以在不改变原来目标方法功能的前提下, 可以在代理中增强自己的功能代码。

    反射实现 AOP 动态代理模式(Spring AOP 的实现原理)

    AOP的意思就是面向切面编程。本文主要是通过梳理JDK中自带的反射机制,实现 AOP动态代理模式,这也是Spring AOP 的实现原理

    Spring Aop的底层实现技术 --- Jdk动态代理原理

    Spring Aop的底层实现技术 --- Jdk动态代理原理 很不错的一篇文章

    两万字吐血总结,代理模式及手写实现动态代理(aop原理,基于jdk动态代理)

    代理模式及手实现动态代理(aop原理)一、代理模式1. 定义2. 示例(1)静态代理(2)动态代理3. 通用类图4. 代理模式的优点二、jdk动态代理实现原理1. jdk动态代理源码分析(通过该示例学会阅读源码的方法)2.jdk动态...

    代理机制及AOP原理实现

    spring中动态代理机制的实现原理及AOP实现原理,JDK的反射,cglib类。

    使用动态代理演示Spring的AOP编程原理

    为了说明Spring的AOP原理,本人使用代理模式中的动态代理完成演示AOP编程的原理的演示。相信,如果你耐心看完整个程序(几乎一行注释一行代码),那么你对Spring这个东西就不是觉得有什么神秘了! 阅读对象:凡是喜爱...

    SpringAOP的实现机制(底层原理)、应用场景等详解,模拟过程的实例

    JDK动态代理: 我们将详细介绍JDK动态代理的概念和工作原理。您将了解如何使用Java的反射机制来创建代理对象,以及如何将横切逻辑注入到目标方法中。我们还提供了实际示例,演示如何在Spring AOP中使用JDK动态代理。...

    Spring AOP代理详细介绍

    如果一个类实现了一个或多个接口,那么Spring就会使用默认的JDK动态代理,如果没有实现任何接口,就会使用cglib来代理。当然我们也可以手动改变这些设置。这也是比较容易掉坑的部分,如果设置错了代理方式,那么在...

    动态代理.xmind

    该思维导图主要讲解了代理模式的具体实现,包括...其中jdk代理主要讲解了其具体的实现方式、原理、缺点、缓存机制等。Cglib代理主要讲解了其原理、与JDK代理的对比、Enhancer源码解析、methodProxy和Fastclass源码等。

    spring动态代理原理

    通过代码了解springaop原理,代码采用jdk的动态代理相关类Proxy、InvocationHandler解释动态代理模式

    Spring框架+Spring工作原理+AOP面向切面编程+JDK代理+Cglib代理

    Spring框架是一个开放源代码的J2EE应用程序框架,是对bean的生命周期进行管理的轻量...Spring框架主要由七部分组成,分别是Spring Core,Spring AOP,Spring ORM,Spring DAO,Spring Context,Spring Web和Spring Web MVC。

    Java 动态代理.md

    动态代理在 Java 中有着广泛的应用,比如 AOP 的实现原理、RPC远程调用、Java 注解对象获取、日志框架、全局性异常处理、事务处理等。 在了解动态代理前,我们需要先了解一下什么是代理模式。 代理模式 代理模式...

    spring第三天.pdf

    6. 搞清楚cglib和jdk动态代理的区别 7. 掌握cglib和jdk产生代理对象的方式 8. 掌握cglib和jdk产生代理对象的底层原理 9. 掌握cglib和jdk如何动态添加代理对象的增强功能。 课程目标 1. 可以自主完成阅读Spring框架中...

    AOP面向切面编程.docx

    1.jdk动态代理:使用jdk中的Proxy,Method,InvocaitonHanderl创建代理对象,jdk动态代理要求目标类必须实现接口 2.cglib动态代理:第三方的工具库,创建代理对象,原理是继承。 通过继承目标类,创建子类,子类就是...

    2020年春招最新阿里Java面试题集锦

    jdk和cglib实现的AOP实际上会在内存生成动态代理对象,还有什么其他办法实现AOP?经提示答出AspectJ以及实现原理 Spring中的对象的作用域 Singleton对象引用Prototype会发生什么 项目中怎样使用微服务? 两个服务...

    spring第四天.pdf

    7. 重点掌握aop底层的原理之动态代理机制的概述及差别 8. 重点掌握JDK代理技术之产生代理对象和代理对象执行逻辑分析 9. 重点掌握Cglib代理技术之产生代理对象和代理对象执行逻辑分析 10. 认识Spring AOP中底层常用...

    高级开发spring面试题和答案.pdf

    为什么jdk动态代理是必须是接口 两种动态代理的区别 AOP实现方式:aop注解或者xml配置;后来工具jar包aspects; aop的属性 事务 事务编码方式: 事务注意事项; 为什么同一个类A调用b方法事务,A方法一定要有事务...

    cglib.jar下载

    它为没有实现接口的类提供代理,为JDK的动态代理提供了很好的补充。通常可以使用Java的动态代理创建代理,但当要代理的类没有实现接口或者为了更好的性能,CGLIB是一个好的选择。 二、CGLIB原理 CGLIB原理:动态...

    JAVA高并发高性能高可用高扩展架构视频教程

    深入理解JDK动态代理本质 企业级高并发缓存解决方案 性能优化之Oracle语句优化雾区 前后台数据验证架构源码级解析 session跨域共享 JAVANIO原理详解 高并发数据库(Mysql数据库性能优化) 软件质量管控 企业常用框架...

Global site tag (gtag.js) - Google Analytics