使用XStream序列化、反序列化XML数据时遇到的各种问题

简介:

现在参与的项目是一个纯Application Server,整个Server都是自己搭建的,使用JMS消息实现客户端和服务器的交互,交互的数据格式采用XML。说来惭愧,开始为了赶进度,所有XML消息都是使用字符串拼接的,而XML的解析则是使用DOM方式查找的。我很早就看这些代码不爽了,可惜一直没有时间去重构,最近项目加了几个人,而且美国那边也开始渐渐的把这个项目开发的控制权交给我们了,所以我开始有一些按自己的方式开发的机会了。因而最近动手开始重构这些字符串拼接的代码。

XMLJava Bean的解析框架,熟悉一点的只有DigesterXStreamDigester貌似只能从XML文件解析成Java Bean对象,所以只能选择XStream来做了,而且同组的其他项目也有在用XStream。一直听说XStream的使用比较简单,而且我对ThoughtWorks这家公司一直比较有好感,所以还以为引入XStream不会花太多时间,然而使用以后才发现XStream并没有想象的你那么简单。不过这个也有可能是因为我不想改变原来的XML数据格式,而之前的XML数据格式的设计自然不会考虑到如何便利的使用XStream。因而记录在使用过程中遇到的问题,供后来人参考,也为自己以后如果打算开其源码提供参考。废话就到这里了,接下来步入正题。

首先对于简单的引用,XStream使用起来确实比较简单,比如自定义标签的属性、使用属性和使用子标签的定义等:

@XStreamAlias( " request " )
public   class  XmlRequest1 {
    
private   static  XStream xstream;
    
static  {
        xstream 
=   new  XStream();
        xstream.autodetectAnnotations(
true );
    }
   
    @XStreamAsAttribute
    
private  String from;
   
    @XStreamAsAttribute
    @XStreamAlias(
" calculate-method " )
    
private  String calculateMethod;
   
    @XStreamAlias(
" request-time " )
    private  Date requestTime;
 
    @XStreamAlias(
" input-files " )
    
private  List < InputFileInfo >  inputFiles;
   
    
public   static  String toXml(XmlRequest1 request) {
        StringWriter writer 
=   new  StringWriter();
        writer.append(Constants.XML_HEADER);
        xstream.toXML(request, writer);
        
return  writer.toString();
    }
    
public   static  XmlRequest1 toInstance(String xmlContent) {
        
return  (XmlRequest1)xstream.fromXML(xmlContent);
}

    @XStreamAlias(
" input-file " )
    
public   static   class  InputFileInfo {
        
private  String type;
        
private  String fileName;
        
    }
    
public   static   void  main(String[] args) {
        XmlRequest1 request 
=  buildXmlRequest();
        System.out.println(XmlRequest1.toXml(request));
    }
    
private   static  XmlRequest1 buildXmlRequest() {
        
    }
}

 对以上Request定义,我们可以得到如下结果:

<? xml version="1.0" encoding="UTF-8" ?>
< request  from ="levin@host"  calculate-method ="advanced" >
 
< request-time > 2012-11-28 17:11:54.664 UTC </ request-time >
 
< input-files >
    
< input-file >
      
< type > DATA </ type >
      
< fileName > data.2012.11.29.dat </ fileName >
    
</ input-file >
    
< input-file >
      
< type > CALENDAR </ type >
      
< fileName > calendar.2012.11.29.dat </ fileName >
    
</ input-file >
 
</ input-files >
</ request >

可惜这个世界不会那么清净,这个格式有些时候貌似并不符合要求,比如request-time的格式、input-files的格式,我们实际需要的格式是这样的:

<? xml version="1.0" encoding="UTF-8" ?>
< request  from ="levin@host"  calculate-method ="advanced" >
 
< request-time > 20121128T17:51:05 </ request-time >
 
< input-file  type ="DATA" > data.2012.11.29.dat </ input-file >
 
< input-file  type ="CALENDAR" > calendar.2012.11.29.dat </ input-file >
</ request >

