狂神说Mybatis课程笔记

文章目录

1. 第一个Mybatis程序

1.1 搭建环境1.2 创建一个模块1.3 编写代码1.4 测试 2. CURD（增删改查）

2.1 namespace2.2 Select、insert、update、delete2.3 分析错误2.4 使用Map传递参数2.5 模糊查询 3. 配置解析

3.1 核心配置文件3.2 环境配置（environments）3.3 属性（Properties）3.4 类型别名（typeAliases）3.5 设置（settings）3.6 映射器（mappers）3.7 声明周期和作用域 4. 解决属性名和字段名不一致的问题

4.1 ResultMap 5. 日志

5.1 日志工厂5.2 Log4j 6. 分页

6.1 Limit分页6.2 RowBounds分页 7. 使用注解开发8. Lombok9. 多对一处理

复杂查询环境搭建按照结果嵌套处理按照查询嵌套处理回顾MySQL 10. 一对多处理

按照结果嵌套处理按照查询嵌套处理小结 11. 动态SQL

搭建环境IF语句Choose语句trim（Where，set）SQL片段Foreach 12. 缓存（了解）

12.1 简介12.2 Mybatis缓存12.3 一级缓存12.4 二级缓存12.5 缓存原理12.6 自定义缓存-ehcache 13. 29道练习题实战

1. 第一个Mybatis程序

Mybatis3中文文档：https://mybatis.org/mybatis-3/zh/index.html

** 思路：搭建环境、导入mybatis、编写代码、测试。**

1.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,'王五','123456')

**新建项目**   
新建一个maven项目，删除src文件夹，导入依赖jar包（mysql、mybatis、junit）

    

        
            mysql
            mysql-connector-java
            8.0.28
        

        
            org.mybatis
            mybatis
            3.5.2
        

        
            junit
            junit
            4.13.2
            test
        
    

1.2 创建一个模块

**在resource文件夹下，创建mybatis-config.xml文件，编写mybatis的核心配置文件**

编写mybatis工具类 （Java.com.kuang.utils.MybatisUtils）

//工具类，sqlSessionFactory
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();
        }
    }

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

1.3 编写代码

实体类 （java.com.kuang.pojo.User）按照创建的mybatis数据的表User，创建实体类

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

package com.kuang.dao;

import com.kuang.pojo.User;

import java.util.List;

public interface UserDao { // 或者 UserMapper
    List getUserList();
}

接口实现类由原来的UserDaoImpl转化为一个Mapper配置文件（userMapper.xml）

    
        select * from mybatis.user
    

 
1.4 测试 
核心配置文件中注册mappers （mybatis-config.xml）
 
    
        
    
 
Junit测试
 
public class UserDaoTest {
    @Test
    public void test(){
        //第一步：获得sqlSession对象
        SqlSession sqlSession = MybatisUtils.getSqlSession();

        //方式一：getMapper
        UserDao userDao = sqlSession.getMapper(UserDao.class);
        List userList = userDao.getUserList();
        for (User user : userList) {
            System.out.println(user);
        }
        //关闭sqlSession
        sqlSession.close();
    }
}
 
碰到的问题：
 
Caused by: org.apache.ibatis.exceptions.PersistenceException: 
### Error building SqlSession.
### The error may exist in com/yd/dao/userdao.xml
### Cause: org.apache.ibatis.builder.BuilderException: Error parsing SQL Mapper Configuration. Cause: java.io.IOException: Could not find resource com/yd/dao/userdao.xml

 
解决方案：pom.xml文件添加如下代码：
 
    
        
            
                src/main/java
                
                    ***.xml
                
                false
            
            
                src/main/resources
                
                    ***.xml
                
                false
            
        
    
 
第一个mybatis程序创建流程：
 
 
2. CURD（增删改查） 
2.1 namespace 
 namespace中的包名要和Dao/Mapper接口的包名一致。
 
