博客

什么是Mybatis?

是优秀的持久层框架,

支持定制化SQL,存储过程以及高级映射,能避免几乎所有的JDBC代码和手动设置参数以及获取结果集,

可以使用简单的简单的XML或注解来配置和映射原生类型,接口和java的POJC为数据库中的记录

如何获得Mybatis?

1.maven仓库

Github

持久化

数据持久化

• 持久化就是将程序的数据持久状态和瞬时状态转化的过程
• 内存:断电即失
• 数据库(jdbc),io文件持久化

为什么需要持久化


有一些对象,不能让它丢掉

持久层

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

为什么需要Mybatis?

• 帮助程序员将数据存入到数据库中。
• 方便
• 传统的JDBC代码太复杂了,简化,框架,自动化
• 简单易学
• 灵活
• sql和代码的分离,提高了可维护性
• 提供映射标签,支持对象关系组件维护
• 提供xml标签,支持编写动态sql
• 
  使用的人多
  

第一个Mybatis程序

搭建数据库



导入配置 (jar包)

 <!--Mybatis-->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.4.2</version>
        </dependency>

        <!--Mysql-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.16</version>
        </dependency>
         <!--junit单元测试-->
        <!-- https://mvnrepository.com/artifact/junit/junit -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>provided</scope><!--test  也是不会被打包到war包-->
        </dependency>

创建一个模块



编写代码

• 实体类
• Mapper接口

增删改查

• namespace=“某个接口的名称”
• select选择查询语句
  
  id:就是对应的namespace中的方法名
  
  parmeterType=“参数类型”
  
  #{属性名}value(?,?,?) 赋值方式是预编译的 安全的 可以防止sql注入
  
  ${属性}:vlues(‘admin’,‘111’,‘男’) 字符串拼接方式 是不安全的
  
  ${}多用来传列名,而不是传数据
  
  select
  
  
  
  c

  o

  l

  u

  m

  n

  1

  ,

  {column1},
  
  
  
  
  
  
  
  c
  
  
  o
  
  
  l
  
  
  u
  
  
  m
  
  
  n
  
  
  1
  
  
  
  ,
  
  
  
  
  
  {column2} from admin order by ${column}
  
  useGeneratedKeys=“true” 可以返回刚插入的主键
  
  keyColumn=“id” 告知主键列
  
  keyProperty=“id” 告知主键列的对应的属性

• Insert 增加语句
  
  resultType=“Admin” 返回值的类型 创建一个对对象
  
  将数据库自动映射到java对象中 ,有前提:表中的列名与类中的属性名相同
  
  开启驼峰命名自动映射 从数据库命名转java驼峰命名 user_name -userName
  
  特情况下 列名与属性名就是不一致,怎么解决映射问题
  
  resultMap 结果映射
• Delete 删除语句
• Update 修改语句

注意增删改休要提交事务

sqlSession.commit();

Map传递参数,直接在sql中取出key即可

对象传递参数,直接在sql中取对象的属性即可

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

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


模糊查询


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

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

2.在sql中拼接使用通配符!(安全一些)

select * from admin where name like "%"#{value}"%"

配置解析

1.核心配置文件

MyBatis 的 XML 配置文件包含了设置和影响 MyBatis 行为的属性。XML 配置文件的层次结构如

下：

configuration
	o properties
	o settings
	o typeAliases
	o typeHandlers
	o objectFactory
	o plugins
	o environments
		environment
		• transactionManager
		• dataSource
o mappers

2.环境配置

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

3.属性

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

<!--
	environments  配置与数据库 连接的相关信息
	-->
	<environments default="development">
		<!--配置开发信息-->
		<environment id="development">
			<!--事务管理类型  使用JDBC事务管理
			事务:一次对数据库操作的若干个流程的管理
			-->
			<transactionManager type="JDBC">
			</transactionManager>
			<!--数据源-->
			<!--UNPOOLED:不使用数据库连接池   POOLED:使用数据库连接池-->
			<dataSource type="UNPOOLED">
				<!--数据库驱动-->
				<property name="driver" value="${driverClassName}" />
 				<!--数据库地址-->
				<property name="url" value="${url}" />
				<property name="username" value="${userName}" />
				<property name="password" value="${passWord}" />
			</dataSource>
		</environment>
	</environments>

