spring boot面向切面编程aop

news2024/10/6 16:26:37

一、什么是AOP

AOP，Aspect Oriented Programming，面向切面编程

举个例子来理解
如果我们的业务需要额外做三件事情，判断是否已经登录，记录日志，统计业务执行时长

传统的做法是这样子的：
在这里插入图片描述
而apo的实现是这样的：

区别在于：
原本的做法是，需要什么功能，就调用什么功能的方法，需要我们主动去调用

aop的做法是，需要什么功能，就把业务交给相应的代理人，由代理人帮我们去完成，是被动完成的

aop做法的好处是：
1、代码解耦
把不相关的功能都抽取出来，需要使用哪个功能就把业务交给专业的代理人，由代理人去完成。需要新功能的时候，直接添加新的代理业务，这样不会对其它的业务造成影响

2、提高开发效率
当需要使用某个功能时，我们不需要关心代理是怎么做的，只需要简单地使用就好了，就像事务注解@Transactional，只要添加了该注解，方法就会代理，获得了事务的功能，简化了开发

二、AOP的实现示例

Logger 注解：

package com.aop.annotation;

import java.lang.annotation.*;

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Logger {
}

Logger 注解代理类：

package com.aop.aop;

import com.aop.annotation.Logger;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;

/**
 * LoggerAop代理类
 */
@Component
@Aspect
public class LoggerAop {

    @Around(value = "@annotation(logger)")
    public Object around(ProceedingJoinPoint pjp, Logger logger) throws Throwable {
        System.out.println("开始记录日志");
        Object proceed = pjp.proceed();
        return proceed;
    }
}

Loggin 注解：

package com.aop.annotation;

import java.lang.annotation.*;

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Login {
    boolean login() default true;
}

Loggin 注解代理类：

package com.aop.aop;

import com.aop.annotation.Login;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;


/**
 * LoginAop代理类
 */
@Component
@Aspect
public class LoginAop {


    @Around("@annotation(login)")
    public Object around(ProceedingJoinPoint pjp, Login login) throws Throwable {
        System.out.println("开始判断登录");
        if(login.login()){
            System.out.println("已经登录，可执行方法");
            Object proceed = pjp.proceed();
            return proceed;
        }else{
            System.out.println("未登录，不执行方法");
            return "请先登录！";
        }
    }
}

Time注解：

package com.aop.annotation;

import java.lang.annotation.*;

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Time {
}

Time注解代理类：

package com.aop.aop;


import com.aop.annotation.Time;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;

import java.util.Date;


/**
 * TimeAop代理类
 */
@Component
@Aspect
public class TimeAop {

    @Around("@annotation(time)")
    public Object around(ProceedingJoinPoint pjp, Time time) throws Throwable {
        long time1 = new Date().getTime();
        Object proceed = pjp.proceed();
        long time2 = new Date().getTime();
        System.out.println("运行了"+((Double.valueOf(time2)-time1)/1000) + "秒");
        return proceed;
    }

}

测试controller类：

package com.aop.controller;


import com.aop.annotation.Logger;
import com.aop.annotation.Login;
import com.aop.annotation.Time;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * RestController,即Controller+ResponseBody,将返回结果转为json字符串响应到客户端
 */
@RestController
public class HelloController {

    /**
     * Logger,打印日志
     * Login,判断登录
     * Time,记录运行时间
     * RequestMapping,请求路径
     *
     */
    @Logger
    @Login
    @Time
    @RequestMapping("/hello")
    public String hello() throws InterruptedException {
        /**
         * sleep,模拟业务时间
         */
        Thread.sleep(500);
        System.out.println("hello");
        return "hello";
    }
}

启动类：

package com.aop;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class AopApplication {

    public static void main(String[] args) {
        SpringApplication.run(AopApplication.class, args);
    }

}