MyBatis详解（一）

程序猿混饭吃

已于 2022-08-29 15:10:15 修改

阅读量531

点赞数 19

文章标签： mybatis 学习 java

于 2022-08-25 16:26:04 首次发布

本文链接：https://blog.csdn.net/weixin_45523187/article/details/126524396

版权

一、MyBatis简介

1.1 MyBatis介绍

MyBatis是一个半自动的ORM框架

ORM（Object Relational Mapping）对象关系映射，将Java中的一个对象与数据表中一行记录一一对应。

ORM框架提供了实体类与数据表的映射关系，通过映射文件的配置，实现对象的持久化。

MyBatis的前身是iBatis，iBatis是Apache软件基金会提供的一个开源项目
2010年iBatis迁移到Google code，正式更名为MyBatis
2013年迁移到Github托管
MyBatis特点：
- 支持自定义SQL、存储过程
- 对原有的JDBC进行了封装，几乎消除了所有JDBC代码，让开发者只需关注SQL本身
- 支持XML和注解配置方式自定完成ORM操作，实现结果映射

二、MyBatis框架部署

框架部署，就是将框架引入到我们的项目中

2.1 创建Maven项目

Java工程
Web工程

2.2 在项目中添加MyBatis依赖

在pom.xml中添加依赖

mybatis
mysql driver

<!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.1.47</version>
</dependency>

<!-- https://mvnrepository.com/artifact/org.mybatis/mybatis -->
<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis</artifactId>
    <version>3.4.6</version>
</dependency>

2.3 创建MyBatis配置文件

创建自定义模板：选择resources----右键New----Edit File Templates 如果版本问题去file----setting中找
在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">
          
          <environment id="mysql">
              <!--transactionManager标签用于配置数据库管理方式-->
              <transactionManager type="JDBC"></transactionManager>
              <!--dataSource标签就是用来配置数据库连接信息 -->
              <dataSource type="POOLED">
                  <property name="driver" value="com.mysql.jdbc.Driver"/>
                  <property name="url" value="jdbc:mysql://localhost:3306/test11?characterEncoding=utf-8"/>
                  <property name="username" value="root"/>
                  <property name="password" value="root"/>
              </dataSource>
          </environment>
          
      </environments>
  
  </configuration>

三、MyBatis框架使用

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

3.1 创建数据表

tb_students


DROP TABLE IF EXISTS `tb_students`;

