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

一、Mybaits中文网

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的核心竞争力。

附：Mybatis的两种映射方式

MyBatis 有两种 SQL 语句映射模式，一种是基于注解，一种是基于XML。

Mybatis应该选择哪种映射方式呢？MyBatis 项目开发中是基于 XML 还是注解？
总结：实际项目开发中，用哪种实现方式取决于团队，因此两种都需要了解。
自己开发时，简单 SQL 语句采用注解模式，复杂 SQL 语句采用 XML 模式。（个人认为对Mybatis来说，XML是核心）

三、快速入门(XML方式)

3.0 创建一个maven项目

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

3.1 导入对应的依赖

<dependencies>
		<!-- Mybatis核心 -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.2</version>
        </dependency>

        <!--注册mysql驱动-->
        <!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.11</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/org.junit.jupiter/junit-jupiter-api -->
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter-api</artifactId>
            <version>5.7.0</version>
            <scope>test</scope>
        </dependency>
		<dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
		
<!--         https://mvnrepository.com/artifact/log4j/log4j-->
           <dependency>
              <groupId>log4j</groupId>
              <artifactId>log4j</artifactId>
              <version>1.2.17</version>
            </dependency>
            

    </dependencies>

3.2 创建数据库，并且对应数据库表的字段创建pojo对象（javaBean）

3.3 编写User的程序实体类（表给实体进行映射）

操作实体从而间接操作表
查询表从而间接封装实体

程序的属性设置对应数据库的字段

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

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

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

3.4 编写Mapper接口

通过动态代理创建出具有 Mapper 接口行为的代理对象，方法中具体执行的 SQL 则是取自映射文件
备注：mapper代理方式，需要满足以下要求

1．定义与SQL映射文件同名的Mapper接口，并且将Mapper接口和SQL映射文件放置在同一目录下
2．设置SQL映射文件的namespace属性为Mapper接口全限定名
3．在Mapper接口中定义方法，方法名就是SQL映射文件中sql语句的id，并保持参数类型和返回值
类型一致

附：程序如何调用/编码该方法？
1.通过SqlSession的getMapper方法【获取Mapper接口的代理对象】
2.【调用对应方法】完成sql的执行

Mapper接口如下：

3.5 编写映射文件UserMapper.xml（用于编写SQL）

Mapper.xml映射文件一般用于【统一】编写SQL语句，然后通过核心配置文件的<mappers>标签加载（多个）映射文件进入核心配置文件中，java程序只需要加载核心配置文件就可以加载所有的映射文件了

<?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="mapper.TeacherMapper">
    <select id="findAll" resultType="pojo.Teacher">
        select *from teacher
    </select>

</mapper>

这里说明下：pojo和数据库表是如何绑定的？
操作实体从而间接操作表
（程序通过调用方法 ，执行指定sql的语句，来完成数据库表的操作）

查询表从而间接封装成pojo实体对象
（程序通过调用方法 ，执行查询数据库的表，将查询的结果封装为pojo实体对象）

3.6 创建核心配置文件

在resources下创建核心配置文件mybatis-config.xml/sqlMapConfig.xml（一般是叫这两个名字，其他名字也可以）
核心配置文件的作用：
1、主要用于配置连接数据库的环境以及MyBatis的全局配置信息
2、核心配置文件存放的位置是src/main/resources目录下
3、【加载其他映射文件】

<?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"></transactionManager>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql:///【数据库名】?useUnicode=true&amp;characterEncoding=UTF-8&amp;useSSL=false&amp;autoReconnect=true&amp;failOverReadOnly=false&amp;serverTimezone=GMT%2B8"/>
                <property name="username" value="【数据库用户名】"/>
                <property name="password" value="【数据库密码】"/>
            </dataSource>
        </environment>
    </environments>

    <!--加载映射文件，然后只用程序调用这个核心文件就可以调用映射文件了-->
    <mappers>
        <mapper resource="【相对resources目录的路径】mapper/UserMapper.xml"></mapper>
    </mappers>
    
</configuration>

3.7 开始测试

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

---

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

---

