SpringBoot Dozer

Dozer

Dozer是什么? Dozer是一个JavaBean映射工具库。

它支持简单的属性映射，复杂类型映射，双向映射，隐式显式的映射，以及递归映射。

它支持三种映射方式：注解、API、XML。

springboot Dozer 可以作为项目实战

项目结构：

springboot 配置 Dozer

1.在pom.xml文件里添加Dozer依赖

<!-- dozer 对象间属性值赋值，不同属性名，借助map映射 -->
<dependency>
   <groupId>net.sf.dozer</groupId>
   <artifactId>dozer</artifactId>
   <version>5.4.0</version>
   <exclusions>
      <exclusion>
         <groupId>org.slf4j</groupId>
         <artifactId>slf4j-log4j12</artifactId>
      </exclusion>
      <exclusion>
         <groupId>log4j</groupId>
         <artifactId>log4j</artifactId>
      </exclusion>
   </exclusions>
</dependency>

2.在config文件夹下添加：DozerConfig.java类

一定要在config下添加：springboot项目目录若没有config文件夹就新建一个

配置完成就可以测试使用mapper映射了！

package com.dist.config;

import org.dozer.spring.DozerBeanMapperFactoryBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * @author yangmin
 * @date 2018/4/11
 * 返回一个dozer实例bean，目的是做对象间属性值的赋值操作
 */
@Configuration
public class DozerConfig {
    @Bean
    public DozerBeanMapperFactoryBean mapper() {
        return new DozerBeanMapperFactoryBean();
    }
}

到此，项目就可以使用Dozer了，用Mapper mapper，可以在controller层也可以在server层。

@Autowired
private Mapper mapper;

演示

此处是springboot项目测试，

在entity文件夹目录下，创建实体类

创建UserDTO.java类

package com.dist.entity.dto;

import lombok.Data;
import java.io.Serializable;

//下载idea插件 lombok ，或网上百度@Data
//下载方式：https://blog.csdn.net/qq_37433657/article/details/83275051
@Data
public class UserDTO implements Serializable {
    private String userCode;
    private String loginName;
    private String loginPassword;
    private String deviceCode;
    private String systemCode;
}

创建：UserVO.java类

package com.dist.entity.dto;

import lombok.Data;
import java.io.Serializable;

@Data
public class UserVO implements Serializable {
    private String userCode;
    private String loginName;
    private String loginPassword;
}

在test文件夹下创建测试类：

DozerTest.java

package com.dist.test;

import com.dist.SpringbootdemoApplication;
import com.dist.entity.dto.UserDTO;
import com.dist.entity.dto.UserVO;
import org.dozer.Mapper;
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 = {SpringbootdemoApplication.class})
public class DozerTest{

    @Autowired
    private Mapper mapper;

    /**
     * 单个对象的深度复制及类型转换，vo/domain , po
     * 输出结果： UserVO(userCode=123, loginName=null, loginPassword=null)
     */
    @Test
    public void testMapper(){
        UserDTO userDTO =new UserDTO();
        userDTO.setUserCode("123");
        UserVO userVO = mapper.map(userDTO, UserVO.class);
        System.out.println(userVO);
    }

输出结果： UserVO(userCode=123, loginName=null, loginPassword=null)

映射成功，实现了类的深度复制；并且，过滤掉了前端不需要的数据；

Dozer工具接口和实现类

IGenerator.java接口：封装了Mapper工具接口：实现了list、set，数组，对象等深度复制！

package com.dist.utils;


import java.util.List;
import java.util.Set;

/**
 * @author zhengja@dist.com.cn
 * @data 2019/5/30 15:19
 */
public interface IGenerator {

    /**
     * @Description: 单个对象的深度复制及类型转换，vo/domain , po
     * @param s 数据对象
     * @param clz 复制目标类型
     * @return
     * @author banjuer@outlook.com
     * @Time 2018年5月9日 下午3:53:24
     */
    <T, S> T convert(S s, Class<T> clz);

    /**
     * @Description: list深度复制
     * @param s 数据对象
     * @param clz 复制目标类型
     * @return
     * @author banjuer@outlook.com
     * @Time 2018年5月9日 下午3:54:08
     */
    <T, S> List<T> convert(List<S> s, Class<T> clz);

    /**
     * @Description: set深度复制
     * @param s 数据对象
     * @param clz 复制目标类型
     * @return
     * @author banjuer@outlook.com
     * @Time 2018年5月9日 下午3:54:39
     */
    <T, S> Set<T> convert(Set<S> s, Class<T> clz);

    /**
     * @Description: 数组深度复制
     * @param s 数据对象
     * @param clz 复制目标类型
     * @return
     * @author banjuer@outlook.com
     * @Time 2018年5月9日 下午3:54:57
     */
    <T, S> T[] convert(S[] s, Class<T> clz);

}

IGenerator的实现类：EJBGenerator.java

package com.dist.utils;

import org.dozer.Mapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Component;

import java.lang.reflect.Array;
import java.util.*;

/**
 * @author zhengja@dist.com.cn
 * @data 2019/5/30 15:21
 */
@Component
@Lazy(true)
public class EJBGenerator implements IGenerator {

    @Autowired
    protected Mapper mapper;

    /**
     * @Description: 单个对象的深度复制及类型转换，vo/domain , po
     * @param s 数据对象
     * @param clz 复制目标类型
     * @param <T>
     * @param <S>
     * @return
     */
    @Override
    public <T, S> T convert(S s, Class<T> clz) {
        if (s == null) {
            return null;
        }
        return this.mapper.map(s, clz);
    }

