笔记主要来源
https://gitee.com/lagouedu/Basic-document/blob/master/document/MyBatis.md

l 经典三层

web表现层（视图+controller）、service层、dao层

分层的好处

代码清晰、解耦、便于维护，出现问题容易定位

分层开发下的常见框架

dao层：hibernate、mybatis

service层：spring框架（对象容器）

web表现层：springmvc框架

[了解]原生JDBC操作数据库分析

package com.mybatis.dao;

import com.mybatis.pojo.User;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.List;

public class UserDaoImpl implements UserDao {

   private String driver = "com.mysql.jdbc.Driver";
   private String url = "jdbc:mysql://localhost:3306/mybatis?characterEncoding=utf-8";
   private String username = "root";
   private String password = "root";


   public List<User> queryUserList() throws Exception {
      List<User> userList = new ArrayList<User>();

      Class.forName(driver);
      /**
       * 问题一：频繁获取/释放数据库连接，影响数据库和应用性能
       * 解决：数据库连接池技术，C3P0,DRUID（阿里巴巴荣誉出品，号称前无古人后无来者世界最强没有之一）
       */
      Connection connection = DriverManager.getConnection(url, username, password);
      /**
       * 问题二：sql语句硬编码，后期难以维护
       * 解决：若sql语句和java代码分离，比如sql写在配置文件中。Mybatis就是这么干的
       */
      String sql = "select * from user";
      /**
       * 问题三：sql语句where条件和占位符一一对应，后期难以维护
       */
      // String sql1 = "select * from user where username=? and id=?";
      PreparedStatement preparedStatement = connection.prepareStatement(sql);
      // preparedStatement.setInt(1,2);
      ResultSet resultSet = preparedStatement.executeQuery();
      User user = null;
      /**
       * 问题四：结果集解析麻烦，查询列硬编码
       * 期望：如果单条记录直接返回实体对象，如果多条记录返回实体的集合
       */
      while(resultSet.next()) {
         user = new User();
         user.setId(resultSet.getInt("id"));
         user.setUsername(resultSet.getString("username"));
         user.setSex(resultSet.getString("sex"));
         user.setBirthday(resultSet.getDate("birthday"));
         user.setAddress(resultSet.getString("address"));

         userList.add(user);
      }
      resultSet.close();
      preparedStatement.close();
      connection.close();
      return userList;
   }
}

Mybatis框架是一个半自动的ORM持久层框架，也可以在Java中实现类似 insert(User)的操作最终操作数据库，但是需要我们自己写Sql语句。Mybatis是目前比较流行的Dao层框架。

自定义Mybatis框架小结

l 框架的开发使用流程

编写源代码—>打jar包—>框架使用者引入jar包—>按照框架的规范进行XML配置—>Java程序中调用框架API实现功能

l 引入框架坐标即可，它所依赖的dom4j和jaxen都不需要我们引入，这是Maven的依赖传递

l 框架是基础知识的整合（本课程中的jdbc、dom4j、xpath、反射、数据库元数据等）

l 框架往往都会用到设计模式（本课程扩展了工厂设计模式和构建者设计模式）

l 框架展示了代码的拆分思想，各司其职，便于维护

[掌握]Mybatis框架快速入门

l Mybatis入门程序

<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
</dependency>

<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>3.4.5</version>
</dependency>

<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.46</version>
</dependency>

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

n pojo类User.java

package com.mybatis.pojo;

import java.util.Date;

public class User {

    private Integer id;
    private String username;
    private String sex;
    private Date birthday;
    private String address;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public Date getBirthday() {
        return birthday;
    }

    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", sex='" + sex + '\'' +
                ", birthday=" + birthday +
                ", address='" + address + '\'' +
                '}';
    }
}

n SqlMapConfig.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
      PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
      "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
<environments default="development">
<environment id="development">
<transactionManager type="JDBC" />
<dataSource type="POOLED">
<property name="driver" value="com.mysql.jdbc.Driver" />
<property name="url" value="jdbc:mysql://127.0.0.1:3306/mybatis?characterEncoding=utf8" />
<property name="username" value="root" />
<property name="password" value="root" />
</dataSource>
</environment>
</environments>

<mappers>
<mapper resource="UserMapper.xml"></mapper>
</mappers>
</configuration>    

n UserMapper.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="test">
<select id="queryUserList" resultType="com.mybatis.pojo.User">
      select * from user
</select>
</mapper>

n 测试程序

@Test
public void testMybatis() throws IOException {
      InputStream inputStream = Resources.getResourceAsStream("SqlMapConfig.xml");
      SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
      SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(inputStream);
      SqlSession sqlSession = sqlSessionFactory.openSession();
      List<User> list = sqlSession.selectList("test.queryUserList");
      if(list != null && list.size() > 0) {
      for (int i = 0; i < list.size(); i++) {
      User user =  list.get(i);
      System.out.println(user);
      }
      }
      sqlSession.close();
      }

