Mybatis笔记_mybatis insert 通用接口-CSDN博客

本文链接：https://blog.csdn.net/weixin_45041762/article/details/125970744

Mybatis笔记

什么是Mybatis

MyBatis 是一款优秀的持久层框架
MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集的过程
MyBatis 可以使用简单的 XML 或注解来配置和映射原生信息，将接口和 Java 的实体类【Plain Old Java Objects,普通的 Java对象】映射成数据库中的记录。
MyBatis 本是apache的一个开源项目ibatis, 2010年这个项目由apache 迁移到了google code，并且改名为MyBatis 。
2013年11月迁移到Github .
Mybatis官方文档 : http://www.mybatis.org/mybatis-3/zh/index.html
GitHub : https://github.com/mybatis/mybatis-3

持久化

持久化是将程序数据在持久状态和瞬时状态间转换的机制。

即把数据（如内存中的对象）保存到可永久保存的存储设备中（如磁盘）。持久化的主要应用是将内存中的对象存储在数据库中，或者存储在磁盘文件中、XML数据文件中等等。
JDBC就是一种持久化机制。文件IO也是一种持久化机制。
在生活中 : 将鲜肉冷藏，吃的时候再解冻的方法也是。将水果做成罐头的方法也是。

为什么需要持久化服务呢？那是由于内存本身的缺陷引起的

内存断电后数据会丢失，但有一些对象是无论如何都不能丢失的，比如银行账号等，遗憾的是，人们还无法保证内存永不掉电。
内存过于昂贵，与硬盘、光盘等外存相比，内存的价格要高2~3个数量级，而且维持成本也高，至少需要一直供电吧。所以即使对象不需要永久保存，也会因为内存的容量限制不能一直呆在内存中，需要持久化来缓存到外存。

什么是持久层？

完成持久化工作的代码块 . ----> dao层【DAO (Data Access Object) 数据访问对象】
大多数情况下特别是企业级应用，数据持久化往往也就意味着将内存中的数据保存到磁盘上加以固化，而持久化的实现过程则大多通过各种关系数据库来完成。
不过这里有一个字需要特别强调，也就是所谓的“层”。对于应用系统而言，数据持久功能大多是必不可少的组成部分。也就是说，我们的系统中，已经天然的具备了“持久层”概念？也许是，但也许实际情况并非如此。之所以要独立出一个“持久层”的概念,而不是“持久模块”，“持久单元”，也就意味着，我们的系统架构中，应该有一个相对独立的逻辑层面，专注于数据持久化逻辑的实现.
与系统其他部分相对而言，这个层面应该具有一个较为清晰和严格的逻辑边界。【说白了就是用来操作数据库存在的！】
Dao层，Service层，Controller层
完成持久化工作的代码块
层界限十分明显

为什么需要Mybatis

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

方便

传统JDBC代码太复杂了，简化，框架，自动化

不用Mybatis也可以，更容易上手。

优点：

简单易学
灵活
解除sql与程序代码的耦合：通过提供DAO层，将业务逻辑和数据访问逻辑分离，使系统的设计更清晰，更易维护，更易单元测试。sql和代码的分离，提高了可维护性。
提供xml标签，支持编写动态sql
使用的人多

第一个Mybatis程序

转义字符

&lt	<	小于
&gt	>	大于
&amp	&	与
&apos	’	单引号
&quot	"	双引号

思路：搭建环境–>导入Mybatis–》编写代码—》测试

1、搭建数据库 id name password

2、导入MyBatis jar包

<dependency>
   <groupId>org.mybatis</groupId>
   <artifactId>mybatis</artifactId>
   <version>3.5.2</version>
</dependency>
<dependency>
   <groupId>mysql</groupId>
   <artifactId>mysql-connector-java</artifactId>
   <version>5.1.47</version>
</dependency>

创建一个模块

3、编写mybatis的核心配置问文件

& 在xml中&符号不能用，需要用转义字符

<?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 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=utf8"/>
                <property name="username" value="root"/>
                <property name="password" value="123456"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <!--注意这里是/ 不是.-->
        <mapper resource="com/kuang/dao/userMapper.xml"/>
    </mappers>
</configuration>

4、编写mybatis工具类

import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;

import java.io.IOException;
import java.io.InputStream;

public class MyvatisUtils {
    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的实例了
    //SqlSeesion 完全包含了面向数据库执行SQL 命令所需的所有方法
    public static SqlSession getSqlSeesion(){
        /*
        SqlSession sqlSession = sqlSessionFactory.openSession();
        return sqlSession;
        */
        //优化
        return sqlSessionFactory.openSession();
    }
}

5、编写代码

实体类

public class User {
    private int id;
    private String name;
    private String 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();
}

接口实现类由原来的UserDaoImpl转变为一个Mapper.xml配置文件【可以自定义文件名称】写在哪里都可以，可以跟Dao接口一个包下

注意这里的id要跟接口的方法名一致

<?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.p.dao.UserDao">
    <!--查询语句
    resultMap:返回一个集合,多个
    resultType：返回一个类型 一个  可以返回一个list泛型
    -->
    <!--注意 这里的id要跟接口的方法名一致-->
    <select id="getUserList" resultType="com.p.pojo.User">
        select * from mybatis.user
    </select>
</mapper>

6、测试

junit测试

  @Test
    public void test(){
        //第一步：获得SqlSeesion对象
        SqlSession sqlSeesion = MybatisUtils.getSqlSeesion();
        //方式一：getMapper
        UserDao mapper = sqlSeesion.getMapper(UserDao.class);
        List<User> userList = mapper.getUserList();
        for (User user:userList){
            System.out.println(user);
        }
        //关闭SqlSeesion
        sqlSeesion.close();
    }

可能会遇到的问题：

1、配置文件没有注册

2、绑定接口错误

3、方法名不对

4、返回类型不对

5、Maven导出资源问题

<!--资源导出问题解决-->
<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>

方式二：不推荐使用

public class UserDaoTest {
    @Test
    public void test(){
        //第一步：获得SqlSeesion对象
        SqlSession sqlSeesion = MybatisUtils.getSqlSeesion();
     
        //方式二：不推荐使用
        //获取到改方法的方法名  UserDao中的getUserList方法名
        List<User> userList = sqlSeesion.selectList("com.p.dao.UserDao.getUserList");
        for (User user:userList){
            System.out.println(user);
        }
        //关闭SqlSeesion
        sqlSeesion.close();
    }
}

