Java程序员从笨鸟到菜鸟（十五）MyBatis 相关介绍

最新推荐文章于 2024-05-03 16:38:38 发布
最新推荐文章于 2024-05-03 16:38:38 发布
阅读量302 收藏
点赞数
分类专栏： java web 文章标签： mybatis 一级缓存 二级缓存
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013090299/article/details/80230556
版权

一、MyBatis 介绍

1. 什么是 mybatis？

mybatis 是一个优秀的持久层框架，对 JDBC 操作数据库的过程进行了封装，只需要关注 SQL 本身，mybatis 通过 xml 或者 注解的方式，将要执行的各种 sql 语句配置，并通过 java 对象和 statement 语句映射成最终的 sql 语句，最后由 mybatis 框架执行 sql 语句，并将结果映射成 Java 对象返回

2. 工作原理？

mybatis 通过配置文件创建 sqlSessionFactory，sqlSessionFactory 根据配置文件，配置文件来源于两个方面：xml 文件，Java 注解，获取 sqlSession, sqlSession 包含了执行 sql 语句的所有方法，可以直接通过 sqlSession 运行 sql语句，完成对数据的增删改查和事务提交工作，之后再关闭 sqlSession.

3. 工作流程

mapper 接口：

xml 中 namespace 中的是接口类的全名；

  • 接口中的方法名是 xml 文件中的 sql 语句中的 id 值
  • 接口中的方法参数就是传递给 sql 的参数
  • mapper 接口的工作原理：mybatis 会使用 jdk 动态代理的方式为 mapper 接口创建 proxy 对象，代理对象会拦截接口中的方法，转而执行 sql 语句，然后将执行结果封装返回

4. mybatis 解决的问题

  1. 使用数据库连接池管理连接，避免了频繁创建、关闭连接，浪费资源，影响性能问题
  2. 使用 xml 管理 sql 语句，让 java 代码和 sql 语句分离，使得代码更容易维护
  3. 解决了 sql 语句参数不定的问题，xml 中可以通过 where 条件决定 sql 语句的条件参数，通过 parameterType 定义输入参数的类型
  4. mybatis 自动将结果集封装成 java 对象，通过 statement 的 resultType 定义输出的类型

 

二、理解MyBatis

MyBatis支持普通的SQL查询、存储过程和高级映射的优秀持久层框架，几乎消除了所有的JDBC代码和参数的手工设置以及对结果集的检索。MyBatis可以使用简单的XML 或注解用于配置和原始映射，将接口和Java的POJO（普通Java对象）映射成数据库中的记录

三、 MyBati缓存

分为一级缓存和二级缓存

1.一级缓存：基于 PerpetualCache 的 HashMap 本地缓存，其存储作用域为 Session, 当 Session flush 或 close 之后，该 Session 的所有 Cache 就将清空，作用域同一个SqlSession，第一次查询会访问数据库，第二次查询直接从缓存中读取，当一个SelSession 结束之后，SqlSession 的一级缓存也不存在了，默认开启 SqlSession 的一级缓存

2.二级缓存：与一级缓存机制相同，默认采用 PerpetualCache 的 HashMap 本地缓存，不同的是存储作用域为 Mapper(namespace),并且可以自定义存储源，多个SqlSession 去执行相同的 SQL 语句，得到的数据会放在二级缓存中，多个SqlSession 共享数据，默认没有开启二级缓存，需手动开启

在MyBatis3.4.4版不能直接使用#{0}要使用 #{arg0}

代码测试：

1.配置 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

2. 使用单例模式创建SqlSessionFactory

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;

/**
 * create by tan on 2018/6/27
 * 用单例模式创建SqlSessionFactory
 **/
public class MybatisUtil {
    private static SqlSessionFactory sqlSessionFactory = null;
    static {
        String resource = "MyBatis.xml";
        InputStream inputStream = null;
        try {
            inputStream = Resources.getResourceAsStream(resource);
        } catch (IOException e) {
            e.printStackTrace();
        }
        sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
    }

    public static SqlSession getSqlSession() {
        return sqlSessionFactory.openSession();
    }
}

 一级缓存

testCache()方法

