Java HierarchicalStreamDriver类代码示例

import com.thoughtworks.xstream.io.HierarchicalStreamDriver; //导入依赖的package包/类
private XStream(
        final ReflectionProvider reflectionProvider, final HierarchicalStreamDriver driver,
        final ClassLoaderReference classLoader, final Mapper mapper,
        final DefaultConverterLookup defaultConverterLookup) {
    this(reflectionProvider, driver, classLoader, mapper, new ConverterLookup() {
        @Override
        public Converter lookupConverterForType(final Class<?> type) {
            return defaultConverterLookup.lookupConverterForType(type);
        }
    }, new ConverterRegistry() {
        @Override
        public void registerConverter(final Converter converter, final int priority) {
            defaultConverterLookup.registerConverter(converter, priority);
        }
    });
}
 

import com.thoughtworks.xstream.io.HierarchicalStreamDriver; //导入依赖的package包/类
/**
 * Deserialize a self-contained XStream with object from an XML Reader.
 * 
 * @param driver the implementation to use
 * @param xml the {@link Reader} providing the XML data
 * @param permissions the permissions to use (ensure that they include the defaults)
 * @throws IOException if an error occurs reading from the Reader.
 * @throws ClassNotFoundException if a class in the XML stream cannot be found
 * @throws com.thoughtworks.xstream.XStreamException if the object cannot be deserialized
 * @since 1.4.7
 */
public <T> T fromXML(final HierarchicalStreamDriver driver, final Reader xml, final TypePermission... permissions)
        throws IOException, ClassNotFoundException {
    final XStream outer = new XStream(driver);
    for (final TypePermission permission : permissions) {
        outer.addPermission(permission);
    }
    final HierarchicalStreamReader reader = driver.createReader(xml);
    final ObjectInputStream configIn = outer.createObjectInputStream(reader);
    try {
        final XStream configured = (XStream)configIn.readObject();
        final ObjectInputStream in = configured.createObjectInputStream(reader);
        try {
            @SuppressWarnings("unchecked")
            final T t = (T)in.readObject();
            return t;
        } finally {
            in.close();
        }
    } finally {
        configIn.close();
    }
}
 

import com.thoughtworks.xstream.io.HierarchicalStreamDriver; //导入依赖的package包/类
/**
 * parse json
 * <p>
 * 
 * @param clazz
 *            the class
 * @param original
 *            original text
 * @return the class
 * @throws SecurityException
 * @throws NoSuchFieldException
 * @throws IllegalArgumentException
 * @throws IllegalAccessException
 */
protected <T> T fromJson(Class<T> clazz, String original) throws SecurityException, NoSuchFieldException, IllegalArgumentException, IllegalAccessException {
    HierarchicalStreamDriver hierarchicalStreamDriver = new JettisonMappedXmlDriver();

    XStream xStream = generateXStream(hierarchicalStreamDriver);

    Field rootField = clazz.getField("XSTREAM_ROOT");
    boolean root = (Boolean) rootField.get(null);
    if (root) {
        original = "{\"" + ROOT + "\":" + original + "}";
        xStream.alias(ROOT, clazz);
    }
    else {
        Field aliasField = clazz.getField("XSTREAM_ALIAS");
        xStream.alias(String.valueOf(aliasField.get(null)), clazz);
    }

    return (T) xStream.fromXML(original);
}
 

import com.thoughtworks.xstream.io.HierarchicalStreamDriver; //导入依赖的package包/类
/**
 * {@link XStream} generator
 * <p>
 * 
 * @param hierarchicalStreamDriver
 *            {@link HierarchicalStreamDriver}
 * @return {@link XStream}
 */
private XStream generateXStream(HierarchicalStreamDriver hierarchicalStreamDriver) {
    XStream xStream = new XStream(hierarchicalStreamDriver) {
        @Override
        protected MapperWrapper wrapMapper(MapperWrapper next) {
            return new MapperWrapper(next) {
                @Override
                // avoid {@link XStream} crash when field misses
                public boolean shouldSerializeMember(Class definedIn, String fieldName) {
                    try {
                        return definedIn != Object.class || realClass(fieldName) != null;
                    }
                    catch (CannotResolveClassException cnrce) {
                        return false;
                    }
                }
            };
        }
    };
    xStream.autodetectAnnotations(true);

    return xStream;
}
 

import com.thoughtworks.xstream.io.HierarchicalStreamDriver; //导入依赖的package包/类
/**
 * Deserialize a self-contained XStream with object from an XML Reader.
 *
 * @param driver the implementation to use
 * @param xml the {@link Reader} providing the XML data
 * @param permissions the permissions to use (ensure that they include the defaults)
 * @throws IOException if an error occurs reading from the Reader.
 * @throws ClassNotFoundException if a class in the XML stream cannot be found
 * @throws com.thoughtworks.xstream.XStreamException if the object cannot be deserialized
 * @since 1.4.7
 */