    /**
     *@Description: list深度复制
     * @param s 数据对象
     * @param clz 复制目标类型
     * @param <T>
     * @param <S>
     * @return
     */
    @Override
    public <T, S> List<T> convert(List<S> s, Class<T> clz) {
        if (s == null) {
            return null;
        }
        List<T> list = new ArrayList<T>();
        for (S vs : s) {
            list.add(this.mapper.map(vs, clz));
        }
        return list;
    }

    /**
     * @Description: Set深度复制
     * @param s 数据对象
     * @param clz 复制目标类型
     * @param <T>
     * @param <S>
     * @return
     */
    @Override
    public <T, S> Set<T> convert(Set<S> s, Class<T> clz) {
        if (s == null) {
            return null;
        }
        Set<T> set = new HashSet<T>();
        for (S vs : s) {
            set.add(this.mapper.map(vs, clz));
        }
        return set;
    }

    /**
     * @Description: 数组深度复制
     * @param s 数据对象
     * @param clz 复制目标类型
     * @param <T>
     * @param <S>
     * @return
     */
    @Override
    public <T, S> T[] convert(S[] s, Class<T> clz) {
        if (s == null) {
            return null;
        }
        @SuppressWarnings("unchecked")
        T[] arr = (T[]) Array.newInstance(clz, s.length);
        for (int i = 0; i < s.length; i++) {
            arr[i] = this.mapper.map(s[i], clz);
        }
        return arr;
    }
}

全面测试

package com.dist.test;

import com.dist.SpringbootdemoApplication;
import com.dist.entity.dto.UserDTO;
import com.dist.entity.dto.UserVO;
import com.dist.utils.IGenerator;
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;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

/**
 * Dozer是什么?

 Dozer是一个JavaBean映射工具库。

 它支持简单的属性映射，复杂类型映射，双向映射，隐式显式的映射，以及递归映射。

 它支持三种映射方式：注解、API、XML。

 它是开源的，遵从Apache 2.0 协议

 * @author zhengja@dist.com.cn
 * @data 2019/5/30 14:36
 */
@RunWith(SpringRunner.class)
@SpringBootTest(classes = {SpringbootdemoApplication.class})
public class DozerTest{

    /*@Autowired
    private Mapper mapper;*/

    /**
     * 封装了Mapper工具接口：实现了list、set，数组，对象等深度复制！
     */
    @Autowired
    IGenerator iGenerator;

    /**
     * 单个对象的深度复制及类型转换，vo/domain , po
     * 输出结果： UserVO(userCode=123, loginName=null, loginPassword=null)
     */
    /*@Test
    public void testMapper(){
        UserDTO userDTO =new UserDTO();
        userDTO.setUserCode("123");
        UserVO userVO = mapper.map(userDTO, UserVO.class);
        System.out.println(userVO);
    }*/

    /**
     *单个对象的深度复制及类型转换，vo/domain , po
     * 输出结果： UserVO(userCode=123, loginName=null, loginPassword=null)
     */
    @Test
    public void test(){
        UserDTO userDTO =new UserDTO();
        userDTO.setUserCode("123");
        UserVO userVO = iGenerator.convert(userDTO, UserVO.class);
        //UserVO userVO = mapper.map(userDTO, UserVO.class);
        System.out.println(userVO);
    }

    /**
     * list深度复制
     */
    @Test
    public void test1(){
        List<UserDTO> dtoList = new ArrayList<>();
        UserDTO userDTO =new UserDTO();
        userDTO.setUserCode("123");
        dtoList.add(userDTO);
        List<UserVO> userVOS = iGenerator.convert(dtoList, UserVO.class);
        System.out.println(userVOS);
    }

    /**
     **set深度复制
     */
    @Test
    public void test2(){
        Set<UserDTO> dtoSet = new HashSet<>();
        UserDTO userDTO =new UserDTO();
        userDTO.setUserCode("123");
        dtoSet.add(userDTO);
        Set<UserVO> userVOS = iGenerator.convert(dtoSet, UserVO.class);
        System.out.println(userVOS);
    }

    /**
     * 数组深度复制
     */
    @Test
    public void test13(){
        UserDTO[] dtos = new UserDTO[3];
        UserDTO userDTO =new UserDTO();
        userDTO.setUserCode("123");
        dtos[0] = userDTO;
        dtos[1] = userDTO;
        dtos[2] = userDTO;
        UserVO[] userVOS = iGenerator.convert(dtos, UserVO.class);
        for (int i=0; i<userVOS.length;i++){
            System.out.println(userVOS[i]);
        }
    }
}

到此完成所有的测试！

<h2>测试结果：已经在测试的上面标注</h2>

项目实战演示

@RestController
@RequestMapping(value = "rest/admin/v1")
@Api(tags = {"OMS-UserController"}, description = "用户模块")
public class UserController extends BaseController {

    @Reference
    IUserService vUserService;
 
    @Autowired
    Mapper mapper;
   
    @ApiOperation(value = "获取用户", httpMethod = "GET")
    @GetMapping(value = "v1/get/user")
    public ResponseData getUser() {
        // 获取用户信息
        VUserinfo userInfo = vUserService.getUserInfo();
      //映射-过滤，只返回给前端需要的数据字段/数据格式
         UserDTO userDTO = mapper.map(userInfo, UserDTO.class);
        return ResponseUtil.success(userDTO);
    }
   

************************本片文章阅读结束************************

作者：宇宙小神特别萌
个人博客：www.zhengjiaao.cn
Gitee 仓库：https://gitee.com/zhengjiaao
Github 仓库：https://github.com/zhengjiaao?tab=repositories
描述：喜欢文章的点赞收藏一下，关注不迷路，避免以后找不到哦，大家遇到问题下方可评论

************************本片文章阅读结束************************