public void testCache() {
        SqlSession session = MybatisUtil.getSqlSession();
        UserDAO userDAO = session.getMapper(UserDAO.class);
        // 第一次查询
        User user = userDAO.getUserById(80);

        // 第二次查询
        User user1 = userDAO.getUserById(80);
        System.out.println(user.equals(user1)); // 返回true，第二次查询是从缓存中取值
        session.close();
    }

 

运行结果：

 

DEBUG [main] - Cache Hit Ratio [ssm.dao.UserDAO]: 0.0
DEBUG [main] - Opening JDBC Connection
DEBUG [main] - Created connection 33105141.
DEBUG [main] - Setting autocommit to false on JDBC Connection [com.mysql.jdbc.JDBC4Connection@1f924f5]
DEBUG [main] - ==>  Preparing: select * from user where id = ?; 
DEBUG [main] - ==> Parameters: 80(Integer)
DEBUG [main] - <==      Total: 1
DEBUG [main] - Cache Hit Ratio [ssm.dao.UserDAO]: 0.0
true

分析：第一次查询从数据库中取数据，打印了SQL语句，第二次直接从缓存中读取，返回的是同一个对象，返回true

对比分析：采用不同的SqlSession,修改testCache()代码如下：

public void testCache() {
        SqlSession session = MybatisUtil.getSqlSession();
        UserDAO userDAO = session.getMapper(UserDAO.class);
        // 第一次查询
        User user = userDAO.getUserById(80);
        session.close();

        // 第二次查询,不同的SqlSession
        session = MybatisUtil.getSqlSession();
        userDAO = session.getMapper(UserDAO.class);
        User user1 = userDAO.getUserById(80);
        
        System.out.println(user.equals(user1)); // 返回true，第二次查询是从缓存中取值
        session.close();
    }

运行结果：

DEBUG [main] - Setting autocommit to false on JDBC Connection [com.mysql.jdbc.JDBC4Connection@a35978]
DEBUG [main] - ==>  Preparing: select * from user where id = ?; // 第一次查询，访问数据库
DEBUG [main] - ==> Parameters: 80(Integer)
DEBUG [main] - <==      Total: 1
DEBUG [main] - Resetting autocommit to true on JDBC Connection [com.mysql.jdbc.JDBC4Connection@a35978]
DEBUG [main] - Closing JDBC Connection [com.mysql.jdbc.JDBC4Connection@a35978] // 关闭 session
DEBUG [main] - Returned connection 10705272 to pool.
DEBUG [main] - Opening JDBC Connection
DEBUG [main] - Checked out connection 10705272 from pool.
DEBUG [main] - Setting autocommit to false on JDBC Connection [com.mysql.jdbc.JDBC4Connection@a35978]
DEBUG [main] - ==>  Preparing: select * from user where id = ?; // 第二次查询，访问数据库
DEBUG [main] - ==> Parameters: 80(Integer)
DEBUG [main] - <==      Total: 1

分析：不同的 SqlSession,两次查询都访问了数据库，多个SqlSession 不能共享缓存

 

testCache2()方法：有删除和提交操作

@Test
    public void testCache2() {
        SqlSession session = MybatisUtil.getSqlSession();
        UserDAO userDAO = session.getMapper(UserDAO.class);
        // 第一次查询
        User user = userDAO.getUserById(80);

        // 执行 delete 和 commit 操作
        userDAO.deleteUser(88);
        session.commit();

        // 第二次查询
        User user1 = userDAO.getUserById(80);
        System.out.println(user.equals(user1)); // 返回true，第二次查询是从缓存中取值
        session.close();
    }

运行结果：

DEBUG [main] - Cache Hit Ratio [ssm.dao.UserDAO]: 0.0 // 第一次拿缓存，没有缓存，命中率为 0 
DEBUG [main] - Opening JDBC Connection // 打开数据库连接
DEBUG [main] - Created connection 19112467.
DEBUG [main] - Setting autocommit to false on JDBC Connection [com.mysql.jdbc.JDBC4Connection@123a213]
DEBUG [main] - ==>  Preparing: select * from user where id = ?; // 第一次查询，访问数据库
DEBUG [main] - ==> Parameters: 80(Integer)
DEBUG [main] - <==      Total: 1
DEBUG [main] - ==>  Preparing: delete from user where id = ?; // 执行删除、提交操作
DEBUG [main] - ==> Parameters: 88(Integer)
DEBUG [main] - <==    Updates: 1
DEBUG [main] - Committing JDBC Connection [com.mysql.jdbc.JDBC4Connection@123a213]
DEBUG [main] - Cache Hit Ratio [ssm.dao.UserDAO]: 0.0
DEBUG [main] - ==>  Preparing: select * from user where id = ?; // 第二次查询，访问数据库
DEBUG [main] - ==> Parameters: 80(Integer)
DEBUG [main] - <==      Total: 1
false

