【Spring】——代理模式、AOP、MyBatis-Spring学习以及Spring事务

最新推荐文章于 2024-09-06 11:04:13 发布

Y小夜

最新推荐文章于 2024-09-06 11:04:13 发布

阅读量1k

点赞数 16

分类专栏： ssm框架文章标签： spring 代理模式 java

本文链接：https://blog.csdn.net/shsjssnn/article/details/140498643

版权

ssm框架专栏收录该内容

2 篇文章 0 订阅

订阅专栏

🎼个人主页：【Y小夜】

😎作者简介：一位双非学校的大二学生，编程爱好者，

专注于基础和实战分享，欢迎私信咨询！

🎆入门专栏：🎇【MySQL，Java基础，Rust】

🎈热门专栏：🎊【Python，Javaweb，Vue框架】

感谢您的点赞、关注、评论、收藏、是对我最大的认可和支持！❤️

🎯代理模式

AOP的底层机制就是动态代理

😎静态代理

静态代理角色分析

抽象角色 : 一般使用接口或者抽象类来实现

真实角色 : 被代理的角色

代理角色 : 代理真实角色 ; 代理真实角色后 , 一般会做一些附属的操作 .

客户 : 使用代理角色来进行一些操作

😎静态代理的好处

可以使得我们的真实角色更加纯粹 . 不再去关注一些公共的事情 .

公共的业务由代理来完成 . 实现了业务的分工 ,

公共业务发生扩展时变得更加集中和方便 .

缺点 :

类多了 , 多了代理类 , 工作量变大了 . 开发效率降低 .

我们想要静态代理的好处，又不想要静态代理的缺点，所以 , 就有了动态代理 !

😎动态代理

动态代理的角色和静态代理的一样 .

动态代理的代理类是动态生成的 . 静态代理的代理类是我们提前写好的

动态代理分为两类 : 一类是基于接口动态代理 , 一类是基于类的动态代理

基于接口的动态代理----JDK动态代理
基于类的动态代理--cglib
现在用的比较多的是 javasist 来生成动态代理 . 百度一下javasist
我们这里使用JDK的原生代码来实现，其余的道理都是一样的！

🎯AOP

AOP（面向切面编程）是一种通过预编译方式和运行期动态代理实现在不修改源代码的情况下给程序动态统一添加特定功能的技术。

😎AOP的定义和作用

概念解释：AOP全称为Aspect Oriented Programming，即面向切面编程，是OOP（面向对象编程）的延续，旨在将横切关注点从业务逻辑中分离出来，以提高模块化和代码的可维护性。
主要作用：AOP主要用于将分散在多个模块中的关注点（如日志记录、事务管理、安全控制等）抽离出来，形成独立的模块（切面），在需要时通过切面动态地加入到业务流程中，从而避免代码的重复和提高可重用性。

😎AOP的核心概念

切面（Aspect）：切面是AOP的核心元素，定义了横切关注点的模块。它包含了通知（Advice）和切点（Pointcut），是实现横切功能的基础单元。
连接点（Joinpoint）：连接点是程序执行过程中的某个特定点，如方法调用或异常处理。在这些点上，切面可以插入额外的逻辑。
通知（Advice）：通知是切面的具体实现，定义了在连接点处要执行的操作。常见的通知类型包括前置通知、后置通知、返回通知、异常通知和环绕通知。
切点（Pointcut）：切点用于定义哪些连接点会触发切面的通知逻辑。通过切点表达式，可以精确地指定需要应用切面的连接点。
引入（Introduction）：引入允许在不修改原有类代码的前提下，为类动态地增加新的方法或属性。
织入（Weaving）：织入是将切面应用到目标对象并创建新的代理对象的过程。织入可以在编译期、类加载期或运行期进行。

😎AOP的实现技术

Spring AOP：Spring框架提供的AOP支持，通过动态代理技术和AspectJ注解，实现切面的管理和重用。Spring AOP适用于企业级应用开发，特别是与Spring框架集成的项目。
AspectJ：一个功能强大的AOP框架，提供了编译时和加载时织入的能力。AspectJ提供了更为丰富的切面定义和织入功能，适合对AOP有更高要求的场景。

😎AOP的应用举例

日志记录：通过AOP，可以在方法调用前后自动记录日志，而无需手动在每个方法中添加日志代码。
事务管理：AOP可以将事务管理逻辑从业务代码中分离出来，实现统一的事务管理策略。例如，在方法执行前开启事务，在方法成功执行后提交事务，出现异常时回滚事务。
性能监测：AOP能够监测方法的执行时间和资源消耗，帮助开发者优化系统性能。