SqlSession：代表Java程序和数据库之间的会话。(HttpSession是Java程序和浏览器之间的会话)，可用于执行sql语句
操作事务的方法主要有:
void commit()
void rollback()

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

---

mapper代理模式：
1.通过SqlSession的getMapper方法【获取Mapper接口的代理对象】
2.【调用对应方法】完成sql的执行
（备注：下面截图的18行是分页插件，暂时不用管）

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");
        /**获取工厂对象：目的工厂类生产session会话对象*/
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
        /**获取session会话对象——工厂打开一个会话*/
        SqlSession sqlSession = sqlSessionFactory.openSession();
		//通过Class字节码反射创建一个TeacherMapper
		TeacherMapper mapper = sqlSession.getMapper(TeacherMapper.class);
        

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

程序是如何完成数据库和实体间的映射的？（如何保证java程序操作的实体类对象就是数据库的对象）

因此，上面的程序加载核心配置文件sqlMapConfig.xml，
程序通过动态代理创建出具有 Mapper 接口行为的代理对象，方法中具体执行的 SQL语句 则是取自映射文件。
下面是核心文件加载文件以及绑定xml文件与Mapper接口代理对象
核心配置文件中可以加载多个xml映射文件（还有加载数据库源等其他作用）
xml映射文件中 通过标签【绑定】【容器对象和Mapper接口】代表的对象，并且xml文件还负责sql语句的编写
绑定完成后，mapper代理对象就可以调用sql语句操作数据库了

附：pojo实体类和数据库表是如何进行映射的？

附：用@Before等抽取出获取session会话对象的固定模板

每次测试代码时，都得重复获取mapper，可以使用@before、@After抽取出重复性的操作

public class MybatisTest {
    private TeacherMapper mapper;
    private SqlSession sqlSession;
    @Before
    public void before()throws IOException {
        /**
         * 获取核心配置文件* Resources ：import org.apache.ibatis.io.Resources;*/
        InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");
        /**获取工厂对象*/
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
        /**获取session会话对象——工厂打开一个会话*/
        sqlSession = sqlSessionFactory.openSession(true);
        mapper = sqlSession.getMapper(TeacherMapper.class);
    }
    
    @After
    public void after ()throws IOException {
        sqlSession.close();
    }
}

四、添加新的方法（测试增删改查）

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

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

mapper接口的全限定名，要和mapper.xml的namespace属性一致
mapper接口中的方法名要和mapper.xml中的SQL标签的id一致
mapper接口中的方法入参类型，要和mapper.xml中SQL语句的入参类型一致
mapper接口中的方法出参类型，要和mapper.xml中SQL语句的返回值类型一致
3、测试：查找所有的用户

注意：下方测试方法的时候，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 的配置文件包含了会深深影响 MyBatis 行为的设置和属性信息。 配置文档的顶层结构如下：

5.1 properties标签：

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

5.2 环境配置（environments）

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

下面演示引入jdbc.properties文件

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、在核心配置文件中配置引入

<?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>
    <!--引入properties文件，此时就可以${属性名}的方式访问属性值-->
    <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>

5.3 mapper 核心文件加载映射xml文件

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

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

2、 扫描整个包

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

引入映射文件

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

5.4typeAliases标签（起类型别名）

类型别名可为 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结果集映射（简单使用）

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

resultMap：设置自定义映射
具体作用：resultMap可以实现将查询结果映射为复杂类型的pojo，比如在查询结果映射对象中包括pojo和list实现一对一查询和一对多查询

属性：
id：表示自定义映射的唯一标识，不能重复
type：查询的数据要映射的实体类的类型
子标签：
id：设置主键的映射关系
result：设置普通字段的映射关系
property：设置映射关系中实体类中的属性名
column：设置映射关系中表中的字段名

当数据库中的字段和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>

七、多表查询

多表查询在数据库查询中不算难，但是在java程序中不能像是数据库查询中一样
首先，pojo实体类中外键对应的tid，应该是一个对象，而不是一个int类型的id，（java中实体与实体的关系是通过实体的引用去维系的），因此会导致数据库中的字段和pojo的实体属性不一致，导致最终结果查询不出

【数据库的多表查询问题本质上还是解决程序实体类属性名和数据库表的字段不一致的问题】