[理解]关于三个对象

l SqlSessionFactoryBuilder： 创建工厂，生命周期短暂即可，类似于一个工具类

l SqlSessionFactory： 应该只有一个工厂对象即可。

l SqlSession： 和数据库通信的会话对象，底层对应connection连接。例如：假如多个线程公用一个sqlsession对象（connection），线程A操作了数据库尚未提交事务，线程B操作了数据库把这个connecttion的事务给提交了，会造成数据安全问题。所以一个线程应该有自己的一个sqlsession对象。

换言之，SqlSession是线程不安全的

[掌握]Mybatis入门级CRUD操作

功能需求：

基于已有数据表user，使用MyBatis实现以下功能：

n 根据用户id查询一个用户

n 根据用户名称模糊查询用户列表

n 添加一个用户

n 根据用户id修改用户名

n 根据用户id删除用户

<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
</dependency>

<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.46</version>
</dependency>
<!--mybatis的jar坐标-->
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>3.4.5</version>
</dependency>
<!--log4j日志组件，要同时把兄弟log4j.properties引入-->
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>1.2.17</version>
</dependency>
</dependencies>

<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.1</version>
<configuration>
<source>1.8</source>
<target>1.8</target>
<encoding>utf-8</encoding>
</configuration>
</plugin>
</plugins>
</build>

组件：

POJO

SqlMapConfig.xml

新增业务，修改：UserMapper.xml

关联SqlMapConfig和UserMapper

新增业务，修改：Java程序调用（测试程序）

根据用户id查询用户

l UserMapper.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：命名空间，分类管理的sql的作用
      -->
<mapper namespace="test">

<!--
      查询使用select标签
      parameterType：传入的参数类型
      resultType：封装的结果类型
      -->
<select id="queryUserById" parameterType="Integer" resultType="com.mybatis.pojo.User">
<!--
      #{}固定取参语法
      #{}取参名称：当parameterType传入简单数据类型的时候，取参名称任意，但是建议见名思意，比如是id就#{id}
      -->
      select * from user where id=#{id}
</select>

</mapper>

l 测试程序

/**
 * 测试用例(Use_case)：根据id查询用户
 */
@Test
public void testQueryUserById() throws IOException {
      InputStream inputStream = Resources.getResourceAsStream("SqlMapConfig.xml");
      SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
      SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(inputStream);
      SqlSession sqlSession = sqlSessionFactory.openSession();
      /*
       * 调用会话对象的api完成crud
       * param1：锁定sql的唯一标识符
       * param2：传入的参数
       * */
      User user = sqlSession.selectOne("test.queryUserById",1);
      System.out.println(user);
      sqlSession.close();
      inputStream.close();
      }

根据用户名模糊查询用户列表

l #{}方式取参

n UserMapper.xml

<!--根据用户名模糊查询用户列表-->
<!--注意：返回多条记录和返回单条记录，resultType配置是一样的-->
<select id="queryUserByUsername" parameterType="String" resultType="com.mybatis.pojo.User">
<!--
      #{}底层原理：预编译语句（防止sql注入，性能提高）
      #{}对字符串参数自动添加单引号对
      -->
      select * from user where username like #{username}
</select>

n 测试程序

/**
 * 测试用例(Use_case)：根据用户名模糊查询用户列表
 */
@Test
public void testQueryUserByUsername() throws IOException {
      InputStream inputStream = Resources.getResourceAsStream("SqlMapConfig.xml");
      SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
      SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(inputStream);
      SqlSession sqlSession = sqlSessionFactory.openSession();
      // TooManyResultsException: Expected one result (or null) to be returned by selectOne(), but found: 2
      List<User>  userList = sqlSession.selectList("test.queryUserByUsername","%王%");
      if(userList != null && userList.size() > 0) {
      for (int i = 0; i < userList.size(); i++) {
      User user =  userList.get(i);
      System.out.println(user);
      }
      }
      sqlSession.close();
      inputStream.close();
      }

l ${}方式取参

n UserMapper.xml

<!--
      ${}：另外一种取参方式
      ${}取参名称：当parameterType传入简单数据类型的时候，取参名称必须为value字符串
      ${}原理：简单的字符串，传什么参数拼接什么
      不会对字符串参数添加单引号对
      -->

<!--
      #和$取参使用原则
      能用#不用$(从底层原理角度出发说的，#是预编译语句),特殊情况使用$：当你传入的参数是数据库对象（比如表名动态传入），或者是
      order by 的那个字段，都不希望自动添加单引号对，所以使用$
      -->
<select id="queryUserByUsername$" parameterType="String" resultType="com.mybatis.pojo.User">
      select * from user where username like ${value}
</select>

n 测试程序

