Mybatis

Mybatis

环境:

  • JDK1.8

  • Mysql 5.7 8.0

  • maven 3.6.1

  • IDEA

回顾:

  • JDBC

  • Mysql

  • Java基础

  • Maven

  • Junit

 

SSM框架:都是有配置文件的。最好的方式:看官方文档;

1、简介

1.1、什么是Mybatis

 

 

  • MyBatis 是一款优秀的持久层框架

  • 它支持自定义 SQL、存储过程以及高级映射。

  • MyBatis 免除了几乎所有的 JDBC 代码以及设置参数和获取结果集。

  • MyBatis 可以通过简单的 XML 或注解来配置和映射原始类型、接口和 Java POJO(Plain Old Java Objects,普通老式 Java 对象)为数据库中的记录。

  • MyBatis本是apache的一个开源项目iBatis,2010年这个项目由apache software foundation迁移到了google code,并且改名为MyBatis。

  • 2013年11月迁移到Github

 

如何获得Mybatis?

 

1.2、持久化

数据持久化

  • 持久化就是将数据在持久状态和瞬时状态转换的过程

  • 内存:断电即失

  • 数据库(jdbc),io文件持久化。

  • 生活:冷藏、罐头。

为什么需要持久化?

  • 有一些对象,不能让他丢掉。例:支付宝的钱如果丢了,你不得打死他!

  • 内存太贵了

 

1.3、持久层

Dao层,Service层,Controller层….

  • 完成持久化工作的代码块。

  • 界限十分明显。

 

1.4、为什么需要Mybatis?

  • 帮助程序猿将数据存入到数据库中。

  • 方便

  • 传统打的 JDBC代码太复杂了。简化。框架。自动化。

  • 不用Mybatis也可以。更容易上手。技术没有高低之分

  • 优点:

    • 简单易学

    • 灵活:mybatis不会对应用程序或者数据库的现有设计强加任何影响。 sql写在xml里,便于统一管理和优化。通过sql语句可以满足操作数据库的所有需求。

    • sql和代码的分离,提高了可维护性。

    • 提供映射标签,支持对象与数据库的orm字段关系映射。

    • 提供对象关系映射标签,支持对象关系组建维护。

    • 提供xml标签,支持编写动态sql。

 

最重要的一点:使用的人多!

Spring、SpringMVC、SpringBoot、SpringCloud!

 

2、第一个Mybatis程序

思路:搭建环境- - >导入Mybatis- - >编写测试代码- - >测试!

 

2.1、搭建环境

搭建数据库

 CREATE DATABASE `mybatis`;
 ​
 USE `mybatis`;
 ​
 CREATE TABLE `user`(
   `id` INT(20) NOT NULL PRIMARY KEY,
   `name` VARCHAR(30) DEFAULT NULL,
   `pwd` VARCHAR(30) DEFAULT NULL
 )ENGINE=INNODB DEFAULT CHARSET=utf8;
 ​
 INSERT INTO `user`(`id`,`name`,`pwd`)VALUES
 (1,'狂神','123456'),
 (2,'张三','123456'),
 (3,'秦疆','111111')

 

新建项目

  1. 新建一个普通的maven项目

  2. 删除src目录

  3. 导入maven依赖

<?xml version="1.0" encoding="UTF-8"?>
 <project xmlns="http://maven.apache.org/POM/4.0.0"
          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
     <modelVersion>4.0.0</modelVersion>

     <!--父工程-->
     <groupId>org.example</groupId>
     <artifactId>Mybatis-Study</artifactId>
     <version>1.0-SNAPSHOT</version>

     <!--导入依赖-->
     <dependencies>
         <!--mysql驱动-->
         <dependency>
             <groupId>mysql</groupId>
             <artifactId>mysql-connector-java</artifactId>
             <version>8.0.27</version>
         </dependency>

         <!--mybatis-->
         <!-- https://mvnrepository.com/artifact/org.mybatis/mybatis -->
         <dependency>
             <groupId>org.mybatis</groupId>
             <artifactId>mybatis</artifactId>
             <version>3.5.9</version>
         </dependency>

         <!--junit-->
         <dependency>
             <groupId>junit</groupId>
             <artifactId>junit</artifactId>
             <version>4.12</version>
         </dependency>
     </dependencies>

 </project>

 