😎AOP的优点

减少代码重复：通过将通用功能模块化为切面，避免了在多个地方重复相同的代码。
提高开发效率：开发者可以专注于核心业务逻辑，非核心功能通过AOP实现，提高了开发效率。
提高代码模块化：AOP将不同关注点分离，使得代码结构更加清晰和模块化。
松耦合和可扩展性：由于切面与业务逻辑相独立，修改或添加新的切面不会影响核心业务代码，提高了系统的灵活性和可扩展性

😎使用Aop

导入依赖

<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.9.4</version>
</dependency>

😎通过Spring API

<?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: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/aop
http://www.springframework.org/schema/aop/spring-aop.xsd">
<!--注册bean-->
<bean id="userService" class="com.aaa.service.UserServiceImpl"/>
<bean id="log" class="com.kuang.log.Log"/>
<bean id="afterLog" class="com.kuang.log.AfterLog"/>
<!--aop的配置-->
<aop:config>
<!--切入点 expression:表达式匹配要执行的方法-->
<aop:pointcut id="pointcut" expression="execution(*
com.kuang.service.UserServiceImpl.*(..))"/>
<!--执行环绕; advice-ref执行方法 . pointcut-ref切入点-->
<aop:advisor advice-ref="log" pointcut-ref="pointcut"/>
<aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"/>
</aop:config>
</beans>

Aop的重要性 : 很重要 . 一定要理解其中的思路 , 主要是思想的理解这一块 .

Spring的 Aop 就是将公共的业务 ( 日志 , 安全等 ) 和领域业务结合起来 , 当执行领域业务时 , 将会把公共业务加进来 . 实现公共业务的重复利用 . 领域业务更纯粹 , 程序猿专注领域业务 , 其本质还是动态代理 .

😎自定义类来实现Aop

<!--第二种方式自定义实现-->
<!--注册bean-->
<bean id="diy" class="com.kuang.config.DiyPointcut"/>
<!--aop的配置-->
<aop:config>
<!--第二种方式：使用AOP的标签实现-->
<aop:aspect ref="diy">
<aop:pointcut id="diyPonitcut" expression="execution(*
com.kuang.service.UserServiceImpl.*(..))"/>
<aop:before pointcut-ref="diyPonitcut" method="before"/>
<aop:after pointcut-ref="diyPonitcut" method="after"/>
</aop:aspect>
</aop:config>

😎使用注解实现

package com.kuang.config;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
@Aspect
public class AnnotationPointcut {
@Before("execution(* com.kuang.service.UserServiceImpl.*(..))")
public void before(){
System.out.println("---------方法执行前---------");
}
@After("execution(* com.kuang.service.UserServiceImpl.*(..))")
public void after(){
System.out.println("---------方法执行后---------");
}
@Around("execution(* com.aaa.service.UserServiceImpl.*(..))")
public void around(ProceedingJoinPoint jp) throws Throwable {
System.out.println("环绕前");
System.out.println("签名:"+jp.getSignature());
//执行目标方法proceed
Object proceed = jp.proceed();
System.out.println("环绕后");
System.out.println(proceed);
}
}

🎯MyBatis-Spring学习

MyBatis-Spring 会帮助你将 MyBatis 代码无缝地整合到 Spring 中

如果使用 Maven 作为构建工具，仅需要在 pom.xml 中加入以下代码即可：

<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis-spring</artifactId>
<version>2.0.2</version>
</dependency>

🎯声明式事务

😎回顾事务

事务是数据库管理系统执行过程中的一个不可再分的工作单元，通过确保数据的一致性和完整性，来管理一系列的操作：

