[Printemps]—SQL dynamique : mappage d'association MyBatis

Cartographie associative de MyBatis

Dans les applications pratiques, le fonctionnement de la base de données impliquera plusieurs tables, ce qui implique la relation entre les objets en mode orienté objet. Pour l'opération entre plusieurs tables, MyBatis fournit un mappage d'association, qui gère la relation d'association entre les objets via le mappage d'association.

1. Aperçu de la relation

Dans une base de données relationnelle, il existe trois types d'associations entre plusieurs tables, à savoir un à un, un à plusieurs et plusieurs à plusieurs.

• Un-à-un : introduisez la clé primaire de l'autre partie en tant que clé étrangère de chaque côté.
• Un à plusieurs : ajoutez la clé primaire du côté "un" au côté "plusieurs" en tant que clé étrangère.
• Plusieurs à plusieurs : générez une table relationnelle intermédiaire, introduisez la clé primaire des deux tables en tant que clé étrangère et faites des deux clés primaires une clé primaire commune ou utilisez un nouveau champ comme clé primaire.

Il existe également trois types d'associations entre objets.

• Relation un à un : définissez des objets de l'autre type dans cette classe, tels que la définition de l'attribut b de type B dans la classe A et la définition de l'attribut a de type A dans la classe B.
• Relation un-à-plusieurs : Dans le cas où un type de la classe A correspond à plusieurs types de la classe B, il faut introduire les objets de la classe B sous la forme d'une collection dans la classe A, et définir l'attribut a de la classe A en classe B.
• Relation plusieurs-à-plusieurs : définissez une collection de type B dans la classe A et définissez une collection de type A dans la classe B.

2. Relations dans MonBatis

2.1 Un à un

Dans la vraie vie, les relations en tête-à-tête sont très courantes. Par exemple, un étudiant n'a qu'une seule carte d'étudiant, et une carte d'étudiant correspond à un seul étudiant.

Alors, comment MyBatis gère cette relation un-à-un L' <resultMap>élément précédemment appris contient un <association>sous-élément à travers lequel MyBatis gère la relation un-à-un.

Dans <association>un élément, les attributs suivants peuvent généralement être configurés.

• propriété : spécifie l'attribut de l'objet de classe d'entité auquel il est mappé et correspond au champ de table un par un.
• colonne : spécifie le champ correspondant dans la table.
• javaType : spécifie le type mappé à l'attribut de l'objet entité.
• select : spécifie l'instruction sous-SQL qui introduit la requête imbriquée, qui est utilisée pour la requête imbriquée dans la carte d'association.
• fetchType : spécifie s'il faut activer le chargement différé pendant la requête d'association. Il existe deux valeurs d'attribut, différé et impatient, et la valeur par défaut est différée (chargement différé du mappage d'association par défaut).

<association>Les éléments peuvent être configurés des deux manières suivantes.

Notez que
MyBatis charge les objets de relation dans le fichier de mappage principalement de deux manières : les requêtes imbriquées et les résultats imbriqués .

Une requête imbriquée est une requête qui renvoie le type complexe attendu en exécutant une autre instruction de mappage SQL ; un
résultat imbriqué est un sous-ensemble d'un résultat uni qui utilise une carte de résultats imbriquée pour gérer la répétition.

[Exemple 9] Ensuite, prenons la relation un à un entre les étudiants et les identifiants des étudiants comme exemple.

Pour interroger les étudiants et leurs informations d'identification d'étudiant associées, obtenez d'abord les informations sur l'étudiant en interrogeant la clé primaire dans la table des étudiants, puis obtenez les informations sur le numéro d'identification de l'étudiant dans la table des ID d'étudiant via la clé étrangère de la table. Ses étapes de mise en œuvre spécifiques sont les suivantes.

Étape 01　Créez une table de données. Créez des tables de données nommées tb_studentidcard et tb_student dans la base de données db_mybatis et insérez plusieurs éléments de données à l'avance. L'instruction SQL exécutée par celui-ci est la suivante.

