MyBatis框架

喜欢写代码的小唐

于 2024-09-25 20:37:33 发布

阅读量646

点赞数 20

文章标签： mybatis

本文链接：https://blog.csdn.net/m0_73245690/article/details/142465128

版权

1. MyBatis

1.MyBatis 简介

MyBatis 是一款优秀的持久层框架，它简化了 Java 应用程序与关系数据库之间的交互。MyBatis 可以自动将 SQL 查询的结果映射到 Java 对象，并支持自定义 SQL、存储过程和高级映射功能。

相比于 Hibernate 等全自动的 ORM 框架，MyBatis 提供了更灵活的 SQL 控制，同时也避免了 Hibernate 可能带来的过于复杂的自动化机制。它的核心是将 SQL 语句与 Java 对象之间进行手动的映射管理，允许开发者手动编写 SQL 语句，但同时也提供了简化的配置和查询方法。

2. MyBatis 的主要特点

轻量级框架：MyBatis 是一个轻量级的持久层框架，依赖少、配置简洁。
SQL 控制灵活：开发者可以自由编写原生的 SQL 语句，对数据库的复杂操作更灵活。
支持动态 SQL：MyBatis 提供了动态 SQL 标签（如 <if>、<foreach> 等），可以根据条件生成动态 SQL 查询，增强了 SQL 的灵活性。
自动映射：可以将 SQL 查询的结果自动映射到 Java 对象，开发者不必手动解析 ResultSet。
良好的性能：MyBatis 提供了 SQL 缓存机制，可以对查询结果进行缓存，以提升查询效率。
支持 XML 和注解：MyBatis 既支持通过 XML 文件配置 SQL 语句，也支持基于 Java 注解的配置方式。

3. MyBatis 与 MyBatis-Plus 的关系

MyBatis-Plus 是在 MyBatis 基础上进行扩展的增强工具，旨在简化开发流程，提升生产力。它保留了 MyBatis 的灵活性，同时提供了更多开箱即用的功能，例如：

CRUD 接口的自动生成
内置分页插件
SQL 性能分析
乐观锁插件等

MyBatis-Plus 是对 MyBatis 的增强版，更适合快速开发企业级应用。

4. MyBatis 工作原理

MyBatis 的核心是 SqlSession，这是与数据库交互的主要对象。其工作原理大致如下：

加载配置文件：MyBatis 通过加载 mybatis-config.xml 配置文件，初始化环境，包括数据库连接、映射文件等。
映射 SQL：MyBatis 将 Java 对象与 SQL 查询的结果映射起来，SQL 语句通常存放在 XML 文件中。
执行 SQL：通过 MyBatis 的 API 发送 SQL 查询到数据库，获取查询结果。
结果映射：将数据库返回的结果映射为 Java 对象，供应用程序使用。

2 .创建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>

    <!-- 配置环境信息 -->
    <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/mydb"/>
                <property name="username" value="root"/>
                <property name="password" value="password"/>
            </dataSource>
        </environment>
    </environments>

    <!-- 配置全局属性 -->
    <settings>
        <setting name="mapUnderscoreToCamelCase" value="true"/>
        <setting name="logImpl" value="STDOUT_LOGGING"/>
    </settings>

    <!-- 配置 Mapper 文件 -->
    <mappers>
        <mapper resource="mapper/UserMapper.xml"/>
    </mappers>

</configuration>

XML 声明和 DTD（Document Type Definition）声明
```
<?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">
```
- 声明了 XML 的版本和字符集编码为 UTF-8。
- 引入了 MyBatis 配置文件的 DTD 定义，以保证配置文件的结构正确。
Configuration 元素
- 所有配置内容都包含在 <configuration> 元素内。
Environments（环境）配置
```
<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/mydb"/> 
            <property name="username" value="root"/> 
            <property name="password" value="password"/> 
        </dataSource> 
    </environment> 
</environments>
```
- environments 元素用于配置不同的数据库连接环境（如开发、测试、生产），并通过 default 属性指定默认环境。
- 每个 environment 代表一个数据库环境，包含 transactionManager 和 dataSource 两个重要元素。
  - transactionManager: 事务管理器，这里使用 JDBC 类型，意味着直接使用 JDBC 的事务管理。
  - dataSource: 数据源，这里使用 POOLED 类型，表示使用 MyBatis 自带的数据库连接池。
