Mybatis3文档学习

浅浅的花香味﹌ 2022-09-13 05:25 166阅读 0赞

### 1.mybatis的介绍 ###

*  持久化：**持久化是将程序数据在持久状态和瞬时状态间转换的机制**
    
     *  即把数据（如内存中的对象）保存到可永久保存的存储设备中（如磁盘）。持久化的主要应用是将内存中的对象存储在数据库中，或者存储在磁盘文件中、XML数据文件中等等
     *  JDBC就是一种持久化机制。文件IO也是一种持久化机制
     *  在生活中 : 将鲜肉冷藏，吃的时候再解冻的方法也是。将水果做成罐头的方法也是
 *  **为什么需要持久化服务呢？那是由于内存本身的缺陷引起的**
    
     *  内存断电后数据会丢失，但有一些对象是无论如何都不能丢失的，比如银行账号等，遗憾的是，人们还无法保证内存永不掉电
     *  内存过于昂贵，与硬盘、光盘等外存相比，内存的价格要高2~3个数量级，而且维持成本也高，至少需要一直供电吧。所以即使对象不需要永久保存，也会因为内存的容量限制不能一直呆在内存中，需要持久化来缓存到外存

### 2.mybatis的简单使用 ###

#### 1.搭建数据库 ####

![image-20210915203006815][]

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

#### 3.编写mybatis核心配置文件 ####

*  XML 配置文件中包含了对 MyBatis 系统的核心设置，包括获取数据库连接实例的数据源（DataSource）以及决定事务作用域和控制方式的事务管理器（TransactionManager）
 *  environment 元素体中包含了事务管理和连接池的配置。mappers 元素则包含了一组映射器（mapper），这些映射器的 XML 映射文件包含了 SQL 代码和映射定义信息

<?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>
        
         <settings>
    
            <setting name="mapUnderscoreToCamelCase" value="true"/>
        </settings>
        
       <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&useUnicode=true&characterEncoding=utf8"/>
                   <property name="username" value="root"/>
                   <property name="password" value="123456"/>
               </dataSource>
           </environment>
       </environments>
       <mappers>
           <mapper resource="dao/userMapper.xml"/>
       </mappers>
    </configuration>

#### 4.编写mybaits工具类 ####

import org.apache.ibatis.io.Resources;
    import org.apache.ibatis.session.SqlSession;
    import org.apache.ibatis.session.SqlSessionFactory;
    import org.apache.ibatis.session.SqlSessionFactoryBuilder;
    import java.io.IOException;
    import java.io.InputStream;
    
    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) { 
               e.printStackTrace();
          }
      }
    
       //获取SqlSession连接
       public static SqlSession getSession(){ 
           //true表示自动提交事务--autocommit
            return sqlSessionFactory.openSession(true);
      }
    
    }

#### 5.创建实体类 ####

public class User { 
       
       private int id;  //id
       private String name;   //姓名
       private String pwd;   //密码
       
       //构造,有参,无参
       //set/get
       //toString()
    }

#### 6.编写mapper接口类 ####

import com.kuang.pojo.User;
    import java.util.List;
    
    public interface UserMapper { 
       List<User> selectUser();
    }

#### 7.编写mapper.xml配置文件 ####

#### 8.编写测试类 ####

public class MyTest { 
       @Test
       public void selectUser() { 
           SqlSession session = MybatisUtils.getSession();
           //方法一:
           //List<User> users = session.selectList("com.kuang.mapper.UserMapper.selectUser");
           //方法二:
           UserMapper mapper = session.getMapper(UserMapper.class);
           List<User> users = mapper.selectUser();
    
           for (User user: users){ 
               System.out.println(user);
          }
           session.close();
      }
    }

*  静态资源过滤

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

### 3.作用域和生命周期 ###

1.  #### SqlSessionFactoryBuilder ####
    
    这个类可以被实例化、使用和丢弃，一旦创建了 SqlSessionFactory，就**不再需要它**了。 因此 SqlSessionFactoryBuilder 实例的最佳作用域是**方法作用域（也就是局部方法变量）**。 你可以重用 SqlSessionFactoryBuilder 来创建多个 SqlSessionFactory 实例，但最好还是不要一直保留着它，以保证所有的 XML 解析资源可以被释放给更重要的事情
2.  #### SqlSessionFactory ####
    
    SqlSessionFactory **一旦被创建就应该在应用的运行期间一直存在**，没有任何理由丢弃它或重新创建另一个实例。 使用 SqlSessionFactory 的最佳实践是在应用运行期间不要重复创建多次，多次重建 SqlSessionFactory 被视为一种代码“坏习惯”。因此 SqlSessionFactory 的最佳作用域是**应用作用域**。 有很多方法可以做到，最简单的就是使用**单例模式**或者静态单例模式
3.  #### SqlSession ####
    
    每个**线程**都应该有它自己的 SqlSession 实例。SqlSession 的实例不是线程安全的，因此是不能被共享的，所以它的最佳的作用域是请求或方法作用域。 **绝对不能将 SqlSession 实例的引用放在一个类的静态域**，甚至一个类的实例变量也不行。 也绝不能将 SqlSession 实例的引用放在任何类型的托管作用域中，比如 Servlet 框架中的 HttpSession。 如果你现在正在使用一种 Web 框架，考虑将 SqlSession 放在一个和 HTTP 请求相似的作用域中。 **换句话说，每次收到 HTTP 请求，就可以打开一个 SqlSession，返回一个响应后，就关闭它**。 这个关闭操作很重要，为了确保每次都能执行关闭操作，**你应该把这个关闭操作放到 finally 块中**。

### 4.CRUD ###

#### 1.**查询 – Select** ####

