#Spring最新完整版学习流程【快速上手】

Spring最新完整版学习流程

1、Spring框架

Spring框架：目的:解决企业应用开发的复杂性

• Spring是一个轻量级控制反转(IOC)和面向切面(AOP)的容器框架。
• Rod Johnson , Spring Framework创始人，著名作者，音乐家。
• “轮子理论”，也即"不要重复发明轮子”。不要重复造轮子
• spring理念:使现有的技术更加容易使用，本身是一个大杂烩，整合了现有的技术框架!

1.1简介——基本内容

设计哲学：
当您了解框架时，不仅要了解框架的工作而且要遵循的原则很重要。以下是Spring框架的指导原则:

• 提供每个级别的选择。Spring使您可以尽可能推迟设计决策。例如，您可以在不更改代码的情况下通过配置切换持久性提供程序。对于许多其他基础架构问题以及与第三方API的集成也是如此。
• 适应不同的观点。Spring拥有灵活性，并且对如何完成工作一无所知。它从不同的角度支持广泛的应用程序需求。
• 保持强大的向后兼容性。对Spring的演变进行了精心管理，以使各个版本之间几乎没有重大更改。Spring支持精心选择的JDK版本和第三方库。以方便维护依赖于Spring的应用程序和库。
• 关心API设计。Spring团队投入了大量的思想和时间来制作直观，并在许多版本和很多年中都适用的API。
• 为代码质量设置高标准。Spring框架非常强调有意义，最新和准确的javadoc。它是极少数可以声明干净代码结构且程序包之间没有循环依赖关系的项目之一。

**SSH : Struct2 + Spring + Hibernate! **

SSM : SpringMVC + Spring + Mybatis!

1.2优点

• Spring是一个开源的免费的框架（容器)
• Spring是一个轻量级的、非入侵式的框架!
• 控制反转(IOC) ，面向切面编程(AOP)！！！
• 支持事务的处理

总结一句话: Spring就是一个轻量级的控制反转(IOC)和面向切面编程的框架!

1.3组成

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

1.4拓展

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

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

• Spring Boot

  ​ 一个快速开发的脚手架。

   **基于SpringBoot可以快速的开发单个微服务。**
  
   **约定大于配置!**
  

• Spring Cloud
  SpringCloud是基于SpringBoot实现的。

因为现在大多数公司都在使用SpringBoot进行快速开发，学习SpringBoot的前提，需要完全掌握Spring及SpringMVC! 承上启下的作用

1.5IOC本质

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

采用XML方式配置Bean的时候，Bean的定义信息是和实现分离的，而采用注解的方式可以把两者合为一体，Bean的定义信息直接以注解的形式定义在实现类中，从而达到了零配置的目的。

控制反转是一种通过描述（XML或注解）并通过第三方去生产或获取特定对象的方式。在Spring中实现控制反转的是loC容器，其实现方法是依赖注入(Dependency Injection,Dl)。

这个过程就叫控制反转:
控制:谁来控制对象的创建，传统应用程序的对象是由程序本身控制创建的，使用Spring后，对象是由Spring来创建的．

反转∶程序本身不创建对象，而变成被动的接收对象．依赖注入:就是利用set方法来进行注入的.

IOC是一种编程思想，由主动的编程变成被动的接收．
可以通过newClassPathXmlApplicationContext去浏览一下底层源码.

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

获取Applicationcontext:到Spring的容器

ApplicationContext context = new classPath×mlApplicationContext(configLocation: "beans.xml");

容器在手，天下我有，需要什么，就直拉get什么

UserServiceImpl userServiceImpl = (UserServiceImp1) context.getBean("UserServiceImp");

userServiceImpl.getUser();

ref : 引用Spring容器中创建好的对象

value : 具体的值，原本数据类型!

1.6IOC创建对象的方式

1.使用无参构造创建对象，默认!

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

<!--第一种，下标赋值! -->
<bean id="user" class="com.tian.user">
<constructor-arg index="0" value="尹金天Spring" /></bean>

​ 2.类型

