java连接数据库（4.1）：Mybatis框架快速入门

mybatis中文网

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

MyBatis 是一款优秀的持久层框架，它支持定制化 SQL、存储过程以及高级映射（一对多、多对一）。

mybatis是一个优秀的基于java的持久层框架，它内部封装了jdbc，使开发者只需要关注sql语句本身，而不需要花费精力去处理加载驱动、创建连接、创建statement等繁杂的过程。

mybatis通过xml或注解的方式将要执行的各种statement配置起来，并通过java对象和statement中sql的动态参数进行映射生成最终执行的sql语句，最后由mybatis框架执行sql并将结果映射为java对象并返回。

MyBatis的主要设计目的就是让我们对执行SQL语句时对输入输出的数据管理更加方便，所以方便地写出SQL和方便地获取SQL的执行结果才是MyBatis的核心竞争力。

（建议创建maven多级模块项目——IDEA创建maven多级模块项目）
（也可以自己创建maven项目）

<dependencies>
		
        <dependency>
            <groupId>org.mybatisgroupId>
            <artifactId>mybatisartifactId>
            <version>3.5.2version>
        dependency>

        
        
        <dependency>
            <groupId>mysqlgroupId>
            <artifactId>mysql-connector-javaartifactId>
            <version>8.0.11version>
        dependency>

        
        <dependency>
            <groupId>org.junit.jupitergroupId>
            <artifactId>junit-jupiter-apiartifactId>
            <version>5.7.0version>
            <scope>testscope>
        dependency>
		<dependency>
            <groupId>junitgroupId>
            <artifactId>junitartifactId>
            <version>4.12version>
            <scope>testscope>
        dependency>
		

           <dependency>
              <groupId>log4jgroupId>
              <artifactId>log4jartifactId>
              <version>1.2.17version>
            dependency>
            

    dependencies>

说明：这里使用了@lombok注解，假如不想使用lombok注解，可以自己实现对应的方法
推荐文章：lombok常用注解
@Data：在JavaBean或类JavaBean中使用，这个注解包含范围最广，它包含getter、setter、NoArgsConstructor、equals、canEqual、hashCode、toString 注解，即当使用当前注解时，会自动生成包含的所有方法；

@NoArgsConstructor注解：在JavaBean或类JavaBean中使用，使用此注解会生成对应的无参构造方法；

@AllArgsConstructor注解：在JavaBean或类JavaBean中使用，使用此注解会生成对应的有参构造方法；

通过动态代理创建出具有 Mapper 接口行为的代理对象，方法中具体执行的 SQL 则是取自映射文件

DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="mapper.TeacherMapper">
    <select id="findAll" resultType="pojo.Teacher">
        select *from teacher
    select>

mapper>

在resources下创建核心配置文件mybatis-config.xml/sqlMapConfig.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">transactionManager>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql:///【数据库名】?useUnicode=true&characterEncoding=UTF-8&useSSL=false&autoReconnect=true&failOverReadOnly=false&serverTimezone=GMT%2B8"/>
                <property name="username" value="【数据库用户名】"/>
                <property name="password" value="【数据库密码】"/>
            dataSource>
        environment>
    environments>

    
    <mappers>
        <mapper resource="【相对resources目录的路径】mapper/UserMapper.xml">mapper>
    mappers>
    
configuration>

SqlSessionFactoryBuilder：用于创建SqlSessionFacoty（SqlSessionFacoty一旦创建完成就不需要）

