什么是 MyBatis?
MyBatis 是一款优秀的持久层框架,它支持自定义 SQL、存储过程以及高级映射。
MyBatis 免除了几乎所有的 JDBC 代码以及设置参数和获取结果集的工作。
MyBatis 可以通过简单的 XML 或注解来配置和映射原始类型、接口和 Java POJO(Plain Old Java Objects,普通老式 Java 对象)为数据库中的记录。
第一个Mybatis程序
创建数据库环境
CREATE TABLE `user`( `id` int(20) not NULL PRIMARY KEY, `name` VARCHAR(50) DEFAULT NULL, `pwd` VARCHAR(30) DEFAULT NULL )ENGINE=INNODB DEFAULT CHARSET=utf8; INSERT into `user`(`id`,`name`,`pwd`) VALUES (1,'ylc','123'), (2,'ww','123'), (3,'张三','123')
新建一个项目
1.建一个普通的maven项目
2.删除src目录,作为父工程使用
3.去官网下载Mysql驱动jar包,在pom文件中写入
<dependencies> <dependency> <groupId>org.mybatis</groupId> <artifactId>mybatis</artifactId> <version>3.5.7</version> </dependency> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>5.1.49</version> </dependency> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>4.11</version> <scope>test</scope> </dependency> </dependencies> <?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.ylc</groupId> <artifactId>Mybatis-study</artifactId> <packaging>pom</packaging> <version>1.0-SNAPSHOT</version> <modules> <module>Mybatis-01</module> </modules> <properties> <maven.compiler.source>8</maven.compiler.source> <maven.compiler.target>8</maven.compiler.target> </properties> <dependencies> <dependency> <groupId>org.mybatis</groupId> <artifactId>mybatis</artifactId> <version>3.5.7</version> </dependency> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>5.1.49</version> </dependency> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>4.11</version> <scope>test</scope> </dependency> </dependencies> <build> <resources> <resource> <directory>src/main/resources</directory> <includes> <include>**/*.properties</include> <include>**/*.xml</include> </includes> <filtering>true</filtering> </resource> <resource> <directory>src/main/java</directory> <includes> <include>**/*.properties</include> <include>**/*.xml</include> </includes> <filtering>true</filtering> </resource> </resources> </build> </project>
创建一个模块
编写Mybatis的核心配置文件mybatis-config.xml
<?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd"> <configuration> <environments default="development"> <environment id="development"> <transactionManager type="JDBC"/> <dataSource type="POOLED"> <property name="driver" value="com.mysql.jdbc.Driver"/> <property name="url" value="jdbc:mysql://waiwanga.mysql.rds.aliyuncs.com:3306?useSSL=true&userUnicode=true&characterEncoding=UTF-8"/> <property name="username" value=""/> <property name="password" value=""/> </dataSource> </environment> </environments> <mappers> <mapper resource="com/ylc/Dao/UserMapper.xml"/> </mappers> </configuration>
编写Mybatis工具类MybatisUtils
public class MybatisUtils { public static SqlSessionFactory sqlSessionFactory=null; static { try { //使用Mybatis获取sqlSessionFactory对象 String resource = "mybatis-config.xml"; InputStream inputStream = Resources.getResourceAsStream(resource); sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream); } catch (IOException e) { e.printStackTrace(); } } //有了sqlSessionFactory就可以创建实例了 public static SqlSession getSqlSeeionFactory() { SqlSession sqlSession = sqlSessionFactory.openSession();//这里设置为true可以自动提交事务 return sqlSession; } }
编写代码
实体类
package com.ylc.pojo; public class User { private int id; private String name; private String pwd; public User(int id, String name, String pwd) { this.id = id; this.name = name; this.pwd = pwd; } public int getId() { return id; } public String getName() { return name; } public String getPwd() { return pwd; } public void setId(int id) { this.id = id; } public void setName(String name) { this.name = name; } 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(); }
接口实现配置文件UserMapper.xml
<?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd"> <!--namespace绑定一个对应的Dao、Mapper接口 resultType;返回结果类型--> <mapper namespace="com.ylc.Dao.UserDao"> <select id="getUserlist" resultType="com.ylc.pojo.User"> select * from student.user </select> </mapper>
student是数据库名
生成测试类
public class UserDaoTest{ @Test public void testGetUserlist() { //获取sqlSeeionFactory对象 SqlSession sqlSeeionFactory = MybatisUtils.getSqlSeeionFactory(); //执行sql UserDao mapper = sqlSeeionFactory.getMapper(UserDao.class); //方式二 //List<User> userlist = sqlSeeionFactory.selectList("com.ylc.Dao.UserDao.getUserlist"); List<User> userlist = mapper.getUserlist(); for (User user : userlist) { System.out.println(user); } sqlSeeionFactory.close(); } }
整体项目结构
增删改实现
接口
public interface UserDao { List<User> getUserlist(); User getUserByID(int id); int AddUser(User user); int UpdateUser(User user); int DeleteUser(int id); }
Select
- id:就是namespace中的方法名
- resultType:sql语句执行的返回值
- parameterType:传入参数类型
<select id="getUserByID" resultType="com.ylc.pojo.User" parameterType="int"> select * from student.user where id = #{id} </select>
@Test public void testTestGetUserByID() { SqlSession sqlSeenFactors = MybatisUtils.getSqlSeeionFactory(); UserDao mapper = sqlSeenFactors.getMapper(UserDao.class); User userById = mapper.getUserByID(1); System.out.println(userById); sqlSeenFactors.close(); }
Insert
<insert id="AddUser" parameterType="com.ylc.pojo.User" > insert into student.user(id,name,pwd) values(#{id},#{name},#{pwd}); </insert>
@Test public void addUser() { User user1=new User(4,"yy","123456"); SqlSession sqlSeenFactors = MybatisUtils.getSqlSeeionFactory(); UserDao mapper = sqlSeenFactors.getMapper(UserDao.class); Object object = mapper.AddUser(user1); sqlSeenFactors.commit(); System.out.println(object); sqlSeenFactors.close(); }
Update
<update id="UpdateUser" parameterType="com.ylc.pojo.User"> update student.user set name=#{name},pwd=#{pwd} where id=#{id}; </update>
public void UpdateUser() { SqlSession sqlSeeionFactory = MybatisUtils.getSqlSeeionFactory(); UserDao mapper = sqlSeeionFactory.getMapper(UserDao.class); System.out.println(mapper); int updateUser = mapper.UpdateUser(new User(3, "yyy", "11111")); sqlSeeionFactory.commit(); System.out.println(updateUser); sqlSeeionFactory.close(); }
Delete
<delete id="DeleteUser" parameterType="int"> delete from student.user where id=#{id}; </delete>
@Test public void DeleteUser() { SqlSession sqlSeeionFactory = MybatisUtils.getSqlSeeionFactory(); UserDao mapper = sqlSeeionFactory.getMapper(UserDao.class); int i = mapper.DeleteUser(4); sqlSeeionFactory.commit(); System.out.println(i); sqlSeeionFactory.close(); }
核心配置文件
mybatis-config.xml
configuration(配置) properties(属性) settings(设置) typeAliases(类型别名) typeHandlers(类型处理器) objectFactory(对象工厂) plugins(插件) environments(环境配置) environment(环境变量) transactionManager(事务管理器) dataSource(数据源) databaseIdProvider(数据库厂商标识) mappers(映射器)
环境变量environment
Mybatis可以配置多个环境,但是SqlsessionFactory实例只能选择一个环境
默认环境设置,更改default
为其他environment
的id就可以了
<environments default="development"> <environment id="development"> <transactionManager type="JDBC"/> <dataSource type="POOLED"> <property name="driver" value="com.mysql.jdbc.Driver"/> <property name="url" value="jdbc:mysql://waiwanga.mysql.rds.aliyuncs.com:3306?useSSL=true&userUnicode=true&characterEncoding=UTF-8"/> <property name="username" value="root"/> <property name="password" value="19990729Yy"/> </dataSource> </environment> <environment id="text"> <transactionManager type=""></transactionManager> <dataSource type=""></dataSource> </environment> </environments>
transactionManager事务管理器
有JDBC
和MANAGED
两种类型:
- JDBC:使用了JDBC的提交和回滚
- MANAGED:配置几乎没做什么, 默认情况下它会关闭连接
dataSource数据源
有三种数据类型:UNPOOLED
、POOLED
、JNDI
默认的是POOLED
property属性
可以通过properties来引用配置文件
db.properties
driver=com.mysql.jdbc.Driver url=jdbc:mysql://localhost:3306/mybatis?useSSL=true&useUnicode=true&characterEncoding=UTF-8 username=root password=123456
在核心配置文件中映入
<!--引入外部配置文件--> <properties resource="db.properties"> <property name="username" value="root"/> <property name="pwd" value="11111"/> </properties>
- 可以直接引入外部文件
- 可以在其中增加一些属性配置
- 如果两个文件有同一个字段,优先使用外部配置文件的!
类型别名typeAliases
存在的意义仅在于用来减少类完全限定名的冗余
<!--可以给实体类起别名--> <typeAliases> <typeAlias type="com.kuang.pojo.User" alias="User"/> </typeAliases>
也可以指定一个包名,MyBatis 会在包名下面搜索需要的 Java Bean,比如:
<typeAliases> <package name="domain.blog"/> </typeAliases>
每一个在包 domain.blog
中的 Java Bean,在没有注解的情况下,会使用 Bean 的首字母小写的非限定类名来作为它的别名。 比如 domain.blog.Author
的别名为 author
;若有注解,则别名为其注解值。见下面的例子:
@Alias("author") public class Author { }
设置Setting
映射器Mappers
注册绑定Mapper文件
方式一:对于相对路径的资源引用
<mappers> <mapper resource="com/ylc/Dao/UserMapper.xml"/> </mappers>
方式二:通过Class文件绑定注册
接口和Mapper文件必须同名和在同一个包下
<mappers> <mapper resource="com.ylc.Dao.UserMapper"/> </mappers>
方式三:使用扫描包注入
<!--每一个Mapper.XML都需要在Mybatis核心配置文件中注册!--> <mappers> <package name="com.ylc.dao"/> </mappers>
接口和Mapper文件必须同名和在同一个包下
生命周期和作用域
生命周期和作用域,是至关重要的,因为错误的使用会导致非常严重的并发问题。
SqlSessionFactoryBuilder:
- 一旦创建了 SqlSessionFactory,就不再需要它了
- 局部变量
SqlSessionFactory:
- 说白了就是可以想象为 :数据库连接池
- SqlSessionFactory 一旦被创建就应该在应用的运行期间一直存在,没有任何理由丢弃它或重新创建另一个实例。
- 因此 SqlSessionFactory 的最佳作用域是应用作用域。
- 最简单的就是使用单例模式或者静态单例模式。
SqlSession
- 连接到连接池的一个请求!
- SqlSession 的实例不是线程安全的,因此是不能被共享的,所以它的最佳的作用域是请求或方法作用域。
- 用完之后需要赶紧关闭,否则资源被占用!
这里面的每一个Mapper,就代表一个具体的业务!
结果映射
数据库中字段和实体类中字段不对应,会找不到数据,因为类型处理器会直接找数据库中的字段
解决方法:起别名
<select id="getUserById" resultType="com.ylc.pojo.User"> select id,name,pwd as password from mybatis.user where id = #{id} </select>
但是这个方法还不太灵活
<!--结果集映射--> <resultMap id="UserMap" type="User"> <!--column数据库中的字段,property实体类中的属性--> <result column="id" property="id"/> <result column="name" property="name"/> <result column="pwd" property="password"/> </resultMap> <select id="getUserById" resultMap="UserMap"> select * from mybatis.user where id = #{id} </select>
resultMap
元素是 MyBatis 中最重要最强大的元素- ResultMap 的设计思想是,对于简单的语句根本不需要配置显式的结果映射,而对于复杂一点的语句只需要描述它们的关系就行了。
ResultMap
最优秀的地方在于,虽然你已经对它相当了解了,但是根本就不需要显式地用到他们。
日志
如果数据库发生了异常怎么可以查看到,需要排错,这时候就需要日志
具体在核心配置文件中设置,但注意日志名称不能输入错误
标准STDOUT_LOGGING日志配置:
<settings> <setting name="logImpl" value="STDOUT_LOGGING"/> </settings>
可以查看到数据库连接情况,以及sql语句和传入的参数,以及返回行数
LOG4J
什么是Log4j?
- Log4j是Apache的一个开源项目,通过使用Log4j,我们可以控制日志信息输送的目的地是控制台、文件、GUI组件
- 我们也可以控制每一条日志的输出格式;
- 通过定义每一条日志信息的级别,我们能够更加细致地控制日志的生成过程。
- 通过一个配置文件来灵活地进行配置,而不需要修改应用的代码。
导入Log4j包,在Maven官网找到包
<!-- https://mvnrepository.com/artifact/log4j/log4j --> <dependency> <groupId>log4j</groupId> <artifactId>log4j</artifactId> <version>1.2.17</version> </dependency>
log4j配置文件
#将等级为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/kuang.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,需要导入import org.apache.log4j.Logger;
日志对象,参数为当前类的class
static Logger logger = Logger.getLogger(UserDaoTest.class);
public class UserDaoTest { static Logger logger = Logger.getLogger(UserDaoTest.class); @Test public void TextLOG4J() { logger.info("进入了TextLOG4J"); logger.debug("进入了TextLOG4J"); logger.error("进入了TextLOG4J"); } }
分页
使用limit分页
接口
void gerLimitUser();
Mapper.xml
<select id="gerLimitUser" parameterType="map" resultType="com.ylc.pojo.User"> select * from student.user limit #{startindex},#{pagesize} </select>
测试
@Test public void gerLimitUser() { SqlSession sqlSeeionFactory = MybatisUtils.getSqlSeeionFactory(); UserDao mapper = sqlSeeionFactory.getMapper(UserDao.class); HashMap<String, Integer> map = new HashMap<>(); map.put("startindex",2); map.put("pagesize",2); List<User> users = mapper.gerLimitUser(map); for (User user : users) { System.out.println(user); } sqlSeeionFactory.close(); }
使用RowBounds分页
不再使用SQL实现分页
接口
List<User> getUserByRowBounds();
mapper.xml
<select id="getUserByRowBounds" resultMap="UserMap"> select * from student.user </select>
测试
@Test public void getUserByRowBounds(){ SqlSession sqlSession = MybatisUtils.getSqlSession(); //RowBounds实现 RowBounds rowBounds = new RowBounds(0, 2); List<User> userList = sqlSession.selectList("com.ylc.dao.UserMapper.getUserByRowBounds",null,rowBounds); for (User user : userList) { System.out.println(user); } sqlSession.close(); }
使用插件分页
PageHelper
使用注解开发
在接口上写一个注解
@Select("select * from student.user") List<User> getUsers();
测试
@Test public void getUsers() { SqlSession sqlSeeionFactory = MybatisUtils.getSqlSeeionFactory(); UserDao mapper = sqlSeeionFactory.getMapper(UserDao.class); List<User> users = mapper.getUsers(); for (User user : users) { System.out.println(user); } }
这样的注解适合简单的sql语句,复杂的还是适合放在XMl里面
Lombok
Project Lombok是一个java库,它可以自动插入编辑器和构建工具,为java增添乐趣。永远不要再编写另一个getter或equals方法,只要有一个注释,您的类就有一个功能齐全的构建器、自动记录变量等等。
比如我们的类中手写了大量的get、set方法,Lombok可以帮助我们简化操作
安装Lombok
导入LomBoK的jar包
<!-- https://mvnrepository.com/artifact/org.projectlombok/lombok --> <dependency> <groupId>org.projectlombok</groupId> <artifactId>lombok</artifactId> <version>1.18.12</version> <scope>provided</scope> </dependency>
@Getter and @Setter @FieldNameConstants @ToString @EqualsAndHashCode @AllArgsConstructor, @RequiredArgsConstructor and @NoArgsConstructor @Log, @Log4j, @Log4j2, @Slf4j, @XSlf4j, @CommonsLog, @JBossLog, @Flogger @Data //无参构造、get set、hascode、ToString @Builder @Singular @Delegate @Value @Accessors @Wither @SneakyThrows
测试:
在我们类名前面加上@Data就可以自动生成相应的结构
优点:
能通过注解形式自定生成构造器:无参构造、get set、hascode、ToString等等
让代码更加简洁,便于维护
缺点:
不支持多种参数构造去重载
降低了源代码的可读性和完整性
多对一
关联查询
配置文件
<?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> <settings> <setting name="logImpl" value="LOG4J"/> </settings> <environments default="development"> <environment id="development"> <transactionManager type="JDBC"/> <dataSource type="POOLED"> <property name="driver" value="com.mysql.jdbc.Driver"/> <property name="url" value="jdbc:mysql://waiwanga.mysql.rds.aliyuncs.com:3306?useSSL=true&userUnicode=true&characterEncoding=UTF-8"/> <property name="username" value="root"/> <property name="password" value="19990729Yy"/> </dataSource> </environment> </environments> <mappers> <mapper resource="StudentMapper.xml"/> <mapper resource="TeacherMapper.xml"/> </mappers> </configuration>
proj类
package com.ylc.pojo; import lombok.Data; @Data public class Student { private int id; private String name; private Teacher teacher; }
package com.ylc.pojo; import lombok.Data; @Data public class Teacher { private int id; private String name; }
StudentMapper.xml
<?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd"> <mapper namespace="com.ylc.Dao.StudentMapper"> <select id="getStudent" resultMap="StudentTeacher"> select * from student.student </select> <resultMap id="StudentTeacher" type="com.ylc.pojo.Student"> <result property="id" column="id"></result> <result property="name" column="name"></result> <association property="teacher" column="tid" javaType="com.ylc.pojo.Teacher" select="getTeacher"> </association> </resultMap> <select id="getTeacher" resultType="com.ylc.pojo.Teacher"> select * from student.teacher where id = #{id} </select> </mapper>
测试类
@Test public void getStudent() { SqlSession sqlSeeionFactory = MybatisUtils.getSqlSeeionFactory(); StudentMapper mapper = sqlSeeionFactory.getMapper(StudentMapper.class); List<Student> student = mapper.getStudent(); for (Student student1 : student) { System.out.println(student1); } sqlSeeionFactory.close(); }
嵌套查询
<select id="getstudent2" resultMap="StudentTeacher2"> select s.id sid, s.name sname, t.name tname,t.id tid from student.student s,student.teacher t where s.tid = t.id ; </select> <resultMap id="StudentTeacher2" type="com.ylc.pojo.Student"> <result property="id" column="sid"></result> <result property="name" column="sname"></result> <association property="teacher" javaType="com.ylc.pojo.Teacher"> <result property="name" column="tname"></result> </association> </resultMap>
@Test public void getstudent2() { SqlSession sqlSeeionFactory = MybatisUtils.getSqlSeeionFactory(); StudentMapper mapper = sqlSeeionFactory.getMapper(StudentMapper.class); List<Student> student = mapper.getstudent2(); for (Student student1 : student) { System.out.println(student1); } sqlSeeionFactory.close(); }
一对多
实体类
@Data public class Teacher { private int id; private String name; private List<Student> studentList; }
@Data public class Student { private int id; private String name; private int tid; }
接口
public interface TeacherMapper { Teacher getTeacher(@Param("tid") int id); }
mapper.xml
<?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd"> <mapper namespace="com.ylc.Dao.TeacherMapper"> <select id="getTeacher" resultMap="TeacherStudent"> select s.id sid, s.name sname, t.name tname,t.id tid from student.student s,student.teacher t where s.tid = t.id and t.id = #{tid} </select> <resultMap id="TeacherStudent" type="com.ylc.pojo.Teacher"> <result column="tid" property="id"></result> <result column="tname" property="name"></result> <collection property="studentList" ofType="com.ylc.pojo.Student"> <result column="sid" property="id"></result> <result column="sname" property="name"></result> <result column="tid" property="tid"></result> </collection> </resultMap> </mapper>
测试类
@Test public void getTeacher() { SqlSession sqlSeeionFactory = MybatisUtils.getSqlSeeionFactory(); TeacherMapper mapper = sqlSeeionFactory.getMapper(TeacherMapper.class); Teacher teacher = mapper.getTeacher(1); System.out.println(teacher); sqlSeeionFactory.close(); }
动态SQL
IF
<select id="queryBlogIF" 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>
choose (when, otherwise)
<select id="queryBlogChoose" 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 = #{views} </otherwise> </choose> </where> </select>
trim (where,set)
select * from mybatis.blog <where> <if test="title != null"> title = #{title} </if> <if test="author != null"> and author = #{author} </if> </where>
<update id="updateBlog" 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>
所谓的动态SQL,本质还是SQL语句 , 只是我们可以在SQL层面,去执行一个逻辑代码
SQL片段
有的时候,我们可能会将一些功能的部分抽取出来,方便复用!
- 使用SQL标签抽取公共的部分
<sql id="if-title-author"> <if test="title != null"> title = #{title} </if> <if test="author != null"> and author = #{author} </if> </sql>
- 在需要使用的地方使用Include标签引用即可
<select id="queryBlogIF" parameterType="map" resultType="blog"> select * from mybatis.blog <where> <include refid="if-title-author"></include> </where> </select>
注意事项:
- 最好基于单表来定义SQL片段!
- 不要存在where标签
Foreach
select * from user where 1=1 and <foreach item="id" collection="ids" open="(" separator="or" close=")"> #{id} </foreach> (id=1 or id=2 or id=3)
<!-- select * from mybatis.blog where 1=1 and (id=1 or id = 2 or id=3) 我们现在传递一个万能的map , 这map中可以存在一个集合! --> <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>
缓存
经常查询并且不经常改变的数据。可以使用缓存
MyBatis系统中默认定义了两级缓存:一级缓存和二级缓存
- 默认情况下,只有一级缓存开启。(SqlSession级别的缓存,也称为本地缓存)
- 二级缓存需要手动开启和配置,他是基于namespace级别的缓存。
- 为了提高扩展性,MyBatis定义了缓存接口Cache。我们可以通过实现Cache接口来自定义二级缓存
缓存失效的情况:
- 查询不同的东西
- 增删改操作,可能会改变原来的数据,所以必定会刷新缓存!
- 查询不同的Mapper.xml
- 手动清理缓存!
小结:一级缓存默认是开启的,只在一次SqlSession中有效,也就是拿到连接到关闭连接这个区间段!
一级缓存就是一个Map。
二级缓存
- 二级缓存也叫全局缓存,一级缓存作用域太低了,所以诞生了二级缓存
- 基于namespace级别的缓存,一个名称空间,对应一个二级缓存;
- 工作机制
- 一个会话查询一条数据,这个数据就会被放在当前会话的一级缓存中;
- 如果当前会话关闭了,这个会话对应的一级缓存就没了;但是我们想要的是,会话关闭了,一级缓存中的数据被保存到二级缓存中;
- 新的会话查询信息,就可以从二级缓存中获取内容;
- 不同的mapper查出的数据会放在自己对应的缓存(map)中;
步骤:
- 开启全局缓存
<!--显示的开启全局缓存--> <setting name="cacheEnabled" value="true"/>
- 在要使用二级缓存的Mapper中开启
<!--在当前Mapper.xml中使用二级缓存--> <cache/>
- 也可以自定义参数
<!--在当前Mapper.xml中使用二级缓存--> <cache eviction="FIFO" flushInterval="60000" size="512" readOnly="true"/>
- 测试
- 问题:我们需要将实体类序列化!否则就会报错!
Caused by: java.io.NotSerializableException: com.kuang.pojo.User
小结:
- 只要开启了二级缓存,在同一个Mapper下就有效
- 所有的数据都会先放在一级缓存中;
- 只有当会话提交,或者关闭的时候,才会提交到二级缓冲中!
- 开启二级缓存需要序列化对象
缓存原理
自定义缓存-ehcache
Ehcache是一种广泛使用的开源Java分布式缓存。主要面向通用缓存
要在程序中使用ehcache,先要导包!
<!-- https://mvnrepository.com/artifact/org.mybatis.caches/mybatis-ehcache --> <dependency> <groupId>org.mybatis.caches</groupId> <artifactId>mybatis-ehcache</artifactId> <version>1.1.0</version> </dependency>
在mapper中指定使用我们的ehcache缓存实现!
<!--在当前Mapper.xml中使用二级缓存--> <cache type="org.mybatis.caches.ehcache.EhcacheCache"/>
ehcache.xml
<?xml version="1.0" encoding="UTF-8"?> <ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="http://ehcache.org/ehcache.xsd" updateCheck="false"> <!-- diskStore:为缓存路径,ehcache分为内存和磁盘两级,此属性定义磁盘的缓存位置。参数解释如下: user.home – 用户主目录 user.dir – 用户当前工作目录 java.io.tmpdir – 默认临时文件路径 --> <diskStore path="./tmpdir/Tmp_EhCache"/> <defaultCache eternal="false" maxElementsInMemory="10000" overflowToDisk="false" diskPersistent="false" timeToIdleSeconds="1800" timeToLiveSeconds="259200" memoryStoreEvictionPolicy="LRU"/> <cache name="cloud_user" eternal="false" maxElementsInMemory="5000" overflowToDisk="false" diskPersistent="false" timeToIdleSeconds="1800" timeToLiveSeconds="1800" memoryStoreEvictionPolicy="LRU"/> <!-- defaultCache:默认缓存策略,当ehcache找不到定义的缓存时,则使用这个缓存策略。只能定义一个。 --> <!-- name:缓存名称。 maxElementsInMemory:缓存最大数目 maxElementsOnDisk:硬盘最大缓存个数。 eternal:对象是否永久有效,一但设置了,timeout将不起作用。 overflowToDisk:是否保存到磁盘,当系统当机时 timeToIdleSeconds:设置对象在失效前的允许闲置时间(单位:秒)。仅当eternal=false对象不是永久有效时使用,可选属性,默认值是0,也就是可闲置时间无穷大。 timeToLiveSeconds:设置对象在失效前允许存活时间(单位:秒)。最大时间介于创建时间和失效时间之间。仅当eternal=false对象不是永久有效时使用,默认是0.,也就是对象存活时间无穷大。 diskPersistent:是否缓存虚拟机重启期数据 Whether the disk store persists between restarts of the Virtual Machine. The default value is false. diskSpoolBufferSizeMB:这个参数设置DiskStore(磁盘缓存)的缓存区大小。默认是30MB。每个Cache都应该有自己的一个缓冲区。 diskExpiryThreadIntervalSeconds:磁盘失效线程运行时间间隔,默认是120秒。 memoryStoreEvictionPolicy:当达到maxElementsInMemory限制时,Ehcache将会根据指定的策略去清理内存。默认策略是LRU(最近最少使用)。你可以设置为FIFO(先进先出)或是LFU(较少使用)。 clearOnFlush:内存数量最大时是否清除。 memoryStoreEvictionPolicy:可选策略有:LRU(最近最少使用,默认策略)、FIFO(先进先出)、LFU(最少访问次数)。 FIFO,first in first out,这个是大家最熟的,先进先出。 LFU, Less Frequently Used,就是上面例子中使用的策略,直白一点就是讲一直以来最少被使用的。如上面所讲,缓存的元素有一个hit属性,hit值最小的将会被清出缓存。 LRU,Least Recently Used,最近最少使用的,缓存的元素有一个时间戳,当缓存容量满了,而又需要腾出地方来缓存新的元素的时候,那么现有缓存元素中时间戳离当前时间最远的元素将被清出缓存。 --> </ehcache>