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

posted on 2019-04-18 22:10  小白coder  阅读(2413)  评论(0编辑  收藏  举报