SqlSessionFactory：是“生产/new“SqlSession对象的”工厂“。
两个构造方法
openSession（）：会默认开启一个事务，但事务不会自动提交，也就意味着需要手动提交该事务，更新 *** 作数据才会持久化到数据库中。
openSession(boolean autoCommt）：参数为是否自动提交，如果设置为true，那么不需要手动提交事务

SqlSession：代表Java程序和数据库之间的会话。(HttpSession是Java程序和浏览器之间的会话)
*** 作事务的方法主要有:
void commit()
void rollback()

工厂模式：如果常见某一个对象，使用的过程基本固定，那么我们就可以把常见这个对象的相关代码封装到一个“工厂类”中，以后都使用这个工厂类来“生产”我们需要的对象。

MyBatis使用及内容介绍

package test;

import com.github.pagehelper.PageHelper;
import mapper.TeacherMapper;
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 org.junit.Test;
import pojo.Teacher;

import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;


public class MybatisTest {
    @Test
    public void test1() throws IOException {
        /**
         * 获取核心配置文件* Resources ：import org.apache.ibatis.io.Resources;*/
        InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");
        /**获取工厂对象*/
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
        /**获取session会话对象——工厂打开一个会话*/
        SqlSession sqlSession = sqlSessionFactory.openSession();
		//通过Class字节码反射创建一个TeacherMapper
TeacherMapper mapper = sqlSession.getMapper(TeacherMapper.class);
        TeacherMapper mapper = sqlSession.getMapper(TeacherMapper.class);

        ArrayList<Teacher> all = mapper.findAll();
        for (Teacher t : all) {
            System.out.println(t);
        }
    }
}

当你的基本框架写好了之后，如何添加新的方法
1、mapper包下编写方法的接口
2、

说明：mapper接口和mapper.xml之间需要遵循一定规则，才能成功的让mybatis将mapper接口和mapper.xml绑定起来

mapper接口的全限定名，要和mapper.xml的namespace属性一致
mapper接口中的方法名要和mapper.xml中的SQL标签的id一致
mapper接口中的方法入参类型，要和mapper.xml中SQL语句的入参类型一致
mapper接口中的方法出参类型，要和mapper.xml中SQL语句的返回值类型一致

测试：查找所有的用户

注意：下方测试方法的时候，sql报错的语法（比如，（这里的用户是我们为了模拟Teacher对象，自己new出来的）新增相同id用户的方法不能运行两次）

@Test
    public void test1() throws IOException {
        /**
         * 获取核心配置文件* Resources ：import org.apache.ibatis.io.Resources;*/
        InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");
        /**获取工厂对象*/
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
        /**获取session会话对象——工厂打开一个会话*/
        SqlSession sqlSession = sqlSessionFactory.openSession();

        TeacherMapper mapper = sqlSession.getMapper(TeacherMapper.class);
        ArrayList<Teacher> all = mapper.findAll();
        for (Teacher t : all) {
            System.out.println(t);
        }

        System.out.println("---------------------------------------------------------");
        Teacher teacher = mapper.getTeacherById(1);
        System.out.println(teacher);


        Teacher t5 = new Teacher(5, "东方不败");
        mapper.addTeacher(t5);
        Teacher teacher5 = mapper.getTeacherById(5);
        System.out.println(teacher5);

        System.out.println("---------------------------------------------------------");

        mapper.updateTeacher(new Teacher(5,"岳不群"));
        System.out.println("---------------------------------------------------------");

        mapper.deleteTeacher(1);
        System.out.println("---------------------------------------------------------");
        sqlSession.close();
    }

核心配置文件中的标签必须按照固定的顺序(有的标签可以不写，但顺序一定不能乱)：
MyBatis 的配置文件包含了会深深影响 MyBatis 行为的设置和属性信息。 配置文档的顶层结构如下：

该标签可以加载外部的properties文件，可以${属性名}的方式访问属性值（这里的jdbc.properties可以用于下面的数据库环境配置）

数据库环境的配置，支持多环境配置
Mybatis默认的事务管理器——JDBC，连接池——POOLED

1、这是jdbc.properties文件

jdbc.driver=com.mysql.cj.jdbc.Driver
jdbc.url= jdbc:mysql:///test?useUnicode=true&useJDBCCompliantTimezoneShift=true&useLegacyDatetimeCode=false&serverTimezone=UTC&useSSL=false&characterEncoding=UTF-8
jdbc.username=root
jdbc.password=123456

数据库8.0以上的配置，需要配置SSL，以及时区的配置
如果未设置explicit选项，默认情况下必须建立SSL连接。为了符合不使用SSL的现有应用程序，verifyServerCertificate属性设置为“false”。您需要通过设置useSSL=false显式禁用SSL，或者设置useSSL=true并为服务器证书验证提供信任库。

在url后面加上这些？useUnicode=true&useJDBCCompliantTimezoneShift=true&useLegacyDatetimeCode=false&serverTimezone=UTC&useSSL=false&characterEncoding=UTF-8

2、在核心配置文件中配置引入

DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">

<configuration>
    
    <properties resource="jdbc.properties"/>

    
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC">transactionManager>
            <dataSource type="POOLED">
                
                <property name="driver" value="${jdbc.driver}"/>
                
                <property name="url" value="${jdbc.url}"/>
                
                <property name="username" value="${jdbc.username}"/>
                
                <property name="password" value="${jdbc.password}"/>
            dataSource>
        environment>
    environments>

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

（备注：可以扫描整个包）
1、正常使用
加载映射文件，然后只需要调用这个核心文件就可以调用映射文件了

	 <mappers>
        <mapper resource="mapper/TeacherMapper.xml">mapper>
    mappers>

2、 扫描整个包

以包为单位，将包下所有的映射文件引入核心配置文件
注意：
1. 此方式必须保证mapper接口和mapper映射文件必须在相同的包下
2. mapper接口要和mapper映射文件的名字一致

引入映射文件

	<mappers>
        <package name="mybatis.mapper"/>
    mappers>

类型别名可为 Java 类型设置一个缩写名字。 它仅用于 XML 配置，意在降低冗余的全限定类名书写
而后我们在使用表示该java类型的时候就可以直接使用该别名

<typeAliases>
  <typeAlias alias="Author" type="domain.blog.Author"/>
  <typeAlias alias="Blog" type="domain.blog.Blog"/>
  <typeAlias alias="Comment" type="domain.blog.Comment"/>
  <typeAlias alias="Post" type="domain.blog.Post"/>
  <typeAlias alias="Section" type="domain.blog.Section"/>
  <typeAlias alias="Tag" type="domain.blog.Tag"/>
typeAliases>

Mybatis设置的别名不区分大小写

官网描述：resultMap 元素是 MyBatis 中最重要最强大的元素。它可以让你从 90% 的 JDBC ResultSets 数据提取代码中解放出来，并在一些情形下允许你进行一些 JDBC 不支持的 *** 作。实际上，在为一些比如连接的复杂语句编写映射代码的时候，一份 resultMap 能够代替实现同等功能的数千行代码。ResultMap 的设计思想是，对简单的语句做到零配置，对于复杂一点的语句，只需要描述语句之间的关系就行了。
总结：用于复杂的sql语句或多表联查

当数据库中的字段和pojo的实体属性不一致，可能导致修改的字段对应不上

解决方案1：直接查询（起别名）

解决方案2：使用ResultMap 结果集映射

如果这个世界总是这么简单就好了。
（下面看看Resultmap结果集映射的复杂使用，先了解下，以后我们再说，先学会上面的如何简单使用即可）

高级结果映射
MyBatis 创建时的一个思想是：数据库不可能永远是你所想或所需的那个样子。 我们希望每个数据库都具备良好的第三范式或 BCNF 范式，可惜它们并不都是那样。 如果能有一种数据库映射模式，完美适配所有的应用程序，那就太好了，但可惜也没有。 而 ResultMap 就是 MyBatis 对这个问题的答案。

比如，我们如何映射下面这个语句？
从ABCTP共5张表查询数据

<select id="selectBlogDetails" resultMap="detailedBlogResultMap">
  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,
       A.favourite_section as author_favourite_section,
       P.id as post_id,
       P.blog_id as post_blog_id,
       P.author_id as post_author_id,
       P.created_on as post_created_on,
       P.section as post_section,
       P.subject as post_subject,
       P.draft as draft,
       P.body as post_body,
       C.id as comment_id,
       C.post_id as comment_post_id,
       C.name as comment_name,
       C.comment as comment_text,
       T.id as tag_id,
       T.name as tag_name
  from Blog B
       left outer join Author A on B.author_id = A.id
       left outer join Post P on B.id = P.blog_id
       left outer join Comment C on P.id = C.post_id
       left outer join Post_Tag PT on PT.post_id = P.id
       left outer join Tag T on PT.tag_id = T.id
  where B.id = #{id}
select>

你可能想把它映射到一个智能的对象模型，这个对象表示了一篇博客，它由某位作者所写，有很多的博文，每篇博文有零或多条的评论和标签。 我们先来看看下面这个完整的例子，它是一个非常复杂的结果映射（假设作者，博客，博文，评论和标签都是类型别名）。 不用紧张，我们会一步一步地来说明。虽然它看起来令人望而生畏，但其实非常简单。

<resultMap id="detailedBlogResultMap" type="Blog">
  <constructor>
    <idArg column="blog_id" javaType="int"/>
  constructor>
  <result property="title" column="blog_title"/>
  <association property="author" javaType="Author">
    <id property="id" column="author_id"/>
    <result property="username" column="author_username"/>
    <result property="password" column="author_password"/>
    <result property="email" column="author_email"/>
    <result property="bio" column="author_bio"/>
    <result property="favouriteSection" column="author_favourite_section"/>
  association>
  <collection property="posts" ofType="Post">
    <id property="id" column="post_id"/>
    <result property="subject" column="post_subject"/>
    <association property="author" javaType="Author"/>
    <collection property="comments" ofType="Comment">
      <id property="id" column="comment_id"/>
    collection>
    <collection property="tags" ofType="Tag" >
      <id property="id" column="tag_id"/>
    collection>
    <discriminator javaType="int" column="draft">
      <case value="1" resultType="DraftPost"/>
    discriminator>
  collection>
resultMap>

（动态Sql就是根据不同的条件生成不同的SQL）
动态SQL是MyBatis的强大特性之一，是一种根据特定条件动态拼装SQL语句的功能，它存在的意义是为了解决拼接SQL语句字符串时的痛点问题。如果你使用过JDBC或其它类似的框架，你应该能理解根据不同条件拱接SQL语句有多痛苦，例如拼接时要确保不能忘记添加必要的空格，还要注意去掉列表最后一个列名的逗号。利用动态SQL，可以彻底摆脱这种痛苦。

反例：使用下面这个查询语句传入的对象必须拥有所有的条件都写上才能查询,少了哪一个条件都会查询不出对象（但是我们要的是根据所选择的筛选条件来查询用户）

 <select id="findByCondition" resultType="com.zkf.pojo.Blog">
        select *
        from test.blog
        where id = #{id}
          and title = #{title}
          and author = #{author}
    select>

那么 如何根据需求生成不同的SQL呢？

<select id="findByCondition" resultType="com.zkf.pojo.Blog">
        select *from test.blog
        <where>
            <if test="id!=0">
                and id = #{id}
            if>
            <if test="title != null">
                and title = #{title}
            if>
            <if test="author != null">
                and author = #{author}
            if>
        where>
    select>

<dependency>
      <groupId>com.github.pagehelpergroupId>
      <artifactId>pagehelperartifactId>
      <version>3.7.5version>
    dependency>
    
    <dependency>
      <groupId>com.github.jsqlparsergroupId>
      <artifactId>jsqlparserartifactId>
      <version>0.9.1version>
    dependency>

<plugins>
    
    <plugin interceptor="com.github.pagehelper.PageHelper">
        <property name="dialect" value="mysql" />
        
        

    plugin>
    plugins>

//pageNum：当前页的页码，pageSize：每页显示的条数
PageHelper.startPage(int pageNum, int pageSize)