• 可以直接引入外部文件
• 可以在其中增加一些属性配置
• 如果两个文件有同一跟字段,优先使用外部文件的!

4.类型别名

• 类型别名是为java类型设置一个短的名字
• 存在的意义仅在于用来减少类完全限定名的冗余。

!--为类定义别名-->
	<typeAliases>
		<typeAlias type="com.ffyc.mybatis.model.Admin" alias="Admin"></typeAlias>
		<typeAlias type="com.ffyc.mybatis.model.Employee" alias="Employee"></typeAlias>
		<typeAlias type="com.ffyc.mybatis.model.Dept" alias="Dept"></typeAlias>


	</typeAliases>

也可以指定一个包名,Mybatis会在包名下搜索需要的javaBean ,比如扫描实体类的包,它的默认别名就为这个类的类名,首字母小写

<typeAliases>
	<package name="com.ffyc.mybatis.model"/>
</typeAliases>

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

如果实体类比较多的时候建议使用第二中

第一种可以自定义包名

第二种自定义包名需要在实体类上加注解标签

@Alias("Admin")
public class Admin{
}

5.设置





plugins插件

mybatis-generator-core

mybatis-plus

通用mapper

7.映射器(mappers)

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

方式一:[推荐使用]

<!--每一个Mapper.XML都需要在Mybatis核心配置文件中注册-->
<!--添加sql映射文件-->
	<mappers>
		<mapper resource="mapper/AdminMapper.xml"/>
		<mapper resource="mapper/EmployeeMapper.xml"/>
		<mapper resource="mapper/DeptMapper.xml"/>
	</mappers>

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

<!--每一个mapper文件都需要在Mybatis核心配置文件中注册绑定-->
<mappers>
		<mapper resource="com.ffyc.mapper.AdminMapper"/>
</mappers>

方式二注意点:

• 接口和mapper配置文件必须同名
• 接口和它的mapper配置文件必须在同一个包下

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

<!--每一个mapper文件都需要在Mybatis核心配置文件中注册绑定-->
<mappers>
		<package name="com.ffyc.mapper"/>
</mappers>

方式三注意点:

• 接口和mapper配置文件必须同名
• 接口和它的mapper配置文件必须在同一个包下

8.生命周期

声明周期和作用域是至关重要的,因为错误的使用会导致非常严重的并发问题


SqlSessionFactoryBuilder:

• 一旦创建了SqlSessionFactory,就不再需要它了
• 局部变量

SqlSessionFactory

• 可以想象成一个数据库连接池
• SqlSessionFactory一旦被创建就应该在应用的运行期间一直存在,没有任何理由丢弃它说着重新创建另一个实例
• 因此sqlSessionFactory的最佳作用域是作用域。
• 最简单的就是使用单例模式或者静态单例模式。
  
  SqlSession
• 连接到连接池的一个请求!
• SqlSession的实例是线程安全的,因此是不能被共享的,因此是不能被共享的,所以它的最佳的作用域是请求或方法作用域。
• 用完之后关闭请求,否则资源被占用!
  
  

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

数据库中的字段域实体类中的字段不一致


解决办法

• 起别名
• 开启驼峰命名自动映射

<!--是否开启驼峰命名自动映射,即从经典数据库列名 A_COLUMN 映射到经典Java属性名 aColum-->
		<setting name="mapUnderscoreToCamelCase" value="true"/>

• 结果集映射

<!--resultType="Admin"  返回值的类型 创建一个对对象
        将数据库自动映射到java对象中 ,有前提:表中的列名与类中的属性名相同
        开启驼峰命名自动映射  从数据库命名转java驼峰命名  user_name -userName
        特情况下 列名与属性名就是不一致,怎么解决映射问题
        resultMap  结果映射
            -->
            <resultMap id="adminMap" type="Admin">
        <!--表中列名与类中属性名一样的可以不写-->
        <id column="id" property="id"></id>
        <result column="account" property="account"></result>
        <result column="pass_word" property="passWord"></result>
        <result column="sex" property="sex1"></result>
    </resultMap>
  <select id="getAdminById" resultMap="adminMap">
        select * from admin where id = #{id};
    </select>

