Spring笔记：AOP面向切面编程

AOP（Aspect Oriented Programming）面向切面编程，是通过预编译和运行期间动态代理的方式实现程序功能的一种技术。Spring中常用的AOP实现方式有三种：Spring原生API、自定义类和注解。我先把不同实现方式的示例中共用的代码贴出来。

切入点，即要测试的接口和类：

package com.yun.service;

public interface UserService {
    public void add();
    public void delete();
    public void update();
    public void query();
}

package com.yun.service;

public class UserServiceImpl implements UserService{
    public void add() {
        System.out.println("Add a user.");
    }

    public void delete() {
        System.out.println("Delete a user.");
    }

    public void update() {
        System.out.println("Update a user.");
    }

    public void query() {
        System.out.println("Query a user.");
    }
}

测试类：

import com.yun.service.UserService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MyTest {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        // 注意，由于Spring AOP的实现原理是动态代理，所以这里的对象类型必须指定为对应的接口，而不是具体的实现类
        UserService userService = (UserService)context.getBean("userService");
        userService.add();
    }
}

1. AOP实现方式一：Spring原生API

使用Spring原生API的方式就需要实现特定的接口，具体接口见示例。

在需要切入的方法之前执行的操作：

package com.yun.log;

import org.springframework.aop.MethodBeforeAdvice;

import java.lang.reflect.Method;

public class BeforeLog implements MethodBeforeAdvice {
    // method: 目标对象中要执行的方法
    // args: 执行方法对应的参数
    // target: 要执行的目标对象
    // 此方法表示在目标对象target的method方法之前执行
    public void before(Method method, Object[] args, Object target) throws Throwable {
        System.out.println("before：" + target.getClass().getName() + "." + method.getName());
    }
}

在需要切入的方法之后执行的操作：

package com.yun.log;

import org.springframework.aop.AfterReturningAdvice;

import java.lang.reflect.Method;

public class AfterReturnLog implements AfterReturningAdvice {
    // 此方法表示在目标对象target的method方法之后执行，这个方法可以拿到method方法的返回值
    public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
        System.out.println(target.getClass().getName() + "." + method.getName() + "的返回结果为：" + returnValue);
    }
}

xml配置：为了使用Spring AOP，需要添加额外的扩展：

• xmlns:aop="http://www.springframework.org/schema/aop"
• http://www.springframework.org/schema/aop
• https://www.springframework.org/schema/aop/spring-aop.xsd

<?xml version="1.0" encoding="UTF-8"?>


    
    
    
    

    
    
        
        
        
        
        
    

输出：

before：com.yun.service.UserServiceImpl.add
Add a user.
com.yun.service.UserServiceImpl.add的返回结果为：null

2. AOP实现方式二：自定义类实现AOP

自定义类的方式可以指定自定义的类中哪些方法在“前”执行，哪些方法在“后”执行。

自定义类：

package com.yun.custom;

public class MyPointCut {
    public void before(){
        System.out.println("--------before-------");
    }

    public void after(){
        System.out.println("--------after-------");
    }
}

xml配置：

<?xml version="1.0" encoding="UTF-8"?>


    
    
    
    
    
    
        
        
            
            
            
            
            
            
        
    

输出：

--------before-------
Add a user.
--------after-------

3. AOP实现方式三：注解

注解的方式更加直观明了，而且同样会使用execution表达式，但是请注意，需要在xml中声明aop自动代理支持。

注解使用：

package com.yun.annotation;

import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;

// 指定切面
@Aspect
public class AnnotationPointcut {
    // 在切入点之前执行，参数为execution表达式
    @Before("execution(* com.yun.service.UserServiceImpl.*(..))")
    public void before(){
        System.out.println("--------before-------");
    }

    // 在切入点之后执行，参数为execution表达式
    @After("execution(* com.yun.service.UserServiceImpl.*(..))")
    public void after(){
        System.out.println("--------after-------");
    }
}

xml配置：特别注意，需要声明使用aop自动代理。

<?xml version="1.0" encoding="UTF-8"?>


    
    
    
    
    

输出：

--------before-------
Add a user.
--------after-------