Mybatis笔记(超长,完结)

image-20200531213054908.png

学习资源来自于哔哩哔哩UP遇见狂神说,一个宝藏UP大家快去关注吧!记得三连加分享,不要做白嫖党.

Mybatis-9.28

环境:

  • JDK1.8
  • Mysql 5.7
  • maven 3.6.1
  • IDEA

回顾:

  • JDBC
  • Mysql
  • Java基础
  • Maven
  • Junit

SSM框架: 配置文件. 最好的方式: 看官网文档.Mybatis中文文档

1.简介

1.1什么是Mybatis

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

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

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

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

  • 原名iBatis,所以很多包的名字叫做iBatis

  • 2013年11月迁移到Github

如何获得Mybatis?

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

1.2 持久化

数据持久化

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

为什么需要持久化?

  • 有一些对象不能丢掉.

  • 内存太贵了

1.3 持久化

Dao层,Service层,Controller层...

  • 完成持久化工作的代码块
  • 层界限十分明显

1.4 为什么需要Mybatis?

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

  • 方便

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

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

  • 优点:(百度百科)

    • 简单易学
    • 灵活
    • sql和代码的分离,提高了可维护性。
    • 提供映射标签,支持对象与数据库的orm字段关系映射
    • 提供对象关系映射标签,支持对象关系组建维护
    • 提供xml标签,支持编写动态sql。

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

2. 第一个Mybatis程序

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

2.1 搭建环境

1.搭建数据库

CREATE DATABASE `mybatis`;

USE `mybatis`;

CREATE TABLE `user`(
`id` INT(20) NOT NULL,
`name`VARCHAR(20) NOT NULL DEFAULT 0 COMMENT '名字',
`pwd`VARCHAR(20) NOT NULL DEFAULT 123456 COMMENT '密码',
PRIMARY KEY (`id`)
)ENGINE = INNODB DEFAULT CHARSET = utf8;

INSERT INTO `user`(`id`,`name`,`pwd`) VALUES
(1,'张三','4354453'),
(2,'李四','434534453'),
(3,'王五','4545343')

2.新建项目

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

  2. 删掉src目录

  3. 导入maven依赖

    <!--导入依赖-->
    <dependencies>
        <!--mysql驱动-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
        </dependency>
        <!--mybatis-->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.2</version>
        </dependency>
        <!--junnit-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
    </dependencies>
    

2.2创建一个模块

2

  • 编写mybatis的核心配置文件
    3

    <?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核心配置环境-->
    <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://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工具类

    //sqlSessionFactory --> sqlSession
    public class MybatisUtils {
    
        private static SqlSessionFactory sqlSessionFactory;
    
        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,顾名思义,我们可以从中获得 SqlSession 的实例。
        // SqlSession 提供了在数据库执行 SQL 命令所需的所有方法。
    
        public static SqlSession sqlSession() {
            return sqlSessionFactory.openSession();
        }
    }
    