• resultMap元素是Mybatis中最中重要强大的功能
• ResultMap的设计思想是,对于简单的语句根本不需要配置显示的结果映射,而对于复杂一点的语句只需要描述它们的关系就行了。
• ResultMap最优秀在于,虽然你已经对它相当了解了,但是根本就不需要显示地用到它们。

日志

日志工厂


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

曾经:sout, debug

现在:日志工厂!

• SLF4J
• LOG4J[掌握]
• LOG4J2
• JDK_LOGGING
• COMMONS_LOGGING
• STDOUT_LOGGING[掌握]
• NO_LOGGING
  
  在Mybatis中具体首页那个由我们的配置决定
  
  标准日志工厂实现:
  
  第一种:STDOUT_LOGGING[掌握]

<settings>
		<!--配置日志实现 使用STDOUT_LOGGING添加log4j 这个不要导入jar包-->
		<setting name="logImpl" value="STDOUT_LOGGING"/>
</settings>	

第二种:LOG4J[掌握]

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

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

log4j.properties文件配置:

log4j.rootLogger = debug,stdout,D
#System out Console
log4j.appender.stdout = org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target = System.out
log4j.appender.stdout.layout = org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern = [%p] %d{yyyy-MM-dd HH:mm:ss,SSS} %m%n
#System out File
log4j.appender.D = org.apache.log4j.FileAppender
log4j.appender.D = org.apache.log4j.DailyRollingFileAppender
log4j.appender.D.File = D://FFjava/logs/log.log
log4j.appender.D.Append = true
log4j.appender.D.layout = org.apache.log4j.PatternLayout
log4j.appender.D.layout.ConversionPattern = %d{yyyy-MM-dd HH:mm:ss}  [ %t:%r ] - [ %p ] -[%l] %m%n

配置实现

<!--配置日志实现   使用log4j  添加log4j的配置文件 导入jar包和配置属性文件-->
<settings>
		<setting name="logImpl" value="LOG4J"/>
</settings>	

简单使用


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

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

static Logger logger=Logger.getLogger(AdminMapperTest.calss)

3.日志级别

logger.info()
logger.debug()
logger.error()

分页

为什么要分页

• 减少数据的处理

使用Limit分页

语法:select * from user limit startIndex,pageSize;
SELECT * FROM admin LIMIT 0,2
若后面只给一个参数,表示从零开始,到这个数

使用Mybatis实现分页

AdminMapper

   //分页查询
    List<Admin> getAdminListlimit(Map<String,Integer> map);

AdminMapper.XML

 <select id="getAdminListlimit" resultType="Admin" parameterType="map">
        select * from admin limit #{startIndex},#{pageSize}
    </select>

测试类

@Test
//分页查询
    public void find6(){
    SqlSession sqlSession= MybatisUtil.getSqlSession();
    AdminMapper mapper = sqlSession.getMapper(AdminMapper.class);
    Map<String,Integer> map=new HashMap<>();
    map.put("startIndex",0);
    map.put("pageSize",4);
    List<Admin> adminListlimit = mapper.getAdminListlimit(map);
    for (Admin admin:adminListlimit
         ){
        System.out.println(admin);
    }
   
}

结果

RoWBounds分页(了解,不建议使用)


不在使用SQL实现分页

1.接口

//分页查询(RowBounds类)
    List<Admin> getAdminRowBounds();

2.mapper.xml

   <select id="getAdminRowBounds" resultMap="adminMap">
        select * from admin
    </select>

3.测试

   //分页查询(RowBounds)
    @Test
    public void find7(){
    SqlSession sqlSession=MybatisUtil.getSqlSession();
    //RowBounds实现
        RowBounds rowBounds = new RowBounds(0, 1);
        List<Admin> adminList = sqlSession.selectList("com.ffyc.mybatis.mapper.AdminMapper.getAdminRowBounds",null,rowBounds);
        AdminMapper mapper = sqlSession.getMapper(AdminMapper.class);
        mapper.getAdminRowBounds();
        for (Admin admin:adminList
        ){
            System.out.println(admin);
        }
        sqlSession.close();
    }

4.结果

分页插件

