JSONObject 保存和传送 数组数据 ,如int[] ,double[] ,String[]...

本文详细介绍了如何使用Java中的JSONObject和JSONArray进行数据转换,并利用Gson库简化JSON数据的解析过程,包括对象到JSON字符串的转换及从JSON字符串中读取对象。

上图为转换后的显示效果。下面介绍如何转换

public class MainActivity extends Activity {

	private TextView show;

	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.activity_main);
		show = (TextView) findViewById(R.id.show);
		jsonSendArray();

	}
	
	/**
	 * 用json发送数据 如int [] ,double[] ,String [] ....
	 * 这里是封装并发送 ,方法略显笨拙
	 */
	public void jsonSendArray(){
		int [] dou={1,2,3,4,5,6,7,8,9,0};
		JSONObject clientKey = new JSONObject(); 
		JSONArray jsonArray = new JSONArray(); //保存数组数据的JSONArray对象
		for(int i = 0 ; i < dou.length ;i++){  //依次将数组元素添加进JSONArray对象中
			jsonArray.put(dou[i]);
//          两种添加方式一样			
//			try {
//				jsonArray.put(i, dou[i]);
//			} catch (JSONException e) {
//				// TODO Auto-generated catch block
//				e.printStackTrace();
//			}
      		}
		
		try {
			clientKey.put("intArray", jsonArray);//jsonArray相当于int数组
	        show.setText(clientKey.toString());   //输出测试
	      
		} catch (JSONException e) {
			e.printStackTrace();
		}
	}
}
下面介绍一些JSONObject 和JSONArray的一些基础用法

     

/**
	 * 一组数据转换成json
	 * */
		public  void string2json(){
			   String str="{\"name\":\"Iyangc\",\"age\":21,\"sex\":'男',\"address\":{\"province\":\"四川\",\"city\":\"成都\"}}";
			   try {
				JSONObject jsonObject = new JSONObject(str);
				String name = jsonObject.getString("name");
				JSONObject address = jsonObject.getJSONObject("address");
				String province = address.getString("province");
				int age = jsonObject.getInt("age"); 
				 show.setText("name: "+name+"\nprovince: "+province+"\nage: "+age);
			   } catch (JSONException e) {
				e.printStackTrace();
			} 
		}
		/**
		 * 数组数据转换json
		 * */
		public  void json2String(){
			 String str= "[{\"name\":\"张一\",\"age\":22,\"address\":" +
						"{\"province\":\"四川\",\"city\":\"成都\",\"details\":\"光明街16号\"}}," +
						"{\"name\":\"张二\",\"age\":23,\"address\":" +
						"{\"province\":\"四川\",\"city\":\"成都\",\"details\":\"建设路5号\"}}," +
						"{\"name\":\"张三\",\"age\":23,\"address\":" +
						"{\"province\":\"四川\",\"city\":\"成都\",\"details\":\"中山南路8号\"}}]";
		   try {
			JSONArray jsonArray = new  JSONArray(str); //将String转换成JsonArray对象
			      int length=jsonArray.length();
			      //取出数据
			 for (int i = 0; i < length; i++) {
				 JSONObject jsonObject = jsonArray.getJSONObject(i);
				 String name = jsonObject.getString("name");
				 JSONObject jsonObject2 = jsonObject.getJSONObject("address");
				 String province = jsonObject2.getString("province");
				 System.out.println(name+"-----------"+province);
			}
		} catch (JSONException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} 
		}
		
		/**
		 * 以键值对写入json
		 * */
		public static void jsonArray2String(){
			JSONArray jsonArray = new  JSONArray();
			JSONObject jsonObject1= new  JSONObject();
			JSONObject jsonObject2= new  JSONObject();
			JSONObject jsonObject3= new  JSONObject();
			try {
				jsonObject1 .put("name","Iyangc");
				jsonObject1 .put("age",21);
				JSONObject addressObject1 = new  JSONObject();
				addressObject1.put("province", "四川");
				jsonObject1.put("address",addressObject1 );
				
				
				jsonObject2 .put("name","ILan");
				jsonObject2 .put("age",22);
				JSONObject addressObject2 = new  JSONObject();
				addressObject2.put("province", "四川简阳");
				jsonObject2.put("address",addressObject2 );
				
				
				jsonObject3 .put("name","IBo");
				jsonObject3 .put("age",21);
				JSONObject addressObject3 = new  JSONObject();
				addressObject3.put("province", "四川石桥");
				jsonObject3.put("address",addressObject3 );
				
				jsonArray.put(jsonObject1);
				jsonArray.put(jsonObject2);
				jsonArray.put(jsonObject3);
				
				//打印输出转换成json格式后的String字符串
				String string = jsonArray.toString();
				System.out.println(string );
				
			} catch (JSONException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			
		}
    就单独用JSON的话 解析起来会显得很麻烦 所以一般要和Gson一起使用。 Gson可以直接将Json类型的字符串转换成类对象,并且对象的属性值与Json的属性值相对应。Gson的一个免费下载地址:http://download.youkuaiyun.com/detail/a771948524/6668573

下载后 将其jar包导入工程就可以使用了。下面是Gson的一些基本用法:

 

public class GsonDemo extends Activity {
	Ure ure1;
	Ure ure2;
	Ure ure3;
	ArrayList<Ure> ures;
	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.gson_demo);
		ures=new ArrayList<Ure>();
		ure1=new Ure("Iyangc",21);
		ure2=new Ure("Iyang",22);
		ure3=new Ure("Iyan",23);
		ures.add(ure1);
		ures.add(ure2);
		ures.add(ure3);
//		strToJson();
//		 listToJson();
//		 strFromJson();
		 listFromJson();
	}
	
	/**
	 * 通过Gson将bean转化成JSON数据
	 * */
	public void  strToJson(){
         Gson g=new Gson();
          //通过Gson.toJson将bean转成Json对象
         String json = g.toJson(ure1);
		   System.out.println(json );
	}
	/**
	 * 通过Gson.toJson将bean集合转成Json对象
	 * */
	public void  listToJson(){
		Gson g=new Gson();
		//通过Gson.toJson将bean集合转成Json对象
		String json = g.toJson(ures);
		System.out.println(json );
	}
	/**
	 * 将JSON格式的数据解析出来~~
	 * */
	public void  strFromJson(){
		Ure ure=new Ure();
		Gson g=new Gson();
		String str="{\"name\":\"ILan\",\"age\":22}";
//			JSONObject json=new JSONObject(str);
			ure=g.fromJson(str, Ure.class);
			System.out.println(ure.name+" ======= "+ure.age);
	}
	/**
	 * 将JSON格式的数据(集合)解析出来~~
	 * */
	public void  listFromJson(){
		Gson g=new Gson();
		String str="[{\"name\":\"ILan1\",\"age\":221},{\"name\":\"ILan2\",\"age\":222}]";
//			JSONObject json=new JSONObject(str);
      	           	 Type type = new  TypeToken<List<Ure>>(){  }.getType();
      	           	 //将JSON集合数据解析出来
      	           List<Ure> l=g.fromJson(str,type);
		       for (Ure ure : l) {
		    	   System.out.println(ure.name+" ======= "+ure.age);
			}
	}
}
class Ure{
	public String name;
	public int age;  
	public Ure(String name, int age) {
		this.name = name;
		this.age = age;
	}
	public Ure() {
	}
}

