SpringBoot整合Dozer映射框架流程详解

目录
  • 1. Dozer 介绍
  • 2. 为什么要使用映射框架 Dozer
  • 3. Dozer 映射框架的使用

1. Dozer 介绍

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

最重要的是,Dozer 可以确保来自数据库的内部域对象不会渗入外部表示层或外部消费者,它还可以将域对象映射到外部 API 调用,反之亦然。

2. 为什么要使用映射框架 Dozer

映射框架在分层架构中作用很大,我们可以通过封装对特定数据对象的更改与将这些对象传播到其他层(即外部服务数据对象、域对象、数据传输对象、内部服务数据对象)来创建抽象层。 映射框架非常适合在负责将数据从一个数据对象映射到另一个数据对象的 Mapper 类型类中使用。

对于分布式系统架构而言,副作用是域对象在不同系统之间的传递。那么,我们不希望内部域对象暴露在外部,也不允许外部域对象渗入我们的系统。

数据对象之间的映射传统上是通过在对象之间复制数据的手动编码值对象组装器(或转换器)来解决的。Dozer 作为一个强大、通用、灵活、可重用和可配置的开源映射框架,节省了开发人员开发某种自定义映射器框架带来的时间成本。

3. Dozer 映射框架的使用

Dozer 的 maven 坐标:

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

为了简化使用方式,Dozer 还提供了 starter,其 maven 坐标为:

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

下面就开始着手在 springboot 项目中使用 dozer 映射框架。工程的目录结构如下图所示:

第一步,创建 maven 工程 dozer_demo 并配置 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>

第二步,创建 UserDTO 和 UserEntity

UserDTO 类

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 类

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;
}

第三步,在 resources/dozer/ 目录下创建 dozer 的全局配置文件 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>

第四步,在 resources/dozer/ 目录下创建 dozer 的映射文件 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>

第五步,编写 application.yml 文件

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

第六步,创建主启动类 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);
    }
}

第七步,编写单元测试 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);
    }
}

到此这篇关于SpringBoot整合Dozer映射框架流程详解的文章就介绍到这了,更多相关SpringBoot Dozer映射框架内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们!

(0)

