org.jibx.runtime.JiBXException Java Examples

public void toXML(ModelDefinition.XMLBindingType bindingType, OutputStream xml)
{
    try
    {
    	if(bindingType == null)
    	{
    		bindingType = ModelDefinition.XMLBindingType.DEFAULT;
    	}

    	String bindingName = bindingType.toString();
        IBindingFactory factory = (bindingName != null) ? BindingDirectory.getFactory(bindingName, M2Model.class) :
        	BindingDirectory.getFactory("default", M2Model.class);
        IMarshallingContext context = factory.createMarshallingContext();
        context.setIndent(4);
        context.marshalDocument(this, "UTF-8", null, xml);
    }
    catch(JiBXException e)
    {
        throw new DictionaryException(ERR_CREATE_M2MODEL_FAILURE, e);
    }
}
 

/**
 * Unmarshal this xml Message to an object.
 * @param xml
 * @param system
 * @return
 */
public static Object unmarshalMessage(String xml, String version)
{
	String packageName = "org.dslforum." + version;
	String bindingName = "binding";

	try {
		IBindingFactory jc = BindingDirectory.getFactory(bindingName, packageName);
		IUnmarshallingContext unmarshaller = jc.createUnmarshallingContext();
		Reader inStream = new StringReader(xml);
		Object message = unmarshaller.unmarshalDocument( inStream, bindingName);
		return message;
	} catch (JiBXException e) {
		e.printStackTrace();
	}
	return null;
}
 

public SimpleRulesData(String ruleName, int width, int height) throws JiBXException {
	this.width = width;
	this.height = height;
	IBindingFactory bfact = BindingDirectory.getFactory(StyledLayerDescriptorInfo.class);
	IUnmarshallingContext uctx = bfact.createUnmarshallingContext();
	Object object = uctx.unmarshalDocument(
			getClass().getResourceAsStream("/org/geomajas/testdata/sld/simple_rules.sld"), null);
	StyledLayerDescriptorInfo sld = (StyledLayerDescriptorInfo) object;
	NamedLayerInfo namedLayerInfo = sld.getChoiceList().get(0).getNamedLayer();
	UserStyleInfo userStyleInfo = namedLayerInfo.getChoiceList().get(0).getUserStyle();
	FeatureTypeStyleInfo featureTypeStyleInfo = userStyleInfo.getFeatureTypeStyleList().get(0);
	for (RuleInfo rule : featureTypeStyleInfo.getRuleList()) {
		if (ruleName.equals(rule.getName())) {
			ruleInfo = rule;
		}
	}
}
 

@Test
public void testStyleWithExternalGraphicNoSize() throws JiBXException, LayerException {
	IBindingFactory bfact = BindingDirectory.getFactory(StyledLayerDescriptorInfo.class);
	IUnmarshallingContext uctx = bfact.createUnmarshallingContext();
	Object object = uctx.unmarshalDocument(
			getClass().getResourceAsStream("/org/geomajas/testdata/sld/point_externalgraphicnosize.sld"),
					null);
	StyledLayerDescriptorInfo sld = (StyledLayerDescriptorInfo) object;
	NamedStyleInfo info = styleConverterService.convert(sld.getChoiceList().get(0).getNamedLayer().getChoiceList()
			.get(0).getUserStyle(), featureInfo);
	Assert.assertNotNull(info);
}
 

@Test
public void testSingleStyle() throws JiBXException, LayerException {
	IBindingFactory bfact = BindingDirectory.getFactory(StyledLayerDescriptorInfo.class);
	IUnmarshallingContext uctx = bfact.createUnmarshallingContext();
	Object object = uctx.unmarshalDocument(
			getClass().getResourceAsStream("/org/geomajas/testdata/sld/single_layer_no_stylename.sld"), null);
	StyledLayerDescriptorInfo sld = (StyledLayerDescriptorInfo) object;
	NamedStyleInfo info = styleConverterService.convert(sld.getChoiceList().get(0).getNamedLayer().getChoiceList()
			.get(0).getUserStyle(), featureInfo);
	Assert.assertNotNull(info);
	Assert.assertEquals("Some title", info.getName());
}
 

