[Java知识库]MyBatis-3.5.6 框架学习

1、MyBatis-3.5.6 第一天

环境：

• jdk1.8
• Mysql 5.7
• maven 3.6.1

1.1、什么是MyBatis ？

• MyBatis 是一款优秀的持久层框架，
• 它支持自定义 SQL、存储过程以及高级映射。
• MyBatis 免除了几乎所有的 JDBC 代码以及设置参数和获取结果集的工作。
• MyBatis 可以通过简单的 XML 或注解来配置和映射原始类型、接口和 Java POJO（Plain Old Java Objects，普通老式 Java 对象）为数据库中的记录。

1.2、 持久层

： 持久层，可以理解成数据保存在数据库或者硬盘一类可以保存很长时间的设备里面，不像放在内存中那样断电就消失了，也就是把数据存在持久化设备上，mybatis就是持久层。

? Dao层 、Service层 、Controller层

• 完成持久化工作的代码块

1.3、为什么需要MyBatis？

原因：

• 传统的jdbc复杂。mybatis–方便开发，简化，框架，自动化
• 帮助程序员将数据存到数据库中

优点：

• 简单易学：本身就很小且简单。没有任何第三方依赖，最简单安装只要两个jar文件+配置几个sql映射文件易于学习，易于使用，通过文档和源代码，可以比较完全的掌握它的设计思路和实现。
• 灵活：mybatis不会对应用程序或者数据库的现有设计强加任何影响。 sql写在xml里，便于统一管理和优化。通过sql语句可以满足操作数据库的所有需求。
• 解除sql与程序代码的耦合：通过提供DAO层，将业务逻辑和数据访问逻辑分离，使系统的设计更清晰，更易维护，更易单元测试。sql和代码的分离，提高了可维护性。
• 提供映射标签，支持对象与数据库的orm字段关系映射
• 提供对象关系映射标签，支持对象关系组建维护
• 提供xml标签，支持编写动态sql。

1.4、 搭建环境

创建maven项目时报错：无法解析插件 org.apache.maven.plugins:maven-jar-plugin:2.4 ：应该是该jar包没有用了

• 删除mvn_repository\org\apache\maven\plugins\maven-jar-plugin下的文件
• 搭建maven环境，将其作为一个父工程，再创建一个子工程

<!--    导入依赖-->
    <dependencies>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.26</version>
        </dependency>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.6</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.10</version>
        </dependency>
    </dependencies>

1.5、创建mybatis的核心配置文件

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<!--核心配置文件-->
<configuration>
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.cj.jdbc.Driver"/><!--注意数据库连接的版本-->
                <property name="url" value="jdbc:mysql:///mybatis?useSSL=true&amp;
                useUnicode=true&amp;characterEncoding=UTF-8"/><!--自己的数据库-->
                <property name="username" value="root"/>!<!--自己的数据库用户名-->
                <property name="password" value="xc999"/><!--自己数据库密码-->
            </dataSource>
        </environment>
    </environments>
</configuration>

1.6、编写mybatis的工具类

1. 每个基于 MyBatis 的应用都是以一个 SqlSessionFactory 的实例为核心的。SqlSessionFactory 的实例可以通过 SqlSessionFactoryBuilder 获得。而 SqlSessionFactoryBuilder 则可以从 XML 配置文件或一个预先配置的 Configuration 实例来构建出 SqlSessionFactory 实例。
2. 既然有了 SqlSessionFactory，顾名思义，我们可以从中获得 SqlSession 的实例。SqlSession 提供了在数据库执行 SQL 命令所需的所有方法。