(扩展了解)


查价文档连接

使用注解开发

面向接口编程

• 大家之前都学过面向对象编程,也学习过接口，但在真正的开发中，很多时候我们会选择面向接口编程.**根本原因:
  
  解耦
  
  ,可拓展,提高复用，分层开发中,上层不用管具体的实现,大家都遵守共同的标准,使得
  
  开发变得容易,规范性更好
• 在一个面向对象的系统中，系统的各种功能是由许许多多的不同对象协作完成的。在这种情况下，各个对象内部是如何实现自己的,对系统设计人员来讲就不那么重要了:
• 而各个对象之间的协作关系则成为系统设计的关键。小到不同类之间的通信，大到各模块之间的交互，在系统设计之初都是要着重考虑的，这也是系统设计的主要工作内容。面向接口编程就是指按照这种思想来编程。

关于接口的理解

• 接口从更深层次的理解，应是定义(规范,约束)与实现(名实分离的原则)的分离。
• 接口的本身反映了系统设计人员对系统的抽象理解。
• 接口应有两类:
• 第一类是对一个个体的抽象，它可对应为-一个抽象体(abstract class);
• 第二类是对一个个体某- -方面的抽象, 即形成-个抽象面(interface) ;
• 个体有可能有多个抽象面。抽象体与抽象面是有区别的。

三个面向区别

• 面向对象是指,我们考虑问题时,以对象为单位,考虑它的属性及方法
• 面向过程是指,我们考虑问题时,以一个具体的流程(事务过程)为单位,考虑它的实现
• 接口设计与非设计是针对复用技术而言的,与面向对象(过程)不是一个问题,更多的体现就是对系统整体的构架

使用注解开发

• 简单语句的用注解

• 底层实现:动态代理
  
  

• 本质:反射机制实现

• 直接在接口上实现

CRUD

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

• 方法存在多个参数时,必须使用@Param区分
  
  

//设置自动提交事务则就不用  sqlSession.commit();
public static SqlSession getSqlSession(){
        return  sqlSessionFactory.openSession(true);
    }

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

关于@Param()注解

• 基本类型的参数或String类型,需加上
• 应用类型不需要加
• 如果我们只有一个参数的话,可以忽略,单建议加上
• 我们在SQL中引用的就是我们这里的@Param(” “)中的设定的属性名!

关于#{ }与${}的区别

 #{属性名}value(?,?,?) 赋值方式是预编译的 安全的 可以防止sql注入
 ${属性}:vlues('admin','111','男') 字符串拼接方式 是不安全的
 ${}多用来传列名,而不是传数据
 select ${column1},${column2}  from admin order by ${column}

Lombok

• lombok是一个可以通过简单的注解的形式来帮助我们简化消除一些必须有但显得很臃肿的 Java 代码的工具，简单来说，比如我们新建了一个类，然后在其中写了几个字段，然后通常情况下我们需要手动去建立getter和setter方法啊，构造函数啊之类的，lombok的作用就是为了省去我们手动创建这些代码的麻烦，它能够在我们编译源码的时候自动帮我们生成这些方法。
• lombok能够达到的效果就是在源码中不需要写一些通用的方法，但是在编译生成的字节码文件中会帮我们生成这些方法，这就是lombok的神奇作用。

虽然有人可能会说IDE里面都自带自动生成这些方法的功能，但是使用lombok会使你的代码看起来更加简洁，写起来也更加方便。


使用步骤


1.在IDEA中安装Lombok插件

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

lombok的jar坐标
<!-- https://mvnrepository.com/artifact/org.projectlombok/lombok -->
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <version>1.18.10</version>
    <scope>provided</scope>
