那么动态代理是如何实现将切面逻辑（advise）织入到目标类方法中去的呢？下面我们就来详细介绍并实现AOP中用到的两种动态代理。
AOP的源码中用到了两种动态代理来实现拦截切入功能：jdk动态代理和cglib动态代理。两种方法同时存在，各有优劣。jdk动态代理是由Java内部的反射机制来实现的，cglib动态代理底层则是借助asm来实现的。总的来说，反射机制在生成类的过程中比较高效，而asm在生成类之后的相关执行过程中比较高效（可以通过将asm生成的类进行缓存，这样解决asm生成类过程低效问题）。还有一点必须注意：jdk动态代理的应用前提，必须是目标类基于统一的接口。如果没有上述前提，jdk动态代理不能应用。由此可以看出，jdk动态代理有一定的局限性，cglib这种第三方类库实现的动态代理应用更加广泛，且在效率上更有优势。。
1、定义接口和实现
[java] view plain copy print?
package com.meituan.hyt.test3.service
public interface UserService {
public String getName(int id)
public Integer getAge(int id)
}
[java] view plain copy print?
package com.meituan.hyt.test3.service.impl
import com.meituan.hyt.test3.service.UserService
public class UserServiceImpl implements UserService {
@Override
public String getName(int id) {
System.out.println("------getName------")
return "Tom"
}
@Override
public Integer getAge(int id) {
System.out.println("------getAge------")
return 10
}
}
2、jdk动态代理实现
[java] view plain copy print?
package com.meituan.hyt.test3.jdk
import java.lang.reflect.InvocationHandler
import java.lang.reflect.Method
public class MyInvocationHandler implements InvocationHandler {
private Object target
MyInvocationHandler() {
super()
}
MyInvocationHandler(Object target) {
super()
this.target = target
}
@Override
public Object invoke(Object o, Method method, Object[] args) throws Throwable {
if("getName".equals(method.getName())){
System.out.println("++++++before " + method.getName() + "++++++")
Object result = method.invoke(target, args)
System.out.println("++++++after " + method.getName() + "++++++")
return result
}else{
Object result = method.invoke(target, args)
return result
}
}
}
[java] view plain copy print?
package com.meituan.hyt.test3.jdk
import com.meituan.hyt.test3.service.UserService
import com.meituan.hyt.test3.service.impl.UserServiceImpl
import java.lang.reflect.InvocationHandler
import java.lang.reflect.Proxy
public class Main1 {
public static void main(String[] args) {
UserService userService = new UserServiceImpl()
InvocationHandler invocationHandler = new MyInvocationHandler(userService)
UserService userServiceProxy = (UserService)Proxy.newProxyInstance(userService.getClass().getClassLoader(),
userService.getClass().getInterfaces(), invocationHandler)
System.out.println(userServiceProxy.getName(1))
System.out.println(userServiceProxy.getAge(1))
}
}
运行结果
++++++before getName++++++
------getName------
++++++after getName++++++
Tom
------getAge------
10
3、cglib动态代理实现
Cglib是一个优秀的动态代理框架，它的底层使用ASM在内存中动态的生成被代理类的子类，使用CGLIB即使代理类没有实现任何接口也可以实现动态代理功能。CGLIB具有简单易用，它的运行速度要远远快于JDK的Proxy动态代理：
CGLIB的核心类：
net.sf.cglib.proxy.Enhancer – 主要的增强类
net.sf.cglib.proxy.MethodInterceptor – 主要的方法拦截类，它是Callback接口的子接口，需要用户实现
net.sf.cglib.proxy.MethodProxy – JDK的java.lang.reflect.Method类的代理类，可以方便的实现对源对象方法的调用,如使用：
Object o = methodProxy.invokeSuper(proxy, args)//虽然第一个参数是被代理对象，也不会出现死循环的问题。
net.sf.cglib.proxy.MethodInterceptor接口是最通用的回调（callback）类型，它经常被基于代理的AOP用来实现拦截（intercept）方法的调用。这个接口只定义了一个方法
public Object intercept(Object object, java.lang.reflect.Method method,
Object[] args, MethodProxy proxy) throws Throwable
第一个参数是代理对像，第二和第三个参数分别是拦截的方法和方法的参数。原来的方法可能通过使用java.lang.reflect.Method对象的一般反射调用，或者使用 net.sf.cglib.proxy.MethodProxy对象调用。net.sf.cglib.proxy.MethodProxy通常被首选使用，因为它更快。
[java] view plain copy print?
package com.meituan.hyt.test3.cglib
import net.sf.cglib.proxy.MethodInterceptor
import net.sf.cglib.proxy.MethodProxy
import java.lang.reflect.Method
public class CglibProxy implements MethodInterceptor {
@Override
public Object intercept(Object o, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
System.out.println("++++++before " + methodProxy.getSuperName() + "++++++")
System.out.println(method.getName())
Object o1 = methodProxy.invokeSuper(o, args)
System.out.println("++++++before " + methodProxy.getSuperName() + "++++++")
return o1
}
}
[java] view plain copy print?
package com.meituan.hyt.test3.cglib
import com.meituan.hyt.test3.service.UserService
import com.meituan.hyt.test3.service.impl.UserServiceImpl
import net.sf.cglib.proxy.Enhancer
public class Main2 {
public static void main(String[] args) {
CglibProxy cglibProxy = new CglibProxy()
Enhancer enhancer = new Enhancer()
enhancer.setSuperclass(UserServiceImpl.class)
enhancer.setCallback(cglibProxy)
UserService o = (UserService)enhancer.create()
o.getName(1)
o.getAge(1)
}
}
运行结果：
++++++before CGLIB$getName$0++++++
getName
------getName------
++++++before CGLIB$getName$0++++++
++++++before CGLIB$getAge$1++++++
getAge
------getAge------
++++++before CGLIB$getAge$1++++++
1. 动态代理是指在运行时，动态生成代理类。代理类的字节码将在运行时生成并载入当前的ClassLoader.生成动态代理类的方法很多，如JDK自带的动态代理、CGLIB、Javassist或者ASM库。
JDK动态代理使用简单，它内置在JDK中，因此不需要引入第三方Jar包，但相对功能比较弱。CGLIB和Javassist都是高级的字节码生成库，总体性能比JDK自带的动态代理好，而且功能十分强大。ASM是低级的字节码生成工具，使用ASM已经近乎在于使用Javabytecode编程，对开发人员要求较高，也是性能最好的一种动态代理生辰工具。但ASM的使用是在过于繁琐，而且性能也没有数量级的提升，与CGLIB等高级字节码生成工具相比，ASM程序的可维护性也较差。
JDK实现
1、步骤
1）通过实现InvocationHandler接口创建自己的调用处理器
2）通过为Proxy类指定ClassLoader对象和一组interface来创建动态代理类
3）通过反射机制获得动态代理类的构造函数，其唯一参数类型是调用处理器接口类型
4）通过构造函数创建动态代理类实例，构造时调用处理器对象作为参数被传入
2、创建代理
//InvocationHandlerImpl 实现了InvocationHandler接口，并能实现方法调用从代理类到委托类的分派转发
//其内部通常包含指向委托类实例的引用，用于真正执行分派转发过来的方法调用
InvocationHandler handler = new InvocaitonHandlerImpl(..)
//通过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对上面具体步骤的后三步做了封装，简化了动态代理对象的获取过程。
//InvocationHandlerImpl实现了InvocaitonHandler接口，并能实现方法调用从代理类到委托类的分派转发
InvocaitonHandler handler = new InvocationHandlerImpl(..)
//通过Proxy直接创建动态代理类实例
nterface proxy = (Interface)Proxy.newProxyInstance(classLoader,new Class[]{Interface.class},handler)
3、代码
/**
* 接口
*
*/
public interface IDBQuery {
String request()
}
/**
* 真实的实现类，具体的目标对象
*
*/
public class DBQuery implements IDBQuery {
public DBQuery(){
try {
Thread.sleep(1000)//可能包含数据库连接等耗时操作
} catch (InterruptedException e) {
e.printStackTrace()
}
}
@Override
public String request() {
return "request string"
}
}
/**
* JDK动态代理的实现类
*
*/
public class JdkDbQueryHandler implements InvocationHandler{
IDBQuery real = null//主题接口
/**
* 生成Handler
*/
@Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
if(real == null)
real = new DBQuery()//如果是第一次调用，则生成真实对象
return real.request() //使用真实主题完成实际的操作
}
/**
* 利用Handler生成动态代理对象
*/
public static IDBQuery createJdkProxy(){
//根据指定的类加载器和接口以及截获器，返回代理类的一个实例对象
//ClassLoader loader :指定被代理对象的类加载器
//Class[] Interfaces ：指定被代理对象所以事项的接口
//InvocationHandler h :指定需要调用的InvocationHandler对象
IDBQuery jdkProxy = (IDBQuery) Proxy.newProxyInstance(ClassLoader.getSystemClassLoader(), new Class[]{IDBQuery.class}, new JdkDbQueryHandler())
return jdkProxy
}
}
