orika入门使用及组件化

最新推荐文章于 2024-08-26 09:23:13 发布
最新推荐文章于 2024-08-26 09:23:13 发布
阅读量3.8k 收藏 24
点赞数 8
分类专栏： 中间件 文章标签： java orika Bean映射 类型转换
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44335140/article/details/122845733
版权

本篇文章，介绍orika的简单使用。以及借助SPI或Spring对orika进行组件化，让增加类型转换规则更加简单方便。

一、orika简介

在工作中，我们经常涉及到对象的DTO、DO等对象的转换。对于这些对象的转换，我们除了自己写大量的get/set方法外，还可以借助orika这样的Bean映射工具来帮我们完成。

二、几款Bean映射工具简单对比

1. BeanUtils

apache的BeanUtils和spring的BeanUtils 底层都是基于放射实现的Bean映射。而反射的性能是比较低的，因此BeanUtils的性能并不太理想。

2. BeanCopier

cglib的BeanCopier 直接使用ASM在字节码层面编写get/set 方法，然后生成class文件直接执行。由于没有使用反射，BeanCopier 的性能相对于BeanUtils有较大的提升。

3. Dozer

使用以上类库虽然可以不用手动编写get/set方法，但是他们都不能对不同名称的对象属性进行映射。在定制化的属性映射方面做得比较好的有Dozer，Dozer支持简单属性映射、复杂类型映射、双向映射、隐式映射以及递归映射。可使用xml或者注解进行映射的配置，支持自动类型转换，使用方便。但Dozer的底层仍然是基于反射做的，因此性能不太理想。

4. Orika

Orika底层采用了javassist类库生成Bean映射的字节码，之后直接加载执行生成的字节码文件，因此在速度上比使用反射进行赋值会快很多。且支持对不同名称的对象属性进行映射。

三、orika使用

导入orika的依赖

<dependency>  
    <groupId>ma.glasnost.orika</groupId>
    <artifactId>orika-core</artifactId>
    <version>1.5.4</version>
</dependency>

下面使用orika将OrderDTO转换成OrderDO。这是案例中用到的Bean：

// 转换类
@Data
@AllArgsConstructor
public class OrderDTO {
    private String orderId;
    private String brand;
    private String address;
    private String mobile;

    private OrderItemDTO orderItem;

    public OrderDTO(String orderId, String brand, String address, String mobile) {
        this.orderId = orderId;
        this.brand = brand;
        this.address = address;
        this.mobile = mobile;
    }
}


// 目标类
@Data
public class OrderDO {
    private String id;
    private String brand;
    private String address;
    private String phone;

    private OrderItemDo orderItem;
}

@Data
@AllArgsConstructor
public class OrderItemDTO {
    private String orderId;
    private String itemId;
    private String name;
}

@Data
public class OrderItemDo {
    private String orderId;
    private String id;
    private String name;
}

场景一：目标类与转换类字段名完全一致

// 俩个对象属性完全一致的场景
OrderDTO orderDTO = new OrderDTO("1", "kfc", "南京路", "666");

DefaultMapperFactory mapperFactory = new DefaultMapperFactory.Builder().build();
OrderDO order = mapperFactory.getMapperFacade().map(orderDTO, OrderDO.class);

System.out.println(order);

运行结果：
在这里插入图片描述
可以看到，名称相同的字段成功转换了。

场景二：目标类与转换类少数几个字段名不一致

对于少数几个字段名称不相同的，我们需要告诉orika他们之间的映射关系。

OrderDTO orderDTO = new OrderDTO("1", "kfc", "南京路", "666");
DefaultMapperFactory mapperFactory = new DefaultMapperFactory.Builder().build();
// 需要多一步，使用classMap，告诉orika字段名之间的映射关系
mapperFactory.classMap(orderDTO.getClass(),OrderDO.class)
    .field("orderId","id")
    .field("mobile","phone").byDefault().register();

OrderDO order = mapperFactory.getMapperFacade().map(orderDTO, OrderDO.class);
System.out.println(order);