<!--第二种方式:通过类型创建，不建议使用! -->
<bean id="user" class="com.tian.user">
<constructor-arg type="java.lang.string" value="qinjiang"/></bean>

​ 3.参数名

<!--第三种，直接通过参数名来设置-->
<bean id="user" class="com.tian.user">
<constructor-arg name="name" value="尹金天"/></bean>

2、Spring配置

2.1、别名

<!--别名，如果添加了别名，我们也可以使用别名获取到这个对象-->
<alias name="user" alias="userNew" />

2.2、Bean的配置

<!--id : bean的唯一标识符，也就是相当于我们学的对象名class : bean对象所对应的全限定名:包名＋类型name :也是别名,而且name可以同时取多个别名
-->
<bean id="userT" c1ass="com.tian.userT" name="user2 u2,u3;u4">
<property name="name" value="尹金天"/>
</bean>

2.3、import

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

• 张三

• 李四

• 王五

• applicationContext.xml

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

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

3、依赖注入

3.1、构造器注入

3.2、Set方式注入【重点】

• 依赖注入: Set注入!
  • 依赖：bean对象的创建依赖于容器
  • 注入：bean对象中的所有属性，由容器来注入!

【环境搭建】

​ 1.复杂类型

pub1ic class Address {
	private String address;
	public String getAddress {
		return address;
	}
	public void setAddress(String address){
		this.address = address;
	}
}

​ 2.真实测试对象

public class student {
    private String name;
    private Address address;
    private String[] books;
    private List<string> hobbys;
    private Map<string, string> card;
    private set<string> games;
    private String wife;
    private Properties info;
}

​ 3.beans.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:p="http://www.springframework.org/schema/p"
	   xsi:schemaLocation="http://www, springframework.org/schema/beans
	   https://ww.springframework.org/schema/beans/spring-beans.xsd">
	   
	   <!--第一种，普通值注入，value-->
		<bean id="user" class="com.springdemo.Person" p:name="尹金天" p:age="18"/>
    <!--p命名空间注入，可以直接注入属性的值: property-->
		<bean id="user" class="com.springdemo.Person" p:name="尹金天" p:age="18"/>
	   
	   
</beans>

​ 测试：

@Test
public void test{
	Applicationcontext context = new classPathxm1App1icationcontext("userbeans.xm1");
    User user = context.getBean("user",user.class);
system.out.println(user);
}

3.3、拓展方式注入

注意点:p命名和c命名空间不能直接使用，需要导入xml约束!

xm1ns:c="http://www.springframework.org/schema/c"
xm1ns :p="http://www.springframework.org/schema/p"

3.4、bean的作用域

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-SJn4Njn5-1658389976895)(C:\Users\86133\AppData\Roaming\Typora\typora-user-images\image-20220423092943147.png)]1.单例模式(Spring默认机制)

bean id="user" class="com.springdemo" c:age="18" c:name="尹金天"scope="singleton"/>

2.原型模式:每次从容器中get的时候，都会产生一个新对象!

<bean id="accountservice" class="com.something.Defau1tAccountservice" scope="prototype" />

3.其余的request、session、application这些个只能在web开发中使用到！

4、Bean的自动装配

• 自动装配是Spring满足bean依赖一种方式!
• Spring会在上下文中自动寻找，并自动给bean装配属性!

在Spring中有三种装配的方式

1.在xml中显示的配置
2在java中显示配置
3.隐式的自动装配bean【重要】

4.1、测试

环境搭建：一个人有两个宠物！【面向对象思想】

4.2、ByName自动装配

<!--byName:会自动在容器上下文中查找，和自己对象set方法后面的值对应的 beanid -->
<bean id="people" class="com.tian.People" autowire="byName">
<property name="name" value="是天天吖""/>
</bean>

4.3、ByType自动装配

<bean class="com. kuang.pojo.cat" />
 <bean class="com. kuang.pojo.Dog" />
<!--
byName:会自动在容器上下文中查找，和自己对象set方法后面的值对应的 beanid !byType:会自动在容器上下文中查找，和自己对象属性类型相同的bean !
-->
<bean id="people" class="com.tian.People" autowire="byType">
<property name="name" value="是天天吖"/>
</bean>

