com.thoughtworks.xstream.core.ClassLoaderReference Java Examples

/**
 * 将执行计划序列化成字符串
 */
public static String createStringPlan(PhysicalPlan plan)
{
    XStream xstream = new XStream(new DomDriver(XML_CHARSET));
    xstream.autodetectAnnotations(true);
    PhysicalPlanLoader.setAlias(xstream);
    xstream.registerConverter(new MapConverter(new DefaultMapper(new ClassLoaderReference(PhysicalPlanWriter.class.getClassLoader()))));
    return xstream.toXML(plan);
}
 

protected CubaXStream(
        ReflectionProvider reflectionProvider, HierarchicalStreamDriver driver, ClassLoaderReference classLoader,
        Mapper mapper, final CubaXStreamConverterLookup converterLookup) {
    super(reflectionProvider, driver, classLoader, mapper,
            converterLookup::lookupConverterForType,
            converterLookup::registerConverter);
}
 

public CubaXStream(List<Class> excluded) {
    this(null,
            new XppDriver(),
            new ClassLoaderReference(Thread.currentThread().getContextClassLoader()),
            null,
            new CubaXStreamConverterLookup(excluded));
}
 

private void readObject(final ObjectInputStream in) throws IOException, ClassNotFoundException {
    in.defaultReadObject();
    setupMappers();
    int max = in.readInt();
    arguments = new Object[max+2];
    for (int i = 0; i < max; i++ ) {
        arguments[i] = in.readObject();
        if (arguments[i] instanceof ClassLoaderReference) {
            arguments[max+1] = ((ClassLoaderReference)arguments[i]).getReference();
        }
    }
    arguments[max] = new JVM();
}
 

/**
 * Construct an AnnotationMapper.
 * 
 * @param wrapped the next {@link Mapper} in the chain
 * @since 1.4.5
 */
public AnnotationMapper(
    final Mapper wrapped, final ConverterRegistry converterRegistry, final ConverterLookup converterLookup,
    final ClassLoaderReference classLoaderReference, final ReflectionProvider reflectionProvider) {
    super(wrapped);
    this.converterRegistry = converterRegistry;
    annotatedTypes.add(Object.class);
    setupMappers();
    locked = true;
    
    final ClassLoader classLoader = classLoaderReference.getReference();
    arguments = new Object[]{
        this, classLoaderReference, reflectionProvider, converterLookup, new JVM(),
        classLoader != null ? classLoader : new TypedNull(ClassLoader.class)};
}
 

private Mapper buildMapper() {
    Mapper mapper = new DefaultMapper(classLoaderReference);
    if (useXStream11XmlFriendlyMapper()) {
        mapper = new XStream11XmlFriendlyMapper(mapper);
    }
    mapper = new DynamicProxyMapper(mapper);
    mapper = new PackageAliasingMapper(mapper);
    mapper = new ClassAliasingMapper(mapper);
    mapper = new ElementIgnoringMapper(mapper);
    mapper = new FieldAliasingMapper(mapper);
    mapper = new AttributeAliasingMapper(mapper);
    mapper = new SystemAttributeAliasingMapper(mapper);
    mapper = new ImplicitCollectionMapper(mapper, reflectionProvider);
    mapper = new OuterClassMapper(mapper);
    mapper = new ArrayMapper(mapper);
    mapper = new DefaultImplementationsMapper(mapper);
    mapper = new AttributeMapper(mapper, converterLookup, reflectionProvider);
    if (JVM.isVersion(5)) {
        mapper = buildMapperDynamically(
            "com.thoughtworks.xstream.mapper.EnumMapper", new Class[]{Mapper.class},
            new Object[]{mapper});
    }
    mapper = new LocalConversionMapper(mapper);
    mapper = new ImmutableTypesMapper(mapper);
    if (JVM.isVersion(8)) {
        mapper = buildMapperDynamically("com.thoughtworks.xstream.mapper.LambdaMapper", new Class[]{Mapper.class},
            new Object[]{mapper});
    }
    mapper = new SecurityMapper(mapper);
    if (JVM.isVersion(5)) {
        mapper = buildMapperDynamically(ANNOTATION_MAPPER_TYPE, new Class[]{
            Mapper.class, ConverterRegistry.class, ConverterLookup.class,
            ClassLoaderReference.class, ReflectionProvider.class}, new Object[]{
            mapper, converterRegistry, converterLookup, classLoaderReference,
            reflectionProvider});
    }
    mapper = wrapMapper((MapperWrapper)mapper);
    mapper = new CachingMapper(mapper);
    return mapper;
}
 

