关于hibernate的实体类中有集合类型转化成JSON的工具类

在做项目中遇见了包含集合类型（Set，List）的实体类，转化为json时报错。报错信息为：

java.lang.StackOverflowError：该错误是由于当前线程的栈满了  ，也就是函数调用层级过多导致。在集合类型上无限的循环造成。

解决该问题，就是不用把实体类中集合类型的属性转化为json。对于也需要转化的再此文章中没有研究。

一：首先利用PropertyUtils.getPropertyDescriptors利用反射机制获取类中的属性，并 查看该属性的类型。首先写两个测试类1，bean.java和beanTest.java

package FanSheLei;

import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
/**
 * 实体类
 * @author ZCZ
 * @time 2014-1-23
 */
public class bean implements java.io.Serializable{
	
	private String String_;
	private int int_;	
	private long long_;
	private Date date_;
	private double double_;
	private float float_;
	private boolean boolean_;
	private Set set_ = new HashSet(0);
	private List list_ = new ArrayList();
	private Map map_=new HashMap();
	public String getString_() {
		return String_;
	}
	public void setString_(String string) {
		String_ = string;
	}
	public int getInt_() {
		return int_;
	}
	public void setInt_(int int1) {
		int_ = int1;
	}
	public long getLong_() {
		return long_;
	}
	public void setLong_(long long1) {
		long_ = long1;
	}
	public Date getDate_() {
		return date_;
	}
	public void setDate_(Date date) {
		date_ = date;
	}
	public double getDouble_() {
		return double_;
	}
	public void setDouble_(double double1) {
		double_ = double1;
	}
	public float getFloat_() {
		return float_;
	}
	public void setFloat_(float float1) {
		float_ = float1;
	}
	public boolean isBoolean_() {
		return boolean_;
	}
	public void setBoolean_(boolean boolean1) {
		boolean_ = boolean1;
	}
	public Set getSet_() {
		return set_;
	}
	public void setSet_(Set set) {
		set_ = set;
	}
	public List getList_() {
		return list_;
	}
	public void setList_(List list) {
		list_ = list;
	}
	public Map getMap_() {
		return map_;
	}
	public void setMap_(Map map) {
		map_ = map;
	}
	
	
}

package FanSheLei;

import java.beans.PropertyDescriptor;

import com.sun.org.apache.commons.beanutils.PropertyUtils;
/**
 * 测试类
 * @author ZCZ
 * @time 2014-1-23
 */
public class beanTest {
	public static void main(String args[]) {
		 
		 beanTest bt=new beanTest();
		 bean bn=new bean();
		 Object obj=bn;
		 
		 bt.test(obj);
	}
	
	public void test(Object obj) 
	 { 
	  PropertyDescriptor[] pd = PropertyUtils.getPropertyDescriptors(obj);	  
		  for (int i = 0; i < pd.length; i++) {	
			  String name = pd[i].getName();
			  System.out.println(name+":该属性的类型="+pd[i].getPropertyType()+"：是否实现了接口："+(pd[i].getPropertyType()).isInterface());
		    }
	  }
	}

运行测试类的输出结果是

boolean_:该属性的类型=boolean：是否实现了接口：false
class:该属性的类型=class java.lang.Class：是否实现了接口：false
date_:该属性的类型=class java.util.Date：是否实现了接口：false
double_:该属性的类型=double：是否实现了接口：false
float_:该属性的类型=float：是否实现了接口：false
int_:该属性的类型=int：是否实现了接口：false
list_:该属性的类型=interface java.util.List：是否实现了接口：true
long_:该属性的类型=long：是否实现了接口：false
map_:该属性的类型=interface java.util.Map：是否实现了接口：true
set_:该属性的类型=interface java.util.Set：是否实现了接口：true
string_:该属性的类型=class java.lang.String：是否实现了接口：false

由输出结果可以看出集合都是集合类都是以接口实现的，根据上述测试如果想要转化的实体类不超出上述测试类型，可以在进行转化json时先进性判断，是否需要转化集合类。即可解决上述问题。下面是我的json的工具类。在项目中只需要传入实体类即可返回json数据

public class JsonUtil {

	    /**
	     * 传入任意一个 object对象生成一个指定规格的字符串
	     * 
	     * @param object 任意对象
	     * @return String
	     */
	    public static String objectToJson(Object object) {
	        StringBuilder json = new StringBuilder();
	        if (object == null) {
	            json.append("\"\"");
	        } else if (object instanceof String || object instanceof Integer || object instanceof Double || object instanceof Long) {
	            json.append("\"").append(object.toString()).append("\"");
	        } else {
	            json.append(beanToJson(object));
	        }
	        return json.toString();
	    }

	    /**
	     * 传入任意一个 Javabean对象生成一个指定规格的字符串
	     * 
	     * @param bean bean对象
	     * @return String "{}"
	     */
	    public static String beanToJson(Object bean) {
	        StringBuilder json = new StringBuilder();
	        json.append("{");
	        PropertyDescriptor[] props = null;
	        try {
	            props = Introspector.getBeanInfo(bean.getClass(), Object.class).getPropertyDescriptors();
	        } catch (Exception e) {
	            e.printStackTrace();
	        }
	        if (props != null) {
	            for (int i = 0; i < props.length; i++) {
	                try {
	                	if(!(props[i].getPropertyType()).isInterface()){
		                    String name = objectToJson(props[i].getName());
		                    String value = objectToJson(props[i].getReadMethod().invoke(bean));
		                    json.append(name);
		                    json.append(":");
		                    json.append(value);
		                    json.append(",");
	                	}
	                } catch (Exception e) {
	                }
	            }
	            json.setCharAt(json.length() - 1, ‘}‘);
	        } else {
	            json.append("}");
	        }
	        return json.toString();
	    }

	    /**
	     * 通过传入一个列表对象,调用指定方法将列表中的数据生成一个JSON规格指定字符串
	     * 
	     * @param list 列表对象
	     * @return String "[{},{}]"
	     */
	    public static String listToJson(List<?> list) {
	        StringBuilder json = new StringBuilder();
	        json.append("[");
	        if (list != null && list.size() > 0) {
	            for (Object obj : list) {
	                json.append(objectToJson(obj));
	                json.append(",");
	            }
	            json.setCharAt(json.length() - 1, ‘]‘);
	        } else {
	            json.append("]");
	        }
	        return json.toString();
	    }
	
}