## 整合Mybatis
### 简介
Tio-Boot： Tio-Boot 是一个基于 Java 高性能网络编程框架，用于快速搭建 Web 、WebSocket、TCP 等网络应用。在本教程中，通过 Tio-Boot 启动了一个简单的 Web 服务，用于演示整合 MyBatis
MyBatis： MyBatis 是一个持久层框架，用于将 Java 对象和关系型数据库之间进行映射。在本教程中，使用 MyBatis 配置数据源、映射文件以及 Mapper 接口，实现了与数据库的交互
### 使用工具类整合Mybatis
#### 添加依赖
```
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<java.version>1.8</java.version>
<maven.compiler.source>${java.version}</maven.compiler.source>
<maven.compiler.target>${java.version}</maven.compiler.target>
<graalvm.version>23.1.1</graalvm.version>
<tio.boot.version>1.3.0</tio.boot.version>
<lombok-version>1.18.30</lombok-version>
<hotswap-classloader.version>1.2.1</hotswap-classloader.version>
<final.name>web-hello</final.name>
<main.class>com.litongjava.tio.web.hello.HelloApp</main.class>
</properties>
<dependencies>
<dependency>
<groupId>com.litongjava</groupId>
<artifactId>tio-boot</artifactId>
<version>${tio.boot.version}</version>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>${lombok-version}</version>
<optional>true</optional>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>com.litongjava</groupId>
<artifactId>hotswap-classloader</artifactId>
<version>${hotswap-classloader.version}</version>
</dependency>
<!-- mybatis -->
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>3.4.4</version>
</dependency>
<!-- 连接池 -->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid</artifactId>
<version>1.1.10</version>
</dependency>
<!-- 数据库驱动 -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.46</version>
</dependency>
</dependencies>
```上面的依赖除去tio-boot的相关依赖外还有mybatis,druid和mysql-connector-java
- mybatis mybatis依赖
- druid 数据库连接池依赖
- mysql-connector-java mysql驱动依赖
#### 启动tio-boot
编写IndexController
```
package demo.mybatis.controller;
import com.litongjava.tio.http.server.annotation.RequestPath;
@RequestPath("/")
public class IndexController {
@RequestPath()
public String index() {
return "index";
}
}
```编写启动类
```
package demo.mybatis;
import com.litongjava.jfinal.aop.annotation.ComponentScan;
import com.litongjava.tio.boot.TioApplication;
@ComponentScan
public class MybatisApp {
public static void main(String[] args) {
TioApplication.run(MybatisApp.class, args);
}
}
```启动MybatisApp,访问http://localhost 如果可以启动成功说明tio-boot启动成功
#### 准备模拟数据
```
CREATE TABLE system_admin(
id INT PRIMARY KEY AUTO_INCREMENT,
login_name VARCHAR(32),
PASSWORD VARCHAR(32)
);
INSERT INTO system_admin(login_name,PASSWORD) VALUE('litong','00000000');
`````` SELECT * FROM system_admin ```
1. 创建了一个名为`system_admin`的新表。这个表有三个字段：`id`，`login_name`和`PASSWORD`。`id`是一个整数类型的字段，被设置为主键，并且会自动增加。`login_name`和`PASSWORD`都是最多包含32个字符的字符串。
2. 在`system_admin`表中插入了一条新的记录。`login_name`的值被设置为`litong`，`PASSWORD`的值被设置为`00000000`。
#### 整合mybatis
SystemAdmin mybatis的model用于和数据表结构对应
``` package demo.mybatis.model; import lombok.Data; @Data public class SystemAdmin { private int id; private String loginName; private String password; } ```
SystemAdminMapper mybatis的mapper,定义了一个方法getSystemAdmin用户查询数据库
```
package demo.mybatis.mapper;
import demo.mybatis.model.SystemAdmin;
public interface SystemAdminMapper {
public SystemAdmin getSystemAdmin(SystemAdmin systemAdmin);
}
```SystemAdminMapper.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">
<mapper namespace="demo.mybatis.mapper.SystemAdminMapper">
<resultMap type="SystemAdmin" autoMapping="true" id="SystemAdminResult">
<id column="id" jdbcType="INTEGER" property="id" />
<result column="login_name" jdbcType="VARCHAR" property="loginName" />
<result column="password" jdbcType="VARCHAR" property="password" />
</resultMap>
<select id="getSystemAdmin" resultMap="SystemAdminResult">
select * from system_admin where 1=1
<if test="loginName != null and loginName !=''">
and login_name=#{loginName}
</if>
</select>
</mapper>
```SystemAdminMapper.xml
1. `<mapper namespace="demo.mybatis.mapper.SystemAdminMapper">`：这个标签定义了一个命名空间，它通常与对应的Mapper接口的全限定名相匹配。
2. `<resultMap type="SystemAdmin" autoMapping="true" id="SystemAdminResult">`：这个标签定义了一个结果映射，它描述了如何从数据库结果集中的列映射到对象的属性。`type`属性指定了目标类的类型，`autoMapping`属性设置为`true`表示自动映射结果集的列到类的属性，`id`属性是这个结果映射的唯一标识符。
3. `<id column="id" jdbcType="INTEGER" property="id" />`：这个标签表示`id`列的值将被映射到`SystemAdmin`类的`id`属性，列的JDBC类型是`INTEGER`。
4. `<result column="login_name" jdbcType="VARCHAR" property="loginName" />`和`<result column="password" jdbcType="VARCHAR" property="password" />`：这两个标签表示`login_name`和`password`列的值将被映射到`SystemAdmin`类的`loginName`和`password`属性，列的JDBC类型是`VARCHAR`。
5. `<select id="getSystemAdmin" resultMap="SystemAdminResult">`：这个标签定义了一个查询语句，`id`属性是这个查询的唯一标识符，`resultMap`属性指定了用于映射结果集的结果映射。
6. `select * from system_admin where 1=1`：这是查询的SQL语句，它从`system_admin`表中选择所有的记录。
7. `<if test="loginName != null and loginName !=''">`：这个标签是一个条件判断，如果`loginName`不为空，那么就会添加`and login_name=#{loginName}`到SQL语句中，这样就可以根据`loginName`过滤结果集。
#### mybatis.xml
``` <!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd"> <configuration> <!-- 打印查询语句 --> <settings> <setting name="logImpl" value="STDOUT_LOGGING" /> </settings> <typeAliases> <package name="demo.mybatis.model" /> </typeAliases> <environments default="development"> <environment id="development"> <transactionManager type="JDBC"> <property name="" value="" /> </transactionManager> <dataSource type="UNPOOLED"> <property name="driver" value="com.mysql.jdbc.Driver" /> <property name="url" value="jdbc:mysql://192.168.3.9:3306/robot_ex" /> <property name="username" value="root" /> <property name="password" value="robot_123456#" /> </dataSource> </environment> </environments> <mappers> <mapper resource="SystemAdminMapper.xml" /> </mappers> </configuration> ```
MyBatis的全局配置文件，它定义了MyBatis的运行环境和行为
1. `<settings>`：这个标签用于配置MyBatis的全局设置。在这个例子中，`<setting name="logImpl" value="STDOUT_LOGGING" />`表示将日志输出到标准输出。
2. `<typeAliases>`：这个标签用于定义类型别名，它可以简化XML配置文件中的全限定类名。在这个例子中，`<package name="demo.mybatis.model" />`表示为`demo.mybatis.model`包下的所有类自动创建别名。
3. `<environments default="development">`：这个标签用于配置环境。`default`属性指定了默认的环境。
4. `<environment id="development">`：这个标签定义了一个环境，`id`属性是这个环境的唯一标识符。
5. `<transactionManager type="JDBC">`：这个标签定义了事务管理器的类型，这里的类型是`JDBC`。
6. `<dataSource type="UNPOOLED">`：这个标签定义了数据源的类型，这里的类型是`UNPOOLED`，表示使用非池化的数据源。
7. `<property name="driver" value="com.mysql.jdbc.Driver" />`等：这些标签定义了数据源的属性，包括驱动类名、数据库URL、用户名和密码。
8. `<mappers>`：这个标签用于注册映射器。在这个例子中，`<mapper resource="SystemAdminMapper.xml" />`表示注册了一个映射器，它的配置文件是`SystemAdminMapper.xml`。
#### 编写一个工具类用于读取mybatis.xml
MybatisUtils
```
package demo.mybatis.utils;
import java.io.IOException;
import java.io.InputStream;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
public class MybatisUtils {
public static final String resource = "mybatis.xml";
private static SqlSessionFactory factory;
static {
InputStream inputStream = null;
try {
inputStream = Resources.getResourceAsStream(resource);
factory = new SqlSessionFactoryBuilder().build(inputStream);
} catch (IOException ioException) {
ioException.printStackTrace();
}
}
/**
* 返回factory
* @return
*/
public static SqlSessionFactory getFactory() {
return factory;
}
/**
* 打开会话
* @return
*/
public static SqlSession openSession(boolean autoCommit) {
return factory.openSession(autoCommit);
}
public static SqlSession openSession() {
return factory.openSession(true);
}
}
````MybatisUtils`的Java工具类，它提供了一些用于操作MyBatis的静态方法。
1. `public static final String resource = "mybatis.xml";`：这是一个静态常量，表示MyBatis的配置文件的名称。
2. `private static SqlSessionFactory factory;`：这是一个静态变量，表示MyBatis的`SqlSessionFactory`，它是创建`SqlSession`的工厂。
3. `static {...}`：这是一个静态代码块，它在类加载时执行。在这个代码块中，它试图从`mybatis.xml`文件中读取MyBatis的配置，并创建一个`SqlSessionFactory`。
4. `public static SqlSessionFactory getFactory() {...}`：这是一个静态方法，它返回`SqlSessionFactory`。
5. `public static SqlSession openSession(boolean autoCommit) {...}`：这是一个静态方法，它创建并返回一个新的`SqlSession`。`autoCommit`参数决定了这个`SqlSession`是否自动提交事务。
6. `public static SqlSession openSession() {...}`：这是一个重载的静态方法，它创建并返回一个新的`SqlSession`，并且这个`SqlSession`会自动提交事务。
#### 在Controller中获取Mapper
MybatisController
```
package demo.mybatis.controller;
import java.sql.Connection;
import org.apache.ibatis.binding.MapperRegistry;
import org.apache.ibatis.session.Configuration;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import com.litongjava.tio.http.server.annotation.RequestPath;
import demo.mybatis.mapper.SystemAdminMapper;
import demo.mybatis.utils.MybatisUtils;
import lombok.extern.slf4j.Slf4j;
@Slf4j
@RequestPath("/mybatis")
public class MybatisController {
public String getMapper() {
SqlSessionFactory factory = MybatisUtils.getFactory();
log.info("factory:{}", factory);
SqlSession sqlSession = MybatisUtils.openSession(true);
log.info("sqlSession:{}", sqlSession);
Connection connection = sqlSession.getConnection();
log.info("connection:{}", connection);
Configuration configuration = sqlSession.getConfiguration();
log.info("configuration:{}", configuration);
MapperRegistry mapperRegistry = configuration.getMapperRegistry();
log.info("mapperRegistry:{}", mapperRegistry);
SystemAdminMapper mapper = sqlSession.getMapper(SystemAdminMapper.class);
log.info("mapper:{}", mapper);
return mapper.toString();
}
}```
`public String getMapper() {...}`：这是一个公共方法，它获取了一个`SystemAdminMapper`对象，并返回了它的字符串表示。
- `SqlSessionFactory factory = MybatisUtils.getFactory();`：这行代码从`MybatisUtils`工具类中获取了一个`SqlSessionFactory`对象。
- `SqlSession sqlSession = MybatisUtils.openSession(true);`：这行代码从`MybatisUtils`工具类中获取了一个`SqlSession`对象，这个`SqlSession`对象会自动提交事务。
- `Connection connection = sqlSession.getConnection();`：这行代码获取了`SqlSession`对象的数据库连接。
- `Configuration configuration = sqlSession.getConfiguration();`：这行代码获取了`SqlSession`对象的配置。
- `MapperRegistry mapperRegistry = configuration.getMapperRegistry();`：这行代码获取了配置的映射器注册表。
- `SystemAdminMapper mapper = sqlSession.getMapper(SystemAdminMapper.class);`：这行代码从`SqlSession`对象中获取了一个`SystemAdminMapper`对象。
- `return mapper.toString();`：这行代码返回了`SystemAdminMapper`对象的字符串表示。
### 使用配类整合mybatis-plus
MySqlSessionManager用户管理SqlSession
```
package demo.mybatis.config;
import org.apache.ibatis.session.SqlSession;
public class MySqlSessionManager {
private static SqlSession sqlSession;
public static SqlSession getSqlSession() {
return sqlSession;
}
public static void setSqlSession(SqlSession sqlSession) {
MySqlSessionManager.sqlSession = sqlSession;
}
public static <T> T getMapper(Class<T> clazz) {
return sqlSession.getMapper(clazz);
}
}
```MybatisConfig配置类
```
package demo.mybatis.config;
import java.io.IOException;
import java.io.Reader;
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 com.litongjava.jfinal.aop.annotation.Bean;
import com.litongjava.jfinal.aop.annotation.Configuration;
import lombok.extern.slf4j.Slf4j;
@Slf4j
@Configuration
public class MybatisConfig {
// 配置文件名称
private String mybatisConfigXml = "mybatis.xml";
/**
* 获取SqlSession
*
* @return
*/
@Bean(destroyMethod = "close")
public SqlSession getSqlSession() {
Reader reader = null;
try {
reader = Resources.getResourceAsReader(mybatisConfigXml);
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(reader);
// 通过sqlSessionFactory打开一个数据库会话
SqlSession sqlSession = sqlSessionFactory.openSession();
MySqlSessionManager.setSqlSession(sqlSession);
return sqlSession;
} catch (IOException e) {
log.error("can not get sqlSession", e);
}
return null;
}
}
````MybatisConfig使用了MyBatis框架来配置数据库会话。
1. `@Slf4j`：这是一个Lombok库提供的注解，它在类中自动创建一个名为`log`的SLF4J（Simple Logging Facade for Java）日志对象。
2. `private String mybatisConfigXml = "mybatis.xml";`：这是一个私有变量，表示MyBatis的配置文件的名称。
3. `@Bean(destroyMethod = "close")`：这是一个注解，它定义了一个Bean，并指定了销毁方法为`close`。
4. `private SqlSession getSqlSession() {...}`：这是一个私有方法，它创建并返回一个新的`SqlSession`对象。让我们详细看看这个方法做了什么：
- `Reader reader = Resources.getResourceAsReader(mybatisConfigXml);`：这行代码从`mybatis.xml`文件中读取MyBatis的配置。
- `SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(reader);`：这行代码使用读取到的配置创建了一个`SqlSessionFactory`对象。
- `SqlSession sqlSession = sqlSessionFactory.openSession();`：这行代码从`SqlSessionFactory`对象中打开了一个新的数据库会话。
- `MySqlSessionManager.setSqlSession(sqlSession);`：这行代码将新打开的数据库会话设置到`MySqlSessionManager`中。
- `return sqlSession;`：这行代码返回了新打开的数据库会话。
- 如果在创建数据库会话过程中发生了异常，那么它会被捕获，并记录到日志中。
#### 在Controller中获取Mapper
```
package demo.mybatis.controller;
import java.sql.Connection;
import java.util.Collection;
import org.apache.ibatis.binding.MapperRegistry;
import org.apache.ibatis.session.Configuration;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import com.litongjava.tio.http.server.annotation.RequestPath;
import demo.mybatis.config.MySqlSessionManager;
import demo.mybatis.mapper.SystemAdminMapper;
import demo.mybatis.utils.MybatisUtils;
import lombok.extern.slf4j.Slf4j;
@Slf4j
@RequestPath("/mybatis")
public class MybatisController {
public String getMappers() {
SqlSession sqlSession = MySqlSessionManager.getSqlSession();
Configuration configuration = sqlSession.getConfiguration();
MapperRegistry mapperRegistry = configuration.getMapperRegistry();
Collection<Class<?>> mappers = mapperRegistry.getMappers();
for (Class<?> c : mappers) {
log.info("c:{}", c);
}
return mappers.toString();
}
}
```访问
http://localhost/mybatis/getMappers
`public String getMappers() {...}`：这是一个公共方法，它获取了所有的映射器，并返回了它们的字符串表示
- `SqlSession sqlSession = MySqlSessionManager.getSqlSession();`：这行代码从`MySqlSessionManager`中获取了一个`SqlSession`对象。
- `Configuration configuration = sqlSession.getConfiguration();`：这行代码获取了`SqlSession`对象的配置。
- `MapperRegistry mapperRegistry = configuration.getMapperRegistry();`：这行代码获取了配置的映射器注册表。
- `Collection<Class<?>> mappers = mapperRegistry.getMappers();`：这行代码获取了所有的映射器。
- `for (Class<?> c : mappers) {...}`：这是一个for-each循环，它遍历了所有的映射器，并将它们的类名记录到日志中。
- `return mappers.toString();`：这行代码返回了所有映射器的字符串表示。
希望这个解释对您有所帮助！如果您有其他关于MyBatis或Java的问题，欢迎随时向我提问。😊
### SystemAdminController
```
package demo.mybatis.controller;
import com.litongjava.tio.http.server.annotation.RequestPath;
import demo.mybatis.config.MySqlSessionManager;
import demo.mybatis.mapper.SystemAdminMapper;
import demo.mybatis.model.SystemAdmin;
@RequestPath("/SystemAdmin")
public class SystemAdminController {
public SystemAdmin getSystemAdmin() {
SystemAdminMapper mapper = MySqlSessionManager.getSqlSession().getMapper(SystemAdminMapper.class);
SystemAdmin systemAdmin = mapper.getSystemAdmin(null);
return systemAdmin;
}
}
```访问测试
http://localhost/SystemAdmin/getSystemAdmin
`public SystemAdmin getSystemAdmin() {...}`：这是一个公共方法，它获取了一个`SystemAdmin`对象，并返回了它
- `SystemAdminMapper mapper = MySqlSessionManager.getSqlSession().getMapper(SystemAdminMapper.class);`：这行代码从`MySqlSessionManager`中获取了一个`SqlSession`对象，然后从这个`SqlSession`对象中获取了一个`SystemAdminMapper`对象。
- `SystemAdmin systemAdmin = mapper.getSystemAdmin(null);`：这行代码调用了`SystemAdminMapper`对象的`getSystemAdmin`方法，获取了一个`SystemAdmin`对象。这个方法的参数是`null`，这意味着它将获取所有的`SystemAdmin`记录。
- `return systemAdmin;`：这行代码返回了获取到的`SystemAdmin`对象。
在测试中，您可以通过访问`http://localhost/SystemAdmin/getSystemAdmin`来调用这个方法，它将返回一个`SystemAdmin`对象的信息。