运行结果：
在这里插入图片描述

场景三：转换集合

转换集合使用的是mapAsList而不是map，同样，如果转换类和目标类名称不一致的对象依旧需要我们告诉orika。

List<OrderDTO> orderDTOS = Arrays.asList(
                new OrderDTO("1", "kfc", "南京路", "666"),
                new OrderDTO("2", "kfc", "北京路", "999"),
                new OrderDTO("3", "kfc", "东京路", "888"),
                new OrderDTO("4", "kfc", "西京路", "555"));

DefaultMapperFactory mapperFactory = new DefaultMapperFactory.Builder().build();
// 如果存在字段名不一致，手动告诉orika他们之间的映射关系
mapperFactory.classMap(OrderDTO.class,OrderDO.class)
    .field("orderId","id")
    .field("mobile","phone").byDefault().register();
// 使用mapAsList进行转换
List<OrderDO> orders = mapperFactory.getMapperFacade().mapAsList(orderDTOS, OrderDO.class);

for (OrderDO order : orders) {
    System.out.println(order);
}

运行结果：
在这里插入图片描述

场景四：转换对象内嵌了其他对象

在本例中OrderDTO还嵌套了OrderItemDTO对象。如果OrderItemDTO和OrderItemDO的字段名完全相同的话，我们就不需要做额外的处理。但如果存在差异，我们同样需要手动告诉orika他们之间的映射关系。

OrderDTO orderDTO = new OrderDTO("1", "kfc", "南京路", "666");
orderDTO.setOrderItem(new OrderItemDTO("1","1","汉堡包"));

DefaultMapperFactory mapperFactory = new DefaultMapperFactory.Builder().build();
// 如果存在字段名不一致，手动告诉orika他们之间的映射关系
mapperFactory.classMap(OrderDTO.class,OrderDO.class)
     .field("orderId","id")
     .field("mobile","phone")
     .field("orderItem.itemId","orderItem.id")    //orderItemDTO和OrderItemDO之间的映射关系
     .byDefault().register();

OrderDO order = mapperFactory.getMapperFacade().map(orderDTO, OrderDO.class);
System.out.println(order);

运行结果：
在这里插入图片描述

场景五：自定义转换规则

有时候，我们不是要简单的转换，比如说我们希望转换后的brand统一变成大写，那么这个时候，我们就可以自定义转换规则做些额外的处理。

OrderDTO orderDTO = new OrderDTO("1", "kfc", "南京路", "666");
        DefaultMapperFactory mapperFactory = new DefaultMapperFactory.Builder().build();
        // 如果存在字段名不一致，手动告诉orika他们之间的映射关系
        mapperFactory.classMap(OrderDTO.class,OrderDO.class)
                .field("orderId","id")
                .field("mobile","phone")
                .field("orderItem.itemId","orderItem.id")
                .byDefault()
                // 自定义我们的转换规则
                .customize(new CustomMapper<OrderDTO, OrderDO>() {
                    @Override
                    public void mapAtoB(OrderDTO orderDTO, OrderDO orderDO, MappingContext context) {
                        // 将品牌转换成大写
                        orderDO.setBrand(orderDTO.getBrand().toUpperCase(Locale.ROOT));
                    }
                })
                .register();

        OrderDO order = mapperFactory.getMapperFacade().map(orderDTO, OrderDO.class);
        System.out.println(order);

运行结果：
在这里插入图片描述
通过这五个案例，我们不难发现orika是很容易使用的

  1. 构建一个DefaultMapperFactory
  2. 如果存在字段名不一致的情况，告诉orika他们之间的映射关系
  3. 使用map/mapAsList进行对象转换

四、orika组件化

基于SPI进行组件化

其实一个DefaultMapperFactory是可以注册多个映射规则的。比如我们的项目中除了有Order需要转换外，现在又多了一个User需要转换。

@Data
@AllArgsConstructor
public class UserDTO {
    private String id;
    private String username;
}

@Data
public class UserDO {
    private String id;
    private String name;
}

注册多个映射规则：