小结：

• **byname的时候，需要保证所有bean的id唯一，**并且这个bean需要和自动注入的属性的set方法的值一致!
• **bytype的时候，需要保证所有bean的class唯一，**并且这个bean需要和自动注入的属性的类型一致!

4.4、使用注解实现自动装配

jdk1.5支持的注解，Spring2.5就支持注解了！

要使用注解须知：

​ 1、导入约束

​ 2、==配置注解的支持:context:annotation-config/【重要!】

<?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"
		xsi:schemaLocation="http://www.springframework.org/schema/beans
https://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
https://www.springframework.org/schema/context/spring-context.xsd">
<context:annotation-config/>
</beans>

**@Autowired **自动装配
直接在属性上使用即可!也可以在set方式上使用!

使用Autowired我们可以不用编写Set方法了，前提是你这个自动装配的属性在IOC(Spring)容器中存在，且符合名字byname!

如果@Autowired自动装配的环境比较复杂，自动装配无法通过一个注解【@Autowired】完成的时候、我们可以使用@Qualifier(value=“xxx”)去配置@Autowired的使用，指定一个唯一的bean对象注入!

小结:
@Resource和@ Autowired的区别:

• 都是用来自动装配的，都可以放在属性字段上
• Autowired通过byname的方式实现【常用】
• @Resource默认通过byname的方式实现，如果找不到名字，则通过byType实现!如果两个都找不到的情况下，就报错!

##注解使用说明##

@Autowired : 自动装配通过类型。名字

如果Autowired不能唯一自动装配上属性，则需要通过@Qualifier(value=“x”)

@Nullable字段标记了这个注解，说明这个字段可以为null;

**@Resource **:自动装配通过类型。名字

**@Component **:组件，放在类上，说明这个类被Spring管理了，就是bean!

5、使用注解开发

在Spring4之后，要使用注解开发，必须要保证aop的包导入了

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

使用注解需要导入context约束，增加注解的支持!

<?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"
    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"> 
 		
 </beans>

1. bean

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

User.java

package com.tian.dao;

import org.springframework.stereotype.Component;

//等价于在applicationContext.xml插入
//<bean id="user" class="com.tian.dao"></bean>
//@Component 组件
@Component
public class User {
	public String name = "尹金天";
	
}

applicationContext.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.tian.dao"></context:component-scan>
		<context:annotation-config/>
 		
 </beans>

Test.java

package com.test;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.tian.dao.User;

public class Test {
	@org.junit.Test
	public void test(){
		//获取spring上下文对象
		ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml");
		User user = (User) context.getBean("user");
		System.out.println(user.name);
	}
}

2. 属性如何注入

User.java

package com.tian.dao;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

//等价于 在applicationContext.xml插入
//<bean id="user" class="com.tian.dao.User">
//<property name="name" value="tian"></property>
//</bean>
//@Component 组件
@Component
public class User {
	@Value("tian")
	public String name;
}

其余不变 applicationContext.xml、Test.java

3. 衍生的注解

@Component有几个衍生注解，我们在web开发中，会按照mvc三层架构分层!

• dao 【@Repository】
• service 【@Service]
• controller 【@Controller】

这四个注解功能都是一样的，都是代表将某个类注册到Spring中，装配Bean！

​ 4.自动装配置

@Autowired : 自动装配通过类型。名字
	如果Autowired不能唯一自动装配上属性，则需要通过@Qualifier(value="x")

@Nullable字段标记了这个注解，说明这个字段可以为null;

@Resource:自动装配通过类型。名字

​ 5.作用域

@Component
@Scope("prototype")
public class User {
	@Value("tian")
	public String name;

	public void setName(String name) {
		this.name = name;
	}	
}

​ 6.小结

​ xml与注解:

• xml更加万能，适用于任何场合!维护简单方便。

