XStream方法列表

最新推荐文章于 2024-05-28 17:52:21 发布
最新推荐文章于 2024-05-28 17:52:21 发布
阅读量703 收藏
点赞数
分类专栏： Json Jackson Xml jackson Java 文章标签： XStream方法列表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zzc1684/article/details/84718362
版权

http://xstream.codehaus.org/javadoc/com/thoughtworks/xstream/XStream.html#ignoreUnknownElements%28%29

 

 

com.thoughtworks.xstream

Class XStream


  • public class XStream
extends Object
    Simple facade to XStream library, a Java-XML serialization tool.

     

    Example 
     XStream xstream = new XStream();
 String xml = xstream.toXML(myObject); // serialize to XML
 Object myObject2 = xstream.fromXML(xml); // deserialize from XML

    Aliasing classes

    To create shorter XML, you can specify aliases for classes using the alias() method. For example, you can shorten all occurrences of element <com.blah.MyThing> to <my-thing> by registering an alias for the class.

     

     xstream.alias("my-thing", MyThing.class);

    Converters

    XStream contains a map of Converter instances, each of which acts as a strategy for converting a particular type of class to XML and back again. Out of the box, XStream contains converters for most basic types (String, Date, int, boolean, etc) and collections (Map, List, Set, Properties, etc). For other objects reflection is used to serialize each field recursively.

    Extra converters can be registered using the registerConverter() method. Some non-standard converters are supplied in the com.thoughtworks.xstream.converters.extended package and you can create your own by implementing the Converter interface.

     

    Example 
     xstream.registerConverter(new SqlTimestampConverter());
 xstream.registerConverter(new DynamicProxyConverter());

    The converters can be registered with an explicit priority. By default they are registered with XStream.PRIORITY_NORMAL. Converters of same priority will be used in the reverse sequence they have been registered. The default converter, i.e. the converter which will be used if no other registered converter is suitable, can be registered with priority XStream.PRIORITY_VERY_LOW. XStream uses by default the ReflectionConverter as the fallback converter.

     

    Example 
     xstream.registerConverter(new CustomDefaultConverter(), XStream.PRIORITY_VERY_LOW);

    Object graphs

    XStream has support for object graphs; a deserialized object graph will keep references intact, including circular references.

    XStream can signify references in XML using either relative/absolute XPath or IDs. The mode can be changed using setMode():

     
    xstream.setMode(XStream.XPATH_RELATIVE_REFERENCES); (Default) Uses XPath relative references to signify duplicate references. This produces XML with the least clutter.
    xstream.setMode(XStream.XPATH_ABSOLUTE_REFERENCES);Uses XPath absolute references to signify duplicate references. This produces XML with the least clutter.
    xstream.setMode(XStream.SINGLE_NODE_XPATH_RELATIVE_REFERENCES);Uses XPath relative references to signify duplicate references. The XPath expression ensures that a single node only is selected always.
    xstream.setMode(XStream.SINGLE_NODE_XPATH_ABSOLUTE_REFERENCES);Uses XPath absolute references to signify duplicate references. The XPath expression ensures that a single node only is selected always.
    xstream.setMode(XStream.ID_REFERENCES);Uses ID references to signify duplicate references. In some scenarios, such as when using hand-written XML, this is easier to work with.
    xstream.setMode(XStream.NO_REFERENCES);This disables object graph support and treats the object structure like a tree. Duplicate references are treated as two separate objects and circular references cause an exception. This is slightly faster and uses less memory than the other two modes.

    Thread safety

    The XStream instance is thread-safe. That is, once the XStream instance has been created and configured, it may be shared across multiple threads allowing objects to be serialized/deserialized concurrently. Note, that this only applies if annotations are not auto-detected on-the-fly.

    Implicit collections

    To avoid the need for special tags for collections, you can define implicit collections using one of the addImplicitCollection methods.

    Author:
    Joe Walnes, Jörg Schaible, Mauro Talevi, Guilherme Silveira

    • Method Detail

      • useXStream11XmlFriendlyMapper
        protected boolean useXStream11XmlFriendlyMapper()
        Deprecated.  As of 1.4.8
      • setupSecurity
        protected void setupSecurity()
      • setupAliases
        protected void setupAliases()
      • setupDefaultImplementations
        protected void setupDefaultImplementations()
      • setupConverters
        protected void setupConverters()
      • setupImmutableTypes
        protected void setupImmutableTypes()
      • setMarshallingStrategy
        public void setMarshallingStrategy(MarshallingStrategy marshallingStrategy)
      • toXML
        public String toXML(Object obj)
        Serialize an object to a pretty-printed XML String.
        Throws:
        XStreamException - if the object cannot be serialized
      • toXML
        public void toXML(Object obj,
                  Writer out)
        Serialize an object to the given Writer as pretty-printed XML. The Writer will be flushed afterwards and in case of an exception.
        Throws:
        XStreamException - if the object cannot be serialized
      • toXML
        public void toXML(Object obj,
                  OutputStream out)
        Serialize an object to the given OutputStream as pretty-printed XML. The OutputStream will be flushed afterwards and in case of an exception.
        Throws:
        XStreamException - if the object cannot be serialized
      • marshal
        public void marshal(Object obj,
                    HierarchicalStreamWriter writer,
                    DataHolder dataHolder)
        Serialize and object to a hierarchical data structure (such as XML).
        Parameters:
        dataHolder - Extra data you can use to pass to your converters. Use this as you want. If not present, XStream shall create one lazily as needed.
        Throws:
        XStreamException - if the object cannot be serialized
      • fromXML
        public Object fromXML(String xml)
        Deserialize an object from an XML String.
        Throws:
        XStreamException - if the object cannot be deserialized
      • fromXML
        public Object fromXML(Reader reader)
        Deserialize an object from an XML Reader.
        Throws:
        XStreamException - if the object cannot be deserialized
      • fromXML
        public Object fromXML(URL url)
        Deserialize an object from a URL. Depending on the parser implementation, some might take the file path as SystemId to resolve additional references.
        Throws:
        XStreamException - if the object cannot be deserialized
        Since:
        1.4
      • fromXML
        public Object fromXML(File file)
        Deserialize an object from a file. Depending on the parser implementation, some might take the file path as SystemId to resolve additional references.
        Throws:
        XStreamException - if the object cannot be deserialized
        Since:
        1.4
      • fromXML
        public Object fromXML(String xml,
                      Object root)
        Deserialize an object from an XML String, populating the fields of the given root object instead of instantiating a new one. Note, that this is a special use case! With the ReflectionConverter XStream will write directly into the raw memory area of the existing object. Use with care!
        Throws:
        XStreamException - if the object cannot be deserialized
      • fromXML
        public Object fromXML(Reader xml,
                      Object root)
        Deserialize an object from an XML Reader, populating the fields of the given root object instead of instantiating a new one. Note, that this is a special use case! With the ReflectionConverter XStream will write directly into the raw memory area of the existing object. Use with care!
        Throws:
        XStreamException - if the object cannot be deserialized
      • fromXML
        public Object fromXML(URL url,
                      Object root)
        Deserialize an object from a URL, populating the fields of the given root object instead of instantiating a new one. Note, that this is a special use case! With the ReflectionConverter XStream will write directly into the raw memory area of the existing object. Use with care! Depending on the parser implementation, some might take the file path as SystemId to resolve additional references.
        Throws:
        XStreamException - if the object cannot be deserialized
        Since:
        1.4
      • fromXML
        public Object fromXML(File file,
                      Object root)
        Deserialize an object from a file, populating the fields of the given root object instead of instantiating a new one. Note, that this is a special use case! With the ReflectionConverter XStream will write directly into the raw memory area of the existing object. Use with care! Depending on the parser implementation, some might take the file path as SystemId to resolve additional references.
        Throws:
        XStreamException - if the object cannot be deserialized
        Since:
        1.4
      • fromXML
        public Object fromXML(InputStream input,
                      Object root)
        Deserialize an object from an XML InputStream, populating the fields of the given root object instead of instantiating a new one. Note, that this is a special use case! With the ReflectionConverter XStream will write directly into the raw memory area of the existing object. Use with care!
        Throws:
        XStreamException - if the object cannot be deserialized
      • unmarshal
        public Object unmarshal(HierarchicalStreamReader reader,
                        Object root)
        Deserialize an object from a hierarchical data structure (such as XML), populating the fields of the given root object instead of instantiating a new one. Note, that this is a special use case! With the ReflectionConverter XStream will write directly into the raw memory area of the existing object. Use with care!
        Throws:
        XStreamException - if the object cannot be deserialized
      • unmarshal
        public Object unmarshal(HierarchicalStreamReader reader,
                        Object root,
                        DataHolder dataHolder)
        Deserialize an object from a hierarchical data structure (such as XML).
        Parameters:
        root - If present, the passed in object will have its fields populated, as opposed to XStream creating a new instance. Note, that this is a special use case! With the ReflectionConverter XStream will write directly into the raw memory area of the existing object. Use with care!
        dataHolder - Extra data you can use to pass to your converters. Use this as you want. If not present, XStream shall create one lazily as needed.
        Throws:
        XStreamException - if the object cannot be deserialized
      • aliasType
        public void aliasType(String name,
                      Class type)
        Alias a type to a shorter name to be used in XML elements. Any class that is assignable to this type will be aliased to the same name.
        Parameters:
        name - Short name
        type - Type to be aliased
        Throws:
        XStream.InitializationException - if no ClassAliasingMapper is available
        Since:
        1.2
      • aliasSystemAttribute
        public void aliasSystemAttribute(String alias,
                                 String systemAttributeName)
        Create an alias for a system attribute. XStream will not write a system attribute if its alias is set to null. However, this is not reversible, i.e. deserialization of the result is likely to fail afterwards and will not produce an object equal to the originally written one.
        Parameters:
        alias - the alias itself (may be null)
        systemAttributeName - the name of the system attribute
        Throws:
        XStream.InitializationException - if no SystemAttributeAliasingMapper is available
        Since:
        1.3.1
      • aliasAttribute
        public void aliasAttribute(Class definedIn,
                           String attributeName,
                           String alias)
        Create an alias for an attribute.
        Parameters:
        definedIn - the type where the attribute is defined
        attributeName - the name of the attribute
        alias - the alias itself
        Throws:
        XStream.InitializationException - if no AttributeAliasingMapper is available
        Since:
        1.2.2
      • useAttributeFor
        public void useAttributeFor(String fieldName,
                            Class type)
        Use an attribute for a field or a specific type.
        Parameters:
        fieldName - the name of the field
        type - the Class of the type to be rendered as XML attribute
        Throws:
        XStream.InitializationException - if no AttributeMapper is available
        Since:
        1.2
      • useAttributeFor
        public void useAttributeFor(Class definedIn,
                            String fieldName)
        Use an attribute for a field declared in a specific type.
        Parameters:
        fieldName - the name of the field
        definedIn - the Class containing such field
        Throws:
        XStream.InitializationException - if no AttributeMapper is available
        Since:
        1.2.2
      • useAttributeFor
        public void useAttributeFor(Class type)
        Use an attribute for an arbitrary type.
        Parameters:
        type - the Class of the type to be rendered as XML attribute
        Throws:
        XStream.InitializationException - if no AttributeMapper is available
        Since:
        1.2
      • addDefaultImplementation
        public void addDefaultImplementation(Class defaultImplementation,
                                     Class ofType)
        Associate a default implementation of a class with an object. Whenever XStream encounters an instance of this type, it will use the default implementation instead. For example, java.util.ArrayList is the default implementation of java.util.List.
        Parameters:
        defaultImplementation -
        ofType -
        Throws:
        XStream.InitializationException - if no DefaultImplementationsMapper is available
      • addImmutableType
        public void addImmutableType(Class type)
        Add immutable types. The value of the instances of these types will always be written into the stream even if they appear multiple times.
        Throws:
        XStream.InitializationException - if no ImmutableTypesMapper is available
      • registerConverter
        public void registerConverter(Converter converter)
      • registerConverter
        public void registerConverter(Converter converter,
                              int priority)
      • registerLocalConverter
        public void registerLocalConverter(Class definedIn,
                                   String fieldName,
                                   Converter converter)
        Register a local Converter for a field.
        Parameters:
        definedIn - the class type the field is defined in
        fieldName - the field name
        converter - the converter to use
        Since:
        1.3
      • registerLocalConverter
        public void registerLocalConverter(Class definedIn,
                                   String fieldName,
                                   SingleValueConverter converter)
        Register a local SingleValueConverter for a field.
        Parameters:
        definedIn - the class type the field is defined in
        fieldName - the field name
        converter - the converter to use
        Since:
        1.3
      • getMapper
        public Mapper getMapper()
        Retrieve the Mapper. This is by default a chain of MapperWrappers.
        Returns:
        the mapper
        Since:
        1.2
      • addImplicitCollection
        public void addImplicitCollection(Class ownerType,
                                  String fieldName)
        Adds a default implicit collection which is used for any unmapped XML tag.
        Parameters:
        ownerType - class owning the implicit collection
        fieldName - name of the field in the ownerType. This field must be a concrete collection type or matching the default implementation type of the collection type.
      • addImplicitCollection
        public void addImplicitCollection(Class ownerType,
                                  String fieldName,
                                  Class itemType)
        Adds implicit collection which is used for all items of the given itemType.
        Parameters:
        ownerType - class owning the implicit collection
        fieldName - name of the field in the ownerType. This field must be a concrete collection type or matching the default implementation type of the collection type.
        itemType - type of the items to be part of this collection
        Throws:
        XStream.InitializationException - if no ImplicitCollectionMapper is available
      • addImplicitCollection
        public void addImplicitCollection(Class ownerType,
                                  String fieldName,
                                  String itemFieldName,
                                  Class itemType)
        Adds implicit collection which is used for all items of the given element name defined by itemFieldName.
        Parameters:
        ownerType - class owning the implicit collection
        fieldName - name of the field in the ownerType. This field must be a concrete collection type or matching the default implementation type of the collection type.
        itemFieldName - element name of the implicit collection
        itemType - item type to be aliases be the itemFieldName
        Throws:
        XStream.InitializationException - if no ImplicitCollectionMapper is available
      • addImplicitArray
        public void addImplicitArray(Class ownerType,
                             String fieldName)
        Adds an implicit array.
        Parameters:
        ownerType - class owning the implicit array
        fieldName - name of the array field
        Since:
        1.4
      • addImplicitArray
        public void addImplicitArray(Class ownerType,
                             String fieldName,
                             Class itemType)
        Adds an implicit array which is used for all items of the given itemType when the array type matches.
        Parameters:
        ownerType - class owning the implicit array
        fieldName - name of the array field in the ownerType
        itemType - type of the items to be part of this array
        Throws:
        XStream.InitializationException - if no ImplicitCollectionMapper is available or the array type does not match the itemType
        Since:
        1.4
      • addImplicitArray
        public void addImplicitArray(Class ownerType,
                             String fieldName,
                             String itemName)
        Adds an implicit array which is used for all items of the given element name defined by itemName.
        Parameters:
        ownerType - class owning the implicit array
        fieldName - name of the array field in the ownerType
        itemName - alias name of the items
        Throws:
        XStream.InitializationException - if no ImplicitCollectionMapper is available
        Since:
        1.4
      • addImplicitMap
        public void addImplicitMap(Class ownerType,
                           String fieldName,
                           Class itemType,
                           String keyFieldName)
        Adds an implicit map.
        Parameters:
        ownerType - class owning the implicit map
        fieldName - name of the field in the ownerType. This field must be a concrete map type or matching the default implementation type of the map type.
        itemType - type of the items to be part of this map as value
        keyFieldName - the name of the field of the itemType that is used for the key in the map
        Since:
        1.4
      • addImplicitMap
        public void addImplicitMap(Class ownerType,
                           String fieldName,
                           String itemName,
                           Class itemType,
                           String keyFieldName)
        Adds an implicit map.
        Parameters:
        ownerType - class owning the implicit map
        fieldName - name of the field in the ownerType. This field must be a concrete map type or matching the default implementation type of the map type.
        itemName - alias name of the items
        itemType - type of the items to be part of this map as value
        keyFieldName - the name of the field of the itemType that is used for the key in the map
        Since:
        1.4
      • createObjectOutputStream
        public ObjectOutputStream createObjectOutputStream(HierarchicalStreamWriter writer,
                                                   String rootNodeName)
                                            throws IOException
        Creates an ObjectOutputStream that serializes a stream of objects to the writer using XStream.

        Because an ObjectOutputStream can contain multiple items and XML only allows a single root node, the stream must be written inside an enclosing node.

        It is necessary to call ObjectOutputStream.close() when done, otherwise the stream will be incomplete.

        Example

          ObjectOutputStream out = xstream.createObjectOutputStream(aWriter, "things");
   out.writeInt(123);
   out.writeObject("Hello");
   out.writeObject(someObject)
   out.close();
        Parameters:
        writer - The writer to serialize the objects to.
        rootNodeName - The name of the root node enclosing the stream of objects.
        Throws:
        IOException
        Since:
        1.0.3
        See Also:
        createObjectInputStream(com.thoughtworks.xstream.io.HierarchicalStreamReader)
      • setClassLoader
        public void setClassLoader(ClassLoader classLoader)
        Change the ClassLoader XStream uses to load classes. Creating an XStream instance it will register for all kind of classes and types of the current JDK, but not for any 3rd party type. To ensure that all other types are loaded with your class loader, you should call this method as early as possible - or consider to provide the class loader directly in the constructor.
        Since:
        1.1.1
      • getClassLoader
        public ClassLoader getClassLoader()
        Retrieve the ClassLoader XStream uses to load classes.
        Since:
        1.1.1
      • getClassLoaderReference
        public ClassLoaderReference getClassLoaderReference()
        Retrieve the reference to this instance' ClassLoader. Use this reference for other XStream components (like converters) to ensure that they will use a changed ClassLoader instance automatically.
        Returns:
        the reference
        Since:
        1.4.5
      • omitField
        public void omitField(Class definedIn,
                      String fieldName)
        Prevents a field from being serialized. To omit a field you must always provide the declaring type and not necessarily the type that is converted.
        Throws:
        XStream.InitializationException - if no FieldAliasingMapper is available
        Since:
        1.1.3
      • ignoreUnknownElements
        public void ignoreUnknownElements()
        Ignore all unknown elements.
        Since:
        1.4.5
      • ignoreUnknownElements
        public void ignoreUnknownElements(String pattern)
        Add pattern for unknown element names to ignore.
        Parameters:
        pattern - the name pattern as regular expression
        Since:
        1.4.5
      • ignoreUnknownElements
        public void ignoreUnknownElements(Pattern pattern)
        Add pattern for unknown element names to ignore.
        Parameters:
        pattern - the name pattern as regular expression
        Since:
        1.4.5
      • processAnnotations
        public void processAnnotations(Class[] types)
        Process the annotations of the given types and configure the XStream.
        Parameters:
        types - the types with XStream annotations
        Since:
        1.3
      • processAnnotations
        public void processAnnotations(Class type)
        Process the annotations of the given type and configure the XStream. A call of this method will automatically turn the auto-detection mode for annotations off.
        Parameters:
        type - the type with XStream annotations
        Since:
        1.3
      • autodetectAnnotations
        public void autodetectAnnotations(boolean mode)
        Set the auto-detection mode of the AnnotationMapper. Note that auto-detection implies that the XStream is configured while it is processing the XML steams. This is a potential concurrency problem. Also is it technically not possible to detect all class aliases at deserialization. You have been warned!
        Parameters:
        mode - true if annotations are auto-detected
        Since:
        1.3
      • addPermission
        public void addPermission(TypePermission permission)
        Add a new security permission.

        Permissions are evaluated in the added sequence. An instance of NoTypePermission or AnyTypePermission will implicitly wipe any existing permission.

        Parameters:
        permission - the permission to add
        Since:
        1.4.7
      • allowTypes
        public void allowTypes(String[] names)
        Add security permission for explicit types by name.
        Parameters:
        names - the type names to allow
        Since:
        1.4.7
      • allowTypes
        public void allowTypes(Class[] types)
        Add security permission for explicit types.
        Parameters:
        types - the types to allow
        Since:
        1.4.7
      • allowTypeHierarchy
        public void allowTypeHierarchy(Class type)
        Add security permission for a type hierarchy.
        Parameters:
        type - the base type to allow
        Since:
        1.4.7
      • allowTypesByRegExp
        public void allowTypesByRegExp(String[] regexps)
        Add security permission for types matching one of the specified regular expressions.
        Parameters:
        regexps - the regular expressions to allow type names
        Since:
        1.4.7
      • allowTypesByRegExp
        public void allowTypesByRegExp(Pattern[] regexps)
        Add security permission for types matching one of the specified regular expressions.
        Parameters:
        regexps - the regular expressions to allow type names
        Since:
        1.4.7
      • allowTypesByWildcard
        public void allowTypesByWildcard(String[] patterns)
        Add security permission for types matching one of the specified wildcard patterns.

        Supported are patterns with path expressions using dot as separator:

        • ?: one non-control character except separator, e.g. for 'java.net.Inet?Address'
        • *: arbitrary number of non-control characters except separator, e.g. for types in a package like 'java.lang.*'
        • **: arbitrary number of non-control characters including separator, e.g. for types in a package and subpackages like 'java.lang.**'
        Parameters:
        patterns - the patterns to allow type names
        Since:
        1.4.7
      • denyPermission
        public void denyPermission(TypePermission permission)
        Add security permission denying another one.
        Parameters:
        permission - the permission to deny
        Since:
        1.4.7
      • denyTypes
        public void denyTypes(String[] names)
        Add security permission forbidding explicit types by name.
        Parameters:
        names - the type names to forbid
        Since:
        1.4.7
      • denyTypes
        public void denyTypes(Class[] types)
        Add security permission forbidding explicit types.
        Parameters:
        types - the types to forbid
        Since:
        1.4.7
      • denyTypeHierarchy
        public void denyTypeHierarchy(Class type)
        Add security permission forbidding a type hierarchy.
        Parameters:
        type - the base type to forbid
        Since:
        1.4.7
      • denyTypesByRegExp
        public void denyTypesByRegExp(String[] regexps)
        Add security permission forbidding types matching one of the specified regular expressions.
        Parameters:
        regexps - the regular expressions to forbid type names
        Since:
        1.4.7
      • denyTypesByRegExp
        public void denyTypesByRegExp(Pattern[] regexps)
        Add security permission forbidding types matching one of the specified regular expressions.
        Parameters:
        regexps - the regular expressions to forbid type names
        Since:
        1.4.7
      • denyTypesByWildcard
        public void denyTypesByWildcard(String[] patterns)
        Add security permission forbidding types matching one of the specified wildcard patterns.

        Supported are patterns with path expressions using dot as separator:

        • ?: one non-control character except separator, e.g. for 'java.net.Inet?Address'
        • *: arbitrary number of non-control characters except separator, e.g. for types in a package like 'java.lang.*'
        • **: arbitrary number of non-control characters including separator, e.g. for types in a package and subpackages like 'java.lang.**'
        Parameters:
        patterns - the patterns to forbid names
        Since:
        1.4.7
