1.引用json库

<!-- jackson -->
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-core</artifactId>
<version>2.9.5</version>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-annotations</artifactId>
<version>2.9.5</version>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.9.5</version>
</dependency>
 

2. json 转化辅助类

(1)json 字符串 与对象相互转化

（2）json字符串与map相互转化

（3）json字符串转map带有对象

（4）json字符串与ist相互转化

package com.demo.test.utils;
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import org.apache.commons.lang.StringUtils;
import net.sf.json.JSONArray;
import net.sf.json.JSONObject;
import com.fasterxml.jackson.core.JsonParseException;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.JsonMappingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;
/**
 * JSON工具类
 */public  Class  JSONUtil {

 /**
 * Json String convert to object with javaBean
 */ public static <T> T jsonToObject(String jsonStr, Class<T> clz) {
 if (StringUtils. isEmpty (jsonStr)) {
 return null;
 }
 ObjectMapper mapper = getObjectMapper();
try {
return mapper.readValue(jsonStr, clz);
} catch (Exception e) {
e.printStackTrace();
}
return null;
 }
 
 /**
 * json string convert to map
 */ @SuppressWarnings("unchecked")
public static Map<String, Object> jsonToMap(String jsonStr){
 ObjectMapper mapper = getObjectMapper();
 try {
return mapper.readValue(jsonStr, Map.class);
} catch (JsonParseException e) {
e.printStackTrace();
} catch (JsonMappingException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
 return null;
 }
 
 //@SuppressWarnings("unchecked")
public static String mapToJson(Map<String, Object> map){
 ObjectMapper mapper = getObjectMapper();
 try {
return mapper.writeValueAsString(map);
} catch (JsonParseException e) {
e.printStackTrace();
} catch (JsonMappingException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
 return null;
 }
 
 /**
 * json string convert to map with javaBean
 */ public static <T> Map<String, T> jsonToMap(String jsonStr, Class<T> clazz){
 ObjectMapper mapper = getObjectMapper();
 Map<String, Map<String, Object>> map;
 Map<String, T> result = new HashMap<String, T>();
try {
map = mapper.readValue(jsonStr,
 new TypeReference<Map<String, T>>() {
 });
for (Entry<String, Map<String, Object>> entry : map.entrySet()) {
 result.put(entry.getKey(), mapToObject(entry.getValue(), clazz));
 }
 return result;
} catch (JsonParseException e) {
e.printStackTrace();
} catch (JsonMappingException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
return null;
 }
 
 /**
 * json array string convert to list with javaBean
 */ public static <T> List<T> jsonToList(String jsonArrayStr, Class<T> clazz)
 throws Exception {
 ObjectMapper mapper = getObjectMapper();
 List<Map<String, Object>> list = mapper.readValue(jsonArrayStr,
 new TypeReference<List<T>>() {
 });
 List<T> result = new ArrayList<T>();
 for (Map<String, Object> map : list) {
 result.add(mapToObject(map, clazz));
 }
 return result;
 }
 
 public static List<String> jsonToStringList(String jsonArrayStr)
 throws Exception {
 ObjectMapper mapper = getObjectMapper();
 List<String> list = mapper.readValue(jsonArrayStr,
 new TypeReference<List<String>>() {
 });
 List<String> result = new ArrayList<String>();
 for (String str : list) {
 result.add(str);
 }
 return result;
 }
 /**
 *Json String convert to object with TypeReference
 */ public static <T> T jsonToObject(String jsonStr, TypeReference<T> typeRef) {
 if (StringUtils.isEmpty(jsonStr)) {
 return null;
 }
 ObjectMapper mapper = getObjectMapper();
 try {
 return mapper.readValue(jsonStr, typeRef);
 } catch (Exception e) {
 e.printStackTrace();
 }
 return null;
 }
 /**
 * object convert to Json String
 */ public static String objectToJson(Object object) {
 if (object == null) {
 return null;
 }
 ObjectMapper mapper = getObjectMapper();
 try {
return mapper.writeValueAsString(object);
} catch (JsonProcessingException e) {
e.printStackTrace();
}
 return null;
 }
 
 /**
 * map convert to javaBean
 */ public static <T> T mapToObject(Map<String,Object> map, Class<T> clazz) {
 ObjectMapper mapper = getObjectMapper();
 return mapper.convertValue(map, clazz);
 }
 
 /**
 * javaBean convert to map
 */ public static Map<String,Object> objectToMap(Object object){
 String json = objectToJson(object);
 return jsonToMap(json);
 }
 
 public static JSONObject stringToObject(String jsonStr) {
 try {
 if (StringUtils.isEmpty(jsonStr)) {
 return null;
 }
 
 JSONObject json = JSONObject.fromObject(jsonStr);
 return json;
 } catch (Exception e) {
 return null;
 }
 }
 public static JSONArray stringToArray(String jsonStr) {
 try {
 if (StringUtils.isEmpty(jsonStr)) {
 return null;
 }
 JSONArray json = JSONArray.fromObject(jsonStr);
 return json;
 } catch (Exception e) {
 return null;
 }
}
 
 private static ObjectMapper getObjectMapper() {
 ObjectMapper objectMapper = new ObjectMapper();
 objectMapper.configure(SerializationFeature.WRITE_NULL_MAP_VALUES,  false );
 objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
 objectMapper.configure(SerializationFeature.FAIL_ON_EMPTY_BEANS, false);
 objectMapper.configure(JsonParser.Feature.ALLOW_UNQUOTED_FIELD_NAMES, true); 
 objectMapper.setDateFormat(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss")); 
 return objectMapper;
 }
}
 

3.使用

Map<String, Object> rsMap = new HashMap<String, Object>();
rsMap.put("phone", "136xxxxx");
rsMap.put("type", "1");
String jsonStr = JSONUtil.mapToJson(rsMap);