fastjson java对象和JSON的相互转换
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONO
json字符串转java对象（OrderInfo(orderId、orderDate)）
OrderInfo orderInfo = JSON.parseObject(jsonStr, OrderInfo.class);
json字符串转json对象
String jsonStr = “{\”orderId\” : \”1111111\”;\”orderDate\” : \” 11:03:00\”}”;
JSONObject jsonObject = JSON.parseObject(jsonStr);
String orderId = jsonObject.getString(“orderId”);
String orderDate =jsonObject.getString(“orderDate”);
java对象转json字符串
String jsonStr = JSON.toJSONString(orderInfo)
java对象转json对象
JSON json = (JSON) JSON.toJSON(orderInfo);
没有更多推荐了，gson java对象与json转换
一. Gson 是 Google 提供的用来在 Java 对象和 JSON 数据之间进行映射的 Java 类库。可以将一个 JSON 字符串转成一个 Java 对象，或者反过来。
Gson里最重要的对象有2个Gson 和 GsonBuilder。
Gson有2个最基本的方法
1) toJson() – 转换java 对象到JSON
2) fromJson() – 转换JSON到java对象
二. 几个简单的例子。
exp1（一个简单对象object和json之间的转换）：
public class MsgInfo2 {
public String getMessage() {
public void setMessage(String message) {
this.message =
public String getFlag() {
public void setFlag(String flag) {
this.flag =
public class Test1 {
public static void main(String[] args) {
MsgInfo2 m2 = new MsgInfo2();
m2.setFlag("00");
m2.setMessage("message");
tojson(m2);
String json = "{'message':'message1','flag':'00'}";
toObject(json);
public static void tojson(MsgInfo2 m) {
Gson gson = new Gson();
String result = gson.toJson(m);
System.out.println(result);
public static void toObject(String m) {
Gson gson = new Gson();
MsgInfo2 msg = gson.fromJson(m, MsgInfo2.class);
System.out.println(msg.getFlag());
System.out.println(msg.getMessage());
exp2（一个复杂对象object和json之间的转换）：
json的结构如下：
"orgId": "orgId",
"orgName": "orgName"
"appcode": 55,
"subscode": "subscode0"
"appcode": 66,
"subscode": "subscode1"
public class ComOpen {
private List&BizObject&
public Org getOrg() {
public void setOrg(Org org) {
this.org =
public List&BizObject& getBiz() {
public void setBiz(List&BizObject& biz) {
this.biz =
public class Org {
private String orgId;
private String orgN
public String getOrgId() {
return orgId;
public void setOrgId(String orgId) {
this.orgId = orgId;
public String getOrgName() {
return orgN
public void setOrgName(String orgName) {
this.orgName = orgN
public class BizObject {
private int
public String getSubscode() {
public void setSubscode(String subscode) {
this.subscode =
public int getAppcode() {
public void setAppcode(int appcode) {
this.appcode =
public class Test2 {
public static void main(String[] args) {
toObject();
public static void toJson(){
ComOpen como = new ComOpen();
Org org = new Org();
org.setOrgId("orgId");
org.setOrgName("orgName");
como.setOrg(org);
List&BizObject& biz = new ArrayList&BizObject&();
BizObject bizObject = new BizObject();
bizObject.setAppcode(55);
bizObject.setSubscode("subscode0");
BizObject bizObject1 = new BizObject();
bizObject1.setAppcode(66);
bizObject1.setSubscode("subscode1");
biz.add(bizObject);
biz.add(bizObject1);
como.setBiz(biz);
Gson gson=new GsonBuilder().create();
String result = gson.toJson(como);
System.out.println(result);
public static void toObject(){
String json = "{'org':{'orgId':'orgId','orgName':'orgName'},'biz':" +
"[{'appcode':55,'subscode':'subscode0'},{'appcode':66,'subscode':'subscode1'}]}";
Gson gson=new Gson();
m3 = gson.fromJson(json, ComOpen.class);
System.out.println(m3.getBiz().size());
System.out.println("orgId："+m3.getOrg().getOrgId());
System.out.println("appcode："+ m3.getBiz().get(0).getAppcode());
三.其他可参考gson教程和官方帮助文档
(267.2 KB) (202.5 KB)
没有更多推荐了，有关restful 怎么把json对象直接映射成java对象_百度知道
有关restful 怎么把json对象直接映射成java对象
我有更好的答案
利用一些jar包对json解析即可。这里推荐两个：1、fastjson，阿里巴巴开源的json解析包。&&&& 使用方便，速度较快，下面的代码可以很快的解析JSON得到Java对象：&JSONObject&jo&=&JSONObject.parseObject(json);2、jackson，国外开源的json解析包，也很流行。&& 其最大的特点是支持流模式的JSON数据解析，这样在解析较大的json数据时很有优势。JsonToken&result&=&int&i&=&1;while&((result&=&p.nextToken())&!=&null)&{&&&&System.out.println(&[&&+&i++&+&&]&&+&result);&//&根据result类型进行处理}
采纳率：82%
来自团队：
//解析json到对象 @SuppressWarnings(&rawtypes&) public static Object parserJson2Object(String content,Class clazz){
Gson gson = new Gson();
info = new Object();
JsonReader jreader = new JsonReader(new StringReader(content));
jreader.setLenient(true);
info = gson.fromJson(jreader, clazz);
} catch (Exception e) {
e.printStackTrace();
本回答被提问者和网友采纳
//解析json到对象 @SuppressWarnings(&rawtypes&) public static Object parserJson2Object(String content,Class clazz){
Gson gson = new Gson();
info = new Object();
JsonReader jreader = new JsonReader(new StringReader(content));
jreader.setLenient(true);
info = gson.fromJson(jreader, clazz);
} catch (Exception e) {
e.printStackTrace();
通过@ResponseBody@RequestBody可以自动将参数转为java对象、或将返回值转换成json。例如：public @ResponseBody Response method(@RequestBody Request req) Response和Request可以分别为自定义的java对象，spring会自动进行参数解析和返回值转换这应该是楼主想要的东西吧。
你可以参考fastjson，其中有个方法是JSON.parseObject(result, clazz);其中clazz是你的类对象如： Person person = JSON.parseObject(result, Person.class);
其他2条回答
为您推荐：
其他类似问题
json的相关知识
换一换
回答问题，赢新手礼包
个人、企业类
违法有害信息,请在下方选择后提交
色情、暴力
我们会通过消息、邮箱等方式尽快将举报结果通知您。fastjson 把java对象转换成json对象的问题
<a data-traceid="question_detail_above_text_l&&
在使用fastjson 把java对象(list，map)转换成json对象时，出现信息丢失的问题，后来使用gson，就正常了，结果如下，谁知道如何解决：
使用Gson转换:
{"backgroundColor": "#ddd","title": {"text": "平台注册用户性别比例统计"},"legend": {"data": ["未知","男","女"],"top": 25},"xAxis": [{"type": "category","data": ["性别"]}],"yAxis": [{"type": "value"}],"series": [{"name": "未知","type": "bar","data": [31]},{"name": "男","type": "bar","data": [9]},{"name": "女","type": "bar","data": [2]}]}
使用fastJson:
{"backgroundColor":"#ddd","legend":{"data":["未知","男","女"],"top":25},"series":[{"data":[31],"name":"未知","type":"bar"},{"data":[9],"name":"男","type":"bar"},{"data":[2],"name":"女","type":"bar"}],"title":{"text":"平台注册用户性别比例统计"}}
xAxis 字段不是public并且没有getter？
xAxis的get方法改成getXAxis()
需要转换的属性都加上get方法就没有问题屏上得来终觉浅，绝知此事要躬行。
fastjson-1.2.21 使用实例，复杂嵌套Java对象转json对象，复杂嵌套json对象转对应Java对象的代码实现
理论我就不多废话了，直接看代码吧。使用的是fastjson-1.2.21版本的来实现下面代码的。
主要是实现复杂的嵌套的Java对象，也就是对象嵌套对象的复杂对象，转换成json字符串。然后就是反过来，把复杂的json字符串转换成对应的嵌套的Java对象。
先上工具类。如下。
package com.lxk.
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONO
* JSON 转换
public final class JsonUtils {
* 把Java对象转换成json字符串
* @param object 待转化为JSON字符串的Java对象
* @return json 串 or null
public static String parseObjToJson(Object object) {
String string =
//string = JSON.toJSONString(object);
string = JSONObject.toJSONString(object);
} catch (Exception e) {
System.out.println(e.getMessage());
* 将Json字符串信息转换成对应的Java对象
* @param json json字符串对象
* @param c
对应的类型
public static &T& T parseJsonToObj(String json, Class&T& c) {
//两个都是可行的，起码我测试的时候是没问题的。
//JSONObject jsonObject = JSONObject.parseObject(json);
JSONObject jsonObject = JSON.parseObject(json);
return JSON.toJavaObject(jsonObject, c);
} catch (Exception e) {
System.out.println(e.getMessage());
从代码中引入的包来看，真就是简单的只是引用了com.alibaba.fastjson这个包里面的2个类。所以，使用这个包，就很简单，不耦合其他工具包。
上面对象转json字符串的方法还可以如下修改下。
* 把Java对象转换成json字符串
* @param object 待转化为JSON字符串的Java对象
* @return json 串 or null
public static &T& String parseObjToJson(T object) {
String string =
//string = JSON.toJSONString(object);
string = JSONObject.toJSONString(object);
} catch (Exception e) {
System.out.println(e.getMessage());
}把穿进去的Object类给换成泛型，显得高级点点。这样的话，2个方法都是使用的泛型啦。可以让你写代码的水平，稍微闷骚一下。这只是泛型的简单用法。所以说只是稍微。
关于泛型，不懂的可以看下面的链接：包教包不会。
pom.xml中引入如下配置。
&!-- json转换很是方便的工具jar --&
&dependency&
&groupId&com.alibaba&/groupId&
&artifactId&fastjson&/artifactId&
&version&1.2.21&/version&
&/dependency&非maven项目，也可以去找这个jar包：fastjson-1.2.21.jar
我给放到云盘上，这里分享下：链接：http://pan.baidu.com/s/1dE1CLc1 密码：xg2c
有需要的可以直接下载使用，省的麻烦。嫌弃版本旧的也可自己找最新的。
下面是测试类。
package com.lxk.
import com.google.common.collect.L
import com.lxk.model.C
import com.lxk.model.D
import com.lxk.model.S
import java.util.L
* 测试json和Java对象之间的转换
* Created by lxk on
public class TestJsonMain {
public static void main(String[] args) {
Student student = getStudent();
String studentJson = JsonUtils.parseObjToJson(student);
System.out.println(studentJson);
Student studentFromJson = JsonUtils.parseJsonToObj(studentJson, Student.class);
System.out.println(studentFromJson);
private static Student getStudent() {
Dog dog1 = new Dog("大师兄的dog", true, true);
Dog dog2 = new Dog("大师兄的dog", false, false);
List&Dog& dogs = Lists.newArrayList();
dogs.add(dog1);
dogs.add(dog2);
List&String& boys = Lists.newArrayList("tom", "jerry", "jack");
Car car = new Car("q7", 182, dogs, boys);
Student student = new Student();
student.setName("Lxk");
student.setCar(car);
然后就是看代码的运行结果。
这个乍一看，看不出来什么，我把我用到的几个Java bean也给放这吧，看官，别嫌弃文章太长。已经删掉getter和setter了
先是主体类Student类
package com.lxk.
* Created by lxk on
public class Student implements Cloneable {
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", car=" + car +
public Student clone() {
Student student =
student = (Student) super.clone();
if (car != null) {
student.setCar(car.clone());
} catch (CloneNotSupportedException ignored) {
System.out.println(ignored.getMessage());
这个是我原来测试clone方法的使用（Java中的深浅克隆）的时候，使用的类，现在顺道带过来测试这个，也是可以的。
只要你暂时没用到过这个clone方法，估计你也是不会去研究这个深浅克隆的，我还是附上链接吧。看链接：
然后就是学生的属性Car类。
package com.lxk.
import com.google.common.collect.L
import java.util.L
public class Car implements Cloneable, Comparable&Car& {
private List&Dog& myD
private List&String&
public Car() {
public Car(String sign, int price) {
this.sign =
this.price =
public Car(String sign, int price, List&Dog& myDog) {
this.sign =
this.price =
this.myDog = myD
public Car(String sign, int price, List&Dog& myDog, List&String& boys) {
this.sign =
this.price =
this.myDog = myD
this.boys =
public int compareTo(Car o) {
//同理也可以根据sign属性排序，就不举例啦。
return this.getPrice() - o.getPrice();
public String toString() {
return "Car{" +
"sign='" + sign + '\'' +
", price=" + price +
", myDog=" + myDog +
", boys=" + boys +
public Car clone() {
car = (Car) super.clone();
if (myDog != null) {
car.setMyDog(Lists.newArrayList(myDog));
if (boys != null) {
car.setBoys(Lists.newArrayList(boys));
} catch (CloneNotSupportedException ignored) {
System.out.println(ignored.getMessage());
这个也是，在测试clone，Java的深浅克隆用法的时候，使用的Javabean。顺道实现了comparable接口，好像是测试集合类排序的时候使用的吧。
下面就是Dog类。
package com.lxk.
import com.google.common.base.O
* 测试boolean属性的getter和setter
* Created by lxk on
public class Dog {
private boolean isL//是忠诚的
p//活蹦乱跳的
public Dog() {
public Dog(boolean isLoyal, boolean alive) {
this.isLoyal = isL
this.alive =
public Dog(String name, boolean isLoyal, boolean alive) {
this.name =
this.isLoyal = isL
this.alive =
public boolean equals(Object o) {
if (this == o)
if (!(o instanceof Dog))
Dog dog = (Dog)
return Objects.equal(getName(), dog.getName());
public int hashCode() {
return Objects.hashCode(getName());
public String toString() {
return "Dog{" +
"name='" + name + '\'' +
", isLoyal=" + isLoyal +
", alive=" + alive +
这个的测试目的，在类注释上说了，主要是boolean类型的属性要是以is开头，可能自动生成getter，setter的时候，会产生一些bug。看链接：
好了，到这里，就把使用的三个model类啰嗦完了。下面再看主代码运行结果吧。
先是把复杂嵌套Java对象转换成json字符串对象，对json对象稍加格式化，展示如下。
"myDog": [
"alive": true,
"loyal": true,
"name": "大师兄的dog"
"alive": false,
"loyal": false,
"name": "大师兄的dog"
"price": 182,
"sign": "q7"
"name": "Lxk"
}然后就是把这个json字符串再转乘Java对象的运行结果。也格式化下，展示如下。
name='Lxk',
sign='q7',
price=182,
name='大师兄的dog',
isLoyal=true,
alive=true
name='大师兄的dog',
isLoyal=false,
alive=false
还有关于这个Student类实例化的对象，调用toString（）方法，可以可以这么完美，你们不好奇么？为什么不是返回的一个Java内存地址，而是我们可以看的懂的一个类似json对象的字符串格式呢？这里面也是大有文章的，细心的小伙伴们，可以回头看下我的三个javabean，这三个Java model都是重写了toString（）方法的，所以，你在调用最上层的toString（）方法的时候，他会一次嵌套调用的。所以，才会这样，这个好像我当时测试什么的时候发现的，既然总结到这了，就多啰嗦两句吧，看官要是不信的话，大可以把这个代码贴出来，去掉某个复写的toString（）方法，再自己测试一下，就可以看到，我所言非虚啦。
关于使用中的问题。
在使用json字符串转Java对象的时候，可能会抛异常，我这遇到的是因为，我的Dog类，没有默认的构造函数，所以，就转换失败了，当添加了默认构造函数之后，就OK啦。看下图的异常截图。
可以看到，我这个默认的构造函数是刚刚添加的。
关于这个默认的构造函数，我们在实际开发的时候，还是一定要记的随时都给写上，不管自己用不用，都要加上，下面是我因为这个默认构造函数又出的bug。看链接：
好了，到此算是啰嗦完了。
等下，还是再啰嗦一下，
这个fastjson是在github上开源的，看链接：
没有更多推荐了，}