对普通对象的JSON封装

JSONWrapper作用：普通java对象--->JSON--->String

 普通java对象支持类型：1)基本类型 2)Date、BigDecimal 3)Map、Iterable 4)JSON本身类型

对自定义类，使用其toString()值。

/**
 * 
 * @author zfzheng
 */
public class JSONWrapper implements JSON{
 private static Log LOG = LogFactory.getLog(JSONWrapper.class);
 
 private JSON json=null;
 
 public JSONWrapper(Object ... arguments){
  json=convert2JSONObject(arguments);
 }
 
 private JSON convert2JSONObject(Object ... arguments){
  if(arguments.length==0){  
   //返回空array较符合用意
   return new JSONArray();//return null;
  }else if(arguments.length==1){
   Object obj=convert2JSONSupportedObject(arguments[0]);
   if(obj instanceof JSON){
    return (JSON)obj;
   }else{
    JSONArray array=new JSONArray();
    array.add(obj);
    return array;
   }
  }else{
   JSONArray array=new JSONArray();
   for(Object obj:arguments){
    array.add(convert2JSONSupportedObject(obj));
   }
   return array;
  }
 }
 
 @SuppressWarnings("unchecked")
 private Object convert2JSONSupportedObject(Object obj){
  if(obj==null){
   return JSONNull.getInstance();
  }else if(obj instanceof JSON){
   return (JSON)obj;
  }else if(obj.getClass().isArray()){
   return convert2JSONObject((Object[])obj);
  }else{
   //转换
   if(JSONUtils.isSupportSimpleType(obj.getClass())){
    return obj;
   }else if(obj instanceof Map){
    JSONObject jo=new JSONObject();
    Map m=(Map)obj;
    for(Object k:m.keySet()){
     jo.put(String.valueOf(k), convert2JSONSupportedObject(m.get(k)));
    }
    return jo;
   }else if(obj instanceof Iterable){
    JSONArray array=new JSONArray();
    Iterable iterable=(Iterable)obj;
    for(Iterator iter=iterable.iterator();iter.hasNext();){
     array.add(convert2JSONSupportedObject(iter.next()));
    }
    return array;
   }else{
    //未明确的支持，使用其toString值。
    return obj.toString();
   }   
  }
 }
 
 public String toString(){
  return String.valueOf(json);
 }

 public void write(Writer writer) throws IOException {
  if(json!=null){
   json.write(writer);
  }
 }
 
 public static void main(String[] args) {
  class A{
   private String name;
   public A(String name){
    this.name=name;
   }
   public String toString(){
    return name;
   }
  }
  Map<String,Object> m=new HashMap<String,Object>();
  m.put("KEY1", "11111111");
  m.put("KEY2", "22222222");
  List<Integer> list=new ArrayList<Integer>();
  list.add(1);
  list.add(2);
  m.put("LIST", list);
  m.put("DEFAULT", new A("aaaaa"));
  System.out.println(new JSONWrapper("vv",m,null,"[]{},'//"///:"));
  System.out.println(new JSONWrapper());
 }
}

执行输出

["vv",{"DEFAULT":"aaaaa","KEY1":"11111111","KEY2":"22222222","LIST":[1,2]},"null","[]{},'//"///:"]
[]

JSONUtils

 

public   class  JSONUtils  ... {
 private static final class InternalResource ...{
  private static Pattern FUNCTION_HEADER_MATCHER;
  private static final String FUNCTION_HEADER_PATTERN = "^function[ ]?/(.*/)$";
  private static Pattern FUNCTION_MACTHER;
  private static Pattern FUNCTION_PARAMS_MATCHER;
  private static final String FUNCTION_PARAMS_PATTERN = "^function[ ]?/((.*?)/)$";
  private static final String FUNCTION_PATTERN = "^function[ ]?/(.*/)[ ]?/{.*/}$";

  public static final Set<Class<?>> supportTypes;
  static ...{
   supportTypes = new HashSet<Class<?>>();
   supportTypes.add(Character.class);
   supportTypes.add(Byte.class);
   supportTypes.add(Short.class);
   supportTypes.add(Integer.class);
   supportTypes.add(Long.class);
   supportTypes.add(Date.class);
   supportTypes.add(java.sql.Date.class);
   supportTypes.add(BigInteger.class);
   supportTypes.add(BigDecimal.class);
   supportTypes.add(String.class);
   supportTypes.add(Boolean.class);

   supportTypes.add(JSONArray.class);
   supportTypes.add(JSONNull.class);
   supportTypes.add(JSONObject.class);
   supportTypes.add(JSONFunction.class);

   FUNCTION_HEADER_MATCHER = Pattern.compile(FUNCTION_HEADER_PATTERN);
   FUNCTION_PARAMS_MATCHER = Pattern.compile(FUNCTION_PARAMS_PATTERN);
   FUNCTION_MACTHER = Pattern.compile(FUNCTION_PATTERN);
  }
 }

 public static boolean isSupportSimpleType(Class<?> type) ...{
  return InternalResource.supportTypes.contains(type);
 }

 /** *//**
  * 将字符串转换为JSON对象
  */
 public static JSON parse(String source) ...{
  if (source == null) return JSONNull.getInstance();
  source = source.trim();
  if (source.length() == 0) return JSONNull.getInstance();

  JSONTokener tokener = new JSONTokener(source);
  char firstToken = tokener.nextClean();

  if (firstToken == '{') ...{
   tokener.back();
   return new JSONObject(tokener);
  }

  if (firstToken == '[') ...{
   tokener.back();
   return new JSONArray(tokener);
  }

  if ("null".equals(source.trim())) ...{
   return JSONNull.getInstance();
  }

  throw new JSONException("syntax error. source : " + source + "");
 }

 /** *//**
  * 对象转换为JSON字符串
  */
 public static String toJSONString(Date date) ...{
  if (date == null) return "null";

  // return ""//Date(" + date.getTime() + ")//"";
  return "new Date(" + date.getTime() + ")";
 }

 /** *//**
  * 对象转换为JSON字符串
  * 
  * @param date
  * @return
  */
 public static String toJSONString(JSON json) ...{
  if (json == null) return "null";

  return json.toString();
 }

 /** *//**
  * 如果是日期格式，则转为日期，否则返回原值
  */
 public static Object parseDateIfMatch(String value) ...{
  if (value == null) return null;

  int len = value.length();

  if (len <= 11) return value;

  if (value.startsWith("new Date(") && value.endsWith(")")) ...{
   String tmp = value.substring(9, len - 1);
   long millis = Long.parseLong(tmp);

   return new Date(millis);
  }

  if (value.startsWith("//Date(") && value.endsWith(")//")) ...{
   String tmp = value.substring(7, len - 3);
   long millis = Long.parseLong(tmp);

   return new Date(millis);
  }

  return value;
 }

 public static boolean isFunctionHeader(Object obj) ...{
  if (obj instanceof String) ...{
   String str = (String) obj;
   return InternalResource.FUNCTION_HEADER_MATCHER.matcher(str).matches();
  }
  return false;
 }

 public static String getFunctionParams(String function) ...{
  Matcher matcher = InternalResource.FUNCTION_PARAMS_MATCHER.matcher(function);
  if (matcher.matches()) ...{
   return matcher.group(1);
  }
  return "";
 }

 public static boolean isFunction(Object obj) ...{
  if (obj instanceof String) ...{
   String str = (String) obj;
   return InternalResource.FUNCTION_MACTHER.matcher(str).matches();
  }
  if (obj instanceof JSONFunction) ...{
   return true;
  }
  return false;
 }