事务的定义与基本概念
- 事务的定义：事务是一个最小的不可再分的工作单元，通常一个事务对应一个完整的业务，如银行账户转账，这个业务是不可再分的最小单元。
- 事务的组成：事务由一系列DML语句（INSERT、UPDATE、DELETE）组成，这些语句共同完成一个完整业务的操作。
事务的四大特性
- 原子性（Atomicity）：事务是一个不可分割的工作单位，事务中的所有操作要么全部成功，要么全部失败，不可能停留在中间状态。
- 一致性（Consistency）：事务必须保证数据库从一个一致性状态转换到另一个一致性状态。即在事务执行过程中，无论成功还是失败，数据库的完整性约束都不被破坏。
- 隔离性（Isolation）：一个事务在提交之前，对其他事务是不可见的。这可以防止多个事务并发执行时由于互相干扰而产生数据不一致的问题。
- 持久性（Durability）：一旦事务成功提交，它对数据库的修改将被永久保存，即使在系统崩溃或重启后，这些修改依然存在。
事务的开启与结束
- 开启事务：使用BEGIN TRANSACTION或START TRANSACTION命令显式开启一个事务。
- 结束事务：事务可以通过COMMIT命令提交完成，使得所有修改永久生效；或者通过ROLLBACK命令撤销所有修改，恢复到事务开始前的状态。
事务的类型
- 手动事务：手动事务允许显式处理事务的开启、提交和回滚等操作。这种事务类型需要手动管理每个步骤。
- 自动事务：自动事务由系统自动管理，简化了事务的处理过程。例如，在.NET环境中，标记为参与事务的对象将自动执行事务行为。
事务的应用场景
- 银行转账：在银行转账操作中，一个账户的资金减少和另一个账户的资金增加这两个操作必须全部成功或全部失败，这是典型的事务应用。
- 数据完整性维护：在大量数据更新和删除操作中，事务可以确保所有操作作为一个整体执行，从而维护数据的完整性和一致性。

😎Spring中的事务管理

Spring框架提供了全面的事务管理支持，它使得在应用程序中处理事务变得简单而透明。以下是Spring事务管理的一些关键概念和特性：

声明式事务管理:
- Spring主要通过声明式事务管理来简化事务的使用。通过在方法或类级别使用注解，可以轻松地管理事务的边界和行为。
编程式事务管理:
- 除了声明式事务管理，Spring也支持编程式事务管理。这种方式通过代码显式地控制事务的创建、提交和回滚。
@Transactional 注解:
- 这是Spring声明式事务管理的核心，可以应用于类或方法上。当应用于类上时，类中的所有方法都将拥有相同的事务行为。
- 常见的配置选项包括：
  - propagation: 事务的传播行为，如REQUIRED、REQUIRES_NEW、SUPPORTS等。
  - isolation: 事务的隔离级别，如DEFAULT、READ_COMMITTED、SERIALIZABLE等。
  - timeout: 事务的超时时间。
  - readOnly: 事务是否为只读。
  - rollbackFor: 定义哪些异常会导致事务回滚。
  - noRollbackFor: 定义哪些异常不会导致事务回滚。
PlatformTransactionManager:
- 这是Spring事务管理的核心接口，用于抽象事务管理的各种操作，如获取和释放事务资源。
DataSourceTransactionManager:
- 这是PlatformTransactionManager的一个实现，用于管理数据源的事务。
HibernateTransactionManager (当使用Hibernate时):
- 这是PlatformTransactionManager的一个实现，专门用于Hibernate事务管理。
JtaTransactionManager (当使用JTA时):
- 这是PlatformTransactionManager的一个实现，用于管理JTA事务。
事务传播行为:
- 定义了当事务方法被另一个方法调用时，事务如何传播。常见的传播行为包括：
  - REQUIRED: 如果当前存在事务，则加入该事务；如果不存在，则创建一个新的事务。
  - REQUIRES_NEW: 总是创建一个新的事务，如果当前存在事务，则挂起当前事务。
  - SUPPORTS: 如果当前存在事务，则加入该事务；如果不存在，则不创建新的事务。
  - MANDATORY: 如果当前存在事务，则加入该事务；如果不存在，则抛出异常。
  - NOT_SUPPORTED: 总是运行在非事务环境中，如果当前存在事务，则挂起当前事务。
  - NEVER: 总是运行在非事务环境中，如果当前存在事务，则抛出异常。
事务隔离级别:
- 控制事务在并发执行时的隔离程度，防止数据不一致的问题。常见的隔离级别包括：
  - DEFAULT: 使用后端数据库的默认隔离级别。
  - READ_UNCOMMITTED: 最低的隔离级别，允许读取未提交的数据。
  - READ_COMMITTED: 保证读取的数据是已经提交的。
  - REPEATABLE_READ: 保证在一个事务内，多次读取同一数据的结果是一致的。
  - SERIALIZABLE: 最高的隔离级别，完全串行执行事务。
事务超时:
- 定义了事务可以持续的最长时间。如果超过这个时间，事务将被自动回滚。
只读事务:
- 标记事务为只读，这可以提高性能，因为数据库可以优化只读事务的处理。
异常处理:
- 定义了哪些异常会导致事务回滚，哪些异常不会导致回滚。