Java XStreamException类代码示例

import com.thoughtworks.xstream.XStreamException; //导入依赖的package包/类
/**
 * Initialize the population by either reading it from the file or making a new one from scratch
 * 
 * @param space
 */
@Override
public void initialize(Toroidal2DPhysics space) {
	XStream xstream = new XStream();
	xstream.alias("ExampleGAPopulation", ExampleGAPopulation.class);

	// try to load the population from the existing saved file.  If that failes, start from scratch
	try { 
		population = (ExampleGAPopulation) xstream.fromXML(new File(getKnowledgeFile()));
	} catch (XStreamException e) {
		// if you get an error, handle it other than a null pointer because
		// the error will happen the first time you run
		System.out.println("No existing population found - starting a new one from scratch");
		population = new ExampleGAPopulation(populationSize);
	}

	currentPolicy = population.getFirstMember();
}
 

import com.thoughtworks.xstream.XStreamException; //导入依赖的package包/类
/**
 * Demonstrates one way to read in knowledge from a file
 */
@Override
public void initialize(Toroidal2DPhysics space) {
	asteroidToShipMap = new HashMap<UUID, Ship>();
	aimingForBase = new HashMap<UUID, Boolean>();
	
	XStream xstream = new XStream();
	xstream.alias("ExampleKnowledge", ExampleKnowledge.class);

	try { 
		myKnowledge = (ExampleKnowledge) xstream.fromXML(new File(knowledgeFile));
	} catch (XStreamException e) {
		// if you get an error, handle it other than a null pointer because
		// the error will happen the first time you run
		myKnowledge = new ExampleKnowledge();
	}
}
 

import com.thoughtworks.xstream.XStreamException; //导入依赖的package包/类
/**
 * Optionally (if the deserialization is successful) loads a <code>History</code> from the given
 * <code>InputStream</code>.
 *
 * @param stream
 *         the <code>InputStream</code> to load the <code>History</code> from
 * @return optionally the loaded <code>History</code>
 */
public static Optional<History> load(InputStream stream) {
    History history;

    try {
        history = (History) serializer.fromXML(stream);
        history.history.stream().filter(state -> GUI.isDumpGraph(state.getCmdArgs())).forEach(state -> {
            GraphvizParser p = new GraphvizParser(state.getOutput());
            state.setTreeViewTabs(p.call().stream().map(GUI::getTreeTableViewTab).collect(Collectors.toList()));
        });
    } catch (XStreamException | ClassCastException e) {
        LOG.log(Level.WARNING, e, () -> "History deserialization failed.");
        return Optional.empty();
    }

    return Optional.of(history);
}
 

import com.thoughtworks.xstream.XStreamException; //导入依赖的package包/类
@Override
public List<ErrorTypeNotificationConfiguration> translateFindAll(
		String returnValue) throws MethodException, RetrievalException {
	int firstLineBreakIndex = returnValue.indexOf("\r\n");
	String firstLine;
	if (firstLineBreakIndex > 0)
		firstLine = returnValue.substring(0, firstLineBreakIndex);
	else
		firstLine = returnValue;
	String[] lineParts = firstLine.split(DELIMITER);
	if (Integer.parseInt(lineParts[0]) == -1)
		throw new MethodException(returnValue);
	String messageContent = returnValue.substring(firstLineBreakIndex + 2);
	ErrorTypeNotificationConfigurationContainer container;
	try {
		XStream deserializer = getConfiguredXStream();
		container = (ErrorTypeNotificationConfigurationContainer) deserializer.fromXML(messageContent);
	} catch (XStreamException xsX) {
		throw new MethodException(xsX.getMessage(), xsX);
	}
	return container.getConfigs();
}
 

