MyBatis基础

MyBatis基础

1 简介

1.1 什么是 MyBatis？

• MyBatis 是一款优秀的持久层框架

• 它支持自定义 SQL、存储过程以及高级映射

• MyBatis 免除了几乎所有的 JDBC 代码以及设置参数和获取结果集的工作

• MyBatis 可以通过简单的 XML 或注解来配置和映射原始类型、接口和 Java POJO（Plain Old Java Objects，普通老式 Java 对象）为数据库中的记录

• MyBatis 本是apache的一个开源项目iBatis, 2010年这个项目由apache software foundation 迁移到了google code，并且改名为MyBatis

• 2013年11月迁移到Github

1.2 持久层（Dao）

数据持久化

• 持久化就是将程序的数据在瞬时状态到持久状态转换的过程
• 内存：断电即失

持久层

• 完成持久化工作的代码
• 层界限明显

1.3 MyBatis优点

• 简单易学。灵活

• sql和代码的分离，提高了可维护性。

• 提供映射标签，支持对象与数据库的orm字段关系映射

• 提供对象关系映射标签，支持对象关系组建维护

• 提供xml标签，支持编写动态sql。

2 入门

2.1 安装使用

• 要使用 MyBatis， 只需将 mybatis-x.x.x.jar 文件置于类路径（classpath）中即可。
• 如果使用 Maven 来构建项目，则需将下面的依赖代码置于 pom.xml 文件中：

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

• 在resources目录下创建mybatis-config.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">   <!-- 也有test环境 -->
    <environment id="development">
      <transactionManager type="JDBC"/>  <!-- 事务管理 -->
      <dataSource type="POOLED">         <!-- [UNPOOLED|POOLED|JNDI]" -->
        <property name="driver" value="${driver}"/>
        <property name="url" value="${url}"/>   <!-- &amp &转义 -->
        <property name="username" value="${username}"/>
        <property name="password" value="${password}"/>
      </dataSource>
    </environment>
  </environments>
    <!-- 每个Mapper.xml都需要在这个核心配置文件里面注册-->
  <mappers>
    
  </mappers>
</configuration>

• 编写MyBatis工具类

  public class MyBatisUtils{
      private static SqlSessionFactory sqlSessionFactory;
      static{
          InputStream inputStream =null;
          try{
              //读取mybatis-config.xml文件
              inputStream = Resources.getResourceAsStream("mybatis-config.xml");
              //创建SqlSessionFactoryBuilder对象
              SqlSessionFactoryBuilder sqlSessionFactoryBuilder=new SqlSessionFactoryBuilder();
              //通过sqlSessionFactoryBuilder对象创建SqlSessionFactory
              sqlSessionFactory=sqlSessionFactoryBuilder.build(inputStream);
          } catch(IOException e){
              e.printStackTrace();
          }finally {
              try {
                  inputStream.close();
              } catch (IOException e) {
                  e.printStackTrace();
              }
          }
      }
      
      //使用sqlSessionFactory获得sqlSession的实例
      //sqlSession完全包含了面向数据库执行SQL语句的所有方法
      public static SqlSession getSqlSession(){
          return sqlSessionFactory.openSession();
      }
  }
  

• 创建pojo实体类和Dao接口

  • 每个Dao/Mapper对应一个xxxMapper.xml(通过namespace绑定)

  • xxxMapper.xml代替了java web中的xxxDaoImpL.java（通过id绑定方法）

  • xxxMapper.xml的方法

    

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

2.2 可以能会遇到的问题

1. 配置文件没有注册

   在mybatis-config.xml的中注册

2. 绑定接口错误

3. 方法名不对

4. 返回类型不对

