Mybatis
简介
MyBatis 是一款优秀的持久层框架,它支持自定义 SQL、存储过程以及高级映射。MyBatis 免除了几乎所有的 JDBC 代码以及设置参数和获取结果集的工作。MyBatis 可以通过简单的 XML 或注解来配置和映射原始类型、接口和 Java POJO(Plain Old Java Objects,普通老式 Java 对象)为数据库中的记录。
总结:
- Mybatis是一个持久层框架,与数据库打交道
- 简化了JDBC操作
- SQL和代码的分离
idea的数据库表名不提示解决方法:
效果
第一个Mybatis程序
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=UTF8
INSERT INTO `user`(`id`,`name`,`pwd`)
VALUES(1,'啦啦啦','123456'),
(2,'张三','123456'),
(3,'狂神','123456');
新建项目
-
新建一个普通的maven项目
-
删除src目录
-
导入pom依赖
<dependencies> <!-- mysql驱动--> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>5.1.47</version> </dependency> <!-- mybatis--> <!-- https://mvnrepository.com/artifact/org.mybatis/mybatis --> <dependency> <groupId>org.mybatis</groupId> <artifactId>mybatis</artifactId> <version>3.5.5</version> </dependency> <!-- junit--> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>4.12</version> </dependency> </dependencies>
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是核心配置文件--> <configuration> <!--环境配置 default属性设置默认需要使用的数据库环境--> <environments default="development"> <!--环境名 唯一标识id--> <environment id="development"> <!--默认使用的是jdbc事务管理器--> <transactionManager type="JDBC"/> <!--默认使用连接池--> <dataSource type="POOLED"> <property name="driver" value="com.mysql.jdbc.Driver"/> <property name="url" value="jdbc:mysql://localhost:3306/mybatis?useSSL=false&useUnicode=true&characterEncoding=UTF-8"/> <property name="username" value="root"/> <property name="password" value="123456"/> </dataSource> </environment> </environments> </configuration>
-
编写Mybatis工具类
public class MybatisUtils { private static SqlSessionFactory sqlSessionFactory; static{ String resource = "mybatis-config.xml"; try { //使用Mybatis获取sqlsessionfactory对象 InputStream inputStream = Resources.getResourceAsStream(resource); sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream); } catch (IOException e) { e.printStackTrace(); } } //sqlsession 是一个可以执行sql的对象 public static SqlSession getSqlsession(){ return sqlSessionFactory.openSession(); } }
3、编写代码
实体类成员变量必须与数据库字段保持一致!!!
-
创建实体类
package com.hou.pojo; 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; } }
-
Dao接口
public interface UserDao { List<User> getUserList(); }
-
接口实现类由原来的UserDaoImpl转变为了UserMapper.xml文件
-
命名空间用于绑定接口
-
resultType会自动封装结果集,所以只需要写返回值真实的类型
<?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"> <!--select查询语句--> <mapper namespace="com.hou.dao.UserDao"> <!--全限定名 写你要绑定的接口--> <select id="getUserList" resultType="com.hou.pojo.User"> <!--id:接口里的方法名 resultType:返回值类型--> select * from user </select> </mapper>
4、测试
-
核心配置文件中注册mappers (只有注册了的mapper才会生效 , 所以写完别忘了!!)
<mappers> <!--注意这里文件路径是以/分隔目录的--> <mapper resource="com/hou/dao/UserMapper.xml"/> </mappers>
-
使用Junit测试 注意:sqlsession不是线程安全的 并且用完必须关闭
@Test public void test(){ //获得sqlsession对象 SqlSession sqlsession = MybatisUtils.getSqlsession(); //执行sql UserMapper userMapper = sqlsession.getMapper(UserMapper.class); List<User> userList = userMapper.getUserList(); for (User user : userList) { System.out.println(user); } sqlsession.close(); }
Mybatis的(CRUD) 增删改查
1、namespace(命名空间) 必须全限定名 例如:com.xxx.xxx.xxx(对应接口的全限定类名)
2、增删改需要提交事务 事务默认自动开启!!!!!!!
3、select
选择 查询语句;
- id:就是对应的namespace的方法名;
- resultType:Sql语句执行的返回值类型
- parameterType:参数类型
#{} 和 ${} 的区别
1)#{} 为参数占位符 ?,即sql 预编译
2)${} 为字符串替换,即 sql 拼接
- 编写mapper接口
- 在mapper.xml中编写sql
- 测试
<select id="getUserList" resultType="com.hou.pojo.User">
select * from user
</select>
<select id="getUserByID" resultType="com.hou.pojo.User" parameterType="int">
select * from user where id = #{id}
</select>
4、insert
<insert id="addUser" parameterType="com.hou.pojo.User">
insert into user (id,name,pwd) values (#{id},#{name},#{pwd})
</insert>
5、updata
<update id="updataUser" parameterType="com.hou.pojo.User">
update user set name=#{name},pwd=#{pwd} where id = #{id};
</update>
6、delete
同上
关于一些错误
- 输出的XML文件中存在中文乱码的问题!
- maven资源无法导出问题!
- NullPointerException,没有注册资源!
万能的Map
假设我们的实体类、数据库中的表、字段、参数过多 我们应当考虑使用map
需要什么参数就往map里丢什么参数
@Test
public void addUser(){
SqlSession sqlsession = MybatisUtils.getSqlsession();
UserMapper mapper = sqlsession.getMapper(UserMapper.class);
Map<String, Object> map = new HashMap<String, Object>();
map.put("id",5);
map.put("name","啦啦啦");
map.put("pwd","222222");
mapper.addUser2(map);
sqlsession.commit();
}
<insert id="addUser2" parameterType="map">
insert into user (id,name,pwd) values (#{id},#{name},#{pwd})
</insert>
map传递参数只需要,直接在sql中写key即可!【 parameterType=“map”】
对象传递参数,直接在sql中取出对象属性即可!
只有在 只有一个参数是基本类型的情况下 可以直接在sql中取出
模糊查询的两种方式
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3qgdYyjn-1619259358443)(C:\Users\Hou\AppData\Roaming\Typora\typora-user-images\image-20200910144237480.png)]
!配置解析
核心配置文件
-
mybatis-config.xml
-
Mybatis的配置文件包含了会深深影响Mybatis行为的设置和属性信息
configuration(配置) properties(属性) settings(设置) typeAliases(类型别名) typeHandlers(类型处理器) objectFactory(对象工厂) plugins(插件) environments(环境配置) environment(环境变量) transactionManager(事务管理器) dataSource(数据源) databaseIdProvider(数据库厂商标识) mappers(映射器)
(environments)环境配置
-
MyBatis 可以配置成适应多种环境,这种机制有助于将 SQL 映射应用于多种数据库之中
-
尽管可以配置多个环境,但每个 SqlSessionFactory 实例只能选择一种环境。
-
Mybatis默认事务管理器是JDBC ,默认连接池是pooled
-
属性(properties)
- 这些属性可以在外部进行配置,并可以进行动态替换。你既可以在典型的 Java 属性文件中配置这些属性,也可以在 properties 元素的子元素中设置。
<!--引入外部文件,此后此mybatis-config.xml配置文件内就可以引用所引用文件内的属性了,此标签可以自闭合-->
<properties resource="db.properties">
<!--这里可以写一些参数-->
</properties>
-----------------------------------------------------------------------------------------------------------------------------------------
或
<properties resource="db.properties">
<property name="username" value="root"/>
<property name="password" value="123456"/>
</properties>
_________________________________________________________________________________________________________________________________________
<!--引用属性使用${}来引用,xml中表示替换拼接字符串-->
<dataSource type="POOLED">
<property name="driver" value="${driver}"/>
<property name="url" value="${url}"/>
<property name="username" value="${username}"/>
<property name="password" value="${password}"/>
</dataSource>
- 可以直接引入外部文件,如上
- 可以在其中增加一些属性配置
- 如果内部属性和外部属性有同一个字段,那么优先使用外部配置文件的,因为最先读取的是XML中的属性配置,然后会读取外部文件,所以导致外部属性会覆盖内部属性值
类型别名(typeAliases)
类型别名可为 Java 类型设置一个缩写名字。 它仅用于 XML 配置,意在降低冗余的全限定类名书写
目前有两种设置方法供选择,在实体类少的情况下建议方法一,实体类多的情况下建议方法二!
方法一:为单个实体类自定义别名
<typeAliases>
<typeAlias alias="Author" type="domain.blog.Author"/>
<typeAlias alias="Blog" type="domain.blog.Blog"/>
<typeAlias alias="Comment" type="domain.blog.Comment"/>
<typeAlias alias="Post" type="domain.blog.Post"/>
<typeAlias alias="Section" type="domain.blog.Section"/>
<typeAlias alias="Tag" type="domain.blog.Tag"/>
</typeAliases>
当这样配置时,Blog
可以用在任何使用 domain.blog.Blog
的地方。
方法二:批量设置别名
扫描包下的所有类,为它们全部起别名,没有注解的情况下,会使用 Bean 的首字母小写的非限定类名来作为它的别名。 比如 domain.blog.Author
的别名为 author
。
<typeAliases>
<package name="domain.blog"/>
</typeAliases>
若使用注解,则其别名为注解值:
@Alias("author")
public class Author {
...
}
设置(settings)
这是 MyBatis 中极为重要的调整设置,它们会改变 MyBatis 的运行时行为。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-lUTKo6jI-1619259358444)(C:\Users\Hou\AppData\Roaming\Typora\typora-user-images\image-20200910164401282.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-etfPM13t-1619259358444)(C:\Users\Hou\AppData\Roaming\Typora\typora-user-images\image-20200910164438903.png)]
映射器(mappers)
我们需要告诉 MyBatis 到哪里去找到这些语句。 在自动查找资源方面,Java 并没有提供一个很好的解决方案,所以最好的办法是直接告诉 MyBatis 到哪里去找映射文件。 你可以使用相对于类路径的资源引用,或完全限定资源定位符或类名和包名等,也就是告诉 MyBatis 去哪里找映射文件
<!-- 使用相对于类路径的资源引用 -->
<mappers>
<mapper resource="org/mybatis/builder/AuthorMapper.xml"/>
<mapper resource="org/mybatis/builder/BlogMapper.xml"/>
<mapper resource="org/mybatis/builder/PostMapper.xml"/>
</mappers>
<!-- 使用完全限定资源定位符(URL) -->
<mappers>
<mapper url="file:///var/mappers/AuthorMapper.xml"/>
<mapper url="file:///var/mappers/BlogMapper.xml"/>
<mapper url="file:///var/mappers/PostMapper.xml"/>
</mappers>
<!-- 使用映射器接口实现类的完全限定类名 -->
<mappers>
<mapper class="org.mybatis.builder.AuthorMapper"/>
<mapper class="org.mybatis.builder.BlogMapper"/>
<mapper class="org.mybatis.builder.PostMapper"/>
</mappers>
<!-- 将包内的映射器接口实现全部注册为映射器 -->
<mappers>
<package name="org.mybatis.builder"/>
</mappers>
注意:除了使用第一种方式映射 其他的方式需要注意:
- 接口和它的Mapper配置文件必须同名!
- 接口和它的Mapper配置 文件必须在同一包下!
- 想要xml和接口分离的话,就需要再resources目录下创建和接口所在的包相同的目录,并把接口对应的mapper放进去
生命周期与作用域
Mybatis流程:
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TL5gM77y-1619259358445)(C:\Users\Hou\AppData\Roaming\Typora\typora-user-images\image-20200910170901085.png)]
SqlSessionFactoryBuilder:
这个类可以被实例化、使用和丢弃,一旦创建了 SqlSessionFactory,就不再需要它了。
SqlSessionFactory:
SqlSessionFactory 一旦被创建就应该在应用的运行期间一直存在,没有任何理由丢弃它或重新创建另一个实例。 使用 SqlSessionFactory 的最佳实践是在应用运行期间不要重复创建多次,SqlSessionFactory 的最佳作用域是应用作用域,建议使用单例模式或者静态单例模式。
SqlSession:
每个线程都应该有它自己的 SqlSession 实例。SqlSession 的实例不是线程安全的,因此是不能被共享的,所以它的最佳的作用域是请求或方法作用域。
绝对不能将 SqlSession 实例的引用放在一个类的静态域,甚至一个类的实例变量也不行。 也绝不能将 SqlSession 实例的引用放在任何类型的托管作用域中
考虑将 SqlSession 放在一个和 HTTP 请求相似的作用域中。 换句话说,每次收到 HTTP 请求,就可以打开一个 SqlSession,返回一个响应后,就关闭它。
具体点击:https://mybatis.org/mybatis-3/zh/getting-started.html
如果说SqlSessionFactory相当于数据库连接池,那么SqlSession就相当于一个数据库连接(Connection对象),
你可以在一个事务里面执行多条SQL,然后通过它的commit、rollback等方法,提交或者回滚事务。所以它应该存活在一个业务请求中,
处理完整个请求后,应该关闭这条连接,让它归还给SqlSessionFactory,否则数据库资源就很快被消耗精光,系统应付瘫痪,所以用try…catch…fanally语句来保证其正确关闭。
解决属性名和字段名不一致的问题
解决方案:
方案一:在sql语句中起别名 例:user_id as id;
方案二:利用结果集映射resultMap修改映射名
column:对应数据库中的字段
property:对应实体类的属性
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4zHgS6TI-1619259358446)(C:\Users\Hou\AppData\Roaming\Typora\typora-user-images\image-20200910180720968.png)]
日志
1、日志工厂
如果一个数据库操作,出现了异常,我们需要排错,那么就需要用到日志
日志:
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FtmpxbxD-1619259358447)(C:\Users\Hou\AppData\Roaming\Typora\typora-user-images\image-20200912153705622.png)]
- SLF4J
- LOG4J 【掌握】
- LOG4J2
- JDK_LOGGING
- COMMONS_LOGGING
- STDOUT_LOGGING 【掌握】
- NO_LOGGING
在Mybatis中具体使用哪一个日志实现,在设置中设定!
STDOUT_LOGGING :标准 日志输出
配置方法:直接在配置文件中settings中配置键值对(官方文档上有)
<settings>
<setting name="logImpl" value="STDOUT_LOGGING"/>
</settings>
LOG4J :Log4j是Apache的一个开源项目
通过使用Log4j,我们可以控制日志信息输送的目的地是控制台、文件、GUI组件,甚至是套接口服务器、NT的事件记录器、UNIX Syslog守护进程等;
我们也可以控制每一条日志的输出格式
配置方法:
-
导入log4j的依赖
<!-- https://mvnrepository.com/artifact/log4j/log4j --> <dependency> <groupId>log4j</groupId> <artifactId>log4j</artifactId> <version>1.2.17</version> </dependency>
-
编写配置文件
#将等级为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/hou.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
-
在配置文件中配置设置
<settings> <setting name="logImpl" value="LOG4J"/> </settings>
-
log4j的简单使用,在程序中使用log4j进行输出日志
//注意包别导错了:org.apache.log4j.Logger 方法参数为当前类的class static Logger logger = Logger.getLogger(MyTest.class); @Test public void selectUser() { logger.info("info:进入selectUser方法"); logger.debug("debug:进入selectUser方法"); logger.error("error: 进入selectUser方法"); SqlSession session = MybatisUtils.getSession(); UserMapper mapper = session.getMapper(UserMapper.class); List<User> users = mapper.selectUser(); for (User user: users){ System.out.println(user); } session.close(); }
分页
为什么要分页?
后端做分页是为了减少数据处理量,因为如果不分页的话一下子查出所有数据对程序负担是很大的
--分页sql:
select * from user limit 起始位,结束位
步骤:
1、编写mapper.xml
<select id="selectUser" parameterType="map" resultType="user">
select * from user limit #{startIndex},#{pageSize}
</select>
2、Mapper对应接口,参数为map
//选择全部用户实现分页
List<User> selectUser(Map<String,Integer> map)
3、在测试类中传入参数测试
- 推断:起始位置 = (当前页面 - 1 ) * 页面大小
//分页查询 , 两个参数startIndex , pageSize
@Test
public void testSelectUser() {
SqlSession session = MybatisUtils.getSession();
UserMapper mapper = session.getMapper(UserMapper.class);
int currentPage = 1; //第几页
int pageSize = 2; //每页显示几个
Map<String,Integer> map = new HashMap<String,Integer>();
map.put("startIndex",(currentPage-1)*pageSize);
map.put("pageSize",pageSize);
List<User> users = mapper.selectUser(map);
for (User user: users){
System.out.println(user);
}
session.close();
}
使用注解开发
利用注解开发
-
mybatis最初配置信息是基于 XML ,映射语句(SQL)也是定义在 XML 中的。而到MyBatis 3提供了新的基于注解的配置。不幸的是,Java 注解的的表达力和灵活性十分有限。最强大的 MyBatis 映射并不能用注解来构建
-
sql 类型主要分成 :
-
- @select ()
- @update ()
- @Insert ()
- @delete ()
**注意:**利用注解开发就不需要mapper.xml映射文件了 .
1、我们在我们的接口中添加注解
//查询全部用户
@Select("select id,name,pwd password from user")
public List<User> getAllUser();
2、在mybatis的核心配置文件中注入
<!--使用class绑定接口-->
<mappers>
<mapper class="com.kuang.mapper.UserMapper"/>
</mappers>
3、我们去进行测试
@Test
public void testGetAllUser() {
SqlSession session = MybatisUtils.getSession();
//本质上利用了jvm的动态代理机制
UserMapper mapper = session.getMapper(UserMapper.class);
List<User> users = mapper.getAllUser();
for (User user : users){
System.out.println(user);
}
session.close();
}
4、利用Debug查看本质
5、本质上利用了jvm的动态代理机制
6、Mybatis详细的执行流程
注解增删改
改造MybatisUtils工具类的getSession( ) 方法,重载实现。
//获取SqlSession连接
public static SqlSession getSession(){
return getSession(true); //事务自动提交
}
public static SqlSession getSession(boolean flag){
return sqlSessionFactory.openSession(flag);
}
【注意】确保实体类和数据库字段对应
查询:
1、编写接口方法注解
//根据id查询用户
@Select("select * from user where id = #{id}")
User selectUserById(@Param("id") int id);
2、测试
@Test
public void testSelectUserById() {
SqlSession session = MybatisUtils.getSession();
UserMapper mapper = session.getMapper(UserMapper.class);
User user = mapper.selectUserById(1);
System.out.println(user);
session.close();
}
新增:
1、编写接口方法注解
//添加一个用户
@Insert("insert into user (id,name,pwd) values (#{id},#{name},#{pwd})")
int addUser(User user);
2、测试
@Test
public void testAddUser() {
SqlSession session = MybatisUtils.getSession();
UserMapper mapper = session.getMapper(UserMapper.class);
User user = new User(6, "秦疆", "123456");
mapper.addUser(user);
session.close();
}
修改:
1、编写接口方法注解
//修改一个用户
@Update("update user set name=#{name},pwd=#{pwd} where id = #{id}")
int updateUser(User user);
2、测试
@Test
public void testUpdateUser() {
SqlSession session = MybatisUtils.getSession();
UserMapper mapper = session.getMapper(UserMapper.class);
User user = new User(6, "秦疆", "zxcvbn");
mapper.updateUser(user);
session.close();
}
删除:
1、编写接口方法注解
//根据id删除用
@Delete("delete from user where id = #{id}")
int deleteUser(@Param("id")int id);
2、测试
@Test
public void testDeleteUser() {
SqlSession session = MybatisUtils.getSession();
UserMapper mapper = session.getMapper(UserMapper.class);
mapper.deleteUser(6);
session.close();
}
【注意点:增删改一定记得对事务的处理】
关于@Param
@Param注解用于给方法参数起一个名字。以下是总结的使用原则:
- 在方法只接受一个参数的情况下,可以不使用@Param。
- 在方法接受多个参数的情况下,建议一定要使用@Param注解给参数命名。
- 如果参数是 JavaBean , 则不能使用@Param。
- 不使用@Param注解时,参数只能有一个,并且是Javabean。
#与$的区别
-
#{} 的作用主要是替换预编译语句(PrepareStatement)中的占位符? 【推荐使用,有防止sql注入的特性】
INSERT INTO user (name) VALUES (#{name}); INSERT INTO user (name) VALUES (?);
-
${} 的作用是直接进行字符串替换
INSERT INTO user (name) VALUES ('${name}'); INSERT INTO user (name) VALUES ('kuangshen');
使用注解和配置文件协同开发,才是MyBatis的最佳实践!
lombook插件的使用
懒,是科技进步的阶梯(手动滑稽)
使用步骤:
-
在IDEA中安装Lombok插件!
-
在项目中导入lombok的jar包
<dependency> <groupId>org.projectlombok</groupId> <artifactId>lombok</artifactId> <version>1.18.10</version> </dependency>
-
在实体类上加注解即可!
@Data @AllArgsConstructor @NoArgsConstructor
@Getter and @Setter
@FieldNameConstants
@ToString
@EqualsAndHashCode
@AllArgsConstructor, @RequiredArgsConstructor and @NoArgsConstructor
@Log, @Log4j, @Log4j2, @Slf4j, @XSlf4j, @CommonsLog, @JBossLog, @Flogger
@Data
@Builder
@Singular
@Delegate
@Value
@Accessors
@Wither
@SneakyThrows
说明:
@Data:生成:无参构造,get、set、tostring、hashcode,equals
@AllArgsConstructor:生成:有参构造,不过相应的,无参构造就没了
@NoArgsConstructor:生成:无参构造,可以配合上面那个AllArgsConstructor使用,这样无参有参俩都有
@EqualsAndHashCode
@ToString
@Getter
使用需谨慎,有时候使用的时候会有一些莫名其妙的bug
多对一处理
多对一:
- 多个学生,对应一个老师
- 对于学生这边而言, 关联 … 多个学生,关联一个老师 【多对一】
- 对于老师而言, 集合 , 一个老师,有很多学生 【一对多】
需求:查找所有学生,并根据学生表中的外键tid查询出学生对应的老师
SQL:
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');
嵌套查询
思路:
- 查询所有的学生信息
- 根据查询出的学生的tid,再查对应的老师
<mapper namespace="com.hou.dao.StudentMapper">
<select id="getStudent" resultMap="StudentTeacher">
select * from mybatis.student
</select>
<resultMap id="StudentTeacher" type="com.hou.pojo.Student">
<result property="id" column="id"/>
<result property="name" column="name"/>
<!--
复杂的属性需要单独处理
如果是对象:用association
如果是集合:用collection
-->
<association property="teacher" column="tid" javaType="com.hou.pojo.Teacher" select="getTeacher"/>
</resultMap>
<select id="getTeacher" resultType="com.hou.pojo.Teacher">
select * from mybatis.teacher where id = #{tid}
</select>
</mapper>
理解:
-
首先查询所有的学生表信息,其中就包括字段tid
-
再嵌套查询,使用(关联)去关联查询一段查询select
-
在子查询中跟据查出的tid去查找对应的老师!
-
这里在getTeacher查询语句中 传入的参数就是查询出的学生信息中的tid,因为只有一个参数 它会自动匹配获取
结果查询(推荐)
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-kFHiY2IK-1619259358449)(C:\Users\Hou\AppData\Roaming\Typora\typora-user-images\image-20200915182233355.png)]
一对多处理
需求:查出老师及老师名下的学生信息!
一个老师拥有多个学生,对老师而言就是一对多的关系!
单个对象用 :javaType指定属性的类型
集合用conllection : ofTepe属性指定集合的泛型
但都是用于复杂环境查询
方法1、结果查询
public class Teacher {
private int id;
private String name;
//老师名下的学生
private List<Student> students;
}
//获取指定老师下的所有学生,及老师的信息
Teacher getTeacher(@Param("tid") int id);
<select id="getTeacher" resultMap="TeacherStudent">
select s.id sid,s.name sname,t.id tid,t.name tname from mybatis.student s,mybatis.teacher t
where s.tid=t.id and t.id = #{tid}
</select>
<!---->
<resultMap id="TeacherStudent" type="com.hou.pojo.Teacher">
<result property="id" column="tid"/>
<result property="name" column="tname"/>
<collection property="students" ofType="com.hou.pojo.Student">
<result property="id" column="sid"/>
<result property="name" column="sname"/>
<result property="tid" column="tid"/>
</collection>
</resultMap>
测试:
@Test
public void test(){
SqlSession sqlsession = MybatisUtils.getSqlsession();
TeacherMapper mapper = sqlsession.getMapper(TeacherMapper.class);
Teacher teacher = mapper.getTeacher(3);
System.out.println(teacher);
sqlsession.commit();
sqlsession.close();
}
//测试结果
Teacher(id=3, name=张老师, students=[Student(id=3, name=小张, tid=3), Student(id=5, name=小王, tid=3)])
2、查询嵌套
按查询嵌套处理
1、TeacherMapper接口编写方法
public Teacher getTeacher2(int id);
2、编写接口对应的Mapper配置文件
<select id="getTeacher2" resultMap="TeacherStudent2">
select * from teacher where id = #{id}
</select>
<resultMap id="TeacherStudent2" type="Teacher">
<!--column是一对多的外键 , 写的是一的主键的列名-->
<collection property="students" javaType="ArrayList" ofType="Student"column="id" select="getStudentByTeacherId"/>
</resultMap>
<select id="getStudentByTeacherId" resultType="Student">
select * from student where tid = #{id}
</select>
3、将Mapper文件注册到MyBatis-config文件中
4、测试
@Test
public void testGetTeacher2(){
SqlSession session = MybatisUtils.getSession();
TeacherMapper mapper = session.getMapper(TeacherMapper.class);
Teacher teacher = mapper.getTeacher2(1);
System.out.println(teacher.getName());
System.out.println(teacher.getStudents());
}
小结
1、关联-association
2、集合-collection
3、所以association是用于一对一和多对一,而collection是用于一对多的关系
4、JavaType和ofType都是用来指定对象类型的
- JavaType是用来指定pojo中属性的类型
- ofType指定的是映射到list集合属性中pojo的类型,泛型中约束的类型。
注意说明:
1、保证SQL的可读性,尽量通俗易懂
2、根据实际要求,尽量编写性能更高的SQL语句
3、注意属性名和字段不一致的问题
4、注意一对多和多对一 中:字段和属性对应的问题
5、尽量使用Log4j,通过日志来查看自己的错误
动态Sql
什么是动态SQL:动态SQL就是指根据不同的条件生成不同的SQL语句
介绍
什么是动态SQL:动态SQL指的是根据不同的查询条件 , 生成不同的Sql语句.
官网描述:
MyBatis 的强大特性之一便是它的动态 SQL。如果你有使用 JDBC 或其它类似框架的经验,你就能体会到根据不同条件拼接 SQL 语句的痛苦。例如拼接时要确保不能忘记添加必要的空格,还要注意去掉列表最后一个列名的逗号。利用动态 SQL 这一特性可以彻底摆脱这种痛苦。
虽然在以前使用动态 SQL 并非一件易事,但正是 MyBatis 提供了可以被用在任意 SQL 映射语句中的强大的动态 SQL 语言得以改进这种情形。
动态 SQL 元素和 JSTL 或基于类似 XML 的文本处理器相似。在 MyBatis 之前的版本中,有很多元素需要花时间了解。MyBatis 3 大大精简了元素种类,现在只需学习原来一半的元素便可。MyBatis 采用功能强大的基于 OGNL 的表达式来淘汰其它大部分元素。
-------------------------------
- if
- choose (when, otherwise)
- trim (where, set)
- foreach
-------------------------------
我们之前写的 SQL 语句都比较简单,如果有比较复杂的业务,我们需要写复杂的 SQL 语句,往往需要拼接,而拼接 SQL ,稍微不注意,由于引号,空格等缺失可能都会导致错误。
那么怎么去解决这个问题呢?这就要使用 mybatis 动态SQL,通过 if, choose, when, otherwise, trim, where, set, foreach等标签,可组合成非常灵活的SQL语句,从而在提高 SQL 语句的准确性的同时,也大大提高了开发人员的效率。
1、搭建环境
新建一个数据库表:blog
字段:id,title,author,create_time,views
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
1、创建Mybatis基础工程
2、IDutil工具类
public class IDUtil {
public static String genId(){
return UUID.randomUUID().toString().replaceAll("-","");
}
}
3、实体类编写 【注意set方法作用】
import java.util.Date;
public class Blog {
private String id;
private String title;
private String author;
private Date createTime;
private int views;
//set,get....
}
4、编写Mapper接口及xml文件
public interface BlogMapper {
}
<?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.kuang.mapper.BlogMapper">
</mapper>
5、mybatis核心配置文件,下划线驼峰自动转换
<settings>
<setting name="mapUnderscoreToCamelCase" value="true"/>
<setting name="logImpl" value="STDOUT_LOGGING"/>
</settings>
<!--注册Mapper.xml-->
<mappers>
<mapper resource="mapper/BlogMapper.xml"/>
</mappers>
6、插入初始数据
编写接口
//新增一个博客
int addBlog(Blog blog);
sql配置文件
<insert id="addBlog" parameterType="blog">
insert into blog (id, title, author, create_time, views)
values (#{id},#{title},#{author},#{createTime},#{views});
</insert>
初始化博客方法
@Test
public void addInitBlog(){
SqlSession session = MybatisUtils.getSession();
BlogMapper mapper = session.getMapper(BlogMapper.class);
Blog blog = new Blog();
blog.setId(IDUtil.genId());
blog.setTitle("Mybatis如此简单");
blog.setAuthor("狂神说");
blog.setCreateTime(new Date());
blog.setViews(9999);
mapper.addBlog(blog);
blog.setId(IDUtil.genId());
blog.setTitle("Java如此简单");
mapper.addBlog(blog);
blog.setId(IDUtil.genId());
blog.setTitle("Spring如此简单");
mapper.addBlog(blog);
blog.setId(IDUtil.genId());
blog.setTitle("微服务如此简单");
mapper.addBlog(blog);
session.close();
}
初始化数据完毕!
2、if 语句
需求:根据作者名字和博客名字来查询博客!如果作者名字为空,那么只根据博客名字查询,反之,则根据作者名来查询
1、编写接口类
//需求1
List<Blog> queryBlogIf(Map map);
2、编写SQL语句
<!--需求1:
根据作者名字和博客名字来查询博客!
如果作者名字为空,那么只根据博客名字查询,反之,则根据作者名来查询,都没有则查询全部
select * from blog where title = #{title} and author = #{author}
-->
<select id="queryBlogIf" parameterType="map" resultType="blog">
select * from blog where 1=1
<if test="title != null">
and title = #{title}
</if>
<if test="author != null">
and author = #{author}
</if>
</select>
3、测试
@Test
public void testQueryBlogIf(){
SqlSession session = MybatisUtils.getSession();
BlogMapper mapper = session.getMapper(BlogMapper.class);
HashMap<String, String> map = new HashMap<String, String>();
map.put("title","Mybatis如此简单");
map.put("author","狂神说");
List<Blog> blogs = mapper.queryBlogIf(map);
System.out.println(blogs);
session.close();
}
这样写我们可以看到,当不写恒等式1=1的话,如果 author 等于 null,那么查询语句为 select * from user where title=#{title},但是如果title为空呢?那么查询语句为 select * from user where and author=#{author},这是错误的 SQL 语句,如何解决呢?请看下面的 where 语句!
Where
修改上面的SQL语句;
<select id="queryBlogIf" parameterType="map" resultType="blog">
select * from blog
<where>
<if test="title != null">
title = #{title}
</if>
<if test="author != null">
and author = #{author}
</if>
</where>
</select>
这个“where”标签会知道如果它包含的标签中有返回值的话,它就插入一个‘where’。此外,如果标签返回的内容是以AND 或OR 开头的,则它会剔除掉。
3、set语句
同理,上面的对于查询 SQL 语句包含 where 关键字,如果在进行更新操作的时候,含有 set 关键词,我们怎么处理呢?
1、编写接口方法
int updateBlog(Map map);
2、sql配置文件
<!--注意set是用的逗号隔开-->
<update id="updateBlog" parameterType="map">
update blog
<set>
<if test="title != null">
title = #{title},
</if>
<if test="author != null">
author = #{author}
</if>
</set>
where id = #{id};
</update>
3、测试
@Test
public void testUpdateBlog(){
SqlSession session = MybatisUtils.getSession();
BlogMapper mapper = session.getMapper(BlogMapper.class);
HashMap<String, String> map = new HashMap<String, String>();
map.put("title","动态SQL");
map.put("author","秦疆");
map.put("id","9d6a763f5e1347cebda43e2a32687a77");
mapper.updateBlog(map);
session.close();
}
4、choose语句
有时候,我们不想用到所有的查询条件,只想选择其中的一个,查询条件有一个满足即可,使用 choose 标签可以解决此类问题,类似于 Java 的 switch 语句
1、编写接口方法
List<Blog> queryBlogChoose(Map map);
2、sql配置文件
<select id="queryBlogChoose" parameterType="map" resultType="blog">
select * from blog
<where>
<choose>
<when test="title != null">
title = #{title}
</when>
<when test="author != null">
and author = #{author}
</when>
<otherwise>
and views = #{views}
</otherwise>
</choose>
</where>
</select>
3、测试类
@Test
public void testQueryBlogChoose(){
SqlSession session = MybatisUtils.getSession();
BlogMapper mapper = session.getMapper(BlogMapper.class);
HashMap<String, Object> map = new HashMap<String, Object>();
map.put("title","Java如此简单");
map.put("author","狂神说");
map.put("views",9999);
List<Blog> blogs = mapper.queryBlogChoose(map);
System.out.println(blogs);
session.close();
}
5、SQL片段
有时候可能某个 sql 语句我们用的特别多,为了增加代码的重用性,简化代码,我们需要将这些代码抽取出来,然后使用时直接调用。
提取SQL片段:
<sql id="if-title-author">
<if test="title != null">
title = #{title}
</if>
<if test="author != null">
and author = #{author}
</if>
</sql>
引用SQL片段:
<select id="queryBlogIf" parameterType="map" resultType="blog">
select * from blog
<where>
<!-- 引用 sql 片段,如果refid 指定的不在本文件中,那么需要在前面加上 namespace -->
<include refid="if-title-author"></include>
<!-- 在这里还可以引用其他的 sql 片段 -->
</where>
</select>
注意:
①、最好基于 单表来定义 sql 片段,提高片段的可重用性
②、在 sql 片段中不要包括 where
6、Foreach
将数据库中前三个数据的id修改为1,2,3;
需求:我们需要查询 blog 表中 id 分别为1,2,3的博客信息
1、编写接口
List<Blog> queryBlogForeach(Map map);
2、编写SQL语句
<select id="queryBlogForeach" parameterType="map" resultType="blog">
select * from blog
<where>
<!--
collection:指定输入对象中的集合属性
item:每次遍历生成的对象
open:开始遍历时的拼接字符串
close:结束时拼接的字符串
separator:遍历对象之间需要拼接的字符串
select * from blog where 1=1 and (id=1 or id=2 or id=3)
-->
<foreach collection="ids" item="id" open="and (" close=")" separator="or">
id=#{id}
</foreach>
</where>
</select>
3、测试
@Test
public void testQueryBlogForeach(){
SqlSession session = MybatisUtils.getSession();
BlogMapper mapper = session.getMapper(BlogMapper.class);
HashMap map = new HashMap();
List<Integer> ids = new ArrayList<Integer>();
ids.add(1);
ids.add(2);
ids.add(3);
map.put("ids",ids);
List<Blog> blogs = mapper.queryBlogForeach(map);
System.out.println(blogs);
session.close();
}
小结:其实动态 sql 语句的编写往往就是一个拼接的问题,为了保证拼接准确,我们最好首先要写原生的 sql 语句出来,然后在通过 mybatis 动态sql 对照着改,防止出错。多在实践中使用才是熟练掌握它的技巧。
-
在mybatis里如果有多种参数,那么就应该加上@param注解,为参数命名,而后如果有参数是引用对象,想在xml里使用它的属性,那么应该使用
参数名.属性名:如下:
public int modifyUser(@Param("user")User user,@Param("id")int id);
<update id="modifyUser"> update smbms.smbms_user <set> <if test="user.userName !=null and user.userName != ''">userName = #{user.userName},</if> <if test="user.userRole != null and user.userRole !=''">userRole = #{user.userRole},</if> <if test="user.gender != null and user.gender != ''">gender = #{user.gender},</if> <if test="user.birthday != null">birthday = #{user.birthday},</if> <if test="user.phone != null and user.phone != ''">phone = #{user.phone},</if> <if test="user.address != null and user.address != ''">address = #{user.address},</if> <if test="user.modifyBy != null and user.modifyBy !=''">modifyBy = #{user.modifyBy},</if> <if test="user.modifyDate != null">modifyDate = #{user.modifyDate}</if> </set> where id = #{id} </update>
动态SQL在开发中大量的使用,一定要熟练掌握!
缓存
简介
- 什么是缓存(Cache)?
- 存在内存中的临时数据
- 将用户经常查询的数据放在缓存中,用户去查询数据就不用从磁盘上(关系型数据库数据文件)查询,而从缓存中查询,从而提高查询效率,解决了高并发系统的性能问题。
- 为何使用缓存
- 减少和数据库的交互次数,减少系统开销,提高系统效率
- 什么样的数据能使用缓存
- 经常查询并且不经常改变的数据。
1. mybatis缓存
- Mybatis包含非常强大的查询缓存特性,它可以非常方便的定制和配置缓存。缓存可以极大的提升查询效率。
- Mybatis系统默认提供了两级缓存:一级缓存和二级缓存
- 默认情况下,只有一级缓存开启。(sqlSession级别的缓存,也称本地缓存)
- 二级缓存需要手动开启和配置,他是基于namespace级别的缓存。
- 为了提高扩展性,MyBatis定义了缓存接口Cache。我们可以通过实现Cache接口自定义二级缓存
缓存:
-
映射语句文件中的所有 select 语句的结果将会被缓存。
-
映射语句文件中的所有 insert、update 和 delete 语句会刷新缓存。(因为可能会改变原来的数据,所以会刷新整个缓存~)
-
缓存会使用最近最少使用算法(LRU, Least Recently Used)算法来清除不需要的缓存。
-
缓存不会定时进行刷新(也就是说,没有刷新间隔)。
-
缓存会保存列表或对象(无论查询方法返回哪种)的 1024 个引用。
-
缓存会被视为读/写缓存,这意味着获取到的对象并不是共享的,可以安全地被调用者修改,而不干扰其他调用者或线程所做的潜在修改。
2. 一级缓存
每当我们使用MyBatis开启一次和数据库的会话,MyBatis会创建出一个SqlSession对象表示一次数据库会话。
在对数据库的一次会话中,我们有可能会反复地执行完全相同的查询语句,如果不采取一些措施的话,每一次查询都会查询一次数据库,而我们在极短的时间 内做了完全相同的查询,那么它们的结果极有可能完全相同,由于查询一次数据库的代价很大,这有可能造成很大的资源浪费。
为了解决这一问题,减少资源的浪费,MyBatis会在表示会话的SqlSession对象中建立一个简单的缓存,将每次查询到的结果结果缓存起来,当下次查询的时 候,如果判断先前有个完全一样的查询,会直接从缓存中直接将结果取出,返回给用户,不需要再进行一次数据库查询了。
如下图所示,MyBatis会在一次会话的表示----一个SqlSession对象中创建一个本地缓存(local cache),对于每一次查询,都会尝试根据查询的条件去本地缓存 中查找是否在缓存中,如果在缓存中,就直接从缓存中取出,然后返回给用户;否则,从数据库读取数据,将查询结果存入缓存并返回给用户。
对于会话(Session)级别的数据缓存,我们称之为一级数据缓存,简称一级缓存
一级缓存默认是开启的,只在一次sqlSession中有效,也就是拿到连接到关闭这个区间段。
一级缓存可以手动清理缓存:sqlSession.clearCache();
3. 二级缓存
-
二级缓存是全局缓存,因为一级缓存的作用域太低了,所以诞生了二级缓存
-
基于namespace级别的缓存,一个命名空间,对应一个二级缓存
-
工作机制:
- 一个会话查询一条语句,这个数据就会被放在当前会话的一级缓存中;
- 如果当前会话关闭了,这个会话对应的一级缓存就没了;但是我们想要的是,会话关闭了,一级缓存中的数据会被保存到二级缓存中;也就是一级缓存失效后,缓存内容才会从一级缓存交付给二级缓存。
- 新的会话查询信息,就可以从二级缓存中获取内容;
- 不同的mapper查出的数据会放在自己对应的缓存(map)中;
步骤:
-
开启全局缓存
<!--显示开启二级全局缓存--> <setting name="cacheEnabled" value="true"/>
-
在mapper.xml中使用二级缓存
<!--使用二级缓存--> <cache/>
cache的这些属性可以通过 cache 元素的属性来修改。比如:
<cache eviction="FIFO" flushInterval="60000" size="512" readOnly="true"/>
这个更高级的配置创建了一个 FIFO 缓存,每隔 60 秒刷新,最多可以存储结果对象或列表的 512 个引用,而且返回的对象被认为是只读的,因此对它们进行修改可能会在不同线程中的调用者产生冲突。
可用的清除策略有:
LRU
– 最近最少使用:移除最长时间不被使用的对象。FIFO
– 先进先出:按对象进入缓存的顺序来移除它们。SOFT
– 软引用:基于垃圾回收器状态和软引用规则移除对象。WEAK
– 弱引用:更积极地基于垃圾收集器状态和弱引用规则移除对象。
默认的清除策略是 LRU。
flushInterval(刷新间隔)属性可以被设置为任意的正整数,设置的值应该是一个以毫秒为单位的合理时间量。 默认情况是不设置,也就是没有刷新间隔,缓存仅仅会在调用语句时刷新。
size(引用数目)属性可以被设置为任意正整数,要注意欲缓存对象的大小和运行环境中可用的内存资源。默认值是 1024。
readOnly(只读)属性可以被设置为 true 或 false。只读的缓存会给所有调用者返回缓存对象的相同实例。 因此这些对象不能被修改。这就提供了可观的性能提升。而可读写的缓存会(通过序列化)返回缓存对象的拷贝。 速度上会慢一些,但是更安全,因此默认值是 false。
提示 二级缓存是事务性的。这意味着,当 SqlSession 完成并提交时,或是完成并回滚,但没有执行 flushCache=true 的 insert/delete/update 语句时,缓存会获得更新。
-
总结:
- 只要开启了二级缓存,在同一个Mapper下就有效
MyBatis的二级缓存是Application级别的缓存,它可以提高对数据库查询的效率,以提高应用的性能。
可以看看博客:https://louluan.blog.csdn.net/article/details/41408341
ps://img-blog.csdn.net/20141121213425390)
对于会话(Session)级别的数据缓存,我们称之为一级数据缓存,简称一级缓存
一级缓存默认是开启的,只在一次sqlSession中有效,也就是拿到连接到关闭这个区间段。
一级缓存可以手动清理缓存:sqlSession.clearCache();
3. 二级缓存
-
二级缓存是全局缓存,因为一级缓存的作用域太低了,所以诞生了二级缓存
-
基于namespace级别的缓存,一个命名空间,对应一个二级缓存
-
工作机制:
- 一个会话查询一条语句,这个数据就会被放在当前会话的一级缓存中;
- 如果当前会话关闭了,这个会话对应的一级缓存就没了;但是我们想要的是,会话关闭了,一级缓存中的数据会被保存到二级缓存中;也就是一级缓存失效后,缓存内容才会从一级缓存交付给二级缓存。
- 新的会话查询信息,就可以从二级缓存中获取内容;
- 不同的mapper查出的数据会放在自己对应的缓存(map)中;
步骤:
-
开启全局缓存
<!--显示开启二级全局缓存--> <setting name="cacheEnabled" value="true"/>
-
在mapper.xml中使用二级缓存
<!--使用二级缓存--> <cache/>
cache的这些属性可以通过 cache 元素的属性来修改。比如:
<cache eviction="FIFO" flushInterval="60000" size="512" readOnly="true"/>
这个更高级的配置创建了一个 FIFO 缓存,每隔 60 秒刷新,最多可以存储结果对象或列表的 512 个引用,而且返回的对象被认为是只读的,因此对它们进行修改可能会在不同线程中的调用者产生冲突。
可用的清除策略有:
LRU
– 最近最少使用:移除最长时间不被使用的对象。FIFO
– 先进先出:按对象进入缓存的顺序来移除它们。SOFT
– 软引用:基于垃圾回收器状态和软引用规则移除对象。WEAK
– 弱引用:更积极地基于垃圾收集器状态和弱引用规则移除对象。
默认的清除策略是 LRU。
flushInterval(刷新间隔)属性可以被设置为任意的正整数,设置的值应该是一个以毫秒为单位的合理时间量。 默认情况是不设置,也就是没有刷新间隔,缓存仅仅会在调用语句时刷新。
size(引用数目)属性可以被设置为任意正整数,要注意欲缓存对象的大小和运行环境中可用的内存资源。默认值是 1024。
readOnly(只读)属性可以被设置为 true 或 false。只读的缓存会给所有调用者返回缓存对象的相同实例。 因此这些对象不能被修改。这就提供了可观的性能提升。而可读写的缓存会(通过序列化)返回缓存对象的拷贝。 速度上会慢一些,但是更安全,因此默认值是 false。
提示 二级缓存是事务性的。这意味着,当 SqlSession 完成并提交时,或是完成并回滚,但没有执行 flushCache=true 的 insert/delete/update 语句时,缓存会获得更新。
-
总结:
- 只要开启了二级缓存,在同一个Mapper下就有效
MyBatis的二级缓存是Application级别的缓存,它可以提高对数据库查询的效率,以提高应用的性能。
可以看看博客:https://louluan.blog.csdn.net/article/details/41408341
本文部分引用引用自狂神 ,还有一些其他的博客的东西,可能有点乱