java jsonstr写入文件 java写json对象

自己写的一段解析的代码:

解析后的字符效果：

{'Student':{id:1,string:'这是一个人',address:'长沙',{'Human':{id:1,type:'黄种人',{'Product':{id:1,name:'IPHONE5',description:'产品的描述信息',img:'图片',stock:12,bidPrice:12.0,price:3000.0,null,null,supplier:'美国',addTime:'1970-01-01 08:00:00.1'}}}
{'list':{'Student':{id:1,string:'这是一个人',address:'长沙',{'Human':{id:1,type:'黄种人',{'Product':{id:1,name:'IPHONE5',description:'产品的描述信息',img:'图片',stock:12,bidPrice:12.0,price:3000.0,null,null,supplier:'美国',addTime:'1970-01-01 08:00:00.1'}}},{'Human':{id:1,type:'黄种人',{'Product':{id:1,name:'IPHONE5',description:'产品的描述信息',img:'图片',stock:12,bidPrice:12.0,price:3000.0,null,null,supplier:'美国',addTime:'1970-01-01 08:00:00.1'}}

不过对象的字段有多少个子对象可以解析，用了递归进行解析。

在调用此类进行解析的时候，Bean 的字段请全部使用包装类，否则会出现异常。

代码部分：

主要解析代码：

BeanUtil.java

package org.dreamer.data.util;

import java.lang.reflect.Field;

/**
 * 返回该对象的所有字段值
 * @author Pan
 *
 */
public class BeanUtil {

	/**
	 * 返回当前对象的字符串
	 */
	public String toString() {
		
		return getString(this);
	}

	/**
	 * 返回指定对象的字符串
	 * @param object
	 * @return
	 */
	public String getString(Object object){
		
		if(object==null)
			return "null";
		
		String str = "";
		
		str+="{'"+object.getClass().getSimpleName()+"':{";
		
		Class cl = object.getClass();
		Field[] fields = cl.getDeclaredFields();
		boolean sign = true;
		String s = ",";
		for (Field field : fields) {
			field.setAccessible(true);	//设置成可访问的
			
			//判断字段是不是对象
		
			
			if (sign) {
				s = "";
				sign = false;
			} else {
				s = ",";
			}
			try {
				
				TypeCollection types=new TypeCollection();
				boolean result=types.check(field.get(object));
				
				//如果不是基础类型就用递归求出所有的子对象
				if(!result){
					str+=s+getString(field.get(object));
					continue;
				}
				
				Object value=JSONHelper.check(field.get(object))?"'"+field.get(object)+"'":field.get(object);
				
				str += s + field.getName() + ":" + value;
			} catch (Exception e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		str+="}";
		return str;
	}
}

Json助手类：

JSONHelper.java

package org.dreamer.data.util;

import java.sql.Timestamp;

public class JSONHelper {
	
	/**
	 * 检查是否是String和Timestamp类型
	 * @param object
	 * @return
	 */
	public static boolean check(Object object){
		return object instanceof String || object instanceof Timestamp;
	}
}

JSONSupport.java

调用的话就调用这个类，这个类可以解析对象，和对象数组

package org.dreamer.data.json;

import java.util.Collection;

import org.dreamer.data.util.BeanUtil;

/**
 * JSON 解析对象
 * 在解析对象的时候，如果发现对象的字段类型不是基础类型
 * 那么将调用递归进行循环解析
 * @author Pan
 *
 */
public class JSONSupport {

	/**
	 * 将对象解析成JSON字符串
	 * @param object
	 * @return
	 */
	public static String parseString(Object object){
		
		//检查对象是否继承了BeanUtil类
		String superClass=object.getClass().getSuperclass().getCanonicalName();
		BeanUtil beanUtil=new BeanUtil();
		
		//如果检测到对象已经继承了BeanUtil类，那么将直接调用对象的toString方法
		//BeanUtil 已经对之类的toString进行重新
		//所以无需进行重复的操作
		if(beanUtil.getClass().getCanonicalName().equals(superClass)){
			return object.toString();
		}
		
		return beanUtil.getString(object);
	}
	
	/**
	 * 解析一个集合对象
	 * @param collection
	 * @return
	 */
	public static String parseCollection(Collection collection){
		
		
		
		String str="{'list':";
		boolean sign=true;
		String charStr=",";
		for (Object object : collection) {
			if(sign){
				charStr="";
				sign=false;
			}else {
				charStr=",";
			}
			str+=charStr+parseString(object);
		}
		return str+="";
	}
}

TypeCollection.java 这一个类非常的重要 因为要判断解析的对象是不是基本类型，如果是基本的一些数据类型 就不进行解析。

package org.dreamer.data.util;

import java.lang.reflect.Field;
import java.sql.Timestamp;
/**
 * 基础类型集合
 * @author Pan
 *
 */
public class TypeCollection {

	/**
	 * 基础数据类型的包装类
	 */
	private Integer integer;
	private Double double1;
	private Float float1;
	private Long long1;
	private String string;
	private Character character;
	private Boolean boolean1;
	private Short short1;
	private Timestamp timestamp;

	/**
	 * 检查该对象是不是基础数据类型
	 * @param object
	 * @return
	 */
	public boolean check(Object object) {

		if(object==null)
			return false;
		
		// 获取当前类的Class对象的字段集合
		Field[] fields = this.getClass().getDeclaredFields();
		for (Field field : fields) {
			// 设置字段可访问
			field.setAccessible(true);

			// 获取字段类型来比较
			if (field.getType().getName().equals(object.getClass().getName())) {
				return true;
			}

		}
		return false;
	}
}

非常容易就解析成JSON了，比起网上臃肿的插件，这方便了少许。

下面给一段我测试的代码：

请勿直接运行，会报错。

package com.domain;

import java.sql.Timestamp;
import java.util.ArrayList;
import java.util.List;

import org.dreamer.data.json.JSONSupport;
import org.dreamer.data.util.BeanUtil;
import org.dreamer.data.util.TypeCollection;

import com.pan.action.Product;
import com.pan.beans.User;

public class JSONTest {

	public static void main(String[] args) throws Exception {
		
		
		Student student=new Student();
		student.setAddress("长沙");
		
		Product product=new Product();
		product.setAddTime(new Timestamp(100));
		product.setBidPrice(12d);
		product.setDescription("产品的描述信息");
		product.setId(1);
		product.setImg("图片");
		product.setName("IPHONE5");
		product.setPrice(3000d);
		product.setStock(12);
		product.setSupplier("美国");
		Human human=new Human();
		human.setProduct(product);
		human.setId(1);
		human.setType("黄种人");
		
		student.setHuman(human);
		student.setId(1);
		student.setString("这是一个人");
		
		System.out.println(student.getClass().getSuperclass().getCanonicalName());
		List list=new ArrayList();
					
			list.add(student);
			list.add(human);
		
		System.out.println(student);
		System.out.println(JSONSupport.parseCollection(list));
	}
}