*  根据姓名和密码查询数据库中的用户
    
     *  方式一
    
        //1.在userMapper中添加方法
        
        User selectUserByCon(@Param("userName")String userName,@Param("password")String password);
    
        
        <select id="selectUserByCon" resultType="pojo.User">
                select * from userinfo
                where user_name = #{userName} and password = #{password}
            </select>
    
        //测试方法
        @Test
            public void queryUser(){ 
                SqlSession sqlSession = mybatis_utils.getSession();
        
                userMapper mapper = sqlSession.getMapper(userMapper.class);
        
                User user = mapper.selectUserByCon("张三", "123");
        
                System.out.println(user);
        
                sqlSession.close();
            }
    
    查询结果：User(id=1, userName=张三, password=123)
    
     *  方式二
    
        User selectUserByCon_map(Map<String,Object> map);
        
        <select id="selectUserByCon_map" parameterType="map" resultType="pojo.User">
                select * from  userinfo
                where user_name = #{ name} and password = #{ password}
        </select>
        
            
        //键是列名，值便是结果行中的对应值
        Map<String,Object> map = new HashMap<>();
        map.put("name","张三");
        map.put("password","123");
        
        User user = mapper.selectUserByCon_map(map);
        System.out.println(user);

#### 2.**插入 – insert** ####

*  向数据库插入一个用户

1.在userMapper中添加方法

int addUser(User user);

2.在userMapper.xml中编写sql语句

