java 中对继承实现类的一次重构-CSDN博客

因为是最近才开始学习的java，虽然一直在思考继承和组合的优劣问题，但因为c++开发时间比较长，对这方面的考虑没有太清楚，导致前段时间写的几个通用类使用了继承方式实现，后面发现，调整版本的时候带来了不好问题；

因为使用的dubbo的服务，服务实现与调用是分开实现的，但实现方的实体结构变化也比较多，主要是数据库设计的问题，另外就是对业务还不是很清楚；这里真想感叹一句，传统公司做IT，需求变更还真是频繁。综合考虑还是使用两个继承JSONObject的类JSONRequest, JSONResponse,都是继承自JSONObject，前期人少，JAVA又没有么私有继承，后面人多，这个两个对象就用得比较随意，导致接口数据就五花八门，现在来想，一开始就不应该使用继承的；

新的JSONResquest使用了组合，使用起来和原来是一样的，因为中间出现了一些不规范的调用，花费了一些时间调整，基本定稿：

package com.etong.frame.service;

import java.io.Serializable;
import java.util.Map;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;

public class JSONRequest implements Serializable {
public static final JSONRequest EMPTY = new JSONRequest();

private static final long serialVersionUID = 2L;
private JSONObject dataJson = new JSONObject();

public JSONRequest() {
}

public JSONRequest(String text) {
from(JSON.parseObject(text));
}

public <T> JSONRequest(String key, T value) {
put(key, value);
}

public JSONRequest(Map<? extends String, ? extends Object> data) {
putAll(data);
}

public <T> JSONRequest(T data) {
putAll((JSONObject) JSON.toJSON(data));
}

public void put(String key, Object value) {
this.dataJson.put(key, value);
}

public void putAll(Map<? extends String, ? extends Object> data) {
this.dataJson.putAll(data);
}

public boolean containsKey(String key) {
return dataJson.containsKey(key);
}

public <T> T get(String key, Class<T> clazz) {
return dataJson.getObject(key, clazz);
}

public Integer getInteger(String key) {
return dataJson.getInteger(key);
}

public int getIntValue(String key) {
return dataJson.getIntValue(key);
}

public String getString(String key) {
return dataJson.getString(key);
}

public Boolean getBoolean(String key) {
return dataJson.getBoolean(key);
}

public boolean getBooleanValue(String key) {
return dataJson.getBooleanValue(key);
}

public Double getDouble(String key) {
return dataJson.getDouble(key);
}

public double getDoubleValue(String key) {
return dataJson.getDoubleValue(key);
}

public Float getFloat(String key) {
return dataJson.getFloat(key);
}

public float getFloatValue(String key) {
return dataJson.getFloatValue(key);
}

public <T> T to(Class<T> clazz) {
return JSON.toJavaObject(dataJson, clazz);
}

public void from(String text) {
putAll(JSON.parseObject(text));
}

public void from(Map<String, ?> map) {
putAll(map);
}

public JSONObject toJSONObject() {
return dataJson;
}

public String toString() {
return dataJson.toJSONString();
}

public String toJSONString() {
return dataJson.toJSONString();
}

public JSONObject getJSONObject(String key) {
return dataJson.getJSONObject(key);
}

public JSONArray getJSONArray(String key) {
return dataJson.getJSONArray(key);
}
}

JSONResponse 的重构没那么顺利，主要是因为在webservice层，FastJsonMessageConvertor把dataJson直接转换成了jSONObject这个字段，最后还只能重写这个类，悲剧。

(这是个悲剧，原来我提供了getJSONObject这个方法，导致它在序列化时，将这个对象序列化成了jSONObject，原来以为它会调用toString方法，结果发现没有调用，@@，理解有误)

package com.etong.frame.service;

import java.io.Serializable;
import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.etong.frame.util.GlobalConfig;
import com.etong.frame.util.KeyConst;

