先定义两个bean
首先是一个User对象
public class User implements Serializable {
private static final long serialVersionUID = -8329084343916143192L;
private String name;
private Phone phone;
省略set和get以及toString然后是一个Phone
public class Phone implements Serializable {
private static final long serialVersionUID = 5812700698675174172L;
private String phoneName;
private int price;
省略set和get以及toString
}这里说下bean要序列化
对象序列化是一个用于将对象状态转换为字节流的过程，可以将其保存到磁盘文件中或通过网络发送到任何其他程序；从字节流创建对象的相反的过程称为反序列化。而创建的字节流是与平台无关的，在一个平台上序列化的对象可以在不同的平台上反序列化。
SerialVersionUID是一个标识符，当它通常使用对象的哈希码序列化时会标记在对象上。我们可以通过Java中serialver工具找到该对象的serialVersionUID。SerialVersionUID用于对象的版本控制。当您添加或修改类中的任何字段时，已经序列化的类将无法恢复，因为serialVersionUID已为新类生成与旧的序列化对象将不同。Java序列化过程依赖于正确的serialVersionUID恢复序列化对象的状态，并在serialVersionUID不匹配时抛出java.io.InvalidClassException 异常。
Transient 关键字
transient修饰符仅适用于变量，不适用于方法和类。在序列化时，如果我们不想序列化特定变量以满足安全约束，那么我们应该将该变量声明为transient。执行序列化时，JVM会忽略transient变量的原始值并将默认值保存到文件中。因此，transient意味着不要序列化。
静态变量不是对象状态的一部分，因此它不参与序列化。所以将静态变量声明为transient变量是没有用处的。
final变量将直接通过值参与序列化，所以将final变量声明为transient变量不会产生任何影响。现在，让我们考虑一个显示Java中的序列化和反序列化的程序。
我们首先使用jackson来序列化一个对象和一个对象集合
List<User> users=new ArrayList<User>();
Phone phone=new Phone();
phone.setPhoneName("苹果");
phone.setPrice(5099);
User user=new User();
user.setName("小明");
user.setPhone(phone);
users.add(user);
users.add(user);
users.add(user);
ObjectMapper objectMapper=new ObjectMapper();
String userjson="";
String usersjson="";
try {
userjson=objectMapper.writeValueAsString(user);
usersjson=objectMapper.writeValueAsString(users);
} catch (JsonProcessingException e) {
e.printStackTrace();
}
System.out.println(userjson);
System.out.println("-----------------");
System.out.println(usersjson);输出
{“name”:“小明”,“phone”:{“phoneName”:“苹果”,“price”:5099}}
[{“name”:“小明”,“phone”:{“phoneName”:“苹果”,“price”:5099}},
{“name”:“小明”,“phone”:{“phoneName”:“苹果”,“price”:5099}},
{“name”:“小明”,“phone”:{“phoneName”:“苹果”,“price”:5099}}]
这里上一个jackson的util包
public class JsonUtils {
public static final ObjectMapper mapper = new ObjectMapper();
private static final Logger logger = LoggerFactory.getLogger(JsonUtils.class);
// 序列化
public static String serialize(Object obj) {
if (obj == null) {
return null;
}
if (obj.getClass() == String.class) {
return (String) obj;
}
try {
return mapper.writeValueAsString(obj);
} catch (JsonProcessingException e) {
logger.error("json序列化出错：" + obj, e);
return null;
}
}
public static <T> T parse(String json, Class<T> tClass) {
try {
return mapper.readValue(json, tClass);
} catch (IOException e) {
logger.error("json解析出错：" + json, e);
return null;
}
}
public static <E> List<E> parseList(String json, Class<E> eClass) {
try {
return mapper.readValue(json, mapper.getTypeFactory().constructCollectionType(List.class, eClass));
} catch (IOException e) {
logger.error("json解析出错：" + json, e);
return null;
}
}
public static <K, V> Map<K, V> parseMap(String json, Class<K> kClass, Class<V> vClass) {
try {
return mapper.readValue(json, mapper.getTypeFactory().constructMapType(Map.class, kClass, vClass));
} catch (IOException e) {
logger.error("json解析出错：" + json, e);
return null;
}
}
public static <T> T nativeRead(String json, TypeReference<T> type) {
try {
return mapper.readValue(json, type);
} catch (IOException e) {
logger.error("json解析出错：" + json, e);
return null;
}
}
}ObjectMapper是JSON操作的核心，Jackson的所有JSON操作都是在ObjectMapper中实现。
ObjectMapper有多个JSON序列化的方法，可以把JSON字符串保存File、OutputStream等不同的介质中。
writeValue(File arg0, Object arg1)把arg1转成json序列，并保存到arg0文件中。
writeValue(OutputStream arg0, Object arg1)把arg1转成json序列，并保存到arg0输出流中。
writeValueAsBytes(Object arg0)把arg0转成json序列，并把结果输出成字节数组。
writeValueAsString(Object arg0)把arg0转成json序列，并把结果输出成字符串。
JSON注解：Jackson提供了一系列注解，方便对JSON序列化和反序列化进行控制，下面介绍一些常用的注解。
@JsonIgnore 此注解用于属性上，作用是进行JSON操作时忽略该属性。
@JsonFormat 此注解用于属性上，作用是把Date类型直接转化为想要的格式，如@JsonFormat(pattern = “yyyy-MM-dd HH-mm-ss”)。
@JsonProperty 此注解用于属性上，作用是把该属性的名称序列化为另外一个名称，如把trueName属性序列化为name， @JsonProperty(“name”)。
再来一个fastjsonUtils
public class FastJsonUtils {
/**
* 功能描述：把JSON数据转换成指定的java对象
* @param jsonData JSON数据
* @param clazz 指定的java对象
* @return 指定的java对象
*/
public static <T> T getJsonToBean(String jsonData, Class<T> clazz) {
return JSON.parseObject(jsonData, clazz);
}
/**
* 功能描述：把java对象转换成JSON数据
* @param object java对象
* @return JSON数据
*/
public static String getBeanToJson(Object object) {
return JSON.toJSONString(object);
}
/**
* 功能描述：把JSON数据转换成指定的java对象列表
* @param jsonData JSON数据
* @param clazz 指定的java对象
* @return List<T>
*/
public static <T> List<T> getJsonToList(String jsonData, Class<T> clazz) {
return JSON.parseArray(jsonData, clazz);
}
/**
* 功能描述: 把JSON数据转换成指定的map类型
* @Param: jsonData JSON数据
* @Return:Map<K, V>
*/
public static <K, V> Map<K, V> stringToCollect(String jsonData) {
return JSONObject.parseObject(jsonData,new TypeReference<Map<K,V>>(){});
}
/**
* 功能描述：把JSON数据转换成较为复杂的List<Map<String, Object>>
* @param jsonData JSON数据
* @return List<Map<String, Object>>
*/
public static List<Map<String, Object>> getJsonToListMap(String jsonData) {
return JSON.parseObject(jsonData, new TypeReference<List<Map<String, Object>>>() {
});
}
}
