1.AOP(Aspect Orient Programming)，称为面向切面编程，它作为面向对象（OOP）的一种补充，用于处理系统中分布于各个模板的横切关注点，比如事务管理、日志、缓存等。AOP实现的关键点是AOP框架自动创建的AOP代理，AOP代理主要分为静态代理和动态代理。静态代理的代表为AspectJ;而动态代理则以Spring AOP为代表。静态代理是编译期实现，动态代理是运行期实现，前者拥有更好的性能。本文主要介绍Spring AOP的两种代理实现机制，jdk动态代理和cglib动态代理。
静态代理是编译阶段生成AOP代理类，也就是说生成的字节码就织入了增强后的AOP对象；动态代理则不会修改字节码，而是在内存中临时生成一个AOP对象，这个AOP对象包含了目标对象的全部方法，并且在特定的切点做了增强处理，并回调原对象的方法。
Spring AOP中的动态代理主要有两种方式，JDK动态代理和CGLIB动态代理。JDK动态代理通过反射来接收被代理的类，并且要求被代理的类必须实现一个接口。JDK动态代理的核心是InvocationHandler接口和Proxy类。
如果目标类没有实现接口，那么Spring AOP会选择使用CGLIB来动态代理目标类。CGLIB（Code Generation Library），是一个代码生成的类库，可以在运行时动态的生成某个类的子类，注意，CGLIB是通过继承的方式做的动态代理，因此如果某个类被标记为final，那么它是无法使用CGLIB做动态代理的，诸如private的方法也是不可以作为切面的。
我们分别通过实例来研究AOP的具体实现。
直接使用Spring AOP
首先定义需要切入的接口和实现。为了简单起见，定义一个Speakable接口和一个具体的实现类，只有两个方法sayHi()和sayBye()。
1 public interface Speakable { 2 void sayHi(); 3 void sayBye(); 4 }
1 @Service 2 public class PersonSpring implements Speakable { 3 @Override 4 public void sayHi() { 5 try { 6 Thread.currentThread().sleep(30); 7 } catch (Exception e) { 8 throw new RuntimeException(e); 9 } 10 System.out.println("Hi!!"); 11 } 12 @Override 13 public void sayBye() { 14 try { 15 Thread.currentThread().sleep(10); 16 } catch (Exception e) { 17 throw new RuntimeException(e); 18 } 19 System.out.println("Bye!!"); 20 } 21 }
接下来我们希望实现一个记录sayHi()和sayBye()执行时间的功能。
定义一个MethodMonitor类用来记录Method执行时间
1 public class MethodMonitor { 2 private long start; 3 private String method; 4 public MethodMonitor(String method) { 5 this.method = method; 6 System.out.println("begin monitor.."); 7 this.start = System.currentTimeMillis(); 8 } 9 public void log() { 10 long elapsedTime = System.currentTimeMillis() - start; 11 System.out.println("end monitor.."); 12 System.out.println("Method: " + method + ", execution time: " + elapsedTime + " milliseconds."); 13 } 14 }
光有这个类还是不够的，希望有个静态方法用起来更顺手，像这样
1 MonitorSession.begin(); 2 doWork(); 3 MonitorSession.end();
说干就干，定义一个MonitorSession
1 public class MonitorSession { 2 private static ThreadLocal<MethodMonitor> monitorThreadLocal = new ThreadLocal<>(); 3 public static void begin(String method) { 4 MethodMonitor logger = new MethodMonitor(method); 5 monitorThreadLocal.set(logger); 6 } 7 public static void end() { 8 MethodMonitor logger = monitorThreadLocal.get(); 9 logger.log(); 10 } 11 }
万事具备，接下来只需要我们做好切面的编码，
1 @Aspect 2 @Component 3 public class MonitorAdvice { 4 @Pointcut("execution (* com.deanwangpro.aop.service.Speakable.*(..))") 5 public void pointcut() { 6 } 7 @Around("pointcut()") 8 public void around(ProceedingJoinPoint pjp) throws Throwable { 9 MonitorSession.begin(pjp.getSignature().getName()); 10 pjp.proceed(); 11 MonitorSession.end(); 12 } 13 }
如何使用？我用了spring boot，写一个启动函数吧。
1 @SpringBootApplication 2 public class Application { 3 @Autowired 4 private Speakable personSpring; 5 public static void main(String[] args) { 6 SpringApplication.run(Application.class, args); 7 } 8 @Bean 9 public CommandLineRunner commandLineRunner(ApplicationContext ctx) { 10 return args -> { 11 // spring aop 12 System.out.println("******** spring aop ******** "); 13 personSpring.sayHi(); 14 personSpring.sayBye(); 15 System.exit(0); 16 }; 17 } 18 }
运行后输出:
1 ******** jdk dynamic proxy ******** 2 begin monitor.. 3 Hi!! 4 end monitor.. 5 Method: sayHi, execution time: 32 milliseconds. 6 begin monitor.. 7 Bye!! 8 end monitor.. 9 Method: sayBye, execution time: 22 milliseconds.
JDK动态代理
刚刚的例子其实内部实现机制就是JDK动态代理，因为Person实现了一个接口。
为了不和第一个例子冲突，我们再定义一个Person来实现Speakable, 这个实现是不带Spring Annotation的，所以他不会被Spring托管。
1 public class PersonImpl implements Speakable { 2 @Override 3 public void sayHi() { 4 try { 5 Thread.currentThread().sleep(30); 6 } catch (Exception e) { 7 throw new RuntimeException(e); 8 } 9 System.out.println("Hi!!"); 10 } 11 @Override 12 public void sayBye() { 13 try { 14 Thread.currentThread().sleep(10); 15 } catch (Exception e) { 16 throw new RuntimeException(e); 17 } 18 System.out.println("Bye!!"); 19 } 20 }
重头戏来了，我们需要利用InvocationHandler实现一个代理，让它去包含Person这个对象。那么再运行期实际上是执行这个代理的方法，然后代理再去执行真正的方法。所以我们得以在执行真正方法的前后做一些手脚。JDK动态代理是利用反射实现，直接看代码。
1 public class DynamicProxy implements InvocationHandler { 2 private Object target; 3 public DynamicProxy(Object object) { 4 this.target = object; 5 } 6 @Override 7 public Object invoke(Object arg0, Method arg1, Object[] arg2) 8 throws Throwable { 9 MonitorSession.begin(arg1.getName()); 10 Object obj = arg1.invoke(target, arg2); 11 MonitorSession.end(); 12 return obj; 13 } 14 @SuppressWarnings("unchecked") 15 public <T> T getProxy() { 16 return (T) Proxy.newProxyInstance( 17 target.getClass().getClassLoader(), 18 target.getClass().getInterfaces(), 19 this 20 ); 21 } 22 }
通过getProxy可以得到这个代理对象，invoke就是具体的执行方法，可以看到我们在执行每个真正的方法前后都加了Monitor。
我实现了一个工厂类来获取Person代理对象
1 public class PersonProxyFactory { 2 public static Speakable newJdkProxy() { 3 // 代理PersonImpl 4 DynamicProxy dynamicProxy = new DynamicProxy(new PersonImpl()); 5 Speakable proxy = dynamicProxy.getProxy(); 6 return proxy; 7 } 8 }
具体使用
1 // jdk dynamic proxy 2 System.out.println("******** jdk dynamic proxy ******** "); 3 Speakable jdkProxy = PersonProxyFactory.newJdkProxy(); 4 jdkProxy.sayHi(); 5 jdkProxy.sayBye();
输出结果:
1 ******** jdk dynamic proxy ******** 2 begin monitor.. 3 Hi!! 4 end monitor.. 5 Method: sayHi, execution time: 32 milliseconds. 6 begin monitor.. 7 Bye!! 8 end monitor.. 9 Method: sayBye, execution time: 22 milliseconds.
CGLib动态代理
我们再新建一个Person来，这次不实现任何接口。
1 public class Person { 2 public void sayHi() { 3 try { 4 Thread.currentThread().sleep(30); 5 } catch (Exception e) { 6 throw new RuntimeException(e); 7 } 8 System.out.println("Hi!!"); 9 } 10 public void sayBye() { 11 try { 12 Thread.currentThread().sleep(10); 13 } catch (Exception e) { 14 throw new RuntimeException(e); 15 } 16 System.out.println("Bye!!"); 17 } 18 }
如果Spring识别到所代理的类没有实现Interface，那么就会使用CGLib来创建动态代理，原理实际上成为所代理类的子类。
1 public class CGLibProxy implements MethodInterceptor { 2 private static CGLibProxy instance = new CGLibProxy(); 3 private CGLibProxy() { 4 } 5 public static CGLibProxy getInstance() { 6 return instance; 7 } 8 private Enhancer enhancer = new Enhancer(); 9 @SuppressWarnings("unchecked") 10 public <T> T getProxy(Class<T> clazz) { 11 enhancer.setSuperclass(clazz); 12 enhancer.setCallback(this); 13 return (T) enhancer.create(); 14 } 15 @Override 16 public Object intercept(Object arg0, Method arg1, Object[] arg2, 17 MethodProxy arg3) throws Throwable { 18 MonitorSession.begin(arg1.getName()); 19 Object obj = arg3.invokeSuper(arg0, arg2); 20 MonitorSession.end(); 21 return obj; 22 } 23 }
类似的通过getProxy可以得到这个代理对象，intercept就是具体的执行方法，可以看到我们在执行每个真正的方法前后都加了Monitor。
在工厂类中增加获得Person代理类的方法,
1 public static Person newCglibProxy() { 2 CGLibProxy cglibProxy = CGLibProxy.getInstance(); 3 Person proxy = cglibProxy.getProxy(Person.class); 4 return proxy; 5 }
具体使用
1 // cglib dynamic proxy 2 System.out.println("******** cglib proxy ******** "); 3 Person cglibProxy = PersonProxyFactory.newCglibProxy(); 4 cglibProxy.sayHi(); 5 cglibProxy.sayBye();
输出结果：
1 begin monitor.. 2 Hi!! 3 end monitor.. 4 Method: sayHi, execution time: 53 milliseconds. 5 begin monitor.. 6 Bye!! 7 end monitor.. 8 Method: sayBye, execution time: 14 milliseconds.
小结
对比JDK动态代理和CGLib代理，在实际使用中发现CGLib在创建代理对象时所花费的时间却比JDK动态代理要长，实测数据
1 Method: newJdkProxy, execution time: 5 milliseconds. 2 Method: newCglibProxy, execution time: 18 milliseconds.
所以CGLib更适合代理不需要频繁实例化的类。
在具体方法执行效率方面，理应是不通过反射的CGlib更快一些，然后测试结果并非如此，还需要高手指教。
1 JDK 2 Method: sayHi, execution time: 32 milliseconds. 3 CGLib 4 Method: sayHi, execution time: 53 milliseconds.
以上code都可以通过Github中获取。
来源http://www.importnew.com/31318.html