基于注解的 AOP 配置

第一步：在 spring 配置文件中开启 spring 对注解 AOP 的支持

  <!-- 开启 spring 对注解 AOP 的支持 -->
  <aop:aspectj-autoproxy> <aop:aspectj-autoproxy />

第二步：在配置文件中指定 spring 要扫描的包

  <!-- 告知 spring，在创建容器时要扫描的包 -->
  <context:component-scan base-package="com.itheima"></context:component-scan>

第三步：把通知类也使用注解配置

/**
 * 事务控制类
 * @author
 * @Company
 */
  @Component("txManager")
  public class TransactionManager {
   //定义一个 DBAssit
  @Autowired
  private DBAssit dbAssit ;
 }

第四步：在通知类上使用@Aspect 注解声明为切面

第五步：在增强的方法上使用注解配置通知

第六步：在增强的方法上使用注解配置通知

  @Before
   作用：   把当前方法看成是前置通知。
   属性：   value：用于指定切入点表达式，还可以指定切入点表达式的引用。

   //开启事务
   @Before("execution(* com.itheima.service.impl.*.*(..))")
   public void beginTransaction() {
        try {
              dbAssit.getCurrentConnection().setAutoCommit(false);
        } catch (SQLException e) {
              e.printStackTrace();
        }
  }

  说明：@AfterReturning 、@AfterThrowing 、@After 运用方式同理

  @Around
        作用：  把当前方法看成是环绕通知。
        属性：
              value：用于指定切入点表达式，还可以指定切入点表达式的引用。 

   /**
    * 环绕通知
    * @param pjp
    * @return
    */
   @Around("execution(* com.itheima.service.impl.*.*(..))")
   public Object transactionAround(ProceedingJoinPoint pjp) {
        //定义返回值   Object rtValue = null;
        try {
           //获取方法执行所需的参数
           Object[] args = pjp.getArgs(); 

           //前置通知：开启事务
           beginTransaction(); 

           //执行方法
           rtValue = pjp.proceed(args);
          //后置通知：提交事务
              commit();
          }catch(Throwable e) {
           //异常通知：回滚事务
            rollback();
            e.printStackTrace();
         }finally {
         //最终通知：释放资源
              release();
         }
         return rtValue;
        }

第七步：切入点表达式注解

  @Pointcut
        作用：  指定切入点表达式 属性：
        value：指定表达式的内容

   @Pointcut("execution(* com.itheima.service.impl.*.*(..))")
   private void pt1() {} 

  引用方式：  

  /**
   * 环绕通知
   * @param pjp
   * @return
   */
   @Around("pt1()")//注意：千万别忘了写括号
  public Object transactionAround(ProceedingJoinPoint pjp) {
        //定义返回值
        Object rtValue = null;
        try {
           //获取方法执行所需的参数
              Object[] args = pjp.getArgs();
           //前置通知：开启事务
              beginTransaction();
           //执行方法
              rtValue = pjp.proceed(args);
           //后置通知：提交事务
              commit();
        }catch(Throwable e) {
           //异常通知：回滚事务
              rollback();
              e.printStackTrace();
        }finally {
           //最终通知：释放资源
           release();
        }
           return rtValue;
         }

第八步：不使用 XML的配置方

        @Configuration
        @ComponentScan(basePackages="com.itheima")
        @EnableAspectJAutoProxy //开启注解式AOP支持----><aop:aspectj-autoproxy> <aop:aspectj-autoproxy />
        public class SpringConfiguration { }

例子：

  @Component(value = "txManager")
  @Aspect //切面类
  public class TransactionManager {

            @Autowired
            private ConnectionUtils connectionUtils;

            @Pointcut("execution(* com.atguigu.account.service.impl.*.*(..))")
            public void pt1(){}

            /**
             * 开启事物
             */

            public void beginTransaction(){
                  System.out.println("beginTransaction...开启事物......!");
                  try {
                        connectionUtils.getThreadConnection().setAutoCommit(false);
                  } catch (Exception e) {
                         e.printStackTrace();
                 }
            }

            /**
             *提交事务
             */

            public void commit(){
                  System.out.println("commit....提交事务......!");
                  try {
                          connectionUtils.getThreadConnection().commit();
                  } catch (Exception e) {
                          e.printStackTrace();
                  }
            }

            /**
             *回滚事物
             */

          public void rollback(){
               System.out.println("rollback....回滚......!");
              try {
                    connectionUtils.getThreadConnection().rollback();
              } catch (Exception e) {
                    e.printStackTrace();
              }
          }

         /**
          *释放连接
          */

            public void release(){
                    System.out.println("release....释放.....!");
                    try {
                          connectionUtils.getThreadConnection().close();//还回连接池中
                          connectionUtils.removeConnection();
                    } catch (Exception e) {
                          e.printStackTrace();
                    }
           }

            @Around("pt1()")
            public Object aroundAdvice(ProceedingJoinPoint pjp){
                     Object rtValue = null;
                try {
                    //1.获取参数
                    Object[] args = pjp.getArgs();
                    //2.开启事务
                    this.beginTransaction();
                    //3.执行方法
                    rtValue = pjp.proceed(args);
                    //4.提交事务
                    this.commit();

                    //返回结果
                    return  rtValue;

                }catch (Throwable e){
                    //5.回滚事务
                    this.rollback();
                    throw new RuntimeException(e);
                }finally {
                    //6.释放资源
                    this.release();
                }
            }
        }