对不同Date格式的支持可以是用Converter实现,在XStream中默认使用自己实现的DateConverter,它支持的格式是:yyyy-MM-dd HH:mm:ss.S 'UTC',然而我们现在需要的格式是yyyy-MM-dd’T’HH:mm:ss,如果使用XStream直接注册DateConverter,可以使用配置自己的DateConverter,但是由于DateConverter的构造函数的定义以及@XStreamConverter的构造函数参数的支持方式的限制,貌似DateConverter不能很好的支持注解方式的注册,因而我时间了一个自己的DateConverter以支持注解:

public   class  LevinDateConverter  extends  DateConverter {
    
public  LevinDateConverter(String dateFormat) {
        
super (dateFormat,  new  String[] { dateFormat });
    }
}

requestTime字段中需要加入以下注解定义:

@XStreamConverter(value = LevinDateConverter. class , strings = { " yyyyMMdd'T'HH:mm:ss " })
@XStreamAlias(
" request-time " )
private  Date requestTime;

对集合类,XStream提供了@XStreamImplicit注解,以将集合中的内容摊平到上一层XML元素中,其中itemFieldName的值为其使用的标签名,此时InputFileInfo类中不需要@XStreamAlias标签的定义:

@XStreamImplicit(itemFieldName = " input-file " )
private  List < InputFileInfo >  inputFiles;

InputFileInfo中的字段,type作为属性很容易,只要为它加上@XStreamAsAttribute注解即可,而将fileName作为input-file标签的一个内容字符串,则需要使用ToAttributedValueConverter,其中Converter的参数为需要作为字符串内容的字段名:

@XStreamConverter(value = ToAttributedValueConverter. class , strings = { " fileName " })
public   static   class  InputFileInfo {
    @XStreamAsAttribute
    
private  String type;
private  String fileName;

}

XStream对枚举类型的支持貌似不怎么好,默认注册的EnumSingleValueConverter只是使用了Enum提供的name()和静态的valueOf()方法将enum转换成String或将String转换回enum。然而有些时候XML的字符串和类定义的enum值并不完全匹配,最常见的就是大小写的不匹配,此时需要写自己的Converter。在这种情况下,我一般会在enum中定义一个name属性,这样就可以自定义enum的字符串表示。比如有TimePeriodenum

public   enum  TimePeriod {
    MONTHLY(
" monthly " ), WEEKLY( " weekly " ), DAILY( " daily " );
   
    
private  String name;
   
    
public  String getName() {
        
return  name;
    }
   
    
private  TimePeriod(String name) {
        
this .name  =  name;
    }
   
    
public   static  TimePeriod toEnum(String timePeriod) {
        
try  {
            
return  Enum.valueOf(TimePeriod. class , timePeriod);
        } 
catch (Exception ex) {
            
for (TimePeriod period : TimePeriod.values()) {
                
if (period.getName().equalsIgnoreCase(timePeriod)) {
                    
return  period;
                }
            }
            
throw   new  IllegalArgumentException( " Cannot convert < "   +  timePeriod  +   " > to TimePeriod enum " );
        }
    }
}

我们可以编写以下Converter以实现对枚举类型的更宽的容错性:

public   class  LevinEnumSingleNameConverter  extends  EnumSingleValueConverter {
    
private   static   final  String CUSTOM_ENUM_NAME_METHOD  =   " getName " ;
    
private   static   final  String CUSTOM_ENUM_VALUE_OF_METHOD  =   " toEnum " ;
   
    
private  Class <?   extends  Enum <?>>  enumType;
 
    
public  LevinEnumSingleNameConverter(Class <?   extends  Enum <?>>  type) {
        
super (type);
        
this .enumType  =  type;
    }
 
    @Override
    
public  String toString(Object obj) {
        Method method 
=  getCustomEnumNameMethod();
        
if (method  ==   null ) {
            
return   super .toString(obj);
        } 
else  {
            
try  {
                
return  (String)method.invoke(obj, (Object[]) null );
            } 
catch (Exception ex) {
                
return   super .toString(obj);
            }
        }
    }
 
