关于对象序列化、jackson以及jackson和cxf配合使用的一些心得体、对象克隆、对象深度复制...

最新推荐文章于 2024-06-27 23:15:00 发布

转载最新推荐文章于 2024-06-27 23:15:00 发布 · 373 阅读

1 ·

CC 4.0 BY-SA版权

原文链接：https://my.oschina.net/fengshuzi/blog/418976

文章标签：

#json #java #python

本文探讨了Java序列化的基本概念及其应用场景，并通过实例演示了序列化与反序列化的操作流程。此外，还介绍了对象克隆及深度复制的实现方法，并讨论了cxf与jackson在RESTful API中的应用技巧。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

2019独角兽企业重金招聘Python工程师标准>>>

一、前言

趁着周末学习一番，目标如下：

明白什么事java序列化，如何进行java序列化和反序列化
对jackson工具包系统的学习，从了json转换外还有没有其他好用的功能，jackson和cxf如何更好的派和使用
java对象克隆的使用场景在哪儿，如何通过克隆进行java的深度复制

二、对象序列化（object serialization）

1、概念

java的向对象序列化API，它提供了一个框架，用来将对象编码成字节流，并从字节流编码中重新构建对象。“将一个对象编码成一个字节流”称作将改对象序列化（serializing）；相反处理过程被称作反序列化（deserializing）。

2、java序列化的要点

你可以通过序列化来存储对象的状态
使用ObjectOutPutStream来序列化对象（Java.IO)
用FileOutPutStream链接ObjectOutPutStream来讲对象序列化到文件中
调用ObjectOutPutStream的writeObject(the object) 来将对象序列化，不需调用FileOutPutStream的方法
静态变量不会被序列化，因为所有对象都是共享同一份静态变量值

3、例子将person对象反序列化

package com.fengshu.Spring;

import java.io.Serializable;

public class Person implements Serializable {

	private static final long serialVersionUID = 1L;

	private String name;
	private int age;

	public Person(String name, int age) {
		this.name = name;
		this.age = age;
	}

	public String getName() {
		return name;
	}

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

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	@Override
	public String toString() {
		return "对象序列化 [name=" + name + ", age=" + age + "]";
	}

}




package com.fengshu.Spring;


import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;


public class SeriableTest {
  public static void main(String[] args) throws Exception {  
        File file = new File("E:\\result.txt");  //如果不存在会被创建
        ObjectOutputStream oout = new ObjectOutputStream(new FileOutputStream(file));  
        Person person = new Person("John", 101);  
        oout.writeObject(person);  
        oout.close();  
  
        ObjectInputStream oin = new ObjectInputStream(new FileInputStream(file));  
        Person newPerson = (Person)oin.readObject();
        oin.close();  
        System.out.println(newPerson);  
    }  
}

二、对象克隆和深度复制

1、以订单为例，下面是一组订单相关的对象，这些对象装在一个clone对象里面

订单对象

package com.fengshu.Spring;

import java.util.List;

public class Order {
	@Override
	public String toString() {
		return "Order [name=" + name + ", orderItems=" + orderItems + "]";
	}

	private String name;
	private List<OrderItem> orderItems;

	public String getName() {
		return name;
	}

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

	public List<OrderItem> getOrderItems() {
		return orderItems;
	}

	public void setOrderItems(List<OrderItem> orderItems) {
		this.orderItems = orderItems;
	}

}

订单详细对象

package com.fengshu.Spring;

public class OrderItem {
	@Override
	public String toString() {
		return "OrderItem [name=" + name + ", price=" + price + "]";
	}

	private String name;
	private double  price;

	public String getName() {
		return name;
	}

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

	public double getPrice() {
		return price;
	}

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

订单结算对象

在实际项目中假设以上两个对象用于跟数据库打交道，很多时候我们为了解耦，我们会建立另外一组用于业务逻辑的对象。如下：

用于业务逻辑的订单对象

package com.fengshu.Spring;

import java.util.List;

public class OrderDTO {
	@Override
	public String toString() {
		return "OrderDTO [name=" + name + ", orderItems=" + orderItems + "]";
	}

	private String name;
	private List<OrderItemDTO> orderItems;

	public String getName() {
		return name;
	}

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

	public List<OrderItemDTO> getOrderItems() {
		return orderItems;
	}

