使用注解的方式实现Spring Aop的五种增强模式

public interface StudentMapper {
    int addStudent();
    String updateStudent();
    int deleteStudent();
    void selectAllStudent();
    String selectOne();
}

import mapper.StudentMapper;
import org.springframework.stereotype.Repository;

@Repository
public class StudentMapperImpl implements StudentMapper {
    @Override
    public int addStudent() {
        System.out.println("添加学生！！！");
        return 100;
    }

    @Override
    public String updateStudent() {
        System.out.println("修改学生！！！");
        return "修改学生！";
    }

    @Override
    public int deleteStudent() {
        System.out.println("删除学生！！！");
        return 100;
    }

    @Override
    public void selectAllStudent() {
        System.out.println("查询所有学生！！！");
    }

    @Override
    public String selectOne() {
        System.out.println("查询单个学生！！！");
        return "查询单个学生！";
    }
}

public interface StudentService {
    int addStudent();
    String updateStudent();
    int deleteStudent();
    void selectAllStudent();
    String selectOne();
}

import mapper.StudentMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import service.StudentService;

@Service
public class StudentServiceImpl implements StudentService {

    @Autowired
    private StudentMapper studentMapper;

    public StudentMapper getStudentMapper() {
        return studentMapper;
    }

    public void setStudentMapper(StudentMapper studentMapper) {
        this.studentMapper = studentMapper;
    }

    @Override
    public int addStudent() {
        return studentMapper.addStudent();
    }

    @Override
    public String updateStudent() {
        return studentMapper.updateStudent();
    }

    @Override
    public int deleteStudent() {
        return studentMapper.deleteStudent();
    }

    @Override
    public void selectAllStudent() {
        studentMapper.selectAllStudent();
    }

    @Override
    public String selectOne() {
        return studentMapper.selectOne();
    }
}

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;

//增强类
@Component
@Aspect
public class LoggerAdvice {

    @Pointcut(value = "execution(* service.StudentService.addStudent(..))")
    public void addStudent(){}
    @Pointcut(value = "execution(* service.StudentService.deleteStudent(..))")
    public void deleteStudent(){}
    @Pointcut(value = "execution(* service.StudentService.updateStudent(..))")
    public void updateStudent(){}
    @Pointcut(value = "execution(* service.StudentService.selectAllStudent(..))")
    public void selectAllStudent(){}

    //前置增强
    @Before(value = "updateStudent() || deleteStudent()")
    public void before(JoinPoint jp){
        System.out.println("前置增强......");
        System.out.println("目标对象："+jp.getTarget().getClass().getName()+"的方法"+jp.getSignature().getName()+"被调用");
    }
    //后置增强，基本业务方法执行完成之后 result表示返回值
    public void afterReturning(JoinPoint jp,Object result){
        System.out.println("后置增强......");
        System.out.println("目标对象："+jp.getTarget().getClass().getName()+
                "的方法"+jp.getSignature().getName()+"被调用，返回值是："+
                result.toString());
    }
    //抛出异常增强
    public void throwing(JoinPoint jp,Throwable e){
        System.out.println("抛出异常增强......");
        System.out.println("目标对象："+jp.getTarget().getClass().getName()+
                "的方法"+jp.getSignature().getName()+"被调用，异常信息是："+
                e.getMessage());
    }
    //最终增强
    public void after(JoinPoint jp){
        System.out.println("最终增强......");
        System.out.println("目标对象："+jp.getTarget().getClass().getName()+
                "的方法"+jp.getSignature().getName()+"被调用");
    }
    //环绕增强
    public void around(ProceedingJoinPoint jp){
        try {
            //方法调用前
            System.out.println("方法调用前执行......");
            //方法被调用的时候
            Object result = (Object) jp.proceed();
            //方法调用后
            System.out.println("方法调用后......result："+result.toString());
        } catch (Throwable e) {
            System.out.println("方法发生异变......e："+e.getMessage());
            e.printStackTrace();
        } finally {
            System.out.println("方法最终执行......");
        }
    }
}

@Test
public void test3(){
    ApplicationContext atx = new
            ClassPathXmlApplicationContext("applicationContext3.xml");
    StudentService service = (StudentService) atx.getBean("studentServiceImpl");
    service.selectAllStudent();
    System.out.println();
    service.addStudent();
    System.out.println();
    service.selectOne();
    System.out.println();
    service.updateStudent();
    System.out.println();
    service.deleteStudent();
}