Mybatis学习

x任哲

已于 2023-08-21 09:02:56 修改

阅读量521

点赞数

文章标签： mybatis 学习

于 2023-07-31 19:56:12 首次发布

本文链接：https://blog.csdn.net/qq_43810306/article/details/132027272

版权

一，Mybatis特性

MyBatis 是支持定制化 SQL、存储过程以及高级映射的优秀的持久层框架。
MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集。
MyBatis可以使用简单的XML或注解用于配置和原始映射，将接口和Java的POJO（Plain Old Java Objects，普通的Java对象）映射成数据库中的记录。
MyBatis 是一个半自动的ORM（Object Relation Mapping）框架（全自动的是Hibernate）。

二，搭建Mybatis

1.依赖引入

下载地址：https://github.com/mybatis/mybatis-3/tags

或者Maven引入

<dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis</artifactId>
        <version>3.5.10</version>
    </dependency>
    <!-- https://mvnrepository.com/artifact/junit/junit -->
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
        <scope>test</scope>
    </dependency>
    <!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.29</version>
 </dependency>

2.核心文件配置

//习惯上命名为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表示MyBatis使用的是事务管理器是原始的JDBC方式
                所以事务的开启，提交与回滚都需要手动处理
            -->
            <transactionManager type="JDBC"/>
            <!--数据源，type="POOLED"表示使用的是连接池-->
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.cj.jdbc.Driver"/>

              <!--需添加时区配置 不过可以配置在 db.properties 文件中 直接引用-->

                <property name="url" value="jdbc:mysql:///mybatis"/>
                <property name="username" value="root"/>
                <property name="password" value="root"/>
            </dataSource>
        </environment>
    </environments>
    <!-- 引入映射文件 -->
    <mappers>
        <mapper resource="org/mybatis/example/BlogMapper.xml"/>
        <!--或者 整包 引用<package name="com.smbms.mapper"/>
    </mappers>
</configuration>

3.创建实体类以及mapper接口以及映射文件

Mybatis中可以面向接口操作数据，要保持两个一致

mapper接口的全类名和映射文件的命名空间（namespace）保持一致。
mapper接口中方法的方法名和映射文件中编写SQL的标签的id属性保持一致。

附：在idea中resources中创建文件夹时使用 / 必须与Java中路径保持一致

关键：执行顺序为接口规定函数类型，映射的xml文件根据函数id进行执行相应的SQL语句。

4.日志log4j以及environment配置

1.log4j

1.引入依赖

<!-- https://mvnrepository.com/artifact/log4j/log4j -->
<dependency>
    <groupId>log4j</groupId>
    <artifactId>log4j</artifactId>
    <version>1.2.17</version>
</dependency>

2.配置log4j.properties

（配置模板根据实际选择）