2.2、搭建一个模块

  • 编写mybatis核心配置文件

 <?xml version="1.0" encoding="UTF-8" ?>
 <!DOCTYPE configuration
         PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
         "http://mybatis.org/dtd/mybatis-3-config.dtd">
 <!--核心配置文件-->
 <configuration>
     <!--environments 环境配置-->
     <environments default="development">
         <environment id="development">
             <transactionManager type="JDBC"/><!--transactionManager 事务管理-->
             <dataSource type="POOLED">
                 <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
                 <property name="url" value="jdbc:mysql://localhost:3306/mybatis?useSSL=true&amp;useUnicode=true&amp;characterEncoding=UTF-8"/>
                 <property name="username" value="root"/>
                 <property name="password" value="123456"/>
             </dataSource>
         </environment>
     </environments>
 </configuration>
  • 编写mybatis工具类

     package com.kuang.utils;
     ​
     import org.apache.ibatis.io.Resources;
     import org.apache.ibatis.session.SqlSession;
     import org.apache.ibatis.session.SqlSessionFactory;
     import org.apache.ibatis.session.SqlSessionFactoryBuilder;
     ​
     import java.io.IOException;
     import java.io.InputStream;
     ​
     //sqlSessionFactory -- > sqlSession
     public class MybatisUtils {
     ​
         private static SqlSessionFactory sqlSessionFactory;//在这里提升了
     ​
         static {
             //使用 Mybatis第一步: 获取 sqlSessionFactory对象
             try {
                 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();//优化
     ​
             //SqlSession sqlSession = sqlSessionFactory.openSession();//这里要拿到 sqlSessionFactory,所以提升作用域
             //return sqlSession;
         }
     }
     ​

 

2.3、编写代码

  • 实体类

 package com.kuang.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;
     }
 ​
     @Override
     public String toString() {
         return "User{" +
                 "id=" + id +
                 ", name='" + name + '\'' +
                 ", pwd='" + pwd + '\'' +
                 '}';
     }
 }
  • Dao接口

 public interface UserDao {
     List<User> getUserList();
 }
  • 接口实现类由原来的UserMapperImpl转换为Mapper配置文件

 <?xml version="1.0" encoding="UTF-8" ?>
 <!DOCTYPE mapper
         PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
         "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
 ​
 <!--namespace= 绑定一个对应的Dao/Mapper接口 -->
 <mapper namespace="com.kuang.dao.UserDao">
     <!--select 查询语句-->
     <select id="getUserList" resultType="com.kuang.pojo.User">
         select * from mybatis.user
     </select>
 </mapper>

 

2.4、测试

注意点:

org.apache.ibatis.binding.BindingException: Type interface com.kuang.dao.UserDao is not known to the MapperRegistry.

MapperRegistry是什么?

出现这个就代表没有注册mappers

 <mappers>
   <mapper resource="com/kuang/dao/UserMapper.xml"/>
 </mappers>
  • junit测试:

 package com.kuang.dao;
 ​
 import com.kuang.pojo.User;
 import com.kuang.utils.MybatisUtils;
 import org.apache.ibatis.session.SqlSession;
 import org.junit.Test;
 ​
 import java.util.List;
 ​
 public class UserDaoTest {
 ​
     @Test
     public void test(){
 ​
         //第一步:获取 SqlSession
         SqlSession sqlSession = MybatisUtils.getSqlSession();
 ​
         //方式一:getMapper
         UserDao mapper = sqlSession.getMapper(UserDao.class);
         List<User> userList = mapper.getUserList();
 ​
         for (User user : userList) {
             System.out.println(user);
         }
 ​
         //关闭sqlSession
         sqlSession.close();
 ​
     }
 }

程序的步骤

 

你们可能会遇到的问题:

1.配置文件没有注册

2.绑定接口错误

3.方法名不对

4.返回类型不对

5.Maven导出资源问题

 

还有错误看下面看看是否有你的问题:

初始化异常失败

 

出现这个你会发现你明明写了呀,但是就是不存在!你可以把UserMapper.xml放在target中对应的目录中就可以正常运行,所以这里就会出现一个问题,约定大于配置!

 

     <build>
         <resources>
             <resource>
                 <directory>src/main/java</directory>
                 <includes>
                     <include>**/*.properties</include>
                     <include>**/*.xml</include>
                 </includes>
                 <filtering>false</filtering>
             </resource>
             <resource>
                 <directory>src/main/resources</directory>
                 <includes>
                     <include>**/*.properties</include>
                     <include>**/*.xml</include>
                 </includes>
                 <filtering>false</filtering>
             </resource>
         </resources>
     </build>

 

