标签：缓存 name public SQL Mybatis id select

1、概述

MyBatis 是一款优秀的持久层框架
MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集的过程
MyBatis 可以使用简单的 XML 或注解来配置和映射原生信息，将接口和 Java 的实体类【Plain Old Java Objects,普通的 Java对象】映射成数据库中的记录

持久层

持久化：
- 将程序数据在持久状态和瞬时状态间转换的机制
- 为什么需要持久化服务呢？那是由于内存本身的缺陷引起的
持久层：
- 完成持久化工作的代码块
- 持久化的实现过程则大多通过各种关系数据库来完成

为什么需要Mybatis

Mybatis就是帮助程序员将数据存入数据库中 , 和从数据库中取数据
传统的jdbc操作 , 有很多重复代码块 , 通过框架可以减少重复代码,提高开发效率
MyBatis 是一个半自动化的ORM框架 (Object Relationship Mapping)

优点

简单易学，灵活。
sql和代码的分离，提高了可维护性。
提供映射标签，支持对象与数据库的ORM字段关系映射。
提供对象关系映射标签，支持对象关系组建维护。
提供xml标签，支持编写动态sql。

2、第一个Mybatis程序

导入数据库

导入依赖

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

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

Mybatis工具类

public class MybatisUtils {
    private static SqlSessionFactory sqlSessionFactory;

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

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

创建实体类

public class User {

    private int id; //id
    private String name; //姓名
    private String pwd; //密码

    public User(int id, String name, String pwd) {
        this.id = id;
        this.name = name;
        this.pwd = pwd;
    }

    public User() {
    }

    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 + '\'' +
                '}';
    }
}

Mapper接口类

public interface UserMapper {
    List<User> selectUser();
}

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.mixian.dao.UserMapper">
    <select id="selectUser" resultType="com.mixian.pojo.User">
        select * from user </select>
</mapper>

测试

public class test {
    @Test
    public void selectUser() {
        SqlSession sqlSession = MybatisUtils.getSession();

        //方法一:
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        List<User> users = userMapper.selectUser();

        //方法二:
//        UserMapper mapper = session.getMapper(UserMapper.class);
//        List<User> users = mapper.selectUser();
        for (User user : users) {
            System.out.println(user);
        }
        sqlSession.close();
    }
}

问题：maven静态资源过滤问题

<build>
    <resources>
        <resource>
            <directory>src/main/java</directory>
            <includes>
                <include>**/*.properties</include>
                <include>**/*.xml</include>
            </includes>
            <filtering>false</filtering>
        </resource>
        <resource>
            <directory>src/main/resources</directory>
            <includes>
                <include>**/*.properties</include>
                <include>**/*.xml</include>
            </includes>
            <filtering>false</filtering>
        </resource>
    </resources>
</build>

3、CRUD

3.1、select

select标签是mybatis中最常用的标签之一

select语句有很多属性可以详细配置每一条SQL语句

id：命名空间中唯一的标识符

接口中的方法名与映射文件中的SQL语句ID 一一对应
parameterType：传入SQL语句的参数类型。
resultType：SQL语句返回值类型。

public interface UserMapper { 
    //根据id查询用户 
    User selectUserById(int id);
}

<select id="selectUserById" resultType="com.mixian.pojo.User">
    select * from user where id = #{id} 
</select>

@Test public void tsetSelectUserById() {
    SqlSession session = MybatisUtils.getSession(); //获取SqlSession连接 
	UserMapper mapper = session.getMapper(UserMapper.class);
	User user = mapper.selectUserById(1); 
	System.out.println(user);
    session.close(); 
}

万能的Map

User selectUserByNP2(Map<String,Object> map); 1

<select id="selectUserByNP2" parameterType="map" resultType="com.kuang.pojo.User"> 
    select * from user where name = #{username} and pwd = #{pwd} 
</select>

Map<String, Object> map = new HashMap<String, Object>(); 
map.put("username","小明");
map.put("pwd","123456"); 
User user = mapper.selectUserByNP2(map);

如果参数过多，可以考虑直接使用Map实现，如果参数比较少，直接传递参数即可

3.2、其他操作