什么是多对一：
多个学生只有一个老师（查询主体是学生）
从编程语句来说，查询出所有的学生（学生拥有一个teacher属性）
什么是一对多：
一对多就是查询那一个老师 的所有学生（查询主体是老师）
从编程语句来说，查询出单个老师，该老师拥有List学生属性
（备注：这里为了方便理解，可以把老师认为是班主任）

多对一映射：

附1、多对一 准备工作（可以复制我的代码尝试自己运行，不想运行可直接从旁边的目录跳到下面）

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, 'x老师'); 

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、编程实体类和Mapper映射

Teacher实体

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@NoArgsConstructor
@AllArgsConstructor
public class Teacher {
    private int id;
    private String name;
}

TeacherMapper映射

public interface TeacherMapper {
        Teacher getTeacher(@Param("tid") int id);
}

Student实体

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@NoArgsConstructor
@AllArgsConstructor
public class Student {
    private int id;
    private String name;
    //学生需要关联一个老师，因此在学生类中需要有一个老师的对象
    private Teacher teacher;
}

StudentMapper映射

import java.util.List;

public interface StudentMapper {
    public List<Student> getStudent();
    public List<Student> getStudent2();
}

3、映射文件

studentMapper.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.zkf.mapper.StudentMapper">
    
<!--    方法一：查询嵌套（子查询）-->
    <select id="getStudent" resultMap="studentMap">
        select * from student
    </select>

    <resultMap id="studentMap" type="com.zkf.pojo.Student">
        <result property="id" column="id"/>
        <result property="name" column="name"/>
        <association property="teacher" column="tid" javaType="com.zkf.pojo.Teacher" select="getTeacher"/>
    </resultMap>

    <select id="getTeacher" resultType="com.zkf.pojo.Teacher">
        select * from teacher where id = #{id}
    </select>

    <!--方法二：按照结果嵌套处理-->
    <select id="getStudent2" resultMap="studentMap2">
        select s.id sid,s.name sname,t.name tname,t.id tid from student s , teacher t where  tid = t.id;
    </select>
    <resultMap id="studentMap2" type="com.zkf.pojo.Student">
        <result property="id" column="sid"/>
        <result property="name" column="sname"/>
        <association property="teacher"  javaType="com.zkf.pojo.Teacher" >
            <result property="name" column="tname"/>
            <result property="id" column="tid"/>
        </association>
    </resultMap>
</mapper>

teacherMapper.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.zkf.mapper.TeacherMapper">

    <select id="getTeacher" resultType="com.zkf.pojo.Teacher">
    </select>
</mapper>

附2、一对多准备工作

1、编程实体类和Mapper映射

编程实体类和Mapper映射
Teacher类

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

Student类

@Data
@NoArgsConstructor
@AllArgsConstructor
public class Student {
    private int id;
    private String name;
    //学生需要关联一个老师，因此在学生类中需要有一个老师的对象
    private int tid;
}

StudentMapper接口

public interface StudentMapper {
}

TeacherMapper接口

public interface TeacherMapper {
    //获取指定老师下的所有学生及老师的信息
    Teacher getTeacher(@Param("tid") int id);

    //获取指定老师下的所有学生及老师的信息
    Teacher getTeacher2(@Param("tid") int id);
}

2、映射文件

studentMapper.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="zkf.mapper.StudentMapper">
</mapper>

teacherMapper.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="zkf.mapper.TeacherMapper">

    <select id="getTeacher" resultMap="TeacherMap">
        select s.id as sid, s.name as sname, t.name as tname, t.id as tid
        from student s,
             teacher t
        where s.tid = t.id
          and t.id = #{tid}
    </select>
    <resultMap id="TeacherMap" type="zkf.pojo.Teacher">
        <result property="id" column="tid"></result>
        <result property="name" column="tname"></result>
        <!--        javaType=""”指定属性的类型!-->
        <!--        集合中的泛型信息，我们使用ofType获取-->
        <collection property="students" ofType="zkf.pojo.Student">
            <result property="id" column="sid"/>
            <result property="name" column="sname"/>
            <result property="tid" column="tid"/>
        </collection>
    </resultMap>

    <select id="getTeacher2" resultMap="TeacherMap2">
        select *
        from teacher
        where id = #{tid}
    </select>
    <resultMap id="TeacherMap2" type="zkf.pojo.Teacher">
        <collection property="students" ofType="zkf.pojo.Student"
                    select="getStudentByTeacherId" column="id"/>
    </resultMap>
    <select id="getStudentByTeacherId" resultType="zkf.pojo.Student">
        select * from student
        where tid = #{tid}
    </select>
