全部栏目

首页 旅游资讯 线路攻略 景点大全 国内游 境外游 美食特产
您的当前位置：首页正文

Jackson常用方法以及jacksonUtil工具类详解

来源：我们爱旅游
Jackson常⽤⽅法以及jacksonUtil⼯具类详解

前⾔：

项⽬中我们通常使⽤ajax返回json数据格式的形式进⾏前后端数据交互，所以会⽤到java数据json数据互相转化，通常我们的做法是在项⽬中创建⼀个⼯具类进⾏转化处理。

如下：

我的demo包含了项⽬中常⽤的jacksonUtil类，以及常⽤的JSON JAVA处理数据转化处理⽅法。项⽬结构以及引⽤jar包如下，jar包中的junit是⽤于单元测试，与jackson及其相关的包⽆关。每个部分我都加了注释，直接copy下来运⾏就可以查看具体效果，下⾯直接上代码：

实体类book:

package test.entity; public class Book {

private int bookId;//书的ID private String author;//作者 private String name;//书名 private int price;//书价

public int getBookId() { return bookId; }

public void setBookId(int bookId) { this.bookId = bookId; }

public String getAuthor() { return author; }

public void setAuthor(String author) { this.author = author; }

public String getName() { return name; }

public void setName(String name) { this.name = name; }

public int getPrice() { return price; }

public void setPrice(int price) { this.price = price; }

@Override

public String toString() {

return \"Book [bookId=\" + bookId + \ + name + \ } }

jackson以及相关jar包对java以及json数据的具体处理⽅法，JackSonDemo类。

package test.jackson; import java.io.IOException;import java.util.ArrayList;import java.util.Arrays;import java.util.HashMap;import java.util.Iterator;import java.util.List;import java.util.Map;import java.util.Set; import org.junit.After;import org.junit.Before;import org.junit.Test; import test.entity.Book;

import com.fasterxml.jackson.core.JsonEncoding;import com.fasterxml.jackson.core.JsonGenerator;

import com.fasterxml.jackson.core.JsonParseException;

import com.fasterxml.jackson.databind.JsonMappingException;import com.fasterxml.jackson.databind.ObjectMapper; public class JackSonDemo {

private JsonGenerator jsonGenerator = null; private ObjectMapper objectMapper = null; private Book book = null; /**

* Junit的⽅法，⽤于给每个单元测试添加前置条件和结束条件 */

@Before

public void init() {

// 构建⼀个Book实例对象并赋值 book = new Book();

book.setAuthor(\"海明威\"); book.setBookId(123);

book.setName(\"⽼⼈与海\"); book.setPrice(30);

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; book = null; System.gc();

} catch (IOException e) { e.printStackTrace(); }

}

/********************** java常见数据类型转JSON ****************************/ /**

* 1.javaBean转化成json---两种⽅法writeObject/writeValue均可 * jsonGenerator依赖于ObjectMapper创建 */ @Test

public void javaBeanToJson() {

try {

System.out.println(\"jsonGenerator\"); // ⽅法⼀

jsonGenerator.writeObject(book); System.out.println();

System.out.println(\"ObjectMapper\"); // ⽅法⼆

objectMapper.writeValue(System.out, book);

} catch (IOException e) { e.printStackTrace(); } } /**

* List转化成JSON，三种⽅式 */ @Test

public void listToJson() { try {

List list = new ArrayList(); Book bookOne = new Book(); bookOne.setAuthor(\"安徒⽣\"); bookOne.setBookId(456);

bookOne.setName(\"安徒⽣童话\"); bookOne.setPrice(55);

Book bookTwo = new Book(); bookTwo.setAuthor(\"安徒⽣\"); bookTwo.setBookId(456);

bookTwo.setName(\"安徒⽣童话\"); bookTwo.setPrice(55); list.add(bookOne); list.add(bookTwo); // ⽅式⼀

System.out.println(\"⽅式⼀jsonGenerator\"); jsonGenerator.writeObject(list); System.out.println();

System.out.println(\"⽅式⼆ObjectMapper\"); // ⽅式⼆

System.out.println(objectMapper.writeValueAsString(list)); // ⽅式三

System.out.println(\"⽅式三直接通过objectMapper的writeValue⽅法:\"); objectMapper.writeValue(System.out, list); } catch (IOException e) { e.printStackTrace(); } } /**

* map转化成JSON,两种⽅式 */ @Test

public void mapToJSON() { try {

Map map = new HashMap(); map.put(\"name\ map.put(\"book\

Book newBook = new Book(); newBook.setAuthor(\"安徒⽣\"); newBook.setBookId(456);

newBook.setName(\"安徒⽣童话\"); newBook.setPrice(55);

map.put(\"newBook\

System.out.println(\"第⼀种⽅式jsonGenerator\"); jsonGenerator.writeObject(map);

System.out.println(\"\");

System.out.println(\"第⼆种⽅式objectMapper\"); objectMapper.writeValue(System.out, map); } catch (IOException e) { e.printStackTrace(); } }

/*********************** JSON数据类型转java数据 ********************************/ /**

* json'对象'数据转化成javaBean */ @Test

public void jsonToJavaBean() {

String json = \"{\\\"bookId\\\":\\\"11111\\\鲁迅\\\朝花⼣拾\\\ try {

Book book = objectMapper.readValue(json, Book.class); System.out.println(book);

} catch (JsonParseException e) { e.printStackTrace();

} catch (JsonMappingException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } } /**

* json'数组'数据转化为ArrayList */ @Test

public void jsonToArrayList() {

String json = \"[{\\\"bookId\\\":\\\"11111\\\鲁迅\\\朝花⼣拾\\\ + \"{\\\"bookId\\\":\\\"11111\\\鲁迅\\\朝花⼣拾\\\ try {

Book[] book = objectMapper.readValue(json, Book[].class); for (int i = 0; i < book.length; i++) {

// 注意book[i]仅仅是数组，需要通过Arrays.asList()⽅法转为ArrayList List list = Arrays.asList(book[i]); System.out.println(list); }

} catch (JsonParseException e) { e.printStackTrace();

} catch (JsonMappingException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } } /**

* json转换成map */ @Test

public void JsonToMap() {

String json = \"{\\\"name\\\":\\\"book\\\鲁迅\\\朝花⼣拾\\\ + \"\\\"book2\\\":{\\\"bookId\\\":\\\"22222\\\易中天\\\祖先\\\ try {

Map> maps = objectMapper.readValue( json, Map.class);

Set key = maps.keySet(); Iterator 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(); } }

}

最后，是我们在实际开发项⽬中使⽤的jacksonUtil类，应⽤起来很简单，直接jacksonUtil.bean2Json(Object object)(bean转JSON)或者jacksonUtil.json2Bean(Object object)(JSON转bean)

package test.util;

import java.io.IOException;import java.io.StringWriter;

import com.fasterxml.jackson.core.JsonFactory;import com.fasterxml.jackson.core.JsonGenerator;

import com.fasterxml.jackson.core.JsonParseException;

import com.fasterxml.jackson.databind.JsonMappingException;import com.fasterxml.jackson.databind.ObjectMapper; /**

* bean转json格式或者json转bean格式, 项⽬中我们通常使⽤这个⼯具类进⾏json---java互相转化 */

public class JacksonUtil {

private static ObjectMapper mapper = new ObjectMapper();

public static String bean2Json(Object obj) throws IOException { StringWriter sw = new StringWriter();

JsonGenerator gen = new JsonFactory().createJsonGenerator(sw); mapper.writeValue(gen, obj); gen.close();

return sw.toString(); }

public static T json2Bean(String jsonStr, Class objClass) throws JsonParseException, JsonMappingException, IOException { return mapper.readValue(jsonStr, objClass); }}

Jackson⼯具类（各种转换）

⾸先要在项⽬中引⼊jackson的jar包（在此不做说明）

下⾯直接上代码

public class JacksonUtils {

private final static ObjectMapper objectMapper = new ObjectMapper(); private JacksonUtils() { }

public static ObjectMapper getInstance() { return objectMapper; } /**

* javaBean、列表数组转换为json字符串 */

public static String obj2json(Object obj) throws Exception { return objectMapper.writeValueAsString(obj); } /**

* javaBean、列表数组转换为json字符串,忽略空值 */

public static String obj2jsonIgnoreNull(Object obj) throws Exception { ObjectMapper mapper = new ObjectMapper();

mapper.setSerializationInclusion(JsonInclude.Include.NON_NULL); return mapper.writeValueAsString(obj); } /**

* json 转JavaBean */

public static T json2pojo(String jsonString, Class clazz) throws Exception {

objectMapper.configure(DeserializationFeature.ACCEPT_SINGLE_VALUE_AS_ARRAY, true); return objectMapper.readValue(jsonString, clazz); } /**

* json字符串转换为map */

public static Map json2map(String jsonString) throws Exception { ObjectMapper mapper = new ObjectMapper();

mapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);

return mapper.readValue(jsonString, Map.class); } /**

* json字符串转换为map */

public static Map json2map(String jsonString, Class clazz) throws Exception {

Map> map = objectMapper.readValue(jsonString, new TypeReference>() { });

Map result = new HashMap();

for (Map.Entry> entry : map.entrySet()) { result.put(entry.getKey(), map2pojo(entry.getValue(), clazz)); }

return result; } /**

* 深度转换json成map *

* @param json * @return */

public static Map json2mapDeeply(String json) throws Exception { return json2MapRecursion(json, objectMapper); } /**

* 把json解析成list，如果list内部的元素存在jsonString，继续解析 *

* @param json

* @param mapper 解析⼯具 * @return

* @throws Exception */

private static List json2ListRecursion(String json, ObjectMapper mapper) throws Exception { if (json == null) { return null; }

List list = mapper.readValue(json, List.class); for (Object obj : list) {

if (obj != null && obj instanceof String) { String str = (String) obj; if (str.startsWith(\"[\")) {

obj = json2ListRecursion(str, mapper); } else if (obj.toString().startsWith(\"{\")) { obj = json2MapRecursion(str, mapper); } } }

return list; } /**

* 把json解析成map，如果map内部的value存在jsonString，继续解析 *

* @param json * @param mapper * @return

* @throws Exception */

private static Map json2MapRecursion(String json, ObjectMapper mapper) throws Exception { if (json == null) { return null; }

Map map = mapper.readValue(json, Map.class); for (Map.Entry entry : map.entrySet()) { Object obj = entry.getValue();

if (obj != null && obj instanceof String) { String str = ((String) obj); if (str.startsWith(\"[\")) {

List list = json2ListRecursion(str, mapper); map.put(entry.getKey(), list); } else if (str.startsWith(\"{\")) {

Map mapRecursion = json2MapRecursion(str, mapper); map.put(entry.getKey(), mapRecursion); } } }

return map; }

/**

* 与javaBean json数组字符串转换为列表 */

public static List json2list(String jsonArrayStr, Class clazz) throws Exception { JavaType javaType = getCollectionType(ArrayList.class, clazz);

List lst = (List) objectMapper.readValue(jsonArrayStr, javaType); return lst; } /**

* 获取泛型的Collection Type *

* @param collectionClass 泛型的Collection * @param elementClasses 元素类 * @return JavaType Java类型 * @since 1.0 */

public static JavaType getCollectionType(Class collectionClass, Class... elementClasses) { return objectMapper.getTypeFactory().constructParametricType(collectionClass, elementClasses); } /**

* map 转JavaBean */

public static T map2pojo(Map map, Class clazz) { return objectMapper.convertValue(map, clazz); } /**

* map 转json *

* @param map * @return */

public static String mapToJson(Map map) { try {

return objectMapper.writeValueAsString(map); } catch (Exception e) { e.printStackTrace(); }

return \"\"; } /**

* map 转JavaBean */

public static T obj2pojo(Object obj, Class clazz) { return objectMapper.convertValue(obj, clazz); }}

导⼊相应的包 就可以使⽤，个⼈觉得还是挺⽅便的！

以上为个⼈经验，希望能给⼤家⼀个参考，也希望⼤家多多⽀持。

因篇幅问题不能全部显示，请点此查看更多更全内容

查看全文
Copyright © 2019- 版权所有