public <T> T fromXML(final HierarchicalStreamDriver driver, final Reader xml, final TypePermission... permissions)
        throws IOException, ClassNotFoundException {
    final XStream outer = new XStream(driver);
    for (final TypePermission permission : permissions) {
        outer.addPermission(permission);
    }
    final HierarchicalStreamReader reader = driver.createReader(xml);
    final ObjectInputStream configIn = outer.createObjectInputStream(reader);
    try {
        final XStream configured = (XStream)configIn.readObject();
        final ObjectInputStream in = configured.createObjectInputStream(reader);
        try {
            @SuppressWarnings("unchecked")
            final T t = (T)in.readObject();
            return t;
        } finally {
            in.close();
        }
    } finally {
        configIn.close();
    }
}
 

import com.thoughtworks.xstream.io.HierarchicalStreamDriver; //导入依赖的package包/类
protected HierarchicalStreamDriver createDriver() {
    // if the system property is set, use it to load the driver
    String driver = null;
    try {
        driver = System.getProperty("xstream.driver");
        if (driver != null) {
            System.out.println("Using driver: " + driver);
            Class type = Class.forName(driver);
            return (HierarchicalStreamDriver) type.newInstance();
        }
    }
    catch (Exception e) {
        throw new RuntimeException("Could not load driver: " + driver);
    }
    return new XppDriver();
}
 

import com.thoughtworks.xstream.io.HierarchicalStreamDriver; //导入依赖的package包/类
public XStream(ReflectionProvider paramReflectionProvider, HierarchicalStreamDriver paramHierarchicalStreamDriver, ClassLoaderReference paramClassLoaderReference, Mapper paramMapper, ConverterLookup paramConverterLookup, ConverterRegistry paramConverterRegistry)
{
  if (paramReflectionProvider == null)
    paramReflectionProvider = JVM.newReflectionProvider();
  this.reflectionProvider = paramReflectionProvider;
  this.hierarchicalStreamDriver = paramHierarchicalStreamDriver;
  this.classLoaderReference = paramClassLoaderReference;
  this.converterLookup = paramConverterLookup;
  this.converterRegistry = paramConverterRegistry;
  Mapper localMapper;
  if (paramMapper == null)
    localMapper = buildMapper();
  else
    localMapper = paramMapper;
  this.mapper = localMapper;
  setupMappers();
  setupSecurity();
  setupAliases();
  setupDefaultImplementations();
  setupConverters();
  setupImmutableTypes();
  setMode(1003);
}
 

import com.thoughtworks.xstream.io.HierarchicalStreamDriver; //导入依赖的package包/类
public Object fromXML(HierarchicalStreamDriver paramHierarchicalStreamDriver, Reader paramReader, TypePermission[] paramArrayOfTypePermission)
{
  XStream localXStream = new XStream(paramHierarchicalStreamDriver);
  for (int i = 0; i < paramArrayOfTypePermission.length; i++)
    localXStream.addPermission(paramArrayOfTypePermission[i]);
  HierarchicalStreamReader localHierarchicalStreamReader = paramHierarchicalStreamDriver.createReader(paramReader);
  ObjectInputStream localObjectInputStream1 = localXStream.createObjectInputStream(localHierarchicalStreamReader);
  try
  {
    ObjectInputStream localObjectInputStream2 = ((XStream)localObjectInputStream1.readObject()).createObjectInputStream(localHierarchicalStreamReader);
    try
    {
      Object localObject3 = localObjectInputStream2.readObject();
      return localObject3;
    }
    finally
    {
    }
  }
  finally
  {
    localObjectInputStream1.close();
  }
}
 

import com.thoughtworks.xstream.io.HierarchicalStreamDriver; //导入依赖的package包/类
public XStream(ReflectionProvider reflectionProvider,
			ClassMapper classMapper, HierarchicalStreamDriver driver,
			String classAttributeIdentifier) {
		jvm = new JVM();
		if (reflectionProvider == null) {
			reflectionProvider = jvm.bestReflectionProvider();
		}
		this.reflectionProvider = reflectionProvider;
		this.hierarchicalStreamDriver = driver;
		//this.classLoaderReference = new ClassLoaderReference(
		//		new CompositeClassLoader());	// サーブレットで実行するとメモリが増えてしまう
		this.classLoaderReference = new ClassLoaderReference(
				getClass().getClassLoader());
		this.classMapper = classMapper == null ? buildMapper(classAttributeIdentifier)
				: classMapper;
		converterLookup = new DefaultConverterLookup(this.classMapper);
		setupAliases();
		setupDefaultImplementations();
		setupConverters();
		setupImmutableTypes();
//		setMode(XPATH_REFERENCES);
		setMode(NO_REFERENCES);
	}
 

