基于注解的 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();
                }
            }
        }