在JSONObject 传送数组时 可以直接在bean类中定义一个数组 ,只要属性名对应且类型对应 用Gson可直接转换出来,就和基本类型一样。
  如果 Ure类中多一个 double[]  数组对象dou, 而且json中有对应数据   那么用Gson将json转换成use对象后 直接 use.dou就能获取这个数组数据。

Demo下载地址: http://download.youkuaiyun.com/detail/yangbo437993234/7626045   不懂的可以下来看看 都是很基础的



我把全链路发给你:发送端:package com.ceprei.rcm.util; import com.alibaba.fastjson.JSONObject; import jnpf.util.wxutil.HttpUtil; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import util.PointData; import java.sql.Timestamp; import java.util.*; import java.util.stream.Collectors; import java.util.stream.IntStream; /** * HC-DB数据库接口访问工具类(带重载方法) */ public class HcdbApiUtil { private static final Logger log = LoggerFactory.getLogger(HcdbApiUtil.class); // HC-DB服务器地址配置 // private static final String HCDB_BASE_URL = "http://10.21.8.190:8001"; private static final String HCDB_BASE_URL = "http://127.0.0.1:8001"; // 接口路径 private static final String LATEST_DATA_URL = HCDB_BASE_URL + "/hcdb/data/consume/latest"; private static final String HISTORY_DATA_URL = HCDB_BASE_URL + "/hcdb/data/consume"; // 默认参数值 private static final Integer DEFAULT_RETURN_POINT_LIST = 0; // 默认不返回测点编码列表 private static final Integer DEFAULT_INTERVAL = 1; // 默认采样间隔1秒 private HcdbApiUtil() { throw new IllegalAccessError("工具类不能实例化"); } // ==================== 实时数据查询方法重载 ==================== /** * 获取实时数据(最简版本,只传测点编码列表) * @param pointList 测点编码列表 * @return 响应结果 */ public static JSONObject getLatestData(List<String> pointList) { return getLatestData(pointList, DEFAULT_RETURN_POINT_LIST); } /** * 获取实时数据(完整参数) * @param pointList 测点编码列表 * @param returnPointList 是否返回测点编码列表 (1:返回, 其他:不返回) * @return 响应结果 * 返回值格式:{ * "msg": "success", * "code": 200, * "content": { * "dataList": [1.5, 2.5], * "pointList": ["W3.UNIT1.GROSS_MW", "W3.UNIT2.GROSS_MW"] * } * } */ public static JSONObject getLatestData(List<String> pointList, Integer returnPointList) { try { // 构建请求体 JSONObject requestBody = new JSONObject(); requestBody.put("pointList", pointList); if (returnPointList != null) { requestBody.put("returnPointList", returnPointList); } // 发送POST请求 String response = HttpUtil.sendHttpPost(LATEST_DATA_URL, requestBody.toJSONString()); if (response == null || response.trim().isEmpty()) { log.error("获取实时数据失败: 响应为空"); return createErrorResponse(500, "响应为空"); } return JSONObject.parseObject(response); } catch (Exception e) { log.error("获取实时数据异常", e); return createErrorResponse(500, "请求异常: " + e.getMessage()); } } /** * 获取实时数据(字符串数组版本) * @param points 测点数组 * @return 响应结果 */ public static JSONObject getLatestData(String... points) { return getLatestData(Arrays.asList(points), DEFAULT_RETURN_POINT_LIST); } /** * 获取实时数据(字符串数组版本,带返回测点编码列表选项) * @param returnPointList 是否返回测点编码列表 * @param points 测点数组 * @return 响应结果 */ public static JSONObject getLatestData(Integer returnPointList, String... points) { return getLatestData(Arrays.asList(points), returnPointList); } // ==================== 历史数据查询方法重载 ==================== /** * 获取历史数据(最简版本,只传测点编码列表起止时间) * @param pointList 测点编码列表 * @param startTime 开始时间 * @param stopTime 结束时间 * @return 响应结果 */ public static JSONObject getHistoryData(List<String> pointList, String startTime, String stopTime) { return getHistoryData(pointList, startTime, stopTime, DEFAULT_INTERVAL, DEFAULT_RETURN_POINT_LIST); } /** * 获取历史数据(带间隔参数) * @param pointList 测点编码列表 * @param startTime 开始时间 * @param stopTime 结束时间 * @param interval 采样间隔(秒) * @return 响应结果 */ public static JSONObject getHistoryData(List<String> pointList, String startTime, String stopTime, Integer interval) { return getHistoryData(pointList, startTime, stopTime, interval, DEFAULT_RETURN_POINT_LIST); } /** * 获取历史数据(完整参数) * @param pointList 测点编码列表 * @param startTime 开始时间 * @param stopTime 结束时间 * @param interval 采样间隔(秒) * @param returnPointList 是否返回测点编码列表 (1:返回, 其他:不返回) * @return 响应结果 */ public static JSONObject getHistoryData(List<String> pointList, String startTime, String stopTime, Integer interval, Integer returnPointList) { try { // 构建请求体 JSONObject requestBody = new JSONObject(); requestBody.put("pointList", pointList); requestBody.put("startTime", startTime); requestBody.put("stopTime", stopTime); requestBody.put("interval", interval); if (returnPointList != null) { requestBody.put("returnPointList", returnPointList); } // 发送POST请求 String response = HttpUtil.sendHttpPost(HISTORY_DATA_URL, requestBody.toJSONString()); if (response == null || response.trim().isEmpty()) { log.error("获取历史数据失败: 响应为空"); return createErrorResponse(500, "响应为空"); } return JSONObject.parseObject(response); } catch (Exception e) { log.error("获取历史数据异常", e); return createErrorResponse(500, "请求异常: " + e.getMessage()); } } /** * 获取历史数据(字符串数组版本,只传测点编码列表起止时间) * @param startTime 开始时间 * @param stopTime 结束时间 * @param points 测点数组 * @return 响应结果 */ public static JSONObject getHistoryData(String startTime, String stopTime, String... points) { return getHistoryData(Arrays.asList(points), startTime, stopTime, DEFAULT_INTERVAL, DEFAULT_RETURN_POINT_LIST); } /** * 获取历史数据(字符串数组版本,带间隔参数) * @param startTime 开始时间 * @param stopTime 结束时间 * @param interval 采样间隔(秒) * @param points 测点数组 * @return 响应结果 */ public static JSONObject getHistoryData(String startTime, String stopTime, Integer interval, String... points) { return getHistoryData(Arrays.asList(points), startTime, stopTime, interval, DEFAULT_RETURN_POINT_LIST); } // ==================== 简化数据获取方法重载 ==================== /** * 获取实时数据(单测点简化版,只传单测点编码) * @param pointKey 测点编码 * @return 单测点数值 */ public static PointData getLatestDataSimple(String pointKey) { List<Double> latestDataSimple = getLatestDataSimple(Collections.singletonList(pointKey), DEFAULT_RETURN_POINT_LIST); if (latestDataSimple.isEmpty()){ return null; }else{ PointData pointData = new PointData(); pointData.setTs(new Timestamp(new Date().getTime())); pointData.setCurrent(latestDataSimple.get(0)); return pointData; } } /** * 获取实时数据(返回结构:Map<测点编码, PointData>) * @param pointList 测点编码列表 * @return Map<String, PointData> 测点编码 -> 最新数据对象(自动填充当前时间) */ public static Map<String, PointData> getLatestDataMap(List<String> pointList) { Map<String, PointData> result = new LinkedHashMap<>(); // 保持插入顺序 if (pointList == null || pointList.isEmpty()) return result; // 获取原始数据(强制返回测点编码列表) JSONObject response = getLatestData(pointList, DEFAULT_INTERVAL); if (!isSuccess(response)) return result; JSONObject content = response.getJSONObject("content"); if (content == null) return result; // 解析数据(防御性处理) List<Double> dataList = Optional.ofNullable(content.getJSONArray("datalist")) .map(arr -> arr.toJavaList(Double.class)) .orElse(Collections.emptyList()); List<String> respPointList = Optional.ofNullable(content.getJSONArray("pointList")) .map(arr -> arr.toJavaList(String.class)) .orElse(pointList); // 若未返回测点列表,使用输入列表 // 构建结果(自动填充当前时间) Timestamp now = new Timestamp(System.currentTimeMillis()); IntStream.range(0, Math.min(respPointList.size(), dataList.size())) .forEach(i -> { String point = respPointList.get(i); Double value = dataList.get(i); result.put(point, new PointData(now, value)); }); return result; } /** * 获取实时数据(简化版,只传测点编码列表) * @param pointList 测点编码列表 * @return 数据列表 */ public static List<Double> getLatestDataSimple(List<String> pointList) { return getLatestDataSimple(pointList, DEFAULT_RETURN_POINT_LIST); } /** * 获取实时数据(简化版,完整参数) * @param pointList 测点编码列表 * @param returnPointList 是否返回测点编码列表 * @return 数据列表 */ public static List<Double> getLatestDataSimple(List<String> pointList, Integer returnPointList) { JSONObject response = getLatestData(pointList, returnPointList); if (isSuccess(response)) { JSONObject content = response.getJSONObject("content"); if (content != null && content.containsKey("datalist")) { return content.getJSONArray("datalist").toJavaList(Double.class); } } return Collections.emptyList(); } /** * 获取实时数据(简化版,字符串数组版本) * @param points 测点数组 * @return 数据列表 */ public static List<Double> getLatestDataSimple(String... points) { return getLatestDataSimple(Arrays.asList(points), DEFAULT_RETURN_POINT_LIST); } /** * 获取历史数据(单测点简化版,只传测点编码列表起止时间) * @param point 测点编码 * @param startTime 开始时间 * @param stopTime 结束时间 * @return 单个测点列表 */ public static List<PointData> getHistoryDataSimple(String point, String startTime, String stopTime) { // 将单个测点转为List传给原方法 Map<String, Object> historyDataSimple = getHistoryDataSimple( Collections.singletonList(point), startTime, stopTime, DEFAULT_INTERVAL, 1 ); List<PointData> result = new ArrayList<>(); if (!historyDataSimple.isEmpty()) { List<String> timeList = (List<String>) historyDataSimple.get("timeList"); List<List<Double>> dataList = (List<List<Double>>) historyDataSimple.get("datalist"); if (timeList != null && dataList != null && !dataList.isEmpty()) { // 取dataList的第一个(也是唯一一个)子列表 List<Double> pointValues = dataList.get(0); // 遍历时间序列 for (int i = 0; i < timeList.size(); i++) { Timestamp timestamp = Timestamp.valueOf(timeList.get(i)); Double value = (i < pointValues.size()) ? pointValues.get(i) : null; result.add(new PointData(timestamp, value)); } } } return result; } /** * 获取历史数据(返回结构:Map<测点编码, List<PointData>>) * @param pointList 测点编码列表 * @param startTime 开始时间 * @param stopTime 结束时间 * @return Map<String, List<PointData>> 测点编码 -> 时间序列数据 */ public static Map<String, List<PointData>> getHistoryDataSimpleMap( List<String> pointList, String startTime, String stopTime) { JSONObject response = getHistoryData(pointList, startTime, stopTime, DEFAULT_INTERVAL, 1); Map<String, List<PointData>> result = new LinkedHashMap<>(); // 保持插入顺序 if (!isSuccess(response)) return result; JSONObject content = response.getJSONObject("content"); if (content == null) return result; // 一次性解析所有基础数据 List<String> timeList = safeGetStringList(content, "timeList"); List<List<Double>> dataList = safeGetDoubleList(content, "datalist"); List<String> respPointList = safeGetStringList(content, "pointList"); // 使用Stream并行处理测点数据(线程安全) respPointList.stream().forEach(point -> { int index = respPointList.indexOf(point); List<PointData> pointData = (index < dataList.size()) ? buildPointDataList(timeList, dataList.get(index)) : Collections.emptyList(); result.put(point, pointData); }); return result; } // 类型安全的辅助方法 private static List<String> safeGetStringList(JSONObject obj, String key) { return Optional.ofNullable(obj.getJSONArray(key)) .map(arr -> arr.toJavaList(String.class)) .orElse(Collections.emptyList()); } private static List<List<Double>> safeGetDoubleList(JSONObject obj, String key) { return Optional.ofNullable(obj.getJSONArray(key)) .map(arr -> arr.toJavaList(List.class)) .map(list -> list.stream() .map(inner -> ((List<?>) inner).stream() .map(e -> e instanceof Number ? ((Number) e).doubleValue() : null) .collect(Collectors.toList())) .collect(Collectors.toList())) .orElse(Collections.emptyList()); } private static List<PointData> buildPointDataList(List<String> timeList, List<Double> values) { return IntStream.range(0, timeList.size()) .mapToObj(i -> { try { Timestamp ts = Timestamp.valueOf(timeList.get(i)); Double val = (i < values.size()) ? values.get(i) : null; return new PointData(ts, val); } catch (Exception e) { return new PointData(null, null); // 错误处理 } }) .collect(Collectors.toList()); } /** * 获取历史数据(简化版,只传测点编码列表起止时间) * @param pointList 测点编码列表 * @param startTime 开始时间 * @param stopTime 结束时间 * @return 包含时间列表数据二维列表的Map */ public static Map<String, Object> getHistoryDataSimple(List<String> pointList, String startTime, String stopTime) { return getHistoryDataSimple(pointList, startTime, stopTime, DEFAULT_INTERVAL, 1); } /** * 获取历史数据(简化版,带间隔参数) * @param pointList 测点编码列表 * @param startTime 开始时间 * @param stopTime 结束时间 * @param interval 采样间隔 * @return 包含时间列表数据二维列表的Map */ public static Map<String, Object> getHistoryDataSimple(List<String> pointList, String startTime, String stopTime, Integer interval) { return getHistoryDataSimple(pointList, startTime, stopTime, interval, 1); } /** * 获取历史数据(简化版,完整参数) * @param pointList 测点编码列表 * @param startTime 开始时间 * @param stopTime 结束时间 * @param interval 采样间隔 * @param returnPointList 是否返回测点编码列表 * @return 包含时间列表数据二维列表的Map * 接口返回格式:pointList个数与dataList中子列表个数一致,子列表个数与timeList个数一致 * { * "msg": "success", * "code": 200, * "content": { * "timeList": [ * "2021-01-01 00:00:00", * "2021-01-01 00:00:02", * "2021-01-01 00:00:04" * ], * "dataList": [ * [1.1, 1.3, 1.5], * [2.1, 2.3, 2.5] * ], * "pointList": ["W3.UNIT1.GROSS_MW", "W3.UNIT2.GROSS_MW"] * } * } */ public static Map<String, Object> getHistoryDataSimple(List<String> pointList, String startTime, String stopTime, Integer interval, Integer returnPointList) { JSONObject response = getHistoryData(pointList, startTime, stopTime, interval, returnPointList); Map<String, Object> result = new HashMap<>(); if (isSuccess(response)) { JSONObject content = response.getJSONObject("content"); if (content != null) { if (content.containsKey("timeList")) { result.put("timeList", content.getJSONArray("timeList").toJavaList(String.class)); } if (content.containsKey("datalist")) { result.put("datalist", content.getJSONArray("datalist").toJavaList(List.class)); } if (content.containsKey("pointList")) { result.put("pointList", content.getJSONArray("pointList").toJavaList(String.class)); } } } return result; } /** * 获取历史数据(简化版,字符串数组版本) * @param startTime 开始时间 * @param stopTime 结束时间 * @param points 测点数组 * @return 包含时间列表数据二维列表的Map */ public static Map<String, Object> getHistoryDataSimple(String startTime, String stopTime, String... points) { return getHistoryDataSimple(Arrays.asList(points), startTime, stopTime, DEFAULT_INTERVAL, 1); } /** * 获取历史数据(简化版,字符串数组版本,带间隔参数) * @param startTime 开始时间 * @param stopTime 结束时间 * @param interval 采样间隔 * @param points 测点数组 * @return 包含时间列表数据二维列表的Map */ public static Map<String, Object> getHistoryDataSimple(String startTime, String stopTime, Integer interval, String... points) { return getHistoryDataSimple(Arrays.asList(points), startTime, stopTime, interval, 1); } // ==================== 辅助方法 ==================== /** * 检查响应是否成功 * @param response 响应对象 * @return 是否成功 */ public static boolean isSuccess(JSONObject response) { return response != null && response.getIntValue("code") == 200; } /** * 获取错误信息 * @param response 响应对象 * @return 错误信息 */ public static String getErrorMessage(JSONObject response) { if (response == null) { return "响应为空"; } return response.getString("msg"); } /** * 创建错误响应 * @param code 错误码 * @param message 错误信息 * @return 错误响应JSON */ private static JSONObject createErrorResponse(int code, String message) { JSONObject errorResponse = new JSONObject(); errorResponse.put("code", code); errorResponse.put("msg", message); errorResponse.put("content", null); return errorResponse; } /** * 批量获取多个测点的实时数据 * @param pointCodes 测点编码列表 * @return 测点编码到值的映射 */ public static Map<String, Double> batchGetLatestData(List<String> pointCodes) { JSONObject response = getLatestData(pointCodes, 1); Map<String, Double> result = new HashMap<>(); if (isSuccess(response)) { JSONObject content = response.getJSONObject("content"); if (content != null && content.containsKey("datalist") && content.containsKey("pointList")) { List<Double> dataList = content.getJSONArray("datalist").toJavaList(Double.class); List<String> pointList = content.getJSONArray("pointList").toJavaList(String.class); for (int i = 0; i < pointList.size(); i++) { if (i < dataList.size()) { result.put(pointList.get(i), dataList.get(i)); } } } } return result; } /** * 批量获取多个测点的实时数据(字符串数组版本) * @param points 测点数组 * @return 测点编码到值的映射 */ public static Map<String, Double> batchGetLatestData(String... points) { return batchGetLatestData(Arrays.asList(points)); } }接收端:package com.ceprei.rcm.controller; import com.ceprei.rcm.model.request.HistoryDataRequest; import com.ceprei.rcm.model.request.LatestDataRequest; import com.ceprei.rcm.model.response.ApiResponse; import com.ceprei.rcm.model.response.HistoryDataResponse; import com.ceprei.rcm.model.response.LatestDataResponse; import com.ceprei.rcm.service.CsvDataService; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.web.bind.annotation.PostMapping; import org.springframework.web.bind.annotation.RequestBody; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RestController; import java.util.ArrayList; import java.util.List; @RestController @RequestMapping("/hcdb/data/consume") public class DataController { @Autowired private CsvDataService csvDataService; @PostMapping("/latest") public ApiResponse<LatestDataResponse> getLatestData(@RequestBody LatestDataRequest request) { try { List<Double> dataList = new ArrayList<>(); List<String> pointList = request.getPointList(); if (pointList == null || pointList.isEmpty()) { return ApiResponse.error("测点列表不能为空"); } for (String point : pointList) { Double value = csvDataService.getLatestValueAsDouble(point); dataList.add(value); } LatestDataResponse content = new LatestDataResponse(); content.setDatalist(dataList); if (request.getReturnPointList() != null && request.getReturnPointList() == 1) { content.setPointList(pointList); } return ApiResponse.success(content); } catch (Exception e) { return ApiResponse.error("服务器错误: " + e.getMessage()); } } @PostMapping public ApiResponse<HistoryDataResponse> getHistoryData(@RequestBody HistoryDataRequest request) { try { List<String> pointList = request.getPointList(); if (pointList == null || pointList.isEmpty()) { return ApiResponse.error("测点列表不能为空"); } if (request.getStartTime() == null || request.getStopTime() == null) { return ApiResponse.error("开始时间结束时间不能为空"); } List<List<Double>> dataList = new ArrayList<>(); for (String point : pointList) { List<Double> pointData = csvDataService.getDataInRangeAsDoubleList( point, request.getStartTime(), request.getStopTime()); dataList.add(pointData); } // 生成时间列表 List<String> timeList = csvDataService.generateTimeList( request.getStartTime(), request.getStopTime(), request.getInterval()); HistoryDataResponse content = new HistoryDataResponse(); content.setTimeList(timeList); content.setDatalist(dataList); if (request.getReturnPointList() != null && request.getReturnPointList() == 1) { content.setPointList(pointList); } return ApiResponse.success(content); } catch (Exception e) { return ApiResponse.error("服务器错误: " + e.getMessage()); } } }
09-09
这是我的一个工具方法,现在我想知道如果我调用这个工具方法,我怎么来处理他的返回值:package com.ceprei.rcm.util; import com.alibaba.fastjson.JSONObject; import jnpf.util.wxutil.HttpUtil; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import java.util.*; /** * HC-DB数据库接口访问工具类(带重载方法) */ public class HcdbApiUtil { private static final Logger log = LoggerFactory.getLogger(HcdbApiUtil.class); // HC-DB服务器地址配置 private static final String HCDB_BASE_URL = "http://127.0.0.1:8001"; // 接口路径 private static final String LATEST_DATA_URL = HCDB_BASE_URL + "/hcdb/data/consume/latest"; private static final String HISTORY_DATA_URL = HCDB_BASE_URL + "/hcdb/data/consume"; // 默认参数值 private static final Integer DEFAULT_RETURN_POINT_LIST = 0; // 默认不返回测点列表 private static final Integer DEFAULT_INTERVAL = 1; // 默认采样间隔1秒 private HcdbApiUtil() { throw new IllegalAccessError("工具类不能实例化"); } // ==================== 实时数据查询方法重载 ==================== /** * 获取实时数据(最简版本,只传测点列表) * @param pointList 测点列表 * @return 响应结果 */ public static JSONObject getLatestData(List<String> pointList) { return getLatestData(pointList, DEFAULT_RETURN_POINT_LIST); } /** * 获取实时数据(完整参数) * @param pointList 测点列表 * @param returnPointList 是否返回测点列表 (1:返回, 其他:不返回) * @return 响应结果 */ public static JSONObject getLatestData(List<String> pointList, Integer returnPointList) { try { // 构建请求体 JSONObject requestBody = new JSONObject(); requestBody.put("pointList", pointList); if (returnPointList != null) { requestBody.put("returnPointList", returnPointList); } // 发送POST请求 String response = HttpUtil.sendHttpPost(LATEST_DATA_URL, requestBody.toJSONString()); if (response == null || response.trim().isEmpty()) { log.error("获取实时数据失败: 响应为空"); return createErrorResponse(500, "响应为空"); } return JSONObject.parseObject(response); } catch (Exception e) { log.error("获取实时数据异常", e); return createErrorResponse(500, "请求异常: " + e.getMessage()); } } /** * 获取实时数据(字符串数组版本) * @param points 测点数组 * @return 响应结果 */ public static JSONObject getLatestData(String... points) { return getLatestData(Arrays.asList(points), DEFAULT_RETURN_POINT_LIST); } /** * 获取实时数据(字符串数组版本,带返回测点列表选项) * @param returnPointList 是否返回测点列表 * @param points 测点数组 * @return 响应结果 */ public static JSONObject getLatestData(Integer returnPointList, String... points) { return getLatestData(Arrays.asList(points), returnPointList); } // ==================== 历史数据查询方法重载 ==================== /** * 获取历史数据(最简版本,只传测点列表起止时间) * @param pointList 测点列表 * @param startTime 开始时间 * @param stopTime 结束时间 * @return 响应结果 */ public static JSONObject getHistoryData(List<String> pointList, String startTime, String stopTime) { return getHistoryData(pointList, startTime, stopTime, DEFAULT_INTERVAL, DEFAULT_RETURN_POINT_LIST); } /** * 获取历史数据(带间隔参数) * @param pointList 测点列表 * @param startTime 开始时间 * @param stopTime 结束时间 * @param interval 采样间隔(秒) * @return 响应结果 */ public static JSONObject getHistoryData(List<String> pointList, String startTime, String stopTime, Integer interval) { return getHistoryData(pointList, startTime, stopTime, interval, DEFAULT_RETURN_POINT_LIST); } /** * 获取历史数据(完整参数) * @param pointList 测点列表 * @param startTime 开始时间 * @param stopTime 结束时间 * @param interval 采样间隔(秒) * @param returnPointList 是否返回测点列表 (1:返回, 其他:不返回) * @return 响应结果 */ public static JSONObject getHistoryData(List<String> pointList, String startTime, String stopTime, Integer interval, Integer returnPointList) { try { // 构建请求体 JSONObject requestBody = new JSONObject(); requestBody.put("pointList", pointList); requestBody.put("startTime", startTime); requestBody.put("stopTime", stopTime); requestBody.put("interval", interval); if (returnPointList != null) { requestBody.put("returnPointList", returnPointList); } // 发送POST请求 String response = HttpUtil.sendHttpPost(HISTORY_DATA_URL, requestBody.toJSONString()); if (response == null || response.trim().isEmpty()) { log.error("获取历史数据失败: 响应为空"); return createErrorResponse(500, "响应为空"); } return JSONObject.parseObject(response); } catch (Exception e) { log.error("获取历史数据异常", e); return createErrorResponse(500, "请求异常: " + e.getMessage()); } } /** * 获取历史数据(字符串数组版本,只传测点列表起止时间) * @param startTime 开始时间 * @param stopTime 结束时间 * @param points 测点数组 * @return 响应结果 */ public static JSONObject getHistoryData(String startTime, String stopTime, String... points) { return getHistoryData(Arrays.asList(points), startTime, stopTime, DEFAULT_INTERVAL, DEFAULT_RETURN_POINT_LIST); } /** * 获取历史数据(字符串数组版本,带间隔参数) * @param startTime 开始时间 * @param stopTime 结束时间 * @param interval 采样间隔(秒) * @param points 测点数组 * @return 响应结果 */ public static JSONObject getHistoryData(String startTime, String stopTime, Integer interval, String... points) { return getHistoryData(Arrays.asList(points), startTime, stopTime, interval, DEFAULT_RETURN_POINT_LIST); } // ==================== 简化数据获取方法重载 ==================== /** * 获取实时数据(简化版,只传测点列表) * @param pointList 测点列表 * @return 数据列表 */ public static List<Double> getLatestDataSimple(List<String> pointList) { return getLatestDataSimple(pointList, DEFAULT_RETURN_POINT_LIST); } /** * 获取实时数据(简化版,完整参数) * @param pointList 测点列表 * @param returnPointList 是否返回测点列表 * @return 数据列表 */ public static List<Double> getLatestDataSimple(List<String> pointList, Integer returnPointList) { JSONObject response = getLatestData(pointList, returnPointList); if (isSuccess(response)) { JSONObject content = response.getJSONObject("content"); if (content != null && content.containsKey("datalist")) { return content.getJSONArray("datalist").toJavaList(Double.class); } } return Collections.emptyList(); } /** * 获取实时数据(简化版,字符串数组版本) * @param points 测点数组 * @return 数据列表 */ public static List<Double> getLatestDataSimple(String... points) { return getLatestDataSimple(Arrays.asList(points), DEFAULT_RETURN_POINT_LIST); } /** * 获取历史数据(简化版,只传测点列表起止时间) * @param pointList 测点列表 * @param startTime 开始时间 * @param stopTime 结束时间 * @return 包含时间列表数据二维列表的Map */ public static Map<String, Object> getHistoryDataSimple(List<String> pointList, String startTime, String stopTime) { return getHistoryDataSimple(pointList, startTime, stopTime, DEFAULT_INTERVAL, 1); } /** * 获取历史数据(简化版,带间隔参数) * @param pointList 测点列表 * @param startTime 开始时间 * @param stopTime 结束时间 * @param interval 采样间隔 * @return 包含时间列表数据二维列表的Map */ public static Map<String, Object> getHistoryDataSimple(List<String> pointList, String startTime, String stopTime, Integer interval) { return getHistoryDataSimple(pointList, startTime, stopTime, interval, 1); } /** * 获取历史数据(简化版,完整参数) * @param pointList 测点列表 * @param startTime 开始时间 * @param stopTime 结束时间 * @param interval 采样间隔 * @param returnPointList 是否返回测点列表 * @return 包含时间列表数据二维列表的Map */ public static Map<String, Object> getHistoryDataSimple(List<String> pointList, String startTime, String stopTime, Integer interval, Integer returnPointList) { JSONObject response = getHistoryData(pointList, startTime, stopTime, interval, returnPointList); Map<String, Object> result = new HashMap<>(); if (isSuccess(response)) { JSONObject content = response.getJSONObject("content"); if (content != null) { if (content.containsKey("timeList")) { result.put("timeList", content.getJSONArray("timeList").toJavaList(String.class)); } if (content.containsKey("datalist")) { result.put("datalist", content.getJSONArray("datalist").toJavaList(List.class)); } if (content.containsKey("pointList")) { result.put("pointList", content.getJSONArray("pointList").toJavaList(String.class)); } } } return result; } /** * 获取历史数据(简化版,字符串数组版本) * @param startTime 开始时间 * @param stopTime 结束时间 * @param points 测点数组 * @return 包含时间列表数据二维列表的Map */ public static Map<String, Object> getHistoryDataSimple(String startTime, String stopTime, String... points) { return getHistoryDataSimple(Arrays.asList(points), startTime, stopTime, DEFAULT_INTERVAL, 1); } /** * 获取历史数据(简化版,字符串数组版本,带间隔参数) * @param startTime 开始时间 * @param stopTime 结束时间 * @param interval 采样间隔 * @param points 测点数组 * @return 包含时间列表数据二维列表的Map */ public static Map<String, Object> getHistoryDataSimple(String startTime, String stopTime, Integer interval, String... points) { return getHistoryDataSimple(Arrays.asList(points), startTime, stopTime, interval, 1); } // ==================== 辅助方法 ==================== /** * 检查响应是否成功 * @param response 响应对象 * @return 是否成功 */ public static boolean isSuccess(JSONObject response) { return response != null && response.getIntValue("code") == 200; } /** * 获取错误信息 * @param response 响应对象 * @return 错误信息 */ public static String getErrorMessage(JSONObject response) { if (response == null) { return "响应为空"; } return response.getString("msg"); } /** * 创建错误响应 * @param code 错误码 * @param message 错误信息 * @return 错误响应JSON */ private static JSONObject createErrorResponse(int code, String message) { JSONObject errorResponse = new JSONObject(); errorResponse.put("code", code); errorResponse.put("msg", message); errorResponse.put("content", null); return errorResponse; } /** * 批量获取多个测点的实时数据 * @param pointCodes 测点编码列表 * @return 测点编码到值的映射 */ public static Map<String, Double> batchGetLatestData(List<String> pointCodes) { JSONObject response = getLatestData(pointCodes, 1); Map<String, Double> result = new HashMap<>(); if (isSuccess(response)) { JSONObject content = response.getJSONObject("content"); if (content != null && content.containsKey("datalist") && content.containsKey("pointList")) { List<Double> dataList = content.getJSONArray("datalist").toJavaList(Double.class); List<String> pointList = content.getJSONArray("pointList").toJavaList(String.class); for (int i = 0; i < pointList.size(); i++) { if (i < dataList.size()) { result.put(pointList.get(i), dataList.get(i)); } } } } return result; } /** * 批量获取多个测点的实时数据(字符串数组版本) * @param points 测点数组 * @return 测点编码到值的映射 */ public static Map<String, Double> batchGetLatestData(String... points) { return batchGetLatestData(Arrays.asList(points)); } }这个工具类对应的文档是(里面包含了post请求的返回值):HC-DB数据库接口文档v1.8(宁德电厂) HC-DB数据库接口文档v1.8(宁德电厂) 1 生产测点数据查询 1.1 实时数据查询 1.1.1 功能描述 1.1.2 HTTP请求报文 1.1.3 HTTP响应报文 1.2 历史数据查询 1.2.1 功能描述 1.2.2 HTTP请求报文 1.2.3 HTTP响应报文 2 备注 1 生产测点数据查询 用于查询生产测点实时数据 1.1 实时数据查询 1.1.1 功能描述 查询指定测点列表的实时数据(最新一条) 1.1.2 HTTP请求报文 【请求头】路径: /hcdb/data/consume/latest 【请求头】 Host : HC-DB 服务器地址,生产现场需要先获取对应电厂的服务器地址 【请求体】需要查询的测点列表 pointList :生产测点列表 returnPointList :选填, 当该值不在或不为1时不返回测点列表 当该值在且等于1时返回测点列表 POST /hcdb/data/consume/latest HTTP/1.1 Host: 127.0.0.1:8001 Content-Type: application/json { "pointList": ["W3.UNIT1.GROSS_MW", "W3.UNIT2.GROSS_MW"], "returnPointList": 1, } 1.1.3 HTTP响应报文 响应为 JSON 格式,以下为成功示例: code :响应码, 200 为成功,其他为错误 msg :响应消息 content :响应的具体内容 dataList :请求测点列表对应的最新一条数据(实时数据) 1.2 历史数据查询 1.2.1 功能描述 按时间区间、采样值查询指定测点列表的历史数据 1.2.2 HTTP请求报文 【请求头】路径: /hcdb/data/consume 【请求头】 Host : HC-DB 服务器地址,生产现场需要先获取对应电厂的服务器地址 【请求体】需要查询的测点列表 pointList :生产测点列表 startTime :开始时间,开区间 stopTime :结束时间,闭区间 interval :采样间隔,单位为秒 { "msg": "success", "code": 200, "content": { "dataList": [1.5, 2.5], "pointList": ["W3.UNIT1.GROSS_MW", "W3.UNIT2.GROSS_MW"] } } POST /hcdb/data/consume HTTP/1.1 Host: 127.0.0.1:8001 Content-Type: application/json { "pointList": ["W3.UNIT1.GROSS_MW", "W3.UNIT2.GROSS_MW"], "startTime": "2021-01-01 00:00:00", "stopTime": "2021-01-01 00:00:05", "interval": 2, "returnPointList": 1 } 1.2.3 HTTP响应报文 响应为 JSON 格式,以下为成功示例: code :响应码, 200 为成功,其他为错误 msg :响应消息 content :响应的具体内容 dataList :该查询条件下 pointList 对应的数据二维列表 timeList :该查询条件下对应的时间列表 2 备注 备注1:读写数据都通过 HTTP 协议实现,请求方式为 POST ,响应方式为 JSON 。使用者机器无需 安装配置任何插件。 备注2:服务器地址: http://172.16.1.74:8001 或 http://192.168.1.179:8001 备注3: SIS 测点见 ningdePoints 文件。 { "msg": "success", "code": 200, "content": { "timeList": [ "2021-01-01 00:00:00", "2021-01-01 00:00:02", "2021-01-01 00:00:04" ], "dataList": [ [1.1, 1.3, 1.5], [2.1, 2.3, 2.5] ], "pointList": ["W3.UNIT1.GROSS_MW", "W3.UNIT2.GROSS_MW"] } }
最新发布
09-09
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值