面试官：说说你对SpringAOP的实现机制的理解！

AOP（Aspect Orient Programming），一般称为面向切面编程，作为面向对象的一种补充，用于处理系统中分布于各个模块的横切关注点，比如事务管理、日志、缓存等等。AOP实现的关键在于AOP框架自动创建的AOP代理，AOP代理主要分为静态代理和动态代理，静态代理的代表为AspectJ；而动态代理则以Spring AOP为代表。静态代理是编译期实现，动态代理是运行期实现，可想而知前者拥有更好的性能。

创新互联是一家专注于做网站、网站制作与策划设计,昆都仑网站建设哪家好?创新互联做网站,专注于网站建设十余年,网设计领域的专业建站公司;建站业务涵盖:昆都仑等地区。昆都仑做网站价格咨询:028-86922220

本文主要介绍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.   
  
  
  
  2.  void sayHi();  
    3.   
  
  
  
  3.  void sayBye();  
    4.   
  
  
  
  4. }  
    5.   
  
  
  
  5. @Service  
    6.   
  
  
  
  6. public class PersonSpring implements Speakable {  
    7.   
  
  
  
  7.  @Override  
    8.   
  
  
  
  8.  public void sayHi() {  
    9.   
  
  
  
  9.  try {  
    10.   
  
  
  
  10.  Thread.currentThread().sleep(30);  
    11.   
  
  
  
  11.  } catch (Exception e) {  
    12.   
  
  
  
  12.  throw new RuntimeException(e);  
    13.   
  
  
  
  13.  }  
    14.   
  
  
  
  14.  System.out.println("Hi!!");  
    15.   
  
  
  
  15.  }  
    16.   
  
  
  
  16.  @Override  
    17.   
  
  
  
  17.  public void sayBye() {  
    18.   
  
  
  
  18.  try {  
    19.   
  
  
  
  19.  Thread.currentThread().sleep(10);  
    20.   
  
  
  
  20.  } catch (Exception e) {  
    21.   
  
  
  
  21.  throw new RuntimeException(e);  
    22.   
  
  
  
  22.  }  
    23.   
  
  
  
  23.  System.out.println("Bye!!");  
    24.   
  
  
  
  24.  }  
    25.   
  
  
  
  25. } 
    26.

接下来我们希望实现一个记录sayHi()和sayBye()执行时间的功能。

定义一个MethodMonitor类用来记录Method执行时间

 
 
 
 
    
  
  
  
  
  1. public class MethodMonitor {  
    2.   
  
  
  
  2.  private long start;  
    3.   
  
  
  
  3.  private String method;  
    4.   
  
  
  
  4.  public MethodMonitor(String method) {  
    5.   
  
  
  
  5.  this.method = method;  
    6.   
  
  
  
  6.  System.out.println("begin monitor..");  
    7.   
  
  
  
  7.  this.start = System.currentTimeMillis();  
    8.   
  
  
  
  8.  }  
    9.   
  
  
  
  9.  public void log() {  
    10.   
  
  
  
  10.  long elapsedTime = System.currentTimeMillis() - start;  
    11.   
  
  
  
  11.  System.out.println("end monitor..");  
    12.   
  
  
  
  12.  System.out.println("Method: " + method + ", execution time: " + elapsedTime + " milliseconds.");  
    13.   
  
  
  
  13.  }  
    14.   
  
  
  
  14. } 
    15.

光有这个类还是不够的，希望有个静态方法用起来更顺手，像这样

 
 
 
 
    
  
  
  
  
  1. MonitorSession.begin();  
    2.   
  
  
  
  2. doWork();  
    3.   
  
  
  
  3. MonitorSession.end(); 
    4.

说干就干，定义一个MonitorSession

 
 
 
 
    
  
  
  
  
  1. public class MonitorSession {  
    2.   
  
  
  
  2.  private static ThreadLocal monitorThreadLocal = new ThreadLocal<>();  
    3.   
  
  
  
  3.  public static void begin(String method) {  
    4.   
  
  
  
  4.  MethodMonitor logger = new MethodMonitor(method);  
    5.   
  
  
  
  5.  monitorThreadLocal.set(logger);  
    6.   
  
  
  
  6.  }  
    7.   
  
  
  
  7.  public static void end() {  
    8.   
  
  
  
  8.  MethodMonitor logger = monitorThreadLocal.get();  
    9.   
  
  
  
  9.  logger.log();  
    10.   
  
  
  
  10.  }  
    11.   
  
  
  
  11. } 
    12.

