MyBatis多表操作

1 多表模型介绍

• 我们之前学习的都是基于单表操作的，而实际开发中，随着业务难度的加深，肯定需要多表操作的。

• 多表模型分类 一对一：在任意一方建立外键，关联对方的主键。
• 一对多：在多的一方建立外键，关联一的一方的主键。
• 多对多：借助中间表，中间表至少两个字段，分别关联两张表的主键。

2 多表模型一对一操作

1. 一对一模型： 人和身份证，一个人只有一个身份证

2. 代码实现

   • 步骤一: sql语句准备

     CREATE TABLE person(
      	id INT PRIMARY KEY AUTO_INCREMENT,
      	NAME VARCHAR(20),
      	age INT
      );
      INSERT INTO person VALUES (NULL,'张三',23);
      INSERT INTO person VALUES (NULL,'李四',24);
      INSERT INTO person VALUES (NULL,'王五',25);
      
      CREATE TABLE card(
      	id INT PRIMARY KEY AUTO_INCREMENT,
      	number VARCHAR(30),
      	pid INT,
      	CONSTRAINT cp_fk FOREIGN KEY (pid) REFERENCES person(id)
      );
      INSERT INTO card VALUES (NULL,'12345',1);
      INSERT INTO card VALUES (NULL,'23456',2);
      INSERT INTO card VALUES (NULL,'34567',3);
     

   • 步骤二: 创建实体类

     package com.itheima.bean;
     
     public class Person {
         private Integer id;     //主键id
         private String name;    //人的姓名
         private Integer age;    //人的年龄
     
         public Person() {
         }
     
         public Person(Integer id, String name, Integer age) {
             this.id = id;
             this.name = name;
             this.age = age;
         }
     
         public Integer getId() {
             return id;
         }
     
         public void setId(Integer id) {
             this.id = id;
         }
     
         public String getName() {
             return name;
         }
     
         public void setName(String name) {
             this.name = name;
         }
     
         public Integer getAge() {
             return age;
         }
     
         public void setAge(Integer age) {
             this.age = age;
         }
     
         @Override
         public String toString() {
             return "Person{" +
                     "id=" + id +
                     ", name='" + name + '\'' +
                     ", age=" + age +
                     '}';
         }
     }
     

     package com.itheima.bean;
     
     public class Card {
         private Integer id;     //主键id
         private String number;  //身份证号
     
         private Person p;       //所属人的对象
     
         public Card() {
         }
     
         public Card(Integer id, String number, Person p) {
             this.id = id;
             this.number = number;
             this.p = p;
         }
     
         public Integer getId() {
             return id;
         }
     
         public void setId(Integer id) {
             this.id = id;
         }
     
         public String getNumber() {
             return number;
         }
     
         public void setNumber(String number) {
             this.number = number;
         }
     
         public Person getP() {
             return p;
         }
     
         public void setP(Person p) {
             this.p = p;
         }
     
         @Override
         public String toString() {
             return "Card{" +
                     "id=" + id +
                     ", number='" + number + '\'' +
                     ", p=" + p +
                     '}';
         }
     }
     

   • 步骤三: dao层的mapper接口定义

     package com.itheima.table01;
     
     import com.itheima.bean.Card;
     
     import java.util.List;
     
     public interface OneToOneMapper {
         //查询全部
         public abstract List<Card> selectAll();
     }
     

   • 步骤四: 映射配置文件

     <?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.itheima.table01.OneToOneMapper">
         <!--配置字段和实体对象属性的映射关系-->
         <!--仔细观察column对应的值都是SQL语句中的字段本身或者别名-->
         <resultMap id="oneToOne" type="card">
             <id column="cid" property="id" />
             <result column="number" property="number" />
             <!--
                 association：配置被包含对象的映射关系
                 property：被包含对象的变量名
                 javaType：被包含对象的数据类型
             -->
             <!--仔细观察column对应的值都是SQL语句中的字段本身或者别名-->
             <!--下面的property="p"中的p对应的是Card类中引用person对象的变量名-->
             <association property="p" javaType="person">
                 <id column="pid" property="id" />
                 <result column="name" property="name" />
                 <result column="age" property="age" />
             </association>
         </resultMap>
     
         <select id="selectAll" resultMap="oneToOne">
             SELECT c.id cid,number,pid,NAME,age FROM card c,person p WHERE c.pid=p.id
         </select>
     </mapper>
     

   • 步骤五: 测试类（目前相当于service层实现类）

      @Test
         public void selectAll() throws Exception{
             //1.加载核心配置文件
             InputStream is = Resources.getResourceAsStream("MyBatisConfig.xml");
     
             //2.获取SqlSession工厂对象
             SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
     
             //3.通过工厂对象获取SqlSession对象
             SqlSession sqlSession = sqlSessionFactory.openSession(true);
     
             //4.获取OneToOneMapper接口的实现类对象
             OneToOneMapper mapper = sqlSession.getMapper(OneToOneMapper.class);
     
             //5.调用实现类的方法，接收结果
             List<Card> list = mapper.selectAll();
     
             //6.处理结果
             for (Card c : list) {
                 System.out.println(c);
             }
     
             //7.释放资源
             sqlSession.close();
             is.close();
         }
     

