MyBatis详解【下】

本文涉及的产品
日志服务 SLS,月写入数据量 50GB 1个月
简介: MyBatis 环境: JDK,Mysql,Maven,IDEA 回顾: JDBC,Mysql,Java基础,Maven,Junit 框架:有配置文件。最好的方式:看官网文档。 1、简介 1.1、什么是MyBatis? MyBatis 是一款优秀的持久层框架 它支持自定义 SQL、存储过程以及高级映

5、解决属性名和字段名不一致的问题


1、问题


数据库中的字段



新建一个项目,拷贝之前的,测试实体类字段不一致的情况


public class User {
    private int id;
    private String name;
    private String password;
}


测试出现问题



//select * from mybatis.user  where id = #{id};
//类型处理器
//select id,name,pwd from mybatis.user  where id = #{id};


解决方法:


  • 起别名


<select id="getUserById" parameterType="int" resultType="com.kuang.pojo.User">
    select id,name,pwd as password from mybatis.user  where id = #{id};
</select>


2、resultMap


结果集映射


id    name    pwd
id    name    password


<!--结果集映射-->
<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的优秀之处——你完全可以不用显式地配置它们。


  • 如果这个世界总是这么简单就好了。


6、日志


6.1、日志工厂


如果一个数据库操作,出现了异常,我们需要排错。日志就是最好的助手!


曾经:sout、debug


现在:日志工厂!



  • SLF4J
  • LOG4J(deprecated since 3.5.9) 【掌握】
  • LOG4J2
  • JDK_LOGGING
  • COMMONS_LOGGING
  • STDOUT_LOGGING 【掌握】
  • NO_LOGGING


在MyBatis中具体使用哪一个日志实现,在设置中设定!


STDOUT_LOGGING标准日志输出


在MyBatis核心配置文件中,配置我们的日志!



6.2、Log4j


什么是Log4j?

  • Log4j是Apache的一个开源项目,通过使用Log4j,我们可以控制日志信息输送的目的地是控制台、文件、GUI组件
  • 我们也可以控制每一条日志的输出格式
  • 通过定义每一条日志信息的级别,我们能够更加细致地控制日志的生成过程。
  • 通过一个配置文件来灵活地进行配置,而不需要修改应用的代码。


  1. 先导入Log4j的包


<!-- https://mvnrepository.com/artifact/log4j/log4j -->
<dependency>
    <groupId>log4j</groupId>
    <artifactId>log4j</artifactId>
    <version>1.2.17</version>