•  /**
   
    - 测试用例(Use_case)：根据用户名模糊查询用户列表$取参形式
    */
   @Test
   public void testQueryUserByUsername$() throws IOException {
           InputStream inputStream = Resources.getResourceAsStream("SqlMapConfig.xml");
           SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
           SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(inputStream);
           SqlSession sqlSession = sqlSessionFactory.openSession();
           // TooManyResultsException: Expected one result (or null) to be returned by selectOne(), but found: 2
           List<User>  userList = sqlSession.selectList("test.queryUserByUsername$","'%王%'");
           if(userList != null && userList.size() > 0) {
           for (int i = 0; i < userList.size(); i++) {
           User user =  userList.get(i);
           System.out.println(user);
           }
           }
           sqlSession.close();
           inputStream.close();
           }
  

小结

查询部分小结：

l selectOne，当结果集有多条记录的时候，抛出异常；

l #{}和${}使用原则

能使用#不用，特殊情况比如传入的参数是数据库对象（表名）或者order by的字段名时，不希望自动添加单引号对；

l 返回结果集列表的时候，resultType和返回单个对象配置都一样；

实现添加用户（及Mysql自增主键返回）

<!--
        #{}和${}取参时，当parameterType为pojo的时候，取参名称为pojo的属性名
        -->
<insert id="saveUser" parameterType="com.mybatis.pojo.User">

<!--
        selectKey用于查询主键数据
        order：selectKey中的sql在insert之前还是之后执行 AFTER/BEFORE
        resultType:查询出的主键的类型
        keyProperty：查询出的主键数据回显到pojo的哪个属性
        -->
<selectKey order="AFTER" resultType="Integer" keyProperty="id">
        select last_insert_id()