private XStream(
        ReflectionProvider reflectionProvider, HierarchicalStreamDriver driver, ClassLoaderReference classLoader,
        Mapper mapper, final DefaultConverterLookup defaultConverterLookup) {
    this(reflectionProvider, driver, classLoader, mapper, new ConverterLookup() {
        public Converter lookupConverterForType(Class type) {
            return defaultConverterLookup.lookupConverterForType(type);
        }
    }, new ConverterRegistry() {
        public void registerConverter(Converter converter, int priority) {
            defaultConverterLookup.registerConverter(converter, priority);
        }
    });
}
 

public static XStream createNonTrustingXStream(HierarchicalStreamDriver hierarchicalStreamDriver, ClassLoader classLoader) {
    return internalCreateNonTrustingXStream(new XStream((ReflectionProvider)null, hierarchicalStreamDriver, new ClassLoaderReference(classLoader)));
}
 

public ObjectWithDefaultStringImplConverter(ConverterLookup lookup, ClassLoaderReference loader) {
    this.lookup = lookup;
    this.loader = loader;
}
 

/**
 * @deprecated As of 1.4.5 use {@link #CustomObjectInputStream(StreamCallback, ClassLoaderReference)}
 */
public CustomObjectInputStream(StreamCallback callback, ClassLoader classLoader) throws IOException, SecurityException {
    this(callback, new ClassLoaderReference(classLoader));
}
 

/**
 * @deprecated As of 1.4.5 use {@link #getInstance(DataHolder, StreamCallback, ClassLoaderReference)}
 */
public static synchronized CustomObjectInputStream getInstance(DataHolder whereFrom, CustomObjectInputStream.StreamCallback callback, ClassLoader classLoader) {
    return getInstance(whereFrom, callback, new ClassLoaderReference(classLoader));
}
 

/**
 * Constructs an XStream with a special {@link HierarchicalStreamDriver},
 * {@link ReflectionProvider}, a prepared {@link Mapper} chain, the
 * {@link ClassLoaderReference} and an own {@link ConverterLookup} and
 * {@link ConverterRegistry}.
 * <p>
 * The ClassLoaderReference should also be used for the Mapper chain. The ConverterLookup
 * should access the ConverterRegistry if you intent to register {@link Converter} instances
 * with XStream facade or you are using annotations.
 * </p>
 * 
 * @param reflectionProvider the reflection provider to use or <em>null</em> for best
 *            matching Provider
 * @param driver the driver instance
 * @param classLoaderReference the reference to the {@link ClassLoader} to use
 * @param mapper the instance with the {@link Mapper} chain or <em>null</em> for the default
 *            chain
 * @param converterLookup the instance that is used to lookup the converters
 * @param converterRegistry an instance to manage the converter instances or <em>null</em>
 *            to prevent any further registry (including annotations)
 * @throws InitializationException in case of an initialization problem
 * @since 1.4.5
 */
public XStream(
    ReflectionProvider reflectionProvider, HierarchicalStreamDriver driver,
    ClassLoaderReference classLoaderReference, Mapper mapper, ConverterLookup converterLookup,
    ConverterRegistry converterRegistry) {
    if (reflectionProvider == null) {
        reflectionProvider = JVM.newReflectionProvider();
    }
    this.reflectionProvider = reflectionProvider;
    this.hierarchicalStreamDriver = driver;
    this.classLoaderReference = classLoaderReference;
    this.converterLookup = converterLookup;
    this.converterRegistry = converterRegistry;
    this.mapper = mapper == null ? buildMapper() : mapper;

    setupMappers();
    setupSecurity();
    setupAliases();
    setupDefaultImplementations();
    setupConverters();
    setupImmutableTypes();
    setMode(XPATH_RELATIVE_REFERENCES);
}
 

/**
 * @deprecated As of 1.4.5 use {@link #JavaMethodConverter(ClassLoaderReference)}
 */
public JavaMethodConverter(ClassLoader classLoader) {
    this(new ClassLoaderReference(classLoader));
}
 