Settings（全局属性设置）
```
<settings> 
    <setting name="mapUnderscoreToCamelCase" value="true"/> 
    <setting name="logImpl" value="STDOUT_LOGGING"/> 
</settings>
```
- mapUnderscoreToCamelCase: 将数据库中的下划线字段（如 user_name）映射为 Java 的驼峰命名（如 userName）。
- logImpl: 设置 MyBatis 的日志实现方式。STDOUT_LOGGING 表示将日志输出到控制台。可以更改为其他日志框架如 LOG4J 或 SLF4J。
Mappers（映射器）配置
```
<mappers> 
    <mapper resource="mapper/UserMapper.xml"/> 
</mappers>
```
- mappers 元素用于加载 SQL 映射文件，resource 属性表示通过类路径加载 UserMapper.xml 文件。
- 也可以通过 package 标签指定 Mapper 接口所在的包，MyBatis 会自动扫描该包下的所有 Mapper。

关键点回顾

transactionManager: 指定事务管理方式，通常在简单项目中使用 JDBC，在复杂应用中使用 MANAGED 或集成 Spring 的事务管理。
dataSource: 定义数据库连接池配置，包括数据库驱动、URL、用户名和密码。
settings: 配置 MyBatis 的全局行为，如日志输出方式和命名规则。
mappers: 指定 SQL 映射文件的位置或包扫描路径。

这个配置文件可以直接用于 MyBatis 项目的基本配置，确保数据库连接正常，Mapper 文件路径正确

3.搭建mapper接口

搭建 MyBatis 的 Mapper 接口是整个 MyBatis 框架与数据库交互的重要部分，它用于定义 SQL 查询方法，与 Mapper.xml 文件中的 SQL 语句绑定。

1. 创建 Mapper 接口

你可以在 Java 项目中创建一个 Mapper 接口，并将它与 MyBatis 的映射文件（Mapper.xml）相结合。

以下是一个简单的 UserMapper 接口的例子：

package com.example.mapper; 
import com.example.domain.User; 
import org.apache.ibatis.annotations.Param; 
import java.util.List; 
public interface UserMapper { 
// 根据用户ID查询用户信息 
    User getUserById(@Param("id") Long id); 
// 查询所有用户 
    List<User> getAllUsers(); 
// 插入新用户 
    void insertUser(User user); 
// 更新用户信息 
    void updateUser(User user); 
// 删除用户 
    void deleteUser(@Param("id") Long id); 
}

2. 接口中的方法说明

getUserById(Long id)：根据用户ID查询用户信息，返回 User 对象。
getAllUsers()：查询所有用户，返回用户列表。
insertUser(User user)：插入新用户，参数为 User 对象。
updateUser(User user)：更新已有用户信息，参数为 User 对象。
deleteUser(Long id)：根据ID删除用户，@Param 注解用于绑定 SQL 语句中的参数。

3. 创建 Mapper XML 文件

Mapper 接口中的方法通常会与 XML 文件中的 SQL 语句绑定。下面是 UserMapper.xml 文件的示例，它与上面的 UserMapper 接口相对应：

<?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.example.mapper.UserMapper"> 
<!-- 根据用户ID查询用户 --> 
    <select id="getUserById" parameterType="Long" resultType="com.example.domain.User">             
        SELECT id, username, email, mobile, create_time 
        FROM users WHERE id = #{id} 
    </select> 
