参考资料：
首先添加maven依赖（版本用最新的）：
<dependency> <groupId>org.codehaus.jackson</groupId> <artifactId>jackson-mapper-asl</artifactId> <version>1.9.13</version> </dependency>
然后是POJO对象：
package jackson.pojo;
import java.util.ArrayList;
import java.util.List;
public class User {
private int age = 29;
private String name = "mkyong";
private List<String> messages = new ArrayList<String>() {
private static final long serialVersionUID = 1L;
{
add("msg 1");
add("msg 2");
add("msg 3");
}
};
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public List<String> getMessages() {
return messages;
}
public void setMessages(List<String> messages) {
this.messages = messages;
}
}
接下来，先测试JAVA对象-->JSON：
package jackson.tojson;
import jackson.pojo.User;
import java.io.File;
import org.codehaus.jackson.map.ObjectMapper;
public class JacksonExample {
public static void main(String[] args) throws Exception {
User user = new User();
ObjectMapper mapper = new ObjectMapper();
// convert user object to json string, and save to a file
mapper.writeValue(new File("e:\\user.json"), user);
// display to console
System.out.println(mapper.writerWithDefaultPrettyPrinter().writeValueAsString(user));
}
}
然后测试JSON->JAVA对象：
package jackson.fromjson;
import jackson.pojo.User;
import java.io.File;
import org.codehaus.jackson.map.ObjectMapper;
public class JacksonExample {
public static void main(String[] args) throws Exception {
ObjectMapper mapper = new ObjectMapper();
// read from file, convert it to user class
User user = mapper.readValue(new File("e:\\user.json"), User.class);
// display to console
System.out.println(mapper.writerWithDefaultPrettyPrinter().writeValueAsString(user));
}
}
JSON->Map:
package jackson.json2map;
import java.util.HashMap;
import java.util.Map;
import org.codehaus.jackson.map.ObjectMapper;
import org.codehaus.jackson.type.TypeReference;
public class JsonMapExample {
public static void main(String[] args) {
String json = "{\"name\":\"mkyong\", \"age\":\"29\"}";
Map<String,String> map = new HashMap<String,String>();
ObjectMapper mapper = new ObjectMapper();
try {
//convert JSON string to Map
map = mapper.readValue(json,
new TypeReference<HashMap<String,String>>(){});
System.out.println(map);
} catch (Exception e) {
e.printStackTrace();
}
}
}
Map->JSON:
package jackson.map2json;
import java.util.HashMap;
import java.util.Map;
import org.codehaus.jackson.map.ObjectMapper;
public class MapJsonExample {
public static void main(String[] args) {
try {
ObjectMapper mapper = new ObjectMapper();
String json = "";
Map<String, String> map = new HashMap<String, String>();
map.put("name", "mkyong");
map.put("age", "29");
//convert map to JSON string
json = mapper.writeValueAsString(map);
System.out.println(json);
} catch (Exception e) {
e.printStackTrace();
}
}
}
Map->JSON File:
package jackson.map2file;
import java.io.File;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.codehaus.jackson.map.ObjectMapper;
public class JsonMapFileExample {
public static void main(String[] args) {
ObjectMapper mapper = new ObjectMapper();
Map<String, Object> map = new HashMap<String, Object>();
map.put("name", "mkyong");
map.put("age", 29);
List<Object> list = new ArrayList<Object>();
list.add("msg 1");
list.add("msg 2");
list.add("msg 3");
map.put("messages", list);
try {
// write JSON to a file
mapper.writeValue(new File("e:\\user.json"), map);
} catch (Exception e) {
e.printStackTrace();
}
}
}
JSON FILE->Map:
package jackson.file2map;
import java.io.File;
import java.util.ArrayList;
import java.util.Map;
import org.codehaus.jackson.map.ObjectMapper;
import org.codehaus.jackson.type.TypeReference;
public class JsonFileMapExample {
public static void main(String[] args) {
try {
ObjectMapper mapper = new ObjectMapper();
// read JSON from a file
Map<String, Object> map = mapper.readValue(
new File("e:\\user.json"),
new TypeReference<Map<String, Object>>() {
});
System.out.println(map.get("name"));
System.out.println(map.get("age"));
@SuppressWarnings("unchecked")
ArrayList<String> list = (ArrayList<String>) map.get("messages");
for (String msg : list) {
System.out.println(msg);
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
用树的方式操作JSON:
package jackson.treemodel;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.util.Iterator;
import org.codehaus.jackson.JsonGenerationException;
import org.codehaus.jackson.JsonNode;
import org.codehaus.jackson.map.JsonMappingException;
import org.codehaus.jackson.map.ObjectMapper;
import org.codehaus.jackson.node.ObjectNode;
public class JacksonTreeNodeExample {
public static void main(String[] args) {
ObjectMapper mapper = new ObjectMapper();
try {
BufferedReader fileReader = new BufferedReader(
new FileReader("e:\\user.json"));
JsonNode rootNode = mapper.readTree(fileReader);
/*** read ***/
JsonNode nameNode = rootNode.path("name");
System.out.println(nameNode.getTextValue());
JsonNode ageNode = rootNode.path("age");
System.out.println(ageNode.getIntValue());
JsonNode msgNode = rootNode.path("messages");
Iterator<JsonNode> ite = msgNode.getElements();
while (ite.hasNext()) {
JsonNode temp = ite.next();
System.out.println(temp.getTextValue());
}
/*** update ***/
((ObjectNode)rootNode).put("nickname", "new nickname");
((ObjectNode)rootNode).put("name", "updated name");
((ObjectNode)rootNode).remove("age");
mapper.writeValue(new File("e:\\user.json"), rootNode);
} catch (JsonGenerationException e) {
e.printStackTrace();
} catch (JsonMappingException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}
用流的方式生成JSON：
package jackson.jsongenerator;
import java.io.File;
import java.io.IOException;
import org.codehaus.jackson.JsonEncoding;
import org.codehaus.jackson.JsonFactory;
import org.codehaus.jackson.JsonGenerationException;
import org.codehaus.jackson.JsonGenerator;
import org.codehaus.jackson.map.JsonMappingException;
public class JacksonStreamExample {
public static void main(String[] args) {
try {
JsonFactory jfactory = new JsonFactory();
/*** write to file ***/
JsonGenerator jGenerator = jfactory.createJsonGenerator(new File(
"e:\\user.json"), JsonEncoding.UTF8);
jGenerator.writeStartObject(); // {
jGenerator.writeStringField("name", "mkyong"); // "name" : "mkyong"
jGenerator.writeNumberField("age", 29); // "age" : 29
jGenerator.writeFieldName("messages"); // "messages" :
jGenerator.writeStartArray(); // [
jGenerator.writeString("msg 1"); // "msg 1"
jGenerator.writeString("msg 2"); // "msg 2"
jGenerator.writeString("msg 3"); // "msg 3"
jGenerator.writeEndArray(); // ]
jGenerator.writeEndObject(); // }
jGenerator.close();
} catch (JsonGenerationException e) {
e.printStackTrace();
} catch (JsonMappingException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}
用流的方式解析JSON：
package jackson.parsejson;
import java.io.File;
import java.io.IOException;
import org.codehaus.jackson.JsonFactory;
import org.codehaus.jackson.JsonGenerationException;
import org.codehaus.jackson.JsonParser;
import org.codehaus.jackson.JsonToken;
import org.codehaus.jackson.map.JsonMappingException;
public class JacksonStreamExample {
public static void main(String[] args) {
try {
JsonFactory jfactory = new JsonFactory();
/*** read from file ***/
JsonParser jParser = jfactory.createJsonParser(new File("e:\\user.json"));
// loop until token equal to "}"
while (jParser.nextToken() != JsonToken.END_OBJECT) {
String fieldname = jParser.getCurrentName();
if ("name".equals(fieldname)) {
// current token is "name",
// move to next, which is "name"'s value
jParser.nextToken();
System.out.println(jParser.getText()); // display mkyong
}
if ("age".equals(fieldname)) {
// current token is "age",
// move to next, which is "name"'s value
jParser.nextToken();
System.out.println(jParser.getIntValue()); // display 29
}
if ("messages".equals(fieldname)) {
jParser.nextToken(); // current token is "[", move next
// messages is array, loop until token equal to "]"
while (jParser.nextToken() != JsonToken.END_ARRAY) {
// display msg1, msg2, msg3
System.out.println(jParser.getText());
}
}
}
jParser.close();
} catch (JsonGenerationException e) {
e.printStackTrace();
} catch (JsonMappingException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}
相关推荐
### Jackson电动力学习题答案详解 #### 一、Jackson电动力学概述 《Classical Electrodynamics》（经典电动力学）第三版是由J.D. Jackson编写的经典教材，在学术界享有极高的声誉。该书内容详尽、研究深入且备受...
### JACKSON 经典电动力学习题解答知识点详解 #### 一、背景介绍 《JACKSON 经典电动力学习题解答》是一本在物理学领域内被广泛认可的经典教材的辅助资料。它包含了大量练习题及其解答，旨在帮助学生深入理解和掌握...
这篇“Jackson快速入门”将带你快速掌握Jackson的核心功能和使用方法。 首先，我们需要了解Jackson的基本组件。核心组件包括`Jackson-databind`，它提供了`ObjectMapper`类，用于实现对象到JSON和JSON到对象的转换...
`jackson-core-2.9.3.jar`文件包含了Jackson库的基础组件，如JsonParser和JsonGenerator，它们分别用于读取和写入JSON数据。此外，还包含了一些关键类，如JsonNode，它是JSON树模型的根节点，用于构建和操作JSON结构...
在本"Jackson学习实例"中，我们将深入探讨Jackson库的核心概念、主要功能以及如何在实际项目中应用。 一、Jackson简介 Jackson是由FasterXML团队开发的开源库，它的全名是com.fasterxml.jackson.databind，是Java...
10. **社区支持和文档**：Jackson有着活跃的社区和详尽的文档，开发者可以在遇到问题时获取帮助，同时学习如何充分利用这个库。 综上所述，Jackson 2.6版本包含了全面的JSON处理功能，从基础的流式API到高级的数据...
在本篇文章中，我们将通过实例来入门Jackson的使用。 一、Jackson库简介 Jackson库的核心组件包括： 1. `Jackson-databind`：提供将Java对象映射到JSON和从JSON反序列化回Java对象的功能。 2. `Jackson-core`：基础...
在第一章，Jackson首先介绍了矢量分析和场论的基础知识，为后续章节建立必要的数学基础。随后，他详细讲解了静电学，包括电势、电场和电偶极子，以及高斯定理和泊松方程的应用。在动力学部分，书中涉及洛伦兹力、...
该书在某些地方假设了读者对基础材料的熟悉度，省略了关键步骤，并且提供的实例不足。对于初学者而言，这可能是一本难以消化的书籍。然而，Jackson的野心在于他几乎涵盖了经典电磁理论的大部分内容，除了一些明显的...
总之，Jackson库是Java开发中处理JSON不可或缺的工具，`jackson-core-asl`和`jackson-mapper-asl`这两个组件共同构成了JSON操作的基础。虽然提供的版本较旧，但它们展示了JSON处理的基本原理和方法，对于理解和学习...
首先，标题"Jackson电动力学答案"和描述"Jackson电动力学所有解题答案，帮助大家更好理解电动...同时，也提醒读者在学习过程中需要有耐心和系统性的学习方法，从基础的概念入手，逐步深入到更复杂的理论和实践问题中。
在阅读和学习"jackson电动力学[1]"这个压缩包中的内容时，读者可以期待获得对电动力学理论的深刻理解和实践经验。通过解决书中问题，读者将能够掌握电动力学的基本原理，并为研究更复杂的物理现象打下坚实基础。无论...
这是Jackson的基础模块，其他模块都依赖于它。 3. **Jackson-annotations**：包含了一组注解，用于配置对象到JSON的映射规则，如`@JsonProperty`、`@JsonInclude`等，使得无需编写大量的代码就能实现复杂的序列化和...
Jackson撰写，自出版以来一直被广泛用作电动力学课程的基础教材。郭硕鸿教授的电动力学教材虽然同样受到好评，但杰克逊的版本以其深入浅出、严谨精确的论述闻名，深受学者和学生喜爱。 电动力学是物理学的一个重要...
1. **Jackson-core**: 这是Jackson库的基础模块，包含了基本的JSON流处理API，如`JsonParser`和`JsonGenerator`，它们分别用于读取和写入JSON数据。 2. **Jackson-databind**: 这个模块提供了更高级别的数据绑定...
在这个名为"JAVA-jackson.zip"的压缩包中，包含了学习Jackson和JSON解析所需的资源。 首先，我们要了解Jackson库的核心组件。主要有三个： 1. **Jackson-databind**：这是Jackson的核心模块，提供了将Java对象转换...
2. **jackson-core-2.8.5.jar**：这是Jackson的基础模块，包含JSON解析和生成的基本API。例如`JsonParser`和`JsonGenerator`类，分别用于解析JSON输入流和生成JSON输出流。此外，它还提供了一些基本类型转换工具，如...
通过对`jackson-core-2.7.9`源码的分析，开发者可以了解JSON处理的底层细节，学习如何利用Jackson实现高效的数据转换，以及如何通过定制和扩展Jackson满足特定的应用场景需求。这对于深入理解和优化JSON处理流程，...
为了实现反序列化，Java对象必须实现`java.io.Serializable`接口，这是Java序列化机制的基础。 【Jackson反序列化原理】 Jackson库是Java中广泛使用的JSON处理库，它提供了高效的序列化和反序列化功能。Jackson的...
2. **jackson-core-2.8.9.jar**：这是Jackson的基础模块，包含了解析和生成JSON的基本功能。它提供了流式API，允许开发者逐个处理JSON令牌，从而实现高效的JSON处理。此外，还包含了一些基本的JSON类型，如`...