5. Maven导出资源问题

   方法一：将xml文件存放在resources目录下

   方法二：

   <!-- 在buiLd中配置resources，来防止我们资源导出失败的问题-->
   <build>
   	<resources>
           <resource>
               <directory>src/main/resources</directory>
               <includes>
               	<include>**/*.properties</include>
                   <include>**/*.xml</include>
               </includes>
               <filtering>false</filtering>
            </resource>
            <resource>
               <directory>src/main/java</directory>
               <includes>
               	<include>**/*.properties</include>
                   <include>**.xml</include>
               </includes>
                <filtering>false</filtering>
           </resource>
       </resources>
   </build>
   

2.3 从 SqlSessionFactory 中获取 SqlSession

• 方法一(不推荐)

SqlSession 提供了在数据库执行 SQL 命令所需的所有方法。你可以通过 SqlSession 实例来直接执行已映射的 SQL 语句。

try (SqlSession session = sqlSessionFactory.openSession()) {
  Blog blog = (Blog) session.selectOne("org.mybatis.example.BlogMapper.selectBlog", 101);
}

• 方法二

使用和指定语句的参数和返回值相匹配的接口（比如 BlogMapper.class），不仅更清晰，更加类型安全，还不用担心可能出错的字符串字面值以及强制类型转换。

try (SqlSession session = sqlSessionFactory.openSession()) {
  BlogMapper mapper = session.getMapper(BlogMapper.class);
  Blog blog = mapper.selectBlog(101);
}

2.4 作用域和生命周期

SqlSessionFactoryBuilder

这个类可以被实例化、使用和丢弃，一旦创建了 SqlSessionFactory，就不再需要它了。 因此 SqlSessionFactoryBuilder 实例的最佳作用域是方法作用域（也就是局部方法变量）。 你可以重用 SqlSessionFactoryBuilder 来创建多个 SqlSessionFactory 实例，但最好还是不要一直保留着它，以保证所有的 XML 解析资源可以被释放给更重要的事情。

SqlSessionFactory(类比数据库连接池)

SqlSessionFactory 一旦被创建就应该在应用的运行期间一直存在，没有任何理由丢弃它或重新创建另一个实例。 使用 SqlSessionFactory 的最佳实践是在应用运行期间不要重复创建多次，多次重建 SqlSessionFactory 被视为一种代码“坏习惯”。因此 SqlSessionFactory 的最佳作用域是应用作用域。 有很多方法可以做到，最简单的就是使用单例模式或者静态单例模式。

SqlSession

每个线程都应该有它自己的 SqlSession 实例。SqlSession 的实例不是线程安全的，因此是不能被共享的，所以它的最佳的作用域是请求或方法作用域。 绝对不能将 SqlSession 实例的引用放在一个类的静态域，甚至一个类的实例变量也不行。 也绝不能将 SqlSession 实例的引用放在任何类型的托管作用域中，比如 Servlet 框架中的 HttpSession。 如果你现在正在使用一种 Web 框架，考虑将 SqlSession 放在一个和 HTTP 请求相似的作用域中。 换句话说，每次收到 HTTP 请求，就可以打开一个 SqlSession，返回一个响应后，就关闭它。 这个关闭操作很重要，为了确保每次都能执行关闭操作，你应该把这个关闭操作放到 finally 块中。

try (SqlSession session = sqlSessionFactory.openSession()) {
  // 你的应用逻辑代码
} finally {
	session.close();
}

3 CRUD

3.1 属性和描述

属性	描述
id	在命名空间中唯一的标识符，可以被用来引用这条语句。
parameterType	将会传入这条语句的参数的类全限定名或别名。这个属性是可选的，因为 MyBatis 可以通过类型处理器（TypeHandler）推断出具体传入语句的参数，默认值为未设置（unset）。
parameterMap	用于引用外部 parameterMap 的属性，目前已被废弃。请使用行内参数映射和 parameterType 属性。
resultType	期望从这条语句中返回结果的类全限定名或别名。 注意，如果返回的是集合，那应该设置为集合包含的类型，而不是集合本身的类型。 resultType 和 resultMap 之间只能同时使用一个。
resultMap	对外部 resultMap 的命名引用。结果映射是 MyBatis 最强大的特性，如果你对其理解透彻，许多复杂的映射问题都能迎刃而解。 resultType 和 resultMap 之间只能同时使用一个。
flushCache	将其设置为 true 后，只要语句被调用，都会导致本地缓存和二级缓存被清空，默认值：false。
useCache	将其设置为 true 后，将会导致本条语句的结果被二级缓存缓存起来，默认值：对 select 元素为 true。
timeout	这个设置是在抛出异常之前，驱动程序等待数据库返回请求结果的秒数。默认值为未设置（unset）（依赖数据库驱动）。
fetchSize	这是一个给驱动的建议值，尝试让驱动程序每次批量返回的结果行数等于这个设置值。 默认值为未设置（unset）（依赖驱动）。
statementType	可选 STATEMENT，PREPARED 或 CALLABLE。这会让 MyBatis 分别使用 Statement，PreparedStatement 或 CallableStatement，默认值：PREPARED。
resultSetType	FORWARD_ONLY，SCROLL_SENSITIVE, SCROLL_INSENSITIVE 或 DEFAULT（等价于 unset） 中的一个，默认值为 unset （依赖数据库驱动）。
databaseId	如果配置了数据库厂商标识（databaseIdProvider），MyBatis 会加载所有不带 databaseId 或匹配当前 databaseId 的语句；如果带和不带的语句都有，则不带的会被忽略。
resultOrdered	这个设置仅针对嵌套结果 select 语句：如果为 true，将会假设包含了嵌套结果集或是分组，当返回一个主结果行时，就不会产生对前面结果集的引用。 这就使得在获取嵌套结果集的时候不至于内存不够用。默认值：false。
resultSets	这个设置仅适用于多结果集的情况。它将列出语句执行后返回的结果集并赋予每个结果集一个名称，多个名称之间以逗号分隔。

3.2 使用

1. 编写接口

   //UserDao/UserMapper
   User getUserById(int id);
   

2. 编写对应的Mapper.xml中的sql语句

   <mapper namespace="com.mapper.UserMapper">
       <select id="selectPerson" parameterType="int" resultType="User">
       	SELECT * FROM user WHERE ID = #{id}
       </select>
   </mapper>
   

3. 调用方法

   public void getUserById(){
       Sqlsession sqlSession = MyBatisUtils.getSqlSession;
       
       UserMapper mapper = sq1Session. getMapper(UserMapper.class);
       User user = mapper.getUserById(1);
       system.out.print1n(user);
   
   	sqlSession.commit();
       sqlSession.close();
   
   }
   

3.3 selsct

<select id="selectPerson" parameterType="int" resultType="hashmap">
  SELECT * FROM PERSON WHERE ID = #{id}
</select>

分页

• 使用Limit实现分页

  select * from user limit 0,n; 
  

• 使用MyBatis实现分页查询(核心还是Limit)

  1. 接口

     List<User> getUserByLimit(Map<String,Integer>);
     

  2. Mapper.xml

     <!--分页-->
     <select id="getuserByLimit" parameterType="map" resu1tMap="usersap">
     	select * from mybatis.user limit #{startindex},#ipagesize}
     </select>
     

  3. 测试

     @Test
     public void getuserByLimit(){
         Sq1session sqlSession = MyBatisUtils.getSq1Session();
         UserMapper mapper = sqlSession. getMapper(UserMapper.c1ass);
         HashMap<String,Integer> map = new HashMap<String,Integer>();
         map.put("startIndex",1);
         map.put("pageSize",2);
         List<User> userList =mapper. getuserByLimit(map);
         for (User user:userList){
         	system.out.print1n(user);
         }
         sqlSession.c1ose();
     }
     

3.4 insert

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

<!-- 多行插入 传入一个 Author 数组或集合，并返回自动生成的主键-->
<insert id="insertAuthor" useGeneratedKeys="true"
    keyProperty="id">
  insert into Author (username, password, email, bio) values
  <foreach item="item" collection="list" separator=",">
    (#{item.username}, #{item.password}, #{item.email}, #{item.bio})
  </foreach>
</insert>

3.5 update

<update id="updateAuthor">
  update Author set
    username = #{username},
    password = #{password},
    email = #{email},
    bio = #{bio}
  where id = #{id}
</update>

3.6 delete

<delete id="deleteAuthor">
  delete from Author where id = #{id}
</delete>

3.7 sql片段

使用标签存放公共的sql语句，在需要的地方通过i标签引用

<sql id="select-blog">
	seccet * from blog
    <!--抽取时不要有<where>、<set>-->
</sql>
<select>
	<include refid="select-blog"></include>
</select>

3.8 万能的Map(野路子)

当实体类或数据库表中,字段、参数过多时,我们可以考虑使用Map

<!--对象中的属性，可以直接取出来传递map的key-->
<insert id="addUser" parameterType="map ">
	insert into mybatis.user (id，pwd) values (#{userid} ,#{password});
</insert>

@Test
public void addUser({
    sq1Session sq1Session = MyBatisUtils.getSqlSession(;
    UserMapper mapper = sqlSession. getMapper(UserMapper.c1ass);
    Map<String，object> map = new HashMap<String，object>();
    map.put("userid" , 5);
    map. put("password" , "2222333");
    mapper.addUser(map);
    sqlSession.close();
}

Map传递参数，直接在sql中取出key即可!【parameterType=“map”】

对象传递参数，直接在sql中取对象的属性即可! 【parameterType=“Object”】

3.9 注意点

• 增删改必须提交事务
• 标签和sql语句不要匹配错
• resource 绑定mapper，需要使用路径!
• 程序配置文件必须符合规范!
• NullPointerException，没有注册到资源!
• maven资源没有导出问题!

4 xml配置解析

4.1 核心配置文件

配置文档的顶层结构如下：

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

4.2 环境配置（environments）

MyBatis 可以配置成适应多种环境

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

MyBatis默认的事务管理器就是JDBC，连接池: POOLED

4.3 属性（properties）

配置属性必须按照顺序：

我们可以使用properties属性来实现引用外部配置

1. 编写一个数据库配置文件db.properties

   driver=com.mysql.cj.jdbc.Driver
   url=jdbc:mysql://localhost:3306/mybatis?useSSL=true?useUnicode=true&charaterEncodeing=UTF-8
   username=root
   password=123456
   

2. 在核心配置文件中引入外部db.properties

   <properties resource="db.properties">
       <property name="username"/ value="root">
       <property name="pwd"/ value="111111"/>
   </properties>
   

   • 可以直接引入外部文件
   • 可以在其中增加一些属性配置

3. 优先级

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

4.4 类型别名（typeAliases）

• 类型别名是为Java类型设置一个短的名字。

• 存在的意义仅在于用来减少类完全限定名的冗余。

1. 使用可以给一个类取别名

   <!--可以给实体类起别名-->
   <typeAliases>
   	<typeAlias type="com.pojo.User" alias="User"/>
   </typeAliases>
   

2. 使用可以给一个包下所有类取别名,每个类的默认别名是这个类的类名首字母小写

   <!--可以给实体类的包起别名-->
   <typeAliases>
   	<package name="com.pojo"/>
   </typeAliases>
   

4.5 设置（settings）

设置名	描述	有效值	默认值
cacheEnabled	全局性地开启或关闭所有映射器配置文件中已配置的任何缓存。	true | false	true
lazyLoadingEnabled	延迟加载的全局开关。当开启时，所有关联对象都会延迟加载。 特定关联关系中可通过设置 fetchType 属性来覆盖该项的开关状态。	true | false	false
aggressiveLazyLoading	开启时，任一方法的调用都会加载该对象的所有延迟加载属性。 否则，每个延迟加载属性会按需加载（参考 lazyLoadTriggerMethods)。	true | false	false （在 3.4.1 及之前的版本中默认为 true）
multipleResultSetsEnabled	是否允许单个语句返回多结果集（需要数据库驱动支持）。	true | false	true
useColumnLabel	使用列标签代替列名。实际表现依赖于数据库驱动，具体可参考数据库驱动的相关文档，或通过对比测试来观察。	true | false	true
useGeneratedKeys	允许 JDBC 支持自动生成主键，需要数据库驱动支持。如果设置为 true，将强制使用自动生成主键。尽管一些数据库驱动不支持此特性，但仍可正常工作（如 Derby）。	true | false	False
autoMappingBehavior	指定 MyBatis 应如何自动映射列到字段或属性。 NONE 表示关闭自动映射；PARTIAL 只会自动映射没有定义嵌套结果映射的字段。 FULL 会自动映射任何复杂的结果集（无论是否嵌套）。	NONE, PARTIAL, FULL	PARTIAL
autoMappingUnknownColumnBehavior	指定发现自动映射目标未知列（或未知属性类型）的行为。NONE: 不做任何反应WARNING: 输出警告日志（'org.apache.ibatis.session.AutoMappingUnknownColumnBehavior' 的日志等级必须设置为 WARN）FAILING: 映射失败 (抛出 SqlSessionException)	NONE, WARNING, FAILING	NONE
defaultExecutorType	配置默认的执行器。SIMPLE 就是普通的执行器；REUSE 执行器会重用预处理语句（PreparedStatement）； BATCH 执行器不仅重用语句还会执行批量更新。	SIMPLE REUSE BATCH	SIMPLE
defaultStatementTimeout	设置超时时间，它决定数据库驱动等待数据库响应的秒数。	任意正整数	未设置 (null)
defaultFetchSize	为驱动的结果集获取数量（fetchSize）设置一个建议值。此参数只可以在查询设置中被覆盖。	任意正整数	未设置 (null)
defaultResultSetType	指定语句默认的滚动策略。（新增于 3.5.2）	FORWARD_ONLY | SCROLL_SENSITIVE | SCROLL_INSENSITIVE | DEFAULT（等同于未设置）	未设置 (null)
safeRowBoundsEnabled	是否允许在嵌套语句中使用分页（RowBounds）。如果允许使用则设置为 false。	true | false	False
safeResultHandlerEnabled	是否允许在嵌套语句中使用结果处理器（ResultHandler）。如果允许使用则设置为 false。	true | false	True
mapUnderscoreToCamelCase	是否开启驼峰命名自动映射，即从经典数据库列名 A_COLUMN 映射到经典 Java 属性名 aColumn。	true | false	False
localCacheScope	MyBatis 利用本地缓存机制（Local Cache）防止循环引用和加速重复的嵌套查询。 默认值为 SESSION，会缓存一个会话中执行的所有查询。 若设置值为 STATEMENT，本地缓存将仅用于执行语句，对相同 SqlSession 的不同查询将不会进行缓存。	SESSION | STATEMENT	SESSION
jdbcTypeForNull	当没有为参数指定特定的 JDBC 类型时，空值的默认 JDBC 类型。 某些数据库驱动需要指定列的 JDBC 类型，多数情况直接用一般类型即可，比如 NULL、VARCHAR 或 OTHER。	JdbcType 常量，常用值：NULL、VARCHAR 或 OTHER。	OTHER
lazyLoadTriggerMethods	指定对象的哪些方法触发一次延迟加载。	用逗号分隔的方法列表。	equals,clone,hashCode,toString
defaultScriptingLanguage	指定动态 SQL 生成使用的默认脚本语言。	一个类型别名或全限定类名。	org.apache.ibatis.scripting.xmltags.XMLLanguageDriver
defaultEnumTypeHandler	指定 Enum 使用的默认 TypeHandler 。（新增于 3.4.5）	一个类型别名或全限定类名。	org.apache.ibatis.type.EnumTypeHandler
callSettersOnNulls	指定当结果集中值为 null 的时候是否调用映射对象的 setter（map 对象时为 put）方法，这在依赖于 Map.keySet() 或 null 值进行初始化时比较有用。注意基本类型（int、boolean 等）是不能设置成 null 的。	true | false	false
returnInstanceForEmptyRow	当返回行的所有列都是空时，MyBatis默认返回 null。 当开启这个设置时，MyBatis会返回一个空实例。 请注意，它也适用于嵌套的结果集（如集合或关联）。（新增于 3.4.2）	true | false	false
logPrefix	指定 MyBatis 增加到日志名称的前缀。	任何字符串	未设置
logImpl	指定 MyBatis 所用日志的具体实现，未指定时将自动查找。	SLF4J | LOG4J(deprecated since 3.5.9) | LOG4J2 | JDK_LOGGING | COMMONS_LOGGING | STDOUT_LOGGING | NO_LOGGING	未设置
proxyFactory	指定 MyBatis 创建可延迟加载对象所用到的代理工具。	CGLIB | JAVASSIST	JAVASSIST （MyBatis 3.3 以上）
vfsImpl	指定 VFS 的实现	自定义 VFS 的实现的类全限定名，以逗号分隔。	未设置
useActualParamName	允许使用方法签名中的名称作为语句参数名称。 为了使用该特性，你的项目必须采用 Java 8 编译，并且加上 -parameters 选项。（新增于 3.4.1）	true | false	true
configurationFactory	指定一个提供 Configuration 实例的类。 这个被返回的 Configuration 实例用来加载被反序列化对象的延迟加载属性值。 这个类必须包含一个签名为static Configuration getConfiguration() 的方法。（新增于 3.2.3）	一个类型别名或完全限定类名。	未设置
shrinkWhitespacesInSql	从SQL中删除多余的空格字符。请注意，这也会影响SQL中的文字字符串。 (新增于 3.5.5)	true | false	false
defaultSqlProviderType	Specifies an sql provider class that holds provider method (Since 3.5.6). This class apply to the type(or value) attribute on sql provider annotation(e.g. @SelectProvider), when these attribute was omitted.	A type alias or fully qualified class name	Not set
nullableOnForEach	Specifies the default value of ‘nullable’ attribute on ‘foreach’ tag. (Since 3.5.9)	true | false	false

4.6 映射器（mappers）

注册Mapper文件

1. 方法一: 使用resource绑定注册

   <!--每一个Mapper.xml都需要在MyBatis核心配置文件中注册! -->
   <mappers>
   	<mapper resource="com/dao/userMapper.xml"/>
   </mappers>
   

2. 方法二: 使用class绑定注册

   <!--每一个Mapper.xml都需要在MyBatis核心配置文件中注册! -->
   <mappers>
   	<mapper class="com.dao.userMapper"/>
   </mappers>
   

   注意点:

   • 接口和他的Mapper配置文件必须同名!
   • 接口和他的Mapper配置文件必须在同一个包下!

3. 方法三: 使用name绑定注册

   <!--每一个Mapper.xml都需要在MyBatis核心配置文件中注册! -->
   <mappers>
   	<package name="com.dao"/>
   </mappers>
   

   注意点:

   • 接口和他的Mapper配置文件必须同名!
   • 接口和他的Mapper配置文件必须在同一个包下!

4.7 其他配置(了解)

• typeHandlers (类型处理器)
• objectFactory_(对象工厂)_
• plugins插件
  • mybatis-generator-core
  • mybatis-plus
  • 通用mapper

5 结果集映射(resultMap)

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

当JavaBeen的属性名和数据库的字段名不一致时,查询结果为null

JavaBean	数据库
id	id
name	name
password	pwd

原因:

// select * from com.pojo.User where id = #{id}

// 经过MyBatis类型处理器处理之后 ↓↓

// select id,name,pwd from com.pojo.User where id = #{id}

解决:

<!--结果集映射-->
<resultMap id="UserMap" type="user">
<!--column数据库中的字段，property实体类中的属性-->
    <result column="id" property="id" />
	<result column="name" property="name"/>
    <result column="pwd" property="password "/>
</resu7tMap>

<select id="getuserById" resultMap="userMap">
	select * from mybatis.user where id = #{id}
</select>

如果这个世界总是这么简单就好了。

5.2 复杂语句结果映射

• resultMap元素是MyBatis中最重要最强大的元素
• ResultMap的设计思想是，对于简单的语句根本不需要配置显式的结果映射，而对于复杂一点的语句只需要描述它们的关系就行了

6 日志

6.1 日志工厂

当一个失去了语句出现错误时,我们希望可以打印出sql语句方便排错,此时可以使用日志

STDOUT_LOGGING

<settings>
	<!--标准的日志工厂实现-->
	<setting name="logImpl " value="STDOUT_LOGGING"/> 
</settings>

日志输出

Opening JDBC Connection
Created connection 832279283.
Setting autocommit to false on JDBC Connection [com.mysq1.jdbc.JDBC4Connection@319b92f3]
==>Preparing: select * from mybatis.user where id = ?
==> Parameters: 1(Integer)
<==   columns : id, name, pwd
<==        Row: 1，root,123456
<==      Total: 1
User{id=1, name='root', password='123456'}
Resetting autocommit to true on JDBC Connection [ com.mysq1.jdbc..DBC4Connection@319b92f3]
Closing JDBc Connection [com.mysql.jdbc.JDBC4Connection@319b92f3]
Returned connection 832279283 to poo1.

LOG4J

1. 什么是log4j

   • Log4j是Apache的一个开源项目，通过使用Log4j我们可以控制日志信息输送的目的地是控制台、文件、GUI组件

   • 我们也可以控制每一条日志的输出格式

   • 通过定义每一条日志信息的级别，我们能够更加细致地控制日志的生成过程

   • 通过一个配置文件来灵活地进行配置，而不需要修改应用的代码

2. 使用

   1. 导入log4j的jar包

      <!-- https://mvnrepository.com/artifact/log4j/log4j -->
      <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/log4j.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. log4j使用

      <settings>
      	<!--标准的日志工厂实现-->
      	<setting name="logImpl" value="LOG4J"/> 
      </settings>
      

      static Logger logger = Logger.getLogger(xxx.class);
      
      logger.info("");
      logger.debug("");
      logger.error("");
      

      日志输出

      [org.apache.ibatis.logging.LogFactory]-Logging initialized using 'class org.apache.ibatis.logging.log4j.Log4jImpl' adapter.
      [org.apache.ibatis.logging.LogFactory]-Logging initialized using 'class org.apache.ibatis.logging.log4j.Log4jImpl' adapter.
      [org.apache.ibatis.datasource.pooled.PooledDataSource]-PooledDataSource forcefully closed/removed all connections.
      [org.apache.ibatis.datasource.pooled.PooledDataSource]-PooledDataSource forcefully closed/removed all connections.
      [org.apache.ibatis.datasource.pooled.PooledDataSource]-PooledDataSource forcefully closed/removed all connections.
      [org.apache.ibatis.datasource.pooled.PooledDataSource]-PooledDataSource forcefully closed/removed all connections.
      [org.apache.ibatis.transaction.jdbc.JdbcTransaction]-Opening JDBC Connection
      [org.apache.ibatis.datasource.pooled.PooledDataSource]-Created connection 411506101.
      [org.apache.ibatis.transaction.jdbc.JdbcTransaction]-Setting autocommit to false on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@188715b5]
      [com.mapper.UserMapper.getUsers]-==>  Preparing: select * from test.user
      [com.mapper.UserMapper.getUsers]-==> Parameters: 
      [com.mapper.UserMapper.getUsers]-<==      Total: 1
      User(id=1, name=test, pwd=123456)
      [org.apache.ibatis.transaction.jdbc.JdbcTransaction]-Resetting autocommit to true on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@188715b5]
      [org.apache.ibatis.transaction.jdbc.JdbcTransaction]-Closing JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@188715b5]
      [org.apache.ibatis.datasource.pooled.PooledDataSource]-Returned connection 411506101 to pool.
      

7 使用注解开发

7.1 面向接口编程

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

​ 在一个面向对象的系统中，系统的各种功能是由许许多多的不同对象协作完成的。在这种情况下．各个对象内部是如何实现自己的.对系统设计人员来讲就不那么重要了;而各个对象之间的协作关系则成为系统设计的关键。小到不同类之间的通信，大到各模块之间的交互，在系统设计之初都是要着重考虑的，这也是系统设计的主要工作内容。面向接口编程就是指按照这种思想来编程。

原因

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

关于接口的理解

• 接口从更深层次的理解，应是定义（规范，约束）与实现(名实分离的原则)的分离
• 接口的本身反映了系统设计人员对系统的抽象理解
• 接口应有两类:
  • 第一类是对一个个体的抽象，它可对应为一个抽象体(abstract class)
  • 第二类是对一个个体某一方面的抽象，即形成一个抽象面: (interface)
  • 一个体有可能有多个抽象面。抽象体与抽象面是有区别的。

三个面向区别

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

7.2 使用注解开发

1. 注解在接口上实现

   @select("select * from user")
   List<User> getUser();
   

2. 需要在核心配置文件中绑定接口

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

3. 原理

   • 本质: 反射机制实现
   • 底层: 动态代理

关于@Param()注解

• 基本类型的参数或者String类型，需要加上
• 引用类型不需要加
• 如果只有一个基本类型的话，可以忽略，但是建议大家都加上!
• 我们在SQL中引用的就是我们这里的@Param()中设定的属性名!

8 复杂对应关系的处理

多个学生，对应一个老师

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

8.1 多对一

JavaBean

Student	Teacher
int id	int id
String name	String name
Teacher teacher

数据库

Student	Teacher
int id	int id
varchar name	varchar name
int tid

按照查询嵌套处理

<select id="getStudent" resultMap="StudentAndTeacher">
	select * from student
</select>
<select id="getTeacher" resultMap="Teacher">
	select * from teacher where id = #{id}
</select>

<!-- 复杂的属性需要单独处理,对象使用association;集合使用collection-->
<resultMap id="StudentAndTeacher" type="Student">
	<association property="teacher" column="tid" javaType="Teacher" select="getTeacher"/>
</resultMap>

按照结果嵌套处理

<select id="getstudent" resu1tMap="studentTeacher">
    select s.id sid,s.name sname , t.name tname
    from student s,teacher t
    where s.tid = t.id;
</select>
<resultMap id="studentTeacher" type="student">
    <result property="id" column="sid"/>
    <result property="name" column="sname"/>
    <association property="teacher" javaType="Teacher">
    	<result property="name" column="tname"/>
    </association>
</resultMap>

8.2 一对多

JavaBean

Student	Teacher
int id	int id
String name	String name
int tid	Liststudents

数据库

Student	Teacher
int id	int id
varchar name	varchar name
int tid

按照查询嵌套处理

<select id="getStudent" resultMap="StudentAndTeacher">
	select * from teacher where id = #{tid}
</select>
<select id="getStudentByTeacherId" resultMap="Student">
	select * from student where tid = #{tid}
</select>

<!-- 复杂的属性需要单独处理,对象使用association;集合使用collection-->
<resultMap id="StudentAndTeacher" type="Teacher">
	<collection property="students" column="id" javaType="List" ofType="Student" select="getStudentByTeacherId"/>
</resultMap>

按照结果嵌套处理

< !--按结果嵌套查询-->
<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 = #{tid}
</select>
<resultMap id="TeacherStudent" type="Teacher">
    <result property="id" column="tid" />
    <result property="name" column="tname" />
    <!--复杂的属性需要单独处理,对象使用association;集合使用collection
	javaType="”指定属性的类型!
    集合中的泛型信息，我们使用ofType获取-->
    <collection property="students" ofType="Student">
        <result property="id" column="sid" />
        <result property="name" column="sname" />
        <result property="tid" column="tid" />
    </collection>
</resultMap>

8.3 小结

1. • 集合 [多对一]
   • 关联 [一对多]
2. • javaType [指定Java类型]
   • ofType [指定范型类型]

9 动态sql

什么是动态SQL:动态SQL就是指根据不同的条件生成不同的SQL语句

利用动态SQL这一特性可以彻底摆脱拼接sql语句的痛苦。

MyBatis的动态sql其实质还是sql语句拼接，只是我们可以在sql层面去执行一个逻辑代码，而不是在Java层面

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

9.1 动态sql之if

<select id="queryB1ogIF" parameterType="map" resultType="blog">
    select * from mybatis.blog where 1=1
        <if test="title!= null">   <!--当title不为null时拼接查询条件-->
            and title = #{title}
        </if>
        <if test="author != nu11">
            and author =#{author}
        </if>
</select>

9.2 choose、when、otherwise

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

<select id="findActiveBlogLike"
     resultType="Blog">
  select * from mybatis.blog
  <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>

9.3 trim、where、set

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

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

• set 元素会动态地在行首插入 SET 关键字，并会删掉额外的逗号

  <update id="updateB1og" parameterType="map">
      update mybatis.blog
      <set>
          <if test="title != null">
          	title = #{title},
          </if>
          <if test="author != null">
          	author = #{author}
          </if>
      </set>
      where id = #{id}
  </update>
  

• trim(where、set的父标签)

  • prefix 添加的关键字
  • prefixOverrides属性会自动忽略通过管道符分隔的文本序列 (注意空格是必须的)
  • suffixOverrides属性会自动忽略设置的后缀

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

9.1 动态sql之foreach

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

10 缓存

10.1 简介

1. 什么是缓存[ Cache ]?

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

2. 为什么使用缓存?

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

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

   • 经常查询并且不经常改变的数据。【可以使用缓存】

10.2 一级缓存

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

10.3 二级缓存

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

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

• 工作机制

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

• 开启 (使用缓存,实体需要序列化)

  • 开启全局缓存

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

  • 自定义参数

    <cache
      eviction="FIFO"
      flushInterval="60000"
      size="512"
      readOnly="true"/>
    

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

10.4 MyBatis缓存

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

10.5 MyBatis缓存原理

• 缓存顺序
  1. 先看二级缓存中有没有
  2. 再看—级缓存中有没有
  3. 直询数据库