Java CollectionConverter类代码示例

import com.thoughtworks.xstream.converters.collections.CollectionConverter; //导入依赖的package包/类
private void testObject(final HierarchicalStreamDriver driver) {
    final XStream xstream = new XStream(driver);
    xstream.allowTypesByWildcard(AbstractAcceptanceTest.class.getPackage().getName() + ".*objects.**");
    xstream.allowTypesByWildcard(this.getClass().getName() + "$*");
    xstream.registerConverter(new CollectionConverter(xstream.getMapper()) {

        @Override
        public Object unmarshal(final HierarchicalStreamReader reader, final UnmarshallingContext context) {
            final ExtendedHierarchicalStreamReader exReader = (ExtendedHierarchicalStreamReader)reader;
            if (exReader.peekNextChild() == null) {
                return new ArrayList<Object>();
            }
            return super.unmarshal(reader, context);
        }

    });

    final SampleLists in = new SampleLists();
    in.good.add("one");
    in.good.add("two");
    in.good.add("three");
    in.bad.add(Boolean.TRUE);
    in.bad.add(Boolean.FALSE);
    final ByteArrayOutputStream buffer = new ByteArrayOutputStream();
    xstream.toXML(in, buffer);
    final Object out = xstream.fromXML(new ByteArrayInputStream(buffer.toByteArray()));

    Assert.assertEquals(in, out);
}
 

import com.thoughtworks.xstream.converters.collections.CollectionConverter; //导入依赖的package包/类
@Nonnull
public static XStream makeXStream() {
  XStream xstream = new XStream();
  if (ConfigProvider.class.getClassLoader() != null) {
    xstream.setClassLoader(ConfigProvider.class.getClassLoader());
  }

  xstream.registerLocalConverter(Stash.class, "contents", new NamedMapConverter(xstream.getMapper(), "component", "name", String.class, "ppm", Double.class,
      true, true, xstream.getConverterLookup()));
  xstream.addImplicitCollection(Material.class, "components");
  xstream.useAttributeFor(Material.class, "name");
  xstream.useAttributeFor(Material.class, "prio");
  xstream.useAttributeFor(Material.class, "volume");
  xstream.useAttributeFor(Material.class, "density");
  xstream.useAttributeFor(Component.class, "name");
  xstream.useAttributeFor(Component.class, "factor");
  xstream.useAttributeFor(Component.class, "count");
  xstream.useAttributeFor(Component.class, "granularity");
  xstream.useAttributeFor(MinecraftItem.class, "modID");
  xstream.useAttributeFor(MinecraftItem.class, "itemName");
  xstream.useAttributeFor(MinecraftItem.class, "itemMeta");
  xstream.useAttributeFor(OreDictionaryItem.class, "oreDictionary");
  xstream.alias("water", Water.class);
  xstream.alias("material", Material.class);
  xstream.alias("component", Component.class);
  xstream.alias("OreDictionaryItem", OreDictionaryItem.class);
  xstream.alias("MinecraftItem", MinecraftItem.class);

  ClassAliasingMapper mapper = new ClassAliasingMapper(xstream.getMapper());
  mapper.addClassAlias("amount", Double.class);
  xstream.registerLocalConverter(Component.class, "granularities", new CollectionConverter(mapper));
  return xstream;
}
 

import com.thoughtworks.xstream.converters.collections.CollectionConverter; //导入依赖的package包/类
/**
* 
*/
  protected PortfolioRepositoryHandler() {
      supportedTypes = new ArrayList<String>(1);
      supportedTypes.add(EPTemplateMapResource.TYPE_NAME);

      myStream.alias("defaultMap", EPDefaultMap.class);
      myStream.alias("structureMap", EPStructuredMap.class);
      myStream.alias("templateMap", EPStructuredMapTemplate.class);
      myStream.alias("structure", EPStructureElement.class);
      myStream.alias("page", EPPage.class);
      myStream.alias("structureToArtefact", EPStructureToArtefactLink.class);
      myStream.alias("structureToStructure", EPStructureToStructureLink.class);
      myStream.alias("collectionRestriction", CollectRestriction.class);

      myStream.alias("org.olat.resource.OLATResourceImpl", OLATResourceImpl.class);
      myStream.alias("OLATResource", OLATResourceImpl.class);

      myStream.alias("org.olat.basesecurity.SecurityGroupImpl", SecurityGroupImpl.class);
      myStream.alias("SecurityGroupImpl", SecurityGroupImpl.class);

      myStream.alias("org.olat.basesecurity.SecurityGroup", SecurityGroup.class);
      myStream.alias("SecurityGroup", SecurityGroup.class);

      myStream.alias("org.olat.core.id.Persistable", Persistable.class);
      myStream.alias("Persistable", Persistable.class);

      myStream.alias("org.hibernate.proxy.HibernateProxy", HibernateProxy.class);
      myStream.alias("HibernateProxy", HibernateProxy.class);

      myStream.omitField(EPStructuredMapTemplate.class, "ownerGroup");
      myStream.addDefaultImplementation(PersistentList.class, List.class);
      myStream.addDefaultImplementation(ArrayList.class, List.class);
      myStream.registerConverter(new CollectionConverter(myStream.getMapper()) {
          @Override
          public boolean canConvert(final Class type) {
              return PersistentList.class == type;
          }
      });
  }
 