/**
 * @deprecated As of 1.4.5 use {@link #JavaFieldConverter(ClassLoaderReference)}
 */
public JavaFieldConverter(ClassLoader classLoader) {
    this(new ClassLoaderReference(classLoader));
}
 

/**
 * @deprecated As of 1.4.5 use {@link #JavaClassConverter(ClassLoaderReference)}
 */
public JavaClassConverter(ClassLoader classLoader) {
    this(new ClassLoaderReference(classLoader));
}
 

public static XStream createTrustingXStream(HierarchicalStreamDriver hierarchicalStreamDriver, ClassLoader classLoader) {
    return internalCreateTrustingXStream(new XStream((ReflectionProvider)null, hierarchicalStreamDriver, new ClassLoaderReference(classLoader)));
}
 

/**
 * @deprecated As of 1.4.5 use {@link #SerializableConverter(Mapper, ReflectionProvider, ClassLoaderReference)}
 */
public SerializableConverter(Mapper mapper, ReflectionProvider reflectionProvider, ClassLoader classLoader) {
    this(mapper, reflectionProvider, new ClassLoaderReference(classLoader));
}
 

/**
 * @deprecated As of 1.4 use {@link #SerializableConverter(Mapper, ReflectionProvider, ClassLoaderReference)}
 */
public SerializableConverter(Mapper mapper, ReflectionProvider reflectionProvider) {
    this(mapper, new UnserializableParentsReflectionProvider(reflectionProvider), new ClassLoaderReference(null));
}
 

/**
 * @deprecated As of 1.4.5 use {@link #ExternalizableConverter(Mapper, ClassLoaderReference)}
 */
public ExternalizableConverter(Mapper mapper, ClassLoader classLoader) {
    this(mapper, new ClassLoaderReference(classLoader));
}
 

/**
 * @deprecated As of 1.4.5 use {@link #DynamicProxyConverter(Mapper, ClassLoaderReference)}
 */
public DynamicProxyConverter(Mapper mapper, ClassLoader classLoader) {
    this(mapper,new ClassLoaderReference(classLoader));
}
 

/**
 * Constructs an XStream with a special {@link HierarchicalStreamDriver},
 * {@link ReflectionProvider}, a prepared {@link Mapper} chain and the {@link ClassLoader}
 * to use.
 * 
 * @param reflectionProvider the reflection provider to use or <em>null</em> for best
 *            matching Provider
 * @param driver the driver instance
 * @param classLoader the {@link ClassLoader} to use
 * @param mapper the instance with the {@link Mapper} chain or <em>null</em> for the default
 *            chain
 * @throws InitializationException in case of an initialization problem
 * @since 1.3
 * @deprecated As of 1.4.5 use
 *             {@link #XStream(ReflectionProvider, HierarchicalStreamDriver, ClassLoaderReference, Mapper)}
 */
public XStream(
    ReflectionProvider reflectionProvider, HierarchicalStreamDriver driver,
    ClassLoader classLoader, Mapper mapper) {
    this(
        reflectionProvider, driver, new ClassLoaderReference(classLoader), mapper, new DefaultConverterLookup());
}
 

/**
 * Constructs an XStream with a special {@link HierarchicalStreamDriver},
 * {@link ReflectionProvider}, a prepared {@link Mapper} chain, the
 * {@link ClassLoaderReference} and an own {@link ConverterLookup} and
 * {@link ConverterRegistry}.
 * 
 * @param reflectionProvider the reflection provider to use or <em>null</em> for best
 *            matching Provider
 * @param driver the driver instance
 * @param classLoader the {@link ClassLoader} to use
 * @param mapper the instance with the {@link Mapper} chain or <em>null</em> for the default
 *            chain
 * @param converterLookup the instance that is used to lookup the converters
 * @param converterRegistry an instance to manage the converter instances
 * @throws InitializationException in case of an initialization problem
 * @since 1.3
 * @deprecated As of 1.4.5 use
 *             {@link #XStream(ReflectionProvider, HierarchicalStreamDriver, ClassLoaderReference, Mapper, ConverterLookup, ConverterRegistry)}
 */
public XStream(
    ReflectionProvider reflectionProvider, HierarchicalStreamDriver driver,
    ClassLoader classLoader, Mapper mapper, ConverterLookup converterLookup,
    ConverterRegistry converterRegistry) {
    this(reflectionProvider, driver, new ClassLoaderReference(classLoader), mapper, converterLookup, converterRegistry);
}
 

