Java-Mybatis配置详解

环境

• JDK1.8
• MySQL
• Maven
• IDEA

回顾

• JDBC
• MySQL
• Java基础
• Maven
• Junit
• SSM框架

Mybatis简介

• 什么是 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。

• 怎么获得Mybatis？

  • Maven仓库：

    
    <dependency>
        <groupId>org.mybatisgroupId>
        <artifactId>mybatisartifactId>
        <version>3.5.6version>
    dependency>
    

  • GitHub：https://github.com/mybatis/mybatis-3
  • 中文文档：https://mybatis.org/mybatis-3/zh/index.html

• 持久化

  • 数据持久化，持久状态和瞬时状态的转化
  • 内存：断电即失
  • 数据库（JDBC）,IO文件持久化

• 持久层

  • Dao层、Service层、Controller层
  • 完成持久化工作的代码块
  • 层次界限十分明显

• 为什么使用Mybatis？

  • 简化JDBC，自动化

第一个Mybatis项目

• 搭建环境

  • 创建数据库和表
  • 创建Maven项目
  • 删除项目中的src目录（使之成为父级项目）
  • 新建module（Maven类型）
  • 导入依赖：mybatis、junit…

• 在resource目录创建Mybatis配置文件：mybatis-config.xml

  
  DOCTYPE configuration
          PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
          "http://mybatis.org/dtd/mybatis-3-config.dtd">
  <configuration>
      <environments default="development">
          <environment id="development">
              <transactionManager type="JDBC"/>
              <dataSource type="POOLED">
                  <property name="driver" value="com.mysql.jdbc.Driver"/>
                  <property name="url" value="jdbc:mysql://localhost:3306/jdbc_test?useSSL=false&characterEncoding=utf8&serverTimezone=Asia/Shanghai"/>
                  <property name="username" value="root"/>
                  <property name="password" value="root"/>
              dataSource>
          environment>
      environments>
      <mappers>
          
          <mapper resource="cn/cnyasin/dao/UserMapper.xml"/>
      mappers>
  configuration>
  

• 创建自己的一个Mybatis工具类：package cn.cnyasin.utils;

  public class MybatisUtils {
      private static SqlSessionFactory sqlSessionFactory;
      private static String resource = "mybatis-config.xml";
      private static InputStream inputStream = null;
      /**
       * 从 XML 中构建 SqlSessionFactory
       */
      static {
          try {
              inputStream = Resources.getResourceAsStream(resource);
              sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
          } catch (IOException e) {
              e.printStackTrace();
          } finally {
              if (null != inputStream) {
                  try {
                      inputStream.close();
                  } catch (IOException e) {
                      e.printStackTrace();
                  }
              }
          }
      }
  
      /**
       * 从 SqlSessionFactory 中获取 SqlSession
       * @return SqlSession
       */
      public static SqlSession getSqlSession(){
          return sqlSessionFactory.openSession();
      }
  }
  

• 创建pojo

  public class User {
      private int id;
      private String username;
      private String email;
      private String password;
      private long balance;
      private long created_at;
      // ...
  }
  

• 在pom.xml中开启java目录资源过滤，Mybatis读取Mapper.xml需要该配置

  <build>
      <resources>
          <resource>
              <directory>src/main/resourcesdirectory>
              <includes>
                  <include>**/*.propertiesinclude>
                  <include>**/*.xmlinclude>
              includes>
          resource>
          <resource>
              <directory>src/main/javadirectory>
              <includes>
                  <include>**/*.propertiesinclude>
                  <include>**/*.xmlinclude>
              includes>
          resource>
      resources>
  build>
  

  注意：src/main/resources、src/main/java两个都要打开，resources如果不配置默认只开启src/main/resources目录，反之，如果配置了就会覆盖默认值。

  注意：如果需要读取xml配置就开启**/*.xml，如果你需要读取properties配置就开启**/*.properties。

• 创建dao：package cn.cnyasin.dao;

  public interface UserMapper {
      // 查询一个用户
      User getOne(@Param("id") int id);
      // 查询所有用户
      List<User> getAll();
      // 添加一个用户
      int addOne(User user);
      // 修改一个用户
      int updateOne(User user);
      // 删除一个用户
      int deleteOne(int id);
  }
  