2.3 编写代码

  • 实体类(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接口

    //以后取名会用Mapper,这里先用Dao
    public interface UserDao {
        List<User> getUserList();
    }
    
  • 接口实现类由原来的UserDaoImpl转变为一个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.tan.dao.UserDao">
    
        <select id="getUserList" resultType="com.tan.pojo.User">
            select * from mybatis.user
        </select>
    </mapper>
    

2.4 测试

2.4.1 junit测试,第一种方法getMapper

public class UserDaoTest {

    @Test
    public void test() {

        //第一步: 获得SqlSession对象
        SqlSession sqlSession = MybatisUtils.sqlSession();

        //方式一: getMapper
        UserDao userDao = sqlSession.getMapper(UserDao.class);
        List<User> userList = userDao.getUserList();

        for (User user : userList) {
            System.out.println(user);
        }

        //关闭SqlSession
        sqlSession.close();
    }
}

结果: 报错

运行错误,报错纠错

注意点:

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

MapperRegistry(映射注册表)是什么?

4

每一个Mapper.xml都需要在Mybatis核心配置文件中注册!(注意这个错误的路径写法,这样写有问题,被这个问题坑了好久)

  • maven过滤设置

配置了Mappers之后仍然出错

5

从图中可以看出maven的生成文件中,dao包下的UserMapper.xml并没有生成,因为maven约定只会生成在resources下的.xml的配置文件,而UserMapper.xml在java代码包下.所以需要配置一下maven的资源过滤

pom.xml文件中添加一下代码:

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

写到这里我仍然出错,而且仍然是初始化错误,和没设置maven过滤的报错一样,找了半天排除了所有的常规错误.

6

问题解决: mybatis-config.xml的mappers配置中

之前是这样写的: 7

因为IDEA自动提示路径,所以我一直没有怀疑这里会有问题.

改成路径的格式后就正常了

8

test运行结果:

9

2.4.2 junit测试,第二种方法,直接执行sqlSession的方法

//方式二:
List<User> userList = sqlSession.selectList("com.tan.dao.UserDao.getUserList");

2.4.3 两种方法的区别

首先,不建议使用方法二

官网解释:

10

3. 总结

主要的7个步骤:

11

3. CRUD

1. namespace

namespace中的包名要和mapper接口的包名一致!

2. select

选择,查询语句;

  • id: 对应namespace中的方法名;
  • resultType: sql语句执行的返回值.
  • parameterType: 参数类型.
  1. 编写接口

    java//查询全部用户
    List<User> getUserList();
    
  2. 编写对应的mapper中的

    <!--select查询语句-->
        <select id="getUserList" resultType="com.tan.pojo.User">
        select *
        from mybatis.user
        </select>
    
  3. 测试

    @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

<!--对象中的属性可以直接取出来-->
<insert id="addUser" parameterType="com.tan.pojo.User">
    insert into mybatis.user(id, name, pwd)
    values (#{id}, #{name}, #{pwd});
</insert>

4. Update

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

5. Delete

<delete id="deleteUser" parameterType="com.tan.pojo.User">
    delete
    from mybatis.user
    where id = (#{});
</delete>

Test

@Test
public void addUser() {
    SqlSession sqlSession = MybatisUtils.getSqlSession();
    UserMapper mapper = sqlSession.getMapper(UserMapper.class);

    int res = mapper.addUser(new User(7, "asdawd", "afefew"));
    if (res > 0) {
        System.out.println("插入成功");
    }

    //提交事务
    sqlSession.commit();
    sqlSession.close();
}

@Test
public void updateUser() {
    SqlSession sqlSession = MybatisUtils.getSqlSession();
    UserMapper mapper = sqlSession.getMapper(UserMapper.class);

    mapper.updateUser(new User(5,"hello","135468"));

    sqlSession.commit();
    sqlSession.close();
}

@Test
public void deleteUser() {
    SqlSession sqlSession = MybatisUtils.getSqlSession();

    UserMapper mapper = sqlSession.getMapper(UserMapper.class);
    mapper.deleteUser(4);

    sqlSession.commit();
    sqlSession.close();
}

注意点:

  • 增删改需要提交事务

运行错误,报错纠错

在写的时候突然报了一个错误:

java.lang.ExceptionInInitializerError
	at com.tan.dao.UserMapperTest.deleteUser(UserMapperTest.java:77)
	at java.base/jdk.internal.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
	at java.base/jdk.internal.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
	at java.base/jdk.internal.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
	at java.base/java.lang.reflect.Method.invoke(Method.java:564)
	at org.junit.runners.model.FrameworkMethod$1.runReflectiveCall(FrameworkMethod.java:50)
	at org.junit.internal.runners.model.ReflectiveCallable.run(ReflectiveCallable.java:12)
	at org.junit.runners.model.FrameworkMethod.invokeExplosively(FrameworkMethod.java:47)
	at org.junit.internal.runners.statements.InvokeMethod.evaluate(InvokeMethod.java:17)
	at org.junit.runners.ParentRunner.runLeaf(ParentRunner.java:325)
	at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:78)
	at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:57)
	at org.junit.runners.ParentRunner$3.run(ParentRunner.java:290)
	at org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:71)
	at org.junit.runners.ParentRunner.runChildren(ParentRunner.java:288)
	at org.junit.runners.ParentRunner.access$000(ParentRunner.java:58)
	at org.junit.runners.ParentRunner$2.evaluate(ParentRunner.java:268)
	at org.junit.runners.ParentRunner.run(ParentRunner.java:363)
	at org.junit.runner.JUnitCore.run(JUnitCore.java:137)
	at com.intellij.junit4.JUnit4IdeaTestRunner.startRunnerWithArgs(JUnit4IdeaTestRunner.java:68)
	at com.intellij.rt.junit.IdeaTestRunner$Repeater.startRunnerWithArgs(IdeaTestRunner.java:33)
	at com.intellij.rt.junit.JUnitStarter.prepareStreamsAndStart(JUnitStarter.java:230)
	at com.intellij.rt.junit.JUnitStarter.main(JUnitStarter.java:58)
