Java Unmarshaller类代码示例

import org.exolab.castor.xml.Unmarshaller; //导入依赖的package包/类
public static Object unMarshallString(Reader reader, Class objectClass) throws IOException {
    Unmarshaller unmarshaller = new Unmarshaller(objectClass);
    Object castor;
    try {
        InputSource is = new InputSource(reader);
        is.setSystemId("stringBuffer");
        castor = unmarshaller.unmarshal(is);
        reader.close();
    } catch (MarshalException marshalException) {
        //TODO Juzer throw proper exception so that calling function can handle it
        throw new IOException(marshalException.getMessage());
    } catch (ValidationException validationException) {
        throw new IOException(validationException.getMessage());
    }
    return castor;
}
 

import org.exolab.castor.xml.Unmarshaller; //导入依赖的package包/类
@Override
public List<StatisticDescriptor> getStatisticDescriptors(String filePath)
		throws ParserException {
	try {
		Mapping mapping = new Mapping();
		mapping.loadMapping(FileUtils.findFileAsResource("StatisticDescriptorMapping.xml"));
		XMLContext context = new XMLContext();
		context.addMapping(mapping);
		InputSource source = new InputSource(FileUtils.findFileAsStream(filePath));
		Unmarshaller unmarshaller = context.createUnmarshaller();
		unmarshaller.setClass(StatisticList.class);
		StatisticList list = (StatisticList)unmarshaller.unmarshal(source);
		validate(list.getDescriptors());
		return list.getDescriptors();
	} catch (Exception e) {
		ParserException parserException = new ParserException("Exception parsing statistic descriptor files", e);
		Logger.getLogger(this.getClass()).error(parserException.getMessage(), parserException);
		throw parserException;
	} 
}
 

import org.exolab.castor.xml.Unmarshaller; //导入依赖的package包/类
@SuppressWarnings("unchecked")
public static List<Synonym> readFromFile(String filename) throws Exception {
	Mapping mapping = getMapping();
	Unmarshaller unmarshaller = new Unmarshaller(ArrayList.class);
	unmarshaller.setMapping(mapping);

	File file = new File(filename);

       if (file.exists() && !file.isFile()) {
           throw new IOException("File " + file.getAbsolutePath() + " exists but is not a file.");
       }

	if (!file.exists() || file.length() == 0) {
		return Collections.emptyList();
	}

	Reader reader = new FileReader(file);
	return (List<Synonym>) unmarshaller.unmarshal(reader);
}
 

import org.exolab.castor.xml.Unmarshaller; //导入依赖的package包/类
/**
 * Initializes the Castor mapping instance.
 * @param mapping a Castor mapping. Shall not be <code>null</code>.
 * @throws NullPointerException if <code>mapping</code> is <code>null</code>.
 * @throws MappingException an exception indicating an invalid mapping error.
 */
private void setMapping(final Mapping mapping) throws MappingException
{
    _unmarshaller = new Unmarshaller(mapping); // May throw MappingException.
    _unmarshaller.setValidation(false);
    _unmarshaller.setIgnoreExtraElements(true);

    _marshaller = new Marshaller();
    _marshaller.setMapping(mapping); // May throw MappingException.
    _marshaller.setValidation(false);
    //_marshaller.setDebug(true);
    // Specifies whether to support XML namespaces by default. Default is false.
    //_marshaller.setProperty("org.exolab.castor.parser.namespaces", "true");
    // Specifies whether XML documents (as generated at marshalling) should use indentation or not. Default is false.
    //_marshaller.setProperty("org.exolab.castor.indent", "true");
}
 

import org.exolab.castor.xml.Unmarshaller; //导入依赖的package包/类
/**
 * {@inheritDoc}
 *
 * @see marshalsec.MarshallerBase#unmarshal(java.lang.Object)
 */
@Override
public Object unmarshal ( String data ) throws Exception {
    XMLContext context = new XMLContext();
    Unmarshaller unmarshaller = context.createUnmarshaller();
    return unmarshaller.unmarshal(new StringReader(data));
}
 

import org.exolab.castor.xml.Unmarshaller; //导入依赖的package包/类
@Override
protected Object unmarshalSaxReader(XMLReader xmlReader, InputSource inputSource)
		throws XmlMappingException, IOException {

	UnmarshalHandler unmarshalHandler = createUnmarshaller().createHandler();
	try {
		ContentHandler contentHandler = Unmarshaller.getContentHandler(unmarshalHandler);
		xmlReader.setContentHandler(contentHandler);
		xmlReader.parse(inputSource);
		return unmarshalHandler.getObject();
	}
	catch (SAXException ex) {
		throw new UnmarshallingFailureException("SAX reader exception", ex);
	}
}
 

import org.exolab.castor.xml.Unmarshaller; //导入依赖的package包/类
/**
 * Template method that allows for customizing of the given Castor {@link Unmarshaller}.
 */