<insert id="addUser" parameterType="pojo.User">
            insert into userinfo values (#{id},#{userName},#{password})
    </insert>

3.测试

SqlSession sqlSession = mybatis_utils.getSession();
    userMapper mapper = sqlSession.getMapper(userMapper.class);
    
    mapper.addUser(new User(5,"李四我","222"));
    
    sqlSession.commit(); //对数据库进行增删改需要提交事务
    sqlSession.close();

#### 3.**修改 --update** ####

*  修改指定id的用户信息

1.在userMapper中添加方法

int updateUser(User user);

2.在userMapper.xml中编写sql语句

<update id="updateUser" parameterType="pojo.User">
            update userinfo set user_name=#{userName},password=#{password}
            where id = #{id}
    </update>

3.测试

SqlSession sqlSession = mybatis_utils.getSession();
    userMapper mapper = sqlSession.getMapper(userMapper.class);
    mapper.updateUser(new User(5,"李四","333"));
    
    sqlSession.commit();
    sqlSession.close();

#### 4.**删除 --delete** ####

*  删除指定id的用户

1.在userMapper中添加方法

int deleteUser(int id);

2.在userMapper.xml中编写sql语句

<delete id="deleteUser" parameterType="int">
            delete from  userinfo where id = #{id}
    </delete>

3.测试

SqlSession sqlSession = mybatis_utils.getSession();
    userMapper mapper = sqlSession.getMapper(userMapper.class);
    mapper.deleteUser(5);
    
    sqlSession.commit();
    sqlSession.close();

#### 5.**模糊查询 --like** ####

*  查询所有指定姓氏的人
    
     *  方式一
        
        1.在userMapper中添加方法
        
            List<User> selectUser2(String val);
        
        2.在userMapper.xml中编写sql语句
        
            <select id="selectUser2" resultType="pojo.User" parameterType="String">
                    select * from userinfo where user_name like #{val}
            </select>
        
        3.测试
        
            SqlSession sqlSession = mybatis_utils.getSession();
            userMapper mapper = sqlSession.getMapper(userMapper.class);
            List<User> users = mapper.selectUser2("%张%");
            for (User user : users) { 
                System.out.println(user);
            }
        
        查询结果：User(id=1, userName=张三, password=123)  
        User(id=4, userName=张武, password=333)
     *  方式二
    
    1.在userMapper中添加方法
    
        List<User> selectUser3(String val);
    
    2.在userMapper.xml中编写sql语句
    
        <select id="selectUser3" resultType="pojo.User" parameterType="String">        select * from userinfo where user_name like "%"#{val}"%"</select>
    
    3.测试
    
        SqlSession sqlSession = mybatis_utils.getSession();
        userMapper mapper = sqlSession.getMapper(userMapper.class);
        List<User> users = mapper.selectUser3("张");
        for (User user : users) { 
            System.out.println(user);
        }
    
    查询结果：User(id=1, userName=张三, password=123)  
    User(id=4, userName=张武, password=333)

#### 6.使用注解开发 ####

*  sql 类型主要分成 :
 *   *  @select ()
     *  @update ()
     *  @Insert ()
     *  @delete ()

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

1.  在接口中添加注解
    
        //查询全部用户
        @Select("select id,name,pwd password from user")
        public List<User> getAllUser();
2.  在mybatis的核心配置文件中注入
    
        
        <mappers>
           <mapper class="dao.UserMapper"/>
        </mappers>
3.  测试
    
        @Test
        public void testGetAllUser() { 
           SqlSession session = MybatisUtils.getSession();
           //本质上利用了jvm的动态代理机制
           UserMapper mapper = session.getMapper(UserMapper.class);
        
           List<User> users = mapper.getAllUser();
           for (User user : users){ 
               System.out.println(user);
          }
        
           session.close();
        }

**mybatis的执行流程**

![image-20210920173246350][]

### 5.mybatis核心配置文件的配置 ###

#### 1.**配置内容** ####

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

#### 2.**environments**元素 ####

MyBatis 可以配置成适应多种环境，这种机制有助于将 SQL 映射应用于多种数据库之中， 现实情况下有多种理由需要这么做。例如，开发、测试和生产环境需要有不同的配置；或者想在具有相同 Schema 的多个生产数据库中使用相同的 SQL 映射。还有许多类似的使用场景

**尽管可以配置多个环境，但每个 SqlSessionFactory 实例只能选择一种环境。**

注意一些关键点:

*  默认使用的环境 ID（比如：default=“development”）。
 *  每个 environment 元素定义的环境 ID（比如：id=“development”）。
 *  事务管理器的配置（比如：type=“JDBC”）。
 *  数据源的配置（比如：type=“POOLED”）。

默认环境和环境 ID 顾名思义。 环境可以随意命名，但务必保证默认的环境 ID 要匹配其中一个环境 ID

**事务管理器（transactionManager）**

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

*  JDBC – 这个配置直接使用了 JDBC 的提交和回滚设施，它依赖从数据源获得的连接来管理事务作用域。
 *  MANAGED – 这个配置几乎没做什么。它从不提交或回滚一个连接，而是让容器来管理事务的整个生命周期（比如 JEE 应用服务器的上下文）。 默认情况下它会关闭连接。然而一些容器并不希望连接被关闭，因此需要将 closeConnection 属性设置为 false 来阻止默认的关闭行为.

**数据源（dataSource）**

dataSource 元素使用标准的 JDBC 数据源接口来配置 JDBC 连接对象的资源。

*  大多数 MyBatis 应用程序会按示例中的例子来配置数据源。虽然数据源配置是可选的，但如果要启用延迟加载特性，就必须配置数据源。

有三种内建的数据源类型（也就是 type="\[UNPOOLED|POOLED|JNDI\]"）：

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

**映射器（mappers）**

<mappers>
      <mapper resource="org/mybatis/builder/AuthorMapper.xml"/>
      <mapper resource="org/mybatis/builder/BlogMapper.xml"/>
      <mapper resource="org/mybatis/builder/PostMapper.xml"/>
    </mappers>

<mappers>
      <mapper url="file:///var/mappers/AuthorMapper.xml"/>
      <mapper url="file:///var/mappers/BlogMapper.xml"/>
      <mapper url="file:///var/mappers/PostMapper.xml"/>
    </mappers>

<mappers>
      <mapper class="org.mybatis.builder.AuthorMapper"/>
      <mapper class="org.mybatis.builder.BlogMapper"/>
      <mapper class="org.mybatis.builder.PostMapper"/>
    </mappers>

<mappers>
      <package name="org.mybatis.builder"/>
    </mappers>

#### 3.**属性（properties）** ####

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

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

driver=com.mysql.jdbc.Driverurl=jdbc:mysql://localhost:3306/mybatis?useSSL=true&useUnicode=true&characterEncoding=utf8username=rootpassword=123456

2.将文件导入properties 配置文件

如果一个属性在不只一个地方进行了配置，那么，MyBatis 将按照下面的顺序来加载：

*  首先读取在 properties **元素体**内指定的属性。
 *  然后根据 properties 元素中的 resource 属性读取类路径下属性文件，或根据 url 属性指定的路径读取属性文件，并覆盖之前读取过的同名属性。
 *  最后读取作为方法参数传递的属性，并覆盖之前读取过的同名属性。

#### 4.**设置（settings）** ####

<table> 
 <thead> 
  <tr> 
   <th align="left">设置名</th> 
   <th align="left">描述</th> 
   <th align="left">有效值</th> 
   <th align="left">默认值</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">cacheEnabled</td> 
   <td align="left">全局性地开启或关闭所有映射器配置文件中已配置的任何缓存。</td> 
   <td align="left">true | false</td> 
   <td align="left">true</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <thead> 
  <tr> 
   <th>lazyLoadingEnabled</th> 
   <th>延迟加载的全局开关。当开启时，所有关联对象都会延迟加载。 特定关联关系中可通过设置 <code>fetchType</code> 属性来覆盖该项的开关状态。</th> 
   <th>true | false</th> 
   <th>false</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>safeRowBoundsEnabled</td> 
   <td>是否允许在嵌套语句中使用分页（RowBounds）。如果允许使用则设置为 false。</td> 
   <td>true | false</td> 
   <td>False</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <thead> 
  <tr> 
   <th>mapUnderscoreToCamelCase</th> 
   <th>是否开启驼峰命名自动映射，即从经典数据库列名 A_COLUMN 映射到经典 Java 属性名 aColumn。</th> 
   <th>true | false</th> 
   <th>False</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>logImpl</td> 
   <td>指定 MyBatis 所用日志的具体实现，未指定时将自动查找。</td> 
   <td>SLF4J | LOG4J | LOG4J2 | JDK_LOGGING | COMMONS_LOGGING | STDOUT_LOGGING | NO_LOGGING</td> 
   <td>未设置</td> 
  </tr> 
 </tbody> 
</table>

#### 5.**类型别名（typeAliases）** ####

类型别名可为 Java 类型设置一个缩写名字。 它仅用于 XML 配置，意在降低冗余的全限定类名书写

当这样配置时，`Blog` 可以用在任何使用 `domain.blog.Blog` 的地方。

也可以指定一个包名，MyBatis 会在包名下面搜索需要的 Java Bean

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

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

### 6.XML映射器 ###

SQL 映射文件只有很少的几个顶级元素（按照应被定义的顺序列出）：

*  `cache` – 该命名空间的缓存配置。
 *  `cache-ref` – 引用其它命名空间的缓存配置。
 *  `resultMap` – 描述如何从数据库结果集中加载对象，是最复杂也是最强大的元素。
 *  `parameterMap` – 老式风格的参数映射。此元素已被废弃，并可能在将来被移除！请使用行内参数映射。文档中不会介绍此元素。
 *  `sql` – 可被其它语句引用的可重用语句块。
 *  `insert` – 映射插入语句。
 *  `update` – 映射更新语句。
 *  `delete` – 映射删除语句。
 *  `select` – 映射查询语句。

#### 1.**Select** ####

*  select元素的部分属性

<table> 
 <thead> 
  <tr> 
   <th align="left">属性</th> 
   <th align="left">描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left"><code>id</code></td> 
   <td align="left">在命名空间中唯一的标识符，可以被用来引用这条语句。</td> 
  </tr> 
  <tr> 
   <td align="left"><code>parameterType</code></td> 
   <td align="left">将会传入这条语句的参数的类全限定名或别名。这个属性是可选的，因为 MyBatis 可以通过类型处理器（TypeHandler）推断出具体传入语句的参数，默认值为未设置（unset）。</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <thead> 
  <tr> 
   <th><code>resultType</code></th> 
   <th>期望从这条语句中返回结果的类全限定名或别名。 注意，如果返回的是集合，那应该设置为集合包含的类型，而不是集合本身的类型。 resultType 和 resultMap 之间只能同时使用一个。</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>resultMap</code></td> 
   <td>对外部 resultMap 的命名引用。结果映射是 MyBatis 最强大的特性，如果你对其理解透彻，许多复杂的映射问题都能迎刃而解。 resultType 和 resultMap 之间只能同时使用一个。</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <thead> 
  <tr> 
   <th><code>flushCache</code></th> 
   <th>将其设置为 true 后，只要语句被调用，都会导致本地缓存和二级缓存被清空，默认值：false。</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>useCache</code></td> 
   <td>将其设置为 true 后，将会导致本条语句的结果被二级缓存缓存起来，默认值：对 select 元素为 true。</td> 
  </tr> 
 </tbody> 
</table>

#### 2.**insert, update 和 delete** ####

<table> 
 <thead> 
  <tr> 
   <th><code>useGeneratedKeys</code></th> 
   <th>（仅适用于 insert 和 update）这会令 MyBatis 使用 JDBC 的 getGeneratedKeys 方法来取出由数据库内部生成的主键（比如：像 MySQL 和 SQL Server 这样的关系型数据库管理系统的自动递增字段），默认值：false。</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>keyProperty</code></td> 
   <td>（仅适用于 insert 和 update）指定能够唯一识别对象的属性，MyBatis 会使用 getGeneratedKeys 的返回值或 insert 语句的 selectKey 子元素设置它的值，默认值：未设置（<code>unset</code>）。如果生成列不止一个，可以用逗号分隔多个属性名称。</td> 
  </tr> 
  <tr> 
   <td><code>keyColumn</code></td> 
   <td>（仅适用于 insert 和 update）设置生成键值在表中的列名，在某些数据库（像 PostgreSQL）中，当主键列不是表中的第一列的时候，是必须设置的。如果生成列不止一个，可以用逗号分隔多个属性名称。</td> 
  </tr> 
 </tbody> 
</table>

示例:

<insert id="insertAuthor">
      insert into Author (id,username,password,email,bio)
      values (#{id},#{username},#{password},#{email},#{bio})
    </insert>
    
    <update id="updateAuthor">
      update Author set
        username = #{username},
        password = #{password},
        email = #{email},
        bio = #{bio}
      where id = #{id}
    </update>
    
    <delete id="deleteAuthor">
      delete from Author where id = #{id}
    </delete>

如果你的数据库支持**自动生成主键**的字段（比如 MySQL 和 SQL Server），那么你可以设置 **useGeneratedKeys=”true”**，然后再把 **keyProperty** 设置为目标属性就 OK 了。例如，如果上面的 Author 表已经在 id 列上使用了自动生成，那么语句可以修改为

<insert id="insertAuthor" useGeneratedKeys="true" keyProperty="id">
      insert into Author (username,password,email,bio)
      values (#{username},#{password},#{email},#{bio})
    </insert>

#### 3.sql ####

用来定义可重用的 SQL 代码片段，以便在其它语句中使用。 参数可以静态地（在加载的时候）确定下来，并且可以在不同的 include 元素中定义不同的参数值

<sql id="userColumns"> ${alias}.id,${alias}.username,${alias}.password </sql>

这个 SQL 片段可以在其它语句中使用

<select id="selectUsers" resultType="map">
      select
        <include refid="userColumns"><property name="alias" value="t1"/></include>,
        <include refid="userColumns"><property name="alias" value="t2"/></include>
      from some_table t1
        cross join some_table t2
    </select>

#### 4.参数 ####

原始类型或简单数据类型（比如 `Integer` 和 `String`）因为没有其它属性，会用它们的值来作为参数。 然而，如果传入一个复杂的对象，行为就会有点不一样了

<insert id="insertUser" parameterType="User">
      insert into users (id, username, password)
      values (#{id}, #{username}, #{password})
    </insert>

如果 User 类型的参数对象传递到了语句中，会查找 id、username 和 password 属性，然后将它们的值传入预处理语句的参数中。

对传递语句参数来说，这种方式真是干脆利落。不过参数映射的功能远不止于此。

首先，和 MyBatis 的其它部分一样，参数也可以指定一个特殊的数据类型。

#{property,javaType=int,jdbcType=NUMERIC}

对于数值类型，还可以设置 `numericScale` 指定小数点后保留的位数。

#{height,javaType=double,jdbcType=NUMERIC,numericScale=2}

#### 5.字符串替换 ####

默认情况下，使用 `#{}` 参数语法时，MyBatis 会创建 `PreparedStatement` 参数占位符，并通过占位符安全地设置参数（就像使用 ? 一样）。 这样做更安全，更迅速，通常也是首选做法，不过有时你就是想直接在 SQL 语句中直接插入一个不转义的字符串。 比如 ORDER BY 子句

ORDER BY ${columnName}

这样，MyBatis 就不会修改或转义该字符串了。

当 SQL 语句中的元数据（如表名或列名）是动态生成的时候，字符串替换将会非常有用。 举个例子，如果你想 `select` 一个表任意一列的数据时，不需要这样写：

@Select("select * from user where id = #{id}")
    User findById(@Param("id") long id);
    
    @Select("select * from user where name = #{name}")
    User findByName(@Param("name") String name);
    
    @Select("select * from user where email = #{email}")
    User findByEmail(@Param("email") String email);

而是可以只写这样一个方法：

@Select("select * from user where ${column} = #{value}")
    User findByColumn(@Param("column") String column, @Param("value") String value);

其中 `${column}` 会被直接替换，而 `#{value}` 会使用 `?` 预处理。 这样，就能完成同样的任务：

User userOfId1 = userMapper.findByColumn("id", 1L);
    User userOfNameKid = userMapper.findByColumn("name", "kid");
    User userOfEmail = userMapper.findByColumn("email", "noone@nowhere.com")

这种方式也同样适用于替换表名的情况。

**提示** ：用这种方式接受用户的输入，并用作语句参数是不安全的，会导致潜在的 SQL 注入攻击。因此，要么不允许用户输入这些字段，要么自行转义并检验这些参数

#### 6.结果映射 ####

简单映射语句，没有显示指定resultMap

<select id="selectUsers" resultType="map">
      select id, username, hashedPassword
      from some_table
      where id = #{id}
    </select>

上述语句只是简单地将所有的列映射到 `HashMap` 的键上，这由 `resultType` 属性指定.

package com.someapp.model;
    public class User { 
      private int id;
      private String username;
      private String hashedPassword;
    
      public int getId() { 
        return id;
      }
      public void setId(int id) { 
        this.id = id;
      }
      public String getUsername() { 
        return username;
      }
      public void setUsername(String username) { 
        this.username = username;
      }
      public String getHashedPassword() { 
        return hashedPassword;
      }
      public void setHashedPassword(String hashedPassword) { 
        this.hashedPassword = hashedPassword;
      }
    }

基于 JavaBean 的规范，上面这个类有 3 个属性：**id，username 和 hashedPassword**。这些属性会对应到 select 语句中的列名。

这样的一个 JavaBean 可以被映射到 `ResultSet`，就像映射到 `HashMap` 一样简单。

<select id="selectUsers" resultType="com.someapp.model.User">
      select id, username, hashedPassword
      from some_table
      where id = #{id}
    </select>

类型别名是你的好帮手。使用它们，你就可以不用输入类的全限定名了

<typeAlias type="com.someapp.model.User" alias="User"/>
    
    
    <select id="selectUsers" resultType="User">
      select id, username, hashedPassword
      from some_table
      where id = #{id}
    </select>

在这些情况下，MyBatis 会在幕后**自动创建**一个 `ResultMap`，再**根据属性名**来映射列到 JavaBean 的属性上。如果列名和属性名不能匹配上，可以在 SELECT 语句中设置列别名（这是一个**基本的 SQL 特性**）来完成匹配

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

<select id="selectUsers" resultType="User">
      select
        user_id             as "id",
        user_name           as "userName",
        hashed_password     as "hashedPassword"
      from some_table
      where id = #{id}
    </select>

显式使用外部的 `resultMap` ，解决列名不匹配

然后在引用它的语句中设置 `resultMap` 属性就行了

<select id="selectUsers" resultMap="userResultMap">
      select user_id, user_name, hashed_password
      from some_table
      where id = #{id}
    </select>

**resultMap**的子元素

![image-20210920164727474][]

**resultMap**的属性列表

<table> 
 <thead> 
  <tr> 
   <th align="left">属性</th> 
   <th align="left">描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left"><code>id</code></td> 
   <td align="left">当前命名空间中的一个唯一标识，用于标识一个结果映射。</td> 
  </tr> 
  <tr> 
   <td align="left"><code>type</code></td> 
   <td align="left">类的完全限定名, 或者一个类型别名（关于内置的类型别名，可以参考上面的表格）。</td> 
  </tr> 
  <tr> 
   <td align="left"><code>autoMapping</code></td> 
   <td align="left">如果设置这个属性，MyBatis 将会为本结果映射开启或者关闭自动映射。 这个属性会覆盖全局的属性 autoMappingBehavior。默认值：未设置（unset）。</td> 
  </tr> 
 </tbody> 
</table>

**id和result的属性**

<table> 
 <thead> 
  <tr> 
   <th align="left">属性</th> 
   <th align="left">描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left"><code>property</code></td> 
   <td align="left">映射到列结果的字段或属性。如果 JavaBean 有这个名字的属性（property），会先使用该属性。否则 MyBatis 将会寻找给定名称的字段（field）。 无论是哪一种情形，你都可以使用常见的点式分隔形式进行复杂属性导航。 比如，你可以这样映射一些简单的东西：“username”，或者映射到一些复杂的东西上：“address.street.number”。</td> 
  </tr> 
  <tr> 
   <td align="left"><code>column</code></td> 
   <td align="left">数据库中的列名，或者是列的别名。一般情况下，这和传递给 <code>resultSet.getString(columnName)</code> 方法的参数一样。</td> 
  </tr> 
  <tr> 
   <td align="left"><code>javaType</code></td> 
   <td align="left">一个 Java 类的全限定名，或一个类型别名（关于内置的类型别名，可以参考上面的表格）。 如果你映射到一个 JavaBean，MyBatis 通常可以推断类型。然而，如果你映射到的是 HashMap，那么你应该明确地指定 javaType 来保证行为与期望的相一致。</td> 
  </tr> 
  <tr> 
   <td align="left"><code>jdbcType</code></td> 
   <td align="left">JDBC 类型，所支持的 JDBC 类型参见这个表格之后的“支持的 JDBC 类型”。 只需要在可能执行插入、更新和删除的且允许空值的列上指定 JDBC 类型。这是 JDBC 的要求而非 MyBatis 的要求。如果你直接面向 JDBC 编程，你需要对可以为空值的列指定这个类型。</td> 
  </tr> 
  <tr> 
   <td align="left"><code>typeHandler</code></td> 
   <td align="left">我们在前面讨论过默认的类型处理器。使用这个属性，你可以覆盖默认的类型处理器。 这个属性值是一个类型处理器实现类的全限定名，或者是类型别名。</td> 
  </tr> 
 </tbody> 
</table>

**关联的嵌套select查询**

<table> 
 <thead> 
  <tr> 
   <th align="left">属性</th> 
   <th align="left">描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left"><code>column</code></td> 
   <td align="left">数据库中的列名，或者是列的别名。一般情况下，这和传递给 <code>resultSet.getString(columnName)</code> 方法的参数一样。 注意：在使用复合主键的时候，你可以使用 <code>column="{prop1=col1,prop2=col2}"</code> 这样的语法来指定多个传递给嵌套 Select 查询语句的列名。这会使得 <code>prop1</code> 和 <code>prop2</code> 作为参数对象，被设置为对应嵌套 Select 语句的参数。</td> 
  </tr> 
  <tr> 
   <td align="left"><code>select</code></td> 
   <td align="left">用于加载复杂类型属性的映射语句的 ID，它会从 column 属性指定的列中检索数据，作为参数传递给目标 select 语句。 具体请参考下面的例子。注意：在使用复合主键的时候，你可以使用 <code>column="{prop1=col1,prop2=col2}"</code> 这样的语法来指定多个传递给嵌套 Select 查询语句的列名。这会使得 <code>prop1</code> 和 <code>prop2</code> 作为参数对象，被设置为对应嵌套 Select 语句的参数。</td> 
  </tr> 
  <tr> 
   <td align="left"><code>fetchType</code></td> 
   <td align="left">可选的。有效值为 <code>lazy</code> 和 <code>eager</code>。 指定属性后，将在映射中忽略全局配置参数 <code>lazyLoadingEnabled</code>，使用属性的值。</td> 
  </tr> 
 </tbody> 
</table>

<select id="selectBlog" resultMap="blogResult">
      SELECT * FROM BLOG WHERE ID = #{id}
    </select>
    
    <resultMap id="blogResult" type="Blog">
      <association property="author" column="author_id" javaType="Author" select="selectAuthor"/>
    </resultMap>
    
    <select id="selectAuthor" resultType="Author">
      SELECT * FROM AUTHOR WHERE ID = #{id}
    </select>

我们有两个 select 查询语句：一个用来加载博客（Blog），另外一个用来加载作者（Author），而且博客的结果映射描述了应该使用 `selectAuthor` 语句加载它的 author 属性。

其它所有的属性将会被自动加载，只要它们的列名和属性名相匹配。

这种方式虽然很简单，但在大型数据集或大型数据表上表现不佳。这个问题被称为“**N+1 查询问题**”。 概括地讲，N+1 查询问题是这样子的：

*  你执行了一个单独的 SQL 语句来获取结果的一个列表（就是“+1”）。
 *  对列表返回的每条记录，你执行一个 select 查询语句来为每条记录加载详细信息（就是“N”）。

这个问题会导致成百上千的 SQL 语句被执行。有时候，我们不希望产生这样的后果。

好消息是，MyBatis 能够对这样的查询进行延迟加载，因此可以将大量语句同时运行的开销分散开来。 然而，如果你加载记录列表之后立刻就遍历列表以获取嵌套的数据，就会触发所有的延迟加载查询，性能可能会变得很糟糕。

所以还有另外一种方法。

**关联的结果嵌套查询**

<table> 
 <thead> 
  <tr> 
   <th align="left">属性</th> 
   <th align="left">描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left"><code>resultMap</code></td> 
   <td align="left">结果映射的 ID，可以将此关联的嵌套结果集映射到一个合适的对象树中。 它可以作为使用额外 select 语句的替代方案。它可以将<strong>多表连接操作的结果映射成一个单一的 <code>ResultSet</code></strong>。这样的 <code>ResultSet</code> 有部分数据是重复的。 为了将结果集正确地映射到嵌套的对象树中, MyBatis 允许你“串联”结果映射，以便解决嵌套结果集的问题。使用嵌套结果映射的一个例子在表格以后。</td> 
  </tr> 
  <tr> 
   <td align="left"><code>columnPrefix</code></td> 
   <td align="left">当连接多个表时，你可能会不得不使用列别名来避免在 <code>ResultSet</code> 中产生重复的列名。指定 columnPrefix 列名前缀允许你将带有这些前缀的列映射到一个外部的结果映射中。 详细说明请参考后面的例子。</td> 
  </tr> 
  <tr> 
   <td align="left"><code>notNullColumn</code></td> 
   <td align="left">默认情况下，在至少一个被映射到属性的列不为空时，子对象才会被创建。 你可以在这个属性上指定非空的列来改变默认行为，指定后，Mybatis 将只在这些列非空时才创建一个子对象。可以使用逗号分隔来指定多个列。默认值：未设置（unset）。</td> 
  </tr> 
  <tr> 
   <td align="left"><code>autoMapping</code></td> 
   <td align="left">如果设置这个属性，MyBatis 将会为本结果映射开启或者关闭自动映射。 这个属性会覆盖全局的属性 autoMappingBehavior。注意，本属性对外部的结果映射无效，所以不能搭配 <code>select</code> 或 <code>resultMap</code> 元素使用。默认值：未设置（unset）。</td> 
  </tr> 
 </tbody> 
</table>

<select id="selectBlog" resultMap="blogResult">
      select
        B.id            as blog_id,
        B.title         as blog_title,
        B.author_id     as blog_author_id,
        A.id            as author_id,
        A.username      as author_username,
        A.password      as author_password,
        A.email         as author_email,
        A.bio           as author_bio
      from Blog B left outer join Author A on B.author_id = A.id
      where B.id = #{id}
    </select

注意查询中的连接，以及为确保结果能够拥有唯一且清晰的名字，我们设置的别名。 这使得进行映射非常简单。现在我们可以映射这个结果：

在上面的例子中，你可以看到，博客（Blog）作者（author）的关联元素委托名为 “authorResult” 的结果映射来加载作者对象的实例。

非常重要： id 元素在嵌套结果映射中扮演着非常重要的角色。你应该总是指定一个或多个可以唯一标识结果的属性。 虽然，即使不指定这个属性，MyBatis 仍然可以工作，但是会产生严重的性能问题。 只需要指定可以唯一标识结果的最少属性。显然，你**可以选择主键**（复合主键也可以）。

现在，上面的示例使用了外部的结果映射元素来映射关联。这使得 Author 的结果映射**可以被重用**。 然而，如果你不打算重用它，或者你更喜欢将你所有的结果映射放在一个具有描述性的结果映射元素中。 你可以直接将结果映射作为**子元素**嵌套在内。这里给出使用这种方式的等效例子：

**集合**

我们来继续上面的示例，一个博客（Blog）只有一个作者（Author)。但一个博客有很多文章（Post)。

private List<Post> posts;

要像上面这样，映射嵌套结果集合到一个 List 中，可以使用集合元素。 和关联元素一样，我们可以使用嵌套 Select 查询，或基于连接的嵌套结果映射集合。

**集合的嵌套select查询**

<resultMap id="blogResult" type="Blog">
      <collection property="posts" javaType="ArrayList" column="id" ofType="Post" select="selectPostsForBlog"/>
    </resultMap>
    
    <select id="selectBlog" resultMap="blogResult">
      SELECT * FROM BLOG WHERE ID = #{id}
    </select>
    
    <select id="selectPostsForBlog" resultType="Post">
      SELECT * FROM POST WHERE BLOG_ID = #{id}
    </select>

你可能会立刻注意到几个不同，但大部分都和我们上面学习过的关联元素非常相似。 首先，你会注意到我们使用的是集合元素。 接下来你会注意到有一个新的 “ofType” 属性。这个属性非常重要，它用来将 JavaBean（或字段）属性的类型和集合存储的类型区分开来。 所以你可以按照下面这样来阅读映射:

读作： “posts 是一个存储 Post 的 ArrayList 集合”

**集合的嵌套结果查询**

<select id="selectBlog" resultMap="blogResult">
      select
      B.id as blog_id,
      B.title as blog_title,
      B.author_id as blog_author_id,
      P.id as post_id,
      P.subject as post_subject,
      P.body as post_body,
      from Blog B
      left outer join Post P on B.id = P.blog_id
      where B.id = #{id}
    </select>

#### 7.自动映射 ####

当自动映射查询结果时，MyBatis 会获取结果中**返回的列名**并在 **Java 类中查找相同名字的属性**（忽略大小写）。 这意味着如果发现了 *ID* 列和 *id* 属性，MyBatis 会将列 *ID* 的值赋给 *id* 属性。

通常数据库列使用大写字母组成的单词命名，单词间用下划线分隔；而 Java 属性一般遵循驼峰命名法约定。为了在这两种命名方式之间启用自动映射，需要将 `mapUnderscoreToCamelCase` 设置为 true。

甚至在提供了结果映射后，自动映射也能工作。在这种情况下，对于每一个结果映射，在 ResultSet 出现的列，如果没有设置手动映射，将被自动映射。在自动映射处理完毕后，再处理手动映射。 在下面的例子中，*id* 和 *userName* 列将被自动映射，*hashed\_password* 列将根据配置进行映射。

<select id="selectUsers" resultMap="userResultMap">
      select
        user_id             as "id",
        user_name           as "userName",
        hashed_password
      from some_table
      where id = #{id}
    </select>

有三种自动映射等级：

*  `NONE` \- 禁用自动映射。仅对手动映射的属性进行映射。
 *  `PARTIAL` \- 对除在内部定义了嵌套结果映射（也就是连接的属性）以外的属性进行映射
 *  `FULL` \- 自动映射所有属性。

默认值是 `PARTIAL`，这是有原因的。当对连接查询的结果使用 `FULL` 时，连接查询会在同一行中获取多个不同实体的数据，因此可能导致非预期的映射.

### 7.日志工厂 ###

如果一个 数据库相关的操作出现了问题，我们可以根据输出的SQL语句快速排查问题Mybatis内置的日志工厂提供日志功能，具体的日志实现有以下几种工具：

*  SLF4J
 *  Apache Commons Logging
 *  Log4j 2
 *  Log4j
 *  JDK logging

具体选择哪个日志实现工具由MyBatis的内置日志工厂确定。它会使用最先找到的（按上文列举的顺序查找）。如果一个都未找到，日志功能就会被禁用

**标准日志实现**

**使用Log4j实现**

**简介：**

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

1.  导包
    
        <dependency>
           <groupId>log4j</groupId>
           <artifactId>log4j</artifactId>
           <version>1.2.17</version>
        </dependency>
2.  编写配置文件
    
        #创建Log4j.properties文件
        #将等级为DEBUG的日志信息输出到console和file这两个目的地，console和file的定义在下面的代码
        log4j.rootLogger=DEBUG,console,file
        
        #控制台输出的相关设置
        log4j.appender.console = org.apache.log4j.ConsoleAppender
        log4j.appender.console.Target = System.out
        log4j.appender.console.Threshold=DEBUG
        log4j.appender.console.layout = org.apache.log4j.PatternLayout
        log4j.appender.console.layout.ConversionPattern=[%c]-%m%n
        
        #文件输出的相关设置
        log4j.appender.file = org.apache.log4j.RollingFileAppender
        log4j.appender.file.File=./log/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.  setting设置日志实现
    
        <settings>
           <setting name="logImpl" value="LOG4J"/>
        </settings>

### 8.分页 ###

在学习mybatis等持久层框架的时候，会经常对数据进行增删改查操作，使用最多的是对数据库进行查询操作，如果查询大量数据的时候，我们往往使用分页进行查询，也就是每次处理小部分数据，这样对数据库压力就在可控范围内。

**使用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.getSession();
           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();
        }

### 9.多对一的处理 ###

多对一的理解：

*  多个学生对应一个老师
 *  如果对于学生这边，就是一个多对一的现象，即从学生这边关联一个老师！

#### 1.创建数据库 ####

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

#### 2.创建实体类 ####

<dependency>
     <groupId>org.projectlombok</groupId>
     <artifactId>lombok</artifactId>
     <version>1.16.10</version>
    </dependency>

@Data //GET,SET,ToString，有参，无参构造
    public class Teacher { 
       private int id;
       private String name;
    }

@Data
    public class Student { 
       private int id;
       private String name;
       //多个学生可以是同一个老师，即多对一
       private Teacher teacher;
    }

#### 3.编写Mapper接口 ####

public interface StudentMapper { 
    }

public interface TeacherMapper { 
    }

#### 4.编写Mapper对应的xml文件 ####

#### 5.在StudentMapper中添加方法 ####

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

#### 6.编写对应的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="dao.StudentMapper">
    
       
       <select id="getStudents" resultMap="StudentTeacher">
        select * from student
       </select>
       <resultMap id="StudentTeacher" type="Student">
           
           <association property="teacher" column="tid" javaType="Teacher" select="getTeacher"/>
       </resultMap>
       
       <select id="getTeacher" resultType="teacher">
          select * from teacher where id = #{id}
       </select>
    
    </mapper>

#### 7.去核心配置文件注册Mapper文件 ####

#### 8.测试 ####

@Test
    public void testGetStudents(){ 
       SqlSession session = MybatisUtils.getSession();
       StudentMapper mapper = session.getMapper(StudentMapper.class);
    
       List<Student> students = mapper.getStudents();
    
       for (Student student : students){ 
           System.out.println(
                   "学生名:"+ student.getName()
                           +"\t老师:"+student.getTeacher().getName());
      }
    }

#### 方法二：结果嵌套查询 ####

**相当于数据库的联表查询**

<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"/>
       
       <association property="teacher" javaType="Teacher">
           <result property="name" column="tname"/>
       </association>
    </resultMap>

### 10.一对多的处理 ###

一对多的理解：

*  一个老师拥有多个学生
 *  如果对于老师这边，就是一个一对多的现象，即从一个老师下面拥有一群学生（集合）

#### 1.创建实体类 ####

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

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

#### 2.按照结果嵌套查询 ####

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

<mapper namespace="dao.TeacherMapper">
    
       
       <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>

@Test
    public void testGetTeacher(){ 
       SqlSession session = MybatisUtils.getSession();
       TeacherMapper mapper = session.getMapper(TeacherMapper.class);
       Teacher teacher = mapper.getTeacher(1);
       System.out.println(teacher.getName());
       System.out.println(teacher.getStudents());
    }

### 11.动态sql ###

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

动态 SQL 是 MyBatis 的强大特性之一。如果你使用过 JDBC 或其它类似的框架，你应该能理解根据不同条件拼接 SQL 语句有多痛苦，例如拼接时要确保不能忘记添加必要的空格，还要注意去掉列表最后一个列名的逗号。利用动态 SQL，可以彻底摆脱这种痛苦。

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

#### if ####

<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 语句，解决方法如下：

<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 开头的，则它会剔除掉.

#### choose ####

有时候，我们不想使用所有的条件，而只是想从多个条件中选择一个使用。针对这种情况，MyBatis 提供了 choose 元素，它有点像 Java 中的 switch 语句。

<select id="findActiveBlogLike" resultType="Blog">  SELECT * FROM BLOG WHERE state = ‘ACTIVE’  <choose>    <when test="title != null">      AND title like #{title}    </when>    <when test="author != null and author.name != null">      AND author_name like #{author.name}    </when>    <otherwise>      AND featured = 1    </otherwise>  </choose></select>

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

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

#### foreach ####

需求：我们需要查询 blog 表中 id 分别为1,2,3的博客信息

<select id="queryBlogForeach" parameterType="map" resultType="blog">  select * from blog   <where>              <foreach collection="ids" item="id" open="and (" close=")" separator="or">          id=#{id}       </foreach>   </where></select>

### 12.缓存 ###

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

#### 一级缓存 ####

一级缓存也叫本地缓存：

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

测试：

//根据id查询用户User queryUserById(@Param("id") int id);

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

@Testpublic void testQueryUserById(){    SqlSession session = MybatisUtils.getSession();   UserMapper mapper = session.getMapper(UserMapper.class);   User user = mapper.queryUserById(1);   System.out.println(user);   User user2 = mapper.queryUserById(1);   System.out.println(user2);   System.out.println(user==user2);   session.close();}

![image-20210927161219510][]

**一级缓存失效的四种情况**

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

一级缓存失效情况：没有使用到当前的一级缓存，效果就是，还需要再向数据库中发起一次查询请求！

1、sqlSession不同

@Testpublic void testQueryUserById(){    SqlSession session = MybatisUtils.getSession();   SqlSession session2 = MybatisUtils.getSession();   UserMapper mapper = session.getMapper(UserMapper.class);   UserMapper mapper2 = session2.getMapper(UserMapper.class);   User user = mapper.queryUserById(1);   System.out.println(user);   User user2 = mapper2.queryUserById(1);   System.out.println(user2);   System.out.println(user==user2);   session.close();   session2.close();}

观察结果：发现发送了两条SQL语句！

结论：**每个sqlSession中的缓存相互独立**

2、sqlSession相同，查询条件不同

@Testpublic void testQueryUserById(){    SqlSession session = MybatisUtils.getSession();   UserMapper mapper = session.getMapper(UserMapper.class);   UserMapper mapper2 = session.getMapper(UserMapper.class);   User user = mapper.queryUserById(1);   System.out.println(user);   User user2 = mapper2.queryUserById(2);   System.out.println(user2);   System.out.println(user==user2);   session.close();}

观察结果：发现发送了两条SQL语句！很正常的理解

结论：**当前缓存中，不存在这个数据**

3、sqlSession相同，两次查询之间执行了增删改操作！

增加方法

//修改用户int updateUser(Map map);

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

@Testpublic void testQueryUserById(){    SqlSession session = MybatisUtils.getSession();   UserMapper mapper = session.getMapper(UserMapper.class);   User user = mapper.queryUserById(1);   System.out.println(user);   HashMap map = new HashMap();   map.put("name","kuangshen");   map.put("id",4);   mapper.updateUser(map);   User user2 = mapper.queryUserById(1);   System.out.println(user2);   System.out.println(user==user2);   session.close();}

观察结果：查询在中间执行了增删改操作后，重新执行了

结论：**因为增删改操作可能会对当前数据产生影响**

4、sqlSession相同，手动清除一级缓存

@Testpublic void testQueryUserById(){    SqlSession session = MybatisUtils.getSession();   UserMapper mapper = session.getMapper(UserMapper.class);   User user = mapper.queryUserById(1);   System.out.println(user);   session.clearCache();//手动清除缓存 User user2 = mapper.queryUserById(1); System.out.println(user2); System.out.println(user==user2); session.close();}

一级缓存就是一个map

#### 二级缓存 ####

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

使用步骤：

1、开启全局缓存 【mybatis-config.xml】

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

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

3.测试

@Testpublic void testQueryUserById(){    SqlSession session = MybatisUtils.getSession();   SqlSession session2 = MybatisUtils.getSession();   UserMapper mapper = session.getMapper(UserMapper.class);   UserMapper mapper2 = session2.getMapper(UserMapper.class);   User user = mapper.queryUserById(1);   System.out.println(user);   session.close();   User user2 = mapper2.queryUserById(1);   System.out.println(user2);   System.out.println(user==user2);   session2.close();}

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

[image-20210915203006815]: /images/20220828/ee46dea552d54a108729da61bd6f55dc.png
[image-20210920173246350]: /images/20220828/f2e6ca0fbf3247ee9b87c47d3734343a.png
[image-20210920164727474]: https://i.loli.net/2021/09/28/uYxNlOsG9E32BIA.png
[image-20210927161219510]: https://i.loli.net/2021/09/27/SMwCBtjeDmIW58r.png