在删除和提交操作之后，再次执行查询操作，查询了数据库2次，因为删除操作之后清空了缓存，所以返回的结果也不是同一个，返回false

 

二级缓存：

实体类需要实现 Serializable 接口，为了将缓存数据取出执行反序列化操作

配置userMapper.xml

开启缓存：

// 开启二级缓存
<cache/>

testCache()

public void testCache() {
        // 获取 SqlSession 对象
        SqlSession session = MybatisUtil.getSqlSession();
        UserDAO userDAO = session.getMapper(UserDAO.class);
        User user = userDAO.getUserById(80);
        //System.out.println("user=" + user);
        session.close();

        // 再次获取 SqlSession 对象
        session = MybatisUtil.getSqlSession();
        userDAO = session.getMapper(UserDAO.class);
        User user2 = userDAO.getUserById(80);
        //System.out.println("user2=" + user2);
        session.close();

        // 执行删除、提交操作
        session = MybatisUtil.getSqlSession();
        userDAO = session.getMapper(UserDAO.class);
        userDAO.deleteUser(87);
        session.commit();
        session.close();

        // 第三次获取 SqlSession 对象
        session = MybatisUtil.getSqlSession();
        userDAO = session.getMapper(UserDAO.class);
        User user3 = userDAO.getUserById(80);
        //System.out.println("user3=" + user2);
        session.close();
    }

运行结果：

DEBUG [main] - Cache Hit Ratio [ssm.dao.UserDAO]: 0.0 // 第一次拿缓存，没有缓存，缓存命中率为0
DEBUG [main] - Opening JDBC Connection
DEBUG [main] - Created connection 19112467.
DEBUG [main] - Setting autocommit to false on JDBC Connection [com.mysql.jdbc.JDBC4Connection@123a213]
DEBUG [main] - ==>  Preparing: select * from user where id = ?; // 第一次执行查询语句，访问数据库
DEBUG [main] - ==> Parameters: 80(Integer)
DEBUG [main] - <==      Total: 1
DEBUG [main] - Resetting autocommit to true on JDBC Connection [com.mysql.jdbc.JDBC4Connection@123a213]
DEBUG [main] - Closing JDBC Connection [com.mysql.jdbc.JDBC4Connection@123a213]
DEBUG [main] - Returned connection 19112467 to pool.
DEBUG [main] - Cache Hit Ratio [ssm.dao.UserDAO]: 0.5 // 第二次拿缓存，之前SqlSession有缓存，缓存命中率为0.5
DEBUG [main] - Opening JDBC Connection
DEBUG [main] - Checked out connection 19112467 from pool.
DEBUG [main] - Setting autocommit to false on JDBC Connection [com.mysql.jdbc.JDBC4Connection@123a213]
DEBUG [main] - ==>  Preparing: delete from user where id = ?; // 执行删除、提交操作，会清空缓存二级缓存中的数据
DEBUG [main] - ==> Parameters: 87(Integer)
DEBUG [main] - <==    Updates: 1
DEBUG [main] - Committing JDBC Connection [com.mysql.jdbc.JDBC4Connection@123a213]
DEBUG [main] - Resetting autocommit to true on JDBC Connection [com.mysql.jdbc.JDBC4Connection@123a213]
DEBUG [main] - Closing JDBC Connection [com.mysql.jdbc.JDBC4Connection@123a213]
DEBUG [main] - Returned connection 19112467 to pool.
DEBUG [main] - Cache Hit Ratio [ssm.dao.UserDAO]: 0.3333333333333333 // 第三次拿缓存，缓存刚被清空，所以缓存命中率为1/3，共拿了三次，就第二次成功了
DEBUG [main] - Opening JDBC Connection
DEBUG [main] - Checked out connection 19112467 from pool.
DEBUG [main] - Setting autocommit to false on JDBC Connection [com.mysql.jdbc.JDBC4Connection@123a213]
DEBUG [main] - ==>  Preparing: select * from user where id = ?; // 第三次拿不到缓存，执行查询语句，访问数据库
DEBUG [main] - ==> Parameters: 80(Integer)
DEBUG [main] - <==      Total: 1
DEBUG [main] - Resetting autocommit to true on JDBC Connection [com.mysql.jdbc.JDBC4Connection@123a213]
DEBUG [main] - Closing JDBC Connection [com.mysql.jdbc.JDBC4Connection@123a213]
DEBUG [main] - Returned connection 19112467 to pool.

