甜甜圈的小饼干

Spring

1、Spring

1.1、简介

spring：春天–>给软件行业带来了春天！

2002年首次推出Spring框架的雏形：interFace21框架

Spring理念：使现有技术更加容易使用，本身是一个大杂烩，整合了现有的技术框架！

官网：http://spring.io/projects/spring-framework#overview

官方下载地址：http://repo.spring.io/release/org/springframework/spring

GitHub:https://github.com/spring-projects/spring-framework

maven：springWebMvc

 
 <dependency>
	<groupId>org. springframeworkgroupId>
	<artifactId> spring-webmvc artifactId>
	<version>5.2.0. RELEASEversion>

 
<dependency>
	<groupId>org. springframeworkgroupId>
	<artifactId>spring-jdbcartifactId>
	<version>5.2.0. RELEASEversion>

1.2、优点

spring是一个开源的免费的框架（容器）！

spring是一个轻量级的、非入侵式的框架！

核心：控制反转（IOC），面向切面编程（AOP）。

支持事务的处理，对框架整合的支持！

总结：Spring就是一个轻量级的控制反转（IOC）和面向切面编程（AOP）的框架！

1.3、组成

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tn2fLcVr-1665910219491)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20221015120123109.png)]

1.4、扩展

在Spring的官网有这个介绍：现代化的Java开发！说白了就是基于Spring的开发!

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-SXrna4Cd-1665910219493)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20221015120254101.png)]

SpringBoot

一个快速开发的脚手架。

基于Spring Boot可以快速的开发单个微服务。

约定大于配置！

Spring Cloud

Spring Cloud是基于Spring Boot实现的。

Spring弊端：发展太久之后，违背了原来的理念，配置十分繁琐，人称“配置地狱”！

2、IOC理论推导

1、userDao接口

2、UserDaoImpl实现类

3、UserService业务接口

4、UserServiceImpl业务实现类

（建立多模块项目：先新建一个项目，将src文件夹删除，然后在项目上右键，新建一个项目）

在我们之前的业务中，用户的需求可能会影响我们原来的代码，我们需要根据用户的需求去修改原代码!

代码量十分大，修改一次的成本代价十分昂贵!

我们使用一个set接口实现，已经发现了革命性的变化！

private userDao userDao;
//利用set进行动态实现值的注入!
pub1ic void setuserDao(userDao userDao) {
this. userDao = userDao;
}

●之前，程序是主动创建对象!控制权在程序猿手上!

●使用了set注入后，程序不再具有主动性，而是变成了被动的接受对象!

这种思想，从本质上解决了问题，我们程序猿不用再去管理对象的创建了。系统的耦合性大大降低了，可以更加专注的在业务的实现上！这是IOC的原型！

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xG0eembB-1665910219494)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20221015122223201.png)]

3、ioc本质

控制反转loC(Inversion of Control),是- -种设计思想，DI(依赖注入)是实现IoC的- 种方法，也有人认为DI只是loC的另一种说法。没有loC的程序中,我们使用面向对象编程,对象的创建与对象间的依赖关系完全硬编码在程序中，对象的创建由程序自己控制，控制反转后将对象的创建转移给第三方，个人认为所谓控制反转就是:获得依赖对象的方式反转了。

loC是Spring框架的核心内容，使用多种方式完美的实现了IoG,可以使用XML配置，也可以使用注解，新版本的Spring也可以零配置实现IoC。
Spring容器在初始化时先读取配置文件，根据配置文件或元数据创建与组织对象存入容器中，程序使用时再从Ioc容器中取出需要的对象。

采用XML方式配置Bean的时候，Bean的定义信息是和实现分离的，而采用注解的方式可以把两者合为一体，Bean的定义信息直接以注解的形式定义在实现类中，从而达到了零配置的目的。控制反转是一种通过描述(XML或注解)井通过第三方去生产或获取特定对象的方式。在Spring中实现控制反转的是IoC容器，其实现方法是依赖注入(Dependency Injection,DI)。

4、Spring的Hello项目

