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>
    <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=false&amp;useUnicode=true&amp;characterEncoding=utf8"/>
                <property name="username" value="root"/>
                <property name="password" value="123456"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <mapper resource="dao/UserMapper.xml"/>
    </mappers>
</configuration>

2、创建工具类生成sqlSession

在src/main/java中创建一个utils工具包，创建了一工具类生成sqlSession，sqlSession就是Mybatis中数据库连接对象
通过 UserMapper mapper = sqlSession.getMapper(UserMapper.class);可以直接获取对应的接口对象，sqlSession.commit()：提交事务。sqlSession.close()：关闭数据库连接。

package utils;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.javassist.bytecode.stackmap.BasicBlock;
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;
public class MybatisUtils {
   private static SqlSessionFactory sqlSessionFactory;
    static {
        try {
//            先获取sqlSessionFactory对象
            String resource = "mybatis-config.xml";
            InputStream inputStream = Resources.getResourceAsStream(resource);
            sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    public static SqlSession getSqlSession(){
//        根据sqlSessionFactory.openSession()获取到sqlSession
//        将sqlSession返回
        return  sqlSessionFactory.openSession();
    }

}

3、创建Mapper（Dao）接口类

public interface UserMapper {

User getUserById(int id);
int addUser(User user);
int deleteUser(int id);
int updateUser(User user);

}

4、创建Mapper.xml配置文件

创建Mapper接口类对应的Mapper.xml配置文件，顶替原先的Impl实现类。

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

<mapper namespace="dao.UserMapper">
//select对应查询，insert对应插入，delete对应删除，update对应修改
//resultType设置返回类型，resultMap设置结果集类型，parameterType设置参数类型，parameterMap设置参数及类型，#{}可以直接获取对应的值，替代jdbc中的？号
   <select id="getUserById" resultType="pojo.User" parameterType="int">
        select * from user where id=#{id}
    </select>
    <insert id="addUser" parameterType="pojo.User">
        insert into user value(#{id},#{name},#{pwd})
    </insert>
    <update id="updateUser" parameterType="pojo.User">
       update user set name=#{name},pwd=#{pwd} where id=#{id}
    </update>
    <delete id="deleteUser" parameterType="int">
        delete from user where id=#{id}
    </delete>
</mapper>

5、测试

在test文件夹下创建相同的文件夹src/test/java/dao，创建测试类

public class UserMapperTest {
     public  void deleteUser(){
 //        获取sqlSession
         SqlSession sqlSession = MybatisUtils.getSqlSession();
 //        执行sql
         UserMapper mapper = sqlSession.getMapper(UserMapper.class);
         int i = mapper.deleteUser(4);
 //增删改需要提交事务
         sqlSession.commit();
         //关闭连接
         sqlSession.close();
     }
 }

二、万能Map

传入参数类型是Map时，直接在sql中取出key即可，可以灵活的增删改查，例如修改密码时只传id和密码就行。
例:Mapper.xml：

<update id="updateUser" parameterType="map">
 update user set pwd=#{password} where id=#{userid}
</update>

测试代码：

Map<String,Object> map=new HashMap<String,Object>();
map.put("userid",1);
map.put("password","23333");
int i = mapper.updateUser(map);

三、核心配置文件mybatis-config.xml

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

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

1、mappers元素：映射器 : 定义映射SQL语句文件

<!-- 使用相对于类路径的资源引用 -->
    <mappers>
     <mapper resource="org/mybatis/builder/AuthorMapper.xml"/>
    </mappers>
<!--使用映射器接口实现类的完全限定类名，注意点：接口和它的配置文件必须同名且在同一包下-->
    <mappers>
     <mapper class="org.mybatis.builder.AuthorMapper"/>
    </mappers>
<!--将包内的映射器接口实现全部注册为映射器，但是需要配置文件名称和接口名称一致，并且位于同一目录下-->
    <mappers>
     <package name="org.mybatis.builder"/>
    </mappers>

2、环境配置（事务管理器）

在 MyBatis 中有两种类型的事务管理器（也就是 type="[JDBC|MANAGED]"）：默认事务管理器时JDBC。

数据源（dataSource）有三种内建的数据源类型（也就是 type=[UNPOOLED|POOLED|JNDI]"）：默认是POOLED
    unpooled：这个数据源的实现只是每次被请求时打开和关闭连接。
    pooled：这种数据源的实现利用“池”的概念将 JDBC 连接对象组织起来 , 这是一种使得并发 Web 应用快速响应请求的流行处理方式。
    jndi：这个数据源的实现是为了能在如 Spring 或应用服务器这类容器中使用，容器可以集中或在外部配置数据源，然后放置一个 JNDI 上下文的引用。
    数据源也有很多第三方的实现，比如dbcp，c3p0，druid等等....

3、属性(properties)

通过properties属性来实现引用配置文件，可以直接引入外部配置文件，也可以在properties元素的子元素中设置

<!--    引入外部properties配置文件-->
     <properties resource="db.properties">
            <property name="password" value="123456"/>
     </properties>

通过方法参数传递的属性具有最高优先级，配置文件次之，最低的则是 properties元素的子元素。

4、类型别名

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

方式一：给实体类起别名，可以DIY，实体类少的时候使用该方式
 <typeAliases>
     <typeAlias type="pojo.User" alias="User"/>
     <typeAlias type="dao.UserMapper" alias="Mapper"/>
 </typeAliases>
 方式二：也可以指定一个包名，MyBatis 会在包名下面搜索需要的 Java Bean，包下的类建议使用时首字母小写，这样可以看出是扫描包的情况。
 <typeAliases>
   <package name="domain.blog"/>
 </typeAliases>
 方式三：也可以使用注解给每个类起别名,作用和方式一一样，不需要再在配置文件中修改
    @Alias("UserMapper")
    public interface UserMapper {
        List<User> getUserList();
    }

注意，为了应对原始类型的命名重复，采取了特殊的命名风格。给基本数据类型起别名前面加_，基本数据类型包装类起别名首字母小写

5、调整设置

这是Mybatis中汲取重要的调整设置，它们会改变Mybatis的运行时行为
1、mapUnderscoreToCamelCase 是否开启驼峰命名自动映射，即从经典数据库列名 A_COLUMN 映射到经典 Java 属性名 aColumn。默认值：False
2、logImpl 指定MyBatis所用日志的具体实现，未指定时将自动查找。日志实现：SLF4J | LOG4J | LOG4J2 | JDK_LOGGING | COMMONS_LOGGING | STDOUT_LOGGING | NO_LOGGING
3、cacheEnabled 全局性地开启或关闭所有映射器配置文件中已配置的任何缓存。默认值：true
4、 lazyLoadingEnabled 延迟加载的全局开关。当开启时，所有关联对象都会延迟加载。特定关联关系中可通过设置 fetchType 属性来覆盖该项的开关状态。默认值：false

四、SqlSession生命周期和作用域

1、 SqlSessionFactoryBuilder

作用在于创建 SqlSessionFactory,创建成功后，SqlSessionFactoryBuilder 就失去了作用，所以它只能存在于创建 SqlSessionFactory 的方法中，而不要让其长期存在。因此 SqlSessionFactoryBuilder 实例的最佳作用域是方法作用域（也就是局部方法变量）。

2、 SqlSessionFactory :

可以被认为是一个数据库连接池，它的作用是创建 SqlSession 接口对象。因为 MyBatis 的本质就是 Java 对数据库的操作，所以 SqlSessionFactory 的生命周期存在于整个 MyBatis 的应用之中，所以一旦创建了 SqlSessionFactory，就要长期保存它，直至不再使用 MyBatis 应用，所以可以认为 SqlSessionFactory 的生命周期就等同于 MyBatis 的应用周期。

由于 SqlSessionFactory 是一个对数据库的连接池，所以它占据着数据库的连接资源。如果创建多个 SqlSessionFactory，那么就存在多个数据库连接池，这样不利于对数据库资源的控制，也会导致数据库连接资源被消耗光，出现系统宕机等情况，所以尽量避免发生这样的情况。

因此在一般的应用中我们往往希望 SqlSessionFactory 作为一个单例，让它在应用中被共享。所以说 SqlSessionFactory 的最佳作用域是应用作用域。

3、SqlSession:

如果说SqlSessionFactory相当于数据库连接池，那么 SqlSession 就相当于一个数据库连接（Connection 对象），你可以在一个事务里面执行多条 SQL，然后通过它的 commit、rollback 等方法，提交或者回滚事务。所以它应该存活在一个业务请求中，处理完整个请求后，应该关闭这条连接，让它归还给 SqlSessionFactory，否则数据库资源就很快被耗费精光，系统就会瘫痪，所以用 try...catch...finally... 语句来保证其正确关闭。
所以SqlSession的最佳的作用域是请求或方法作用域。

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

方式一：起别名
        <select id="getUserById" resultType="pojo.User" parameterType="int">
            select id,name,pwd as password from user where id=#{id}
        </select>
方式二：resultMap结果集映射
        <!--    结果集映射-->
            <resultMap id="UserMap" type="User">
        <!-- column表示数据库的列，property表示实体类的属性-->
                <result column="id" property="id"/>
                <result column="name" property="name"/>
                <result column="pwd" property="password"/>
            </resultMap>
            <select id="getUserById" resultMap="UserMap">
                select * from user where id=#{id}
            </select>

六、日志

1、日志工厂

如果数据可操作出现了异常，为了方便排错，引入日志。使用settings引入
logImpl 指定MyBatis所用日志的具体实现，未指定时将自动查找。

日志实现：
SLF4J
LOG4J 掌握
LOG4J2
JDK_LOGGING
COMMONS_LOGGING
STDOUT_LOGGING 掌握
NO_LOGGING

在Mybatis中具体使用哪个日志实现

2、Log4j

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

3、使用步骤：

3.1、导入log4j的包

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

3.2、配置文件编写

#将等级为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.3、setting设置日志实现

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

3.4、在程序中使用Log4j进行输出！

//注意导包：org.apache.log4j.Logger
//参数为当前类的class
static Logger logger = Logger.getLogger(MyTest.class);
@Test
public void selectUser() {
   logger.info("info：进入selectUser方法");
   logger.debug("debug：进入selectUser方法");
   logger.error("error: 进入selectUser方法");
   SqlSession session = MybatisUtils.getSession();
   UserMapper mapper = session.getMapper(UserMapper.class);
   List<User> users = mapper.selectUser();
   for (User user: users){
       System.out.println(user);
  }
   session.close();
}

3.5、测试，看控制台输出！

使用Log4j 输出日志

可以看到还生成了一个日志的文件【需要修改file的日志级别】

七、分页

1、使用Limit实现分页

语法

SELECT * FROM table LIMIT stratIndex，pageSize
SELECT * FROM table LIMIT 5,10; // 检索记录行 6-15
为了检索从某一个偏移量到记录集的结束所有的记录行，可以指定第二个参数为 -1：
SELECT * FROM table LIMIT 95,-1; // 检索记录行 96-last.
如果只给定一个参数，它表示返回最大的记录行数目：
SELECT * FROM table LIMIT 5; //检索前 5 个记录行
换句话说，LIMIT n 等价于 LIMIT 0,n。

步骤：

1、修改Mapper文件

<select id="selectUser" parameterType="map" resultType="user">
    select * from user limit #{startIndex},#{pageSize}
</select>

2、Mapper接口，参数为map

//选择全部用户实现分页
List<User> selectUser(Map<String,Integer> map);

3、在测试类中传入参数测试

推断：起始位置 = （当前页面 - 1 ） * 页面大小

//分页查询 , 两个参数startIndex , pageSize
@Test
public void testSelectUser() {
  SqlSession session = MybatisUtils.getSqlSession();
  UserMapper mapper = session.getMapper(UserMapper.class);
  int currentPage = 1;  //第几页
  int pageSize = 2;  //每页显示几个
  Map<String,Integer> map = new HashMap<String,Integer>();
  map.put("startIndex",(currentPage-1)*pageSize);
  map.put("pageSize",pageSize);
  List<User> users = mapper.selectUser(map);
  for (User user: users){
      System.out.println(user);
 }
  session.close();
}

2、RowBounds分页

我们除了使用Limit在SQL层面实现分页，也可以使用RowBounds在Java代码层面实现分页，当然此种方式作为了解即可。我们来看下如何实现的！
步骤：
2.1、mapper接口

//选择全部用户RowBounds实现分页
List<User> getUserByRowBounds();

2.2、mapper文件

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

2.3、测试类

在这里，我们需要使用RowBounds类

@Test
public void testUserByRowBounds() {
  SqlSession session = MybatisUtils.getSqlSession();
  int currentPage = 2;  //第几页
  int pageSize = 2;  //每页显示几个
  RowBounds rowBounds = new RowBounds((currentPage-1)*pageSize,pageSize);
  //通过session.**方法进行传递rowBounds，[此种方式现在已经不推荐使用了]
  List<User> users = session.selectList("mapper.UserMapper.getUserByRowBounds", null, rowBounds);
  for (User user: users){
      System.out.println(user);
 }
  session.close();
}

3、分页插件：PageHelper

八、注解开发

注意：利用注解开发就不需要mapper.xml映射文件了

使用注解开发只能在核心配置文件中使用class一个个导入接口，使用.xml开发可以直接使用resource配置*.xml配置所有.xml文件

1、我们在我们的接口中添加注解

//如果有多个基本数据类型参数，每个参数都需要使用注解@Param("")说明
@Select("select id,name,pwd password from user where id=#{id} and name=#{name}")
 User getUserById(@Param("id") int id,@Param("name") String name);

2、在mybatis的核心配置文件中注入

<!--使用class绑定接口-->
<mappers>
    <mapper class="dao.UserMapper"/>
</mappers>

3、测试

@Test
   public  void getUserById(){
//        获取sqlSession
       SqlSession sqlSession = MybatisUtils.getSqlSession();
//        执行sql
       UserMapper mapper = sqlSession.getMapper(UserMapper.class);
       User userById = mapper.getUserById(2,"张三");
       System.out.println(userById);
       sqlSession.close();
   }

4、利用Debug查看本质

5、本质上利用了JVM动态代理机制

6、设置事务自动提交

//获取SqlSession连接
public static SqlSession getSession(){
  return sqlSessionFactory.openSession(true);
}

@Param注解用于给方法参数起一个名字。以下是总结的使用原则：

在方法只接受一个参数的情况下，可以不使用@Param。

在方法接受多个参数的情况下，建议一定要使用@Param注解给参数命名。

如果参数是JavaBean，则不能使用@Param。

不使用@Param注解时，参数只能有一个，并且是Javabean。

使用注解和配置文件协同开发，才是MyBatis的最佳实践！

#与$的区别

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

INSERT INTO user (name) VALUES (#{name});
INSERT INTO user (name) VALUES (?);

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

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

九、Mybatis详细的执行流程

十、Lombok

使用步骤：
1、IDEA安装插件Lombok
2、在pom中导入Lombok包
3、以下注解及生成的方法

 @Getter:get方法
  @Setter:set方法
  @FieldNameConstants：Fields
  @ToString：toString方法
  @EqualsAndHashCode：equals、hashCode、canEqual
  @AllArgsConstructor：全参构造器, @RequiredArgsConstructor and @NoArgsConstructor:空参构造器
  @Log, @Log4j, @Log4j2, @Slf4j, @XSlf4j, @CommonsLog, @JBossLog, @Flogger, @CustomLog
  @Data ：无参构造、get、set、toString、hashcode、equals
  @Builder
  ...

十一、数据库关系多对一处理

多个学生对应一个老师，学生数据库表中设置老师的id的外键
对于学生，多对一的现象，从学生这边关联一个老师！
对于老师而言，集合，一对多现象

1、多对一

多个学生对应一个老师。设计：学生数据库表中设置老师的id的外键，Student有Teacher teacher属性
查询方式一：按查询嵌套处理

    <select id="getStudents" resultMap="StudentTeacher">
     select id,name,tid from student
    </select>
    <resultMap id="StudentTeacher" type="Student">
        <!--result只能映射单个属性-->
        <result property="id" column="id"/>
        <!--复杂属性需要单独处理
        对象：association ，数据封装成对象时使用该方法。
             property是JavaBean中对应的数据名称，
             column表示子查询要传入的参数，如果是多参数column="{key=value,key=value}"，key是传给下个sql的取值名称，value是sql查询出的字段名。
             javaType是要封装成的类型，
             select是要嵌套的子查询
        集合：collection
        -->
        <association property="teacher" column="tid" javaType="Teacher" select="getTeacher"/>
    </resultMap>
    <select id="getTeacher" resultType="Teacher">
        select id,name from teacher where id=#{tid}
    </select>

方式二：按结果嵌套处理

<select id="getStudents2" resultMap="StudentTeacher2">
        select s.id sid,s.name sname,t.id tid,t.name tname from student s,teacher t where s.tid=t.id
</select>
<resultMap id="StudentTeacher2" type="Student">
        <result property="id" column="sid"/>
        <result property="name" column="sname"/>
          <!--复杂属性需要单独处理
           对象：association ，数据封装成对象时使用该方法。
                           property是JavaBean中对应的数据名称
                           javaType是要封装成的类型，
           集合：collection
        -->
        <association property="teacher" javaType="Teacher">
             <result property="id" column="tid"/>
             <result property="name" column="tname"/>
        </association>
</resultMap>

2、一对多

一个老师拥有多个学生。设计：学生数据库表中设置老师的id的外键，Teacher中设置List<Student> students属性
查询方式一：按查询嵌套处理

<select id="getTeachers" resultMap="TeacherStudent2">
    select id,name from teacher
</select>
<resultMap id="TeacherStudent" type="Teacher">
    <!--
    对查询出来的操作做结果集映射
    集合的话，使用collection！
    JavaType和ofType都是用来指定对象类型的
    JavaType是用来指定pojo中属性的类型
    ofType指定的是映射到list集合属性中pojo的类型。
    -->
    <collection property="students" column="id" javaType="ArrayList" ofType="Student" select="getStudent"/>
</resultMap>
<select id="getStudent" resultType="Student">
    select id,name,tid from student where tid=#{id}
</select>

方式二：按结果嵌套处理

<select id="getTeachers" resultMap="TeacherStudent">
    select t.id tid, t.name tname, s.id sid, s.name sname from teacher t,student s where t.id = s.tid
</select>
<resultMap id="TeacherStudent" type="Teacher">
    <result property="id" column="tid"/>
    <result property="name" column="tname"/>
    <!--
         对查询出来的操作做结果集映射
         集合的话，使用collection！
          JavaType和ofType都是用来指定对象类型的
          JavaType是用来指定pojo中属性的类型
          ofType指定的是映射到list集合属性中pojo的类型。
    -->
    <collection property="students" javaType="ArrayList" ofType="Student">
        <result property="id" column="sid"/>
        <result property="name" column="sname"/>
        <result property="tid" column="tid"/>
    </collection>
</resultMap>

十二、动态SQL

动态SQL指的是根据不同的查询条件 , 生成不同的Sql语句.

1、if标签

可以DIY拼接实现功能,如果有满足的条件，则在sql语句后拼接上if内的内容

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

2、where标签

作用和where一样。拼接语句中的and会自动处理，第一个参数处的and删除，后面的保存

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

3、set标签

代替update语句中的set，set标签会自动处理拼接语句后面的逗号,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>

4、trim

set和choose都属于trim，trim可以自定义

choose标签，前缀覆盖符是and或or
<trim prefix="CHOOSE" prefixOverrides="AND|OR"></trim>
set标签，后缀覆盖符是,
<trim prefix="SET" suffixOverrides=","></trim>

5、choose\when\otherwise标签

结果只能进入一个标签体，相当于if、else if、else

<select id="queryBlogChoose" parameterType="map" resultType="Blog">
    select * from blog
    <where>
        <choose>
            <when test="title!=null">and title=#{title}</when>
            <otherwise>and views=0</otherwise>
        </choose>
    </where>
</select>

6、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标签！

7、foreach标签

对一个集合进行遍历，通常是在构建in语句的时候

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

十三、缓存

1、缓存：

1、什么是缓存 [ Cache ]？

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

2、为什么使用缓存？

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

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

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

2、Mybatis缓存

MyBatis包含一个非常强大的查询缓存特性，它可以非常方便地定制和配置缓存。缓存可以极大的提升查询效率。

MyBatis系统中默认定义了两级缓存：一级缓存和二级缓存
默认情况下，只有一级缓存开启。（SqlSession级别的缓存，也称为本地缓存）
二级缓存需要手动开启和配置，他是基于namespace级别的缓存。
为了提高扩展性，MyBatis定义了缓存接口Cache。我们可以通过实现Cache接口来自定义二级缓存

3、一级缓存

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

    @Test
    public  void getUserById(){
//        获取sqlSession
        SqlSession sqlSession = MybatisUtils.getSqlSession();
//        执行sql
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        User userById = mapper.getUserById(2);
        System.out.println(userById);
        User userById1 = mapper.getUserById(2);
        System.out.println(userById1);
        System.out.println(userById1==userById);
        sqlSession.close();
    }

输出为：

    ==>  Preparing: select * from user where id=?
    ==> Parameters: 2(Integer)
    <==    Columns: id, name, pwd
    <==        Row: 2, 张三, 1233
    <==      Total: 1
    User(id=2, name=张三, password=1233)
    User(id=2, name=张三, password=1233)
    true

可以看出第二次没有进数据库搜索,并且两次搜索的对象是同一个。
缓存失效的情况：

1、sqlsession不同
2、增删改操作可能会改变原来数据，所以必定刷新缓存，即使查询的数据没有改变
3、sqlsession相同，查询语句（数据）不同
4、sqlSession相同，手动清除一级缓存:session.clearCache();

4、二级缓存

二级缓存也叫全局缓存，一级缓存作用域太低了，所以诞生了二级缓存

基于namespace级别的缓存，一个名称空间，对应一个二级缓存；

工作机制：

一个会话查询一条数据，这个数据就会被放在当前会话的一级缓存中；
    如果当前会话关闭了，这个会话对应的一级缓存就没了；但是我们想要的是，会话关闭了，一级缓存中的数据被保存到二级缓存中；
    新的会话查询信息，就可以从二级缓存中获取内容；
    不同的mapper查出的数据会放在自己对应的缓存（map）中；

使用步骤：
1、开启全局缓存【mybatis-config.xml】

 <setting name="cacheEnabled" value="true"/>

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

【xxxMapper.xml】FIFO先进先出缓存，
<cache/>
<!--    开启二级缓存
eviction：缓存类型
flushInterval：间隔多少毫秒刷新缓存
size：最多可以存储结果对象或列表的多少个引用
readOnly：返回的对象是否被认为是只读的
         可读写的缓存会通过序列化返回缓存对象的拷贝，实体类序列化：public class User implements Serializable {}
-->
<cache
 eviction="FIFO"
 flushInterval="60000"
 size="512"
 readOnly="true"/>

这个更高级的配置创建了一个 FIFO 缓存，每隔 60 秒刷新，最多可以存储结果对象或列表的 512 个引用，而且返回的对象被认为是只读的，因此对它们进行修改可能会在不同线程中的调用者产生冲突。
3、测试：

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

    UserMapper mapper = sqlSession.getMapper(UserMapper.class);
    UserMapper mapper1 = sqlSession1.getMapper(UserMapper.class);

    User user= mapper.getUserById(2);
    System.out.println(user);
    sqlSession.close();

    User user1 = mapper1.getUserById(2);
    System.out.println(user1);
    System.out.println(user1==user);
    sqlSession1.close();
}

    结论：
        查出的数据都会被默认先放在一级缓存中
        只有会话提交或者关闭以后，一级缓存中的数据才会转到二级缓存中

5、缓存原理：

每个sqlsession向数据库访问，然后将数据缓存在该sqlsession下的一级缓存中
如果某个sqlsession关闭，该sqlsession中的一级缓存中的内容放在对应Mapper.xml下的二级缓存中。
一级缓存是SqlSession级别的缓存
二级缓存是Mapper.xml级别的缓存

查询顺序：先查看二级缓存，再查看一级缓存，最后查数据库

6、自定义缓存ehcache

Ehcache是一种广泛使用的java分布式缓存，用于通用缓存；
1、要在应用程序中使用Ehcache，需要引入依赖的jar包

<!-- 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中使用对应的缓存即可

  <cache type = "org.mybatis.caches.ehcache.EhcacheCache"/>

3、编写ehcache.xml文件，如果在加载时未找到/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>