MyBatis教程：从入门到实践

2024/11/15 23:03:10

本文主要是介绍MyBatis教程：从入门到实践，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

概述

本文详细介绍了MyBatis教程，涵盖从环境搭建到核心概念详解、CRUD操作实现、动态SQL使用、分页查询、嵌套查询、Spring集成以及调试与性能优化技巧。此外，还提供了丰富的示例代码和配置文件，帮助读者更好地理解和应用MyBatis的相关技术。

MyBatis简介与环境搭建

MyBatis是什么

MyBatis是一个优秀的持久层框架，它支持定制化SQL查询，存储过程以及高级映射。MyBatis避免了几乎所有的JDBC代码和手动设置参数以及获取结果集。MyBatis可以使用简单的XML或注解进行配置和原始映射，将接口和Java的POJOs（普通的Java对象）映射成数据库中的记录。

MyBatis的优势与应用场景

MyBatis具有以下优势：

简化了数据库操作：MyBatis通过预编译的SQL语句，减少了SQL语句的拼接和执行的复杂性。
灵活性高：MyBatis的SQL映射文件使得SQL语句与Java代码分离，便于维护。
支持存储过程：MyBatis支持存储过程，可以实现复杂的业务逻辑。
动态SQL：通过XML标签和注解，MyBatis可以处理动态生成的SQL语句。
支持高级映射：例如一对多、多对多等高级映射关系。

MyBatis适用于以下场景：

需要灵活编写SQL语句的应用
需要高性能数据库操作的应用
需要优化SQL语句以提升性能的应用
需要支持复杂查询的应用

开发环境搭建步骤

环境要求

Java开发工具包（JDK）版本8及以上
数据库（例如MySQL、Oracle等）
MyBatis框架版本3.5.7及以上

搭建步骤

创建一个Maven项目，并在pom.xml中添加MyBatis的依赖：

<dependencies>
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis</artifactId>
        <version>3.5.7</version>
    </dependency>
    <!-- 数据库驱动依赖，以MySQL为例 -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.26</version>
    </dependency>
    <!-- 测试依赖 -->
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.13.2</version>
        <scope>test</scope>
    </dependency>
</dependencies>

配置数据库连接信息，例如在src/main/resources目录下创建一个名为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/test"/>
                <property name="username" value="root"/>
                <property name="password" value="password"/>
            </dataSource>
        </environment>
    </environments>
</configuration>

创建一个测试类，使用MyBatis进行简单的数据库操作：

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.apache.ibatis.session.defaults.DefaultSqlSessionFactory;

import java.io.InputStream;
import java.util.List;

public class MyBatisTest {
    public static void main(String[] args) throws Exception {
        String resource = "mybatis-config.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        try (SqlSession session = sqlSessionFactory.openSession()) {
            List<String> users = session.selectList("com.example.demo.UserMapper.selectAllUsers");
            for (String user : users) {
                System.out.println(user);
            }
        }
    }
}

创建一个映射文件UserMapper.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">
<mapper namespace="com.example.demo.UserMapper">
    <select id="selectAllUsers" resultType="string">
        SELECT username FROM users
    </select>
</mapper>

快速入门示例

创建数据库表和数据

在数据库中创建一个用户表users，并插入一些测试数据。

CREATE TABLE users (
    id INT AUTO_INCREMENT PRIMARY KEY,
    username VARCHAR(255) NOT NULL
);

INSERT INTO users (username) VALUES ('Alice');
INSERT INTO users (username) VALUES ('Bob');

修改UserMapper.xml以使用新的SQL语句。

<mapper namespace="com.example.demo.UserMapper">
    <select id="selectAllUsers" resultType="string">
        SELECT username FROM users
    </select>
</mapper>

修改Java测试代码以使用新的映射文件。

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.InputStream;
import java.util.List;

public class MyBatisTest {
    public static void main(String[] args) throws Exception {
        String resource = "mybatis-config.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        try (SqlSession session = sqlSessionFactory.openSession()) {
            List<String> users = session.selectList("com.example.demo.UserMapper.selectAllUsers");
            for (String user : users) {
                System.out.println(user);
            }
        }
    }
}

运行测试代码，输出所有用户的名字。

练习