而且你可能还会遇到的问题,这里我的运行时出现了Could not find resource mybatis-config.xml(找不到 xxx.xml)

如果出现了这个问题:请看这个博客:https://blog.csdn.net/qq_38589743/article/details/110263936,可以解决你的需求!

 

3、CRUD

在这里有的小伙伴可能会遇到一个问题就是为什么idea连接了数据库但是没有提示:

https://blog.csdn.net/qq_39510043/article/details/107978717可以看看这个,可以帮助你!

1、namespace

namespace中的包名要和 Dao/Mapper 接口的包名一直!

2、select

选择,查询语句:

  • id:就是对应的namespace中的方法名;

  • resultType:sql语句执行的返回值!

  • parameterType:参数类型!

 

  1. 编写接口

     //查询全部用户
     List<User> getUserList();
     //根据ID查询用户
     User getUserById(int id);
  2. 编写对应的mapper中的sql语句

 <!--select 查询语句-->
 <select id="getUserList" resultType="com.kuang.pojo.User">
   select * from mybatis.user;
 </select>
 <select id="getUserById" parameterType="int" resultType="com.kuang.pojo.User">
   select * from mybatis.user where id = #{id};
 </select>

3、测试

 @Test
 public void test(){
 ​
     //第一步:获取 SqlSession
     SqlSession sqlSession = MybatisUtils.getSqlSession();
 ​
     //方式一:getMapper
     UserMapper mapper = sqlSession.getMapper(UserMapper.class);
     List<User> userList = mapper.getUserList();
 ​
     //方式二:不推荐使用!
     //List<User> userList = sqlSession.selectList("com.kuang.dao.UserDao.getUserList");
 ​
     for (User user : userList) {
         System.out.println(user);
     }
 ​
     //关闭sqlSession
     sqlSession.close();
 ​
 }
 ​
 @Test
 public void getUserById(){
   SqlSession sqlSession = MybatisUtils.getSqlSession();
 ​
   UserMapper mapper = sqlSession.getMapper(UserMapper.class);
 ​
   User user = mapper.getUserById(1);
 ​
   System.out.println(user);
 ​
   sqlSession.close();
 }

3、Insert

1、编写接口

 //insert一个用户
 int addUser(User user);

2、编写mapper对应的sql

 <insert id="addUser" parameterType="com.kuang.pojo.User">
   insert into mybatis.user (id, name, pwd) VALUES (#{id},#{name},#{pwd});
 </insert>

3、测试

 //增删改需要提交事务!
 @Test
 public void addUser(){
     SqlSession sqlSession = MybatisUtils.getSqlSession();
 ​
     UserMapper mapper = sqlSession.getMapper(UserMapper.class);
 ​
     int i = mapper.addUser(new User(4, "桐人", "111222"));
 ​
     if (i > 0){
         System.out.println("插入成功!");
     }
     //提交事务!
     sqlSession.commit();
 ​
     sqlSession.close();
 }

4、update

1、接口

 //修改用户
 int updateUser(User user);

2、sql

 <update id="updateUser" parameterType="com.kuang.pojo.User">
     update mybatis.user set name=#{name} ,pwd=#{pwd} where id=#{id};
 </update>

3、测试

 @Test
 public void updateUser(){
     SqlSession sqlSession = MybatisUtils.getSqlSession();
 ​
     UserMapper mapper = sqlSession.getMapper(UserMapper.class);
 ​
     mapper.updateUser(new User(4,"桐人","123456"));
 ​
     sqlSession.commit();
 ​
     sqlSession.close();;
 }

5、Delete

1、接口

 //删除用户
 int deleteUser(int id);

2、sql

 <delete id="deleteUser" parameterType="int">
     delete from  mybatis.user   where id=#{id};
 </delete>

3、测试

 @Test
 public void deleteUser(){
     SqlSession sqlSession = MybatisUtils.getSqlSession();
 ​
     UserMapper mapper = sqlSession.getMapper(UserMapper.class);
 ​
     mapper.deleteUser(4);
 ​
     sqlSession.commit();
 ​
     sqlSession.close();
 }

 

注意点:

  • 增删改需要提交事务!

 

6、分析错误

  • 标签不要匹配错

  • resource 绑定 mapper,需要使用路径!

  • 程序配置文件必须规范!

  • NullPointerException,没有注册到资源!

  • 输出的xml文件中存在乱码!

  • maven资源没有导出问题!

 

7、万能的Map

假设,我们的实体类,或者数据库中的表、字段或者参数过多,我们应当考虑使用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","krito");
     map.put("password","2333333");
 ​
     mapper.addUser2(map);
 ​
     //提交事务!
     sqlSession.commit();
 ​
     sqlSession.close();
 }

 

