MyBatis深度解析：快速入门与实战指南-优快云博客

本文链接：https://blog.youkuaiyun.com/weixin_43618464/article/details/123635330

一、框架

1.1 框架概念

框架就是软件的半成品，框架完成了软件开发过程中的通用操作，程序猿只需要很少或者不用加工就能够实现特定的功能，从而简化开发人员在软件开发中的步骤，提高开发效率。

1.2 常用框架

MVC框架：简化了Servlet的开发步骤，负责和前端进行交互
- Struts2
- SpringMVC
持久层框架：完成数据库操作的框架，负责和数据库交互
- MyBatis
- Hibernate
胶水框架：Spring

SSM：Spring + SpringMVC + MyBatis
SSH：Spring + Struts2 + Hibernate

二、MyBatis简介

2.1 MyBatis介绍

MyBatis是一个半自动的ORM框架
ORM（Object Relation Mapping）对象关系映射，将Java中的一个对象和数据表中的一行记录一一对应。
ORM框架提供了实体类与数据表的映射关系，通过映射文件的配置，实现了对象的持久化。

MyBatis特点：

支持自定义SQL、存储过程
对原有的JDBC进行了封装，几乎消除了所有JDBC的代码，让开发人员只需要关注SQL语句本身
支持XML和注解配置的方式自动完成ORM操作，实现结果映射

2.2 MyBatis部署

框架部署就是把框架引入到我们自己的项目里

2.2.1 创建Maven项目

Java项目
Web项目

2.2.2 在项目中添加MyBatis依赖

在 pom.xml 中添加依赖
- mybatis
- mysqldriver

<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.1.47</version>
</dependency>
<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis</artifactId>
    <version>3.4.6</version>
</dependency>

2.2.3 创建MyBatis配置文件

在resources中创建名为mybatis-config.xml的文件
在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中配置数据库连接信息-->
    <!--一个environments标签中可以定义而多个environment标签，
    每个environment标签可以定义一套连接配置-->
    <!--default用来指定使用哪一个environment-->
    <environments default="mysql">
        <!--transactionManager标签用于配置数据库的管理方式-->
        <!--dataSource标签就是用来配置数据库连接信息-->
        <environment id="mysql">
            <transactionManager type="JDBC"></transactionManager>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/db1?characterEncoding=utf-8"/>
                <property name="username" value="root"/>
                <property name="password" value="root"/>
            </dataSource>
        </environment>
    </environments>

</configuration>

2.3 MyBatis框架使用

案例：学生信息的数据库操作

2.3.1 创建数据表

tb_student

SQL语句如下：

create table tb students(
 sid int primary key auto increment,
 stu_num char(5) not null unique, 
 stu_name varchar(20) not null, 
 stu_gender char(2) not null, 
 stu_age int not null);

2.3.2 创建实体类

在这里插入图片描述

2.3.3 创建DAO接口，定义操作方法

在这里插入图片描述

2.3.4 创建DAO接口下的映射文件

在resources目录下，新建名为mappers文件夹
在mappers中新建名为StudentMapper.xml的映射文件（根据模板创建）
在映射文件中对DAO中定义的方法进行实现：