• 注解不是自己类使用不了，维护相对复杂!

  xml与注解最佳实践:

  • xml 用来管理bean;

  • 注解只负责完成属性的注入;

  • 我们在使用的过程中，只需要注意一个问题:必须让注解生效，就需要开启注解的支持【在applicationContext.xml配置一下即可，让它找到】

     <!-- 指定要扫描的包，这个包的注解就会生效-->
    <context:component-scan base-package="com.tian.dao"/>
    <context:annotation-config/>
    

6、使用Java的方式配置Spring

User.java

package com.tian.dao;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;

//@Component 组件
//这里这个注解的意思，就是说明这个类被Spring接管了，注册到了容器中
@Component
public class User {
	public String name;

	public String getName() {
		return name;
	}

	@Value("尹金天")		//属性注入值
	public void setName(String name) {
		this.name = name;
	}

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

TianConfig.java

package com.tian.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

import com.tian.dao.User;

@Configuration
@ComponentScan("com.tian.dao")
//这个也会被Spring托管，注册到容器中，因为它本来就是一个@Component
//@Configuration代表这是一个配置类，就和我们之前看的beans.xml
public class TianConfig {
	
	//注册一个bean，就相当于我们之前写的一个bean标签
	//这个方法的名字，就相当于bean标签中的id属性
	//这个方法的返回值，就相当于bean标签中的cLass属性

