1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000 1.2 +++ b/src/share/jaxws_classes/javax/xml/bind/helpers/AbstractUnmarshallerImpl.java Wed Apr 27 01:27:09 2016 +0800 1.3 @@ -0,0 +1,435 @@ 1.4 +/* 1.5 + * Copyright (c) 2003, 2013, Oracle and/or its affiliates. All rights reserved. 1.6 + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 1.7 + * 1.8 + * This code is free software; you can redistribute it and/or modify it 1.9 + * under the terms of the GNU General Public License version 2 only, as 1.10 + * published by the Free Software Foundation. Oracle designates this 1.11 + * particular file as subject to the "Classpath" exception as provided 1.12 + * by Oracle in the LICENSE file that accompanied this code. 1.13 + * 1.14 + * This code is distributed in the hope that it will be useful, but WITHOUT 1.15 + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 1.16 + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 1.17 + * version 2 for more details (a copy is included in the LICENSE file that 1.18 + * accompanied this code). 1.19 + * 1.20 + * You should have received a copy of the GNU General Public License version 1.21 + * 2 along with this work; if not, write to the Free Software Foundation, 1.22 + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 1.23 + * 1.24 + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 1.25 + * or visit www.oracle.com if you need additional information or have any 1.26 + * questions. 1.27 + */ 1.28 + 1.29 +package javax.xml.bind.helpers; 1.30 + 1.31 +import org.xml.sax.InputSource; 1.32 +import org.xml.sax.SAXException; 1.33 +import org.xml.sax.XMLReader; 1.34 +import org.w3c.dom.Node; 1.35 + 1.36 +import javax.xml.bind.JAXBException; 1.37 +import javax.xml.bind.PropertyException; 1.38 +import javax.xml.bind.UnmarshalException; 1.39 +import javax.xml.bind.Unmarshaller; 1.40 +import javax.xml.bind.ValidationEventHandler; 1.41 +import javax.xml.bind.JAXBElement; 1.42 +import javax.xml.bind.annotation.adapters.XmlAdapter; 1.43 +import javax.xml.bind.attachment.AttachmentUnmarshaller; 1.44 +import javax.xml.parsers.ParserConfigurationException; 1.45 +import javax.xml.parsers.SAXParserFactory; 1.46 +import javax.xml.stream.XMLEventReader; 1.47 +import javax.xml.stream.XMLStreamReader; 1.48 +import javax.xml.transform.Source; 1.49 +import javax.xml.transform.dom.DOMSource; 1.50 +import javax.xml.transform.sax.SAXSource; 1.51 +import javax.xml.transform.stream.StreamSource; 1.52 +import javax.xml.validation.Schema; 1.53 +import java.io.File; 1.54 +import java.io.Reader; 1.55 +import java.net.MalformedURLException; 1.56 +import java.net.URL; 1.57 + 1.58 +/** 1.59 + * Partial default <tt>Unmarshaller</tt> implementation. 1.60 + * 1.61 + * <p> 1.62 + * This class provides a partial default implementation for the 1.63 + * {@link javax.xml.bind.Unmarshaller}interface. 1.64 + * 1.65 + * <p> 1.66 + * A JAXB Provider has to implement five methods (getUnmarshallerHandler, 1.67 + * unmarshal(Node), unmarshal(XMLReader,InputSource), 1.68 + * unmarshal(XMLStreamReader), and unmarshal(XMLEventReader). 1.69 + * 1.70 + * @author <ul> 1.71 + * <li>Kohsuke Kawaguchi, Sun Microsystems, Inc.</li> 1.72 + * </ul> 1.73 + * @see javax.xml.bind.Unmarshaller 1.74 + * @since JAXB1.0 1.75 + */ 1.76 +public abstract class AbstractUnmarshallerImpl implements Unmarshaller 1.77 +{ 1.78 + /** handler that will be used to process errors and warnings during unmarshal */ 1.79 + private ValidationEventHandler eventHandler = 1.80 + new DefaultValidationEventHandler(); 1.81 + 1.82 + /** whether or not the unmarshaller will validate */ 1.83 + protected boolean validating = false; 1.84 + 1.85 + /** 1.86 + * XMLReader that will be used to parse a document. 1.87 + */ 1.88 + private XMLReader reader = null; 1.89 + 1.90 + /** 1.91 + * Obtains a configured XMLReader. 1.92 + * 1.93 + * This method is used when the client-specified 1.94 + * {@link SAXSource} object doesn't have XMLReader. 1.95 + * 1.96 + * {@link Unmarshaller} is not re-entrant, so we will 1.97 + * only use one instance of XMLReader. 1.98 + */ 1.99 + protected XMLReader getXMLReader() throws JAXBException { 1.100 + if(reader==null) { 1.101 + try { 1.102 + SAXParserFactory parserFactory; 1.103 + parserFactory = SAXParserFactory.newInstance(); 1.104 + parserFactory.setNamespaceAware(true); 1.105 + // there is no point in asking a validation because 1.106 + // there is no guarantee that the document will come with 1.107 + // a proper schemaLocation. 1.108 + parserFactory.setValidating(false); 1.109 + reader = parserFactory.newSAXParser().getXMLReader(); 1.110 + } catch( ParserConfigurationException e ) { 1.111 + throw new JAXBException(e); 1.112 + } catch( SAXException e ) { 1.113 + throw new JAXBException(e); 1.114 + } 1.115 + } 1.116 + return reader; 1.117 + } 1.118 + 1.119 + public Object unmarshal( Source source ) throws JAXBException { 1.120 + if( source == null ) { 1.121 + throw new IllegalArgumentException( 1.122 + Messages.format( Messages.MUST_NOT_BE_NULL, "source" ) ); 1.123 + } 1.124 + 1.125 + if(source instanceof SAXSource) 1.126 + return unmarshal( (SAXSource)source ); 1.127 + if(source instanceof StreamSource) 1.128 + return unmarshal( streamSourceToInputSource((StreamSource)source)); 1.129 + if(source instanceof DOMSource) 1.130 + return unmarshal( ((DOMSource)source).getNode() ); 1.131 + 1.132 + // we don't handle other types of Source 1.133 + throw new IllegalArgumentException(); 1.134 + } 1.135 + 1.136 + // use the client specified XMLReader contained in the SAXSource. 1.137 + private Object unmarshal( SAXSource source ) throws JAXBException { 1.138 + 1.139 + XMLReader r = source.getXMLReader(); 1.140 + if( r == null ) 1.141 + r = getXMLReader(); 1.142 + 1.143 + return unmarshal( r, source.getInputSource() ); 1.144 + } 1.145 + 1.146 + /** 1.147 + * Unmarshals an object by using the specified XMLReader and the InputSource. 1.148 + * 1.149 + * The callee should call the setErrorHandler method of the XMLReader 1.150 + * so that errors are passed to the client-specified ValidationEventHandler. 1.151 + */ 1.152 + protected abstract Object unmarshal( XMLReader reader, InputSource source ) throws JAXBException; 1.153 + 1.154 + public final Object unmarshal( InputSource source ) throws JAXBException { 1.155 + if( source == null ) { 1.156 + throw new IllegalArgumentException( 1.157 + Messages.format( Messages.MUST_NOT_BE_NULL, "source" ) ); 1.158 + } 1.159 + 1.160 + return unmarshal( getXMLReader(), source ); 1.161 + } 1.162 + 1.163 + 1.164 + private Object unmarshal( String url ) throws JAXBException { 1.165 + return unmarshal( new InputSource(url) ); 1.166 + } 1.167 + 1.168 + public final Object unmarshal( URL url ) throws JAXBException { 1.169 + if( url == null ) { 1.170 + throw new IllegalArgumentException( 1.171 + Messages.format( Messages.MUST_NOT_BE_NULL, "url" ) ); 1.172 + } 1.173 + 1.174 + return unmarshal( url.toExternalForm() ); 1.175 + } 1.176 + 1.177 + public final Object unmarshal( File f ) throws JAXBException { 1.178 + if( f == null ) { 1.179 + throw new IllegalArgumentException( 1.180 + Messages.format( Messages.MUST_NOT_BE_NULL, "file" ) ); 1.181 + } 1.182 + 1.183 + try { 1.184 + // copied from JAXP 1.185 + String path = f.getAbsolutePath(); 1.186 + if (File.separatorChar != '/') 1.187 + path = path.replace(File.separatorChar, '/'); 1.188 + if (!path.startsWith("/")) 1.189 + path = "/" + path; 1.190 + if (!path.endsWith("/") && f.isDirectory()) 1.191 + path = path + "/"; 1.192 + return unmarshal(new URL("file", "", path)); 1.193 + } catch( MalformedURLException e ) { 1.194 + throw new IllegalArgumentException(e.getMessage()); 1.195 + } 1.196 + } 1.197 + 1.198 + public final Object unmarshal( java.io.InputStream is ) 1.199 + throws JAXBException { 1.200 + 1.201 + if( is == null ) { 1.202 + throw new IllegalArgumentException( 1.203 + Messages.format( Messages.MUST_NOT_BE_NULL, "is" ) ); 1.204 + } 1.205 + 1.206 + InputSource isrc = new InputSource( is ); 1.207 + return unmarshal( isrc ); 1.208 + } 1.209 + 1.210 + public final Object unmarshal( Reader reader ) throws JAXBException { 1.211 + if( reader == null ) { 1.212 + throw new IllegalArgumentException( 1.213 + Messages.format( Messages.MUST_NOT_BE_NULL, "reader" ) ); 1.214 + } 1.215 + 1.216 + InputSource isrc = new InputSource( reader ); 1.217 + return unmarshal( isrc ); 1.218 + } 1.219 + 1.220 + 1.221 + private static InputSource streamSourceToInputSource( StreamSource ss ) { 1.222 + InputSource is = new InputSource(); 1.223 + is.setSystemId( ss.getSystemId() ); 1.224 + is.setByteStream( ss.getInputStream() ); 1.225 + is.setCharacterStream( ss.getReader() ); 1.226 + 1.227 + return is; 1.228 + } 1.229 + 1.230 + 1.231 + /** 1.232 + * Indicates whether or not the Unmarshaller is configured to validate 1.233 + * during unmarshal operations. 1.234 + * <p> 1.235 + * <i><b>Note:</b> I named this method isValidating() to stay in-line 1.236 + * with JAXP, as opposed to naming it getValidating(). </i> 1.237 + * 1.238 + * @return true if the Unmarshaller is configured to validate during 1.239 + * unmarshal operations, false otherwise 1.240 + * @throws JAXBException if an error occurs while retrieving the validating 1.241 + * flag 1.242 + */ 1.243 + public boolean isValidating() throws JAXBException { 1.244 + return validating; 1.245 + } 1.246 + 1.247 + /** 1.248 + * Allow an application to register a validation event handler. 1.249 + * <p> 1.250 + * The validation event handler will be called by the JAXB Provider if any 1.251 + * validation errors are encountered during calls to any of the 1.252 + * <tt>unmarshal</tt> methods. If the client application does not register 1.253 + * a validation event handler before invoking the unmarshal methods, then 1.254 + * all validation events will be silently ignored and may result in 1.255 + * unexpected behaviour. 1.256 + * 1.257 + * @param handler the validation event handler 1.258 + * @throws JAXBException if an error was encountered while setting the 1.259 + * event handler 1.260 + */ 1.261 + public void setEventHandler(ValidationEventHandler handler) 1.262 + throws JAXBException { 1.263 + 1.264 + if( handler == null ) { 1.265 + eventHandler = new DefaultValidationEventHandler(); 1.266 + } else { 1.267 + eventHandler = handler; 1.268 + } 1.269 + } 1.270 + 1.271 + /** 1.272 + * Specifies whether or not the Unmarshaller should validate during 1.273 + * unmarshal operations. By default, the <tt>Unmarshaller</tt> does 1.274 + * not validate. 1.275 + * <p> 1.276 + * This method may only be invoked before or after calling one of the 1.277 + * unmarshal methods. 1.278 + * 1.279 + * @param validating true if the Unmarshaller should validate during 1.280 + * unmarshal, false otherwise 1.281 + * @throws JAXBException if an error occurred while enabling or disabling 1.282 + * validation at unmarshal time 1.283 + */ 1.284 + public void setValidating(boolean validating) throws JAXBException { 1.285 + this.validating = validating; 1.286 + } 1.287 + 1.288 + /** 1.289 + * Return the current event handler or the default event handler if one 1.290 + * hasn't been set. 1.291 + * 1.292 + * @return the current ValidationEventHandler or the default event handler 1.293 + * if it hasn't been set 1.294 + * @throws JAXBException if an error was encountered while getting the 1.295 + * current event handler 1.296 + */ 1.297 + public ValidationEventHandler getEventHandler() throws JAXBException { 1.298 + return eventHandler; 1.299 + } 1.300 + 1.301 + 1.302 + /** 1.303 + * Creates an UnmarshalException from a SAXException. 1.304 + * 1.305 + * This is an utility method provided for the derived classes. 1.306 + * 1.307 + * <p> 1.308 + * When a provider-implemented ContentHandler wants to throw a 1.309 + * JAXBException, it needs to wrap the exception by a SAXException. 1.310 + * If the unmarshaller implementation blindly wrap SAXException 1.311 + * by JAXBException, such an exception will be a JAXBException 1.312 + * wrapped by a SAXException wrapped by another JAXBException. 1.313 + * This is silly. 1.314 + * 1.315 + * <p> 1.316 + * This method checks the nested exception of SAXException 1.317 + * and reduce those excessive wrapping. 1.318 + * 1.319 + * @return the resulting UnmarshalException 1.320 + */ 1.321 + protected UnmarshalException createUnmarshalException( SAXException e ) { 1.322 + // check the nested exception to see if it's an UnmarshalException 1.323 + Exception nested = e.getException(); 1.324 + if(nested instanceof UnmarshalException) 1.325 + return (UnmarshalException)nested; 1.326 + 1.327 + if(nested instanceof RuntimeException) 1.328 + // typically this is an unexpected exception, 1.329 + // just throw it rather than wrap it, so that the full stack 1.330 + // trace can be displayed. 1.331 + throw (RuntimeException)nested; 1.332 + 1.333 + 1.334 + // otherwise simply wrap it 1.335 + if(nested!=null) 1.336 + return new UnmarshalException(nested); 1.337 + else 1.338 + return new UnmarshalException(e); 1.339 + } 1.340 + 1.341 + /** 1.342 + * Default implementation of the setProperty method always 1.343 + * throws PropertyException since there are no required 1.344 + * properties. If a provider needs to handle additional 1.345 + * properties, it should override this method in a derived class. 1.346 + */ 1.347 + public void setProperty( String name, Object value ) 1.348 + throws PropertyException { 1.349 + 1.350 + if( name == null ) { 1.351 + throw new IllegalArgumentException( 1.352 + Messages.format( Messages.MUST_NOT_BE_NULL, "name" ) ); 1.353 + } 1.354 + 1.355 + throw new PropertyException(name, value); 1.356 + } 1.357 + 1.358 + /** 1.359 + * Default implementation of the getProperty method always 1.360 + * throws PropertyException since there are no required 1.361 + * properties. If a provider needs to handle additional 1.362 + * properties, it should override this method in a derived class. 1.363 + */ 1.364 + public Object getProperty( String name ) 1.365 + throws PropertyException { 1.366 + 1.367 + if( name == null ) { 1.368 + throw new IllegalArgumentException( 1.369 + Messages.format( Messages.MUST_NOT_BE_NULL, "name" ) ); 1.370 + } 1.371 + 1.372 + throw new PropertyException(name); 1.373 + } 1.374 + 1.375 + public Object unmarshal(XMLEventReader reader) throws JAXBException { 1.376 + 1.377 + throw new UnsupportedOperationException(); 1.378 + } 1.379 + 1.380 + public Object unmarshal(XMLStreamReader reader) throws JAXBException { 1.381 + 1.382 + throw new UnsupportedOperationException(); 1.383 + } 1.384 + 1.385 + public <T> JAXBElement<T> unmarshal(Node node, Class<T> expectedType) throws JAXBException { 1.386 + throw new UnsupportedOperationException(); 1.387 + } 1.388 + 1.389 + public <T> JAXBElement<T> unmarshal(Source source, Class<T> expectedType) throws JAXBException { 1.390 + throw new UnsupportedOperationException(); 1.391 + } 1.392 + 1.393 + public <T> JAXBElement<T> unmarshal(XMLStreamReader reader, Class<T> expectedType) throws JAXBException { 1.394 + throw new UnsupportedOperationException(); 1.395 + } 1.396 + 1.397 + public <T> JAXBElement<T> unmarshal(XMLEventReader reader, Class<T> expectedType) throws JAXBException { 1.398 + throw new UnsupportedOperationException(); 1.399 + } 1.400 + 1.401 + public void setSchema(Schema schema) { 1.402 + throw new UnsupportedOperationException(); 1.403 + } 1.404 + 1.405 + public Schema getSchema() { 1.406 + throw new UnsupportedOperationException(); 1.407 + } 1.408 + 1.409 + public void setAdapter(XmlAdapter adapter) { 1.410 + if(adapter==null) 1.411 + throw new IllegalArgumentException(); 1.412 + setAdapter((Class)adapter.getClass(),adapter); 1.413 + } 1.414 + 1.415 + public <A extends XmlAdapter> void setAdapter(Class<A> type, A adapter) { 1.416 + throw new UnsupportedOperationException(); 1.417 + } 1.418 + 1.419 + public <A extends XmlAdapter> A getAdapter(Class<A> type) { 1.420 + throw new UnsupportedOperationException(); 1.421 + } 1.422 + 1.423 + public void setAttachmentUnmarshaller(AttachmentUnmarshaller au) { 1.424 + throw new UnsupportedOperationException(); 1.425 + } 1.426 + 1.427 + public AttachmentUnmarshaller getAttachmentUnmarshaller() { 1.428 + throw new UnsupportedOperationException(); 1.429 + } 1.430 + 1.431 + public void setListener(Listener listener) { 1.432 + throw new UnsupportedOperationException(); 1.433 + } 1.434 + 1.435 + public Listener getListener() { 1.436 + throw new UnsupportedOperationException(); 1.437 + } 1.438 +}