Mybatis自我实践（二）一对多关联查询

mybatis 一对多实践操作

新建一张部门表--<t_dept>

DROP TABLE IF EXISTS `t_dept`;
CREATE TABLE `t_dept` (
        `id` int(10) NOT NULL AUTO_INCREMENT,
        `dept_name` varchar(20) DEFAULT NULL,
PRIMARY KEY (`id`)
) 
ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8;

INSERT INTO `t_dept` VALUES ('1', '开发部');
INSERT INTO `t_dept` VALUES ('2', '市场部');
INSERT INTO `t_dept` VALUES ('3', '行政部');

新建一个员工表---<t_emp>

DROP TABLE IF EXISTS `t_emp`;
CREATE TABLE `t_emp` (
        `id` int(10) NOT NULL AUTO_INCREMENT,
        `emp_name` varchar(100) DEFAULT NULL,
        `dept_id` int(10) DEFAULT NULL,
PRIMARY KEY (`id`)
)
ENGINE=InnoDB AUTO_INCREMENT=6 DEFAULT CHARSET=utf8;

INSERT INTO `t_emp` VALUES ('1', 'queen', '1');
INSERT INTO `t_emp` VALUES ('2', 'king', '1');
INSERT INTO `t_emp` VALUES ('3', 'tom', '2');
INSERT INTO `t_emp` VALUES ('4', 'james', '3');
INSERT INTO `t_emp` VALUES ('5', 'paul', '3');

从表的结构就可以看的出来我们的需求，，一对多的关系是：一个部门有好多个员工，

建立部门的实体类 TDept

package com.example.demo.bean;
import lombok.Data;

@Data
public class TDept {
  private Integer id;
  private String deptName;
}

建立员工的实体类Temp

package com.example.demo.bean;
import lombok.Data;

@Data
public class TEmp {

  private Integer id;
  private String empName;
  private Integer deptId;

}

建立部门包含多个员工的实体类DepToEmp

（这里面我选择了新建立一个实体类来继承其中代表“一”的一方“部门”，用List的集合来代表“多”的一方“员工”，因为  因为有的时候我们还需要进行单表的查询，如果我们在原有的单表的实体类的基础上更改了的话，那么单表的查询就会发生错误）

package com.example.demo.bean;
import lombok.Data;
import java.util.List;

@Data
public class DeptToEmp extends  TDept {

    private List<TEmp> emps;
}

先写出来想要的Mapper接口，来决定下一步好写什么sql进行查询

package com.example.demo.dao;
import com.example.demo.bean.DeptToEmp;
import com.example.demo.bean.TDept;
import com.example.demo.bean.TEmp;
import org.apache.ibatis.annotations.Mapper;
import org.springframework.stereotype.Component;
import java.util.List;

@Mapper
@Component
public interface TDeptAndDeptDao {

    //1、根据ID查询某一个部门
    TDept getDeptById(Integer id);

    //2、根据ID查询某一个员工
    TEmp getEmpById(Integer id);

    //3、根据ID查询某一个部门下包含的员工（一对多关联查询）
    DeptToEmp getDeptToEmpById(Integer id);

    //4、查询所有部门并且每一个部门下包含的员工（一对多关联查询）
    List<DeptToEmp> getDeptToEmpAll();
}

<!--1、根据ID查询某一个部门-->
<select id="getDeptById" resultType="com.example.demo.bean.TDept">
    select *
    from t_dept d
    where d.id = #{id}
</select>

<!--2、根据ID查询某一个员工-->
<select id="getEmpById" resultType="com.example.demo.bean.TEmp">
    select *
    from t_emp e
    where e.id = #{id}
</select>

<resultMap id="deptToEmp" type="com.example.demo.bean.DeptToEmp">
    <id column="mid" property="id"/>
    <result column="deptName" property="deptName"/>
    <!-- collection定义集合类型的属性封装规则；ofType：指定集合里面的元素类型-->
    <collection property="emps" ofType="com.example.demo.bean.TEmp">
        <!-- 定义这个集合中元素的封装规则 -->
        <id column="nid" property="id"/>
        <result column="empName" property="empName"/>
        <result column="deptId" property="deptId"/>
    </collection>
</resultMap>
<!--3、根据ID查询某一个部门下包含的员工-->
<select id="getDeptToEmpById" resultMap="deptToEmp">

    SELECT
        m.id mid,
        m.dept_name deptName,
        n.id nid,
        n.emp_name empName,
        n.dept_id deptId
    FROM
        t_dept m
        LEFT JOIN t_emp n ON m.id = n.dept_id
    WHERE
        m.id = #{id}
</select>

<!--4、查询所有部门并且每一个部门下包含的员工-->
<select id="getDeptToEmpAll" resultMap="deptToEmp">
    SELECT
        m.id mid,
        m.dept_name deptName,
        n.id nid,
        n.emp_name empName,
        n.dept_id deptId
    FROM
        t_dept m
        LEFT JOIN t_emp n ON m.id = n.dept_id
</select>

建立controller来测试这些个方法好不好用

package com.example.demo;
import com.example.demo.bean.DeptToEmp;
import com.example.demo.bean.TDept;
import com.example.demo.bean.TEmp;
import com.example.demo.dao.TDeptAndDeptDao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

@RestController
public class TestController {

    @Autowired
    private TDeptAndDeptDao tDeptAndDeptDao;

    //1、根据ID查询某一个部门
    @RequestMapping("/queryOneDeptById")
    public TDept queryOneDeptById(){
        TDept dept = tDeptAndDeptDao.getDeptById(1);
        return dept;
    }

    //2、根据ID查询某一个员工
    @RequestMapping("/queryOneEmpById")
    public TEmp queryOneEmpById(){
        TEmp emp = tDeptAndDeptDao.getEmpById(1);
        return emp;
    }

    //3、根据ID查询某一个部门下包含的员工（一对多关联查询）
    @RequestMapping("/queryOneDeptToEmp")
    public DeptToEmp queryOneDeptToEmp(){
        DeptToEmp deptToEmpById = tDeptAndDeptDao.getDeptToEmpById(1);
        return deptToEmpById;
    }

    //4、查询所有部门并且每一个部门下包含的员工（一对多关联查询）
    @RequestMapping("/queryListDeptToEmp")
    public List<DeptToEmp> queryListDeptToEmp(){
        List<DeptToEmp> deptToEmpAll = tDeptAndDeptDao.getDeptToEmpAll();
        return deptToEmpAll;
    }
} 

测试结果：

1、

2、

3、

4、