修改UserMapper.xml以实现insertUser、updateUser和deleteUser操作。
在测试代码中实现这些操作，并验证它们是否按预期工作。

MyBatis的核心概念与配置

核心配置文件详解

MyBatis的核心配置文件mybatis-config.xml定义了数据库连接信息、环境配置、映射文件等重要配置。以下是核心配置文件的基本结构和常用配置项：

<configuration>
    <properties>
        <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/test"/>
        <property name="username" value="root"/>
        <property name="password" value="password"/>
    </properties>

    <settings>
        <setting name="cacheEnabled" value="true"/>
    </settings>

    <typeAliases>
        <typeAlias alias="User" type="com.example.demo.User"/>
    </typeAliases>

    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="${driver}"/>
                <property name="url" value="${url}"/>
                <property name="username" value="${username}"/>
                <property name="password" value="${password}"/>
            </dataSource>
        </environment>
    </environments>

    <mappers>
        <mapper resource="com/example/demo/UserMapper.xml"/>
    </mappers>
</configuration>

配置项详解

properties：定义数据库连接信息。
settings：设置MyBatis的行为，例如启用缓存、配置日志等。
typeAliases：定义类型别名，简化MyBatis中类型的指定。
environments：定义数据库连接环境，包括事务管理和数据源配置。
mappers：指定映射文件的位置。

SqlSessionFactory与SqlSession的使用

SqlSessionFactory和SqlSession是MyBatis的核心对象。

SqlSessionFactory

SqlSessionFactory用于创建SqlSession对象，是线程安全的，并且只能创建一次。创建SqlSessionFactory的方法通常是在mybatis-config.xml配置文件中定义。

SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(inputStream);

SqlSession

SqlSession提供了执行SQL语句所需的方法，包括select、insert、update和delete等。通常通过SqlSessionFactory的openSession方法获取SqlSession对象。

try (SqlSession session = factory.openSession()) {
    // 使用session执行SQL语句
}

MyBatis的映射文件配置

MyBatis的映射文件（通常是.xml文件）定义了SQL查询语句及其对应的方法。映射文件中包含多个<mapper>标签，每个标签定义了一个SQL语句。

映射文件示例