### 配置根 ###
#log4j.rootLogger = debug,console ,fileAppender,dailyRollingFile,ROLLING_FILE,MAIL,DATABASE
log4j.rootLogger = debug,console
### 设置输出sql的级别，其中logger后面的内容全部为jar包中所包含的包名 ###
#log4j.logger.org.apache=dubug
#log4j.logger.java.sql.Connection=dubug
#log4j.logger.java.sql.Statement=dubug
#log4j.logger.java.sql.PreparedStatement=dubug
#log4j.logger.java.sql.ResultSet=dubug
### 配置输出到控制台 ###
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} %p %t %c - %m%n
### 配置输出到文件 ###
#log4j.appender.fileAppender = org.apache.log4j.FileAppender
#log4j.appender.fileAppender.Encoding = UTF-16
#log4j.appender.fileAppender.File = E:/workfile/log4j/log4j.txt
#log4j.appender.fileAppender.Append = true
#log4j.appender.fileAppender.Threshold = DEBUG
#log4j.appender.fileAppender.layout = org.apache.log4j.PatternLayout
#log4j.appender.fileAppender.layout.ConversionPattern = %-d{yyyy-MM-dd HH:mm:ss}  [ %t:%r ] - [ %p ]  %m%n
### 配置输出到文件，并且每天都创建一个文件 ###
#log4j.appender.dailyRollingFile = org.apache.log4j.DailyRollingFileAppender
#log4j.appender.dailyRollingFile.File = logs/log.log
#log4j.appender.dailyRollingFile.Append = true
#log4j.appender.dailyRollingFile.Threshold = DEBUG
#log4j.appender.dailyRollingFile.layout = org.apache.log4j.PatternLayout
#log4j.appender.dailyRollingFile.layout.ConversionPattern = %-d{yyyy-MM-dd HH:mm:ss}  [ %t:%r ] - [ %p ]  %m%n
### 配置输出到文件，且大小到达指定尺寸的时候产生一个新的文件 ###
#log4j.appender.ROLLING_FILE=org.apache.log4j.RollingFileAppender
#log4j.appender.ROLLING_FILE.Threshold=ERROR
#log4j.appender.ROLLING_FILE.File=rolling.log
#log4j.appender.ROLLING_FILE.Append=true
#log4j.appender.ROLLING_FILE.MaxFileSize=10KB
#log4j.appender.ROLLING_FILE.MaxBackupIndex=1
#log4j.appender.ROLLING_FILE.layout=org.apache.log4j.PatternLayout
#log4j.appender.ROLLING_FILE.layout.ConversionPattern=[framework] %d - %c -%-4r [%t] %-5p %c %x - %m%n
### 配置输出到邮件 ###
#log4j.appender.MAIL=org.apache.log4j.net.SMTPAppender
#log4j.appender.MAIL.Threshold=DEBUG
##事件的紧急级别
#log4j.appender.MAIL.BufferSize=1
##日志缓存文件大小
#log4j.appender.MAIL.From=ziggymav@outlook.com
#log4j.appender.MAIL.SMTPHost=smtp.office365.com
#log4j.appender.MAIL.SMTPPort=587
##smtp服务器配置
#log4j.appender.MAIL.SMTPUsername=ziggymav@outlook.com
#log4j.appender.MAIL.SMTPPassword=ADS12l3ads
##账户加密码
#log4j.appender.MAIL.Subject=Log4J DEBUG事件
##邮件主题
#log4j.appender.MAIL.To=1272601809@qq.com
##接收邮箱
#log4j.appender.MAIL.layout=org.apache.log4j.PatternLayout
#log4j.appender.MAIL.layout.ConversionPattern=[framework] %d - %c -%-4r [%t] %-5p %c %x - %m%n
#邮件的格式
### 配置输出到数据库 ###
#log4j.appender.DATABASE=org.apache.log4j.jdbc.JDBCAppender
#log4j.appender.DATABASE.URL=jdbc:mysql://localhost:3306/test
#log4j.appender.DATABASE.driver=com.mysql.jdbc.Driver
#log4j.appender.DATABASE.user=root
#log4j.appender.DATABASE.password=
#log4j.appender.DATABASE.sql=INSERT INTO LOG4J (Message) VALUES ('[framework] %d - %c -%-4r [%t] %-5p %c %x - %m%n')
#log4j.appender.DATABASE.layout=org.apache.log4j.PatternLayout
#log4j.appender.DATABASE.layout.ConversionPattern=[framework] %d - %c -%-4r [%t] %-5p %c %x - %m%n
#log4j.appender.A1=org.apache.log4j.DailyRollingFileAppender
#log4j.appender.A1.File=SampleMessages.log4j
#log4j.appender.A1.DatePattern=yyyyMMdd-HH'.log4j'
#log4j.appender.A1.layout=org.apache.log4j.xml.XMLLayout

2.environment配置