@Override
protected void marshalOutputStream(Object graph, OutputStream outputStream)
		throws XmlMappingException, IOException {
	try {
		IMarshallingContext marshallingContext = createMarshallingContext();
		marshallingContext.startDocument(this.encoding, this.standalone, outputStream);
		marshalDocument(marshallingContext, graph);
	}
	catch (JiBXException ex) {
		throw convertJibxException(ex, true);
	}
}
 

@Override
protected void marshalWriter(Object graph, Writer writer) throws XmlMappingException, IOException {
	try {
		IMarshallingContext marshallingContext = createMarshallingContext();
		marshallingContext.startDocument(this.encoding, this.standalone, writer);
		marshalDocument(marshallingContext, graph);
	}
	catch (JiBXException ex) {
		throw convertJibxException(ex, true);
	}
}
 

private void marshalDocument(IMarshallingContext marshallingContext, Object graph) throws IOException, JiBXException {
	if (StringUtils.hasLength(docTypeRootElementName)) {
		IXMLWriter xmlWriter = marshallingContext.getXmlWriter();
		xmlWriter.writeDocType(docTypeRootElementName, docTypeSystemId, docTypePublicId, docTypeInternalSubset);
	}
	marshallingContext.marshalDocument(graph);
}
 

@Override
protected void marshalXmlStreamWriter(Object graph, XMLStreamWriter streamWriter) throws XmlMappingException {
	try {
		MarshallingContext marshallingContext = (MarshallingContext) createMarshallingContext();
		IXMLWriter xmlWriter = new StAXWriter(marshallingContext.getNamespaces(), streamWriter);
		marshallingContext.setXmlWriter(xmlWriter);
		marshallingContext.marshalDocument(graph);
	}
	catch (JiBXException ex) {
		throw convertJibxException(ex, false);
	}
}
 

@Override
protected Object unmarshalXmlStreamReader(XMLStreamReader streamReader) {
	try {
		UnmarshallingContext unmarshallingContext = (UnmarshallingContext) createUnmarshallingContext();
		IXMLReader xmlReader = new StAXReaderWrapper(streamReader, null, true);
		unmarshallingContext.setDocument(xmlReader);
		return unmarshallingContext.unmarshalElement();
	}
	catch (JiBXException ex) {
		throw convertJibxException(ex, false);
	}
}
 

@Override
protected Object unmarshalInputStream(InputStream inputStream) throws XmlMappingException, IOException {
	try {
		IUnmarshallingContext unmarshallingContext = createUnmarshallingContext();
		return unmarshallingContext.unmarshalDocument(inputStream, encoding);
	}
	catch (JiBXException ex) {
		throw convertJibxException(ex, false);
	}
}
 

@Override
protected Object unmarshalReader(Reader reader) throws XmlMappingException, IOException {
	try {
		IUnmarshallingContext unmarshallingContext = createUnmarshallingContext();
		return unmarshallingContext.unmarshalDocument(reader);
	}
	catch (JiBXException ex) {
		throw convertJibxException(ex, false);
	}
}
 

/**
 * Convert the given {@code JiBXException} to an appropriate exception from the
 * {@code org.springframework.oxm} hierarchy.
 * <p>A boolean flag is used to indicate whether this exception occurs during marshalling or
 * unmarshalling, since JiBX itself does not make this distinction in its exception hierarchy.
 * @param ex {@code JiBXException} that occured
 * @param marshalling indicates whether the exception occurs during marshalling ({@code true}),
 * or unmarshalling ({@code false})
 * @return the corresponding {@code XmlMappingException}
 */
public XmlMappingException convertJibxException(JiBXException ex, boolean marshalling) {
	if (ex instanceof ValidationException) {
		return new ValidationFailureException("JiBX validation exception", ex);
	}
	else {
		if (marshalling) {
			return new MarshallingFailureException("JiBX marshalling exception", ex);
		}
		else {
			return new UnmarshallingFailureException("JiBX unmarshalling exception", ex);
		}
	}
}
 

