[Java]Spring6(动力节点老杜)
Posted 萤火虫的小尾巴
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了[Java]Spring6(动力节点老杜)相关的知识，希望对你有一定的参考价值。
文章目录
🥽 课件&资料
老杜Spring6课件：https://www.yuque.com/docs/share/866abad4-7106-45e7-afcd-245a733b073f?# 《Spring6》
密码：mg9b
资料：https://pan.baidu.com/s/1HsmuLXtGLxifwNGr4vu1Rw?pwd=1234
提取码：1234
🥽 Spring启示录
🌊 OCP开闭原则
- 什么是OCP？
- OCP是软件七大开发原则当中最基本的一个原则：开闭原则
- 对什么开？对扩展开放。
- 对什么闭？对修改关闭。
- OCP原则是最核心的，最基本的，其他的六个原则都是为这个原则服务的。
- OCP开闭原则的核心是什么？
- 只要你在扩展系统功能的时候，没有修改以前写好的代码，那么你就是符合OCP原则的。
- 反之，如果在扩展系统功能的时候，你修改了之前的代码，那么这个设计是失败的，违背OCP原则。
- 当进行系统功能扩展的时候，如果动了之前稳定的程序，修改了之前的程序，之前所有程序都需要进行重新测试。这是不想看到的，因为非常麻烦。
🌊 依赖倒置原则（DIP原则）
- 什么是依赖倒置原则？
- 面向接口编程，面向抽象编程，不要面向具体编程。
- 依赖倒置原则的目的？
- 降低程序的耦合度，提高扩展力。
- 什么叫做符合依赖倒置？
- 上 不依赖 下，就是符合。
- 什么叫做违背依赖倒置？
- 上 依赖 下，就是违背。
- 只要“下”一改动，“上”就受到牵连。
🌊 控制反转
- 当前程序的设计，显然既违背OCP，又违背DIP，怎么办？
- 可以采用“控制反转”这种编程思想来解决这个问题。
- 什么是控制反转？
- 控制反转：IoC（Inversion of Control）
- 反转是什么呢？
- 反转的是两件事：
- 第一件事：我不在程序中采用硬编码的方式来new对象了。（new对象我不管了，new对象的权利交出去了。）
- 第二件事：我不在程序中采用硬编码的方式来维护对象的关系了。（对象之间关系的维护权，我也不管了，交出去了。）
- 控制反转：是一种编程思想。或者叫做一种新型的设计模式。由于出现的比较新，没有被纳入GoF23种设计模式范围内。
- 控制反转的核心是：将对象的创建权交出去，将对象和对象之间关系的管理权交出去，由第三方容器来负责创建与维护。
🌊 Spring框架
- Spring框架实现了控制反转IoC这种思想
- Spring框架可以帮你new对象。
- Spring框架可以帮你维护对象和对象之间的关系。
- Spring是一个实现了IoC思想的容器。
🌊 依赖注入
- 控制反转的实现方式有多种，其中比较重要的叫做：依赖注入(Dependency Injection，简称DI)。
- 控制反转是思想。依赖注入是这种思想的具体实现。
- 依赖注入DI，又包括常见的两种方式：
- 第一种：set注入（执行set方法给属性赋值）
- 第二种：构造方法注入（执行构造方法给属性赋值）
- 依赖注入 中 “依赖”是什么意思？ “注入”是什么意思？
- 依赖：A对象和B对象的关系。
- 注入：是一种手段，通过这种手段，可以让A对象和B对象产生关系。
- 依赖注入：对象A和对象B之间的关系，靠注入的手段来维护。而注入包括：set注入和构造注入。
注意术语：
OCP：开闭原则（开发原则）
DIP：依赖倒置原则（开发原则）
IoC：控制反转（一种思想，一种新型的设计模式）
DI：依赖注入（控制反转思想的具体实现方式）
🥽 Spring概述
🌊 Spring简介
- Spring是一个开源框架，它由Rod Johnson创建。它是为了解决企业应用开发的复杂性而创建的。
- 从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。
- Spring是一个轻量级的控制反转(IoC)和面向切面(AOP)的容器框架。
- Spring最初的出现是为了解决EJB臃肿的设计，以及难以测试等问题。
- Spring为简化开发而生，让程序员只需关注核心业务的实现，尽可能的不再关注非业务逻辑代码（事务控制，安全日志等）。
🌊 Spring8大模块
注意：Spring5版本之后是8个模块。在Spring5中新增了WebFlux模块。
-
Spring Core模块
这是Spring框架最基础的部分，它提供了依赖注入（DependencyInjection）特征来实现容器对Bean的管理。核心容器的主要组件是 BeanFactory，BeanFactory是工厂模式的一个实现，是任何Spring应用的核心。它使用IoC将应用配置和依赖从实际的应用代码中分离出来。 -
Spring Context模块
如果说核心模块中的BeanFactory使Spring成为容器的话，那么上下文模块就是Spring成为框架的原因。
这个模块扩展了BeanFactory，增加了对国际化（I18N）消息、事件传播、验证的支持。另外提供了许多企业服务，例如电子邮件、JNDI访问、EJB集成、远程以及时序调度（scheduling）服务。也包括了对模版框架例如Velocity和FreeMarker集成的支持 -
Spring AOP模块
Spring在它的AOP模块中提供了对面向切面编程的丰富支持，Spring AOP 模块为基于 Spring 的应用程序中的对象提供了事务管理服务。通过使用 Spring AOP，不用依赖组件，就可以将声明性事务管理集成到应用程序中，可以自定义拦截器、切点、日志等操作。 -
Spring DAO模块
提供了一个JDBC的抽象层和异常层次结构，消除了烦琐的JDBC编码和数据库厂商特有的错误代码解析，用于简化JDBC。 -
Spring ORM模块
Spring提供了ORM模块。Spring并不试图实现它自己的ORM解决方案，而是为几种流行的ORM框架提供了集成方案，包括Hibernate、JDO和iBATIS SQL映射，这些都遵从 Spring 的通用事务和 DAO 异常层次结构。 -
Spring Web MVC模块
Spring为构建Web应用提供了一个功能全面的MVC框架。虽然Spring可以很容易地与其它MVC框架集成，例如Struts，但Spring的MVC框架使用IoC对控制逻辑和业务对象提供了完全的分离。 -
Spring WebFlux模块
Spring Framework 中包含的原始 Web 框架 Spring Web MVC 是专门为 Servlet API 和 Servlet 容器构建的。反应式堆栈 Web 框架 Spring WebFlux 是在 5.0 版的后期添加的。它是完全非阻塞的，支持反应式流(Reactive Stream)背压，并在Netty，Undertow和Servlet 3.1+容器等服务器上运行。
-
Spring Web模块
Web 上下文模块建立在应用程序上下文模块之上，为基于 Web 的应用程序提供了上下文，提供了Spring和其它Web框架的集成，比如Struts、WebWork。还提供了一些面向服务支持，例如：实现文件上传的multipart请求。
🌊 Spring特点
- 轻量
- 从大小与开销两方面而言Spring都是轻量的。完整的Spring框架可以在一个大小只有1MB多的JAR文件里发布。并且Spring所需的处理开销也是微不足道的。
- Spring是非侵入式的：Spring应用中的对象不依赖于Spring的特定类。
- 非侵入式，spring框架的运行不需要依赖其他框架
- 控制反转
- Spring通过一种称作控制反转（IoC）的技术促进了松耦合。当应用了IoC，一个对象依赖的其它对象会通过被动的方式传递进来，而不是这个对象自己创建或者查找依赖对象。你可以认为IoC与JNDI相反——不是对象从容器中查找依赖，而是容器在对象初始化时不等对象请求就主动将依赖传递给它。
- 面向切面
- Spring提供了面向切面编程的丰富支持，允许通过分离应用的业务逻辑与系统级服务（例如审计（auditing）和事务（transaction）管理）进行内聚性的开发。应用对象只实现它们应该做的——完成业务逻辑——仅此而已。它们并不负责（甚至是意识）其它的系统级关注点，例如日志或事务支持。
- 容器
- Spring包含并管理应用对象的配置和生命周期，在这个意义上它是一种容器，你可以配置你的每个bean如何被创建——基于一个可配置原型（prototype），你的bean可以创建一个单独的实例或者每次需要时都生成一个新的实例——以及它们是如何相互关联的。然而，Spring不应该被混同于传统的重量级的EJB容器，它们经常是庞大与笨重的，难以使用。
- 框架
- Spring可以将简单的组件配置、组合成为复杂的应用。在Spring中，应用对象被声明式地组合，典型地是在一个XML文件里。Spring也提供了很多基础功能（事务管理、持久化框架集成等等），将应用逻辑的开发留给了你。
所有Spring的这些特征使你能够编写更干净、更可管理、并且更易于测试的代码。它们也为Spring中的各种模块提供了基础支持。
- Spring可以将简单的组件配置、组合成为复杂的应用。在Spring中，应用对象被声明式地组合，典型地是在一个XML文件里。Spring也提供了很多基础功能（事务管理、持久化框架集成等等），将应用逻辑的开发留给了你。
🥽 Spring的入门程序
Spring6要求JDK最低版本是Java17
🌊 Spring5的下载
官网地址：【https://spring.io/】
官网地址（中文）：【http://spring.p2hp.com/】
【https://github.com/spring-projects/spring-framework/wiki/Spring-Framework-Artifacts】
【https://repo.spring.io/artifactory/release/org/springframework/spring/5.3.9/】
🌊 Spring6的下载
官网地址：【https://spring.io/】
官网地址（中文）：【http://spring.p2hp.com/】
【https://github.com/spring-projects/spring-framework/wiki/Spring-Framework-Artifacts】
将下图配置写入pom文件中
🌊 Spring的jar文件
打开libs目录，会看到很多jar包：
- spring-core-5.3.9.jar：字节码（这个是支撑程序运行的jar包）
- spring-core-5.3.9-javadoc.jar：代码中的注释
- spring-core-5.3.9-sources.jar：源码
我们来看一下spring框架都有哪些jar包：
| JAR文件 | 描述 |
|---|---|
| spring-aop-5.3.9.jar | 这个jar 文件包含在应用中使用Spring 的AOP 特性时所需的类 |
| spring-aspects-5.3.9.jar | 提供对AspectJ的支持，以便可以方便的将面向切面的功能集成进IDE中 |
| spring-beans-5.3.9.jar | 这个jar 文件是所有应用都要用到的，它包含访问配置文件、创建和管理bean 以及进行Inversion ofControl / Dependency Injection（IoC/DI）操作相关的所有类。如果应用只需基本的IoC/DI 支持，引入spring-core.jar 及spring-beans.jar 文件就可以了。 |
| spring-context-5.3.9.jar | 这个jar 文件为Spring 核心提供了大量扩展。可以找到使用Spring ApplicationContext特性时所需的全部类，JDNI 所需的全部类，instrumentation组件以及校验Validation 方面的相关类。 |
| spring-context-indexer-5.3.9.jar | 虽然类路径扫描非常快，但是Spring内部存在大量的类，添加此依赖，可以通过在编译时创建候选对象的静态列表来提高大型应用程序的启动性能。 |
| spring-context-support-5.3.9.jar | 用来提供Spring上下文的一些扩展模块,例如实现邮件服务、视图解析、缓存、定时任务调度等 |
| spring-core-5.3.9.jar | Spring 框架基本的核心工具类。Spring 其它组件要都要使用到这个包里的类，是其它组件的基本核心，当然你也可以在自己的应用系统中使用这些工具类。 |
| spring-expression-5.3.9.jar | Spring表达式语言。 |
| spring-instrument-5.3.9.jar | Spring3.0对服务器的代理接口。 |
| spring-jcl-5.3.9.jar | Spring的日志模块。JCL，全称为"Jakarta Commons Logging"，也可称为"Apache Commons Logging"。 |
| spring-jdbc-5.3.9.jar | Spring对JDBC的支持。 |
| spring-jms-5.3.9.jar | 这个jar包提供了对JMS 1.0.2/1.1的支持类。JMS是Java消息服务。属于JavaEE规范之一。 |
| spring-messaging-5.3.9.jar | 为集成messaging api和消息协议提供支持 |
| spring-orm-5.3.9.jar | Spring集成ORM框架的支持，比如集成hibernate，mybatis等。 |
| spring-oxm-5.3.9.jar | 为主流O/X Mapping组件提供了统一层抽象和封装，OXM是Object Xml Mapping。对象和XML之间的相互转换。 |
| spring-r2dbc-5.3.9.jar | Reactive Relational Database Connectivity (关系型数据库的响应式连接) 的缩写。这个jar文件是Spring对r2dbc的支持。 |
| spring-test-5.3.9.jar | 对Junit等测试框架的简单封装。 |
| spring-tx-5.3.9.jar | 为JDBC、Hibernate、JDO、JPA、Beans等提供的一致的声明式和编程式事务管理支持。 |
| spring-web-5.3.9.jar | Spring集成MVC框架的支持，比如集成Struts等。 |
| spring-webflux-5.3.9.jar | WebFlux是 Spring5 添加的新模块，用于 web 的开发，功能和 SpringMVC 类似的，Webflux 使用当前一种比较流程响应式编程出现的框架。 |
| spring-webmvc-5.3.9.jar | SpringMVC框架的类库 |
| spring-websocket-5.3.9.jar | Spring集成WebSocket框架时使用 |
注意：
如果你只是想用Spring的IoC功能，仅需要引入：spring-context即可。将这个jar包添加到classpath当中。
如果采用maven只需要引入context的依赖即可。
<!--Spring6的正式版发布之前，这个仓库地址是需要的-->
<repositories>
<repository>
<id>repository.spring.milestone</id>
<name>Spring Milestone Repository</name>
<url>https://repo.spring.io/milestone</url>
</repository>
</repositories>
<dependencies>
<!--spring context依赖：使用的是6.0.0-M2里程碑版-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>6.0.0-M2</version>
</dependency>
</dependencies>
🌊 第一个Spring程序
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>cw.spring</groupId>
<artifactId>spring-002</artifactId>
<version>1.0-SNAPSHOT</version>
<!-- 打包方式 -->
<packaging>jar</packaging>
<!-- 配置多个仓库 -->
<repositories>
<!-- spring里程碑版本的仓库 -->
<repository>
<id>repository.spring.milestone</id>
<name>Spring Milestone Repository</name>
<url>https://repo.spring.io/milestone</url>
</repository>
</repositories>
<!-- 依赖 -->
<dependencies>
<!--spring context依赖：使用的是6.0.0-M2里程碑版-->
<!--引入spring context依赖，标识引入spring基础依赖-->
<!--如果需要使用spring的其他功能还需要引入相应的依赖-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>6.0.0-M2</version>
</dependency>
<!--junit-->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.13.2</version>
<scope>test</scope>
</dependency>
</dependencies>
<properties>
<maven.compiler.source>17</maven.compiler.source>
<maven.compiler.target>17</maven.compiler.target>
</properties>
</project>
spring框架中管理的每个对象都叫bean
定义bean：User
package cw.spring.bean;
public class User
编写spring的配置文件，该文件放在类的根路径下。
<?xml version="1.0" encoding="UTF-8"?>
<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">
<!-- spring的配置文件 -->
<!-- 该文件放在类的根路径下方便后期的移植 -->
<!-- 放在resources目录下，相当于放在类的根路径下 -->
<!-- 配置bean，spring才能帮助我们管理这个对象 -->
<!--
id: bean的唯一标识
class: 类的全路径
-->
<bean id="userBean" class="cw.spring.bean.User" />
</beans>
编写测试程序
package cw.spring.test;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class SpringTest
@Test
public void springTest()
// 第一步：获取Spring容器对象。
// ApplicationContext 翻译为：应用上下文。其实就是Spring容器。
// ApplicationContext 是一个接口。
// ApplicationContext 接口下有很多实现类。其中有一个实现类叫做：ClassPathXmlApplicationContext
// ClassPathXmlApplicationContext 专门从类路径当中加载spring配置文件的一个Spring上下文对象。
// 这行代码只要执行：就相当于启动了Spring容器，解析spring.xml文件，并且实例化所有的bean对象，放到spring容器当中。
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml");
// 第二步：根据bean的id从Spring容器中获取这个对象。
Object userBean = applicationContext.getBean("userBean");
System.out.println(userBean);
🌊 第一个Spring程序剖析
- 在spring的配置文件中id是不能重名
- spring是通过反射机制调用类的无参数构造方法来创建对象的，所以要想让spring给你创建对象，必须保证无参数构造方法是存在的。
- spring把创建好的对象存储到一个Map当中
- spring配置文件名字是我们负责提供的，spring配置文件的名字是随意的。
- spring的配置文件可以有多个，在ClassPathXmlApplicationContext构造方法的参数上传递文件路径即可。且配置文件的文件名、文件路径都是任意的
//ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring6.xml"); //ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring6.xml", "beans.xml"); ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring6.xml", "beans.xml", "xml/beans.xml"); // 源码： public ClassPathXmlApplicationContext(String... configLocations) throws BeansException this(configLocations, true, (ApplicationContext)null); - 在spring配置文件中配置的bean可以任意类，只要这个类不是抽象的，并且提供了无参数构造方法。
- getBean()方法调用时，id不存在的时候，会出现异常
- getBean()方法返回的类型是Object，如果访问子类的特有属性和方法时，还需要向下转型，有其它办法可以解决这个问题吗？
//Object nowTime = applicationContext.getBean("nowTime"); //Date nowTime = (Date) applicationContext.getBean("nowTime"); // 不想强制类型转换，可以使用以下代码（通过第二个参数来指定返回的bean的类型。） Date nowTime = applicationContext.getBean("nowTime", Date.class); - ClassPathXmlApplicationContext是从类路径中加载配置文件，如果没有在类路径当中，又应该如何加载配置文件呢？
- 没有在类路径中的话，需要使用FileSystemXmlApplicationContext类进行加载配置文件。
- 这种方式较少用。一般都是将配置文件放到类路径当中，这样可移植性更强。
ApplicationContext applicationContext2 = new FileSystemXmlApplicationContext("d:/spring6.xml");
- ApplicationContext的超级父接口BeanFactory。
- BeanFactory是Spring容器的超级接口。ApplicationContext是BeanFactory的子接口。
//ApplicationContext接口的超级父接口是：BeanFactory（翻译为Bean工厂，就是能够生产Bean对象的一个工厂对象。） //BeanFactory是IoC容器的顶级接口。 //Spring的IoC容器底层实际上使用了：工厂模式。 //Spring底层的IoC是怎么实现的？XML解析 + 工厂模式 + 反射机制 //ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring6.xml"); BeanFactory applicationContext = new ClassPathXmlApplicationContext("spring6.xml"); User user = applicationContext.getBean("userBean", User.class); System.out.println(user);
- BeanFactory是Spring容器的超级接口。ApplicationContext是BeanFactory的子接口。
- Spring底层的IoC容器是通过：XML解析+工厂模式+反射机制实现的。
- spring不是在调用getBean()方法的时候创建对象，执行
new ClassPathXmlApplicationContext("spring6.xml");的时候，就会实例化对象。
🌊 Spring6启用Log4j2日志框架
从Spring5之后，Spring框架支持集成的日志框架是Log4j2
第一步：引入Log4j2的依赖
<!--log4j2的依赖-->
<dependency>
<groupId>org.apache.logging.log4j</groupId>
<artifactId>log4j-core</artifactId>
<version>2.19.0</version>
</dependency>
<dependency>
<groupId>org.apache.logging.log4j</groupId>
<artifactId>log4j-slf4j2-impl</artifactId>
<version>2.19.0</version>
</dependency>
第二步：在类的根路径下提供log4j2.xml配置文件（文件名固定为：log4j2.xml，文件必须放到类根路径下。）
<?xml version="1.0" encoding="UTF-8"?>
<configuration>
<loggers>
<!--
level指定日志级别，从低到高的优先级：
ALL < TRACE < DEBUG < INFO < WARN < ERROR < FATAL < OFF
达到相应的级别才会输出日志信息
级别越低输出的日志信息越多
-->
<root level="DEBUG">
<appender-ref ref="spring6log"/>
</root>
</loggers>
<appenders>
<!--输出日志信息到控制台-->
<console name="spring6log" target="SYSTEM_OUT">
<!--控制日志输出的格式-->
<PatternLayout pattern="%dyyyy-MM-dd HH:mm:ss SSS [%t] %-3level %logger1024 - %msg%n"/>
</console>
</appenders>
</configuration>
第三步：使用日志框架
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
// 你自己怎么去使用log4j2记录日志信息呢？
// 第一步：创建日志记录器对象
// 获取FirstSpringTest类的日志记录器对象，也就是说只要是FirstSpringTest类中的代码执行记录日志的话，就输出相关的日志信息。
Logger logger = LoggerFactory.getLogger(FirstSpringTest.class);
// 第二步：记录日志，根据不同的级别来输出日志
logger.info("我是一条消息");
logger.debug("我是一条调试信息");
logger.error("我是一条错误信息");
🥽 Spring对IoC的实现
🌊 IoC 控制反转
- 控制反转是一种思想。
- 控制反转是为了降低程序耦合度，提高程序扩展力，达到OCP原则，达到DIP原则。
- 控制反转，反转的是什么？
- 将对象的创建权利交出去，交给第三方容器负责。
- 将对象和对象之间关系的维护权交出去，交给第三方容器负责。
- 控制反转这种思想如何实现呢？
- DI（Dependency Injection）：依赖注入
🌊 依赖注入
- 依赖注入实现了控制反转的思想。
- Spring通过依赖注入的方式来完成Bean管理的。
- Bean管理说的是：Bean对象的创建，以及Bean对象中属性的赋值（或者叫做Bean对象之间关系的维护）。
- 依赖注入：
- 依赖指的是对象和对象之间的关联关系。
- 注入指的是一种数据传递行为，通过注入行为来让对象和对象产生关系。
- 依赖注入常见的实现方式包括两种：
- 第一种：set注入
- 第二种：构造注入
💦 set注入
set注入，基于set方法实现的，底层会通过反射机制调用属性对应的set方法然后给属性赋值。这种方式要求属性必须对外提供set方法。
public class UserDao
private static final Logger logger = LoggerFactory.getLogger(UserDao.class);
public void insert()
//System.out.println("数据库动力节点Spring框架学习笔记-王鹤spring整合MyBatis
三、spring整合MyBatis
官方下载地址
视频观看地址
https://www.bilibili.com/video/BV1nz4y1d7uy
将 MyBatis 与 Spring 进行整合，主要解决的问题就是将SqlSessionFactory 对象交由 Spring来管理
只需要将 SqlSessionFactory 的对象生成器 SqlSessionFactoryBean 注册在 Spring 容器中，再将其注入给 Dao 的实现类即可完成整合
整合思路
需要有需要有Dao接口的代理对象,例如studentDao需要一个他的代理对象,使用SqlSession.getMapper(StudentDao.class),得到dao代理对象
需要有SqlSessionFactory,创建一个SqlSessionFactory对象,使用SqlSessionFactory.open()得到SqlSession对象
数据源DataSource对象,使用连接池对象替换mybatis自己的PooledDataSource
3.1 maven依赖
maven依赖
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.11</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.2.5.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-tx</artifactId>
<version>5.3.8</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>5.3.8</version>
</dependency>
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>3.5.7</version>
</dependency>
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis-spring</artifactId>
<version>2.0.6</version>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>8.0.25</version>
</dependency>
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid</artifactId>
<version>1.2.1</version>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.18.20</version>
</dependency>
</dependencies>
<build>
<resources>
<resource>
<directory>src/main/java</directory><!--所在的目录-->
<includes><!--包括目录下的.properties,.xml 文件都会扫描到-->
<include>**/*.properties</include>
<include>**/*.xml</include>
</includes>
<filtering>false</filtering>
</resource>
</resources>
</build>
3.2 实体类
- 定义实体类
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Student
private Integer id;
private String name;
private String email;
private Integer age;
3.3 Dao接口与mapper文件
- Dao接口
public interface StudentDao
int insertStudent(Student student);
List<Student> selectStudentList();
- mapper文件
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.jjh.dao.StudentDao">
<insert id="insertStudent">
insert into student values (#id,#name,#email,#age)
</insert>
<select id="selectStudentList" resultType="com.jjh.domain.entity.Student">
select * from student order by id desc
</select>
</mapper>
3.4 service接口与实现类
- service接口
public interface StudentService
int addStudent(Student student);
List<Student> queryAllStudents();
- service实现类
@Service("myStudentService")
public class StudentServiceImpl implements StudentService
@Autowired
private StudentDao studentDao;
@Override
public int addStudent(Student student)
int result = studentDao.insertStudent(student);
return result;
@Override
public List<Student> queryAllStudents()
List<Student> students = studentDao.selectStudentList();
return students;
3.5 MyBatis主配置文件
主配置文件中不再需要数据源的配置了,因为数据源要交给 Spring 容器来管理了
这里对 mapper 映射文件的注册，使用<package/>标签，即只需给出 mapper 映射文件所在的包即可,因为 mapper 的名称与 Dao 接口名相同，可以使用这种简单注册方式。这种方式的好处是，若有多个映射文件，这里的配置也是不用改变的。当然，也可使用原来的<resource/>标签方式
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
<!--settings：控制mybatis全局行为-->
<settings>
<!--设置mybatis输出日志-->
<setting name="logImpl" value="STDOUT_LOGGING"/>
</settings>
<!--设置别名-->
<typeAliases>
<!--实体类别名-->
<!--
package:把包下面所有类名作为别名
name:实体类的包名
-->
<package name="com.jjh.domain.entity"/>
</typeAliases>
<!-- sql mapper(sql映射文件)的位置-->
<mappers>
<!--
package:指定Dao接口包的位置,表示将包下面的sql映射文件找到
name:Dao接口的包名
使用package指定映射文件的要求:
1.sql映射的文件名与Dao接口名一致
2.sql映射文件和Dao接口在同一目录
-->
<package name="com.jjh.dao"/>
</mappers>
</configuration>
3.6 spring的配置文件
- jdbc.properties文件
jdbc.driver=com.mysql.cj.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/mybatis01?serverTimezone=Asia/Shanghai
jdbc.username=root
jdbc.password=123456
该属性文件若要被 Spring 配置文件读取，其必须在配置文件中进行注册。使用<context>标签
<context:property-placeholder/>标签中有一个属性 location，用于指定属性文件的位置
- 注册 SqlSessionFactoryBean
<!--声明的是mybatis中提供的SqlSessionFactoryBean类，这个类内部创建SqlSessionFactory的
SqlSessionFactory sqlSessionFactory = new ..
-->
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
<!--set注入，把数据库连接池付给了dataSource属性-->
<property name="dataSource" ref="myDataSource" />
<!--mybatis主配置文件的位置
configLocation属性是Resource类型，读取配置文件
它的赋值，使用value，指定文件的路径，使用classpath:表示文件的位置
-->
<property name="configLocation" value="classpath:mybatis.xml" />
</bean>
- 定义 Mapper 扫描配置器 MapperScannerConfigurer
Mapper 扫描配置器 MapperScannerConfigurer会自动生成指定的基本包中 mapper 的代理对象 。该 Bean无需设置 id 属性。basePackage 使用分号或逗号设置多个包
<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
<!--指定SqlSessionFactory对象的id-->
<property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
<!--指定包名， 包名是dao接口所在的包名。
MapperScannerConfigurer会扫描这个包中的所有接口，把每个接口都执行
一次getMapper()方法，得到每个接口的dao对象。
创建好的dao对象放入到spring的容器中的。dao对象的默认名称是 接口名首字母小写
-->
<property name="basePackage" value="com.jjh.dao"/>
</bean>
3.7 向service注入接口名
向 Service 注入 Mapper 代理对象时需要注意，由于通过 Mapper 扫描配置器MapperScannerConfigurer生成的 Mapper 代理对象没有名称，所以在向 Service 注入 Mapper代理时，无法通过名称注入。但可通过接口的简单类名注入，因为生成的是这个 Dao 接口的对象。
- 全部配置文件
<context:component-scan base-package="com.jjh.service"/>
<!--
把数据库的配置信息，写在一个独立的文件，编译修改数据库的配置内容
spring知道jdbc.properties文件的位置
-->
<context:property-placeholder location="classpath:jdbc.properties"/>
<!--声明数据源DataSource,作用是连接数据库-->
<bean id="myDataSource" class="com.alibaba.druid.pool.DruidDataSource"
init-method="init" destroy-method="close">
<!--set注入-->
<property name="url" value="$jdbc.url"/>
<property name="username" value="$jdbc.username"/>
<property name="password" value="$jdbc.password"/>
<property name="maxActive" value="20"/>
</bean>
<!--声明的是mybatis中提供的SqlSessionFactoryBean类，这个类内部创建SqlSessionFactory的
SqlSessionFactory sqlSessionFactory = new ..
-->
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
<!--set注入，把数据库连接池付给了dataSource属性-->
<property name="dataSource" ref="myDataSource" />
<!--mybatis主配置文件的位置
configLocation属性是Resource类型，读取配置文件
它的赋值，使用value，指定文件的路径，使用classpath:表示文件的位置
-->
<property name="configLocation" value="classpath:mybatis.xml" />
</bean>
<!--创建dao对象，使用SqlSession的getMapper（StudentDao.class）
MapperScannerConfigurer:在内部调用getMapper()生成每个dao接口的代理对象。
-->
<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
<!--指定SqlSessionFactory对象的id-->
<property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
<!--指定包名， 包名是dao接口所在的包名。
MapperScannerConfigurer会扫描这个包中的所有接口，把每个接口都执行
一次getMapper()方法，得到每个接口的dao对象。
创建好的dao对象放入到spring的容器中的。dao对象的默认名称是 接口名首字母小写
-->
<property name="basePackage" value="com.jjh.dao"/>
</bean>
</beans>
以上是关于[Java]Spring6(动力节点老杜)的主要内容，如果未能解决你的问题，请参考以下文章