AOP的那些事以及在SpringBoot的应用

最新推荐文章于 2024-08-07 09:42:34 发布

卡萨巴

最新推荐文章于 2024-08-07 09:42:34 发布

阅读量2.1k

点赞数

文章标签： aop spring

本文链接：https://blog.csdn.net/zhaoenweiex/article/details/78177481

版权

本文介绍了AOP的概念，通过三个场景解释了AOP的重要性，并探讨了其优势和典型应用场景。接着，展示了在Spring Boot中配置和使用AOP的基本流程及示例代码，深入解析了Spring AOP的原理和注意事项，帮助读者理解和掌握AOP在实际开发中的应用。

摘要由CSDN通过智能技术生成

前言

最近读了《Spring源码深度解析》这本书，感觉到Spring设计的巧妙和严谨，读到了AOP这块发现自己还有不少问题没有理解清楚，特此进行AOP相关技术的集中调研和总结，记录在此希望可以帮到大家。

什么是AOP

面向切面编程(Aspect Oriented Programming),通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。
AOP其实只是OOP的补充而已。OOP从横向上区分出一个个的类来，而AOP则从纵向上向对象中加入特定的代码。有了AOP，OOP变得立体了。如果加上时间维度，AOP使OOP由原来的二维变为三维了，由平面变成立体了
AOP对系统过程的公共行为抽取

把大象放在冰箱里的故事

比如我们做了一个项目是要求把大象放在冰箱里。

场景一

（开发把大象放到冰箱模块）
打开冰箱
把大象放到冰箱
关闭冰箱

场景二

（复用改模块并扩展到其他动物上）
把马放到冰箱里
把长颈鹿放到冰箱里
把其他大象放到冰箱里
目前已经把这个过长应用到1000多种动物

场景三

（增加需求）
为了进一步优化，需要计算每次的时间

怎么办

为每个过程单独计时？

耗时大
重复工作
错误可能性高

还可以怎么做
1.将大象放到冰箱中这个过程封装成标准的过程
2.为标准过程的开始通知开始计时
3.为标准过程的结束通知结束计时
4.输出计时结果
上面的思路就是AOP的思路
即通过一定手段将不同服务的公共的纵向处理逻辑提取出来，统一实现。

AOP的优势

避免修改业务代码
避免引入重复代码
可以对业务逻辑的各个部分进行隔离，降低逻辑的耦合度

AOP的典型应用场景

缓存
日志
安全验证
审计
性能监控
事物处理
异常处理

AOP的理论

1.横切关注点
对哪些方法进行拦截，拦截后怎么处理，这些关注点称之为横切关注点
2.切面（aspect）
类是对物体特征的抽象，切面就是对横切关注点的抽象
3.连接点（joinpoint）
被拦截到的点因为Spring只支持方法类型的连接点，所以在Spring中连接点指的就是被拦截到的方法，实际上连接点还可以是字段或者构造器
4.切入点（pointcut）
对连接点进行拦截的定义
5.通知（advice）
所谓通知指的就是指拦截到连接点之后要执行的代码，通知分为前置、后置、异常、最终、环绕通知五类
目标对象,代理的目标对象
6.织入（weave）
将切面应用到目标对象并导致代理对象创建的过程
7.引入（introduction）
在不修改代码的前提下，引入可以在运行期为类动态地添加一些方法或字段

Spring Boot中如何使用

环境

Springboot(1.5.7)
Maven依赖（3.3.9）
Intellij IDEA

基本流程

1、定义普通业务组件
2、定义切入点，一个切入点可能横切多个业务组件
3、定义增强处理，增强处理就是在AOP框架为普通业务组件织入的处理动作

示例代码

目录结构
这里写图片描述

依赖

pom.xml

<?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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.zw.se2.research</groupId>
    <artifactId>demo-aop</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>jar</packaging>

    <name>demo-aop</name>
    <description>Aop Demo project for Spring Boot</description>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.5.7.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</artifactId>
        </dependency>
        <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>
        </dependency>
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger2</artifactId>
            <version>2.2.2</version>
        </dependency>
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger-ui</artifactId>
            <version>2.2.2</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>


</project>

入口

package com.zw.se2.research;

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

@SpringBootApplication
public class DemoAopApplication {

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

Controller

package com.zw.se2.research.ctrl;

import io.swagger.annotations.ApiOperation;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * Created by zhaoenwei on 2017/10/17.
 */
@RestController
public class Controller {
    @ApiOperation(value="测试", notes="")
    @RequestMapping("/hello")
    public String sayHello(){
        return "hello aop";
    }
}

切面处理

package com.zw.se2.research.aspect;

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

import java.lang.reflect.Method;
import java.util.Date;

/**
 * Created by zhaoenwei on 2017/10/17.
 */
@Aspect
@Component
public class CtrlAspect {
    private static final Logger logger= LoggerFactory.getLogger(CtrlAspect.class);

    @Pointcut("execution(* com.zw.se2.research.ctrl..*.*(..)) && @annotation(org.springframework.web.bind.annotation.RequestMapping)")
    public void controllerMethodPointcut(){}

    @Around("controllerMethodPointcut()")
    public void Interceptor(ProceedingJoinPoint pjp){
        long beginTime = System.currentTimeMillis();
        MethodSignature signature = (MethodSignature) pjp.getSignature();
        Method method = signature.getMethod(); //获取被拦截的方法
        String methodName = method.getName(); //获取被拦截的方法名
        logger.info("请求开始，方法：{}", methodName);
        Date date=new Date(beginTime);
        logger.info("请求开始，时间：{}",date);
        try {
            pjp.proceed();
        } catch (Throwable throwable) {
            logger.info("异常，{}", throwable.getMessage());
        }
        logger.info("请求结束，耗时：{}", System.currentTimeMillis()-beginTime);
    }
}

Spring AOP原理

Spring中AOP代理由Spring的IOC容器负责生成、管理，其依赖关系也由IOC容器负责管理。因此，AOP代理可以直接使用容器中的其它bean实例作为目标，这种关系可由IOC容器的依赖注入提供。Spring创建代理的规则为：
1、默认使用Java动态代理来创建AOP代理，这样就可以为任何接口实例创建代理了
2、当需要代理的类不是代理接口的时候，Spring会切换为使用CGLIB代理，也可强制使用CGLIB