配置和select标签差不多

所有的增删改操作都需要提交事务！
接口所有的普通参数，尽量都写上@Param参数，尤其是多个参数时，必须写上！
有时候根据业务的需求，可以考虑使用map传递参数！
为了规范操作，在SQL的配置文件中，我们尽量将Parameter参数和resultType都写上！

模糊查询

在java代码中添加sql通配符
```
String value = “%value%”;
```

在sql语句中拼接通配符，会引起SQL注入

<select id=”selectlike”> select * from foo where bar like "%"#{value}"%" </select>

4、配置解析

mybatis-confifig.xml 系统核心配置文件
MyBatis 的配置文件包含了会深深影响 MyBatis 行为的设置和属性信息。

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

4.1、environments

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

配置MyBatis的多套运行环境，将SQL映射到多个不同的数据库上，必须指定其中一个为默认运行环境（通过default指定）

子元素节点environment：

具体的一套环境，通过设置id进行区别，id保证唯一！

transactionManager - [ 事务管理器 ]

<transactionManager type="[ JDBC | MANAGED ]"/>

数据源（dataSource）
- dataSource 元素使用标准的 JDBC 数据源接口来配置 JDBC 连接对象的资源。
- 数据源是必须配置的
- 有三种内建的数据源类型：[UNPOOLED|POOLED|JNDI]

4.2、mappers

映射器 : 定义映射SQL语句文件

映射器是MyBatis中最核心的组件之一，在MyBatis 3之前，只支持xml映射器，即：所有的SQL语句都必须在xml文件中配置。而从MyBatis 3开始，还支持接口映射器，这种映射器方式允许以Java代码的方式注解定义SQL语句，非常简洁。

1、引入资源

<!-- 使用相对于类路径的资源引用 --> 
<mappers> 
    <mapper resource="org/mybatis/builder/PostMapper.xml"/> 
</mappers>

<!-- 使用完全限定资源定位符（URL） -->
<mappers>
    <mapper url="file:///var/mappers/AuthorMapper.xml"/>
</mappers>

<!-- 
使用映射器接口实现类的完全限定类名 需要配置文件名称和接口名称一致，并且位于同一目录下
 -->
<mappers>
    <mapper class="org.mybatis.builder.AuthorMapper"/> 
</mappers>

<!-- 
将包内的映射器接口实现全部注册为映射器 但是需要配置文件名称和接口名称一致，并且位于同一目录下 
-->
<mappers>
    <package name="org.mybatis.builder"/>
</mappers>

2、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"> 
<mapper namespace="com.mixian.mapper.UserMapper"> 
</mapper>

namespace和子元素的id联合保证唯一 , 区别不同的mapper

绑定DAO接口

namespace的命名必须跟某个接口同名
接口中的方法与映射文件中sql语句id应该一一对应

namespace命名规则 : 包名+类名

3、properties优化

数据库这些属性都是可外部配置且可动态替换的，既可以在典型的 Java 属性文件中配置，亦可通过properties 元素的子元素来传递

在资源目录下新建一个db.properties

driver=com.mysql.jdbc.Driver url=jdbc:mysql://localhost:3306/mybatis? useSSL=true&useUnicode=true&characterEncoding=utf8 username=root password=123456

将文件导入properties 配置文件

<configuration>
    <!--导入properties文件--> 
    <properties resource="db.properties"/> 
    <environments default="development"> 
        <environment id="development"> 
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="${driver}"/>
                <property name="url" value="${url}"/> 
                <property name="username" value="${username}"/>
                <property name="password" value="${password}"/> 
            </dataSource> 
        </environment>
    </environments>
    <mappers>
        <mapper resource="mapper/UserMapper.xml"/> 
    </mappers> 
</configuration>

4、typeAliases优化

类型别名是为 Java 类型设置一个短的名字。它只和 XML 配置有关，存在的意义仅在于用来减少类完全限定名的冗余

<!--配置别名,注意顺序--> 
<typeAliases> 
    <typeAlias type="com.kuang.pojo.User" alias="User"/> 
</typeAliases>

