标签：缓存 name log4j SQL MyBatis where id

Mybatis

官方文档：https://mybatis.org/

前言

狂神的环境

JDK 1.8
MySQL 5.7
Maven 3.6.1
IDEA

学会标准建表

注意引擎、字符集、主键非空、其他字段不为空等设置。

drop table if exists user;

create table user(
	id int(20) not null,
	name varchar(30) default null,
	pwd varchar(30) default null,
	primary key(id)
)engine=INNODB default charset=utf8;
insert into user(id,name,pwd) values(1,'luis','123'),(2,'jack','123'),(3,'mary','123')

学会使用父子工程，解决依赖频繁导入

项目测试所需基本依赖：

MySQL
Mybatis
Junit

关于数据库连接时多几个参数

使用 IDEA 连接数据库

学会使用 SQLyog

注意创建数据库选用指定排序规则：避免中文乱码

面试高频

mysql 引擎
InnoDB 底层原理
索引
索引优化

Mybatis 实现 CRUD

实现简单 CRUD 只需要在搭建基本框架后，继续完善 mapper 接口和 mapper.xml，

然后测试运行即可。

基本搭建步骤

创建项目

配置 pom 文件，加依赖和资源插件，完善项目结构

<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.9</version>
</dependency>

<build>
    <resources>
        <!-- 指定src/main/java目录下的.properties,.xml 文件资源位置，让其编译时能被拷贝 -->
        <resource>
            <directory>src/main/java</directory><!--所在的目录-->
            <includes><!--包括目录下的.properties,.xml 文件都会扫描到-->
                <include>**/*.properties</include>
                <include>**/*.xml</include>
            </includes>
            <filtering>false</filtering>
        </resource>
        <!-- 指定src/main/resources资源位置，让其编译时能被拷贝（此法非老师教） -->
        <resource>
            <directory>src/main/resources</directory><!--所在的目录-->
            <includes><!--包括目录下的.properties,.xml 文件都会扫描到-->
                <include>**/*.properties</include>
                <include>**/*.xml</include>
            </includes>
            <filtering>false</filtering>
        </resource>
    </resources>
</build>

写 util 获取 Sqlsession

public class MybatisUtils {

    private MybatisUtils() {
    }

    private static SqlSessionFactory sqlSessionFactory;

