本篇紧接着spring入门详细教程（二），建议阅读本篇前，先阅读第一篇和第二篇。链接如下：

Spring入门详细教程（一） https://www.cnblogs.com/jichi/p/10165538.html

Spring入门详细教程（二） https://www.cnblogs.com/jichi/p/10176601.html

本篇主要讲解spring的aop相关。

在软件业，AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。AOP是可以通过预编译方式和运行期动态代理实现在不修改源代码的情况下给程序动态统一添加功能的一种技术。

AOP主要实现功能日志记录，性能统计，安全控制，事务处理，异常处理等等。将日志记录，性能统计，安全控制，事务处理，异常处理等代码从业务逻辑代码中划分出来，通过对这些行为的分离，我们希望可以将它们独立到非指导业务逻辑的方法中，进而改变这些行为的时候不影响业务逻辑的代码。

AOP主要思想总结为横向重复，纵向抽取。

spring实现aop的底层使用了两种代理机制。一种是jdk的动态代理，一种是cglib的动态代理。下面来分析一下两种代理模式。

1、jdk的动态代理

被代理对象必须要实现接口才能产生代理对象，如果被代理对象不能实现接口，则这种方式的动态代理技术无效。

接下来做一个底层代码的编写来进行理解。

（1）首先jdk的动态代理要求被代理对象必须实现接口。我们准备一个接口以及一个接口的实现类。

  1. public interface UserDao {
  2.     public void saveUser();
  3. }
  1. public class UserDaoImpl implements UserDao {
  2.     public void saveUser(){
  3.         System.out.println("保存用户");
  4.     }
  5. }

（2）建立一个UserDao的动态代理类，实现接口InvocationHandler。

  1. public class UserProxy implements InvocationHandler{
  2.     private UserDao userDao ;
  3.     
  4.     public UserProxy(UserDao userDao) {
  5.         this.userDao = userDao;
  6.     }
  8.     public UserDao createProxy(){
  9.         UserDao userDaoProxy = (UserDao) Proxy.newProxyInstance(userDao.getClass().getClassLoader(),userDao.getClass().getInterfaces(), this);
  10.         return userDaoProxy;
  11.     }
  12.     
  13.     @Override
  14.     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  15.         System.out.println("动态代理");
  16.         return method.invoke(userDao, args);
  17.     }
  19. }

（3）进行单元测试，发现第一个方法执行的时候没有被动态代理，第二个执行的时候进行了动态代理。

  1. @RunWith(SpringJUnit4ClassRunner.class)
  2. @ContextConfiguration("classpath:applicationContext.xml")
  3. public class TestJunit {
  4.     @Test
  5.     public void test3(){
  6.         UserDaoImpl userDaoImpl = new UserDaoImpl();
  7.         userDaoImpl.saveUser();
  8.         UserProxy userProxy = new UserProxy(userDaoImpl);
  9.         UserDao createProxy = userProxy.createProxy();
  10.         createProxy.saveUser();
  11.     }
  12. }

2、cglib动态代理

针对一些不能实现接口的代理对象产生代理，可以对没有被final修饰的任何对象进行继承代理，其底层应用的是字节码增强的技术，生成代理对象的子类对象。如果被final修饰，类不可继承，便不可使用cglib动态代理。

（1）创建一个cglib动态代理对象实现接口。

  1. public class CglibProxy implements MethodInterceptor{
  3.     private UserDaoImpl userDaoImpl;
  4.     
  5.     public CglibProxy(UserDaoImpl userDaoImpl) {
  6.         this.userDaoImpl = userDaoImpl;
  7.     }
  8.     
  9.     public UserDaoImpl createProxy(){
  10.         Enhancer enhancer = new Enhancer();
  11.         enhancer.setSuperclass(UserDaoImpl.class);
  12.         enhancer.setCallback(this);
  13.         UserDaoImpl udi = (UserDaoImpl) enhancer.create();
  14.         return udi;
  15.     }
  16.     
  17.     @Override
  18.     public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
  19.         Object obj = methodProxy.invokeSuper(proxy, args);
  20.         System.out.println("动态代理");
  21.         return obj;
  22.     }
  24. }