万事具备，接下来只需要我们做好切面的编码，

 
 
 
 
    
  
  
  
  
  1. @Aspect  
    2.   
  
  
  
  2. @Component  
    3.   
  
  
  
  3. public class MonitorAdvice {  
    4.   
  
  
  
  4.  @Pointcut("execution (* com.deanwangpro.aop.service.Speakable.*(..))")  
    5.   
  
  
  
  5.  public void pointcut() {  
    6.   
  
  
  
  6.  }  
    7.   
  
  
  
  7.  @Around("pointcut()")  
    8.   
  
  
  
  8.  public void around(ProceedingJoinPoint pjp) throws Throwable {  
    9.   
  
  
  
  9.  MonitorSession.begin(pjp.getSignature().getName());  
    10.   
  
  
  
  10.  pjp.proceed();  
    11.   
  
  
  
  11.  MonitorSession.end();  
    12.   
  
  
  
  12.  }  
    13.   
  
  
  
  13. } 
    14.

如何使用？我用了spring boot，写一个启动函数吧。

 
 
 
 
    
  
  
  
  
  1. @SpringBootApplication  
    2.   
  
  
  
  2. public class Application {  
    3.   
  
  
  
  3.  @Autowired  
    4.   
  
  
  
  4.  private Speakable personSpring;  
    5.   
  
  
  
  5.  public static void main(String[] args) {  
    6.   
  
  
  
  6.  SpringApplication.run(Application.class, args);  
    7.   
  
  
  
  7.  }  
    8.   
  
  
  
  8.  @Bean  
    9.   
  
  
  
  9.  public CommandLineRunner commandLineRunner(ApplicationContext ctx) {  
    10.   
  
  
  
  10.  return args -> {  
    11.   
  
  
  
  11.  // spring aop  
    12.   
  
  
  
  12.  System.out.println("******** spring aop ******** ");  
    13.   
  
  
  
  13.  personSpring.sayHi();  
    14.   
  
  
  
  14.  personSpring.sayBye();  
    15.   
  
  
  
  15.  System.exit(0);  
    16.   
  
  
  
  16.  };  
    17.   
  
  
  
  17.  }  
    18.   
  
  
  
  18. } 
    19.

运行后输出:  

 
 
 
 
    
  
  
  
  
  1. jdk dynamic proxy begin monitor..Hi!!end monitor..Method: sayHi, execution time: 32 milliseconds.begin monitor..Bye!!end monitor..Method: sayBye, execution time: 22 milliseconds. 
    2.

JDK动态代理

刚刚的例子其实内部实现机制就是JDK动态代理，因为Person实现了一个接口。

为了不和***个例子冲突，我们再定义一个Person来实现Speakable, 这个实现是不带Spring Annotation的，所以他不会被Spring托管。

 
 
 
 
    
  
  
  
  
  1. public class PersonImpl implements Speakable {  
    2.   
  
  
  
  2.  @Override  
    3.   
  
  
  
  3.  public void sayHi() {  
    4.   
  
  
  
  4.  try {  
    5.   
  
  
  
  5.  Thread.currentThread().sleep(30);  
    6.   
  
  
  
  6.  } catch (Exception e) {  
    7.   
  
  
  
  7.  throw new RuntimeException(e);  
    8.   
  
  
  
  8.  }  
    9.   
  
  
  
  9.  System.out.println("Hi!!");  
    10.   
  
  
  
  10.  }  
    11.   
  
  
  
  11.  @Override  
    12.   
  
  
  
  12.  public void sayBye() {  
    13.   
  
  
  
  13.  try {  
    14.   
  
  
  
  14.  Thread.currentThread().sleep(10);  
    15.   
  
  
  
  15.  } catch (Exception e) {  
    16.   
  
  
  
  16.  throw new RuntimeException(e);  
    17.   
  
  
  
  17.  }  
    18.   
  
  
  
  18.  System.out.println("Bye!!");  
    19.   
  
  
  
  19.  }  
    20.   
  
  
  
  20. } 
    21.