	@Bean
	public User getUser() {
		return new User();//就是返回要注入到bean的对象！
	}
}

Test.java

package com.test;

import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

import com.tian.config.TianConfig;
import com.tian.dao.User;

public class Test {
	@org.junit.Test
	public void test(){
		//获取spring上下文对象.
		//如果完全使用了配置类方式去做，
		//我们就只能通过AnnotationConfig上下文来获取容器，
		//通过配置类的fclass对象加载！
		ApplicationContext context = new AnnotationConfigApplicationContext(TianConfig.class);
		User user = (User) context.getBean("getUser");
		System.out.println(user.getName());
	}
}

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

7、代理模式

为什么要学习代理模式？

因为这就是SpringAOP的底层! 【SpringAOP 和 SpringMVC】

---

代理模式的分类:

• 静态代理
• 动态代理

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

7.1、静态代理

角色分析:

• 抽象角色:一般会使用接口或者抽象类来解决
• 真实角色∶被代理的角色
• 代理角色∶代理真实角色，代理真实角色后，我们一般会做一些附属操作
• 客户:访问代理对象的人!

代理模式的好处:

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

缺点:

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

代码步骤:

1.接口

1//租房
public interface Rent {
	pub1ic void rent();
6}

2.真实角色

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

3.代理角色

public class Proxy implements Rent {
	private Host host;
	public Proxy(){
	public Proxy (Host host) {
	this.host = host;
    }
	public void rent(){
	seeHouse();
	host.rent();
    hetong();
    fare();
    }
	//看房
	public void seeHouse(){
	System.out.println("中介带你看房");
	}
	//合同
	public void hetongo(){
	System.out.print1n("签租赁合同");
    }
	//收中介费
	public void fare(){
	System.out.println("收中介费");
    }
 }

4.客户端访问代理角色

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

7.2、加深理解

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

测试：

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

流程图：（横切）

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

10.2、动态代理

• 动态代理和静态代理角色一样
• 动态代理的代理类是动态生成的，不是我们直接写好的!
• 动态代理分为两大类:基于接口的动态代理，基于类的动态代理
  • 基于接口—JDK动态代理。
  • 基于类: cglib
  • java字节码实现: javasist

需要了解两个类 :

Proxy : 代理，

InvocationHandler : 调用处理程序

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

动态代理的好处：

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

8、AOP（Aspect Oriented Programming）

8.1、什么是AOP：

面向切面编程

通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

8.2、Aop在Spring中的作用

提供声明式事务;允许用户自定义切面

• 横切关注点:跨越应用程序多个模块的方法或功能。即是，与我们业务逻辑无关的，但是我们需要关注的部分，就是横切关注点。如日志，安全，缓存，事务等等…

• 切面(ASPECT)∶横切关注点被模块化的特殊对象。即，它是一个类。·通知(Advice) :切面必须要完成的工作。即，它是类中的一个方法。

• 目标(Target):被通知对象。

• 代理(Proxy)︰向目标对象应用通知之后创建的对象。

• 切入点(PointCut):切面通知执行的“地点""的定义。

• 连接点（JointPoint) :与切入点匹配的执行点。

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

SpringAOP中，通过Advice定义横切逻辑，Spring中支持5种类型的Advice：

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

8.3、使用Spring实现AOP

【重点】 使用AOP织入，需要导入一个依赖包！

<!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver --><dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId><version>1.9.4</version>
</dependency>

方式一︰使用Spring的API接口**【主要是SpringAPI接口实现】**

方式二︰自定义来实现AOP**【主要是切面定义】 **

方式三：使用注解实现

9、整合MyBatis

步骤:

1.导入相关jar包

​ junit

​ mybatis

​ mysql数据库

spring相关的

aop织入
mybatis-spring 【new】

2.编写配置文件

3.测试

9.1、回顾MyBatis

1.编写实体类

2.编写核心配置文件

3.编写接口

4.编写Mapper.xml

5.测试

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

9.2、MyBatis-spring

1.编写数据源配置

2.sqlSessionFactory

3. sqlSessionTemglate
4. 需要给接口加实现类【】
5. 将自己写的实现类，注入到Spring中
6. 测试使用即可!

10、声明式事务

1、回顾事务

• 把一组业务当成一个业务来做;要么都成功，要么都失败！
• 事务在项目开发中，十分重要，涉及到数据的一致性问题，不能马虎！
• 确保完整性和一致性；

事务ACID原则：

• 原子性
• 一致性
• 隔离性
  • 多个业务可能操作同一个资源，防止数据损坏
• 持久性
  • 事务一旦提交，无论系统发生什么问题，结果都不会再被影响，被持久化的写到存储器中！

2、spring中的事务管理

• 声明式事务：AOP（不影响原有代码）
• 编程式事务：需要在代码中，进行事务的管理

思考：为什么需要事务？

• 如果不配置事务，可能存在数据提交不一致的情况下；
• 如果我们不在Spring中去配置声明式事务，我们就需要在代码中手动配置事务!
• 事务在项目的开发中十分重要，设计到数据的一致性和完整性问题，不容马虎!
  SpringAPI接口实现】**

方式二︰自定义来实现AOP**【主要是切面定义】 **

方式三：使用注解实现

9、整合MyBatis

步骤:

1.导入相关jar包

​ junit

​ mybatis

​ mysql数据库

spring相关的

aop织入
mybatis-spring 【new】

2.编写配置文件

3.测试

9.1、回顾MyBatis

1.编写实体类

2.编写核心配置文件

3.编写接口

4.编写Mapper.xml

5.测试

[外链图片转存中…(img-V2gO0uGu-1658389976899)]

9.2、MyBatis-spring

1.编写数据源配置

2.sqlSessionFactory

3. sqlSessionTemglate
4. 需要给接口加实现类【】
5. 将自己写的实现类，注入到Spring中
6. 测试使用即可!

10、声明式事务

1、回顾事务

• 把一组业务当成一个业务来做;要么都成功，要么都失败！
• 事务在项目开发中，十分重要，涉及到数据的一致性问题，不能马虎！
• 确保完整性和一致性；

事务ACID原则：

• 原子性
• 一致性
• 隔离性
  • 多个业务可能操作同一个资源，防止数据损坏
• 持久性
  • 事务一旦提交，无论系统发生什么问题，结果都不会再被影响，被持久化的写到存储器中！

2、spring中的事务管理

• 声明式事务：AOP（不影响原有代码）
• 编程式事务：需要在代码中，进行事务的管理

思考：为什么需要事务？

• 如果不配置事务，可能存在数据提交不一致的情况下；
• 如果我们不在Spring中去配置声明式事务，我们就需要在代码中手动配置事务!
• 事务在项目的开发中十分重要，设计到数据的一致性和完整性问题，不容马虎!