import com.thoughtworks.xstream.XStreamException; //导入依赖的package包/类
public List<ServiceRegistration> translateServiceRegistrations(
		String message) throws MethodException, ConnectionException {
	int firstLineBreakIndex = message.indexOf("\r\n");
	String firstLine;
	if (firstLineBreakIndex > 0)
		firstLine = message.substring(0, firstLineBreakIndex);
	else
		firstLine = message;
	String[] lineParts = firstLine.split(DELIMITER);
	if (Integer.parseInt(lineParts[0]) == -1)
		throw new MethodException(message);
	String messageContent = message.substring(firstLineBreakIndex + 2);
	ServiceRegistry registry;
	try {
		XStream deserializer = getConfiguredXStream();
		registry = (ServiceRegistry) deserializer.fromXML(messageContent);
	} catch (XStreamException xsX) {
		throw new MethodException(xsX.getMessage(), xsX);
	}
	return registry.getRegistrations();
}
 

import com.thoughtworks.xstream.XStreamException; //导入依赖的package包/类
public void testCannotInjectEventHandler() {
    final String xml = ""
        + "<string class='runnable-array'>\n"
        + "  <dynamic-proxy>\n"
        + "    <interface>java.lang.Runnable</interface>\n"
        + "    <handler class='java.beans.EventHandler'>\n"
        + "      <target class='com.thoughtworks.acceptance.SecurityVulnerabilityTest$Exec'/>\n"
        + "      <action>exec</action>\n"
        + "    </handler>\n"
        + "  </dynamic-proxy>\n"
        + "</string>";

    try {
        xstream.fromXML(xml);
        fail("Thrown " + XStreamException.class.getName() + " expected");
    } catch (final XStreamException e) {
        assertTrue(e.getMessage().contains(EventHandler.class.getName()));
    }
    assertEquals(0, BUFFER.length());
}
 

import com.thoughtworks.xstream.XStreamException; //导入依赖的package包/类
public void testCausingExceptionIsNotSuppressed() {
    try {
        toXML(new InvalidForConverter());
        fail("Thrown " + XStreamException.class.getName() + " expected");
    } catch (final XStreamException e) {
        Throwable th = e.getCause();
        for(;;) {
            th = th.getCause();
            assertNotNull("No causing InitializationException.", th);
            if (th instanceof InitializationException) {
                assertTrue("No hint for enum types only", th.getMessage().indexOf(" enum ") >= 0);
                break;
            }
        }
    }
}
 

import com.thoughtworks.xstream.XStreamException; //导入依赖的package包/类
@Override
public void testIsXXEVulnerableWithExternalParameterEntity() throws Exception {
    try {
        super.testIsXXEVulnerableWithExternalParameterEntity();
        fail("Thrown " + XStreamException.class.getName() + " expected");
    } catch (final XStreamException e) {
        final String message = e.getCause().getMessage();
        if (!message.contains("external entity")) {
            if (message.contains("com.wutka.dtd.DTDParseException")) {
                System.err.println("BEAStaxReader was selected as default StAX driver for StaxReaderTest!");
            } else {
                throw e;
            }
        }
    }
}
 

import com.thoughtworks.xstream.XStreamException; //导入依赖的package包/类
public Class realClass(String paramString)
{
  Object localObject = this.realClassCache.get(paramString);
  if (localObject != null)
  {
    if ((localObject instanceof Class))
      return (Class)localObject;
    throw ((XStreamException)localObject);
  }
  try
  {
    Class localClass = super.realClass(paramString);
    this.realClassCache.put(paramString, localClass);
    return localClass;
  }
  catch (ForbiddenClassException localForbiddenClassException)
  {
    this.realClassCache.put(paramString, localForbiddenClassException);
    throw localForbiddenClassException;
  }
  catch (CannotResolveClassException localCannotResolveClassException)
  {
    this.realClassCache.put(paramString, localCannotResolveClassException);
    throw localCannotResolveClassException;
  }
}
 

import com.thoughtworks.xstream.XStreamException; //导入依赖的package包/类
/**
 * Write an object to a file. The default implementation uses XStream.
 * Override to use another way to write objects. Must be compatible with the
 * {@link #readFromFile(Path)} method
 * 
 * @param path
 *            the path of the file to be written
 * @param object
 *            the object to be written
 * @throws IOException
 *             if the object can not be write to the file
 */