重头戏来了，我们需要利用InvocationHandler实现一个代理，让它去包含Person这个对象。那么再运行期实际上是执行这个代理的方法，然后代理再去执行真正的方法。所以我们得以在执行真正方法的前后做一些手脚。JDK动态代理是利用反射实现，直接看代码。

 
 
 
 
    
  
  
  
  
  1. public class DynamicProxy implements InvocationHandler {  
    2.   
  
  
  
  2.  private Object target;  
    3.   
  
  
  
  3.  public DynamicProxy(Object object) {  
    4.   
  
  
  
  4.  this.target = object;  
    5.   
  
  
  
  5.  }  
    6.   
  
  
  
  6.  @Override  
    7.   
  
  
  
  7.  public Object invoke(Object arg0, Method arg1, Object[] arg2)  
    8.   
  
  
  
  8.  throws Throwable {  
    9.   
  
  
  
  9.  MonitorSession.begin(arg1.getName());  
    10.   
  
  
  
  10.  Object obj = arg1.invoke(target, arg2);  
    11.   
  
  
  
  11.  MonitorSession.end();  
    12.   
  
  
  
  12.  return obj;  
    13.   
  
  
  
  13.  }  
    14.   
  
  
  
  14.  @SuppressWarnings("unchecked")  
    15.   
  
  
  
  15.  public  T getProxy() {  
    16.   
  
  
  
  16.  return (T) Proxy.newProxyInstance(  
    17.   
  
  
  
  17.  target.getClass().getClassLoader(),  
    18.   
  
  
  
  18.  target.getClass().getInterfaces(),  
    19.   
  
  
  
  19.  this  
    20.   
  
  
  
  20.  );  
    21.   
  
  
  
  21.  }  
    22.   
  
  
  
  22. } 
    23.

通过getProxy可以得到这个代理对象，invoke就是具体的执行方法，可以看到我们在执行每个真正的方法前后都加了Monitor。

我实现了一个工厂类来获取Person代理对象

 
 
 
 
    
  
  
  
  
  1. public class PersonProxyFactory {  
    2.   
  
  
  
  2.  public static Speakable newJdkProxy() {  
    3.   
  
  
  
  3.  // 代理PersonImpl  
    4.   
  
  
  
  4.  DynamicProxy dynamicProxy = new DynamicProxy(new PersonImpl());  
    5.   
  
  
  
  5.  Speakable proxy = dynamicProxy.getProxy();  
    6.   
  
  
  
  6.  return proxy;  
    7.   
  
  
  
  7.  }  
    8.   
  
  
  
  8. } 
    9.

具体使用

 
 
 
 
    
  
  
  
  
  1. // jdk dynamic proxy  
    2.   
  
  
  
  2. System.out.println("******** jdk dynamic proxy ******** ");  
    3.   
  
  
  
  3. Speakable jdkProxy = PersonProxyFactory.newJdkProxy();  
    4.   
  
  
  
  4. jdkProxy.sayHi();  
    5.   
  
  
  
  5. jdkProxy.sayBye(); 
    6.

输出结果:

 
 
 
 
    
  
  
  
  
  1. ******** jdk dynamic proxy ********   
    2.   
  
  
  
  2. begin monitor..  
    3.   
  
  
  
  3. Hi!!  
    4.   
  
  
  
  4. end monitor..  
    5.   
  
  
  
  5. Method: sayHi, execution time: 32 milliseconds.  
    6.   
  
  
  
  6. begin monitor..  
    7.   
  
  
  
  7. Bye!!  
    8.   
  
  
  
  8. end monitor..  
    9.   
  
  
  
  9. Method: sayBye, execution time: 22 milliseconds. 
    10.

CGLib动态代理

我们再新建一个Person来，这次不实现任何接口。

 
 
 
 
    
  
  
  
  
  1. public class Person {  
    2.   
  
  
  
  2.  public void sayHi() {  
    3.   
  
  
  
  3.  try {  
    4.   
  
  
  
  4.  Thread.currentThread().sleep(30);  
    5.   
  
  
  
  5.  } catch (Exception e) {  
    6.   
  
  
  
  6.  throw new RuntimeException(e);  
    7.   
  
  
  
  7.  }  
    8.   
  
  
  
  8.  System.out.println("Hi!!");  
    9.   
  
  
  
  9.  }  
    10.   
  
  
  
  10.  public void sayBye() {  
    11.   
  
  
  
  11.  try {  
    12.   
  
  
  
  12.  Thread.currentThread().sleep(10);  
    13.   
  
  
  
  13.  } catch (Exception e) {  
    14.   
  
  
  
  14.  throw new RuntimeException(e);  
    15.   
  
  
  
  15.  }  
    16.   
  
  
  
  16.  System.out.println("Bye!!");  
    17.   
  
  
  
  17.  }  
    18.   
  
  
  
  18. } 
    19.