<environments default="development">
    <!-- 开发库环境配置 -->
    <environment id="development">
        <!--
            transactionManager：设置事务管理方式（工作中我们采用Spring的事务管理器）
            属性：type="JDBC|MANAGED"
                JDBC：表示当前环境中，执行SQL时，使用的是JDBC中原生的事务管理方式，
                如提交是commit，回滚是rollback，事务的提交或回滚需要手动处理
                MANAGED：表示被管理，如可以被Spring管理
        -->
        <transactionManager type="JDBC"/>
        <!--数据源，type="POOLED"表示使用的是连接池（工作中用Spring配置数据源）-->
        <!--
            属性：type="POOLED|UNPOOLED|JNDI"（设置数据源类型）
                POOLED:表示使用数据库连接池缓冲数据库连接
                UNPOOLED:表示不使用数据库连接池
                JNDI:表示使用使用上下文中的数据源
        -->
        <dataSource type="POOLED">
            <!-- 获取数据库连接配置文件中的key -->
            <property name="driver" value="${jdbc.driver}"/>
            <property name="url" value="${jdbc.url}"/>
            <property name="username" value="${jdbc.username}"/>
            <property name="password" value="${jdbc.password}"/>
        </dataSource>
    </environment>
    <!-- 测试库环境配置 -->
    <environment id="test">
        <!--
            这里的transactionManager表示MyBatis使用的是事务管理器是原始的JDBC方式
            所以事务的开启，提交与回滚都需要手动处理
        -->
        <transactionManager type="JDBC"/>
        <!--数据源，type="POOLED"表示使用的是连接池-->
        <dataSource type="POOLED">
            <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
            <property name="url" value="jdbc:mysql:///mybatis"/>
            <property name="username" value="root"/>
            <property name="password" value="root"/>
        </dataSource>
    </environment>
</environments>

5.db.properties文件配置

###配置生产环境
prod.jdbc.driver = com.mysql.cj.jdbc.Driver
prod.jdbc.url = jdbc:mysql:///mybatis?useSSL=false&amp&serverTime=Asia/Shanghai
prod.jdbc.user = root
prod.jdbc.password =root

###配置测试环境
test.jdbc.driver = com.mysql.cj.jdbc.Driver
test.jdbc.url = jdbc:mysql:///mybatis?useSSL=false&amp&serverTime=Asia/Shanghai
test.jdbc.user = root
test.jdbc.password =root

###配置开发环境
dev.jdbc.driver = com.mysql.cj.jdbc.Driver
dev.jdbc.url = jdbc:mysql:///mybatis?useSSL=false&amp&serverTime=Asia/Shanghai
dev.jdbc.user = root
dev.jdbc.password =root

6.MyBatis获取参数值的两种方式#{}和${}

${}的本质就是字符串拼接，#{}的本质就是占位符赋值
${}使用字符串拼接的方式拼接sql，若为字符串类型或日期类型的字段进行赋值时，需要手动加单引号；但是#{}使用占位符赋值的方式拼接sql，此时为字符串类型或日期类型的字段进行赋值时，可以自动添加单引号

7. MyBatis获取参数值的各种情况（传递多个值）

MyBatis会自动将这些参数放在一个map集合中，以arg0,arg1...为键，以参数为值；以param1,param2...为键，以参数为值；因此只需要通过${}和#{}访问map集合的键就可以获取相对应的值，注意${}需要手动加单引号

8.MyBatis获取参数值的各种情况（传递Map集合类型的参数）

若mapper接口中的方法需要的参数为多个时，此时可以手动创建map集合，将这些数据放在map中只需要通过${}和#{}访问map集合的键就可以获取相对应的值，注意${}需要手动加单引号。

// 验证登录（参数为Map集合）
User checkLoginByMap(Map<String,Object> map);

<!--User checkLoginByMap(Map<String,Object> map);-->
<select id="checkLoginByMap" resultType="User">
    select * from t_user where username = '${uname}' and password = '${passwd}'
</select>

@Test
public void testcheckloginMap() {
    // 获取SqlSession
    SqlSession sqlSession = SqlSessionUtils.getSqlSession();
    ParameterMapper mapper = sqlSession.getMapper(ParameterMapper.class);
    Map<String,Object> map = new HashMap<>();
    map.put("uname","renzhe");
    map.put("passwd","123456");
    User renzhe = mapper.checkLoginByMap(map);
    System.out.println(renzhe);
}

9.出现问题

1.测试字段名和属性名不一致

1.给字段名起名需与实体类中相同

2.通过全局配置mapUnderscoreToCamelCase解决字段名和属性名的映射关系

<settings>
    <!--
        mapUnderscoreToCamelCase：将下划线自动映射为驼峰（虽然可以自动但也不是随便）
        如：emp_name 映射为：empName
    -->
    <setting name="mapUnderscoreToCamelCase" value="true"/>