官方建议使用异常抛出

  @Test
    public void test(){
        //第一步：获得SqlSeesion对象
        SqlSession sqlSeesion = MybatisUtils.getSqlSeesion();
        try{
            //方式一：getMapper
       /* UserDao mapper = sqlSeesion.getMapper(UserDao.class);
        List<User> userList = mapper.getUserList();*/

            //方式二：不推荐使用
            List<User> userList = sqlSeesion.selectList("com.p.dao.UserDao.getUserList");
            for (User user:userList){
                System.out.println(user);
            }
        }catch (Exception e){
                e.printStackTrace();
        }finally {
            //关闭SqlSeesion
            sqlSeesion.close();
        }

CRUD(增删改查)

1、namespace

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

<!--namespace=绑定一个对应的Dao/Mapper接口-->
<mapper namespace="com.p.dao.UserDao">

2、select

选择，查询语句

 <select id="getUserList" resultType="com.p.pojo.User" parameterType=“”>
       select * from mybatis.user
 </select>

id:就是对应的那么space中的方法名

resultType：Sql语句执行的返回值

parameterType：参数类型

带参数的查询语句

1.接口

 //根据ID查询用户
User getUserById(int id);

在Mapper.xml绑定该接口实现其sql语句

 <select id="getUserById" resultType="com.p.pojo.User" parameterType="int">
       select * from  mybatis.user where id = #{id}
 </select>

测试类

 @Test
    public void getUserById(){
        SqlSession sqlSeesion = MybatisUtils.getSqlSeesion();
        UserDao mapper = sqlSeesion.getMapper(UserDao.class);
        User user = mapper.getUserById(1);
        System.out.println(user);
        sqlSeesion.close();
    }

3、insert

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

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

 //增删改需要提交事务
    @Test
    public void addUser(){
        SqlSession sqlSeesion = MybatisUtils.getSqlSeesion();
        UserDao mapper = sqlSeesion.getMapper(UserDao.class);
        int res = mapper.addUser(new User(4, "123", "123"));
        if (res>0){
            System.out.println("插入成功");
             //提交事务
        	sqlSeesion.commit();
        }
        sqlSeesion.close();
    }

4、update

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

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

 @Test
    public void updateUser(){
        SqlSession sqlSeesion = MybatisUtils.getSqlSeesion();
        UserDao mapper = sqlSeesion.getMapper(UserDao.class);
        int res = mapper.updateUser(new User(4, "234", "234"));
        if (res>0){
            System.out.println("修改成功");
            //提交事务
            sqlSeesion.commit();
        }
        sqlSeesion.close();
    }

5、Delete

//删除一个用户
    int deleteById(int id);

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

 @Test
    public void deleteById(){
        SqlSession sqlSeesion = MybatisUtils.getSqlSeesion();
        UserDao mapper = sqlSeesion.getMapper(UserDao.class);
        int res = mapper.deleteById(4);
        if (res>0){
            System.out.println("删除成功");
            //提交事务
            sqlSeesion.commit();
        }
        sqlSeesion.close();
    }

注意：增删改需要提交事务，查询不需要

6、注意点：

1、标签不要匹配错

2、resource 绑定mapper，需要使用路径 / ，不能用 . 来拼接

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

3、程序配置文件符合规范

4、空指针异常，没有注册到资源

5、输出的xml文件中存在中文乱码问题

6、maven资源没有导出问题

Map和模糊查询拓展

万能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 sqlSeesion = MybatisUtils.getSqlSeesion();
        UserDao mapper = sqlSeesion.getMapper(UserDao.class);
        Map<String, Object> map = new HashMap<String, Object>();
        map.put("userId",5);
        map.put("userName","555");
        map.put("passWord","5555");
        mapper.addUser2(map);
        sqlSeesion.commit();
        sqlSeesion.close();
    }

Map传递参数，直接在sql中取出key即可【parameterType=“map”】

对象传递参数，直接在sql中取出对象属性即可【parameterType=“object”】

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

多个参数用map，或者注解

模糊查询

1、java代码执行的时候，传递通配符% %【一般这样写，比较安全】

  //模糊查询用户
    List<User> getUserByLike(String value);

<select id="getUserByLike"  resultType="com.p.pojo.User">
        select * from mybatis.user where name like #{value}
    </select>

@Test
    public void getUserByLike(){
        SqlSession sqlSeesion = MybatisUtils.getSqlSeesion();
        UserDao mapper = sqlSeesion.getMapper(UserDao.class);
        List<User> userByLike = mapper.getUserByLike("%李%");
        for (User user : userByLike) {
            System.out.println(user);
        }
        sqlSeesion.close();
    }

2、在sql拼接中使用通配符【这样写容易SQL注入，不建议写】

<select id="getUserByLike"  resultType="com.p.pojo.User">
        select * from mybatis.user where name like "%"#{value}"%"
    </select>

配置解析

1、核心配置文件

mybatis默认的事务管理器就是JDBC，连接池：POOLED

mybatis-config【官方推荐配置文件名】

MyBatis 的配置文件包含了会深深影响 MyBatis 行为的设置和属性信息。
能配置的内容如下：

configuration（配置）
properties（属性）
settings（设置）
typeAliases（类型别名）
typeHandlers（类型处理器）
objectFactory（对象工厂）
plugins（插件）
environments（环境配置）
environment（环境变量）
transactionManager（事务管理器）
dataSource（数据源）
databaseIdProvider（数据库厂商标识）
mappers（映射器）
<!-- 注意元素节点的顺序！顺序不对会报错 -->

mybatis-config.xml 上面的元素

environments元素

<environments default="development">
 <environment id="development">
   <transactionManager type="JDBC">
     <property name="..." value="..."/>
   </transactionManager>
   <dataSource type="POOLED">
     <property name="driver" value="${driver}"/>
     <property name="url" value="${url}"/>
     <property name="username" value="${username}"/>
     <property name="password" value="${password}"/>
   </dataSource>
 </environment>
</environments>