2.2 Select、insert、update、delete 
 选择，查询语句
 id：对应的userMapper中的方法名，即该sql语句需要调用的接口的某个方法名；
 resultType：sql语句执行的返回值；
 parameterType： userMapper中相应的方法传递的参数类型；
 Select 需要写返回值类型，update、insert、delete则不需要写。
 
编写接口
 
    //根据ID查询用户
    User getUserById(int Id);

    //添加用户
    int addUser(User user);

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

    //删除一个用户
    int deleteUser(int userId);
 
编写对应的UserMapper.xml中的sql语句
 
    
        select * from mybatis.user where id = #{id}
    


    
        insert into mybatis.user (id, name, pwd) value (#{id},#{name},#{pwd})
    

    
        update mybatis.user set name = #{name}, pwd = #{pwd} where id = #{id};
    

    
        delete from mybatis.user where id = #{id};
    

测试

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

    @Test
    public void addUser(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        int res = mapper.addUser(new User(4,"哈哈","123456"));
        //增删改必须要提交事务
        sqlSession.commit();
        sqlSession.close();
    }

    @Test
    public void updateUser(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        mapper.updateUser(new User(4,"呵呵","123123"));
        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();
    }

注意：
测试类中增删改的sql语句中，需要提交事务。

2.3 分析错误

标签匹配不要错resource绑定mapper，需要使用路径 / / / 2.4 使用Map传递参数

假设，实体类或数据库中的表，字段或者参数过多，应当考虑使用map传递参数。

UserMapper.java

    //使用map传递参数，查询用户
    User getUserById2(Map map);
    
    //使用map传递参数，添加用户
    int addUser2(Map map);

UserMapper.xml

    
        select * from mybatis.user where id = #{userId} and name =#{userName};
    
    
    
    
        insert into mybatis.user (id, name) value (#{userId},#{userName})
    
 
UserMapperTest.java
 
    //使用map传递参数
    @Test
    public void getUserById2(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        Map map = new HashMap<>();
        map.put("userId",6);
        map.put("userName","侯帅鑫");
        User user = mapper.getUserById2(map);
        System.out.println(user);
        sqlSession.close();
    }
    
    @Test
    public void addUser2(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        Map map = new HashMap<>();
        map.put("userId",6);
        map.put("userName","侯帅鑫");
        mapper.addUser2(map);
        //增删改必须要提交事务
        sqlSession.commit();
        sqlSession.close();
    }
 
 
 
Map传递参数，直接在sql中取出key即可。 parameterType = ”map“
 对象传递参数，直接在sql中取出对象的属性即可。
 只有一个基本类型参数的情况下，可以直接在sql中取到。
 多个参数用Map，或者注解。
 
 
2.5 模糊查询 
java代码执行的时候，传递的参数使用通配符。 
List userLike = mapper.getUserLike("%帅%");
 
在sql拼接中使用通配符。（有SQL注入的风险） 
select * from mybatis.user where name like "%"#{value}"%"
 
    
        select * from mybatis.user where name like #{value}"
    
 
    @Test
    public void getUserLike(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        List userLike = mapper.getUserLike("%帅%");
        for (User user : userLike) {
            System.out.println(user);
        }
        sqlSession.close();
    }
 
3. 配置解析 
3.1 核心配置文件 
mybatis-config.xmlMyBatis的配置文件包含了影响MyBatis行为的设置和属性信息。 
properties（属性）
settings（设置）
typeAliases（类型别名）
environments（环境配置）
environment（环境变量）
transactionManager（事务管理器）
dataSource（数据源）
databaseIdProvider（数据库厂商标识）
mappers（映射器）
 
3.2 环境配置（environments） 
MyBatis可以配置成适应多种环境，但每个SqlSessionFactory实例只能选择一种环境。
 MyBatis默认的事务管理器就是JDBC，连接池：POOLED
 
     更改default为test，即可切换到第二套环境。
        
            
            
                
                
                
                
            
        
        
            
            
        
    
 
3.3 属性（Properties） 
通过properties属性来实现引用配置文件。属性可外部配置且可动态替换，既可在典型的java属性文件中配置，亦可通过properties元素的子元素传递。文件：【db.properties】
 
在resources下编写配置文件：
 db.properties
 
driver=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/mybatis?useSSL=false&useUnicode=true&characterEncoding=UTF-8
username=root
password=123456
 
在核心配置文件中引入：
 
    
        
        
    
 
可以直接引入外部文件，db.properties。可以在其中增加一些属性配置。如果两个文件有同一个字段，优先使用外部配置文件的内容。 
修改相应的environment配置：
 
    
        
            
            
                   here
                     here
                  here
                   here
            
        
    
 
3.4 类型别名（typeAliases） 
类型别名是为java类型设置一个短的名字。用来减少类完全限定名的冗余。 

    
        
    
 
亦可以指定一个包名，MyBatis会在包名下面搜索需要的Java Bean，扫描实体类的包，它的默认别名就为这个类的类名，首字母小写。
 
    
        
    
 
在实体类比较少的时候，使用第一种。如果实体类比较多，建议使用第二种。
 第一种可以自己取别名，第二种默认使用首字母小写的类名（也可以使用注解的方式取别名）。 
@Alias("user")
public class User {
}
 
3.5 设置（settings） 
 

  
  

 
3.6 映射器（mappers） 
MapperRegistry：注册绑定我们的Mapper文件；
 
方式一：【推荐使用】
 
    
        
    
 
方式二：使用class文件绑定注册
 
    
        
    
 
注意点：
 
接口和它的Mapper配置文件必须同名。接口和它的Mapper配置文件必须在同一个包下。 
3.7 声明周期和作用域 
SqlSessionFactoryBuilder：
 
一旦创建了SqlSessionFactory，就不再需要它了。局部变量 
SqlSessionFactory：
 
可以想象为：数据库连接池SqlSessionFactory一旦被创建就应该在运行期间一直存在，没有任何理由丢弃它或重新创建另外一个实例。因此SqlSessionFactory的最佳作用域是应用作用域。最简单的就是使用单例模式或静态单例模式。 
SqlSession：
 
连接到连接池的一个请求。SqlSesssion的实例不是线程安全的，因此是不能被共享，所以它的最佳作用域是请求或方法作用域。用完之后需要赶紧关闭，否则资源被占用。 
4. 解决属性名和字段名不一致的问题 
4.1 ResultMap 
结果集映射：
 
实体类属性：id    name     password
数据库字段：id    name     pwd
 
当实体类的属性和数据库的字段名字不同的时候，查询出来的值为null。
 
解决方式一：取别名
 
    
--         select * from mybatis.user where id = #{id}
        select id,name,pwd as password from mybatis.user where id = #{id}
    

解决方式二：结果集映射

    

        
        
        
    

    
        select * from mybatis.user where id = #{id}
    
 
ResultMap元素是MyBatis中最重要最强大的元素。ResultMap的设计思想是：对于简单的语句不需要配置显式的结果映射，而对于复杂一点的语句只需要描述他们的关系就行。 
5. 日志 
5.1 日志工厂 

 **
 
SLF4JLOG4J(deprecated since 3.5.9) 【掌握】LOG4J2JDK_LOGGINGCOMMONS_LOGGINGSTDOUT_LOGGING 【掌握】NO_LOGGING 
**
 
在mybatis中具体使用那个日志实现，在设置中设定。
 
STDOUT_LOGGING标准日志输出
 
在mybatis核心配置文件中，配置我们的日志。
 
    
        
    
 
 
5.2 Log4j 
1. 先导入Log4j的包
 
        
            log4j
            log4j
            1.2.12
        
 
2. 在resources下创建log4j.properties
 
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为日志的实现
 
    
        
    
 
4. Log4j的使用
 
 简单使用
 
在要使用Log4j的类中，导入包 import org.apache.log4j.Logger。日志对象，参数为当前类的class。日志级别。
 
public class UserMapperTest {

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

    @Test
    public void testLog4j(){
        logger.info("info:进入了testLog4j");
        logger.debug("debug:进入了testLog4j");
        logger.error("error:进入了testLog4j");
    }
}
 
6. 分页 
6.1 Limit分页 
使用Limit分页：
 
语法：Select * from user limit 0,2;
 
使用mybatis实现分页，核心Sql
 
接口 UserMapper
 
    //分页
    List getUserByLimit(Map map);
 
UserMapper.xml
 
    
        select * from mybatis.user limit #{startIndex},#{pageSize};
    
 
测试
 
    @Test
    public void getUserByLimit(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        HashMap map = new HashMap<>();
        map.put("startIndex",0);
        map.put("pageSize",2);
        List userList = mapper.getUserByLimit(map);
        for (User user : userList) {
            System.out.println(user);
        }
        sqlSession.close();
    }
 
6.2 RowBounds分页 
不再使用SQL实现分页
 
UserMapper接口
 
    //Rowbounds分页
    List getUserByRowBounds();
 
UserMapper.xml
 
    
        select * from mybatis.user
    

测试类

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

        //RowBounds实现
        RowBounds rowBounds = new RowBounds(1, 2); // 起始值（从零开始），每页显示个数
        //通过java代码层面实现分页
        List userList = sqlSession.selectList("com.kuang.dao.UserMapper.getUserByRowBounds",null,rowBounds);
        for (User user : userList) {
            System.out.println(user);
        }
        sqlSession.close();
    }

7. 使用注解开发

本质：反射机制实现
底层：动态代理

Mybatis详细执行流程：

UserMapper中的接口上编写sql注解：

public interface UserMapper {
    @Select("select * from user")
   List getUserList();
}

核心配置文件mybatis-config.xml中绑定接口：

测试：

    @Test
    public void getUserList(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        List userList = mapper.getUserList();
        for (User user : userList) {
            System.out.println(user);
        }
        sqlSession.close();
    }

注解增删改查：

1. 更改Mybatis工具类，设置为自动提交事务。

    public static SqlSession getSqlSession(){
        //设置为自动提交事务
        return sqlSessionFactory.openSession(true);
    }

2. 编写接口增加注解：

 //方法存在多个参数的时候，所有的参数前面必须加上@Param("id")注解
    @Select("select * from user where id = #{id}")
    User getUserById(@Param("id") int id);

    //引用型对象则不需要Param
    @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);