</selectKey>
        insert into user(username,sex,birthday,address)
        values(#{username},#{sex},#{birthday},#{address})
</insert>

自增主键返回：其实就是mybaits在执行完insert之后立马查询last_insert_id()

根据用户id修改用户名

<update id="updateUsernameById" parameterType="com.mybatis.pojo.User"> update user set username=#{username} where id=#{id}</update>

根据用户id删除用户

<delete id="deleteUserById" parameterType="Integer"> delete from user where id=#{id}</delete>

Mybatis解决原生JDBC操作数据库存在的问题

1、频繁创建、释放数据库连接造成系统资源浪费，影响系统性能。使用数据库连接池技术可以解决此问题。

解决：在SqlMapConfig.xml中配置数据连接池，使用连接池管理数据库连接。

2、Sql语句写在代码中造成代码不易维护，实际应用中Sql变化的可能较大，Sql变动需要改变java代码。

解决：将Sql语句配置在XXXXmapper.xml文件中与Java代码分离。

3、向Sql语句传参数麻烦，因为Sql语句的where条件不一定，可能多也可能少，占位符需要和参数一一对应（硬编码）。

解决：Mybatis自动将Java对象映射至Sql语句，通过statement中的parameterType定义输入参数的类型。

4、对结果集解析麻烦（查询列硬编码），Sql变化会导致解析代码变化，且解析前需要遍历，如果能将数据库记录封装成Pojo对象解析比较方便。

解决：Mybatis自动将Sql执行结果映射至Java对象，通过statement中的resultType定义输出结果的类型。

[掌握]Mybatis的两种Dao开发方式

使用MyBatis开发DAO的方式实现以下的功能：

n 根据用户id查询一个用户信息

原始Dao开发方式

​ 定义接口（UserDao）

​ 写实现类（UserDaoImpl）：在实现类中写crud那套程序

l 定义接口UserDao

package com.mybatis.dao;

import com.mybatis.pojo.User;

/**
 * 原始Dao开发方式接口定义
 */
public interface UserDao {

    User queryUserById(Integer id) throws Exception;
}

l 写实现类

package com.mybatis.dao;

import com.mybatis.pojo.User;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;

public class UserDaoImpl implements UserDao {

    /**
     * 声明一个SqlSessionFactory变量，用于接收service层调用dao层时传入的工厂对象
     * 因为工厂对象全局唯一，对于全局唯一的对象，在分层的架构中，dao层使用时候应该由
     * 外部传入
     */
    private SqlSessionFactory sqlSessionFactory;
    public UserDaoImpl(SqlSessionFactory sqlSessionFactory) {
        this.sqlSessionFactory = sqlSessionFactory;
    }

    @Override
    public User queryUserById(Integer id) throws Exception {
        SqlSession sqlSession = sqlSessionFactory.openSession();
        User user = sqlSession.selectOne("test.queryUserById", id);
        sqlSession.close();
        return user;
    }
}

注意：分层其实是对原有代码的重新组织

l 思考

一个项目当中会有很多表，都对应dao接口和实现类，实现类就是做增删改查这些东西

能否不写实现类只定义接口，让框架帮我们完成实现类的逻辑，那么就是Mapper动态代理的开发方式

Mapper动态代理开发方式

l 定义一个Mapper接口，这个接口其实和我们UserDao接口是一样的

Mapper接口中的接口方法被调用时候，最终要找到这个接口方法所使用的sql语句？那如何找到呢？

遵从下面4个规范即可

l 从Mybatis框架中拿到一个代理对象（代理的是这个Mapper接口），通过代理对象调用接口当中的方法完成业务

n 传统dao开发方式中的实现类其实起了一个连接、承上启下的作用，连接了接口和xml映射文件，效果就是调用接口方法时能够找到xml映射文件

n Mapper动态代理开发遵从的规范

u sql映射文件的namespace必须和mapper接口的全限定类名保持一致

u mapper接口的接口方法名必须和xml中的sql语句id保持一致

u mapper接口的接口方法形参类型必须和sql语句的输入参数类型保持一致

u mapper接口的接口方法返回类型必须和sql语句的resultType保持一致

小结

原始Dao和Mapper动态代理开发在企业中都很常见，推荐使用Mapper动态代理开发模式

[掌握]全局配置文件SqlMapConfig.xml的使用说明

注意：子标签是有顺序要求的，因为使用了dtd校验

properties（属性）

引入外部属性文件

<properties resource="db.properties"><property name="jdbc.username" value="root1"/></properties>

typeAliases（类型别名）

Mybatis默认支持的别名

别名	映射的类型
_byte	byte
_long	long
_short	short
_int	int
_integer	int
_double	double
_float	float
_boolean	boolean
string	String
byte	Byte
long	Long
short	Short
int	Integer
integer	Integer
double	Double
float	Float
boolean	Boolean
date	Date
decimal	BigDecimal
bigdecimal	BigDecimal
map	Map

注意：更多默认别名参见mybatis源码中的TypeAliasRegistry类

自定义别名

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

mappers（映射器）

引入sql语句的xml配置文件，把sql语句加载到内存当中

l <mapper resource=""/> 万能型选手，基础crud、原始dao开发、mapper动态代理开发都可以使用这种方式

l 针对mapper动态代理开发dao层，我们进行一个增加

mapper class属性：执行mapper接口类的全限定类名

​ 前提要求：

​ 1、编译之后 mapper.xml和mapper.class在同一个目录文件夹中

2、两个文件名称相同

<mapper class="com.mybatis.mapper.UserMapper"/><package name="com.mybatis.mapper"/>

[掌握]Mybatis的输入类型和结果类型

parameterType（输入类型）

l 传递简单类型

参考上面

l 传递Pojo对象

参考上面

l 传递Pojo包装对象

n 需求：使用POJO包装对象，根据用户名模糊查询用户列表

地址：http://epub.sipo.gov.cn/gjcx.jsp

resultType（输出类型）

l 输出简单类型

查询user表总记录数

l 输出Pojo对象

参考上面

l 输出Pojo列表

参考上面

resultMap（手动映射）

l 订单表POJO类

package com.mybatis.pojo;

import java.util.Date;

public class Orders {
    // 订单id
    private int id;
    // 用户id
    private Integer userId;
    // 订单号
    private String number;
    // 订单创建时间
    private Date createtime;
    // 备注
    private String note;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public Integer getUserId() {
        return userId;
    }

    public void setUserId(Integer userId) {
        this.userId = userId;
    }

    public String getNumber() {
        return number;
    }

    public void setNumber(String number) {
        this.number = number;
    }

    public Date getCreatetime() {
        return createtime;
    }

    public void setCreatetime(Date createtime) {
        this.createtime = createtime;
    }

    public String getNote() {
        return note;
    }

    public void setNote(String note) {
        this.note = note;
    }

    @Override
    public String toString() {
        return "Orders{" +
                "id=" + id +
                ", userId=" + userId +
                ", number='" + number + '\'' +
                ", createtime=" + createtime +
                ", note='" + note + '\'' +
                '}';
    }
}

n OrdersMapper.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.mybatis.mapper.OrdersMapper">

<!--
        resultType：自动映射，要求查询列名和pojo属性名保持一致
        1 最终封装的对象
        2 查询列名和pojo属性名一致
        当不一致的时候，要使用手动映射
        resultMap：配置手动映射
        -->
<select id="queryOrdersAllList" resultMap="ordersResultMap">
        select * from orders
</select>


<resultMap id="ordersResultMap" type="orders">
<!--手动配置映射关系-->
<!--
        主键字段不一致的时候使用<id>标签配置
        普通字段不一致的时候使用<result>标签配置
        property严格区分大小写，要和pojo属性名称一致
        -->
<id column="id" property="id"/>
<result column="user_id" property="userId"/>
<result column="number" property="number"/>
<result column="createtime" property="createtime"/>
<result column="note" property="note"/>
</resultMap>


</mapper>

工程准备

新建一个Maven类型的module：实现Mybatis第二天的保存用户功能，便于基于该功能的代码程序说明Mybatis数据库连接池和Mybatis事务控制。

[理解]Mybatis连接池和事务控制

Mybatis连接池

l POOLED使用连接池

n 什么时候从连接池获取连接

getMapper的时候还是真正调用api操作数据库的时候？

从连接池获取连接的时机：真正操作数据库调用api的时候，不是getMapper的时候

l 其他

n UNPOOLED：不使用数据库连接池（一般不使用）

n JNDI:(前提你的Mybatis环境必须是Web应用)（了解）

u 什么是JNDI

JNDI:java naming directory interface(java命名目录接口)，它是一种该服务发布技术，可以通过JNDI技术把数据源发布成一个服务，那么客户端可以调用这个服务

u 为什么必须是web应用

因为支持JNDI技术的往往是tomcat/weblogic/websphere这些中间件才支持JNDI技术

u 如果在Mybatis当中用，怎么用

参考附录

Mybatis事务控制

type="JDBC"：使用Jdbc的事务管理机制，connection的事务

Mybatis默认把Jdbc的事务自动提交给关闭了

注意：考虑提交的数据量较小的时候使用自动提交，如果数据量大影响了操作数据库的性能，那么考虑分批次手动控制事务的提交

type="MANAGED"：什么都不做，交给其他框架管理事务

[掌握]Mybatis映射文件的Sql深入（即动态Sql）

更优雅更方便的帮助我们拼接sql语句。

根据用户性别和用户名称查询用户列表

if标签/where标签

sql片段

引用sql片段使用include标签，refid指向sql片段的id，如果共享其他mapper文件当中的sql片段，只需要refid前面加上另外一个mapper映射文件的namespace即可

foreach标签

delete from user where id in(1,2,3)

String sql = "delete from user where id in("

for(String s: list) {

​   sql += s + ","

}

substring

sql += ")"

需求：根据多个id来查询用户列表

select * from user where id in(1,2,3)

l 形式一：直接传入list集合给mybatis

l 形式二：直接传入数组给Mybatis

Mybatis底层别名定义类

<!--
        foreach直接传入Array数组
        -->
<select id="queryUserByIdsArray" parameterType="int[]" resultType="user">
        select id,username,sex,birthday,address from user
<!--
        foreach：遍历拼接sql语句
        collection：遍历的集合，注意当直接传数组，除了知道是数组外没有别的名字，所以collection固定配置为array
        open：遍历拼接前干点啥（拼接点什么字符串）
        close:遍历结束后干点啥（拼接点什么字符串）
        separator：遍历拼接时候使用的分隔符
        item：遍历到的具体元素值，等同于下面for循环中的s
        for(String s : list) {
        s
        }
        -->
        <foreach collection="array" open=" where id in(" close=")" separator="," item="item">
        #{item}
        </foreach>
        </select> 

l 形式三：传入一个pojo，pojo中有list或者数组

 <!--        foreach直接传入pojo,pojo中封装list或者数组        --><select id="queryUserByIdsQueryVo" parameterType="queryvo" resultType="user">        select id,username,sex,birthday,address from user<!--        foreach：遍历拼接sql语句        collection：遍历的集合，当传入pojo的时候，collection配置为pojo当中集合的属性名        如果不指定具体属性名，那么mybatis是不知道要取pojo哪个属性的        open：遍历拼接前干点啥（拼接点什么字符串）        close:遍历结束后干点啥（拼接点什么字符串）        separator：遍历拼接时候使用的分隔符        item：遍历到的具体元素值，等同于下面for循环中的s        for(String s : list) {        s        }        -->        <foreach collection="idsList" open=" where id in(" close=")" separator="," item="item">        #{item}        </foreach>        </select>

[掌握]Mybatis的多表关联查询

多表：至少2张表

多表关系分析技巧：从一条记录出发，比如分析A表和B表的关系，就看A表的一条记录可以对应B表中几条记录，如果对应一条，从A到B表就是一对一的关系，如果对应多条就是一对多的关系。

多对多其实是双向的一对多

l 一对一

从订单表出发到用户表，一条订单记录只会对应用户表的一条记录，一对一

l 一对多

从用户表出发到订单表，一个用户记录可以对应订单表的多条记录，一对多

（通过主外键，一的一方是主表，多的一方是从表，外键在从表多的那一方）

l 多对多

用户和角色，一个用户可以有多个角色，一个角色也可以对应多个用户

通过中间表表达两个表之间的关系

a表 b表

id field.. id field..

中间表（往往两个字段即可）

aid bid

多表关联的SQL语句表达分析

l Sql语句表达

n 笛卡尔积

u SELECT * FROM USER,orders

SELECT * FROM USER u,orders o WHERE u.id=o.user_id(笛卡尔积进一步筛选)

n 关联查询

u 内关联 innder join on（和笛卡尔积进一步筛选效果一样）

SELECT * FROM USER u INNER JOIN orders o ON u.id=o.user_id

u 外连接(outer join on)（使用较多）

左外连接(left join) left join左边的表是基础表

SELECT * FROM USER u LEFT JOIN orders o ON u.id=o.user_id

右外连接(right join) right join右边的表是基础表

SELECT * FROM USER u RIGHT JOIN orders o ON u.id=o.user_id

l 内关联和外关联分析

一对一查询

Mybatis帮我们做的事情：

1、 SQL语句是用户自己写，Mybatis框架只是帮我们执行而已

2、 封装结果集

需求：查询订单表全部数据，关联查询出订单对应的用户数据（username address）

l Mapper映射文件

<select id="queryOrdersUser" resultMap="ordersUserResultMap">
        SELECT
        o.`id`,
        o.`user_id`,
        o.`number`,
        o.`createtime`,
        o.`note`,
        u.`username`,
        u.`address`
        FROM
        orders o
        LEFT JOIN USER u
        ON o.`user_id` = u.`id`
</select>


<resultMap id="ordersUserResultMap" type="orders">
<!--两部分数据：订单+用户-->
<id column="id" property="id"/>
<result column="user_id" property="userId"/>
<result column="number" property="number"/>
<result column="createtime" property="createtime"/>
<result column="note" property="note"/>

<!--association：关联的意思,用于一对一关联封装数据
        property：一对一关联后封装成的数据所对应的属性名
        javaType：属性的类型
        -->
<association property="user" javaType="user">
<id column="user_id" property="id"/>
<result column="username" property="username"/>
<result column="address" property="address"/>
</association>
</resultMap> 

l 测试程序

@Test
public void testQueryOrdersUser() {
        SqlSession sqlSession = sqlSessionFactory.openSession();
        OrdersMapper ordersMapper = sqlSession.getMapper(OrdersMapper.class);
        List<Orders> ordersList = ordersMapper.queryOrdersUser();
        if(ordersList != null && ordersList.size() > 0) {
        for (int i = 0; i < ordersList.size(); i++) {
        Orders orders =  ordersList.get(i);
        System.out.println(orders);
        }
        }
        sqlSession.close();
        }

一对多查询

需求：查询全部用户数据，关联查询出订单数据

l Mapper映射文件

<!--一对多用例-->
<select id="queryUserOrders" resultMap="userOrdersResultmap">
        SELECT
        u.`id`,
        u.`username`,
        u.`sex`,
        u.`birthday`,
        u.`address`,
        o.`id` oid,
        o.`user_id`,
        o.`number`,
        o.`createtime`,
        o.`note`
        FROM
        USER u
        LEFT JOIN orders o
        ON u.`id` = o.`user_id`
</select>



<resultMap id="userOrdersResultmap" type="user">
<!--两部分数据：用户+订单-->
<id column="id" property="id"/>
<result column="username" property="username"/>
<result column="sex" property="sex"/>
<result column="birthday" property="birthday"/>
<result column="address" property="address"/>

<!--一对多使用collection标签
        property：封装成对应的属性的属性名
        ofType：因为此时属性是一个list集合，collection已经表明了集合的意思，最重要的指定list里面的泛型类型，
        所以使用ofType
        -->
<collection property="ordersList" ofType="orders">
<id column="oid" property="id"/>
<result column="user_id" property="userId"/>
<result column="number" property="number"/>
<result column="createtime" property="createtime"/>
<result column="note" property="note"/>
</collection>
</resultMap>

多对多查询

多对多关系分析

多对多是双向的一对多

实现Role到User的一对多

l Mapper映射文件

<select id="queryRoleUsers" resultMap="roleUsersResultMap">
        SELECT
        r.rid,
        r.rname,
        r.rdesc,
        u.`username`,
        u.`address`
        FROM
        role r
        LEFT JOIN user_role ur
        ON r.`RID` = ur.`RID`
        LEFT JOIN USER u
        ON ur.`UID` = u.`id`
</select>

<!-- 多对多拆分成双向的一对多-->
<resultMap id="roleUsersResultMap" type="role">
<id column="rid" property="rid"/>
<result column="rname" property="rname"/>
<result column="rdesc" property="rdesc"/>

<collection property="userList" ofType="user">
<result column="username" property="username"/>
<result column="address" property="address"/>
</collection>
</resultMap>

实现User到Role的一对多

[了解]扩展知识

Tomcat配置JNDI数据源（了解）

l 第一步：将数据库驱动程序(jar包)放到tomcat安装目录下的common\lib文件夹下

l 第二步：在Tomcat的conf/context.xml文件中进行jndi数据源服务配置

name：在JNDI中叫做目录名，等同于服务名，此处的jndi/mybatis是自定义的，往往以/连接前后字符串即可。

auth和type是固定的，其他都是数据库连接池的具体配置信息

l 第三步：在自己web项目的web.xml中引用Jndi数据源服务

l 第四步：在自己web项目的Mybatis配置文件中使用

配置data_source属性，指向你的数据源引用，java:comp/env/jndi/mybatis中红色部分是固定的，绿色部分是你自己定义的目录名（服务名）

工程准备

使用Mapper动态代理的方式实现：

l 根据用户id查询用户

l 查询全部订单数据并关联查询出用户数据（一对一）

l 查询全部用户数据并关联查询出订单数据（一对多）

便于基于代码程序讲解Mybatis延迟加载和缓存。

[掌握]Mybatis延迟加载策略

关联对象：数据库层次用户和订单是关联表，在对象层次订单对象和用户对象就叫做关联对象

什么是延迟加载？

在使用关联对象的过程中

比如使用了Orders对象，但是我只是获取Orders的订单数据尚未获取user的数据，但是依然查询了user表（这不是延迟）

我orders.getNumber()你不要查user表的数据，当我orders.getUser()你再去查user表

关联查询的关联对象，在较多的场合中并不需要的时候，只在少部分场合需要关联的那个对象数据，可以考虑使用延迟加载

Mybatis中怎么实现延迟加载？

步骤1：原来关联sql语句要拆分

1） 第一条sql查询基础表

2） 第二条sql根据基础表的条件查询关联表

步骤2：让两条sql自动产生联系，通过<association column="" select=""/> 或者<collection column="" select =""/>

l 全局延迟加载开关配置（一对一和一对多都需要开启）

<setting name="lazyLoadingEnabled" value="true" /><setting name="aggressiveLazyLoading" value="false" /><setting name="lazyLoadTriggerMethods" value="true" />

l 一对一关联查询的延迟加载

<select id="queryOrdersWithUser" resultMap="ordersUserResultMap">
      SELECT
      o.`id`,
      o.`user_id`,
      o.`number`,
      o.`createtime`,
      o.`note`
      FROM
      orders o
</select>

<!--
      延迟加载分析
      1、原来关联查询的sql语句必然要拆分，如果不拆分，那肯定要执行关联查询，两个表用不用都要查
      2、sql=sql1+sql2拆分之后，要让这两个sql自动产生联系
      sql1:select id,user_id,number,createtime,note from orders
      sql2:select * from user u where id=user_id
      -->

<resultMap id="ordersUserResultMap" type="orders">
<id column="id" property="id"/>
<result column="user_id" property="userId"/>
<result column="number" property="number"/>
<result column="createtime" property="createtime"/>
<result column="note" property="note"/>
<association property="user" javaType="user" column="user_id" select="com.mybatis.mapper.UserMapper.queryUserByUserId">
</association>
</resultMap>

<select id="queryUserByUserId"  parameterType="int" resultType="user">
      select id,username,sex,birthday,address from user where id=#{user_id}
</select> 

l 一对多关联查询的延迟加载

<select id="queryUserWithOrders" resultMap="userOrdersResultMap">
      SELECT
      u.`id`,
      u.`username`,
      u.`sex`,
      u.`birthday`,
      u.`address`
      FROM
      USER u
</select>

<resultMap id="userOrdersResultMap" type="user">
<id column="id" property="id"/>
<result column="username" property="username"/>
<result column="sex" property="sex"/>
<result column="birthday" property="birthday"/>
<result column="address" property="address"/>

<collection property="ordersList" ofType="orders" column="id" select="com.mybatis.mapper.OrdersMapper.queryOrdersByUserId">
</collection>
</resultMap>

<!--拆分的第二条sql语句-->
<select id="queryOrdersByUserId" parameterType="int" resultType="orders">
      select o.id,o.user_id,o.number,o.createtime,o.note  from orders o  where o.user_id=#{id}
</select> 

[了解]Mybatis缓存

Mybatis的一级缓存

Mybatis的一级缓存是SqlSession级别的缓存，是默认开启的

注意：以下情形缓存会失效（被清理掉）：

n sqlSession关闭

n sqlSession提交事务：意味着可能是一个增删改的动作，数据表数据产生变化，那么这个时候Mybatis就会把这个sqlSession已有的一级缓存给清理掉

Mybatis的二级缓存

l Mybatis二级缓存机制

l 怎么用Mybatis的二级缓存

n 开启二级缓存开关

第一个开关：需要在SqlMapConfig.xml中开启二级缓存总开关

第二个开关：需要在使用二级缓存的mapper.xml中开启（因为二级缓存是mapper级别的）

n Pojo实现序列化

ratio：命中率的意思，两次都去查询了二级缓存，但是第一次的时候缓存中没有数据，所以没有命中，第二次查询的时候缓存中已经有数据了，所以命中率是0.5

l Mybatis二级缓存的清理时机：当这个mapper.xml中执行了非select语句的时候，整个Mapper的缓存全部清除掉。

注意：避免使用二级缓存，因为二级缓存带来的好处远远比不上他所隐藏的危害

n 如果你针对user表的sql操作并不是全部都在UserMapper.xml中，使用缓存的结果可能会不正确。

n 多表操作一定不能使用缓存

为什么不能？
首先不管多表操作写到那个Mapper.xml下，都会存在某个表不在这个Mapper下的情况。
例如两个表：role和user_role，如果我想查询出某个用户的全部角色role，就一定会涉及到多表的操作

<select id="selectUserRoles" resultType="UserRoleVO">
      select * from user_role a,role b where a.roleid = b.roleid and a.userid = #{userid}
</select>

像上面这个查询，你会写到那个xml中呢？？
不管是写到RoleMapper.xml还是UserRoleMapper.xml，或者是一个独立的XxxMapper.xml中。如果使用了二级缓存，都会导致上面这个查询结果可能不正确。
如果你正好修改了这个用户的角色，上面这个查询使用缓存的时候结果就是错的。

[掌握]Mybatis的注解开发

效果：没有写sql语句的xml了

l 基础的crud（基础crud怎么使用注解）

l 关联查询延迟加载（怎么使用注解完成）

l 动态sql的注解方式

原则：把原来xml里面的内容都对应的放到注解上即可

注解开发不需要引入额外的jar包，和原来一致即可

注解添加在接口类的方法上

使用注解实现基本的CRUD

@Insert("insert into user(username,sex,birthday,address) values (#{username},#{sex},#{birthday},#{address})")

/*回显mysql自增主键id 
  等同于原来我们xml中使用<selectKey/>，一一对应过来即可
* */
@SelectKey(statement = "select last_insert_id()",before = false,keyProperty = "id",resultType = Integer.class)
void saveUser(User user);

@Update("update user set username=#{username} where id=#{id}")
void updateUsernameById(User user);

@Delete("delete from user where id=#{id}")
void deleteUserById(Integer id);

@Select("select id,username,sex,birthday,address from user where id=#{id}")
User queryUserById(Integer id);

@Select("select id,username,sex,birthday,address from user")
List<User> queryUserList();


@Select("<script>select id,username,sex,birthday,address from user" +
        "<where>" +
        "<if test=\"sex != null and sex != ''\">" +
        " and sex=#{sex}" +
        "</if>" +
        "<if test=\"username != null and username != ''\">" +
        " and username like #{username}" +
        "</if>" +
        "</where></script>")
List<User> queryUserByWhere(User user);


@Select("<script>select id,username,sex,birthday,address from user" +
        "<foreach collection=\"list\" open=\" where id in(\" close=\")\" separator=\",\" item=\"item\">" +
        "#{item}" +
        "</foreach></script>")
List<User> queryUserByIdsList(List<Integer> ids); 

使用注解实现复杂关系映射开发

使用注解实现一对一查询

/*
 * 对应关系
 * @Results对应xml中的resultMap
 * @Result对应xml中的id/result
 * id：true/false，是否是主键，默认false
 * column：查询列名
 * property：pojo属性名
 * association：在注解中使用@Result+one=@One的方式去表达
 * fetchType：延迟加载类型，默认是延迟加载，eager：积极加载
 * */

@Results({
        @Result(id = true,column = "id",property = "id"),
        @Result(column = "user_id",property = "userId"),
        @Result(column = "number",property = "number"),
        @Result(column = "createtime",property = "createtime"),
        @Result(column = "note",property = "note"),
        @Result(property = "user",column = "user_id",javaType = User.class,one=@One(select = "com.mybatis.mapper.UserMapper.queryUserByUserid",fetchType = FetchType.LAZY))
})
List<Orders> queryOrdersUser();

@Select("select id,username,sex,birthday,address from user where id=#{user_id}")
User queryUserByUserid(Integer id); 

使用注解实现一对多查询

l mapper接口

/*
 * 对应关系
 * @Results对应xml中的resultMap
 * @Result对应xml中的id/result
 * id：true/false，是否是主键，默认false
 * column：查询列名
 * property：pojo属性名
 * collection：在注解中使用@Result+many=@Many的方式去表达
 * xml中的ofType在注解中使用 javaType表达=List.class
 * fetchType：延迟加载类型，默认是延迟加载，eager：积极加载
 * */
@Select("select id,username,sex,birthday,address from user")
@Results({
        @Result(id = true,column = "id",property = "id"),
        @Result(column = "username",property = "username"),
        @Result(column="sex",property="sex"),
        @Result(column="birthday",property="birthday"),
        @Result(column="address",property="address"),
        @Result( property="ordersList",javaType = List.class,column="id",
                many = @Many(select="com.mybatis.mapper.OrdersMapper.queryOrdersByUserid",fetchType = FetchType.LAZY))
})
List<User> queryUserOrders();

@Select("select id,number from orders where user_id=#{userId}")
List<Orders> queryOrdersByUserid(Integer userId);