[Java知识库]Springboot整合Mybatis(逆向工程)

一、springboot整合Mybatis

1.准备工具:IDEA

浏览器直接搜索IDEA进入官网，点击Download，进入如下页面

第一个是旗舰版，第二个是社区版，一个要钱一个免费，但是第一个可以用其他方法进行使用，本文用的是旗舰版2020。

下载完后进行安装，基本就是一路next，然后完成。

首次打开旗舰版 IDEA 时，会让你激活，这里有 3 种选择：

• 利用你的 JetBrains 账号登录激活；
• 利用你的 IDEA 激活码激活；
• 最后则是许可证服务器地址激活；

这里选择Evaluate for free使用三十天，进去之后打开设置，找到插件。

?第一个是将IDEA换成中文版，第二个则可以让你的旗舰版idea反复使用三十天

?

?进行以上步骤，选择“是”将idea重启，则试用日期又会变成30天，每个月只需要刷一两次就能一直使用了。

2.创建项目

?可以使用默认，就是有点慢，这里使用的是阿里云镜像的地址，然后下一步。

?

?这里只要设置框内内容，继续下一步。

选择项目需要的依赖，第一个是springboot的基本依赖，下面两个是mybatis的依赖和驱动依赖 ，继续下一步。

选择项目名称和存放路径，完成项目创建。

?1是我们的启动类。2是我们的配置文件。3是我们管理依赖的地方，可以通过右边的maven进行依赖引用情况。

3.引用逆向工程依赖

 <!--        mybatis自动生成代码 的插件-->
            <plugin>
                <groupId>org.mybatis.generator</groupId>
                <artifactId>mybatis-generator-maven-plugin</artifactId>
                <version>1.4.1</version>
                <configuration>
                    <!--允许移动生成的文件 -->
                    <verbose>true</verbose>
                    <!-- 是否覆盖 -->
                    <overwrite>true</overwrite>
                    <!-- 自动生成的配置文件路径。启动插件时，插件会根据这里配置的路径去找到generatorConfig.xml配置文件，
                    根据配置文件里的配置，去自动生成Mapper接口（可以理解为Dao层）、实体类、Mapper.xml文件
                    -->
                    <configurationFile>src/main/resources/GeneratorConfig.xml</configurationFile>
                </configuration>
                <dependencies>
                    <dependency>
                        <groupId>mysql</groupId>
                        <artifactId>mysql-connector-java</artifactId>
                        <version>8.0.29</version>
                    </dependency>
                    <dependency>
                        <groupId>org.mybatis.generator</groupId>
                        <artifactId>mybatis-generator-core</artifactId>
                        <version>1.4.1</version>
                    </dependency>

                </dependencies>
                <executions>
                    <execution>
                        <id>Generate MyBatis Artifacts</id>
                        <phase>package</phase>
                        <goals>
                            <goal>generate</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>