OrderDTO orderDTO = new OrderDTO("1", "kfc", "南京路", "666");
orderDTO.setOrderItem(new OrderItemDTO("1","1","汉堡包"));
        
DefaultMapperFactory mapperFactory = new DefaultMapperFactory.Builder().build();
// 1.注册orderDTO和OrderDO的映射关系
mapperFactory.classMap(OrderDTO.class,OrderDO.class)
    .field("orderId","id")
    .field("mobile","phone")
    .field("orderItem.itemId","orderItem.id")
    .byDefault()
     .register();
// 2.注册UserDTO和UserDO的映射关系
mapperFactory.classMap(UserDTO.class,UserDO.class)
     .field("username","name")
     .byDefault().register();

OrderDO order = mapperFactory.getMapperFacade().map(orderDTO, OrderDO.class);
System.out.println(order);

// 转换UserDTO
UserDTO userDTO = new UserDTO("1", "小王");
UserDO user = mapperFactory.getMapperFacade().map(userDTO, UserDO.class);
System.out.println(user);

运行结果：
在这里插入图片描述
基于这个特点，我们完全可以将DefaultMapperFactory作为一个单例，只创建一次即可。下面我们将对orika进行封装，利用SPI机制动态的往MapperFactory中注册多个映射规则。

1、定义BeanMapperRegistry接口，后续所有的映射规则都需要实现该接口

public interface BeanMapperRegistry {
    void registry(MapperFactory mapperFactory);
}

2、定义Order和User映射规则

/**
 * OrderDTO转OrderDO的映射规则
 */
public class OrderBeanMapper implements BeanMapperRegistry {

    @Override
    public void registry(MapperFactory mapperFactory) {
        mapperFactory.classMap(OrderDTO.class, OrderDO.class)
                .field("orderId","id")
                .field("mobile","phone")
                .field("orderItem.itemId","orderItem.id")
                .byDefault()
                .register();
    }
}

/**
 * UserDTO转UserDO的映射规则
 */
public class UseBeanMapper implements BeanMapperRegistry {
    @Override
    public void registry(MapperFactory mapperFactory) {
        mapperFactory.classMap(UserDTO.class, UserDO.class)
                .field("username","name")
                .byDefault().register();
    }
}

3、封装orika

/**
 * 对orika进行简单的封装
 */
public class BeanMapper {
    private static MapperFactory mapperFactory;
    private static MapperFacade mapperFacade;


    static {
        mapperFactory = new DefaultMapperFactory.Builder().build();
        mapperFacade = mapperFactory.getMapperFacade();

        // 利用SPI,注册Bean的转换规则
        ServiceLoader<BeanMapperRegistry> serviceLoader = ServiceLoader.load(BeanMapperRegistry.class);
        for (BeanMapperRegistry beanMapperRegistry : serviceLoader) {
            beanMapperRegistry.registry(mapperFactory);
        }
    }

    public static <S, T> T map(S sourceObj, Class<T> targetClass) {
        return mapperFacade.map(sourceObj, targetClass);
    }

    public static <S, T> List<T> mapAsList(Iterable<S> sourceObj, Class<T> targetClass) {
        return mapperFacade.mapAsList(sourceObj, targetClass);
    }
}

4、在resources/META-INF/services/目录下创建fcp.orika.BeanMapperRegistry (BeanMapperRegistry 的全类名)

内容如下：

fcp.orika.convert.OrderBeanMapper
fcp.orika.convert.UseBeanMapper

5、使用我们封装后的BeanMapper

OrderDTO orderDTO = new OrderDTO("1", "kfc", "南京路", "666");
UserDTO userDTO = new UserDTO("1", "小王");
System.out.println(BeanMapper.map(orderDTO, OrderDO.class));
System.out.println(BeanMapper.map(userDTO, UserDO.class));

运行结果：
在这里插入图片描述

注：如果看蒙了，那么可能是对于ServiceLoader的使用不太了解。可以看看这篇文章Java SPI机制 - ServiceLoader - 知乎 (zhihu.com)