1、新建一个项目，导入依赖

<!-- https://mvnrepository.com/artifact/org.springframework/spring-web -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-web</artifactId>
      <version>5.3.23</version>
</dependency>
<dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.3.22</version>
            <scope>test</scope>
</dependency>

2、新建一个Hello对象

package com.java.pojo;

public class Hello {
    private String str;

    public String getStr() {
        return str;
    }

    public void setStr(String str) {
        this.str = str;
    }

    @Override
    public String toString() {
        return "Hello{" +
                "str='" + str + '\'' +
                '}';
    }
}

3、书写Spring配置applicationContext.xml


<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd">


<bean id="hello" class="com.java.pojo.Hello">
   
    <property name="str" value= "Spring"/>
bean>
beans>

4、书写测试类

import com.java.pojo.Hello;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MySpring {
    public static void main(String[] args) {
        //获取spring的上下文对象1
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xm1");
        //我们的对象理在都在Spring中的管理了，我们要使心。直接去望面收出来就可以!
        Hello he11o = (Hello) context .getBean("hello");
        System.out.println(he11o.toString());

    }
}

输出结果

Hello{str='Spring'}

Hello 对象是谁创建的?
hello对象是由Spring创建的。
Hello对象的属性是怎么设置的?
hello对象的属性是由Spring容器设置的。

这个过程就叫控制反转:
控制:谁来控制对象的创建,传统应用程序的对象是由程序本身控制创建的,使用Spring后，对象是由Spring来创建的.
反转:程序本身不创建对象，而变成被动的接收对象.
依赖注入:就是利用set方法来进行注入的.
IOC是一种编程思想，由主动的编程变成被动的接收.
可以通过newClassPathXmlApplicationContext去浏览一下底层源码 .

OK，到了现在，我们彻底不用再程序中去改动了，要实现不同的操作,只需要在xml配置文件中进行修改，所谓的IoC,-句话搞定:对象由Spring来创建,管理，装配!

直接使用业务层

<bean id="mysqlImp1" class="com. kuang . dao. UserDaoMysq1Imp1"/>
<bean id= "orac1eImpl" class=" com. kuang. dao. UserDaoorac1eImpl-/>
"JserServiceImp1" class=" com. kuang. service .UserServiceImpl">

<property name="userDao" ref= "mysq1Imp1"/>
bean>

测试：

public static void main(string[] args) {
//获4收Appl icationContext;秀 pring的容器
ApplicationContext context = new ClassPathXmlApplicationContext( configLocation; "beans . xm1");
//容器在手。天卜我有。需要什么。就直孩get什么!
UserServiceImpl userServiceImpl =(UserServiceImp1)context.getBean(s:"UserServiceImp1");
userServiceImpl . getUser();
}

5、IOC创建对象的方式

1、使用无参构造方法创建对象，默认！

2.假设我们要使用有参构造创建对象。
1.下标赋值


<bean id= "user" class= "com. kuang. pojo. User">
<constructor-arg index="e" value=" 测试下标赋值"/>
bean>

2.通过类型创建

不建议使用
<bean id="user" class=" com. kuang . pojo .User">
<constructor-arg type=" java。lang . String" value="ceshi" />
bean>

3.直接通过参数名

<bean id="user" classm" com. kuang. pojo.User">
<constructor- arg nhame="name" value=" ceshi"/>
< /bean>

总结:在配置文件加载的时候，容器中管理的对象就已经初始化了!

6、spring配置

6.1、别名

一对一


<alias name= "user" alias="userNew"/>

6.2、bean配置


<bean id="userT" class="com. kuang. pojo. userT" name="user2 u2,u3;u4">
<property name="name" value=" sss"/>
bean>

6.3、import

这个import, 一般用于团队开发使用，他可以将多个配置文件，导入合并为一个
假设，现在项目中有多个人开发,这三个人复制不同的类开发，不同的类需要注册在不同的bean中,我们可以利用import将所有人的beans.xml合并为一个总的!
●张三

●李四
●王五