<!-- 查询所有用户 --> 
    <select id="getAllUsers" resultType="com.example.domain.User"> 
        SELECT id, username, email, mobile, create_time 
        FROM users 
    </select> 
<!-- 插入新用户 --> 
    <insert id="insertUser" parameterType="com.example.domain.User"> 
        INSERT INTO users (username, email, mobile, create_time) 
        VALUES (#{username}, #{email}, #{mobile}, #{createTime}) 
    </insert> 
<!-- 更新用户信息 --> 
    <update id="updateUser" parameterType="com.example.domain.User"> 
        UPDATE users SET username = #{username}, email = #{email}, mobile = #{mobile} 
        WHERE id = #{id} </update> 
<!-- 根据用户ID删除用户 --> 
    <delete id="deleteUser" parameterType="Long"> 
        DELETE FROM users WHERE id = #{id} 
    </delete> 
</mapper>

4. 关键点

namespace：声明 Mapper 的命名空间，与 UserMapper 接口的全路径一致。
select、insert、update 和 delete：定义了 SQL 语句的类型。id 与接口中的方法名一致，parameterType 定义参数类型，resultType 定义返回结果类型。
#{}：占位符，用于接收参数。

通过这个流程，你就完成了 MyBatis 中 Mapper 接口与 SQL 映射文件的基本搭建，并可以开始进行数据库操作。

4.添加log4j加入日志功能

在项目中添加 log4j 日志功能的步骤如下：

1. 添加 Log4j 依赖

首先，在你的项目中使用 log4j 作为日志框架。假设你正在使用 Maven，确保在 pom.xml 文件中引入以下依赖：

<dependency> 
    <groupId>log4j</groupId> 
    <artifactId>log4j</artifactId> 
    <version>1.2.17</version> 
</dependency>

如果你使用 log4j2，可以改为：

<dependency>
    <groupId>org.apache.logging.log4j</groupId> 
    <artifactId>log4j-core</artifactId> 
    <version>2.17.2</version> 
</dependency> 
<dependency> 
    <groupId>org.apache.logging.log4j</groupId> 
    <artifactId>log4j-api</artifactId> 
    <version>2.17.2</version> 
</dependency>

2. 创建 `log4j.properties` 文件

在 resources 目录下创建 log4j.properties 文件，用于配置日志输出规则。

# 设置日志根目录级别为 INFO，输出到控制台和日志文件 log4j.rootLogger=INFO, console, file # 控制台输出 log4j.appender.console=org.apache.log4j.ConsoleAppender log4j.appender.console.Target=System.out 
log4j.appender.console.layout=org.apache.log4j.PatternLayout 
log4j.appender.console.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} [%t] %-5p %c{1} - %m%n 

# 文件输出 

log4j.appender.file=org.apache.log4j.RollingFileAppender 
log4j.appender.file.File=logs/app.log log4j.appender.file.MaxFileSize=10MB 
log4j.appender.file.MaxBackupIndex=5 
log4j.appender.file.layout=org.apache.log4j.PatternLayout 
log4j.appender.file.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} [%t] %-5p %c{1} - %m%n 
# 设置MyBatis日志级别 

log4j.logger.org.mybatis=DEBUG log4j.logger.org.apache.ibatis=DEBUG 
log4j.logger.com.example.mapper=DEBUG # 针对 Mapper 包设置日志级别

3. 使用日志记录

在你的代码中，通过 Log4j 的 Logger 来记录日志：

import org.apache.log4j.Logger; 
public class ExampleService { 
        private static final Logger logger = Logger.getLogger(ExampleService.class); 
        public void doSomething() { 
            logger.info("This is an info log"); 
            logger.debug("This is a debug log"); 
            logger.error("This is an error log"); 
            try { // some code 
                
            } catch (Exception e) { 
                    logger.error("Error occurred", e); 
            } 
        } 
}

4. 启用 MyBatis SQL 日志输出