</settings>

3.通过resultMap解决字段名和属性名的映射关系

##

2.解决多对一的映射关系

1.级联属性赋值在实体类中添加相应的属性

2.通过association 讲需要字段通过association标签写入resultmap标签中

3.通过分步查询

/**
 * 通过分布查询员工和员工对应的部门
 * 分步——第一步：查询员工信息
 */
Emp getEmpAndDeptByStepOne(@Param("eid") Integer eid);

<resultMap id="getEmpAndDeptByMap" type="Emp">
    <result property="eid" column="eid"></result>
    <result property="empName" column="emp_name"></result>
    <result property="age" column="age"></result>
    <result property="sex" column="sex"></result>
    <result property="email" column="email"></result>
    <!--
    property：多对一中的属性
    select：设置分步查询的SQL的唯一标识（namespace.sqlid或mapper接口的全类名.方法名）
    column: 设置分步查询的条件
-->
    <association property="dept"
                 select="com.renzhe.mybatis.mapper.DeptMapper.getEmpAndDeptByStepTwo"
                 column="did"></association>
</resultMap>
<!--Emp getEmpAndDeptByStepOne(@Param("eid") Integer eid);-->
<select id="getEmpAndDeptByStepOne" resultMap="getEmpAndDeptByMap">
    select * from t_emp where eid = #{eid}
</select>

/**
 * 分步查询：第二步
 * 根据did查找员工所在的部门信息
 */
Dept getEmpAndDeptByStepTwo(@Param("did") Integer did);

<?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.renzhe.mybatis.mapper.DeptMapper">

    <resultMap id="getDeptByEmpDid" type="Dept">
        <id property="did" column="did"></id>
        <result property="deptName" column="dept_name"></result>
    </resultMap>
    <!--Dept getEmpAndDeptByStepTwo(@Param("did") Integer did);-->
    <select id="getEmpAndDeptByStepTwo" resultMap="getDeptByEmpDid">
        select * from t_dept where did = #{did}
    </select>

</mapper>

附：

分步查询的优点：可以实现延迟加载（mybatis是默认没开启），但是必须在核心配置文件中设置全局配置信息：

lazyLoadingEnabled：延迟加载的全局开关。当开启时，所有关联对象都会延迟加载。
aggressiveLazyLoading：当开启时，任何方法的调用都会加载该对象的所有属性。否则，每个属性会按需加载。

此时就可以实现按需加载，获取的数据是什么，就只会执行相应的sql。此时可通过association和collection中的fetchType属性设置当前的分步查询是否使用延迟加载，fetchType="lazy(延迟加载)|eager(立即加载)"。

还可以使用fetchTypr标签进行设置

3.解决一对多的映射关系

1.collection

/**
 * 获取部门和部门所有的员工
 */
Dept getDeptAndEmp(@Param("did") Integer did);

<resultMap id="deptAndEmpResultMap" type="Dept">
    <id property="did" column="did"></id>
    <result property="deptName" column="dept_name"></result>
    <collection property="emps" ofType="Emp">
        <id property="eid" column="eid"></id>
        <result property="empName" column="emp_name"></result>
        <result property="age" column="age"></result>
        <result property="sex" column="sex"></result>
        <result property="email" column="email"></result>
        <!--
         在这里不能设置员工，如果设置了就成了部门有员工，员工有部门，即经典套娃操    作工作中一定会有一张主表，要么获取员工对应的部门，要么获取部门对应的员工
        -->

    </collection>
</resultMap>
<!--Dept getDeptAndEmp(@Param("did") Integer did);-->
<!--第一种：一次性全部查询出来-->
<select id="getDeptAndEmp" resultMap="deptAndEmpResultMap">
    select * from t_dept left join t_emp on t_dept.did = t_emp.did where t_dept.did = #{did}
</select>

2.分步查询

/**
 * 通过分布查询查询部门以及部门中所有的员工信息
 * 分步第一步：查询部门信息
 */
Dept getDeptAndEmpByStepOne(@Param("did") Integer did);