public class JSONResponse implements Serializable {

private static final long serialVersionUID = 1L;

Integer code;
String toast, msg;

JSONObject dataJson = new JSONObject();

private static final Integer SUCCEED = 0;
private static final String MSG_SUCCEED = "succeed";
private static final String TOAST_SUCCEED = "操作成功";

private String getToast(int err) {
return GlobalConfig.getErrToast(err);
}

public JSONResponse() {
this.code = SUCCEED;
this.msg = MSG_SUCCEED;
this.toast = TOAST_SUCCEED;
}

public <T> JSONResponse(T data) {
this();
put(data);
}

public JSONResponse(int error, String msg) {
this.error(error, msg);
}

public void error(int code, String msg) {
String toast = getToast(code);
this.code = code;
this.toast = toast;
this.msg = msg;
}

/**
* @Title : getJSONObject
* @Description : 返回一个JSONObject
* @params
* @return 设定文件
* @return JSONObject 返回类型
* @throws
*/
public JSONObject getJSONObject() {
return dataJson;
}

/**
* @Title : get
* @Description : 将数据部分转换成一个java对象
* @params
* @param clazz
* @return 设定文件
* @return T 返回类型
* @throws
*/
public <T> T get(Class<T> clazz) {
return JSON.toJavaObject(dataJson, clazz);
}

public <T> T get(String key, Class<T> clazz) {
return dataJson.getObject(key, clazz);
}

/**
* @Title : clear
* @Description : 清空已添加的数据
* @params 设定文件
* @return void 返回类型
* @throws
*/
public void clear() {
dataJson.clear();
}

/**
* @Title : put
* @Description : 添加数据,将会清空已有数据
* @params
* @param data
* 设定文件
* @return void 返回类型
* @throws
*/
public <T> void put(T data) {
clear();
append(data);
}

public <T> void put(String key, T data) {
clear();
append(key, data);
}

/**
* @Title : append
* @Description : 在data节点下添加一个子节点
* @params
* @param key
* @param data
* 设定文件
* @return void 返回类型
* @throws
*/

public <T> void append(T data) {
Object obj = JSON.toJSON(data);
if (data instanceof Array || data instanceof List) {
dataJson.put("array", obj);
} else {
dataJson.putAll((JSONObject) obj);
}
}

public <T> void append(String key, T data) {

if (data instanceof Serializable) {
if (data instanceof Collection) {
dataJson.put(key, JSON.toJSON(data));
} else {
dataJson.put(key, data);
}
} else {
dataJson.put(key, JSON.toJSON(data));
}
}

/**
* @Title : getList
* @Description : 返回一个java列表
* @params
* @param key
* @param clazz
* @return 设定文件
* @return List<T> 返回类型
* @throws
*/
public <T> List<T> getList(String key, Class<T> clazz) {
List<T> dataList = new ArrayList<T>();
JSONArray array = dataJson.getJSONArray(key);
for (Object o : array) {
T obj = JSON.toJavaObject((JSON) o, clazz);
dataList.add(obj);
}
return dataList;
}

/**
* @Title : getJSONArray
* @Description : 返回JSON数据组
* @params
* @param key
* @return 设定文件
* @return JSONArray 返回类型
* @throws
*/
public JSONArray getJSONArray(String key) {
return dataJson.getJSONArray(key);
}

public Integer getCode() {
return this.code;
}

public String getMsg() {
return this.msg;
}

public String getToast() {
return this.toast;
}

public String toJSONString() {
JSONObject obj = new JSONObject();
obj.put(KeyConst.KEY_DATA, dataJson);
obj.put(KeyConst.KEY_CODE, code);
obj.put(KeyConst.KEY_MSG, msg);
obj.put(KeyConst.KEY_TOAST, toast);
return obj.toJSONString();
}

public String toString() {
return toJSONString();
}

public boolean succeed() {
return SUCCEED.equals(this.code);
}
}

转载于:https://www.cnblogs.com/the7year/p/5330657.html