【MyBatis持久层框架】使用Java注解完成CRUD详细解读

1. 前言

之前我们通过 XML 配置文件的方式映射 sql 语句，将 sql 语句与 Java 代码分离，大大的提高了开发的效率并且解决了 JDBC 原生方式中的一些问题。其实，使用 Java 注解的方式来映射简单的 sql 语句也是十分高效且低成本的。

• 【MyBatis持久层框架】配置文件实现增删改查实战案例
• 【MyBatis持久层框架】配置文件实现增删改查实战案例（下）

示例：之前在使用 XML 配置来映射 sql 语句实现查询数据表中所有数据的操作。

public interface StudentMapper {
    /*
    查询student表中所有的数据信息
     */
    List<Student> selectALL();
}

在XML中：

<mapper namespace="org.chengzi.mapper.StudentMapper">

    <resultMap id="studentResultMap" type="student">
        <result column="score_english" property="scoreEnglish"/>
        <result column="score_math" property="scoreMath"/>
    </resultMap>

    <select id="selectALL" resultMap="studentResultMap">
        select *
        from student;
    </select>
</mapper>

使用注解来映射简单 sql 语句会使代码显得更加简洁，但对于稍微复杂一点的语句，Java 注解不仅力不从心，还会让本就复杂的 sql 语句更加混乱不堪。因此，如果你需要做一些很复杂的操作，最好用 XML 来映射语句（MyBatis官网）。

示例：使用注解映射简单 sql 语句。

public interface StudentMapper {

    /*
    查询student表中所有的数据信息
     */
    @Select("select * from student")
    List<Student> selectAll();
}

虽然 Java 注解提供了一种简单且低成本的方式来实现简单的映射语句，但是其灵活性十分有限，选择何种方式来配置映射，以及是否应该要统一映射语句定义的形式，完全取决于你和你的团队。

永远不要拘泥于一种方式，你可以很轻松地在基于注解和 XML 的语句映射方式间自由移植和切换。

2. 实战案例

需求： 使用注解的方式映射 sql 语句并且实现查找数据表中的全部数据。

MyBatis 针对 CRUD 操作提供了对应的注解，并且遵循见名知意的规则：

• 查询： @Select
• 添加： @Insert
• 修改： @Update
• 删除： @Delete

2.1 准备工作

首先，我们要创建好数据库表和添加数据，涉及到的 sql 语句如下：

drop table if exists student;

create table student(
	id int primary key auto_increment,
	name varchar(10),
	gender char(1),
	score_english int,
	score_math int
);

insert into student(name,gender,score_english,score_math) values
('张三','男',61,65),
('李四','女',45,38),
('王五','男',85,53),
('小王','男',56,58),
('小樊','女',85,92);

数据表如下图：

接下来在 idea 中 org.chengzi.pojo 包下创建实体类 Student ：

public class Student{
    //id 主键
    private int id;
    //学生姓名
    private String name;
    //学生性别
    private String gender;
    //学生英语成绩
    private int scoreEnglish;
    //学生数学成绩
    private int scoreMath;
    
    //这里省略了Getter and Setter方法和重写的Object中的toString方法
}

接下来编写测试用例，这里在 Test 中写单元测试的代码。在测试代码 Java 文件目录下创建 MyBatisTest 类。如图：

2.2 编写接口方法

在 StudentMapper 接口中编写查询所有数据的方法，如下：

List<Student> selectAll();

2.3 映射SQL语句

在 StudentMapper 接口中刚才定义的方法上面一行使用 Java 注解映射 sql 语句，如下：

@Select("select * from student")
List<Student> selectAll();

2.4 编写测试方法

在 MyBatisTest 中编写单元测试的方法，如下：

    @Test
    public void testSelectAll() throws IOException {
        //1. 获取SqlSessionFactory
        String resource = "mybatis-config.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

        //2. 获取SqlSession对象
        SqlSession sqlSession = sqlSessionFactory.openSession();

        //3. 获取Mapper接口的代理对象
        StudentMapper studentMapper = sqlSession.getMapper(StudentMapper.class);

        //4. 执行方法
        List<Student> students = studentMapper.selectAll();
        System.out.println(students);

        //5. 释放资源
        sqlSession.close();
    }

运行程序，数据表中的所有数据被打印到控制台，如下图：

前提是在 Student 类中已经重写了 Object 类中的 toString() 方法。

3. SQL语句构建器

回到最初的问题，此时我们又将 sql 写到了 Java 代码中，并且如果修改了 sql 语句，那么程序将要重新编译，十分的不方便，并且在 Java 代码中嵌入大量的 sql 语句是十分头疼的，例如之前使用的动态 sql 语句，此时将 sq l嵌入 Java 代码后代码可读性会大大的降低。而在 XML中定义 sql 似乎更加的方便与强大。

对于需要在 Java 代码中构建 sql 语句的情况，MyBatis 提供了 SQL 类来简化操作，我们只需要创建一个实例化对象，调用它的方法生成 sql 语句。

下面是SQL类的一些示例：

  // Anonymous inner class
    public String deletePersonSql() {
      return new SQL() {{
        DELETE_FROM("PERSON");
        WHERE("ID = ${id}");
      }}.toString();
    }

    // Builder / Fluent style
    public String insertPersonSql() {
      String sql = new SQL()
        .INSERT_INTO("PERSON")
        .VALUES("ID, FIRST_NAME", "${id}, ${firstName}")
        .VALUES("LAST_NAME", "${lastName}")
        .toString();
      return sql;
    }

    // With conditionals (note the final parameters, required for the anonymous inner class to access them)
    public String selectPersonLike(final String id, final String firstName, final String lastName) {
      return new SQL() {{
        SELECT("P.ID, P.USERNAME, P.PASSWORD, P.FIRST_NAME, P.LAST_NAME");
        FROM("PERSON P");
        if (id != null) {
          WHERE("P.ID like ${id}");
        }
        if (firstName != null) {
          WHERE("P.FIRST_NAME like ${firstName}");
        }
        if (lastName != null) {
          WHERE("P.LAST_NAME like ${lastName}");
        }
        ORDER_BY("P.LAST_NAME");
      }}.toString();
    }

    public String deletePersonSql() {
      return new SQL() {{
        DELETE_FROM("PERSON");
        WHERE("ID = ${id}");
      }}.toString();
    }

    public String insertPersonSql() {
      return new SQL() {{
        INSERT_INTO("PERSON");
        VALUES("ID, FIRST_NAME", "${id}, ${firstName}");
        VALUES("LAST_NAME", "${lastName}");
      }}.toString();
    }

    public String updatePersonSql() {
      return new SQL() {{
        UPDATE("PERSON");
        SET("FIRST_NAME = ${firstName}");
        WHERE("ID = ${id}");
      }}.toString();
    }

这里不再深入详解，初学者移步官网，因为这篇文章是 JavaWeb 基础教程系列的一部分，只是对 MyBatis 做一个基础的学习，后面在 SSM 框架的系列文章中，会详细讲解 MyBatis 框架的细节。

4. 总结

使用注解来映射简单 sql 语句会使代码显得更加简洁，但对于稍微复杂一点的语句，Java 注解不仅力不从心，还会让本就复杂的 SQL 语句更加混乱不堪。因此，如果你需要做一些很复杂的操作，最好用 XML 来映射语句。

选择何种方式来配置映射，以及是否应该要统一映射语句定义的形式，完全取决于你和你的团队。换句话说，永远不要拘泥于一种方式，你可以很轻松地在基于注解和 XML 的语句映射方式间自由移植和切换。