public String marshalEmployee(Employee employee){
	try {
		IBindingFactory bfact = BindingDirectory.getFactory(Employee.class);
		IMarshallingContext mctx = bfact.createMarshallingContext();
		mctx.setIndent(2);
		StringWriter stringWriter = new StringWriter();
		mctx.setOutput(stringWriter);
		mctx.marshalDocument(employee, "UTF-8", null);
		String output = stringWriter.toString();
		return output;
	} catch (JiBXException e) {
		e.printStackTrace();
	}
	return null;
}
 

public void unMarshalEmployee(String inputXml){
	try {
		IBindingFactory bfact = BindingDirectory.getFactory(Employee.class);
		IUnmarshallingContext uctx = bfact.createUnmarshallingContext();
		StringReader stringReader = new StringReader(inputXml);
		Employee employee  = (Employee) uctx.unmarshalDocument(stringReader, null);
		System.out.println("Employee ID:"+employee.getId());
	} catch (JiBXException e) {
		e.printStackTrace();
	}	
}
 

/**
 * Parse incoming XML request data via JiBX's unmarshaller and return only the MSISDN being requested
 *
 * @param requestStream InputStream (likely directly from the HTTP POST) of the XML input data
 * @return MSISDN of device to locate
 * @throws MLPException
 */
public String parseRequest(InputStream requestStream) throws MLPException {
  // Result XML
  String requestingserviceid, requestingMSISDN = null;

  // Process the request
  try {
    // Create the JiBX unmarshalling object
    IBindingFactory jc = BindingDirectory.getFactory(org.oma.protocols.mlp.svc_init.SvcInit.class);
    IUnmarshallingContext unmarshaller = jc.createUnmarshallingContext();

    // Unmarshal directly from the POST input stream
    org.oma.protocols.mlp.svc_init.SvcInit svcInit = (org.oma.protocols.mlp.svc_init.SvcInit) unmarshaller.unmarshalDocument(requestStream, "UTF-8");

    // Process the location request for the specified MSISDN
    org.oma.protocols.mlp.svc_init.Msids msids = svcInit.getSlir().getMsids();
    org.oma.protocols.mlp.svc_init.Msids.Choice c = msids.getChoiceList().get(0);
    org.oma.protocols.mlp.svc_init.Msid msisdn = c.getMsid();
    requestingMSISDN = msisdn.getString();
    //Process the location request for serviceid
    org.oma.protocols.mlp.svc_init.Serviceid serviceidd = svcInit.getHdr().getClient().getServiceid();
    requestingserviceid = serviceidd.getServiceid();
    this.logger.info("Parsed location request for MSISDN: " + requestingMSISDN);
    return requestingMSISDN + ";" + requestingserviceid;
  } catch (JiBXException e) {
    e.printStackTrace();
    this.logger.info("Exception while unmarshalling XML request data: " + e.getMessage());

    // Set a custom error message for delivering directly to the client
    // and throw a new exception
    MLPException mlpException = new MLPException(e.getMessage());
    mlpException.setMlpClientErrorMessage("Invalid XML received: " + e.getMessage());
    mlpException.setMlpClientErrorType(MLPResponse.MLPResultType.FORMAT_ERROR);
    throw mlpException;
  }
}
 

@Override
public void afterPropertiesSet() throws JiBXException {
	if (this.targetClass != null) {
		if (StringUtils.hasLength(this.bindingName)) {
			if (logger.isInfoEnabled()) {
				logger.info("Configured for target class [" + this.targetClass + "] using binding [" + this.bindingName + "]");
			}
			this.bindingFactory = BindingDirectory.getFactory(this.bindingName, this.targetClass);
		}
		else {
			if (logger.isInfoEnabled()) {
				logger.info("Configured for target class [" + this.targetClass + "]");
			}
			this.bindingFactory = BindingDirectory.getFactory(this.targetClass);
		}
	}
	else if (this.targetPackage != null) {
		if (!StringUtils.hasLength(bindingName)) {
			bindingName = DEFAULT_BINDING_NAME;
		}
		if (logger.isInfoEnabled()) {
			logger.info("Configured for target package [" + this.targetPackage	+ "] using binding [" + this.bindingName + "]");
		}
		this.bindingFactory = BindingDirectory.getFactory(this.bindingName, this.targetPackage);
	}
	else {
		throw new IllegalArgumentException("Either 'targetClass' or 'targetPackage' is required");
	}
}
 