#使用数据库db mybatis
USE db_mybatis;
#创建一个名称为tb_studentidcard的表
CREATE TABLE IF NOT EXISTS tb_studentidcard( 
		id INT PRIMARY KEY AUTO_INCREMENT,
		CODE VARCHAR(8)
);
#插入两条数据
INSERT INTO tb_studentidcard(CODE) VALUES('18030128');
INSERT INTO tb_studentidcard(CODE) VALUES('18030135');
#创建一个名称为tb_student的表（暂时添加少量字段)
CREATE TABLE tb_student(
	id INT PRIMARY KEY AUTO_INCREMENT,
	name VARCHAR(32),
	sex CHAR(1),
	card_id INT UNIQUE,
	FOREIGN KEY (card_id) REFERENCES tb_studentidcard(id)
);
#插入两条数据
INSERT INTO tb_student (name,sex,card_id) VALUES ('limin','f',1);
INSERT INTO tb_student (name,sex,card_id) VALUES ('jack','m',2);

Étape 02　Créez un projet Web nommé chapitre09, puis importez les packages JAR associés, les classes d'outils MybatisUtils et les fichiers de configuration de base mybatis-config.xml.

Étape 03　Créez des classes persistantes sous le package com.ssm.po du projet : classe d'identification d'étudiant StudentIdCard et classe d'étudiant Student.

//StudentIdCard.java

package com.ssm.po;

/**
 * 功能描述
 *
 * @author: 衍生星球
 * @date: 2023年06月08日 17:40
 */

public class StudentIdCard {
    
    
    private Integer id;
    private String code;

    public Integer getId() {
    
    
        return id;
    }

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

    public String getCode() {
    
    
        return code;
    }

    public void setCode(String code) {
    
    
        this.code = code;
    }

    @Override
    public String toString() {
    
    
        return "StudentIdCard [id=" + id + ", code= " + code + "]";
    }
}

//Student.java

package com.ssm.po;

/**
 * 功能描述
 *
 * @author: 衍生星球
 * @date: 2023年06月08日 17:41
 */

public class Student {
    
    
    private Integer id;
    private String name;
    private String sex;
    private StudentIdCard studentIdCard;

    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 String getSex() {
    
    
        return sex;
    }

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

    public StudentIdCard getStudentIdCard() {
    
    
        return studentIdCard;
    }

    public void setStudentIdCard(StudentIdCard studentIdCard) {
    
    
        this.studentIdCard = studentIdCard;
    }

    @Override
    public String toString() {
    
    
        return "Student[id=" + id + ", name=" + name + ", sex=" + sex + ", studentIdCard=" + studentIdCard +"]";
    }
}

Étape 04　Créez un fichier de mappage de carte d'étudiant StudentIdCardMapper.xml et un fichier de mappage étudiant StudentMapper.xml dans le package com.ssm.mapper, et écrivez les informations de configuration pour les requêtes de mappage d'association un à un dans les deux fichiers de mappage.

StudentIdCardMapper.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.ssm.mapper.StudentIdCardMapper">
<!--    根据学生id获取学生证信息-->
    <select id="findStudentIdCardById" parameterType="com.ssm.po.StudentIdCard" resultType="com.ssm.po.StudentIdCard">
        select * from tb_studentidcard where id = #{
    
    id}
    </select>

</mapper>

StudentMapper.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.ssm.mapper.StudentMapper">
    <!--    根据学生id获取学生证信息-->
    <select id="findStudentById" parameterType="com.ssm.po.Student" resultMap="CardId">
        select * from tb_student where id = #{
    
    id}
    </select>
    <resultMap id="CardId" type="Student">
        <id property="id" column="id"/>
        <result property="name" column="name"/>
        <result property="sex" column="sex"/>
        <!--        一对一，association使用select属性引入另一条SQL语句 -->
        <association property="studentIdCard" column="card_id" javaType="StudentIdCard"
                     select="com.ssm.mapper.StudentIdCardMapper.findStudentIdCardById"/>
    </resultMap>
</mapper>

