Comment SpringBoot intègre le framework de cartographie Dozer

1. Introduction à Dozer

Dozer est un mappeur Java Bean vers Java Bean qui copie de manière récursive les données d'un objet à un autre. Dozer est un outil utilisé pour convertir des attributs entre deux objets. Avec cet outil, lorsque nous transférons toutes les valeurs d'attribut d'un objet vers un autre objet, nous n'avons plus besoin d'écrire des appels répétés aux méthodes set et get.

Plus important encore, Dozer garantit que les objets de domaine internes de la base de données ne fuient pas dans les couches de présentation externes ou les consommateurs externes, et il peut également mapper les objets de domaine aux appels d'API externes et vice versa.

2. Pourquoi utiliser le framework de cartographie Dozer

Le framework de cartographie joue un grand rôle dans l'architecture en couches Nous pouvons encapsuler les modifications apportées à des objets de données spécifiques et propager ces objets à d'autres. couches (c'est-à-dire objets de données de service externes, objets de domaine, objets de transfert de données, objets de données de service internes) pour créer des couches d'abstraction. Le cadre de mappage est idéal pour une utilisation dans les classes de type Mapper qui sont responsables du mappage des données d'un objet de données à un autre.

Pour l'architecture de système distribué, un effet secondaire est le transfert d'objets de domaine entre différents systèmes. Eh bien, nous ne voulons pas que les objets de domaine internes soient exposés à l'extérieur, et nous ne voulons pas non plus que des objets de domaine externes infiltrent notre système.

Le mappage entre les objets de données a traditionnellement été résolu avec des assembleurs (ou convertisseurs) d'objets de valeur codés à la main qui copient les données entre les objets. En tant que framework de cartographie open source puissant, polyvalent, flexible, réutilisable et configurable, Dozer permet aux développeurs d'économiser le temps et les coûts liés au développement d'un framework de mappage personnalisé.

3. Utilisation du framework de cartographie Dozer

Coordonnées maven de Dozer :

<dependency>
    <groupId>com.github.dozermapper</groupId>
    <artifactId>dozer-core</artifactId>
    <version>6.5.0</version>
</dependency>

Afin de simplifier l'utilisation, Dozer fournit également un starter, dont le maven Les coordonnées sont :

<dependency>
    <groupId>com.github.dozermapper</groupId>
    <artifactId>dozer-spring-boot-starter</artifactId>
    <version>6.5.0</version>
</dependency>

Commençons par utiliser le framework de cartographie dozer dans le projet springboot. La structure des répertoires du projet est la suivante :

La première étape consiste à créer le projet maven dozer_demo et à configurer le fichier pom.xml #🎜 🎜#

<?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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.hzz</groupId>
    <artifactId>dozer_demo</artifactId>
    <version>1.0-SNAPSHOT</version>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.2.2.RELEASE</version>
        <relativePath/>
    </parent>
    <dependencies>
        <dependency>
            <groupId>com.github.dozermapper</groupId>
            <artifactId>dozer-spring-boot-starter</artifactId>
            <version>6.5.0</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
    </dependencies>
</project>

#🎜 🎜#La deuxième étape, créer UserDTO et UserEntity

UserDTO class

package com.hzz.dto;
import lombok.Data;
@Data
public class UserDTO {
    private String userId;
    private String userName;
    private int userAge;
    private String address;
    private String birthday;
}

UserEntity class

package com.hzz.entity;
import lombok.Data;
import java.util.Date;
@Data
public class UserEntity {
    private String id;
    private String name;
    private int age;
    private String address;
    private Date birthday;
}

La troisième étape, dans le répertoire resources/dozer/ Créer le fichier de configuration globale du bulldozer global.dozer.xml

<?xml version="1.0" encoding="UTF-8"?>
<mappings xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xmlns="http://dozermapper.github.io/schema/bean-mapping"
          xsi:schemaLocation="http://dozermapper.github.io/schema/bean-mapping
                              http://dozermapper.github.io/schema/bean-mapping.xsd">
    <!--全局配置:<date-format>表示日期格式-->
    <configuration>
        <date-format>yyyy-MM-dd</date-format>
    </configuration>
</mappings>

La quatrième étape consiste à créer le fichier de cartographie du bulldozer biz.dozer.xml

<?xml version="1.0" encoding="UTF-8"?>
<mappings xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xmlns="http://dozermapper.github.io/schema/bean-mapping"
          xsi:schemaLocation="http://dozermapper.github.io/schema/bean-mapping
                             http://dozermapper.github.io/schema/bean-mapping.xsd">
    <!--描述两个类中属性的对应关系，对于两个类中同名的属性可以不映射-->
    <mapping date-format="yyyy-MM-dd">
        <class-a>com.hzz.entity.UserEntity</class-a>
        <class-b>com.hzz.dto.UserDTO</class-b>
        <field>
            <a>id</a>
            <b>userId</b>
        </field>
        <field>
            <a>name</a>
            <b>userName</b>
        </field>
        <field>
            <a>age</a>
            <b>userAge</b>
        </field>
    </mapping>
    <!--
    可以使用 map-id 指定映射的标识，在程序中通过此标识来确定使用当前这个映射关系
    -->
    <mapping date-format="yyyy-MM-dd" map-id="user">
        <class-a>com.hzz.entity.UserEntity</class-a>
        <class-b>com.hzz.dto.UserDTO</class-b>
        <field>
            <a>id</a>
            <b>userId</b>
        </field>
        <field>
            <a>name</a>
            <b>userName</b>
        </field>
        <field>
            <a>age</a>
            <b>userAge</b>
        </field>
    </mapping>
</mappings>

#🎜🎜 dans les ressources /dozer/ répertoire #La cinquième étape, écrivez le fichier application.yml

dozer:

mappingFiles:

- classpath:dozer/global.dozer.xml# 🎜🎜# - classpath :dozer/biz.dozer.xml

La sixième étape consiste à créer la classe de démarrage principale DozerApp

package com.hzz;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class DozerApp {
    public static void main(String[] args) {
        SpringApplication.run(DozerApp.class, args);
    }
}

La septième étape consiste à écrire le test unitaire DozerTest

package com.hzz;
import com.github.dozermapper.core.Mapper;
import com.hzz.dto.UserDTO;
import com.hzz.entity.UserEntity;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
@RunWith(SpringRunner.class)
@SpringBootTest(classes = DozerApp.class)
public class DozerTest {
    @Autowired
    private Mapper mapper;
    @Test
    public void testDozer() {
        UserDTO userDTO = new UserDTO();
        userDTO.setUserId("100");
        userDTO.setUserName("ls");
        userDTO.setUserAge(2);
        userDTO.setAddress("bj");
        userDTO.setBirthday("2020-07-04");
        UserEntity user = mapper.map(userDTO, UserEntity.class);
        System.out.println(user);
    }
    @Test
    public void testDozer2(){
        UserDTO userDTO = new UserDTO();
        userDTO.setUserId("100");
        userDTO.setUserName("ls");
        userDTO.setUserAge(5);
        userDTO.setAddress("bj");
        userDTO.setBirthday("2017-07-04");
        UserEntity user = new UserEntity();
        user.setId("200");
        System.out.println(user);
        mapper.map(userDTO, user);
        System.out.println(user); //被 userDTO 覆盖了
    }
    @Test
    public void testDozer3(){
        UserDTO userDTO = new UserDTO();
        userDTO.setUserId("100");
        userDTO.setUserName("zs");
        userDTO.setUserAge(3);
        userDTO.setAddress("bj");
        UserEntity user = new UserEntity();
        System.out.println(user);
        mapper.map(userDTO,user,"user"); //指定映射ID为user
        System.out.println(user);
    }
}

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!