/**
 * 通过分布查询查询部门以及部门中所有的员工信息
 * 分步第二步：根据did查询员工信息
 */
List<Emp> getDeptAndEmpByStepTwo(@Param("did") Integer did);

<!--List<Emp> getDeptAndEmpByStepTwo(@Param("did") Integer did);-->
<select id="getDeptAndEmpByStepTwo" resultType="Emp">
    select * from t_emp where did = #{did}
</select>

<resultMap id="deptAndEmpByStepResultMap" type="Dept">
    <id property="did" column="did"></id>
    <result property="deptName" column="dept_name"></result>
    <collection property="emps"
                select="com.renzhe.mybatis.mapper.EmpMapper.getDeptAndEmpByStepTwo"
                column="did"></collection>
</resultMap>
<!--Dept getDeptAndEmpByStepOne(@Param("did") Integer did);-->
<select id="getDeptAndEmpByStepOne" resultMap="deptAndEmpByStepResultMap">
    select * from t_dept where did = #{did}
</select>

10.动态SQL标签

if，where

trim

若标签中有内容时

prefix|suffix：将trim标签中内容前面或后面添加指定内容
prefixOverrides|suffixOverrides：将trim标签中内容前面或后面去掉指定内容

若标签中没有内容时

trim标签也没有任何效果

choose，when，otherwise，foreach

三，Mybatis缓存

1.一级缓存

一级缓存是SqlSession级别的，通过同一个SqlSession查询的数据会被缓存，下次查询相同的数据，就会从缓存中直接获取，不会从数据库重新访问

使一级缓存失效的四种情况：

不同的SqlSession对应不同的一级缓存
同一个SqlSession但是查询条件不同
同一个SqlSession两次查询期间执行了任何一次增删改操作
同一个SqlSession两次查询期间手动清空了缓存（只对一级缓冲有效）

2.二级缓存

二级缓存是SqlSessionFactory级别，通过同一个SqlSessionFactory创建的SqlSession查询的结果会被缓存；此后若再次执行相同的查询语句，结果就会从缓存中获取

二级缓存开启的条件：

在核心配置文件中，设置全局配置属性cacheEnabled="true"，默认为true，不需要设置
在映射文件中设置标签<cache />
二级缓存必须在SqlSession关闭或提交之后才有效
查询的数据所转换的实体类类型必须实现序列化的接口

使二级缓存失效的情况：

两次查询之间执行了任意的增删改，会使一级和二级缓存同时失效

3.查询顺序

先查询二级缓存，因为二级缓存中可能会有其他程序已经查出来的数据，可以拿来直接使用。
如果二级缓存没有命中，再查询一级缓存
如果一级缓存也没有命中，则查询数据库
SqlSession关闭之后，一级缓存中的数据会写入二级缓存

4.MyBatis整合第三方缓存EHCache

1.添加依赖

<!-- https://mvnrepository.com/artifact/org.mybatis.caches/mybatis-ehcache -->
<dependency>
    <groupId>org.mybatis.caches</groupId>
    <artifactId>mybatis-ehcache</artifactId>
    <version>1.2.1</version>
</dependency>
<!-- 
    slf4j日志门面的一个具体实现 
    就像JDBC提供接口，具体的实现由各数据库厂商来提供一样。
-->
<!-- https://mvnrepository.com/artifact/ch.qos.logback/logback-classic -->
<dependency>
    <groupId>ch.qos.logback</groupId>
    <artifactId>logback-classic</artifactId>
    <version>1.2.11</version>
    <scope>test</scope>
</dependency>

2.配置文件ehcache.xml（名字必须是这个）

<?xml version="1.0" encoding="utf-8" ?>
<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:noNamespaceSchemaLocation="../config/ehcache.xsd">
    <!-- 磁盘保存路径 -->
    <diskStore path="D:\atguigu\ehcache"/>
    <defaultCache
            maxElementsInMemory="1000"
            maxElementsOnDisk="10000000"
            eternal="false"
            overflowToDisk="true"
            timeToIdleSeconds="120"
            timeToLiveSeconds="120"
            diskExpiryThreadIntervalSeconds="120"
            memoryStoreEvictionPolicy="LRU">
    </defaultCache>