XStream使用方法总结附实例代码
01-08
XStream中的核心类就是XStream类，一般来说，熟悉这个类基本就够用了，如果你用的更多，估计是你设计有问题，否则不需要。 XStream对象相当Java对象和XML之间的转换器，转换过程是双向的。创建XSteam对象的方式很简单，只需要new XStream()即可。 Java到xml，用toXML()方法。 Xml到Java，用fromXML()方法。 在没有任何设置默认情况下，java到xml的映射，是java成员名对应xml的元素名，java类的全名对应xml根元素的名字。而实际中，往往是xml和java类都有了，要完成相互转换，必须进行别名映射。 别名配置包含三种情况： 1、类
XStream别名指南
PaulHeKo的专栏
08-06 352
1，存在的问题设想我们的客户端定义了一个用于XStream读写的XML文件：我们将设计一些模型类并配置XStream按照这个XML文件格式执行读写操作。 first My first blog entry. tutorial Today we have developed a nice alias
XStream 数组(List)输出结构
weixin_34051201的博客
07-19 240
&lt;!-- 期望的DOM树 --&gt; &lt;Articles&gt; &lt;item&gt; &lt;Title&gt;微信SDK初步结构&lt;/Title&gt; &lt;Description&gt;恩..这是微信project的结构,嘻嘻~&lt;/Description&gt; &lt;PicUrl&gt
XStream使用方法
JOKER_SAMA的博客
03-10 4921
XStream 1. 什么作用   * 可以把JavaBean转换为（序列化为）xml 2. XStream的jar包   * 核心JAR包：xstream-1.4.7.jar；   * 必须依赖包：xpp3_min-1.1.4c（XML Pull Parser，一款速度很快的XML解析器）； 3. 使用步骤   * XStream xstream = new XStream();
XStream的一些有用的方法
yes1983的专栏
03-19 704
1.addImplicitCollection 类里面包含一个List变量在读取xml配置的时候是很常见的情况,比如: 有三个类:AuditTrail, AuditTrailEntry, AuditTrailEntryField,要读取的xml: ...
XStream解析XML实例
04-14
当处理包含集合的类时，XStream会自动将它们转换为XML列表。例如，如果`Person`类包含一个`List<String>`的地址列表，XStream会将每个元素转换为一个单独的XML元素。 ```java @XStreamAlias("person") class Person...
Xstream
08-02
在文件名称列表中，只有一个条目“Xstream”，这可能是博客文章的源代码示例或者一个包含XStream相关示例的压缩包。如果这是一个压缩文件，通常会包含一些Java源代码文件，这些文件展示了如何使用XStream进行序列化...
xstream-1.3.1
12-07
在压缩包文件列表中，我们只有一个文件"xstream-1.3.1.jar"，这是XStream库的JAR文件，包含所有必要的类和资源，用于在Java项目中导入并使用XStream库。 接下来，我们将深入探讨XStream的核心概念和实际应用： 1. ...
xstream-1.3.1.zip
01-02
XStream还支持处理集合和数组，可以将它们转换为XML列表，也可以从XML列表中恢复。此外，对于嵌套的对象和复杂的继承结构，XStream也能处理得游刃有余。 总结起来，XStream作为一个强大的Java库，极大地简化了...
xstream-1.4.2.jar
11-13
在压缩包子文件的文件名称列表中，我们只看到"xstream-1.4.2"，这可能是XStream-1.4.2版本的源代码或者文档，或者是未打包的JAR文件。解压后，用户可以查看源代码，了解其内部实现，或者进行二次开发。 深入理解...
XStream使用方法总结-对象-转换.txt
02-11
XStream使用方法总结L-对象-转换.txt
XML-----JAVABEAN 的xstream方式
无名小辈
03-28 313
XML-----JAVABEAN 的xstream方式 什么是Xstream？ 1.Xstream是一种OXMapping技术，是用来处理XML文件序列化的框架 2.xstream的特点？ 将javaBean序列化，或将XML文件反序列化的时候，不需要其它辅助类和映射文件，使得XML序列化不再繁索。 3.xstream的概述. XStream对象相当Java对象和XML之间的转换器， ...
XStream 用法总结
CheerForU
03-05 706
XStream是一个Java对象和XML相互转换的工具，提供了所有的基础类型、数组、集合等类型直接转换的支持。因此XML常用于数据交换、对象序列化（这种序列化和Java对象的序列化技术有着本质的区别）。 XStream对象相当Java对象和XML之间的转换器，转换过程是双向的。创建XSteam对象的方式很简单，只需要new XStream()即可。 ...
XStream 转换 List＜String＞的方法
oarsman的专栏
09-10 6220
今天在做一个基于XML报文的通信接口的时候，遇到了一个小问题，在这个XML里面，客户定义了一个纯String的List，如下所示 <root> <desc>this is only a example</desc> <namelist> <name>user01</name> ...
XStream介绍
weixin_41629964的博客
04-17 2787
XStream是一个实现javaBean与XML互相转换的工具，极大地简化了开发人员的对XML的处理 1、添加依赖 <dependency> <groupId>com.thoughtworks.xstream</groupId> <artifactId>xstream</artifactId> <version>1.4.11.1</version> </dependency> 2、
xjl:XStream的对象图与转换器
weixin_34310785的博客
02-13 98
对象图XStream支持对象图，也就是“反序列化”一个对象的时候将会保持原来的对象引用关系，这其中包括循环引用关系。我们可以指定XStream是使用XPath还是IDs来实现对象引用的这种处理方式，指定的方式就是调用XStream的setMode方法，此方法有XStream.XPATH_REFERENCES、XStream.ID_REFERENCES、XStream.NO_...
java安装有错误码咋办_java编程出现的错误对应的解决方法
weixin_36480423的博客
02-13 2440
error: could not open D:\java\jre1.8\lib\amd64\jvm.cfg解决方法：把java的环境变量%JAVA_HOME%/bin上移到最上面优化查看网页源代码Ctrl+U测试浏览器是否支持html5访问word封面加下划线打好字 ctrl+U 在字后面打空格自动生成下划线在字前面打空格 选中所有空格 ctrl+U邮件服务器的搭建和客户端的安装1.安装易邮服...
使用XStream 把xml转对象时报错
最新发布
qq_34605300的博客
05-28 1073
使用XStream遇见的问题
XStream XML-Object转换
amos_tl的专栏
06-10 307
[url]http://xstream.codehaus.org[/url] [b]XStream是一个序列化对象为XML或XML转换为对象的库.[/b] [b]特点:[/b] 简化的API; 无映射文件; 高性能,低内存占用; 整洁的XML; 不需要修改对象;支持内部私有字段,不需要setter/getter方法,final字段;非公有类,内部类;类不需要默认构造器,完全对...
XStream深度解析：Java对象与XML的转换
为了处理集合类，XStream提供了`addImplicitCollection(Class ownerType, String fieldName)`方法，它会自动将字段值转换为XML中的元素列表。 `registerConverter(Converter converter)`允许注册自定义的转换器，以...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值