（2）进行单元测试。

  1.     public void test4(){
  2.         UserDaoImpl userDaoImpl = new UserDaoImpl();
  3.         userDaoImpl.saveUser();
  4.         CglibProxy cglib = new CglibProxy(userDaoImpl);
  5.         UserDaoImpl userDaoImpl2 = cglib.createProxy();
  6.         userDaoImpl2.saveUser();
  7.     }

可以发现第一个saveUser没有执行动态代理，第二个执行了动态代理。

结论：两种代理技术针对不同情况，互相弥补，从而使任何对象都可以实现动态代理。spring在进行aop的时候，默认使用jdk的动态代理技术，当发现jdk的动态代理技术不好使的情况下，使用cglib动态代理技术，保证被代理对象能够被正常代理。如需使用cglib动态代理可以再spring的配置文件中进行配置。

  1. <aop:config proxy-target-class="true">

1、Joinpoint（连接点）：目标对象中，所有可以增强的方法。

2、Pointcut（切入点）：目标对象中，已经增强的方法。

3、Advice（通知）：对于目标对象来说，需要给目标对象增强的方法。

4、Target（目标对象）：被代理对象。

5、Weaving（织入）：将通知应用到切入点的过程。

6、Proxy（代理）：将通知织入到目标对象后，形成的增强后的对象。

7、Aspect（切面）：切入点和通知的结合。

分两种方式介绍，一种是xml配置方式，一种是注解方式。

1、xml配置方式

（1）实现spring的aop需要导入aop包，aspect包，aopalliance包，weaver包。在spring教程一中可以找到获取这些包的方法。

（2）编写需要增加的方法类。

  1. public class UserDaoImpl{
  2.     
  3.     public void saveUser(){
  4.         System.out.println("保存用户");
  5.     }
  6.     public void deleteUser(){
  7.         System.out.println("删除用户");
  8.     }
  9. }

（3）编写通知，也就是说想要增加的代码方法。

  1. public class UserAdvice{
  2.     
  3.     public void before(){
  4.         System.out.println("前置通知");
  5.     }
  6.     
  7.     public void afterReturning(){
  8.         System.out.println("后置通知（不发生异常的情况下调用）");
  9.     }
  11.     public Object around(ProceedingJoinPoint pjp) throws Throwable{
  12.         System.out.println("执行前");
  13.         Object proceed = pjp.proceed();
  14.         System.out.println("执行后");
  15.         return proceed;
  16.     }
  17.     
  18.     public void afterThrowException(){
  19.         System.out.println("发生异常调用");
  20.     }
  21.     
  22.     public void after(){
  23.         System.out.println("后置通知，发生异常也会调用");
  24.     }
  25. }

（4）在spring的配置文件中进行配置

  1.     <bean name = "userDaoImpl" class="com.jichi.aop.UserDaoImpl"></bean>
  2.     <bean name="userAdvice" class="com.jichi.aop.UserAdvice"></bean>
  3.     <aop:config>
  4.         <aop:pointcut expression="execution(* com.jichi.aop..UserDaoImpl.*(..))" id="pc"/>
  5.         <aop:aspect ref="userAdvice">
  6.             <aop:before method="before" pointcut-ref="pc"/>
  7.             <aop:after-returning method="afterReturning" pointcut-ref="pc"/>
  8.             <aop:around method="around" pointcut-ref="pc"/>
  9.             <aop:after-throwing method="afterThrowException" pointcut-ref="pc"/>
  10.             <aop:after method="after" pointcut-ref="pc"/>
  11.         </aop:aspect>
  12.     </aop:config>

（5）进行单元测试

  1. @RunWith(SpringJUnit4ClassRunner.class)
  2. @ContextConfiguration("classpath:applicationContext.xml")
  3. public class TestAop {
  5.     @Resource
  6.     private UserDaoImpl userDaoImpl;
  7.     
  8.     @Test
  9.     public void test1(){
  10.         userDaoImpl.saveUser();
  11.     }
  12. }

结果如下：织入成功。

2、注解配置方式

（1）同第一种方式需要导入包

