Traitement de la logique métier complexe de la requête multi-table MyBatis : exemple de démonstration

Exemple de requête multi-tables MyBatis : comment gérer une logique métier complexe de données de tables associées nécessite des exemples de code spécifiques

En développement, nous sommes souvent confrontés à des situations où nous devons interroger plusieurs tables associées. Dans ce cas, afin de répondre à des exigences métier complexes, nous devons traiter une certaine logique métier des données de table associées lors de l'interrogation. Cet article explique comment utiliser MyBatis pour effectuer des requêtes multi-tables et donne des exemples de code spécifiques.

Tout d'abord, nous devons créer des tables de données et des classes d'entités pertinentes. Supposons que nous ayons deux tables : l’une est la table des utilisateurs et l’autre est la table des commandes. Il existe une relation entre ces deux tables et un utilisateur peut avoir plusieurs commandes.

Nous créons d'abord la table user user :

CREATE TABLE `user` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `name` varchar(50) NOT NULL,
  PRIMARY KEY (`id`)
)

Ensuite, nous créons la table de commande order :

CREATE TABLE `order` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `user_id` int(11) NOT NULL,
  `amount` decimal(10,2) NOT NULL,
  PRIMARY KEY (`id`),
  INDEX `fk_user_id` (`user_id`),
  CONSTRAINT `fk_user_id` FOREIGN KEY (`user_id`) REFERENCES `user` (`id`)
)

Ensuite, nous créons les classes d'entités correspondantes User et Order :

User.java :

public class User {
    private int id;
    private String name;
    // 省略getter和setter方法
}

Order.java :

public class Order {
    private int id;
    private User user;
    private BigDecimal amount;
    // 省略getter和setter方法
}

Ensuite, nous devons écrire l'interface de requête Mapper et le fichier XML Mapper correspondant. Supposons que nous devions interroger les utilisateurs et leur liste de commandes, cela peut être réalisé de la manière suivante.

UserMapper.java :

public interface UserMapper {
    User getUserById(int id);

    List<Order> getOrdersByUserId(int userId);
}

UserMapper.xml :

<!-- 查询用户 -->
<select id="getUserById" parameterType="int" resultType="User">
    SELECT * FROM `user` WHERE id = #{id}
</select>

<!-- 查询订单 -->
<select id="getOrdersByUserId" parameterType="int" resultMap="OrderMap">
    SELECT o.id as order_id, o.amount, u.id as user_id, u.name
    FROM `order` o
    INNER JOIN `user` u ON o.user_id = u.id
    WHERE o.user_id = #{userId}
</select>

<!-- 定义ResultMap -->
<resultMap id="OrderMap" type="Order">
    <id property="id" column="order_id"/>
    <result property="amount" column="amount"/>
    <association property="user" column="user_id" javaType="User"
                 resultMap="UserResultMap"/>
</resultMap>

<!-- 定义User的ResultMap -->
<resultMap id="UserResultMap" type="User">
    <id property="id" column="user_id"/>
    <result property="name" column="name"/>
</resultMap>

Dans le code ci-dessus, nous associons les deux tables via INNER JOIN et utilisons ResultMap pour mapper les résultats de la requête dans l'objet Order. Dans le même temps, nous définissons également un User ResultMap pour mapper les résultats de la requête aux objets User.

Nous pouvons désormais utiliser MyBatis pour effectuer des requêtes multi-tables et traiter une logique métier complexe des données de table associées.

SqlSessionFactory sqlSessionFactory = // 获取SqlSessionFactory
SqlSession sqlSession = sqlSessionFactory.openSession();
try {
    UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
    
    User user = userMapper.getUserById(1);
    List<Order> orders = userMapper.getOrdersByUserId(1);
    
    user.setOrders(orders); // 将订单列表设置到用户对象中
    
    // 处理业务逻辑
    for (Order order : orders) {
        // ...
    }
} finally {
    sqlSession.close();
}

Dans le code ci-dessus, nous interrogeons d'abord les informations utilisateur de l'identifiant spécifié via la méthode getUserById, puis interrogeons la liste de commandes de l'utilisateur via la méthode getOrdersByUserId. Enfin, nous définissons la liste de commandes dans l'objet utilisateur afin de gérer une logique métier complexe.

Grâce à l'exemple de code ci-dessus, nous pouvons voir que la logique métier complexe de l'utilisation de MyBatis pour effectuer des requêtes multi-tables et traiter les données de table associées n'est pas compliquée. En concevant correctement l'interface Mapper et le fichier XML Mapper, nous pouvons facilement implémenter une telle fonction.

En résumé, cet article explique comment utiliser MyBatis pour effectuer des requêtes multi-tables et traiter une logique métier complexe de données de table associées, et donne des exemples de code spécifiques. J'espère que cela vous sera utile lorsque vous traiterez des requêtes multi-tables en développement réel.

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!