总体如下图

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.test</groupId>
    <artifactId>project</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>project</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>1.8</java.version>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <spring-boot.version>2.3.7.RELEASE</spring-boot.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.1.4</version>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
    </dependencies>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>${spring-boot.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.8.1</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                    <encoding>UTF-8</encoding>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <version>2.3.7.RELEASE</version>
                <configuration>
                    <mainClass>com.test.project.ProjectApplication</mainClass>
                </configuration>
                <executions>
                    <execution>
                        <id>repackage</id>
                        <goals>
                            <goal>repackage</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
            <!--        mybatis自动生成代码 的插件-->
            <plugin>
                <groupId>org.mybatis.generator</groupId>
                <artifactId>mybatis-generator-maven-plugin</artifactId>
                <version>1.4.1</version>
                <configuration>
                    <!--允许移动生成的文件 -->
                    <verbose>true</verbose>
                    <!-- 是否覆盖 -->
                    <overwrite>true</overwrite>
                    <!-- 自动生成的配置文件路径。启动插件时，插件会根据这里配置的路径去找到generatorConfig.xml配置文件，
                    根据配置文件里的配置，去自动生成Mapper接口（可以理解为Dao层）、实体类、Mapper.xml文件
                    -->
                    <configurationFile>src/main/resources/GeneratorConfig.xml</configurationFile>
                </configuration>
                <dependencies>
                    <dependency>
                        <groupId>mysql</groupId>
                        <artifactId>mysql-connector-java</artifactId>
                        <version>8.0.29</version>
                    </dependency>
                    <dependency>
                        <groupId>org.mybatis.generator</groupId>
                        <artifactId>mybatis-generator-core</artifactId>
                        <version>1.4.1</version>
                    </dependency>

                </dependencies>
                <executions>
                    <execution>
                        <id>Generate MyBatis Artifacts</id>
                        <phase>package</phase>
                        <goals>
                            <goal>generate</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>

</project>

4.创建数据库(mysql)

使用Navicat Premium 15工具进行mysql的管理

a.新建数据库

CREATE DATABASE `test_project` CHARACTER SET 'utf8mb4' COLLATE 'utf8mb4_general_ci';

?b.新建表(学生表，老师表)

创建学生表

CREATE TABLE `test_project`.`student`   (
  `student_id` varchar(255) NOT NULL COMMENT '学生ID',
  `student_name` varchar(255) NOT NULL COMMENT '学生姓名',
  `student_age` varchar(255) NOT NULL COMMENT '学生年龄',
  `student_sex` varchar(255) NOT NULL COMMENT '学生性别',
  PRIMARY KEY (`student_id`)
);

插入三条数据

INSERT INTO `test_project`.`student`(`student_id`, `student_name`, `student_age`, `student_sex`) VALUES ('12345601', '张三', '15', '男');
INSERT INTO `test_project`.`student`(`student_id`, `student_name`, `student_age`, `student_sex`) VALUES ('12345602', '李四', '18', '女');
INSERT INTO `test_project`.`student`(`student_id`, `student_name`, `student_age`, `student_sex`) VALUES ('12345603', '王五', '17', '男');

创建老师表

CREATE TABLE `test_project`.`teacher`  (
  `teacher_id` varchar(255) NOT NULL COMMENT '老师Id',
  `teacher_name` varchar(255) NOT NULL COMMENT '老师姓名',
  `course` varchar(255) NOT NULL COMMENT '教学课程',
  PRIMARY KEY (`teacher_id`)
);

插入两条数据

INSERT INTO `test_project`.`teacher`(`teacher_id`, `teacher_name`, `course`) VALUES ('111111', '赵老师', '语文');
INSERT INTO `test_project`.`teacher`(`teacher_id`, `teacher_name`, `course`) VALUES ('222222', '向老师', '数学');

创建关联表

CREATE TABLE `test_project`.`associate`  (
  `associate_id` int NOT NULL AUTO_INCREMENT COMMENT '关联ID',
  `teacher_id` varchar(255) NOT NULL COMMENT '老师ID',
  `student_id` varchar(255) NOT NULL COMMENT '学生ID',
  PRIMARY KEY (`associate_id`)
);

添加关联数据

INSERT INTO `test_project`.`associate`(`associate_id`, `teacher_id`, `student_id`) VALUES (1, '111111', '12345601');
INSERT INTO `test_project`.`associate`(`associate_id`, `teacher_id`, `student_id`) VALUES (2, '111111', '12345603');
INSERT INTO `test_project`.`associate`(`associate_id`, `teacher_id`, `student_id`) VALUES (3, '222222', '12345601');
INSERT INTO `test_project`.`associate`(`associate_id`, `teacher_id`, `student_id`) VALUES (4, '222222', '12345602');

表结构如下

5.配置相关文件

a.新建文件GeneratorConfig.xml

b.配置GeneratorConfig.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE generatorConfiguration
        PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN"
        "http://mybatis.org/dtd/mybatis-generator-config_1.0.dtd">
<generatorConfiguration>

    <!-- 数据库驱动:选择你的本地硬盘上面的数据库驱动包 -->
<!--    因为已经在pom.xml添加逆向工程插件时添加了驱动依赖，所以省略这一步-->
    <!--    <classPathEntry  location="C:\Users\lenovo\Desktop\Software_project\java\mysql-connector-java-8.0.28/mysql-connector-java-8.0.28.jar"/>-->

    <context id="DB2Tables" targetRuntime="MyBatis3">
        <!-- 实体类生成序列化属性-->
        <plugin type="org.mybatis.generator.plugins.SerializablePlugin"/>
        <!-- 实体类重写HashCode()和equals()-->
        <plugin type="org.mybatis.generator.plugins.EqualsHashCodePlugin"/>
        <!-- 实体类重写toString() -->
        <plugin type="org.mybatis.generator.plugins.ToStringPlugin"/>

        <commentGenerator>
            <!-- 是否去除自动生成的注释 -->
            <property name="suppressAllComments" value="true"/>
            <!-- 生成注释是否带时间戳-->
            <property name="suppressDate" value="true"/>
            <!-- 生成的Java文件的编码格式 -->
            <property name="javaFileEncoding" value="utf-8"/>
            <!-- 数据库注释支持 -->
            <property name="addRemarkComments" value="true"/>
            <!-- 时间格式设置 -->
            <property name="dateFormat" value="yyyy-MM-dd HH:mm:ss"/>
            <!-- 格式化java代码-->
            <property name="javaFormatter" value="org.mybatis.generator.api.dom.DefaultJavaFormatter"/>
            <!-- 格式化XML代码-->
            <property name="xmlFormatter" value="org.mybatis.generator.api.dom.DefaultXmlFormatter"/>
        </commentGenerator>

        <!-- 数据库连接驱动类,URL，用户名、密码 -->
        <jdbcConnection driverClass="com.mysql.cj.jdbc.Driver"
                        connectionURL="jdbc:mysql://localhost:3306/test_project?serverTimezone=GMT&amp;useSSL=false"
                        userId="root"
                        password="root">
            <property name="nullCatalogMeansCurrent" value="true"/>
        </jdbcConnection>

        <!-- java类型处理器：处理DB中的类型到Java中的类型 -->
        <javaTypeResolver type="org.mybatis.generator.internal.types.JavaTypeResolverDefaultImpl">
            <!-- 是否有效识别DB中的BigDecimal类型 -->
            <property name="forceBigDecimals" value="true"/>
        </javaTypeResolver>

        <!-- 生成Domain模型：包名(targetPackage)、位置(targetProject) -->
        <javaModelGenerator targetPackage="com.test.project.entity" targetProject="C:\Users\lenovo\Desktop\project\src\main\java">
            <!-- 在targetPackage的基础上，根据数据库的schema再生成一层package，最终生成的类放在这个package下，默认为false -->
            <property name="enableSubPackages" value="true"/>
            <!-- 设置是否在getter方法中，对String类型字段调用trim()方法-->
            <property name="trimStrings" value="true"/>
        </javaModelGenerator>

        <!-- 生成xml映射文件：包名(targetPackage)、位置(targetProject) -->
        <sqlMapGenerator targetPackage="mapper" targetProject="C:\Users\lenovo\Desktop\project\src\main\resources">
            <property name="enableSubPackages" value="true"/>
        </sqlMapGenerator>

        <!-- 生成DAO接口：包名(targetPackage)、位置(targetProject) -->
        <javaClientGenerator type="XMLMAPPER" targetPackage="com.test.project.dao"
                             targetProject="C:\Users\lenovo\Desktop\project\src\main\java">
            <property name="enableSubPackages" value="true"/>
        </javaClientGenerator>

        <!-- 要生成的表：tableName - 数据库中的表名或视图名，domainObjectName - 实体类名 -->
        <table tableName="student" domainObjectName="Student"></table>
        <table tableName="teacher" domainObjectName="Teacher">
<!--            若数据库中某个属性类型为text或类似类型，可能会发生无法生成这个属性，此时可以在这里指定转换类型为VARCHAR-->
<!--            <columnOverride column="teacher_name" jdbcType="VARCHAR" />-->
        </table>
    </context>
</generatorConfiguration>

?c.配置application.properties文件

# 应用名称
spring.application.name=project
# 应用服务 WEB 访问端口
server.port=8080
#下面这些内容是为了让MyBatis映射
#指定Mybatis的Mapper文件
mybatis.mapper-locations=classpath:mapper/*xml
#指定Mybatis的实体目录
mybatis.type-aliases-package=com.test.project.mybatis.entity
# 数据库驱动：
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
# 数据源名称
spring.datasource.name=defaultDataSource
# 数据库连接地址
spring.datasource.url=jdbc:mysql://localhost:3306/test_project?serverTimezone=UTC
# 数据库用户名&密码：
spring.datasource.username=root
spring.datasource.password=root

6.逆向生成文件

?如图依次打开，生成结果如下

?二、使用mybatis逆向工程实现数据的增、删、查、改

1.mapper接口中的方法

2.example实例解析

mybatis的逆向工程中会生成实例及实例对应的example，example用于添加条件，相当where后面的部分：
XxxExample example = new XxxExample();
XxxExample.criteria? criteria?= example.createCriteria();

3.具体实现(以查询为例)

首先创建service层的包，然后创建查询接口，代码如下：

package com.test.project.service;

import com.test.project.entity.Student;

import java.util.List;

public interface SelectService {
    //查询所有学生信息
    List<Student> selectAllStudent();

    //按主键查询某个学生信息
    Student selectByStudentId(String stuId);

    //按性别查询学生信息
    List<Student> selectBySex(String sex);
}

然后创建实现类，创建时注意添加注解，代码如下：

package com.test.project.service.imp;

import com.test.project.dao.StudentMapper;
import com.test.project.entity.Student;
import com.test.project.entity.StudentExample;
import com.test.project.service.SelectService;
import org.springframework.beans.factory.annotation.Autowired;

import java.util.List;
@Service
public class SelectServiceImp implements SelectService {
    @Autowired
    private StudentMapper studentMapper;
    @Override
    public List<Student> selectAllStudent() {
        return studentMapper.selectByExample(new StudentExample());
    }

    @Override
    public Student selectByStudentId(String stuId) {
        return studentMapper.selectByPrimaryKey(stuId);
    }

    @Override
    public List<Student> selectBySex(String sex) {
        StudentExample studentExample = new StudentExample();
        StudentExample.Criteria criteria = studentExample.createCriteria();
        criteria.andStudentSexEqualTo(sex);
        return studentMapper.selectByExample(studentExample);
    }
}

在调用XxxMapper接口时，会报错，是因为还没有对Mapper接口进行映射，只需要在接口上面加上@Mapper注解就可以了，也可以直接在启动类上添加@MapperScan注解，并指定需要扫描的basePackages，代码如下

@MapperScan(basePackages = {"com.test.project.dao"})

此时依旧报红，是因为还没有将其指定为bean，只需要在接口上加入@Repository注解就行了。

最后在测试类中进行调用，代码如下：

package com.test.project;

import com.test.project.entity.Student;
import com.test.project.entity.Teacher;
import com.test.project.model.StudentWithTeacher;
import com.test.project.service.SelectService;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.List;

@SpringBootTest
public class StudentTest {
    @Autowired
    private SelectService selectService;
    @Test
    public void selectStudent(){
//        查询所有学生信息
        List<Student> studentList1 = selectService.selectAllStudent();
//        条件查询性别为男生的学生信息
        List<Student> studentList2 = selectService.selectBySex("男");
//        查询学号为12345601的学生信息
        Student student = selectService.selectByStudentId("12345601");

        System.out.println("所有学生信息如下:");
        for (Student stu1:studentList1) {
            System.out.println(stu1.toString());
        }
        System.out.println("所有男学生信息如下:");
        for (Student stu1:studentList2) {
            System.out.println(stu1.toString());
        }
        System.out.println("学号为12345601的学生信息如下:");
        System.out.println(student.toString());
    }

   
}

结果如下:

此时项目结构如下图:

?三、联表查询

在实际运用时，我们会发现mybatis逆向工程只能用于单表操作，而不能进行联表操作，因此还需要自己手动进行一些改变，来满足功能需求。下面以多对多为例，实现学生表与教师表的联表查询。

1.实体类

修改原来的实体类或者新建一个实体类，存放需要查询的对象属性，如果数据库结构有变，重新进行逆向工程时，原来生成的文件需要删除，所以为了与原来逆向工程的文件分开来，这里选择新建实体类，代码如下:

package com.test.project.model;

import com.test.project.entity.Student;
import com.test.project.entity.Teacher;

import java.util.List;
import java.util.Objects;

public class StudentWithTeacher extends Student {
    /*
    * 一对多查询
    * 一个学生对应多个老师
    * */
    private Student student;//学生类
    private List<Teacher> teacherList;//每个学生类对应的老师列表

    public Student getStudent() {
        return student;
    }

    public void setStudent(Student student) {
        this.student = student;
    }

    public List<Teacher> getTeacherList() {
        return teacherList;
    }

    public void setTeacherList(List<Teacher> teacherList) {
        this.teacherList = teacherList;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        if (!super.equals(o)) return false;
        StudentWithTeacher that = (StudentWithTeacher) o;
        return Objects.equals(student, that.student) && Objects.equals(teacherList, that.teacherList);
    }

    @Override
    public int hashCode() {
        return Objects.hash(super.hashCode(), student, teacherList);
    }

    @Override
    public String toString() {
        return "StudentWithTeacher{" +
                "student=" + student +
                ", teacherList=" + teacherList +
                '}';
    }
}