（2）编写需要增加的方法类。

  1. public class UserDaoImpl{
  2.     
  3.     public void saveUser(){
  4.         System.out.println("保存用户");
  5.     }
  6.     public void deleteUser(){
  7.         System.out.println("删除用户");
  8.     }
  9. }

（3）编写通知，也就是说想要增加的代码方法。

  1. public class UserAdvice{
  2.     
  3.     public void before(){
  4.         System.out.println("前置通知");
  5.     }
  6.     
  7.     public void afterReturning(){
  8.         System.out.println("后置通知（不发生异常的情况下调用）");
  9.     }
  11.     public Object around(ProceedingJoinPoint pjp) throws Throwable{
  12.         System.out.println("执行前");
  13.         Object proceed = pjp.proceed();
  14.         System.out.println("执行后");
  15.         return proceed;
  16.     }
  17.     
  18.     public void afterThrowException(){
  19.         System.out.println("发生异常调用");
  20.     }
  21.     
  22.     public void after(){
  23.         System.out.println("后置通知，发生异常也会调用");
  24.     }
  25. }

（4）在spring配置文件中进行配置，并开启注解aop

  1.     <bean name = "userDaoImpl" class="com.jichi.aop.UserDaoImpl"></bean>
  2.     <bean name="userAdvice" class="com.jichi.aop.UserAdvice"></bean>
  3.     <aop:aspectj-autoproxy></aop:aspectj-autoproxy>

（5）在通知类上打上aspect的注解。在方法上打上相应注解

  1. @Aspect
  2. public class UserAdvice{
  3.     
  4.     @Before("execution(* com.jichi.aop..UserDaoImpl.*(..))")
  5.     public void before(){
  6.         System.out.println("前置通知");
  7.     }
  8.     
  9.     @AfterReturning("execution(* com.jichi.aop..UserDaoImpl.*(..))")
  10.     public void afterReturning(){
  11.         System.out.println("后置通知（不发生异常的情况下调用）");
  12.     }
  14.     @Around("execution(* com.jichi.aop..UserDaoImpl.*(..))")
  15.     public Object around(ProceedingJoinPoint pjp) throws Throwable{
  16.         System.out.println("执行前");
  17.         Object proceed = pjp.proceed();
  18.         System.out.println("执行后");
  19.         return proceed;
  20.     }
  21.     
  22.     @AfterThrowing("execution(* com.jichi.aop..UserDaoImpl.*(..))")
  23.     public void afterThrowException(){
  24.         System.out.println("发生异常调用");
  25.     }
  26.     
  27.     @After("execution(* com.jichi.aop..UserDaoImpl.*(..))")
  28.     public void after(){
  29.         System.out.println("后置通知，发生异常也会调用");
  30.     }
  31. }

优化方式：每个方法都配置方法抽取，显得比较臃肿，可以进行提取，方法如下

  1. @Aspect
  2. public class UserAdvice{
  3.     
  4.     @Pointcut("execution(* com.jichi.aop..UserDaoImpl.*(..))")
  5.     public void adc(){}
  6.     
  7.     @Before("UserAdvice.adc()")
  8.     public void before(){
  9.         System.out.println("前置通知");
  10.     }
  11.     
  12.     @AfterReturning("UserAdvice.adc()")
  13.     public void afterReturning(){
  14.         System.out.println("后置通知（不发生异常的情况下调用）");
  15.     }
  17.     @Around("UserAdvice.adc()")
  18.     public Object around(ProceedingJoinPoint pjp) throws Throwable{
  19.         System.out.println("执行前");
  20.         Object proceed = pjp.proceed();
  21.         System.out.println("执行后");
  22.         return proceed;
  23.     }
  24.     
  25.     @AfterThrowing("UserAdvice.adc()")
  26.     public void afterThrowException(){
  27.         System.out.println("发生异常调用");
  28.     }
  29.     
  30.     @After("UserAdvice.adc()")
  31.     public void after(){
  32.         System.out.println("后置通知，发生异常也会调用");
  33.     }
  34. }

 

版权声明：本文为jichi原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://www.cnblogs.com/jichi/p/10177004.html