@Test
public void testStyleWithAttributeLabel() throws JiBXException, LayerException {
	IBindingFactory bfact = BindingDirectory.getFactory(StyledLayerDescriptorInfo.class);
	IUnmarshallingContext uctx = bfact.createUnmarshallingContext();
	Object object = uctx.unmarshalDocument(
			getClass().getResourceAsStream("/org/geomajas/testdata/sld/line_labelfollowingline.sld"),
					null);
	StyledLayerDescriptorInfo sld = (StyledLayerDescriptorInfo) object;
	NamedStyleInfo info = styleConverterService.convert(sld.getChoiceList().get(0).getNamedLayer().getChoiceList()
			.get(0).getUserStyle(), featureInfo);
	Assert.assertNotNull(info);
	
	Assert.assertEquals("name", info.getLabelStyle().getLabelAttributeName());

}
 

@Test
public void testStyleWithLiteralLabel() throws JiBXException, LayerException {
	IBindingFactory bfact = BindingDirectory.getFactory(StyledLayerDescriptorInfo.class);
	IUnmarshallingContext uctx = bfact.createUnmarshallingContext();
	Object object = uctx.unmarshalDocument(
			getClass().getResourceAsStream("/org/geomajas/testdata/sld/line_literallabelfollowingline.sld"),
					null);
	StyledLayerDescriptorInfo sld = (StyledLayerDescriptorInfo) object;
	NamedStyleInfo info = styleConverterService.convert(sld.getChoiceList().get(0).getNamedLayer().getChoiceList()
			.get(0).getUserStyle(), featureInfo);
	Assert.assertNotNull(info);
	
	Assert.assertEquals("'\u2192'", info.getLabelStyle().getLabelValueExpression());

}
 

@Test
public void testStyleWithLiteralCssParameter() throws JiBXException, LayerException {
	IBindingFactory bfact = BindingDirectory.getFactory(StyledLayerDescriptorInfo.class);
	IUnmarshallingContext uctx = bfact.createUnmarshallingContext();
	Object object = uctx.unmarshalDocument(
			getClass().getResourceAsStream("/org/geomajas/testdata/sld/polygon_literalcssparameter.sld"),
					null);
	StyledLayerDescriptorInfo sld = (StyledLayerDescriptorInfo) object;
	NamedStyleInfo info = styleConverterService.convert(sld.getChoiceList().get(0).getNamedLayer().getChoiceList()
			.get(0).getUserStyle(), featureInfo);
	Assert.assertNotNull(info);
}
 

@Test
public void whenUnmarshalXML_ThenFieldsAreMapped() throws JiBXException, FileNotFoundException {
	IBindingFactory bfact = BindingDirectory.getFactory(Customer.class);
	IUnmarshallingContext uctx = bfact.createUnmarshallingContext();
	ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
	InputStream inputStream = classLoader.getResourceAsStream("Customer1.xml");
	Customer customer = (Customer) uctx.unmarshalDocument(inputStream, null);

	assertEquals("Stefan Jaeger", customer.getPerson().getName());
	assertEquals("Davos Dorf", customer.getCity());

}
 

@Test
public void WhenUnmarshal_ThenMappingInherited() throws JiBXException, FileNotFoundException {
	IBindingFactory bfact = BindingDirectory.getFactory(Customer.class);
	IUnmarshallingContext uctx = bfact.createUnmarshallingContext();
	ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
	InputStream inputStream = classLoader.getResourceAsStream("Customer1.xml");
	Customer customer = (Customer) uctx.unmarshalDocument(inputStream, null);

	assertEquals(12345, customer.getPerson().getCustomerId());

}
 