3. 测试类：

【注意】必须将接口注册绑定到MyBatis的核心配置文件中。

关于@Param（）注解：

基本类型的参数或者String类型，需要加上。引用类型不需要加。如果只有一个基本类型的话，可以忽略，但是建议都加上。在SQL中引用的就是Param（）中设定的属性名，可以自定义。 8. Lombok

1. 在IDEA中安装Lombok插件

2. 在pom.xml文件中添加依赖

        
            org.projectlombok
            lombok
            1.18.10
        

3. 在实体类上加注解即可

@Date：无参构造，get set toString hashCode equals
@AllArgsConstructor  有参构造
@NoArgsConstructor   无参构造
@EqualsAndHashCode
@ToString
@Getter

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

9. 多对一处理

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

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

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

3. 建立Mapper接口

public interface TeacherMapper {
    @Select("select * from teacher where id = #{tid}")
    Teacher getTeacher(@Param("tid") int id);
}

public interface StudentMapper {
}

4. 建立TeacherMapper.xml、StudentMapper.xml文件

5. 在核心配置文件中绑定注册Mapper接口或者文件

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

    @Test
    public void test(){ //根据id查询老师
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        TeacherMapper mapper = sqlSession.getMapper(TeacherMapper.class);
        Teacher teacher = mapper.getTeacher(1);
        System.out.println(teacher);
        sqlSession.close();
    }

