devbox
IT小白
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

MyBatis学习总结（三）MyBatis 的连接池技术MyBatis 的事务控制手动提交事务MyBatis 的动态 SQL 语句MyBatis 多表查询一对一、多对一、一对多、多对多查询_mybatisplus 手动提交事务

作者：IT小白 | 2024-03-09 18:26:22

赞

踩

mybatisplus 手动提交事务

MyBatis学习总结（三）MyBatis 的连接池技术/MyBatis 的事务控制/手动提交事务/MyBatis 的动态 SQL 语句/MyBatis 多表查询/一对一、多对一、一对多、多对多查询

一、MyBatis 的连接池技术分类

  • 连接池就是一个用于存储连接的容器。这个容器其实就是一个集合对象，该集合必须是线程安全的，不能两个线程同时拿到同一个连接。该集合还必须有队列的特性：先进先出（归还的连接放在连接池队列的末尾）。
  • 我们在实际开发中都会使用数据库连接池，因为它可以减少我们获取连接所消耗的时间。
  • 我们在JDBC部分也学习过类似的连接池技术，而在 MyBatis 中也有连接池技术，但是它采用的是自己的连接池技术。在 MyBatis 的核心配置文件中，通过<dataSource type="具体连接池技术">来实现 MyBatis 中连接池的配置。
  • MyBatis核心配置文件中的dataSource标签，type属性就是表示采用何种连接池方式。
  • Mybatis 将它自己的数据源（连接池技术）分为三类（type属性的取值）：
    • POOLED：使用传统的 javax.sql.DataSource 规范中的连接池的数据源
    • UNPOOLED：采用传统的获取连接的方式，虽然也实现 javax.sql.DataSource 接口，但不使用连接池的数据源
    • JNDI：采用服务器提供的JNDI技术实现来获取DataSource对象，不同的服务器所能拿到DataSource是不一样的。
      注意：如果不是web或者maven的war工程，是不能使用JNDI的。
      我们如果使用的是Tomcat服务器，那么JNDI采用的连接池就是DBCP连接池。

在这三种数据源中，我们一般采用的是 POOLED 数据源。

（一）POOLED

MyBatis核心配置文件：

<!-- 配置数据源（连接池）信息 --> 
<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>
1234567

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • MyBatis 在初始化时，根据<dataSource>的 type 属性来创建相应类型的的数据源 DataSource，即：
    type="POOLED"：MyBatis 会创建 PooledDataSource 实例
    type="UNPOOLED" ： MyBatis 会创建 UnpooledDataSource 实例
    type="JNDI"：MyBatis 会从 JNDI 服务上查找 DataSource 实例，然后返回使用
  • PooledDataSource和UnpooledDataSource都实现了 javax.sql.DataSource 接口。并且PooledDataSource持有一个UnpooledDataSource的引用，当PooledDataSource需要创建 java.sql.Connection 实例对象时，还是通过UnpooledDataSource来创建，PooledDataSource只是提供一种缓存连接池机制。

MyBatis中的DataSource的存取和连接的获取过程：

  • MyBatis 是通过工厂模式来创建数据源 DataSource 对象的，MyBatis 定义了抽象的工厂接口:org.apache.ibatis.datasource.DataSourceFactory，通过其 getDataSource()方法返回数据源DataSource。
  • MyBatis 创建了 DataSource 实例后，会将其放到 Configuration 对象内的 Environment 对象中， 供以后使用。
  • 当我们需要创建 SqlSession 对象并需要执行 SQL 语句时，这时候 MyBatis 才会去调用 dataSource 对象来创建java.sql.Connection对象。也就是说，java.sql.Connection对象的创建一直延迟到执行SQL语句的时候。数据库连接是我们最为宝贵的资源，只有在要用到的时候，才去获取并打开连接，当我们用完了就再立即将数据库连接归还到连接池中。

（二）UNPOOLED

MyBatis核心配置文件：

<!-- 配置数据源（连接池）信息 --> 
<dataSource type="UNPOOLED"> 
	<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>

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

（三）JNDI

JNDI：Java Naming and Directory Interface，Java命名和目录接口。是SUN公司推出的一套规范，属于JavaEE技术之一。目的是模仿windows系统中的注册表在服务器中注册数据源。

创建Maven的war工程并导入依赖：
在这里插入图片描述
在这里插入图片描述
配置自己安装的Maven版本（也可以选择默认的版本）：
在这里插入图片描述
导入依赖：

<dependencies>
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis</artifactId>
      <version>3.4.5</version>
    </dependency>

    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>5.1.6</version>
    </dependency>

    <dependency>
      <groupId>log4j</groupId>
      <artifactId>log4j</artifactId>
      <version>1.2.12</version>
    </dependency>

    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.10</version>
    </dependency>

    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>servlet-api</artifactId>
      <version>2.5</version>
    </dependency>

    <dependency>
      <groupId>javax.servlet.jsp</groupId>
      <artifactId>jsp-api</artifactId>
      <version>2.0</version>
    </dependency>

  </dependencies>

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38

在src/main下创建java、resource目录，并标记为对应的目录类型：
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述
User实体类：

import java.io.Serializable;
import java.util.Date;

public class User implements Serializable {

    private Integer userId;
    private String userName;
    private String userAddress;
    private String userSex;
    private Date userBirthday;

    public Integer getUserId() {
        return userId;
    }

