java 类转换器 Covert

╰+攻爆jí腚メ 2023-02-18 01:51 8阅读 0赞

在编码过程中，时常遇到类与类之间进行转换，本人以前用的值笨办法，一个属性一个属性的取值赋值，效率低不说，时常出现错误。在几经折腾下，本人找到了以下的方法，仅供参考。

# 基础要求： #

1、要进行转换的类必须继承Covert类

2、目标类中的字段包含源类中的字段

# 代码实现： #

1、基础的转换工具类：

public class BeanConverter {
        private static final ModelMapper modelMapper;
    
        static {
            modelMapper = new ModelMapper();
            Jsr310ModuleConfig config = Jsr310ModuleConfig.builder()
                    .dateTimePattern("yyyy-MM-dd HH:mm:ss") // default is yyyy-MM-dd HH:mm:ss
                    .datePattern("yyyy-MM-dd") // default is yyyy-MM-dd
                    .zoneId(ZoneOffset.UTC) // default is ZoneId.systemDefault()
                    .build();
            modelMapper.registerModule(new Jsr310Module(config)).registerModule(new Jdk8Module());
            modelMapper.getConfiguration().setFullTypeMatchingRequired(true);
            modelMapper.getConfiguration().setMatchingStrategy(MatchingStrategies.STRICT);
        }
    
        /**
         * 获取 modelMapper
         *
         * @return
         */
        public static ModelMapper getModelMapper() {
            return modelMapper;
        }
    
        /**
         * Bean转换为Map
         *
         * @param bean
         * @param <T>
         * @return
         */
        public static <T> Map<String, Object> beanToMap(T bean) {
            Map<String, Object> map = Collections.emptyMap();
            if (null != bean) {
                BeanMap beanMap = BeanMap.create(bean);
                map = new HashMap<>(beanMap.keySet().size());
                for (Object key : beanMap.keySet()) {
                    map.put(String.valueOf(key), beanMap.get(key));
                }
            }
            return map;
        }
    
        /**
         * List<E>转换为List<Map<String, Object>>
         *
         * @param objList
         * @param <T>
         * @return
         */
        public static <T> List<Map<String, Object>> beansToMap(List<T> objList) {
            List<Map<String, Object>> list = Collections.emptyList();
            if (CollectionUtils.isNotEmpty(objList)) {
                list = new ArrayList<>(objList.size());
                Map<String, Object> map;
                T bean;
                for (T anObjList : objList) {
                    bean = anObjList;
                    map = beanToMap(bean);
                    list.add(map);
                }
            }
            return list;
        }
    
        /**
         * map转为bean
         *
         * @param <T>       the type parameter
         * @param mapList   the map list
         * @param beanClass the bean class
         * @return t list
         */
        public static <T> List<T> mapToBean(List<Map<String, Object>> mapList, Class<T> beanClass) {
            List<T> list = Collections.emptyList();
            if (CollectionUtils.isNotEmpty(mapList)) {
                list = new ArrayList<>(mapList.size());
                Map<String, Object> map;
                T bean;
                for (Map<String, Object> map1 : mapList) {
                    map = map1;
                    bean = mapToBean(map, beanClass);
                    list.add(bean);
                }
            }
            return list;
        }
    
        /**
         * map转为bean
         *
         * @param map       the map
         * @param beanClass the bean class
         * @return t
         */
        public static <T> T mapToBean(Map<String, Object> map, Class<T> beanClass) {
            T entity = ClassUtils.newInstance(beanClass);
            BeanMap beanMap = BeanMap.create(entity);
            beanMap.putAll(map);
            return entity;
        }
    
        /**
         * 列表转换
         *
         * @param clazz the clazz
         * @param list  the list
         */
        public static <T> List<T> convert(Class<T> clazz, List<?> list) {
            return CollectionUtils.isEmpty(list) ? Collections.emptyList() : list.stream().map(e -> convert(clazz, e)).collect(Collectors.toList());
        }
    
        /**
         * 单个对象转换
         *
         * @param targetClass 目标对象
         * @param source      源对象
         * @return 转换后的目标对象
         */
        public static <T> T convert(Class<T> targetClass, Object source) {
            return getModelMapper().map(source, targetClass);
        }
    }

2、Covert类

public class Covert implements Serializable {
    
        /**
         * 获取自动转换后的JavaBean对象
         *
         * @param clazz
         * @param <T>
         * @return
         */
        public <T> T convert(Class<T> clazz) {
            return BeanConverter.convert(clazz, this);
        }
    }

# 示例： #

public class CS {
    
        public static void main(String[] args) {
    
            SysVo sysVo = new SysVo();
            sysVo.setAccount("11");
            sysVo.setPassword("11");
            SysUser user = sysVo.convert(SysUser.class);
            System.out.println(user);
        }
    
        @Data
        static
        class SysVo extends Covert {
    
            @TableField("ACCOUNT")
            private String account;
    
            @TableField("PASSWORD")
            private String password;
        }
    }