public class MyBatisUtils {
    private static SqlSessionFactory build ;
    //静态代码块，初始就加载配置文件
    static {
        String resource="mybatis-config.xml";
        try {
            //1、获取SqlSessionFactory对象(SqlSessionFactory 的实例可以通过SqlSessionFactoryBuilder 获得
            InputStream is = Resources.getResourceAsStream(resource);
            build = new SqlSessionFactoryBuilder().build(is);

        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    //SqlSession 提供了在数据库执行 SQL 命令所需的所有方法。
    public static SqlSession getSqlSession(){
        //获取操作sql对象(既然有了 SqlSessionFactory，顾名思义，我们可以从中获得 SqlSession 的实例。)
       return build.openSession();
    }
}

1.7、编写代码，测试

1. 实体类

public class User {
    private int id;
    private String name;
    private String age;

    public User() {
    }

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

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", age='" + age + '\'' +
                '}';
    }

    public int getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getAge() {
        return age;
    }

    public void setAge(String age) {
        this.age = age;
    }
}

2. 接口

public interface UserMapper {
    //查询全部用户
    List<User> getUserList();

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

    //增加用户
    int addUser(User user);

    //修改用户
    int updateUser(User user);

    //删除用户
    int deleteUser(int id);
}

3. 接口实现类–之前（UserDaoImpl） 现在在mybatis中不写，只在配置文件(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="com.xcong.dao.UserMapper">
<!--    id:对应dao里方法名 其实就是之前实现类重写的方法名-->
<!--    resultType:sql语句执行返回的结果 对应全包名-->
  <select id="getUserList" resultType="com.xcong.pojo.User">
        select * from tab_user
  </select>
    <select id="getUserById" parameterType="int" resultType="com.xcong.pojo.User">
        select * from tab_user where id=#{id}
    </select>

<!--    对象中的属性可以直接取出来-->
    <insert id="addUser" parameterType="com.xcong.pojo.User">
        insert into  tab_user values (#{id},#{name},#{age})
    </insert>

    <update id="updateUser" parameterType="com.xcong.pojo.User">
        update tab_user set name =#{name},age=#{age} where id=#{id}
    </update>

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

4. 测试

报错：

• org.apache.ibatis.binding.BindingException: Type interface com.xcong.dao.UserDao is not known to the MapperRegistry.
• 解决方案： 在核心配置文件中注册

<mappers>
    <mapper resource="com/xcong/dao/UserDao.xml"/>
</mappers>

• java.lang.ExceptionInInitializerError：The error may exist in com/xcong/dao/UserDao.xml（资源过滤问题）

由于maven的约定大于配置，会导致我们写的配置文件无法导出或生效，所以我们需要在pom.xml里加入一下代码来防止我们资源导出失败的问题。

解决方案：在pom.xml 如果没有用，可以刷新下maven

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

• 测试代码

@Test
public  void test(){
    //获取操作对象-SqlSession
    SqlSession sqlSession = MyBatisUtils.getSqlSession();
    
    //相当于之前--获取接口实现类对象，
    UserDao dao = sqlSession.getMapper(UserDao.class);
    
    //调用UserDao里方法
    List<User> userList = dao.getUserList();
    
    //遍历集合
    for (User user : userList) {
        System.out.println(user);
    }
    //关闭连接
    sqlSession.close();
}

2、MyBatis–3.5.6 第二天

2.1、CRUD

crud：主要被用在描述软件系统中数据库或者持久层的基本操作功能。

增加(Create) 检索(Retrieve) 更新(Update) 删除(Delete)

1. id：对应 dao/Mapper 里方法名，其实就是之前实现类里重写的UserDao接口方法名
2. ResultType：sql语句执行返回值 对应全包名
3. parameterType：参数类型
4. namespace：命名空间 相当于实现类 对应全包名（一直到接口）

//增删改 需要提交事务
public class UserMapperTest {
    @Test
    public  void test1(){
        //获取操作对象-SqlSession
        SqlSession sqlSession = MyBatisUtils.getSqlSession();
        //相当于之前--获取接口实现类对象，调用方法  方法1：
//        UserDao dao = sqlSession.getMapper(UserDao.class);
        //方法2
        List<User> userList = sqlSession.selectList("com.xcong.dao.UserDao.getUserList");
//        List<User> userList = dao.getUserList();
        for (User user : userList) {
            System.out.println(user);
        }
        //关闭连接
        sqlSession.close();
    }

    @Test
    public void getUserById(){
        SqlSession sqlSession = MyBatisUtils.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);//获取接口（相当于之前实现类获取接口）
        User user = mapper.getUserById(1);
        System.out.println(user);
        sqlSession.close();
    }

    //增删改 需要提交事务
    @Test
    public void addUser(){
        SqlSession sqlSession = MyBatisUtils.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        int num = mapper.addUser(new User(3, "光头强", "14"));
        if(num>0){
            System.out.println("成功");
        }
        //提交事务
        sqlSession.commit();
        sqlSession.close();
    }

    //改
    @Test
    public void updateUser(){
        SqlSession sqlSession = MyBatisUtils.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        mapper.updateUser(new User(3,"团子","6") );
        sqlSession.commit();
        sqlSession.close();
    }
    //删
    @Test
    public void deleteUser(){
        SqlSession sqlSession = MyBatisUtils.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        mapper.deleteUser(3);
        sqlSession.commit();
        sqlSession.close();
    }
}

2.2、Map（DB字段过多，使用map）

User getUserById2(Map<String,Object> map);

 int addUser1(Map<String,Object> map);

• 好处：通过 key=value
  1. Map传参，直接在sql中取出key即可–在多个参数情况下使用
  2. 对象传参，直接在sql中取对象的属性即可

2.3、模糊查询

出现问题：Invalid bound statement (not found) ——是自己在UserMapper.xml 方法名写错了–要和接口

UserMapper里面的方法名一直，否则会报错

• List<User> getUserLike(String value);
  

• <select id="getUserLike" resultType="com.xcong.pojo.User">
      select *from tab_user where name like "%"#{value}"%"
  </select>
  

2.4、配置解析

MyBatis 的配置文件包含了会深深影响 MyBatis 行为的设置和属性信息。

1. configuration（配置）

2. properties（属性）：同时存在，先执行外部配置

   • 编写配置文件：db.properties

     driver=com.mysql.cj.jdbc.Driver
     url=jdbc:mysql:///mybatis
     username=root
     password=xc999
     

   • 在核心配置文件引入

   <!--引入外部配置文件-->
   <properties resource="db.properties">
       <property name="username" value="root"/>
       <property name="password" value="xc999"/>
   </properties>
   

3. settings（设置）：这是 MyBatis 中极为重要的调整设置，它们会改变 MyBatis 的运行时行为。

4. typeAliases（类型别名）：类型别名可为 Java 类型设置一个缩写名字。 它仅用于 XML 配置，意在降低冗余的全限定类名书写。（建议使用第二种-就是直接：resultType=“com.xcong.pojo.User” ）

   • 第一种：在核心配置文件引入

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

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

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

     扫描实体类的包，它的默认别名就是这个类的类名，首字母小写(大写也行)

     <select id="getUserList" resultType="user">
           select * from tab_user
     </select>
     

   • 注解方式：在扫描包的情况下

   • @Alias("user")
     public class User {   ~~~~~  }
     

5. typeHandlers（类型处理器）

6. objectFactory（对象工厂）

7. plugins（插件）

8. environments（环境配置）:

   • MyBatis 可以配置成适应多种环境，这种机制有助于将 SQL 映射应用于多种数据库之中
   • 尽管可以配置多个环境，但每个 SqlSessionFactory 实例只能选择一种环境。
   • 每个数据库对应一个 SqlSessionFactory 实例

   ? environment（环境变量）

   ? transactionManager（事务管理器）:

   • 在 MyBatis 中有两种类型的事务管理器（也就是 type="[JDBC|MANAGED(了解)]"）
   • JDBC – 这个配置直接使用了 JDBC 的提交和回滚设施，它依赖从数据源获得的连接来管理事务作用域。
   • 提示 如果你正在使用 Spring + MyBatis，则没有必要配置事务管理器，因为 Spring 模块会使用自带的管理器来覆盖前面的配置。

   ? dataSource（数据源）：type="[UNPOOLED|POOLED|JNDI]"

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

   • POOLED– 这种数据源的实现利用“池”的概念将 JDBC 连接对象组织起来，避免了创建新的连接实例时所必需的初始化和认证时间。 这种处理方式很流行，能使并发 Web 应用快速响应请求。

     除了上述提到 UNPOOLED 下的属性外，还有更多属性用来配置 POOLED 的数据源：

     • poolMaximumActiveConnections – 在任意时间可存在的活动（正在使用）连接数量，默认值：10
     • poolMaximumIdleConnections – 任意时间可能存在的空闲连接数。
     • poolMaximumCheckoutTime – 在被强制返回之前，池中连接被检出（checked out）时间，默认值：20000 毫秒（即 20 秒）
     • poolTimeToWait – 这是一个底层设置，如果获取连接花费了相当长的时间，连接池会打印状态日志并重新尝试获取一个连接（避免在误配置的情况下一直失败且不打印日志），默认值：20000 毫秒（即 20 秒）。
     • poolMaximumLocalBadConnectionTolerance – 这是一个关于坏连接容忍度的底层设置， 作用于每一个尝试从缓存池获取连接的线程。 如果这个线程获取到的是一个坏的连接，那么这个数据源允许这个线程尝试重新获取一个新的连接，但是这个重新尝试的次数不应该超过 poolMaximumIdleConnections 与 poolMaximumLocalBadConnectionTolerance 之和。 默认值：3（新增于 3.4.5）
     • poolPingQuery – 发送到数据库的侦测查询，用来检验连接是否正常工作并准备接受请求。默认是“NO PING QUERY SET”，这会导致多数数据库驱动出错时返回恰当的错误消息。
     • poolPingEnabled – 是否启用侦测查询。若开启，需要设置 poolPingQuery 属性为一个可执行的 SQL 语句（最好是一个速度非常快的 SQL 语句），默认值：false。
     • poolPingConnectionsNotUsedFor – 配置 poolPingQuery 的频率。可以被设置为和数据库连接超时时间一样，来避免不必要的侦测，默认值：0（即所有连接每一时刻都被侦测 — 当然仅当 poolPingEnabled 为 true 时适用）。

9. databaseIdProvider（数据库厂商标识）

10. mappers（映射器）：直接告诉 MyBatis 到哪里去找映射文件

    • 接口和Mapper配置文件的名字必须相同（eg:UserMapper 接口 UserMapper.xml 配置文件）
    • 接口和Mapper配置文件必须在同一个包下

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

2.5、生命周期

作用域和生命周期类别是至关重要的，因为错误的使用会导致非常严重的并发问题。

• SqlSessionFactoryBuilder

：这个类可以被实例化、使用和丢弃，一旦创建了 SqlSessionFactory，就不再需要它了。 因此 SqlSessionFactoryBuilder 实例的最佳作用域是方法作用域（也就是局部方法变量）

• SqlSessionFactory

：SqlSessionFactory 一旦被创建就应该在应用的运行期间一直存在，没有任何理由丢弃它或重新创建另一个实例。因此 SqlSessionFactory 的最佳作用域是应用作用域

• SqlSession

：连接请求。SqlSession 的实例不是线程安全的，因此是不能被共享的，所以它的最佳的作用域是请求或方法作用域。及时关闭，资源释放。

2.6、ResultMap：结果集映射

1. resultMap 元素是 MyBatis 中最重要最强大的元素。

2. ResultMap 的设计思想是，对简单的语句做到零配置，对于复杂一点的语句，只需要描述语句之间的关系就行了。

3. 解决实体类属性名和数据库字段名不一致的问题（如果相同，可以不映射）

  <resultMap id="UserMap" type="User">
      <!--<result column="id" property="id"></result>-->
      <result column="name" property="userName"></result>
      <result column="age" property="userAge"></result>
  </resultMap>


<select id="getUserList" resultMap="UserMap">
      select * from tab_user
</select>

2.7、日志工厂

1. 如果出现了异常，我们需要排错，就要用到日志。

2. logImpl：指定 MyBatis 所用日志的具体实现，未指定时将自动查找。

   • LOG4J

     1. Log4j是Apache的一个开源项目，通过使用Log4j，我们可以控制日志信息输送的目的地是控制台、文件、GUI组件
     2. 我们也可以控制每一条日志的输出格式
     3. 可以通过一个配置文件来灵活地进行配置

     第一步:导包

     ? 加入log4j-1.2.8.jar(可以选择log4j的更高版本)到lib下。

     ? 如果使用maven项目，也可以选择在pom.xml中新增依赖：

     <!-- 加入log4j支持 -->
     
     <dependency>
             <groupId>log4j</groupId>
             <artifactId>log4j</artifactId>
             <version>1.2.17</version>
     </dependency>
     

     第二步:配置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=[%c]-%m%n
     #log4j.appender.credit.layout.ConversionPattern=%d{yyyy/MM/dd HH\:mm\:ss,SSS} [%-3p][class:%l] %m %n
     #文件输出的相关设置
     log4j.appender.file = org.apache.log4j.RollingFileAppender
     log4j.appender.file.File=./log/logging.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
     

     第三步：

     在要输出日志的类中加入相关语句：

     定义属性：static Logger logger = Logger.getLogger(LogDemo.class); //LogDemo为相关的类

     在相应的方法中：执行后会生成响应的log包和文件（log4j.appender.file.File=./log/logging.log）

      @Test
         public void log4j(){
             logger.info("info:log4j");
             logger.debug("debug:log4j");
             logger.error("error:log4j");
         }
     

   • STDOUT_LOGGING（stdout_logging）:标准日志输出（什么都不用配，直接用）

   <!--注意位置-->
   <settings>
       <setting name="logImpl" value="STDOUT_LOGGING"/>
   </settings>
   

2.8、分页

好处：减少数据的处理量

使用Limit分页

select *from tab_user limit startIndex,pagesSize;

使用mybatis实现：

1. 接口

//分页
List<User> getUserByLimit(Map<String,Integer> map);

2. 配置

<select id="getUserByLimit" resultType="user" parameterType="map">
    select *from tab_user limit #{startIndex},#{pageSize}
</select>

3. 测试

      @Test
       public void limit(){
           SqlSession sqlSession = MyBatisUtils.getSqlSession();
           UserMapper mapper = sqlSession.getMapper(UserMapper.class);
           HashMap<String, Integer> map = new HashMap<String, Integer>();
   //        map.put("0",1);  错误的，sql里面的字段是一个个键
           map.put("startIndex",1);
           map.put("pageSize",1);
           List<User> user = mapper.getUserByLimit(map);
           for (User user1 : user) {
               System.out.println(user1);
           }
           sqlSession.close();
       }
   

使用RowBounds分页

1. 接口

//分页
List<User> getUserByLimit();

2. 配置

   <select id="getUserByLimit" resultType="user">
       select *from tab_user 
   </select>
   

3. 测试

@Test
public void test11(){
    SqlSession sqlSession = MyBatisUtils.getSqlSession();
    RowBounds rowBounds = new RowBounds(0, 1);
    List<User> userList = sqlSession.selectList("com.xcong.dao.UserMapper.getUserByRowBound", null, rowBounds);
    for (User user : userList) {
        System.out.println(user);
    }
    sqlSession.close();
}

分页插件：PageHelper

2.9、使用注解开发

package org.mybatis.example;
public interface BlogMapper {
  @Select("SELECT * FROM blog WHERE id = #{id}")
  Blog selectBlog(int id);
}

<mappers>
    <mapper resource="com/xcong/dao/UserMapper.xml"/>
</mappers>

在进行一些简单的增删改时使用

使用注解来映射简单语句会使代码显得更加简洁，但对于稍微复杂一点的语句，Java 注解不仅力不从心，还会让你本就复杂的 SQL 语句更加混乱不堪。 因此，如果你需要做一些很复杂的操作，最好用 XML 来映射语句。