    @Override
    
public  Object fromString(String str) {
        Method method 
=  getCustomEnumStaticValueOfMethod();
        
if (method  ==   null ) {
            
return  enhancedFromString(str);
        }
        
try  {
            
return  method.invoke( null , str);
        } 
catch (Exception ex) {
            
return  enhancedFromString(str);
        }
    }
   
    
private  Method getCustomEnumNameMethod() {
        
try  {
            
return  enumType.getMethod(CUSTOM_ENUM_NAME_METHOD, (Class <?> []) null );
        } 
catch (Exception ex) {
            
return   null ;
        }
    }
   
    
private  Method getCustomEnumStaticValueOfMethod() {
        
try  {
            Method method 
=  enumType.getMethod(CUSTOM_ENUM_VALUE_OF_METHOD, (Class <?> []) null );
            
if (method.getModifiers()  ==  Modifier.STATIC) {
                
return  method;
            }
            
return   null ;
        } 
catch (Exception ex) {
            
return   null ;
        }
    }
   
    
private  Object enhancedFromString(String str) {
        
try  {
            
return   super .fromString(str);
        } 
catch (Exception ex) {
            
for (Enum <?>  item : enumType.getEnumConstants()) {
                
if (item.name().equalsIgnoreCase(str)) {
                    
return  item;
                }
            }
            
throw   new  IllegalStateException( " Cannot converter < "   +  str  +   " > to enum < "   +  enumType  +   " > " );
        }
    }
}

如下方式使用即可:

@XStreamAsAttribute
@XStreamAlias(
" time-period " )
@XStreamConverter(value
= LevinEnumSingleNameConverter. class )
private  TimePeriod timePeriod;

double类型,貌似默认的DoubleConverter实现依然不给力,它不支持自定义的格式,比如我们想在序列化的时候用一下格式: ###,##0.0########,此时又需要编写自己的Converter

public   class  FormatableDoubleConverter  extends  DoubleConverter {
    
private  String pattern;
    
private  DecimalFormat formatter;
   
    
public  FormatableDoubleConverter(String pattern) {
        
this .pattern  =  pattern;
        
this .formatter  =   new  DecimalFormat(pattern);
    }
   
    @Override
    
public  String toString(Object obj) {
        
if (formatter  ==   null ) {
            
return   super .toString(obj);
        } 
else  {
            
return  formatter.format(obj);
        }
    }
   
    @Override
    
public  Object fromString(String str) {
        
try  {
            
return   super .fromString(str);
        } 
catch (Exception ex) {
            
if (formatter  !=   null ) {
                
try  {
                    
return  formatter.parse(str);
                } 
catch (Exception e) {
                    
throw   new  IllegalArgumentException( " Cannot parse < "   +  str  +   " > to double value " , e);
                }
            }
            
throw   new  IllegalArgumentException( " Cannot parse < "   +  str  +   " > to double value " , ex);
        }
    }
   
    
public  String getPattern() {
        
return  pattern;
    }
}

使用方式和之前的Converter类似:

@XStreamAsAttribute
@XStreamConverter(value
= FormatableDoubleConverter. class , strings = { " ###,##0.0######## " })
private   double  value;

最后,还有两个XStream没法实现的,或者说我没有找到一个更好的实现方式的场景。第一种场景是XStream不能很好的处理对象组合问题:

在面向对象编程中,一般尽量的倾向于抽取相同的数据成一个类,而通过组合的方式构建整个数据结构。比如Student类中有nameaddressAddress是一个类,它包含citycodestreet等信息,此时如果要对Student对象做如下格式序列化:

< student  name =”Levin”>
 
<city > shanghai </ city >
 
< street > zhangjiang </ street >
 
< code > 201203 </ code >
</ student >

貌似我没有找到可以实现的方式,XStream能做是在中间加一层address标签。对这种场景的解决方案,一种是将Address中的属性平摊到Student类中,另一种是让Student继承自Address类。不过貌似这两种都不是比较理想的办法。

第二种场景是XStream不能很好的处理多态问题:

比如我们有一个Trade类,它可能表示不同的产品:

public   class  Trade {
    
private  String tradeId;
    private  Product product;

}
abstract   class  Product {
    
private  String name;
    
public  Product(String name) {
        
this .name  =  name;
}

}
class  FX  extends  Product {
    
private   double  ratio;
    
public  FX() {
        
super ( " fx " );
    }
    
}
class  Future  extends  Product {
    
private   double  maturity;
    
public  Future() {
        
super ( " future " );
    }
    
}