Dans les deux fichiers de mappage ci-dessus, la méthode de requête imbriquée dans MyBatis est utilisée pour interroger les étudiants et leurs informations de carte d'étudiant associées, car l'objet étudiant retourné a un attribut studentIdCard associé en plus des attributs de base, il doit donc être écrit manuellement Cartographie des résultats. <association>Comme le montre le fichier de mappage StudentMapper.xml, la méthode de requête imbriquée consiste à exécuter d'abord une instruction SQL simple, puis à utiliser l'attribut select de l'objet associé dans l'élément pour exécuter une autre instruction SQL lors de l'exécution du mappage des résultats (StudentIdCardMapper. xmlSQL).

Étape 05　Introduisez le fichier de mappage Mapper et définissez un alias dans le fichier de configuration principal mybatis-config.xml, comme indiqué ci-dessous.

mybatis-config.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
<!--    引入数据库连接配置文件-->
<!--    <properties resource="db.properties"/>-->
<!--    使用扫描包的形式定义别名-->
    <typeAliases>
        <package name="com.ssm.po"/>
    </typeAliases>
    <environments default="mysql">
<!--        1.2 配置id为mysql 的数据库环境-->
        <environment id="mysql">
<!--            使用JDBC的事务管理-->
            <transactionManager type="JDBC" />
<!--            数据库连接池-->
            <dataSource type="POOLED">
<!--                数据库驱动-->
                <property name="driver" value="com.mysql.jdbc.Driver" />
<!--                连接数据库的url-->
                <property name="url" value="jdbc:mysql://localhost:3306/db_mybatis" />
<!--                连接数据库的用户名-->
                <property name="username" value="root" />
<!--                连接数据库的用户名-->
                <property name="password" value="root" />
            </dataSource>
        </environment>
    </environments>
<!--2.配置 Mapper的位置-->
    <mappers>
        <mapper resource="com/ssm/mapper/UserMapper.xml" />
        <mapper resource="com/ssm/mapper/StudentMapper.xml" />
        <mapper resource="com/ssm/mapper/StudentIdCardMapper.xml" />
    </mappers>
</configuration>

Dans le fichier de configuration principal ci-dessus, le fichier de configuration de connexion à la base de données est d'abord introduit, puis l'alias est personnalisé sous la forme d'un package d'analyse, puis l'environnement est configuré et enfin les informations d'emplacement du fichier de mappage Mapper sont configurées.

Étape 06　Créez la classe de test MybatisAssociatedTest dans le package com.ssm.test et écrivez la méthode de test findStudentByIdTest() dans la classe, comme indiqué dans le fichier.

//MybatisAssociatedTest.java

package com.ssm.test;

import com.ssm.po.Student;
import com.ssm.po.User;
import com.ssm.util.MybatisUtil;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;
import java.util.List;

public class MybatisAssociatedTest {
    
    
    /*
     *嵌套查询
     */
    @Test
    public void findStudentByIdTest() {
    
    
        //通过工具类生成SqlSession对象
        SqlSession sqlSession = MybatisUtil.getSession();
        //执行SqlSession的查询办法，返回结果集
        Student student =
                sqlSession.selectOne("com.ssm.mapper.StudentMapper.findStudentById",1);
        System.out.println(student.toString());
        sqlSession.close();
    }
}

Dans la méthode findStudentByIdTest(), obtenez d'abord l'objet SqlSession via la classe d'outils MybatisUtils, puis obtenez les informations sur l'étudiant via la méthode selectOne() de l'objet SqlSession, et enfin fermez la SqlSession. Après l'exécution de la méthode, le résultat de sortie de la console est affiché dans la figure. Utilisez la requête imbriquée MyBatis pour interroger les étudiants et leurs informations d'identification d'étudiant associées, qui est la requête d'association un à un dans MyBatis.

Bien que la méthode d'utilisation de la requête imbriquée soit relativement simple, la méthode de requête imbriquée doit exécuter plusieurs instructions SQL, ce qui n'est pas très bon pour les grandes collections de données et l'affichage de liste, car cela peut entraîner l'exécution de centaines, voire de milliers d'instructions SOL associées. L'exécution, qui consomme considérablement les performances de la base de données et réduit l'efficacité des requêtes. Pour cela, MyBatis propose un moyen d'imbriquer les résultats des requêtes associées.