项目结构：

按照结果嵌套处理

    
        select s.id sid, s.name sname,t.name tname
        from student s,teacher t
        where s.tid = t.tid
    

    
        
        
        
            
        
    
 

按照查询嵌套处理

StudentMapper.xml文件配置

    
        select * from student
    

    
        
        
        
        
    

    
        select * from teacher where id = #{id}
    

回顾MySQL

子查询 — 按照查询嵌套处理联表查询 — 按照结果嵌套处理 10. 一对多处理

比如：一个老师拥有多个学生，对老师而言，就是一对多的关系。

1. 环境搭建

实体类：

@Data
public class Teacher {
    private int id;
    private String name;
    private List student;
}

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

按照结果嵌套处理

    
        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 * from mybatis.teacher where id = #{tid}
    

    
        
    

    
        select * from mybatis.student where tid = #{tid}
    
 
 
小结 
1. 关联 – association 【多对一】
 
2. 集合 – collection 【一对多】
 
3. javaType & ofType
 
JavaType 用来指定实体类中属性的类型。ofType 用来指定映射到List或者集合中的pojo类型，泛型中的约束类型。 
注意点：
 
 - 保证SQL的可读性，尽量保证通俗易懂。  
 - 注意一对多和多对一中，属性名和字段的问题。 
 - 如果错误不好排查，可以使用日志，建议使用Log4j。
 