通过一些简单的设置,我们能得到如下XML格式:

< trades >
 
< trade  trade-id ="001" >
    
< product  class ="levin.xstream.blog.FX"  name ="fx"  ratio ="0.59" />
 
</ trade >
 
< trade  trade-id ="002" >
    
< product  class ="levin.xstream.blog.Future"  name ="future"  maturity ="2.123" />
 
</ trade >
</ trades >

作为数据文件,对Java类的定义显然是不合理的,因而简单一些,我们可以编写自己的Converterclass属性从product中去除:

xstream.registerConverter( new  ProductConverter(
        xstream.getMapper(), xstream.getReflectionProvider()));
 
    
public  ProductConverter(Mapper mapper, ReflectionProvider reflectionProvider) {
        
super (mapper, reflectionProvider);
    }
   
    @Override
    
public   boolean  canConvert(@SuppressWarnings( " rawtypes " ) Class type) {
        
return  Product. class .isAssignableFrom(type);
    }
 
    @Override
    
protected  Object instantiateNewInstance(HierarchicalStreamReader reader, UnmarshallingContext context) {
        Object currentObject 
=  context.currentObject();
        
if (currentObject  !=   null ) {
            
return  currentObject;
        }
       
        String name 
=  reader.getAttribute( " name " );
        
if ( " fx " .equals(name)) {
            
return  reflectionProvider.newInstance(FX. class );
        } 
else   if ( " future " .equals(name)) {
            
return  reflectionProvider.newInstance(Future. class );
        }
        
throw   new  IllegalStateException( " Cannot convert < "   +  name  +   " > product " );
    }
}

在所有Production上定义@XStreamAlias(“product”)注解。这时的XML输出结果为:

< trades >
 
< trade  trade-id ="001" >
    
< product  name ="fx"  ratio ="0.59" />
 
</ trade >
 
< trade  trade-id ="002" >
    
< product  name ="future"  maturity ="2.123" />
 
</ trade >
</ trades >

然而如果有人希望XML的输出结果如下呢?

< trades >
 
< trade  trade-id ="001" >
    
< fx  ratio ="0.59" />
 
</ trade >
 
< trade  trade-id ="002" >
    
< future  maturity ="2.123" />
 
</ trade >
</ trades >

大概找了一下,可能可以定义自己的Mapper来解决,不过XStream的源码貌似比较复杂,没有时间深究这个问题,留着以后慢慢解决吧。

补充:

对Map类型数据,XStream默认使用以下格式显示:

< map  class ="linked-hash-map" >
    
< entry >
      
< string > key1 </ string >
      
< string > value1 </ string >
    
</ entry >
    
< entry >
      
< string > key2 </ string >
      
< string > value2 </ string >
    
</ entry >
 
</ map >

 

但是对一些简单的Map,我们希望如下显示:

  < map >
    
< entry  key ="key1"  value ="value1" />
    
< entry  key ="key2"  value ="value2" />
 
</ map >

对这种需求需要通过编写Converter解决,继承自MapConverter,覆盖以下函数,这里的Map默认key和value都是String类型,如果他们不是String类型,需要另外添加逻辑:

@SuppressWarnings( " rawtypes " )
@Override
public   void  marshal(Object source, HierarchicalStreamWriter writer,
        MarshallingContext context) {
    Map map 
=  (Map) source;
    
for  (Iterator iterator  =  map.entrySet().iterator(); iterator.hasNext();) {
        Entry entry 
=  (Entry) iterator.next();
        ExtendedHierarchicalStreamWriterHelper.startNode(writer, mapper()
                .serializedClass(Map.Entry.
class ), entry.getClass());
 
        writer.addAttribute(
" key " , entry.getKey().toString());
        writer.addAttribute(
" value " , entry.getValue().toString());
        writer.endNode();
    }
}
 
@Override
@SuppressWarnings({ 
" unchecked " " rawtypes "  })
protected   void  putCurrentEntryIntoMap(HierarchicalStreamReader reader,
        UnmarshallingContext context, Map map, Map target) {
    Object key 
=  reader.getAttribute( " key " );
    Object value 
=  reader.getAttribute( " value " );
 
    target.put(key, value);
}

