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

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

如有下列类定义：

public abstract class AbstracObj {

    private String propCommmon;

    public String getPropCommmon() {
        return propCommmon;
    }

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

}

public class ObjectA extends AbstracObj{

    private String propA;

    public String getPropA() {
        return propA;
    }

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

}

public class ObjectB extends AbstracObj{

    private String propB;

    public String getPropB() {
        return propB;
    }

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

}

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无法反序列化，因为它有一个抽象属性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;
    }

}

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;
    }

}

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);
    }
}

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

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

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

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