protected void writeToFile(Path path, Object object) throws IOException {
    XStream xstream = createXStream();

    OutputStream outputStream;

    // TODO output to temp file and then copy

    outputStream = Files.newOutputStream(path);

    try {
        xstream.toXML(object, outputStream);
    } catch (XStreamException e) {
        throw new IOException(e);
    }
}
 

import com.thoughtworks.xstream.XStreamException; //导入依赖的package包/类
/**
 * Reads an object from a file. The default implementation uses XStream.
 * Override to use another way to read objects. Must be compatible with the
 * {@link #writeToFile(Path, Object)} method
 * 
 * @param path
 *            the path of the file to be read
 * @return the object read from the file
 * @throws IOException
 *             if the object can not be read from the file
 */
protected Object readFromFile(Path path) throws IOException {
    XStream xstream = createXStream();

    InputStream inputStream = Files.newInputStream(path);

    // TODO output to temp file and then copy

    try {
        return xstream.fromXML(inputStream);
    } catch (XStreamException e) {
        e.printStackTrace();

        throw new IOException(e);
    }
}
 

import com.thoughtworks.xstream.XStreamException; //导入依赖的package包/类
/**
 * Write an object to a file. The default implementation uses XStream.
 * Override to use another way to write objects. Must be compatible with the
 * {@link #readFromFile(Path)} method
 * 
 * @param path
 *            the path of the file to be written
 * @param object
 *            the object to be written
 * @throws IOException
 *             if the object can not be write to the file
 */
protected void writeToFile(Path path, Object object) throws IOException {
    XStream xstream = createXStream();

    OutputStream outputStream;

    // TODO output to temp file and then copy

    outputStream = Files.newOutputStream(path);

    try {
        xstream.marshal(object, new PrettyPrintWriter(new OutputStreamWriter(outputStream)));
    } catch (XStreamException e) {
        throw new IOException(e);
    }
}
 

import com.thoughtworks.xstream.XStreamException; //导入依赖的package包/类
/**
 * Convert an object to XML
 * 
 * @param obj
 * @return XML string representation
 */
public static String toXML(Object obj)
{
	init();
	if (xs != null)
	{
		try
		{
			return xs.toXML(obj);
		}
		catch (XStreamException ex)
		{
			//ex.printStackTrace();
		}
	}
	return "";
}
 

import com.thoughtworks.xstream.XStreamException; //导入依赖的package包/类
/**
 * Load an object from the XML string representation
 * 
 * @param xml
 * @return the object
 */
public static Object fromXML(String xml)
{
	init();
	if (xs != null)
	{
		try
		{
			return xs.fromXML(xml);
		}
		catch (XStreamException ex)
		{
			//ex.printStackTrace();
		}
	}
	return null;
}
 

import com.thoughtworks.xstream.XStreamException; //导入依赖的package包/类
/**
 * Reads a dictionary from the provided reader.
 * @param reader reader, cannot be null
 * @return the corresponding dictionary
 * @throws IOException if the dictionary could not be read
 */
public static NaaccrDictionary readDictionary(Reader reader) throws IOException {
    try {
        NaaccrDictionary dictionary = (NaaccrDictionary)instanciateXStream().fromXML(reader);

        if (dictionary.getSpecificationVersion() == null)
            dictionary.setSpecificationVersion(SpecificationVersion.SPEC_1_0);

        // let's not validate the internal dictionaries, we know they are valid
        String uri = dictionary.getDictionaryUri();
        if (uri == null || uri.trim().isEmpty())
            throw new IOException("'dictionaryUri' attribute is required");
        else if (!BASE_DICTIONARY_URI_PATTERN.matcher(uri).matches() && !DEFAULT_USER_DICTIONARY_URI_PATTERN.matcher(uri).matches()) {
            String error = validateUserDictionary(dictionary);
            if (error != null)
                throw new IOException(error);
        }

        return dictionary;
    }
    catch (XStreamException ex) {
        throw new IOException("Unable to read dictionary", ex);
    }
}