SpringBoot 初步实现AOP功能

首先我们要了解一下什么是AOP

AOP就是将重复，多次利用的业务从代码中抽离出来，然后整合成一个切面，可以用在各个方法总具体内容CSDN其他博客上也有，在这里我就不在进行过多讲解，这里我们就看看是如何实现的

首先我们用的是SpringBoot，需要导入相关的依赖

 <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aspects</artifactId>
            <version>4.3.7.RELEASE</version>
        </dependency>

 其次我们就创建一个简单的测试业务，先创建一个测试service

package project.services;

import org.springframework.stereotype.Service;

@Service
public class proxyService implements project.dao.proxyService {

    @Override
    public void method1() {
        System.out.println("方法一");
    }

    @Override
    public void method2() {
        System.out.println("方法二");
    }

    @Override
    public void method3() {
        System.out.println("方法三");
    }


}

然后我们再创建一个切面，实现具体的业务逻辑（这里就简单的测试 一下）

package project.AOPutils;

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

@EnableAspectJAutoProxy
@Component
@Aspect
public class LogAspect {


    /**
     * define point cut.切入点
     */
    @Pointcut("execution(* project.services.*.*(..))")
    private void pointCutMethod() {
    }


    /**
     * 环绕通知.
     *
     * @param pjp pjp
     * @return obj
     * @throws Throwable exception
     */
    @Around("pointCutMethod()")
    public Object doAround(ProceedingJoinPoint pjp) throws Throwable {
        System.out.println("-----------------------");
        System.out.println("环绕通知: 进入方法");
        Object o = pjp.proceed();
        System.out.println("环绕通知: 退出方法");
        return o;
    }

    /**
     * 前置通知.
     */
    @Before("pointCutMethod()")
    public void doBefore() {
        System.out.println("前置通知");
    }


    /**
     * 后置通知.
     *
     * @param result return val
     */
    @AfterReturning(pointcut = "pointCutMethod()", returning = "result")
    public void doAfterReturning(String result) {
        System.out.println("后置通知, 返回值: " + result);
    }

    /**
     * 异常通知.
     *
     * @param e exception
     */
    @AfterThrowing(pointcut = "pointCutMethod()", throwing = "e")
    public void doAfterThrowing(Exception e) {
        System.out.println("异常通知, 异常: " + e.getMessage());
    }

    /**
     * 最终通知.
     */
    @After("pointCutMethod()")
    public void doAfter() {
        System.out.println("最终通知");
    }
}

这里需要注意一下，@Pointcut是指你要增强方法的具体位置，里面的方法可以不用写，具体是写了也没有用，反正博主是没有测试出来

@RestController
public class webController {
    @Autowired
    project.services.proxyService proxyService;
@RequestMapping("/hello")

public String hello(){
       proxyService.method1();
    return "index.html";

}

这里再写一个简单的Controller测试一下

具体结果如下

这里博主再提一下 AOP是通过动态代理模式实现的，而动态代理模式又是通过反射来实现，感兴趣的朋友可以多去了解一下