java中将数据封装为JSON包，可以使用java提供的jsonArray这个工具类进行转换，代码如下：
package com.jsonimport java.io.IOException
import java.util.ArrayList
import java.util.Collection
import java.util.HashMap
import java.util.Iterator
import java.util.List
import java.util.Map
import javax.servlet.http.HttpServletResponse
import net.sf.json.JSONArray
import net.sf.json.JSONObject
import org.apache.commons.beanutils.BeanUtils
import org.apache.struts2.ServletActionContext
import com.opensymphony.xwork2.ActionContext
public class JSONUtils
{
/**
*
* @author wangwei JSON工具类
* @param <T>
*
*/
/***
* 将List对象序列化为JSON文本
*/
public static <T> String toJSONString(List<T> list)
{
JSONArray jsonArray = JSONArray.fromObject(list)
return jsonArray.toString()
}
/***
* 将对象序列化为JSON文本
* @param object
* @return
*/
public static String toJSONString(Object object)
{
JSONArray jsonArray = JSONArray.fromObject(object)
return jsonArray.toString()
}
/***
* 将JSON对象数组序列化为JSON文本
* @param jsonArray
* @return
*/
public static String toJSONString(JSONArray jsonArray)
{
return jsonArray.toString()
}
/***
* 将JSON对象序列化为JSON文本
* @param jsonObject
* @return
*/
public static String toJSONString(JSONObject jsonObject)
{
return jsonObject.toString()
}
/***
* 将对象转换为List对象
* @param object
* @return
*/
public static List toArrayList(Object object)
{
List arrayList = new ArrayList()
JSONArray jsonArray = JSONArray.fromObject(object)
Iterator it = jsonArray.iterator()
while (it.hasNext())
{
JSONObject jsonObject = (JSONObject) it.next()
Iterator keys = jsonObject.keys()
while (keys.hasNext())
{
Object key = keys.next()
Object value = jsonObject.get(key)
arrayList.add(value)
}
}
return arrayList
}
/***
* 将对象转换为Collection对象
* @param object
* @return
*/
public static Collection toCollection(Object object)
{
JSONArray jsonArray = JSONArray.fromObject(object)
return JSONArray.toCollection(jsonArray)
}
/***
* 将对象转换为JSON对象数组
* @param object
* @return
*/
public static JSONArray toJSONArray(Object object)
{
return JSONArray.fromObject(object)
}
/***
* 将对象转换为JSON对象
* @param object
* @return
*/
public static JSONObject toJSONObject(Object object)
{
return JSONObject.fromObject(object)
}
/***
* 将对象转换为HashMap
* @param object
* @return
*/
public static HashMap toHashMap(Object object)
{
HashMap<String, Object> data = new HashMap<String, Object>()
JSONObject jsonObject = JSONUtils.toJSONObject(object)
Iterator it = jsonObject.keys()
while (it.hasNext())
{
String key = String.valueOf(it.next())
Object value = jsonObject.get(key)
data.put(key, value)
}
return data
}
/***
* 将对象转换为List<Map<String,Object>>
* @param object
* @return
*/
// 返回非实体类型(Map<String,Object>)的List
public static List<Map<String, Object>> toList(Object object)
{
List<Map<String, Object>> list = new ArrayList<Map<String, Object>>()
JSONArray jsonArray = JSONArray.fromObject(object)
for (Object obj : jsonArray)
{
JSONObject jsonObject = (JSONObject) obj
Map<String, Object> map = new HashMap<String, Object>()
Iterator it = jsonObject.keys()
while (it.hasNext())
{
String key = (String) it.next()
Object value = jsonObject.get(key)
map.put((String) key, value)
}
list.add(map)
}
return list
}
/***
* 将JSON对象数组转换为传入类型的List
* @param <T>
* @param jsonArray
* @param objectClass
* @return
*/
public static <T> List<T> toList(JSONArray jsonArray, Class<T> objectClass)
{
return JSONArray.toList(jsonArray, objectClass)
}
/***
* 将对象转换为传入类型的List
* @param <T>
* @param jsonArray
* @param objectClass
* @return
*/
public static <T> List<T> toList(Object object, Class<T> objectClass)
{
JSONArray jsonArray = JSONArray.fromObject(object)
return JSONArray.toList(jsonArray, objectClass)
}
/***
* 将JSON对象转换为传入类型的对象
* @param <T>
* @param jsonObject
* @param beanClass
* @return
*/
public static <T> T toBean(JSONObject jsonObject, Class<T> beanClass)
{
return (T) JSONObject.toBean(jsonObject, beanClass)
}
/***
* 将将对象转换为传入类型的对象
* @param <T>
* @param object
* @param beanClass
* @return
*/
public static <T> T toBean(Object object, Class<T> beanClass)
{
JSONObject jsonObject = JSONObject.fromObject(object)
return (T) JSONObject.toBean(jsonObject, beanClass)
}
/***
* 将JSON文本反序列化为主从关系的实体
* @param <T> 泛型T 代表主实体类型
* @param <D> 泛型D 代表从实体类型
* @param jsonString JSON文本
* @param mainClass 主实体类型
* @param detailName 从实体类在主实体类中的属性名称
* @param detailClass 从实体类型
* @return
*/
public static <T, D> T toBean(String jsonString, Class<T> mainClass,
String detailName, Class<D> detailClass)
{
JSONObject jsonObject = JSONObject.fromObject(jsonString)
JSONArray jsonArray = (JSONArray) jsonObject.get(detailName)
T mainEntity = JSONUtils.toBean(jsonObject, mainClass)
List<D> detailList = JSONUtils.toList(jsonArray, detailClass)
try
{
BeanUtils.setProperty(mainEntity, detailName, detailList)
}
catch (Exception ex)
{
throw new RuntimeException("主从关系JSON反序列化实体失败！")
}
return mainEntity
}
/***
* 将JSON文本反序列化为主从关系的实体
* @param <T>泛型T 代表主实体类型
* @param <D1>泛型D1 代表从实体类型
* @param <D2>泛型D2 代表从实体类型
* @param jsonString JSON文本
* @param mainClass 主实体类型
* @param detailName1 从实体类在主实体类中的属性
* @param detailClass1 从实体类型
* @param detailName2 从实体类在主实体类中的属性
* @param detailClass2 从实体类型
* @return
*/
public static <T, D1, D2> T toBean(String jsonString, Class<T> mainClass,
String detailName1, Class<D1> detailClass1, String detailName2,
Class<D2> detailClass2)
{
JSONObject jsonObject = JSONObject.fromObject(jsonString)
JSONArray jsonArray1 = (JSONArray) jsonObject.get(detailName1)
JSONArray jsonArray2 = (JSONArray) jsonObject.get(detailName2)
T mainEntity = JSONUtils.toBean(jsonObject, mainClass)
List<D1> detailList1 = JSONUtils.toList(jsonArray1, detailClass1)
List<D2> detailList2 = JSONUtils.toList(jsonArray2, detailClass2)
try
{
BeanUtils.setProperty(mainEntity, detailName1, detailList1)
BeanUtils.setProperty(mainEntity, detailName2, detailList2)
}
catch (Exception ex)
{
throw new RuntimeException("主从关系JSON反序列化实体失败！")
}
return mainEntity
}
/***
* 将JSON文本反序列化为主从关系的实体
* @param <T>泛型T 代表主实体类型
* @param <D1>泛型D1 代表从实体类型
* @param <D2>泛型D2 代表从实体类型
* @param jsonString JSON文本
* @param mainClass 主实体类型
* @param detailName1 从实体类在主实体类中的属性
* @param detailClass1 从实体类型
* @param detailName2 从实体类在主实体类中的属性
* @param detailClass2 从实体类型
* @param detailName3 从实体类在主实体类中的属性
* @param detailClass3 从实体类型
* @return
*/
public static <T, D1, D2, D3> T toBean(String jsonString,
Class<T> mainClass, String detailName1, Class<D1> detailClass1,
String detailName2, Class<D2> detailClass2, String detailName3,
Class<D3> detailClass3)
{
JSONObject jsonObject = JSONObject.fromObject(jsonString)
JSONArray jsonArray1 = (JSONArray) jsonObject.get(detailName1)
JSONArray jsonArray2 = (JSONArray) jsonObject.get(detailName2)
JSONArray jsonArray3 = (JSONArray) jsonObject.get(detailName3)
T mainEntity = JSONUtils.toBean(jsonObject, mainClass)
List<D1> detailList1 = JSONUtils.toList(jsonArray1, detailClass1)
List<D2> detailList2 = JSONUtils.toList(jsonArray2, detailClass2)
List<D3> detailList3 = JSONUtils.toList(jsonArray3, detailClass3)
try
{
BeanUtils.setProperty(mainEntity, detailName1, detailList1)
BeanUtils.setProperty(mainEntity, detailName2, detailList2)
BeanUtils.setProperty(mainEntity, detailName3, detailList3)
}
catch (Exception ex)
{
throw new RuntimeException("主从关系JSON反序列化实体失败！")
}
return mainEntity
}
/***
* 将JSON文本反序列化为主从关系的实体
* @param <T> 主实体类型
* @param jsonString JSON文本
* @param mainClass 主实体类型
* @param detailClass 存放了多个从实体在主实体中属性名称和类型
* @return
*/
public static <T> T toBean(String jsonString, Class<T> mainClass,
HashMap<String, Class> detailClass)
{
JSONObject jsonObject = JSONObject.fromObject(jsonString)
T mainEntity = JSONUtils.toBean(jsonObject, mainClass)
for (Object key : detailClass.keySet())
{
try
{
Class value = (Class) detailClass.get(key)
BeanUtils.setProperty(mainEntity, key.toString(), value)
}
catch (Exception ex)
{
throw new RuntimeException("主从关系JSON反序列化实体失败！")
}
}
return mainEntity
}
/**
* 封装json数据从后台传输
* @param obj
*/
public static void outPutJson(Object obj){
ActionContext context = ActionContext.getContext()
HttpServletResponse response = (HttpServletResponse) context.get(ServletActionContext.HTTP_RESPONSE)
try {
response.getWriter().print(obj)
} catch (IOException e) {
e.printStackTrace()
}
}
}
//测试类
String s1 = "[{id:1, pId:0, name:\"test1\" , open:true}]"
String s2 = "{id:2, pId:1, name:\"test211\" , open:true}"
String s3 = "{id:3, pId:2, name:\"test311\" , open:true}"
String s4 = "{id:4, pId:1, name:\"test411\" , open:true}"
List<String> listZtree = new ArrayList<String>()
listZtree.add(s1)
listZtree.add(s2)
listZtree.add(s3)
listZtree.add(s4)
System.out.println(JSONUtils.toJSONString(listZtree))
}
java实现JSON打包UDP cJSON支持在C程序中创建和解析JSON数据，其提供多种方法供C程序使用，最直接的是将cJSON.c和cJSON.h加入到C工程中
（1） QJsonObject用于在Qt中创建JSON对象
（2）数据传输通过UDP运行
代码如下
首先在pro文件中加入
QT += network
h文件内容：
首先在pro文件中加入
QT += network
h文件内容：
#ifndef MAINWINDOW_H
#define MAINWINDOW_H
#include <QMainWindow>
#include<QtNetwork>
namespace Ui {
class MainWindow
}
class MainWindow : public QMainWindow
{
Q_OBJECT
public:
explicit MainWindow(QWidget *parent = 0)
~MainWindow()
QUdpSocket *sender
QByteArray byteArray
private slots:
void on_pushButton_clicked()
private:
Ui::MainWindow *ui
}
#endif // MAINWINDOW_H
cpp文件内容：
#include "mainwindow.h"
#include "ui_mainwindow.h"
#include<QJsonObject>
#include<QJsonDocument>
#include<QDebug>
MainWindow::MainWindow(QWidget *parent) :
QMainWindow(parent),
ui(new Ui::MainWindow)
{
ui->setupUi(this)
sender = new QUdpSocket(this)
QJsonObject rectJson
rectJson.insert("Type","Rectangle")
rectJson.insert("height",42)
rectJson.insert("widght",23)
QJsonDocument rectJsonDoc
rectJsonDoc.setObject(rectJson)
byteArray = rectJsonDoc.toJson(QJsonDocument::Compact)
}
MainWindow::~MainWindow()
{
delete ui
}
void MainWindow::on_pushButton_clicked()
{
QHostAddress address
address.setAddress(QString("192.168.230.140"))
sender->writeDatagram(byteArray.data(),byteArray.size(),
address,4444)
}
程序通过端口4444，向IP为192.168.230.140的主机发送JSON数据
C程序如下：
{
int sock_fd
char rcv_buff[512]
struct sockaddr_in client_addr
struct sockaddr_in server_addr
int client_len
int rcv_num = -1
if ((sock_fd = socket(AF_INET, SOCK_DGRAM,0)) <0)
{
perror("socket create error\n")
exit(1)
}
memset(&server_addr,0,sizeof(struct sockaddr_in))
server_addr.sin_family = AF_INET
server_addr.sin_port = htons(4444)
server_addr.sin_addr.s_addr = htonl(INADDR_ANY)
client_len = sizeof(struct sockaddr_in)
if (bind(sock_fd, (struct sockaddr *)&server_addr, sizeof(struct sockaddr_in)) <0)
{
perror("bind socket error.\n")
exit(1)
}
while (1)
{
/*zero the buff of rvbsm and hvbsm? zhp*/
rcv_num= recvfrom(sock_fd, rcv_buff, sizeof(rcv_buff), 0, (struct sockaddr*)&client_addr, &client_len)
if (rcv_num>0)
{
rcv_buff[rcv_num] = '\0'
printf("rx bsm num = %d\n",rcv_num)
//printf()
printf("%s %u says: %s\n",inet_ntoa(client_addr.sin_addr),ntohs(client_addr.sin_port),rcv_buff)
//parse_UDP_data(rcv_num,rcv_buff)
if(rcv_buff != NULL)
{
cJSON* pJson = cJSON_Parse(rcv_buff)
if(pJson == NULL)
{
printf("Json Parse failed.\n")
return 0
}
cJSON* pSub1 = cJSON_GetObjectItem(pJson,"Type")
cJSON* pSub2 = cJSON_GetObjectItem(pJson,"height")
cJSON* pSub3 = cJSON_GetObjectItem(pJson,"widght")
if(pSub1!=NULL)
{
printf("Type : %s\n", pSub1->valuestring)
}
if(pSub2!=NULL)
{
printf("height : %d\n", pSub2->valueint)
}
if(pSub3!=NULL)
{
printf("widght : %d\n", pSub3->valueint)
}
}
}
else
{
perror("recv BSM error\n")
break
}
}
close(sock_fd)
}
编译C程序:gcc -I. -lm -o rencode *.c
由于cJSON使用了标准数学库，所以在编译中需链接其库文件-lm；
在IP为192.168.230.140的Linux服务器中执行./rencode
输出结果为：
解决java程序包org.json不存在的3个步骤。1、Maven项目默认jdk配置。
2、在项目配置时配置好依赖。
3、Maven项目的pomxml中添加依赖。
4、重新载入项目即可生效。
