一. 背景

在开发过程中，经常涉及到对象之间的拷贝（尤其是微服务架构下，api 层，biz层，Dao层，视图层之间的对象拷贝）。 当前项目中，用的比较多的是Spring 提供的 BeanUtils。

BeanUtils.copyProperties(Object source, Object target)

实现原理比较简单，就是通过Java的Introspector获取到两个类的PropertyDescriptor，对比两个属性具有相同的名字和类型，如果是，则进行赋值（通过ReadMethod获取值，通过WriteMethod赋值），否则忽略。

为了提高性能Spring对BeanInfo和PropertyDescriptor进行了缓存（首次复制比较慢）。
高性能的代价是简洁，同时失去了灵活性和扩展性，功能简单。

二. Orika 简洁

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

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

2.1 效率高

    底层使用Javassist生成字节码，运行效率很高

2.2 功能强大

  不同属性名复制，嵌套对象复制，属性忽略，集合复制等等，也支持自定convert，实现自身复杂转换逻辑。

三. 使用案例

3.1 简单对象-相同属性名拷贝

//构建一个映射工厂
MapperFactory mapperFactory = new DefaultMapperFactory.Builder().build();
//注册映射关系，避免首次复制效率低
mapperFactory.classMap(UserDTO.class,UserInfo.class)
        //byDefault 就是按相同属性名称复制
        .byDefault()

        .register();
// 从映射工厂获取一个工具对象
MapperFacade mapperFacade = mapperFactory.getMapperFacade();    
//使用
UserDTO userDTO=new UserDTO();
userDTO.setName("jack");
UserInfo userInfo=new UserInfo();
//
mapperFacade.map(userDTO,userInfo);

//直接帮我们创建对象
UserInfo userInfo2 = mapperFacade.map(userDTO, UserInfo.class);

3.2 简单对象-不同属性名拷贝

//假设我们需要将userDTO的属性name，复制给UserInfo的属性userName
mapperFactory.classMap(UserDTO.class,UserInfo.class)
        .field("name","userName")
        .byDefault()
        .register();

3.3 内嵌对象拷贝

@Data
public class UserDTO {

    private Long userId;

    private String name;

    private AddressDTO address;
}
@Data
public class UserInfo {

    private Long userId;

    private String name;

    private AddressInfo address;
}
// UserDTO属性address复制，只需要注册AddressDTO和AddressInfo的映射关系即可

mapperFactory.classMap(AddressDTO.class,AddressInfo.class)
        .byDefault()
        .register();

3.4 排除属性复制

mapperFactory.classMap(AddressDTO.class,AddressInfo.class)
        .exclude("userId")
        .byDefault()
        .register();

3.5 集合对象拷贝

// 集合对象的拷贝不需要额外定义映射关系

List<UserInfo> userInfos=mapperFacade.mapAsList(userDTos, UserInfo.class);

3.6 自定义转换关系

@Data
public class UserDTO {

    private Long userId;

    private String name;

    private Integer age;

    private UserProfessionEnum profession;

    private AddressDTO address;

    private Date createTime;
}
@Data
public class UserInfo {

    private Long userId;

    private String name;

    private Integer age;

    private Date createTime;

    private String profession;

    private AddressInfo address;
}

mapperFactory.classMap(UserDTO.class,UserInfo.class)
        .customize(new CustomMapper<UserDTO, UserInfo>() {
            @Override
            public void mapAtoB(UserDTO userDTO, UserInfo userInfo, MappingContext context) {
                super.mapAtoB(userDTO, userInfo, context);
                userInfo.setProfession(userDTO.getProfession().getName());
            }

            @Override
            public void mapBtoA(UserInfo userInfo, UserDTO userDTO, MappingContext context) {
                super.mapBtoA(userInfo, userDTO, context);
                userDTO.setProfession(Arrays.stream(UserProfessionEnum.values()).filter(p->Objects.equals(p.getName(),userInfo.getProfession())).findFirst().orElseGet(null));
            }
        })
        .byDefault()
        .register();

3.7 自定义转换关系-全局

mapperFactory.getConverterFactory().registerConverter(new BidirectionalConverter<UserProfessionEnum,String>() {

    @Override
    public String convertTo(UserProfessionEnum userProfessionEnum, Type<String> type, MappingContext mappingContext) {

        return userProfessionEnum.getName();
    }

    @Override
    public UserProfessionEnum convertFrom(String s, Type<UserProfessionEnum> type, MappingContext mappingContext) {

       return Arrays.stream(UserProfessionEnum.values()).filter(p->Objects.equals(p.getName(),s)).findFirst().orElseGet(null);
    }
});

四. 使用姿势推荐

4.1 定义全局抽象convert

public abstract class AbstractOrikaConvert {

    protected MapperFactory mapperFactory = new DefaultMapperFactory.Builder().build();

    private MapperFacade mapperFacade = null;

    public AbstractOrikaConvert() {

        //注册一些项目级别的转换器，比如和业务无关的日期的转换
        mapperFacade=mapperFactory.getMapperFacade();
    }
    public <V, P> P convert(V base, Class<P> target) {

    if(base==null){
        return null;
    }
    return mapperFacade.map(base, target);
    }

    public <V, P> void convert(V base, P target) {
        mapperFacade.map(base, target);
    }

    public <V, P> List<P> convertList(List<V> baseList, Class<P> target) {
        return baseList == null ? new LinkedList<>() : mapperFacade.mapAsList(baseList, target);
    } 
}

4.2 层与层之间定义convert

// 比如Biz层和视图层之间
@Component
public class BizConvert  extends AbstractOrikaConvert{

    public BizConvert() {
        // 定义一些只存在biz层和视图层对象映射关系的公共转换器
        
       // 定义一系列classMap
    }
}

4.3 转换对象较多的可单独定义convert

// 定义Customer业务域内的转换关系
@Component
public class CustomerBizConvert extends AbstractOrikaConvert{


    public CustomerBizConvert() {
        
        // mapperFactory.classMap()
    }
}