改造后，以后增加新的映射规则的步骤就是：

  1. 添加一个类实现BeanMapperRegistry接口
  2. 在fcp.orika.BeanMapperRegistry 文件中追加新增类的全类名
    符合开闭原则

比如在本案例中，涉及的映射规则有：

  1. OrderDTO转OrderDo
  2. UserDTO转UserDo

对应的转换类就有俩个

  1. OrderBeanMapper
  2. UseBeanMapper

基于Spring进行组件化

同样还是以OrderDTO<=>OrderDO，UserDTO<=>UserDO为例。利用Spring生命周期的特性，我们新建一个OrikaBeanPostprocessor ，如果Bean实现了BeanMapperRegistry 接口，我们就调用它的registry方法注册映射规则。

@Component
public class OrikaBeanPostprocessor implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        if (bean instanceof BeanMapperRegistry) {
            ((BeanMapperRegistry) bean).registry(BeanMapper.getMapperFactory());
        }
        return bean;
    }
}

当然，我们要确保之前的转换类也是一个Bean。

@Component
public class OrderBeanMapper implements BeanMapperRegistry {
    @Override
    public void registry(MapperFactory mapperFactory) {
        mapperFactory.classMap(OrderDTO.class, OrderDO.class)
                .field("orderId","id")
                .field("mobile","phone")
                .field("orderItem.itemId","orderItem.id")
                .byDefault()
                .register();
    }
}

@Component
public class UseBeanMapper implements BeanMapperRegistry {
    @Override
    public void registry(MapperFactory mapperFactory) {
        mapperFactory.classMap(UserDTO.class, UserDO.class)
                .field("username","name")
                .byDefault().register();
    }
}

测试：

public static void main(String[] args) {
    // 1. 创建Spring容器
    AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
    // 2. 指定扫描的包(确保BeanMapperPostProcessor和转换类都能被扫描到)
    context.scan("fcp.orika.*");
    context.refresh();

    // 3. 测试转换
    OrderDTO orderDTO = new OrderDTO("1", "kfc", "南京路", "666");
    orderDTO.setOrderItem(new OrderItemDTO("1", "1", "汉堡包"));
    UserDTO userDTO = new UserDTO("1", "小王");
    System.out.println(BeanMapper.map(orderDTO, OrderDO.class));
    System.out.println(BeanMapper.map(userDTO, UserDO.class));
}

使用这种方式，后续我们在增加转换规则的时候，只需要增加一个转换类，然后加个@Component注解就可以了。总体上来讲，还是比SPI更方便使用。

