切面类中增加方法afterThrowing和after

    /**
     * 抛出异常后通知
     * @param jp   连接点
     * @param e   异常
     */
    public void afterThrowing(JoinPoint jp,Throwable e){
        System.out.println("抛出异常通知....."+jp.getSignature().getName()+e.getMessage());
    }


    public void after(JoinPoint jp){
        System.out.println("最终通知......"+jp.getSignature().getName());
    }

配置xml

 <!--配置aop-->
    <aop:config>
        <!--指定切面-->
        <aop:aspect ref="aspect">
            <!--指定切入点-->
            <aop:pointcut id="poincut1" expression="execution(* com.xzy.service.UserSeviceImpl.*(..))"/>
       
            <!--环绕通知-->
            <aop:around method="around" pointcut-ref="poincut1"></aop:around>

            <!--异常通知:当目标方法发生异常后会执行 -->
          <aop:after-throwing method="afterThrowing" pointcut-ref="poincut1" throwing="e"/>

           <!--最终通知:无论方法有没有发生异常，都会执行-->
           <aop:after method="after" pointcut-ref="poincut1"/>

    </aop:config>

并在deleteUser方法中主动抛出异常：

    @Override
    public int deleteUser(int id) {
        System.out.println("删除了id为" + id + "的用户");
        throw  new RuntimeException(new Exception("自定义异常...."));
    }

测试结果如下：

如果去掉异常的测试结果如下：

2、基于Annotation配置AOP

既然使用注解配置，那就全部用注解，包括配置文件都用注解+Java类来实现 * 编写配置类Appconfig.java替代xml文件

package com.xzy;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

@Configuration       //告诉spring这是配置文件
@EnableAspectJAutoProxy   //开启aop自动代理
@ComponentScan(basePackages = {"com.xzy"})    //告诉spring去哪里扫描注解
public class AppConfig {

   //这里头以后可以写各种配置，这个类的作用就和XML文件的作用一样
}

当然这段java代码可以用下面这段XML配置文件替代

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd">
  
  <!--开启注解功能-->
  <context:annotation-config/> 
  <!--告诉Spring去哪里扫描注解-->
  <context:component-scan base-package="com.xzy"></context:component-scan>
  <!--配置aop自动代理-->
  <aop:aspectj-autoproxy/>
     
</beans>

编写一个日志记录的切面类LoggerApsect.java 在切面类中可以使用如下几个注解来定制一个切面：

• @Aspect：告诉Spring这是切面类
• @Brfore：前置通知
• @AfterRuning：返回后通知
• @Around：环绕通知，是@Brfore和@AfterRuning<的结合，功能十分强大
• @After-Throwing：抛出异常后的通知，没有异常不会执行
• @After：最终通知，无论有没有异常一定会执行的
• @PointCut：定义切点

package com.xzy.Aspect;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

import java.util.Date;

/**
 * 一个记录各种操作的日志切面类
 */
@Component //告诉Spring你要把这个类给我实例化了
@Aspect    //告诉Spring这是一个切面类
public class LoggerAspect {

    //声明一个公共的切点：将com.xzy.service包下的所有以Impl结尾的方法作为切入点，切入点中可以没有任何代码实现，只是让他在形式上存在即可
    @Pointcut("execution(* com.xzy.service.*Impl.*(..))")
    public void pointcut() {
    }


    @Before("execution(* com.xzy.service.*Impl.*(..))")
    public void before(JoinPoint joinPoint) {
        System.out.println("before给" + joinPoint.getSignature().getName() + "方法作前日志.........." + new Date());
    }

    @AfterReturning(pointcut = "pointcut()", returning = "retValue")
    public void afterReturning(JoinPoint joinPoint, Object retValue) {
        System.out.println("afterReturning给" + joinPoint.getSignature().getName() + "方法作后日志.........." + new Date());
        System.out.println("方法的返回值是：" + retValue);
    }

    @Around("pointcut()")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("around给" + joinPoint.getSignature().getName() + "方法作前日志.........." + new Date());
        Object retValue = joinPoint.proceed();
        System.out.println("around给" + joinPoint.getSignature().getName() + "方法作前后志.........." + new Date());
        return retValue;
    }

    @AfterThrowing(pointcut = "pointcut()", throwing = "e")
    public void afterThrowing(JoinPoint joinPoint, Throwable e) {
        System.out.println("给" + joinPoint.getSignature().getName() + "方法作异常日志：" + new Date() + "抛出" + e.getMessage());
    }

    @After("pointcut()")
    public void afterAll(JoinPoint joinPoint) {
        System.out.println("给" + joinPoint.getSignature().getName() + "方法作最终日志.........." + new Date());
    }
}

测试类如下：

package com.xzy;

import com.xzy.service.UserSeviceBase;
import org.apache.log4j.Logger;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;


@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes= {AppConfig.class})
public class AppTest {

    private static Logger log= Logger.getLogger(AppTest.class);

    @Autowired
    UserSeviceBase userSevice;

    @Test
    public void test3(){
        userSevice.deleteUser(12);
        userSevice.updateUser(34);
    }
}

测试结果:

现在去掉before、after-return以及在deleteUser中抛出一个异常：