List<T>转换json，不多说，直接放"码"过去
新建两个类，一个User、一个Emp，User中存在Emp对象，还有一个注解类Entity
1 public class User { 2 private Integer id; 3 private String name;
@Entity 4 private Emp emp; 5 public Integer getId() { 6 return id; 7 } 8 public void setId(Integer id) { 9 this.id = id; 10 } 11 public String getName() { 12 return name; 13 } 14 public void setName(String name) { 15 this.name = name; 16 } 17 public Emp getEmp() { 18 return emp; 19 } 20 public void setEmp(Emp emp) { 21 this.emp = emp; 22 } 23 24 }
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; } }
1 import java.lang.annotation.ElementType; 2 import java.lang.annotation.Retention; 3 import java.lang.annotation.RetentionPolicy; 4 import java.lang.annotation.Target; 5 6 @Retention(RetentionPolicy.RUNTIME) 7 @Target(value=ElementType.FIELD) 8 public @interface Entity { 9 10 }
接下来是主要代码，主要是通过反射实现的
/**
* 解析集合
* @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只能是对象，不过还是有了思路了，总体来说反射还是挺好用的~.~