3. 一对一配置总结:

   <resultMap>：配置字段和对象属性的映射关系标签。
       id 属性：唯一标识
       type 属性：实体对象类型
   <id>：配置主键映射关系标签。
   <result>：配置非主键映射关系标签。
       column 属性：表中字段名称
       property 属性： 实体对象变量名称
   <association>：配置被包含对象的映射关系标签。
       property 属性：被包含对象的变量名
       javaType 属性：被包含对象的数据类型
   

3 多表模型一对多操作

1. 一对多模型： 一对多模型：班级和学生，一个班级可以有多个学生。

2. 代码实现

   • 步骤一: sql语句准备

     CREATE TABLE classes(
     	id INT PRIMARY KEY AUTO_INCREMENT,
     	NAME VARCHAR(20)
     );
     INSERT INTO classes VALUES (NULL,'一班');
     INSERT INTO classes VALUES (NULL,'二班');
     
     
     CREATE TABLE student(
     	id INT PRIMARY KEY AUTO_INCREMENT,
     	NAME VARCHAR(30),
     	age INT,
     	cid INT,
     	CONSTRAINT cs_fk FOREIGN KEY (cid) REFERENCES classes(id)
     );
     INSERT INTO student VALUES (NULL,'张三',23,1);
     INSERT INTO student VALUES (NULL,'李四',24,1);
     INSERT INTO student VALUES (NULL,'王五',25,2);
     INSERT INTO student VALUES (NULL,'赵六',26,2);
     

   • 步骤二: 创建实体类

     package com.itheima.bean;
     import java.util.List;
     
     public class Student {
         private Integer id;     //主键id
         private String name;    //学生姓名
         private Integer age;    //学生年龄
     
         public Student() {
         }
     
         public Student(Integer id, String name, Integer age) {
             this.id = id;
             this.name = name;
             this.age = age;
             this.courses = courses;
         }
     
         public Integer getId() {
             return id;
         }
     
         public void setId(Integer id) {
             this.id = id;
         }
     
         public String getName() {
             return name;
         }
     
         public void setName(String name) {
             this.name = name;
         }
     
         public Integer getAge() {
             return age;
         }
     
         public void setAge(Integer age) {
             this.age = age;
         }
     
         @Override
         public String toString() {
             return "Student{" +
                     "id=" + id +
                     ", name='" + name + '\'' +
                     ", age=" + age +
                     '}';
         }
     }
     

     package com.itheima.bean;
     import java.util.List;
     
     public class Classes {
         private Integer id;     //主键id
         private String name;    //班级名称
     
         private List<Student> students; //班级中所有学生对象
     
         public Classes() {
         }
     
         public Classes(Integer id, String name, List<Student> students) {
             this.id = id;
             this.name = name;
             this.students = students;
         }
     
         public Integer getId() {
             return id;
         }
     
         public void setId(Integer id) {
             this.id = id;
         }
     
         public String getName() {
             return name;
         }
     
         public void setName(String name) {
             this.name = name;
         }
     
         public List<Student> getStudents() {
             return students;
         }
     
         public void setStudents(List<Student> students) {
             this.students = students;
         }
     
         @Override
         public String toString() {
             return "Classes{" +
                     "id=" + id +
                     ", name='" + name + '\'' +
                     ", students=" + students +
                     '}';
         }
     }
     

   • 步骤三: dao层的mapper接口定义

     package com.itheima.table02;
     
     import com.itheima.bean.Classes;
     
     import java.util.List;
     
     public interface OneToManyMapper {
         //查询全部
         public abstract List<Classes> selectAll();
     }
     

   • 步骤四: 映射配置文件

     <?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.itheima.table02.OneToManyMapper">
         <resultMap id="oneToMany" type="classes">
             <id column="cid" property="id"/>
             <result column="cname" property="name"/>
     
             <!--
                 collection：配置被包含的集合对象映射关系
                 property：被包含对象的变量名
                 ofType：被包含对象的实际数据类型
             -->
              <!--仔细观察column对应的值都是SQL语句中的字段本身或者别名-->
             <!--下面的property="students"中的students对应的是Classes类中引用List<Student>对象的变量名-->
             <collection property="students" ofType="student">
                 <id column="sid" property="id"/>
                 <result column="sname" property="name"/>
                 <result column="sage" property="age"/>
             </collection>
         </resultMap>
         <select id="selectAll" resultMap="oneToMany">
             SELECT c.id cid,c.name cname,s.id sid,s.name sname,s.age sage FROM classes c,student s WHERE c.id=s.cid
         </select>
     </mapper>
     

   • 步骤五: 测试类（目前相当于service层实现类）

         @Test
         public void selectAll() throws Exception{
             //1.加载核心配置文件
             InputStream is = Resources.getResourceAsStream("MyBatisConfig.xml");
     
             //2.获取SqlSession工厂对象
             SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
     
             //3.通过工厂对象获取SqlSession对象
             SqlSession sqlSession = sqlSessionFactory.openSession(true);
     
             //4.获取OneToManyMapper接口的实现类对象
             OneToManyMapper mapper = sqlSession.getMapper(OneToManyMapper.class);
     
             //5.调用实现类的方法，接收结果
             List<Classes> classes = mapper.selectAll();
     
             //6.处理结果
             for (Classes cls : classes) {
                 System.out.println(cls.getId() + "," + cls.getName());
                 List<Student> students = cls.getStudents();
                 for (Student student : students) {
                     System.out.println("\t" + student);
                 }
             }
     
             //7.释放资源
             sqlSession.close();
             is.close();
         }
     