Dans StudentMapper.xml, utilisez les résultats imbriqués MyBatis pour interroger les étudiants et leurs informations d'identification d'étudiant associées, et le code ajouté est le suivant.

<?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.ssm.mapper.StudentMapper">
    <!--    嵌套结果，通过嵌套结果映射来处理重复的联合结果的子集-->
    <select id="findStudentById2" parameterType="Integer" resultMap="CardId2">
        select s.* ,sidcard.code
        from tb_student s,tb_studentidcard sidcard
        where s.card_id = sidcard.id and s.id=#{
    
    id}
    </select>
    <resultMap id="CardId2" type="Student">
        <id property="id" column="id"/>
        <result property="name" column="name"/>
        <result property="sex" column="sex"/>
        <!--        一对一，association使用select属性引入另一条SQL语句 -->
        <association property="studentIdCard" javaType="StudentIdCard">
            <id property="id" column="card_id"/>
            <result property="code" column="code"/>
        </association>
    </resultMap>
</mapper>

Comme on peut le voir dans le code ci-dessus, MyBatis écrit uniquement une instruction SQL complexe multi-table associée à la manière d'imbriquer les résultats, et continue d'utiliser <association>des sous-éléments associés dans l'élément pour effectuer un mappage un à un entre les champs de la table de la base de données. et les attributs de classe d'entité. Les résultats d'exécution sont les mêmes, mais une seule instruction SQL est exécutée à l'aide des résultats imbriqués de MyBatis.

Avis

Lors de l'utilisation de la méthode de requête imbriquée MyBatis pour le mappage de requête associé, l'utilisation du chargement paresseux de MyBatis peut réduire la consommation d'exécution et améliorer l'efficacité des requêtes dans une certaine mesure.

MyBatis n'active pas le chargement différé par défaut. Il doit être <settings>configuré dans les éléments du fichier de configuration principal mybatis-config.xml. La méthode de configuration spécifique est la suivante.

Dans le fichier de mapping, <association>les éléments et <collection>les éléments du mapping de l'association MyBatis ont été configurés avec des attributs de chargement différé par défaut, c'est-à-dire l'attribut par défaut fetchType="lazy" (l'attribut fetchType="eager" signifie chargement immédiat), donc activez chargement différé dans le fichier de configuration Après cela, il n'est plus nécessaire de configurer dans le fichier de mappage.

2.2 Un à plusieurs

Dans les applications pratiques, l'application de plusieurs associations est un à plusieurs (ou plusieurs à un). Par exemple, une classe compte plusieurs élèves, c'est-à-dire que plusieurs élèves appartiennent à une classe. Comment MyBatis gère-t-il cette relation un-à-plusieurs ? L'élément précédemment appris <resultMap>contient un <collection>sous-élément à travers lequel MyBatis gère la relation un-à-plusieurs . <collection>La plupart des attributs de l'élément enfant <collection>sont identiques à ceux de l'élément, mais il contient également un attribut spécial, ofType. L'attribut ofType correspond à l'attribut javaType et est utilisé pour spécifier le type d'élément contenu dans l'attribut de classe de collection dans l'objet entité.

<collection>Les éléments peuvent être configurés en référence aux deux exemples suivants, et le code spécifique est le suivant.

[ Exemple ] Après avoir compris les éléments et la manière dont MyBatis gère les relations un-à-plusieurs, prenez la relation un-à-plusieurs entre les classes et les élèves comme exemple pour apprendre à gérer les relations un-à-plusieurs dans MyBatis, plus précisément Procédez comme suit.

Étape 01　Créez deux tables de données dans la base de données db_mybatis : tb_banji et tb_student, et pré-insérez plusieurs données dans la table en même temps. L'instruction SQL exécutée est la suivante.

