public void marshal(Object obj, Result result) throws JAXBException { // XMLSerializable so = Util.toXMLSerializable(obj); XMLSerializable so = context.getGrammarInfo().castToXMLSerializable(obj); if (so == null) throw new MarshalException(Messages.format(Messages.NOT_MARSHALLABLE)); if (result instanceof SAXResult) { write(so, ((SAXResult) result).getHandler()); return; } if (result instanceof DOMResult) { Node node = ((DOMResult) result).getNode(); if (node == null) { try { DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance(); dbf.setNamespaceAware(true); DocumentBuilder db = dbf.newDocumentBuilder(); Document doc = db.newDocument(); ((DOMResult) result).setNode(doc); write(so, new SAX2DOMEx(doc)); } catch (ParserConfigurationException pce) { throw new JAXBAssertionError(pce); } } else { write(so, new SAX2DOMEx(node)); } return; } if (result instanceof StreamResult) { StreamResult sr = (StreamResult) result; XMLWriter w = null; if (sr.getWriter() != null) w = createWriter(sr.getWriter()); else if (sr.getOutputStream() != null) w = createWriter(sr.getOutputStream()); else if (sr.getSystemId() != null) { String fileURL = sr.getSystemId(); if (fileURL.startsWith("file:///")) { if (fileURL.substring(8).indexOf(":") > 0) fileURL = fileURL.substring(8); else fileURL = fileURL.substring(7); } // otherwise assume that it's a file name try { w = createWriter(new FileOutputStream(fileURL)); } catch (IOException e) { throw new MarshalException(e); } } if (w == null) throw new IllegalArgumentException(); write(so, w); return; } // unsupported parameter type throw new MarshalException(Messages.format(Messages.UNSUPPORTED_RESULT)); }
public void validate(Source source, Result result) throws SAXException, IOException { if (result instanceof StreamResult || result == null) { final StreamSource streamSource = (StreamSource) source; final StreamResult streamResult = (StreamResult) result; XMLInputSource input = new XMLInputSource(streamSource.getPublicId(), streamSource.getSystemId(), null); input.setByteStream(streamSource.getInputStream()); input.setCharacterStream(streamSource.getReader()); // Gets the parser configuration. We'll create and initialize a new one, if we // haven't created one before or if the previous one was garbage collected. boolean newConfig = false; XMLParserConfiguration config = (XMLParserConfiguration) fConfiguration.get(); if (config == null) { config = initialize(); newConfig = true; } // If settings have changed on the component manager, refresh the error handler and entity // resolver. else if (fComponentManager.getFeature(PARSER_SETTINGS)) { config.setProperty(ENTITY_RESOLVER, fComponentManager.getProperty(ENTITY_RESOLVER)); config.setProperty(ERROR_HANDLER, fComponentManager.getProperty(ERROR_HANDLER)); config.setProperty(SECURITY_MANAGER, fComponentManager.getProperty(SECURITY_MANAGER)); } // prepare for parse fComponentManager.reset(); if (streamResult != null) { if (fSerializerFactory == null) { fSerializerFactory = SerializerFactory.getSerializerFactory(Method.XML); } // there doesn't seem to be a way to reset a serializer, so we need to make // a new one each time. Serializer ser; if (streamResult.getWriter() != null) { ser = fSerializerFactory.makeSerializer(streamResult.getWriter(), new OutputFormat()); } else if (streamResult.getOutputStream() != null) { ser = fSerializerFactory.makeSerializer(streamResult.getOutputStream(), new OutputFormat()); } else if (streamResult.getSystemId() != null) { String uri = streamResult.getSystemId(); OutputStream out = XMLEntityManager.createOutputStream(uri); ser = fSerializerFactory.makeSerializer(out, new OutputFormat()); } else { throw new IllegalArgumentException( JAXPValidationMessageFormatter.formatMessage( fComponentManager.getLocale(), "StreamResultNotInitialized", null)); } // we're using the parser only as an XNI-to-SAX converter, // so that we can use the SAX-based serializer SAXParser parser = (SAXParser) fParser.get(); if (newConfig || parser == null) { parser = new SAXParser(config); fParser = new SoftReference(parser); } else { parser.reset(); } config.setDocumentHandler(fSchemaValidator); fSchemaValidator.setDocumentHandler(parser); parser.setContentHandler(ser.asContentHandler()); } else { fSchemaValidator.setDocumentHandler(null); } try { config.parse(input); } catch (XMLParseException e) { throw Util.toSAXParseException(e); } catch (XNIException e) { throw Util.toSAXException(e); } finally { // release the references to the SAXParser and Serializer fSchemaValidator.setDocumentHandler(null); } return; } throw new IllegalArgumentException( JAXPValidationMessageFormatter.formatMessage( fComponentManager.getLocale(), "SourceResultMismatch", new Object[] {source.getClass().getName(), result.getClass().getName()})); }
/** * Build the JAXB model and generate the schemas based on tha data * * @param extraFiles additional files. * @return class to {@link QName} resolver. */ private Resolver buildModelAndSchemas( Map<String, ApplicationDescription.ExternalGrammar> extraFiles) { // Lets get all candidate classes so we can create the JAX-B context // include any @XmlSeeAlso references. Set<Class> classSet = new HashSet<Class>(seeAlsoClasses); for (TypeCallbackPair pair : nameCallbacks) { final GenericType genericType = pair.genericType; Class<?> clazz = genericType.getRawType(); // Is this class itself interesting? if (clazz.getAnnotation(XmlRootElement.class) != null) { classSet.add(clazz); } else if (SPECIAL_GENERIC_TYPES.contains(clazz)) { Type type = genericType.getType(); if (type instanceof ParameterizedType) { Type parameterType = ((ParameterizedType) type).getActualTypeArguments()[0]; if (parameterType instanceof Class) { classSet.add((Class) parameterType); } } } } // Create a JAX-B context, and use this to generate us a bunch of // schema objects JAXBIntrospector introspector = null; try { JAXBContext context = JAXBContext.newInstance(classSet.toArray(new Class[classSet.size()])); final List<StreamResult> results = new ArrayList<StreamResult>(); context.generateSchema( new SchemaOutputResolver() { int counter = 0; @Override public Result createOutput(String namespaceUri, String suggestedFileName) { StreamResult result = new StreamResult(new CharArrayWriter()); result.setSystemId("xsd" + (counter++) + ".xsd"); results.add(result); return result; } }); // Store the new files for later use // for (StreamResult result : results) { CharArrayWriter writer = (CharArrayWriter) result.getWriter(); byte[] contents = writer.toString().getBytes("UTF8"); extraFiles.put( result.getSystemId(), new ApplicationDescription.ExternalGrammar( MediaType .APPLICATION_XML_TYPE, // I don't think there is a specific media type for XML // Schema contents)); } // Create an introspector // introspector = context.createJAXBIntrospector(); } catch (JAXBException e) { LOGGER.log(Level.SEVERE, "Failed to generate the schema for the JAX-B elements", e); } catch (IOException e) { LOGGER.log( Level.SEVERE, "Failed to generate the schema for the JAX-B elements due to an IO error", e); } // Create introspector if (introspector != null) { final JAXBIntrospector copy = introspector; return new Resolver() { public QName resolve(Class type) { Object parameterClassInstance = null; try { Constructor<?> defaultConstructor = type.getDeclaredConstructor(); defaultConstructor.setAccessible(true); parameterClassInstance = defaultConstructor.newInstance(); } catch (InstantiationException ex) { LOGGER.log(Level.FINE, null, ex); } catch (IllegalAccessException ex) { LOGGER.log(Level.FINE, null, ex); } catch (IllegalArgumentException ex) { LOGGER.log(Level.FINE, null, ex); } catch (InvocationTargetException ex) { LOGGER.log(Level.FINE, null, ex); } catch (SecurityException ex) { LOGGER.log(Level.FINE, null, ex); } catch (NoSuchMethodException ex) { LOGGER.log(Level.FINE, null, ex); } if (parameterClassInstance == null) { return null; } try { return copy.getElementName(parameterClassInstance); } catch (NullPointerException e) { // EclipseLink throws an NPE if an object annotated with @XmlType and without the // @XmlRootElement // annotation is passed as a parameter of #getElementName method. return null; } } }; } else { return null; // No resolver created } }