Springboot整合AOP拦截器

1、AOP（面向切面编程）是Spring提供的重要技术工具，其主要功能是对业务层的方法调用进行拦截处理。SpringBoot默认情况下并没有配置AOP拦截器，需要在项目中手动引入spring-boot-starter-aop依赖库后才可以使用。

修改pom.xml配置文件，配置spring-boot-starter-aop依赖库，如下所示：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 
    https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.5.RELEASE</version>
        <relativePath /> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.example</groupId>
    <artifactId>demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>demo</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>1.8</java.version>
        <maven-jar-plugin.version>3.1.1</maven-jar-plugin.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.hibernate/hibernate-validator -->
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-validator</artifactId>
            <version>6.1.0.Final</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-thymeleaf</artifactId>
        </dependency>
        <!-- aop -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</artifactId>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
        <resources>
            <resource>
                <directory>src/main/resources</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.yml</include>
                    <include>**/*.xml</include>
                    <include>**/*.p12</include>
                    <include>**/*.html</include>
                    <include>**/*.jpg</include>
                    <include>**/*.png</include>
                </includes>
            </resource>
        </resources>
    </build>

</project>

搞一个业务层接口，然后搞一个业务层接口实现子类。

package com.demo.service;

public interface UserService {

    public String login(String username, String password);
}

package com.demo.service.impl;

import org.springframework.stereotype.Service;

import com.demo.service.UserService;

@Service
public class UserServiceImpl implements UserService {

    @Override
    public String login(String username, String password) {
        if (username.equals("admin") && password.equals("123456")) {
            return "success!!!";
        }
        return "fail!!!";
    }

}

定义AOP程序类，对业务方法进行拦截，这里使用环绕通知处理。

package com.demo.aop;

import java.util.Arrays;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;

/**
 * 定义业务层拦截
 * 
 * @author Aiyufei
 *
 */
@Component
@Aspect
public class ServiceAspect {

    private Logger log = LoggerFactory.getLogger(ServiceAspect.class);

    /**
     * 环绕通知
     * 
     * @param point
     * @return
     * @throws Throwable
     */
    @Around("execution(* com.demo.service..*.*(..))")
    public Object arroudInvoke(ProceedingJoinPoint point) throws Throwable {
        this.log.info("the before 执行参数：  " + Arrays.toString(point.getArgs()));
        Object proceed = point.proceed(point.getArgs());
        this.log.info("the after 返回结果：" + proceed);
        return proceed;
    }

}

搞一个控制层类，如下所示：

package com.demo.controller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;

import com.demo.service.UserService;

@Controller
public class SpringBootController {

    @Autowired
    private UserService userService;

    @RequestMapping(value = "/login")
    @ResponseBody
    public String hello(@RequestParam(value = "username") String username,
            @RequestParam(value = "password") String password) {
        System.out.println("hello world!!!");
        String login = userService.login(username, password);
        return login;
    }

}

使用postman测试一下，如下所示：

由于将切入点设置在了所有的业务层上，所以在调用UserService接口方法时会自动执行AOP拦截。