但是只是使用Converter,得到的结果多了一个class属性:

  < map  class ="linked-hash-map" >
    
< entry  key ="key1"  value ="value1" />
    
< entry  key ="key2"  value ="value2" />
 
</ map >

在XStream中,如果定义的字段是一个父类或接口,在序列化是会默认加入class属性以确定反序列化时用的类,为了去掉这个class属性,可以定义默认的实现类来解决(虽然感觉这种解决方案不太好,但是目前还没有找到更好的解决方案)。

xstream.addDefaultImplementation(LinkedHashMap.class, Map.class);

 


相关文章
|
12天前
|
JSON 数据格式 索引
Python中序列化/反序列化JSON格式的数据
【11月更文挑战第4天】本文介绍了 Python 中使用 `json` 模块进行序列化和反序列化的操作。序列化是指将 Python 对象(如字典、列表)转换为 JSON 字符串,主要使用 `json.dumps` 方法。示例包括基本的字典和列表序列化,以及自定义类的序列化。反序列化则是将 JSON 字符串转换回 Python 对象,使用 `json.loads` 方法。文中还提供了具体的代码示例,展示了如何处理不同类型的 Python 对象。
|
23天前
|
存储 安全 Java
Java编程中的对象序列化与反序列化
【10月更文挑战第22天】在Java的世界里,对象序列化和反序列化是数据持久化和网络传输的关键技术。本文将带你了解如何在Java中实现对象的序列化与反序列化,并探讨其背后的原理。通过实际代码示例,我们将一步步展示如何将复杂数据结构转换为字节流,以及如何将这些字节流还原为Java对象。文章还将讨论在使用序列化时应注意的安全性问题,以确保你的应用程序既高效又安全。
|
1月前
|
存储 Java
Java编程中的对象序列化与反序列化
【10月更文挑战第9天】在Java的世界里,对象序列化是连接数据持久化与网络通信的桥梁。本文将深入探讨Java对象序列化的机制、实践方法及反序列化过程,通过代码示例揭示其背后的原理。从基础概念到高级应用,我们将一步步揭开序列化技术的神秘面纱,让读者能够掌握这一强大工具,以应对数据存储和传输的挑战。
|
1月前
|
存储 安全 Java
Java编程中的对象序列化与反序列化
【10月更文挑战第3天】在Java编程的世界里,对象序列化与反序列化是实现数据持久化和网络传输的关键技术。本文将深入探讨Java序列化的原理、应用场景以及如何通过代码示例实现对象的序列化与反序列化过程。从基础概念到实践操作,我们将一步步揭示这一技术的魅力所在。
|
23天前
|
存储 缓存 NoSQL
一篇搞懂!Java对象序列化与反序列化的底层逻辑
本文介绍了Java中的序列化与反序列化,包括基本概念、应用场景、实现方式及注意事项。序列化是将对象转换为字节流,便于存储和传输;反序列化则是将字节流还原为对象。文中详细讲解了实现序列化的步骤,以及常见的反序列化失败原因和最佳实践。通过实例和代码示例,帮助读者更好地理解和应用这一重要技术。
22 0
|
1月前
|
XML Web App开发 数据格式
HTML 页面显示 XML 数据
10月更文挑战第2天
|
1月前
|
XML JSON 前端开发
C#使用HttpClient四种请求数据格式:json、表单数据、文件上传、xml格式
C#使用HttpClient四种请求数据格式:json、表单数据、文件上传、xml格式
361 0
|
2月前
|
JSON 安全 编译器
扩展类实例的序列化和反序列化
扩展类实例的序列化和反序列化
35 0
|
XML Java 数据格式
XStream xml与javabean之间的互转
XStream是thoughtworks公司发布的一个简单的Java类库,用于将JavaBean序列化为XML,并且能够将XML文件反向转换为JavaBean. 实例: user.java [java] view plain copy import java.io.Serializable;          public 
1376 0
|
1月前
|
XML 前端开发 Java
讲解SSM的xml文件
本文详细介绍了SSM框架中的xml配置文件,包括springMVC.xml和applicationContext.xml,涉及组件扫描、数据源配置、事务管理、MyBatis集成以及Spring MVC的视图解析器配置。
57 1