深入了解Spring框架

淩亂°似流年 2024-03-26 17:16 10阅读 0赞

## 文章目录 ##

第一章：AOP概念的引入

第二章：AOP相关的概念

第三章：Spring的AOP技术

1.配置文件方式

2. AOP配置文件方式的入门

3. 切入点的表达式

4. AOP的通知类型

第四章：Spring的AOP技术-注解方式

--------------------

### 第一章：AOP概念的引入 ###

首先我们来看一下登录的原理

![383b0226bdb84460876205ad2ffbb1ec.png][]

如上图所示这是一个基本的登录原理图，但是如果我们想要在这个登录之上添加一些新的功能，比如权限校验

那么我们能想到的就有两种方法：

①：通过对源代码的修改实现

**②：不通过修改源代码方式添加新的功能 （AOP）**![1a67c31b86b2419b90f318d1cc37b3e9.png][]

### 第二章：AOP相关的概念 ###

**1. AOP的概述**

**什么是AOP的技术？**

在软件业，AOP为Aspect Oriented Programming的缩写，意为：面向切面编程

AOP是一种编程范式，隶属于软工范畴，指导开发者如何组织程序结构

AOP最早由AOP联盟的组织提出的,制定了一套规范.Spring将AOP思想引入到框架中,必须遵守AOP联盟的规范

通过预编译方式或者运行期动态代理实现程序功能的统一维护的一种技术

AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型

利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可

重用性，同时提高了开发的效率

AOP采取横向抽取机制，取代了传统纵向继承体系重复性代码（事务管理、安全检查、缓存）

为什么要学习AOP，可以在不修改源代码的前提下，对程序进行增强！！

**2. AOP的优势**

运行期间，不修改源代码的情况下对已有的方法进行增强

优势：

1. 减少重复的代码

2. 提供开发的效率

3. 维护方便

3. AOP的底层原理

**JDK的动态代理技术**

1、为接口创建代理类的字节码文件

2、使用ClassLoader将字节码文件加载到JVM

3、创建代理类实例对象，执行对象的目标方法

**cglib代理技术**

为类生成代理对象，被代理类有没有接口都无所谓，底层是生成子类，继承被代理类![5a8c7161e9394da1b887aa8ba11c1015.png][]

### 第三章：Spring的AOP技术 ###

### 1.配置文件方式 ###

**1. AOP相关的术语**

Joinpoint(连接点) 类里面有哪些方法可以增强这些方法称为连接点

Pointcut(切入点) -- 所谓切入点是指我们要对哪些Joinpoint进行拦截的定义

Advice(通知/增强)-- 所谓通知是指拦截到Joinpoint之后所要做的事情就是通知.通知分为前置通知,后置通知,异常通知,最终通知,环绕通知(切面要完成的功能)

Aspect(切面)-- 是 切入点+通知 的结合，以后咱们自己来编写和配置的![cb070bb77613481ba96b9197bb8041b2.png][]

**2. 基本准备工作**

AspectJ是一个面向[切面][Link 1]的框架，它扩展了Java语言。AspectJ定义了AOP语法,AspectJ实际上是对AOP编程思想的一个实践.

### **2. AOP配置文件方式的入门** ###

创建maven项目，坐标依赖

<dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.0.2.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>commons-logging</groupId>
            <artifactId>commons-logging</artifactId>
            <version>1.2</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>5.0.2.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.12</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
        
        <dependency>
            <groupId>aopalliance</groupId>
            <artifactId>aopalliance</artifactId>
            <version>1.0</version>
        </dependency>
        
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aspects</artifactId>
            <version>5.0.2.RELEASE</version>
        </dependency>
        
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.8.3</version>
        </dependency>
    </dependencies>

##  ##

创建被增强的类

// 被增强的类
    public class User {
        //连接点/切入点
        public void add(){
            System.out.println("add......");
        }
        public void update(){
            System.out.println("update......");
        }
    }

将目标类配置到Spring中

定义切面类

public class UserProxy {
        //增强/通知  ---》前置通知
        public void before(){
            System.out.println("before.............");
        }
    }

在配置文件中定义切面类

在配置文件中完成aop的配置

<aop:config>
        
        <aop:aspect ref="userProxy">
            
            
            <aop:before method="before" pointcut="execution(public void com.aopImpl.User.add())"/>
        </aop:aspect>
    </aop:config>

完成测试

public class DemoTest {
        @Test
        public void aopTest1(){
            ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
            User user = (User) applicationContext.getBean("user");
            user.add();
        }
    }

### **3. 切入点的表达式** ###

再配置切入点的时候，需要定义表达式，具体展开如下：

切入点表达式的格式如下：

> execution(\[修饰符\] \[返回值类型\] \[类全路径\] \[方法名 ( \[参数\] )\])
> 
> 修饰符可以省略不写，不是必须要出现的。
> 
> 返回值类型是不能省略不写的，根据你的方法来编写返回值，可以使用 \* 代替。
> 
> 包名，类名，方法名，参数的规则如下：

例如：com.qcby.demo3.BookDaoImpl.save()

首先包名，类名，方法名是不能省略不写的，但是可以使用 \* 代替

中间的包名可以使用 \* 号代替