#创建一个名称为tb_banji的表（暂添加少量字段)
CREATE TABLE tb_banji(
	id INT PRIMARY KEY AUTO_INCREMENT,
	name VARCHAR(32)
);
#插入两条数据
INSERT INTO tb_banji VALUES(1, '16软件技术1班');
INSERT INTO tb_banji VALUES(2, '16软件技术2班');
#创建一个名称为tb_student的表（暂时添加少量字段)
CREATE TABLE tb_student(
	id INT PRIMARY KEY AUTO_INCREMENT,
	name VARCHAR(32),
	sex CHAR(1),
	banji_id INT,
	FOREIGN KEY (banji_id) REFERENCES tb_banji (id)
);
#插入3条数据
INSERT INTO tb_student VALUES(1,'孙蕙','m',1);
INSERT INTO tb_student VALUES(2,'刘梦奕','f',1);
INSERT INTO tb_student VALUES(3,'无为','m',2);

Étape 02　Créez des classes persistantes dans le package com.ssm.po : class class Banji et student class StudentOne, et définissez les propriétés et méthodes associées dans les deux classes, comme indiqué dans le fichier 9.7 et le fichier 9.8.

//Banji.java 

package com.ssm.po;
import java.util.List;

/**
 * 功能描述
 *
 * @author: 衍生星球
 * @date: 2023年06月09日 16:07
 */

public class Banji {
    
    
    private Integer id;
    private String name;
    private List<Student> studentList;

    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> getStudentList() {
    
    
        return studentList;
    }

    public void setStudentList(List<Student> studentList) {
    
    
        this.studentList = studentList;
    }

    public String toString() {
    
    
        return "Banji [id=" + id + ",name=" + name + ",studentList=" + studentList + "]";
    }

}

//StudentOne.java

package com.ssm.po;

/**
 * 功能描述
 *
 * @author: 衍生星球
 * @date: 2023年06月09日 16:14
 */

public class StudentOne {
    
    
    private Integer id;
    private String name;
    private String sex;

    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 String getSex() {
    
    
        return sex;
    }

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

    @Override
    public String toString() {
    
    
        return "StudentOne [id=" + id + ", name=" + name + ", sex=" + sex + "]";
    }
}

Étape 03　Créez le fichier de mappage d'entité de classe BanjiMapper.xml dans le package com.ssm.mapper et écrivez la configuration de la requête de mappage d'association un à plusieurs dans le fichier, comme indiqué dans le fichier.

<?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.ssm.mapper.BanjiMapper">
    <!--一对多，查看某一班级及其关联的学生信息
    注意：若关联查出的列名相同，则需要使用别名区分-->
    <select id="findBanjiWithStudent" parameterType="Integer" resultMap="BanjiWithStudentResult">
        select b.* ,s.id as student_id,s.name
        from tb_banji b,tb_student s
        where b.id = s.banji_id and b.id=#{
    
    id}
    </select>
    <resultMap id="BanjiWithStudentResult" type="Banji">
        <id property="id" column="id"/>
        <result property="name" column="name"/>
        <!--一对多关系映射：collection
        ofType表示属性集合中的元素的类型List<Student>属性，即Student类 -->
        <collection property="studentList" ofType="Student">
            <id property="id" column="student_id"/>
            <result property="name" column="name"/>
            <result property="sex" column="sex"/>
        </collection>
    </resultMap>
</mapper>

L'utilisation des résultats imbriqués de MyBatis dans le fichier définit une instruction de sélection qui interroge la classe et ses informations sur les étudiants associés en fonction de l'identifiant de la classe. Étant donné que l'objet de classe renvoyé contient les propriétés de l'objet de collection Student, vous devez écrire manuellement les informations de mappage des résultats.

Étape 04　Configurez le chemin du fichier de mappage BanjiMapper.xml vers le fichier de configuration principal mybatis-config.xml, et son code est le suivant.

<mapper resource="com/ssm/mapper/BanjiMapper.xml" />

Etape 05　Ecrivez la méthode de test findBanjiTest() dans la classe de test MyBatisAssociatedTest.

	@Test
    public void findStudentByIdTest() {
    
    
        //通过工具类生成SqlSession对象
        SqlSession sqlSession = MybatisUtil.getSession();
        //执行SqlSession的查询办法，返回结果集
        Banji banji =
                sqlSession.selectOne("com.ssm.mapper.BanjiMapper.findBanjiWithStudent",1);
        System.out.println(banji.toString());
        sqlSession.close();
    }