</mapper>

需求：【查询出所有的学生（多）】及其对应的一个老师（一）

查询sql目标语句：

步骤一：将该外键以(单个)对象的形式写入实体类

外键tid在数据库中可以表示另一个数据库表的id，进而代表一个数据对象，但是在程序实体中，int类型的id不可能代表一个对象（因为无法表示对象的属性，比如说Teacher对象的name不能用id来表示）所以，pojo实体类中外键对应的tid，应该是一个对象，这里tid对应的对象teacher，如下图

问题：编程查询不出学生【所属】老师

为什么查询不到？
tid外键对应的teacher对象没有映射到teacher表

方法一：那么将每个学生的teacher属性（tid外键）和数据库的teacher表映射即可
通过使用Resultmap结果集映射的标签处理多对一的映射关系
方法二：
1、查询数据库teacher表中id=tid的teacher数据给Student实体类的teacher属性
2、此时再查询student表，就能够查询到Student的teacher属性（过程1返回的）

步骤二：完成映射

方法一：按照结果嵌套处理（单个对象用<association>）

Teacher为Student的一个对象，
1、将Student实体类的属性和数据库student表的字段进行映射
2、针对teachers【Student实体类的Teacher对象属性】和数据库Teacher表进行映射

附：Resultmap结果集 参数说明

resultMap：设置自定义映射
resultMap属性：

• id：表示自定义映射的唯一标识，不能重复
• type：查询的数据要映射的实体类的类型
• association：一个复杂类型的【关联】；许多结果将包装成这种类型（下面用来映射对象）（association是用于一对一和【多对一】）
• collection：一个复杂类型的【集合】（映射对象）（而collection是用于【一对多】的关系）

子标签：

• id：设置主键的映射关系

• result：设置普通字段的映射关系

• 子标签属性：
  property：设置映射关系中实体类中的属性名
  column：设置映射关系中数据库的表中的字段名
  javaType:设置映射关系中实体类中的属性类型
  ofTyper：用来指定映射到List或者集合中的pojo类型，【泛型】中的约束类型

方法二：查询嵌套（子查询）

子查询上面配置的映射不同
过程：
1、查询数据库teacher表中id=tid的teacher数据给Student实体类的teacher属性
2、此时再查询student表，就能够查询到Student的teacher属性（过程1返回的）

备注：
1、JavaType是用来指定pojo中属性的类型，
而ofType指定的是映射到list集合属性中pojo的类型
2、#{id}对应数据库的tid（column=tid）
查询结果：
【附：必须要给sql被查询的字段起别名,并用别名进行结果集映射,不然就会输出为null，（而且，也无法区分name是属于student表还是teacher表的字段）】

一对多：

需求：查询出指定的老师 及其所有学生
查询的主体是一（即老师）

步骤一：添加多个学生，即List集合

一个老师拥有多个学生（表拥有）
因此需要在老师中添加多个学生——即List集合**

直接查询

问题：直接查询无法查询出Teacher的Student属性

为什么无法查询？同上，没有完成自定义映射
解决：使用Resultmap结果集映射，使用collection标签将List<Student> students （一个属性）映射成数据库student表中的对应的多个学生

步骤二：完成映射

方法一：结果嵌套处理（多个对象用<collection>）

collection标签将List students （一个属性）映射成数据库student表中的对应的多个学生

方法二（子查询）：

1、select * from teacher where id = #{tid} (这里的tid就是传入的参数)
2、在结果集映射中 （找id=1的 students 的查询结果——调用getStudentByTeacherId方法，此方法中的#{tid}是结果集映射中的id=1）

查询结果：