指定一个包名，MyBatis 会在包名下面搜索需要的 Java Bean，在没有注解的情况下，会使用 Bean 的首字母小写的非限定类名来作为它的别名

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

注解别名

@Alias("user") 
public class User {
    ...
}

4.3、其他配置

懒加载
日志实现
缓存开启关闭

1、设置

<settings> 
    <setting name="cacheEnabled" value="true"/> 
    <setting name="lazyLoadingEnabled" value="true"/> 
    <setting name="multipleResultSetsEnabled" value="true"/>
    <setting name="useColumnLabel" value="true"/> 
    <setting name="useGeneratedKeys" value="false"/> 
    <setting name="autoMappingBehavior" value="PARTIAL"/>
    <setting name="autoMappingUnknownColumnBehavior" value="WARNING"/> 
    <setting name="defaultExecutorType" value="SIMPLE"/>
    <setting name="defaultStatementTimeout" value="25"/> 
    <setting name="defaultFetchSize" value="100"/> 
    <setting name="safeRowBoundsEnabled" value="false"/>
    <setting name="mapUnderscoreToCamelCase" value="false"/> 
    <setting name="localCacheScope" value="SESSION"/> 
    <setting name="jdbcTypeForNull" value="OTHER"/> 
    <setting name="lazyLoadTriggerMethods" value="equals,clone,hashCode,toString"/>
</settings>

2、类型处理器

无论是 MyBatis 在预处理语句（PreparedStatement）中设置一个参数时，还是从结果集中取出一个值时，都会用类型处理器将获取的值以合适的方式转换成 Java 类型。

可以重写类型处理器或创建自己的类型处理器来处理不支持的或非标准的类型。

对象工厂

MyBatis 每次创建结果对象的新实例时，它都会使用一个对象工厂（ObjectFactory）实例来完成。

默认的对象工厂需要做的仅仅是实例化目标类，要么通过默认构造方法，要么在参数映射存在的时候通过有参构造方法来实例化。

如果想覆盖对象工厂的默认行为，则可以通过创建自己的对象工厂来实现。

4.4、生命周期和作用域

SqlSessionFactoryBuilder 的作用在于创建 SqlSessionFactory，创建成功后，SqlSessionFactoryBuilder 就失去了作用，所以它只能存在于创建 SqlSessionFactory 的方法中，而不要让其长期存在。因此 SqlSessionFactoryBuilder 实例的最佳作用域是方法作用域（也就是局部方法变量）。
SqlSessionFactory 可以被认为是一个数据库连接池，它的作用是创建 SqlSession 接口对象。因为MyBatis 的本质就是 Java 对数据库的操作，所以 SqlSessionFactory 的生命周期存在于整个MyBatis 的应用之中，所以一旦创建了 SqlSessionFactory，就要长期保存它，直至不再使用MyBatis 应用，所以可以认为 SqlSessionFactory 的生命周期就等同于 MyBatis 的应用周期。
由于 SqlSessionFactory 是一个对数据库的连接池，所以它占据着数据库的连接资源。如果创建多个 SqlSessionFactory，那么就存在多个数据库连接池，这样不利于对数据库资源的控制，也会导致数据库连接资源被消耗光，出现系统宕机等情况，所以尽量避免发生这样的情况。因此在一般的应用中我们往往希望 SqlSessionFactory 作为一个单例，让它在应用中被共享。所以说 SqlSessionFactory 的最佳作用域是应用作用域。
如果说 SqlSessionFactory 相当于数据库连接池，那么 SqlSession 就相当于一个数据库连接（Connection 对象），你可以在一个事务里面执行多条 SQL，然后通过它的 commit、rollback等方法，提交或者回滚事务。所以它应该存活在一个业务请求中，处理完整个请求后，应该关闭这条连接，让它归还给 SqlSessionFactory，否则数据库资源就很快被耗费精光，系统就会瘫痪，所以用 try...catch...fifinally... 语句来保证其正确关闭。所以 SqlSession 的最佳的作用域是请求或方法作用域。

5、ResultMap

解决：属性名和字段名不一致，导致查询结果为null

public class User {
    private int id; //id
    private String name; //姓名
    private String password; //密码和数据库不一样！
    //构造 //set/get //toString()
}

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

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