配置MyBatis的多套运行环境，将SQL映射到多个不同的数据库上，必须指定其中一个为默认运行环境（通过default指定）
子元素节点：environment
- dataSource 元素使用标准的 JDBC 数据源接口来配置 JDBC 连接对象的资源。连接数据库 dbcp、c390、druid
- 数据源是必须配置的。
- 有三种内建的数据源类型

type="[UNPOOLED|POOLED|JNDI]"）

unpooled：这个数据源的实现只是每次被请求时打开和关闭连接。
pooled：这种数据源的实现利用“池”的概念将 JDBC 连接对象组织起来 , 这是一种使得并发 Web 应用快速响应请求的流行处理方式。
jndi：这个数据源的实现是为了能在如 Spring 或应用服务器这类容器中使用，容器可以集中或在外部配置数据源，然后放置一个 JNDI 上下文的引用。
数据源也有很多第三方的实现，比如dbcp，c3p0，druid等等…
这两种事务管理器类型都不需要设置任何属性。
具体的一套环境，通过设置id进行区别，id保证唯一！
子元素节点：transactionManager - [ 事务管理器 ]

<transactionManager type="[ JDBC | MANAGED ]"/> 【在问到这里时，不能回答只有JDBC一种连接方式】

子元素节点：数据源（dataSource）

使用配置多套运行环境

<environments default="development"> <!--默认的运行环境-->
<environments default="test">  <!--选择自定义的运行环境-->
        <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=utf8"/>
                <property name="username" value="root"/>
                <property name="password" value="123456"/>
            </dataSource>
        </environment>

        <environment id="test">   <!--自定义的运行环境-->
            <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=utf8"/>
                <property name="username" value="root"/>
                <property name="password" value="123456"/>
            </dataSource>
        </environment>
    </environments>

2、属性(properties)

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

这些属性都是可外部配置且可动态替换的，即可在java属性中配置，也可以通过properties元素的子元素来传递【dp.properties】

编写一个dp.properties配置文件

driver=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/mybatis?useSSL=trueuseUnicode=truecharacterEncoding=utf8
username=root
password=123456

在mybatis-config.xml文件中引入properties需要注意顺序

<?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>
    <!--导入properties文件-->
    <properties resource="db.properties"/>

    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="${driver}"/>
                <property name="url" value="${url}"/>
                <property name="username" value="${username}"/>
                <property name="password" value="${password}"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <mapper resource="com/p/Dao/UserDaoMapper.xml"/>
    </mappers>
</configuration>

1、可以直接引入外部文件

2、可以在其中增加一些属性配置

    <!--导入properties文件-->
    <properties resource="db.properties">
        <property name="username" value="root"/>
        <property name="password" value="123456"/>
    </properties>

3、如果两个文件有同一个字段，优先使用外部配置文件

3、类型别名（typeAliases）

第一种：通过指定类来起别名

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

在mybatis-config.xml中起别名

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

在Mapping.xml中使用

<select id="getUserList" resultType="User">
        select * from user
    </select>

第二种：通过扫描指定的包

也可以指定一个报名，mybatis会在包名下面搜索需要的java Bean。

扫描实体类的包，他的默认别名就为这个类的类名，首字母小写！

mybatis-config.xml

<!--可以给实体类起别名-->
    <typeAliases>
        <!--扫描一个包，给这个包下的类起别名-->
        <package name="com.p.pojo"/>
    </typeAliases>

在Mapper.xml中使用 【首字母大小写都可以，推荐使用小写】

<select id="getUserList" resultType="user">
        select * from user
    </select>

用法：

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

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

第一种可以DIY别名，第二种则不行

第三种：使用注解起别名@Alias

在实体类上使用 @Alias(“自定义别名”) 来实现起别名

实体类

import org.apache.ibatis.type.Alias;
@Alias("hello")
public class User {
    private int id;
    private String name;
    private String pwd;
}

Mapper.xml

<select id="getUserList" resultType="hello">
        select * from user
    </select>

4、设置

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

5、映射器（mappers）

MapperRegistry：注册绑定我们的Mapper文件

方式一：使用相对于类路径资源引用【推荐使用】

<mappers>
        <mapper resource="com/p/Dao/UserDaoMapper.xml"/>
    </mappers>

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

UserDao

接口

UserDao.xml

<mappers>
        <mapper class="com.p.Dao.UserDao"/>
    </mappers>

注意点：

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

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

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

<mappers>
        <package name="com.p.Dao"/>
</mappers>

注意点：

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

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

6、生命周期和作用域

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

SqlSessionFactoryBuilder：

一旦创建了SalSessionFactory，就不需要它了

局部变量

SqlSessionFactory：

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

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

因此SqlSessionFactory的最佳作用域是应用作用域

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

SqlSession:

连接到连接池的一个请求

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

用完之后需要感觉关闭，否则资源被占用。

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

如数据库中的字段为

id,username,pwd

而java实体类中的属性名为

private int id;
private String username;
private String password;  //跟数据库中的字段不一致

测试中出现的问题： password=null 没有数据

//类处理器会自动拼接类型
select * from user where id=1;
select id,name,pwd form user where id=1;

如何解决

方式一：

起别名：【最简单，最暴力的解决办法】

select id,name,pwd as password form user where id=1;

方式二：

resultMap 结果集映射

数据库中的字段: id   name   pwd
实体类中属性：	 id   name   password

使用resultMap 在Mapper.xml配置文件中修改

 <!--结果集映射  UserMap自定义名   User实体类类名，返回的类型-->
    <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="UserDao" resultMap="UserMap">
        select * from student
    </select>

resultMap元素是MyBatis中最重要最强大的元素

ResultMap的设计思想是：对于简单的语句根本不需要配置显式的结构映射，而对于复杂一点的语句只需要描述他们的关系就行了

ResultMap最优秀的地方在与，当你对它相当了解后，就不需要显式的使用它

 <!--结果集映射  UserDao接口名   User实体类类名-->
    <resultMap id="UserDao" type="User">
        <!--column:数据库中的字段
            property：实体类中属性
			字段和属性一样的情况下可以不写，只写字段不一样的地方-->
        <result column="pwd" property="password"/>
    </resultMap>

8、日志

日志工厂

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

曾经：sout、debug

现在：日志工厂

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

Mybatis内置的日志工厂提供日志功能，具体的日志实现有以下几种工具：

