json-lib反序列化抽象属性及对象

使用json默认反序列化接口反序列化对象时，对象的类型必须的确定的，比如不能是抽象类型，否则会报无法实例化对象的异常

如有下列类定义：

 public abstract class AbstracObj {

     private String propCommmon;

     public String getPropCommmon() {
         return propCommmon;
     }

     public void setPropCommmon(String propCommmon) {
         this.propCommmon = propCommmon;
     }

 }

AbstracObj

 public class ObjectA extends AbstracObj{

     private String propA;

     public String getPropA() {
         return propA;
     }

     public void setPropA(String propA) {
         this.propA = propA;
     }

 }

ObjectA

 public class ObjectB extends AbstracObj{

     private String propB;

     public String getPropB() {
         return propB;
     }

     public void setPropB(String propB) {
         this.propB = propB;
     }

 }

ObjectB

 import net.sf.json.JSONObject;

 public class TestJsonObj {

     private String jsonProp;

     private AbstracObj absProp;

     public String getJsonProp() {
         return jsonProp;
     }

     public void setJsonProp(String jsonProp) {
         this.jsonProp = jsonProp;
     }

     public AbstracObj getAbsProp() {
         return absProp;
     }

     public void setAbsProp(AbstracObj absProp) {
         this.absProp = absProp;
     }

     public static void main(String[] args) {
         TestJsonObj tb = new TestJsonObj();
         tb.setJsonProp("aaaa");
         ObjectA oa = new ObjectA();
         oa.setPropCommmon("common");
         oa.setPropA("propA");
         tb.setAbsProp(oa);
         JSONObject jsonObject = JSONObject.fromObject(tb);
         jsonObject.toBean(jsonObject, TestJsonObj.class);
     }
 }

TestJsonObj

TestJsonObj无法反序列化，因为它有一个抽象属性absProp。

可以通过增加标志抽象对象的类型属性及重载json-lib反序列化的接口实现。

定义接口Jsonable，让对象实现这个接口：

 public class ObjectA extends AbstracObj implements Jsonable {

     private String propA;

     public String getPropA() {
         return propA;
     }

     public void setPropA(String propA) {
         this.propA = propA;
     }

     @Override
     public Class<?> getClazz() {
         return ObjectA.class;
     }

 }

ObjectA

 public class ObjectB extends AbstracObj implements Jsonable {

     private String propB;

     public String getPropB() {
         return propB;
     }

     public void setPropB(String propB) {
         this.propB = propB;
     }

     @Override
     public Class<?> getClazz() {
         return ObjectB.class;
     }

 }

ObjectB

 package com.mucfc.mpf.utils;

 import java.lang.reflect.Array;
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Modifier;
 import java.util.List;

 import net.sf.json.JSONArray;
 import net.sf.json.JSONObject;
 import net.sf.json.JsonConfig;
 import net.sf.json.util.JSONTokener;
 import net.sf.json.util.NewBeanInstanceStrategy;

 import com.lz.lsf.exception.ServiceException;
 import com.lz.lsf.exception.SystemException;
 import com.mucfc.mpf.common.exception.MpfErrorCode;

 /**
  * json序列化反序列化帮助类
  *
  * @author hebeisheng
  * @Since 2015/7/1
  *
  */
 public class JsonUtil {

     private static JsonConfig unserializableConfig = new JsonConfig();

     static {
         // 设置类初始化策略，过滤抽象类
         unserializableConfig.setNewBeanInstanceStrategy(new NewBeanInstanceStrategy() {

             @Override
             public Object newInstance(Class c, JSONObject jo) throws InstantiationException, IllegalAccessException,
                     SecurityException, NoSuchMethodException, InvocationTargetException {
                 // 是否为抽象类
                 if (Modifier.isAbstract(c.getModifiers())) {
                     try {
                         // 返回类
                         return Class.forName(jo.getString("clazz")).newInstance();
                     }
                     catch (Exception e) {
                         e.printStackTrace();
                     }
                 }
                 return c.newInstance();
             }
         });
     }

     /**
      * 将对象转成Json字符串
      *
      * @param object
      *            对象
      * @return 返回 Json字符串
      */
     public static String toJson(Object object) {
         if (List.class.isAssignableFrom(object.getClass())) {
             JSONArray array = JSONArray.fromObject(object);
             return array.toString();
         }
         JSONObject jsonObject = JSONObject.fromObject(object);
         return jsonObject.toString();
     }

     /**
      * 将json字符串反序列化成对象.</p>
      *
      * 如果传下来classType的值，则反序列了classType，如果没有传，则json串中必须含有clazz属性，指定json串要反序列化的类型。
      *
      * @param json
      *            json字符串
      * @return 返回对象
      */
     public static Object toObject(String json, Class<?> classType) throws ServiceException {
         Object jsonObj = new JSONTokener(json).nextValue();
         JsonConfig jsonConfig = unserializableConfig.copy();

         //JSONArray和JSONObject不兼容，所以要先判断类型
         if (jsonObj instanceof JSONArray) {
             ArgumentChecker.notNull("classType", classType);
             jsonConfig.setRootClass(classType);
             JSONArray jsonArray = (JSONArray) jsonObj;
             if (Array.class.isAssignableFrom(classType)) {
                 return JSONArray.toArray(jsonArray, jsonConfig);
             }
             return JSONArray.toCollection(jsonArray, jsonConfig);
         }

         JSONObject jsonObject = (JSONObject) jsonObj;
         Class<?> clazz = classType;
         if (classType != null) {
             clazz = classType;
         }
         else {
             String clazzName = jsonObject.getString("clazz");
             try {
                 clazz = Class.forName(clazzName);
             }
             catch (ClassNotFoundException e) {
                 throw new SystemException(MpfErrorCode.SYSTEM_ERROR, "实例化" + clazzName + "失败");
             }
         }
         jsonConfig.setRootClass(clazz);
         return JSONObject.toBean(jsonObject, jsonConfig);
     }
 }

TestJsonObj

ObjectA和ObjectB实现getClazz接口，返回了自己的Class类型。

这时将TestJsonObj序列化后看到absProp增加了clazz属性：

{
    "absProp": {
        "clazz": "ObjectA",
        "propA": "propA",
        "propCommmon": "common"
    },
    "jsonProp": "aaaa"
}

Json串

反序列化时实例化clazz类型就可以了，见JsonConfig的配置。