相关推荐

  • Springboot整合Dozer实现深度复制的方法

    目录 Dozer SpringBoot整合Dozer jar依赖引入 dozer配置xml引入 Dozer的JavaConfig 格式化工厂 使用Demo Dozer Dozer是一种Java Bean到Java Bean的映射器,递归地将数据从一个对象复制到另一个对象,它是一个强大的,通用的,灵活的,可重用的和可配置的开源映射框架. 常用于: 代码层与层之间javabean转换, 如dao层PO转前端VO 分布式中, DAO层PO转DTO, DO 以及web层DTO转VO 注意的场景: 由于b

  • SpringBoot2.x集成Dozer的示例代码

    目录 一.引入依赖 二.实体类 三.编写配置文件 四.创建测试类 五.Dozer的基本使用 代码示例 Dozer是Java Bean到Java Bean的映射器,它以递归的方式将数据从一个对象复制到另一个对象.通常,这些Java Bean将具有不同的复杂类型.它支持简单属性映射,复杂类型映射,双向映射,隐式显式映射,以及递归映射.这包括映射需要在元素层面上进行映射的集合属性.可以将Dozer用作两个对象之间属性转换的工具,使用它可以很方便地对项目中的DO.DTO.VO进行相互转换. 本文主要对S

  • SpringBoot中Dozer的使用小结

    什么是Dozer? Dozer是一种Java Bean到Java Bean的映射器,递归地将数据从一个对象复制到另一个对象,它是一个强大的,通用的,灵活的,可重用的和可配置的开源映射框架.说白点就是dozer是一个能把实体和实体之间进行转换的工具.只要建立好映射关系.就像是ORM的数据库和实体映射一样. dozer是用来两个对象之间属性转换的工具,有了这个工具之后,我们将一个对象的所有属性值转给另一个对象时,就不需要再去写重复的set和get方法了. 下面我们来学习一下dozer的使用 1.添加

  • SpringBoot整合Dozer映射框架流程详解

    目录 1. Dozer 介绍 2. 为什么要使用映射框架 Dozer 3. Dozer 映射框架的使用 1. Dozer 介绍 Dozer 是一个 Java Bean 到 Java Bean 的映射器,它递归地将数据从一个对象复制到另一个对象.Dozer 是用来对两个对象之间属性转换的工具,有了这个工具之后,我们将一个对象的所有属性值转给另一个对象时,就不需要再去写重复的调用 set 和 get 方法. 最重要的是,Dozer 可以确保来自数据库的内部域对象不会渗入外部表示层或外部消费者,它还可

  • SpringBoot整合junit与Mybatis流程详解

    目录 SpringBoot整合junit 环境准备 编写测试类 SpringBoot整合mybatis 回顾Spring整合Mybatis SpringBoot整合mybatis 创建模块 定义实体类 定义dao接口 定义测试类 编写配置 测试 使用Druid数据源 SpringBoot整合junit 回顾 Spring 整合 junit @RunWith(SpringJUnit4ClassRunner.class) @ContextConfiguration(classes = SpringC

  • Springboot整合Netty实现RPC服务器详解流程

    目录 一.什么是RPC? 二.实现RPC需要解决那些问题? 1. 约定通信协议格式 RPC请求 RPC响应 2. 序列化方式 3. TCP粘包.拆包 4. 网络通信框架的选择 三.RPC服务端 四.RPC客户端 总结 一.什么是RPC? RPC(Remote Procedure Call)远程过程调用,是一种进程间的通信方式,其可以做到像调用本地方法那样调用位于远程的计算机的服务.其实现的原理过程如下: 本地的进程通过接口进行本地方法调用. RPC客户端将调用的接口名.接口方法.方法参数等信息利

  • SpringBoot自定义路由覆盖实现流程详解

    目录 背景 设计 实现 注解定义 注解扫描及管理 自定义RequestMappingHandlerMapping 注册RequestMappingHandlerMapping 使用示例 背景 公司最近有一个项目二期需要对一些功能进行改造,涉及部分框架内置业务接口个性化定制,兼容老接口功能并且增加一部分新的数据返回,由于前端调用这些接口分布较多且较为零碎,修改测试成本较大,所以打算在框架层面提供路由覆盖功能,加快项目进度减少无技术含量的修改带来的系统风险 设计 提供自定义注解指定需要覆盖的路由及新

  • 使用SpringBoot整合ssm项目的实例详解

    SpringBoot是什么? Spring Boot 是由 Pivotal 团队提供的全新框架,其设计目的是用来简化新 Spring 应用的初始搭建以及开发过程. Spring Boot 现在已经成为 Java 开发领域的一颗璀璨明珠,它本身是包容万象的,可以跟各种技术集成.成为 SpringBoot 全家桶,成为一把万能钥匙. SpringBoot的特点 1.创建独立的 Spring 应用程序 2.嵌入的 Tomcat ,无需部署 WAR 文件 3.简化 Maven 配置 4.自动配置 Spr

  • SpringBoot整合Web之AOP配置详解

    目录 配置AOP AOP简介 Spring Boot 支持 其它 自定义欢迎页 自定义 favicon 除去某个自动配置 配置AOP AOP简介 要介绍面向切面变成(Aspect-Oriented Programming,AOP),需要先考虑一个这样的场景:公司有一个人力资源管理系统目前已经上线,但是系统运行不稳定,有时运行的很慢,为了检测到底是哪个环节出现问题了,开发人员想要监控每一个方法执行的时间,再根据这些执行时间判断出问题所在.当问题解决后,再把这些监控移除掉.系统目前已经运行,如果手动

  • SpringBoot配置和切换Tomcat流程详解

    目录 1.基本介绍 2.内置 Tomcat 的配置 1.通过 application.yml 完成配置 2.通过类来配置 Tomcat 3.切换 WebServer 1.基本介绍 SpringBoot 支持的 webServer: Tomcat, Jetty, or Undertow SpringBoot 应用启动是 Web 应用时.web 场景包-导入 tomcat 支持对 Tomcat(也可以是 Jetty .Undertow)的配置和切换 2.内置 Tomcat 的配置 1.通过 appl

  • SpringBoot Session接口验证实现流程详解

    目录 添加pom.xml 创建简单的测试接口 使用过滤器实现 使用拦截器实现 需求:只有用户登录成功后,才能访问其它接口,否则提示需要进行登录 项目仓库地址:https://gitee.com/aiw-nine/springboot_session_verify 添加pom.xml 新建Spring Boot(2.7.2)项目,添加如下依赖: <?xml version="1.0" encoding="UTF-8"?> <project xmlns

  • SpringBoot整合Netty心跳机制过程详解

    前言 Netty 是一个高性能的 NIO 网络框架,本文基于 SpringBoot 以常见的心跳机制来认识 Netty. 最终能达到的效果: 客户端每隔 N 秒检测是否需要发送心跳. 服务端也每隔 N 秒检测是否需要发送心跳. 服务端可以主动 push 消息到客户端. 基于 SpringBoot 监控,可以查看实时连接以及各种应用信息. IdleStateHandler Netty 可以使用 IdleStateHandler 来实现连接管理,当连接空闲时间太长(没有发送.接收消息)时则会触发一个

  • springboot整合mybatis流程详解

    目录 1.mybatis是什么 2.整合 2.1 导入依赖 2.2 创建包和类 2.3 在application.yaml配置mybatis 3.使用注解版mybaits 4.实战过程 1.mybatis是什么 MyBatis 是一款优秀的持久层框架,它支持自定义 SQL.存储过程以及高级映射.MyBatis 免除了几乎所有的 JDBC 代码以及设置参数和获取结果集的工作.MyBatis 可以通过简单的 XML 或注解来配置和映射原始类型.接口和 Java POJO(Plain Old Java

随机推荐