为了让 MyBatis 的 SQL 执行过程在日志中输出，还可以在 MyBatis 配置文件（如 mybatis-config.xml 或 application.yml）中启用 SQL 日志输出。

配置 MyBatis 使用 Log4j

如果你使用的是 mybatis-config.xml 文件，在其中添加以下配置：

<configuration> 
    <settings> 
        <setting name="logImpl" value="LOG4J"/> 
    </settings> 
</configuration>

如果你使用的是 `application.yml` 配置文件，可以这样配置：

mybatis-plus: configuration: log-impl: LOG4J

5.通过junit测试功能

通过 JUnit 测试功能的步骤如下：

1. 添加 JUnit 依赖

确保在你的 `pom.xml` 文件中添加 JUnit 依赖。对于 JUnit 5，可以使用以下配置：

<dependency>
    <groupId>org.junit.jupiter</groupId>
    <artifactId>junit-jupiter</artifactId>
    <version>5.8.2</version>
    <scope>test</scope>
</dependency>

如果你使用 JUnit 4，配置如下：

<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.13.2</version>
    <scope>test</scope>
</dependency>

2. 创建测试类

在 `src/test/java` 目录下创建测试类。以下是一个使用 JUnit 5 的示例：

import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;

public class ExampleServiceTest {

    private final ExampleService exampleService = new ExampleService();

    @Test
    void testDoSomething() {
        // Arrange: 设置预期结果
        String expected = "预期结果";

        // Act: 调用被测试的方法
        String actual = exampleService.doSomething();

        // Assert: 验证结果
        assertEquals(expected, actual);
    }

    @Test
    void testErrorHandling() {
        Exception exception = assertThrows(Exception.class, () -> {
            exampleService.methodThatThrows();
        });

        String expectedMessage = "错误信息";
        String actualMessage = exception.getMessage();

        assertTrue(actualMessage.contains(expectedMessage));
    }
}

3. 运行测试

你可以使用 IDE（如 IntelliJ IDEA 或 Eclipse）中的测试运行器来运行测试。也可以使用 Maven 命令行：

mvn test

4. 观察测试结果

运行测试后，JUnit 将输出测试结果。如果所有测试通过，你会看到绿色的输出；如果有测试失败，会显示详细的错误信息。

5. 日志测试

如果需要测试日志输出，可以使用 `System.out` 来验证控制台输出，但这种方法通常不推荐。建议通过 `log4j` 的 `Appender` 进行更正式的测试。

6. 集成测试

如果你的功能涉及到数据库或外部系统，考虑使用 Spring 的 `@SpringBootTest` 注解来进行集成测试。示例：

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
public class UserServiceIntegrationTest {

    @Autowired
    private UserService userService;

    @Test
    void testUserLogin() {
        // 测试用户登录逻辑
    }
}

通过这些步骤，你可以使用 JUnit 进行功能测试，确保你的代码按预期工作。

5.MyBaits的增删改查

好的，这里是更详细的解释和一些最佳实践：