SLF4J
Apache Commons Logging
Log4j 2
Log4j
JDK logging
STDOUT_LOGGING等

需要掌握的有：LOG4J、STDOUT_LOGGING

在Mybatis中具体使用哪个日志实现，这设置中设定。

在mybatis-config.xml核心配置文件中，配置我们的日志

标准日志实现

指定 MyBatis 应该使用哪个日志记录实现。如果此设置不存在，则会自动发现日志记录实现

<settings>
       <setting name="logImpl" value="STDOUT_LOGGING"/>  <!--注意空格-->
</settings>

Log4j

概念：

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

使用：

1、先导入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、setting设置日志实现

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

4、在程序中使用Log4j输出

简单使用

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

2、日志对象，参数为当前类的class

static Logger logger = Logger.getLogger(当前测试类类名.class);

3、日志级别

@Test
public void Log4j(){
    //相当于System.out.printf()
    logger.info("info:进入了Log4j")
    logger.debug("debug,进入了Log4j");
    logger.error("error,进入了Log4j");
}

在测试类中加入日志功能

public class myTest {
    static Logger logger = Logger.getLogger(myTest.class);
    @Test
    public void Test(){
        SqlSession sqlSeesion = MyvatisUtils.getSqlSeesion();
        UserDao mapper = sqlSeesion.getMapper(UserDao.class);
        List<User> userList = mapper.getUserList();
        for (User user : userList) {
            logger.info(user);
        }
        sqlSeesion.close();
    }
}

9、分页

分页的好处：

减少数据的处理量

select * from user limit 0,2
每页显示两个，从第0个开始查
当前页 = （当前页-1）*页面大小
0，2   0 1 前两条数据
2，2   2 3 从第二条数据开始查两条数据
select * from user limit 2 #[0,n]
从第0个开始查，查n个

使用Mybatis实现分页【核心SQL】：

1、接口

 List<User> getUserListByLimit(Map<String,Integer> map);

2、Mapper.xml

<select id="getUserListByLimit" parameterType="map" resultType="com.p.pojo.User">
        select * from user limit #{startIndex},#{pageSize}
    </select>

3、测试

    @Test
    public void getUserListByLimit(){
        SqlSession sqlSeesion = MyvatisUtils.getSqlSeesion();
        UserDao mapper = sqlSeesion.getMapper(UserDao.class);
        HashMap<String, Integer> map = new HashMap<String, Integer>();
        map.put("startIndex",2);
        map.put("pageSize",2);
        List<User> userList = mapper.getUserListByLimit(map);
        for (User user : userList) {
            System.out.println(user);
        }
        sqlSeesion.close();
    }

RowBounds分页【不推荐】：

不适用SQLS实现分页

1、接口

 List<User> getUserListByRowBounds();

2、mapper.xml

<select id="getUserListByRowBounds" resultType="com.p.pojo.User">
        select * from user
    </select>

3、测试

    @Test
    public void getUserListByRowBounds(){
        SqlSession sqlSeesion = MyvatisUtils.getSqlSeesion();
        RowBounds rowBounds = new RowBounds(1,2);
        List<User> UserList = sqlSeesion.selectList("com.p.dao.UserDao.getUserListByRowBounds",null,rowBounds);
        for (User user : UserList) {
            System.out.println(user);
        }
        sqlSeesion.close();
    }

分页插件

了解即可：https://pagehelper.github.io/

10、使用注解开发

面向接口编程

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

关于接口的理解

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

三个面向区别

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

使用注解开发

1、注解在接口上实现

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

2、需要再mybatis-config.xml配置文件中绑定接口

<mappers>
	<mapper class="com.p.dao.UserDao"/>
</mappers>

3、测试

@Test
    public void getUsers(){
        SqlSession sqlSeesion = MybatisUtils.getSqlSeesion();
        UserDao mapper = sqlSeesion.getMapper(UserDao.class);
        List<User> users = mapper.getUsers();
        for (User user : users) {
            System.out.println(user);
        }
        sqlSeesion.close();
    }

@Param起别名

1**、基本类型的参数或者String类型，需要加上**

2、引用类型不需要加

3、如果只有一个基本类型的话，可以忽略，但是建议加上

4、在SQL中引用的就是这里@Param()中设定的属性名

方法存在多个参数，所有的参数前面必须加上 @Param(“id”)注解

@Select("select * from user where id= #{id2}")
List<User> getUsersByID(@Param("id2") int id);
//以注解中 id2  位主

使用注解编写CRUD

Select

接口

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

mybatis-config,xml配置文件

<?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 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=utf8"/>
                <property name="username" value="root"/>
                <property name="password" value="123456"/>
            </dataSource>
        </environment>
    </environments>


    <!--绑定接口-->
    <mappers>
        <mapper class="com.p.dao.UserDao"/>
    </mappers>
</configuration>

测试类中

 @Test
    public void getUsers(){
        SqlSession sqlSeesion = MyvatisUtils.getSqlSeesion();
        UserDao mapper = sqlSeesion.getMapper(UserDao.class);
        List<User> users = mapper.getUsers();
        for (User user : users) {
            System.out.println(user);
        }
        sqlSeesion.close();
    }

Insert

在原先的工具类中添加、修改、删除需要提交事务

在MybatisUtils工具类中修改 openSession()中的参数，则会自动提交，默认为关闭

MybatisUtils

public class MyvatisUtils {
    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 getSqlSeesion(){
        //自动提交开启
        return sqlSessionFactory.openSession( true);
    }
}

接口

   @Insert("insert into user(id,name,pwd) values(#{id},#{name},#{pwd})")
    int addUser(User user);

测试

 @Test
    public void addUser(){
        SqlSession sqlSeesion = MyvatisUtils.getSqlSeesion();
        UserDao mapper = sqlSeesion.getMapper(UserDao.class);
        int i = mapper.addUser(new User(7, "777", "777"));
        System.out.println(i);
        sqlSeesion.close();
    }

Update

接口

 @Update("update user set name=#{name},pwd=#{pwd} where id=#{id} ")
    int UpdateUser(User user);

测试

@Test
    public void UpdateUser(){
        SqlSession sqlSeesion = MyvatisUtils.getSqlSeesion();
        UserDao mapper = sqlSeesion.getMapper(UserDao.class);
        int i = mapper.UpdateUser(new User(7, "777777", "7777777"));
        System.out.println(i);
        sqlSeesion.close();
    }