?2.mapper接口

自定义一个mapper接口，可以放在原来的dao包下，也能重新创建一个包，不过记得加上@mapper和@Repository两个注解，这里是新建一个包，与上面同理。代码如下:

package com.test.project.personalMapper;

import com.test.project.entity.StudentExample;
import com.test.project.model.StudentWithTeacher;
import org.apache.ibatis.annotations.Mapper;
import org.springframework.stereotype.Repository;

import java.util.List;

@Mapper
@Repository
public interface StudentWithTeacherMapper {
    List<StudentWithTeacher> findStudentWithTeacher(StudentExample example);
}

3.mapper配置文件

创建Xxxmapper.xml配置文件，放在mpper文件下面，因为配置文件中已经规定了mpper文件的映射路径。在xml文件中编写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.test.project.personalMapper.StudentWithTeacherMapper">
    <sql id="Example_Where_Clause">
        <where>
            <foreach collection="oredCriteria" item="criteria" separator="or">
                <if test="criteria.valid">
                    <trim prefix="(" prefixOverrides="and" suffix=")">
                        <foreach collection="criteria.criteria" item="criterion">
                            <choose>
                                <when test="criterion.noValue">
                                    and ${criterion.condition}
                                </when>
                                <when test="criterion.singleValue">
                                    and ${criterion.condition} #{criterion.value}
                                </when>
                                <when test="criterion.betweenValue">
                                    and ${criterion.condition} #{criterion.value} and #{criterion.secondValue}
                                </when>
                                <when test="criterion.listValue">
                                    and ${criterion.condition}
                                    <foreach close=")" collection="criterion.value" item="listItem" open="(" separator=",">
                                        #{listItem}
                                    </foreach>
                                </when>
                            </choose>
                        </foreach>
                    </trim>
                </if>
            </foreach>
            and associate.teacher_id = teacher.teacher_id
            and associate.student_id = student.student_id
        </where>
    </sql>
    <select id="findStudentWithTeacher" parameterType="com.test.project.model.StudentWithTeacher" resultMap="StudentWithTeacherResult">
        select
        <if test="distinct">
            distinct
        </if>
        student.*,teacher.*
        from student,teacher,associate
        <if test="_parameter != null">
            <include refid="Example_Where_Clause" />
        </if>
        <if test="orderByClause != null">
            order by ${orderByClause}
        </if>
    </select>
    <resultMap id="StudentWithTeacherResult" type="com.test.project.model.StudentWithTeacher">
        <id column="student_id" jdbcType="VARCHAR" property="student.studentId" />
        <result column="student_name" jdbcType="VARCHAR" property="student.studentName" />
        <result column="student_age" jdbcType="VARCHAR" property="student.studentAge" />
        <result column="student_sex" jdbcType="VARCHAR" property="student.studentSex" />
        <collection property="teacherList" column="teacher_id" ofType="com.test.project.entity.Teacher">
            <id column="teacher_id" jdbcType="VARCHAR" property="teacherId" />
            <result column="teacher_name" jdbcType="VARCHAR" property="teacherName" />
            <result column="course" jdbcType="VARCHAR" property="course" />
        </collection>
    </resultMap>