sql语句可看做select id,name,pwd from user where id = #{id}

mybatis会根据这些查询的列名(会将列名转化为小写,数据库不区分大小写) , 去对应的实体类中查找

相应列名的set方法设值 , 由于找不到setPwd() , 所以password返回null ; 【自动映射】

5.1、解决方式

方案一：为列名指定别名 , 别名和java实体类的属性名一致

<select id="selectUserById" resultType="User"> 
    select id , name , pwd as password from user where id = #{id}
</select>

方案二：使用结果集映射->ResultMap 【推荐】

<resultMap id="UserMap" type="User"> 
    <!-- id为主键 --> 
    <id column="id" property="id"/>
    <!-- column是数据库表的列名 , property是对应实体类的属性名 --> 
    <result column="name" property="name"/>
    <result column="pwd" property="password"/> 
</resultMap> 
<select id="selectUserById" resultMap="UserMap">
    select id , name , pwd from user where id = #{id} 
</select>

5.2、ResultMap

1、自动映射

resultMap 元素是 MyBatis 中最重要最强大的元素。它可以让你从 90% 的 JDBC ResultSets 数据提取代码中解放出来
在为一些比如连接的复杂语句编写映射代码的时候，一份 resultMap 能够代替实现同等功能的长达数千行的代码
对于简单的语句根本不需要配置显式的结果映射，而对于复杂一点的语句只需要描述它们的关系就行了

简单映射

<select id="selectUserById" resultType="map"> 
    select id , name , pwd from user where id = #{id} 
</select>

2、手动映射

<select id="selectUserById" resultMap="UserMap"> 
    select id , name , pwd from user where id = #{id}
</select>

6、日志工厂

我们在测试SQL的时候，要是能够在控制台输出 SQL 的话，是不是就能够有更快的排错效率？如果一个数据库相关的操作出现了问题，我们可以根据输出的SQL语句快速排查问题。对于以往的开发过程，我们会经常使用到debug模式来调节，跟踪我们的代码执行过程。但是现在使用Mybatis是基于接口，配置文件的源代码执行过程。因此，我们必须选择日志工具来作为我们开发，调节程序的工具。

Mybatis内置的日志工厂提供日志功能：

SLF4J
Apache Commons Logging
Log4j 2
Log4j
JDK logging

标准日志实现

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

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

7、注解开发

在真正的开发中，很多时候我们会选择面向接口编程

根本原因 : 解耦 , 可拓展 , 提高复用 , 分层开发中 , 上层不用管具体的实现 , 大家都遵守共同的标准, 使得开发变得容易 , 规范性更好

接口从更深层次的理解，应是定义（规范，约束）与实现（名实分离的原则）的分离。

接口应有两类：

第一类是对一个个体的抽象，它可对应为一个抽象体(abstract class)；
第二类是对一个个体某一方面的抽象，即形成一个抽象面（interface）；
一个体有可能有多个抽象面。抽象体与抽象面是有区别的。

三个面向的区别

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

7.1、注解

mybatis最初配置信息是基于 XML ,映射语句(SQL)也是定义在 XML 中的。而到MyBatis 3提供了新的基于注解的配置。不幸的是，Java 注解的的表达力和灵活性十分有限。最强大的 MyBatis 映射并不能用注解来构建

sql 类型主要分成 :

@select ()
@update ()
@Insert ()
@delete ()

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

添加注解

//查询全部用户
@Select("select id,name,pwd password from user") public List<User> getAllUser();

在mybatis的核心配置文件中注册

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

7.2、CRUD

MybatisUtils工具类

//获取SqlSession连接
public static SqlSession getSession(){
    return getSession(true); //事务自动提交 
}
public static SqlSession getSession(boolean flag){
    return sqlSessionFactory.openSession(flag);
}

//根据id查询用户 
@Select("select * from user where id = #{id}") 
User selectUserById(@Param("id") int id);

7.3、注意

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

在方法只接受一个参数的情况下，可以不使用@Param。
在方法接受多个参数的情况下，一定要使用@Param注解给参数命名。
如果参数是 JavaBean ，则不能使用@Param。
不使用@Param注解时，参数只能有一个，并且是Javabean。

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