</dependency>


  1. 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 = %-d{yyyy-MM-dd HH\:mm\:ss} [%p]-[%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 = %-d{yyyy-MM-dd HH\:mm\:ss} [%p]-[%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.PrepareStatement=DEBUG


  1. 配置log4j为日志的实现


<settings>
    <setting name="logImpl" value="LOG4J"/>
</settings>


  1. Log4j的使用!直接测试运行刚才的查询



简单使用


  1. 在要使用Log4j的类中,导入包import org.apache.log4j.Logger;


  1. 日志对象,参数为当前类的class


static Logger logger = Logger.getLogger(UserMapperTest.class);


  1. 日志级别


logger.info("info:进入了testLog4j");
logger.debug("debug:进入了testLog4j");
logger.error("error:进入了testLog4j");


7、分页


思考:为什么要分页?


  • 减少数据的处理量


7.1、使用Limit分页


语法:select * from `user` limit startIndex,pageSize;
select * from `user` limit 3;    #[0,n]


使用Mybatis实现分页,核心SQL


  1. 接口


//分页
List<User> getUserByLimit(Map<String,Integer> map);


  1. Mapper.xml


<!--分页-->
<select id="getUserByLimit" resultMap="UserMap" parameterType="map">
    select * from mybatis.user limit #{startIndex},#{pageSize}
</select>


  1. 测试


@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();
}


7.2、RowBounds分页


不再使用SQL实现分页


  1. 接口


//分页2
List<User> getUserByRowBounds();


  1. mapper.xml


<!--分页2-->
<select id="getUserByRowBounds" resultMap="UserMap">
    select * from mybatis.user
</select>


  1. 测试


@Test
public void getUserByRowBounds(){
    SqlSession sqlSession = MybatisUtils.getSqlSession();
    //RowBounds实现
    RowBounds rowBounds = new RowBounds(1, 2);
    //通过Java代码层面实现分页
    List<User> userList = sqlSession.selectList("com.kuang.dao.UserMapper.getUserByRowBounds",null,rowBounds);
    for (User user : userList) {
        System.out.println(user);
    }
    sqlSession.close();
}


7.3、分页插件



了解即可,万一以后需要使用,需要知道是什么东西!


8、使用注解开发


8.1、面向接口编程


-大家之前都学习过面向对象编程,也学习过接口,但在真正的开发中,很多时候我们会选择面向接口编程


-根本原因:解耦,可拓展,提高复用,分层开发中,上层不用管具体的实现,大家都遵守共同的标准,使得开发变得容易,规范性更好


-在一个面向对象的系统中,系统的各种功能是由许许多多的不同对象协作完成的。在这种情况下,各个对象内部是如何实现自己的,对系统设计人员来讲就不那么重要了;

-而各个对象之间的协作关系则成为系统设计的关键。小到不同类之间的通信,达到各个模块之间的交互,在系统设计之初都是要着重考虑的,这也是系统设计的主要工作内容。面向接口编程就是指按照这种思想来编程。


关于接口的理解


-接口从更深层次的理解,应是定义(规范,约束)与实现(名实分离的原则)的分离。


-接口的本身反映了系统设计人员对系统的抽象理解。


-接口应有两类:

-第一类是对一个个体的抽象,它可对应为一个抽象体(abstract class);

-第二类是对一个个体某一方面的抽象,即形成一个抽象面(interface);


-一个个体有可能有多个抽象面。抽象体与抽象面是有区别的。


三个面向区别


-面向对象是指,我们考虑问题时,以对象为单位,考虑它的属性及方法。


-面向过程是指,我们考虑问题时,以一个具体的流程(事务过程)为单位,考虑它的实现。


-接口设计与非接口设计是针对复用技术而言的,与面向对象(过程)不是一个问题,更多的体现就是对系统整体的架构。


8.2、使用注解开发


  1. 注解在接口上实现


@Select("select * from user")
List<User> getUsers();


  1. 需要在核心配置文件中绑定接口!


<!--绑定接口-->
<mappers>
    <mapper class="com.kuang.dao.UserMapper"/>
</mappers>


  1. 测试


本质:反射机制实现


底层:动态代理!



MyBatis详细的执行流程!



8.3、CRUD


我们可以在工具类创建的时候实现自动提交事务!


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


编写接口,增加注解


public interface UserMapper {
    @Select("select * from user")
    List<User> getUsers();
    //方法存在多个参数,所有的参数前必须加上@Param注解
    @Select("select * from user where id = #{id}")
    User getUserById(@Param("id") int id);
    @Insert("insert into user(id,name,pwd) values (#{id},#{name},#{password})")
    int addUser(User user);
    @Update("update user set name=#{name},pwd=#{password} where id = #{id}")
    int updateUser(User user);
    @Delete("delete from user where id=#{uid}")
    int deleteUser(@Param("uid") int id);
}


测试类


【注意:我们必须要将接口注册绑定到我们的核心配置文件中!】


<!--绑定接口-->
<mappers>
    <mapper class="com.kuang.dao.UserMapper"/>
</mappers>


public class UserMapperTest {
    @Test
    public void test(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        //底层主要应用反射
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        mapper.deleteUser(5);
        sqlSession.close();
    }
    /*
    List<User> users = mapper.getUsers();
        for (User user : users) {
            System.out.println(user);
        }
        User userById = mapper.getUserById(1);
        System.out.println(userById);
        mapper.addUser(new User(5,"hello","123123"));
        mapper.updateUser(new User(5,"to","213213"));
     */
}


关于@Param()注解


  • 基本类型的参数或者String类型,需要加上


  • 引用类型不需要加


  • 如果只有一个基本类型的话,可以忽略,但是建议大家都加上!


  • 我们在SQL中引用的就是我们这里的@Param()中设定的属性名!


9、Lombok


Project Lombok is a java library that automatically plugs into your editor and build tools, spicing up your java.
Never write another getter or equals method again, with one annotation your class has a fully featured builder, Automate your logging variables, and much more.


  • java library


  • plugs


  • build tools


  • with one annotation your class


使用步骤:


  1. 在IDEA中安装Lombok插件!


  1. 在项目中导入lombok的jar包


<!-- https://mvnrepository.com/artifact/org.projectlombok/lombok -->
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <version>1.18.22</version>
</dependency>


  1. 在实体类上加注解即可!


@Data
@AllArgsConstructor
@NoArgsConstructor


@Getter and @Setter
@FieldNameConstants
@ToString
@EqualsAndHashCode
@AllArgsConstructor, @RequiredArgsConstructor and @NoArgsConstructor
@Log, @Log4j, @Log4j2, @Slf4j, @XSlf4j, @CommonsLog, @JBossLog, @Flogger, @CustomLog
@Data
@Builder
@SuperBuilder
@Singular
@Delegate
@Value
@Accessors
@Wither
@With
@SneakyThrows
@val
@var
experimental @var
@UtilityClass


说明:


@Data:无参构造,get,set,tostring,hashcode,equals
@AllArgsConstructor
@NoArgsConstructor
@ToString
@EqualsAndHashCode


10、多对一处理


多对一:



  • 多个学生,对应一个老师


  • 对于学生这边而言,关联 .. 多个学生,关联一个老师 【多对一】


  • 对于老师而言,集合,一个老师,有很多学生 【一对多】



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');


测试环境搭建


  1. 导入lombok


  1. 新建实体类Teacher,Student


  1. 建立Mapper接口


  1. 建立Mapper.xml文件


  1. 在测试配置文件中绑定注册我们的Mapper接口或者文件!【方式很多,随心选】


  1. 测试查询是否能够成功!


按照查询嵌套处理


<!--
    思路:
        1.查询所有的学生信息
        2.根据查询出来的学生的tid,寻找对应的老师! 子查询
    -->
<resultMap id="StudentTeacher" type="Student">
    <result property="id" column="id"/>
    <result property="name" column="name"/>
    <!--复杂的属性,我们需要单独处理 对象:association 集合:collection-->
    <association property="teacher" column="tid" javaType="Teacher" select="getTeacher"/>
</resultMap>
<select id="getStudent" resultMap="StudentTeacher">
    select * from student
</select>
<select id="getTeacher" resultType="Teacher">
    select * from teacher where id = #{id};
</select>


按照结果嵌套处理


<!--按照结果嵌套处理-->
<select id="getStudent2" resultMap="StudentTeacher2">
    select s.id sid,s.name sname,t.name tname
    from student s,teacher t
    where s.tid = t.id;
</select>
<resultMap id="StudentTeacher2" type="Student">
    <result property="id" column="sid"/>
    <result property="name" column="sname"/>
    <association property="teacher" javaType="Teacher">
        <result property="name" column="tname"/>
    </association>
</resultMap>


回顾Mysql多对一查询方式:


  • 子查询


  • 联表查询


11、一对多处理


比如:一个老师拥有多个学生!


对于老师而言,就是一对多的关系!


环境搭建


  1. 环境搭建,和刚才一样


实体类


@Data
public class Student {
    private int id;
    private String name;
    private int tid;
}


@Data
public class Teacher {
    private int id;
    private String name;
    //一个老师拥有多个学生
    private List<Student> students;
}


按照结果嵌套处理


<!--按结果嵌套查询-->
<select id="getTeacher" resultMap="TeacherStudent">
    select s.id sid,t.name tname,s.name sname,t.id tid from  teacher t, student s where t.id=s.tid 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>


按照查询嵌套处理


<resultMap id="TeacherStudent2" type="Teacher">
    <result property="id" column="id"/>
    <result property="name" column="name"/>
    <!--将teacher中的id传给getStudentByTeacherId,column的作用,需要写javaType-->
    <collection property="students" javaType="ArrayList" ofType="Student" column="id" select="getStudentByTeacherId"/>
</resultMap>
<select id="getTeacher2" resultMap="TeacherStudent2">
    select * from teacher where id=#{tid}
</select>
<select id="getStudentByTeacherId" resultType="Student">
    select * from student where tid=#{tid}
</select>


小结


  1. 关联 - association 【多对一】


  1. 集合 - collection 【一对多】


  1. javaType & ofType
  1. JavaType 用来指定实体类中属性的类型
  2. ofType 用来指定映射到List或者集合中的 pojo类型,泛型中的约束类型!


注意点:


  • 保证SQL的可读性,尽量保证通俗易懂


  • 注意一对多和多对一中,属性名和字段的问题!


  • 如果问题不好排查错误,可以使用日志,建议使用 Log4j

面试高频


  • Mysql引擎


  • InnoDB底层原理


  • 索引


  • 索引优化!


12、动态SQL



什么是动态SQL:动态SQL就是指根据不同的条件生成不同的SQL语句


如果你之前用过 JSTL 或任何基于类 XML 语言的文本处理器,你对动态 SQL 元素可能会感觉似曾相识。在 MyBatis 之前的版本中,需要花时间了解大量的元素。借助功能强大的基于 OGNL 的表达式,MyBatis 3 替换了之前的大部分元素,大大精简了元素种类,现在要学习的元素种类比原来的一半还要少。
if
choose (when, otherwise)
trim (where, set)
foreach


搭建环境


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. 导包


  1. 编写配置文件


  1. 编写实体类


@Data
public class Blog {
    private String id;
    private String title;
    private String author;
    private Date createTime;
    private int views;
}


@SuppressWarnings("all") //抑制警告


  1. 编写实体类对应的 Mapper接口和 Mapper.XML文件


IF


<select id="queryBlogIF" parameterType="map" resultType="Blog">
    select * from blog where 1=1
    <if test="title != null">
        and title like #{title}
    </if>
    <if test="author != null">
        and author like #{author}
    </if>
</select>


choose(when, otherwise)


<select id="queryBlogChoose" parameterType="map" resultType="Blog">
    select * from blog
    <where>
        <choose>
            <when test="title != null">
                title like #{tile}
            </when>
            <when test="author != null">
                and author like #{author}
            </when>
            <otherwise>
                views like #{views}
            </otherwise>
        </choose>
    </where>
</select>


trim(where, set)


<select id="queryBlogIF" parameterType="map" resultType="Blog">
    select * from blog
    <where>
        <if test="title != null">
            title like #{title}
        </if>
        <if test="author != null">
            and author like #{author}
        </if>
    </where>
</select>


<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>


所谓的动态SQL,本质还是SQL语句,只是我们可以在SQL层面,去执行一些逻辑代码


if


where(动态去除多余and), set(动态去除多余逗号,), choose, when


SQL片段


有时候,我们可能会将一些功能的部分抽取出来,方便复用!


  1. 使用SQL标签抽取公共的部分


<sql id="if-title-author">
    <if test="title != null">
        and title like #{title}
    </if>
    <if test="author != null">
        and author like #{author}
    </if>
</sql>


  1. 在需要使用的地方使用Include标签引用即可


<select id="queryBlogIF" parameterType="map" resultType="Blog">
    select * from 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 = #{id}
</foreach>
(id=1 or id=2 or id=3)




<!--
  select * from blog where 1=1 and (id=1 or id=2 or id=3)
  我们现在传递一个万能的map,这map中可以存在一个集合!
-->
<select id="queryBlogForeach" parameterType="map" resultType="Blog">
    select * from blog
    <where>
        <foreach item="id" collection="ids" open="(" separator="or" close=")">
            id = #{id}
        </foreach>
    </where>
</select>


动态SQL就是在拼接SQL语句,我们只要保证SQL的正确性,按照SQL的格式,去排列组合就可以了


建议:

  • 先在Mysql中写出完整的SQL,再对应的去修改成为我们的动态SQL实现通用即可!


13、缓存(了解)


13.1、简介


查询  :  连接数据库  耗资源
  一次查询的结果,给他暂存在一个可以直接取到的地方! --> 内存  :  缓存
我们再次查询相同的数据的时候,直接走缓存,就不用走数据库了


  1. 什么是缓存[Cache]?
  • 存在内存中的临时数据。
  • 将用户经常查询的数据放在缓存(内存)中,用户去查询数据就不用从磁盘上(关系型数据库数据文件)查询,从缓存中查询,从而提高查询效率,解决了高并发系统的性能问题。


  1. 为什么使用缓存?
  • 减少和数据库的交互次数,减少系统开销,提高系统效率。


  1. 什么样的数据能使用缓存?
  • 经常查询并且不经常改变的数据。 【可以使用缓存】


13.2、Mybatis缓存


  • MyBatis包含一个非常强大的查询缓存特性,它可以非常方便地定制和配置缓存。缓存可以极大的提升查询效率。


  • MyBatis系统中默认定义了两级缓存:一级缓存二级缓存
  • 默认情况下,只有一级缓存开启。 (SqlSession级别的缓存,也称为本地缓存)
  • 二级缓存需要手动开启和配置,他是基于namespace级别的缓存。
  • 为了提高扩展性,MyBatis定义了缓存接口Cache。我们可以通过实现Cache接口来自定义二级缓存


13.3、一级缓存


  • 一级缓存也叫本地缓存:sqlSession
  • 与数据库同一次会话期间查询到的数据会放在本地缓存中
  • 以后如果需要获取相同的数据,直接从缓存中拿,没必要再去查询数据库;


测试步骤:


  1. 开启日志


  1. 测试在一个Session中查询两次相同的记录


  1. 查看日志输出



缓存失效的情况:


  1. 查询不同的东西


  1. 增删改操作,可能会改变原来的数据,所以必定会刷新缓存!



  1. 查询不同的Mapper.xml


  1. 手动清理缓存!



小结:一级缓存默认是开启的,只在一次SqlSession中有效,也就是拿到连接到关闭连接这个区间段!


一级缓存就是一个Map。


13.4、二级缓存


  • 二级缓存也叫全局缓存,一级缓存作用域太低了,所以诞生了二级缓存


  • 基于namespace级别的缓存,一个名称空间,对应一个二级缓存


  • 工作机制
  • 一个会话查询一条数据,这个数据就会被放在当前会话的一级缓存中;
  • 如果当前会话关闭了,这个会话对应的一级缓存就没了;但是我们想要的是,会话关闭了,一级缓存中的数据被保存到二级缓存中;
  • 新的会话查询信息,就可以从二级缓存中获取内容;
  • 不同的mapper查出的数据会放在自己对应的缓存(map)中;


步骤:


  1. 开启全局缓存


<!--显示的开启全局缓存-->
<setting name="cacheEnabled" value="true"/>


  1. 在要使用二级缓存的Mapper中开启


<!--在当前Mapper.xml中使用二级缓存-->
<cache/>


  1. 也可以自定义参数


<!--在当前Mapper.xml中使用二级缓存-->
<cache eviction="FIFO"
           flushInterval="60000"
           size="512"
           readOnly="true"/>


  1. 测试
  1. 问题:我们需要将实体类序列化!否则就会报错!


Caused by: java.io.NotSerializableException: com.kuang.pojo.User


小结:

  • 只要开启了二级缓存,在同一个Mapper下就有效
  • 所有的数据都会先放在一级缓存中;
  • 只有当会话提交,或者关闭的时候,才会提交到二级缓存中!


13.5、缓存原理



13.6、自定义缓存-ehcache


Ehcache是一种广泛使用的开源Java分布式缓存。主要面向通用缓存


要在程序中使用,先导包


<!-- https://mvnrepository.com/artifact/org.mybatis.caches/mybatis-ehcache -->
<dependency>
    <groupId>org.mybatis.caches</groupId>
    <artifactId>mybatis-ehcache</artifactId>
    <version>1.2.2</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="java.io.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>


Redis数据库来做缓存!K-V


练习:29道练习题实战

相关实践学习
日志服务之使用Nginx模式采集日志
本文介绍如何通过日志服务控制台创建Nginx模式的Logtail配置快速采集Nginx日志并进行多维度分析。
相关文章
|
SQL Java 数据库连接
MyBatis大全
MyBatis大全
53 0
|
XML Java 数据库连接
|
6月前
|
SQL Java 数据库连接
|
3月前
|
SQL Java 数据库连接
Mybatis02(一)
Mybatis02(一)
29 0
|
3月前
|
SQL XML Java
Mybatis02(二)
Mybatis02(二)
28 0
|
4月前
|
Java 关系型数据库 MySQL
MyBatis-Plus详解(1)
MyBatis-Plus详解(1)
51 0
|
6月前
|
SQL Java 数据库连接
从0开始回顾Mybatis
Mybatis 1、什么是Mybatis? 概念: 1. Mybatis 是一个半 ORM(对象关系映射)框架,它内部封装了 JDBC,开发时只需要关注 SQL 语句本身,不需要花费精力去处理加载驱动、创建连接、创建statement 等繁杂的过程。程序员直接编写原生态 sql,可以严格控制 sql 执行性能,灵活度高。 2. MyBatis 可以使用 XML 或注解来配置和映射原生信息,将 POJO 映射成数据库中的记录,避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集。 缺点: 1. SQL语句的编写工作量较大,尤其当字段多、关联表多时,对开发人员编写SQL语句的功底有一定要求
|
6月前
|
SQL 缓存 Java
|
11月前
|
Java 数据库连接 测试技术
mybatis中@Many
mybatis中@Many
100 0
|
SQL Java 数据库连接
14MyBatis - MyBatis介绍
14MyBatis - MyBatis介绍
43 0