Mybaits

Mybaits官方文档

官方文档mybatis – MyBatis 3 | Introduction

Mybaits

一、简介

Ⅰ什么是Mybaits

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

• 它支持自定义 SQL、存储过程以及高级映射。MyBatis 免除了几乎所有的 JDBC 代码以及设置参数和获取结果集的工作。MyBatis 可以通过简单的 XML 或注解来配置和映射原始类型、接口和 Java POJO（Plain Old Java Objects，普通老式 Java 对象）为数据库中的记录。

• MyBatis本是apache的一个开源项目iBatis，2010年这个项目由apache software foundation迁移到了[google code](https://baike.baidu.com/item/google code/2346604)，并且改名为MyBatis。2013年11月迁移到Github。

• iBATIS一词来源于“internet”和“abatis”的组合，是一个基于Java的持久层框架。iBATIS提供的持久层框架包括SQL Maps和Data Access Objects（DAOs）。

  当前，最新版本是MyBatis 3.5.9，其发布时间是2021年12月26日。

  如何获得Mybaits？

  • Github源码下载Search · Mybaits (github.com)

  • Maven仓库(手打)

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

Ⅱ持久化

数据持久化

• 持久化就是将程序的数据在持久状态和瞬时状态转化的过程
• 内存：断电即失
• 数据库（Jdbc）,io文件持久化。

为什么要持久化？

有一些对象，不能让他丢掉
内存太贵

Ⅲ持久层

Dao层、Service层、Controller层

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

Ⅳ为什么需要MyBatis

• 帮助程序员将数据存入到数据库中
• 方便
• 传统的JDBC代码太复杂了，简化，框架，自动化
• 不用MyBatis也可以，技术没有高低之分
• 优点：
  • 简单易学
  • 灵活
  • sql和代码的分离，提高了可维护性。
  • 提供映射标签，支持对象与数据库的orm字段关系映射
  • 提供对象关系映射标签，支持对象关系组建维护
  • 提供xml标签，支持编写动态sql

二、第一个Mybaits程序

思路：搭建环境 --> 导入MyBatis --> 编写代码 --> 测试

Ⅰ搭建环境

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

2. 删除src目录 （就可以把此工程当做父工程了，然后创建子工程）

3. 导入maven依赖

   <!--导入依赖-->
   <dependencies>
       <!--mysqlq驱动-->
       <dependency>
           <groupId>mysql</groupId>
           <artifactId>mysql-connector-java</artifactId>
           <version>8.0.12</version>
       </dependency>
       <!--mybatis-->
       <dependency>
           <groupId>org.mybatis</groupId>
           <artifactId>mybatis</artifactId>
           <version>3.5.4</version>
       </dependency>
       <!--junit-->
       <dependency>
           <groupId>junit</groupId>
           <artifactId>junit</artifactId>
           <version>4.12</version>
           <scope>test</scope>
       </dependency>
   </dependencies>
   

4. 创建一个Module

创建Module时要注意，我自己的这个东西是不对的，需要修改

正确创建一个Maven项目的图示：

Ⅱ创建一个模块

详细参考【狂神说Java】Mybatis最新完整教程IDEA版通俗易懂_哔哩哔哩_bilibili

注意21：43的连接数据库和配置Mybatis即：找寻URL和name和password

• 编写mybatis的核心配置文件（连接数据库）

  <?xml version=\"1.0\" encoding=\"UTF-8\" ?>
  <!DOCTYPE configuration
          PUBLIC \"-//mybatis.org//DTD Config 3.0//EN\"
          \"http://mybatis.org/dtd/mybatis-3-config.dtd\">
  <!--configuration核心配置文件-->
  <configuration>
      <environments default=\"development\">
          <environment id=\"development\">
              <transactionManager type=\"JDBC\"/><!--事物管理，默认使用JDBC来管理-->
              <dataSource type=\"POOLED\">
                  <property name=\"driver\" value=\"com.mysql.jdbc.Driver\"/>
                  <property name=\"url\" value=\"jdbc:mysql://localhost:3306/mybatis?userSSL=true&amp;useUnicode=true&amp;characterEncoding=UTF-8&amp;serverTimezone=UTC\"/>
                  <property name=\"username\" value=\"root\"/>
                  <property name=\"password\" value=\"123456\"/>
              </dataSource>
          </environment>
      </environments>
  </configuration>
  

• 编写mybatis工具类（写死的，这是固定步骤）

  package com.Ji.utils;
  
  import org.apache.ibatis.io.Resources;
  import org.apache.ibatis.session.SqlSession;
  import org.apache.ibatis.session.SqlSessionFactory;
  import org.apache.ibatis.session.SqlSessionFactoryBuilder;
  
  import java.io.IOException;
  import java.io.InputStream;
  
  //sqlSessionFactory --> sqlSession 工厂模式
  public class MybatisUtils {
  
      static SqlSessionFactory sqlSessionFactory = null;
  
      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 getSqlSession(){
          return sqlSessionFactory.openSession();
      }
  }
  

Ⅲ编写代码

• 实体类

  package com.Ji.pojo;
  
  //实体类
  public class User {
      private int id;
      private String name;
      private String pwd ;
  
      public User(){}
  
      public User(int id, String name, String pwd){
          this.id = id;
          this.name = name;
          this.pwd = pwd;
      }
  
      public int getId() {
          return id;
      }
  
      public void setId(int id) {
          this.id = id;
      }
  
      public String getName() {
          return name;
      }
  
      public void setName(String name) {
          this.name = name;
      }
  
      public String getPwd() {
          return pwd;
      }
  
      public void setPwd(String pwd) {
          this.pwd = pwd;
      }
  
      @Override
      public String toString() {
          return \"User{\" +
                  \"id=\" + id +
                  \", name=\'\" + name + \'\\\'\' +
                  \", pwd=\'\" + pwd + \'\\\'\' +
                  \'}\';
      }
  }
  

• Dao接口

  public interface UserDao {
      public 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.kuang.dao.UserDao\">
      <select id=\"getUserList\" resultType=\"com.kuang.pojo.User\">
      select * from USER
    </select>
  </mapper>
  

resultType=\"com.Ji.pojo.User\" 返回结果集

• 测试

注意点：

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

MapperRegistry是什么?

核心配置文件中注册mappers

<mappers>
    <mapper resource=\"org/mybatis/example/BlogMapper.xml\"/>
</mappers>

资源过滤问题，之前在Maven中强调过！！！

• junit测试

      @Test
      public void test(){
  
          //1.获取SqlSession对象
          SqlSession sqlSession = MybatisUtils.getSqlSession();
          //2.执行SQL
          // 方式一：getMapper
          UserDao userDao = sqlSession.getMapper(UserDao.class);
          List<User> userList = userDao.getUserList();
          for (User user : userList) {
              System.out.println(user);
          }
  
          //关闭sqlSession
          sqlSession.close();
      }
  

可能会遇到的问题：
1.配置文件没有注册
2.绑定接口错误
3.方法名不对
4.返回类型不对
5.Maven导出资源问题(maven中约定大于配置，无法生效的解决方案)

  <!--在build中配置resource来防止我们资源导出失败的问题-->
    <build>
        <resources>
            <resource>
                <directory>src/main/resources</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>false</filtering>
            </resource>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>false</filtering>
            </resource>
        </resources>
    </build>

还有一个报错就是：

将这个改为cj就好了，因为是新版本

最后得实现target中有xml才行

命名空间也要注意：

代码优化

对最新版本的Mybatis而言，用try catch finally 代码块包裹更好，官方建议

package com.Ji.dao;

import com.Ji.pojo.User;
import com.Ji.utils.MybatisUtils;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;

import java.util.List;

public class UserDaoTest {
    @Test
    public void test(){
        //获得sqlSession对象
        SqlSession sqlSession = MybatisUtils.getSqlSession();

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

//        //方式二,不推荐，旧版
//        List<User> userList = sqlSession.selectList(\"com.Ji.dao.UserDao.getUserList\");

            for (User user : userList) {
                System.out.println(user);
            }
        }catch (Exception e){
                e.printStackTrace();
        }finally {
            //关闭SqlSession
            sqlSession.close();
        }

    }
}

再次温习一般书写步骤

三、CURD

Ⅰnamespace

namespace中的包名要和Dao/Mapper接口的包名一致需要进行匹配，不然会报错

Ⅱselect

选择，查询语句；

• id：就是对应的namespace中的方法名；
• resultType : Sql语句执行的返回值；
• parameterType : 参数类型；

1. 编写接口

   public interface UserMapper {
       //查询所有用户
       public List<User> getUserList();
       //插入用户
       public void addUser(User user);
   }
   

2. 编写对应的mapper中的sql语句

   <insert id=\"addUser\" parameterType=\"com.Ji.pojo.User\">
       insert into user (id,name,pwd) values (#{id}, #{name}, #{pwd})
   </insert>
   

3. 测试

   //添加用户
       @Test
       public void addUser(){
           SqlSession sqlSession = MybatisUtils.getSqlSession();
           UserMapper mapper = sqlSession.getMapper(UserMapper.class);
   
           mapper.addUser(new User(4,\"hui hui~\",\"567\"));
   
           //增删改一定要提交事务！！！！！
           sqlSession.commit();
   
           sqlSession.close();
       }
   

   注意：增删改查一定要提交事务：

sqlSession.commit();

ⅢInsert

1. 编写接口

   public interface UserMapper {
       //查询所有用户
       List<User> getUserList();
   
       //根据ID查询用户
       User getUserById(int id);
   
       //添加用户
       void addUser(User user);
       
   }
   

2. 编写对应的mapper中的sql语句

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

3. 测试

   //添加用户
       @Test
       public void addUser(){
           SqlSession sqlSession = MybatisUtils.getSqlSession();
           UserMapper mapper = sqlSession.getMapper(UserMapper.class);
   
           mapper.addUser(new User(4,\"hui hui~\",\"567\"));
   
           //增删改一定要提交事务！！！！！
           sqlSession.commit();
   
           sqlSession.close();
       }
   

Ⅳupdate

1. 编写接口

   public interface UserMapper {
       //查询所有用户
       List<User> getUserList();
   
       //根据ID查询用户
       User getUserById(int id);
   
       //添加用户
       void addUser(User user);
   
       //修改用户
       void updateUser(User user);
   }
   

2. 编写对应的mapper中的sql语句

       <!--修改用户的sql语句-->
       <update id=\"updateUser\" parameterType=\"com.Ji.pojo.User\" >
           update mybatis.user
           set name =  #{name}, pwd =  #{pwd}
           where id =  #{id};
       </update>
   

3. 测试

   //更新用户
       @Test
       public void updateUser(){
           SqlSession sqlSession = MybatisUtils.getSqlSession();
           UserMapper mapper = sqlSession.getMapper(UserMapper.class);
   
           mapper.updateUser(new User(4,\"yh\",\"111\"));
   
           sqlSession.commit();
           sqlSession.close();
       }
   

ⅤDelete

1. 编写接口

   public interface UserMapper {
       //查询所有用户
       List<User> getUserList();
   
       //根据ID查询用户
       User getUserById(int id);
   
       //添加用户
       void addUser(User user);
   
       //修改用户
       void updateUser(User user);
   
       //删除用户
       void deleteUser(int id);
   }
   

2. 编写对应的mapper中的sql语句

       <!--删除用户-->
       <delete id=\"deleteUser\" parameterType=\"int\">
           delete from mybatis.user where id = #{id};
       </delete>
   

3. 测试

   //删除用户
       @Test
       public void deleteUser(){
           SqlSession sqlSession = MybatisUtils.getSqlSession();
           UserMapper mapper = sqlSession.getMapper(UserMapper.class);
   
           mapper.deleteUser(4);
   
           sqlSession.commit();
           sqlSession.close();
       }
   

Ⅵ万能Map

假设，我们的实体类，或者数据库中的表，字段或者参数过多，我们应该考虑使用Map!

1. UserMapper接口

   //用万能Map插入用户
   public void addUser2(Map<String,Object> map);
   

2. UserMapper.xml

       <!--Mapper方法,对象中的属性可以直接取出来 传递map的key，属性的值可以不和数据库中的值对应-->
       <insert id=\"addUser2\" parameterType=\"map\" >
           insert into user (id,name,password) values (#{userid},#{username},#{password});
       </insert>
   

3. 测试

   //Mapper方法测试
   @Test
   public void addUser2(){
       SqlSession sqlSession = MybatisUtils.getSqlSession();
       UserMapper mapper = sqlSession.getMapper(UserMapper.class);
   
       HashMap<String, Object> map = new HashMap<String, Object>();
       map.put(\"userid\",4);
       map.put(\"username\",\"yuanHui\");
       map.put(\"password\",789);
       mapper.addUser2(map);
   
       //增删改一定要提交事务！！！！！
       sqlSession.commit();
   
       sqlSession.close();
   }
   

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

   对象传递参数，直接在sql中取出对象的属性即可！ 【parameter=“Object”】

   只有一个基本类型参数的情况下，可以直接在sql中取到 多个参数用Map , 或者注解！

Ⅶ模糊查询

模糊查询这么写？

1. Java代码执行的时候，传递通配符% %

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

2. 在sql拼接中使用通配符

   select * from user where name like #{value}
   

3. 代码

       //模糊查询的实现
       List<User> getUserLike(String value);
   

    <!--模糊查询的查询方式-->
           <select id=\"getUserLike\" resultType=\"com.Ji.pojo.User\">
               select * from mybatis.user where name like #{value};
           </select>
   

       //测试模糊查询
       @Test
       public void getUserLike() {
           SqlSession sqlSession = MybatisUtils.getSqlSession();
           UserMapper mapper = sqlSession.getMapper(UserMapper.class);
   
           List<User> userList = mapper.getUserLike(\"%李%\");
   
           for (User user : userList) {
               System.out.println(user);
           }
   
           sqlSession.close();
       }
   

注意点：

{} 就是编译好SQL语句再取值.

${} 就是取值以后再去编译SQL语句.

所以#{}不存在sql注入问题

四、配置解析

Ⅰ核心配置文件

• 官方建议使用mybatis-config.xml的名称
• Mybatis的配置文件包含了会深深影响MyBatis行为的设置和属性信息。

configuration（配置）

properties（属性）

settings（设置）

typeAliases（类型别名）

typeHandlers（类型处理器）

objectFactory（对象工厂）

plugins（插件）

environments（环境配置）

environment（环境变量）

transactionManager（事务管理器）

dataSource（数据源）

databaseIdProvider（数据库厂商标识）

mappers（映射器）

Ⅱ环境配置 (environments)

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

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

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

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

Ⅲ属性 (properties)

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

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

即：【db.poperties】

1.编写一个配置文件

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

1.可以直接引入外部文件 (比如我们把db.properties的文件如上重新注册一遍)
2.可以在其中增加一些属性配置 （可以在db.properties中写一半，再在xml中进行配置）

3.如果两个文件有同一个字段，优先使用外部配置文件的 （同时设置了pwd，首先使用外部文件的！！！)

Ⅳ类型别名 （typeAliases）

• 类型别名可为 Java 类型设置一个缩写名字。 它仅用于 XML 配置.

• 

• 意在降低冗余的全限定类名书写。

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

也可以指定一个包，每一个在包 domain.blog 中的 Java Bean，在没有注解的情况下，会使用 Bean 的首字母小写的非限定类名来作为它的别名。 比如 domain.blog.Author 的别名为 author,；若有注解，则别名为其注解值。见下面的例子：

<typeAliases>
    <package name=\"com.kuang.pojo\"/>
</typeAliases>

在实体类比较少的时候，使用第一种方式。 如果实体类十分多，建议用第二种扫描包的方式。

第一种可以DIY别名，第二种不行，如果非要改，需要在实体上增加注解。(增加注解后我们放在config里面的!

@Alias(\"author\")
public class Author {
    ...
}

Ⅴ设置 （Settings）

Ⅵ其他配置

• typeHandlers（类型处理器）
• objectFactory（对象工厂）
• plugins 插件
  • mybatis-generator-core
  • mybatis-plus
  • 通用mapper

Ⅶ映射器 （mappers）

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

方式一：【推荐使用】

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

方式二：使用class文件绑定注册(步骤比较繁琐) 实际应用中常常会用到

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

注意点：

• 接口和他的Mapper配置文件必须同名（就是你不能写一个UserDao的接口，然后xml里面注册的时UserMapper.xml，两个文件名称必须相同）
• 接口和他的Mapper配置文件必须在同一个包下
• 

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

<mappers>
    <package name=\"com.Ji.dao\"/>
</mappers>

Ⅷ作用域和生命周期

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

流程分析：

SqlSessionFactoryBuilder:

• 一旦创建了SqlSessionFactory，就不再需要它了
• 局部变量
  SqlSessionFactory:
• 说白了就可以想象为：数据库连接池
• SqlSessionFactory一旦被创建就应该在应用的运行期间一直存在，没有任何理由丢弃它或重新创建一个实例。
• 因此SqlSessionFactory的最佳作用域是应用作用域（ApplocationContext）。程序开始就执行，程序结束就结束
• 最简单的就是使用单例模式或静态单例模式。

SqlSession：

• 连接到连接池的一个请求（直到程序结束时就不存在了）

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

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

  图示理解：

五、解决属性名和字段不一样的问题

Ⅰ问题

数据库中的字段

//实体类
public class User {
    private int id;
    private String name;
    private String password ;
//把之前的pwd改成了password
}

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

测试出现问题

 select * from user where id = #{id}
 类型处理器
 //原本的查询语句查不出来我们没有一一对应的字段，因此我们需要类型处理器来处理与数据库的问题
 select id,name,pwd from user where id = #{id}

解决方法：

• 起别名

• <select id=\"getUserById\" resultType=\"com.kuang.pojo.User\">
      select id,name,pwd as password from USER where id = #{id}
  </select>
  

ⅡresultMap

结果集映射:让数据库中的实体类映射到xml中

id name pwd 我们xml需求的
id name password  我们实体类中存在的

    <!--结果集映射-->
    <resultMap id=\"UserMap\" type=\"User\">
        <!--column数据库中的字段，property实体类中的属性-->
        <result column=\"id\" property=\"id\"></result>
        <result column=\"name\" property=\"name\"></result>
        <result column=\"pwd\" property=\"password\"></result>
    </resultMap>

    <select id=\"getUserById\" resultMap=\"UserMap\">
        select * from USER where id = #{id}
    </select>

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

• ResultMap 的设计思想是，对简单的语句做到零配置，对于复杂一点的语句，只需要描述语句之间的关系就行了。（结果集映射）

• ResultMap 的优秀之处——你完全可以不用显式地配置它们。（即：我们只需要动变过的东西就好了，已经定义好的东西不需要改变）

      <!--结果集映射-->
      <resultMap id=\"UserMap\" type=\"User\">
          <!--column数据库中的字段，property实体类中的属性-->
  <!--        <result column=\"id\" property=\"id\"></result>-->
  <!--        <result column=\"name\" property=\"name\"></result>-->
          <result column=\"pwd\" property=\"password\"></result>
      </resultMap>
  
      <select id=\"getUserById\" resultMap=\"UserMap\">
          select * from USER where id = #{id}
      </select>
  

• 如果这个世界总是这么简单就好了。

六、日志

Ⅰ日志工厂

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

曾经：sout（输出）、debug

• SLF4J
• LOG4J 【掌握】
• LOG4J2
• JDK_LOGGING
• COMMONS_LOGGING
• STDOUT_LOGGING 【掌握】
• NO_LOGGING
  在MyBatis中具体使用哪一个日志实现，在设置中设定

STDOUT_LOGGING

标准的日志工厂的实现STDOUT_LOGGING

<settings>
    <setting name=\"logImpl\" value=\"STDOUT_LOGGING\"/>
</settings>

读日志！！！

ⅡLog4j

什么是Log4j？

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

1. 先导入log4j的包

2.     <settings>
   <!-- <setting name=\"logImpl\" value=\"STDOUT_LOGGING\"/>-->
               <setting name=\"logImpl\" value=\"LOG4J\"/>
       </settings>
   

   <dependency>
       <groupId>log4j</groupId>
       <artifactId>log4j</artifactId>
       <version>1.2.17</version> 
   </dependency>
   

3. 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/rzp.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.sq1.PreparedStatement=DEBUG
   

4. 配置settings为log4j实现

       <settings>
       <!--<setting name=\"logImpl\" value=\"STDOUT_LOGGING\"/>-->
               <setting name=\"logImpl\" value=\"LOG4J\"/>
       </settings>
   

5. 测试运行

Log4j简单使用

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

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

   Logger logger = Logger.getLogger(UserDaoTest.class);
   

3. 日志级别

   logger.info(\"info: 测试log4j\");
   logger.debug(\"debug: 测试log4j\");
   logger.error(\"error:测试log4j\");
   

1.info
2.debug
3.erro

七、分页

思考：为什么分页？

• 减少数据的处理量

Ⅰ使用Limit分页（通过sql层面实现）

sql 语法：SELECT * from user limit startIndex,pageSize 

使用MyBatis实现分页，核心SQL

1. 接口

   //分页
   List<User> getUserByLimit(Map<String,Integer> map);
   

2. Mapper.xml

   <!--分页查询-->
   <select id=\"getUserByLimit\" parameterType=\"map\" resultMap=\"UserMap\">
       select * from 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\",1);
           map.put(\"pageSize\",2);
           List<User> list = mapper.getUserByLimit(map);
           for (User user : list) {
               System.out.println(user);
           }
       }
   

Ⅱ RowBounds分页（通过Java代码层面实现）

不再使用SQL实现分页

1. 接口

   //分页2
   List<User> getUserByRowBounds();
   

2. mapper.xml

       <!--分页查询2-->
       <select id=\"getUserByRowBounds\" resultMap=\"UserMap\">
           select * from USER
       </select>
   

3. 测试

   @Test
       //分页2
       public void getUserByRowBounds(){
           SqlSession sqlSession = MybatisUtils.getSqlSession();
   
           //RowBounds实现
           RowBounds rowBounds = new RowBounds(1, 2);
   
           //通过Java代码层面实现分页
           List<User> userList = sqlSession.selectList(\"com.Ji.dao.UserMapper.getUserByRowBounds\", null, rowBounds);
           for (User user : userList) {
               System.out.println(user);
           }
   
           sqlSession.close();
       }
   

Ⅲ分页插件（通过第三方插件实现）

MyBatis 分页插件 PageHelper

注：不管使用哪种分页它的底层都是limi

八、使用注解开发

Ⅰ面向接口开发

三个面向区别

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

Ⅱ使用注解开发

1. 注解在接口上实现

2. 

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

3. 需要在核心配置文件中绑定接口

       <!--绑定接口-->
       <mappers>
           <mapper class=\"com.Ji.dao.UserMapper\"/>
       </mappers>
   

4. .测试

   本质：反射机制实现

   底层：动态代理

   

   **Java的方式不如写resultMap方便 **

MyBatis详细执行流程

Ⅲ注解CURD

设置自动提交事物，在MybatisUtils.xml里面

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

接口：

//使用注解代替xml
public interface UserMapper {
    @Select(\"select * from user\")
    List<User> getUsers();

    @Select(\"select * from user where id = #{id}\")
    User getUserById(@Param(\"id\") int id);

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

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

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

测试类：

public class UserMapperTest {
    @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);
//        }

//查
//        User userById = mapper.getUserById(1);
//        System.out.println(userById);

//        mapper.addUser(new User(5,\"hello\",\"111\"));

//        mapper.updateUser(new User(4,\"hello update\",\"000\"));

//删
          mapper.deleteUser(5);
        sqlSession.close();
    }
}

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

//方法存在多个参数，所有的参数前面必须加上@Param(\"id\")注解，且取出的id以Param为主
@Delete(\"delete from user where id = ${uid}\")
int deleteUser(@Param(\"uid\") int id);

关于@Param( )注解

• 基本类型的参数或者String类型，需要加上
• 引用类型不需要加
• 如果只有一个基本类型的话，可以忽略，但是建议大家都加上
• 我们在SQL中引用的就是我们这里的@Param()中设定的属性名
• #{} 和 ${}的区别
• 

九、Lombok

(需要偷懒的可以使用，但不建议使用！！！)

Lombok项目是一个Java库，它会自动插入编辑器和构建工具中，

Lombok提供了一组有用的注释，用来消除Java类中的大量样板代码。

仅五个字符(@Data)就可以替换数百行代码从而产生干净，简洁且易于维护的Java类。

使用步骤：

1. 在IDEA中安装Lombok插件

   新版已经内置在IDEA中

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

   <dependency>
       <groupId>org.projectlombok</groupId>
       <artifactId>lombok</artifactId>
       <version>1.18.10</version>
       <scope>provided</scope>
   </dependency>
   

3. 在程序上加注解

   @Getter and @Setter
       
   @FieldNameConstants
       
   @ToString
       
   @EqualsAndHashCode
       
   @AllArgsConstructor, @RequiredArgsConstructor and @NoArgsConstructor
       
   @Log, @Log4j, @Log4j2, @Slf4j, @XSlf4j, @CommonsLog, @JBossLog, @Flogger, @CustomLog
       
   @Data
       
   @Builder
       
   @SuperBuilder
       
   @Singular
       
   @Delegate
       
   @Value
       
   @Accessors
       
   @Wither
       
   @With
       
   @SneakyThrows
       
   @val
   

   说明：

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

   

十、多对一处理

多对一：

• 多个学生，对应一个老师
• 对于学生而言，关联–-多个学生，关联一个老师【多对一】
• 对于老师而言，集合–-一个老师，有很多个学生【一对多】
• 

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

2. 新建实体类Teacher，Student

   package com.Ji.pojo;
   
   import lombok.Data;
   
   @Data
   public class Student {
       private int id;
       private String name;
   
       //学生需要关联一个老师
       private Teacher teacher;
   
   }
   

   package com.Ji.pojo;
   
   import lombok.Data;
   
   @Data
   public class Teacher {
       private int id;
       private String name;
   }
   

3. 建立Mapper接口

   public interface StudentMapper1 {
   }
   

   package com.Ji.dao;
   
   import com.Ji.pojo.Teacher;
   import org.apache.ibatis.annotations.Param;
   import org.apache.ibatis.annotations.Select;
   
   public interface TeacherMapper {
       @Select(\"select * from teacher where id = #{tid}\")
      Teacher getTeacher(@Param(\"tid\") int id);
   }
   
   

4. 建立Mapper.XML文件

   <?xml version=\"1.0\" encoding=\"UTF-8\" ?>
   <!DOCTYPE mapper
           PUBLIC \"-//mybatis.org//DTD Config 3.0//EN\"
           \"http://mybatis.org/dtd/mybatis-3-mapper.dtd\">
   
   <mapper namespace=\"com.Ji.dao.StudentMapper1\">
   
   </mapper>
   

   <?xml version=\"1.0\" encoding=\"UTF-8\" ?>
   <!DOCTYPE mapper
           PUBLIC \"-//mybatis.org//DTD Config 3.0//EN\"
           \"http://mybatis.org/dtd/mybatis-3-mapper.dtd\">
   
   <mapper namespace=\"com.Ji.dao.TeacherMapper\">
   
   </mapper>
   

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

       <mappers>
           <mapper class=\"com.Ji.dao.TeacherMapper\"/>
           <mapper class=\"com.Ji.dao.StudentMapper1\"/>
       </mappers>
   

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

   mapper标签中,xml用resource,注解要用class!!!不然会找不到

Ⅱ按照结果嵌套处理

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

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

Ⅲ按照查询嵌套处理

 <!--
      思路：
          1.查询所有的学生信息
          2.根据查询出来的学生的tid，寻找对应的老师！ 子查询-->
    <select id=\"getStudent\" resultMap=\"StudentTeacher\">
        select * from mybatis.student
    </select>

    <resultMap id=\"StudentTeacher\" type=\"Student\">
        <result property=\"id\" column=\"id\"/>
        <result property=\"name\" column=\"name\"/>
        <!--  复杂的属性，我们需要单独处理 对象：association 集合：collection      -->
        <association property=\"teacher\" column=\"tid\" javaType=\"Teacher\" select=\"getTeacher\"/>
    </resultMap>

    <select id=\"getTeacher\" resultType=\"Teacher\">
        select * from mybatis.teacher where id = #{id}
    </select>

对象使用：association property=\"teacher\" column=\"tid\"就是之前解决名字和字段不一致的问题，我们增加了javaType类型和select的这个属性

集合使用：collection

回顾Mysql多对一查询方式：

• 子查询
• 联表查询

十一、一对多处理

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

**环境搭建 **

1. 环境搭建，和刚才一样
   实体类：

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

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

Ⅰ按照结果嵌套处理

 <!--    按结果嵌套查询-->
    <select id=\"getTeacher\" resultMap=\"TeacherStudent\">
            SELECT  s.id sid,s.name sname,t.name tname,t.id,tid
            from 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=\"\" 指定属性的类型！
             集合中的泛型信息，我们使用ofType获取
             -->
        <collection property=\"students\" ofType=\"Student\">
            <result property=\"id\" column=\"sid\"/>
            <result property=\"name\" column=\"sname\"/>
            <result property=\"tid\" column=\"tid\"/>
        </collection>
    </resultMap>

复杂的属性，我们需要单独处理 对象：association 集合：collection

javaType=\"\" 指定属性的类型！
集合中的泛型信息，我们使用ofType获取

查询结果

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

    <resultMap id=\"TeacherStudent2\" type=\"Teacher\">
        <collection property=\"students\" javaType=\"ArrayList\" ofType=\"Student\" select=\"getStudentByTeacherId\" column=\"tid\"/>
    </resultMap>

    <select id=\"getStudentByTeacherId\" resultType=\"Student\">
        select * from  mybatis.student where tid = #{tid}
    </select>

Ⅲ小结

1. 关联-association【多对一】
2. 集合-collection【一对多】
3. javaType & ofType
   javaType 用来指定实体类中属性的类型
4. ofType 用来指定映射到List或者集合中的pojo类型，泛型中的约束类型！
   

注意点：保证SQL的可读性，尽量保证通俗易懂

• 注意一对多和多对一中，属性名和字段的问题！
• 如果问题不好排查错误，可以使用日志，建议使用Log4j

面试高频

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

十二、动态SQL

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

利用动态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. 编写配置文件

   <?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>
   
       <settings>
           <setting name=\"logImpl\" value=\"STDOUT_LOGGING\"/>
   <!--开启驼峰命名规范-->
           <setting name=\"mapUnderscoreToCamelCase\" value=\"true\"/>
       </settings>
   
       <typeAliases>
           <package name=\"com.Ji.pojo\"/>
       </typeAliases>
       
       <environments default=\"development\">
           <environment id=\"development\">
               <transactionManager type=\"JDBC\"/><!--事物管理，默认使用JDBC来管理-->
               <dataSource type=\"POOLED\">
                   <property name=\"driver\" value=\"com.mysql.cj.jdbc.Driver\"/>
                   <property name=\"url\" value=\"jdbc:mysql://localhost:3306/mybatis?userSSL=false&amp;useUnicode=true&amp;characterEncoding=utf8&amp;serverTimezone=UTC\"/>
   
                   <property name=\"username\" value=\"root\"/>
                   <property name=\"password\" value=\"123456\"/>
               </dataSource>
           </environment>
       </environments>
   
       <mappers>
           <mapper class=\"com.Ji.dao.BlogMapper\"/>
       </mappers>
   
   </configuration>
   

3. 编写实体类

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

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

接口：

public interface BlogMapper {
        //插入数据
    int addBlog(Blog blog);
}

xml

<?xml version=\"1.0\" encoding=\"UTF-8\" ?>
<!DOCTYPE mapper
        PUBLIC \"-//mybatis.org//DTD Config 3.0//EN\"
        \"http://mybatis.org/dtd/mybatis-3-mapper.dtd\">
<mapper namespace=\"com.Ji.dao.BlogMapper\">
    <insert id=\"addBlog\" parameterType=\"blog\">
        insert into mybatis.blog (id,title,author,create_time,views)
        values(#{id},#{title},#{author},#{createTime},#{views});

    </insert>
</mapper>

ⅠIF

编写接口：

public interface BlogMapper {
    //插入数据
    int addBlog(Blog blog);
    //查询博客
    List<Blog> queryBlogIF(Map map);

}

xml：

为了方便拼接的，习惯性拼接1=1，这样后面添加的都可以用 and 连接 省去后期需要去掉第一个and

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

测试：（在map.put中输入的是数据库的 列名 和 需要 查询的名字）

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

        HashMap map = new HashMap();
//        map.put(\"title\",\"Mybatis\");
        map.put(\"author\",\"Kuang shen\");
        List<Blog> blogs = mapper.queryBlogIF(map);

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

    }

Ⅱ choose (when, otherwise)

choose的作用就是有id我就查ID，有title我就查title

并且when标签中第一个不需要加and，之后的得加and，意思就是如果第一个不成立那么第二个再继续成立

接口：

public interface BlogMapper {
    //插入数据
    int addBlog(Blog blog);
    //查询博客
    List<Blog> queryBlogIF(Map map);

    List<Blog> queryBlogChoose(Map map);
}

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 views = #{views}
                </otherwise>
            </choose>
        </where>
    </select>

测试类：

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

        HashMap map = new HashMap();
//        map.put(\"title\",\"Mybatis\");
//        map.put(\"author\",\"Kuang shen\");
        map.put(\"title\",\"Java\");
        map.put(\"views\",\"9999\");

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

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

        sqlSession.close();

    }

Ⅲ trim (where, set)

Where标签

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

where标签对1=1的优化：（即采用where标签取消对where sql 语句的书写）

之前的代码   
<select id=\"queryBlogIF\" parameterType=\"map\" resultType=\"Blog\">
        select * from mybatis.blog where 1=1
        <if test=\"title != null\">
            and title = #{title}
        </if>
        <if test=\"author != null\">
            and author = #{author}
        </if>
    </select>

采用如上的代码运行结果为：

我们在测试中的代码没有写map.put(\"title\",\"Mybatis\");

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

        HashMap map = new HashMap();
//        map.put(\"title\",\"Mybatis\");
        map.put(\"author\",\"Kuang shen\");
        List<Blog> blogs = mapper.queryBlogIF(map);

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

        sqlSession.close();

    }

当我们写了map.put(\"title\",\"Mybatis\");

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

        HashMap map = new HashMap();
        map.put(\"title\",\"Mybatis\");
        map.put(\"author\",\"Kuang shen\");
        List<Blog> blogs = mapper.queryBlogIF(map);

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

        sqlSession.close();

    }

查询结果如下：

Set标签

明确两个作用：

1. set语句里面如果能执行成功，那就走里面的功能
2. 如果存在逗号，那么set方法会自动地去除
3. 

    <update id=\"updateBlog\" parameterType=\"map\">
        update mybatis.blog
        <set>
            <if test=\"title != null\">
                title = #{title},
            </if>
            <if test=\"author != null\">
                author = #{author}
            </if>
        </set>
        where id = #{id}
    </update>

父标签：trim

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

Ⅳ Foreach

• 动态 SQL 的另一个常见使用场景是对集合进行遍历（尤其是在构建 IN 条件语句的时候）。
• foreach 元素的功能非常强大，它允许你指定一个集合，声明可以在元素体内使用的集合项（item）和索引（index）变量。它也允许你指定开头与结尾的字符串以及集合项迭代之间的分隔符。这个元素也不会错误地添加多余的分隔符，看它多智能！
• 提示你可以将任何可迭代对象（如 List、Set 等）、Map 对象或者数组对象作为集合参数传递给 foreach。当使用可迭代对象或者数组时，index 是当前迭代的序号，item 的值是本次迭代获取到的元素。当使用 Map 对象（或者 Map.Entry 对象的集合）时，index 是键，item 是值。
• 

  <!--select * from blog where 1=1 and (id=1 or id=2 or id=3)
        我们现在传递一个万能的map，这map中可以存在一个集合！
        -->
    <select id=\"queryBlogForeach\" parameterType=\"map\" resultType=\"Blog\">
        select * from mybatis.blog
        <where>
            <foreach collection=\"ids\" item=\"id\" open=\"and (\" close=\")\" separator=\"or\">
                id = #{id}
            </foreach>
        </where>
    </select>

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

• 先在Mysql中写出完整的SQL，再对应的去修改成我们的动态SQL实现通用即可！
• 查询结果如下：id被拼接成了or了
• 

Ⅴ SQL片段

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

sql标签类似于将sql公共部分进行分类化，然后再我们需要用的这段代码中   引入它们

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

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

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

      <select id=\"queryBlogIF\" parameterType=\"map\" resultType=\"Blog\">
           select * from mybatis.blog
           <where>
               <include refid=\"if-title-author\"></include>
           </where>
       </select>

注意事项：

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

十三、缓存

Ⅰ简介

1. 什么是缓存 [ Cache ] ？

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

2. 为什么使用缓存？
   减少和数据库的交互次数，减少系统开销，提高系统效率。
3. 什么样的数据能使用缓存？
   经常查询并且不经常改变的数据。【可以使用缓存】
4. 经常查询且不经常改变的数据 【不可以使用缓存】

ⅡMybatis缓存

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

Ⅲ一级缓存

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

测试步骤：

1. 开启日志！
2. 测试在一个Session中查询两次相同记录
3. 查看日志输出

代码：

实体类：

package com.Ji.pojo;

import lombok.Data;

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

接口：

import com.Ji.pojo.User;
import org.apache.ibatis.annotations.Param;

public interface UserMapper {
    //查询用户
    User queryUserById(@Param(\"id\") int id);
}

xml：

<?xml version=\"1.0\" encoding=\"UTF-8\" ?>
<!DOCTYPE mapper
        PUBLIC \"-//mybatis.org//DTD Config 3.0//EN\"
        \"http://mybatis.org/dtd/mybatis-3-mapper.dtd\">
<mapper namespace=\"com.Ji.dao.UserMapper\">
    <select id=\"queryUserById\" resultType=\"user\">
        select * from user where id = #{id}
    </select>
</mapper>

测试类：

import com.Ji.dao.UserMapper;
import com.Ji.pojo.User;
import com.Ji.utils.MybatisUtils;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;

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

        User user1 = mapper.queryUserById(1);
        System.out.println(user1);
        System.out.println(\"================分割线====================\");

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

        System.out.println(user1 == user2   );
        sqlSession.close();
    }
}

缓存失效的情况：

1. 查询不同的东西；

2. 增删改操作，可能会改变原来的数据，所以必定会刷新缓存！没有更新的也会执行一起sql语句

3. 查询不同的Mapper.xml

4. 手动清理缓存！

   sqlSession.clearCache();
   

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

Ⅳ二级缓存

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

开启缓存
<cache/>
 <settings>
        <setting name=\"logImpl\" value=\"STDOUT_LOGGING\"/>
        <!--显示地开启全局缓存-->
        <setting name=\"cacheEnabled\" value=\"true\"/>
    </settings>

步骤：

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

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

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

   也可以自定义参数

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

3. 测试

   1. 问题：如果没有自定义参数，则会报错，我们需要将实体类序列化！

      Cause: java.io.NotSerializableException: com.kuang.pojo.User
      

      小结：

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

Ⅴ缓存原理

Ⅵ自定义缓存-ehcache

Ehcache是一种广泛使用的开源Java分布式缓存，主要面向通用缓存。

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

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

目前：Redis数据库来做缓存！K-V

<?xml version=\"1.0\" encoding=\"UTF-8\"?>
<ehcache xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"
         xsi:noNamespaceSchemaLocation=\"http://ehcache.org/ehcache.xsd\"
         updateCheck=\"false\">
    
    <diskStore path=\"./tmpdir/Tmp_EhCache\"/>

    <defaultCache
            eternal=\"false\"
            maxElementsInMemory=\"10000\"
            overflowToDisk=\"false\"
            diskPersistent=\"false\"
            timeToIdleSeconds=\"1800\"
            timeToLiveSeconds=\"259200\"
            memoryStoreEvictionPolicy=\"LRU\"/>

    <cache
            name=\"cloud_user\"
            eternal=\"false\"
            maxElementsInMemory=\"5000\"
            overflowToDisk=\"false\"
            diskPersistent=\"false\"
            timeToIdleSeconds=\"1800\"
            timeToLiveSeconds=\"1800\"
            memoryStoreEvictionPolicy=\"LRU\"/>
</ehcache>

来源：https://www.cnblogs.com/HuihuiGoforIt/p/16598093.html
本站部分图文来源于网络，如有侵权请联系删除。