初始MyBatis ,详细步骤运行第一个MyBatis程序,同时对应步骤MyBatis底层剖析
1. 初始MyBatis ,详细步骤运行第一个MyBatis程序,同时对应步骤MyBatis底层剖析
@
每博一文案
才华果然比金钱更耀眼
2. 前沿知识
2.1 框架(framework)
Java当中常见的框架:
- SSM三大框架:Spring + SpringMVC + MyBatis
- SpringBoot
- SpringCloud
- ......
框架其实就是对通用代码的封装,被提前写好的一大堆接口和类(供你使用),我们可以在做项目的时候直接引入这些接口和类(引入框架),基于这些现有的接口和类进行开发,可以大大提高开发效率。
框架一般都是以jar
包的形式存在。(jar 包中有 class 文件以及各种配置文件等。)
SSM三大框架的学习顺序:MyBatis,Spring,SpringMVC 。因为 MyBatis 框架和后面两个 Spring,SpringMVC 比较的独立开来了,可以先学。
关于Spring 框架的内容,大家感兴趣的可以移步至:✏️✏️✏️ Spring_ChinaRainbowSea的博客-CSDN博客
2.2 三层架构
- 表示层(直接跟前端进行交互的,一是接受前端 AJAX 请求,二是返回 JSON 数据给前端)
- 业务逻辑层:一是处理表现层转发过来的前端请求(也就是具体的业务),二是将从持久层获取的数据返回到表示层。
- 数据访问层:直接操作数据库完成CRUD,并获得数据返回到上一层(也就是业务逻辑层)
- Java持久层框架:
关于持久层的框架有如下这些:
- MyBatis
- Hibernate(实现了JPA规范)
- jOOQ
- Guzz
- Spring Data(实现了JPA 规范)
- ActiveJDBC
- ......
更多关于三层架构的内容,大家可以移步至:✏️✏️✏️ MVC 三层架构案例详细讲解_mvc三层架构-CSDN博客
2.3 分析 JDBC 的缺点
我们先观察,分析如下代码的
示例1:
// ......
// sql语句写死在java程序中
String sql = "insert into t_user(id,idCard,username,password,birth,gender,email,city,street,zipcode,phone,grade) values(?,?,?,?,?,?,?,?,?,?,?,?)";
PreparedStatement ps = conn.prepareStatement(sql);
// 繁琐的赋值:思考一下,这种有规律的代码能不能通过反射机制来做自动化。
ps.setString(1, "1");
ps.setString(2, "123456789");
ps.setString(3, "zhangsan");
ps.setString(4, "123456");
ps.setString(5, "1980-10-11");
ps.setString(6, "男");
ps.setString(7, "zhangsan@126.com");
ps.setString(8, "北京");
ps.setString(9, "大兴区凉水河二街");
ps.setString(10, "1000000");
ps.setString(11, "16398574152");
ps.setString(12, "A");
// 执行SQL
int count = ps.executeUpdate();
// ......
示例2:
// ......
// sql语句写死在java程序中
String sql = "select id,idCard,username,password,birth,gender,email,city,street,zipcode,phone,grade from t_user";
PreparedStatement ps = conn.prepareStatement(sql);
ResultSet rs = ps.executeQuery();
List<User> userList = new ArrayList<>();
// 思考以下循环中的所有代码是否可以使用反射进行自动化封装。
while(rs.next()){
// 获取数据
String id = rs.getString("id");
String idCard = rs.getString("idCard");
String username = rs.getString("username");
String password = rs.getString("password");
String birth = rs.getString("birth");
String gender = rs.getString("gender");
String email = rs.getString("email");
String city = rs.getString("city");
String street = rs.getString("street");
String zipcode = rs.getString("zipcode");
String phone = rs.getString("phone");
String grade = rs.getString("grade");
// 创建对象
User user = new User();
// 给对象属性赋值
user.setId(id);
user.setIdCard(idCard);
user.setUsername(username);
user.setPassword(password);
user.setBirth(birth);
user.setGender(gender);
user.setEmail(email);
user.setCity(city);
user.setStreet(street);
user.setZipcode(zipcode);
user.setPhone(phone);
user.setGrade(grade);
// 添加到集合
userList.add(user);
}
// ......
JDBC的不足点:
SQL语句写牢在了Java程序当中了,不灵活,改SQL的话,就要改Java代码,违背了开闭原则OCP。
给
?
占位符传值是繁琐的,不能自动化将结果集封装成Java对象也是比较繁琐的,不能自动化
关于这些自动化的问题,以及OCP开闭原则,运用下面我们正在学习的MyBatis 可以得到一个很好的解决方案。
关于JDBC的更多详细内容,大家可以移步至:✏️✏️✏️ JDBC_ChinaRainbowSea的博客-CSDN博客
3. 初始了解MyBatis
MyBatis 本质上就是对JDBC的封装,通过MyBatis完成CRUD。
MyBatis 在三层架构中负责持久层,属于持久层框架。
MyBatis的发展历程:这里【引用百度百科】
- MyBatis本是apache的一个开源项目iBatis,2010年这个项目由apache software foundation迁移到了[google code](https://baike.baidu.com/item/google code/2346604?fromModule=lemma_inlink),并且改名为MyBatis。2013年11月迁移到Github。
- iBATIS一词来源于“internet”和“abatis”的组合,是一个基于Java的持久层框架。iBATIS提供的持久层框架包括SQL Maps和Data Access Objects(DAOs)。
- 当前,最新版本是MyBatis 3.5.13,其发布时间是2023年03月11日。
打开MyBatis 代码可以看到它的包结构中包含:ibatis
ORM :对象关系映射。
O (object) :Java虚拟机中的Java对象。
R(Relational):关系型数据库
M(Mapping):将Java虚拟机中的Java对象映射到数据库表中一行记录,或是将数据库表中一行记录映射成Java虚拟机中的一个Java对象。
ORM示图:
MyBatis 框架就是一个ORM框架。
MyBatis可以干啥?
java 对象 < ------ > 数据库表中的一条记录
像User 这样在图中,有特殊的称呼: 有的人把它叫做:pojo(普通Java类) 有的叫做: JavaBean (咖啡豆) 有的叫做: domain(领域模型)
MyBatis 是一个半自动化的ORM,因为MyBatis 框架中SQL语句是需要程序员自己写的。
Hibernate 框架是一个全自动化的ORM 使用Hibenrnate 框架的时候,不需要程序员手动编写SQL语句,SQL语句可以自动生成,所以Hibernate 是一个完全的全自动化的ORM框架。
这里我们的主题是 MyBatis 。
MyBatis 框架特点:
- 支持定制化SQL,存储过程,基本映射以及高级映射
- 避免了几乎所有的 JDBC代码中手动设置参数以及获取结果集。
- 支持XML 开发,也支持注解开发。【为了保证 SQL 语句的灵活,所有MyBatis 大部分采用 XML方式开发。】
- 将接口和 Java 的 POJOs(Plain Ordinary Java Object ,简单普通的Java对象)映射成数据库中的记录
- 体积小,好学,两个jar 包,两个 XML 配置文件
- 完全做到 SQL 解耦合
- 提供了基本映射标签
- 提供了高级映射标签
- 提供了XML标签,支持动态SQL的编写。
4. MyBatis第一个入门程序
4.1 MyBatis下载
- 从github上下载,地址:https://github.com/mybatis/mybatis-3
将框架以及框架的源码都下载下来,下载框架后解压,打开mybatis目录
-
通过以上解压可以看到,框架一般都是以jar包的形式存在。我们的mybatis课程使用 maven,所以这个jar我们不需要。
-
官方手册需要。但是,这个官方文档是英文的,对应英文不好的朋友,大家可以来的这个网站:https://mybatis.net.cn/ 是一个 mybatis 的中文网站。
4.2 MyBatis入门程序开发步骤
首先我们先准备好数据库信息
准备数据库表:汽车表t_car,字段包括:
id:主键(自增)【bigint】
car_num:汽车编号【varchar】
brand:品牌【varchar】
guide_price:厂家指导价【decimal类型,专门为财务数据准备的类型】
produce_time:生产时间【char,年月日即可,10个长度,'2022-10-11'】
car_type:汽车类型(燃油车、电车、氢能源)【varchar】
DROP TABLE IF EXISTS `t_car`;
CREATE TABLE `t_car` (
`id` bigint NOT NULL AUTO_INCREMENT COMMENT '主键,和业务没有关系,自增',
`car_num` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NULL DEFAULT NULL COMMENT '汽车编号',
`brand` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NULL DEFAULT NULL COMMENT '汽车品牌',
`guide_price` decimal(10, 2) NULL DEFAULT NULL COMMENT '厂商指导价格',
`produce_time` char(10) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NULL DEFAULT NULL COMMENT '生产日期',
`car_type` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NULL DEFAULT NULL COMMENT '汽车类型,燃油车,氢能源',
PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 33 CHARACTER SET = utf8mb4 COLLATE = utf8mb4_unicode_ci ROW_FORMAT = Dynamic;
INSERT INTO `t_car` VALUES (1, '1001', '宝马520Li', 10.00, '2020-10-11', '燃油车');
INSERT INTO `t_car` VALUES (2, '1002', '奔驰E300L', 55.00, '2020-11-11', '新能源');
INSERT INTO `t_car` VALUES (5, '1003', '丰田霸道', 30.00, '2000-10-11', '燃油车');
创建Project:建议创建Empty Project,设置Java版本以及编译版本等。
创建Module:普通的Maven Java模块
第一步:通过maven 在 pom.xml
文件当中引入相关依赖。
mybatis依赖 ,mysql依赖
<!--mybatis核心依赖-->
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>3.5.10</version>
</dependency>
<!--mysql驱动依赖-->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>8.0.30</version>
</dependency>
<?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>com.ranbowsea</groupId>
<artifactId>mybatis-001-introduction</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>jar</packaging>
<properties>
<maven.compiler.source>17</maven.compiler.source>
<maven.compiler.target>17</maven.compiler.target>
</properties>
<dependencies>
<!--mybatis核心依赖-->
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>3.5.10</version>
</dependency>
<!--mysql驱动依赖-->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>8.0.30</version>
</dependency>
</dependencies>
</project>
第二步:在 resources
根(类)目录下新建 mybatis-config.xml
(文件名随意)配置文件(可以参考mybatis手册拷贝 (https://mybatis.net.cn/getting-started.html))
注意:
- 第一,这个文件名不是必须叫 mybatis-config.xml,可以用其他的名字,只是大家都采用这个名字。
- 这个文件存放的位置也不是固定的,可以随意,但一般情况下,会放到类的根路径下
关于这两点的注意事项,该文章的后面,会详细说明。请继续看下去。
<?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>
<environments default="development">
<environment id="development">
<transactionManager type="JDBC"/>
<dataSource type="POOLED">
<property name="driver" value="com.mysql.cj.jdbc.Driver"/>
<property name="url" value="jdbc:mysql://localhost:3306/powernode"/>
<property name="username" value="root"/>
<property name="password" value="root"/>
</dataSource>
</environment>
</environments>
<mappers>
<!--sql映射文件创建好之后,需要将该文件路径配置到这里-->
<mapper resource=""/>
</mappers>
</configuration>
第三步:编写XxxMapper.xml 文件
在这个配置文件当编写SQL语句。
这个文件名也不是固定的,放的位置也不是固定的,我们这里给它起个名字,叫做:CarMapper.xml (mapper 英文单词是“映射”的意思),把它暂时放到类的根路径下。
在resources根目录下新建CarMapper.xml配置文件(可以参考mybatis手册拷贝)
同时我们在其中编写一条SQL语句,一条insert 插入的SQL语句。
注意编写的是 insert 插入的SQL语句所以,在该 xml 文件中用,<insert> 标签进行定义编写。如下:
而在<insert> 标签当中,需要定义一个 id 属性的值,该
insert语句,id是这个条SQL语句的唯一标识,这个id就代表了这条SQL语句
<!-- insert语句,id是这个条SQL语句的唯一标识,这个id就代表了这条SQL语句 --> <insert id="insertCar"> insert into t_car(id,car_num,brand,guide_price,produce_time,car_type) values (null,'1003','丰田霸道',30.0,'2000-10-11','燃油车') </insert> // 因为我们的 id 是主键,自增的,所以可以不赋值。为 null ,让其进行一个自增的效果。
因为我们的 id 是主键,自增的,所以可以不赋值。为 null ,让其进行一个自增的效果。
注意1:sql语句最后结尾可以不写“;”
注意2:CarMapper.xml文件的名字不是固定的。可以使用其它名字。
注意3:CarMapper.xml文件的位置也是随意的。这里选择放在resources根下,相当于放到了类的根路径下。
注意4:将CarMapper.xml文件路径配置到mybatis-config.xml:
<?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">
<!--namespace先随意写一个-->
<mapper namespace="fas">
<!-- insert语句,id是这个条SQL语句的唯一标识,这个id就代表了这条SQL语句 -->
<insert id="insertCar">
insert into t_car(id,car_num,brand,guide_price,produce_time,car_type)
values (null,'1003','丰田霸道',30.0,'2000-10-11','燃油车')
</insert>
</mapper>
第四步: 在mybatis-config.xml 文件中指定XxxMapper.xml 文件的路径
就是将我们上面配置的 XxxMapper.xml(这里是 CarMapper.xml)
的SQL语句的映射文件创建好,将该文件所在位置的路径,填入到 <mapper resource="xxx">
当中,让MyBatis 框架可以顺利的找到它,并执行其中的SQL语句。注意:resource 属性会自动从类的根路径下开始查找资源。
<mapper resource="CarMapper.xml">
注意: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>
<environments default="development">
<environment id="development">
<!-- MANAGED 没有用第三框架管理的话,都是会被提交的,没有事务上的管理了。-->
<transactionManager type="JDBC"/>
<dataSource type="POOLED">
<property name="driver" value="com.mysql.cj.jdbc.Driver"/>
<property name="url" value="jdbc:mysql://localhost:3306/mybatis"/>
<property name="username" value="root"/>
<property name="password" value="MySQL123"/>
</dataSource>
</environment>
</environments>
<mappers>
<!--sql映射文件创建好之后,需要将该文件路径配置到这里-->
<!-- 执行XxxMapper.xml 文件的路径-->
<!-- resource 属性自动会从类的根路径下开始查找资源-->
<mapper resource="CarMapper.xml"/>
</mappers>
</configuration>
第五步: 编写MyBatis 测试程序(使用MyBatis的类库,编写myBatis 程序,该数据库,做增删改查就行了)
首先我们需要知道,在MyBatis 当中,负责执行SQL语句的是哪个对象,同时又该如何获取到该对象。
负责执行 SQL语句的对象是: SqlSession
SqlSession 是专门来执行 SQL语句的,是一个Java程序和数据库之间的一次会话
想要获取到 SqlSession 对象,就需要先获取SqlSessionFactory 对象,通过SqlSessionFactory 工厂的openSession( ) 方法,来生产 SqlSession 对象。
那怎么湖获取SqlSessionFactory 对象
通过SqlSessionFactoryBuilder 对象的 build( ) 方法,来获取一个SqlSessionFactory 对象。
总结:
MyBatis的核心对象包括:
SqlSessionFactoryBuilder
SqlSessionFactory
SqlSessionSqlSessionFactoryBuilder-->SqlSessionFactory-->SqlSession
注意事项:
int count = sqlSession.insert("insertCar"); // 这个"insertCar"必须是sql的id
该insert(id) 就是,我们上面 CarMapper.xml SQL映射文件当中编写的 SQL 语句(这里是 <insert> 标签当中的 id 的属性值,保持一致)
同时需要:
执行 sqlSession.commit(); 提交数据给数据库(和JDBC是一样的); 提交(mybatis默认采用的事务管理器是JDBC,默认是不提交的,需要手动提交。)
以及执行: sqlSession.close(); 关闭资源,注意:仅仅是关闭资源,并不会提交数据的。
// 5. 提交(mybatis默认采用的事务管理器是JDBC,默认是不提交的,需要手动提交。) sqlSession.commit(); // 6. 关闭资源(只关闭是不会提交的) sqlSession.close();
完整执行代码:
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
public class MyBatisIntroductionTest {
public static void main(String[] args) {
// 1. 创建SqlSessionFactoryBuilder对象
SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
// 2. 创建SqlSessionFactory对象
InputStream is = Thread.currentThread().getContextClassLoader().getResourceAsStream("mybatis-config.xml");
SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(is);
// 3. 创建SqlSession对象
SqlSession sqlSession = sqlSessionFactory.openSession();
// 4. 执行sql
int count = sqlSession.insert("insertCar"); // 这个"insertCar"必须是sql的id
System.out.println("插入几条数据:" + count);
// 5. 提交(mybatis默认采用的事务管理器是JDBC,默认是不提交的,需要手动提交。)
sqlSession.commit();
// 6. 关闭资源(只关闭是不会提交的)
sqlSession.close();
}
}
运行结果:
MyBatis 第一个入门程序小总结:
第一: 在MyBatis中一定是有一个很重要的对象,这个对象是:SqlSessionFactory对象
第二: SqlSessionFactory 对象的创建需要 xml
xml 是什么?它是一个配置文件
MyBatis中有两个主要的配置文件:
- mybatis-config.xml ,这是核心配置文件,主要配置连接数据库的信息等(一般是第一个数据库一个),同样的与之对应的通过
mybatis-config.xml
的配置文件创建的对象 SqlSessionFactoryBuilder,SqlSessionFactory 也是一个数据库一个对象 。- XxxMapper.xml ,这个是专门用来编写SQL语句的配置文件(一个数据表一个)。
t_user 表,一般会对应一个UserMapper.xml
t_student 表,一般会对应一个StudentMapper.xml
4.3 MyBatis 的第一个入门程序的细节问题
- 在MyBatis 中的SQ语句的结尾“;” 可以省略的。
- 在 MyBatis 当中的 SQL语句错误的,异常信息是:
java.sql.SQLSyntaxErrorException
该异常表示是你的SQL语句写的不对,SQL语法可能存在问题。
- 在MyBatis 当中的工具类: Resource.getResourceAsStream( ) 方法。
小技巧:以后凡是遇到 resource 这个单词,大部分情况下,这种加载资源的方式就是从
(resource)
类路径下开始检索加载的。例如: 下面三种获取 IO流文件的,检索方式都是从类路径下开始的。
InputStream is = Resources.getResourceAsStream("mybatis-config.xml"); InputStream is = Thread.currentThread().getContextClassLoader().getResourceAsStream("mybatis-config.xml"); InputStream is = ClassLoader.getSystemClassLoader().getResourceAsStream("mybatis-config.xml"); // 使用类加载器
采用从 (resource)类路径 加载文件的优点:
采用这种方式,从类的路径当种加载资源,项目的移植性很强,项目从Windwos移植到Linux,没有路径上的问题
而下面这个是:从系统的绝对路径开始加载的
InputStream stream = new FileInputStream("E:\\mybatis-config.xml");
采用系统的绝对路径加载文件资源的缺点:
可移植性差,程序不够健壮,可能移植到其他的操作系统当中,导致以上路径无效,比如Linux,因为Linux系统是没有所谓的D盘,C盘之类的说法。所以想要移植到Linux当中运行的话,还需要修改Java代码才行。这样就违背了OCP原则了。
5. 关于MyBatis核心配置文件的名字和路径详解
MyBatis 的核心配置文件就是,我们上述的名为 mybatis-config.xml
的配置文件。
已经验证过了,mybatis 核心配置文件的名字,不一定是:mybatis-config.xml 。mybatis 核心配置文件存放的路径,也不一定是类的根路径,可以放到其他的位置,但是为了项目的移植性。健壮性,最好将这个配置文件放到类路径下面。
同理的对应的 SQL 映射文件 XxxMapper.xml 文件的路径也可以不放在根(类)路径下,不过如果 SQL 映射文件 XxxMapper.xml 文件是根据 系统的绝对路径 来的话,需要用 <url> 标签。如下:
重点:注意的是,无论是 MyBatis 的核心配置文件,还是对应的 SQL 映射文件 XxxMapper.xml 文件,如果文件含义目录的话,一定要带上目录才行如下:
源码解析:MyBatis 工具类的:InputStream is = Resources.getResourceAsStream("mybatis-config.xml") 的底层调用的机制。
> InputStream is = ClassLoader.getSystemClassLoader().getResourceAsStream("mybatis-config.xml")
> ClassLoader.getSystemClassLoader() 获取系统的类加载器。
> 系统类加载器有一个方法叫做:getResourceAsSteam
> 它就是从类路径当中加载资源的
> 通过源代码分析发现:
> InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
> 底层的源代码其实现就是:
> InputStream is = ClasLoader.getSystemClassLoader().getResourceAsStream("mybatis-config.xml");
>
6. 关于 mybatis 的事务管理机制(深度剖析)
关于 mybatis 的事务管理机制:
在mybatis-config.xml 文件中,可以通过以下的配置进行 mybatis 的事务处理。
通过:**<transactionManager type="JDBC"> ** 标签进行设置即可。
type 的属性值包括两个:
- JDBC (jdbc)
- MANGED(managed)
type 后面的值,只有以上两个值可以选择,不区分大小写。
在mybatis 中提供了两种事务管理机制。
- 第一种 JDBC事务管理器
MyBatis 框架自己管理事务,自己采用原生的JDBC 代码去管理事务
> conn.setAutoCommit(false);开启事务,false 是默认的,可以不用写
> ...业务处理...
> conn.commit(); 手动提交事务
使用JDBC事务管理器的话,底层创建的事务管理器对象,jdbcTransaction对象。
如果你编写的代码是下面的代码:
SqlSession sqlSession = sqlSessionFactory.openSession(true);
表示没有开启事务,因为这种方式压根不会执行,com.setAutoCommit(false)
在JDBC事务中,没有执行com.setAutoCommit(false);那么autoCommit就是true.
如果autoCommit 是 true ,就表示没有开启事务,只要执行任意一条DML语句就提交了一次
我们可以进行一个 Debug 调试,进行一个检查
这里我们用默认的 false ,也可以不填,都是 false
SqlSession sqlSession = sqlSessionFactory.openSession();
SqlSession sqlSession = sqlSessionFactory.openSession(false);
下面我们设置为:true
在
- 第二种 MANAGED 是事务管理器
在
<!-- MANAGED 没有用第三框架管理的话,都是会被提交的,没有事务上的管理了。-->
<transactionManager type="MANAGED"/>
MyBatis 说,我不管事务了(会自动提交数据给数据库),你来负责吧(Spring)
如果对于我们当前的单纯的只有 MyBatis 的情况下,如果配置为:MANAGED ,那么事务这块是没人管的,没有人管理事务标识,事务压根没有开启,后面我们可以配合使用Spring 进行事务上的管理。
关于 MyBatis 配合Spring 开启事务的详细内容,大家可以移步至:✏️✏️✏️ Spring6 对 集成MyBatis 开发运用(附有详细的操作步骤)-CSDN博客
7. MyBatis第一个比较完整的代码写法
resources 的配置文件下的信息。
CarMapper.xml SQL 语句的映射文件
<?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">
<!--namespace先随意写一个-->
<mapper namespace="fas">
<!-- insert语句,id是这个条SQL语句的唯一标识,这个id就代表了这条SQL语句 -->
<insert id="insertCar">
insert into t_car(id,car_num,brand,guide_price,produce_time,car_type)
values (null,'1003','丰田霸道',30.0,'2000-10-11','燃油车');
</insert>
</mapper>
mybatis-config.xml 的MyBatis 的核心配置文件。
<?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>
<!-- 开启mybatis 对标准日志的实现-->
<!-- 如果导入的第三方框架的日志,没有下面这个 settings 也是可以的-->
<!-- <settings>-->
<!-- <setting name="logImpl" value="STDOUT_LOGGING"/>-->
<!-- </settings>-->
<environments default="development">
<environment id="development">
<!-- MANAGED 没有用第三框架管理的话,都是会被提交的,没有事务上的管理了。-->
<transactionManager type="JDBC"/>
<dataSource type="POOLED">
<property name="driver" value="com.mysql.cj.jdbc.Driver"/>
<property name="url" value="jdbc:mysql://localhost:3306/mybatis"/>
<property name="username" value="root"/>
<property name="password" value="MySQL123"/>
</dataSource>
</environment>
</environments>
<mappers>
<!--sql映射文件创建好之后,需要将该文件路径配置到这里-->
<!-- 执行XxxMapper.xml 文件的路径-->
<!-- resource 属性自动会从类的根路径下开始查找资源-->
<!-- <mapper resource="CarMapper.xml"/>-->
<mapper resource="com/CarMapper2.xml"/>
<!-- url属性: 从绝对路径当中加载资源。-->
<!-- 语法格式:file:///绝对路径-->
<!-- <mapper url="file:///e:/CarMapper.xml"></mapper>-->
</mappers>
</configuration>
运行测试程序:
package com.rainbowsea.mybatis.test;
import com.ranbowsea.mybatis.utils.SqlSessionUtil;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.Test;
import java.io.IOException;
public class MyBatisCompleteTest {
public static void main(String[] args) {
// 获取到SqlSessionFactoryBuilder 对象
SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
SqlSession sqlSession = null;
try {
// 获取到SqlSessionFactoryBuilder 一个数据库对应一个 SqlSessionFactoryBuilder
SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(Resources.getResourceAsReader("mybatis-config.xml"));
// 获取到SqlSession对象
sqlSession = sqlSessionFactory.openSession();
sqlSession.insert("insertCar");// 对应 执行SQL语句对应的数据表的 XxxMapper.xml当中,对应SQL语句的id
// 执行到这里,提交事务,终止事务
sqlSession.commit();
} catch (IOException e) {
if(sqlSession != null) { // 上面可能 sqlSession 还是为空
// 回滚事务
sqlSession.rollback();
}
throw new RuntimeException(e);
} finally {
if(sqlSession != null) {
// 关闭会话
sqlSession.close();
}
}
}
}
8. MyBatis 引入日志框架
8.1 使用 MyBatis 自带的日志框架
引入日志框架的目的:是为了看清楚MyBatis执行的具体的 SQL语句,以及赋值内容。
启动MyBatis 自带的标准日志组件,只需要在mybatis-config.xml
MyBatis 的核心配置文件中添加配置文件【可参考mybatis 手册https://mybatis.net.cn/logging.html】
关于mybatis 集成日志组件,让我们调试起来更加方便。
mybatis常见的集成的日志组件有哪些呢?
SLF4J(沙拉风)
LOG4J
LOG$J2
STDOUT_LOGGING
...
注意:log4j log4j2 logback都是同一个作者开发的。
其中STDOUT_LOGGING 是标准日志,mybatis已经实现了这种标准日志,mybatis框架本身已经实现了这种
标准。只要开启即可,怎么开启呢?在mybatis-config.xml文件中使用settings标签进行配置开启。
<settings>
<setting name="logImpl" value="STDOUT_LOGGING" />
</settings>
注意:
这个标签在编写的时候要注意,它必须在 environments 标签之前(不然会报错的),注意顺序,当然,不需要记忆这个顺序。
因为有dtd文件进行约束呢。我们只要参考did约束即可
<?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>
<!-- 开启mybatis 对标准日志的实现-->
<settings>
<setting name="logImpl" value="STDOUT_LOGGING"/>
</settings>
<environments default="development">
<environment id="development">
<!-- MANAGED 没有用第三框架管理的话,都是会被提交的,没有事务上的管理了。-->
<transactionManager type="JDBC"/>
<dataSource type="POOLED">
<property name="driver" value="com.mysql.cj.jdbc.Driver"/>
<property name="url" value="jdbc:mysql://localhost:3306/mybatis"/>
<property name="username" value="root"/>
<property name="password" value="MySQL123"/>
</dataSource>
</environment>
</environments>
<mappers>
<!--sql映射文件创建好之后,需要将该文件路径配置到这里-->
<!-- 执行XxxMapper.xml 文件的路径-->
<!-- resource 属性自动会从类的根路径下开始查找资源-->
<!-- <mapper resource="CarMapper.xml"/>-->
<mapper resource="com/CarMapper2.xml"/>
<!-- url属性: 从绝对路径当中加载资源。-->
<!-- 语法格式:file:///绝对路径-->
<!-- <mapper url="file:///e:/CarMapper.xml"></mapper>-->
</mappers>
</configuration>
运行测试:
8.2 引入 logback 日志框架
上述的MyBatis 自带的日志框架,这种实现也是可以的,可以看到一些信息,比如:连接对象什么时候创建,什么时候关闭,sql语句是怎样的
但是没有详细的日期,线程名字,等,如果你想使用更加丰富的配置,可以集成第三方Log组件。
同时配置也不够灵活,我们可以集成其他的日志组件,例如:log4j,logback等。
- logback是目前日志框架中性能较好的,较流行的,所以我们选它。
- 引入logback的步骤:
logback 日志框架实现了slf4j标准(沙拉风,日志门面,日志标准)
第一步: 引入logback的依赖
我们需要在项目的 pom.xml
配置文件当中,引入 logbakc 的依赖,通过 maven 进行导入。
<!-- 引入 logback的依赖,这个日志框架实现了slf4j 规范-->
<dependency>
<groupId>ch.qos.logback</groupId>
<artifactId>logback-classic</artifactId>
<version>1.2.11</version>
</dependency>
<?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>com.ranbowsea</groupId>
<artifactId>mybatis-001-introduction</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>jar</packaging>
<properties>
<maven.compiler.source>17</maven.compiler.source>
<maven.compiler.target>17</maven.compiler.target>
</properties>
<dependencies>
<!--mybatis核心依赖-->
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>3.5.10</version>
</dependency>
<!--mysql驱动依赖-->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>8.0.30</version>
</dependency>
<!-- junit 依赖-->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.13.2</version>
<scope>test</scope>
</dependency>
<!-- 引入 logback的依赖,这个日志框架实现了slf4j 规范-->
<dependency>
<groupId>ch.qos.logback</groupId>
<artifactId>logback-classic</artifactId>
<version>1.2.11</version>
</dependency>
</dependencies>
</project>
第二步:如logback所必须的 xml 配置文件
注意:这个配置文件的名字必须叫做:logback.xml
或者 logback-test.xml
不能是其他的名字
并且这个配置文件必须放到类的根路径下,不能是其他位置。
<?xml version="1.0" encoding="UTF-8"?>
<configuration debug="false">
<!-- 控制台输出 -->
<appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
<encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
<!--格式化输出:%d表示日期,%thread表示线程名,%-5level:级别从左显示5个字符宽度%msg:日志消息,%n是换行符-->
<pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
</encoder>
</appender>
<!-- 按照每天生成日志文件 -->
<appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
<rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
<!--日志文件输出的文件名-->
<FileNamePattern>${LOG_HOME}/TestWeb.log.%d{yyyy-MM-dd}.log</FileNamePattern>
<!--日志文件保留天数-->
<MaxHistory>30</MaxHistory>
</rollingPolicy>
<encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
<!--格式化输出:%d表示日期,%thread表示线程名,%-5level:级别从左显示5个字符宽度%msg:日志消息,%n是换行符-->
<pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
</encoder>
<!--日志文件最大的大小-->
<triggeringPolicy class="ch.qos.logback.core.rolling.SizeBasedTriggeringPolicy">
<MaxFileSize>100MB</MaxFileSize>
</triggeringPolicy>
</appender>
<!--mybatis log configure-->
<logger name="com.apache.ibatis" level="TRACE"/>
<logger name="java.sql.Connection" level="DEBUG"/>
<logger name="java.sql.Statement" level="DEBUG"/>
<logger name="java.sql.PreparedStatement" level="DEBUG"/>
<!-- 日志输出级别,logback日志级别包括五个:TRACE < DEBUG < INFO < WARN < ERROR -->
<root level="DEBUG">
<appender-ref ref="STDOUT"/>
<appender-ref ref="FILE"/>
</root>
</configuration>
<?xml version="1.0" encoding="UTF-8"?>
<configuration debug="false">
<!-- 控制台输出 -->
<appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
<encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
<!--格式化输出:%d表示日期,%thread表示线程名,%-5level:级别从左显示5个字符宽度%msg:日志消息,%n是换行符-->
<pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
</encoder>
</appender>
<!--mybatis log configure-->
<logger name="com.apache.ibatis" level="TRACE"/>
<logger name="java.sql.Connection" level="DEBUG"/>
<logger name="java.sql.Statement" level="DEBUG"/>
<logger name="java.sql.PreparedStatement" level="DEBUG"/>
<!-- 日志输出级别,logback日志级别包括五个:TRACE < DEBUG < INFO < WARN < ERROR -->
<root level="ERROR">
<appender-ref ref="STDOUT"/>
<appender-ref ref="FILE"/>
</root>
</configuration>
配置好以后,我们运行看看。
package com.rainbowsea.mybatis.test;
import com.ranbowsea.mybatis.utils.SqlSessionUtil;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.Test;
import java.io.IOException;
public class MyBatisCompleteTest {
public static void main(String[] args) {
// 获取到SqlSessionFactoryBuilder 对象
SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
SqlSession sqlSession = null;
try {
// 获取到SqlSessionFactoryBuilder 一个数据库对应一个 SqlSessionFactoryBuilder
SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(Resources.getResourceAsReader("mybatis-config.xml"));
// 获取到SqlSession对象
sqlSession = sqlSessionFactory.openSession();
sqlSession.insert("insertCar");// 对应 执行SQL语句对应的数据表的 XxxMapper.xml当中,对应SQL语句的id
// 执行到这里,提交事务,终止事务
sqlSession.commit();
} catch (IOException e) {
if(sqlSession != null) { // 上面可能 sqlSession 还是为空
// 回滚事务
sqlSession.rollback();
}
throw new RuntimeException(e);
} finally {
if(sqlSession != null) {
// 关闭会话
sqlSession.close();
}
}
}
}
9. 总结:
MyBatis 本质上就是对JDBC的封装,通过MyBatis完成CRUD。MyBatis 在三层架构中负责持久层,属于持久层框架。
MyBatis 的包目录,路径是 ibatis 。不是 mybatis 。这一点需要注意清楚明白。
mybatis 核心配置文件的名字,不一定是:mybatis-config.xml 。mybatis 核心配置文件存放的路径,也不一定是类的根路径,可以放到其他的位置,但是为了项目的移植性。健壮性,最好将这个配置文件放到类路径下面。
MyBatis 的SQL 映射文件XxxMapper.xml 和MyBatis 的核心配置文件, mybatis-config.xml 都尽量放到类(resources) 根路径下 ,为了项目的移植性。健壮性,最好将这个配置文件放到类路径下面。
小技巧:以后凡是遇到 resource 这个单词,大部分情况下,这种加载资源的方式就是从
(resource)
类路径下开始检索加载的。例如: 下面三种获取 IO流文件的,检索方式都是从类路径下开始的。
InputStream is = Resources.getResourceAsStream("mybatis-config.xml"); InputStream is = Thread.currentThread().getContextClassLoader().getResourceAsStream("mybatis-config.xml"); InputStream is = ClassLoader.getSystemClassLoader().getResourceAsStream("mybatis-config.xml"); // 使用类加载器
在mybatis 中提供了两种事务管理机制
第一种 JDBC事务管理器
MyBatis 框架自己管理事务,自己采用原生的JDBC 代码去管理事务
> conn.setAutoCommit(false);开启事务,false 是默认的,可以不用写 > ...业务处理... > conn.commit(); 手动提交事务
使用JDBC事务管理器的话,底层创建的事务管理器对象,jdbcTransaction对象。
在
JDBC事务管理器 下,SqlSession sqlSession = sqlSessionFactory.openSession( 不填,或者 false); 表示开启事务了(需要自己手动提交,sqlSession.commit()😉,填 true 表示关闭了事务,自动就会提交了 第二种 MANAGED 是事务管理器
在
mybatis 不再负责事务的管理了,事务管理交给其他容器来负责,例如:Spring 。 如果对于我们当前的单纯的只有 MyBatis 的情况下,如果配置为:MANAGED ,那么事务这块是没人管的,没有人管理事务标识,事务压根没有开启,后面我们可以配合使用Spring 进行事务上的管理。
引入日志框架的目的:是为了看清楚MyBatis执行的具体的 SQL语句,以及赋值内容。
启动MyBatis 自带的标准日志组件,只需要在
mybatis-config.xml
MyBatis 的核心配置文件中添加配置文件<settings> <setting name="logImpl" value="STDOUT_LOGGING" /> </settings>
setting 这个标签在编写的时候要注意,它必须在 environments 标签之前(不然会报错的),注意顺序,当然,不需要记忆这个顺序。
引入 logback 日志框架。导入的依赖
<!-- 引入 logback的依赖,这个日志框架实现了slf4j 规范--> <dependency> <groupId>ch.qos.logback</groupId> <artifactId>logback-classic</artifactId> <version>1.2.11</version> </dependency>
如logback所必须的 xml 配置文件**
注意:这个配置文件的名字必须叫做:
logback.xml
或者logback-test.xml
不能是其他的名字
并且这个配置文件必须放到类的根路径下,不能是其他位置。
10. 最后:
“在这个最后的篇章中,我要表达我对每一位读者的感激之情。你们的关注和回复是我创作的动力源泉,我从你们身上吸取了无尽的灵感与勇气。我会将你们的鼓励留在心底,继续在其他的领域奋斗。感谢你们,我们总会在某个时刻再次相遇。”