/**
 * Constructs an XStream with a special {@link HierarchicalStreamDriver},
 * {@link ReflectionProvider}, a prepared {@link Mapper} chain and the
 * {@link ClassLoaderReference}.
 * <p>
 * The {@link ClassLoaderReference} should also be used for the {@link Mapper} chain.
 * </p>
 * 
 * @param reflectionProvider the reflection provider to use or <em>null</em> for best
 *            matching Provider
 * @param driver the driver instance
 * @param classLoaderReference the reference to the {@link ClassLoader} to use
 * @param mapper the instance with the {@link Mapper} chain or <em>null</em> for the default
 *            chain
 * @throws InitializationException in case of an initialization problem
 * @since 1.4.5
 */
public XStream(
    ReflectionProvider reflectionProvider, HierarchicalStreamDriver driver,
    ClassLoaderReference classLoaderReference, Mapper mapper) {
    this(
        reflectionProvider, driver, classLoaderReference, mapper, new DefaultConverterLookup());
}
 

/**
 * Construct an AnnotationMapper.
 * 
 * @param wrapped the next {@link Mapper} in the chain
 * @since 1.3
 * @deprecated As of 1.4.5 use {@link #AnnotationMapper(Mapper, ConverterRegistry, ConverterLookup, ClassLoaderReference, ReflectionProvider)}
 */
public AnnotationMapper(
    final Mapper wrapped, final ConverterRegistry converterRegistry, final ConverterLookup converterLookup,
    final ClassLoader classLoader, final ReflectionProvider reflectionProvider,
    final JVM jvm) {
    this(wrapped, converterRegistry, converterLookup, new ClassLoaderReference(classLoader), reflectionProvider);
}
 

/**
 * Construct a JavaFieldConverter.
 * @param classLoaderReference the reference to the {@link ClassLoader} of the XStream instance
 * @since 1.4.5
 */
public JavaFieldConverter(ClassLoaderReference classLoaderReference) {
    this(new JavaClassConverter(classLoaderReference), new DefaultMapper(classLoaderReference));
}
 

/**
 * Construct a CGLIBEnhancedConverter.
 * @param mapper the mapper chain instance
 * @param reflectionProvider the reflection provider
 * @param classLoaderReference the reference to the {@link ClassLoader} of the XStream instance
 * @since 1.4.5
 */
public CGLIBEnhancedConverter(Mapper mapper, ReflectionProvider reflectionProvider, ClassLoaderReference classLoaderReference) {
    super(mapper, new CGLIBFilteringReflectionProvider(reflectionProvider), classLoaderReference);
    this.fieldCache = new HashMap();
}
 

/**
 * Construct a SerializableConverter.
 *
 * @param mapper the mapper chain instance
 * @param reflectionProvider the reflection provider
 * @param classLoaderReference the reference to the {@link ClassLoader} of the XStream instance
 * @since 1.4.5
 */
public SerializableConverter(Mapper mapper, ReflectionProvider reflectionProvider, ClassLoaderReference classLoaderReference) {
    super(mapper, new UnserializableParentsReflectionProvider(reflectionProvider));
    this.classLoaderReference = classLoaderReference;
}
 

/**
 * Construct a JavaMethodConverter.
 * @param classLoaderReference the reference to the {@link ClassLoader} of the XStream instance
 * @since 1.4.5
 */
public JavaMethodConverter(ClassLoaderReference classLoaderReference) {
    this(new JavaClassConverter(classLoaderReference));
}
 

/**
 * Warning, this object is expensive to create (due to functionality inherited from superclass).
 * Use the static fetch() method instead, wherever possible.
 *
 * @see #getInstance(DataHolder, StreamCallback, ClassLoaderReference)
 */
public CustomObjectInputStream(StreamCallback callback, ClassLoaderReference classLoaderReference) throws IOException, SecurityException {
    super();
    this.callbacks.push(callback);
    this.classLoaderReference = classLoaderReference;
}
 

/**
 * Construct a JavaClassConverter.
 * @param classLoaderReference the reference to the {@link ClassLoader} of the XStream instance
 * @since 1.4.5
 */
public JavaClassConverter(ClassLoaderReference classLoaderReference) {
    this(new DefaultMapper(classLoaderReference));
}