protected void customizeUnmarshaller(Unmarshaller unmarshaller) {
	unmarshaller.setValidation(this.validating);
	unmarshaller.setWhitespacePreserve(this.whitespacePreserve);
	unmarshaller.setIgnoreExtraAttributes(this.ignoreExtraAttributes);
	unmarshaller.setIgnoreExtraElements(this.ignoreExtraElements);
	unmarshaller.setObject(this.rootObject);
	unmarshaller.setReuseObjects(this.reuseObjects);
	unmarshaller.setClearCollections(this.clearCollections);
	if (this.namespaceToPackageMapping != null) {
		for (Map.Entry<String, String> mapping : this.namespaceToPackageMapping.entrySet()) {
			unmarshaller.addNamespaceToPackageMapping(mapping.getKey(), mapping.getValue());
		}
	}
	if (this.entityResolver != null) {
		unmarshaller.setEntityResolver(this.entityResolver);
	}
	if (this.classDescriptorResolver != null) {
		unmarshaller.setResolver(this.classDescriptorResolver);
	}
	if (this.idResolver != null) {
		unmarshaller.setIDResolver(this.idResolver);
	}
	if (this.objectFactory != null) {
		unmarshaller.setObjectFactory(this.objectFactory);
	}
	if (this.beanClassLoader != null) {
		unmarshaller.setClassLoader(this.beanClassLoader);
	}
}
 

import org.exolab.castor.xml.Unmarshaller; //导入依赖的package包/类
@Override
public TxnRes unserializeTxnRes(String xml) throws IOException {
	try {
        Unmarshaller unmarshaller = new Unmarshaller(_mapping);
        return (TxnRes) unmarshaller.unmarshal(new InputSource(new ByteArrayInputStream(xml.getBytes())));
        
	} catch (Exception e) {
		throw new IOException("Exception occured during XML unmarshalling.", e);
		
	}
}
 

import org.exolab.castor.xml.Unmarshaller; //导入依赖的package包/类
public static Configuration readFromFile(String filename) throws Exception {
	Mapping mapping = getMapping();
	Unmarshaller unmarshaller = new Unmarshaller(mapping);

	File file = new File(filename);
	Reader reader = new FileReader(file);
	Configuration configuration = (Configuration)unmarshaller.unmarshal(reader);
	LOG.info("Configuration read from " + file.getAbsoluteFile());
	return configuration;
}
 

import org.exolab.castor.xml.Unmarshaller; //导入依赖的package包/类
private Xport getXportData(String queryString) throws JRException {
    String rrdBinary = getRrdBinary();
       if(rrdBinary == null) {
           throw new JRException("rrd.binary property must be set either in opennms.properties or in iReport");
       }

	String command = rrdBinary + " xport " + queryString.replaceAll("[\r\n]+", " ").replaceAll("\\s+", " ");
	log().debug("getXportData: executing command: " + command);
	String[] commandArray = StringUtils.createCommandArray(command, '@');
	Xport data = null;
	try {
		Process process = Runtime.getRuntime().exec(commandArray);
		// this closes the stream when its finished
		byte[] byteArray = FileCopyUtils.copyToByteArray(process.getInputStream());             
		// this close the stream when its finished
		String errors = FileCopyUtils.copyToString(new InputStreamReader(process.getErrorStream()));
		if (errors.length() > 0) {
			log().error("getXportData: RRDtool command fail: " + errors);
			return null;
		}
		BufferedReader reader = null;
		try {
			InputStream is = new ByteArrayInputStream(byteArray);
			reader = new BufferedReader(new InputStreamReader(is));
			data = (Xport) Unmarshaller.unmarshal(Xport.class, reader);
		} finally {
			reader.close();
		}
	} catch (Exception e) {
		log().error("getXportData: can't execute command '" + command + ": ", e);
		throw new JRException("getXportData: can't execute command '" + command + ": ", e);
	}
	return data;
}
 

import org.exolab.castor.xml.Unmarshaller; //导入依赖的package包/类
/**
 * <p>Constructor for XmpConfigFactory.</p>
 *
 * @param configFile a {@link java.lang.String} object.
 * @throws org.exolab.castor.xml.MarshalException if any.
 * @throws org.exolab.castor.xml.ValidationException if any.
 * @throws java.io.IOException if any.
 */
public XmpConfigFactory(String configFile) 
throws MarshalException, ValidationException, IOException 
{ 
    InputStream cfgIn = new FileInputStream(configFile);

    config = (XmpConfig)Unmarshaller.unmarshal(XmpConfig.class,
                                               new InputStreamReader(cfgIn, "UTF-8"));
    cfgIn.close();
    return; 
}
 

import org.exolab.castor.xml.Unmarshaller; //导入依赖的package包/类
@SuppressWarnings("unchecked")
public static <T> T duplicateObject(T object, Class<T> clazz) throws MarshalException, ValidationException {
    StringWriter stringWriter = new StringWriter();
    Marshaller.marshal(object, stringWriter);
    StringReader stringReader = new StringReader(stringWriter.toString());
    return (T) Unmarshaller.unmarshal(clazz, stringReader);
}
 

import org.exolab.castor.xml.Unmarshaller; //导入依赖的package包/类
public Object readCastorObject( String inputFileName, Class expectedClass ) {
  Object o = null;
  try {
    // read in the object
    o = Unmarshaller.unmarshal( expectedClass, new FileReader( inputFileName ) );
  } catch ( Exception e ) {
    getLogger().error( e.getMessage(), e );
  }
  return o;
}
 

import org.exolab.castor.xml.Unmarshaller; //导入依赖的package包/类
private Unmarshaller createUnmarshaller() {
	Unmarshaller unmarshaller = this.xmlContext.createUnmarshaller();
	customizeUnmarshaller(unmarshaller);
	return unmarshaller;
}
 

import org.exolab.castor.xml.Unmarshaller; //导入依赖的package包/类
public Unmarshaller createUnmarshaller(Exchange exchange) throws Exception {
    // need to create new marshaller as we may have concurrent processing
    Unmarshaller answer = xmlContext.createUnmarshaller();
    answer.setValidation(isValidation());
    return answer;
}