Explication détaillée du fichier de mappage Mybatis

Cet article vous apporte une explication détaillée du fichier de cartographie Mybatis. Il a une certaine valeur de référence. Les amis dans le besoin peuvent s'y référer. J'espère qu'il vous sera utile.

Le véritable noyau de MyBatis est le fichier de mappage. Parce qu'il est extrêmement puissant, si vous le comparez avec le code JDBC avec la même fonction, vous constaterez qu'il enregistre près de 95 % du code.

Fichier de mappage de classe d'entité MyBatis

MyBatis comporte plusieurs éléments de niveau supérieur

select : instruction de requête de mappage

<select id="findAll" resultType="com.simple.mybatis.entitys.Employee">
        select * from tal_employee
</select>

insert : instruction d'insertion de mappage

Utilisez #{nom de l'attribut du paramètre} pour attribuer une valeur

<insert id="saveEmp" parameterType="com.simple.mybatis.entitys.Employee">
        insert into tal_employee(last_name,email,gender) values(#{lastName},#{email},#{gender})
</insert>

 : instruction de modification de la carte

<update id="updateEmp" parameterType="com.simple.mybatis.entitys.Employee">
        update tal_employee set last_name=#{lastName},email=#{email},gender=#{gender} where id=#{id}
 </update>

 : instruction de suppression de la carte

<delete id="deleteEmp" parameterType="Integer">
        delete from tal_employee where id=#{id}
</delete>

: oui, des instructions SQL réutilisées par d'autres instructions SQL.
 : C'est l'élément le plus complexe et le plus puissant, utilisé pour mapper les tables de base de données et les classes d'entités.

<resultMap type="com.simple.mybatis.entitys.Employee" id="Employee">
    <id property="id" column="id"/>
    <result property="lastName" column="last_name"/>
    <result property="email" column="email"/>
    <result property="gender" column="gender"/></resultMap><!-- 返回外部resultMap格式的类型。-->
 <select id="findAll" resultMap="Employee">
    select id,last_name AS lastName,email,gender from tal_employee
</select>

 : Configuration du cache pour l'espace de noms donné.
 : références à d'autres configurations de cache d'espace de noms.

Nous combinons le chapitre 1 et utilisons la méthode précédente d'interaction avec la base de données :

sqlSession.selectList("命名空间.select标签ID");
sqlSession.selectOne("命名空间.select标签ID");
sqlSession.update("命名空间.update标签ID", "Object类型参数");
sqlSession.delete("命名空间.delete标签ID", "Object类型参数");
sqlSession.insert("命名空间.insert标签ID", "Object类型参数");

Les transactions d'ajout, de suppression et de modification doivent être soumises : sqlSession.commit();

Lors de l'utilisation de la méthode du fichier de mappage XML pour exécuter la méthode, puisque la méthode est appelée via la méthode chaîne, les contraintes de type ne sont pas obligatoires et la lisibilité est mauvaise. C'était la méthode d'appel des premiers ibatis. De plus, Mybatis fournit également deux autres méthodes d'implémentation

Méthode d'annotation MyBatis

1 @Select : utilisée pour modifier la méthode d'utilisation des instructions de requête

2. Utilisé pour modifier la méthode d'ajout d'instructions,

3. @Update : Utilisé pour modifier la méthode de modification et de modification.

4. @Delete : utilisé pour modifier la méthode d'utilisation de l'instruction delete.

interface publique EmployeeAnnotation {
@Select("select id,last_name AS lastName,email,gender from tal_employee")
List

 @Insert("insert into tal_employee(last_name,email,gender) values(#{lastName},#{email},#{gender})")
 int saveEmp(Employee employee);

 @Update("update tal_employee set last_name=#{lastName},email=#{email},gender=#{gender} where id=#{id}")
 boolean updateEmp(Employee employee);

 @Delete("elete from tal_employee where id=#{id}")
 long deleteEmp(Integer id);
 }

Ensuite, nous devons configurer le mybatis master Bien qu'il soit plus pratique d'utiliser des annotations en mappant cette interface d'annotation

<!-- 映射注解类 -->
<mapper class="com.simple.mybatis.dao.EmployeeAnnotation"/>

@Test
    public void testAnnotation(){
        SqlSession session = sqlSessionFactory.openSession();
        EmployeeAnnotation employeeAnnotation = session.getMapper(EmployeeAnnotation.class);
        Employee employee = new Employee("测试注解增加", "email", "男");
        employeeAnnotation.saveEmp(employee);
        //提交事务
        session.commit();
        session.close();
}

dans le fichier de configuration, il est plus compliqué de configurer des instructions SQL complexes. C’est pourquoi une combinaison des deux méthodes est souvent utilisée.

Programmation de l'interface Mybatis

On ajoute d'abord une interface

public interface EmployeeMapper {
    List<Employee> findAll();
    
    int saveEmp(Employee employee);
    
    boolean updateEmp(Employee employee);
    
    long deleteEmp(Integer id);
}

L'espace de noms du fichier de mapping de classe d'entité doit correspondre au nom complet de l'interface, et les méthodes à l'intérieur il faut correspondre Ajouter, supprimer, modifier et vérifier l'ID de la balise pour compléter la liaison

<?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.simple.mybatis.dao.EmployeeMapper">
    <resultMap type="com.simple.mybatis.entitys.Employee" id="Employee">
        <id property="id" column="id"/>
        <result property="lastName" column="last_name"/>
        <result property="email" column="email"/>
        <result property="gender" column="gender"/>
    </resultMap>

    <!-- 返回外部resultMap格式的类型。-->
    <select id="findAll" resultMap="Employee">
        select id,last_name AS lastName,email,gender from tal_employee
    </select>
    
    <insert id="saveEmp" parameterType="com.simple.mybatis.entitys.Employee">
        insert into tal_employee(last_name,email,gender) values(#{lastName},#{email},#{gender})
    </insert>
    
    <update id="updateEmp" parameterType="com.simple.mybatis.entitys.Employee">
        update tal_employee set last_name=#{lastName},email=#{email},gender=#{gender} where id=#{id}
    </update>
    
    <delete id="deleteEmp" parameterType="Integer">
        delete from tal_employee where id=#{id}
    </delete>
</mapper>

et ce fichier de mappage doit être chargé dans le fichier de configuration principal de MyBatis

<mappers>
        <mapper resource="com/simple/mybatis/entitys/EmployeeMapper.xml" />
</mappers>

Utilisation :

@Test
    public void test4(){
        SqlSession session = sqlSessionFactory.openSession();
        //获取接口。这个接口mybatis会帮我创建代理实现类完成接口与XML映射的绑定
        EmployeeMapper employeeMapper = session.getMapper(EmployeeMapper.class);
        employeeMapper.deleteEmp(1);
        session.commit();
        session.close();
    }

Obtenir la clé primaire à croissance automatique après l'insertion

Le paramètre useGeneratedKeys ne prend effet que pour l'instruction insert, et la valeur par défaut est false. Lorsqu'il est défini sur true, cela signifie que si la table insérée a une colonne à incrémentation automatique comme clé primaire, JDBC est autorisé à prendre en charge la génération automatique de la clé primaire et la clé primaire générée automatiquement peut être renvoyée. keyProperty doit être encapsulé dans le nom de l'attribut d'ID de clé primaire dans paramètreType="com.simple.mybatis.entitys.Employee

<insert id="saveEmpGetKey" parameterType="com.simple.mybatis.entitys.Employee"
    useGeneratedKeys="true" keyProperty="id"
    >
        insert into tal_employee(last_name,email,gender) values(#{lastName},#{email},#{gender})
</insert>

@Test
    public void saveEmpGetKey(){
        SqlSession session = sqlSessionFactory.openSession();
        EmployeeMapper employeeMapper = session.getMapper(EmployeeMapper.class);
        Employee employee = new Employee("自动封装主键", "email", "男");//增加之前主键没赋值
        employeeMapper.saveEmpGetKey(employee);
        session.commit();//提交事务
        System.out.println("增加后主键有值： " + employee.getId());
        session.close();//关闭资源
    }

Règles du paramètre Mybatis

lorsqu'un paramètre est utilisé :

Utilisez simplement #{xxx} pour accéder au paramètre. Par exemple, #{a}, #{b} peuvent accéder à la valeur du paramètre. S'il s'agit d'un type de collection (Collection, Liste, Ensemble). nom minuscule de la collection.

Méthode d'interface requise :

long deleteEmp(Integer emp);

Fichier de mappage :

<delete id="deleteEmp" parameterType="Integer">
        delete from tal_employee where id=#{id}
</delete>

Vous pouvez voir ici que nous n'avons pas attribué de valeur. valeur à ceci, #{id }Mon nom d'attribut ne s'appelle pas id mais emp, donc le nom d'un paramètre peut être arbitraire S'il s'agit du type de collection entrant

, la valeur lors du passage du paramètre Map. :

//接口有方法：long deleteEmp(Map<String, Object> map);
<delete id="deleteEmp" parameterType="Map">
        delete from tal_employee where id=#{empID}
</delete>

La valeur ici est empID Si vous y réfléchissez, créez simplement un map.put("empID", 1) et transmettez-le comme paramètre à l'appel de méthode

<. 🎜>Lorsqu'il y a plusieurs paramètres :

1. Par défaut : vous ne pouvez pas utiliser #{xxx} pour accéder aux paramètres. Lorsqu'il y a plusieurs paramètres, mybatis encapsulera les paramètres dans un ensemble de cartes, qui. accessible uniquement via #{subscript} ou #{paramN} Méthode pour obtenir la valeur

2. Paramètres nommés : spécifiez manuellement la clé de la carte en ajoutant @Param("key"). à la méthode d'interface. 🎜>

Classe d'entité : Si plusieurs paramètres sont des classes métier encapsulées, vous pouvez directement transmettre l'objet métier Map : S'il y en a plusieurs. classe affaires, vous pouvez alors transmettre la collection de cartes pour obtenir la valeur correspondante 🎜>Dans MyBatis, en plus d'utiliser #{} pour obtenir la valeur du paramètre, vous pouvez également utiliser ${} pour obtenir la valeur de. le paramètre.

3. Différence : #{} : sera pré-compilé. Les paramètres sont générés dans l'instruction sql ${} : générera directement la valeur dans l'instruction sql

In. dans la plupart des cas, nous utilisons #{} pour obtenir les paramètres, mais les espaces réservés ne sont pas pris en charge à certains endroits. Vous pouvez ensuite utiliser ${} pour obtenir des paramètres, tels que le nom de la table

resultType return type

.

Pour les méthodes d'ajout, de suppression et de modification, Mybatis modifiera automatiquement les résultats. L'encapsulation peut renvoyer un entier, un booléen ou un long

Pour renvoyer l'entité. et les collections List, le resultType peut être défini sur le type d'entité. Si un seul objet est renvoyé, il peut également être encapsulé sous la forme Map, et le resultType est défini sur map.

1. Si un objet de collection Map est renvoyé, tel que Map, le resultType est défini sur le type Student et la valeur clé placée dans la Map est modifiée via le @MapKey("id")annotation .

ResultMap标签介绍

ResultMap的常用子标签

1. id：映射主键。result：映射普通列。

2. association：复杂结果映射。

3. collection：复杂类型的集合映射。

4. constructor：构造函数注入。

前面我们的案例我们数据库的字段与实体类的属性基本上一致，或者不一致使用取别名方案解决，可是每条语句都去取别名是非常麻烦的，ResultMap这个标签就很好的解决数据库与实体类字段不对应的问题

我们新创建一个部门表：

CREATE TABLE tal_dept(
    d_id INT PRIMARY KEY AUTO_INCREMENT,
    d_name VARCHAR(50)
);

对应实体类：

public class Dept {
    private Integer id;
    private Integer name;
}

如果我们查询语句直接使用resultType="com.simple.mybatis.entitys.Dept那么毫无疑问我们的实体类中名字不对应是赋值为null的，我们可以ResultMap映射实体类与数据库的对应关系

<!--配置返回结果，配置数据库字段与类属性的映射-->
<resultMap type="com.simple.mybatis.entitys.Dept" id="DeptResult">
        <id column="d_id" property="id"/>
        <result column="d_name" property="name"/>
</resultMap>
<!--使用resultMap使用指向上面返回结果的ID-->
<select id="getDeptOne" parameterType="Integer" resultMap="DeptResult">
        select * from tal_dept where d_id = #{id}
</select>

关系映射

在数据库中，许多数据是分布在多个表中的，有时候需要将多个表的数据关联起来进行查询。那么在ORM框架中，我们需要处理数据表的映射关系。

常见的映射关系：

1. 关联属性映射association

2. 映射collection映射

result方式映射属性

这种方式并不推荐，没有什么重用性

<resultMap type="com.simple.mybatis.entitys.Employee" id="EmployeeOrDept">
        <id property="id" column="id"/>
        <result property="lastName" column="last_name"/>
        <result property="email" column="email"/>
        <result property="gender" column="gender"/>
        <!-- 指定Employee中Dept对象属性 -->
        <result property="dept.id" column="d_id"/>
        <result property="dept.name" column="d_name"/>
</resultMap>
<select id="getEmployeeOrDeptAll" resultMap="EmployeeOrDept">
        select * from tal_employee e inner join tal_dept d on e.d_id=d.d_id
</select>

association映射（分步查询）

多对一，查询员工获取员工中的部门：

<resultMap type="com.simple.mybatis.entitys.Employee" id="EmployeeOrDept">
        <id property="id" column="id"/>
        <result property="lastName" column="last_name"/>
        <result property="email" column="email"/>
        <result property="gender" column="gender"/>
        <!-- property指定实体类中对象dept 指定发过去的参数column="d_id" 
             select指定com.simple.mybatis.dao.DeptMapper映射文件中getDeptOne查询方法
         -->
        <association property="dept" column="d_id" 
        select="com.simple.mybatis.dao.DeptMapper.getDeptOne"></association>
</resultMap>
<!--resultMap指定使用上面定义的返回结果-->
<select id="getEmployeeOrDeptAll" resultMap="EmployeeOrDept">
        select * from tal_employee e inner join tal_dept d on e.d_id=d.d_id
</select>

Collection查询

一对多，获取部门同时部门中员工也获取：

<!--部门映射-->
<resultMap type="com.simple.mybatis.entitys.Dept" id="DeptResult">
        <id column="d_id" property="id"/>
        <result column="d_name" property="name"/>
        <!--property指定Dept中集合属性名 ofType指定集合中属性类型 -->
        <collection property="Employees" ofType="com.simple.mybatis.entitys.Employee" >
            <id property="id" column="id"/>
            <result property="lastName" column="last_name"/>
            <result property="email" column="email"/>
            <result property="gender" column="gender"/>
        </collection>
</resultMap>
<select id="getDeptAll" resultMap="DeptResult">
        select * from tal_dept d left join tal_Employee e on d.d_id = e.d_id
</select>

Collection嵌套查询

一对多分布查询

<resultMap type="com.simple.mybatis.entitys.Dept" id="DeptOrEmployee">
        <id column="d_id" property="id"/>
        <result column="d_name" property="name"/>
        <!--select指定com.simple.mybatis.dao.EmployeeMapper映射文件中的getEmployeeByDeptId-->
        <collection property="Employees" column="d_id"  ofType="com.simple.mybatis.entitys.Employee" 
        select="com.simple.mybatis.dao.EmployeeMapper.getEmployeeByDeptId">
        </collection>
    </resultMap>
<!--com.simple.mybatis.dao.EmployeeMapperXML中方法-->
<select id="getEmployeeByDeptId" parameterType="Integer" resultType="com.simple.mybatis.entitys.Employee">
        select * from tal_employee where d_id = #{id}
    </select>

关联查询和分步查询的区别：

1. 关联查询一次将多个表的数据查询出来，分步查询通过多次查询获取查询结果。

2. 配置文件不同，关联查询需要定义额外的映射，分步查询需要定义外键列，和查询的select方法。

3. 关联查询不支持延迟加载，分步查询支持延迟加载。fetchType="lazy"

延迟加载

刚才分布查询是一次将结果查询出来，为了提高效率，mybatis还支持延迟加载技术，等需要用到对象时才进行查询。

在mybatis主配置文件中配置:

<!– 通过全局配置文件设置延迟加载-->
<settings>
<!-- 全局启用或禁用延迟加载。当禁用时，所有关联对象都会即时加载。 -->
<setting name="lazyLoadingEnabled" value="true"/>
<!-- 当启用时，有延迟加载属性的对象在被调用时将会完全加载任意属性。否则，每种属性将会按需要加载。 -->
<setting name="aggressiveLazyLoading" value="false"/>
</settings>

设置级联延迟加载

<!– 设置延迟加载属性-->
<association fetchType="lazy"/>

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!