import com.thoughtworks.xstream.converters.collections.CollectionConverter; //导入依赖的package包/类
protected void setupConverters() {
    registerConverter(new ReflectionConverter(mapper, reflectionProvider), PRIORITY_VERY_LOW);

    registerConverter(new SerializableConverter(mapper, reflectionProvider, classLoaderReference), PRIORITY_LOW);
    registerConverter(new ExternalizableConverter(mapper, classLoaderReference), PRIORITY_LOW);

    registerConverter(new NullConverter(), PRIORITY_VERY_HIGH);
    registerConverter(new IntConverter(), PRIORITY_NORMAL);
    registerConverter(new FloatConverter(), PRIORITY_NORMAL);
    registerConverter(new DoubleConverter(), PRIORITY_NORMAL);
    registerConverter(new LongConverter(), PRIORITY_NORMAL);
    registerConverter(new ShortConverter(), PRIORITY_NORMAL);
    registerConverter((Converter)new CharConverter(), PRIORITY_NORMAL);
    registerConverter(new BooleanConverter(), PRIORITY_NORMAL);
    registerConverter(new ByteConverter(), PRIORITY_NORMAL);

    registerConverter(new StringConverter(), PRIORITY_NORMAL);
    registerConverter(new StringBufferConverter(), PRIORITY_NORMAL);
    registerConverter(new StringBuilderConverter(), PRIORITY_NORMAL);
    registerConverter(new ThrowableConverter(converterLookup), PRIORITY_NORMAL);
    registerConverter(new StackTraceElementConverter(), PRIORITY_NORMAL);
    registerConverter(new DateConverter(), PRIORITY_NORMAL);
    registerConverter(new GregorianCalendarConverter(), PRIORITY_NORMAL);
    registerConverter(new RegexPatternConverter(), PRIORITY_NORMAL);
    registerConverter(new CurrencyConverter(), PRIORITY_NORMAL);
    registerConverter(new CharsetConverter(), PRIORITY_NORMAL);
    registerConverter(new LocaleConverter(), PRIORITY_NORMAL);
    registerConverter(new BitSetConverter(), PRIORITY_NORMAL);
    registerConverter(new UUIDConverter(), PRIORITY_NORMAL);
    registerConverter(new URIConverter(), PRIORITY_NORMAL);
    registerConverter(new URLConverter(), PRIORITY_NORMAL);
    registerConverter(new BigIntegerConverter(), PRIORITY_NORMAL);
    registerConverter(new BigDecimalConverter(), PRIORITY_NORMAL);

    registerConverter(new ArrayConverter(mapper), PRIORITY_NORMAL);
    registerConverter(new CharArrayConverter(), PRIORITY_NORMAL);
    registerConverter(new CollectionConverter(mapper), PRIORITY_NORMAL);
    registerConverter(new MapConverter(mapper), PRIORITY_NORMAL);
    registerConverter(new TreeMapConverter(mapper), PRIORITY_NORMAL);
    registerConverter(new TreeSetConverter(mapper), PRIORITY_NORMAL);
    registerConverter(new SingletonCollectionConverter(mapper), PRIORITY_NORMAL);
    registerConverter(new SingletonMapConverter(mapper), PRIORITY_NORMAL);
    registerConverter(new PropertiesConverter(), PRIORITY_NORMAL);
    registerConverter((Converter)new EncodedByteArrayConverter(), PRIORITY_NORMAL);
    registerConverter(new EnumConverter(), PRIORITY_NORMAL);
    registerConverter(new EnumSetConverter(mapper), PRIORITY_NORMAL);
    registerConverter(new EnumMapConverter(mapper), PRIORITY_NORMAL);

    registerConverter(new FileConverter(), PRIORITY_NORMAL);
    if (JVM.isSQLAvailable()) {
        registerConverter(new SqlTimestampConverter(), PRIORITY_NORMAL);
        registerConverter(new SqlTimeConverter(), PRIORITY_NORMAL);
        registerConverter(new SqlDateConverter(), PRIORITY_NORMAL);
    }
    registerConverter(new DynamicProxyConverter(mapper, classLoaderReference), PRIORITY_NORMAL);
    registerConverter(new JavaClassConverter(classLoaderReference), PRIORITY_NORMAL);
    registerConverter(new JavaMethodConverter(classLoaderReference), PRIORITY_NORMAL);
    registerConverter(new JavaFieldConverter(classLoaderReference), PRIORITY_NORMAL);
    if (JVM.isAWTAvailable()) {
        registerConverter(new FontConverter(mapper), PRIORITY_NORMAL);
        registerConverter(new ColorConverter(), PRIORITY_NORMAL);
        registerConverter(new TextAttributeConverter(), PRIORITY_NORMAL);
    }
    if (JVM.isSwingAvailable()) {
        registerConverter(new LookAndFeelConverter(mapper, reflectionProvider), PRIORITY_NORMAL);
    }

    if (JVM.loadClassForName("javax.security.auth.Subject") != null) {
        registerConverterDynamically("com.thoughtworks.xstream.converters.extended.SubjectConverter",
            PRIORITY_NORMAL, new Class[]{Mapper.class}, new Object[]{mapper});
    }
    if (JVM.loadClassForName("javax.xml.datatype.Duration") != null) {
        registerConverterDynamically("com.thoughtworks.xstream.converters.extended.DurationConverter",
            PRIORITY_NORMAL, null, null);
    }

    registerConverter(new SelfStreamingInstanceChecker(converterLookup, this), PRIORITY_NORMAL);
}
 

import com.thoughtworks.xstream.converters.collections.CollectionConverter; //导入依赖的package包/类
private static void registerStringAlias(XStream xstream, Class clazz, String tag) {
    ClassAliasingMapper mapper = new ClassAliasingMapper(xstream.getMapper());
    mapper.addClassAlias(tag, String.class);
    xstream.registerLocalConverter(clazz, tag + "s", new CollectionConverter(mapper));
}