</mapper>

4.编写service层代码

a.接口如下:

package com.test.project.service;

import com.test.project.entity.Student;
import com.test.project.model.StudentWithTeacher;

import java.util.List;

public interface SelectService {
    //查询所有学生信息
    List<Student> selectAllStudent();

    //按主键查询某个学生信息
    Student selectByStudentId(String stuId);

    //按性别查询学生信息
    List<Student> selectBySex(String sex);

    //查询所有学生及其老师
    List<StudentWithTeacher> selectStudentWithTeacherAll();
}

b.实现类如下:

package com.test.project.service.imp;

import com.test.project.dao.StudentMapper;
import com.test.project.entity.Student;
import com.test.project.entity.StudentExample;
import com.test.project.model.StudentWithTeacher;
import com.test.project.personalMapper.StudentWithTeacherMapper;
import com.test.project.service.SelectService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;
@Service
public class SelectServiceImp implements SelectService {
    @Autowired
    private StudentMapper studentMapper;//单表查询的mapper接口

    @Autowired
    private StudentWithTeacherMapper studentWithTeacherMapper;//联表查询的mapper接口
    @Override
    public List<Student> selectAllStudent() {
        return studentMapper.selectByExample(new StudentExample());
    }

    @Override
    public Student selectByStudentId(String stuId) {
        return studentMapper.selectByPrimaryKey(stuId);
    }

