java Bean之间的转换（属性名不同）

原文文章： https://blog.csdn.net/luliuliu1234/article/details/84141595

相同属性名时转换：

import org.springframework.beans.BeanUtils;
test1 a = new test1();
test2 b = new test2();
BeanUtils.copyProperties(a, b);

封装的Beanutils:

package com.zhiwei.common.utils.bean;

import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * Bean 工具类
 *
 * @author zhiwei
 */
public class BeanUtils extends org.springframework.beans.BeanUtils {
    /**
     * Bean方法名中属性名开始的下标
     */
    private static final int BEAN_METHOD_PROP_INDEX = 3;

    /**
     * 匹配getter方法的正则表达式
     */
    private static final Pattern GET_PATTERN = Pattern.compile("get(\p{javaUpperCase}\w*)");

    /**
     * 匹配setter方法的正则表达式
     */
    private static final Pattern SET_PATTERN = Pattern.compile("set(\p{javaUpperCase}\w*)");

    /**
     * Bean属性复制工具方法。
     *
     * @param dest 目标对象
     * @param src  源对象
     */
    public static void copyBeanProp(Object dest, Object src) {
        try {
            copyProperties(src, dest);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 获取对象的setter方法。
     *
     * @param obj 对象
     * @return 对象的setter方法列表
     */
    public static List<Method> getSetterMethods(Object obj) {
        // setter方法列表
        List<Method> setterMethods = new ArrayList<Method>();

        // 获取所有方法
        Method[] methods = obj.getClass().getMethods();

        // 查找setter方法

        for (Method method : methods) {
            Matcher m = SET_PATTERN.matcher(method.getName());
            if (m.matches() && (method.getParameterTypes().length == 1)) {
                setterMethods.add(method);
            }
        }
        // 返回setter方法列表
        return setterMethods;
    }

    /**
     * 获取对象的getter方法。
     *
     * @param obj 对象
     * @return 对象的getter方法列表
     */

    public static List<Method> getGetterMethods(Object obj) {
        // getter方法列表
        List<Method> getterMethods = new ArrayList<Method>();
        // 获取所有方法
        Method[] methods = obj.getClass().getMethods();
        // 查找getter方法
        for (Method method : methods) {
            Matcher m = GET_PATTERN.matcher(method.getName());
            if (m.matches() && (method.getParameterTypes().length == 0)) {
                getterMethods.add(method);
            }
        }
        // 返回getter方法列表
        return getterMethods;
    }

    /**
     * 检查Bean方法名中的属性名是否相等。<br>
     * 如getName()和setName()属性名一样，getName()和setAge()属性名不一样。
     *
     * @param m1 方法名1
     * @param m2 方法名2
     * @return 属性名一样返回true，否则返回false
     */

    public static boolean isMethodPropEquals(String m1, String m2) {
        return m1.substring(BEAN_METHOD_PROP_INDEX).equals(m2.substring(BEAN_METHOD_PROP_INDEX));
    }
}

不同属性名时转换：

  两种方式，第一种 使用cglib进行动态生成，缺点：  需要手动维护映射关系。

                    第二种 java8函数式接口，缺点： 不同bean之间进行转换就需要写一个转换方法

  第一种方式：

    首先加入依赖：

<dependency>  
            <groupId>asm</groupId>  
            <artifactId>asm</artifactId>  
            <version>3.3.1</version>  
        </dependency>  
        <dependency>  
            <groupId>asm</groupId>  
            <artifactId>asm-commons</artifactId>  
            <version>3.3.1</version>  
        </dependency>  
        <dependency>  
            <groupId>asm</groupId>  
            <artifactId>asm-util</artifactId>  
            <version>3.3.1</version>  
        </dependency>  
        <dependency>  
            <groupId>cglib</groupId>  
            <artifactId>cglib-nodep</artifactId>  
            <version>2.2.2</version>  
        </dependency>  

      CglibBean:

package com.zhiwei.common.utils.bean;

import org.springframework.cglib.beans.BeanGenerator;
import org.springframework.cglib.beans.BeanMap;

import java.util.Iterator;
import java.util.Map;
import java.util.Set;

/**
 * CglibBean   class
 *
 * @author zhiwei
 * @date 2020/09/28
 */
public class CglibBean {
    /**
     * 实体Object
     */
    public Object object = null;
    /**
     * 属性map
     */
    public BeanMap beanMap = null;

    public CglibBean() {
    }

    public CglibBean(Map<String, Class> propertyMap) {
        this.object = generateBean(propertyMap);
        this.beanMap = BeanMap.create(this.object);
    }

    /**
     * 给bean属性赋值
     *
     * @param property
     * @param value
     */
    public void setValue(String property, Object value) {
        beanMap.put(property, value);
    }

    /**
     * 通过属性名得到属性值
     *
     * @param property
     * @return
     */
    public Object getValue(String property) {
        return beanMap.get(property);
    }

    /**
     * 得到该实体bean对象
     *
     * @return
     */
    public Object getObject() {
        return this.object;
    }

    /**
     * 创建cglib动态代理的bean
     *
     * @param propertyMap 通过map创建
     * @return 返回bean对象
     */
    @SuppressWarnings("rawtypes")
    private Object generateBean(Map<String, Class> propertyMap) {
        BeanGenerator generator = new BeanGenerator();
        Set keySet = propertyMap.keySet();
        for (Iterator i = keySet.iterator(); i.hasNext(); ) {
            String key = (String) i.next();
            generator.addProperty(key, (Class) propertyMap.get(key));
        }
        return generator.create();
    }
}

    CglibBeanUtils:

package com.zhiwei.common.utils.bean;

import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.JavaType;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.apache.commons.beanutils.PropertyUtils;

import java.io.IOException;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.util.HashMap;
import java.util.Map;

/**
 * CglibBeanUtils   class
 *
 * @author zhiwei
 * @date 2020/09/28
 */
public class CglibBeanUtils {
    private static final ObjectMapper mapper = new ObjectMapper();

    static {
        mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
    }

    /**
     * 根据源对象content转换成目标对象，源对象支持集合类型，但源对象中的实体类和目标对象中的实体类需要属性名相同
     *
     * @param content 源对象
     * @param source  需要转换的目标集合类型
     * @param param   目标集合类型里封装的实体类
     * @return
     */
    public static <T> T getCollectionBean(Object content, Class<?> collectionClass, Class<?>... elementClasses) {
        if (content == null) {
            return null;
        }
        String contentStr = null;
        try {
            contentStr = mapper.writeValueAsString(content);
            JavaType javaType = mapper.getTypeFactory().constructParametricType(collectionClass, elementClasses);
            return mapper.readValue(contentStr, javaType);
        } catch (IllegalArgumentException | IOException e) {
        }
        return null;
    }

    /**
     * 根据源对象obj转换成目标对象，不支持集合类型，源对象和目标对象属性名需要相同
     *
     * @param obj源对象
     * @param valueType需要转换的目标集合类型
     * @return
     */
    public static <T> T getDataBeanWithType(Object obj, Class<T> valueType) {
        String dataNode = null;
        try {
            dataNode = mapper.writeValueAsString(obj);
            return mapper.readValue(dataNode, valueType);
        } catch (IOException e) {
        }
        return null;
    }

    /**
     * 拷贝bean的不同名称之间属性值,
     * 需要手工维护一个bean之间不同属性名的映射关系，不支持源对象或目标对象为集合类型
     *
     * @param target 目标对象
     * @param source 源对象
     * @param param  源对象和目标对象的映射关系,其中key为源对象的属性名，value为目标对象的属性名
     * @return 目标对象
     * @throws ClassNotFoundException
     * @throws IllegalArgumentException
     * @throws IllegalAccessException
     * @throws InvocationTargetException
     * @throws NoSuchMethodException
     */
    @SuppressWarnings("rawtypes")
    public static Object getObject(Object target, Object source, Map<String, String> param) throws ClassNotFoundException,
            IllegalArgumentException, IllegalAccessException, InvocationTargetException, NoSuchMethodException {
        //获取源对象的属性名和值，属性名作为key,值作为value
        Map<String, Object> sourceBeanMap = PropertyUtils.describe(source);
        // 获取实体对象属性名数组
        Field[] fields = source.getClass().getDeclaredFields();
        // 属性名，属性类型
        Map<String, Class> temp = new HashMap<>();
        // 属性名，属性值
        Map<String, Object> valueParam = new HashMap<>();
        for (Field f : fields) {
            // 设置访问权限，否则不能访问私有化属性
            f.setAccessible(true);
            // 若没有映射关系，则跳过继续寻找有映射关系的属性
            if (null == param.get(f.getName()))
                continue;
            temp.put(param.get(f.getName()), Class.forName(f.getType().getName()));
            for (Map.Entry<String, String> entry : param.entrySet()) {
                if (entry.getKey().equals(f.getName())) {
                    Object value = sourceBeanMap.get(entry.getKey());
                    valueParam.put(param.get(f.getName()), value);
                    break;
                }
            }
        }
        // 根据参数生成CglibBean对象
        CglibBean cglibBean = new CglibBean(temp);
        for (Map.Entry<String, Object> entry : valueParam.entrySet()) {
            cglibBean.setValue(entry.getKey(), entry.getValue());
        }
        Object object = cglibBean.getObject();
        /*// 用object给目标对象赋值
        PropertyUtils.copyProperties(target, object);*/
        BeanUtils.copyBeanProp(target, object);
        return target;
    }

    public static void main(String[] args) throws ClassNotFoundException, IllegalArgumentException,
            IllegalAccessException, InvocationTargetException, NoSuchMethodException {
        Map<String, String> mapping = new HashMap<>();
        UserDTO source = new UserDTO();
        UserVO target = new UserVO();
        source.setUserName("expireDate");
        source.setUserAge(11);
        mapping.put("userName", "name");//source field,target field,
        mapping.put("userAge", "age");
        target = (UserVO) getObject(target, source, mapping);
        System.out.println(target.toString());
    }
}

    两个实体类：

@Data
@AllArgsConstructor
@NoArgsConstructor
@Accessors(chain = true)
public class UserDTO {
    private String userName;
    private Integer userAge;
}


@Data
@AllArgsConstructor
@NoArgsConstructor
@Accessors(chain = true)
public class UserVO {
    private String name;
    private Integer age;
}

  第二种方式：

使用jdk8函数式接口：

public class UserDTO {
    private String userName;
    private Integer userAge;

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public Integer getUserAge() {
        return userAge;
    }

    public void setUserAge(Integer userAge) {
        this.userAge = userAge;
    }

        public UserDTO convert(){
        return ((Function<UserDTO,UserVO>) userDto ->{
            UserVO userVo = new UserVO();
            userVo.setAge(userDto.getUserAge());
            userVo.setName(userDto.getUserName());
        })
    }
}