<?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文件相当于DAO接口的‘实现类’，namespace属性要指定`实现`DAO接口的全限定名-->
<mapper namespace="com.qfedu.dao.StudentDAO">
    <insert id="insertStudent" parameterType="com.qfedu.pojo.Student">
        insert into tb_student(stu_num,stu_name,stu_gender,stu_age)
        values(#{stuNum},#{stuName},#{stuGender},#{stuAge})
    </insert>

    <delete id="deleteStudent">
        delete from tb_students where stu_num = #{stuNum};
    </delete>

</mapper>

2.3.5 将映射文件添加到主配置文件

在这里插入图片描述

2.4 单元测试

2.4.1 添加单元测试依赖

        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13</version>
        </dependency>

2.4.2 创建单元测试类

被测试类名后，alt + insert – 选择Test
在这里插入图片描述

2.4.3 测试代码

package com.qfedu.dao;

import com.qfedu.pojo.Student;
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.IOException;
import java.io.InputStream;

import static org.junit.Assert.*;

/**
 * @auther xiaochen
 * @create 2022-03-22 9:13
 */
public class StudentDAOTest {

    @org.junit.Test
    public void insertStudent() {
        try {
            //加载配置文件（连接信息）
            InputStream is = Resources.getResourceAsStream("mybatis-config.xml");

            SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();

            //会话工厂，连接需要连接信息
            SqlSessionFactory factory = builder.build(is);

            //会话（连接）
            SqlSession sqlSession = factory.openSession();
            //通过会话获取DAO对象
            StudentDAO studentDAO = sqlSession.getMapper(StudentDAO.class);
            //测试StudentDAO中的方法
            int i = studentDAO.insertStudent(new Student(0, "10001", "飞飞", "男", 21));
            //需要手动提交
            sqlSession.commit();

            System.out.println(i);


        } catch (IOException e) {
            e.printStackTrace();
        }

    }

    @org.junit.Test
    public void deleteStudent() {
    }
}

三、MyBatis的CRUD操作

案例：学生信息的增删查改

3.1 添加操作

略

3.2 删除操作

根据学号删除一条学生信息

在StudentDAO中定义删除方法
在StudentMapper.xml中对接口方法进行实现
单元测试：在StudentDAO的测试类中添加测试方法

@org.junit.Test
    public void deleteStudent() {

        //不能保证文件名一定是正确的，所以可能会抛出异常，需要进行捕获
        try {
            InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
            //SqlSessionFactoryBuilder
            SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();

            //sqlSessionFactory表示MyBatis的会话工厂
            SqlSessionFactory factory = builder.build(is);

            //sqlSession表示MyBatis与数据库之间的会话：通过工厂方法设计模式
            SqlSession sqlSession = factory.openSession();

            //通过SqlSession对象调用getMapper方法来获取DAO对象
            StudentDAO studentDAO = sqlSession.getMapper(StudentDAO.class);
            //调用被测试方法
            int i = studentDAO.deleteStudent("10001");
            //提交事务
            sqlSession.commit();
            System.out.println(i);
        } catch (IOException e) {
            e.printStackTrace();
        }


    }

3.3 修改操作

根据学生学号，修改学生信息

在StudentDAO定义修改方法
在StudentMapper.xml中对接口方法进行实现
单元测试

    @Test
    public void testUpdateStudent(){

        //不能保证文件名一定是正确的，所以可能会抛出异常，需要进行捕获
        try {
            InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
            //SqlSessionFactoryBuilder
            SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();

            //sqlSessionFactory表示MyBatis的会话工厂
            SqlSessionFactory factory = builder.build(is);

            //sqlSession表示MyBatis与数据库之间的会话：通过工厂方法设计模式
            SqlSession sqlSession = factory.openSession();

            //通过SqlSession对象调用getMapper方法来获取DAO对象
            StudentDAO studentDAO = sqlSession.getMapper(StudentDAO.class);
            //调用被测试方法
            int i = studentDAO.updateStudent(new Student(0, "10001", "佳佳", "男", 21));
            //断言
            assertEquals(1,i);
            //提交事务
            sqlSession.commit();
            System.out.println(i);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

其中，assertEquals()方法表示断言，如果与期望值不同则会出现断言异常。
在这里插入图片描述

3.4 查询操作-查询所有数据操作

在StudentDAO中定义查询所有学生的方法
在StudentMapper.xml对接口方法进行实现
定义实体类和数据库表的映射关系
引用实体类和数据库表的映射关系
单元测试

    @Test
    public void testListStudent(){

        //不能保证文件名一定是正确的，所以可能会抛出异常，需要进行捕获
        try {
            InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
            //SqlSessionFactoryBuilder
            SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();

            //sqlSessionFactory表示MyBatis的会话工厂
            SqlSessionFactory factory = builder.build(is);

            //sqlSession表示MyBatis与数据库之间的会话：通过工厂方法设计模式
            SqlSession sqlSession = factory.openSession();

            //通过SqlSession对象调用getMapper方法来获取DAO对象
            StudentDAO studentDAO = sqlSession.getMapper(StudentDAO.class);
            //调用被测试方法
            List<Student> students = studentDAO.listStudent();
            for (Student student : students) {
                System.out.println(student);
            }
            //断言
            assertNotNull(students);
            //查询操作不需要提交事务，因为不会更改数据库
  
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

3.5 查询操作-查询单条记录

在StudentDAO中定义查询所有学生的方法
在StudentMapper.xml对接口方法实现
单元测试

    @Test
    public void testQueryStudent(){

        //不能保证文件名一定是正确的，所以可能会抛出异常，需要进行捕获
        try {
            InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
            //SqlSessionFactoryBuilder
            SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();

            //sqlSessionFactory表示MyBatis的会话工厂
            SqlSessionFactory factory = builder.build(is);

            //sqlSession表示MyBatis与数据库之间的会话：通过工厂方法设计模式
            SqlSession sqlSession = factory.openSession();

            //通过SqlSession对象调用getMapper方法来获取DAO对象
            StudentDAO studentDAO = sqlSession.getMapper(StudentDAO.class);
            //调用被测试方法
            Student student = studentDAO.queryStudent("10001");
            System.out.println(student);
            //断言
            assertNotNull(student);

        } catch (IOException e) {
            e.printStackTrace();
        }
    }

3.6 查询操作-多参数查询

在MyBatis进行操作时：

如果操作方法只有一个简单类型或者字符串类型的参数，在Mapper配置中可以直接通过#{str}直接获取
如果操作方法只有一个对象类型的参数，在Mapper配置中可以直接通过#{attrName}来获取对象的指定属性值
如果操作方法有一个Map类型，在Mapper配置中可以直接通过#{key}获取key对应的value
如果操作方法有多个参数，可以使用@Param注解声明参数的别名

分页查询（参数 start，pageSize）

在StudentDAO定义分页查询的方法
在StudentMapper.xml对接口方法进行实现，，使用#{别名}获取到指定的参数
单元测试

    @Test
    public void testListStudentByPage(){

        //不能保证文件名一定是正确的，所以可能会抛出异常，需要进行捕获
        try {
            InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
            //SqlSessionFactoryBuilder
            SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();

            //sqlSessionFactory表示MyBatis的会话工厂
            SqlSessionFactory factory = builder.build(is);

            //sqlSession表示MyBatis与数据库之间的会话：通过工厂方法设计模式
            SqlSession sqlSession = factory.openSession();

            //通过SqlSession对象调用getMapper方法来获取DAO对象
            StudentDAO studentDAO = sqlSession.getMapper(StudentDAO.class);
            //调用被测试方法
            List<Student> students = studentDAO.listStudentByPage(0,2);

            for (Student student : students) {
                System.out.println(student);
            }
            //断言
            assertNotNull(students);

        } catch (IOException e) {
            e.printStackTrace();
        }
    }

注意：如果DAO操作方法没有通过@Param指定参数别名，在SQL中也可以使用arg0,arg1,...或者param1,param2,...的方式来获取参数。

3.7 查询操作-查询总记录数

在StudentDAO中定义操作方法
在StudentMapper.xml中实现接口方法，通过resultType指定当前操作的返回类型为int
单元测试

    @Test
    public void testgetCount(){

        //不能保证文件名一定是正确的，所以可能会抛出异常，需要进行捕获
        try {
            InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
            //SqlSessionFactoryBuilder
            SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();

            //sqlSessionFactory表示MyBatis的会话工厂
            SqlSessionFactory factory = builder.build(is);

            //sqlSession表示MyBatis与数据库之间的会话：通过工厂方法设计模式
            SqlSession sqlSession = factory.openSession();

            //通过SqlSession对象调用getMapper方法来获取DAO对象
            StudentDAO studentDAO = sqlSession.getMapper(StudentDAO.class);
            //调用被测试方法

            int count = studentDAO.getCount();
            System.out.println(count);

        } catch (IOException e) {
            e.printStackTrace();
        }
    }

3.7 添加操作-主键回填

在StudentMapper.xml中添加操作标签–insert

	<!--useGeneratedKey 表示设置添加操作是否需要回填生成的主键-->
	<!--keyProperty 设置回填的主键复制到参数对象中的哪一个属性-->
    <insert id="insertStudent" useGeneratedKeys="true" keyProperty="stuId">
        insert into tb_students(stu_num,stu_name,stu_gender,stu_age)
        values(#{stuNum},#{stuName},#{stuGender},#{stuAge})
    </insert>

四、工具类封装

MyBatisUtil

/**
 * @auther xiaochen
 * @create 2022-03-23 8:28
 */
//工具类的目标是对外提供SQLSession
public class MyBatisUtil {

    private static SqlSessionFactory factory;
    //当我们在创建一个ThreadLocal变量后，每个线程对其进行访问的时候访问的都是线程自己的变量,这样就不会存在线程不安全问题。
    private static final ThreadLocal<SqlSession> local = new ThreadLocal<SqlSession>();


    static {

        try {
            //加载MyBatis配置文件
            InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
            SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
            //工厂是单例的，所以只加载一次就够了
            //不能每做一顿红烧肉就开一家饭店
            factory = builder.build(is);
        } catch (IOException e) {
            e.printStackTrace();
        }

    }

    public static SqlSessionFactory getFactory() {
        return factory;
    }


    public static SqlSession getSqlSession() {
        SqlSession sqlSession = local.get();
        if (sqlSession == null) {
            sqlSession = factory.openSession();
            local.set(sqlSession);
        }
        return factory.openSession();
    }


    public static <T extends Object> T getMapper(Class<T> c) {
        SqlSession sqlSession = getSqlSession();
        return sqlSession.getMapper(c);
    }

}

五、事务管理

SqlSession功能：

getMapper(DAO.class):获取Mapper（DAO对象的实例）
事务管理

5.1 手动提交事务

测试类中的手动事务管理

    @org.junit.Test
    public void insertStudent() {

        SqlSession sqlSession = MyBatisUtil.getSqlSession();
        //1.当获取SqlSession对象时，就默认开启了事务
        try {
            //通过会话获取DAO对象
            StudentDAO studentDAO = sqlSession.getMapper(StudentDAO.class);
            //测试StudentDAO中的方法
            Student student = new Student(5, "10009", "周杰伦", "男", 28);
            int i = studentDAO.insertStudent(student);
            //2.操作成功之后，需要手动提交事务
            sqlSession.commit();

            System.out.println(student);
        } catch (Exception e) {
            //3.操作出现异常，需要对事务进行rollback回滚事务
            sqlSession.rollback();
        }
    }

5.2 自动提交事务

通过SqlSessionFactory调用openSession方法获取SQLSession对象时，可以通过参数来设置事务是否自动提交：

如果参数设置为true，表示自动事务提交
如果不设置参数或者设置为false，表示手动事务提交

MyBatisUtil优化


/**
 * @auther xiaochen
 * @create 2022-03-23 8:28
 */
//工具类的目标是对外提供SQLSession
public class MyBatisUtil {

    private static SqlSessionFactory factory;
    //当我们在创建一个ThreadLocal变量后，每个线程对其进行访问的时候访问的都是线程自己的变量,这样就不会存在线程不安全问题。
    private static final ThreadLocal<SqlSession> local = new ThreadLocal<SqlSession>();


    static {

        try {
            //加载MyBatis配置文件
            InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
            SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
            //工厂是单例的，所以只加载一次就够了
            //不能每做一顿红烧肉就开一家饭店
            factory = builder.build(is);
        } catch (IOException e) {
            e.printStackTrace();
        }

    }

    public static SqlSessionFactory getFactory() {
        return factory;
    }

    //自动提交事务
    public static SqlSession getSqlSession(boolean isAutoCommit) {
        SqlSession sqlSession = local.get();
        if (sqlSession == null) {
            sqlSession = factory.openSession(isAutoCommit);
            local.set(sqlSession);
        }
        return sqlSession;
    }

    //手动提交事务,以重载的方式实现
    public static SqlSession getSqlSession() {
        return getSqlSession(false);
    }

    //自动提交事务
    //直接获取DAO就是不想进行手动事务管理，所以直接设置为自动事务提交
    public static <T extends Object> T getMapper(Class<T> c) {
        SqlSession sqlSession = getSqlSession(true);
        return sqlSession.getMapper(c);
    }

}

测试操作

手动事务提交

    @org.junit.Test
    public void insertStudent() {

        SqlSession sqlSession = MyBatisUtil.getSqlSession(false);
        //1.当获取SqlSession对象时，就默认开启了事务
        try {
            //通过会话获取DAO对象
            StudentDAO studentDAO = sqlSession.getMapper(StudentDAO.class);
            //测试StudentDAO中的方法
            Student student = new Student(5, "10009", "周杰伦", "男", 28);
            int i = studentDAO.insertStudent(student);

            //操作1
            //操作2
            //...
            //操作3

            //如果需要使用SqlSession进行多步操作，建议使用手动提交事务

            //2.操作成功之后，需要手动提交事务
            sqlSession.commit();

            System.out.println(student);
        } catch (Exception e) {
            //3.操作出现异常，需要对事务进行rollback回滚事务
            sqlSession.rollback();
        }
    }

自动事务提交

    @org.junit.Test
    public void deleteStudent() {
        StudentDAO studentDAO = MyBatisUtil.getMapper(StudentDAO.class);
        int i = studentDAO.deleteStudent("10001");
            //提交事务
    }

五、MyBatis主配置文件

mybatis-config.xml是MyBatis框架的主配置文件，主要用于配置MyBatis数据源以及属性信息

5.1 properties标签

用于设置键值对，或者加载属性文件

在resources目录下创建jdbc.properties文件，配置键值对如下

mysql_driver=com.mysql.jdbc.Driver
mysql_url=jdbc:mysql://localhost:3306/db1?useSSL=true
mysql_username=root
mysql_password=123456

在mybatis-config.xml中通过properties标签引用jdbc.properties文件；
引入文件之后，在配置environment时可以直接使用jdbc.properties的key来获取对应的value

注意：${}是properties文件中的变量占位符，#{}是sql的参数占位符。

5.2 setting标签

<!--设置mybatis的属性-->
<settings>
    <!-- 启动二级缓存-->
    <setting name="cacheEnabled" value="true"/>
    <!-- 启动延迟加载 -->
    <setting name="lazyLoadingEnabled" value="true"/>
</settings>

8.3 typeAliases标签

<!--typeAliases标签用于给实体类取别名，在映射文件中可以直接使用别名来替代实体类的全限定名-->
<typeAliases>
    <typeAlias type="com.qfedu.pojo.Student" alias="Student"></typeAlias>
    <typeAlias type="com.qfedu.pojo.Book" alias="Book"></typeAlias>
</typeAliases>

5.4 plugins标签

<!--plugins标签，用于配置MyBatis插件（分页插件）-->
<plugins>
    <plugin interceptor=""></plugin>
</plugins>

5.5 environments标签

<!-- 在environments配置数据库连接信息 -->
<!-- 在environments标签中可以定义多个environment标签，每个environment标签可以定义一套连接配置 -->
<!-- default属性，用来指定使用哪个environment标签 -->
<environments default="mysql">

    <!--  environment 标签用于配置数据库连接信息  -->
    <environment id="mysql">

        <!--transactionManager标签用于配置数据库管理方式
            type="JDBC"  可以进行事务的提交和回滚操作
            type="MANAGED" 依赖容器完成事务管理，本身不进行事务的提交和回滚操作 -->
        <transactionManager type="JDBC"></transactionManager>

        <!--dataSource标签就是用来配置数据库连接信息 POOLED|UNPOOLED -->
        <dataSource type="POOLED">
            <property name="driver" value="${mysql_driver}"/>
            <property name="url" value="${mysql_url}"/>
            <property name="username" value="${mysql_username}"/>
            <property name="password" value="${mysql_password}"/>
        </dataSource>
    </environment>

</environments>

5.6 mappers标签

加载映射配置（映射文件、DAO注解）

<!--mappers标签用于载入映射文件-->
<mappers>
    <mapper resource="mappers/StudentMapper.xml"></mapper>
</mappers>

六、映射文件

6.1 MyBatis Mapper初始化

XML文件解析：读取xml文件中的标签配置封装到Java对象中

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-n7eXPOJ3-1648176376717)(imgs/1616487875112.png)]

6.2 mapper根标签

mapper文件相当于DAO接口的‘实现类’，namespace属性要指定实现DAO接口的全限定名

6.3 insert标签

声明添加操作（sql: insert …）

常用属性

id属性，绑定对应DAO接口中的方法

parameterType属性，用以指定接口中对应方法的参数类型（可省略）

useGeneratedKeys属性，设置添加操作是否需要回填生成的主键

keyProperty属性，指定回填的id设置到参数对象中的哪个属性

timeout属性，设置此操作的超时时间，如果不设置则一直等待

主键回填

<insert id="insertStudent" useGeneratedKeys="true" keyProperty="stuId">
    insert into tb_students(stu_num, stu_name, stu_gender, stu_age)
    values (#{stuNum}, #{stuName}, #{stuGender}, #{stuAge})
</insert>

<insert id="insertStudent" >
    <selectKey keyProperty="stuId" resultType="java.lang.Integer">
        select last_insert_id()
    </selectKey>
    insert into tb_students(stu_num, stu_name, stu_gender, stu_age)
    values (#{stuNum}, #{stuName}, #{stuGender}, #{stuAge})
</insert>

6.4 delete标签

声明删除操作

6.5 update标签

声明修改操作

6.6 select标签

声明查询操作

id属性，指定绑定方法的方法名

parameterType属性，设置参数类型

resultType属性，指定当前sql返回数据封装的对象类型（实体类）

resultMap属性，指定从数据表到实体类的字段和属性的对应关系

useCache属性，指定此查询操作是否需要缓存

timeout属性，设置超时时间

6.7 resultMap标签

<!-- resultMap标签用于定义实体类与数据表的映射关系（ORM） -->
<resultMap id="studentMap" type="Student">
    <id column="sid" property="stuId"/>
    <result column="stu_num" property="stuNum"/>
    <result column="stu_name" property="stuName"/>
    <result column="stu_gender" property="stuGender"/>
    <result column="stu_age" property="stuAge"/>
</resultMap>

6.8 cache标签

设置当前DAO进行数据库操作时的缓存属性设置

<cache type="" size="" readOnly="false"/>

6.9 sql和include

SQL片段

<sql id="wanglaoji">sid , stu_num , stu_name , stu_gender , stu_age</sql>

<select id="listStudents" resultMap="studentMap">
    select <include refid="wanglaoji"/> from tb_students
</select>