Java中的RPC(遠程服務調用)可以通過序列化的方式進行要出。
1. Jackson 進行JSON的解析和序列化
1.1 Jackson的API
1 需要注意的是:
-
ObjectMapper
是JSON
操作的核心霞掺,Jackson的JSON
操作都是在ObjectMapper
中實現的。 -
ObjectMapper
有多個JSON
序列化的方法讹躯,可以把JSON
串保存在File
菩彬、OutputStream
等不同的介質中。
2 Jackson的API:`
writeValue(File resultFile, Object value)
可以用于所有Java
值的序列化潮梯,將JSON
輸出到File
中骗灶。writeValue(OutputStream out, Object value)
可以用于所有Java
對象的序列化,并將JSON串保存到流中酷麦。注意矿卑,此方法不會顯示的關閉流。writeValueAsString(Object value)
可以用于任何Java
對象的序列化方式沃饶,并輸出字符串母廷。等效于writeValue(Writer,Object) 并構造String
糊肤,但是效率更高琴昆。writeValueAsBytes(Object value)
可用于任何Java
對象的序列化方式,并輸出byte[]
數組馆揉。等效于writeValue(Writer业舍,Object) 并得到byte[]數組
,注意數組的編碼是UTF-8
升酣;<T> T readValue(String content, Class<T> valueType)
注意舷暮,我們在傳入Class<T>
對象,注意一般是傳入Class<?>
噩茄,因為Class類中并不使用泛型對象下面,但是此處使用泛型對象,因為我們的返回值就是T
绩聘,避免了類型強轉沥割。溫故知新——泛型實踐篇
3. Jackson提供的注解
Jackson
提供了一系列的注解耗啦,方便對JSON
序列化和反序列化進行控制,下面介紹一些常用的注解:
-
JsonIgnore
此注解用于屬性上机杜,作用是Json
操作時帜讲,忽略該屬性。 -
JsonFormat
此注解用于屬性上椒拗, 作用是把Date
類型轉化成為想要的格式似将。 -
JsonProperty
此注解用于屬性上,作用是把改屬性的名稱序列化成另一個名稱陡叠。 -
JsonSerialize
此注解用于屬性上玩郊,作用是指定屬性序列化的類型肢执。 -
JsonDeserialize
此注解用于屬性上枉阵,作用是指定屬性反序列化的類型。
1.2 Jackson源碼分析
1.2.1 源碼
1. 引入MAVEN依賴:
<!--Jackson的API-->
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.9.4</version>
</dependency>
<!--JDK1.8時間類序列化-->
<dependency>
<groupId>com.fasterxml.jackson.datatype</groupId>
<artifactId>jackson-datatype-jsr310</artifactId>
</dependency>
2. 實體類
public class User implements Serializable {
private String name;
private List<String> sports;
//序列化格式
//@JsonSerialize(using = LocalDateSerializer.class)
//反序列化格式
//@JsonDeserialize(using = LocalDateDeserializer.class)
//Json格式
//@JsonFormat(pattern = "yyyy-MM-dd")
private LocalDate date;
//節(jié)省篇幅预茄,省略get/set方法
}
3. 測試類:
public static void main(String[] args) {
//創(chuàng)建用戶對象
User user = new User();
user.setName("小胖");
List sports = new ArrayList<>();
sports.add("足球");
sports.add("游泳");
user.setSports(sports);
user.setDate(LocalDate.now());
//創(chuàng)建對象
//Json序列化和反序列化
ObjectMapper mapper = new ObjectMapper();
// mapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);
// mapper.registerModule(new JavaTimeModule());
//User轉化為Json
try {
//對象轉化為Json數據
String s = mapper.writeValueAsString(user);
System.out.println("s:" + s);
//Json轉化為對象
User user1 = mapper.readValue(s, User.class);
System.out.println(user1.toString());
} catch (JsonProcessingException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
注意點:Jackson序列化對象時兴溜,對象必須實現getXxx方法。但是對象中若存在普通方法以
get
開頭耻陕,那么在序列化時拙徽,也會將該方法進行序列化。此時需要在方法上添加@JsonIgnore
注解诗宣。
public class School {
@JsonIgnore
public String getData(){
User user = new User();
return user.getFields().get(0);
}
}
1.2.2 源碼分析
首先注意的是JDK1.8
中時間類膘怕,采用了一套新的API。
在這里我們采用是LocalDate
類召庞,若是User
類中岛心,沒有使用注解,那么序列化結果為:
{
"name": "小胖",
"sports": ["足球", "游泳"],
"date": {
"year": 2019,
"month": "MARCH",
"chronology": {
"id": "ISO",
"calendarType": "iso8601"
},
"dayOfMonth": 27,
"dayOfWeek": "WEDNESDAY",
"dayOfYear": 86,
"era": "CE",
"monthValue": 3,
"leapYear": false
}
}
顯然篮灼,這不是我們預期的Json
串忘古。并且,我們在反序列化過程中诅诱,會出現異常:
com.fasterxml.jackson.databind.exc.InvalidDefinitionException: Cannot construct instance of java.time.LocalDate
(no Creators, like default construct, exist):
cannot deserialize from Object value (no delegate- or property-based Creator)
at [Source: (String)"{"name":"小胖","sports":["足球","游泳"],"date":{"year":2019,"month":"MARCH","chronology":{"id":"ISO","calendarType":"iso8601"},"dayOfMonth":27,"dayOfWeek":"WEDNESDAY","dayOfYear":86,"era":"CE","monthValue":3,"leapYear":false}}"; line: 1, column: 43] (through reference chain: com.JsonSerializer.User["date"])
大概意思:就是LocalDate
的沒有參數是Object
的構造函數髓堪。不能實例化對象。
華麗的分割線SpringBoot的處理
SpringBoot的解決方案:
- 首先在
MAVEN
中加入ckson-datatype-jsr310
依賴娘荡。
<dependency>
<groupId>com.fasterxml.jackson.datatype</groupId>
<artifactId>jackson-datatype-jsr310</artifactId>
</dependency>
- 配置
Configuration
中的ObjectMapper
干旁。
@Bean
public ObjectMapper serializingObjectMapper() {
ObjectMapper objectMapper = new ObjectMapper();
objectMapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);
objectMapper.registerModule(new JavaTimeModule());
return objectMapper;
}
Java bean的解決方案:
在Java Bean
中使用注解,就可以進行反序列化和序列化炮沐。
//序列化格式
@JsonSerialize(using = LocalDateSerializer.class)
//反序列化格式
@JsonDeserialize(using = LocalDateDeserializer.class)
//Json格式
@JsonFormat(pattern = "yyyy-MM-dd")
private LocalDate date;
執(zhí)行結果:
1.3 Jackson序列化工具類
為了便于使用Jackson進行序列化操作争群,故實現該工具類:
@Slf4j
public class JacksonUtils {
private static ObjectMapper objectMapper = new ObjectMapper();
/**
* 將對象序列化為JSON
*/
public static <T> String toJSONString(T obj) {
try {
return objectMapper.writeValueAsString(obj);
} catch (JsonProcessingException e) {
log.error("序列化失敗", e);
throw new RuntimeException(e);
}
}
/**
* @param str 反序列化的JSON串
* @param clazz 反序列化的目標對象
*/
public static <T> T parseObject(String str, Class<T> clazz) {
try {
return objectMapper.readValue(str, clazz);
} catch (IOException e) {
log.error("反序列化失敗", e);
throw new RuntimeException(e);
}
}
/**
* 帶泛型的反序列化
*
* @param str 待序列化的字符串
* @param type {@code new TypeReference<List<Student>>(){}}
* @param <T> 泛型對象
* @return 序列化為泛型對象
*/
public static <T> T parseObject(String str, TypeReference<T> type) {
try {
return objectMapper.readValue(str, type);
} catch (JsonProcessingException e) {
log.error("反序列化失敗", e);
throw new RuntimeException(e);
}
}
/**
* 驗證字符串是否為JSON格式。
* <p>
* 注意:該方法是比較簡易的判斷央拖,只是判斷字符串以什么開頭祭阀。
*
* @param str 待驗證的字符串
* @return true:為JSON格式鹉戚,false不為JSON格式
*/
public static boolean validateJSON(String str) {
return str.startsWith("{") || str.startsWith("[");
}
}
2. FastJson 序列化
2.1 FastJson的API
FastJson
是性能極好的JSON
解析器和生成器。
1. FastJson的優(yōu)點:
- 速度快:超越其他任何
java json parser
- 功能強大:支持
Java Bean
专控、Collection
抹凳、Map
、日期伦腐、枚舉赢底、支持泛型和自省。 - 零依賴:只依賴于
JDK
柏蘑。
2. FastJson的主要類:
- JSON:
FastJson
解析器幸冻,用于JSON
格式字符串與JSON
對象以及javaBean
之間轉換。 - JSONObject:
FastJson
提供的json
對象咳焚。 - JSONArray:
FastJson
提供的json
數組對象洽损。
2.2 FastJson的準備工作
1. FastJson的MAVEN依賴:
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>1.2.2</version>
</dependency>
2. JSON準備:
private static final String OBJ_JSON = "{\"studentName\":\"lily\",\"studentAge\":12}";
private static final String ARR_JSON = "[{\"studentName\":\"lily\",\"studentAge\":12},{\"studentName\":\"lucy\",\"studentAge\":15}]";
private static final String COMPLEX_JSON = "{\"teacherName\":\"crystall\",\"teacherAge\":27,\"course\":{\"courseName\":\"english\",\"code\":1270},\"students\":[{\"studentName\":\"lily\",\"studentAge\":12},{\"studentName\":\"lucy\",\"studentAge\":15}]}";
ARR_JSON格式:
[{
"studentName": "lily",
"studentAge": 12
}, {
"studentName": "lucy",
"studentAge": 15
}]
COMPLEX_JSON格式:
{
"teacherName": "crystall",
"teacherAge": 27,
"course": {
"courseName": "english",
"code": 1270
},
"students": [{
"studentName": "lily",
"studentAge": 12
}, {
"studentName": "lucy",
"studentAge": 15
}]
}
2.3 JSON字符串和JSONObject或JSONArray之間的轉換
我們日常操作是:JSON字符串和JavaBean對象之間的轉換。但是為什么存在JSONObject或者JSONArray對象呢革半?因為我們不想為每一個JSON字符串都創(chuàng)建一個Bean對象碑定,但是我們還是想像對象一樣操作JSON串時。就可這樣操作
2.3.1 JSON字符串和JSONObject之間的轉換
1 JSON到JSONObject的轉換又官;
JSONObject object = JSONObject.parseObject(OBJ_JSON);
- JSONObject到JSON的轉換延刘;
String toJSONString = JSONObject.toJSONString(object);
2.3.2 數組對象型——JSON和JSONArray轉換
- JSON到JSONArray的轉換;
JSONArray jsonArray = JSONArray.parseArray(ARR_JSON);
需要注意的是JSONArray實現了List<Object>接口六敬。- JSONArray到JSON的轉換碘赖;
String string = jsonArray.toJSONString();
2.3.3 如何操作JSONObject對象
- 獲取JSONObject里面的JSONObject對象;
jsonObject.getJSONObject("course");
- 獲取JSONObject里面的JSONArray對象外构;
jsonObject.getJSONArray("students");
- 獲取JSONObject里面的String或基本數據類型普泡;
jsonObject.getXXX("students");
public static void main(String[] args) {
JSONObject jsonObject = JSONObject.parseObject(COMPLEX_JSON);
//獲取JSON中的參數
jsonObject.getString("teacherName");
//獲取JSON中的對象
jsonObject.getJSONObject("course");
//獲取JSON中數組
jsonObject.getJSONArray("students");
//JSON轉換為Object
String jsonString = jsonObject.toJSONString();
System.out.println("序列化后的對象"+jsonString);
}
2.4 JSON字符串和JavaBean之間的轉換
JSON和JavaBean之間的轉化,其實是將轉化Bean的class對象傳入即可典勇。
public static <T> T parseJWT2Sub(String token, Class<T> clazz) {
SecretKey key = obtainKey();
Claims body = Jwts.parser().setSigningKey(key).parseClaimsJws(token).getBody();
return JSON.parseObject(body.getSubject(), clazz);
}
2.4.1 JSON轉化為Object(TypeReference方式)
在
FastJson
中提供了一個可用來處理泛型反序列化的類TypeRefernce
劫哼。
2.4.1.1 TypeRefrence進行反序列化
通過設置new TypeReference<Teacher<String>>() {};割笙,JSON字符串反序列化成Teacher對象會保留泛型<String>权烧;
使用方式:github的使用文檔
1. 通過TypeReference
處理泛型對象
Teacher<String> teacher = JSONObject.parseObject(COMPLEX_JSON, new TypeReference<Teacher<String>>() {
});
2. 使用getType()
可以獲取更好的性能。
Type type = new TypeReference<Teacher<String>>() {
}.getType();
Teacher<String> teacher = JSONObject.parseObject(COMPLEX_JSON, type);
2.4.1.2 TypeRefrence源碼分析
1. TypeRefrence部分源碼分析:
public class TypeReference<T> {
static ConcurrentMap<Type, Type> classTypeCache = new ConcurrentHashMap(16, 0.75F, 1);
protected final Type type;
public static final Type LIST_STRING = (new TypeReference<List<String>>() {
}).getType();
protected TypeReference() {
Type superClass = this.getClass().getGenericSuperclass();
Type type = ((ParameterizedType)superClass).getActualTypeArguments()[0];
Type cachedType = (Type)classTypeCache.get(type);
if (cachedType == null) {
classTypeCache.putIfAbsent(type, type);
cachedType = (Type)classTypeCache.get(type);
}
this.type = cachedType;
}
public Type getType() {
return this.type;
}
為什么這里的構造方法要是protected
的伤溉,即我們無法直接創(chuàng)建該對象般码,只能使用匿名類創(chuàng)建子類
對象。
getGenericSuperclass()的API方法
public Type getGenericSuperclass();
- Returns the Type representing the direct superclass of the entity (class, interface, primitive type or void) represented by this Class.
- If the superclass is a
parameterized type
, theType
object returned must accurately reflect the actual type parameters used in the source code.
返回Class
對象(類乱顾,接口板祝,基本數據類型,void)的直接父類的Type
類型走净。
如果父類是parameterized [p?'r?m?t?ra?zd]
類型(也可以理解為父類是泛型對象)券时,那么返回的參數類型是父類的泛型類型孤里。
基本原理:
類型擦除是擦除的方法中
Code
字節(jié)碼,但是會把泛型類型保存在Signature
中橘洞,不能通過反射直接獲取捌袜,但是可以通過子類
獲取父類的泛型類型。類型擦除不會將元數據(即類結構)上的泛型擦除炸枣,還是可以通過反射直接獲取虏等。復習盤點——泛型擦除。
可以通過
匿名內部類
的方式獲取子類适肠,在這里霍衫,推薦使用protected
構造方法,創(chuàng)建匿名類侯养。復習盤點——內部類
2.4.2 JSON轉化為Object(Class方式)
不保留泛型的反序列化敦跌。
使用public static <T> T parseObject(String text, Class<T> clazz)
方法,邊可完成JSON的反序列化沸毁。
1. 特殊JSON反序列化
需要注意的是峰髓,若是text為null的情況下傻寂,最后反序列化的結構也是為null
public static void main(String[] args) {
UserPO userPO = JSON.parseObject(null, UserPO.class);
System.out.println(userPO); //若是null息尺,反序列化對象也是null
UserPO userPO1 = JSON.parseObject("", UserPO.class);
System.out.println(userPO1); //若是空串,拋出異常
UserPO userPO2 = JSON.parseObject("{}", UserPO.class);
System.out.println(userPO2); //若是空JSON疾掰,返回空對象
}
2. 泛型丟失
Teacher teacher = JSONObject.parseObject(COMPLEX_JSON, Teacher.class);
我們可以看到搂誉,因為返回值需要泛型類型T
所以我們采用的是Class<T>
,防止返回Object對象静檬,讓用戶強轉炭懊。但需要注意:這種方式在反序列化的時候,會丟失泛型類型拂檩。
2.4.3 JSON轉化為Object集合對象
方式一:TypeReference
//獲取數組對象的List<Student>的Type
Type type = new TypeReference<ArrayList<Student>>() {
}.getType();
List<Student> list = JSONObject.parseObject(ARR_JSON, type);
System.out.println(list);
方式二:使用parseArray
List<Student> students = JSONObject.parseArray(ARR_JSON, Student.class);
2.4.4 Object轉化為(自定義格式)的JSON
我們通過:fastjson如何json數組串轉換為Object[]時如何指定各個數據項的數據類型引出fastjson SerializerFeature對象
我們可以通過這個API
侮腹,完成Bean
對象轉換成String
類型。
String toJSONString(Object object, SerializerFeature... features)
Student stu = new Student();
stu.setStudentAge(null);
stu.setStudentName("黎明");
String toJSONString = JSONObject.toJSONString(stu,
SerializerFeature.PrettyFormat,
SerializerFeature.WriteNullStringAsEmpty, //如果字符串是空稻励,那么返回""父阻,而非不返回
SerializerFeature.WriteNullNumberAsZero, //如果字符串是空,那么返回0望抽,而不是不返回加矛、
SerializerFeature.WriteClassName, //序列化時寫入類型信息,反序列化時用到
SerializerFeature.DisableCircularReferenceDetect); //消除對同一對象循環(huán)引用問題煤篙。
System.out.println(toJSONString);
2.5 JSON轉化為Object到底采用哪種方式
在項目中斟览,一般都是使用JSON進行數據的傳輸。那么通常采用Class方式還是TypeRefrence方式進行反序列化呢辑奈?
1. JSON轉化為簡單對象
若是對象的屬性只是簡單數據類型(基本數據類型苛茂,或者String類型)那么可以使用Class方式轉化為Object對象已烤。
JSON.parseObject(dataInfo.getData(), Order.class);
2. JSON轉化為復雜對象
若是一個對象里面的屬性依舊是一個對象,那么我們就可以使用TypeRefrence進行轉換妓羊。
public class ApiResponseVo<T> {
private String subCode;
private String subMsg;
private String count;
private List<T> list;
//省略 getter草戈、setter方法
}
我們在將JSON轉換為對象的時候,就可以保留List<T>的泛型侍瑟。即:
ApiResponseVo<Order> apiResponseVo=
JSON.parseObject(dataInfo.getData(), new TypeReference<ApiResponseVo<Order>>(){});