参考：http://www.cnblogs.com/hoojo/archive/2011/04/22/2024628.html
在其基础上做了稍微调整
详情见附件
jackson API文档：http://tool.oschina.net/apidocs/apidoc?api=jackson-1.9.9
Jackson 框架，轻易转换JSON
Jackson可以轻松的将Java对象转换成json对象和xml文档，同样也可以将json、xml转换成Java对象。相比json-lib框架，Jackson所依赖的jar包较少，简单易用并且性能也要相对高些。而且Jackson社区相对比较活跃，更新速度也比较快。
一、准备工作
pom.xml 里关联jar包如下：
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> <modelVersion>4.0.0</modelVersion> <groupId>com.waegg</groupId> <artifactId>jacksonTest</artifactId> <version>0.0.1-SNAPSHOT</version> <dependencies> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>4.12</version> </dependency> <dependency> <groupId>org.codehaus.jackson</groupId> <artifactId>jackson-mapper-asl</artifactId> <version>1.9.13</version> </dependency> <dependency> <groupId>com.fasterxml.jackson.dataformat</groupId> <artifactId>jackson-dataformat-xml</artifactId> <version>2.7.1</version> </dependency> </dependencies> <packaging>war</packaging> </project>
二、Bean代码
AccountBean ：
package com.bugyun.pojo;
public class AccountBean {
private int id;
private String name;
private String email;
private String address;
private Birthday birthday;
// getter、setter
@Override
public String toString() {
return this.name + "#" + this.id + "#" + this.address + "#" + this.birthday + "#" + this.email;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
public Birthday getBirthday() {
return birthday;
}
public void setBirthday(Birthday birthday) {
this.birthday = birthday;
}
}
Birthday：
package com.bugyun.pojo;
public class Birthday {
private String birthday;
public Birthday(String birthday) {
super();
this.birthday = birthday;
}
// getter、setter
public Birthday() {
}
public String getBirthday() {
return birthday;
}
public void setBirthday(String birthday) {
this.birthday = birthday;
}
@Override
public String toString() {
return this.birthday;
}
}
三、测试代码
package com.bugyun.test;
import java.io.IOException;
import java.io.StringWriter;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.codehaus.jackson.JsonEncoding;
import org.codehaus.jackson.JsonGenerationException;
import org.codehaus.jackson.JsonGenerator;
import org.codehaus.jackson.JsonParseException;
import org.codehaus.jackson.map.JsonMappingException;
import org.codehaus.jackson.map.ObjectMapper;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import com.bugyun.pojo.AccountBean;
import com.fasterxml.jackson.dataformat.xml.XmlMapper;
/**
* 项目名称：jacksonTest
* 类名称：JacksonTest.java
* 类描述：
* 创建人：beyond
* 创建时间：2016年2月24日 上午11:24:33
* 修改人：
* 修改时间：
* 修改备注：
* @version
*/
public class JacksonTest {
private JsonGenerator jsonGenerator = null;
private ObjectMapper objectMapper = null;
private AccountBean bean = null;
@Before
public void init() {
bean = new AccountBean();
bean.setAddress("js_wuxi");
bean.setEmail("bugyun@hotmail.com");
bean.setId(1);
bean.setName("bugyun");
objectMapper = new ObjectMapper();
try {
jsonGenerator = objectMapper.getJsonFactory().createJsonGenerator(System.out, JsonEncoding.UTF8);
} catch (IOException e) {
e.printStackTrace();
}
}
@After
public void destory() {
try {
if (jsonGenerator != null) {
jsonGenerator.flush();
}
if (!jsonGenerator.isClosed()) {
jsonGenerator.close();
}
jsonGenerator = null;
objectMapper = null;
bean = null;
System.gc();
} catch (IOException e) {
e.printStackTrace();
}
}
/**
*
* @description: JavaBean(Entity/Model)转换成JSON
* 上面分别利用JsonGenerator的writeObject方法和ObjectMapper的writeValue方法完成对Java对象的转换，二者传递的参数及构造的方式不同；
* JsonGenerator的创建依赖于ObjectMapper对象。
* 也就是说如果你要使用JsonGenerator来转换JSON，那么你必须创建一个ObjectMapper。
* 但是你用ObjectMapper来转换JSON，则不需要JSONGenerator。objectMapper的writeValue方法可以将一个Java对象转换成JSON。
* 这个方法的参数一，需要提供一个输出流，转换后可以通过这个流来输出转换后的内容。
* 或是提供一个File，将转换后的内容写入到File中。当然，这个参数也可以接收一个JSONGenerator，然后通过JSONGenerator来输出转换后的信息。
* 第二个参数是将要被转换的Java对象。如果用三个参数的方法，那么是一个Config。
* 这个config可以提供一些转换时的规则，过指定的Java对象的某些属性进行过滤或转换等。
*
* 输出：
* jsonGenerator {"id":1,"name":"bugyun","email":"bugyun@hotmail.com","address":"js_wuxi","birthday":null}
* ObjectMapper {"id":1,"name":"bugyun","email":"bugyun@hotmail.com","address":"js_wuxi","birthday":null}
* @return void
* @throws
* @author beyond
* @data:2016年2月24日上午11:34:53
*/
@Test
public void writeEntityJSON() {
try {
System.out.println("jsonGenerator");
jsonGenerator.writeObject(bean);
System.out.println("\nObjectMapper");
objectMapper.writeValue(System.out, bean);
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* @description: 将Map集合转换成Json字符串
* 输出：
* jsonGenerator {"name":"bugyun","account":{"id":1,"name":"bugyun","email":"bugyun@hotmail.com","address":"js_wuxi","birthday":null}}
* ObjectMapper {"name":"bugyun","account":{"id":1,"name":"bugyun","email":"bugyun@hotmail.com","address":"js_wuxi","birthday":null}}
* @return void
* @throws
* @author beyond
* @data:2016年2月24日上午11:41:48
*/
@Test
public void writeMapJSON() {
try {
Map<String, Object> map = new HashMap<String, Object>();
map.put("name", bean.getName());
map.put("account", bean);
System.out.println("jsonGenerator");
jsonGenerator.writeObject(map);
System.out.println("\n ObjectMapper");
objectMapper.writeValue(System.out, map);
} catch (IOException e) {
e.printStackTrace();
}
}
/**
*
* @description: 将List集合转换成json
* 外面就是多了个[]中括号；同样Array也可以转换，转换的JSON和上面的结果是一样的
* 输出：
* jsonGenerator [{"id":1,"name":"bugyun","email":"bugyun@hotmail.com","address":"js_wuxi","birthday":null}]
* ObjectMapper 1###[{"id":1,"name":"bugyun","email":"bugyun@hotmail.com","address":"js_wuxi","birthday":null}]
* 2###[{"id":1,"name":"bugyun","email":"bugyun@hotmail.com","address":"js_wuxi","birthday":null}]
* @return void
* @throws
* @author beyond
* @data:2016年2月24日上午11:46:41
*/
@Test
public void writeListJSON() {
try {
List<AccountBean> list = new ArrayList<AccountBean>();
list.add(bean);
System.out.println("jsonGenerator");
jsonGenerator.writeObject(list);
System.out.println("\nObjectMapper");
System.out.println("1###" + objectMapper.writeValueAsString(list));
System.out.print("2###");
objectMapper.writeValue(System.out, list);
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* @description: 复杂的Java类型的JSON转换
* 输出：
* {"user":{"name":"jackson","sex":true,"age":22},"infos":[22,"this is array"]}
* {"user":{"id":1,"name":"haha","email":"email","address":"address","birthday":null},"infos":["a","b","c"]}
* @return void
* @throws
* @author beyond
* @data:2016年2月24日下午1:08:06
*/
@Test
public void writeOthersJSON() {
try {
String[] arr = { "a", "b", "c" };
//Object
jsonGenerator.writeStartObject();//{
jsonGenerator.writeObjectFieldStart("user");//user:{
jsonGenerator.writeStringField("name", "jackson");//name:jackson
jsonGenerator.writeBooleanField("sex", true);//sex:true
jsonGenerator.writeNumberField("age", 22);//age:22
jsonGenerator.writeEndObject();//}
jsonGenerator.writeArrayFieldStart("infos");//infos:[
jsonGenerator.writeNumber(22);//22
jsonGenerator.writeString("this is array");//this is array
jsonGenerator.writeEndArray();//]
jsonGenerator.writeEndObject();//}
// ********************************************
AccountBean bean = new AccountBean();
bean.setAddress("address");
bean.setEmail("email");
bean.setId(1);
bean.setName("haha");
jsonGenerator.writeStartObject();//{
jsonGenerator.writeObjectField("user", bean);//user:{bean}
jsonGenerator.writeObjectField("infos", arr);//infos:[array]
jsonGenerator.writeEndObject();//}
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* @description: 将json字符串转换成JavaBean对象
* 用到了ObjectMapper这个对象的readValue这个方法，这个方法需要提供2个参数。
* 第一个参数就是解析的JSON字符串，
* 第二个参数是将这个JSON解析持什么Java对象，Java对象的类型。当然，还有其他相同签名方法。
*
* 输出：
* haha
* haha#1#address#null#email
* @return void
* @throws
* @author beyond
* @data:2016年2月24日下午3:37:50
*/
@Test
public void readJson2Entity() {
String json = "{\"address\":\"address\",\"name\":\"haha\",\"id\":1,\"email\":\"email\"}";
try {
AccountBean acc = objectMapper.readValue(json, AccountBean.class);
System.out.println(acc.getName());
System.out.println(acc);
} catch (JsonParseException e) {
e.printStackTrace();
} catch (JsonMappingException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* @description: json字符串转换成list<map>
* 输出：
* address:address2
* name:haha2
* id:2
* email:email2
* address:address
* name:haha
* id:1
* email:email
* @return void
* @throws
* @author beyond
* @data:2016年2月25日下午4:39:39
*/
@Test
public void readJson2List() {
String json = "[{\"address\": \"address2\",\"name\":\"haha2\",\"id\":2,\"email\":\"email2\"},"
+ "{\"address\":\"address\",\"name\":\"haha\",\"id\":1,\"email\":\"email\"}]";
try {
List<Map<String, Object>> list = objectMapper.readValue(json, List.class);
// System.out.println(list.size());
for (int i = 0; i < list.size(); i++) {
Map<String, Object> map = list.get(i);
Set<String> set = map.keySet();
for (Iterator it = set.iterator(); it.hasNext();) {
String key = (String) it.next();
System.out.println(key + ":" + map.get(key));
}
}
} catch (JsonParseException e) {
e.printStackTrace();
} catch (JsonMappingException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
/**
*
* @description: json字符串转换成Array
* 输出：
* haha2#2#address2#null#email2
* haha#1#address#null#email
* @return void
* @throws
* @author beyond
* @data:2016年2月25日下午4:44:09
*/
@Test
public void readJson2Array() {
String json = "[{\"address\": \"address2\",\"name\":\"haha2\",\"id\":2,\"email\":\"email2\"},"
+ "{\"address\":\"address\",\"name\":\"haha\",\"id\":1,\"email\":\"email\"}]";
try {
AccountBean[] arr = objectMapper.readValue(json, AccountBean[].class);
// System.out.println(arr.length);
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
} catch (JsonParseException e) {
e.printStackTrace();
} catch (JsonMappingException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
/**
*
* @description: json字符串转换Map集合
* 输出：
* success:true
* A:{address=address2, name=haha2, id=2, email=email2}
* B:{address=address, name=haha, id=1, email=email}
* @return void
* @throws
* @author beyond
* @data:2016年2月25日下午4:48:40
*/
@Test
public void readJson2Map() {
String json = "{\"success\":true,\"A\":{\"address\": \"address2\",\"name\":\"haha2\",\"id\":2,\"email\":\"email2\"},"
+ "\"B\":{\"address\":\"address\",\"name\":\"haha\",\"id\":1,\"email\":\"email\"}}";
try {
Map<String, Map<String, Object>> maps = objectMapper.readValue(json, Map.class);
// System.out.println(maps.size());
Set<String> key = maps.keySet();
Iterator<String> iter = key.iterator();
while (iter.hasNext()) {
String field = iter.next();
System.out.println(field + ":" + maps.get(field));
}
} catch (JsonParseException e) {
e.printStackTrace();
} catch (JsonMappingException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* @description: java Object 转换为 xml
* 输出：
* <ArrayList xmlns=""><item><id>1</id><name>bugyun</name><email>bugyun@hotmail.com</email><address>js_wuxi</address><birthday/></item></ArrayList>
* <HashMap xmlns=""><A><id>1</id><name>bugyun</name><email>bugyun@hotmail.com</email><address>js_wuxi</address><birthday/></A></HashMap>
* @return void
* @throws
* @author beyond
* @data:2016年2月26日上午9:20:49
*/
@Test
public void writeObject2Xml() {
XmlMapper xml = new XmlMapper();
try {
//javaBean转换成xml
//xml.writeValue(System.out, bean);
StringWriter sw = new StringWriter();
xml.writeValue(sw, bean);
// System.out.println(sw.toString());
// List转换成xml
List<AccountBean> list = new ArrayList<AccountBean>();
list.add(bean);
System.out.println(xml.writeValueAsString(list));
// Map转换xml文档
Map<String, AccountBean> map = new HashMap<String, AccountBean>();
map.put("A", bean);
System.out.println(xml.writeValueAsString(map));
} catch (JsonGenerationException e) {
e.printStackTrace();
} catch (JsonMappingException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}
相关推荐
在 Java 中，我们可以使用各种库和框架来将 JSON 转换为 List。其中，常用的库包括 Jackson、Gson 和 Fastjson 等。下面，我们将使用 Jackson 库来将 JSON 转换为 List。 首先，我们需要添加 Jackson 库的依赖项到...
如果JSON包含嵌套的对象或数组，它们会被转换为`Map`或`List`。 对于Map取值，你可以使用`get`方法： ```java String key = "exampleKey"; Object value = jsonData.get(key); ``` 如果值是另一个JSON对象或数组...
1. **XML到Map转换**： - 使用`dom4j`库可以解析XML文档为DOM（Document Object Model）对象，然后遍历DOM树将元素转换为Map。`DocumentHelper.createDocument()`方法创建一个新的XML文档对象，`Document`类代表...
本篇文章将深入探讨如何将Java中的List和Map对象转化为JSON格式，并涉及与AJAX交互的相关知识。 1. **Java JSON库**: 在Java中，我们可以使用多种库来实现对象到JSON的转换，如Jackson、Gson、Fastjson等。这里以...
在Java开发中，XML、List、Map和JSON之间的转换是常见的需求。XML用于数据交换，而JSON则常用于前后端的数据传输。以下是一些关于如何在Java中进行这些转换的关键知识点： 1. **XML到Map转换**： - 使用`...
Java在软件开发中经常涉及到数据格式的转换，如XML、List、Map以及JSON之间的相互转换。这些转换在处理数据交换、API调用或是序列化时非常常见。以下是一些关于如何在Java中进行这些转换的知识点： 1. JSON转换： ...
2. **Service层对象转换**：在业务逻辑中，我们可能会用到`ObjectMapper`来手动转换对象，比如将数据库查询结果转化为JSON格式返回给前端。 3. **配置优化**：在Spring的配置文件中，我们可以对Jackson进行定制，...
Java在软件开发中经常涉及到数据格式的转换，如XML、List、Map以及JSON之间的相互转换。这些转换在处理数据交换、API接口或者序列化时尤为关键。以下将详细讲解如何在Java中进行这些转换。 首先，JSON（JavaScript ...
在Java服务端，你可以使用如下的代码将List或Map转换为JSON： ```java import org.json.JSONArray; import org.json.JSONObject; // List转换 List<String> list = Arrays.asList("item1", "item2"); JSONArray ...
这个特定的jar包专注于将Map和List对象转换为JSON格式，这意味着它包含了Jackson的核心组件，如`Jackson-databind`模块，该模块提供了`ObjectMapper`类，它是Jackson序列化和反序列化的主力。 使用Jackson，你可以...
JSON数据和Java对象的相互转换 常见的解析器：Jsonlib，Gson，fastjson，jackson JSON转为Java对象 1. 导入jackson的相关jar包 2. 创建Jackson核心对象 ObjectMapper 3.调用ObjectMapper的相关方法进行...
在Eclipse中创建一个全新的Spring Boot项目，我们可以利用Spring框架的强大功能来处理JSON数据、POJO对象、Map以及List类型的请求。Spring Boot简化了Spring应用的初始搭建以及开发过程，它集成了大量的常用库，使得...
总结，SSH框架中将含有级联对象或集合的list转化为JSON，主要涉及Java对象到JSON的转换、EasyUI的数据格式要求以及与前端的数据交互。通过引入和使用Jackson库，我们可以方便地完成这一过程。同时，确保前端能够正确...
要将Java List转换为JSON，使用`writeValueAsString()`方法，但这次传入的是List： ```java String jsonArrayString = mapper.writeValueAsString(people); ``` 5. JSON到自定义复杂Java对象 对于更复杂的结构，...
- **Map与JSON**：Jackson可以方便地处理`Map, Object>`类型的数据，将Map转换为JSON或反之。`ObjectMapper.writeValueAsString(map)`可以将Map转换为JSON字符串，`mapper.readValue(json, Map.class)`则能将JSON...
Jackson库提供了高效、灵活的API，使得JSON与Java对象之间的转换变得简单易行。 Jackson库由FasterXML公司开发，其核心组件包括`Jackson-databind`、`Jackson-core`和`Jackson-annotations`。在本项目中，`jackson-...
比如，`fromJsonToList(String jsonString, Class<T> elementType)`可以将JSON数组转换为List，`fromJsonToMap(String jsonString, Class<K> keyType, Class<V> valueType)`可以将JSON对象转换为Map, V>。...
最后，使用org.json库的`JSONArray.fromObject()`方法将JSON字符串转换为`JSONArray`对象，再进一步转换为`List<Map>`： ```java import org.json.JSONArray; import org.json.JSONObject; List<Map, Object>> ...