MyBatis快速入门（一）（隔壁王大爷都学会了！）

最新推荐文章于 2022-04-30 16:57:23 发布
最新推荐文章于 2022-04-30 16:57:23 发布
阅读量326 收藏 6
点赞数 2
分类专栏： Java mybatis 文章标签： maven java mybatis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/layonly/article/details/120658083
版权

一、引言

1.1 什么是框架？

软件的半成品，解决了软件开发过程当中的普适性问题，从而简化了开发步骤，提供了开发的效率。

1.2 什么是ORM框架？

1.3 使用JDBC完成ORM操作的缺点？

  • 存在大量的冗余代码。

  • 手工创建 Connection、Statement 等。

  • 手工将结果集封装成实体对象。

  • 查询效率低，没有对数据访问进行过优化（Not Cache）。

二、MyBatis框架

2.1 概念

  • MyBatis本是Apache软件基金会的一个开源项目iBatis, 2010年这个项目由apache software foundation 迁移到了Google Code，并且改名为MyBatis 。2013年11月迁移到Github。

  • MyBatis是一个优秀的基于Java的持久层框架，支持自定义SQL，存储过程和高级映射。

  • MyBatis对原有JDBC操作进行了封装，几乎消除了所有JDBC代码，使开发者只需关注 SQL 本身。

  • MyBatis可以使用简单的XML或Annotation来配置执行SQL，并自动完成ORM操作，将执行结果返回。

2.2 访问与下载

官方网站：mybatis – MyBatis 3 | Introduction

下载地址：https://github.com/mybatis/mybatis-3/releases/tag/mybatis-3.5.1

三、构建Maven项目

3.1 新建项目

使用IDEA打开已创建的文件夹目录

3.2 选择Maven目录

选择Maven项目

3.3 GAV坐标

GAV坐标

四、MyBatis入门案例【重点】

4.1 pom.xml中引入MyBatis核心依赖

在pom.xml中引入相关依赖

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
​
    <groupId>com.qf</groupId>
    <artifactId>mybatis-02</artifactId>
    <version>1.0-SNAPSHOT</version>
​
    <dependencies>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.21</version>
        </dependency>
​
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.4</version>
        </dependency>
​
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13</version>
        </dependency>
​
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.12</version>
        </dependency>
        
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>
    </dependencies>
​
</project>

4.2 创建db.properties配置文件

在resources目录下创建db.properties

db.url=jdbc:mysql://localhost:3306/javacoffee?serverTimezone=Asia/Shanghai
db.username=root
db.password=root
db.driver=com.mysql.cj.jdbc.Driver

4.3 创建log4j.properties配置文件

在resources目录下创建log4j.properties

# Global logging configuration
log4j.rootLogger=DEBUG, stdout
# Console output...
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%5p [%t] - %m%n
级别描述
ALL LEVEL打开所有日志记录开关；是最低等级的，用于打开所有日志记录。
DEBUG输出调试信息；指出细粒度信息事件对调试应用程序是非常有帮助的。
INFO输出提示信息；消息在粗粒度级别上突出强调应用程序的运行过程。
WARN输出警告信息；表明会出现潜在错误的情形。
ERROR输出错误信息；指出虽然发生错误事件，但仍然不影响系统的继续运行。
FATAL输出致命错误；指出每个严重的错误事件将会导致应用程序的退出。
OFF LEVEL关闭所有日志记录开关；是最高等级的，用于关闭所有日志记录。

4.4 创建mybatis-config.xml配置文件

在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">

<!-- mybatis的主配置文件 -->
<configuration>
    <!-- 配置外部文件 -->
    <properties resource="db.properties"></properties>
    <!-- 配置别名 -->
    <typeAliases>
        <!--        <typeAlias type="com.qf.entity.User" alias="user"></typeAlias>-->
        <package name="com.coffee.entity"/>
    </typeAliases>
    <!-- 配置环境 -->
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <!-- 配置数据源（连接池） -->
            <dataSource type="POOLED">
                <property name="driver" value="${db.driverClassName}"/>
                <property name="url" value="${db.url}"/>
                <property name="username" value="${db.username}"/>
                <property name="password" value="${db.password}"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <package name="com.coffee.dao"/>
    </mappers>