    static {
        String resource = "mybatis-config.xml";
        InputStream in = null;
        try {
            in = Resources.getResourceAsStream(resource);
            sqlSessionFactory = new SqlSessionFactoryBuilder().build(in);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

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

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

    <!--指定properties文件的位置，从类路径根开始找文件-->
    <properties resource="jdbc.properties" />

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

    <typeAliases>
        <package name="com.luis.domain"/>
    </typeAliases>

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

    <!-- sql mapper(sql映射文件)的位置-->
    <mappers>
        <package name="com.luis.dao"/>
    </mappers>
</configuration>

写 pojo、mapper 、xml

<?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="com.luis.dao.UserDao">

</mapper>

测试
完善，完成CRUD

可设置自动提交事务

了解即可，不要设置自动提交，万一有问题也会提交。

// 不传值，需要手动提交事务
// 传 true，设置自动提交事务
sqlSessionFactory.openSession(true);

Mybatis 中注意事项

记得配置 pom.xml 中资源插件
记得在 mybatis-config.xml 中配置 mapper 映射文件路径
获取 SqlSession 对象后使用 getMapper() 方式进行数据库操作
记得关闭 sqlSession
增删改操作需要提交事务
写 SQL 时，resultType 建议写全限定类名，不要用别名！
mapper/dao 包下 mapper/dao 接口名和 xml 配置文件名务必要同名！以便底层可用动态代理！

排错技巧

从下往上找，找第一个 Cause by: xxx，然后按顺序找自己的代码

万能 Map

如果开发中，实体类属性过多或数据库表字段过多，但是我们只需要使用其中的几个，就可以考虑使用 Map 实现可定制化。

现在没写项目可能体会不到，在后面狂神讲微服务项目时，注意多理解这个技巧。

写 SQL 时，关于参数传递：

Map 传递参数，直接在 SQL 中取 key
对象传递参数，直接在 SQL 中取对象属性
只有一个基本类型或 String 的参数情况下，直接在 SQL 中取该参数即可

关于模糊查询

SQL 中怎么避免 SQL 注入是重点。

还有哪些情况会出现 SQL 注入，自己多查询资料，找到解决办法！

避免 SQL 注入的两种写法：

改 SQL，拼接

<select id="getUserList" resultMap="userMap">
    select id,name,pwd from user where name like "%"#{name}"%"
</select>

在字符串中拼接

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

避免 SQL 注入的其他写法：（掌握）

select * from news where tile like concat(‘%’,#{title}, ‘%’)

XML 配置解析

学习部分即可，其他未提及的不用学！

MyBatis 的核心配置文件包含了会深深影响 MyBatis 行为的设置和属性信息。

// 以下是全部的，不需要全部掌握！
properties（属性）
settings（设置）
typeAliases（类型别名）
typeHandlers（类型处理器）
objectFactory（对象工厂）
plugins（插件）
environments（环境配置）
environment（环境变量）
transactionManager（事务管理器）
dataSource（数据源）
databaseIdProvider（数据库厂商标识）
mappers（映射器）

掌握下面列出的部分配置使用即可

环境配置（environments）

MyBatis 可配置成适应多种环境，但是每个 SqlSessionFactory 实例只能选择一种环境。
MyBatis 默认的事务管理器是 JDBC，连接池是 POOLED

属性（properties）

作用：可通过配置 properties 属性，实现在 xml 配置文件中使用通配符动态配置属性值。

可从外部引入属性配置文件或自定义配置自己的通用属性。

注意：

当引入的配置文件中 key 和自定义的 key 相同时，会优先使用引用的配置文件中 key。
配置 properties 的位置应当按照在主配置中的指定顺序，因为是按照从上到下读取，先配置或自定义上，才可使用！

类型别名（typeAliases）

Spring 之后不用。

作用：为 Java 类型自定义一个短的名字，减少书写全限定类名的冗余。

配置文件中的两种用法：
1. 直接给每一个类自定义别名
2. 直接指定一个包名，包中的每一个类的别名默认就是其类名（不区分大小写）
实体类中使用注解的用法：在类上使用 @Alias("别名") 注解

注意：

mapper 文件中 resultType 非常不建议使用别名！！！建议使用全限定类名！

原因：同时指定多个包时，不同包下名字相同的类的别名会一样，容易出问题！
配置文件中配置别名时的位置需要按照指定上下顺序，不能配置到太底部。

了解常见的 Java 类型内建的类型别名。

设置（settings）

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

了解，需要用到时会查资料设置即可。

// 自己了解以下几个先
cacheEnabled // 缓存配置
lazyLoadingEnabled // 懒加载
logImpl // MyBatis 日志设定    
mapUnderscoreToCamelCase // 驼峰命令自动映射

映射器（mappers）

**作用：告诉 MyBatis 到哪里去找映射文件 **

注意：其实有四种方式实现，但是只介绍使用以下几种方式！

方式一：直接指定一个或多个 mapper 文件【推荐使用】

<!-- 使用相对于类路径的资源引用 -->
<mappers>
    <mapper resource="com/luis/mapper/UserMapper.xml"/>
</mappers>

方式二：指定包名

这个包中所有 xml 文件一次都能加载给 mybatis

使用要求：

mapper 文件名称需要和接口名称一样，区分大小写的一样

mapper 文件和 dao 接口需要在同一目录

<!-- 将包内的映射器接口实现全部注册为映射器 -->
<mappers>
  <package name="com.luis.dao"/>
</mappers>

方式三：使用类名

此方式可使注解和 mapper.xml 同时生效。

使用要求：

mapper 文件名称需要和接口名称一样，区分大小写的一样

mapper 文件和 dao 接口需要在同一目录

<!-- 使用映射器接口实现类的完全限定类名 -->
<mappers>
  <mapper class="org.mybatis.builder.AuthorMapper"/>
  <mapper class="org.mybatis.builder.BlogMapper"/>
  <mapper class="org.mybatis.builder.PostMapper"/>
</mappers>

作用域和生命周期

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

SqlSessionFactoryBuilder

这个类可以被实例化、使用和丢弃，一旦创建了 SqlSessionFactory，就不再需要它了。
局部变量

SqlSessionFactory

依赖它来获取/创建 SqlSession，全局应该只有一个实例
一旦被创建就应该在应用的运行期间一直存在，没有任何理由丢弃它或重新创建另一个实例。
说白了可以想象为：一个数据库连接池
最佳作用域是应用作用域
使用单例模式或者静态单例模式

SqlSession

连接到连接池的一个请求
每个线程都应该有它自己的 SqlSession 实例
SqlSession 的实例不是线程安全的，因此是不能被共享的，所以它的最佳的作用域是请求或方法作用域
如果你现在正在使用一种 Web 框架，考虑将 SqlSession 放在一个和 HTTP 请求相似的作用域中。换句话说，每次收到 HTTP 请求，就可以打开一个 SqlSession，返回一个响应后，就关闭它。 这个关闭操作很重要！

怎么解决属性名和字段名不一致

resultMap 是一个重点

// 数据库字段：id name pwd
// 实体类属性
private int id;
private String name;
private String password;

方式一：起别名

使用 as 关键字，为列字段起别名

<select id="getUserById" resultType="com.luis.pojo.User">
    select id,name,pwd as password from user where id = #{id}
</select>

方式二：使用结果集映射 resultMap（掌握）

配置字段和属性之间的映射关系。

推荐使用 resultMap 解决属性名和字段不一致的问题

<mapper namespace="com.luis.mapper.UserMapper">
    
    <resultMap id="userMap" type="com.luis.pojo.User">
        <result column="pwd" property="password"/>
    </resultMap>
    
    <select id="getUserList" resultMap="userMap">
        select id,name,pwd from user
    </select>
</mapper>

resultMap 元素是 MyBatis 中最重要最强大的元素
ResultMap 的设计思想是，对简单的语句做到零配置，对于复杂一点的语句，只需要描述语句之间的关系就行了。
MyBatis 创建时的一个思想是：数据库不可能永远是你所想或所需的那个样子。我们希望每个数据库都具备良好的第三范式或 BCNF 范式，可惜它们并不都是那样。如果能有一种数据库映射模式，完美适配所有的应用程序，那就太好了，但可惜也没有。而 ResultMap 就是 MyBatis 对这个问题的答案。

日志

在 Mybatis 中封住了底层连接数据库等一系列操作，如果需要查看必要的数据交互信息如 SQL 语句，需要使用日志工具！

Mybatis 通过使用内置的日志工厂提供日志功能，通过配置，内置日志工厂将会把日志工作委托给不同的实现。

用法：在设置（settings）中配置 logImpl 的具体实现

掌握常用的两个：LOG4J 和日志工厂 STDOUT_LOGGING

常用的有两个：

STDOUT_LOGGING（日志工厂）
LOG4J

注意：

字符串配置一定要复制，不要手写，不要有空格！！！
settings 标签配置位置需要按照指定要求，不可随意。（配错位置会有提示）

日志工厂 STDOUT_LOGGING

格式：

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

LOG4J

Log4j是Apache的一个开源项目
使用Log4j，可控制日志信息输送的目的地是控制台、文件、GUI组件，甚至是套接口服务器、NT的事件记录器、UNIX Syslog 守护进程等
可控制每一条日志的输出格式
可定义每一条日志信息的级别，更加细致地控制日志的生成过程
可以通过一个配置文件来灵活地进行配置，而不需要修改应用的代码

使用：

添加 pom 依赖

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

添加 log4j.properties 配置文件（配置日志输出格式）

以下为 log4j 干净配置，可自己改输出的日志文件名

#将等级为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 HH:mm:ss}][%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

在 mybatis 主配置文件的 settings 中，将 log4j 配置为日志的实现

注意复制，不要手写，不要有空格！

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

测试

log4j 在类中的简单使用

使用的前提：进行了 log4j 基本的使用配置

在需要使用 log4j 的 xxx 类中定义静态变量

static Logger logger = Logger.getLogger(xxx.class); // xxx 为相关的类

在类中即可使用日志方法进行日志打印/记录

以下是三种最常用的日志级别

可以先判断运行状态再决定使用哪种打印级别进行日志记录

logger.info("info:xxxxxxxxxxxxxx");
logger.debug("debug:-------------");
logger.error("error:=================");

分页

分页有多种方法可实现，可通过 java 代码、SQL、插件等

目前主要掌握 Limit 分页方式！

注意：传参可使用万能 Map 这种数据结构

作用：减少数据处理量

列举几种分页实现方法：

使用 Limit 分页（重点掌握）
RowBounds 分页（了解）
分页插件 PageHelper（了解）

使用 Limit 分页

掌握！

分页 SQL 语法：

select * from user limit startIndex,pageSize

startIndex：起始下标

pageSize：每页显示数据的条数

示例代码：

select * from user limit 0,3
# 等同于：
select * from user limit 3 # 默认从第一条开始显示

使用 RowBounds 分页

旧的实现方案，了解即可，具体使用查资料

使用分页插件 PageHelper

插件方式实现分页，需要知道，使用可参考有道云笔记或查资料！

使用注解开发

此方式只适用于一些简单的 SQL，对于需要在 mapper 中配置参数的情况下，此注解开发方式就不实用了！

而且此方式需要设置自动提交事务，每次数据操作都会自动提交，有隐患。

本质：反射机制实现

底层：动态代理

此注解开发只适用于一些简单 SQL 的情况！

步骤：

创建工具类的时候设置自动提交事务（有隐患）

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

在接口上使用 @Select 注解开发

在主配置文件中使用 class 方式映射接口

<mappers>
    <mapper class="com.luis.mapper.UserMapper"/>
</mappers>

@Param 注解

使用情景：

在 mapper 文件中写 SQL 时，如果前面方法中传来的参数是基本类型或 String 类型，

就必须使用方法上我们使用 @Param() 中自定义的参数，即 #{自定义参数}。

简单类型：基本类型和 String 类型

基本类型的参数或者 String 类型的参数，需要加上
引用类型不需要加
只有一个简单类型的话，可以省略，但建议加上！
我们在 SQL 中引用的就是我们这里的 @Param() 中设定的属性名

定义参数使用：@Param 注解

使用位置：方法中，形参定义前使用

一个简单类型参数

在方法参数中自定义参数：

List<User> getUserListById(@Param("myId") int id);

在 mapper 文件中写 SQL 使用自定义的参数：

<select id="getUserListById" resultType="com.luis.pojo.User">
	select id,name,pwd from user where id = #{myId}
</select>

多个简单类型参数

在方法参数中自定义参数：

List<User> getUserListByIdAndName(@Param("myId") int id, 
                                  @param("myName") String name);

在 mapper 文件中写 SQL 使用自定义的参数：

<select id="getUserListByIdAndName" resultType="com.luis.pojo.User">
	select id,name,pwd from user where id = #{myId} and name = #{myName}
</select>

复杂查询之多对一处理

环境：

学生和老师，多个学生关联一个老师
对于学生这边而言，关联——多个学生关联一个老师【多对一】
对于老师而言，集合——一个老师，有很多学生【一对多】

要求：查出所有学生信息，包含学生关联的老师名

数据库表字段：

teacher 表：
id name
student 表：
id name tid
PS：学生的 tid 对应老师的 id

实体类：

注意：学生实体类存的不是 tid，是 Teacher 对象

// Student
private int id;
private String name;
private Teacher teacher;

// Teacher
private int id;
private String name;

查询方法：

List<Student> selectStudent();

按照查询嵌套处理（不建议）

<!--
	思路：子查询
	1.先查出所有学生信息
	2.根据查出的学生信息中的 tid，查询老师信息
-->

<resultMap id="studentMap" type="com.luis.pojo.Student">
    <result property="id" column="id"/>
    <result property="name" column="name"/>
    <!-- 处理对象属性专用：association -->
	<!-- 指定属性类型：javaType -->
    <association property="teacher" column="tid" javaType="com.luis.pojo.Teacher" select="selectTeacher"/>
</resultMap>

<select id="selectStudent" resultMap="studentMap">
    select * from student
</select>

<select id="selectTeacher" resultType="com.luis.pojo.Teacher">
    select * from teacher where id = #{tid}
</select>

查询结果：

Student{id=1, name='zs', teacher=Teacher{id=1, name='luis'}}
Student{id=2, name='ls', teacher=Teacher{id=1, name='luis'}}
Student{id=3, name='ww', teacher=Teacher{id=1, name='luis'}}

按照结果嵌套处理（建议）

<!--
	思路：联表查询
-->

<resultMap id="stuMap" type="com.luis.pojo.Student">
    <result property="id" column="sid"/>
    <result property="name" column="sname"/>
    <!-- 处理对象属性用：association -->
    <!-- 指定属性类型：javaType -->
    <association property="teacher" javaType="com.luis.pojo.Teacher">
    	<result property="name" column="tname"/>
    </association>
</resultMap>

<select id="selectStudent" resultMap="stuMap">
    select s.id sid,s.name sname,t.name tname
    from student s
    join teacher t
    on s.tid = t.id
</select>

查询结果：

Student{id=1, name='zs', teacher=Teacher{id=0, name='luis'}}
Student{id=2, name='ls', teacher=Teacher{id=0, name='luis'}}
Student{id=3, name='ww', teacher=Teacher{id=0, name='luis'}}

复杂查询之一对多处理

环境：

学生和老师，一个老师下有多个学生
对于学生这边而言，关联——多个学生关联一个老师【多对一】
对于老师而言，集合——一个老师，有很多学生【一对多】

要求：查出指定老师下的所有学生以及老师信息

数据库表字段：（和上面多对一使用的表相同）

teacher 表：
id name
student 表：
id name tid
PS：学生的 tid 对应老师的 id

实体类：

注意：

学生实体类存的是 tid

老师实体类存的有学生集合

// Student
private int id;
private String name;
private int tid;

// Teacher
private int id;
private String name;
private List<Student> students;

查询方法：

Teacher selectTeacher(@Param("tid") int tid);

按照结果嵌套处理（建议）

<resultMap id="teacherMap" type="com.luis.pojo.Teacher">
    <result property="id" column="tid"/>
    <result property="name" column="tname"/>
    <!-- 处理集合属性专用：collection -->
    <!-- 集合中泛型信息用 ofType 获取 -->
    <collection property="students" ofType="com.luis.pojo.Student">
        <result property="id" column="sid"/>
        <result property="name" column="sname"/>
        <result property="tid" column="tid"/>
    </collection>
</resultMap>

<select id="selectTeacher" resultMap="teacherMap">
    select s.id sid,s.name sname,t.name tname,t.id tid
    from student s
    join teacher t
    on s.tid = t.id and t.id = #{tid}
</select>

查询结果：

Teacher{id=1, name='luis', students=[Student{id=1, name='zs', tid=1}, 
                                     Student{id=2, name='ls', tid=1}, 
                                     Student{id=3, name='ww', tid=1}]}

按照查询嵌套处理（不建议）

<select id="selectTeacher" resultMap="teacherMap">
    select * from teacher where id = #{tid}
</select>

<resultMap id="teacherMap" type="com.luis.pojo.Teacher">
    <collection property="students" column="id" javaType="ArrayList" ofType="com.luis.pojo.Student" select="selectStudentsByTid"/>
</resultMap>

<select id="selectStudentsByTid" resultType="com.luis.pojo.Student">
    select * from student where tid = #{id}
</select>

查询结果：

Teacher{id=0, name='luis', students=[Student{id=1, name='zs', tid=1}, 
                                     Student{id=2, name='ls', tid=1}, 
                                     Student{id=3, name='ww', tid=1}]}

复杂查询小结

多写，慢慢掌握其中原理和用法，选择适合自己的处理方法

推荐使用结果嵌套处理方式！

关联 - association【多对一】
集合 - collection【一对多】
JavaType 和 ofType
- javaType：指定实体类中属性的类型
- ofType：指定映射到 List 或集合中的实体类型，以及泛型中的约束类型

注意：

注意 SQL 的可读性，保证通俗易懂
注意一对多和多对一中，属性名和字段的对应问题
如果问题不要排错，可以使用日志，建议使用 Log4j

动态 SQL

概念：

动态 SQL 就是指根据不同的条件生成不同的 SQL 语句
本质还是 SQL 语句，只是我们可以在 SQL 层面，去执行一个逻辑代码
在拼接 SQL 语句，我们只要保证 SQL 的正确性，按照 SQL 的格式，去排列组合即可

使用建议：

先写出完整 SQL，测试通过后，再对应的去修改成为我们的动态 SQL，实现通用。

总览：

if
choose (when, otherwise)
trim (where, set)
foreach

if where set 比较常用

知识点总结：

使用 UUID 生成随机串代替主键 id ，不要自增
settings 中配置 mapUnderscoreToCamelCase 为 true 开启驼峰命名自动映射可解决数据库字段下划线，实体类属性驼峰命名兼容问题
主配置文件中 mapper 文件映射可使用包机制
使用 Map 类型作为参数可灵活控制 SQL 语句的执行情况（是否有参，参数个数不同，可控制不同 SQL 执行）
熟悉 Log4j 日志配置和使用
保证 dao 包下，每一个 dao 接口名和对应的 mapper 文件名相同，且都在同一个 dao 包下

初始环境搭建测试

构建项目，加依赖，完善目录结构
写主配置文件和数据库配置文件

<properties resource="db.properties" />
<mappers>
    <!--        <mapper resource="com/luis/mapper/UserMapper.xml"/>-->
    <!--        <mapper class="com.luis.mapper.UserMapper"/>-->
    <package name="com.luis.dao"/>
</mappers>

建表

DROP TABLE IF EXISTS blog;

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 '创建时间',
	vi`blog`ews INT(30) NOT NULL COMMENT '浏览量'
)ENGINE=INNODB DEFAULT CHARSET=utf8;

写实体类

private String id;
private String title;
private String author;
private Date createTime;
private int views;

写生成 id 工具类和获取 SqlSession 对象的工具类

UUID.randomUUID().toString().replaceAll("-", "");

settings 中开启驼峰命名自动映射并配置日志实现

<settings>
    <setting name="logImpl" value="STDOUT_LOGGING"/>
    <setting name="mapUnderscoreToCamelCase" value="true"/>
</settings>

编写 dao 接口和 mapper 映射文件

List<Blog> selectBlogsByIf(Map map);

<select id="selectBlogsByIf" resultType="com.luis.bean.Blog">
    select * from blog where 1=1
    <if test="title != null">
        and title = #{title}
    </if>
    <if test="author != null">
        and author = #{author}
    </if>
</select>

添加数据，查询数据

SqlSession sqlSession = MybatisUtils.getSqlSession();

BlogDao mapper = sqlSession.getMapper(BlogDao.class);

Map map = new HashMap();
// map.put("title", "java");
map.put("author", "luis");
List<Blog> blogs = mapper.selectBlogsByIf(map);
for (Blog blog : blogs) {
    System.out.println("=============> " + blog);
}

sqlSession.close();

测试

where

where 元素使用在其他子元素外面，用来控制语句的正常执行。

where 元素只会在子元素返回任何内容的情况下才插入 “WHERE” 子句。而且，若子句的开头为 “AND” 或 “OR”，where 元素也会将它们去除。

if

每多一个 if 满足条件，就多一个查询条件

<select id="selectBlogsByIf" resultType="com.luis.bean.Blog">
    select * from blog
    <where>
        <if test="title != null">
            and title = #{title}
        </if>
        <if test="author != null">
            and author = #{author}
        </if>
    </where>
</select>

choose（when、otherwise）

choose 中必定只会有一个条件通过，类似 Java 中的 switch 语句。

<select id="selectBlogsByIf" resultType="com.luis.bean.Blog">
    select * from blog
    <where>
        <choose>
            <when test="title != null">
                title = #{title}
            </when>
            <when test="author != null">
                and author = #{author}
            </when>
            <otherwise>
                views = #{views}
            </otherwise>
        </choose>
    </where>
</select>

trim（where、set）

where

介绍：

where 元素使用在其他子元素外面，用来控制语句的正常执行。

where 元素只会在子元素返回任何内容的情况下才插入 “WHERE” 子句。而且，若子句的开头为 “AND” 或 “OR”，where 元素也会将它们去除。

简单记忆：

返回任何子元素，则会插入 where；不返回，则不插入；

若子句开头为 “AND” 或 “OR”，where 元素会将它们去除

set

set 元素会动态地在行首插入 SET 关键字，并会删掉额外的逗号（这些逗号是在使用条件语句给列赋值时引入的）。

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

trim

通过自定义 trim 元素可实现开发者自己期望的效果！

如：通过自定义 trim 元素可定制出和 where 元素，set 元素等相同的功能

用法示例一：自定义 trim 元素来定制和 where 元素相同的功能

prefixOverrides 属性会忽略通过管道符分隔的文本序列（注意此例中的空格是必要的）。

下述例子会移除所有 prefixOverrides 属性中指定的内容，并且插入 prefix 属性中指定的内容。

<trim prefix="WHERE" prefixOverrides="AND |OR ">
  ...
</trim>

用法示例二：自定义 trim 元素来定制和 set 元素相同的功能

注意，我们覆盖了后缀值设置，并且自定义了前缀值。

下面例子中，set 元素会动态地在行首插入 SET 关键字，并会删掉额外的逗号（这些逗号是在使用条件语句给列赋值时引入的）。

<trim prefix="SET" suffixOverrides=",">
  ...
</trim>

SQL 代码片段

可复用 SQL 语句，表名，字段等。

需要先定义，然后在需要用到的地方进行引用。

示例一：整段 SQL 复用

<!-- 定义sql代码片段 -->
<sql id="selectByIdSql">
    select id,name,email,age from student where id=#{id}
</sql>

<select id="selectStudentById" resultType="com.linwei.domain.Student">
  <!--引用自定义的 SQL 片段-->
  <include refid="selectByIdSql" />
</select>

示例二：部分 SQL 复用

<!-- 定义sql代码片段 -->
<sql id="selectAllSql">
    select id,name,email,age from student
</sql>

<select id="test1" resultType="com.linwei.domain.Student">
    <include refid="selectAllSql"/> where name=#{myName} or age=#{myAge}
</select>

注意事项：

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

forench

作用：循环 java 中的数组，list集合的。主要用在 sql 的 in 语句中。

collection：表示接口中的方法参数的类型，如果是数组使用 array , 如果是 list 集合使用 list

item：自定义的，表示数组或集合成员的变量

open：循环开始时的字符

close：循环结束时的字符

separator：集合成员之间的分隔符

示例一：

<select id="selectPostIn" resultType="domain.blog.Post">
    SELECT *
    FROM POST P
    <where>
        <foreach item="item" index="index" collection="list"
                 open="ID in (" separator="," close=")" nullable="true">
            #{item}
        </foreach>
    </where>
</select>

示例二：

<!-- select * from student where id in(1001,1002,1003) -->
<!-- foreach使用方式一，集合中是一个简单基本类型 -->
<select id="selectForeachOne" resultType="com.linwei.domain.Student">
    select * from student where id in
    <foreach collection="list" item="myid" open="(" close=")" separator=",">
      #{myid}
    </foreach>
</select>

示例三：

<!-- foreach使用方式二，集合中是一个对象，List<Student> -->
<select id="selectForeachTwo" resultType="com.linwei.domain.Student">
    select * from student where id in
    <foreach collection="list" item="stu" open="(" close=")" separator=",">
        #{stu.id}
    </foreach>
</select>

缓存（了解）

简介

什么是缓存？
- 存在内存中的临时数据。
- 将用户经常查询的数据放到缓存（内存）中，用户去查询数据就不用从磁盘上（关系型数据库数据文件）查询，直接从缓存中查询，从而提高查询效率，解决了高并发系统的性能问题。
为什么使用缓存？
- 减少和数据库的交互次数，减少系统开销，提高系统效率。
什么样的数据能使用缓存？
- 经常查询并且不经常改变的数据。

注意：缓存机制是为经常查询且不经常改变的数据而存在！为了提高查询效率！

Mybatis 缓存

MyBatis 内置了一个强大的事务性查询缓存机制，它可以非常方便地配置和定制。
默认情况下，只启用了本地的会话缓存，它仅仅对一个会话中的数据进行缓存。要启用全局的二级缓存需要手动配置。

一级缓存

一级缓存也叫本地缓存：SqlSession
- 与数据库同一次会话期间查询到的数据会放在本地缓存中
- 以后如果需要获取相同的数据，直接从缓存中拿，没必要再去查询数据库
缓存失效的情况：
1. 查询不同的数据
2. 增删改操作，可能会改变原来的数据，所以必定会刷新缓存
3. 查询不同的 Mapper.xml
4. 手动清理缓存

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

二级缓存

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

二级缓存开启步骤：

开启二级缓存/全局缓存（在两个地方都要设置开启）
1. 在主配置文件的 settings 中显示的开启全局缓存/二级缓存
cacheEnabled：全局性地开启或关闭所有映射器配置文件中已配置的任何缓存。
```

<setting name="cacheEnabled" value="true"/>
```
1. 在要使用二级缓存/全局缓存的 Mapper 中添加开启缓存的指定标签
该标签中可自定义参数
```

<cache/>
```
注意：涉及缓存的实体类都需要进行序列化！否则会报错！

小结：

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

缓存原理

数据获取流程：
1. 先看二级缓存/全局缓存中有没有，有则直接获取
2. 再看一级缓存中有没有，有则直接获取
3. 如果二级缓存和一级缓存中都没有，则从数据库中获取
数据库获取数据流程图：

自定义缓存 - ehcache

https://www.bilibili.com/video/BV1NE411Q7Nx?p=30&spm_id_from=pageDriver

以上是举例，了解如何自定义缓存即可，后面会使用 Redis 数据库来做缓存。

标签：缓存,name,log4j,SQL,MyBatis,where,id
From： https://www.cnblogs.com/luisblog/p/16849539.html

MyBatis

Mybatis

前言

狂神的环境

学会标准建表

学会使用父子工程，解决依赖频繁导入

关于数据库连接时多几个参数

使用 IDEA 连接数据库

学会使用 SQLyog

面试高频

Mybatis 实现 CRUD

基本搭建步骤

可设置自动提交事务

Mybatis 中注意事项

排错技巧

万能 Map

关于模糊查询

XML 配置解析

环境配置（environments）

属性（properties）

类型别名（typeAliases）

设置（settings）

映射器（mappers）

作用域和生命周期

SqlSessionFactoryBuilder

SqlSessionFactory

SqlSession

怎么解决属性名和字段名不一致

方式一：起别名

方式二：使用结果集映射 resultMap（掌握）

日志

日志工厂 STDOUT_LOGGING

LOG4J

log4j 在类中的简单使用

分页

使用 Limit 分页

使用 RowBounds 分页

使用分页插件 PageHelper

使用注解开发

@Param 注解

一个简单类型参数

多个简单类型参数

复杂查询之多对一处理

按照查询嵌套处理（不建议）

按照结果嵌套处理（建议）

复杂查询之一对多处理

按照结果嵌套处理（建议）

按照查询嵌套处理（不建议）

复杂查询小结

动态 SQL

初始环境搭建测试

where

if

choose（when、otherwise）

trim（where、set）

where

set

trim

SQL 代码片段

forench

缓存（了解）

简介

Mybatis 缓存

一级缓存

二级缓存

缓存原理

自定义缓存 - ehcache

相关文章

赞助商

阅读排行