Après l'exécution de la méthode, les résultats de sortie de la console sont affichés dans la figure. Utilisez les résultats imbriqués de MyBatis pour interroger la classe et ses informations de collecte d'élèves associées. Il s'agit de la requête d'association un-à-plusieurs de MyBatis.

Avis

Le cas ci-dessus part du point de vue de la classe et il existe une relation un-à-plusieurs entre la classe et les élèves. Cependant, du point de vue d'un seul élève, un élève ne peut appartenir qu'à une seule classe, c'est-à-dire une relation de un à un.

2.3 Plusieurs à plusieurs

Dans le développement de projets réels, les relations plusieurs-à-plusieurs sont très courantes. En prenant les étudiants et les cours comme exemple, un étudiant peut suivre plusieurs cours et un cours peut être suivi par plusieurs étudiants. Les étudiants et les cours appartiennent à la relation plusieurs-à-plusieurs.

Dans la base de données, la relation plusieurs-à-plusieurs est généralement maintenue à l'aide d'une table intermédiaire. L'identifiant de l'étudiant (student_id) dans la table intermédiaire electiveCourse est utilisé comme clé étrangère pour faire référence à l'identifiant de la table des étudiants et à l'identifiant du cours. (course_id) est utilisé comme référence de clé étrangère. L'identifiant du curriculum. La relation entre les trois tables est illustrée dans la figure.

[Exemple] Après avoir compris la relation plusieurs à plusieurs entre la table des élèves et la table des programmes dans la base de données, expliquons à l'aide d'un cas spécifique comment utiliser MyBatis pour gérer cette relation plusieurs à plusieurs. Les étapes de mise en œuvre spécifiques sont comme suit.

Étape 01　Créez une table de données. Créez deux tables de données nommées tb_course et tb_electiveCourse dans la base de données mybatis (la table tb_student a été créée dans le cas précédent, qui est directement référencée ici), et pré-insérez plusieurs données dans la table. L'instruction SQL exécutée par celui-ci est la suivante.

#创建一个名称为tb_course的表
CREATE TABLE tb_course (
	id INT PRIMARY KEY AUTO_INCREMENT,
	name VARCHAR(32),
	code VARCHAR(32)
);
#插入两条数据
INSERT INTO tb_course VALUES (1, 'Java程序设计语言','08113226');
INSERT INTO tb_course VALUES (2, 'Javaweb程序开发入门','08113228');

#创建一个名称为tb_electiveCourse的中间表
CREATE TABLE tb_electiveCourse (
	id INT PRIMARY KEY AUTO_INCREMENT,
	student_id INT,
	course_id INT,
	FOREIGN KEY (student_id) REFERENCES tb_student(id),
	FOREIGN KEY (course_id) REFERENCES tb_course(id)
);
#插入3条数据
INSERT INTO tb_electiveCourse VALUES (1,1,1);
INSERT INTO tb_electiveCourse VALUES (2,1,2);
INSERT INTO tb_electiveCourse VALUES (3,2,2);

Étape 02　Créez une classe de cours persistante Course dans le package com.ssm.po et définissez les attributs et méthodes associés dans la classe, comme indiqué dans le fichier.

//Course.java

package com.ssm.po;

import java.util.List;

/**
 * 功能描述
 *
 * @author: 衍生星球
 * @date: 2023年06月11日 23:01
 */

public class Course {
    
    
    private Integer id;
    private String name;
    private String code;
    private List<Student> studentlist;//于学生集合的关联属性

    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 String getCode() {
    
    
        return code;
    }

    public void setCode(String code) {
    
    
        this.code = code;
    }

    public List<Student> getStudentlist() {
    
    
        return studentlist;
    }

    public void setStudentlist(List<Student> studentlist) {
    
    
        this.studentlist = studentlist;
    }

    @Override
    public String toString() {
    
    
        return "Course[id=" + id + ", name=" + name + ", code=" + code + "}";
    }
}

