精华内容
下载资源
问答
  • orika

    千次阅读 2018-07-23 14:50:04
    Orika是什么 Orika是一个简单、快速的JavaBean拷贝框架,它能够递归地将数据从一个JavaBean复制到另一个JavaBean,这在多层应用开发中是非常有用的。 为什么要使用Orika Orika用于简化多层之间的对象映射,避免...

    Orika是什么

    Orika是一个简单、快速的JavaBean拷贝框架,它能够递归地将数据从一个JavaBean复制到另一个JavaBean,这在多层应用开发中是非常有用的。

    为什么要使用Orika

    Orika用于简化多层之间的对象映射,避免苦苦挣扎于手工编码和基于反射的映射。

    Orika致力于提供一个全面、有效、强大的Java Bean映射解决方案。Orika关注尽可能地自动化,同时根据需要提供配置和扩展实现定制。

    Orika为开发者提供了如下功能:
    1.映射复杂的、深层次结构性对象。
    2.通过将嵌套属性映射到顶级属性,“压平”或“展开”对象,反之亦然。
    3.自动创建映射,并且在部分或所有映射上自定义。
    4.创建转换器,以完全控制对象图中的任何特定对象集合的映射——按类型,甚至是通过特定的属性名。
    5.处理代理或增强对象(如Hibernate或各种模拟框架)
    6.用一个配置应用双向映射。
    7.为一个目标抽象类或接口映射到具体的实现类。
    8.映射POJO属性到Lists, Arrays, and Maps。

    如何使用Orika

    Orika使用字节代码生成来创建具有最小开销的快速映射器。

    示例

    <dependency>
       <groupId>ma.glasnost.orika</groupId>
       <artifactId>orika-core</artifactId>
       <version1.4.5</version>
    </dependency>
    @Configuration
    public class OrikaBeanMapperConfig {
    
        @Bean
        public OrikaBeanMapper getOrikaBeanMapper(){
            OrikaBeanMapper beanMapper=new OrikaBeanMapper();
            beanMapper.setBasePackage("com.*");
            return beanMapper;
        }
    }

     

    public class OrikaMapperUtil {
    
        /**     
         *
         * @param source     要复制的对象实例
         * @param targetCls  要生成的对象类型
         * @param sourceProperties 源对象的属性名数组
         * @param targetProperies  目标对象的属性名数组
         * @param <T> 泛型
         * @param <E> 泛型
         * @return
         */
        public static <T,E> E mapObject( T source, Class<E> targetCls, String[] sourceProperties, String[] targetProperies) {
            if(null == sourceProperties || null == targetProperies || sourceProperties.length != targetProperies.length)
            {
                throw new RuntimeException("缺失属性映射关系");
            }
    
            DefaultMapperFactory orikaFactory = new DefaultMapperFactory.Builder().build();
    
            ClassMapBuilder<?, E> orikaClassBuilder = orikaFactory.classMap( source.getClass(), targetCls);
    
            for(int i = 0; i < sourceProperties.length; i++)
            {
                orikaClassBuilder.field(sourceProperties[i], targetProperies[i]);
            }
            orikaClassBuilder.byDefault().register();
            E targetIntance = orikaFactory.getMapperFacade().map(source, targetCls);
    
            return targetIntance;
        }

     

     

    public class ShopDto {
    
        private Integer userId;
        private String shopName;
        private String shopIntro;
       
        public AppShop transFromToEntity() {
    
            String[] sourceProperties = new String[]{"shopName", "shopIntro"};
            String[] targetProperties = new String[]{"name", "intro"};
    
            return OrikaMapperUtil.mapObject(this, AppShop.class, sourceProperties, targetProperties);
        }
    }

     

    @Entity
    @Table(name = "shop")
    public class Shop {
    
        @Id
        @GeneratedValue(strategy = GenerationType.IDENTITY)
        @Column(name = "id")
        private Integer id;
    
        private Integer userId;
        private String name;
        private String intro;
    }

     

    @RestController
    @RequestMapping("/Shop")
    public class ShopController {
    
        @PostMapping("/Info")
        public JsonResult saveShopInfo(ShopDto dto) {
            Shop shop = dto.transFromToEntity();
    
        }

     

     

     

     

     

     

     

     

    展开全文
  • Orika使用

    2020-03-18 16:38:41
    1,引入jar <dependency> <groupId>ma.glasnost.orika</groupId> <artifactId>orika-core</artifactId> <orika.version>1...

    1,引入jar

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

    2,映射

    public class DDCustomMapper extends CustomMapper<Dept, DepartEntity> {
        @Override
        public void mapAtoB(Dept dept, DepartEntity department, MappingContext context) {
            department.setId(dept.getId());
           .....
        }
    
        @Override
        public void mapBtoA(DepartEntity department, Dept dept, MappingContext context) {
            dept.setId(department.getId());
          
        }
    
    

    3,使用

    @Slf4j
    @Service
    @Transactional
    public class DeptServiceImpl extends AbstractNoahServiceImpl<IDeptDAO, Dept> implements IDeptService {
        private static final MapperFactory MAPPER_FACTORY = new DefaultMapperFactory.Builder().build();
    
        static {
            MAPPER_FACTORY.classMap(Dept.class, DepartEntity.class)
                    .customize(new DeptCustomMapper())
                    .byDefault().register();
        }
     @Override
        public Boolean batchInsert(List<DepartEntity> departments) {
            try {
                List<Dept> depts = MAPPER_FACTORY.getMapperFacade().mapAsList(departments, Dept.class);
            
            } catch (Exception e) {
                log.error( e.getMessage());
            }
            return Boolean.FALSE;
        }
    }
    
    
    
    
    展开全文
  • Orika 拷贝框架

    千次阅读 2019-07-09 10:45:28
    Orika是一个简单、快速的JavaBean拷贝框架,Orika使用字节代码生成来创建具有最小开销的快速映射器。 pom.xml 引入: <dependency> <groupId>ma.glasnost.orika</groupId> <artifactId&...
    Orika是一个简单、快速的JavaBean拷贝框架,Orika使用字节代码生成来创建具有最小开销的快速映射器。

    pom.xml 引入:

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

    封装工具类:

    import ma.glasnost.orika.MapperFactory;
    import ma.glasnost.orika.impl.DefaultMapperFactory;
    import ma.glasnost.orika.metadata.ClassMapBuilder;
    
    import java.util.List;
    
    /**
     *
     * Orika是一个简单、快速的JavaBean拷贝框架,Orika使用字节代码生成来创建具有最小开销的快速映射器。
     *
     */
    public class OrikaUtil {
    
        private static MapperFactory mapperFactory = new DefaultMapperFactory.Builder().build();
    
        public static <A, B> ClassMapBuilder<A, B> classMap(Class<A> source, Class<B> target) {
            return mapperFactory.classMap(source, target);
        }
    
        public static <T> T convert(Object source, Class<T> target) {
            return mapperFactory.getMapperFacade().map(source, target);
        }
    
        public static <S, D> List<D> convertList(Iterable<S> source, Class<D> target) {
            return mapperFactory.getMapperFacade().mapAsList(source, target);
        }
    
    }

     

    展开全文
  • 使用“ ma.glasnost.orika”的示例
  • orika-spring-boot-starter 适用于 Starter 。 注意:此页面用于Spring 。如果使用Spring Boot 1,请参阅。 产品特点 在应用程序上下文中管理MapperFacade (Orika的mapper界面),并将其注入代码中。 提供用于...
  • Add Orika starter

    2021-01-06 02:45:59
    <div><p>Adding orika strarter option. <p>Read more about the starter: https://github.com/akihyro/orika-spring-boot-starter</p><p>该提问来源于开源项目:spring-io/initializr</p></div>
  • Orika对象转换

    2021-03-06 00:45:41
    Orika介绍 Orika是java Bean映射框架,可以实现从一个对象递归拷贝数据至另一个对象。在开发多层应用程序中非常有用。在这些层之间交换数据时,通常为了适应不同API需要转换一个实例至另一个实例。 有很多方法可以...

    Orika介绍

    Orika是java Bean映射框架,可以实现从一个对象递归拷贝数据至另一个对象。在开发多层应用程序中非常有用。在这些层之间交换数据时,通常为了适应不同API需要转换一个实例至另一个实例。最常见的就是实体对象和数据显示层(VO,DTO等)的转换。

    有很多方法可以实现:硬代码拷贝或Dozer实现bean映射等。总之,需要简化不同层对象之间映射过程。

    Orika使用字节码生成器创建开销最小的快速映射,比其他基于反射方式实现(如,Dozer,Bean Copy)更快。

    依赖

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

    对象转换工具类

    import ma.glasnost.orika.MapperFacade;
    import ma.glasnost.orika.MapperFactory;
    import ma.glasnost.orika.converter.BidirectionalConverter;
    import ma.glasnost.orika.impl.DefaultMapperFactory;
    import ma.glasnost.orika.metadata.Type;
    import ma.glasnost.orika.metadata.TypeFactory;
    
    import java.math.BigDecimal;
    import java.util.List;
    
    /**
     * 简单封装orika, 实现深度的BeanOfClasssA<->BeanOfClassB复制
     * <p>
     * 不要是用Apache Common BeanUtils进行类复制,每次就行反射查询对象的属性列表, 非常缓慢.
     * <p>
     * 注意: 需要参考本模块的POM文件,显式引用orika.
     */
    public class BeanMapper {
        /**
         * beanMapper 门面
         */
        private static MapperFacade mapper;
    
        static {
            //mapNulls 表示 原对象中的null不会拷贝到目标对象
            MapperFactory mapperFactory = new DefaultMapperFactory.Builder().mapNulls(false).build();
            mapperFactory.getConverterFactory().registerConverter(new BigDecimal2IntConverter());
            mapper = mapperFactory.getMapperFacade();
        }
    
        /**
         * BigDecimal与Integer互转转换器
         */
        static class BigDecimal2IntConverter extends BidirectionalConverter<BigDecimal, Integer> {
            @Override
            public Integer convertTo(BigDecimal bigDecimal, Type<Integer> type) {
                return bigDecimal.intValue();
            }
    
            @Override
            public BigDecimal convertFrom(Integer integer, Type<BigDecimal> type) {
                return new BigDecimal(integer);
            }
        }
    
        /**
         * 简单的复制出新类型对象.
         * <p>
         * 通过source.getClass() 获得源Class
         * @param <S> 源对象类型
         * @param <D> 目标对象类型
         * @param source 源对象
         * @param destinationClass 目标类型
         * @return 目标对象
         */
        public static <S, D> D map(S source, Class<D> destinationClass) {
            return mapper.map(source, destinationClass);
        }
    
        /**
         * 极致性能的复制出新类型对象.
         * <p>
         * 预先通过BeanMapper.getType() 静态获取并缓存Type类型,在此处传入
         * @param <S> 源对象类型
         * @param <D> 目标对象类型
         * @param source 源对象
         * @param sourceType 源对象类型
         * @param destinationType 目标类型
         * @return 目标对象
         */
        public static <S, D> D map(S source, Type<S> sourceType, Type<D> destinationType) {
            return mapper.map(source, sourceType, destinationType);
        }
    
        /**
         * 简单的复制出新对象列表到ArrayList
         * <p>
         * 不建议使用mapper.mapAsList(Iterable<S>,Class<D>)接口, sourceClass需要反射,实在有点慢
         * @param <S> 源对象类型
         * @param <D> 目标对象类型
         * @param sourceList 源对象列表
         * @param sourceClass 源对象类 class
         * @param destinationClass 目标类 class
         * @return 目标对象对象
         */
        public static <S, D> List<D> mapList(Iterable<S> sourceList, Class<S> sourceClass, Class<D> destinationClass) {
            return mapper.mapAsList(sourceList, TypeFactory.valueOf(sourceClass), TypeFactory.valueOf(destinationClass));
        }
    
        /**
         * 极致性能的复制出新类型对象到ArrayList.
         * <p>
         * 预先通过BeanMapper.getType() 静态获取并缓存Type类型,在此处传入
         * @param <S> 源对象类型
         * @param <D> 目标对象类型
         * @param sourceList 源对象列表
         * @param sourceType 源对象类型
         * @param destinationType 目标类型
         * @return 目标对象对象列表
         */
        public static <S, D> List<D> mapList(Iterable<S> sourceList, Type<S> sourceType, Type<D> destinationType) {
            return mapper.mapAsList(sourceList, sourceType, destinationType);
        }
    
        /**
         * 简单复制出新对象列表到数组
         * 通过source.getComponentType() 获得源Class
         * destinationType
         * @param <S> 源对象类型
         * @param <D> 目标对象类型
         * @param destination 目标对象数组
         * @param source 源对象数组
         * @param destinationClass 目标类型
         * @return 目标对象对象数组
         */
        public static <S, D> D[] mapArray(final D[] destination, final S[] source, final Class<D> destinationClass) {
            return mapper.mapAsArray(destination, source, destinationClass);
        }
    
        /**
         * 极致性能的复制出新类型对象到数组
         * <p>
         * 预先通过BeanMapper.getType() 静态获取并缓存Type类型,在此处传入
         * @param <S> 源对象类型
         * @param <D> 目标对象类型
         * @param destination 目标对象数组
         * @param source 源对象数组
         * @param sourceType 源对象类型
         * @param destinationType 源对象类型
         * @return 目标对象数组
         */
        public static <S, D> D[] mapArray(D[] destination, S[] source, Type<S> sourceType, Type<D> destinationType) {
            return mapper.mapAsArray(destination, source, sourceType, destinationType);
        }
    
        /**
         * 预先获取orika转换所需要的Type,避免每次转换.
         * @param <E> 对象类型
         * @param rawType 要转换的类型
         * @return 转换后的类型
         */
        public static <E> Type<E> getType(final Class<E> rawType) {
            return TypeFactory.valueOf(rawType);
        }
    
        /**
         * 把源对象中的属性拷贝到目标对象,源对象中的null属性不拷贝到目标对象。
         *
         * @param sourceObject      源对象
         * @param destinationObject 目标对象
         * @param <S>               源对象
         * @param <D>               目标对象
         */
        public static <S, D> void map(S sourceObject, D destinationObject) {
            mapper.map(sourceObject, destinationObject);
        }
    }
    
    展开全文
  • Orika对象复制

    2021-02-03 15:39:08
    Orika背景介绍 Orika是java Bean映射框架,可以实现从一个对象递归拷贝数据至另一个对象。在开发多层应用程序中非常有用。在这些层之间交换数据时,通常为了适应不同API需要转换一个实例至另一个实例。  有很多...
  • Deadlock with Orika 1.4.4

    2020-11-25 12:28:34
    ve had a deadlock using Orika 1.4.4 when getting a MapperFacade from a DefaultMapperFactory. This is the deadlock threads dump: <pre><code> "Thread-18": at ma.glasnost.orika.impl....
  • orika 这篇文章着眼于使用Orika将JAXB对象映射到业务域对象。 本月初,我使用基于反射的Dozer讨论了相同的映射用例。 在本文中,我假设需要映射相同的示例类,但是它们将使用Orika而不是Dozer进行映射。 Dozer和...
  • 1、pom导入 <!-- https://mvnrepository.com/artifact/com.gitlab.haynes/orika-spring-boot-starter --> <dependency>...orika-spring-boot-starter</artifactId> <version>
  • Spring集成Orika

    千次阅读 2018-05-16 11:08:19
    我喜欢好的软件,而且Orika真的是一个有意思的项目,在这篇文章中,我将讨论我最近使用的这个Java bean映射框架,我强烈推荐它。 Orika(以前托管于谷歌代码)声称它是一个更简单、更轻量、更快的Java Bean映射工具,...
  • java orika学习

    2018-07-24 11:23:21
    Orika是一个简单、快速的JavaBean拷贝框架,它能够递归地将数据从一个JavaBean复制到另一个JavaBean。 在pom.xml引入 &lt;dependency&gt; &lt;groupId&gt;ma.glasnost.orika&lt;/groupId...
  • Orika占坑

    2019-06-20 13:33:12
    Orika 作用同MapStruct 转载于:https://juejin.im/post/5d0b8aeb51882514c324b548
  • Orika 使用方法

    2020-06-24 23:01:19
    ma.glasnost.orika /** * 测试属性复制功能: * - [x] 同名属性 * - [x] 非同名属性 * - [x] 导航属性,List,Map也可导航list[0],map['a'] * - [x] List & Array * - [x] 集合泛型 * - [x] 递归 * -...
  • Orika 性能调优

    2018-08-08 17:23:00
    1.使用MapperFactory作为单例 2.使用BoundMapperFacade可避免重复查找...官方资料 : http://orika-mapper.github.io/orika-docs/performance-tuning.html 转载于:https://www.cnblogs.com/vitalq/p/9444116.html...
  • Orika 是一个 Java Bean 映射框架。示例代码:mapperFactory.classMap(BasicPerson.class, BasicPersonDto.class)  .mapNulls(true).mapNullsInReverse(true)  .field("field1", "fieldOne")  .mapNulls(false)...
  • Orika简单使用

    千次阅读 2017-07-18 09:51:43
    使用orika进行对象间Mapping 1. 当两个类的属性名都一样 package com.orika; /** * Title:CopiedStudent.java * Description: * * @author zhuyang * @version 1.0 2017/7/18 */ public class ...
  • 使用 Orika 实现bean 映射 Orika是...
  • orika 映射非空字段 这篇文章着眼于使用Orika将JAXB对象映射到业务域对象。 本月初, 我使用基于反射的Dozer讨论 了相同的映射用例 。 在本文中,我假设需要映射相同的示例类,但是它们将使用Orika而不是Dozer进行...
  • <div><p>偶然看到该项目的灵感来自于 <strong>Orika</strong>,看了 Orika 的介绍没找到 EasyMapper 中 <code>Transformer</code> 的功能,即创建 <code>ClassMap</code> 时建立不同类型之间的关联关系&...
  • 个人维护的一个后台服务使用了Orika框架去处理bean对象之间的映射,并对Orika框架做了简单的封装,减少冗余代码。这里简单说明下Orika框架的原理,Orika框架是在运行时动态创建字节码,生成最小开销的映射器来实现...
  • 关于orika做对象映射

    2021-06-04 11:05:10
    一、Orika背景介绍    Orika是java Bean映射框架,可以实现从一个对象递归拷贝数据至另一个对象。在开发多层应用程序中非常有用。在这些层之间交换数据时,通常为了适应不同API需要转换一个实例至另一个实例。 ...

空空如也

空空如也

1 2 3 4 5 ... 16
收藏数 310
精华内容 124
关键字:

Orika