</configuration>

4.5 建表 

4.6 定义实体类

定义所需CURD操作的实体类（我导入了lombok依赖 需要的小伙伴们也可以下载插件去maven仓库找找蛤）（不想使用的就正常getter setter就行）

package com.coffee.entity;

import lombok.Data;

@Data
public class Student {
    private Integer id;
    private String name;
    private String age;
}

4.7 定义DAO接口

根据所需DAO定义接口、以及方法

package com.coffee.dao;

import com.coffee.entity.Student;

import java.io.IOException;
import java.util.List;

public interface StudentDao {
    List<Student> findAll() throws IOException;
}

4.8 编写StudentDao.xml

在resources目录中下创建与Dao对应的路径和StudentDao.xml文件

<?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">

<!--namespace = 所需实现的接口全限定名-->
<mapper namespace="com.coffee.dao.StudentDao">

    <!--配置查询所有-->
    <!--id = 所需重写的接口抽象方法名，resultType = 查询后所需返回的对象类型-->
    <select id="findAll" resultType="student">
        select * from student
    </select>

</mapper>

4.9 注册Mapper

将Mapper.xml注册到mybatis-config.xml中

<!-- 指定映射配置文件的位置，映射配置文件指的是每个dao独立的配置文件 -->
<mappers>
    <package name="com.coffee.dao"/>
</mappers>

测试

在\src\test\java目录下创建测试类进行测试（这里用了Test注解 需要导入junit依赖）

import com.coffee.dao.StudentDao;
import com.coffee.entity.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 java.util.List;

public class Test {
    @org.junit.Test
    public void test() throws IOException {
        String resource = "mybatis-config.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);
        SqlSessionFactory build = new SqlSessionFactoryBuilder().build(inputStream);
        SqlSession sqlSession = build.openSession();
        StudentDao studentDao = sqlSession.getMapper(StudentDao.class);
        List<Student> students = studentDao.findAll();
        for (Student student : students) {
            System.out.println(student);
        }
        sqlSession.close();
        inputStream.close();
    }
}

 运行结果

 这里有个易错点，导Resource包一定要导对！！！！

五、MyBatis的CRUD操作【重点】

5.1 在Dao添加方法

添加方法


​
import com.qf.entity.User;
import org.apache.ibatis.annotations.Param;
​
import java.util.HashMap;
import java.util.List;
​
public interface UserDao {
​
    public List<User> findAll();
​
    public User findById(@Param("id") Integer id);
​
    public void add(User user);
​
    public void update(User user);
​
    public void delete(String id);
​
    //模糊查询1
    public List<User> findByUserName1(String username);
​
    //模糊查询2
    public List<User> findByUserName2(String username);
​
    //模糊查询3
    public List<User> findByUserName3(String username);
​
    //获取总记录数
    public Integer getTotalCount();
​
    //获取分页数据
    public List<User> findPageData(HashMap<String,Integer> hashMap);
​
}

5.2 在Mapper.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.qf.dao.UserDao">
​
    <!--配置查询所有-->
    <select id="findAll" resultType="user">
        select * from t_user
    </select>
​
    <!-- 查询单个对象 -->
    <select id="findById" resultType="com.qf.entity.User">
        select * from t_user where id = #{id}
    </select>
​
​
    <insert id="add">
​
        <selectKey keyProperty="id" keyColumn="id" resultType="int" order="AFTER">
            select last_insert_id();
        </selectKey>
