List 集合轉換Json

  List<T>轉換json，不多說，直接放"碼"過去

   新建兩個類，一個User、一個Emp，User中存在Emp對象，還有一個注解類Entity

public class User {
    private Integer id;
    private String name;
　　    @Entity
    private Emp emp;
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Emp getEmp() {
        return emp;
    }
    public void setEmp(Emp emp) {
        this.emp = emp;
    }
    
}

public class Emp {
    private Integer id;
    private String name;
    @Entity
    private Dept dept;
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Dept getDept() {
        return dept;
    }
    public void setDept(Dept dept) {
        this.dept = dept;
    }
    
}

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Retention(RetentionPolicy.RUNTIME)
@Target(value=ElementType.FIELD)
public @interface Entity {
    
}

 

接下來是主要代碼，主要是通過反射實現的

/**
     * 解析集合
     * @param list
     * @return
     */
    public static <T> String ToJsonByTObject(List<T> list){
        //json格式  [{"":"","":""},{}]
        StringBuffer sb = new StringBuffer("[");
        if(list!=null){
            try {
                //獲取集合類型
                int j = list.size();
                for (int i = 0; i < j; i++) {
                    Class c = Class.forName(list.get(i).getClass().getName());
                    Field[] fs = c.getDeclaredFields();
                    sb.append("{");
                    for (int k = 0; k < fs.length; k++) {
                        Object objs = list.get(i);
                        StringBuffer suf = new StringBuffer("get");
                        suf.append(captureName(fs[k].getName()));
                        Method me = c.getDeclaredMethod(suf.toString());
                        Object o = me.invoke(objs);
                        //判斷屬性值是否為空
                        if(o!=null){
                            String str = fs[k].getType().getName();
　　　　　　　　　　　　　　　　 //注解判斷屬性是否是本地類
                            Entity entity = fs[k].getAnnotation(Entity.class);
                            if(entity!=null){
                                //判斷是否是對象
                                //if(isMyObject(str)){
                                analysisObject(str,sb,fs,k,o);
                            }else{
                                if(k!=0){
                                    sb.append(",");
                                }
                                sb.append("\""+fs[k].getName()+"\":\""+o+"\"");
                            }
                        }
                    }
                    sb.append("}");
                    if(i!=j-1){
                        sb.append(",");
                    }
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
            sb.append("]");
        }
        return sb.toString();
    }

如果屬性是對象的話，則要再次解析對象，這里並沒有把對象解析成一個新的json對象，而是以對象首字母小寫+下划線+屬性名稱的形式（e_id,e_name）

/**
     * 解析屬性為對象的本地類，p_name
     * @param str
     */
    public static void analysisObject(String str,StringBuffer sb,Field[] fs,int k,Object o){
        try {
            String content = getFirstA(fs[k].getName());
            Class c1 = Class.forName(str);
            
            Field[] f1 = c1.getDeclaredFields();
            for (int l = 0; l < f1.length; l++) {
                StringBuffer suf = new StringBuffer("get");
                suf.append(captureName(f1[l].getName()));
                Method me = c1.getDeclaredMethod(suf.toString());
                Object ob = me.invoke(o);
                if(ob!=null){
                    String str1 = f1[l].getType().getName();
                    Entity entity = f1[l].getAnnotation(Entity.class);
                    if(entity!=null){
                        //判斷是否是對象
                        //if(isMyObject(str)){
                        analysisObject(str1,sb,f1,l,ob);
                    }else{
                        sb.append(",");
                        sb.append("\""+content+f1[l].getName()+"\":\""+ob+"\"");
                    }
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        } 
    }

主要代碼完了，其次是其他的小信息，獲取對象屬性的值是通過get方法的，具體形式是通過StringBuffer的append()方法來完成，首先追加一個字符串  "get"  然后獲取屬性名稱並首字母大寫，然后調用invoke方法返回屬性值

/**
     * 字符串第一個字符大寫
     * @param name
     * @return
     */
    public static String captureName(String name) {
        char[] cs=name.toCharArray();
        //字符a對應數字97
        cs[0]-=32;
        return String.valueOf(cs);
    }

這個已經廢棄了，因為判斷太麻煩了，我們通過注解類來判斷

/**
     * 判斷是否是本地類，通過endswith獲取字符串后綴，然后判斷是java類型或者對象
     * @param str
     * @return
     */
    private static boolean isMyObject(String str){
        boolean state = false;
        if(!str.endsWith("String") && !str.endsWith("Integer") && !str.endsWith("Date") 
            && !str.endsWith("Char") && !str.endsWith("Double") && !str.endsWith("Float") 
            && !str.endsWith("Boolean") && !str.endsWith("Long") && !str.endsWith("Object")){
            state = true;
        }
        return state;
    }

這個是首字母小寫，前面說的，如果對象是屬性，那么他的格式對象首字母小寫+下划線+屬性名稱

/**
     * 首字母小寫
     * @param str
     * @return
     */
    public static String getFirstA(String str){
        String name = str.toLowerCase();
        char[] cs=name.substring(0, 1).toCharArray();
        return String.valueOf(cs[0])+"_";
    }

最后來個測試

public static void main(String[] args){
        List<User> list = new ArrayList<User>();
        User uer = new User();
        uer.setId(1);
        uer.setName("張三");
        Emp e = new Emp();
        e.setId(1);
        Dept dept = new Dept();
        dept.setId(1);
        dept.setName("安保");
        e.setDept(dept);
        uer.setEmp(e);
        list.add(uer);
        
        User uer1 = new User();
        uer1.setId(2);
        uer1.setName("李四");
        Emp e1 = new Emp();
        e1.setId(1);
        uer1.setEmp(e1);
        list.add(uer1);

        System.out.println(ToJson.ToJsonByTObject(list));

    }

[{"id":"1","name":"張三","e_id":"1","d_id":"1","d_name":"安保"},{"id":"2","name":"李四","e_id":"1"}]

 

好了，寫到這里，其實還沒有寫完，比如List<Map<String,Object>>這種形式的還未加入到代碼中，T只能是對象，不過還是有了思路了，總體來說反射還是挺好用的~.~