CREATE TABLE `tb_students` (
  `sid` int(11) NOT NULL AUTO_INCREMENT,
  `stu_num` char(5) NOT NULL,
  `stu_name` varchar(20) NOT NULL,
  `stu_gender` char(2) NOT NULL,
  `stu_age` int(11) NOT NULL,
  PRIMARY KEY (`sid`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

3.2 创建实体类

Student.java

package com.xinhua.pojo;

public class Student {

    private int sid;
    private String stuNum;
    private String stuName;
    private String stuGender;
    private int stuAge;

    public int getSid() {
        return sid;
    }

    public void setSid(int sid) {
        this.sid = sid;
    }

    public String getStuNum() {
        return stuNum;
    }

    public void setStuNum(String stuNum) {
        this.stuNum = stuNum;
    }

    public String getStuName() {
        return stuName;
    }

    public void setStuName(String stuName) {
        this.stuName = stuName;
    }

    public String getStuGender() {
        return stuGender;
    }

    public void setStuGender(String stuGender) {
        this.stuGender = stuGender;
    }

    public int getStuAge() {
        return stuAge;
    }

    public void setStuAge(int stuAge) {
        this.stuAge = stuAge;
    }

    public Student(int sid, String stuNum, String stuName, String stuGender, int stuAge) {
        this.sid = sid;
        this.stuNum = stuNum;
        this.stuName = stuName;
        this.stuGender = stuGender;
        this.stuAge = stuAge;
    }

    @Override
    public String toString() {
        return "Student{" +
                "sid=" + sid +
                ", stuNum='" + stuNum + '\'' +
                ", stuName='" + stuName + '\'' +
                ", stuGender='" + stuGender + '\'' +
                ", stuAge=" + stuAge +
                '}';
    }

    public Student() {
    }
}

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

StudentDAO.java

package com.xinhua.dao;

import com.xinhua.pojo.Student;

public interface StudentDao {

    public int insertStudent(Student student);
}

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.xinhua.dao.StudentDAO"></mapper>

    <insert id="insertStudent">
        insert into tb_students(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>

注意：mapper文件中的sql的id为接口中的对应的方法名，sql语句中的#为了防止sql注入的问题，大括号里面的为实体类中的属性

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

mybatis-config.xml

<mappers>
        <mapper resource="mapper/StudentMapper.xml"></mapper>
</mappers>

4.2 创建单元测试类

在被测试类名后alt+insert — 选择Test

public class StudentDAOTest {

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

        try {
            //加载mybatis配置文件
            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() {
    }
}

3.5 测试项目的主题结构

在这里插入图片描述

五、MyBatis的CRUD操作

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

5.1 添加操作

见学习总结一

5.2 删除操作

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

在StudentDAO中定义删除方法

StudentDAO

public int deleteStudent(String stuNum);

在StudentMapper.xml中对接口方法进行“实现”

StudentMapper.xml

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

测试：在StudentDAO的测试类中添加测试方法
| StudentDAOTest |
| ---------------------------------------- |

 @Test
    public void testdeleteStudent(){


        try {
           InputStream inputStream =  Resources.getResourceAsStream("mybatis-config.xml");
            SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
            //代表mybatis的会话工厂
            SqlSessionFactory factory =builder.build(inputStream);
            //sqlsessoion代表与数据库之间的一次会话  通过工厂模式去生产
            SqlSession  sqlSession = factory.openSession();
            //通过sqlsession对象的getmapper方法调用接口对象
            StudentDao studentDao = sqlSession.getMapper(StudentDao.class);

            //执行操作
            int i = studentDao.deleteStudent("10001");
            System.out.println(i);
            //提交
            sqlSession.commit();
        } catch (IOException e) {
            e.printStackTrace();
        }

    }

5.3 修改操作

根据学生学号，修改其他字段信息

在StudentDAO接口中定义修改方法

StudentDAO

public int updateStudent(Student student);

在StudentMapper.xml中“实现”接口中定义的修改方法

StudentMapper.xml

<update id="updateStudent">
        update tb_students set stu_name=#{stuName},
                               stu_gender=#{stuGender},
                               stu_age=#{stuAge}
                            where stu_num=#{stuNum}
    </update>

单元测试

StudentDAOTest

@Test
    public void testUpdateStudent(){
        try {
            InputStream inputStream =  Resources.getResourceAsStream("mybatis-config.xml");
            SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
            //代表mybatis的会话工厂
            SqlSessionFactory factory =builder.build(inputStream);
            //sqlsessoion代表与数据库之间的一次会话  通过工厂模式去生产
            SqlSession  sqlSession = factory.openSession();
            //通过sqlsession对象的getmapper方法调用接口对象
            StudentDao studentDao = sqlSession.getMapper(StudentDao.class);
            studentDao.updateStudent(new Student(5,"10001","李四","女",18));
            sqlSession.commit();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

5.4 查询操作-查询所有

在StudentDAO接口定义操作方法

StudentDAO

 //查询操作之查询所有操作
    public List<Student> listStudents();

在StudentMapper.xml中“实现”DAO中定义的方法，一共两种方式

StudentMapper.xml

 <!--查询所有操作
    resultType:指定查询结果对应的实体类
    -->
    <select id="listStudents" resultType="com.xinhua.pojo.Student">
    /*注意数据库字段和实体类字段不一致这个地方需要起别名  封装到实体类中*/
        select sid sid,stu_num stuNum,stu_name stuName,stu_gender stuGender,stu_age stuAge
        from tb_Students
    </select>

第二种查询所有的方式

<!--<resultMap id="aaa" type="com.xinhua.pojo.Student">
        <id column="sid" property="sid"></id>
        <result column="stu_num" property="stuName"></result>
        <result column="stu_name" property="stuName"></result>
        <result column="stu_gender" property="stuGender"></result>
        <result column="stu_age" property="stuAge"></result>
    </resultMap>
    <select id="listStudents" resultType="com.xinhua.pojo.Student" resultMap="aaa">
        select sid,stu_num,stu_name,stu_gender,stu_age
        from tb_Students
    </select>-->

单元测试

StudentDAOTest

   @Test
    public void testlistStudent(){
        try {
            InputStream inputStream =  Resources.getResourceAsStream("mybatis-config.xml");
            SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
            //代表mybatis的会话工厂
            SqlSessionFactory factory =builder.build(inputStream);
            //sqlsessoion代表与数据库之间的一次会话  通过工厂模式去生产
            SqlSession  sqlSession = factory.openSession();
            //通过sqlsession对象的getmapper方法调用接口对象
            StudentDao studentDao = sqlSession.getMapper(StudentDao.class);
            List<Student> list = studentDao.listStudents();
            for (Student stu:list) {
                System.out.println(list);
            }
            sqlSession.commit();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

5.5 查询操作-查询一条记录

根据学号查询一个学生信息

在StudentDAO接口中定义方法

StudentDAO

//查询一条记录
    public Student queryStudent(String stuNum);

在StudentDAOMapper.xml中配置StudentDAO接口的方法实现——SQL

StudentDAOMapper.xml

<!--查询一条记录sql-->
    <select id="queryStudent" resultMap="aaa">
        select sid,stu_num,stu_name,stu_gender,stu_age
        from tb_students where stu_num=#{stuNum}
    </select>

单元测试

StudentDAOTest

 @Test
    public void testqueryStudent(){
        try {
            InputStream inputStream =  Resources.getResourceAsStream("mybatis-config.xml");
            SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
            //代表mybatis的会话工厂
            SqlSessionFactory factory =builder.build(inputStream);
            //sqlsessoion代表与数据库之间的一次会话  通过工厂模式去生产
            SqlSession  sqlSession = factory.openSession();
            //通过sqlsession对象的getmapper方法调用接口对象
            StudentDao studentDao = sqlSession.getMapper(StudentDao.class);
            Student student studentDao.queryStudent("10002");
            sqlSession.commit();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

5.6 查询操作-多参数查询

分页查询（参数 start ， pageSize）

在StudentDAO中定义操作方法，如果方法有多个参数，使用@Param注解声明参数的别名

StudentDAO

//分页查询
    public List<Student> listStudentsByPage(HashMap<String,Integer> map);

在StudentMapper.xml配置sql时，使用#{别名}获取到指定的参数

StudentMapper.xml

 <!--分页查询-->
    <select id="listStudentsByPage" resultMap="aaa">
        select sid,stu_num,stu_name,stu_gender,stu_age
        from tb_students
        limit #{start},#{pageSize}
    </select>

单元测试

StudentDAOTest

 @Test
    public void testlsitStudent(){
        try {
            InputStream inputStream =  Resources.getResourceAsStream("mybatis-config.xml");
            SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
            //代表mybatis的会话工厂
            SqlSessionFactory factory =builder.build(inputStream);
            //sqlsessoion代表与数据库之间的一次会话  通过工厂模式去生产
            SqlSession  sqlSession = factory.openSession();
            //通过sqlsession对象的getmapper方法调用接口对象
            StudentDao studentDao = sqlSession.getMapper(StudentDao.class);
            /*
            * 解释一下为什么使用HashMap：
            * 1.如果操作方法是一个简单类型的或者字符串类型的参数，在mapper配置中使用#{key}获取
            * 2.如果操作方法有一个对象类型的参数，可以在mapper中使用#{attrName}来获取对象指定的属性值，前提attrname必须是对象的属性
            * 3.如果操作方法是一个map类型的集合，在mapper中使用#{key}来获取对应的value值
            * 
            * */
            HashMap<String,Integer> map = new HashMap<String,Integer>();
            map.put("start",0);
            map.put("pageSize",2);
            List<Student> list = studentDao.listStudentsByPage(map);
            sqlSession.commit();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

分页查询情况二

如果操作方法有多个参数，该如何处理

StudentDAO

public List<Student> listStudentsByPage(@Param("size") int size, @Param("start")int start);

5.8 添加操作回填生成的主键

继续接学习总结二中内容

StduentMapper.xml的添加操作标签——insert

<!-- useGeneratedKeys 设置添加操作是否需要回填生成的主键 -->
<!-- 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>

六、MyBatis工具类封装

MyBatisUtil

public class MyBatisUtil {

    private static SqlSessionFactory factory;
    private static final ThreadLocal<SqlSession> local = new ThreadLocal<SqlSession>();

    static{
        try {
            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 sqlSession;
    }

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

}

七、事务管理

SqlSession 对象

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

7.1 手动提交事务

sqlSession.commit();提交事务
sqlSession.rollback();事务回滚

测试类中进行事务管理

@Test
public void insertStudent() {
    SqlSession sqlSession = MyBatisUtil.getSqlSession();
    //1.当我们获取sqlSession对象时，就默认开启了事务
    try{
        //通过会话获取DAO对象
        StudentDAO studentDAO = sqlSession.getMapper(StudentDAO.class);
        //测试StudentDAO中的方法
        Student student = new Student(0, "10005", "Lily", "女", 21);
        int i = studentDAO.insertStudent(student);
        //2.操作完成并成功之后，需要手动提交
        sqlSession.commit();
    }catch (Exception e){
        //3.当操作出现异常，调用rollback进行回滚
        sqlSession.rollback();
    }
}

业务逻辑层手动事务管理

public class StudentServiceImpl implements StudentService {

    public boolean addStudent(Student student) {
        boolean b = false;
        SqlSession sqlSession = MyBatisUtil.getSqlSession();
        try{
            StudentDAO studentDAO = sqlSession.getMapper(StudentDAO.class);
            int i = studentDAO.insertStudent(student);
            b = i>0;
            sqlSession.commit();
        }catch (Exception e){
            sqlSession.rollback();
        }
        return b;
    }
}

7.2 自动提交事务

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

如果参数设置为true，表示自定提交事务： factory.openSession(true);

如果参数设置为false，或者不设置参数，表示手动提交：factory.openSession();/factory.openSession(false);

MyBatisUtil优化

public class MyBatisUtil {

    private static SqlSessionFactory factory;
    private static final ThreadLocal<SqlSession> local = new ThreadLocal<SqlSession>();

    static{
        try {
            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;
    }

    private 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);
    }

    //自动事务提交
    public static <T extends Object>T getMapper(Class<T> c){
        SqlSession sqlSession = getSqlSession(true);
        return sqlSession.getMapper(c);
    }

}

测试操作

@Test
public void testDeleteStudent() {
    StudentDAO studentDAO = MyBatisUtil.getMapper(StudentDAO.class);
    int i = studentDAO.deleteStudent("10001");
}

业务逻辑层自动事务管理

public class StudentServiceImpl implements StudentService {

    private StudentDAO studentDAO = MyBatisUtil.getMapper(StudentDAO.class);

    public boolean addStudent(Student student) {
        int i = studentDAO.insertStudent(student);
        boolean b = i>0;
        return b;
    }
}

八、MyBatis主配置文件

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

8.1 properties标签

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

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

mysql_driver=com.mysql.jdbc.Driver
mysql_url=jdbc:mysql://localhost:3306/db_2010_fmwy?characterEncoding=utf-8
mysql_username=root
mysql_password=admin123

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

mybatis-config.xml

8.2 settings标签

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

8.3 typeAliases标签

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

8.4 plugins标签

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

8.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>

8.6 mappers标签

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

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

九、映射文件

9.1 MyBatis Mapper初始化

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

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

9.2 mapper根标签

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

9.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>

9.4 delete标签

声明删除操作

9.5 update标签

声明修改操作

9.6 select标签

声明查询操作

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

parameterType属性，设置参数类型

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

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

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

timeout属性，设置超时时间

9.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>

9.8 cache标签

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

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

9.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>

十、分页插件

分页插件是一个独立于MyBatis框架之外的第三方插件;

10.1 添加分页插件的依赖

PageHelper

 <!-- pagehelper分页插件 -->
<dependency>
    <groupId>com.github.pagehelper</groupId>
    <artifactId>pagehelper</artifactId>
    <version>5.1.10</version>
</dependency>

10.2 配置插件

在mybatis的主配置文件mybatis-config.xml中通过plugins标签进行配置

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

10.3 分页实例

对学生信息进行分页查询

@Test
public void testListStudentsByPage() {
    StudentDAO studentDAO = MyBatisUtil.getMapper(StudentDAO.class); //sqlSession
    PageHelper.startPage(2,4);
    List<Student> students = studentDAO.listStudents();
    PageInfo<Student> pageInfo = new PageInfo<Student>(students);
    //pageInfo中就包含了数据及分页信息
}

带条件分页

@Test
public void testListStudentsByPage() {
    StudentDAO studentDAO = MyBatisUtil.getMapper(StudentDAO.class); //sqlSession
    PageHelper.startPage(2,4);
    //List<Student> students = studentDAO.listStudents();
    List<Student> list = studentDAO.listStudentsByGender("女");
    PageInfo<Student> pageInfo = new PageInfo<Student>(list);
    //pageInfo中就包含了数据及分页信息
}

程序猿混饭吃

关注

19
点赞
踩
7

收藏

觉得还不错? 一键收藏
1
评论
MyBatis详解（一）

MyBatis是一个半自动的ORM框架ORM（Object Relational Mapping）对象关系映射，将Java中的一个对象与数据表中一行记录一一对应。ORM框架提供了实体类与数据表的映射关系，通过映射文件的配置，实现对象的持久化。MyBatis的前身是iBatis，iBatis是Apache软件基金会提供的一个开源项目2010年iBatis迁移到Google code，正式更名为MyBatis2013年迁移到Github托管MyBatis特点：支持自定义SQL、存储过程。......
复制链接

扫一扫