JAVA反射实体对象和String相互转换

JAVA实体对象和String相互转换

在实际工作应用当中，我们需要将实体对象转换为String字符串来进行传参，定义好固定格式，然后在接收方将String转换为实体对象。为方便直接转换，无需每次定义，故提取方法直接调用。本次转换只支持JAVA常用基本类型和实体对象类型，不支持List等集合类型。

上代码

import java.lang.reflect.Field;
import java.math.BigDecimal;
import java.text.SimpleDateFormat;
/**
 * ClassName: <br/>
 * Description: <br/>
 * date: 2020/12/30 8:48<br/>
 * @author chenziyang <br/>
 * @since JDK 1.8
 */
public class A {

    /**
     * 根据实体类属性数据拼接成字符串返回
     * @param obj  实体对象
     * @param regex 分隔符
     * @return
     * @throws Exception
     */
     public static String ObjectParseStr(Object obj, String regex) throws Exception{
         StringBuffer sb = new StringBuffer("");
         // 非空判断
         if (obj == null || regex == null){
             return sb.toString();
         }
         int i = 0 ;
         // 遍历实体对象属性
         for (Field field : obj.getClass().getDeclaredFields()){
             // 第一个属性拼接不加分隔符
             if (i++ == 0){
                 sb.append(field.get(obj) == null ? "" : field.get(obj).toString());
                 continue;
             }
             // 拼接属性值，增加分隔符
             sb.append(regex);
             sb.append(field.get(obj) == null ? "" : field.get(obj).toString());
         }
         return sb.toString();
     }

    /**
     * 分割字符串，将获取数据放入实体类中
     * @param obj     实体对象
     * @param str     字符串
     * @param regex   分隔符
     * @return
     * @throws Exception
     */
     public static Object getObject(Object obj, String str,String regex) throws Exception{
         // 非空判断
         if (str == null || obj == null || regex == null)
             return null;
         // 分割字符串
         String[] strs = str.split(regex);
         int i = 0 ;
         // 遍历实体对象属性
         for (Field field : obj.getClass().getDeclaredFields()){
             // 判断分割值数量是否已到最大值，防止下标溢出
             if (i == strs.length){
                 break;
             }
             // 取消安全检查
             field.setAccessible(true);
             // 根据属性值类型处理数据
             field.set(obj,getFieldValue(field.getType().toString(),strs[i++]));
         }
         return obj;
     }

    /**
     * 根据属性类型返回对应得属性值  暂时只支持基本常用类型，实体类对象
     * @param type    属性类型
     * @param str     准备处理得数据
     * @return
     * @throws Exception
     */
    private static Object getFieldValue(String type, String str) throws Exception {
        if (str == null){
            str = "";
        }
        if (type.equals("class java.lang.String")) {
            return str;
        }
        if (type.equals("class java.lang.Integer")) {
            return Integer.parseInt(str);
        }
        if (type.equals("class java.lang.Short")) {
            return Short.parseShort(str);
        }
        if (type.equals("class java.lang.Double")) {
            return Double.parseDouble(str);
        }
        if (type.equals("class java.lang.Boolean")) {
            return Boolean.parseBoolean(str);
        }
        if (type.equals("class java.util.Date")) {
            if (str.length() == 15)
                return new SimpleDateFormat("yyyyMMdd HHmmss").parse(str);
            if (str.length() == 8)
                return new SimpleDateFormat("yyyyMMdd").parse(str);
        }
        if (type.equals("class java.lang.Long")) {
            return Long.parseLong(str);
        }
        if (type.equals("class java.math.BigDecimal")) {
            return new BigDecimal(str);
        }
        /**
         * 以上转化常用基本类型
         * 以下为用到实体类转化时使用，实体类中toString方法需重写，分隔符定义相同，格式与A中toString一致适用于此方法转换
         */
        if (type.equals("class A")){
            return getObject(new A(),str,"-");
        }
        return str;
    }

    private String field1;
    private String field2;
    private String field3;
    private A a1;
    public A getA1() {
        return a1;
    }
    public void setA1(A a1) {
        this.a1 = a1;
    }

    public String getField1() {
        return field1;
    }

    public void setField1(String field1) {
        this.field1 = field1;
    }

    public String getField2() {
        return field2;
    }

    public void setField2(String field2) {
        this.field2 = field2;
    }

    public String getField3() {
        return field3;
    }

    public void setField3(String field3) {
        this.field3 = field3;
    }

    /**
     * 实体类类中对象属性，toString 分隔符固定，区分其他对象。这样可在互相转化时直接调用
     * @return
     */
    public String toString(){
        return field1+"-"+field2+"-"+field3;
    }

    public static void main(String[] args) throws Exception {
        String s = "11,22,,33-44-55" ;
        for (String aa : s.split(",")){
            System.out.println(aa);
        }
        A a = new A();
        getObject(a,s,",");
        // 11-22-===33-44-55
        System.out.println(a.toString()+"==="+a.getA1().toString());
        // 11,22,,33-44-55
        System.out.println(ObjectParseStr(a,","));
    }
}