Spring学习之路
1、Spring
前言
本文是根据狂神Spring整理而成，仅供学习交流使用，侵删。
1.1、简介
-
Spring:春天--------->软件行业的春天
-
2002，首次推出了Spring的雏形：interface21框架！
-
spring框架即以interface21框架位基础，经过重新设计，并不断丰富其内涵，于2004年3月24号发布了1.0正式版。
-
Rod Johnson, spring framework创始人，悉尼大学的音乐学博士
-
spring设计理念：实现有的技术跟价容易使用，本身是一个大杂烩，整合了现有的技术框架！
-
SSH：Struct2+Spring+Hibernate!
-
SSM:SpringMVC+Spring+Mybatis!
官网：https://docs.spring.io/spring-framework/docs/current/reference/html/index.html
官方下载地址：https://repo.spring.io/release/org/springframework/
GitHub:https://github.com/spring-projects/spring-framework
<dependency>
<groupId>org.springframeworkgroupId>
<artifactId>spring-webmvcartifactId>
<version>5.2.0.RELEASEversion>
dependency>
<dependency>
<groupId>org.springframeworkgroupId>
<artifactId>spring-jdbcartifactId>
<version>5.2.0.RELEASEversion>
dependency>
1.2、优点
- Spring是一个开源的免费的框架（容器）！
- Spring是一个轻量级的、非入侵式的框架！
- 控制反转(IOC)，面向切面编程（AOP）
- 支持事务的处理，对框架整合的支持
总结：spring就是一个轻量级的控制反转（IOC）和面向切面编程（AOP）的框架！
1.3、spring的组成
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-a0yniWqO-1648563258308)(C:%5CUsers%5Cfayoung%5CAppData%5CRoaming%5CTypora%5Ctypora-user-images%5Cimage-20210328130806972.png)]
1.4、拓展
介绍：现代化的Java开发！说白了就是基于Spring的开发！
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zyLKV2rs-1648563258309)(C:%5CUsers%5Cfayoung%5CAppData%5CRoaming%5CTypora%5Ctypora-user-images%5Cimage-20210328131056437.png)]
- Spring Boot
- 一个快速开发的脚手架
- 基于SpringBoot可以快速的开发单个微服务
- 约定大于配置
- Spring Cloud
- Spring Cloud 是基于SpringBoot实现的
现在在多数公司都在使用SpringBoot进行快速开发，学校SpringBoot的前提，需要完全掌握Spring及SpringMVC!
承上启下的作用！
弊端：发展太久，违背了原来的理念！配置十分繁琐，人称：“配置地狱”
2、IOC理论推导
- UserDao接口
- UserDaoImpl实现类
- UserService业务接口
- UserServiceImpl 业务实现类
在我们之前的业务中，用户的需求可以拿会影响我们原来写的代码，我们需要根据用户的需求去修改员代码！如果程序代码量十分大，修改一次的成本代价十分昂贵。
我们使用一个Set接口实现，发生了革命性的变化！
//利用set进行动态实现值的注入！
public void setUserDao(UserDao userDao) {
this.userDao = userDao;
}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-kBw6AXlG-1648563258310)(C:%5CUsers%5Cfayoung%5CAppData%5CRoaming%5CTypora%5Ctypora-user-images%5Cimage-20210328141405325.png)]
- 之前，程序是主动创建对象！控制权在程序员手上！
- 使用了set注入后，程序不再具有主动性，而是变成了被动的接受对象！
这种思想，从本质上解决了问题，我们程序员不用再去管理对象的创建了。系统的耦合性大大降低，可以更加专注在业务的实现上！这是IOC的原型！
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-SO3sb7qT-1648563258311)(C:%5CUsers%5Cfayoung%5CAppData%5CRoaming%5CTypora%5Ctypora-user-images%5Cimage-20210328141423143.png)]
IOC本质
控制反转IOC（Inversion of Control），是一种设计思想，DI（依赖注入）是实现IOC的一种方法，也有人任务DI只是IOC的另一种说法。没有IOC的程序中，我们使用面向对象编程，对象的创建于对象间的依赖关系完全硬编程在重新中，对象的创建由程序自己控制，控制反转后将对象的创建转移给第三方，个人认为事务控制反转就是：获得依赖对象的方式反转了。
采用XML方式配置Bean的时候，Bean的定义信息是和实现分离的，而采用注解的方式可以把两者合为一体，Bean的定义信息直接以注解的形式定义在实现类中，从而达到零配置的目的。
控制反转是一种通过描述（XML或注解）并通过第三方去生产会回去特定对象的方式。在Spring中实现控制反转是是IOC容器，其实现方法是依赖注入（Dependency Injection,DI）
3、HelloSpring
1.先创建一个POJO
package com.fayoung.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 + '\'' +
'}';
}
}
2.配置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
https://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="hello" class="com.fayoung.pojo.Hello">
<property name="str" value="Spring"/>
bean>
beans>
3.测试
import com.fayoung.pojo.Hello;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MyTest {
public static void main(String[] args) {
//获取Spring的上下文对象
ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
//我们的对象都在Spring中管理了，我们要使用，直接去里面去出来就可以了
Hello hello = (Hello) context.getBean("hello");
System.out.println(hello.toString());
}
}
思考问题：
-
Hello对象是谁创建的？
hello的对象是由Spring创建的
-
hello对象的属性是这么设置的？
hello的对象的属性是由Spring容器设置的
这个过程就叫做控制反转：
控制：谁来控制对象的创建，传统应用程序的对象是由程序本身控制创建的，使用Spring后，对象是由Spring来创建。
反转：程序本身不创建对象，而变成被动的接受对象。
依赖注入：就是利用set方法来进行注入的
IOC是一种编程思想，由主动的编程编程被动的接受
到了现在，我们彻底不用在程序中其改动代码了，要实现不同的操作，只需要在XML中配置文件中进行修改，所谓的IOC，就是：对象由Spring来创建，管理，装配！
4、IOC创建对象的方式
1.使用无参构造创建对象，默认！
2.假设我们要使用有参构造创建对象。
-
下标赋值
<bean id="user" class="com.fayoung.pojo.User"> <constructor-arg index="0" value="fayoung学Java"/> bean> -
类型
<bean id="user" class="com.fayoung.pojo.User"> <constructor-arg type="java.lang.String" value="fayoung"/> bean> -
参数名
<bean id="user" class="com.fayoung.pojo.User"> <constructor-arg name="name" value="fayoung"/> bean>
总结：在配置文件加载的时候，容器中管理的对象就已经初始化了！
5、Spring配置
5.1、别名
<alias name="user" alias="abc"/>
5.2、Bean的配置
<bean id="user2" class="com.fayoung.pojo.User2" name="userT,abc">
<property name="name" value="fayoung"/>
bean>
5.3、import
这个import，一般用于团队开发使用，他可以将多个配置文件，导入合并为一个。
假设，现在项目中有多个人开发，这三个人复制不同的类开发，不同的类需要注册在不同的bean中，我们可以利用import，将所有人的beans.xml合并为一个总的！
使用的时候，直接使用总的配置就可以了
<import resource="beans.xml"/>
<import resource="beans2.xml"/>
<import resource="beans3.xml"/>
6、DI依赖注入
6.1、构造器注入
参考前文
6.2、Set方式注入【重点】
- 依赖注入：Set注入！
- 依赖：bean对象的创建依赖于容器
- 注入：bean对象中所有属性，由容器注入！
【环境搭建】
-
复杂类型
package com.fayoung.pojo; public class Address { private String address; public String getAddress() { return address; } public void setAddress(String address) { this.address = address; } } -
真实测试对象
package com.fayoung.pojo; import java.util.*; public class Student { private String name; private Address address; private String[] books; private List<String> hobbies; private Map<String,String> card; private Set<String > game; private Properties info; private String wife; @Override public String toString() { return "Student{" + "name='" + name + '\'' + ", address=" + address + ", books=" + Arrays.toString(books) + ", hobbies=" + hobbies + ", card=" + card + ", game=" + game + ", info=" + info + ", wife='" + wife + '\'' + '}'; } public String getName() { return name; } public void setName(String name) { this.name = name; } public Address getAddress() { return address; } public void setAddress(Address address) { this.address = address; } public String[] getBooks() { return books; } public void setBooks(String[] books) { this.books = books; } public List<String> getHobbies() { return hobbies; } public void setHobbies(List<String> hobbies) { this.hobbies = hobbies; } public Map<String, String> getCard() { return card; } public void setCard(Map<String, String> card) { this.card = card; } public Set<String> getGame() { return game; } public void setGame(Set<String> game) { this.game = game; } public Properties getInfo() { return info; } public void setInfo(Properties info) { this.info = info; } public String getWife() { return wife; } public void setWife(String wife) { this.wife = wife; } } -
beans.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 https://www.springframework.org/schema/beans/spring-beans.xsd"> <bean id="student" class="com.fayoung.pojo.Student"> <property name="name" value="fayoung"/> bean> beans> -
测试类
public class MyTest { public static void main(String[] args) { ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml"); Student student = (Student) context.getBean("student"); System.out.println(student.getName()); } }5、完善注入信息
<bean id="student" class="com.fayoung.pojo.Student"> <property name="name" value="fayoung"/> <property name="address" ref="address"/> <property name="books"> <array> <value>红楼梦value> <value>西游记value> <value>水浒传value> <value>三国演义value> array> property> <property name="hobbies"> <list> <value>唱value> <value>跳value> <value>rapvalue> list> property> <property name="card"> <map> <entry key="校园卡" value="2019102062"/> map> property> <property name="game"> <set> <value>刺客信条：奥德赛value> <value>大表哥value> <value>人类一败涂地value> set> property> <property name="wife"> <null/> property> <property name="info"> <props> <prop key="学号">2019102062prop> <prop key="性别">男prop> props> property> bean> <bean id="address" class="com.fayoung.pojo.Address"> <property name="address" value="南昌"/> bean>
6.3、拓展方式注入
我们可以使用p命名空间和c命名空间注入
官方解释：
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-aC7fKgkG-1648563258312)(Spring.assets/image-20210328205211881.png)]
xml配置：
<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"
xmlns:c="http://www.springframework.org/schema/c"
xsi:schemaLocation="http://www.springframework.org/schema/beans
https://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="user" class="com.fayoung.pojo.User" p:name="fayoung" p:age="22"/>
<bean id="user2" class="com.fayoung.pojo.User" c:age="22" c:name="fayoung"/>
beans>
测试：
@Test
public void test2(){
ApplicationContext context = new ClassPathXmlApplicationContext("userbean.xml");
User user = context.getBean("user2", User.class);
System.out.println(user);
}
注意点：p命名和c命名空间不能直接使用，需要导入xml约束
6.4、bean的作用域
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-K0K5jYzN-1648563258313)(Spring.assets/image-20210329213030818.png)]
-
单例模式（Spring默认模式）
<bean id="user2" class="com.fayoung.pojo.User" scope="singleton"/> -
原型模式：每次从容器中get的时候，都会产生一个新对象！
<bean id="accountService" class="com.something.DefaultAccountService" scope="prototype"/> -
其余的request、session、application 这些只能在web开发中使用到！
7、Bean的自动装配
- 自动装配是Spring满足bean依赖的一种方式！
- Spring会在上下文中自动寻找，并自动给bean装配属性！
在Spring中有三种装配的方式
- 在xml中显示配置
- 在java中显示配置
- 隐式的自动装配bean【重要】
7.1、测试
环境搭建：一个人有两个宠物
7.2、自动装配
- byName
<bean id="people" class="com.fayoung.pojo.People" autowire="byName">
<property name="name" value="fayoung"/>
bean>
- byType
<bean id="people" class="com.fayoung.pojo.People" autowire="byType">
<property name="name" value="fayoung"/>
bean>bean>
小结：
- byName的时候，需要保证所有bean的id唯一，并且这个bean需要和自动注入的属性的set方法的值一致！
- byType的时候，需要保证所有bean的class唯一，并且这个bean需要和自动注入的属性的类型一致！
7.3、使用注解实现自动装配
jdk1.5支持的注解，Spring2.5就支持注解了！
The introduction of annotation-based configuration raised the question of whether this approach is “better” than XML.
要使用注解须知：
- 导入约束 context约束
- 配置注解的支持
<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!
科普：
@Nullable //字段标记了这个注解，说明这个字段可以为null
public @interface Autowired {
boolean required() default true;
}
public class People {
//如果显示定义了Autowired的request属性为false，说明这个对象可以为null,否则不允许为空
@Autowired(required = false)
private Cat cat;
@Autowired
private Dog dog;
private String name;
}
如果@Autowired自动装配的环境比较复杂，自动装配无法通过一个注解【@Autowired】 完成的时候，我们可以使用@Qualifier(value=“XXXX”)去配合@Autowired的使用，指定一个唯一的bean对象注入
@Autowired
@Qualifier(value = "cat1")
private Cat cat;
@Autowired
@Qualifier(value ="dog22")
private Dog dog;
@Resource注解
public class People{
@Request(name="cat2")
private Cat cat;
@Request(name="dog2")
private Dog dog;
}
@Resource和@Autowired的区别：
-
都是用来指定装配的，都可以放在属性自字段上
-
@Autowired 通过byName的方式实现，而且必须要求这个对象存在【常用】
-
@Resource默认通过byName的方式实现，如果找不到名字，则通过byType实现！如果两个都找不的情况下，就报错【常用】
-
执行顺序不同：@Resource默认通过byName的方式实现，@Autowired 通过byName的方式实现
8、使用注解开发
在Spring4之后，要使用注解开发，必须要保证aop的包导入了
在使用需要导入需要导入context约束，增加注解的支持！
<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>
-
bean
-
属性如何注入
@Component public class User { public String name; //相当于@Value("fayoung") public void setName(String name) { this.name = name; } } -
衍生的注解
@Component有几个衍生注解，我们在web开发中，会按照mvc三层架构分层！
-
dao 【@Repository】
-
service 【@Service】
-
controller【@Controller】
这四个注解功能都是一样的，都是代表将某个类注册到Spring中，装配Bean
-
-
自动装配注解
- @Autowired : 自动装配通过类型。名字 如果Autowired不能唯一自动装配上属性，则需要通过@qualifier(value="xxx") - @Nullable 字段标记了这个注解，说明这个字段可以为null; - @Resource : 自动装配通过名字。类型 -
作用域
@Scope("singleton") @Component public class User { public String name; //相当于@Value("fayoung") public void setName(String name) { this.name = name; } } -
小结
xml与注解：
- xml更加万能，适用于任何场合！维护简单方便
- 注解 不是自己类使用不了，维护相对复杂
最佳实践
-
xml用来管理bean；
-
注解只负责完成属性的注入；
-
我们在使用的过程中，只需要注意一个问题：要让注解生效，就需要开启注解的支持
<context:component-scan base-package="com.fayoung"/> <context:annotation-config/>
9、使用Java的方式配置Spring
我们现在要完全不使用Spring的配置了，全权交给Java来做！
javaConfig是spring的一个子项目，在spring4之后，他成为了一个核心功能！
实体类
package com.fayoung.pojo;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
@Component这个也会被Spring容器托管，注册到容器中，因为他本来就是一个Component
public class User {
private String name;
public String getName(){
return name;
}
@Value("fayoung")//属性注入值
public void setName(String name){
this.name = name;
}
@Override
public String toString() {
return "User{" +
"name='" + name + '\'' +
'}';
}
}
配置类
package com.fayoung.Config;
import com.fayoung.pojo.User;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
@Configuration
//@Configuration代表这是一个配置类，就和我们之前看的beans.xml
@ComponentScan("com.fayoung.pojo")
@Import(FayoungConfig2.class)
public class FayoungConfig {
//注册一个bean,就相当于我们之前写的一个bean标签
//这个方法的名字，就相当于bean标签中的id属性
//这方法的返回值，就相当于bean标签中的class属性
@Bean
public User User(){
return new User();//就是返回要注入到bean的对象！
}
}
测试类
public class MyTest {
public static void main(String[] args) {
//如果完全使用了配置类方法去做，我们就只能通过AnnotationConfig 上下文来获取容器，通过配置类的class对象加载！
ApplicationContext context = new AnnotationConfigApplicationContext(FayoungConfig.class);
User getUser = (User) context.getBean("User");
System.out.println(getUser.getName());
}
}
这种纯Java的配置方式，在SpringBoot中随处可见！
10、代理模式
为什么要学习代理模式？
因为这个就是SpringAOP的底层！【SpringAOP和SpringMVC】
代理模式的分类：
- 静态代理
- 动态代理
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Vlhr0rV9-1648563258314)(Spring.assets/image-20210331210304690.png)]
10.1、静态代理
角色分析：
- 抽象角色：一般会使用接口或者抽象类来解决
- 真实角色：被代理的角色
- 代理角色：代理真实角色，代理真实角色后，我们一般会做一些附属操作
- 客户：访问代理对象的人
代码步骤：
-
接口
//租房 public interface Rent { public void rent(); } -
真实角色
//房东 public class Host implements Rent{ @Override public void rent() { System.out.println("房东要出租房子！"); } } -
代理角色
public class Proxy implements Rent{ private Host host; public Proxy() { } public Proxy(Host host) { this.host = host; } public void rent() { host.rent(); seeHouse(); contract(); charge(); } //看房 public void seeHouse(){ System.out.println("中介带你看房"); } //收中介费 public void charge(){ System.out.println("收中介费"); } //合同 public void contract(){ System.out.println("签合同"); } } -
客户段访问代理角色
public class Client { public static void main(String[] args) { //房东要出租房子 Host host = new Host(); //代理，中介帮房东出租房子。代理一般会有一些附属操作 Proxy proxy = new Proxy(host); //你不用面对房东，直接找中介租房即可！ proxy.rent(); } }
代理模式的好处：
- 可以使真实角色的操作更加纯粹！不用区关注一些公共的业务
- 公共业务也就交给了代理角色！实现了业务的分工！
- 公共业务发生拓展的时候，方便集中管理
缺点：
- 一个真实角色就会产生以恶代理角色；代码量就会翻倍，开发效率就会降低
10.2、加深理解
代码：spring-08-demo02
AOP实现：
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-IJtpZxXK-1648563258315)(Spring.assets/image-20210331215828331.png)]
10.3、动态代理
- 动态代理和静态代理角色一样
- 动态代理的代理类是动态生成的，不是我们直接写好的！
- 动态代理分为两大类：基于接口的动态代理，基于类的动态代理
- 基于接口----JDK动态代理
- 基于类：cglib
- java字节码实现：javasist
需要理解两个类：Proxy: 代理, InvocationHandier：调用处理程序
动态代理的好处：
- 可以使真实角色的操作更加纯粹！不用区关注一些公共的业务
- 公共业务也就交给了代理角色！实现了业务的分工！
- 公共业务发生拓展的时候，方便集中管理
- 一个动态代理类代理的是一个接口，一般对应的一类业务
- 一个动态代理类可以代理多个类，只要实现了同一个接口即可
11、AOP
11.1、什么是AOP
AOP（Aspect Oriented Programming）意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高开发的效率。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-uwbwZM76-1648563258315)(Spring.assets/20200409224308164.png)]
11.2、AOP在Spring中的作用
提供声明式事务；允许用户自定义切面
- 横切关注点：跨越应用程序多个模块的方法或功能。即是，与我们业务逻辑无关的，但是我们需要关注的部分，就是横切关注点。入日志，安全，缓存，事务等等…
- 切面（Aspect）：横切关注点 被模块化的特殊对象。切面就是一个类
- 通知(Advice):切面必须完成的工作。它是类中的一个方法。
- 目标(Tar):被通知的对象
- 代理(Proxy):向目标对象应用通知之后创建的对象.
- 切入点(PointCut):切面通知 执行的"地点"的定义
- 连接点(JointPoint):与切入点匹配的执行点
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wKD3dvRw-1648563258316)(Spring.assets/20200409224329828.png)]
SpringAOP中,通过Advice定义横切逻辑,Spring中支持5种类型的Advice:
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wS8KMIkN-1648563258317)(Spring.assets/20200409224348776.png)]
即AOP在不改变原有代码的情况下,去增加新功能.
11.3、使用Spring实现AOP
使用AOP织入,需要导入一个依赖包!
<dependency>
<groupId>org.aspectjgroupId>
<artifactId>aspectjweaverartifactId>
<version>1.9.5version>
dependency>
方式一:使用Spring的API接口 (主要SpringAPI接口实现)
方式二:自定义来实现（主要是切面定义）
方式三:使用注解实现!
12、整合Mybatis
步骤：
-
导入相关的jar包
- junit
- mybatis
- mysql数据库
- spring相关的
- aop织入
- mybatis-spring【new】
<dependencies> <dependency> <groupId>junitgroupId> <artifactId>junitartifactId> <version>4.12version> dependency> <dependency> <groupId>mysqlgroupId> <artifactId>mysql-connector-javaartifactId> <version>5.1.47version> dependency> <dependency> <groupId>org.mybatisgroupId> <artifactId>mybatisartifactId> <version>3.5.2version> dependency> <dependency> <groupId>org.springframeworkgroupId> <artifactId>spring-webmvcartifactId> <version>5.2.0.RELEASEversion> dependency> <dependency> <groupId>org.springframeworkgroupId> <artifactId>spring-jdbcartifactId> <version>5.3.4version> dependency> <dependency> <groupId>org.aspectjgroupId> <artifactId>aspectjweaverartifactId> <version>1.9.5version> dependency> <dependency> <groupId>org.mybatisgroupId> <artifactId>mybatis-springartifactId> <version>2.0.6version> dependency> dependencies> -
编写配置文件
-
测试
12.1、回忆配置mybatis
- 编写实体类
- 编写核心配置文件
- 编写接口
- 编写Mapper.xml
- 测试
12.2、Mybatis-spring
- 编写数据源配置
- sqlSessionFactory
- sqlSessionTemplate
- 需要给接口加实现类【】
- 将自己写的实现类，注入到Spring中
- 测试使用
看mybatis-spring文档
13、声明式事务
1、回顾事务
- 要么都成功，要么都失败
- 事务在项目开发中，十分的重要，涉及到数据的一致性问题，不能马虎！
- 确保完整性和一致性
事务ACID原则：
- 原子性
- 一致性
- 隔离性
- 多个业务可能操作同一个资源，防止数据损坏
- 持久性
- 事务一旦提交，无论系统发生声明问题，结果都不会再被影响，被持久化的写到存储器中
2、spring中的事务管理
- 声明式事务：AOP
- 编程式事务：需要在代码中，实现事务的管理
为什么需要事务？
- 如果不配置事务，可能存在数据提交不一致的情况
- 如果不再spring中配置声明式事务，我们就需要在代码中手动配置事务
- 事务在项目开发中十分重要，涉及到数据的一致性和完整性问题