Caused by: org.apache.ibatis.exceptions.PersistenceException: 
### Error building SqlSession.
### The error may exist in com/tan/dao/UserMapper.xml
### Cause: org.apache.ibatis.builder.BuilderException: Error parsing SQL Mapper Configuration. Cause: org.apache.ibatis.builder.BuilderException: Error parsing Mapper XML. The XML location is 'com/tan/dao/UserMapper.xml'. Cause: org.apache.ibatis.builder.BuilderException: Parsing error was found in mapping #{}.  Check syntax #{property|(expression), var1=value1, var2=value2, ...} 
	at org.apache.ibatis.exceptions.ExceptionFactory.wrapException(ExceptionFactory.java:30)
	at org.apache.ibatis.session.SqlSessionFactoryBuilder.build(SqlSessionFactoryBuilder.java:80)
	at org.apache.ibatis.session.SqlSessionFactoryBuilder.build(SqlSessionFactoryBuilder.java:64)
	at com.tan.utils.MybatisUtils.<clinit>(MybatisUtils.java:26)
	... 23 more
Caused by: org.apache.ibatis.builder.BuilderException: Error parsing SQL Mapper Configuration. Cause: org.apache.ibatis.builder.BuilderException: Error parsing Mapper XML. The XML location is 'com/tan/dao/UserMapper.xml'. Cause: org.apache.ibatis.builder.BuilderException: Parsing error was found in mapping #{}.  Check syntax #{property|(expression), var1=value1, var2=value2, ...} 
	at org.apache.ibatis.builder.xml.XMLConfigBuilder.parseConfiguration(XMLConfigBuilder.java:121)
	at org.apache.ibatis.builder.xml.XMLConfigBuilder.parse(XMLConfigBuilder.java:98)
	at org.apache.ibatis.session.SqlSessionFactoryBuilder.build(SqlSessionFactoryBuilder.java:78)
	... 25 more
Caused by: org.apache.ibatis.builder.BuilderException: Error parsing Mapper XML. The XML location is 'com/tan/dao/UserMapper.xml'. Cause: org.apache.ibatis.builder.BuilderException: Parsing error was found in mapping #{}.  Check syntax #{property|(expression), var1=value1, var2=value2, ...} 
	at org.apache.ibatis.builder.xml.XMLMapperBuilder.configurationElement(XMLMapperBuilder.java:122)
	at org.apache.ibatis.builder.xml.XMLMapperBuilder.parse(XMLMapperBuilder.java:94)
	at org.apache.ibatis.builder.xml.XMLConfigBuilder.mapperElement(XMLConfigBuilder.java:374)
	at org.apache.ibatis.builder.xml.XMLConfigBuilder.parseConfiguration(XMLConfigBuilder.java:119)
	... 27 more
Caused by: org.apache.ibatis.builder.BuilderException: Parsing error was found in mapping #{}.  Check syntax #{property|(expression), var1=value1, var2=value2, ...} 
	at org.apache.ibatis.builder.SqlSourceBuilder$ParameterMappingTokenHandler.parseParameterMapping(SqlSourceBuilder.java:132)
	at org.apache.ibatis.builder.SqlSourceBuilder$ParameterMappingTokenHandler.buildParameterMapping(SqlSourceBuilder.java:72)
	at org.apache.ibatis.builder.SqlSourceBuilder$ParameterMappingTokenHandler.handleToken(SqlSourceBuilder.java:67)
	at org.apache.ibatis.parsing.GenericTokenParser.parse(GenericTokenParser.java:77)
	at org.apache.ibatis.builder.SqlSourceBuilder.parse(SqlSourceBuilder.java:45)
	at org.apache.ibatis.scripting.defaults.RawSqlSource.<init>(RawSqlSource.java:46)
	at org.apache.ibatis.scripting.defaults.RawSqlSource.<init>(RawSqlSource.java:40)
	at org.apache.ibatis.scripting.xmltags.XMLScriptBuilder.parseScriptNode(XMLScriptBuilder.java:72)
	at org.apache.ibatis.scripting.xmltags.XMLLanguageDriver.createSqlSource(XMLLanguageDriver.java:44)
	at org.apache.ibatis.builder.xml.XMLStatementBuilder.parseStatementNode(XMLStatementBuilder.java:96)
	at org.apache.ibatis.builder.xml.XMLMapperBuilder.buildStatementFromContext(XMLMapperBuilder.java:137)
	at org.apache.ibatis.builder.xml.XMLMapperBuilder.buildStatementFromContext(XMLMapperBuilder.java:130)
	at org.apache.ibatis.builder.xml.XMLMapperBuilder.configurationElement(XMLMapperBuilder.java:120)
	... 30 more
Caused by: java.lang.StringIndexOutOfBoundsException: String index out of range: 0
	at java.base/java.lang.StringLatin1.charAt(StringLatin1.java:48)
	at java.base/java.lang.String.charAt(String.java:711)
	at org.apache.ibatis.builder.ParameterExpression.parse(ParameterExpression.java:44)
	at org.apache.ibatis.builder.ParameterExpression.<init>(ParameterExpression.java:39)
	at org.apache.ibatis.builder.SqlSourceBuilder$ParameterMappingTokenHandler.parseParameterMapping(SqlSourceBuilder.java:128)
	... 42 more