@Test
public void WhenUnmarshal_ThenPhoneMappingRead() throws JiBXException, FileNotFoundException {
	IBindingFactory bfact = BindingDirectory.getFactory(Customer.class);
	IUnmarshallingContext uctx = bfact.createUnmarshallingContext();
	ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
	InputStream inputStream = classLoader.getResourceAsStream("Customer1.xml");
	Customer customer = (Customer) uctx.unmarshalDocument(inputStream, null);
	
	assertEquals("234678", customer.getHomePhone().getNumber());

}
 

public static Object unmarshalMessage(Class className, String xml, String version) {
	String packageName = "org.dslforum." + version;
	String bindingName = "binding";
	try {
		IBindingFactory jc = BindingDirectory.getFactory(bindingName, className);
		IUnmarshallingContext unmarshaller = jc.createUnmarshallingContext();
		Reader inStream = new StringReader(xml);
		Object message = unmarshaller.unmarshalDocument( inStream, bindingName);
		return message;
	} catch (JiBXException e) {
		e.printStackTrace();
	}
	return null;
}
 

/**
 * Convert xml string to Java Objects
 */
public Object deserialize(String xml) {
IBindingFactory bfact = null;
StringReader sr = new StringReader(xml);
Object obj = null;
try {
        bfact = BindingDirectory.getFactory(bindingName, packageName);
        obj = bfact.createUnmarshallingContext().unmarshalDocument(sr);
} catch (JiBXException e) {
        log.error(e);
        throw new XMLMappingException("Can't deserialize xml: " + xml, e);
}
        return obj;
}
 

/**
 * Convert Java Object to XML String
 */
public String serialize(Object obj) {
        IBindingFactory bfact = null;
        StringWriter sw = new StringWriter();
        try {
                bfact =  BindingDirectory.getFactory(obj.getClass());
                bfact.createMarshallingContext().marshalDocument(obj, "UTF-8", null, sw );
        } catch (JiBXException e) {
                log.error(e);
                throw new XMLMappingException("Can't serialize object: " + obj.toString(), e );
        }
        return sw.toString();
}
 

private void marshalDocument(IMarshallingContext marshallingContext, Object graph) throws IOException, JiBXException {
	if (StringUtils.hasLength(this.docTypeRootElementName)) {
		IXMLWriter xmlWriter = marshallingContext.getXmlWriter();
		xmlWriter.writeDocType(this.docTypeRootElementName, this.docTypeSystemId,
				this.docTypePublicId, this.docTypeInternalSubset);
	}
	marshallingContext.marshalDocument(graph);
}
 

@Override
protected void marshalOutputStream(Object graph, OutputStream outputStream)
		throws XmlMappingException, IOException {
	try {
		IMarshallingContext marshallingContext = createMarshallingContext();
		marshallingContext.startDocument(this.encoding, this.standalone, outputStream);
		marshalDocument(marshallingContext, graph);
	}
	catch (JiBXException ex) {
		throw convertJibxException(ex, true);
	}
}
 

@Override
protected void marshalWriter(Object graph, Writer writer) throws XmlMappingException, IOException {
	try {
		IMarshallingContext marshallingContext = createMarshallingContext();
		marshallingContext.startDocument(this.encoding, this.standalone, writer);
		marshalDocument(marshallingContext, graph);
	}
	catch (JiBXException ex) {
		throw convertJibxException(ex, true);
	}
}
 

private void marshalDocument(IMarshallingContext marshallingContext, Object graph) throws IOException, JiBXException {
	if (StringUtils.hasLength(this.docTypeRootElementName)) {
		IXMLWriter xmlWriter = marshallingContext.getXmlWriter();
		xmlWriter.writeDocType(this.docTypeRootElementName, this.docTypeSystemId,
				this.docTypePublicId, this.docTypeInternalSubset);
	}
	marshallingContext.marshalDocument(graph);
}