Delete

接口

@Delete("delete from user where id=#{id}")
    int DeleteUser(@Param("id")int id);

测试

 @Test
    public void DeleteUser(){
        SqlSession sqlSeesion = MyvatisUtils.getSqlSeesion();
        UserDao mapper = sqlSeesion.getMapper(UserDao.class);
        int i = mapper.DeleteUser(7);
        System.out.println(i);
        sqlSeesion.close();
    }

【注意：必须要将接口注册绑定到核心配置文件中！】

#与$的区别

#{} 的作用主要是替换预编译语句(PrepareStatement)中的占位符? 【推荐使用】
```
INSERT INTO user (name) VALUES (#{name});
INSERT INTO user (name) VALUES (?);
```

${} 的作用是直接进行字符串替换

INSERT INTO user (name) VALUES ('${name}');
INSERT INTO user (name) VALUES ('kuangshen');

如果有if标签之类的

    @Select("<script> select * from user where 1=1\n" +
            "            <if test=\"username!=null\">\n" +
            "                and username=#{username}\n" +
            "            </if> </script>")
    List<User> getUserByCon(User user);

注解一对一

Order对象

@Data
@ToString
public class Orders {
    private int id;
    private String order_name;
    private SysUser sysUser;
}

SysRole对象

@Data
@ToString
public class SysRole {
    private Integer id;
    private String  roleName;
    private String  roleDesc;
}

SysUser对象

@ToString
@Data
public class SysUser {
    private int id;
    private String username;
    private String password;
    List<Orders> ordersList;
    List<SysRole> sysRoles;
}

@Select("select * from orders")
    @Results({
            @Result(property = "id",column = "id"),
            @Result(property = "order_name",column = "order_name"),
            @Result(property = "sysUser",
            column = "uid",javaType = SysUser.class,//uid类型形参，给下面的地址传参
            one = @One(select ="com.stx.mapper.SysUserMapper.fingUserByid"))
        					//需要调用其他mapper中的方法 
    })
    List<Orders> getOrdes();

被调用的mapper接口中的注解方法

 //查询详情
    @Select("select * from sys_user where id=#{id}")
    SysUser fingUserByid(int id);

一对多

@Select("select * from sys_user")
    @Results({
            @Result(property = "id",column = "id"),
            @Result(property = "username",column = "username"),
            @Result(property = "password",column = "password"),
            @Result(property = "ordersList",column = "id",javaType = List.class,
            many = @Many(select = "com.stx.mapper.OrdersMapper.getOrdersByUid"))
    })
    List<SysUser> findUserAndOrders();

 @Select("select * from orders where uid=#{uid}")
    List<Orders> getOrdersByUid(int uid);

多对多

 //多对多
    @Select("select * from sys_user")
    @Results({
            @Result(property = "id",column = "id"),
            @Result(property = "username",column = "username"),
            @Result(property = "password",column = "password"),
            @Result(property = "sysRoles",column = "id",javaType = List.class,
            many = @Many(select = "com.stx.mapper.SysRoleMapper.getRoleByUid"))
    })
    List<SysUser> findUserAndRoles();

 //根据用户id查询
    @Select("select * from sys_role where id " +
            "in (select roleId from sys_user_role) " +
            "where userId= #{uid}")
    List<SysRole> getRoleByUid(int uid);

11、Lombok

使用步骤：

1、在IDEA中安装Lombok插件

2、在项目中导入Lombok包

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

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

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@AllArgsConstructor
@NoArgsConstructor
@ToString
@EqualsAndHashCode
@Getter
public class User {
    private int id;
    private String name;
    private String pwd;
}

@Data: 无参构造，get、set、tostring、hashcode、equals
@AllArgsConstructor
@NoArgsConstructor

12、多对一处理

多个学生，对应一个老师

对于学生这边而言，关联多个学生关联一个老师**【多对一】**

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

环境搭建