En plus d'ajouter les propriétés de la collection d'étudiants dans la classe de persistance du cours, il est également nécessaire d'ajouter les propriétés de la collection de cours et leurs méthodes getter()/setter() correspondantes dans la classe de persistance des étudiants (Student.java), et pour la commodité de la visualisation Pour afficher le résultat, vous devez réécrire toString(). Le code ajouté dans la classe Étudiant est illustré ci-dessous.

Étape 03　Créez un fichier de mappage d'entité de cours CourseMapper.xml et un fichier de mappage d'entité étudiant StudentMapper.xml dans le package com.ssm.mapper Après avoir modifié les deux fichiers de mappage, les fichiers suivants sont affichés.

//CourseMapper.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.ssm.mapper.CourseMapper">
    <!--    多对多嵌套查询：通过执行一条SQL映射语句来返回预期的特殊类型-->
    <select id="findCourseWithStudent" parameterType="Integer" resultMap="CourseWithStudentResult">
        select * from tb_course where id = #{
    
    id}
    </select>
    <resultMap id="CourseWithStudentResult" type="Course">
        <id property="id" column="id"/>
        <result property="name" column="name"/>
        <result property="code" column="code"/>
        <collection property="studentlist" column="id" ofType="Student"
    select="com.ssm.mapper.StudentMapper.findStudentById">
        </collection>
    </resultMap>
</mapper>

Une instruction select dont l'id est findCourseWithStudent est définie par une requête imbriquée pour interroger les cours et leurs informations sur les étudiants associés. <resultMap>L'élément est utilisé dans l' <collection>élément pour mapper la relation plusieurs à plusieurs, où l'attribut de propriété indique l'attribut course dans la classe de persistance de l'ordre, l'attribut ofType indique que les données de la collection sont du type Étudiant et l'attribut La valeur de la colonne sera utilisée comme paramètre pour exécuter le StudentMapper. L'identifiant défini dans xml est l'instruction d'exécution de findStudentById pour interroger les informations sur les étudiants dans l'ordre.

//StudentMapper.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.ssm.mapper.StudentMapper">
    <!--    嵌套结果，通过嵌套结果映射来处理重复的联合结果的子集-->
    <select id="findStudentById" parameterType="Integer" resultType="Student">
        select * from tb_student where id in (
        select student_id from tb_electivecourse where course_id=#{
    
    id}
        )
    </select>
</mapper>

Il définit une instruction d'exécution dont l'id est findStudentById, et le SQL de l'instruction d'exécution interrogera les informations sur les étudiants associées au cours en fonction de l'id du cours. Étant donné que les cours et les étudiants sont dans une relation plusieurs à plusieurs, il est nécessaire d'interroger les informations sur les étudiants via une table intermédiaire.

Étape 04　Configurez le chemin du fichier des fichiers de mappage nouvellement créés CourseMapper.xml et StudentMapper.xml vers le fichier de configuration de base mybatis-config.xml, le code est le suivant.

<mapper resource="com/ssm/mapper/CourseMapper.xml" />
<mapper resource="com/ssm/mapper/StudentMapper.xml" />

Etape 05　Ecrivez la méthode de test findCourseByIdTest() de la requête d'association plusieurs-à-plusieurs dans la classe de test MyBatisAssociatedTest, et son code est présenté ci-dessous.

  /*
     *多对多嵌套查询
     */
    @Test
    public void findCourseByIdTest() {
    
    
        SqlSession sqlSession = MybatisUtil.getSession();
        //查询id为1的课程中的学生信息
        Course course =
                sqlSession.selectOne("com.ssm.mapper.CourseMapper.findCourseWithStudent",1);
        System.out.println(course);
        sqlSession.close();
    }

Utilisez la méthode de requête imbriquée MyBatis pour interroger les cours et leurs informations sur les étudiants associés. Il s'agit de la requête associée MyBatis plusieurs-à-plusieurs.

Si vous êtes familiarisé avec l'instruction SQL de la requête d'association multi-tables, vous pouvez utiliser la méthode de résultat imbriqué dans CourseMapper.xml, et le code est le suivant.