分析：多个 SqlSession 可以共享缓存中的数据，不会再次访问数据库，当执行insert、update、delete 操作时，会刷新缓存

参考文章：https://blog.csdn.net/u010858605/article/details/70906617?locationNum=2&fps=1 非常感谢作者

四、MyBatis 批量操作

批量插入insert：

  1. 普通 for 循环
  2. mybatis batch 模式插入
  3. foreach 方式插入

五、相关面试题

1.mybatis #{} 以及 ${}

动态 sql 是 mybatis 的主要特征之一，在 mapper 中定义的参数传到 xml 中，在查询之前 mybatis 会对其进行动态解析，mybatis 为我们提供了两种支持动态 sql 的语法： #{} 以及 ${}

#{}：标志占位符，向占位符传入参数，mybatis 会自动将 java 类型转换成 jdbc 类型，预编译时，不传入参数，而是传入占位符 ？，不容易出现 sql 注入

${}:标志 sql 拼接，通过 ${} 接收参数，将参数内容不加修饰的传入 sql，容易 sql 注入，不安全

版权声明：欢迎转载, 转载请保留原文链接。https://mp.csdn.net/postedit/80230556

明割啦
关注
专栏目录
菜鸟的mybatis实战教程
最强菜鸟
05-20 3万+
菜鸟的mybatis实战教程说明一、mybatis简介二、mybatis简单入门（1）数据库创建（2）创建springboot项目（3）增删改查操作（4）总结 说明 之前学习了mybatis之后没有做记录，在前几天做一个题库系统时，刚好要用到mybatis,因为之前做东西时用的jpa,mybatis没怎么去用，导致有些知识点想不起来，在使用mybatis出现了一些低级的错误，现将mybatis的学习笔记记录在这里，以便日后查看，本文会持续更新，不断地扩充 本文仅为记录学习轨迹，如有侵权,联系删除 一、myb
Java-mybatis学习（一）--- 第一个Mybatis程序
weixin_44824745的博客
07-23 212
第一个Mybatis程序 mybatis简介 MyBatis 本是apache的一个开源项目iBatis, 2010年这个项目由apache software foundation迁移到了google code，并且改名为MyBatis 。2013年11月迁移到Github。 MyBatis 是一款优秀的持久层框架，它支持定制化 SQL、存储过程以及高级映射。MyBatis 避免了几乎所有的JDB...
Java程序简介
weixin_30527323的博客
02-26 89
---恢复内容开始--- java程序的基本构成： HelloDate.java package 语句 import 语句 类定义 -class 一个文件只能有一个public 类 （与文件同名） 类=类头 +类体 类成员= 字段+方法 方法=方法头+方法体 ---恢复内容结束--- 转载于:https://www.cnblogs.com/cmysky/p/8476255...
高级JAVA程序员应该掌握的Mybatis知识
qq_32648593的博客
08-19 1197
Jdbc： 在学习Mybatis前，请允许我介绍下Jdbc，百度百科里，这样解释道：Jdbc是Java语言中用来规范客户端程序如何来访问数据库的应用程序接口API，提供了诸如查询和更新数据库中数据的方法。 Mybatis： 而同样，百度百科里这样介绍Mybatis：MyBatis 是一款优秀的持久层框架，它支持定制化 SQL、存储过程以及高级映射。MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集。 结果显而易见，Jdbc是接口，Mybatis是封装接口的框架。这就是二者的本质区别
MyBatis学习
热门推荐
jbgtwang的专栏
02-29 1万+
一、MyBatis简介与配置MyBatis+Spring+MySql MyBatis学习 之 一、MyBatis简介与配置MyBatis+Spring+MySql MyBatis学习 之 二、SQL语句映射文件(1)resultMap MyBatis学习 之 二、SQL语句映射文件(2)增删改查、参数、缓存 MyBatis学习 之 三、动态SQL语句 MyBatis学习 之 四、
《Java程序员-从笨鸟到菜鸟》PDF下载
07-22
资源名称：《Java程序员-从笨鸟到菜鸟》PDF 下载资源目录：作者简介：..........................................................................................................................................
java程序员-从笨鸟到菜鸟.pdf
01-08
java程序员-从笨鸟到菜鸟.pdf
[网盘]java程序员由菜鸟到笨鸟.pdf
03-21
### Java程序员成长之路——从菜鸟到笨鸟 #### 一、引言 《Java程序员由菜鸟到笨鸟》是一本由曹胜欢编写的书籍，旨在帮助初学者掌握Java编程的基础知识，并逐步进阶至更高级的应用场景。本书不仅适合初学者作为...
Java学习十五,Maven,Mybatis
土豆科技的博客
03-28 508
目录1.Maven1.1 Maven的概念1.2 Maven的作用1.3 Maven的使用1.3.1 Maven目录1.3.2 Maven基本命令1.3.3 Pom.xml的配置1.3.4 Maven的功能演示1.3.5 Maven常规使用 1.Maven 1.1 Maven的概念 Maven 是跨平台的项目管理工具。它主要服务于基于 Java 平台的项目构建、依赖管理和项目信息管理。 Maven...
MyBatis 菜鸟教程 2 单表操作
菜鸟教程
02-03 1809
对单表进行CRUD操作
mybatis自学习(一)
心跳停了HeartBeat的博客
05-26 528
Mybatis学习             最近mybatis火爆得爆棚，大有取代各类持久层框架的趋势；在这趋势催动下，我也耐不住寂寞开始自学， 所发表全是自己学习心得     一、什么是mybaits        mybatis是基于普通sql查询，存储过程，以及高级映射的持久层框架     二、mybatis核心对象         大家都知道每一个框架都有一个核心对象，my
菜鸟教程
sinat_15155817的专栏
06-24 3324
http://www.runoob.com/sitemap
Mybatis 入门学习（菜鸟必须掌握的示例）
djinjie945的专栏
04-20 498
说明： 1，本文采用的Mybatis框架版本为： mybatis-3.0.4.jar 2， 以持久化一个简单的User bean为例 3、教你规范的使用mybatis  ，首先我们来定义service层的接口，定义dao接口 4、写dao接口的实现，在写service接口的实现（很关键的一个问题是，怎么是dao的实现注入到service的实现中，这个很重要） 下面是我的包结构
【MybatisPlus】最全面的MybatisPlus通关教程_mybatisplus 菜鸟教程(4)
最新发布
2401_84181501的博客
05-03 863
为什么要学习MyBatisPlus呢？MyBatisPlus可以节省我们大量工作时间，所有的CRUD代码它都可以自动化完成！MyBatisPlus 本来就是简化 JDBC 操作的！无侵入：只做增强不做改变，引入它不会对现有工程产生影响，如丝般顺滑损耗小：启动即会自动注入基本 CURD，性能基本无损耗，直接面向对象操作， BaseMapper。
MyBatis新手教程，附代码&解释。
young_qin的博客
11-27 207
1.新建一个maven项目,并配置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:
mybatis教程
codecode_and_code的博客
08-08 682
http://blog.csdn.net/LoveYaozu/article/category/5640793
Mybatis教程
hello world
03-03 345
简介 什么是Mybatis Mybatis是一款持久框架层，它内部封装了jdbc，使开发者只需要关注sql语句本身，而不需要花费精力去处理加载驱动、创建连接、创建statement等繁杂的过程。 mybatis通过xml或注解的方式将要执行的各种statement配置起来，并通过java对象和statement中sql的动态参数进行映射生成最终执行的sql语句，最后由mybatis框架执行sql并将结果映射为java对象并返回。 MyBatis的主要设计目的就是让我们对执行SQL语句时对输入输出的数据管理更
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值