• 创建Mapper：

  
  DOCTYPE mapper
          PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
          "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
  
  <mapper namespace="cn.cnyasin.dao.UserMapper">
      
      
      <select id="getOne" resultType="cn.cnyasin.pojo.User">
          select * from user where id = #{id}
      select>
      
      <select id="getAll" resultMap="userListMap">
          select * from user
      select>
      
      <insert id="addOne" parameterType="cn.cnyasin.pojo.User">
          insert into user (`username`,`email`,`password`,`created_at`) values (#{username}, #{email}, #{password}, #{created_at})
      insert>
      
      <update id="updateOne" parameterType="cn.cnyasin.pojo.User">
          update user set balance = #{balance} where id = #{id};
      update>
      
      <delete id="deleteOne">
          delete from user where id = #{id}
      delete>
      <resultMap id="userListMap" type="cn.cnyasin.pojo.User"/>
  mapper>
  

• 测试

  @Test
  public void getOneTest()
  {
      // 获取SQLSession
      SqlSession sqlSession = MybatisUtils.getSqlSession();
      // getMapper
      UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
      User user = userMapper.getOne(1);
      System.out.println(user);
      System.out.println("----------------------------");
      List<User> users = userMapper.getAll();
      for (User user1 : users) {
          System.out.println(user1);
      }
      // 关闭SQLSession
      sqlSession.close();
  }
  @Test
  public void updateOneTest() {
      SqlSession sqlSession = MybatisUtils.getSqlSession();
      UserMapper mapper = sqlSession.getMapper(UserMapper.class);
      User user = mapper.getOne(6);
      if (null == user) {
          System.out.println("用户不存在。。。");
          return;
      }
      user.setBalance(user.getBalance() + 100000);
      int updateOne = mapper.updateOne(user);
      if (updateOne > 0) {
          System.out.println("用户余额更新成功。。。");
      }
      sqlSession.commit();
      sqlSession.close();
  }
  // 增加、删除的测试方法省略。。。
  

遇到的问题

• MySQL连接异常：The server time zone value '�й���׼ʱ��' is unrecognized or represents more than one time zone. ...
  • 原因分析：如果mysql的jar包使用了8.*版本，该版本要求必须显式的指定serverTimezone
  • 解决方案：

    <property name="url" value="jdbc:mysql://localhost:3306/jdbc_test?useSSL=false&characterEncoding=utf8&serverTimezone=Asia/Shanghai"/>
    

• MySQL链接异常：org.xml.sax.SAXParseException; lineNumber: 11; columnNumber: 113; 对实体 "characterEncoding" 的引用必须以 ';' 分隔符结尾。...
  • 原因分析：xml配置文件特殊符号必须转实体（&->&），properties配置文件则不需要（&）。
  • 解决方案：xml配置中将url中的&改成&，properties配置中则相反。
• 启动报错，找不到XxxMapper.xml：The error may exist in cn/cnyasin/dao/UserMapper.xml...

  • 原因分析：Maven资源过滤问题。Maven默认资源过滤文件目录为resources目录，java目录下的文件是不会被导出的，需要手动开启该目录的资源过滤。

  • 解决方案：在pom.xml中添加如下代码：

    <build>
        <resources>
            <resource>
                <directory>src/main/resourcesdirectory>
                <includes>
                    <include>**/*.propertiesinclude>
                    <include>**/*.xmlinclude>
                includes>
            resource>
            <resource>
                <directory>src/main/javadirectory>
                <includes>
                    <include>**/*.propertiesinclude>
                    <include>**/*.xmlinclude>
                includes>
            resource>
        resources>
    build>
    

    注意：src/main/resources、src/main/java两个都要打开，resources如果不配置默认只开启src/main/resources目录，反之，如果配置了就会覆盖默认值。

    注意：如果需要读取xml配置就开启**/*.xml，如果你需要读取properties配置就开启**/*.properties。

补充说明

• 如果参数比较多又不方便传一个pojo，可以考虑传一个Map，俗称“万能map”。
• 模糊查询怎么写？
  • 方式一参数这么传：value=%张三%
  • 方式二SQL这么写：select * from user where name like "%"#{value}"%"

配置解析

• 核心配置文件
  • MyBatis 的配置文件包含了会深深影响 MyBatis 行为的设置和属性信息。 配置文档的顶层结构如下：
    • configuration（配置）
      • properties（属性）
      • settings（设置）
      • typeAliases（类型别名）
      • typeHandlers（类型处理器）
      • objectFactory（对象工厂）
      • plugins（插件）
      • environments（环境配置）
        • environment（环境变量）
          • transactionManager（事务管理器）
          • dataSource（数据源）
      • databaseIdProvider（数据库厂商标识）
      • mappers（映射器）
  • 具体参考官方文档：https://mybatis.org/mybatis-3/zh/configuration.html#
• 环境配置（environments）
  • Mybatis可以实现连接多个数据库
  • 不过要记住：尽管可以配置多个环境，但每个 SqlSessionFactory 实例只能选择一种环境。
  • 如果你想连接两个数据库，就需要创建两个 SqlSessionFactory 实例，每个数据库对应一个。
  • 事务管理器（transactionManager）
    • 在 MyBatis 中有两种类型的事务管理器（也就是 type="[JDBC|MANAGED]"），默认JDBC。
    • JDBC：我理解是对事务友好。
    • MANAGED：我理解是适用于容器使用完连接后需要手动关闭的情况。
    • 如果你正在使用 Spring + MyBatis，则没有必要配置事务管理器，因为 Spring 模块会使用自带的管理器来覆盖前面的配置。
  • 数据源（dataSource）
    • 有三种内建的数据源类型（也就是 type="[UNPOOLED|POOLED|JNDI]"）
    • UNPOOLED：没有池子，适用于小型网站，慢点但节省资源。
    • POOLED：有池子，适用于大型高并发网站，响应速度更快。
    • JNDI：用的不多就不说了。
• 属性（properties）
  • 优先级：.properties > property标签
• 类型别名（typeAliases）
  • 作用：简化xml
  • 用法一：

    <typeAliases>
        <typeAlias type="cn.cnyasin.pojo.User" alias="user"/>
    typeAliases>
    

  • 用法二：每一个在包cn.cnyasin.pojo中的JavaBean，在没有注解的情况下，会使用Bean的首字母小写的非限定类名来作为它的别名。若有注解，则别名为其注解值。

    <typeAliases>
        <package name="cn.cnyasin.pojo"/>
    typeAliases>
    

    @Alias("user001")
    public class User {}
    

• 设置（settings）
• 映射器（mappers）
• 其他配置。。。

生命周期

• SqlSessionFactoryBuilder：创建SqlSessionFactory用的，一次性。
• SqlSessionFactory：在应用的运行期间一直存在。
• SqlSession：最佳的作用域是请求或方法中，方法调用结束后销毁。

结果映射（resultMap ）

• 主要用于处理复杂的SQL
• 其中重要的一个作用：解决类属性和字段名不一致

  
  <resultMap id="userListMap" type="user">
      
      <result column="created_at" property="createdAt"/>
  resultMap>
  

日志

• 如果数据库操作异常我们需要拍错，就需要用到日志
• 日志工厂
  • 指定 MyBatis 所用日志的具体实现，未指定时将自动查找。
  • 在mybatis设置中进行设置：设置（settings） -> logImpl，默认未设置（不输出详细日志），支持的选项：
    • SLF4J
    • LOG4J（掌握）
    • LOG4J2
    • JDK_LOGGING
    • COMMONS_LOGGING
    • STDOUT_LOGGING（掌握）
    • NO_LOGGING
• STDOUT_LOGGING：标准日志输出，mybatis内置，不用手动导包，设置了该选项后自动输出日志。

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

• LOG4J：强大的日志工具，需要手动导包。
  • 什么是log4j？
    • Log4j是Apache的一个开源项目，通过使用Log4j，我们可以控制日志信息输送的目的地是控制台、文件、GUI组件，甚至是套接口服务器、NT的事件记录器、UNIX Syslog守护进程等；
    • 我们也可以控制每一条日志的输出格式；
    • 通过定义每一条日志信息的级别，我们能够更加细致地控制日志的生成过程。
    • 最令人感兴趣的就是，这些可以通过一个配置文件来灵活地进行配置，而不需要修改应用的代码。
  • 如何基本使用？
    • 导入包

      
      
          log4j
          log4j
          1.2.17
      
      

    • 在mybatis核心配置文件将settings中的logImpl选项设置为LOG4J

    • 在classpath（resources）目录创建log4j的配置文件：log4j.properties（固定名字），一个简单的配置文件如下：

      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=[%p][%d{yy-MM-dd}][%c]%m%n
      #文件输出的相关设置
      log4j.appender.file=org.apache.log4j.RollingFileAppender
      log4j.appender.file.File=./log/logs.txt
      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
      

      • log4j.rootLogger=DEBUG,console,file：意思是日志输出级别为DEBUG，输出到控制台、文件
      • 其它详细配置自己研究吧
  • 如何手动使用？
    • 前提：配置好了log4j基本使用
    • 在要手动输出日志的类中定义一个日志对象
    • 在适当的位置调用该日志对象的相关方法
    • 核心代码

      public class UserMapperTest {
          private static Logger logger = Logger.getLogger(UserMapperTest.class);
          @Test
          public void log4jTest() {
              // 错误级别：debug < info < warn < error，级别越低输出的日志越详细
              logger.debug("hahaha...呵呵。。。");
              logger.info("hahaha...呵呵。。。");
              logger.warn("hahaha...呵呵。。。");
              logger.error("hahaha...呵呵。。。");
          }
      }
      

分页

• 借助Map传start、pageSize给Mapper.xml，然后SQL中使用limit语句实现（推荐）。
• RowBounds
• PageHelper插件

使用注解开发

• 说明：适用于简单逻辑，复杂的逻辑不适合注解，比如字段属性映射关系就实现不了。
• 原理：反射、动态代理
• 注意：
  • 如果接口上加了注解，那么同目录下务必不要有对应的Mapper.xml文件，或者Mapper.xml中不要定义同id的方法，会冲突。
  • 如果方法上有多个参数，务必在每个参数前加上@Param()注解。
• 具体实现步骤
  • 环境准备（略）
  • 注解在接口上实现

    public interface UserMapper {
        @Select("select * from user where id = #{id}")
        User getOne(int id);
    }
    

  • mybatis核心配置文件中的mappers映射器中加载类

    <mappers>
        <mapper class="cn.cnyasin.dao.UserMapper"/>
    mappers>
    

  • 测试

lombok的使用

• 简介
  • Java使用工具。简化Javabean（POJO）的，免去Getter/Setter/Constructor/toString…。
• 用法（idea）
  • 在idea的设置中的插件设置里搜索lombok进行安装，然后按提示会让你重启idea，重启后默认开启该插件支持，要关闭可以再次打开idea的插件设置项，找到installed，禁用或者卸载。
  • 在要使用该用具的项目中加入lombok包依赖

    
    <dependency>
        <groupId>org.projectlombokgroupId>
        <artifactId>lombokartifactId>
        <version>1.18.12version>
    dependency>
    

  • 在POJO中使用
• 支持的注解

  @Getter and @Setter
  @FieldNameConstants
  @ToString
  @EqualsAndHashCode
  @AllArgsConstructor, @RequiredArgsConstructor and @NoArgsConstructor
  @Log, @Log4j, @Log4j2, @Slf4j, @XSlf4j, @CommonsLog, @JBossLog, @Flogger, @CustomLog
  @Data
  @Builder
  @SuperBuilder
  @Singular
  @Delegate
  @Value
  @Accessors
  @Wither
  @With
  @SneakyThrows
  @val
  @var
  experimental @var
  @UtilityClass
  @ExtensionMethod (Experimental, activate manually in plugin settings)
  

关联嵌套查询

• 属性列表

  • constructor - 用于在实例化类时，注入结果到构造方法中
    • idArg - ID 参数；标记出作为 ID 的结果可以帮助提高整体性能
    • arg - 将被注入到构造方法的一个普通结果
  • id – 一个 ID 结果；标记出作为 ID 的结果可以帮助提高整体性能
  • result – 注入到字段或 JavaBean 属性的普通结果
  • association – 一个复杂类型的关联；许多结果将包装成这种类型
    • 嵌套结果映射 – 关联可以是 resultMap 元素，或是对其它结果映射的引用
  • collection – 一个复杂类型的集合
    • 嵌套结果映射 – 集合可以是 resultMap 元素，或是对其它结果映射的引用
  • discriminator – 使用结果值来决定使用哪个 resultMap
    • case – 基于某些值的结果映射
      • 嵌套结果映射 – case 也是一个结果映射，因此具有相同的结构和元素；或者引用其它的结果映射

• 其他常用属性

  • property：映射到列结果的字段或属性。
  • column：数据库中的列名，或者是列的别名。
  • select：用于加载复杂类型属性的映射语句的ID，它会从column属性中指定的列检索数据，作为参数传递给此select语句。对外部select的命名引用。
  • resultMap：对外部resultMap的命名引用。
  • resultType：期望从这条语句中返回结果的类全限定名或别名，比如：User。
  • type：ResultMap的专用属性，该结果返回的类型，接受类的完全限定名或者一个类型别名，比如：User。
  • ofType：collection的专用属性，该结果集返回的类型，接受类的完全限定名或者一个类型别名，比如：User。
  • javaType：association的专用属性，一个Java类的全限定名或一个类型别名，比如：ArrayList。MyBatis通常可以自动推断类型。

• 具体实现核心代码

  • 按查询嵌套

    
    
        select * from student where id = #{id}
    
    
        
        
        
    
    
        select * from teacher where id = #{id}
    
    
    
    
        select * from teacher where id = #{id}
    
    
        
        
        
            
        
    
    
        select id,name,created_at createdAt from student where tid = #{id}
    
    

  • 按结果嵌套

    
    
        select s.*, t.`name` tName, t.created_at tCreatedAt
        from student s, teacher t
        where s.tid = t.id
        and s.id = #{id};
    
    
        
        
        
        
        
    
    
        
        
        
    
    
    
    
    
        select
        t.id t_id, t.name t_name, t.created_at t_created_at,
        s.id s_id, s.name s_name, s.created_at s_created_at
        from teacher t, student s
        where s.tid = t.id
        and t.id = #{id}
    
    
        
        
        
        
    
    
        
        
        
    
    
    
    
        
        
        
        
            
            
            
        
    
    

动态SQL

• 概念
  • 你应该能理解根据不同条件拼接 SQL 语句有多痛苦，例如拼接时要确保不能忘记添加必要的空格，还要注意去掉列表最后一个列名的逗号。利用动态 SQL，可以彻底摆脱这种痛苦。
• 常用标签
  • if
  • choose (when, otherwise)
  • trim (where, set)
  • foreach
• 环境准备（略）
• 具体实现核心代码

  
  
      
      
  
  
      select * from user
      
          
              `username` = #{username}
          
          
              and `email` = #{email}
          
          
              and `password` = #{password}
          
          
              and id in
              
                  #{id}
              
          
      
      
          
              order by `id` desc
          
          
              order by `id` asc
          
      
  
  
  
  
      update user
      
          `username` = #{username}
          `email` = #{email}
          `password` = #{password}
          `balance` = #{balance}
      
      where id = #{id}
  
  

• SQL片段
  • 使用sql标签抽取公共部分

    
        
            `username` = #{username}
        
        
            and `email` = #{email}
        
        
            and `password` = #{password}
        
        
            and id in
            
                #{id}
            
        
    
    

  • 在要使用片段的地方用include标签引用

缓存

• 一级缓存
  • 默认开启
  • 默认情况下，只启用了本地的会话缓存，它仅仅对一个会话中的数据进行缓存。
  • 相同的SQL，同一个会话只会执行一次（如果期间未执行非select语句）。
• 二级缓存
  • 要启用全局的二级缓存，只需要在你的 SQL 映射文件中添加一行：
  • 效果如下
    • 映射语句文件中的所有 select 语句的结果将会被缓存。
    • 映射语句文件中的所有 insert、update 和 delete 语句会刷新缓存。
    • 缓存会使用最近最少使用算法（LRU, Least Recently Used）算法来清除不需要的缓存。
    • 缓存不会定时进行刷新（也就是说，没有刷新间隔）。
    • 缓存会保存列表或对象（无论查询方法返回哪种）的 1024 个引用。
    • 缓存会被视为读/写缓存，这意味着获取到的对象并不是共享的，可以安全地被调用者修改，而不干扰其他调用者或线程所做的潜在修改。
  • 二级缓存也叫全局缓存，一个namespace一个二级缓存。
  • 二级缓存可跨会话有效。

---