    @Override
    public List<Student> selectBySex(String sex) {
        StudentExample studentExample = new StudentExample();
        StudentExample.Criteria criteria = studentExample.createCriteria();
        criteria.andStudentSexEqualTo(sex);
        return studentMapper.selectByExample(studentExample);
    }

    @Override
    public List<StudentWithTeacher> selectStudentWithTeacherAll() {
        return studentWithTeacherMapper.findStudentWithTeacher(new StudentExample());
    }
}

5.编写测试类

    @Test
    public  void selectStudentWithTeacher(){
        List<StudentWithTeacher> studentList = selectService.selectStudentWithTeacherAll();
        for (StudentWithTeacher stu:studentList) {
            System.out.println(stu.getStudent().toString());
            for (Teacher te:stu.getTeacherList()) {
                System.out.println(te.toString());
            }
        }
    }

此时，因为关联表中的两个关联属性与其他两个表的主键重名，若通过主键属性名进行查找时，会分不清是通过哪个表的属性名进行查找，所以需要修改XxxExample中的代码，具体如下:

?找到需要调用的方法，其中有三个值，一个是sql语句的属性名，一个是传进来的值和值的名字，只需要将第一值前面加上这个值得表名就行了，对其他方法也适用。

6.测试结果如下:

这样就实现了联表查询。

四、结论

Mybatis是一个支持普通SQL查询、存储及高级映射的持久框架，它几乎消除了JDBC的冗余代码，无须手动设置参数和对结果进行检索，使用简单的XML或注解进行配置和原理映射，将接口和Java的POJO映射成数据库中的记录，使java开发人员可以使用面向对象的编程思想来操作数据库。

在开发过程中，为了减少编写的代码量，使用mybatis逆向工程可以省略大部分代码的编写，如果想增加其他操作，只需要在其基础上添加新的mapper接口及映射就行了。