1. 增（Insert）

 **示例代码**：
 
  <insert id="insertUser" parameterType="User">
      INSERT INTO users (name, age) VALUES (#{name}, #{age})
  </insert>
- **最佳实践**：确保对输入数据进行验证，以防止SQL注入或不合法的数据插入。

2. 删（Delete）

 <delete id="deleteUser" parameterType="int">
      DELETE FROM users WHERE id = #{id}
  </delete>

在删除之前可以考虑先查询确认记录是否存在。

3. 改（Update）

  <update id="updateUser" parameterType="User">
      UPDATE users SET name = #{name}, age = #{age} WHERE id = #{id}
  </update>

在更新时可以考虑使用乐观锁（如版本号）来避免并发更新的问题。

4. 查（Select）

  <select id="selectUser" parameterType="int" resultType="User">
      SELECT * FROM users WHERE id = #{id}
  </select>

  <select id="selectAllUsers" resultType="User">
      SELECT * FROM users
  </select>

对于大量数据的查询，考虑分页，以提高性能。

事务管理

在执行增、删、改操作时，通常需要管理事务。可以在MyBatis的配置文件中启用事务管理，确保数据一致性。

Mapper 接口

确保Mapper接口与XML映射文件中定义的方法一致，以便于MyBatis能够正确调用。

public interface UserMapper {
    void insertUser(User user);
    void deleteUser(int id);
    void updateUser(User user);
    User selectUser(int id);
    List<User> selectAllUsers();
}

使用示例
在服务层中调用这些Mapper方法：


@Autowired
private UserMapper userMapper;

public void addUser(User user) {
    userMapper.insertUser(user);
}

public void removeUser(int id) {
    userMapper.deleteUser(id);
}

public void modifyUser(User user) {
    userMapper.updateUser(user);
}

public User getUser(int id) {
    return userMapper.selectUser(id);
}

public List<User> getAllUsers() {
    return userMapper.selectAllUsers();
}

6.MyBatis中获取参数

好的，以下是MyBatis中获取参数的五种方式，分成四个点：

1. 单个字面量类型的参数

示例

  public interface UserMapper {
      User selectUserById(int id);
  }

xml

 <select id="selectUserById" parameterType="int" resultType="User">
      SELECT * FROM users WHERE id = #{id}
  </select>

2. 多个字面量类型的参数

示例

  public interface UserMapper {
      User selectUserByIdAndName(int id, String name);
  }

xml

  <select id="selectUserByIdAndName" parameterType="map" resultType="User">
      SELECT * FROM users WHERE id = #{id} AND name = #{name}
  </select>

3. Map集合类型的参数

示例

  public interface UserMapper {
      User selectUserByMap(Map<String, Object> params);
  }

xml

  <select id="selectUserByMap" parameterType="map" resultType="User">
      SELECT * FROM users WHERE id = #{id} AND name = #{name}
  </select>

4. 实体类类型的参数

  public class UserQuery {
      private int id;
      private String name;
      // getters and setters
  }

  public interface UserMapper {
      User selectUserByQuery(UserQuery query);
  }

  <select id="selectUserByQuery" parameterType="UserQuery" resultType="User">
      SELECT * FROM users WHERE id = #{id} AND name = #{name}
  </select>
  ```

5. 使用 `@Param` 标识的参数


  public interface UserMapper {
      User selectUserByIdAndName(@Param("id") int id, @Param("name") String name);
  }

  <select id="selectUserByIdAndName" parameterType="map" resultType="User">
      SELECT * FROM users WHERE id = #{id} AND name = #{name}
  </select>

7.MyBatis的各种查询

以下是MyBatis的各种查询功能示例：

1. 查询一个实体类对象

示例
  public interface UserMapper {
      User selectUserById(int id);
  }

  <select id="selectUserById" parameterType="int" resultType="User">
      SELECT * FROM users WHERE id = #{id}
  </select>

2. 查询 List 集合

示例：
  public interface UserMapper {
      List<User> selectAllUsers();
  }

  <select id="selectAllUsers" resultType="User">
      SELECT * FROM users
  </select>

3. 查询单个数据

  public interface UserMapper {
      int countUsers();
  }


  <select id="countUsers" resultType="int">
      SELECT COUNT(*) FROM users
  </select>

4. 查询一条数据为 Map 集合

  public interface UserMapper {
      Map<String, Object> selectUserAsMap(int id);
  }

  <select id="selectUserAsMap" parameterType="int" resultType="map">
      SELECT * FROM users WHERE id = #{id}
  </select>

5. 查询多条数据为 Map 集合

  public interface UserMapper {
      List<Map<String, Object>> selectAllUsersAsMap();
  }

  <select id="selectAllUsersAsMap" resultType="map">
      SELECT * FROM users
  </select>