3. 一对多配置总结:

   <resultMap>：配置字段和对象属性的映射关系标签。
    	id 属性：唯一标识
    	type 属性：实体对象类型
    <id>：配置主键映射关系标签。
    <result>：配置非主键映射关系标签。
    	column 属性：表中字段名称
    	property 属性： 实体对象变量名称
    <collection>：配置被包含集合对象的映射关系标签。
    	 property 属性：被包含集合对象的变量名
    	 ofType 属性：集合中保存的对象数据类型
   

4 多表模型多对多操作

1. 多对多模型：学生和课程，一个学生可以选择多门课程、一个课程也可以被多个学生所选择。

2. 代码实现

   • 步骤一: sql语句准备

     CREATE TABLE course(
     	id INT PRIMARY KEY AUTO_INCREMENT,
     	NAME VARCHAR(20)
     );
     INSERT INTO course VALUES (NULL,'语文');
     INSERT INTO course VALUES (NULL,'数学');
     
     
     CREATE TABLE stu_cr(
     	id INT PRIMARY KEY AUTO_INCREMENT,
     	sid INT,
     	cid INT,
     	CONSTRAINT sc_fk1 FOREIGN KEY (sid) REFERENCES student(id),
     	CONSTRAINT sc_fk2 FOREIGN KEY (cid) REFERENCES course(id)
     );
     INSERT INTO stu_cr VALUES (NULL,1,1);
     INSERT INTO stu_cr VALUES (NULL,1,2);
     INSERT INTO stu_cr VALUES (NULL,2,1);
     INSERT INTO stu_cr VALUES (NULL,2,2);
     

   • 步骤二: 创建实体类(注意：此时Course类中没有引用Student的List Student中引用Course 没有中间表对应的实体类 稍后会进行研究)

     package com.itheima.bean;
     
     public class Course {
         private Integer id;     //主键id
         private String name;    //课程名称
     
         public Course() {
         }
     
         public Course(Integer id, String name) {
             this.id = id;
             this.name = name;
         }
     
         public Integer getId() {
             return id;
         }
     
         public void setId(Integer id) {
             this.id = id;
         }
     
         public String getName() {
             return name;
         }
     
         public void setName(String name) {
             this.name = name;
         }
     
         @Override
         public String toString() {
             return "Course{" +
                     "id=" + id +
                     ", name='" + name + '\'' +
                     '}';
         }
     }
     

     package com.itheima.bean;
     
     import java.util.List;
     
     public class Student {
         private Integer id;     //主键id
         private String name;    //学生姓名
         private Integer age;    //学生年龄
     
         private List<Course> courses;   // 学生所选择的课程集合
     
         public Student() {
         }
     
         public Student(Integer id, String name, Integer age, List<Course> courses) {
             this.id = id;
             this.name = name;
             this.age = age;
             this.courses = courses;
         }
     
         public List<Course> getCourses() {
             return courses;
         }
     
         public void setCourses(List<Course> courses) {
             this.courses = courses;
         }
     
         public Integer getId() {
             return id;
         }
     
         public void setId(Integer id) {
             this.id = id;
         }
     
         public String getName() {
             return name;
         }
     
         public void setName(String name) {
             this.name = name;
         }
     
         public Integer getAge() {
             return age;
         }
     
         public void setAge(Integer age) {
             this.age = age;
         }
     
         @Override
         public String toString() {
             return "Student{" +
                     "id=" + id +
                     ", name='" + name + '\'' +
                     ", age=" + age +
                     '}';
         }
     }
     

   • 步骤三: dao层的mapper接口定义

     package com.itheima.table03;
     import com.itheima.bean.Student;
     import java.util.List;
     
     public interface ManyToManyMapper {
         //查询全部
         public abstract List<Student> selectAll();
     }
     

   • 步骤四: 映射配置文件

     <?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.itheima.table03.ManyToManyMapper">
         <resultMap id="manyToMany" type="student">
             <id column="sid" property="id"/>
             <result column="sname" property="name"/>
             <result column="sage" property="age"/>
     
             <collection property="courses" ofType="course">
                 <id column="cid" property="id"/>
                 <result column="cname" property="name"/>
             </collection>
         </resultMap>
         <select id="selectAll" resultMap="manyToMany">
             SELECT sc.sid,s.name sname,s.age sage,sc.cid,c.name cname FROM student s,course c,stu_cr sc WHERE sc.sid=s.id AND sc.cid=c.id
         </select>
     </mapper>
     

   • 步骤五: 测试类（目前相当于service层实现类）

     package com.itheima.table03;
     
     public class Test01 {
         @Test
         public void selectAll() throws Exception{
             //1.加载核心配置文件
             InputStream is = Resources.getResourceAsStream("MyBatisConfig.xml");
     
             //2.获取SqlSession工厂对象
             SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
     
             //3.通过工厂对象获取SqlSession对象
             SqlSession sqlSession = sqlSessionFactory.openSession(true);
     
             //4.获取ManyToManyMapper接口的实现类对象
             ManyToManyMapper mapper = sqlSession.getMapper(ManyToManyMapper.class);
     
             //5.调用实现类的方法，接收结果
             List<Student> students = mapper.selectAll();
     
             //6.处理结果
             for (Student student : students) {
                 System.out.println(student.getId() + "," + student.getName() + "," + student.getAge());
                 List<Course> courses = student.getCourses();
                 for (Course cours : courses) {
                     System.out.println("\t" + cours);
                 }
             }
     
             //7.释放资源
             sqlSession.close();
             is.close();
         }
     }
     