Map传递参数,直接在sql中取出key即可! 【parameterType="map"】

对象传递参数,直接在SQL中取出对象的属性即可! 【parameterType="Object"】

只有一个基本类型参数的情况下,可以直接在sql中取到!

多个参数用Map,或者注解!

 

8、思考题

模糊查询怎么写?

1、java代码执行的时候,传递通配符% %

 List<User> userList = mapper.getUserLike("%李%");

2、在sql拼接中使用通配符!

 select * from mybatis.user where name like "%"#{value}"%"
 注意点:
 <!--
     select * from mybatis.user where id = ?
     select * from mybatis.user where id = 1 or 1=1
 -->
 <select id="getUserLike" resultType="com.kuang.pojo.User">
     select * from mybatis.user where name like concat(concat('%',#{value}),'%')
 </select>

 

4、配置解析

4.1、核心配置文件

  • mybatis.config.xml

  • MyBatis 的配置文件包含了会深深影响 MyBatis 行为的设置和属性信息。

 configuration(配置)
 properties(属性)
 settings(设置)
 typeAliases(类型别名)
 typeHandlers(类型处理器)
 objectFactory(对象工厂)
 plugins(插件)
 environments(环境配置)
 environment(环境变量)
 transactionManager(事务管理器)
 dataSource(数据源)
 databaseIdProvider(数据库厂商标识)
 mappers(映射器)

 

4.2、配置环境(environments)

Mybatis可以配置成适应多种环境

不过要记住:尽管可以配置多个环境,但每个 SqlSessionFactory 实例只能选择一种环境!

学会使用配置多套运行环境!

Mybatis默认的事务管理器是 JDBC,连接池:POOLED

4.3、properties(属性)

我们可以通过properties属性来实现引用配置文件

这些属性可以在外部进行配置,并可以进行动态替换。你既可以在典型的 Java 属性文件中配置这些属性,也可以在 properties 元素的子元素中设置。【db.properties】

编写一个配置文件

db.properties

 driver=com.mysql.jdbc.Driver
 url=jdbc:mysql://localhost:3306/mybatis?useSSL=true&useUnicode=true&characterEncoding=UTF-8
 username=root
 password=mysqlstart

在核心配置文件中引入

 <!--引入外部配置文件-->
 <properties resource="db.properties">
     <property name="username" value="root"/>
     <property name="password" value="mysqlstart"/>
 </properties>
  • 可以直接引入外部文件

  • 可以在其中添加一些属性配置

  • 如果两个文件有同一个字段,优先使用外部配置文件的!

 

4.4、类型别名(typeAliases)

  • 类型别名可为 Java 类型设置一个缩写名字。

  • 它仅用于 XML 配置,意在降低冗余的全限定类名书写。

 <!--可以给实体类起别名-->
 <typeAliases>
     <typeAlias type="com.kuang.pojo.User" alias="User"/>
 </typeAliases>

也可以指定一个包名,MyBatis 会在包名下面搜索需要的 Java Bean,比如:

扫描实体类的包,它的默认别名就是为这个类的类名,首字母小写!

 <!--可以给实体类起别名-->
 <typeAliases>
     <package name="com.kuang.pojo"/>
 </typeAliases>

 

在实体类比较少的时候,使用第一种方式。

如果实体类十分多,建议使用第二种。

第一种可以DIY别名,第二种则 不行 ,如果非要改,需要在实体类上增加注解

 @Alias("user")
 public class User {}

 

4.5、设置

这是Mybatis 中极其重要的调整设置,他们会改变Mybatis的运行时行为。

 

4.6、其他设置

  • typeHandlers(类型处理器)

  • objectFactory(对象工厂)

  • plugins(插件)

    • mybatis-generator-core

    • mybatis-plus

    • 通用mapper

 

4.7、映射器(mappers)

MapperRegistry:注册绑定我们的mapper文件;

方式一:【推荐使用】

 <!--每一个Mapper.xml都需要在Mybatis核心配置文件中注册!-->
 <mappers>
     <mapper resource="com/kuang/dao/UserMapper.xml"/>
 </mappers>

方式二:使用class文件绑定注册

 <!--每一个Mapper.xml都需要在Mybatis核心配置文件中注册!-->
 <mappers>
     <mapper class="com.kuang.dao.UserMapper"/>
 </mappers>

 

注意点:

  • 接口和他的Mapper配置文件必须同名!

  • 接口和他的Mapper配置文件必须在同一个包下!

 

方式三:使用扫描包进行注入绑定

 <!--每一个Mapper.xml都需要在Mybatis核心配置文件中注册!-->
 <mappers>
   <package name="com.kuang.dao"/>
 </mappers>

 

注意点:

  • 接口和他的Mapper配置文件必须同名!

  • 接口和他的Mapper配置文件必须在同一个包下!

 

练习:

  • 将数据库配置文件导入

  • 实体类别名

  • 保证UserMapper 接口 和UserMapper.xml 改为一致!并且放在同一个包下!

 

4.8、生命周期和作用域

不同作用域和生命周期类别是至关重要的,因为错误的使用会导致非常严重的并发问题

SqlSessionFactoryBuilder

  • 一旦创建了 SqlSessionFactory,就不需要它了

  • 局部变量

SqlSessionFactory

  • 说白了就是可以想象为:数据库连接池

  • SqlSessionFactory 一旦被创建就应该在应用的运行期间一直存在,没有任何理由丢弃它或重新创建另一个实例。

  • SqlSessionFactory 的最佳作用域是应用作用域。

  • 最简单的就是使用单例模式或者静态单例模式。

SqlSession

  • 连接到连接池的一个请求!

  • SqlSession 的实例不是线程安全的,因此是不能被共享的,所以它的最佳的作用域是请求或方法作用域。

  • 用完之后需要赶紧关闭,否则资源被占用!

 

这里的每一个mapper,都代表一个具体的业务!

 

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

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 【掌握】

  • LOG4J2

  • JDK_LOGGING

  • COMMONS_LOGGING

  • STDOUT_LOGGING 【掌握】

  • NO_LOGGING

 

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

STDOUT_LOGGING 标准日志输出

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

 <settings>
     <!--标准的日志工厂实现-->
     <setting name="logImpl" value="STDOUT_LOGGING"/>
 </settings>

 

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>

2.log4j.properties

 #将等级为DEBUG的日志信息输出到console和file这两个目的地,console和file的定义在下面的代码
 log4j.rootLogger=DEBUG,console,file
 ​
 #控制台输出的相关设置
 log4j.appender.console = org.apache.log4j.ConsoleAppender
 log4j.appender.console.Target = System.out
 log4j.appender.console.Threshold=DEBUG
 log4j.appender.console.layout = org.apache.log4j.PatternLayout
 log4j.appender.console.layout.ConversionPattern=【%c】-%m%n
 ​
 #文件输出的相关设置
 log4j.appender.file = org.apache.log4j.RollingFileAppender
 log4j.appender.file.File=./log/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

3.配置log4j为日志实现

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

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

 

 

简单使用

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

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

     static Logger logger = Logger.getLogger("UserMapperTest");
  3. 日志级别

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

 

案例:

 package com.kuang.dao;
 ​
 import com.kuang.pojo.User;
 import com.kuang.utils.MybatisUtils;
 import org.apache.ibatis.session.SqlSession;
 import org.apache.log4j.Logger;
 import org.junit.Test;
 ​
 ​
 ​
 ​
 public class UserMapperTest {
 ​
     static Logger logger = Logger.getLogger("UserMapperTest");
 ​
     @Test
     public void testgetUserLike(){
 ​
         //第一步:获取 SqlSession
         SqlSession sqlSession = MybatisUtils.getSqlSession();
 ​
         logger.info("测试,进入testgetUserLike,成功!");//在这里写一个提示信息
 ​
         //方式一:getMapper
         UserMapper mapper = sqlSession.getMapper(UserMapper.class);
         User userList = mapper.getUserById(1);
 ​
         System.out.println(userList);
 ​
         //关闭sqlSession
         sqlSession.close();
       }
 }

 

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);
  2. Mapper.xml

     <select id="getUserByLimit" parameterType="map" resultMap="UserMap">
         select * from mybatis.user limit #{startIndex} ,#{pageSize};
     </select>
  3. 测试

 @Test
 public void getUserByLimit(){
     SqlSession sqlSession = MybatisUtils.getSqlSession();
 ​
     UserMapper mapper = sqlSession.getMapper(UserMapper.class);
 ​
     HashMap<String, Integer> map = new HashMap<>();
 ​
     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();
  2. mapper.xml

     <select id="getUserByRowBounds"  resultMap="UserMap">
         select * from mybatis.user
     </select>
  3. 测试

     @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、面向接口编程

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

 

接口的理解

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

接口的本质反应了系统设计人员对系统的抽象理解

分为两类:

  • 第一类对一个个体的抽象,他可对应一个抽象体(abstart class)

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

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

 

三个面向区别

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

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

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

 

8.2、使用注解开发

  1. 注解在接口上实现

      @Select("select * from user")
      List<User> getUsers();
  2. 需要在核心配置文件中绑定接口!

     <!--绑定配置文件-->
     <mappers>
         <mapper class="com.kuang.dao.UserMapper"/>
     </mappers>
  3. 测试

     @Test
     public void getUserTest(){
         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();
     }

 

本质:反射机制实现

底层:动态代理!

 

Mybatis详细执行流程

在这里插入图片描述

 

8.3、CRUD

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

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

 

编写接口,增加注解

 package com.kuang.dao;
 ​
 import com.kuang.pojo.User;
 import org.apache.ibatis.annotations.*;
 ​
 import java.util.List;
 ​
 public interface UserMapper {
 ​
     @Select("select * from user")
     List<User> getUsers();
 ​
     // 方法存在多个参数,所有的参数前面必须加上 @Param("id") 注解
     @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);
 }

 

测试类

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

 import com.kuang.dao.UserMapper;
 import com.kuang.pojo.User;
 import com.kuang.utils.MybatisUtils;
 import org.apache.ibatis.session.SqlSession;
 import org.junit.Test;
 ​
 import java.util.List;
 ​
 public class UserMapperTest {
 ​
     @Test
     public void getUserTest(){
         SqlSession sqlSession = MybatisUtils.getSqlSession();
         //底层主要应用反射
         UserMapper mapper = sqlSession.getMapper(UserMapper.class);
 ​
         mapper.deleteUser(6);
 ​
 ​
         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(4,"尤吉欧","123456"));
      *
      *         mapper.updateUser(new User(6,"杂货","11117881"));
      */
 }

 

关于@Param()注解

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

  • 引用类型不需要加

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

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

 

#{} ${} 区别

可以简单理解为 PreparedStatement 与 Statement

使用${}会有SQL注入拼接问题,所以我们使用#{}

 

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

  • ith one annotation your class

 

使用步骤:

  1. 在IDEA中安装Lombok插件!

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

     <!-- https://mvnrepository.com/artifact/org.projectlombok/lombok -->
     <dependency>
         <groupId>org.projectlombok</groupId>
         <artifactId>lombok</artifactId>
         <version>1.18.22</version>
     </dependency>
  3. 在实体类上加注解

 @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
 Lombok config system
 Code inspections
 Refactoring actions (lombok and delombok)

 

说明:

 @Data :无参构造、get、set、tostring、hashcode、equals
 @AllArgsConstructor   有参构造
 @NoArgsConstructor    无参构造
 @Getter and @Setter
 @EqualsAndHashCode
 @ToString

图示:

 

10、多对一处理

多对一:

  • 多个学生对应一个老师

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

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

 

 

SQL:

 USE mybatis
 ​
 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');

对于多表查询:这里字段解析:

-- constraint 外键名 foreign key 外键字段 references 主表名(关联字段) [主表记录删除时的动作] [主表记录更新时的动作]
-- constraint可以省略,只是用来指定外键名: 约束

测试环境搭建

  1. 导入lombok

  2. 新建实体类 Teacher、Student

  3. 建立Mapper接口

  4. 建立Mapper.xml文件

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

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

 

按照查询嵌套处理

 <!--
     思路:
         1.查询所有的学生信息
         2.根据查询出来的学生的 tid ,寻找对应的老师!  子查询
 -->
 ​
 <select id="getStudent" resultMap="StudentTeacher">
     select * from mybatis.student ;
 </select>
 ​
 <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="getTeacher" resultType="Teacher">
     select * from mybatis.teacher where id = #{tid}
 </select>

 

 

按照结果嵌套处理

 <!--按照结果嵌套处理-->
 <select id="getStudent2" resultMap="StudentTeacher2">
     select s.id sid,s.name sname ,t.name tname
     from mybatis.student s,mybatis.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,s.name sname,t.name tname ,t.id tid
     from mybatis.teacher t,mybatis.student s
     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 mybatis.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 mybatis.student where tid = #{tid}
 </select>

 

 

小结:

  1. 关联 - association 【多对一】

  2. 集合 - collection 【一对多】

  3. javaType & ofType

    1. JavaType用来指定实体类中的类型

    2. ofType用来指定映射到List或者集合中的pojo类型,泛型中的约束类型

注意点:

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

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

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

 

慢SQL 1s 1000s

 

面试高频

  • Mysql引擎

  • InnoDB底层原理

  • 索引

  • 索引优化!

 

12、动态SQL

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

动态 SQL 是 MyBatis 的强大特性之一。如果你使用过 JDBC 或其它类似的框架,你应该能理解根据不同条件拼接 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. 导包

  2. 编写配置文件

  3. 编写实体类

     package com.kuang.pojo;
     ​
     import java.util.Date;
     ​
     @lombok.Data
     public class Blog {
         private int id;
         private String name;
         private String author;
         private Date createTime;
         private int views;
     }
  4. 编写实体类对应Mapper接口 和 Mapper.xml 文件

 

IF标签

接口

 //查询博客
 List<Blog> queryBlogIF(Map map);

配置文件(重点是这个!)

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

 

trim (where, set)

  • where 元素只会在子元素返回任何内容的情况下才插入 “WHERE” 子句。而且,若子句的开头为 “AND” 或 “OR”,where 元素也会将它们去除。

  • set 元素会动态地在行首插入 SET 关键字,并会删掉额外的逗号

  • trim可以自定义

 select * from mybatis.blog 
 <where>
     <if test="title != null">
        and 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片段

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

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

     <sql id="if-title-author">
         <if test="title != null">
             and title = #{title}
         </if>
         <if test="author != null">
             and author = #{author}
         </if>
     </sql>
  2. 在需要使用的地方使用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 (id=1 or id=2 or id=3)
 ​
 <foreach item="item" index="index" collection="list"
     open="ID in (" separator="," close=")" nullable="true">
     #{item}
 </foreach>
 ​
 <foreach item="id"  collection="ids"
     open="(" separator="or" close=")"">
     #{id}
 </foreach>
 ​
 (id=1 or id=2 or id=3)

接口

 //查询第1,2,3好记录的博客
 List<Blog> queryBlogForEach(Map map);

foreach

     <!--
         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>
 </mapper>

测试

 

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

建议:

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

 

13、缓存

13.1、简介

1.什么是缓存[Cache]?

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

 

  • 存在内存中的临时数据

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

2.为什么使用缓存?

  • 减少和数据库的交互次数,减少系统开销,提高系统效率

3.什么样的数据可以使用缓存?

  • 经常查询并且不经常改变的数据 【可以使用缓存】

 

13.2 MyBatis缓存

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

  • MyBatis系统中默认定义了两级缓存:一级缓存和二级缓存

    • 默认情况下,只有一级缓存开启(SqlSession级别的缓存,也称为本地缓存)

    • 二级缓存需要手动开启和配置,他是基于namespace级别的缓存。

    • 为了提高可扩展性,MyBatis定义了缓存接口Cache。我们可以通过实现Cache接口来定义二级缓存。

 

13.3 一级缓存

  • 一级缓存也叫本地缓存:SqlSession

    • 与数据库同一次会话期间查询到的数据会放在本地缓存中

    • 以后如果需要获取相同的数据,直接从缓存中拿,没必要再去查询数据库

 

测试步骤:

1.开启日志

2.测试在一个Session中查询两次记录

 //根据id查询用户
 User getUserById(@Param("id") int id);
 <select id="getUserById" resultType="user">
     select * from mybatis.user where id = #{id};
 </select>
 @Test
 public void test(){
 ​
     SqlSession sqlSession = MybatisUtils.getSqlSession();
 ​
     UserMapper mapper = sqlSession.getMapper(UserMapper.class);
 ​
 ​
     User userById = mapper.getUserById(2);
 ​
     System.out.println(userById);
 ​
     System.out.println("===================");
     User userById2 = mapper.getUserById(2);
 ​
     System.out.println(userById2);
 ​
     sqlSession.close();
 }

3.查看日志输出

 

缓存失效的情况:

1.查询不同的东西

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

3.查询不同的Mapper.xml

4.手动清理缓存

 

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

一级缓存就是一个Map!

 

13.4 二级缓存

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

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

  • 工作机制

    • 一个会话查询一条数据,这个数据就会被放在当前会话的一级缓存中

    • 如果会话关闭了,这个缓存对应的一级缓存就没了;但是我们想要的是,会话关闭了,一级缓存中的数据被保存到二级缓存中

    • 新的会话查询信息,就可以从二级缓存中获取内容

    • 不同的mapper查询出的数据会放在自己对应的缓存(map)中

一级缓存开启(SqlSession级别的缓存,也称为本地缓存)

  • 二级缓存需要手动开启和配置,他是基于namespace级别的缓存。

  • 为了提高可扩展性,MyBatis定义了缓存接口Cache。我们可以通过实现Cache接口来定义二级缓存。

 

步骤:

1.开启全局缓存

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

2.在Mapper.xml中使用缓存

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

也可以自定义参数

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

3.测试

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

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

序列化:

 @Data
 public class User implements Serializable {
     private int id;
     private String name;
     private String pwd;
 }

小结:

  • 只要开启了二级缓存,在同一个Mapper下就有效

  • 所有的数据都会放在一级缓存中

  • 只有当前会话提交,或者关闭的时候,才会提交到二级缓存中

 

 

13.5 缓存原理

在这里插入图片描述

 

注意:

  • 只有查询才有缓存,根据数据是否需要缓存(修改是否频繁选择是否开启)useCache=“true”

 <select id="getUserById" resultType="user" useCache="true">
   select * from user where id = #{id}
 </select>

 

13.6 自定义缓存-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.2.2</version>
 </dependency>

 

2.在mapper中指定使用我们的ehcache缓存实现

 <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 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"/>
 ​
 </ehcache>
     <!--
 ​
 defaultCache:默认缓存策略,当ehcache找不到定 义的缓存时,则使用这个缓存策略。只能定义个。
 ​
 -->
 ​
     <!--
 ​
     name;缓仔名称。
 ​
     maxE7 ementsInMemory:级存最大数目
 ​
     maxEl ementsonDisk:硬盘最大级存个数。
 ​
     eternal:对象是否水久有效,但设置 了,timeout将 不起作用。
 ​
     overflowToDisk:是否保存到磁盘,当系统当机时
 ​
     timeToIpleseconds:设置对象在失效前的允许闲置时间(单位:秒)。仅"eternal=false对象不是水
 ​
     久有效时使用,可选属性,默认值是0,也就是可闲置时间无穷 大。
 ​
     timeToLiveseconds:设置对象在失效前允许存活时间(单位:秒)。最大时间介于创建时间和失效时间之
 ​
     间。仅当eterna1=false对象不是永久有效时使用,默认是0.,也就是对象存活时间无穷大。
 ​
     diskPersistent:是否缓存虚拟机重启期数据whether the disk store persists between
 ​
     restarts of the virtua7 Machine. The default value is false.
 ​
     di skSpoolBuffersizeMB:这个参数设置Diskstore (磁盘缓存)的缓存区大小。默认是30MB。每个
 ​
     Cache都应该有自己的一个缓冲区。
 ​
     diskExpi ryThreadIntervalseconds:磁盘失效线程运行时间间隔,默认是120秒。
 ​
     memorystoreEvictionPolicy:当达imaxElements InMemory限制时。Ehcache将 会根据指定的策略
     
     去清理内存。默认策略是LRU (最近最少使用)。你可以设置为FIFO (先进先出)或是LFU (较少使用)。
     
     clearonFlush:内存数量最大时是否清除。
     
     memorystoreEvictionPolicy:可选策略有: LRU (最近最少使用,默认策略)、FIFO (先进先出)、
     
     FIFO, first in first out. 这个是大家最熟的,先进先出。
     
     LFU, Less Frequently used,就是上面例子中使用的策略,直白一点就是讲一直以来最少 被使用的。
     
     如士面所讲,缓存的元素有一个hit属性,hit值最小的将会被清出缓存。
     
     LRU. Least Recently Used,最近最少使用的,缓存的元素有一个时间戳,当缓存容量满了,而又需要
     
     腾出地方来缓存新的元素的时候,那么现有缓存元素中时问戳离当前时间最远的元素将被清出缓存。
     
     一一>

 

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

posted @ 2022-02-20 16:04  nakano_may  阅读(49)  评论(0编辑  收藏  举报