<mapper namespace="com.example.demo.UserMapper">
    <select id="selectAllUsers" resultType="string">
        SELECT username FROM users
    </select>
    <insert id="insertUser">
        INSERT INTO users (username) VALUES (#{username})
    </insert>
    <update id="updateUser">
        UPDATE users SET username=#{username} WHERE id=#{id}
    </update>
    <delete id="deleteUser">
        DELETE FROM users WHERE id=#{id}
    </delete>
</mapper>

namespace：命名空间，用于区分不同的映射文件。
id：映射语句的唯一标识符。
resultType：结果类型，可以是Java类型或别名。
#{}：占位符，用于参数传递。

简化的映射文件

通过在Java接口中定义方法，并在映射文件中指定方法名，可以简化映射文件的配置。

public interface UserMapper {
    List<String> selectAllUsers();
    void insertUser(String username);
    void updateUser(String username, int id);
    void deleteUser(int id);
}

<mapper namespace="com.example.demo.UserMapper">
    <select id="selectAllUsers" resultType="string">
        SELECT username FROM users
    </select>
    <insert id="insertUser">
        INSERT INTO users (username) VALUES (#{username})
    </insert>
    <update id="updateUser">
        UPDATE users SET username=#{username} WHERE id=#{id}
    </update>
    <delete id="deleteUser">
        DELETE FROM users WHERE id=#{id}
    </delete>
</mapper>

练习

定义一个映射文件，包含多个SQL语句（例如selectAllUsers、insertUser、updateUser、deleteUser）。
在Java接口中定义相应的方法，并在测试代码中调用这些方法。

CRUD操作详解

基本的CRUD操作实现

CRUD操作是指创建（Create）、读取（Read）、更新（Update）和删除（Delete）操作。以下是CRUD操作的实现步骤：

创建（Create）

创建一个新的实体对象。
使用SqlSession的insert方法执行插入语句。

public interface UserMapper {
    void insertUser(String username);
}

// 映射文件
<insert id="insertUser">
    INSERT INTO users (username) VALUES (#{username})
</insert>

try (SqlSession session = factory.openSession()) {
    UserMapper mapper = session.getMapper(UserMapper.class);
    mapper.insertUser("Alice");
    session.commit();
}

读取（Read）

使用SqlSession的select方法执行查询语句。
获取查询结果。

public interface UserMapper {
    List<String> selectAllUsers();
}

// 映射文件
<select id="selectAllUsers" resultType="string">
    SELECT username FROM users
</select>

try (SqlSession session = factory.openSession()) {
    UserMapper mapper = session.getMapper(UserMapper.class);
    List<String> users = mapper.selectAllUsers();
    for (String user : users) {
        System.out.println(user);
    }
}

更新（Update）

创建一个更新实体对象。
使用SqlSession的update方法执行更新语句。

public interface UserMapper {
    void updateUser(String username, int id);
}

// 映射文件
<update id="updateUser">
    UPDATE users SET username=#{username} WHERE id=#{id}
</update>

try (SqlSession session = factory.openSession()) {
    UserMapper mapper = session.getMapper(UserMapper.class);
    mapper.updateUser("Bob", 1);
    session.commit();
}

删除（Delete）

创建一个删除实体对象。
使用SqlSession的delete方法执行删除语句。

public interface UserMapper {
    void deleteUser(int id);
}

// 映射文件
<delete id="deleteUser">
    DELETE FROM users WHERE id=#{id}
</delete>

try (SqlSession session = factory.openSession()) {
    UserMapper mapper = session.getMapper(UserMapper.class);
    mapper.deleteUser(1);
    session.commit();
}

使用注解简化CRUD操作

MyBatis支持注解来简化映射文件的配置。例如，@Select、@Insert、@Update和@Delete注解可以用于Java接口中定义的方法。

使用注解定义CRUD操作

使用@Select注解定义查询方法。

public interface UserMapper {
    @Select("SELECT username FROM users")
    List<String> selectAllUsers();
}

使用@Insert注解定义插入方法。

public interface UserMapper {
    @Insert("INSERT INTO users (username) VALUES (#{username})")
    void insertUser(String username);
}

使用@Update注解定义更新方法。

public interface UserMapper {
    @Update("UPDATE users SET username=#{username} WHERE id=#{id}")
    void updateUser(String username, int id);
}

使用@Delete注解定义删除方法。

public interface UserMapper {
    @Delete("DELETE FROM users WHERE id=#{id}")
    void deleteUser(int id);
}

测试代码

try (SqlSession session = factory.openSession()) {
    UserMapper mapper = session.getMapper(UserMapper.class);

    mapper.insertUser("Alice");
    mapper.updateUser("Bob", 1);
    mapper.deleteUser(1);

    List<String> users = mapper.selectAllUsers();
    for (String user : users) {
        System.out.println(user);
    }

    session.commit();
}

处理复杂的查询与更新

复杂查询

复杂的查询通常涉及到连接查询、子查询等。例如，查询所有用户的姓名及其所属的部门。

SELECT users.username, departments.department_name
FROM users
JOIN departments ON users.department_id = departments.id

在映射文件中定义该查询：

<select id="selectAllUsersWithDepartments" resultType="com.example.demo.UserDepartment">
    SELECT users.username, departments.department_name
    FROM users
    JOIN departments ON users.department_id = departments.id
</select>

复杂更新

复杂的更新可能涉及到多个表的更新。例如，更新用户信息的同时更新其所属的部门信息。

UPDATE users
SET username = #{username}
WHERE id = #{id}

UPDATE departments
SET department_name = #{departmentName}
WHERE id = #{departmentId}

在映射文件中定义这些更新语句：

<update id="updateUserAndDepartment">
    UPDATE users
    SET username = #{username}
    WHERE id = #{id}

    UPDATE departments
    SET department_name = #{departmentName}
    WHERE id = #{departmentId}
</update>

测试代码

try (SqlSession session = factory.openSession()) {
    UserMapper mapper = session.getMapper(UserMapper.class);

    mapper.updateUserAndDepartment("Alice", 1, "Engineering");

    session.commit();
}

练习

实现一个复杂查询，例如查询所有用户的姓名及其所属的部门。
实现一个复杂的更新操作，例如更新用户信息的同时更新其所属的部门信息。

动态SQL与高级查询

动态SQL的使用场景

动态SQL是指根据不同的条件生成不同的SQL语句。例如，根据用户输入的不同条件动态生成查询语句。动态SQL的使用场景包括：

动态生成查询条件
动态生成更新语句
动态生成SQL语句的其他部分

if, choose, when, otherwise标签的使用

MyBatis提供了<if>、<choose>、<when>和<otherwise>标签来实现动态SQL。

if标签

<if>标签用于根据条件动态生成SQL语句的一部分。

<select id="selectUsersByCondition" resultType="string">
    SELECT username FROM users
    <where>
        <if test="username != null">
            AND username = #{username}
        </if>
        <if test="id != null">
            AND id = #{id}
        </if>
    </where>
</select>

choose标签

<choose>标签用于选择一组条件中的一个进行匹配。

<select id="selectUsersByCondition" resultType="string">
    SELECT username FROM users
    <where>
        <choose>
            <when test="username != null">
                AND username = #{username}
            </when>
            <when test="id != null">
                AND id = #{id}
            </when>
            <otherwise>
                AND id = 1
            </otherwise>
        </choose>
    </where>
</select>

when标签

<when>标签用于定义条件分支。

otherwise标签

<otherwise>标签用于定义默认情况。

测试代码

try (SqlSession session = factory.openSession()) {
    UserMapper mapper = session.getMapper(UserMapper.class);

    List<String> users = mapper.selectUsersByCondition(null, 1);
    for (String user : users) {
        System.out.println(user);
    }

    users = mapper.selectUsersByCondition("Alice", null);
    for (String user : users) {
        System.out.println(user);
    }
}

分页查询与嵌套查询

分页查询

分页查询通常使用SQL的LIMIT关键字实现。例如，查询第一页第1到10条记录。

SELECT username FROM users
LIMIT 0, 10

在映射文件中定义分页查询：

<select id="selectAllUsersWithPage" resultType="string">
    SELECT username FROM users
    <if test="offset != null and limit != null">
        LIMIT #{offset}, #{limit}
    </if>
</select>

嵌套查询

嵌套查询通常用于查询一个表中的数据，再根据该表数据查询另一个表的数据。例如，查询所有用户的姓名及其所属的部门。

SELECT users.username, departments.department_name
FROM users
JOIN departments ON users.department_id = departments.id

在映射文件中定义嵌套查询：

<select id="selectAllUsersWithDepartments" resultType="com.example.demo.UserDepartment">
    SELECT users.username, departments.department_name
    FROM users
    JOIN departments ON users.department_id = departments.id
</select>

测试代码

try (SqlSession session = factory.openSession()) {
    UserMapper mapper = session.getMapper(UserMapper.class);

    List<String> users = mapper.selectAllUsersWithPage(0, 10);
    for (String user : users) {
        System.out.println(user);
    }

    List<UserDepartment> userDepartments = mapper.selectAllUsersWithDepartments();
    for (UserDepartment userDepartment : userDepartments) {
        System.out.println(userDepartment.getUsername() + ": " + userDepartment.getDepartmentName());
    }
}

练习

实现一个分页查询，例如查询第一页第1到10条记录。
实现一个嵌套查询，例如查询所有用户的姓名及其所属的部门。

MyBatis与Spring集成

Spring与MyBatis集成的目的

Spring是一个流行的Java应用框架，它提供了多种功能，包括依赖注入、事务管理等。Spring与MyBatis集成的目的在于：

通过Spring管理MyBatis的配置和依赖注入。
通过Spring管理MyBatis的事务管理。

使用Spring管理MyBatis的配置

通过在Spring配置文件中定义MyBatis的配置，可以简化MyBatis的管理和依赖注入。

Spring配置文件

在Spring配置文件中定义MyBatis配置：

<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
    <property name="dataSource" ref="dataSource"/>
    <property name="configLocation" value="classpath:mybatis-config.xml"/>
</bean>

<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSource"/>
</bean>

<bean id="userMapper" class="org.mybatis.spring.mapper.MapperScannerConfigurer">
    <property name="basePackage" value="com.example.demo.mapper"/>
</bean>

添加Spring依赖

在pom.xml中添加Spring的依赖：

<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.3.10</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-tx</artifactId>
        <version>5.3.10</version>
    </dependency>
    <dependency>
        <groupId>org.mybatis.spring.boot</groupId>
        <artifactId>mybatis-spring-boot-starter</artifactId>
        <version>2.2.0</version>
    </dependency>
</dependencies>

测试代码

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import java.util.List;

public class SpringMyBatisTest {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserMapper userMapper = context.getBean(UserMapper.class);

        List<String> users = userMapper.selectAllUsers();
        for (String user : users) {
            System.out.println(user);
        }
    }
}

实现事务管理

通过Spring管理MyBatis的事务管理，可以简化事务的管理。

事务管理配置

在Spring配置文件中定义事务管理：

<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSource"/>
</bean>

使用事务管理

通过@Transactional注解实现事务管理。

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
public class UserService {
    @Autowired
    private UserMapper userMapper;

    @Transactional
    public void createUser(String username) {
        userMapper.insertUser(username);
    }
}

测试代码

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class SpringMyBatisTest {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserService userService = context.getBean(UserService.class);

        userService.createUser("Alice");
    }
}

练习

使用Spring管理MyBatis的配置和依赖注入。
使用Spring管理MyBatis的事务管理。

MyBatis的调试与常见问题解决

调试技巧与日志设置

MyBatis的调试可以通过配置日志级别和使用调试工具来实现。

配置日志级别

在mybatis-config.xml中配置日志级别：

<settings>
    <setting name="logImpl" value="STDOUT_LOGGING"/>
</settings>

使用调试工具

使用IDE的调试工具或MyBatis的调试工具进行调试。

常见错误排查方法

常见的MyBatis错误包括SQL语法错误、配置错误、类型映射错误等。

SQL语法错误

确保SQL语句正确无误。

配置错误

检查mybatis-config.xml和映射文件的配置是否正确。

类型映射错误

确保Java对象和数据库字段的类型映射正确。

性能优化建议

性能优化可以通过以下方法实现：

使用缓存：启用MyBatis的缓存功能。
减少查询次数：通过分页查询和嵌套查询减少查询次数。
优化SQL语句：通过优化SQL语句提高查询性能。

使用缓存

启用MyBatis的缓存功能：

<settings>
    <setting name="cacheEnabled" value="true"/>
</settings>

减少查询次数

通过分页查询和嵌套查询减少查询次数：

<select id="selectAllUsersWithPage" resultType="string">
    SELECT username FROM users
    <if test="offset != null and limit != null">
        LIMIT #{offset}, #{limit}
    </if>
</select>

优化SQL语句

优化SQL语句以提高查询性能：

SELECT username FROM users
WHERE username LIKE #{username} ESCAPE '\\'

练习

使用调试工具或日志配置进行调试。
解决常见的MyBatis错误。
通过优化SQL语句和配置提高MyBatis的性能。

通过以上详细的步骤和示例代码，你可以深入学习和掌握MyBatis的核心概念、配置、操作以及调试技巧，从而更好地应用于实际开发中。

这篇关于MyBatis教程：从入门到实践的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！

MyBatis教程：从入门到实践

MyBatis是什么

MyBatis的优势与应用场景

开发环境搭建步骤

环境要求

搭建步骤

快速入门示例

创建数据库表和数据

练习

核心配置文件详解

配置项详解

SqlSessionFactory与SqlSession的使用

SqlSessionFactory

SqlSession

MyBatis的映射文件配置

映射文件示例

简化的映射文件

练习

基本的CRUD操作实现

创建（Create）

读取（Read）

更新（Update）

删除（Delete）

使用注解简化CRUD操作

使用注解定义CRUD操作

测试代码

处理复杂的查询与更新

复杂查询

复杂更新

测试代码

练习

动态SQL的使用场景

if, choose, when, otherwise标签的使用

if标签

choose标签

when标签

otherwise标签

测试代码

分页查询与嵌套查询

分页查询

嵌套查询

测试代码

练习

Spring与MyBatis集成的目的

使用Spring管理MyBatis的配置

Spring配置文件

添加Spring依赖

测试代码

实现事务管理

事务管理配置

使用事务管理

测试代码

练习

调试技巧与日志设置

配置日志级别

使用调试工具

常见错误排查方法

SQL语法错误

配置错误

类型映射错误

性能优化建议

使用缓存

减少查询次数

优化SQL语句

练习

相关编程文章