​
        insert into t_user(name,password) values( #{name},#{password} )
​
    </insert>
​
    <update id="update">
        update t_user set name = #{name} where id = #{id}
    </update>
​
    <delete id="delete">
        delete from t_user where id = #{id}
    </delete>
​
    <!-- 模糊查询1 -->
    <select id="findByUserName1" resultType="user">
        SELECT * FROM t_user
        WHERE name LIKE concat('%',#{name},'%') <!-- 拼接'%' -->
    </select>
​
    <!-- 模糊查询2 -->
    <select id="findByUserName2" resultType="com.qf.entity.User">
        select * from t_user where name like #{name}
    </select>
​
    <!-- 模糊查询3 -->
    <select id="findByUserName3" resultType="com.qf.entity.User">
        select * from t_user where name like "%"'${value}'"%"
    </select>
​
    <!-- 查询总记录数 -->
    <select id="getTotalCount" resultType="java.lang.Integer">
        select count(id) from t_user
    </select>
​
    <!-- 查询总记录数 -->
    <select id="findPageData" resultType="com.qf.entity.User">
        select * from t_user limit #{first},#{second}
    </select>
​
</mapper>

5.3 测试

在\src\test\java目录下测试类中添加方法进行测试

package com.qf.demo;
​
import com.qf.dao.UserDao;
import com.qf.entity.User;
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.junit.Test;
​
import java.io.InputStream;
import java.util.HashMap;
import java.util.List;
​
public class MybatisTest {
​
    //查询所有
    @Test
    public void testfindAll()throws Exception {
        //1.读取配置文件
        InputStream in = Resources.getResourceAsStream("mybatis-config.xml");
        //2.创建SqlSessionFactory工厂
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        SqlSessionFactory factory = builder.build(in);
        //3.使用工厂生产SqlSession对象
        SqlSession session = factory.openSession();
        //4.使用SqlSession创建Dao接口的代理对象
        UserDao userDao = session.getMapper(UserDao.class);
        //5.使用代理对象执行方法
        List<User> users = userDao.findAll();
        for(User user : users){
            System.out.println(user);
        }
        //6.释放资源
        session.close();
        in.close();
    }
​
    //查询单个
    @Test
    public void testfindById()throws Exception {
​
        InputStream in = Resources.getResourceAsStream("mybatis-config.xml");
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        SqlSessionFactory factory = builder.build(in);
        SqlSession session = factory.openSession();
        //---------------------------------------------
​
        UserDao userDao = session.getMapper(UserDao.class);
        //5.使用代理对象执行方法
        User user = userDao.findById(1);
​
        System.out.println(user);
​
        //---------------------------------------------
        session.close();
        in.close();
    }
​
    //添加
    @Test
    public void testadd()throws Exception {
​
        InputStream in = Resources.getResourceAsStream("mybatis-config.xml");
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        SqlSessionFactory factory = builder.build(in);
        SqlSession session = factory.openSession();
        //---------------------------------------------
​
        UserDao userDao = session.getMapper(UserDao.class);
​
        User user = new User();
        user.setName("张三");
        user.setPassword("123");
​
        userDao.add(user);
​
        System.out.println(user.getId());
​
        //提交
        session.commit();
        //---------------------------------------------
        session.close();
        in.close();
    }
​
    //修改
    @Test
    public void testupdate()throws Exception {
​
        InputStream in = Resources.getResourceAsStream("mybatis-config.xml");
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        SqlSessionFactory factory = builder.build(in);
        SqlSession session = factory.openSession();
        //---------------------------------------------
​
        UserDao userDao = session.getMapper(UserDao.class);
​
        User user = userDao.findById(4);
        //user.setId(5);
        user.setName("李四");
        user.setPassword("456");
​
        userDao.update(user);
​
        //提交
        session.commit();
        //---------------------------------------------
        session.close();
        in.close();
    }
​
​
    //删除
    @Test
    public void testdelete()throws Exception {
​
        InputStream in = Resources.getResourceAsStream("mybatis-config.xml");
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        SqlSessionFactory factory = builder.build(in);
        SqlSession session = factory.openSession();
        //---------------------------------------------
​
        UserDao userDao = session.getMapper(UserDao.class);
​
        userDao.delete("4");
​
        //提交
        session.commit();
        //---------------------------------------------
        session.close();
        in.close();
    }
​
    //模糊查询
    @Test
    public void testfindByUserName()throws Exception {
​
        InputStream in = Resources.getResourceAsStream("mybatis-config.xml");
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        SqlSessionFactory factory = builder.build(in);
        SqlSession session = factory.openSession();
        //---------------------------------------------
​
        String name = "张";
​
        UserDao userDao = session.getMapper(UserDao.class);
​
        //List<User> users = userDao.findByUserName1(name);
        //List<User> users = userDao.findByUserName2("%" + name + "%");
        List<User> users = userDao.findByUserName3(name);
​
        for(User user : users){
            System.out.println(user);
        }
        
        //---------------------------------------------
        session.close();
        in.close();
    }
​
    //查询总记录数
    @Test
    public void testgetTotalCount()throws Exception {
​
        InputStream in = Resources.getResourceAsStream("mybatis-config.xml");
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        SqlSessionFactory factory = builder.build(in);
        SqlSession session = factory.openSession();
        //---------------------------------------------
​
        UserDao userDao = session.getMapper(UserDao.class);
​
        System.out.println(userDao.getTotalCount());
​
        //---------------------------------------------
        session.close();
        in.close();
    }
​
    //查询分页数据
    @Test
    public void testfindPageData()throws Exception {
​
        InputStream in = Resources.getResourceAsStream("mybatis-config.xml");
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        SqlSessionFactory factory = builder.build(in);
        SqlSession session = factory.openSession();
        //---------------------------------------------
​
        UserDao userDao = session.getMapper(UserDao.class);
​
        HashMap<String, Integer> hashMap = new HashMap<>();
        hashMap.put("first",0);
        hashMap.put("second",3);
​
        List<User> users = userDao.findPageData(hashMap);
​
        for(User user : users){
            System.out.println(user);
        }
​
        //---------------------------------------------
        session.close();
        in.close();
    }
​
}

六、Druid连接池

6.1 概念

Druid 是阿里巴巴开源平台上的一个项目，整个项目由数据库连接池、插件框架和 SQL 解析器组成。该项目主要是为了扩展 JDBC 的一些限制，可以让程序员实现一些特殊的需求，比如向密钥服务请求凭证、统计 SQL 信息、SQL 性能收集、SQL 注入检查、SQL 翻译等，程序员可以通过定制来实现自己需要的功能。

6.2基准测试结果对比

JDBC-Conn Pool1 Thread2 threads5 threads10 threads20 threads50 threads
Druid8981,1911,3241,3621,3251,459
tomcat-jdbc1,2691,3782,0292,1031,8792,025
DBCP2,3245,0555,4465,4715,5245,415
BoneCP3,7383,1503,1945,68111,01823,125
jboss-datasource4,3772,9883,6803,98032,70837,742
C3P010,84113,63710,68211,05514,49720,351
Proxool16,33716,18718,310(Ex)25,94533,706(Ex)39,501 (Ex)

6.3 测试结论

6.4 配置pom.xml

引入Druid依赖

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.1.21</version>
</dependency>

6.5 创建DruidDataSourceFactory

创建MyDruidDataSourceFactory来替换数据源

​

import com.alibaba.druid.pool.DruidDataSource;
import org.apache.ibatis.datasource.pooled.PooledDataSourceFactory;
​
public class MyDruidDataSourceFactory extends PooledDataSourceFactory {
    public MyDruidDataSourceFactory() {
        this.dataSource = new DruidDataSource();//替换数据源
    }
}

6.6修改mybatis-config.xml

修改mybatis-config.xml中连接池的相关配置，指定Druid数据源

<!--连接池-->


 <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="com.qwz.util.DruidDataSourceFactory">
                <property name="driverClassName" value="${db.driverClassName}"/>
                <property name="url" value="${db.url}"/>
                <property name="username" value="${db.username}"/>
                <property name="password" value="${db.password}"/>
            </dataSource>
        </environment>
    </environments>

注意：< property name="属性名" />属性名必须与com.alibaba.druid.pool.DruidAbstractDataSource中一致。

七、PageHelper

7.1 概念

PageHelper是适用于MyBatis框架的一个分页插件，使用方式极为便捷，支持任何复杂的单表、多表分页查询操作。

7.2 访问与下载

官方网站：MyBatis 分页插件 PageHelper

下载地址：PageHelper中文文档

我这里从网站上截取出来了一些

分页插件参数介绍

分页插件提供了多个可选参数，这些参数使用时，按照上面两种配置方式中的示例配置即可。

分页插件可选参数如下：

  • dialect：默认情况下会使用 PageHelper 方式进行分页，如果想要实现自己的分页逻辑，可以实现 Dialect(com.github.pagehelper.Dialect) 接口，然后配置该属性为实现类的全限定名称。

下面几个参数都是针对默认 dialect 情况下的参数。使用自定义 dialect 实现时，下面的参数没有任何作用。

  1. helperDialect：分页插件会自动检测当前的数据库链接，自动选择合适的分页方式。 你可以配置helperDialect属性来指定分页插件使用哪种方言。配置时，可以使用下面的缩写值：
    oracle,mysql,mariadb,sqlite,hsqldb,postgresql,db2,sqlserver,informix,h2,sqlserver2012,derby
    特别注意：使用 SqlServer2012 数据库时，需要手动指定为 sqlserver2012，否则会使用 SqlServer2005 的方式进行分页。
    你也可以实现 AbstractHelperDialect，然后配置该属性为实现类的全限定名称即可使用自定义的实现方法。

  2. offsetAsPageNum：默认值为 false，该参数对使用 RowBounds 作为分页参数时有效。 当该参数设置为 true 时，会将 RowBounds 中的 offset 参数当成 pageNum 使用，可以用页码和页面大小两个参数进行分页。

  3. rowBoundsWithCount：默认值为false，该参数对使用 RowBounds 作为分页参数时有效。 当该参数设置为true时，使用 RowBounds 分页会进行 count 查询。

  4. pageSizeZero：默认值为 false，当该参数设置为 true 时，如果 pageSize=0 或者 RowBounds.limit = 0 就会查询出全部的结果（相当于没有执行分页查询，但是返回结果仍然是 Page 类型）。

  5. reasonable：分页合理化参数，默认值为false。当该参数设置为 true 时，pageNum<=0 时会查询第一页， pageNum>pages（超过总数时），会查询最后一页。默认false 时，直接根据参数进行查询。

  6. params：为了支持startPage(Object params)方法，增加了该参数来配置参数映射，用于从对象中根据属性名取值， 可以配置 pageNum,pageSize,count,pageSizeZero,reasonable，不配置映射的用默认值， 默认值为pageNum=pageNum;pageSize=pageSize;count=countSql;reasonable=reasonable;pageSizeZero=pageSizeZero。

  7. supportMethodsArguments：支持通过 Mapper 接口参数来传递分页参数，默认值false，分页插件会从查询方法的参数值中，自动根据上面 params 配置的字段中取值，查找到合适的值时就会自动分页。 使用方法可以参考测试代码中的 com.github.pagehelper.test.basic 包下的 ArgumentsMapTest 和 ArgumentsObjTest。

  8. autoRuntimeDialect：默认值为 false。设置为 true 时，允许在运行时根据多数据源自动识别对应方言的分页 （不支持自动选择sqlserver2012，只能使用sqlserver），用法和注意事项参考下面的场景五。

  9. closeConn：默认值为 true。当使用运行时动态数据源或没有设置 helperDialect 属性自动获取数据库类型时，会自动获取一个数据库连接， 通过该属性来设置是否关闭获取的这个连接，默认true关闭，设置为 false 后，不会关闭获取的连接，这个参数的设置要根据自己选择的数据源来决定。

重要提示：

当 offsetAsPageNum=false 的时候，由于 PageNum 问题，RowBounds查询的时候 reasonable 会强制为 false。使用 PageHelper.startPage 方法不受影响。

4. 如何选择配置这些参数

单独看每个参数的说明可能是一件让人不爽的事情，这里列举一些可能会用到某些参数的情况。

场景一

如果你仍然在用类似ibatis式的命名空间调用方式，你也许会用到rowBoundsWithCount， 分页插件对RowBounds支持和 MyBatis 默认的方式是一致，默认情况下不会进行 count 查询，如果你想在分页查询时进行 count 查询， 以及使用更强大的 PageInfo 类，你需要设置该参数为 true。

注： PageRowBounds 想要查询总数也需要配置该属性为 true。

场景二

如果你仍然在用类似ibatis式的命名空间调用方式，你觉得 RowBounds 中的两个参数 offset,limit 不如 pageNum,pageSize 容易理解， 你可以使用 offsetAsPageNum 参数，将该参数设置为 true 后，offset会当成 pageNum 使用，limit 和 pageSize 含义相同。

场景三

如果觉得某个地方使用分页后，你仍然想通过控制参数查询全部的结果，你可以配置 pageSizeZero 为 true， 配置后，当 pageSize=0 或者 RowBounds.limit = 0 就会查询出全部的结果。

场景四

如果你分页插件使用于类似分页查看列表式的数据，如新闻列表，软件列表， 你希望用户输入的页数不在合法范围（第一页到最后一页之外）时能够正确的响应到正确的结果页面， 那么你可以配置 reasonable 为 true，这时如果 pageNum<=0 会查询第一页，如果 pageNum>总页数 会查询最后一页。

场景五

如果你在 Spring 中配置了动态数据源，并且连接不同类型的数据库，这时你可以配置 autoRuntimeDialect 为 true，这样在使用不同数据源时，会使用匹配的分页进行查询。 这种情况下，你还需要特别注意 closeConn 参数，由于获取数据源类型会获取一个数据库连接，所以需要通过这个参数来控制获取连接后，是否关闭该连接。 默认为 true，有些数据库连接关闭后就没法进行后续的数据库操作。而有些数据库连接不关闭就会很快由于连接数用完而导致数据库无响应。所以在使用该功能时，特别需要注意你使用的数据源是否需要关闭数据库连接。

当不使用动态数据源而只是自动获取 helperDialect 时，数据库连接只会获取一次，所以不需要担心占用的这一个连接是否会导致数据库出错，但是最好也根据数据源的特性选择是否关闭连接。

7.3 开发步骤

1.在pom.xml中引入PageHelper依赖。

<dependency>
    <groupId>com.github.pagehelper</groupId>
    <artifactId>pagehelper</artifactId>
    <version>5.1.11</version>
</dependency>

2.在MyBatis-config.xml中添加< plugins >（这里name就是上面的各个属性）

<configuration>
    <typeAliases></typeAliases>
        
   <plugins>
       <!-- com.github.pagehelper为PageHelper类所在包名 -->
        <plugin interceptor="com.github.pagehelper.PageInterceptor">
            <property name="reasonable" value="true"/>
            <property name="supportMethodsArguments" value="true"/>
        </plugin>
    </plugins>
  
    <environments>...</environments>
</configuration>

3.在测试类中添加方法进行测试

//查询分页
    @Test
    public void testfindByPage()throws Exception {
        //1.读取配置文件
        InputStream in = Resources.getResourceAsStream("mybatis-config.xml");
        //2.创建SqlSessionFactory工厂
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        SqlSessionFactory factory = builder.build(in);
        //3.使用工厂生产SqlSession对象
        SqlSession session = factory.openSession();
        //4.使用SqlSession创建Dao接口的代理对象
        UserDao userDao = session.getMapper(UserDao.class);
​
        //5.使用代理对象执行方法
        PageHelper.startPage(1,2);//设置当前页和每页显示记录数
        List<User> users = userDao.findAll();
        PageInfo<User> userPageInfo = new PageInfo<>(users);//封装到PageInfo对象中
        System.out.println(userPageInfo);
​
        //6.释放资源
        session.close();
        in.close();
    }

7.4 PageInfo对象

PageInfo对象中包含了分页操作中的所有相关数据。

PageInfo结构图

7.5 注意事项

宇智波波奶茶
关注
  • 2
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
GAVDP 13(Generic Audio/Videi Distribution Profile 13)
技术学习
10-10 545
这里写目录标题一级目录二级目录三级目录 一级目录 二级目录 三级目录
MyBatis全局配置属性
@siye
01-04 2189
   目录 properties(属性配置)  settings(设置ibatis运行状态) typeAliases(设置类对象的别名) typeHandlers(类型处理器) objectFactory(对象工厂配置) plugins(插件配置) environments(环境配置集) environment(数据源配置) transactionManager(数据事务配置)...
Java DBJava 6 里的数据库
dalezhu的专栏
02-01 1737
新安装了 JDK 6 的程序员们也许会发现，除了传统的 bin、jre 等目录，JDK 6 新增了一个名为 db 的目录。这便是 Java 6 的新成员：Java DB。这是一个纯 Java 实现、开源的数据库管理系统（DBMS），源于 Apache 软件基金会（ASF）名下的项目 Derby。它只有 2MB 大小，对比动辄上 G 的数据库来说可谓袖珍。但这并不妨碍 Derby 功能齐备，支持几乎...
mybatis常用的注解
哈哈
04-30 2678
1. 增删改查注解 1.1 @Insert和@Options public interface UserDAO{ @Options(useGeneratedKeys = true,keyColumn = "uid", keyProperty = "id") @Insert("insert into t_user(username,password,gender,birth) values(#{username},#{password},#{gender},#{birth})") public void
Gavhack:加夫哈克
03-09
加夫哈克 我的客户。 当我更好地理解Java时，我将重写废话 学分： 存取变压器和渲染实用程序-olliem5 / past 自定义字体渲染器-086 / KAMI 自述下载柜台和LoC柜台徽章-Mooooooo / Postman ViewModel-Moomooooo /邮递员 可以在代码中找到其他学分的注释 提交拉取请求，这样我将对其进行审核！
MyBatis入门学习教程（一）-MyBatis快速入门
09-03
MyBatis是一个强大的Java持久层框架，它最初是Apache软件基金会的iBatis项目，后来在2010年转移到Google Code并更名为MyBatis，最终于2013年迁移到GitHub进行维护。MyBatis的核心功能在于将SQL查询与Java对象之间的...
MyBatis 入门教程，超详细！！！
03-18
Mybatis 入门到放弃
mybatis快速入门
07-15
关于学习mybatis的视频和书都是很多的，如果要快速入门肯定要学一些点，这个文档我觉得还是能在一天内帮助快速入门的
MyBatis快速入门
08-31
MyBatis是一个优秀的持久层框架，它专注于SQL查询、存储过程和高级映射。通过使用MyBatis，开发者可以摆脱繁琐的JDBC代码编写，无需手动设置参数和处理结果集。MyBatis允许通过XML或注解进行配置和对象映射，将Java...
mybatis快速入门jar包
最新发布
04-16
在快速入门MyBatis的过程中，了解其核心概念至关重要。首先，`SqlSessionFactoryBuilder`是创建`SqlSessionFactory`的构建者，它是整个MyBatis的核心。通过读取配置文件（XML或Java注解形式），它能够构建出`...
DB2 重启
Gavid0124的专栏
07-20 2098
应用场景：修改配置文件后，系统提示修改非动态生效，此时你需要重启db2 解决方案： 请依次进行如下操作 1，执行db2stop 2，如果步骤1报错，执行db2 force applications all 如果步骤1报错（目前多数遇到的都是这个错误，后续有新错误，我会同步更新） SQL1025N The database manager was not stopped because ...
java db 使用_javaDB简单使用笔记
weixin_42563415的博客
02-19 7446
Javadb学习环境变量设置:DERBY_HOME=D:\ProgramFiles\Environment\javadbpath=.;%JAVA_HOME%/bin;%path%;%CATALINA_HOME%/bin;%ANT_HOME%/bin;%ANT_HOME%/bin;C:\Program Files\IDM Computer Solutions\UltraEdit\;%JAVA_HOM...
三维人脸研究
Ramble Over The Cloud~
04-17 9129
三维人脸研究现状： 传统的人脸识别方法是基于二维图像分析的理论进行人脸的表示、分析、提取特征并进行分类识别。虽然基于二维图像的人脸识别算法在半个多世纪的研究过程中，取得了丰硕的成果，但是研究表明，基于二维图像分析的人脸识别方法受到诸如光照、姿态、表情等成像条件的影响较大。与二维数据相比，三维数据包含了人脸的空间信息，是人脸本身固有的信息，对外界条件的变化具有很好鲁棒性[13]。采集获得的脸部三维
mybatis详解 oracle,Mybatis注解方式操作Oracle数据库详解
weixin_39903872的博客
04-04 542
1.新增多行数据@Insert({"insert all " +"" +" into s_user (user,username) values " +"(#{item.user},#{item.username}) " +"" +" select 1 from dual " +""})2.执行多条SQL语句特别注意：open属性设置为begin，close设置为;end;@Update({"" ...
Mybatis入门（上）
qq_42649356的博客
05-09 105
关于Mybatis的入门教学 关于mybatis使用的初步介绍，包含ORM框架的概念，项目配置，更换数据源，多表查询，动态sql等操作。 1.ORM框架的概念 ORM（Object Relational Mapping）对象关系映射，将程序中的一个对象与表中的一行数据一一对应。 ORM框架提供了持久化类与表的映射关系，在运行时参照映射文件的信息，把对象持久化到数据库中。 提到ORM框架就不得不提两个框架，SSM和SSH，其中的H是指Hibernate,M是指Mybatis，二者都是常用的ORM框架，但M
使用mybatis来操作oracle
qq_40850266的博客
10-25 3919
1.使用spring的初始化工具来构建项目 2.添加依赖 3.项目结构 4.详细文件 4.1配置文件 server: port: 8888 spring: datasource: driver-class-name: oracle.jdbc.driver.OracleDriver url: jdbc:oracle:thin:@127.0.0.1:11521:helowin username: mark password: 123456 flyway:
mybatis框架简单搭建_Oracle
前行的博客
06-28 727
参考：搭建一个简单的mybatis框架_Mysql 项目结构 完整代码 poseidon.xml &amp;lt;?xml version=&quot;1.0&quot; encoding=&quot;UTF-8&quot; ?&amp;gt; &amp;lt;!DOCTYPE configuration PUBLIC &quot;-//mybatis.org//DTD Config 3.
LayUI框架
热门推荐
来一杯Java咖啡
10-25 2万+
一、引言 1.1 介绍 LayUI 是一款经典模块化前端 UI 框架，我们只需要定义简单的HTML、CSS、JS即可实现很复杂的前端效果。 使得前端页面的制作变得更加简单，可以说是为后端人员量身定制的一款开源框架。 可是很遗憾的是，贤心大神因为各种因素吧，从官网迁走了 不过layui中的些许知识对我们而言还是挺好用的， 我们也可以通过镜像网站 Layui - 经典开源模块化前端 UI 框架layui 是一套开源的 Web UI 解决方案，其内部采用的是自身经典的模块化规范，并遵...
Java 简单的用户管理系统（代码注释超全超详细！！！）
来一杯Java咖啡
10-02 1万+
1.简介 本项目是个java开发的简单的用户管理系统，因为能力有限，我做的界面丑陋了些，大家见谅 实现的功能：登录、添加用户、修改用户（修改的时候用户原始数据显示到界面上、单个删除用户和多个删除用户、数据的分页和跳转、url过滤器 因为我写的时候是开了两个tomcat服务器将图片存储到另一个服务器上进行访问 大家这里有疑问的也欢迎咨询哈 同时如果有小伙伴想要项目源文件的欢迎加qq群 2.准备工作 1.1开发工具 ...
Mybatis快速入门：一天精通Mybatis框架
"一天学会Mybatis，通过学习掌握Mybatis这一优秀的持久层框架，实现SQL查询、存储过程和高级映射的高效操作。" 在Java开发中，Mybatis是一个备受推崇的持久层框架，它旨在简化数据库操作，消除繁杂的JDBC代码编写...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

宇智波波奶茶

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值