通用权限系统-Dozer对象转换

合集 - SpringBoot(6)

1.SpringBoot利用自定义注解实现多数据源05-212.SpringBoot实现限流注解05-213.SpringBoot整合OSS文件上传05-314.通用权限系统-Spring-Boot-Starter07-08

5.通用权限系统-Dozer对象转换07-09

6.SpringBoot对接OpenAI08-06

收起

Dozer对象转换

介绍

Dozer 是一个 Java Bean 到 Java Bean 的映射器，它可以递归地将数据从一个对象复制到另一个。通常情况下，这些Java Beans将是不同的复杂类型。

Dozer支持简单的属性映射，复杂的类型映射，双向映射，隐式-显式映射，以及递归映射。这包括映射集合属性，这些集合属性也需要在元素层面进行映射。

Dozer是Java Bean到Java Bean映射器，它以递归方式将数据从一个对象复制到另一个对象。 dozer是用来对两个对象之间属性转换的工具，有了这个工具之后，我们将一个对象的所有属性值转给另一个对象时，就不需要再去写重复的调用set和get方法了。dozer其实是对我们熟知的beanutils的封装。

dozer的maven坐标：

<dependency>
    <groupId>com.github.dozermappergroupId>
    <artifactId>dozer-coreartifactId>
    <version>6.5.0version>
dependency>

为了简化使用方式，dozer还提供了starter，其maven坐标为：

<dependency>
    <groupId>com.github.dozermappergroupId>
    <artifactId>dozer-spring-boot-starterartifactId>
    <version>6.5.0version>
dependency>

Dozer入门案例

第一步：创建maven工程dozer_demo并配置pom.xml文件

<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.0modelVersion>
    <parent>
        <groupId>org.springframework.bootgroupId>
        <artifactId>spring-boot-starter-parentartifactId>
        <version>2.2.2.RELEASEversion>
        <relativePath/>
    parent>
    <groupId>org.ppgroupId>
    <artifactId>dozer-demoartifactId>
    <version>1.0-SNAPSHOTversion>
 
    <properties>
        <maven.compiler.source>8maven.compiler.source>
        <maven.compiler.target>8maven.compiler.target>
        <project.build.sourceEncoding>UTF-8project.build.sourceEncoding>
    properties>
    <dependencies>
        <dependency>
            <groupId>com.github.dozermappergroupId>
            <artifactId>dozer-spring-boot-starterartifactId>
            <version>6.5.0version>
        dependency>
        <dependency>
            <groupId>junitgroupId>
            <artifactId>junitartifactId>
        dependency>
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-testartifactId>
        dependency>
        <dependency>
            <groupId>org.projectlombokgroupId>
            <artifactId>lombokartifactId>
        dependency>
    dependencies>
project>

第二步：创建UserDTO和UserEntity

package org.pp.dto;
 
import lombok.Data;
 
/**
 * TODO
 *
 * @author ss_419
 * @version 1.0
 * @date 2023/7/9 17:29
 */
@Data
public class UserDTO {
    private String userId;
    private String userName;
    private int userAge;
    private String address;
    private String birthday;
}

package org.pp.entity;
 
import lombok.Data;
import java.util.Date;
/**
 * @author ss_419
 */
@Data
public class UserEntity {
    private String id;
    private String name;
    private int age;
    private String address;
    private Date birthday;
}

第三步：在resources/dozer/目录下创建dozer的全局配置文件global.dozer.xml

<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">
    
    <configuration>
        <date-format>yyyy-MM-dddate-format>
    configuration>
mappings>

注：全局配置文件名称可以任意

第四步：在resources/dozer/目录下创建dozer的映射文件biz.dozer.xml

<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>org.pp.entity.UserEntityclass-a>
        <class-b>org.pp.dto.UserDTOclass-b>
        <field>
            <a>ida>
            <b>userIdb>
        field>
        <field>
            <a>namea>
            <b>userNameb>
        field>
        <field>
            <a>agea>
            <b>userAgeb>
        field>
    mapping>
    
    <mapping date-format="yyyy-MM-dd" map-id="user">
        <class-a>org.pp.entity.UserEntityclass-a>
        <class-b>org.pp.dto.UserDTOclass-b>
        <field>
            <a>ida>
            <b>userIdb>
        field>
        <field>
            <a>namea>
            <b>userNameb>
        field>
        <field>
            <a>agea>
            <b>userAgeb>
        field>
    mapping>
mappings>

注：映射文件名称可以任意

第五步：编写application.yml文件

dozer:
  mappingFiles:
    - classpath:dozer/global.dozer.xml
    - classpath:dozer/biz.dozer.xml

第六步：编写启动类DozerApp

package org.pp;
 
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
 
/**
 * @author ss_419
 */
@SpringBootApplication
public class DozerApp {
    public static void main(String[] args) {
        SpringApplication.run(DozerApp.class,args);
    }
}

第七步：编写单元测试DozerTest

package org.pp.test;
 
import com.github.dozermapper.core.Mapper;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.pp.DozerApp;
import org.pp.dto.UserDTO;
import org.pp.entity.UserEntity;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
 
/**
 * TODO
 *
 * @author ss_419
 * @version 1.0
 * @date 2023/7/9 17:59
 */