<import resource="beans .xml"/>
<import resource="beans2 .xml"/>
< import resource="beans3 . xml" />

使用的时候，直接使用总的配置就可以了

7、依赖注入

7.1、构造器注入

前面已经说过了

7.2、set方式注入(重点)

依赖注入：set注入！

依赖：bean对象的创建依赖于容器！

注入：bean对象中的所有属性，由容器来注入！

<bean id=" address" class="com. kuang . pojo . Address"/>
<bean id="student" class="com. kuang. pojo. Student">
<!-第一种，普通值注入。value-->
<property name="name" value="哇哇哇哇哇"/>

<property name=" address" ref= " address" />

<property name= "books">
<array>
<value>红楼梦va1ue>
<value>西游记value>
<value>水浒传value>
<value>三国演义value>
array>
property>
bean>

<property name= "hobbys">
<list>
<value>听歌value>
<value>船代码< /value>
<value>看电影value>
list>



<map>
<entry key= "" value=""/>
<entry key="" value=""/>
<entry key="" value=""/>
map>


+
'}";|
}

@Configuration//这个也会被spring容器托管，注册道容器中，因为它本来就是一个@component，@Configuration代表这是一个配置类， 就和我们之前看的beans . xmL
@ComponentScan(" com. fan . pojo" )
@Import ( FanConfig2.class)
public class FanConfig {
//注册一-个bean ，就相当于我们之 前号的一- 个bean标签
//这个方法的名字。就相当/bean标签中的id属性
//这个方法的函回值。就相当/bean标签中的class屙性
    @Bean
public User getUser(){
return new User();//.就是返阿要注入bean的对象!

}

测试：

public class MyTest {
public static void main(String[] args) {
    //如果完全使用 了配置类方式去做，我们就只能通过AnnotationConfig 上下文 來获取容器，通过配置类的class对象加载!
ApplicationContext context = new AnnotationConfigApplicationContext(FanConfig.class);
User getUser = (User) context .getBean( s: "getUser");
System. out . print1n(getUser . getName(0);
}

这种纯Java的配置方式，在SpringBoot中随处可见!

11、静态代理

11.1、AOP

1、代理模式

为什么要学习代理模式？因为着及时SpringAOP的底层【SpringAOP和SpringMVC】

代理模式的分类：

静态代理：

动态代理：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-l9Yr4A2W-1665910219496)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20221016144406775.png)]

11.2、静态代理

角色分析：

抽象角色：一般会使用接口或者抽象类来解决

真实角色：被代理的角色

代理角色：代理真实的角色后，我们一般会做一些附属操作

客户：访问代理对象的人！

代理模式的好处: .
●可以使真实角色的操作更加纯粹!不用去关注一些公共的业务
●公共也就就交给代理角色!实现了业务的分工!
●公共业务发生扩展的时候，方便集中管理!

代码步骤:
1.接口