如果Spring识别到所代理的类没有实现Interface，那么就会使用CGLib来创建动态代理，原理实际上成为所代理类的子类。

 
 
 
 
    
  
  
  
  
  1. public class CGLibProxy implements MethodInterceptor {  
    2.   
  
  
  
  2.  private static CGLibProxy instance = new CGLibProxy();  
    3.   
  
  
  
  3.  private CGLibProxy() {  
    4.   
  
  
  
  4.  }  
    5.   
  
  
  
  5.  public static CGLibProxy getInstance() {  
    6.   
  
  
  
  6.  return instance;  
    7.   
  
  
  
  7.  }  
    8.   
  
  
  
  8.  private Enhancer enhancer = new Enhancer();  
    9.   
  
  
  
  9.  @SuppressWarnings("unchecked")  
    10.   
  
  
  
  10.  public  T getProxy(Class clazz) {  
    11.   
  
  
  
  11.  enhancer.setSuperclass(clazz);  
    12.   
  
  
  
  12.  enhancer.setCallback(this);  
    13.   
  
  
  
  13.  return (T) enhancer.create();  
    14.   
  
  
  
  14.  }  
    15.   
  
  
  
  15.  @Override  
    16.   
  
  
  
  16.  public Object intercept(Object arg0, Method arg1, Object[] arg2,  
    17.   
  
  
  
  17.  MethodProxy arg3) throws Throwable {  
    18.   
  
  
  
  18.  MonitorSession.begin(arg1.getName());  
    19.   
  
  
  
  19.  Object obj = arg3.invokeSuper(arg0, arg2);  
    20.   
  
  
  
  20.  MonitorSession.end();  
    21.   
  
  
  
  21.  return obj;  
    22.   
  
  
  
  22.  }  
    23.   
  
  
  
  23. } 
    24.

类似的通过getProxy可以得到这个代理对象，intercept就是具体的执行方法，可以看到我们在执行每个真正的方法前后都加了Monitor。

在工厂类中增加获得Person代理类的方法,

 
 
 
 
    
  
  
  
  
  1. public static Person newCglibProxy() {  
    2.   
  
  
  
  2.  CGLibProxy cglibProxy = CGLibProxy.getInstance();  
    3.   
  
  
  
  3.  Person proxy = cglibProxy.getProxy(Person.class);  
    4.   
  
  
  
  4.  return proxy;  
    5.   
  
  
  
  5. } 
    6.

具体使用

 
 
 
 
    
  
  
  
  
  1. // cglib dynamic proxy  
    2.   
  
  
  
  2. System.out.println("******** cglib proxy ******** ");  
    3.   
  
  
  
  3. Person cglibProxy = PersonProxyFactory.newCglibProxy();  
    4.   
  
  
  
  4. cglibProxy.sayHi();  
    5.   
  
  
  
  5. cglibProxy.sayBye(); 
    6.

输出结果：

 
 
 
 
    
  
  
  
  
  1. begin monitor..Hi!!end monitor..Method: sayHi, execution time: 53 milliseconds.begin monitor..Bye!!end monitor..Method: sayBye, execution time: 14 milliseconds. 
    2.

小结

对比JDK动态代理和CGLib代理，在实际使用中发现CGLib在创建代理对象时所花费的时间却比JDK动态代理要长，实测数据

 
 
 
 
    
  
  
  
  
  1. Method: newJdkProxy, execution time: 5 milliseconds.  
    2.   
  
  
  
  2. Method: newCglibProxy, execution time: 18 milliseconds. 
    3.

所以CGLib更适合代理不需要频繁实例化的类。

在具体方法执行效率方面，理应是不通过反射的CGlib更快一些，然后测试结果并非如此，还需要高手指教。  

 
 
 
 
    
  
  
  
  
  1. JDKMethod: sayHi, execution time: 32 milliseconds.CGLibMethod: sayHi, execution time: 53 milliseconds.  
    2.

当前标题：面试官：说说你对SpringAOP的实现机制的理解！
文章转载：http://www.shufengxianlan.com/qtweb/news20/545820.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

企业建站知识

行业网站建设

云服务器　　 　雷运建站　　 　香港服务器空间　　 　东电技服　　 　商城网站　　 　绵阳托管服务器　　 　绵阳网站制作公司　　 　网站开发　　 　成都移动服务器托管　　 　温江网站建设　　 　成都广告招牌制作　　 　谷歌推广　　 　成都服务器托管　　 　成都响应式网站建设公司　　 　成都虚拟主机　　 　成都康明斯发电机　　 　成都搬家公司　　 　成都网站建设公司　　 　梓潼网站设计　　 　成都app开发