环境:
回顾:
Mybatis中文文档:https://mybatis.net.cn/
获得maven:
<!-- https://mvnrepository.com/artifact/org.mybatis/mybatis --> <dependency> <groupId>org.mybatis</groupId> <artifactId>mybatis</artifactId> <version>3.5.10</version> </dependency>
数据持久化:
为什么需要持久化:
Dao层、Service层、Controller层……
持久层:
思路:搭建环境 -> 导入Mybatis -> 编写代码 -> 测试
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')
<?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>
<?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(); } }
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 + '\'' + '}'; } }
public interface UserDao { List<User> getUserList(); }
<?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>
测试类写在测试文件夹下:
注意点:
org.apache.ibatis.binding.BindingException: Type interface com.cha.dao.UserDao is not known to the MapperRegistry.
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(); } }
可能存在问题:
namespace中的包名要和Dao/Mapper接口的包名一致
选择,查询语句
实现:
// 根据ID查询用户 // 接口中的方法原本需要依靠实现类实现,在此处通过补充标签实现 User getUserById(int i);
#{类型}
传递参数<!--传递变量--> <select id="getUserById" parameterType="int" resultType="com.cha.pojo.User"> select * from mybatis.user where id = #{id} </select>
@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(); }
<!--对象中的属性可以直接取出--> <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(); }
<update id="updateUser" parameterType="com.cha.pojo.User"> update mybatis.user set name=#{name}, pwd=#{pwd} where id=#{id}; </update>
<delete id="deleteUser" parameterType="int"> delete from mybatis.user where id = #{id} </delete>
在实体类或数据库中的表的字段或参数过多时,应该考虑使用Map
但不易维护,应该有替代方法
// 万能Map int addUser2(Map<String, Object> 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或注解
%
List<User> users = mapper.getUserLike("%A%")
${}
进行查询时会存在sql注入问题)select * from mybatis.user where name like "%"#{value}"%";
mybatis-config.xml
:
MyBatis 可以配置成适应多种环境
不过要记住:尽管可以配置多个环境,但每个 SqlSessionFactory 实例只能选择一种环境。
可以配置多套运行环境:
这些属性可以在外部进行配置,并可以进行动态替换。既可以在典型的 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>
typeAliases需要写在第三的位置:仅在set和properties之后
作用:
给实体类起别名:实体类较少时
<!--可以给实体类起别名--> <typeAliases> <typeAlias type="com.cha.pojo.User" alias="User"/> </typeAliases>
<typeAliases> <package name="com.cha.pojo"/> </typeAliases>
区别:
@Alias("user") public class User{}
设置名 | 描述 | 有效值 |
---|---|---|
logImpl | 指定 MyBatis 所用日志的具体实现,未指定时将自动查找。 | SLF4J | LOG4J | LOG4J2 | JDK_LOGGING | COMMONS_LOGGING | STDOUT_LOGGING | NO_LOGGING |
cacheEnabled | 全局性地开启或关闭所有映射器配置文件中已配置的任何缓存。 | true | false |
lazyLoadingEnabled | 延迟加载的全局开关。当开启时,所有关联对象都会延迟加载。 特定关联关系中可通过设置 fetchType 属性来覆盖该项的开关状态。 |
true | false |
MapperRegisrty:注册绑定Mapper文件
<mappers> <mapper resource="com/cha/dao/UserMapper.xml"/> </mappers>
<mappers> <mapper class="com.cha.dao.UserMapper"/> </mappers>
<mappers> <package name="com.cha.dao"/> </mappers>
共同的注意点:
不同作用域和生命周期类别是至关重要的,因为错误的使用会导致非常严重的并发问题。
数据库中的字段和测试实体类中的字段不同时,测试获取不到数据
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>
仅需要映射不同的的内容
<!--使用结果集映射--> <!--返回值类型的映射--> <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
的优秀之处:完全可以不用显式地配置在数据库操作出现异常时,通过日志工厂排错
设置名 | 描述 | 有效值 |
---|---|---|
logImpl | 指定 MyBatis 所用日志的具体实现,未指定时将自动查找。 | SLF4J | LOG4J | LOG4J2 | JDK_LOGGING | COMMONS_LOGGING | STDOUT_LOGGING | NO_LOGGING |
mybatis中使用哪个日志,由设置决定
<settings> <setting name="logImpl" value="STDOUT_LOGGING"/> </settings>
最新版本的mybatis的log4j已过时
log4j简介:
1.导入包
<!-- 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/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
<settings> <setting name="logImpl" value="LOG4J"/> </settings>
直接运行
static Logger logger = Logger.getLogger(UserMapperTest.class)
logger.info("info:xxxx") logger.debug("debug:xxxx") logger.error("error:xxxx")
为什么需要分页?
使用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);
<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(); }
其他跳过了
关于接口的理解
三个面向区别
public interface UserMapper { @Select("select * from user") List<User> getUsers(); }
<!--绑定接口--> <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(); }
将工具类中获取SqlSession的参数设置为true,会自动提交事务
尽量不要设置自动提交,避免代码出现问题
// 有了 SqlSessionFactory,我们可以从中获得 SqlSession 的实例 // SqlSession 提供了在数据库执行 SQL 命令所需的所有方法 public static SqlSession getSqlSession() { // 将此处的参数设置为true后会自动提交事务,无需再手动进行提交 return sqlSessionFactory.openSession(true); }
需要将接口注册绑定到核心配置文件中,才能使用注解开发
@Select("select * from user where id = #{id}") User getUserById(@Param("id") int id2);
注意:
@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 user set name=#{name},pwd=#{pwd} where id=#{id}") int updateUser(User user);
@Delete("delete from user where id=#{uid}") int deleteUser(@Param("uid") int id);
不建议使用,看公司用不用
自动生成get\set,日志工具的插件。
使用步骤:
<!-- 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 // 无参构造
缺点:
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');
public class Student { private int id; private String name; // 令学生关联一个老师 private Teacher teacher; }
/
分隔),创建对应的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(); }
<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>
<!--思路: 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>
类似联表查询
<!--按照结果嵌套查询--> <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>
一个老师有多个学生
修改实体类:
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; }
<!--根据结果嵌套查询--> <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>
<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>
什么是动态sql:根据不同的条件生成不同的sql语句
MyBatis精简了元素,基于OGNL的表达式淘汰大部分元素
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; }
开启驼峰命名自动映射,将下划线转换为驼峰命名
<setting name="mapUnderscoreToCamelCase" value="true"/>
在xml文件中仍要注意into
和values
中值的对应。
使用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>
类似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>
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 关键字,并会删掉额外的逗号
会自动删除语句末尾的逗号,记得在语句后添加逗号,
!
<!--返回类型为基本参数,可以不写--> <!--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 元素的功能
<trim prefix="WHERE" prefixOverrides="AND |OR "> ... </trim>
prefixOverrides 属性会忽略通过管道符分隔的文本序列(注意此例中的空格是必要的)。上述例子会移除所有 prefixOverrides 属性中指定的内容,并且插入 prefix 属性中指定的内容。
覆盖了后缀值设置,并且自定义了前缀值,移除所有 suffixOverrides 属性中指定的内容
<trim prefix="SET" suffixOverrides=","> ... </trim>
动态sql的本质仍是sql语句,不同之处是可以在sql层面执行代码逻辑
有时候将一些公共的部分抽取出来,以供代码复用
<sql id="if-title-author"> <if test="title != null"> and title = #{title} </if> <if test="author != null"> and author = #{author} </if> </sql>
<select id="queryBlog" parameterType="map" resultType="blog"> select * from mybatis.blog <where> <include refid="if-title-author"/> </where> </select>
注意:
<where>
标签对集合进行遍历(尤其是在构建 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语句,再根据语句进行拼接
查询操作:连接数据库,资源消耗大
解决方法:将查询的结果暂存在可以直接获取的地方 -> 放在内存中,也就是缓存
当再次查询相同数据时,直接通过缓存获取,就不用通过数据库。
读写分离,主从复制?
Cache
,可以通过实现Cache
接口来自定义二级缓存Mybatis的清除策略
LRU
– 最近最少使用:移除最长时间不被使用的对象。(默认)FIFO
– 先进先出:按对象进入缓存的顺序来移除它们。SOFT
– 软引用:基于垃圾回收器状态和软引用规则移除对象。WEAK
– 弱引用:更积极地基于垃圾收集器状态和弱引用规则移除对象一级缓存也叫本地缓存:SqlSession
测试步骤
日志输出可以看出仅进行了一次连接和查询操作,获取了相同的内容
查询两次相同内存,查看日志,判断缓存是否失效
可能原因:
sqlSession.clearCache(); //手动清理缓存
总结:一级缓存是默认开启的,只在一次SqlSession中有效,即连接到关闭区间。
一级缓存就是一个map
步骤:
<!--显式的开启全局缓存--> <setting name="cacheEnabled" value="true"/>
<!--在当前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>
java.io.NotSerializableException: com.cha.pojo.User
总结:
查询顺序:
先看二级缓存中有没有
再看一级缓存中有没有
查询数据库
Ehcache是一种广泛使用的开源Java分布式缓存,主要面向通用缓存
使用:
导包
配置cache
<cache type="org.mybatis.caches.ehcache.EhcacheCache"/>
实际中使用redis做缓存:K-V