做时间的朋友。
关注
专栏目录
orika-core-1.5.4-API文档-中文版.zip
07-13
赠送jar包：orika-core-1.5.4.jar； 赠送原API文档：orika-core-1.5.4-javadoc.jar； 赠送源代码：orika-core-1.5.4-sources.jar； 赠送Maven依赖信息文件：orika-core-1.5.4.pom； 包含翻译后的API文档：orika-core-1.5.4-javadoc-API文档-中文(简体)版.zip； Maven坐标：ma.glasnost.orika:orika-core:1.5.4； 标签：glasnost、orika、core、中文文档、jar包、java； 使用方法：解压翻译后的API文档，用浏览器打开“index.html”文件，即可纵览文档内容。 人性化翻译，文档中的代码和结构保持不变，注释和说明精准翻译，请放心使用。
Orika使用
Willow的博客
07-31 3825
1.MapperFacade自动注入失败：需要加OrikaConfig https://www.cnblogs.com/bihanghang/p/10287990.html 2.springboot启动后输入url报错404：目录层级不对，目录结构不符合要求，Controller包必须和AppApplication.java同级，因为@SpringBootApplication默认会去扫描同级目录或者子集目录下的所有类。 https://blog.csdn.net/weixin_37841366/artic
Orika-Spring-Boot-Starter 使用指南
最新发布
gitblog_00528的博客
08-26 362
Orika-Spring-Boot-Starter 使用指南 orika-spring-boot-starterSpring Boot Starter for Orika.项目地址:https://gitcode.com/gh_mirrors/or/orika-spring-boot-starter 1. 项目目录结构及介绍 Orika-Spring-Boot-Starter 是一个为了简化Sp...
【Java】拷贝工具之 Orika 的介绍与演示
Ulrich蚊子Blog
07-20 1497
在现在流行且广泛应用的各类 Java 分层代码框架中，不同的层定义了不同类型的实体类，如 Entity、DO、DTO、VO 等。层与层之间的对象总是需要进行各种转换和映射，这些操作重复繁琐，于是催生了各种各样的工具，用来快捷、高效地完成这些操作。本文先介绍一款 Java 的拷贝工具Orika，简单讲解一下它的特性，以及进行一些常用的、基础的代码演示。Orika使用反射来访问数据对象的属性，它会自动收集类的元数据，生成映射对象。这些映射对象可用于将数据从一个对象递归拷贝到另一个对象。
Orika--更快的bean复制工具
weixin_42030357的博客
05-29 1413
文章目录pom使用 原博客，点击这里 参考博文，点击这里 pom <dependency> <groupId>ma.glasnost.orika</groupId> <artifactId>orika-core</artifactId> <version>1.4.2</version><!-- or latest version --> </dependency> 使用 这里假设我
探秘Orika：优雅的数据映射解决方案
gitblog_00058的博客
03-26 1080
探秘Orika：优雅的数据映射解决方案 orika项目地址:https://gitcode.com/gh_mirrors/or/orika 是一个开源的Java库，用于在不同的Java对象模型之间进行自动数据映射。在现代软件开发中，数据转换是常见的需求，比如从数据库记录到业务对象，或者在不同API之间交换数据。Orika提供了一种高效、灵活且易于使用的解决方案，帮助开发者节省时间，减少错误，并提...
【业务功能篇51】对象复制的三种方式 工具类Orika、反射、BeanUtils浅拷贝
studyday1的博客
07-25 831
业务场景： 设计规范前提下，我们数据层传输承载的是用DTO，而到控制层返回给前端会对应定义一个VO对象，比如是一个问题单数据集合list,数据层接收的是DTO对对象，到控制层接收后需要转换成list,这里就涉及到要转换对象数据对象复制的类库工具有很多Orika，同时也最流行的对象映射工具,Orika底层采用了javassist类库生成Bean映射的字节码，之后直接加载执行生成的字节码文件，在速度上比使用反射进行赋值会快很多。阿里巴巴开发手册上强制规定避免使用。
orika Java实例Demo
08-09
- **减少手动复制代码**：手动编写拷贝构造函数或`clone()`方法来实现对象间的数据复制非常繁琐且容易出错，Orika自动化这一过程，提高开发效率。 - **灵活性**：Orika提供了高度自定义的映射规则，可以对特定字段...
Orika-core使用总结整理.html
07-26
Orika-core使用总结整理
Orika-core使用总结整理.md
07-26
Orika-core使用总结整理
orika-sample:使用“ ma.glasnost.orika”的样本
05-19
"orika-sample:使用“ma.glasnost.orika”的样本"是一个关于Java对象映射库Orika的实践项目。Orika是一个高性能、易用的对象映射框架，它简化了Java对象到Java对象之间的数据转换过程。这个项目提供了一系列示例，...
Orika JavaBean映射工具使用
BASK2312的博客
03-13 389
1.Orika是什么？Orika是一个简单、快速的JavaBean拷贝框架，它能够递归地将数据从一个JavaBean复制到另一个JavaBean，这在多层应用开发中是非常有用的。2.为什么要引入Orika?工作中，我们经常需要将对象转换成不同的形式以适应不同的api，或者在不同业务层中传输对象而不同分层的对象存在不同的格式，因此我们需要编写映射代码将对象中的属性值从一种类型转换成另一种类型。Orika用于简化多层之间的对象映射，避免苦苦挣扎于手工编码和基于反射的映射。
orika简介
一个持续编程的盲人。
04-10 331
在工作中，我们经常涉及到对象的[DTO](https://so.csdn.net/so/search?q=DTO&spm=1001.2101.3001.7020)、DO等对象的转换。对于这些对象的转换，我们除了自己写大量的get/set方法外，还可以借助orika这样的Bean映射工具来帮我们完成。OrderDTO orderDTO = new OrderDTO("1", "kfc", "南京路", "666");UserDTO userDTO = new UserDTO("1", "小王");
关于orika做对象映射
jslzcydd的博客
06-04 836
一、Orika背景介绍 　　 　　Orika是java Bean映射框架，可以实现从一个对象递归拷贝数据至另一个对象。在开发多层应用程序中非常有用。在这些层之间交换数据时，通常为了适应不同API需要转换一个实例至另一个实例。 　　有很多方法可以实现：硬代码拷贝或Dozer实现bean映射等。总之，需要简化不同层对象之间映射过程。 　 Orika使用字节码生成器创建开销最小的快速映射，比其他基于反射方式实现（如，Dozer）更快。之前使用Bean Copy 性能非常慢，发现在这个领域业界还是有很多...
一看就会的Orika实体映射工具
冉野 、
06-30 9681
看一眼就会的Orika映射工具。 我感觉真不用再写什么Orika的详细介绍了。想必你要是写过Convert类的话应该会明白这个工具大概是能做什么了，如果真要写我可能也只会是跟别人有所雷同，我之所以想起这个工具是因为在DO（实体对象-持久化） 和数据传输对象（DTO）之间的映射时候，要写get 和set方法，超级麻烦，我就开始琢磨能不能使用一种工具如果DO对象和DTO对象之间保持字段...
记一次Orika使用不当导致的内存溢出
子月生的博客
08-25 934
hprof 文件分析 2021-08-24，订单中心的一个项目出现了 OOM 异常，使用 MemoryAnalyzer 打开 dump 出来的 hprof 文件，可以看到 91.27% 的内存被一个超大对象javassist.ClassPool占用了。 那么，ClassPool是一个什么样的对象呢？我们知道，javassist 可以用来动态生成类，而生成的类就是放在这个ClassPool里面，具体以javassist.CtClass的形式存在。 所以，初步分析是 OOM 的原因是 javassist 生成的
spring boot 对象拷贝工具(Orika)
qq_42702229的博客
10-23 1768
1.spring 自带拷贝工具 LoginUser user = new LoginUser(); // 将data中字段相同的属性拷贝到user中 BeanUtils.copyProperties(data , user); 2. 基于Orika的字节码拷贝工具 1) pom <!-- 基于字节码的深拷贝工具类 --> <dependency> <groupId>ma.glasnost.orika&
使用 Orika 实现bean 映射
热门推荐
neweastsun的专栏
06-03 1万+
使用 Orika 实现bean 映射 Orika是java Bean映射框架，可以实现从一个对象递归拷贝数据至另一个对象。在开发多层应用程序中非常有用。在这些曾之间交换数据时，通常为了适应不同API需要转换一个实例至另一个实例。 有很多方法可以实现：硬代码拷贝或Dozer实现bean映射等。总之，需要简化不同层对象之间映射过程。 Orika使用字节码生成器创建开销最小的快速映射，比其他基于反...
Orika 映射器
dahanzhinu的博客
12-05 746
aaa
Orika与BeanUtil.copyProperties
10-13
Orika和BeanUtil.copyProperties都是Java中用于对象属性拷贝的工具类，它们的作用都是将一个Java对象的属性值拷贝到另一个Java对象中。但是它们之间还是有一些区别的。 Orika相对于BeanUtil.copyProperties来说，具有更高的性能和更强的扩展性。Orika使用了ASM字节码操作库来生成字节码，从而实现了高性能的对象属性拷贝。而BeanUtil.copyProperties则是通过反射来实现属性拷贝，性能相对较低。 此外，Orika还支持更多的属性映射方式，比如可以通过注解、XML文件等方式来指定属性映射规则，而BeanUtil.copyProperties则只支持基本的属性名相同的映射方式。
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值