${} 的作用是直接进行字符串替换（SQL注入问题）

8、多对一

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

实体类

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

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

接口

public interface StudentMapper { }

public interface TeacherMapper { }

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">
<mapper namespace="com.kuang.mapper.StudentMapper"> 
</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">
<mapper namespace="com.kuang.mapper.TeacherMapper"> 
</mapper>

8.1、查询嵌套处理

//获取所有学生及对应老师的信息 
public List<Student> getStudents();

<?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.kuang.mapper.StudentMapper"> <!-- 需求：获取所有学生及对应老师的信息 
	思路：
	1. 获取所有学生的信息
 	2. 根据获取的学生信息的老师ID->获取该老师的信息
 	3. 思考问题，这样学生的结果集中应该包含老师，该如何处理呢，数据库中我们一般 使用关联查询？ 
		1. 做一个结果集映射：StudentTeacher
 		2. StudentTeacher结果集的类型为 Student
 		3. 学生中老师的属性为teacher，对应数据库中为tid。 多个 [1,...）学生关联一个老师=> 一对一，一对多 
		4. 查看官网找到：association – 一个复杂类型的关联；使用它来处理关联查 询 
	-->
    <select id="getStudents" resultMap="StudentTeacher">
        select * from student 
        </select> 
        <resultMap id="StudentTeacher" type="Student"> 
            <!--association关联属性 property属性名 javaType属性类型 column在多的一方的表中的列名--> 
            <association property="teacher" column="tid" javaType="Teacher" select="getTeacher"/> 
        </resultMap>
        <!-- 
		这里传递过来的id，只有一个属性的时候，下面可以写任何值 association中column多参数配置：
 		column="{key=value,key=value}" 
		其实就是键值对的形式，key是传给下个sql的取值名称，value是片段一中sql查询的 字段名。
		--> 
        <select id="getTeacher" resultType="teacher">
            select * from teacher where id = #{id} 
        </select>
</mapper>

8.2、结果嵌套处理

public List<Student> getStudents2();

<!--
按查询结果嵌套处理 
思路：
	1. 直接查询出结果，进行结果集的映射 
--> 
<select id="getStudents2" resultMap="StudentTeacher2" > 
    select s.id sid, s.name sname , t.name tname from student s,teacher t where s.tid = t.id
</select>
<resultMap id="StudentTeacher2" type="Student"> <id property="id" column="sid"/>
    <result property="name" column="sname"/>
    <!--关联对象property 关联对象在Student实体类中的属性--> 
    <association property="teacher" javaType="Teacher">
        <result property="name" column="tname"/> 
    </association> 
</resultMap>

按照查询进行嵌套处理就像SQL中的子查询
按照结果进行嵌套处理就像SQL中的联表查询

9、一对多

实体类

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

9.1、查询嵌套处理

public Teacher getTeacher2(int id);

<select id="getTeacher2" resultMap="TeacherStudent2"> 
    select * from teacher where id = #{id} 
</select> 
<resultMap id="TeacherStudent2" type="Teacher">
    <!--column是一对多的外键 , 写的是一的主键的列名--> 
    <collection property="students" javaType="ArrayList" ofType="Student" column="id" select="getStudentByTeacherId"/> 
</resultMap> 
<select id="getStudentByTeacherId" resultType="Student"> 
    select * from student where tid = #{id} 
</select>

9.2、结果嵌套处理

//获取指定老师，及老师下的所有学生
public Teacher getTeacher(int id);

<mapper namespace="com.kuang.mapper.TeacherMapper">
<!--
 思路:
	1. 从学生表和老师表中查出学生id，学生姓名，老师姓名 
	2. 对查询出来的操作做结果集映射 
		1. 集合的话，使用collection！
 			JavaType和ofType都是用来指定对象类型的
 			JavaType是用来指定pojo中属性的类型 
			ofType指定的是映射到list集合属性中pojo的类型。
 --> 
    <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=#{id} 
    </select>
    <resultMap id="TeacherStudent" type="Teacher">
        <result property="name" column="tname"/> 
        <collection property="students" ofType="Student">
            <result property="id" column="sid" /> 
            <result property="name" column="sname" />
            <result property="tid" column="tid" /> 
        </collection> 
    </resultMap> 
</mapper>

9.3、小结

关联-association
集合-collection
所以association是用于一对一和多对一，而collection是用于一对多的关系
JavaType和ofType都是用来指定对象类型的
- JavaType是用来指定pojo中属性的类型
- ofType指定的是映射到list集合属性中pojo的类型。

注意说明：

保证SQL的可读性，尽量通俗易懂
根据实际要求，尽量编写性能更高的SQL语句
注意属性名和字段不一致的问题
注意一对多和多对一中：字段和属性对应的问题
通过日志来查看自己的错误

10、动态SQL

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

之前写的 SQL 语句都比较简单，如果有比较复杂的业务，我们需要写复杂的 SQL 语句，往往需要拼接，而拼接 SQL ，稍微不注意，由于引号，空格等缺失可能都会导致错误

CREATE TABLE `blog` (
    `id` varchar(50) NOT NULL COMMENT '博客id',
    `title` varchar(100) NOT NULL COMMENT '博客标题', 
    `author` varchar(30) NOT NULL COMMENT '博客作者', 
    `create_time` datetime NOT NULL COMMENT '创建时间', 
    `views` int(30) NOT NULL COMMENT '浏览量'
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

IDutil工具类

public class IDUtil {
    public static String genId(){ 
        return UUID.randomUUID().toString().replaceAll("-","");
    } 
}

实体类

@Data
public class Blog { 
    private String id;
    private String title; 
    private String author; 
    private Date createTime; 
    private int views;
}

mybatis核心配置文件，下划线驼峰自动转换

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

10.1、if

<!--需求1： 
根据作者名字和博客名字来查询博客！ 
如果作者名字为空，那么只根据博客名字查询，反之，则根据作者名来查询 
select * from blog where title = #{title} and author = #{author}
 --> 
<select id="queryBlogIf" parameterType="map" resultType="blog"> 
    select * from blog where 
    <if test="title != null">
        title = #{title} 
    </if> 
    <if test="author != null">
        and author = #{author} 
    </if> 
</select>

如果 author 等于 null，那么查询语句为 select * from user where title=#{title},但是如果title为空呢？那么查询语句为 select * from user where and author=#{author}，这是错误的SQL 语句，如何解决呢？使用where

10.2、where

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

这个“where”标签会知道如果它包含的标签中有返回值的话，它就插入一个‘where’。此外，如果标签返回的内容是以AND 或OR 开头的，则它会剔除掉

10.3、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>

10.4、choose

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

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

10.5、SQL片段

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

<sql id="if-title-author">
    <if test="title != null"> 
        title = #{title} 
    </if>
    <if test="author != null"> 
        and author = #{author} 
    </if> 
</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

10.6、foreach

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

其实动态 sql 语句的编写往往就是一个拼接的问题，为了保证拼接准确，我们最好首先要写原生的 sql 语句出来，然后在通过 mybatis 动态sql 对照着改，防止出错。

11、缓存

什么是缓存 [ Cache ]？

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

为什么使用缓存？

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

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

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

11.1、mybatis缓存

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

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

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

11.2、一级缓存

一级缓存也叫本地缓存：

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

一级缓存失效

一级缓存是SqlSession级别的缓存，是一直开启的，我们关闭不了它；

sqlSession不同
sqlSession相同，查询条件不同
sqlSession相同，两次查询之间执行了增删改操作！
sqlSession相同，手动清除一级缓存

10.3、二级缓存

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

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

工作机制

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

开启全局缓存【mybatis-confifig.xml】

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

配置二级缓存

<cache/>

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

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

11.4、缓存原理

11.5、EhCache

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

要在应用程序中使用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

在配置文件中使用对应的缓存

<mapper namespace = “org.acme.FooMapper” > 
    <cache type = “org.mybatis.caches.ehcache.EhcacheCache” /> 
</mapper>

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>

标签：缓存,name,public,SQL,Mybatis,id,select
From： https://www.cnblogs.com/cherish-0/p/16652024.html

Mybatis