AOP--Aspect Oriented Programming

    <context:component-scan base-package="com.neuedu.aop.mathtest"/> <!-- 扫描包的代码 -->
    <aop:aspectj-autoproxy/>   <!-- 开启注解aop功能  -->

        @Aspect//表示这是一个切面类
        @Component//加入IOC容器
        public class LogAspect {}

  @Aspect//表示这是一个切面类
        @Component//将本类对象加入到IOC容器中！ 
        public class LogAspect {
            @Before(value="execution(public int com.neuedu.aop.target.MathCalculatorImpl.add(int, int))")
            public void showBeginLog(){
                System.out.println("AOP日志开始");
            }
            @After(value="execution(public int com.neuedu.aop.target.MathCalculatorImpl.add(int, int))")
            public void showReturnLog(){
                System.out.println("AOP方法返回");
            }
            @AfterThrowing(value="execution(public int com.neuedu.aop.target.MathCalculatorImpl.add(int, int))")
            public void showExceptionLog(){
                System.out.println("AOP方法异常");
            }
            @AfterReturning(value="execution(public int com.neuedu.aop.target.MathCalculatorImpl.add(int, int))")
            public void showAfterLog(){
                System.out.println("AOP方法结束");
            }
        }

 @Component//加入IOC容器
        public class MathCalculatorImpl {
 
            public int add(int i,int j){
                int result = i+j;
                return result;
            }
            public int sub(int i,int j){
                int result = i-j;
                return result;
            }
            public int multi(int i,int j){
                int result = i*j;
                return result;
            }
            public int divide(int i,int j){
                int result = i/j;
                return result;
            }
        }

     @Pointcut(value= "execution(public int com.atguigu.aop.target.EazyImpl.add(int,int))")
     public void myPointCut(){}
     //调用上面的函数，就可以代替重复的很多代码
@AfterReturning (value="myPointCut()", returning= "result")

 @AfterReturning (value="myPointCut()", returning= "result")

showReturnLog(JoinPoint joinPoint, Object result)

 @AfterThrowing (value="myPointCut()",throwing= "throwable" )

showExceptinLog(JoinPoint joinPoint, Throwable throwable)

     @Around(value="pointCut()")
        public void around(ProceedingJoinPoint joinPoint){
        }

     @Around(value="pointCut()")
        public Object around(ProceedingJoinPoint joinPoint){
            Object[] args = joinPoint.getArgs();
            Signature signature = joinPoint.getSignature();
            String methodName = signature.getName();
            List<Object> list = Arrays.asList(args);
            Object result = null;
            try {
                //目标方法之前要执行的操作
                System.out.println("[环绕日志]"+methodName+"开始了，参数为:"+list);
                //调用目标方法
                result = joinPoint.proceed(args);
 
                //目标方法正常执行之后的操作
                System.out.println("[环绕日志]"+methodName+"返回了，返回值为:"+result);
            } catch (Throwable e) {
                //目标方法抛出异常信息之后的操作
                System.out.println("[环绕日志]"+methodName+"出异常了，异常对象为:"+e);
                throw new RuntimeException(e.getMessage());
            }finally{
                //方法最终结束时执行的操作！
                System.out.println("[环绕日志]"+methodName+"结束了!");
            }
            return result;
        }
 

   @Aspect
        @Component
        @Order(value=40)
        public class TxAspect {
            @Around(value="execution(public * com.neuedu.aop.target.MathCalculatorImpl.*(..))")
            public Object around(ProceedingJoinPoint joinPoint){
                Object[] args = joinPoint.getArgs();
                Signature signature = joinPoint.getSignature();
                String methodName = signature.getName();
                List<Object> list = Arrays.asList(args);
                Object result = null;
                try {
                    //目标方法之前要执行的操作
                    System.out.println("[事务日志]"+methodName+"开始了，参数为:"+list);
                    //调用目标方法
                    result = joinPoint.proceed(args);
 
                    //目标方法正常执行之后的操作
                    System.out.println("[事务日志]"+methodName+"返回了，返回值为:"+result);
                } catch (Throwable e) {
                    //目标方法抛出异常信息之后的操作
                    System.out.println("[事务日志]"+methodName+"出异常了，异常对象为:"+e);
                    throw new RuntimeException(e.getMessage());
                }finally{
                    //方法最终结束时执行的操作！
                    System.out.println("[事务日志]"+methodName+"结束了!");
                }
                return result;
            }
        }

<!-- 1.将需要加载到IOC容器中的bean配置好 -->
    <bean id="logAspect" class="com.neuedu.aop.proxy.LogAspect"></bean>
    <bean id="txAspect" class="com.neuedu.aop.target.TxAspect"></bean>
    <bean id="calculator" class="com.neuedu.aop.target.MathCalculatorImpl"></bean>
 
    <!-- 2.配置AOP,需要导入AOP名称空间 -->
    <aop:config>
       <!-- 声明切入点表达式 -->
       <aop:pointcut expression="execution(* com.neuedu.aop.target.MathCalculatorImpl.*(..))" id="myPointCut"/>
       <!-- 配置日志切面类,引用前面的类 ,通过order属性控制优先级-->
       <aop:aspect ref="logAspect" order="25">
               <!-- 通过method属性指定切面类的切面方法，通过pointcut-ref指定切入点表达式 -->
               <aop:before method="showBeginLog" pointcut-ref="myPointCut"/>
               <aop:after method="showAfterLog" pointcut-ref="myPointCut"/>
               <aop:after-throwing method="showExceptionLog" pointcut-ref="myPointCut" throwing="ex"/>
               <aop:after-returning method="showReturnLog" pointcut-ref="myPointCut" returning="result"/>
               <aop:around method="around" pointcut-ref="myPointCut"/>
       </aop:aspect>
 
              <!-- 配置事务切面类,引用前面的类 -->
       <aop:aspect ref="txAspect" order="20">
               <aop:around method="around" pointcut-ref="myPointCut"/>
       </aop:aspect>
    </aop:config>