orika Bean映射工具介绍及日期类型LocalDate映射问题解决

orika Bean映射工具介绍及日期类型LocalDate映射问题解决

---

场景：在CRUD操作中，一个实体类内成员变量过多时，需要写大量的get、set方法，第一影响了我们的工作效率，第二大量的get、set方法影响代码美观，降低了代码的可读性，那么一款高效的Bean映射框架Orike就出现了！

---

一、Orike是什么？

Orika是java Bean映射框架，可以实现从一个对象递归拷贝数据至另一个对象。在开发多层应用程序中非常有用。在这些层之间交换数据时，通常为了适应不同API需要转换一个实例至另一个实例。

有很多方法可以实现：硬代码拷贝或Dozer实现bean映射等。总之，需要简化不同层对象之间映射过程。
Orika使用字节码生成器创建开销最小的快速映射，比其他基于反射方式实现（如，Dozer）更快。

二、对比

BeanUtils：
apache的BeanUtils和spring的BeanUtils中拷贝方法的原理都是先用jdk中 java.beans.Introspector类的getBeanInfo()方法获取对象的属性信息及属性get/set方法，接着使用反射(Method的invoke(Object obj, Object… args))方法进行赋值。apache支持名称相同但类型不同的属性的转换，spring支持忽略某些属性不进行映射，他们都设置了缓存保存已解析过的BeanInfo信息。

BeanCopier：
cglib的BeanCopier采用了不同的方法：它不是利用反射对属性进行赋值，而是直接使用ASM的MethodVisitor直接编写各属性的get/set方法(具体过程可见BeanCopier类的generateClass(ClassVisitor v)方法)生成class文件，然后进行执行。由于是直接生成字节码执行，所以BeanCopier的性能较采用反射的BeanUtils有较大提高

Dozer：
使用以上类库虽然可以不用手动编写get/set方法，但是他们都不能对不同名称的对象属性进行映射。在定制化的属性映射方面做得比较好的有Dozer，Dozer支持简单属性映射、复杂类型映射、双向映射、隐式映射以及递归映射。可使用xml或者注解进行映射的配置，支持自动类型转换，使用方便。但Dozer底层是使用reflect包下Field类的set(Object obj, Object value)方法进行属性赋值，执行速度上不是那么理想。

Orika：
那么有没有特性丰富，速度又快的Bean映射工具呢，这就是下面要介绍的Orika，Orika是近期在github活跃的项目，底层采用了javassist类库生成Bean映射的字节码，之后直接加载执行生成的字节码文件，因此在速度上比使用反射进行赋值会快很多，下面详细介绍Orika的使用方法。

三、使用步骤

1.引入依赖

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

2.配置解决日期类型映射报错问题

在config包下引入配置

import ma.glasnost.orika.CustomConverter;
import ma.glasnost.orika.Mapper;
import ma.glasnost.orika.MapperFactory;
import ma.glasnost.orika.impl.DefaultMapperFactory;
import ma.glasnost.orika.metadata.ClassMapBuilder;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.FactoryBean;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;

public class MapperFactoryBean implements FactoryBean<MapperFactory>, ApplicationContextAware {
 
	ApplicationContext applicationContext;
 
	@SuppressWarnings({ "unchecked", "rawtypes" })
	@Override
	public MapperFactory getObject() throws Exception {
		DefaultMapperFactory build = new DefaultMapperFactory.Builder().build();
		for (CustomConverter converter : applicationContext.getBeansOfType(CustomConverter.class).values()) {
			build.getConverterFactory().registerConverter(converter);
		}
		for (Mapper<?, ?> mapper : applicationContext.getBeansOfType(Mapper.class).values()) {
			build.registerMapper(mapper);
		}
		for (ClassMapBuilder<?, ?> mapper : applicationContext.getBeansOfType(ClassMapBuilder.class).values()) {
			build.registerClassMap(mapper);
		}
		return build;
	}
 
	@Override
	public Class<?> getObjectType() {
		return MapperFactory.class;
	}
 
	@Override
	public boolean isSingleton() {
		return true;
	}
 
	@Override
	public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
		this.applicationContext = applicationContext;
	}
 
}

import ma.glasnost.orika.MapperFacade;
import ma.glasnost.orika.MapperFactory;
import ma.glasnost.orika.converter.BidirectionalConverter;
import ma.glasnost.orika.metadata.Type;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import javax.annotation.PostConstruct;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
 
@Configuration
public class OrikaConfig {
	@Bean
	public MapperFactoryBean loadFactory(){
		return new MapperFactoryBean();
	}

	@Bean
	public MapperFacade loadMapperFacade(MapperFactory factory){
		return factory.getMapperFacade();
	}

	@Autowired
	private MapperFactory mapperFactory;

	/**
	 * 解决orika映射LocalDateTime报错问题
	 */
	@PostConstruct
	public void init() {
		mapperFactory.getConverterFactory().registerConverter(new LocalDateTimeConverter());
		mapperFactory.getConverterFactory().registerConverter(new LocalDateConverter());
		mapperFactory.getConverterFactory().registerConverter(new LocalTimeConverter());
	}
	private class LocalDateTimeConverter extends BidirectionalConverter<LocalDateTime, LocalDateTime> {
		@Override
		public LocalDateTime convertTo(LocalDateTime source, Type<LocalDateTime> destinationType) {
			return LocalDateTime.from(source);
		}
		@Override
		public LocalDateTime convertFrom(LocalDateTime source, Type<LocalDateTime> destinationType) {
			return LocalDateTime.from(source);
		}
	}
	private class LocalDateConverter extends BidirectionalConverter<LocalDate, LocalDate> {
		@Override
		public LocalDate convertTo(LocalDate source, Type<LocalDate> destinationType) {
			return LocalDate.from(source);
		}
		@Override
		public LocalDate convertFrom(LocalDate source, Type<LocalDate> destinationType) {
			return LocalDate.from(source);
		}
	}
	private class LocalTimeConverter extends BidirectionalConverter<LocalTime, LocalTime> {
		@Override
		public LocalTime convertTo(LocalTime source, Type<LocalTime> destinationType) {
			return LocalTime.from(source);
		}
		@Override
		public LocalTime convertFrom(LocalTime source, Type<LocalTime> destinationType) {
			return LocalTime.from(source);
		}
	}
}

3.使用

以批量保存接口举例

	//引入
	@Service
public class Service extends ServiceImpl<Mapper, C> {
    @Resource
    private MapperFacade mapperFacade;
    
    /**
     * 批量保存
     *
     * @author MYH
     * @date 2022/3/17 14:28
     */
    @Transactional
    public void batchModifyConfig(List<ConfigDTO> configDTOList) {
        for (ConfigDTO configDTO : configDTOList) {
//            MapperFactory mapperFactory = new DefaultMapperFactory.Builder().build();
//            Config config = mapperFactory.getMapperFacade().map(configDTO, Config.class);
            Config config = mapperFacade.map(configDTO, Config.class);
            updateById(config);
        }
    }
}

---

总结

生活总是来来往往，千万别等来日方长。