	public void setOrderItems(List<OrderItemDTO> orderItems) {
		this.orderItems = orderItems;
	}

}

用于业务逻辑的订单详细对象

package com.fengshu.Spring;

public class OrderItemDTO {
	@Override
	public String toString() {
		return "OrderItemDTO [name=" + name + "]";
	}

	private String name;

	public String getName() {
		return name;
	}

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

用于业务逻辑的订单结算对象

package com.fengshu.Spring;

import java.util.List;

public class SettleOrderDTO {
	@Override
	public String toString() {
		return "SettleOrderDTO [name=" + name + ", orders=" + orders + "]";
	}
	private String  name;
	private List<OrderDTO> orders;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public List<OrderDTO> getOrders() {
		return orders;
	}
	public void setOrders(List<OrderDTO> orders) {
		this.orders = orders;
	}
	
	
}

2、那么问题来了，我们如何一次性的把SettleOrderView里面的内容复制给SettleOrderDTO ，使用过apache或spring的beanUtils工具类的开发人员都知道beanutils在copy对象的过程中是不会帮忙copy对象里面的复杂属性的，即所谓的浅复制，那么如何进行深度复制呢，有一个办法是通过json字符串作为中间对象来进行转换，

3、json方式如下

package com.fengshu.Spring;

import java.util.ArrayList;
import java.util.List;

public class Clone {
	
	
	private  static List<OrderItem> orderItems =  new ArrayList<OrderItem>();
	
	private static List<Order> orders = new ArrayList<Order>();
	
	static SettlerOrderView settlerOrderView = new SettlerOrderView();
	
	static {
		init();
	}
	
	
	public static  void init() {
		OrderItem orderItem = new OrderItem();
		orderItem.setName("orderitem");
		orderItems.add(orderItem);
		
		Order order = new Order();
		order.setName("order");
		order.setOrderItems(orderItems);
		orders.add(order);
		settlerOrderView.setName("settlerOrderView");
		settlerOrderView.setOrders(orders);
	}
	
	public static void main(String[] args) {
		try {
			String jsonStr = JsonUtils.toJson(settlerOrderView);
			System.out.println(jsonStr);
			
			SettleOrderDTO  settleOrderDTO  =  JsonUtils.getObjectMapper().readValue(jsonStr, SettleOrderDTO.class);
			
			jsonStr = JsonUtils.toJson(settleOrderDTO);
			System.out.println(jsonStr);//price 为0  被忽略了 
		} catch (Exception e) {
			// TODO: handle exception
		}
		
	}
}

json工具类

package com.fengshu.Spring;

import java.io.IOException;

import org.codehaus.jackson.JsonEncoding;
import org.codehaus.jackson.JsonGenerationException;
import org.codehaus.jackson.JsonGenerator;
import org.codehaus.jackson.JsonNode;
import org.codehaus.jackson.JsonParseException;
import org.codehaus.jackson.map.JsonMappingException;
import org.codehaus.jackson.map.ObjectMapper;
import org.codehaus.jackson.map.annotate.JsonSerialize.Inclusion;

public class JsonUtils {

	public static final String MESSAGE = "message";

	@SuppressWarnings("unused")
	private static JsonGenerator jsonGenerator;

	private static ObjectMapper objectMapper;

	@SuppressWarnings("deprecation")
	private static void init() {
		objectMapper = new ObjectMapper();
		objectMapper.getSerializationConfig().setSerializationInclusion(Inclusion.ALWAYS);
		objectMapper.getDeserializationConfig().set(org.codehaus.jackson.map.DeserializationConfig.Feature.FAIL_ON_UNKNOWN_PROPERTIES, false);
		try {
			jsonGenerator = objectMapper.getJsonFactory().createJsonGenerator(System.out, JsonEncoding.UTF8);

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

	public static ObjectMapper getObjectMapper() {
		if (objectMapper == null) {
			init();
		}
		return objectMapper;
	}

	public static String toJson(Object obj) throws JsonGenerationException, JsonMappingException, IOException {
		return getObjectMapper().writeValueAsString(obj);
	}

	public static <T> T formJson(JsonNode json, Class<T> clazz) throws JsonParseException, JsonMappingException, IOException {
		return getObjectMapper().readValue(json, clazz);
	}

}