//租房
public interface Rent {
public void rent();

2.真实角色

//房东
pub1ic class Host implements Rent {
public void rentO {
system. out.print1n("房东要出租房子! ");
}

3.代理角色

publ1c class Proxy implements Rent {
prlvate Host host;
public Proxy() {
public Proxy(Host host) {
this. host = host;
}
public void rent() {
seeHouse（）;
host. rent():
hetong();
fare();
}
//看房
public vold seeHouse(){
System . out . printIn("中介带你看房");
}
//租赁
public void hetong(){
System. out . printin("签租赁合同");
}
//收中介费
public void fare(){
System . out . println("收中介费" );
}
}

4.客户端访问代理角色

public class client {
public static void main(string[] args) {
//房东要租房子
Host host = new Host(;
//代理，中介帮房东租房子，但是呢?代理角一般会有一 些附属操作!
Proxy proxy = new Proxy(hoit);
//你不用面对房东。直按找中介租房即可!
proxy. rent（）;
}
}

缺点:
●一个真实角色就会产生-个代理角色;代码量会翻倍-开发效率会变低~

11.3、加深理解

用户userviceImpl有增删改查功能，现在需要加日志功能，在不改变原有代码的基础上，增加日志功能，这就是AOP思想，实现方式如下：

新建一个代理类，实现service的方法，在主体中引入userviceImpl对象，并写一个set方法，在该类中书写一个日志方法，增删改查方法重写时调用原有userviceImpl的增删改查方法，再在实现之前加入自己的日志方法即可。

11.4、动态代理

底层原理是反射
●动态代理和静态代理角色一样
●动态代理的代理类是动态生成的，不是我们直接写好的.

●动态代理分为两大类:基于接口的动态代理，基于类的动态代理

。基于接口：JDK动态代理
。基于类: cglib
。java字节码实现: javasist

需要了解两个类: Proxy. InvocationHandler

InvocationHandler：调用处理程序

//等我们会用这个类，自动生成代理类!
public class ProxyInvocationHandler implements InvocationHandler {
1/被化理的接口
private Rent rent;
public void setRent(Rent rent) {
this.rent = rent;
//生成得到代理美
public object getProxy(){
return Proxy .newProxyInstance(this. getClass(). getClassLoader(),rent . getClass(). getInterfaces(). h: this);
//处理代理实例，并返回结果
public object invoke(object proxy, Method method, Object[] args) throws Throwable d
//动态代理的本质。就是使用反射机制实现!
object result = method . invoke(rent, args);
]
return resu1t;

测试

public class Client {
public statlc vo1d main(String[] args) {
//真实角色.
Host host = new Host();
//代理角色:现在没有
ProxyInvocationHandler pih = new ProxyInvocationHand1er();
//.通i调川程序处理角色来处理我们要调川的接11对象!
pih. setRent(host);
Rent proxy = (Rent) pih. getProxy();//这里的proxy就是动态生成的。我们并没有写
proxy . rent();
}

通用类：

//等我们会用这个类，自动生成代理类!
public class ProxyInvoct ionHandler implements InvocationHandler {
//被代理的接11
private object target;
public void setTarget(Object target) {
this.target = target;
}
//生成得到代理类
public object getProxy(){
return Proxy .newProxyInstance(this. getClass(). getClassloader(),
target .getC1ass(). getInterfaces(). h: this);
}
1/处理代理文阙，并题回结梁:
public object invoke(0bject proxy, Method method, object[] args) throws Throwable {
1og(method. getName());
object result = method. invake(target, args);
return result;
}
public void 1og(String msg){
System. out . print1n("执行了"+msg+"方法" );
}

测试：

public class Client {
public static void main(String[] args) {
//真实角色
UserServiceImpl userService = new UserServiceImp1();
//代理角色，不存在
ProxyInvocationHandler pih = new ProxyInvocationHandler();
pih. setTarget(userService); // 设置要代理的对象
//动态生成代理类
UserService proxy = (UserService) pih. getProxy();
proxy . delete();
}
}

动态代理的好处:
●可以使真实角色的操作更加纯粹!不用去关注一些公共的业务
●公共也就就交给代理角色!实现了业务的分工!
●公共业务发生扩展的时候，方便集中管理!
●一个动态代理类代理的是一个接口，一般就是对应的一类业务
●一个动态代理类可以代理多个类，只要是实现了同一个接口即可!

12、AOP的实现

11.2 Aop在Spring中的作用
提供声明式事务:允许用户自定义切面
●横切关注点:跨越应用程序多个模块的方法或功能。即是，与我们业务逻辑无关的，但是我们需要关注的部分，就是横切关注点。如日志,安全,缓存,事务等等
●切面(ASPECT) :横切关注点被模块化的特殊对象。即，它是一个类。
●通知(Advice) :切面必须要完成的工作。即，它是类中的一个方法。
●目标(Target) :被通知对象。
●代理(Proxy) :向目标对象应用通知之后创建的对象。
●切入点(PointCut) : 切面通知执行的“地点”的定义。
●连接点UointPoint) :与切入点匹配的执行点。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-yCLCMFlb-1665910219497)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20221016153150649.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nCWlFReC-1665910219498)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20221016153319665.png)]

<dependencies>
<1-- https://mvnrepository. com/artifact/org. aspectj/aspectjwe
<dependency>
<groupId>org . aspectj
<artifactId>aspectjweaver
<version>1.9. 4version>

方式一：使用spring的接口【主要是SpringAPI接口实现】

public class Log implements MethodBeforeAdvice {
//method:|要执 行的月标对象的方法
//args:多数
//target: 1标对象
public void before(Method method, 0bject[] args, object target) throws Throwable {
System. out . print1n(target . getClass() . getName( )+"的“+method. getName()+"被执行了");
}

public class MyTest
public static void main(string[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext( configLocation: " applicationContext . xml" );
//动态代理代理的是接口
UserService userService = (UserService) context. getBean( s: "userService");
userService. add();
}
}

aop配置


<bean id="userService" class=" com. kuang。service .UserServiceImp1"/>
<bean id="1og" class=" com. kuang.1og.Log"/>
<bean id="afterlog" class=" com . kuang。log .AfterLog"/>
<！--配置Aop:需要导入aop的约束-->
<aop :config>

<aop:pointcut 1d="pointcut" expression-"execution(* com . kuang. service. UserServiceImp1.*(..))"/>
aop :config>

方式二：使用自定义来实现AOP【主要是切面定义】

public class DiyPointCut {
public vold before(){
System. out . printin-(="======方法执行=======");
}
public void after()[
System. out . print1n(" ======方法执行后=======" );
    }
    }

注册类

 .
<bean 1d="diy" class="com. kuang. diy. DiyPointcut"/>
<aop:config>
<!-月定义切面，ref 要引用的类-->
kaop:aspect ref="diy">

<aop: pointcut id-" point" expression= "execution(* com. kuang. service. UserServiceImpl. *(..))"/>

<aop: before method="before" pointcut -ref=" point"/>
<aop:after method=" after" pointcut -ref= "point"/>

aop :conf1g>

public class MyTest {
public static void main(string[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext( configLocation: " applicationContext . xml" );
//动态代理代理的是接11:兹意点
UserService userService = (UserService) context. getBean( s: "userService");
userService . add(;|
}

方式三：使用注解

@Aspect：标注这个类是一个切面


//方式三：使用注解方式 实现AOP
import org . aspectj。lang. annotation . Aspect;
import org. aspectj .1ang. annotation.Before;
@Aspect //标注这个类是一-个 切面
public class AnnotationPointCut {
 @Before(" execution(* com. kuang . service.UserServiceImp1.*(.))") 
public void before( ){
system. out . printn("====方法执行前=====");
}
}


<bean 1d=" annatatlonPointCut" class="com. kuang . diy. AnnotatlonPolntCut" />

<aop: aspectj - autoproxy/>

@Around

//在环绕增强中，我们可以给定一个参数。 代表我们要获取处型切入的点:
@Around( " execution(* com. kuang . service . UserServiceImpl. *(..))")
public vold around(ProceedingJoinPoint jp) throws Throwable {
System. out . println("环绕前");
//执行方法
object proceed = jp . proceed();
system. out . println("环绕后");
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JXkE7fUw-1665910219499)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20221016160054743.png)]

13、整合MyBatis

步骤：

1、导入相关Jar包

junit

mybatis

mysql

spring

aop

mybatis-spring

<dependencies>
<dependency>
<groupId>junit
<artifactId>junitartifactId>
<version>4.12version>
dependency>
<dependency>
<groupId>mysq1
<artifactId>mysq1-connector- javaartifactId>
<version>5.1.47dependency>
<dependency>
<groupId>org. mybatis
<artifactId>mybatisartifactId>
<vers1on>3.5.2vers1on>
dependency>
<dependency>
<groupId>org. springframework
<artifactId>spring-webmvc
<version>5.1.9. RELEASEversion>
dependency>

<dependency>
<groupId>org . springframework
<artifactId>spring-jdbc
<version>5.1.9. RELEASEversion>
dependency>
<dependency>
groupId>org . aspectj
<artifactId>aspectjweaverk/ artifactId>
<version>1.8.13dependency>
    <dependency>
<groupId>org . mybatis
<artifactId>mybatis-springartifactId>
<version>2.0.2< /version>

2、编写配置类mybatis-config.xml


< !DOCTYPE configuration
PUBLIC "-/ /mybatis. org//DTD Config 3.0//EN"
"http://mybatis .org/dtd/ mybatis-3-config.dtd">

< configuration>
<environments default= " development">
<environment id=" development">
<transactionManager type="JDBC"/>
<dataSource type="POOLED" >
<property name="driver" value=" com. mysq1. jdbc . Driver"/>

<property name="password" value="123456"/>
dataSource>
< /environment> I

3、测试

13.1、mybatis-spring

applicationContext.xml


<beans xmIns="http: //www. springframework . org/ schema/beans"
◎◎❼00
xmlns:xsi="http://ww.w3. org/2001/XML Schema- instance"
xmIns :aop= "http:/ /www。springframework。org/ schema/aop"
xsi : schemaLocation="http:/ /www. springframework . org/ schema/beans
https://www. springframework . org/ schema/beans/spring-beans .xsd
http:/ /www. springframework . org/ schema/ aop
https://www. springframework . org/ schema/ aop/ spring-aop.xsd">

<bean id="datasource" class="org. springfr amework. jdbc . datasource. DriverManagerDataSource">
<property name=" driverClassName" value="com. mysq1. jdbc . Driver"/>
<property name="ur1" value= "jdbc :mysq1://localhost: 3306/mybatis ?useSSL=true& useUnicode=true& characterEncoding=UTF-8"/>
<property name="username" value="root"/>
<property name="password" value="123456"/>
bean>
<! --sqlSessionFactory-->
<bean id="sqlSessionFactory" class="org . mybatis . spring . SqlSessionFactoryBean">
<property name="dataSource" ref="dataSource" />
    
<property name=" configuration" value=" classpath:mybatis-config . xml"/>
<property name=" mapperLocations" value=" classpath: com/kuang/ mapper/* . xm1"/>
bean>
    
<bean id="sq1Session" c1ass="org. mybatis。spring. Sq1SessionTemplate">

constructor-arg index "0" ref="sqlSessionFactory"/>
bean>
beans>

14、声明式事务

1、回顾事务

把一组业务当成一个义务处理，要么都成功，要么都失败！

事务在项目开发中十分的重要，设计到数据的一致性问题，不能马虎！

确保完整性和一致性！

事务的ACID原则：

原子性

一致性

隔离性：多个业务操作同一个资源，防止数据损坏

持久性：事务一旦提交，无论系统发生什么问题，结果都不会被影响，被持久化的写到存储器中!

2、Spring中的事务管理

声明式事务：AOP

编程式事务：


<bean id="transactionManager" class= "org. springframework . jdbc . datasource . DataSourceTransactionManager">
<property name= "dataSource" ref="dataSource"/>
bean>

 
<tx:advice id="txAdvice" transaction-manager= "transactionManager">


<tx:attributes>
<tx :method name=" add" propagation="REQUIRED"/>
<tx :method name=" delete" propagation="REQUIRED"/>
<tx:method name= "update" propagation= "REQUIRED"/>
<tx:method name= "query" read-on1y="true"/>
<tx :method name="*" propagation= "REQUIRED"/>
tx: attributes >
tx: advice>

<aop :config>
<aop: pointcut id="txPointCut" expression=" execution(* com. kuang . mapper.*.*(..))"/>
<aop : advisor advice-ref="txAdvice" pointcut-ref="txPointCut"/>

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-NzGuvdRD-1665910219499)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20221016164430054.png)]

思考:
为什么需要事务?
●如果不配置事务，可能存在数据提交不一致的情况下;
●如果我们不在SPRING中去配置声明式事务，我们就需要在代码中手动配置事务!