面试高频：
 
Mysql引擎InnoDB底层原理索引索引优化 
11. 动态SQL 
动态SQL：就是根据不同的条件生成不同的SQL语句。
 
动态SQL就是在拼接SQL语句，只需要保证SQL的正确性，按照SQL的格式，进行排列组合即可。
 
搭建环境 
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;
 
创建一个基础工程
 
导包编写配置文件编写实体类
 
@Data
public class Blog {
    private int id;
    private String title;
    private String author;
    private Date createTime; //需解决实体类属性和数据库字段不一致
    private int views;
}
 
编写实体类对应的Mapper接口和Mapper.xml文件
 
public interface BlogMapper {
    //插入数据
    int addBlog(Blog blog);
}
 




    
        insert into mybatis.blog(id,title,author,create_time,views)
        values (#{id},#{title},#{author},#{createTime},#{views});
    

 
随机数生成工具类 （utils.IDUtils）
 
public class IDUtils {
    public static String getId(){
        return UUID.randomUUID().toString().replaceAll("-","");
    }
    @Test
    public void test(){
        System.out.println(IDUtils.getId());
    }
}
 
插入Blog数据
 
    @Test
    public void addInitBlog(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        BlogMapper mapper = sqlSession.getMapper(BlogMapper.class);

        Blog blog = new Blog();
        blog.setId(IDUtils.getId());//随机的数
        blog.setTitle("Mybatis如此简单");
        blog.setAuthor("狂神说");
        blog.setCreateTime(new Date());
        blog.setViews(999);

        mapper.addBlog(blog);

        blog.setId(IDUtils.getId());
        blog.setTitle("Java如此简单");
        mapper.addBlog(blog);

        blog.setId(IDUtils.getId());
        blog.setTitle("Spring如此简单");
        mapper.addBlog(blog);

        blog.setId(IDUtils.getId());
        blog.setTitle("微服务");
        mapper.addBlog(blog);

        sqlSession.close();
    }
 
IF语句 
1. Blog接口
 
public interface BlogMapper {
    //插入数据
    int addBlog(Blog blog);

    //查询博客
    List queryBlogIf(Map map);
}
 
2. BlogMapper.xml文件
 
根据条件查询，如果没有条件要求，输出所有的数据。否则，按照输入的要求条件输出。
 
    
        select * from mybatis.blog where 1=1
        
            and title = #{title}
        
        
            and author = #{author}
        
    
    

    
        
    

3. 测试类

    @Test
    public void queryBlogIf(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        BlogMapper mapper = sqlSession.getMapper(BlogMapper.class);
        HashMap map = new HashMap();
//        map.put("title","Java如此简单");
        map.put("author","狂神说");
        List blogs = mapper.queryBlogIf(map);
        for (Blog blog : blogs) {
            System.out.println(blog);
        }
    }

Choose语句

Choose：类似switch结构。从上至下判断，满足其中一个条件，自动跳出。上面都不满足，自动执行otherwise语句中的内容。

    
        select * from mybatis.blog
        
            
                
                    title = #{title};
                
                
                    and author = #{author}
                
                
                    and views = #{views}
                
            
        
    
 
trim（Where，set） 
Where
 Where：条件的追加，IF语句的高级版本。若语句开头为 ”And“ 或 ”OR“，将自动去除。
 
        
            select * from mybatis.blog
            
                
                    and title = #{title}
                
                
                    and author = #{author}
                
            
        

Set

    
        update mybatis.blog
        
            
                title = #{title},
            
            
                author = #{author}
            
        
        where id = #{id}
    

所谓的动态SQL，本质还是SQL语句，只是在SQL层面，去执行一个逻辑代码。

SQL片段

实现公用代码的复用，对多sql语句共有的语句进行抽取封装。

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

    
        
            and title = #{title}
        
        
            and author = #{author}
        
    

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

    
            select * from mybatis.blog
            
                
            
    
 
注意事项：
 
最好基于单表来定义SQL片段。不要存在where标签。SQL片段内一般只是IF判断。 
Foreach 
open：以…开头
 close：以…结尾
 seperator：以…分割
 
select * from mybatis.blog WHERe ( id = ? or id = ? or id = ? )    

 
        select * from mybatis.blog
        
            
                id = #{id}
            
        
  

测试类：

    @Test
    public void queryBlogForeach(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        BlogMapper mapper = sqlSession.getMapper(BlogMapper.class);
        HashMap map = new HashMap();

        ArrayList ids = new ArrayList();
        ids.add(1);
        ids.add(2);
        ids.add(3);

        map.put("ids",ids);

        List blogs = mapper.queryBlogForeach(map);
        for (Blog blog : blogs) {
            System.out.println(blog);
        }
    }

12. 缓存（了解） 12.1 简介

1. 什么是缓存？

存在内存中的临时数据。将用户经常查询的数据放在缓存（内存）中，用户查询时不需从磁盘上查询，从缓存中查询，从而提高查询效率，解决了高并发系统的性能问题。

2. 为什么使用缓存？

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

3. 什么样的数据使用缓存？

经常查询并且不经常改变的数据。 12.2 Mybatis缓存

Mybatis系统中默认定义了两级缓存：一级缓存 和 二级缓存。

默认情况下，只有一级缓存开启。（SqlSession级别的缓存，也称为本地缓存）二级缓存需要手动开启和配置，是基于namespace级别的缓存。为了提高扩展性，Mybatis定义了缓存接口Cache，可通过Cache接口自定义二级缓存。 12.3 一级缓存

缓存失效的情况：

查询不同的东西。增删改操作，可能会改变原来的数据，所以会刷新缓存。查询不同的Mapper.xml。手动清楚缓存。 sqlSession.clearCache();

小结：

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

12.4 二级缓存

步骤：

开启全局缓存

在要使用二级缓存的Mapper中开启，可以自定义参数

小结：

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

12.6 自定义缓存-ehcache

要在程序中使用ehcache，先要导包。

        
            org.mybatis.caches
            mybatis-ehcache
            1.1.0
        

13. 29道练习题实战

推荐博客：

https://blog.csdn.net/qq_38616503/article/details/107149495?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522164802218216780264043931%2522%252C%2522scm%2522%253A%252220140713.130102334…%2522%257D&request_id=164802218216780264043931&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2_allbaidu_landing_v2~default-1-107149495.142^v3pc_search_result_control_group,143^v4control&utm_term=smbms+mybatis&spm=1018.2226.3001.4187