总结（结果嵌套处理）：

查询多个对象，及该对象的外键（多对一）
1、将该外键以(单个)对象的形式写入实体类
2、完成每个Student的单个对象的映射 使用 <association>,去映射

查询一个对象，及其相对应的多个对象（一对多）
1、要查询一个对象里面的多个对象，需要先在实体类中添加多个对象的集合属性
2、完成单个Teacher类的多个对象形成的List集合的映射，使用 <collection>,去映射：property=“students（List集合对象名）” ofType=“zkf.pojo.Student（泛型的类型）”

多对多

实际上，多对多本质上是一对多（基本上一样）
举例：每个用户可以有多个角色，一个角色可以被多个用户使用
需求：查询出用户的同时查询出该用户的所有角色
那么对user的角色集合字段映射role字段即可。


查询目标（sql）

操作：对user的角色集合字段映射role字段

八、动态SQL

（动态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呢？

8.1 <if>标签

当满足test条件时，才会将标签内的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>

上面会根据传入的参数动态生成sql语句
比如：Preparing: select *from test.blog WHERE id = ? and title = ?

8.2 choose、when、otherwise

• choose、when、otherwise相当于if...else if..else(swith case default)
• when至少要有一个，otherwise至多只有一个
• when中只会满足其中一个，前面的满足了，就执行前面的，如果都没有满足，那么执行otherwise中的语句
• 
  相当于if a else if b else if c else d，只会执行其中一个

8.3 foreach

collection：设置要循环的数组或集合
item：表示集合或数组中的每一个数据(元素)
separator：设置循环体之间的分隔符，分隔符前后默认有一个空格，如,
open：设置foreach标签中的内容的开始符
close：设置foreach标签中的内容的结束符

index：
当使用数组时，index 是当前迭代的序号，item 的值是本次迭代获取到的元素。
当使用 Map 对象（或者 Map.Entry 对象的集合）时，index 是键，item 是值。

查询id为1-3
SELECT* FROM USER WHERE 1=1 and id=1 or id=2 or id=3）

SELECT*FROM USER WHERE id IN(1,2,3)
对应动态sql标签 foreach

你也可以使用@param给参数命名

8.4 sql标签

可将重复的SQL片段提取出来，然后在需要的地方，使用标签进行引用

九、分页插件

1、引入依赖

<dependency>
      <groupId>com.github.pagehelper</groupId>
      <artifactId>pagehelper</artifactId>
      <version>3.7.5</version>
    </dependency>
    <!-- https://mvnrepository.com/artifact/com.github.jsqlparser/jsqlparser -->
    <dependency>
      <groupId>com.github.jsqlparser</groupId>
      <artifactId>jsqlparser</artifactId>
      <version>0.9.1</version>
    </dependency>

2、核心配置文件中配置分页助手

<plugins>
    <!--核心配置文件中配置分页助手 -->
    <plugin interceptor="com.github.pagehelper.PageHelper">
        <property name="dialect" value="mysql" />
        <!-- 该参数默认为false -->
        <!-- 设置为true时，使用RowBounds分页会进行count查询 -->
<!--        <property name="rowBoundsWithCount" value="true" />-->
    </plugin>
    </plugins>

3、开启分页功能

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

4、开始测试

5、分页插件常用数据：
pageNum：当前页的页码
pageSize：每页显示的条数
size：当前页显示的真实条数
total：总记录数
pages：总页数
prePage：上一页的页码
nextPage：下一页的页码
isFirstPage/isLastPage：是否为第一页/最后一页
hasPreviousPage/hasNextPage：是否存在上一页/下一页
navigatePages：导航分页的页码数
navigatepageNums：导航分页的页码，[1,2,3,4,5]

引用文章：
1、https://blog.csdn.net/Littewood/article/details/123986392?spm=1001.2014.3001.5501
2、mybatis看这一篇就够了，简单全面一发入魂

---

java连接数据库专栏文章：

java连接数据库（一）：JDBC

Java连接数据库（二）：数据库连接池（druid）

java连接数据库（三）：Spring JDBC/JDBC Template

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

java连接数据库（4.2）：Mybatis框架注解的简单使用