</ehcache>

3.设置二级缓冲类型

四，逆向工程

1.添加依赖

<build>
    <!-- 构建过程中用到的插件 -->
    <plugins>
        <!-- 具体插件，逆向工程的操作是以构建过程中插件形式出现的 -->
        <plugin>
            <groupId>org.mybatis.generator</groupId>
            <artifactId>mybatis-generator-maven-plugin</artifactId>
            <version>1.3.0</version>
            <!-- 插件的依赖 -->
            <dependencies>
                <!-- 逆向工程的核心依赖 -->
                <dependency>
                    <groupId>org.mybatis.generator</groupId>
                    <artifactId>mybatis-generator-core</artifactId>
                    <version>1.3.2</version>
                </dependency>
            </dependencies>
        </plugin>
    </plugins>
</build>

2.逆向工程的配置文件（generatorConfig.xml）

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE generatorConfiguration
        PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN"
        "http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd">
<generatorConfiguration>
    <!--
            targetRuntime: 执行生成的逆向工程的版本
                    MyBatis3Simple: 生成基本的CRUD（清新简洁版）
                    MyBatis3: 生成带条件的CRUD（奢华尊享版）
     -->
    <context id="DB2Tables" targetRuntime="MyBatis3Simple">
        <!-- 数据库的连接信息 -->
        <jdbcConnection driverClass="com.mysql.cj.jdbc.Driver"
                        connectionURL="jdbc:mysql:///mybatis"
                        userId="root"
                        password="root">
        </jdbcConnection>
        <!--路径要修改为自己的路径-->
        <!-- javaBean的生成策略-->
        <javaModelGenerator targetPackage="com.chenxin.mybatis.pojo" targetProject=".\src\main\java">
            <!--com.chenxin.mybatis.pojo下面的一行表示这里的每个.表示都是一个目录-->
            <property name="enableSubPackages" value="true" />
            <!--去掉字段名转换实体类属性的时候的空格-->
            <property name="trimStrings" value="true" />
        </javaModelGenerator>
        <!-- SQL映射文件的生成策略 -->
        <sqlMapGenerator targetPackage="com.atguigu.mybatis.mapper"  targetProject=".\src\main\resources">
            <property name="enableSubPackages" value="true" />
        </sqlMapGenerator>
        <!-- Mapper接口的生成策略 -->
        <javaClientGenerator type="XMLMAPPER" targetPackage="com.atguigu.mybatis.mapper"  targetProject=".\src\main\java">
            <property name="enableSubPackages" value="true" />
        </javaClientGenerator>
        <!-- 逆向分析的表 -->
        <!-- tableName设置为*号，可以对应所有表，此时不写domainObjectName -->
        <!-- domainObjectName属性指定生成出来的实体类的类名 -->
        <table tableName="t_emp" domainObjectName="Emp"/>
        <table tableName="t_dept" domainObjectName="Dept"/>
    </context>
</generatorConfiguration>

3.点击Maven插件执行逆向工程

4.使用升级版

五，分页插件

1.添加依赖

<!-- https://mvnrepository.com/artifact/com.github.pagehelper/pagehelper -->
<dependency>
    <groupId>com.github.pagehelper</groupId>
    <artifactId>pagehelper</artifactId>
    <version>5.2.0</version>
</dependency>

2.核心配置文件配置分页插件

<!--配置分页插件-->
<plugins>
    <plugin interceptor="com.github.pagehelper.PageInterceptor"></plugin>
</plugins>

3.在测试类中使用PageHelper调用需要的函数

x任哲

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
Mybatis学习

此时就可以实现按需加载，获取的数据是什么，就只会执行相应的sql。MyBatis可以使用简单的XML或注解用于配置和原始映射，将接口和Java的POJO（Plain Old Java Objects，普通的Java对象）映射成数据库中的记录。一级缓存是SqlSession级别的，通过同一个SqlSession查询的数据会被缓存，下次查询相同的数据，就会从缓存中直接获取，不会从数据库重新访问。mapper接口中方法的方法名和映射文件中编写SQL的标签的id属性保持一致。
复制链接

扫一扫