import com.thoughtworks.xstream.io.HierarchicalStreamDriver; //导入依赖的package包/类
protected CubaXStream(
        ReflectionProvider reflectionProvider, HierarchicalStreamDriver driver, ClassLoaderReference classLoader,
        Mapper mapper, final CubaXStreamConverterLookup converterLookup) {
    super(reflectionProvider, driver, classLoader, mapper,
            converterLookup::lookupConverterForType,
            converterLookup::registerConverter);
}
 

import com.thoughtworks.xstream.io.HierarchicalStreamDriver; //导入依赖的package包/类
/**
 * creates an XMLConfigurer instance backed by a new XStream instance
 * using the com.thoughtworks.xstream.io.xml.StaxDriver for XML parsing
 * if the StAX API is available
 *
 * @see com.thoughtworks.xstream.io.xml.StaxDriver
 */
public XMLConfigurer() {
    final HierarchicalStreamDriver xmlDriver = //
            ReflectionUtils.isClassPresent("javax.xml.stream.XMLStreamReader") ? new StaxDriver() : //
                    ReflectionUtils.isClassPresent("org.xmlpull.mxp1.MXParser") ? new XppDriver() : //
                            new DomDriver();
    LOG.info("XML driver implementation: {1}", xmlDriver.getClass().getName());
    xStream = new XStream(new XStreamReflectionProvider(), xmlDriver);
    configureXStream();
}
 

import com.thoughtworks.xstream.io.HierarchicalStreamDriver; //导入依赖的package包/类
protected HierarchicalStreamDriver createDriver() {
    // careful, called from inside base class constructor
    qnameMap = new QNameMap();
    StaxDriver driver = new BEAStaxDriver(qnameMap);
    driver.setRepairingNamespace(false);
    return driver;
}
 

import com.thoughtworks.xstream.io.HierarchicalStreamDriver; //导入依赖的package包/类
protected HierarchicalStreamDriver createDriver() {
    // if the system property is set, use it to load the driver
    String driver = null;
    try {
        driver = System.getProperty("xstream.driver");
        if (driver != null) {
            System.out.println("Using driver: " + driver);
            final Class<?> type = Class.forName(driver);
            return (HierarchicalStreamDriver)type.newInstance();
        }
    } catch (final Exception e) {
        throw new RuntimeException("Could not load driver: " + driver, e);
    }
    return new XppDriver();
}
 

import com.thoughtworks.xstream.io.HierarchicalStreamDriver; //导入依赖的package包/类
private void test(final HierarchicalStreamDriver driver, final String encoding) throws IOException {
    final String headerLine = encoding != null ? "<?xml version=\"1.0\" encoding=\"" + encoding + "\"?>\n" : "";
    final String xmlData = headerLine // force code format
        + "<test>\n"
        + "  <data>J\u00f6rg</data>\n"
        + "</test>";

    final XStream xstream = new XStream(driver);
    xstream.allowTypes(TestObject.class);
    xstream.alias("test", TestObject.class);
    final TestObject obj = new TestObject();
    obj.data = "J\u00f6rg";

    final ByteArrayOutputStream bos = new ByteArrayOutputStream();
    final OutputStreamWriter writer = encoding != null
        ? new OutputStreamWriter(bos, encoding)
        : new OutputStreamWriter(bos);
    xstream.toXML(obj, writer);
    writer.close();

    final String generated = encoding != null ? bos.toString(encoding) : bos.toString();
    Assert.assertTrue("'" + obj.data + "' was not found", generated.indexOf(obj.data) > 0);

    final Object restored = xstream.fromXML(new ByteArrayInputStream(encoding != null
        ? xmlData.getBytes(encoding)
        : xmlData.getBytes()));
    Assert.assertEquals(obj, restored);
}
 

import com.thoughtworks.xstream.io.HierarchicalStreamDriver; //导入依赖的package包/类
/**
 * Create a XStream product based on a driver.
 * 
 * @param driver the driver to use for serialization/deserialization 
 * @param desc the driver description
 * 
 * @since 1.4
 */
public XStreamDriver(HierarchicalStreamDriver driver, String desc) {
    this.xstream = new XStream(driver);
    this.xstream.registerConverter(new JavaBeanConverter(this.xstream.getMapper()) {

        public boolean canConvert(Class type) {
            return type == OneBean.class || type == FiveBean.class;
        }
        
    });
    this.desc = desc;
}