CREATE TABLE `teacher` (
  `id` INT(10) NOT NULL,
  `name` VARCHAR(30) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=INNODB DEFAULT CHARSET=utf8;

INSERT INTO teacher(`id`, `name`) VALUES (1, '秦老师'); 

CREATE TABLE `student` (
  `id` INT(10) NOT NULL,
  `name` VARCHAR(30) DEFAULT NULL,
  `tid` INT(10) DEFAULT NULL,
  PRIMARY KEY (`id`),
  KEY `fktid` (`tid`),
  CONSTRAINT `fktid` FOREIGN KEY (`tid`) REFERENCES `teacher` (`id`)
) ENGINE=INNODB DEFAULT CHARSET=utf8;
INSERT INTO `student` (`id`, `name`, `tid`) VALUES ('1', '小明', '1'); 
INSERT INTO `student` (`id`, `name`, `tid`) VALUES ('2', '小红', '1'); 
INSERT INTO `student` (`id`, `name`, `tid`) VALUES ('3', '小张', '1'); 
INSERT INTO `student` (`id`, `name`, `tid`) VALUES ('4', '小李', '1'); 
INSERT INTO `student` (`id`, `name`, `tid`) VALUES ('5', '小王', '1');

1、导入Lombok

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

2、新建实体类Teacher，Student

Teacher

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

Student

@Data
public class Student {
    private int id;
    private String name;
    //学生需要关联一个老师
    private Teacher teacher;
}

3、建立Mapper接口

Teacher

public interface TeacherDao {
    @Select("select * from Teacher")
    List<Teacher> getTeachers();
}

4、建立Mapper.xml文件

可以在resources文件下建立相同目录的文件如：com/p/dao/TeacherMapper.xml

【注意：】在resources文件下创建目录时，应该是com/p 而不是com.p

5、在核心配置文件中绑定注册Mapper接口或者文件【方式很多，随心选】

 <!--绑定接口-->
    <mappers>
        <mapper resource="com/p/dao/TeacherMapper.xml"/>
        <mapper resource="com/p/dao/StudentMapper.xml"/>
    </mappers>

6、测试

按照查询嵌套处理【子查询】

接口

 //查询所有的学生信息，以及对应的老师信息
    List<Student> getStudents();

StudentMapper.xml配置

<!--思路：
    1、查询所有学生信息
    2、根据查询出来的学生的tid 寻找对应的老师    子查询-->
<mapper namespace="com.p.dao.StudentDao">
    <!--resultMap 结果集映射-->
    <select id="getStudents" resultMap="StudentTeacher">
        select * from student
    </select>
    <resultMap id="StudentTeacher" type="com.p.pojo.Student">
        <!--复杂的属性，我们需要单独处理
        属性中有对象：association
        属性中有集合：collection-->
        <association property="teacher" column="tid" javaType="com.p.pojo.Teacher" select="getTeacher"/>
    </resultMap>
    <select id="getTeacher" resultType="com.p.pojo.Teacher">
        select * from teacher where id=#{id}
    </select>
</mapper>

测试

@Test
    public void getStduent(){
        SqlSession sqlSeesion = MyvatisUtils.getSqlSeesion();
        StudentDao mapper = sqlSeesion.getMapper(StudentDao.class);
        List<Student> students = mapper.getStudents();
        for (Student student : students) {
            System.out.println(student);
        }
        sqlSeesion.close();
    }

按照结果嵌套处理【联表查询】

<select id="getStudents2" resultMap="StudentTeacher2">
        select s.id sid,s.name sname,t.name tname from student s,teacher t where s.tid=t.id
    </select>
    <resultMap id="StudentTeacher2" type="com.p.pojo.Student">
        <result property="id" column="sid"/>
        <result property="name" column="sname"/>
        <association property="teacher" javaType="com.p.pojo.Teacher">
            <result property="name" column="tname"/>
        </association>
    </resultMap>

一对多处理

比如：一个老师拥有多个学生

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

环境搭建

实体类

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

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

按照结果嵌套处理【联表查询】

<select id="getTeacher" resultMap="TeacherStudent">
        select t.id tid,t.name tname,s.id sid,s.name sname from teacher t,student s where s.tid=t.id and t.id= #{tid}
    </select>
    <resultMap id="TeacherStudent" type="com.p.pojo.Teacher">
        <result property="id" column="tid"/>
        <result property="name" column="tname"/>
        <!--private List<Student> students; 对应这里的students
			 属性中有对象：association
        	  属性中有集合：collection
        -->
        <collection property="students" ofType="com.p.pojo.Student">
            <result property="id" column="sid"/>
            <result property="name" column="sname"/>
            <result property="tid" column="tid"/>
        </collection>
    </resultMap>
<!--
结果
Teacher(id=1, name=秦老师, students=[Student(id=1, name=小明, tid=1), Student(id=2, name=小红, tid=1), Student(id=3, name=小张, tid=1), Student(id=4, name=小李, tid=1), Student(id=5, name=小王, tid=1)])-->

按照查询嵌套处理【子查询】

 <select id="getTeacher2" resultMap="TeacherStudent2">
        select * from teacher where id= #{tid};
    </select>
    <resultMap id="TeacherStudent2" type="com.p.pojo.Teacher">
        <collection property="students" column="id" javaType="ArrayList" ofType="com.p.pojo.Student" select="getStudentByTeacherID"/>
    </resultMap>
    <select id="getStudentByTeacherID" resultType="com.p.pojo.Student">
        select * from student where tid=#{tid};
    </select>

<!--结果：
Teacher(id=0, name=秦老师, students=[Student(id=1, name=小明, tid=1), Student(id=2, name=小红, tid=1), Student(id=3, name=小张, tid=1), Student(id=4, name=小李, tid=1), Student(id=5, name=小王, tid=1)])-->

小结：

1、关联----association

2、集合----collection

3、javaType：用来指定实体类中的类型

4、ofType：用来指定映射到List或者集合中的pojo类型，泛型中的约束类型

注意：

1、保证SQL的可读性，尽量保证通俗易懂

2、注意一对多和多对一，属性名和字段的问题

3、如果问题不好排查错误，可以使用日志，建议使用Log4j

面试高频

Mysql引擎

InnoDb底层原理

索引

索引优化

13、动态SQL

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

if、where、set、choose、when

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

动态 SQL 元素和 JSTL 或基于类似 XML 的文本处理器相似。在 MyBatis 之前的版本中，有很多元素需要花时间了解。MyBatis 3 大大精简了元素种类，现在只需学习原来一半的元素便可。MyBatis 采用功能强大的基于 OGNL 的表达式来淘汰其它大部分元素。

  -------------------------------
  - 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、编写配置文件

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


    <settings>
        <!--是否开启自动驼峰命名规则(camel case) 映射-->
        <setting name="mapUnderscoreToCamelCase" value="true"/>
    </settings>

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

    <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=utf8"/>
                <property name="username" value="root"/>
                <property name="password" value="123456"/>
            </dataSource>
        </environment>
    </environments>


    <!--绑定接口-->
    <mappers>
        <mapper class="com.p.dao.BolgMapper"/>
        <!--或者-->
         <mapper pa
    </mappers>
</configuration>

3、编写实体类

@Data
public class Bolg {
    private String id;
    private String title;
    private String author;
    private Date createTime; //属性名和字段名不一致
    private int views;

4、编写实体类对应Mapper接口和Mapper.xml文件

BolgMapper接口

public interface BolgMapper {
    //插入数据
    int addBlog(Bolg bolg);
}

BolgMapper.xml配置文件

<mapper namespace="com.p.dao.BolgMapper">
    <insert id="addBlog" parameterType="com.p.pojo.Bolg">
        insert into blog (id, title, author, create_time, views) values (#{id}, #{title}, #{author}, #{createTime}, #{views});
    </insert>
</mapper>

测试

 @Test
    public void addBlogTest(){
        SqlSession sqlSession = MyvatisUtils.getSqlSeesion();
        BolgMapper mapper = sqlSession.getMapper(BolgMapper.class);
        Bolg blog = new Bolg();
        blog.setId(IDUtils.getId());
        blog.setTitle("Mybatis");
        blog.setAuthor("狂神说");
        blog.setCreateTime(new Date());
        blog.setViews(9999);

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

IF

 //查询博客
    List<Bolg> queryBolgIF(Map map);

如果title和author 为空时，全查

如果title不为空，而author为空，则查跟title匹配的值，跟jstl表达式一样

<select id="queryBolgIF" parameterType="map" resultType="com.p.pojo.Bolg">
        select * from blog where 1=1
        <if test="title !=null">
            and title = #{title}
        </if>
        <if test="author !=null">
            and author=#{author}
        </if>
    </select>

或者改成这种,如果只查title它会自动将and去掉

如果要查title和author，会把第二个条件给加上and

where

<select id="queryBolgIF" parameterType="map" resultType="com.p.pojo.Bolg">
        select * from blog
    <where>
    	 <if test="title !=null">
            and title = #{title}
        </if>
        <if test="author !=null">
            and author=#{author}
        </if>
    </where>
    </select>

测试

@Test
    public void  Test2(){
        SqlSession sqlSeesion = MyvatisUtils.getSqlSeesion();
        BolgMapper mapper = sqlSeesion.getMapper(BolgMapper.class);
        HashMap map = new HashMap();
        //map.put("title","Mybatis");//Bolg(id=b553887c9be64079ae9ab7041ae2d1ae, title=Mybatis, author=狂神说, createTime=Mon Apr 11 11:16:44 CST 2022, views=9999)
        map.put("author","狂神说");//author为狂神说的全部查出来
        //map为空时，全查
        List<Bolg> bolgs = mapper.queryBolgIF(map);
        for (Bolg bolg : bolgs) {
            System.out.println(bolg);
        }
        sqlSeesion.close();
    }

有时候，不想用到所有的查询条件，只想选择其中的一个，查询条件有一个满足即可，使用 choose 标签可以解决此类问题，类似于 Java 的 switch 语句

Choose（when，otherwise）

当满足一个就不执行其他的了，相当于switch

List<Blog> queryBlogChoose(Map map);

<select id="queryBlogChoose" parameterType="map" resultType="blog">
  select * from 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>
</select>

@Test
public void testQueryBlogChoose(){
   SqlSession session = MybatisUtils.getSession();
   BlogMapper mapper = session.getMapper(BlogMapper.class);

   HashMap<String, Object> map = new HashMap<String, Object>();
   map.put("title","Java如此简单");
   map.put("author","狂神说");
   map.put("views",9999);
   List<Blog> blogs = mapper.queryBlogChoose(map);

   System.out.println(blogs);

   session.close();
}

set

同理，上面的对于查询 SQL 语句包含 where 关键字，如果在进行更新操作的时候，含有 set 关键词，我们怎么处理呢？

update blog set title=#{title},author=#{author};

int updateBlog(Map map);

<!--注意set是用的逗号隔开-->
<update id="updateBlog" parameterType="map">
  update blog
     <set>
         <if test="title实体类 != null"> <!--这里面的字段要跟实体类中的属性一样-->
            title数据库 = #{title实体类},
         </if>
         <if test="author != null">
            author = #{author}
         </if>
     </set>
  where id = #{id};
</update>

@Test
public void testUpdateBlog(){
   SqlSession session = MybatisUtils.getSession();
   BlogMapper mapper = session.getMapper(BlogMapper.class);

   HashMap<String, String> map = new HashMap<String, String>();
   map.put("title","动态SQL");
   map.put("author","秦疆");
   map.put("id","9d6a763f5e1347cebda43e2a32687a77");

   mapper.updateBlog(map);
   session.close();
}

SQL片段

有时候可能某个 sql 语句我们用的特别多，为了增加代码的重用性，简化代码，我们需要将这些代码抽取出来，然后使用时直接调用

提取SQL片段：

提取公共部分

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

引用SQL片段：

<select id="queryBlogIf" parameterType="map" resultType="blog">
  select * from blog
   <where>
       <!-- 引用 sql 片段，如果refid 指定的不在本文件中，那么需要在前面加上 namespace -->
       
       <include refid="if-title-author"></include>
       <!-- 在这里还可以引用其他的 sql 片段 -->
   </where>
</select>

注意：

①、最好基于单表来定义 sql 片段，提高片段的可重用性

②、在 sql 片段中不要包括 where

Foreach

将数据库中前三个数据的id修改为1,2,3；

需求：我们需要查询 blog 表中 id 分别为1,2,3的博客信息

原先的sql语句是

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

1、编写接口

List<Blog> queryBlogForeach(Map map);

2、编写SQL语句

<select id="queryBlogForeach" parameterType="map" resultType="blog">
  select * from blog
   <where>
       <!--
		传递一个万能的map，这map中可以存在一个集合
       collection:指定输入对象中的集合属性
       item:每次遍历生成的对象
       open:开始遍历时的拼接字符串
       close:结束时拼接的字符串
       separator:遍历对象之间需要拼接的字符串
       select * from blog where 1=1 and (id=1 or id=2 or id=3)
							字符拼接(1 or 2 or 3)
     -->
       <foreach collection="ids"  item="id" open="and (" close=")" separator="or">
          id=#{id}
       </foreach>
   </where>
</select>

3、测试

@Test
public void testQueryBlogForeach(){
   SqlSession session = MybatisUtils.getSession();
   BlogMapper mapper = session.getMapper(BlogMapper.class);

   HashMap map = new HashMap();
   List<Integer> ids = new ArrayList<Integer>();
   ids.add(1);
   ids.add(2);
   ids.add(3);
   map.put("ids",ids);

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

   System.out.println(blogs);

   session.close();
}

小结：

其实动态 sql 语句的编写往往就是一个拼接的问题，为了保证拼接准确，我们最好首先要写原生的 sql 语句出来，然后在通过 mybatis 动态sql 对照着改，防止出错。多在实践中使用才是熟练掌握它的技巧

14、缓存（了解）

简介

查询：连接数据库，耗资源

一次查询的结果，给他暂存在一个可以直接取到的地方—内存：缓存

再次查询相同数据的时候，直接走缓存，就不用走数据库了

1、什么是缓存

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

2、为什么使用缓存？

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

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

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

4、什么样的数据不能使用缓存

经常改变数据并且不经常查询的数据

Mybatis缓存

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

缓存顺序：

1、先看二级缓存中有没有

2、再看一级缓存中有没有数据

3、如果都没有，再查查询数据库

一级缓存

一级缓存也叫本地缓存：

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

步骤：

1、开启日志，方便测试结果

2、编写接口方法

//根据id查询用户
User queryUserById(@Param("id") int id);

3、接口对应的Mapper文件

<select id="queryUserById" resultType="user">
  select * from user where id = #{id}
</select>

4、测试

@Test
public void testQueryUserById(){
   SqlSession session = MybatisUtils.getSession();
   UserMapper mapper = session.getMapper(UserMapper.class);

   User user = mapper.queryUserById(1);
   System.out.println(user);
   User user2 = mapper.queryUserById(1);
   System.out.println(user2);
   System.out.println(user==user2); //true  地址相同

   session.close();
}

只连接了一次数据库，查相同数据时有缓存，所以两者地址相同。

一级缓存失效的四种情况：

1、查询不同的东西

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

3、查询不同的Mapper.xml

4、手动清理缓存，在测试类中

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

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

SqlSession sqlSeesion = MyvatisUtils.getSqlSeesion();
sqlSeesion.close();

一级缓存就是一个map

二级缓存

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

步骤：

1、开启全局缓存【mybatis-config.xml】

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

2、去每个mapper.xml中配置使用二级缓存，这个配置非常简单；【xxxMapper.xml】

<cache/>

<mapper namespace="com.p.dao.BolgMapper">
    <!--在当前的Mapper.xml中使用二级缓存-->
    <cache/>
    <select useCache="true"> <!--使用缓存，false这个查询不再使用缓存-->
        sql语句
    </select>
</mapper>

官方示例=====>查看官方文档
<cache
 eviction="FIFO"
 flushInterval="60000"
 size="512"
 readOnly="true"/>
这个更高级的配置创建了一个 FIFO 缓存，每隔 60 秒刷新，最多可以存储结果对象或列表的 512 个引用，而且返回的对象被认为是只读的，因此对它们进行修改可能会在不同线程中的调用者产生冲突。

测试

@Test
public void testQueryUserById(){
   SqlSession session = MybatisUtils.getSession();
   SqlSession session2 = MybatisUtils.getSession();

   UserMapper mapper = session.getMapper(UserMapper.class);
   UserMapper mapper2 = session2.getMapper(UserMapper.class);

   User user = mapper.queryUserById(1);
   System.out.println(user);
   session.close();
    //第一个 一级缓存关闭

   User user2 = mapper2.queryUserById(1);
   System.out.println(user2);
   System.out.println(user==user2);

   session2.close();
}

注意：需要将实体类序列化，否则就会报错

小结：

只要开启了二级缓存，我们在同一个Mapper中的查询，可以在二级缓存中拿到数据
查出的数据都会被默认先放在一级缓存中
只有会话提交或者关闭以后，一级缓存中的数据才会转到二级缓存中

自定义缓存【EhCache】

Ehcache是一种广泛使用的java分布式缓存，用于通用缓存；

步骤：

1、导包

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

2、在mapper.xml中使用对应的缓存即可

<mapper namespace ="com.p.dao.BolgMapper">
   <cache type = "org.mybatis.caches.ehcache.EhcacheCache" />
</mapper>

3、编写ehcache.xml文件

<?xml version="1.0" encoding="UTF-8"?>
<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:noNamespaceSchemaLocation="http://ehcache.org/ehcache.xsd"
        updateCheck="false">
   <!--
      diskStore：为缓存路径，ehcache分为内存和磁盘两级，此属性定义磁盘的缓存位置。参数解释如下：
      user.home – 用户主目录
      user.dir – 用户当前工作目录
      java.io.tmpdir – 默认临时文件路径
    -->
   <diskStore path="./tmpdir/Tmp_EhCache"/>
   
   <defaultCache
           eternal="false"
           maxElementsInMemory="10000"
           overflowToDisk="false"
           diskPersistent="false"
           timeToIdleSeconds="1800"
           timeToLiveSeconds="259200"
           memoryStoreEvictionPolicy="LRU"/>

   <cache
           name="cloud_user"
           eternal="false"
           maxElementsInMemory="5000"
           overflowToDisk="false"
           diskPersistent="false"
           timeToIdleSeconds="1800"
           timeToLiveSeconds="1800"
           memoryStoreEvictionPolicy="LRU"/>
   <!--
      defaultCache：默认缓存策略，当ehcache找不到定义的缓存时，则使用这个缓存策略。只能定义一个。
    -->
   <!--
     name:缓存名称。
     maxElementsInMemory:缓存最大数目
     maxElementsOnDisk：硬盘最大缓存个数。
     eternal:对象是否永久有效，一但设置了，timeout将不起作用。
     overflowToDisk:是否保存到磁盘，当系统宕机(崩溃)时
     timeToIdleSeconds:设置对象在失效前的允许闲置时间（单位：秒）。仅当eternal=false对象不是永久有效时使用，可选属性，默认值是0，也就是可闲置时间无穷大。
     timeToLiveSeconds:设置对象在失效前允许存活时间（单位：秒）。最大时间介于创建时间和失效时间之间。仅当eternal=false对象不是永久有效时使用，默认是0.，也就是对象存活时间无穷大。
     diskPersistent：是否缓存虚拟机重启期数据 Whether the disk store persists between restarts of the Virtual Machine. The default value is false.
     diskSpoolBufferSizeMB：这个参数设置DiskStore（磁盘缓存）的缓存区大小。默认是30MB。每个Cache都应该有自己的一个缓冲区。
     diskExpiryThreadIntervalSeconds：磁盘失效线程运行时间间隔，默认是120秒。
     memoryStoreEvictionPolicy：当达到maxElementsInMemory限制时，Ehcache将会根据指定的策略去清理内存。默认策略是LRU（最近最少使用）。你可以设置为FIFO（先进先出）或是LFU（较少使用）。
     clearOnFlush：内存数量最大时是否清除。
     memoryStoreEvictionPolicy:可选策略有：LRU（最近最少使用，默认策略）、FIFO（先进先出）、LFU（最少访问次数）。
     FIFO，first in first out，这个是大家最熟的，先进先出。
     LFU， Less Frequently Used，就是上面例子中使用的策略，直白一点就是讲一直以来最少被使用的。如上面所讲，缓存的元素有一个hit属性，hit值最小的将会被清出缓存。
     LRU，Least Recently Used，最近最少使用的，缓存的元素有一个时间戳，当缓存容量满了，而又需要腾出地方来缓存新的元素的时候，那么现有缓存元素中时间戳离当前时间最远的元素将被清出缓存。
  -->

</ehcache>