</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
@ExtensionMethod (Experimental, activate manually in plugin settings)
Lombok config system`

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

一对多,多对一

• 多个学生,对应一个老师
• 对于学生而言,关联…多个学生,关联一个老师[多对一]
• 对于老师而言,集合,一个老师,有很多学生[一对多]

环境搭建


1.导入lombok(根据自己意愿自行选择)

2.新建实体类Dept,Employee

3.建立Mapper接口

4.建立Mapper.XML文件

5.绑定注册核心配置

<!--嵌套查询-->
    <resultMap id="empmap1" type="Employee">
        <id column="id" property="id"></id>
        <result property="name" column="name"></result>
        <result column="sex" property="sex"></result>
        <result column="age" property="age"></result>
        <!--嵌套查询管理员-->
        <association property="admin" column="adminId" fetchType="lazy" javaType="Admin"  select="findadminById">
            <result column="account" property="account"></result>
        </association>
        <!--嵌套查询部门名称-->
        <!--
        fetchType="lazy" 开启延迟查询,前提时先要写成嵌套查询
        -->
        <association property="dept" column="deptId" javaType="Dept" fetchType="lazy" select="finddeptById">
            <result column="naem" property="name"></result>
        </association>
    </resultMap>

    <select id="getEmployeeById1" resultMap="empmap1">
        select id,name,sex,age,adminId,deptId from employee where id=#{id};
    </select>

    <!--嵌套管理员查询-->
    <select id="findadminById" resultType="Admin">
        select account from admin where id=#{adminId}
    </select>
    <!--嵌套部门查询-->
    <select id="finddeptById" resultType="Dept">
        select name from dept where id=#{deptId}
    </select>

回顾Masql多对一查询

• 子查询
• 联表查询

一对多

<!--namespace="某个接口的名称"-->
<mapper namespace="com.ffyc.mybatis.mapper.DeptMapper">
<resultMap id="deptmap" type="Dept">
   <id column="id" property="id"></id>
    <result column="dname" property="name"></result>
    <association property="admin" javaType="Admin">
        <result column="account" property="account"></result>
    </association>
    <!--由于一个部门有多个员工,所以需要封装(用collection)-->
    <collection property="employees" javaType="list" ofType="Employee">
        <result column="ename" property="name"></result>
    </collection>
</resultMap>
    <select id="getDeptById" resultMap="deptmap">
SELECT
  d.id,
  d.name dname,
  a.account,
  emp.name ename
FROM
  dept d
  LEFT JOIN admin a
    ON d.adminId = a.id
  LEFT JOIN employee emp
    ON d.id = emp.deptId
    WHERE d.id=#{id}
    </select>
    <select id="getDeptList" resultMap="deptmap">
        SELECT
  d.id,
  d.name dname,
  a.account,
  emp.name ename
FROM
  dept d
  LEFT JOIN admin a
    ON d.adminId = a.id
  LEFT JOIN employee emp
    ON d.id = emp.deptId
    </select>
</mapper>

小结


1.关联 associattion [ 多对一]

2.集合 collection [ 一对多]

3.javaType &ofType

1. javaTpye:用来指定实体类中的属性类型
2. ofType用来指定映射到Loist或者集合中的pojp类型,泛型中的约束类型!

注意点

• 保证SQL的可读性,尽量保证通俗易懂
• 注意一对多和多对一中,属性名和字段名的问题
• 如果问题不好排查,建议使用Log4J

面试高频

• Mysql引擎
• InnoDB底层原理
• 索引
• 索引优化

动态SQL

什么是动态sql


动态sql就是指根据不同的条件生成不同的sql语句

• 
  trim
  
  :当if有成立条件时,添加一个指定的前缀如果以and or等开头可以覆盖掉关键字

   <select id="getEmployeeList" parameterType="Employee" resultMap="empmap">
        SELECT
        emp.id,
        emp.name ename,
        emp.sex,
        emp.age,
        d.name dname,
        a.account
        FROM
        employee emp
        LEFT JOIN dept d
        ON emp.deptId = d.id
        LEFT JOIN admin a
        ON emp.adminID=a.id
        <trim prefix="where" prefixOverrides="and|or">
            <if test="name!=null&amp;name!=''">
                emp.name=#{name}
            </if>
            <if test="age!=null">
                and emp.age=#{age}
            </if>
        </trim>
    </select>-->

• 
  where
  

<update id="updateAuthorIfNecessary">
  update Author
    <set>
      <if test="username != null">username=#{username},</if>
      <if test="password != null">password=#{password},</if>
      <if test="email != null">email=#{email},</if>
      <if test="bio != null">bio=#{bio}</if>
    </set>
  where id=#{id}
</update>

• 
  choose
  
  : choose where test=” “成立执行otherwise 不成立就执行

<select id="findActiveBlogLike"
     resultType="Blog">
  SELECT * FROM BLOG WHERE state = ‘ACTIVE’
  <choose>
    <when test="title != null">
      AND title like #{title}
    </when>
    <when test="author != null and author.name != null">
      AND author_name like #{author.name}
    </when>
    <otherwise>
      AND featured = 1
    </otherwise>
  </choose>
</select>

• 
  set
  
  :set元素可以去掉最后一个逗号

<select id="findActiveBlogLike"
     resultType="Blog">
  SELECT * FROM BLOG
  WHERE
  <if test="state != null">
    state = #{state}
  </if>
  <if test="title != null">
    AND title like #{title}
  </if>
  <if test="author != null and author.name != null">
    AND author_name like #{author.name}
  </if>
</select>

• 
  foreach
  
  :动态 SQL 的另一个常见使用场景是对集合进行遍历（尤其是在构建 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>

• 
  SQL片段
  
  
  有时候,我们可能会将一些功能的部分抽取出来,方便服用!
  
  1.使用SQL标签抽取公共的部分

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

2.在需要使用的地方使用include标签引用即可

<select id="queryBlogIF" parmeterType="map" resultType="blog">
   select * from blog
   <where>
   		<include refid="if-title-author"></include>
   	</where>
</select>

注意事项

• 最好的基于单表来定义SQL片段!
• 不要存在where标签

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

缓存

简介

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

1.什么是缓存?

• 存在内存中的临时数据
• 将用户经常查询的数据放在缓存(内存)中,用户去查询数据就不能从磁盘上(关系型数据库数据文件)查询,从缓存中查询,从而提高查询效率,解决了高并发系统的性能问题。
  
  
  2.为什么使用缓存?
  
• 减少和数据库交互的次数,减少系统开销,提高系统效率
  
  3.
  
  什么样的数据库可以使用缓存?
  
• 经常出啊寻并且不经常改变的数据

Mybatis缓存

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

一级缓存

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

测试一级缓存步骤

• 开启日志
• 测试在一个Session中查询两次相同记录
• 查看日志输出

缓存失效的情况

• 查询不用的东西
• 增删改操作,可能会改变原来的数据,所以必定会刷新缓存
• 查询不同的Mapper.xml
• 手动清理缓存

 sqlSession.clearCache();//手动清理缓存

小结

• 一级缓存默认是开启的,只在一次sqlSession中有效,也就是从创建到关闭
• 一级缓存相当于一个map

二级缓存

• 二级缓存也叫全局缓存,一级缓存作用域太低了,所以诞生了二级缓存
• 基于namespace级别的缓存,一个名称空间,对应一个二级缓存
• 工作机制
  
  1.一个会话查询一条数据,这个数据就会被放在当前会话的一级缓存中;
  
  2.如果当前会话关闭了,这个会话对应的一级缓存就没了;但是我们想要的是,会话关闭了,一级缓存数据被保存到二级缓存中去;
  
  3.新的会话查询信息,就可以从二级缓存中获取内容;
  
  4.不同的mapper查询出的数据会放在自己对应的缓存(map)中;

使用步骤


1.开启全局缓存

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

2.在要使用二级缓存Mapper.xml中开启

这个更高级的配置创建了一个 FIFO 缓存，每隔 60 秒刷新，最多可以存储结果对象或列表的 512 个引用，而且返回的对象被认为是只读的，因此对它们进行修改可能会在不同线程中的调用者产生冲突。
<cache
  eviction="FIFO"
  flushInterval="60000"
  size="512"
  readOnly="true"/>
 LRU – 最近最少使用：移除最长时间不被使用的对象。
FIFO – 先进先出：按对象进入缓存的顺序来移除它们。
SOFT – 软引用：基于垃圾回收器状态和软引用规则移除对象。
WEAK – 弱引用：更积极地基于垃圾收集器状态和弱引用规则移除对象。

小结

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

缓存原理

• 缓存顺序:

1. 第一次查询会先查看二级缓存中有没有,
2. 再看一级缓存中有没有
3. 两个都没有,查询数据库

下一章: spring了解

点此跳转spring学习地址