@RunWith(SpringRunner.class)
@SpringBootTest(classes = DozerApp.class)
public class DozerTest {
    @Autowired
    private Mapper mapper;// 使用Mapper对象可以完成两个对象之间属性复制
 
    /**
     * 原本UserEntity不存在
     */
    @Test
    public void testDozer1(){
        UserDTO userDTO = new UserDTO();
        userDTO.setUserId("100");
        userDTO.setUserName("panpan");
        userDTO.setUserAge(24);
        userDTO.setAddress("nj");
        userDTO.setBirthday("1999-04-19");
 
        // 调用方法进行转换
        UserEntity user = mapper.map(userDTO, UserEntity.class);
        System.out.println("user = " + user);
    }
 
 
    /**
     * 原本UserEntity已经存在，对其进行覆盖参数值
     */
    @Test
    public void testDozer2(){
        UserDTO userDTO = new UserDTO();
        userDTO.setUserId("100");
        userDTO.setUserName("itcast");
        userDTO.setUserAge(20);
        userDTO.setAddress("bj");
        userDTO.setBirthday("2010-11-20");
 
        UserEntity userEntity = new UserEntity();
        userEntity.setId("2000");
        System.out.println("1====>  userEntity = " + userEntity);
        mapper.map(userDTO,userEntity);
        System.out.println("2====>  userEntity = " + userEntity);
 
    }
    @Test
    public void testDozer3(){
        UserDTO userDTO = new UserDTO();
        userDTO.setUserId("100");
        userDTO.setUserName("itcast");
        userDTO.setUserAge(20);
        userDTO.setAddress("bj");
 
        UserEntity user = new UserEntity();
        System.out.println(user);
        // 指定使用配置文件中的映射关系进行映射
        mapper.map(userDTO,user,"user");
        System.out.println(user);
    }
}
 

pd-tools-dozer使用

在pd-tools-dozer模块中为了进一步简化操作，封装了一个工具类DozerUtils，其内部使用的就是Mapper对象进行的操作。并且按照Spring Boot starter的规范编写/resources/META-INF/spring.factories文件，内容如下：

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
    com.itheima.pinda.dozer.DozerAutoConfiguration

在配置类DozerAutoConfiguration中完成DozerUtils对象的创建，这样其他的程序如果需要使用dozer进行对象转换，只需要引入这个模块的maven坐标并且提供对应的映射文件就可以在程序中直接注入DozerUtils对象进行操作了。

具体使用过程：

第一步：创建maven工程myDozerApp并配置pom.xml

<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.0modelVersion>
    <parent>
        <groupId>org.springframework.bootgroupId>
        <artifactId>spring-boot-starter-parentartifactId>
        <version>2.2.2.RELEASEversion>
        <relativePath/>
    parent>
    <groupId>org.ppgroupId>
    <artifactId>myDozerDemoartifactId>
    <version>1.0-SNAPSHOTversion>
 
    <properties>
        <maven.compiler.source>8maven.compiler.source>
        <maven.compiler.target>8maven.compiler.target>
        <project.build.sourceEncoding>UTF-8project.build.sourceEncoding>
    properties>
    <dependencies>
        
        <dependency>
            <groupId>com.itheimagroupId>
            <artifactId>pd-tools-dozerartifactId>
            <version>1.0-SNAPSHOTversion>
        dependency>
        <dependency>
            <groupId>org.projectlombokgroupId>
            <artifactId>lombokartifactId>
        dependency>
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-webartifactId>
        dependency>
    dependencies>
project>

第二步：创建UserEntity和UserDTO

package org.pp.entity;
 
import lombok.Data;
 
/**
 * @author ss_419
 */
@Data
public class UserEntity {
    private Integer id;
    private String name;
    private int age;
    private String addr;
}

package org.pp.dto;
 
import lombok.Data;
 
/**
 * @author ss_419
 */
@Data
public class UserDTO {
    private Integer userId;
    private String userName;
    private int userAge;
    private String address;
}

第三步：创建UserController

package org.pp.controller;
 
import com.itheima.pinda.dozer.DozerUtils;
import org.pp.dto.UserDTO;
import org.pp.entity.UserEntity;
 
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
 
@RestController
@RequestMapping("/user")
public class UserController {
    @Autowired
    private DozerUtils dozerUtils; //在pd-tools-dozer中已经完成了自动配置，可以直接注入
 
    @GetMapping("/mapper")
    public UserEntity mapper(){
        UserDTO userDTO = new UserDTO();
        userDTO.setUserId(10);
        userDTO.setUserName("P_P");
        userDTO.setUserAge(20);
        userDTO.setAddress("njnj");
        System.out.println("userDTO = " + userDTO);
        UserEntity userEntity = dozerUtils.map(userDTO, UserEntity.class);
        System.out.println("userEntity = " + userEntity);
        return userEntity;
    }
}

第四步：创建application.yml

server:
  port: 8080

第五步：创建启动类

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

启动项目，访问地址：http://localhost:8080/user/mapper

注意：由于当前我们创建的UserEntity和UserDTO中的属性完全一致，所以并没有提供映射文件，如果这两个类中的属性存在不一致的情况，需要创建映射文件进行映射，并且还需要在application.yml中配置映射文件的位置，例如：

dozer:
  mappingFiles:
    - classpath:dozer/biz.dozer.xml  #指定dozer的映射文件位置