类名也可以使用 \* 号代替，也有类似的写法：\*DaoImpl

方法也可以使用 \* 号代替

参数如果是一个参数可以使用 \* 号代替，如果想代表任意参数使用 ..

比较通用的表达式：execution(\* com.qcby.\*.ServiceImpl.save(..))

举例2：com.qcby.demo3.BookDaoImpl当中所有的方法进行增强

execution(\* com.qcby.\*.ServiceImpl.\*(..))

举例3：com.qcby.demo3包当中所有的方法进行增强

execution(\* com.qcby.\*.\*.\*(..))

<aop:config>
        
        <aop:aspect ref="userProxy">
            
            <aop:before method="before" pointcut="execution(* com.*.User.add(..))"/>
        </aop:aspect>
    </aop:config>

### 4. AOP的通知类型 ###

1. 前置通知 目标方法执行前，进行增强。

如上配置案例就是前置通知

2. 环绕通知 目标方法执行前后，都可以进行增强。目标对象的方法需要手动执行。

// 环绕通知
    public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("before.............");
        //  执行被增强的方法
        proceedingJoinPoint.proceed();
        
        System.out.println("after.............");
    }

xml配置

<aop:around method="around" pointcut="execution(* com.*.User.add(..))"/>

3. 最终通知 目标方法执行成功或者失败，进行增强。

// 最终通知
    public void after() {
        System.out.println("after.............");
    }

4. 后置通知 目标方法执行成功后，进行增强。

//后置通知
    public void afterReturning() {
        System.out.println("afterReturning.............");
    }

xml配置

<aop:after-returning method="afterReturning" pointcut="execution(public void com.aopImpl.User.add())"/>

5. 异常通知 目标方法执行失败后，进行增强。(发生异常的时候才会执行，否则不执行)

//异常通知
    public void afterThrowing() {
    
        System.out.println("afterThrowing.............");
    }

需要改动一下切点

//连接点/切入点
    public void add(){
        int a = 10 / 0;
        System.out.println("add......");
    }

xml配置

<aop:after-throwing method="afterThrowing" pointcut="execution(public void com.aopImpl.User.add())"/>

### 第四章：Spring的AOP技术-注解方式 ###

**1. AOP注解方式入门程序**

创建maven工程，导入坐标。编写接口，完成IOC的操作。步骤略。

编写切面类

给切面类添加注解 @Aspect，编写增强的方法，使用通知类型注解声明

**1.配置xml扫描注解**

<?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xmlns:context="http://www.springframework.org/schema/context"
           xmlns:aop="http://www.springframework.org/schema/aop"
           xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
    
        
        <context:component-scan base-package="com.aopImpl"></context:component-scan>
        
    </beans>

**2.配置注解**

@Component
    public class User {
        //连接点/切入点
        public void add(){
            System.out.println("add......");
        }
    }

给切面类添加注解 @Aspect，编写增强的方法，使用通知类型注解声明

@Component
    @Aspect  //生成代理对象
    public class UserProxy {
    
    }

**3.配置文件中开启自动代理**

4.通知类型注解

@Before -- 前置通知

@AfterReturing -- 后置通知

@Around -- 环绕通知（目标对象方法默认不执行的，需要手动执行）

@After -- 最终通知

@AfterThrowing -- 异常抛出通知

@Component
    @Aspect  //生成代理对象
    public class UserProxy {
        //增强/通知  ---》前置通知
        @Before(value = "execution(* com.*.User.add(..))")
        public void before(){
            System.out.println("before.............");
    
        }
    
        // 环绕通知
        @Around(value = "execution(* com.*.User.add(..))")
        public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
            System.out.println("before.............");
            //  执行被增强的方法
            proceedingJoinPoint.proceed();
            System.out.println("after.............");
        }
    
        // 最终通知
        @After(value = "execution(* com.*.User.add(..))")
        public void after() {
    
            System.out.println("after.............");
        }
    
        //异常通知
        @AfterThrowing(value = "execution(* com.*.User.add(..))")
        public void afterThrowing() {
    
            System.out.println("afterThrowing.............");
        }
    
        //后置通知
        @AfterReturning(value = "execution(* com.*.User.add(..))")
        public void afterReturning() {
    
            System.out.println("afterReturning.............");
        }
    }

5.测试类

@Test
    public void aopTest1(){
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        
        user.add();
    }

--------------------

![81a7936872f34f4bb39776360cb0b71d.jpeg][]

[383b0226bdb84460876205ad2ffbb1ec.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/1aa020bb6c2842a4aa84c196ccfee5bf.png
[1a67c31b86b2419b90f318d1cc37b3e9.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/89d9bb75cf0f405e8f993f0654bba6e9.png
[5a8c7161e9394da1b887aa8ba11c1015.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/0b0c87d7ba564732acacf42387ab61d8.png
[cb070bb77613481ba96b9197bb8041b2.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/7f86abbc458747b2993afc5f4968434f.png
[Link 1]: https://baike.baidu.com/item/%E5%88%87%E9%9D%A2/10870837
[81a7936872f34f4bb39776360cb0b71d.jpeg]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/02ae5eff58144d2ab087d077625f9669.png