Process finished with exit code -1

这问题很奇怪的地方在于之前之前一直没有出错,突然就运行失败,而且其他运行成功的test也没有办法再运行了.

刚开始搜的错误是第一个java.lang.ExceptionInInitializerError,但是这个错误太大了,没有搜到答案,于是又搜索了最后一个错误java.lang.StringIndexOutOfBoundsException: String index out of range: 0,下标从0开始就越界,说明可能是数据库出了问题,但是检查一番发现数据库没有错误,可以运行,于是看了中间的错误Parsing error was found in mapping #{}. ,可能是mapper.xml中的 #{}出了问题,...

里面少了id,补上where id = (#{id});,全部都运行正确.

这么一个小错误,居然可以让整个程序都无法运行......

6. 用Map更新特定字段

使用update更新有一个问题,就是更新的是整个User对象,这样就必须将这个对象所有的字段都写出来,但如果我们只更新其中一两个字段怎么办?使用Map就不用与表对象字段一一对应.

使用Map来更新:

接口层:

//用Map插入对象
int Map_updateUser(Map<String, Object> map);

Mapper.xml:

<!--Map更新-->
    <update id="Map_updateUser" parameterType="com.tan.pojo.User">
    update mybatis.user
    set name=(#{username})
    where id = (#{userid});
</update>

这里只更新了name,没有更新password,如果用User对象来更新就必须要写出更新后password的值

Test:

//Map更新
@Test
public void Map_updateUser() {
    SqlSession sqlSession = MybatisUtils.getSqlSession();
    UserMapper mapper = sqlSession.getMapper(UserMapper.class);

    Map<String, Object> map = new HashMap<String, Object>();
    map.put("userid", 6);
    map.put("username", "map更新");

    mapper.Map_updateUser(map);

    sqlSession.commit();
    sqlSession.close();
}

7. 模糊查询

由于mybatis会在sql语句两边添加单引号 `` 所以要用 双引号包裹"%", 这样可以进行模糊查询,但是idea会提示sql语句错误.

<select id="queryBookByName" resultType="Books">
    select *
    from ssmbuild.books
    where bookName like "%"#{bookName}"%"
</select>

所以mybatis提供了CONCAT关键字 : 这样就不会提示错误

<select id="queryBookByName" resultType="Books">
    select *
    from ssmbuild.books
    where bookName like CONCAT(CONCAT('%',#{userName},'%'))
</select>

4. 配置解析

1. 核心配置文件

  • mybatis-config.xml

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

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

2. 环境配置(environments)

MyBatis可以配置多种环境

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

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

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

3. 属性(properties)

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

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

1.编写一个配置文件

db.properties

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

2.在核心配置文件中引入

配置文件规定的顺序:

1

<!--引入外部配置文件-->
<properties resource="db.properties"/>

还可以这样写:

<!--引入外部配置文件-->
<properties resource="db.properties">
    <property name="username" value="root"/>
    <property name="password" value="123456"/>
</properties>
  • 可以直接引入外部文件
  • 可以在其中增加一些属性配置
  • 这样写如果内部和外部不一样,会先读取内部再读取外部,然后外部会覆盖内部的property

4.类型别名(typeAliases)

  • 类型别名可为 Java 类型设置一个缩写名字
  • 它仅用于 XML 配置,意在降低冗余的全限定类名书写
<!--给实体类取别名-->
<typeAliases>
    <typeAlias type="com.tan.pojo.User" alias="User"/>
</typeAliases>

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

扫描实体类的包,它的默认别名就为这个类的 类名的小写.

<typeAliases>
    <package name="com.tan.pojo"/>
</typeAliases>
<!--pojo下的实体类为User,则缩写为user(大写也可以)-->

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

在实体类十分多,建议使用第二种,若实体类上有注解则使用注解名.

@Alias("自定义别名")
public class User {
}

5. 设置(没必要记)

这是 MyBatis 中极为重要的调整设置,它们会改变 MyBatis 的运行时行为.

cacheEnabled 全局性地开启或关闭所有映射器配置文件中已配置的任何缓存。
lazyLoadingEnabled 延迟加载的全局开关。当开启时,所有关联对象都会延迟加载。 特定关联关系中可通过设置 fetchType 属性来覆盖该项的开关状态。
logImpl 指定 MyBatis 所用日志的具体实现,未指定时将自动查找。
mapUnderscoreToCamelCase 是否开启驼峰命名自动映射,即从经典数据库列名 A_COLUMN 映射到经典 Java 属性名 aColumn。

所有配置

6. 其他配置

  • plugins插件
    • mybatis-generator-core
    • mybatis-plus
    • 通用mapper

7.映射器(mappers)

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

方式一 :

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

方式二:使用class文件绑定注册(不建议使用很容易出错)

方式三: 使用包扫描注入绑定(不建议使用)

方式二和三的注意点:

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

8. 生命周期和作用域

(不知道为什么官网这部分没有了)

image-20200606233013664

生命周期,和作用域,是至关重要的,因为错误地使用回到是非常严重的并发问题.

SqlSessionFactoryBuilder :

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

SqlSessionFactory :

  • 说白了就是可以想象为 : 数据库连接池
  • 一旦创建就应该在运行期间一直存在,没有任何理由丢弃它或重新创建一个实例
  • 应用作用域
  • 最简单的就是使用单例模式或者静态单例模式 , 保证全局只有一份变量

**SqlSession : **

  • 连接到连接池的一个请求.
  • 每个SqlSession连接一个线程 , SqlSession的实例不是线程安全的,因此是不能被共享的,所以他的最佳的作用域是请求或方法作用域.
  • 用完之后需要赶紧关闭 , 否则资源被占用 !

image-20200606233946045

这里面的每一个Mapper , 就代表一个具体的业务 ! (增删改查等)

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

1. 问题

数据库中的字段

image-20200606234220890

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

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

输出: User{id=1, name='张三', password='null'}
//  select * from mybatis.user where id = #{id}
//   类型处理器
//  select id,name,pwd from mybatis.user where id = #{id}

解决方法:

  • sql语句起别名

select id,name,pwd as password from mybatis.user where id = #{id}

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 的优秀之处——你完全可以不用显式地配置它们
  • 如果这个世界总是这么简单就好了

image-20200607002512887

6. 日志

6.1 日志工厂

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

曾经: sout , debug

现在: 日志工厂.

logImpl指定 MyBatis 所用日志的具体实现,未指定时将自动查找。

  • SLF4J
  • LOG4J [掌握]
  • LOG4J2
  • JDK_LOGGING
  • COMMONS_LOGGING
  • STDOUT_LOGGING [掌握 ]
  • NO_LOGGING

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

STDOUT_LOGGING : 标准日志输出

  • 在mybatis核心配置文件中配置日志:
<settings>
    <setting name="logImpl" value="STDOUT_LOGGING"/>
</settings>
<!--大小写一定要注意,不能有多余的空格-->

image-20200607083141359

6.2 Log4j

什么是Log4j ?

  • Log4j是Apache的一个开源项目,通过使用Log4j,我们可以控制日志信息输送的目的地是控制台)、文件、组件
  • 可以控制每一条日志的输出格式
  • 通过定义每一条日志信息的级别,我们能够更加细致地控制日志的生成过程
  • 最令人感兴趣的就是,这些可以通过一个配置文件来灵活地进行配置,而不需要修改应用的代码
  1. 先导包

    <!-- 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/mylog.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的使用
    image-20200607085358640

简单使用

  1. 在要使用Log4j的类中,导入import org.apache.log4j.Logger;,注意jdk中有一个自带的Logger包,不要导错了.

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

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

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

用框架分页真的简单了好多😭,当初用servlet传统分页,传五六个参数,sql语句和java语句混在一起,还要拼接sql语句,sql语句写在String类型里面还没有任何sql语句的提示,真的要吐了.

7.2 RowBounds分页

通过java代码层面实现分页,强行面向对象,不建议使用,笔记就不做了(其实是我懒).

7.3 分页插件

Mybatis PageHelper

看官方文档就好了,本质都是limit分页

了解即可,只需要知到是什么就好了

8. 使用注解开发

8.1 面向接口编程

为了解耦

关于接口的理解

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

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

  • 接口应有两类:

    • 第一类是对一个个体的抽象,它可对应为一个抽象体(abstract class);
    • 第二类是对一个个体某一方面的抽象,即形成一个抽象面(interface);
  • 一个体有可能有多个抽象面。抽象体与抽象面是有区别的。

8.2 使用注解开发

  1. 接口

    @Select("select * from user")
    List<User> getUsers();
    
  2. mybatis-config.xml (接口第一次时的配置)

    <!--绑定接口-->
    <mappers>
        <mapper class="com.tan.dao.UserMapper"/>
    </mappers>
    
  3. @Test
    public void test() {
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
    
        List<User> users = mapper.getUsers();
        for (User user : users) {
            System.out.println(user);
        }
    
        sqlSession.close();
    }
    

官方建议: 对于简单的sql语句可以这么用就,但对于复杂的sql语句就显得力不从心,所以复杂的sql语句还是建议使用xml配置来运行.

注解开发的实现方法: 通过反射获取一个类中的所有信息,并帮我们自动化完成一些操作.

  • 本质: 反射机制实现
  • 底层: 动态代理 !
    image-20200607105844722

注解与反射的笔记

Mybatis详细的执行流程

Mybatis详细的执行流程

  1. SqlSessionFactoryBuilder通过构造器build调用build构造方法
    image-20200607165902625

  2. build构造方法调用XMLConfigBuilder这个类解析了(inputStream, environment, properties)
    image-20200607165934987

  3. 解析完后传给Configuration这个对象(Configuration中包含了所有的配置内容)
    image-20200607170003230

  4. 之后SqlSessionFactory实例化,获取sqlSession(事务在这一层去做,相当于原来的Connection)
    image-20200607170106493

  5. sqlSession里面有一个executor执行器,executor执行mapper,mapper通过反射加载出类的所有信息,包括了sqlSession,sqlSession中又有缓存executor执行器(executor把自己套进去了),套进去后开始执行sql语句,sql从配置文件中读取.
    成功执行sql语句提交事务,失败回滚.

    image-20200607171401782

对第5步做一些简单的解释: sqlSession中包括了运行一个sql语句所需的条件,包括事务,执行器,加载器等.但就是没有sql语句,于是通过反射获取到了接口以及接口下类的所有信息,就有了sql语句,mapper只是放这所有信息的变量 . 于是有条件又有语句就可以执行sql语句了.
image-20200607171822567

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插件.

  2. 在项目中导包

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

    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    public class User {
        private int id;
        private String name;
        private String password;
    }
    

建议: idea的自动生成已经很厉害了 , Lombok只是实现了一点点的简化,却要在编译时通过操作抽象语法树(AST)改变字节码的生成 , 变相改变了java语法.这就很不爽了,如果不是公司要求用就尽量别用.

10. 多对一处理

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

image-20200607184746531

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

  2. 新建实体类Teacher , Student
    注意: 学生的实体类中有tid所以实体类实体类应这样写 :

    @Data
    public class Student {
        private int id;
        private String name;
    
        //学生需要关联一个老师
        private Teacher teacher;
    }
    
  3. 建立Mapper接口

  4. 建立Mapper.xml

  5. 在核心文件中绑定注册我们的Mapper接口或者文件

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

按照查询嵌套处理

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

简单解释:

<association property="tetacher" column="tid" javaType="Teacher" select="getTeacher"/>

用Map将字段对应到属性,resultMap中前面两个idname可以直接对应,但是tid这个复杂的属性没办法直接对应.因为tid指向的是teacher这个对象,于是用association将字段tid指向teacher对象.但是teacher是一个复杂类型,需要再给他一个类型Teacher.

这样就将两个表通过tid联系了起来,再在student的association中再嵌套一个查询select="getTeacher",这样就完成了一对多(也就是 sql 联表查询).

  • 一对多的最终解决办法在springboot中用 json 解决,这个能看懂即可.

按照结果嵌套处理

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

<resultMap id="StudentTeacher2" type="Student">
    <result property="id" column="sid"/>
    <result property="name" column="sname"/>
    <association property="teacher" javaType="Teacher">
        <result property="name" column="tname"/>
        <result property="id" column="tid"/>
    </association>
</resultMap>

上面写 完整sql 语句,下面用resultMap写关联,比第一种好理解一些.

11. 一对多处理

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

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

环境搭建

  1. 环境搭建,和刚才一样
    实体类:

    @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 student s,
         teacher t
    where s.tid = t.id and t.id = #{tid}
</select>
<resultMap id="TeacherStudent" type="Teacher">
    <result property="id" column="tid"/>
    <result property="name" column="tname"/>
    <!--
    复杂的属性,我们需要单独处理,对象: association,集合: collection
    javaType="" 指定属性的类型,
    但此处类型为 List<Student> ,使用ofType获取
    -->
    <collection property="students" ofType="Student">
        <result property="id" column="sid"/>
        <result property="name" column="sname"/>
        <result property="tid" column="tid"/>
    </collection>
</resultMap>

小结

  1. 关联 - association [多对一]
  2. 集合 - collection [一对多]
  3. javaType & ofType
    1. javaType 用来指定实体类中属性的类型
    2. ofType 用来指定映射到List或者集合中的 pojo 类型 , 也就是泛型中的约束类型

注意点:

  • 尽量通俗易懂
  • 注意一对多和多对一中属性名和字段名的问题
  • 如果问题不好排查错误,可以使用日志 , 建议使用Log4j

面试高频 :

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

12. 动态SQL

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

动态 SQL 是 MyBatis 的强大特性之一。如果你使用过 JDBC 或其它类似的框架,你应该能理解根据不同条件拼接 SQL 语句有多痛苦,例如拼接时要确保不能忘记添加必要的空格,还要注意去掉列表最后一个列名的逗号。利用动态 SQL,可以彻底摆脱这种痛苦。

使用动态 SQL 并非一件易事,但借助可用于任何 SQL 映射语句中的强大的动态 SQL 语言,MyBatis 显著地提升了这一特性的易用性。

如果你之前用过 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. 编写实体类

    @Data
    public class Blog {
        private String id;
        private String title;
        private String author;
        private Date createTime;
        private int views;
    }
    
  4. 编写实体类对应的Mapper接口 和 Mapper.xml文件

if

接口Mapper

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

Mapper.xml

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

select * from mybatis.blog where 1=1 and title = ? and author = ? ,

注意点:

  • 如果title和author只传其中一个,则查询其中一个
  • 如果两个都传则取交集
  • 如果都不传则执行select * from mybatis.blog where 1=1 查询所有
  • 如果不写1=1则在title和author都不传的时候where关键字和and关键字会连起来sql语法错误.

但是在sql语句中加上1=1很明显不规范,于是mybatis中又添加了<where>标签.来自动判断和处理sql拼接时关键字会连起来的问题.

where与set

where标签

接口Mapper

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

Mapper.xml

<select id="queryBlogChoose" parameterType="map" resultType="blog">
    select * from mybatis.blog
    <where>
        <if test="title != null">
            and title = #{title} /*此处 and 可有可无*/
        </if>
        <if test="author != null">
            and author = #{author} /*此处 and 可有可无*/
        </if>
    </where>
</select>

where标签官网解释 :

where 元素只会在至少有一个子元素的条件返回SQL子句的情况下才会去插入"WHERE"子句,而且,若语句的开头为"AND"或"OR",where元素也会将他们去除

也就是说拼接sql语句select * from mybatis.blog where 1=1 and title = ? and author = ? 时where标签会自动判断是保留还是删除and .

set标签

与where类似,更新表的时候set关键字需要考虑, 是否需要,set标签提供了只能添加与删除, 保证不会因为缺少或则多余的, 影响sql语句的执行

接口Mapper

//更新博客
int updateBlog(Map map);

Mapper.xml

<update id="updateBlog" parameterType="map">
    update mybatis.blog
    <set>
        <if test="title != null">
            title = #{title}, /*此处 , 可有可无*/
        </if>
        <if test="views != null">
            views = #{views}, /*此处 , 可有可无*/
        </if>
    </set>
    where id = #{id}
</update>

choose (when, otherwise)

接口Mapper

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

Mapper.xml

<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 1=1
            </otherwise>
        </choose>
    </where>
</select>

choose (when, otherwise)类似于java中的switch ,case ,只会执行when 标签中最先满足条件的那个,如果都不满足条件则执行otherwise 标签中的内容.

trim(where,set)

/*等价于set标签*/
<trim prefix="SET" suffixOverrides=",">
    ...
</trim>

/*等价于where标签*/
<trim prefix="WHERE" prefixOverrides="AND | OR">
    ...
</trim>

trim标签 就是自定义某关键词的前缀后缀是否保留.

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

if

where , set , choose , when

SQL片段

抽取部分常用的sql语句,便于复用.

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

    <!--sql片段-->
    <sql id="choose-title-test">
        <choose>
            <when test="title != null">
                title = #{title}
            </when>
            <when test="author != null">
                and author = #{author}
            </when>
            <otherwise>
                and 1=1
            </otherwise>
        </choose>
    </sql>
    
  2. 在需要的地方使用include标签引用即可

    <!--引用sql片段部分-->
    <select id="queryBlogChoose" parameterType="map" resultType="blog">
        select * from mybatis.blog
        <where>
            <include refid="choose-title-test">
    
            </include>
        </where>
    </select>
    

注意事项:

  • 最好基于单表来定义SQL片段.保证复用性
  • sql 片段中不要有where标签,尽量只要有 if 判断就好了

Foreach

sql 语句查询多个 id :

select * from user where 1=1 and (id=1 or id=2 or id=3)

select * from user where 1=1 and id in (1,2,3)

select * from user where id < 4

官网图片 :

image-20200610162339218

接口:

//查询第1-2-3-4号记录的博客
List<Blog> queryBlogForeach(Map map);

Mapper.xml : (这样写Mapper传入的id在数据库中找不到不要紧,但一定要传不然会报错 . 不传id会报错的问题,我试了好久都没有解决...)

<!--select * from blog where id in (1, 2, 3, 4,5)-->
<select id="queryBlogForeach" parameterType="map" resultType="blog">
    select * from mybatis.blog
    <where>
        id in
        <foreach collection="ids" item="id" open="(" separator="," close=")">
            #{id}
        </foreach>
    </where>
</select>

测试类: (因为我自己写写错了,没写出来,所以这里贴一下)

//foreach查询
@Test
public void queryBlogForeach() {
    SqlSession sqlSession = MybatisUtils.getSqlSession();
    BlogMapper mapper = sqlSession.getMapper(BlogMapper.class);

    HashMap map = new HashMap();
    ArrayList<Integer> list = new ArrayList<Integer>();
    list.add(1);
    list.add(2);
    list.add(3);
    list.add(4);

    map.put("ids", list);

    List<Blog> blogs = mapper.queryBlogForeach(map);

    for (Blog blog : blogs) {
        System.out.println(blog);
    }

    sqlSession.close();
}

往Map中传List集合.

小总结

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

建议:

  • 先在IDEA的mysql控制台中写出完整的SQL,再对应地去修改成为我们的动态SQL实现通用即可 .

最后再附上官网对动态SQL的解释:

动态 SQL 是 MyBatis 的强大特性之一。如果你使用过 JDBC 或其它类似的框架,你应该能理解根据不同条件拼接 SQL 语句有多痛苦,例如拼接时要确保不能忘记添加必要的空格,还要注意去掉列表最后一个列名的逗号。利用动态 SQL,可以彻底摆脱这种痛苦。

13. 缓存(重要,但是掌握概念即可)

具体会学习redis缓存.

13.1 简介

查询  :  连接数据库 , 耗资源
	一次查询的结果, 给他一个可以直接取到的地方 --> 内存 : 缓存
我们再次查询相同数据的时候,直接就走缓存 ,就不用走数据库了
  1. 什么是缓存[Cache]?
    • 存在内存中的临时数据。
    • 将用户经常查询的数据放在缓存(内存)中,用户去查询数据就不用从磁盘上(关系型数据库数据文件)查询,从缓存中查询,从而提高查询效率,解决了高并发系统的性能问题。
  2. 为什么使用缓存?
    • 减少和数据库的交互次数,减少系统开销,提高系统效率。
  3. 什么样的数据能使用缓存?
    • 经常查询并且不经常改变的数据。

13.2 Mybatis缓存

  • MyBatis包含一个非常强大的查询缓存特性,它可以非常方便地定制和配置缓存。缓存可以极大的提升查询效率。
  • MyBatis系统中默认定义了两级缓存:一级缓存二级缓存
    • 默认情况下,只有一级缓存开启。(SqlSession级别的缓存,也称为本地缓存)
    • 二级缓存需要手动开启和配置,他是基于namespace级别的缓存。(也就是一个接口或者一个Mapper)
    • 为了提高扩展性,MyBatis定义了缓存接口Cache。我们可以通过实现Cache接口来自定义二级缓存

13.3 一级缓存

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

测试步骤:

  1. 开启日志

  2. 接口(略)

  3. Mapper (select *from user where id = #{id})

  4. Test类

    @Test
    public void queryUserById() {
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
    
        User user = mapper.queryUserById(1);
        System.out.println(user);
    
        System.out.println("==============================");
    
        User user2 = mapper.queryUserById(1);
        System.out.println(user2);
    
        System.out.println(user == user2);
    
        sqlSession.close();
    }
    
    1. 查询的时候当第二次查询和第一次查询相同时,直接从一级缓存从获取 :
      image-20200610181746666

    2. 当两次查询不同id时 :

      image-20200610182126608

      很明显第二次从数据库中查询,没有缓存

缓存失效的情况 :

  1. 查询不同的东西 .(上面那个情况)
  2. 增删改操作,可能会改变原来的数据,所以必定会刷新缓存 .
  3. 查询不同的Mapper.xml (二级缓存都不行)
  4. 手动清理缓存sqlSession.clearCache();

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

13.4 二级缓存

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

步骤:

  1. mybatis-config.xml中开启全局缓存

    <settings>
        <!--显式开始全局缓存-->
        <setting name="cacheEnabled" value="true"/>
    </settings>
    
  2. 在使用二级缓存的Mapper.xml中开启

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

    也可以自定义参数 官网缓存参数介绍

    <!--在当前Mapper.xml中使用二级缓存-->
    <cache eviction="FIFO"
           flushInterval="60000"
           size="512"
           readOnly="true"/>
    
  3. 测试
    <( ̄ c ̄)y▂ξ
    没什么好写的,就是一级缓存(SqlSession)关闭的时候,会自动提升作用域,其他SqlSession会直接从Mapper中获取已有的结果.

测试的时候报错,提醒没有序列化.

  • 开启二级缓存 存入缓存需要序列化(深拷贝),保证查的是同一个实体类.
    pojo 实体类实现Serializable接口即可 :

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

小结 :

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

13.5 缓存原理

缓存图

用户 -> 二级缓存 -> 一级缓存 -> 数据库

14 配张思维导图

Cache_7679607583f7c38a.

完结撒花! 完结撒花! 完结撒花!

开始Spring之旅~ ~ ~

posted @ 2020-07-11 19:46  Vlats  阅读(778)  评论(0编辑  收藏  举报