    public void setUserId(Integer userId) {
        this.userId = userId;
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public String getUserAddress() {
        return userAddress;
    }

    public void setUserAddress(String userAddress) {
        this.userAddress = userAddress;
    }

    public String getUserSex() {
        return userSex;
    }

    public void setUserSex(String userSex) {
        this.userSex = userSex;
    }

    public Date getUserBirthday() {
        return userBirthday;
    }

    public void setUserBirthday(Date userBirthday) {
        this.userBirthday = userBirthday;
    }

    @Override
    public String toString() {
        return "User{" +
                "userId=" + userId +
                ", userName='" + userName + '\'' +
                ", userAddress='" + userAddress + '\'' +
                ", userSex='" + userSex + '\'' +
                ", userBirthday=" + userBirthday +
                '}';
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62

IUserDao：

import com.fox.pojo.User;
import java.util.List;

public interface IUserDao {
	//查询所有用户
    List<User> findAll();
}
1234567

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

IUserDao.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.fox.dao.IUserDao">
    <!-- 查询所有 -->
    <select id="findAll" resultType="com.fox.pojo.User">
        select * from user;
    </select>
</mapper>

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10

jdbc.properties：

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf8
jdbc.username=root
jdbc.password=123456

  • 1
  • 2
  • 3
  • 4

log4j.properties：

# Set root category priority to INFO and its only appender to CONSOLE.
#log4j.rootCategory=INFO, CONSOLE            debug   info   warn error fatal
log4j.rootCategory=debug, CONSOLE, LOGFILE

# Set the enterprise logger category to FATAL and its only appender to CONSOLE.
log4j.logger.org.apache.axis.enterprise=FATAL, CONSOLE

# CONSOLE is set to be a ConsoleAppender using a PatternLayout.
log4j.appender.CONSOLE=org.apache.log4j.ConsoleAppender
log4j.appender.CONSOLE.layout=org.apache.log4j.PatternLayout
log4j.appender.CONSOLE.layout.ConversionPattern=%d{ISO8601} %-6r [%15.15t] %-5p %30.30c %x - %m\n

# LOGFILE is set to be a File appender using a PatternLayout.
log4j.appender.LOGFILE=org.apache.log4j.FileAppender
log4j.appender.LOGFILE.File=d:\axis.log
log4j.appender.LOGFILE.Append=true
log4j.appender.LOGFILE.layout=org.apache.log4j.PatternLayout
log4j.appender.LOGFILE.layout.ConversionPattern=%d{ISO8601} %-6r [%15.15t] %-5p %30.30c %x - %m\n

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18

在webapp文件下创建META-INF目录，并在META-INF目录中建立一个名为context.xml的配置文件：

在这里插入图片描述
context.xml：

<?xml version="1.0" encoding="UTF-8"?>
<Context>
    <!--
    <Resource
    name="jdbc/test"						        数据源的名称
    type="javax.sql.DataSource"						数据源类型
    auth="Container"								数据源提供者
    maxActive="20"									最大活动数
    maxWait="10000"									最大等待时间
    maxIdle="5"										最大空闲数
    username="root"									用户名
    password="123456"								密码
    driverClassName="com.mysql.jdbc.Driver"			驱动类
    url="jdbc:mysql://localhost:3306/test"	        连接url字符串
    />
     -->
    <Resource
            name="jdbc/test"
            type="javax.sql.DataSource"
            auth="Container"
            maxActive="20"
            maxWait="10000"
            maxIdle="5"
            username="root"
            password="123456"
            driverClassName="com.mysql.jdbc.Driver"
            url="jdbc:mysql://localhost:3306/test"
    />
</Context>

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29

配置 MyBatis 核心配置文件SqlMapConfig.xml，数据源写JNDI：

<?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"></properties>

    <!--配置环境-->
    <environments default="mysql">
        <!-- 配置mysql的环境-->
        <environment id="mysql">
            <!-- 配置事务 -->
            <transactionManager type="JDBC"></transactionManager>
            <!-- 配置连接数据库的必备信息  type属性表示是否使用数据源（连接池）-->
            <dataSource type="JNDI">
                <property name="data_source" value="java:comp/env/jdbc/test"/><!--java:comp/env/是固定的-->
            </dataSource>
        </environment>
    </environments>
    <!-- 配置映射文件的位置 -->
    <mappers>
        <mapper resource="com/fox/dao/IUserDao.xml" />
    </mappers>
</configuration>

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25

配置Tomcat：
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述
在WEB-INF下的index.jsp中写测试代码（因为只有这样才会经过Tomcat服务器 ）：

<%@ page import="org.apache.ibatis.io.Resources" %>
<%@ page import="java.io.InputStream" %>
<%@ page import="org.apache.ibatis.session.SqlSessionFactoryBuilder" %>
<%@ page import="org.apache.ibatis.session.SqlSessionFactory" %>
<%@ page import="org.apache.ibatis.session.SqlSession" %>
<%@ page import="com.fox.dao.IUserDao" %>
<%@ page import="com.fox.pojo.User" %>
<%@ page import="java.util.List" %>
<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<html>
<body>
<h2>Hello World!</h2>
<%
    //1.读取配置文件
    InputStream in = Resources.getResourceAsStream("SqlMapConfig.xml");
    //2.根据配置文件构建SqlSessionFactory
    SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
    SqlSessionFactory factory = builder.build(in);
    //3.使用SqlSessionFactory创建SqlSession对象
    SqlSession sqlSession = factory.openSession();
    //4.使用SqlSession构建Dao的代理对象
    IUserDao userDao = sqlSession.getMapper(IUserDao.class);
    //5.执行dao中的findAll方法
    List<User> users = userDao.findAll();
    for(User user : users){
        System.out.println(user);
    }
    //6.释放资源
    sqlSession.close();
    in.close();
%>
</body>
</html>

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33

运行Tomcat：
在这里插入图片描述
IDEA输出：
在这里插入图片描述

二、MyBatis 的事务控制

在 JDBC 中我们可以通过手动方式将事务的提交改为手动方式，通过 setAutoCommit()方法就可以调整。那么我们的 Mybatis 框架因为是对 JDBC 的封装，所以 Mybatis 框架的事务控制方式，本身也是用 JDBC 的setAutoCommit()方法来设置事务提交方式的。
MyBatis是通过sqlsession对象的commit()方法和rollback()方法实现事务的提交和回滚。

（一）MyBatis 中手动提交事务方式

手动提交事务：sqlSession.commit();

我们运行之前所写的代码：

import com.fox.dao.IUserDao;
import com.fox.pojo.User;
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.After;
import org.junit.Before;
import org.junit.Test;
import java.io.IOException;
import java.io.InputStream;

public class MybatisTest {
    private InputStream in = null;
    private SqlSession sqlSession =null;
    private IUserDao userDao = null;

    @Before //标记在非静态方法上。在@Test方法前面执行，而且是在每一个@Test方法前面都执行。
    public void init() throws IOException {
        //1.读取配置文件
        in = Resources.getResourceAsStream("SqlMapConfig.xml");
        //2.使用构建者创建工厂对象 SqlSessionFactory
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);
        //3.使用 SqlSessionFactory 生产 SqlSession 对象
        sqlSession = factory.openSession();
        //4.使用 SqlSession 创建 dao 接口的代理对象
        userDao = sqlSession.getMapper(IUserDao.class);
    }

    @After //标记在非静态方法上。在@Test方法后面执行，而且是在每一个@Test方法后面都执行。
    public void destroy() throws IOException {
        //增删改，记得提交事务
        sqlSession.commit();
        //释放资源
        sqlSession.close();
        in.close();
    }

    @Test
    public void testAddUser(){
        User user = new User();
        //由于id是自增的，所以没有id
        user.setUserName("小黑");
        user.setBirthday(new Date());
        user.setUserAddress("上海");
        user.setSex("男");
        userDao.addUser(user);
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49

观察在它在控制台输出的结果：
在这里插入图片描述
这是我们的 Connection 的整个变化过程，通过分析我们能够发现之前的 CUD 操作过程中，我们都要手动进行事务的提交，原因是在执行前 setAutoCommit() 方法它的值被设置为 false 了，所以我们在 CUD 操作中，必须通过 sqlSession.commit()方法来执行提交操作。

（二）MyBatis 中自动提交事务方式

通过上面的研究和分析，现在我们一起思考，为什么 CUD 过程中必须使用 sqlSession.commit()提交事务？主要原因就是在连接池中取出的连接，都会将调用 connection.setAutoCommit(false)方法，这样我们就必须使用 sqlSession.commit()方法，相当于使用了 JDBC 中的 connection.commit()方法实现事务提交。
自动提交事务：SqlSession sqlSession = factory.openSession(true);

import com.fox.dao.IUserDao;
import com.fox.pojo.User;
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.After;
import org.junit.Before;
import org.junit.Test;
import java.io.IOException;
import java.io.InputStream;

public class MybatisTest {
    private InputStream in = null;
    private SqlSession sqlSession =null;
    private IUserDao userDao = null;

    @Before //标记在非静态方法上。在@Test方法前面执行，而且是在每一个@Test方法前面都执行。
    public void init() throws IOException {
        //1.读取配置文件
        in = Resources.getResourceAsStream("SqlMapConfig.xml");
        //2.使用构建者创建工厂对象 SqlSessionFactory
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);
        //3.使用 SqlSessionFactory 生产 SqlSession 对象
        sqlSession = factory.openSession(true);
        //4.使用 SqlSession 创建 dao 接口的代理对象
        userDao = sqlSession.getMapper(IUserDao.class);
    }

    @After //标记在非静态方法上。在@Test方法后面执行，而且是在每一个@Test方法后面都执行。
    public void destroy() throws IOException {
        //释放资源
        sqlSession.close();
        in.close();
    }

    @Test
    public void testAddUser(){
        User user = new User();
        //由于id是自增的，所以没有id
        user.setUserName("小黑");
        user.setBirthday(new Date());
        user.setUserAddress("上海");
        user.setSex("男");
        userDao.addUser(user);
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47

所对应的 DefaultSqlSessionFactory 类的源代码：
在这里插入图片描述

运行的结果如下：
在这里插入图片描述
我们发现，此时事务就设置为自动提交了，同样可以实现CUD操作时记录的保存。虽然这也是一种方式，但就编程而言，设置为自动提交方式为 false 再根据情况决定是否进行提交，（手动提交事务）这种方式更常用。因为我们可以根据业务情况来决定提交是否进行提交。

三、MyBatis 的动态 SQL 语句

Mybatis 的映射文件中，前面我们的 SQL 都是比较简单的，有些时候业务逻辑复杂时，我们的 SQL 是动态变化的，此时在前面的学习中我们的 SQL 就不能满足要求了。

（一）动态 SQL 之<if>标签

我们根据实体类的不同取值，使用不同的 SQL 语句来进行查询。比如在 id 如果不为空时可以根据 id 查询，如果 username 不为空时还要加入用户名作为条件。这种情况在我们的多条件组合查询中经常会碰到。

案例：
数据库：
在这里插入图片描述
对应的实体类User（字段与列名故意不一致）：

import java.util.Date;

public class User{

    private Integer id;
    private String userName;
    private Date birthday;
    private String sex;
    private String userAddress;

    public String getUserAddress() {
        return userAddress;
    }

    public void setUserAddress(String userAddress) {
        this.userAddress = userAddress;
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }
    public Integer getId() {
        return id;
    }

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

    public Date getBirthday() {
        return birthday;
    }

    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", userName='" + userName + '\'' +
                ", birthday=" + birthday +
                ", sex='" + sex + '\'' +
                ", userAddress='" + userAddress + '\'' +
                '}';
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60

IUserDao：

import com.fox.pojo.User;
import java.util.List;

public interface IUserDao {
    List<User> findByUser(User user);
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

IUserDao.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.fox.dao.IUserDao">
    <resultMap id="userMap" type="com.fox.pojo.User"> 
        <id column="id" property="id"/>
        <result column="username" property="userName"/>
        <result column="sex" property="sex"/>
        <result column="address" property="userAddress"/>
        <result column="birthday" property="birthday"/>
    </resultMap>

    <select id="findByUser" parameterType="com.fox.pojo.User" resultMap="userMap">
        select * from user where 1=1
        <if test="userName!=null and userName!=''">
            and username = #{userName}
        </if>
        <if test="userAddress!=null">
            and address=#{userAddress}
        </if>
        <!--注意：<if>标签的 test 属性中写的是对象的属性名，如果是包装类的对象要使用 OGNL 表达式的写法。
        另外如果只有if标签要注意写上 where 1=1，这样才能做下面的判断并加入条件
        if标签中的和是and而不是&&
        -->
    </select>
</mapper>

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28

测试类：

import com.fox.dao.IUserDao;
import com.fox.pojo.User;
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.After;
import org.junit.Before;
import org.junit.Test;
import java.io.IOException;
import java.io.InputStream;
import java.util.List;

public class MybatisTest {
    private InputStream in = null;
    private SqlSession sqlSession =null;
    private IUserDao userDao = null;

    @Before //标记在非静态方法上。在@Test方法前面执行，而且是在每一个@Test方法前面都执行。
    public void init() throws IOException {
        //1.读取配置文件
        in = Resources.getResourceAsStream("SqlMapConfig.xml");
        //2.使用构建者创建工厂对象 SqlSessionFactory
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);
        //3.使用 SqlSessionFactory 生产 SqlSession 对象
        sqlSession = factory.openSession();
        //4.使用 SqlSession 创建 dao 接口的代理对象
        userDao = sqlSession.getMapper(IUserDao.class);
    }

    @After //标记在非静态方法上。在@Test方法后面执行，而且是在每一个@Test方法后面都执行。
    public void destroy() throws IOException {
		sqlSession.commit();
		//释放资源
        sqlSession.close();
        in.close();
    }

    @Test
    public void testFindByUser(){
        User user = new User();
        user.setUserName("小明");
        user.setUserAddress("广东");
        List<User> list = userDao.findByUser(user);
        for (User user1 : list) {
            System.out.println(user1);
        }
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49

在这里插入图片描述

（二）动态 SQL 之<where>标签

为了简化上面 where 1=1 的条件拼装，我们可以采用<where>标签来简化开发。

案例：
IUserDao：

import com.fox.pojo.User;
import java.util.List;

public interface IUserDao {
    List<User> findByUser(User user);
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

IUserDao.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.fox.dao.IUserDao">
    <resultMap id="userMap" type="com.fox.pojo.User"> 
        <id column="id" property="id"/>
        <result column="username" property="userName"/>
        <result column="sex" property="sex"/>
        <result column="address" property="userAddress"/>
        <result column="birthday" property="birthday"/>
    </resultMap>

    <select id="findByUser" parameterType="com.fox.pojo.User" resultMap="userMap">
        select * from user
        <where>
            <if test="userName!=null and userName!=''">
                username = #{userName}
            </if>
            <if test="userAddress!=null">
                and address=#{userAddress}
            </if>
        </where>
    </select>
</mapper>

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26

测试类：

import com.fox.dao.IUserDao;
import com.fox.pojo.User;
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.After;
import org.junit.Before;
import org.junit.Test;
import java.io.IOException;
import java.io.InputStream;
import java.util.List;

public class MybatisTest {
    private InputStream in = null;
    private SqlSession sqlSession =null;
    private IUserDao userDao = null;

    @Before //标记在非静态方法上。在@Test方法前面执行，而且是在每一个@Test方法前面都执行。
    public void init() throws IOException {
        //1.读取配置文件
        in = Resources.getResourceAsStream("SqlMapConfig.xml");
        //2.使用构建者创建工厂对象 SqlSessionFactory
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);
        //3.使用 SqlSessionFactory 生产 SqlSession 对象
        sqlSession = factory.openSession();
        //4.使用 SqlSession 创建 dao 接口的代理对象
        userDao = sqlSession.getMapper(IUserDao.class);
    }

    @After //标记在非静态方法上。在@Test方法后面执行，而且是在每一个@Test方法后面都执行。
    public void destroy() throws IOException {
		sqlSession.commit();
		//释放资源
        sqlSession.close();
        in.close();
    }

    @Test
    public void testFindByUser(){
        User user = new User();
        user.setUserName("小明");
        user.setUserAddress("广东");
        List<User> list = userDao.findByUser(user);
        for (User user1 : list) {
            System.out.println(user1);
        }
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49

在这里插入图片描述

（三）动态标签之<foreach>标签

  • 假如我们需要传入多个 id 查询用户信息：
    SELECT * FROM USERS WHERE id IN (42,43,46)
    这样我们在进行范围查询时，就要将一个集合中的值，作为参数动态添加进来。
    那么我们将如何进行参数的传递？这就要用到<foreach>标签

  • <foreach>

    • 1

    标签用于遍历集合，它的属性：

    • collection：代表要遍历的集合元素
    • open：代表语句的开始部分
    • close：代表结束部分
    • separator：代表分隔符
    • item：代表遍历集合的每个元素，生成的变量名

案例：
创建一个用于封装查询条件的类QueryVo，在 QueryVo 中加入一个 List 集合用于封装参数：

import java.io.Serializable;
import java.util.List;

public class QueryVo implements Serializable {
	private List<Integer> ids;

	public List<Integer> getIds() {
		return ids;
	}

	public void setIds(List<Integer> ids) {
		this.ids = ids;
	}
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14

IUserDao：

import com.fox.pojo.User;
import java.util.List;

public interface IUserDao {
	 List<User> findInIds(QueryVo vo);
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

IUserDao.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.fox.dao.IUserDao">
    <resultMap id="userMap" type="com.fox.pojo.User"> 
        <id column="id" property="id"/>
        <result column="username" property="userName"/>
        <result column="sex" property="sex"/>
        <result column="address" property="userAddress"/>
        <result column="birthday" property="birthday"/>
    </resultMap>

    <select id="findInIds" parameterType="com.fox.pojo.QueryVo" resultMap="userMap">
        select * from user
        <where>
            <if test="ids!=null and ids.size()>0">
                <foreach collection="ids" open="id in (" close=")" item="uid" separator=",">
                    #{uid} <!-- #{}里的名字由item的名字决定，必须保持一致 -->
                </foreach>
            </if>
        </where>
    </select>
</mapper>

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25

测试类：

import com.fox.dao.IUserDao;
import com.fox.pojo.User;
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.After;
import org.junit.Before;
import org.junit.Test;
import java.io.IOException;
import java.io.InputStream;
import java.util.List;

public class MybatisTest {
    private InputStream in = null;
    private SqlSession sqlSession =null;
    private IUserDao userDao = null;

    @Before //标记在非静态方法上。在@Test方法前面执行，而且是在每一个@Test方法前面都执行。
    public void init() throws IOException {
        //1.读取配置文件
        in = Resources.getResourceAsStream("SqlMapConfig.xml");
        //2.使用构建者创建工厂对象 SqlSessionFactory
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);
        //3.使用 SqlSessionFactory 生产 SqlSession 对象
        sqlSession = factory.openSession();
        //4.使用 SqlSession 创建 dao 接口的代理对象
        userDao = sqlSession.getMapper(IUserDao.class);
    }

    @After //标记在非静态方法上。在@Test方法后面执行，而且是在每一个@Test方法后面都执行。
    public void destroy() throws IOException {
		sqlSession.commit();
		//释放资源
        sqlSession.close();
        in.close();
    }

    @Test
    public void testFindInIds(){
        QueryVo vo = new QueryVo();
        List<Integer> list = new ArrayList<Integer>();
        list.add(42);
        list.add(43);
        list.add(46);
        vo.setIds(list);
        List<User> users = userDao.findInIds(vo);
        for (User user : users) {
            System.out.println(user);
        }
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52

在这里插入图片描述

（四）MyBatis中SQL 语句的重用

<sql>标签可将重复的 sql 语句提取出来，使用时用 <include>标签引用即可，最终达到 sql 重用的目的。

案例：

<?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.fox.dao.IUserDao">
    <resultMap id="userMap" type="com.fox.pojo.User"> 
        <id column="id" property="id"/>
        <result column="username" property="userName"/>
        <result column="sex" property="sex"/>
        <result column="address" property="userAddress"/>
        <result column="birthday" property="birthday"/>
    </resultMap>
    
    <!--定义复用代码片段-->
    <sql id="defaultSql">
        select * from user
    </sql>
    
    <select id="findInIds" parameterType="com.fox.pojo.QueryVo" resultMap="userMap">
        <include refid="defaultSql"></include>
        <where>
            <if test="ids!=null and ids.size()>0">
                <foreach collection="ids" open="id in (" close=")" item="uid" separator=",">
                    #{uid} <!-- #{}里的名字由item的名字决定，必须保持一致 -->
                </foreach>
            </if>
        </where>
    </select>
</mapper>

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30

四、 MyBatis 多表查询

表之间的关系有几种：

  • 一对一
  • 多对一
  • 一对多
  • 多对多

举例：

  • 用户和订单就是一对多，订单和用户就是多对一（一对一）：
    • 一个用户可以下多个订单
    • 多个订单属于同一个用户
    • 注意：开发中我们常常把多对一也看成一对一。比如用户和订单，拿出每一个订单，他都只能属于一个用户。所以MyBatis就把多对一看成了一对一。
  • 人和身份证号就是一对一：
    • 一个人只能有一个身份证号
    • 一个身份证号只能属于一个人
  • 老师和学生之间就是多对多：
    • 一个学生可以被多个老师教过
    • 一个老师可以教多个学生

（一）一对一查询（多对一查询）

示例：用户和账户
一个账户只能属于一个用户（多个账户也可以属于同一个用户）

（1）建立两张表：用户表，账户表
让用户表和账户表之间具备一对多的关系，需要使用外键在账户表中添加：

user表：

DROP TABLE IF EXISTS `user`;

CREATE TABLE `user` (
  `id` INT(11) NOT NULL AUTO_INCREMENT,
  `username` VARCHAR(32) NOT NULL COMMENT '用户名称',
  `birthday` DATETIME DEFAULT NULL COMMENT '生日',
  `sex` CHAR(1) DEFAULT NULL COMMENT '性别',
  `address` VARCHAR(256) DEFAULT NULL COMMENT '地址',
  PRIMARY KEY  (`id`)
) ENGINE=INNODB DEFAULT CHARSET=utf8;

INSERT  INTO `user`(`id`,`username`,`birthday`,`sex`,`address`) VALUES (41,'老王','2018-02-27 17:47:08','男','北京'),(42,'小王','2018-03-02 15:09:37','女','安徽'),(43,'小二','2018-03-04 11:34:34','女','上海'),(45,'小明','2018-03-04 12:04:06','男','广东'),(46,'杰克','2018-03-07 17:37:26','男','北京'),(48,'小马','2018-03-08 11:44:00','女','北京');

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12

在这里插入图片描述

account表：

DROP TABLE IF EXISTS `account`;

CREATE TABLE `account` (
  `ID` INT(11) NOT NULL COMMENT '编号',
  `UID` INT(11) DEFAULT NULL COMMENT '用户编号',
  `MONEY` DOUBLE DEFAULT NULL COMMENT '金额',
  PRIMARY KEY  (`ID`),
  KEY `FK_Reference_8` (`UID`),
  CONSTRAINT `FK_Reference_8` FOREIGN KEY (`UID`) REFERENCES `user` (`id`)
) ENGINE=INNODB DEFAULT CHARSET=utf8;

INSERT  INTO `account`(`ID`,`UID`,`MONEY`) VALUES (1,41,1000),(2,45,1000),(3,41,2000);

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12

在这里插入图片描述

我们想要的结果：
当我们查询账户时，可以同时得到账户的所属用户信息

SELECT a.id AS aid,a.uid,a.money,u.* FROM account a,USER u WHERE a.uid=u.id;

  • 1

在这里插入图片描述

（2）建立两个实体类：用户实体类和账户实体类
让账户和用户的实体类能体现出来一对一（多对一）的关系

User类：

import java.io.Serializable;
import java.util.Date;

public class User implements Serializable {

    private Integer id;
    private String username;
    private Date birthday;
    private String sex;
    private String address;

    public Integer getId() {
        return id;
    }

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

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public Date getBirthday() {
        return birthday;
    }

    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", birthday=" + birthday +
                ", sex='" + sex + '\'' +
                ", address='" + address + '\'' +
                '}';
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62

Account类（一对一、多对一关系映射：从表实体应该包含一个主表实体的对象引用）：

import java.io.Serializable;

public class Account implements Serializable {
    private Integer id;
    private Integer uid;
    private Double money;
    //一对一关系映射：从表实体应该包含一个主表实体的对象引用
    private User user;

    public User getUser() {
        return user;
    }

    public void setUser(User user) {
        this.user = user;
    }

    public Integer getId() {
        return id;
    }

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

    public Integer getUid() {
        return uid;
    }

    public void setUid(Integer uid) {
        this.uid = uid;
    }

    public Double getMoney() {
        return money;
    }

    public void setMoney(Double money) {
        this.money = money;
    }

    @Override
    public String toString() {
        return "Account{" +
                "id=" + id +
                ", uid=" + uid +
                ", money=" + money +
                '}';
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50

（3）建立账户的配置文件
IAccountDao：

import com.fox.pojo.Account;
import java.util.List;

public interface IAccountDao {
    //查询所有账户信息以及其所属的用户的信息
    List<Account> findAll();
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

IAccountDao.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.fox.dao.IAccountDao">

    <resultMap id="accountUser" type="com.fox.pojo.Account">
        <id property="id" column="aid"></id>    <!--由于在下面查询sql中起了别名aid，因此这里写aid-->
        <result property="uid" column="uid"></result>
        <result property="money" column="money"></result>
        <!-- 一对一的关系映射：association配置封装 User的内容。
        property表示实体类中属性名称，column表示以哪一列为依据获得这个属性，javaType：封装到哪个类-->
        <association property="user" column="uid" javaType="com.fox.pojo.User">
            <id property="id" column="id"></id>
            <result property="username" column="username"></result>
            <result property="sex" column="sex"></result>
            <result property="address" column="address"></result>
            <result property="birthday" column="birthday"></result>
        </association>
    </resultMap>

    <!-- 查询所有账户信息以及其所属的用户的信息 -->
    <select id="findAll" resultMap="accountUser">
        select u.*,a.id as aid,a.uid,a.money from account a,user u where u.id = a.uid;
    </select>

</mapper>

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27

（4）测试类：

import com.fox.dao.IAccountDao;
import com.fox.pojo.Account;
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.After;
import org.junit.Before;
import org.junit.Test;
import java.io.IOException;
import java.io.InputStream;
import java.util.List;

public class AccountTest {
    private InputStream in = null;
    private SqlSession sqlSession =null;
    private IAccountDao accountDao = null;

    @Before //标记在非静态方法上。在@Test方法前面执行，而且是在每一个@Test方法前面都执行。
    public void init() throws IOException {
        //1.读取配置文件
        in = Resources.getResourceAsStream("SqlMapConfig.xml");
        //2.使用构建者创建工厂对象 SqlSessionFactory
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);
        //3.使用 SqlSessionFactory 生产 SqlSession 对象
        sqlSession = factory.openSession();
        //4.使用 SqlSession 创建 dao 接口的代理对象
        accountDao = sqlSession.getMapper(IAccountDao.class);
    }

    @After //标记在非静态方法上。在@Test方法后面执行，而且是在每一个@Test方法后面都执行。
    public void destroy() throws IOException {
        sqlSession.commit();
        //释放资源
        sqlSession.close();
        in.close();
    }

    @Test
    public void testFindAll(){
        List<Account> accounts = accountDao.findAll();
        for(Account account : accounts){
            System.out.println("---------------每条账户信息--------------");
            System.out.println(account);
            System.out.println(account.getUser());
        }
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48

在这里插入图片描述

（二）一对多查询

示例：用户和账户
一个用户可以有多个账户

（1）建立两张表：用户表，账户表。

两表同上例。

我们想要的结果：
当我们查询所有用户时，可以同时得到用户下所包含的账户信息（查询结果包含所有用户并不一定包含所有账户，因此用左外连接）

select u.*,a.id as aid,a.uid,a.money from user u left outer join account a on u.id=a.uid;

  • 1

在这里插入图片描述

（2）建立两个实体类：用户实体类和账户实体类
让用户和账户的实体类能体现出来一对多的关系

Account类同上例。
User类（一对多关系映射：主表实体应该包含从表实体的集合引用）：

import java.io.Serializable;
import java.util.Date;
import java.util.List;

public class User implements Serializable {

    private Integer id;
    private String username;
    private Date birthday;
    private String sex;
    private String address;
    //一对多关系映射：主表实体应该包含从表实体的集合引用
    private List<Account> accounts;

    public List<Account> getAccounts() {
        return accounts;
    }

    public void setAccounts(List<Account> accounts) {
        this.accounts = accounts;
    }

    public Integer getId() {
        return id;
    }

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

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public Date getBirthday() {
        return birthday;
    }

    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", birthday=" + birthday +
                ", sex='" + sex + '\'' +
                ", address='" + address + '\'' +
                '}';
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73

（3）建立用户的配置文件
IUserDao：

import com.fox.pojo.User;
import java.util.List;

//用户的持久层接口
public interface IUserDao {
    //查询所有用户信息以及其帐户信息
    List<User> findAll();
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

IUserDao.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">

<!--namespace对应接口的全限定类名-->
<mapper namespace="com.fox.dao.IUserDao">

    <resultMap id="userAccount" type="com.fox.pojo.User">
        <id property="id" column="id"></id>
        <result property="username" column="username"></result>
        <result property="birthday" column="birthday"></result>
        <result property="sex" column="sex"></result>
        <result property="address" column="address"></result>
        <!-- 配置user对象中accounts集合的映射，ofType：集合元素的类型 
        collection定义了用户关联的账户信息。表示关联查询结果集
		property=""：关联查询的结果集存储在 User 对象的上哪个属性。
		ofType=""：指定关联查询的结果集中的对象类型即List中的对象类型。此处可以使用别名，也可以使用全限定名。-->
        <collection property="accounts" ofType="com.fox.pojo.Account">
            <id property="id" column="aid"></id>
            <result property="uid" column="uid"></result>
            <result property="money" column="money"></result>
        </collection>
    </resultMap>
    <select id="findAll" resultMap="userAccount">
        select u.*,a.id as aid,a.uid,a.money from user u left outer join account a on u.id=a.uid;
    </select>
</mapper>

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28

（4）测试类：

import com.fox.dao.IUserDao;
import com.fox.pojo.User;
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.After;
import org.junit.Before;
import org.junit.Test;
import java.io.IOException;
import java.io.InputStream;
import java.util.List;

public class UserTest {
    private InputStream in = null;
    private SqlSession sqlSession =null;
    private IUserDao userDao = null;

    @Before //标记在非静态方法上。在@Test方法前面执行，而且是在每一个@Test方法前面都执行。
    public void init() throws IOException {
        //1.读取配置文件
        in = Resources.getResourceAsStream("SqlMapConfig.xml");
        //2.使用构建者创建工厂对象 SqlSessionFactory
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);
        //3.使用 SqlSessionFactory 生产 SqlSession 对象
        sqlSession = factory.openSession();
        //4.使用 SqlSession 创建 dao 接口的代理对象
        userDao = sqlSession.getMapper(IUserDao.class);
    }

    @After //标记在非静态方法上。在@Test方法后面执行，而且是在每一个@Test方法后面都执行。
    public void destroy() throws IOException {
        sqlSession.commit();
        //释放资源
        sqlSession.close();
        in.close();
    }

    @Test
    public void testFindAll(){
        List<User> users = userDao.findAll();
        for (User user : users) {
            System.out.println("----------用户信息----------");
            System.out.println(user);
            System.out.println(user.getAccounts());
        }
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48

在这里插入图片描述

（三）多对多查询

多对多关系其实我们可以看成是双向的一对多关系。

示例：用户和角色
一个用户可以有多个角色
一个角色可以赋予多个用户

（1）建立三张表：用户表，角色表，中间表
让用户表和角色表具有多对多的关系。需要使用中间表，中间表中包含用户表和角色表各自的主键，在中间表中是外键。

用户表同上例。
角色表：

DROP TABLE IF EXISTS `role`;

CREATE TABLE `role` (
  `id` INT(11) NOT NULL COMMENT '编号',
  `role_name` VARCHAR(30) DEFAULT NULL COMMENT '角色名称',
  `role_desc` VARCHAR(60) DEFAULT NULL COMMENT '角色描述',
  PRIMARY KEY  (`id`)
) ENGINE=INNODB DEFAULT CHARSET=utf8;

INSERT  INTO `role`(`id`,`role_name`,`role_desc`) VALUES (1,'院长','管理整个学院'),(2,'总裁','管理整个公司'),(3,'校长','管理整个学校');

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10

在这里插入图片描述

中间表：

DROP TABLE IF EXISTS `user_role`;

CREATE TABLE `user_role` (
  `uid` INT(11) NOT NULL COMMENT '用户编号',
  `rid` INT(11) NOT NULL COMMENT '角色编号',
  PRIMARY KEY  (`uid`,`rid`),
  KEY `FK_Reference_10` (`rid`),
  CONSTRAINT `FK_Reference_10` FOREIGN KEY (`rid`) REFERENCES `role` (`id`),
  CONSTRAINT `FK_Reference_9` FOREIGN KEY (`uid`) REFERENCES `user` (`id`)
) ENGINE=INNODB DEFAULT CHARSET=utf8;

INSERT  INTO `user_role`(`uid`,`rid`) VALUES (41,1),(45,1),(41,2);

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12

在这里插入图片描述

（2）建立两个实体类：用户实体类和角色实体类
让用户和角色的实体类能体现出来多对多的关系，各自包含对方一个集合引用。
User：

import java.io.Serializable;
import java.util.Date;
import java.util.List;

public class User implements Serializable {

    private Integer id;
    private String username;
    private Date birthday;
    private String sex;
    private String address;
    //多对多的关系映射：各自包含对方一个集合引用（一个用户可以具备多个角色）
    private List<Role> roles;

    public List<Role> getRoles() {
        return roles;
    }

    public void setRoles(List<Role> roles) {
        this.roles = roles;
    }
    public Integer getId() {
        return id;
    }

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

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public Date getBirthday() {
        return birthday;
    }

    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", birthday=" + birthday +
                ", sex='" + sex + '\'' +
                ", address='" + address + '\'' +
                '}';
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72

Role：

import java.io.Serializable;
import java.util.List;

public class Role implements Serializable {

    private Integer roleId;
    private String roleName;
    private String roleDesc;

    //多对多的关系映射：各自包含对方一个集合引用（一个角色可以赋予多个用户）
    private List<User> users;

    public List<User> getUsers() {
        return users;
    }

    public void setUsers(List<User> users) {
        this.users = users;
    }

    public Integer getRoleId() {
        return roleId;
    }

    public void setRoleId(Integer roleId) {
        this.roleId = roleId;
    }

    public String getRoleName() {
        return roleName;
    }

    public void setRoleName(String roleName) {
        this.roleName = roleName;
    }

    public String getRoleDesc() {
        return roleDesc;
    }

    public void setRoleDesc(String roleDesc) {
        this.roleDesc = roleDesc;
    }

    @Override
    public String toString() {
        return "Role{" +
                "roleId=" + roleId +
                ", roleName='" + roleName + '\'' +
                ", roleDesc='" + roleDesc + '\'' +
                '}';
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53

（3）建立配置文件
用户的配置文件
IUserDao：

import com.fox.pojo.User;
import java.util.List;

public interface IUserDao {

    //查询所有用户以及所包含的角色信息
    List<User> findAll();
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

IUserDao.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">

<!--namespace对应接口的全限定类名-->
<mapper namespace="com.fox.dao.IUserDao">
    <!-- 定义User的resultMap-->
    <resultMap id="userMap" type="com.fox.pojo.User">
        <id property="id" column="id"></id>
        <result property="username" column="username"></result>
        <result property="birthday" column="birthday"></result>
        <result property="sex" column="sex"></result>
        <result property="address" column="address"></result>
        <collection property="roles" ofType="role">
            <id property="roleId" column="rid"></id>
            <result property="roleName" column="role_name"></result>
            <result property="roleDesc" column="role_desc"></result>
        </collection>
    </resultMap>
    <!-- 查询所有 -->
    <select id="findAll" resultMap="userMap">
        select r.id as rid,r.role_name,r.role_desc,u.* from user u
        left outer join user_role ur on u.id=ur.uid
        left outer join role r on ur.rid=r.id
    </select>
</mapper>

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27

角色的配置文件
IRoleDao：

import com.fox.pojo.Role;
import java.util.List;

public interface IRoleDao {
    //查询所有角色信息以及所对应的用户信息
    List<Role> findAll();
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

IRoleDao.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">

<!--namespace对应接口的全限定类名-->
<mapper namespace="com.fox.dao.IRoleDao">
    <!--定义role表的ResultMap-->
    <resultMap id="roleMap" type="com.fox.pojo.Role">
        <id property="roleId" column="rid"></id>
        <result property="roleName" column="role_name"></result>
        <result property="roleDesc" column="role_desc"></result>
        <collection property="users" ofType="com.fox.pojo.User">
            <id property="id" column="id"></id>
            <result property="username" column="username"></result>
            <result property="sex" column="sex"></result>
            <result property="birthday" column="birthday"></result>
            <result property="address" column="address"></result>
        </collection>
    </resultMap>
    <!--查询所有-->
    <select id="findAll" resultMap="roleMap">
        select r.id as rid,r.role_name,r.role_desc,u.* from role r
        left outer join user_role ur on r.id=ur.rid
        left outer join user u on ur.uid=u.id;
    </select>
</mapper>

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27

（4）测试：
当我们查询所有用户时，可以同时得到用户所包含的角色信息：

import com.fox.dao.IUserDao;
import com.fox.pojo.User;
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.After;
import org.junit.Before;
import org.junit.Test;
import java.io.IOException;
import java.io.InputStream;
import java.util.List;

public class UserTest {
    private InputStream in = null;
    private SqlSession sqlSession =null;
    private IUserDao userDao = null;

    @Before //标记在非静态方法上。在@Test方法前面执行，而且是在每一个@Test方法前面都执行。
    public void init() throws IOException {
        //1.读取配置文件
        in = Resources.getResourceAsStream("SqlMapConfig.xml");
        //2.使用构建者创建工厂对象 SqlSessionFactory
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);
        //3.使用 SqlSessionFactory 生产 SqlSession 对象
        sqlSession = factory.openSession();
        //4.使用 SqlSession 创建 dao 接口的代理对象
        userDao = sqlSession.getMapper(IUserDao.class);
    }

    @After //标记在非静态方法上。在@Test方法后面执行，而且是在每一个@Test方法后面都执行。
    public void destroy() throws IOException {
        sqlSession.commit();
        //释放资源
        sqlSession.close();
        in.close();
    }

    @Test
    public void testFindAll(){
        List<User> users = userDao.findAll();
        for (User user : users) {
            System.out.println("----------每个用户信息----------");
            System.out.println(user);
            System.out.println(user.getRoles());
        }
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48

在这里插入图片描述
当我们查询所有角色时，可以同时得到角色的所赋予的用户信息：

import com.fox.dao.IRoleDao;
import com.fox.pojo.Role;
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.After;
import org.junit.Before;
import org.junit.Test;
import java.io.IOException;
import java.io.InputStream;
import java.util.List;

public class RoleTest {
    private InputStream in = null;
    private SqlSession sqlSession =null;
    private IRoleDao roleDao = null;

    @Before //标记在非静态方法上。在@Test方法前面执行，而且是在每一个@Test方法前面都执行。
    public void init() throws IOException {
        //1.读取配置文件
        in = Resources.getResourceAsStream("SqlMapConfig.xml");
        //2.使用构建者创建工厂对象 SqlSessionFactory
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);
        //3.使用 SqlSessionFactory 生产 SqlSession 对象
        sqlSession = factory.openSession();
        //4.使用 SqlSession 创建 dao 接口的代理对象
        roleDao = sqlSession.getMapper(IRoleDao.class);
    }

    @After //标记在非静态方法上。在@Test方法后面执行，而且是在每一个@Test方法后面都执行。
    public void destroy() throws IOException {
        sqlSession.commit();
        //释放资源
        sqlSession.close();
        in.close();
    }

    @Test
    public void testFindAll(){
        List<Role> roles = roleDao.findAll();
        for (Role role : roles) {
            System.out.println("---------每个角色信息----------");
            System.out.println(role);
            System.out.println(role.getUsers());
        }
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48

在这里插入图片描述
在这里插入图片描述

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/IT小白/article/detail/216081
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号