Mybatis笔记
2022/6/27 23:26:18
本文主要是介绍Mybatis笔记,对大家解决编程问题具有一定的参考价值,需要的程序猿们随着小编来一起学习吧!
Mybatis
环境:
- JDK 1.8
- MySQL 8.0
- maven 3.6.1
- IDEA
回顾:
- JDBC
- MySQL
- Java基础
- Maven
- Junit
Mybatis中文文档:https://mybatis.net.cn/
1. Mybatis简介
1.1 什么是Mybatis
- MyBatis 是一款优秀的持久层框架
- 它支持自定义 SQL、存储过程以及高级映射。
- MyBatis 免除了几乎所有的 JDBC 代码以及设置参数和获取结果集的工作。
- MyBatis 可以通过简单的 XML 或注解来配置和映射原始类型、接口和 Java POJO(Plain Old Java Objects,普通老式 Java 对象)为数据库中的记录。
- MyBatis 本是apache的一个开源项目iBatis, 2010年这个项目由apache software foundation迁移到了google code,并且改名为MyBatis。
- 2013年11月迁移到Github
获得maven:
- maven依赖包
<!-- https://mvnrepository.com/artifact/org.mybatis/mybatis --> <dependency> <groupId>org.mybatis</groupId> <artifactId>mybatis</artifactId> <version>3.5.10</version> </dependency>
- 官方中文网站:https://mybatis.net.cn/
- github
1.2 持久化
数据持久化:
- 持久化:将程序的数据在持久状态和瞬时状态转化的过程
- 内存:断电即失
- 数据库(JDBC):IO文件持久化
为什么需要持久化:
- 有些对象不能丢失
- 内存呢昂贵
1.3 持久层
Dao层、Service层、Controller层……
持久层:
- 完成持久化工作的代码
- 层的界限之分明显
1.4 为什么需要Mybatis
- 帮助程序员将数据存入到数据库中
- 方便
- 简化传统的JDBC,构造框架,自动化
- 不使用Mybatis也可以,但学习后更容易上手
- 优点:
- 简单易学
- 灵活
- SQL和代码分离,提高了可维护性
- 提供映射标签,支持对象与数据库的orm字段关系映射(不懂
- 提供对象关系映射标签,支持对象关系组件维护
- 提供xml标签,支持编写动态SQL
- 使用的人多
2. 第一个Mybatis程序
思路:搭建环境 -> 导入Mybatis -> 编写代码 -> 测试
2.1 搭建环境
搭建数据库:
CREATE DATABASE `mybatis`; USE `mybatis` CREATE TABLE `user`( `id` INT(20) NOT NULL, `name` VARCHAR(30) DEFAULT NULL, `pwd` VARCHAR(30) DEFAULT NULL, PRIMARY KEY(`id`) )ENGINE=INNODB DEFAULT CHARSET=utf8mb4; INSERT INTO `user`(`id`,`name`,`pwd`) VALUES (1,'A','123456'), (2,'B','1234567'), (3,'C','12345678')
创建项目
- 新建空maven项目
- 删除src文件夹
- 导入maven依赖
<?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.cha</groupId> <artifactId>Mybatis_Study</artifactId> <version>1.0-SNAPSHOT</version> <!--删掉src,作为父工程--> <!--导入依赖--> <dependencies> <!--mysql驱动--> <!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java --> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>8.0.29</version> </dependency> <!-- https://mvnrepository.com/artifact/org.mybatis/mybatis --> <dependency> <groupId>org.mybatis</groupId> <artifactId>mybatis</artifactId> <version>3.5.10</version> </dependency> <!-- https://mvnrepository.com/artifact/org.junit.jupiter/junit-jupiter-api --> <dependency> <groupId>org.junit.jupiter</groupId> <artifactId>junit-jupiter-api</artifactId> <version>5.8.2</version> <scope>test</scope> </dependency> </dependencies> </project>
2.2 创建模块
- 配置Mybatis的核心配置文件
<?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 type="JDBC"/> <dataSource type="POOLED"> <property name="driver" value="com.mysql.cj.jdbc.Driver"/> <property name="url" value="jdbc:mysql://localhost:3306/mybatis?useUnicode=true&characterEncoding=utf8&useSSL=true&serverTimezone=GMT"/> <property name="username" value="root"/> <property name="password" value="123456"/> </dataSource> </environment> </environments> <mappers> <mapper resource="org/mybatis/example/BlogMapper.xml"/> </mappers> </configuration>
- 编写工具类
public class MybatisUtils { private static SqlSessionFactory sqlSessionFactory; static { try { // 获取sqlSessionFactory对象 String resource = "mybatis-config.xml"; InputStream inputStream = Resources.getResourceAsStream(resource); sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream); } catch (IOException e) { e.printStackTrace(); } } // 有了 SqlSessionFactory,我们可以从中获得 SqlSession 的实例 // SqlSession 提供了在数据库执行 SQL 命令所需的所有方法 public static SqlSession getSqlSession(){ return sqlSessionFactory.openSession(); } }
2.3 编写代码
- 实体类(pojo/model:模型对应的实体类(javabean对象)
public class User { private int id; private String name; private String pwd; public User(){} public User(int id, String name, String pwd) { this.id = id; this.name = name; this.pwd = pwd; } public int getId() { return id; } public void setId(int id) { this.id = id; } public String getName() { return name; } public void setName(String name) { this.name = name; } public String getPwd() { return pwd; } public void setPwd(String pwd) { this.pwd = pwd; } @Override public String toString() { return "User{" + "id=" + id + ", name='" + name + '\'' + ", pwd='" + pwd + '\'' + '}'; } }
- Dao接口
public interface UserDao { List<User> getUserList(); }
- 接口实现类:由原来的UserDaoImpl转化为一个Mapper配置文件
<?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=绑定一个对应的Dao/Mapper接口--> <mapper namespace="com.cha.dao.UserDao"> <!--id:对应的方法,要与UserDao里的方法相同--> <!--resultType:返回类型,写全限定名--> <!--from: 数据库名.表名--> <select id="getUserList" resultType="com.cha.polo.User"> select * from mabatis.user </select> </mapper>
2.4 测试
测试类写在测试文件夹下:
注意点:
org.apache.ibatis.binding.BindingException: Type interface com.cha.dao.UserDao is not known to the MapperRegistry.
- 在核心配置文件中注册mappers
- 在namespace修改对应的接口地址
- junit测试
public class UserDaoTest { @Test public void test(){ // 1. 获得SqlSession对象 SqlSession sqlSession = MybatisUtils.getSqlSession(); // 2. 执行sql // 通过反射获得 UserDao mapper = sqlSession.getMapper(UserDao.class); List<User> userList = mapper.getUserList(); for (User user : userList) { System.out.println(user); } // 关闭 sqlSession.close(); } }
可能存在问题:
- 配置文件没用注册
- 绑定接口错误
- 方法名错误
- 返回类型错误
- maven导出资源(约束大于
3. CRUD
3.1 namespace
namespace中的包名要和Dao/Mapper接口的包名一致
3.2 select
选择,查询语句
- id:对应的namespace中的方法名
- resultType:sql语句执行的返回值
- parameterType:参数类型
实现:
- 创建接口类中方法
// 根据ID查询用户 // 接口中的方法原本需要依靠实现类实现,在此处通过补充标签实现 User getUserById(int i);
- 在xml中实现接口,使用
#{类型}
传递参数
<!--传递变量--> <select id="getUserById" parameterType="int" resultType="com.cha.pojo.User"> select * from mybatis.user where id = #{id} </select>
- junit测试
@Test public void getUserById(){ SqlSession sqlSession = MybatisUtils.getSqlSession(); UserMapper mapper = sqlSession.getMapper(UserMapper.class); User userById = mapper.getUserById(1); System.out.println(userById); sqlSession.close(); }
3.3 Insert
<!--对象中的属性可以直接取出--> <insert id="addUser" parameterType="com.cha.pojo.User"> insert into mybatis.user(id, name, pwd) values (#{id},#{name},#{pwd}); </insert>
- 实现
// 增删改需要提交事务 @Test public void addUser(){ SqlSession sqlSession = MybatisUtils.getSqlSession(); UserMapper mapper = sqlSession.getMapper(UserMapper.class); int res = mapper.addUser(new User(5,"E","123456")); if (res > 0){ System.out.println("插入成功"); } // 提交事务 sqlSession.commit(); sqlSession.close(); }
3.4 update
<update id="updateUser" parameterType="com.cha.pojo.User"> update mybatis.user set name=#{name}, pwd=#{pwd} where id=#{id}; </update>
3.5 delete
<delete id="deleteUser" parameterType="int"> delete from mybatis.user where id = #{id} </delete>
注意:增删改需要提交事务
3.6 万能Map
在实体类或数据库中的表的字段或参数过多时,应该考虑使用Map
但不易维护,应该有替代方法
// 万能Map int addUser2(Map<String, Object> map);
- 使用map可以不传递完整参数
<!--传递Map的key--> <insert id="addUser2" parameterType="Map"> insert into mybatis.user(id, name, pwd) values (#{userId},#{userName},#{password}); </insert>
- 可以不传递完整参数
@Test public void addUser2(){ SqlSession sqlSession = MybatisUtils.getSqlSession(); UserMapper mapper = sqlSession.getMapper(UserMapper.class); Map<String, Object> map = new HashMap<String, Object>(); map.put("userId",5); map.put("userName","Fmap"); map.put("password","234"); mapper.addUser2(map); // 提交事务 sqlSession.commit(); sqlSession.close(); }
对比:
-
Map传递参数,直接在sql曲中key
-
对象传递参数,直接在sql中去除对象的属性
-
只有一个基本类型参数时,可以不标注
parameterType
直接获取 -
多个参数使用Map或注解
3.7 模糊查询
- 在java代码传递的时候加入拼接符号
%
List<User> users = mapper.getUserLike("%A%")
- 在sql中使用通配符(使用
${}
进行查询时会存在sql注入问题)
select * from mybatis.user where name like "%"#{value}"%";
4. 配置解析
4.1 核心配置文件
mybatis-config.xml
:
- configuration(配置)
- properties(属性)
- settings(设置)
- typeAliases(类型别名)
typeHandlers(类型处理器)objectFactory(对象工厂)plugins(插件)- environments(环境配置)
- environment(环境变量)
- transactionManager(事务管理器)
- dataSource(数据源)
- environment(环境变量)
- databaseIdProvider(数据库厂商标识)
- mappers(映射器)
4.2 环境配置(environments)
MyBatis 可以配置成适应多种环境
不过要记住:尽管可以配置多个环境,但每个 SqlSessionFactory 实例只能选择一种环境。
可以配置多套运行环境:
- 默认使用的环境 ID(比如:default="development"):更改配置环境。
- 每个 environment 元素定义的环境 ID(比如:id="development"):配置其他环境。
- 事务管理器的配置(比如:type="JDBC"):事务管理器有两种,默认为JDBC。
- 数据源的配置(比如:type="POOLED"):默认为连接池。
4.3 属性(properties)
这些属性可以在外部进行配置,并可以进行动态替换。既可以在典型的 Java 属性文件中配置这些属性,也可以在 properties 元素的子元素中设置。db.properties
- 编写
db.properties
:文件中的url的分隔使用&
,直接放入配中的分隔为&
driver=com.mysql.cj.jdbc.Driver url=jdbc:mysql://localhost:3306/mybatis?useUnicode=true&characterEncoding=utf8&useSSL=true username=root password=123456
- 插入配置文件:属性要放在配置的最上面
<!--自闭合,引入外部配置文件--> <properties resource="db.properties"/>
- 在
db.properties
中没有写入的内容,可以在properties中补充,优先使用外部配置文件db中的内容
<properties resource="db.properties"> <property name="username" value="root"/> <property name="password" value="123456"/> </properties>
4.4 类型别名(typeAliases)
typeAliases需要写在第三的位置:仅在set和properties之后
-
作用:
- 为Java类型设置一个较短的名字
- 用于减少类完全限定名的冗余
-
给实体类起别名:实体类较少时
<!--可以给实体类起别名--> <typeAliases> <typeAlias type="com.cha.pojo.User" alias="User"/> </typeAliases>
- 指定包,MyBatis 会在包名下面搜索需要的 Java Bean
- 扫描实体类的包,默认别名为这个类类名,默认首字母小写,大小写不区分
- 实体类较多时建议使用
<typeAliases> <package name="com.cha.pojo"/> </typeAliases>
-
区别:
- 第一种可以自定义别名
- 第二种不能自定义(可以在实体类上使用注解自定义)
@Alias("user") public class User{}
4.5 设置(settings)
设置名 | 描述 | 有效值 |
---|---|---|
logImpl | 指定 MyBatis 所用日志的具体实现,未指定时将自动查找。 | SLF4J | LOG4J | LOG4J2 | JDK_LOGGING | COMMONS_LOGGING | STDOUT_LOGGING | NO_LOGGING |
cacheEnabled | 全局性地开启或关闭所有映射器配置文件中已配置的任何缓存。 | true | false |
lazyLoadingEnabled | 延迟加载的全局开关。当开启时,所有关联对象都会延迟加载。 特定关联关系中可通过设置 fetchType 属性来覆盖该项的开关状态。 |
true | false |
4.6 其他配置
- typeHandlers(类型处理器)
- objectFactory(对象工厂)
- plugins(插件)
- Mybatis-generator-core
- Mybatis-Plus:简化
- 通用mapper
4.7 映射器(mappers)
MapperRegisrty:注册绑定Mapper文件
方法1:使用相对于类路径的资源引用
<mappers> <mapper resource="com/cha/dao/UserMapper.xml"/> </mappers>
方法2:使用映射器接口实现类的完全限定类名
<mappers> <mapper class="com.cha.dao.UserMapper"/> </mappers>
方法3: 包扫描,将包内的映射器接口实现全部注册为映射器
<mappers> <package name="com.cha.dao"/> </mappers>
共同的注意点:
- 接口和对应的Mapper配置文件必须同名
- 接口和对应的Mapper配置文件必须在同一个包下
4.8 生命周期和作用域(Scope)
不同作用域和生命周期类别是至关重要的,因为错误的使用会导致非常严重的并发问题。
- SqlSessionFactoryBuilder:
- 一旦创建了 SqlSessionFactory,就不再需要
- 局部变量
- SqlSessionFactory:
- 类似数据库连接池
- 一旦被创建就应该在应用的运行期间一直存在,没有任何理由丢弃它或重新创建另一个实例
- 最佳作用域是应用作用域,全局作用域
- 最简单的就是使用单例模式或者静态单例模式
- SqlSession:
- 连接到连接池的请求,连接mapper对应的具体业务
- 实例不是线程安全的,因此是不能被共享的,所以它的最佳的作用域是请求或方法作用域
- 用完之后需要关闭,否则资源会被占用
5. 解决属性名和字段名不一致的问题
5.1 问题
数据库中的字段和测试实体类中的字段不同时,测试获取不到数据
select * from mybatis.user where id = #{id} select id,name,pwd from mybatis.user where id = #{id}
解决方法:
- 起别名
<select id="getUserById" parameterType="int" resultType="com.cha.pojo.User"> select id,name,pwd as password from mybatis.user where id = #{id} </select>
5.2 resultMap结果集映射
仅需要映射不同的的内容
<!--使用结果集映射--> <!--返回值类型的映射--> <resultMap id="UserMap" type="com.cha.pojo.User"> <!--column数据库中的字段,property实体类中的id--> <result column="pwd" property="password"/> </resultMap> <select id="getUserById" parameterType="int" resultMap="UserMap"> select * from mybatis.user where id = #{id} </select>
resultMap
元素是 MyBatis 中最重要最强大的元素。ResultMap
的设计思想是,对简单的语句做到零配置,对于复杂一点的语句,只需要描述语句之间的关系就行了ResultMap
的优秀之处:完全可以不用显式地配置- 高级结果映射(10.1,联表查询)
6. 日志
6.1 日志工厂
在数据库操作出现异常时,通过日志工厂排错
设置名 | 描述 | 有效值 |
---|---|---|
logImpl | 指定 MyBatis 所用日志的具体实现,未指定时将自动查找。 | SLF4J | LOG4J | LOG4J2 | JDK_LOGGING | COMMONS_LOGGING | STDOUT_LOGGING | NO_LOGGING |
mybatis中使用哪个日志,由设置决定
- SLF4J
- LOG4J(掌握)
- LOG4J2
- JDK_LOGGING
- COMMONS_LOGGING
- STDOUT_LOGGING(掌握)
- NO_LOGGING
标准的日志工厂实现
<settings> <setting name="logImpl" value="STDOUT_LOGGING"/> </settings>
6.2 LOG4J
最新版本的mybatis的log4j已过时
log4j简介:
- Log4j是Apache的一个开源项目,通过使用Log4j,我们可以控制日志信息输送的目的地是控制台
文件、GUI组件 - 我们也可以控制每一条日志的输出格式;
- 通过定义每一条日志信息的级别,我们能够更加细致地控制日志的生成过程。
- 通过一个配置文件来灵活地进行配置,而不需要修改应用的代码。
1.导入包
<!-- https://mvnrepository.com/artifact/log4j/log4j --> <dependency> <groupId>log4j</groupId> <artifactId>log4j</artifactId> <version>1.2.17</version> </dependency>
- log4j.properties
#将等级为DEBUG的日志信息输出到console和file这两个目的地,console和file的定义在下面的代码 log4j.rootLogger=DEBUG,console,file #控制台输出的相关设置 log4j.appender.console = org.apache.log4j.ConsoleAppender log4j.appender.console.Target = System.out log4j.appender.console.Threshold=DEBUG log4j.appender.console.layout = org.apache.log4j.PatternLayout log4j.appender.console.layout.ConversionPattern=[%c]-%m%n #文件输出的相关设置 log4j.appender.file = org.apache.log4j.RollingFileAppender log4j.appender.file.File=./log/logFile.log log4j.appender.file.MaxFileSize=10mb log4j.appender.file.Threshold=DEBUG log4j.appender.file.layout=org.apache.log4j.PatternLayout log4j.appender.file.layout.ConversionPattern=[%p][%d{yy-MM-dd}][%c]%m%n #日志输出级别 log4j.logger.org.mybatis=DEBUG log4j.logger.java.sql=DEBUG log4j.logger.java.sql.Statement=DEBUG log4j.logger.java.sql.ResultSet=DEBUG log4j.logger.java.sql.PreparedStatement=DEBUG
- 配置log4j为日志的实现
<settings> <setting name="logImpl" value="LOG4J"/> </settings>
- log4j的使用
直接运行
简单应用
- 在要使用log4j的累中导入包(apache
- 日志对象,参数为当前类的class
static Logger logger = Logger.getLogger(UserMapperTest.class)
- 日志级别
logger.info("info:xxxx") logger.debug("debug:xxxx") logger.error("error:xxxx")
7. 分页
为什么需要分页?
- 减少数据处理量
使用Limit分页
select * from user limit startIndex,pageSize; [startIndex, startIndex+pageSize] select * from user limit pageSize; [0, pageSize]
使用Mybatis分页:使用sql
- 接口
// 分页 List<User> getUserByLimit(Map<String,Integer> map);
- UserMapper.xml
<select id="getUserById" parameterType="int" resultMap="UserMap"> select * from mybatis.user where id = #{id} </select>
- 测试
@Test public void getUserByLimit(){ SqlSession sqlSession = MybatisUtils.getSqlSession(); UserMapper mapper = sqlSession.getMapper(UserMapper.class); HashMap<String, Integer> map = new HashMap<String, Integer>(); map.put("startIndex", 0); map.put("pageSize", 2); List<User> userList = mapper.getUserByLimit(map); for (User user : userList) { System.out.println(user); } sqlSession.close(); }
其他跳过了
8. 使用注解开发
8.1 面向接口编程
- 大家之前都学过面向对象编程,也学习过接口,但在真正的开发中,很多时候我们会选择面向接口编程
- 根本原因∶解耦,可拓展,提高复用,分层开发中,上层不用管具体的实现,大家都遵守共同的标准,使得开发变得容易,规范性更好
- 在一个面向对象的系统中,系统的各种功能是由许许多多的不同对象协作完成的。在这种情况下,各个对象内部是如何实现自己的,对系统设计人员来讲就不那么重要了;
- 而各个对象之间的协作关系则成为系统设计的关键。小到不同类之间的通信,大到各模块之间的交互,在系统设计之初都是要着重考虑的,这也是系统设计的主要工作内容。面向接口编程就是指按照这种思想来编程。
关于接口的理解
- 接口从更深层次的理解,应是定义(规范,约束)与实现(名实分离的原则)的分离。
- 接口的本身反映了系统设计人员对系统的抽象理解。
- 接口应有两类:
- 第一类是对一个个体的抽象,它可对应为一个抽象体(abstract class);
- 第二类是对一个个体某一方面的抽象,即形成一个抽象面(interface) ;
- 一个体有可能有多个抽象面。抽象体与抽象面是有区别的。
三个面向区别
- 面向对象是指,我们考虑问题时,以对象为单位,考虑它的属性及方法
- 面向过程是指,我们考虑问题时,以一个具体的流程(事务过程)为单位,考虑它的实现
- 接口设计与非接口设计是针对复用技术而言的,与面向对象(过程)不是一个问题.更多的体现就是对系统整体的架构
8.2 注解开发
- 在接口上实现注解
public interface UserMapper { @Select("select * from user") List<User> getUsers(); }
- 在核心配置文件中绑定接口(类注册,package好像也行)
<!--绑定接口--> <mappers> <mapper class="com.cha.dao.UserMapper"/> </mappers>
- 测试
- 本质:反射机制实现
- 底层:动态代理
@Test public void test(){ SqlSession sqlSession = MybatisUtils.getSqlSession(); // 通过反射获取 UserMapper mapper = sqlSession.getMapper(UserMapper.class); List<User> users = mapper.getUsers(); for (User user : users) { System.out.println(user); } sqlSession.close(); }
8.3 注解的CRUD
事务自动提交
将工具类中获取SqlSession的参数设置为true,会自动提交事务
尽量不要设置自动提交,避免代码出现问题
// 有了 SqlSessionFactory,我们可以从中获得 SqlSession 的实例 // SqlSession 提供了在数据库执行 SQL 命令所需的所有方法 public static SqlSession getSqlSession() { // 将此处的参数设置为true后会自动提交事务,无需再手动进行提交 return sqlSessionFactory.openSession(true); }
需要将接口注册绑定到核心配置文件中,才能使用注解开发
@Param注解传参
- 方法存在多个参数时,必须添加@Param
- @Param()中的内容对应@Select中查找的内容(包括xml查询),传入参数可以设置为不同的名字
@Select("select * from user where id = #{id}") User getUserById(@Param("id") int id2);
注意:
- 基本类型的参数或String类型需要加上@Param
- 引用类型不需要添加
- 如果只有一个基本类型可以忽略,但建议添加
- 在SQl引用的就是@Param("")中设定的数学
注解插入@Insert
- 创建插入接口
@Insert("insert into user(id,name,pwd) values (#{id},#{name},#{pwd})") int addUser(User user);
- 测试
@Test public void testGetById(){ SqlSession sqlSession = MybatisUtils.getSqlSession(); UserMapper mapper = sqlSession.getMapper(UserMapper.class); mapper.addUser(new User(6,"insertTest","123456")); sqlSession.close(); }
注解修改@Update
@Update("update user set name=#{name},pwd=#{pwd} where id=#{id}") int updateUser(User user);
注解删除@Delete
@Delete("delete from user where id=#{uid}") int deleteUser(@Param("uid") int id);
#{}和${}的区别
-
{}可以防止sql注入
- ${}会自动拼接,会存在sql注入问题
Mybatis的详细执行流程(需细化)
9. Lombok
不建议使用,看公司用不用
自动生成get\set,日志工具的插件。
使用步骤:
- 下载插件Lombok
- 使用maven依赖导入jar包
<!-- https://mvnrepository.com/artifact/org.projectlombok/lombok --> <dependency> <groupId>org.projectlombok</groupId> <artifactId>lombok</artifactId> <version>1.18.22</version> <scope>provided</scope> </dependency>
- 在实体类上加注解
@Data // 无参构造,get, set, toSrting, hashCode, equals @AllArgsConstructor // 有参构造 @NoArgsConstructor // 无参构造
缺点:
- 不支持多种参数构造器的重载(可以在代码中加入)
10. 多对一处理
- 多个学生对应一个老师
- 学生:多个学生关联一个老师(多对一)
- 老师:一个老师集合多个学生(一对多)
CREATE TABLE `teacher` ( `id` INT(10) NOT NULL, `name` VARCHAR(30) DEFAULT NULL, PRIMARY KEY (`id`) ) ENGINE=INNODB DEFAULT CHARSET=utf8 INSERT INTO teacher(`id`, `name`) VALUES (1, '秦老师'); CREATE TABLE `student` ( `id` INT(10) NOT NULL, `name` VARCHAR(30) DEFAULT NULL, `tid` INT(10) DEFAULT NULL, PRIMARY KEY (`id`), KEY `fktid` (`tid`), CONSTRAINT `fktid` FOREIGN KEY (`tid`) REFERENCES `teacher` (`id`) ) ENGINE=INNODB DEFAULT CHARSET=utf8 INSERT INTO `student` (`id`, `name`, `tid`) VALUES ('1', '小明', '1'); INSERT INTO `student` (`id`, `name`, `tid`) VALUES ('2', '小红', '1'); INSERT INTO `student` (`id`, `name`, `tid`) VALUES ('3', '小张', '1'); INSERT INTO `student` (`id`, `name`, `tid`) VALUES ('4', '小李', '1'); INSERT INTO `student` (`id`, `name`, `tid`) VALUES ('5', '小王', '1');
10.1 环境搭建
- 构建项目对应的实体类,注意类间的关联
public class Student { private int id; private String name; // 令学生关联一个老师 private Teacher teacher; }
- 构建实体类对应接口
- 在resources中创建对应的文件夹(用
/
分隔),创建对应的mapper.xml文件
<?xml version="1.0" encoding="UTF8" ?> <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd"> <mapper namespace="com.cha.dao.StudentMapper"> </mapper>
- 将配置文件
mybatis_config.xml
中的mapper于3中创建的文件对应
<mappers> <package name="com.cha.dao"/> or <mapper resource="com/cha/dao/*.xml"/> </mappers>
- 测试环境
实体类:
@Select("select * from teacher where id = #{tid}") Teacher test(@Param("tid") int id);
测试类:
@Test public void test(){ SqlSession sqlSession = MybatisUtils.getSqlSession(); TeacherMapper mapper = sqlSession.getMapper(TeacherMapper.class); Teacher test = mapper.test(1); System.out.println(test); sqlSession.close(); }
10.2 直接联表查询(老师的姓名为String类型)
<select id="getStudent" resultType="com.cha.pojo.Student"> select s.id, s.name, t.name as teacherName from student as s inner join teacher as t on s.tid = t.id </select>
10.3 按照查询嵌套处理
- 查询所有学生信息
- 根据查询结果的tid,寻找对应老师(子查询)
<!--思路: 1.查询所有学生信息 2. 根据查询结果的tid,寻找对应老师(子查询) --> <select id="getStudent" resultMap="StudentTeacher"> select * from student </select> <resultMap id="StudentTeacher" type="com.cha.pojo.Student"> <!--column 数据库,property 实体类--> <result column="id" property="id"/> <result column="name" property="name"/> <!--复杂的属性单独处理 对象:association 集合:collection --> <!--javaType参数设置类型--> <association property="teacher" column="tid" javaType="com.cha.pojo.Teacher" select="getTeacher"/> </resultMap> <select id="getTeacher" resultType="com.cha.pojo.Teacher"> select * from teacher where id = #{tid} </select>
10.4 按照结果嵌套查询
类似联表查询
<!--按照结果嵌套查询--> <select id="getStudent2" resultMap="StudentTeacher2"> select s.id sid,s.name sname,t.name tname,t.id tid from student s, teacher t where s.tid = t.id </select> <resultMap id="StudentTeacher2" type="com.cha.pojo.Student"> <result property="id" column="sid"/> <result property="name" column="sname"/> <association property="teacher" javaType="com.cha.pojo.Teacher"> <result property="name" column="tname"/> <result property="id" column="tid"/> </association> </resultMap>
11. 一对多处理
一个老师有多个学生
- 环境搭建
修改实体类:
public class Student { private int id; private String name; // 学生关联的老师id private int tid; }
public class Teacher { private int id; private String name; // 一个老师有多个学生 private List<Student> students; }
11.1 按照结果嵌套处理
<!--根据结果嵌套查询--> <select id="getTeacher" resultMap="TeacherStudent"> select s.id sid, s.name sname, t.name tname, t.id tid from student s, teacher t where s.tid = t.id and t.id = #{tid} </select> <resultMap id="TeacherStudent" type="Teacher"> <result property="id" column="tid"/> <result property="name" column="tname"/> <!--复杂的属性,需要单独处理: 对象:association 集合:collection javaType:指定属性的类型 集合中的泛型新型用ofType获取 --> <collection property="students" ofType="Student"> <result property="id" column="sid"/> <result property="name" column="sname"/> <result property="tid" column="tid"/> </collection> </resultMap>
11.2 按照查询嵌套处理
<select id="getTeacher2" resultMap="TeacherStudent2"> select * from teacher where id = #{tid} </select> <resultMap id="TeacherStudent2" type="Teacher"> <collection property="students" javaType="ArrayList" ofType="Student" select="getStudentByTeacherId" column="id"/> </resultMap> <select id="getStudentByTeacherId" resultType="Student"> select * from student where tid = #{tid} </select>
10和11对比
- 关联:association(多对一)
- 集合:colleciton(一对多)
- javaType 和 ofType
- javaType:用来指定实体类中的属性
- ofType:用来指定映射到List或者集合中的pojo类型,泛型中的约束类型
注意点
- 保证sql的可读性,尽量通俗易懂
- 注意一对多和多对一中,属性名的字段问题
- 如果问题不易排查,可以使用日志
面试高频
- Mysql引擎
- InnoDB底层原理
- 索引
- 索引优化
12. 动态SQL
什么是动态sql:根据不同的条件生成不同的sql语句
MyBatis精简了元素,基于OGNL的表达式淘汰大部分元素
- if
- choose (when, otherwise)
- trim (where, set)
- foreach
12.1 搭建环境
CREATE TABLE `blog`( `id` VARCHAR(50) NOT NULL COMMENT '博客id', `title` VARCHAR(100) NOT NULL COMMENT '博客标题', `author` VARCHAR(30) NOT NULL COMMENT '博客作者', `create_time` DATETIME NOT NULL COMMENT '创建时间', `views` INT(30) NOT NULL COMMENT '浏览量' )ENGINE=INNODB DEFAULT CHARSET=utf8
创建一个基础工程:
- 导包
- 编写配置文件
- 编写实体类
@Data public class Blog { private String id; private String title; private String author; private Date createTime; private int views; }
- 编写实体类对应的接口和Mapper.xml文件
开启驼峰命名自动映射,将下划线转换为驼峰命名
<setting name="mapUnderscoreToCamelCase" value="true"/>
在xml文件中仍要注意into
和values
中值的对应。
12.2 if
使用if,可以根据map设置需要查询的title和author的条件进行查询
<!--加上where 1=1 是为了简化后续的if条件,不用每句都写where--> <select id="queryBlog" parameterType="map" resultType="blog"> select * from mybatis.blog where 1=1 <if test="title != null"> and title = #{title} </if> <if test="author != null"> and author = #{author} </if> </select>
12.3 choose (when, otherwise)
类似java中的包含break
的switch语句,按顺序测试是否符合条件,符合条件则执行
<select id="ChooseBlog" parameterType="map" resultType="blog"> select * from mybatis.blog <where> <choose> <when test="title != null"> title = #{title} </when> <when test="author != null"> and author = #{author} </when> <otherwise> and views > 5000 </otherwise> </choose> </where> </select>
12.4 trim (where, set)
where
where 元素只会在子元素返回任何内容的情况下才插入 “WHERE” 子句。而且,若子句的开头为 “AND” 或 “OR”,where 元素也会将它们去除。
自动插入和去除,where中的内容为空时自动去除where,自动省略句子开头
<select id="queryBlog" parameterType="map" resultType="blog"> select * from mybatis.blog <where> <if test="title != null"> and title = #{title} </if> <if test="author != null"> and author = #{author} </if> </where> </select>
set
用于动态包含需要更新的列,忽略其它不更新的列
set 元素会动态地在行首插入 SET 关键字,并会删掉额外的逗号
会自动删除语句末尾的逗号,记得在语句后添加逗号,
!
<!--返回类型为基本参数,可以不写--> <!--update不需要返回值类型--> <update id="update" parameterType="map"> update mybatis.blog <set> <if test="title != null"> title = #{title}, </if> <if test="author != null"> author = #{author}, </if> </set> where id = #{id} </update>
trim:对where和set进行设置
设置where
通过自定义 trim 元素来定制 where 元素的功能
<trim prefix="WHERE" prefixOverrides="AND |OR "> ... </trim>
prefixOverrides 属性会忽略通过管道符分隔的文本序列(注意此例中的空格是必要的)。上述例子会移除所有 prefixOverrides 属性中指定的内容,并且插入 prefix 属性中指定的内容。
设置set
覆盖了后缀值设置,并且自定义了前缀值,移除所有 suffixOverrides 属性中指定的内容
<trim prefix="SET" suffixOverrides=","> ... </trim>
动态sql的本质仍是sql语句,不同之处是可以在sql层面执行代码逻辑
12.5 SQL片段
有时候将一些公共的部分抽取出来,以供代码复用
- 使用sql标签抽取公告部分
<sql id="if-title-author"> <if test="title != null"> and title = #{title} </if> <if test="author != null"> and author = #{author} </if> </sql>
- 在需要使用的地方使用include标签引用即可
<select id="queryBlog" parameterType="map" resultType="blog"> select * from mybatis.blog <where> <include refid="if-title-author"/> </where> </select>
注意:
- 最好基于单表定义sql片段
- 片段中不要存在
<where>
标签
12.6 foreach
对集合进行遍历(尤其是在构建 IN 条件语句的时候)
<select id="selectPostIn" resultType="domain.blog.Post"> SELECT * FROM POST P WHERE ID in <foreach item="item" index="index" collection="list" open="(" separator="," close=")"> #{item} </foreach> </select>
允许你指定一个集合,声明可以在元素体内使用的集合项(item)和索引(index)变量。它也允许你指定开头与结尾的字符串以及集合项迭代之间的分隔符。
index一般不适用,#{item}是需要获取的内容
使用
collection
:搜索的集合
item
:搜索的内容
open="and ("
:拼接的开头
close=")"
:拼接的结尾
separator="or"
:分隔的内容
id = #{id}
:搜索的条件
<!-- 查找123号id select * from mybatis.blog where 1=1 and (id = 1 or id = 2 or id = 3) --> <select id="queryBlogForeach" parameterType="map" resultType="blog"> select * from mybatis.blog <where> <foreach collection="ids" item="id" open="and (" close=")" separator="or"> id = #{id} </foreach> </where> </select>
动态sql就是在拼接sql语句,只要保证sql语句的正确,按照sql的格式排列组合就行
建议:写出sql语句,再根据语句进行拼接
13. 缓存(了解)
13.1 简介
查询操作:连接数据库,资源消耗大
解决方法:将查询的结果暂存在可以直接获取的地方 -> 放在内存中,也就是缓存
当再次查询相同数据时,直接通过缓存获取,就不用通过数据库。
读写分离,主从复制?
- 什么是缓存(Cache)?
- 存在内存中的临时数据。
- 将用户经常查询的数据放在缓存(内存)中,用户去查询数据就不用从磁盘上(关系型数据库数据文件)查询,从缓存中查询,从而提高查询效率,解决了高并发系统的性能问题。
- 为什么使用缓存
- 减少和数据库交互的次数,减少系统开销,提高系统效率
- 什么样的数据能使用缓存
- 经常查询并且不经常改变的数据
13.2 Mybatis缓存
- Mybatis包含一个非常强大的查询缓存特性,它可以非常方便的定制和配置缓存。缓存可以极大的提升查询效率。
- Mybatis系统中默认定义了两级缓存:一级缓存和二级缓存
- 默认情况下,只有一级缓存开启。(SqlSession级别的缓存,也称为本地缓存,连接到连接池)
- 二级缓存需要手动开启和配置,是基于namespace级别的缓存
- 为了提高扩展性,Mybatis定义了缓存接口
Cache
,可以通过实现Cache
接口来自定义二级缓存
Mybatis的清除策略
LRU
– 最近最少使用:移除最长时间不被使用的对象。(默认)FIFO
– 先进先出:按对象进入缓存的顺序来移除它们。SOFT
– 软引用:基于垃圾回收器状态和软引用规则移除对象。WEAK
– 弱引用:更积极地基于垃圾收集器状态和弱引用规则移除对象
13.3 一级缓存
-
一级缓存也叫本地缓存:SqlSession
- 与数据库同一次会话期间查询到的数据会存放在本地缓存中
- 如果需要获取相同的数据,直接从缓存中获取,不会再进行查询操作
-
测试步骤
- 开启日志
- 测试在一个Session中查询两次相同记录
- 查看日志输出
日志输出可以看出仅进行了一次连接和查询操作,获取了相同的内容
缓存失效
查询两次相同内存,查看日志,判断缓存是否失效
可能原因:
- 查询不同的东西
- 进行增删改操作,可能会改变原来的数据,必定会刷新缓存
- 查询不同的Mapper.xml
- 手动清除缓存
sqlSession.clearCache(); //手动清理缓存
总结:一级缓存是默认开启的,只在一次SqlSession中有效,即连接到关闭区间。
一级缓存就是一个map
13.4 二级缓存
- 二级缓存也叫全局缓存,一级缓存作用域太低了,所以诞生了二级缓存
- 基于namespace级别的缓存,一个名称空间,对应一个二级缓存
- 工作机制
- 一个会话查询一条数据,这个数据就会被放在当前会话的一级缓存中
- 如果当前会话关闭了,这个会话对应的一级缓存就没了;但是我们想要的是,会话关闭了,一级缓存中的数据被保存到二级缓存中
- 新的会话查询信息,就可以从二级缓存中获取内容
- 不同的mapper查出的数据会放在自己对应的缓存(map)中
步骤:
- 开启全局缓存(默认开启)
<!--显式的开启全局缓存--> <setting name="cacheEnabled" value="true"/>
- 在要使用二级缓存的Mapper中开启
<!--在当前Mapper中使用二级缓存--> <cache/>
可以自定义参数:创建了一个 FIFO 缓存,每隔 60 秒刷新,最多可以存储结果对象或列表的 512 个引用,而且返回的对象被认为是只读的
<cache eviction="FIFO" flushInterval="60000" size="512" readOnly="true"/>
可以在执行语句中使用useCache
,设置是否使用缓存
<select id="queryUserById" resultType="user" useCache="true"> select * from mybatis.user where id = #{id} </select>
- 测试
- 问题1:没有设置参数时,需要将实体类序列化
java.io.NotSerializableException: com.cha.pojo.User
总结:
- 只要开启了二级缓存,在同一个Mapper下就有效
- 所有数据都会先放在一级缓存中
- 当会话提交或关闭时,才会提交到二级缓存中
13.5 缓存原理
查询顺序:
-
先看二级缓存中有没有
-
再看一级缓存中有没有
-
查询数据库
13.6 自定义缓存
Ehcache是一种广泛使用的开源Java分布式缓存,主要面向通用缓存
使用:
-
导包
-
配置cache
<cache type="org.mybatis.caches.ehcache.EhcacheCache"/>
- 通过xml文件配置Ehcache
实际中使用redis做缓存:K-V
这篇关于Mybatis笔记的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!
- 2024-06-15matplotlib作图不显示3D图,怎么办?
- 2024-06-1503-Loki 日志监控
- 2024-06-1504-让LLM理解知识 -Prompt
- 2024-06-05做软件测试需要懂代码吗?
- 2024-06-0514-ShardingSphere的分布式主键实现
- 2024-06-03为什么以及如何要进行架构设计权衡?
- 2024-05-31全网首发第二弹!软考2024年5月《软件设计师》真题+解析+答案!(11-20题)
- 2024-05-31全网首发!软考2024年5月《软件设计师》真题+解析+答案!(21-30题)
- 2024-05-30【Java】百万数据excel导出功能如何实现
- 2024-05-30我们小公司,哪像华为一样,用得上IPD(集成产品开发)?