3. 多对多配置总结:

   <resultMap>：配置字段和对象属性的映射关系标签。
   	id 属性：唯一标识
   	type 属性：实体对象类型
    <id>：配置主键映射关系标签。
    <result>：配置非主键映射关系标签。
   	column 属性：表中字段名称
   	property 属性： 实体对象变量名称
   <collection>：配置被包含集合对象的映射关系标签。
   	property 属性：被包含集合对象的变量名
   	ofType 属性：集合中保存的对象数据类型
   

5 多表模型操作总结

•  <resultMap>：配置字段和对象属性的映射关系标签。
      id 属性：唯一标识
      type 属性：实体对象类型
  <id>：配置主键映射关系标签。
  <result>：配置非主键映射关系标签。
  	column 属性：表中字段名称
  	property 属性： 实体对象变量名称
  <association>：配置被包含对象的映射关系标签。
  	property 属性：被包含对象的变量名
  	javaType 属性：被包含对象的数据类型
  <collection>：配置被包含集合对象的映射关系标签。
  	property 属性：被包含集合对象的变量名
  	ofType 属性：集合中保存的对象数据类型
  

• 以上案例中使用的核心配置文件MyBatisConfig.xml定义为：

  <?xml version="1.0" encoding="UTF-8" ?>
  <!--MyBatis的DTD约束-->
  <!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">
  
  <!--configuration 核心根标签-->
  <configuration>
  
      <!--引入数据库连接的配置文件-->
      <properties resource="jdbc.properties"/>
  
      <!--配置LOG4J-->
      <settings>
          <setting name="logImpl" value="log4j"/>
      </settings>
  
      <!--起别名-->
      <typeAliases>
          <package name="com.itheima.bean"/>
      </typeAliases>
  
      <!--environments配置数据库环境，环境可以有多个。default属性指定使用的是哪个-->
      <environments default="mysql">
          <!--environment配置数据库环境  id属性唯一标识-->
          <environment id="mysql">
              <!-- transactionManager事务管理。  type属性，采用JDBC默认的事务-->
              <transactionManager type="JDBC"></transactionManager>
              <!-- dataSource数据源信息   type属性 连接池-->
              <dataSource type="POOLED">
                  <!-- property获取数据库连接的配置信息 -->
                  <property name="driver" value="${driver}" />
                  <property name="url" value="${url}" />
                  <property name="username" value="${username}" />
                  <property name="password" value="${password}" />
              </dataSource>
          </environment>
      </environments>
  
      <!-- mappers引入映射配置文件 -->
      <mappers>
          <mapper resource="com/itheima/one_to_one/OneToOneMapper.xml"/>
          <mapper resource="com/itheima/one_to_many/OneToManyMapper.xml"/>
          <mapper resource="com/itheima/many_to_many/ManyToManyMapper.xml"/>
      </mappers>
  </configuration>
  

• 数据库连接的配置文件jdbc.properties

  driver=com.mysql.jdbc.Driver
  url=jdbc:mysql://192.168.59.143:3306/db2
  username=root
  password=itheima
  

• log4j.properties

  # Global logging configuration
  # ERROR WARN INFO DEBUG
  log4j.rootLogger=DEBUG, stdout
  # Console output...
  log4j.appender.stdout=org.apache.log4j.ConsoleAppender
  log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
  log4j.appender.stdout.layout.ConversionPattern=%5p [%t] - %m%n
  

原文链接:https://blog.csdn.net/qq_24410589/article/details/117638416