前言：
项目中我们通常使用ajax返回json数据格式的形式进行前后端数据交互，所以会用到java数据json数据互相转化，通常我们的做法是在项目中创建一个工具类进行转化处理。
如下：
我的demo包含了项目中常用的jacksonUtil类，以及常用的JSON JAVA处理数据转化处理方法。
项目结构以及引用jar包如下，jar包中的junit是用于单元测试，与jackson及其相关的包无关。
每个部分我都加了注释，直接copy下来运行就可以查看具体效果，下面直接上代码：
实体类book:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 |
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 + ", author=" + author + ", name=" + name + ", price=" + price + "]" ; } } |
jackson以及相关jar包对java以及json数据的具体处理方法，JackSonDemo类。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 |
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<Book> list = new ArrayList<Book>(); 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<String, Object> map = new HashMap<String, Object>(); map.put( "name" , book.getName()); map.put( "book" , book); Book newBook = new Book(); newBook.setAuthor( "安徒生" ); newBook.setBookId( 456 ); newBook.setName( "安徒生童话" ); newBook.setPrice( 55 ); map.put( "newBook" , 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\",\"author\":\"鲁迅\",\"name\":\"朝花夕拾\",\"price\":\"45\"}" ; 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\",\"author\":\"鲁迅\",\"name\":\"朝花夕拾\",\"price\":\"45\"}," + "{\"bookId\":\"11111\",\"author\":\"鲁迅\",\"name\":\"朝花夕拾\",\"price\":\"45\"}]" ; try { Book[] book = objectMapper.readValue(json, Book[]. class ); for ( int i = 0 ; i < book.length; i++) { // 注意book[i]仅仅是数组，需要通过Arrays.asList()方法转为ArrayList List<Book> 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\",\"number\":\"12138\",\"book1\":{\"bookId\":\"11111\",\"author\":\"鲁迅\",\"name\":\"朝花夕拾\",\"price\":\"45\"}," + "\"book2\":{\"bookId\":\"22222\",\"author\":\"易中天\",\"name\":\"祖先\",\"price\":\"25\"}}" ; try { Map<String, Map<String, Object>> maps = objectMapper.readValue( json, Map. class ); 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(); } } } |
最后，是我们在实际开发项目中使用的jacksonUtil类，应用起来很简单，直接jacksonUtil.bean2Json(Object object)(bean转JSON)或者jacksonUtil.json2Bean(Object object)(JSON转bean)
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 |
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> T json2Bean(String jsonStr, Class<T> objClass) throws JsonParseException, JsonMappingException, IOException { return mapper.readValue(jsonStr, objClass); } } |
Jackson工具类（各种转换）
首先要在项目中引入jackson的jar包（在此不做说明）
下面直接上代码
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 |
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> T json2pojo(String jsonString, Class<T> clazz) throws Exception { objectMapper.configure(DeserializationFeature.ACCEPT_SINGLE_VALUE_AS_ARRAY, true ); return objectMapper.readValue(jsonString, clazz); } /** * json字符串转换为map */ public static <T> Map<String, Object> 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 <T> Map<String, T> json2map(String jsonString, Class<T> clazz) throws Exception { Map<String, Map<String, Object>> map = objectMapper.readValue(jsonString, new TypeReference<Map<String, T>>() { }); Map<String, T> result = new HashMap<String, T>(); for (Map.Entry<String, Map<String, Object>> entry : map.entrySet()) { result.put(entry.getKey(), map2pojo(entry.getValue(), clazz)); } return result; } /** * 深度转换json成map * * @param json * @return */ public static Map<String, Object> json2mapDeeply(String json) throws Exception { return json2MapRecursion(json, objectMapper); } /** * 把json解析成list，如果list内部的元素存在jsonString，继续解析 * * @param json * @param mapper 解析工具 * @return * @throws Exception */ private static List<Object> json2ListRecursion(String json, ObjectMapper mapper) throws Exception { if (json == null ) { return null ; } List<Object> 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<String, Object> json2MapRecursion(String json, ObjectMapper mapper) throws Exception { if (json == null ) { return null ; } Map<String, Object> map = mapper.readValue(json, Map. class ); for (Map.Entry<String, Object> 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<String, Object> mapRecursion = json2MapRecursion(str, mapper); map.put(entry.getKey(), mapRecursion); } } } return map; } /** * 与javaBean json数组字符串转换为列表 */ public static <T> List<T> json2list(String jsonArrayStr, Class<T> clazz) throws Exception { JavaType javaType = getCollectionType(ArrayList. class , clazz); List<T> lst = (List<T>) 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> T map2pojo(Map map, Class<T> 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> T obj2pojo(Object obj, Class<T> clazz) { return objectMapper.convertValue(obj, clazz); } } |
导入相应的包 就可以使用，个人觉得还是挺方便的！
以上为个人经验，希望能给大家一个参考，也希望大家多多支持。
原文链接：https://blog.csdn.net/Huangcsdnjava/article/details/72869206
查看更多关于Jackson常用方法以及jacksonUtil工具类详解的详细内容...