1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415
/* * Copyright 2003 Sun Microsystems, Inc. All rights reserved. * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. */ package javax.xml.bind.helpers; import org.xml.sax.InputSource; import org.xml.sax.SAXException; import org.xml.sax.XMLReader; import org.w3c.dom.Node; import javax.xml.bind.JAXBException; import javax.xml.bind.PropertyException; import javax.xml.bind.UnmarshalException; import javax.xml.bind.Unmarshaller; import javax.xml.bind.ValidationEventHandler; import javax.xml.bind.JAXBElement; import javax.xml.bind.annotation.adapters.XmlAdapter; import javax.xml.bind.attachment.AttachmentUnmarshaller; import javax.xml.parsers.ParserConfigurationException; import javax.xml.parsers.SAXParserFactory; import javax.xml.stream.XMLEventReader; import javax.xml.stream.XMLStreamReader; import javax.xml.transform.Source; import javax.xml.transform.dom.DOMSource; import javax.xml.transform.sax.SAXSource; import javax.xml.transform.stream.StreamSource; import javax.xml.validation.Schema; import java.io.File; import java.io.Reader; import java.net.MalformedURLException; import java.net.URL; /** * Partial default <tt>Unmarshaller</tt> implementation. * * <p> * This class provides a partial default implementation for the * {@link javax.xml.bind.Unmarshaller}interface. * * <p> * A JAXB Provider has to implement five methods (getUnmarshallerHandler, * unmarshal(Node), unmarshal(XMLReader,InputSource), * unmarshal(XMLStreamReader), and unmarshal(XMLEventReader). * * @author <ul> * <li>Kohsuke Kawaguchi, Sun Microsystems, Inc.</li> * </ul> * @version $Revision: 1.13 $ $Date: 2005/07/28 22:18:12 $ * @see javax.xml.bind.Unmarshaller * @since JAXB1.0 */ public abstract class AbstractUnmarshallerImpl implements Unmarshaller { /** handler that will be used to process errors and warnings during unmarshal */ private ValidationEventHandler eventHandler = new DefaultValidationEventHandler(); /** whether or not the unmarshaller will validate */ protected boolean validating = false; /** * XMLReader that will be used to parse a document. */ private XMLReader reader = null; /** * Obtains a configured XMLReader. * * This method is used when the client-specified * {@link SAXSource} object doesn't have XMLReader. * * {@link Unmarshaller} is not re-entrant, so we will * only use one instance of XMLReader. */ protected XMLReader getXMLReader() throws JAXBException { if(reader==null) { try { SAXParserFactory parserFactory; parserFactory = SAXParserFactory.newInstance(); parserFactory.setNamespaceAware(true); // there is no point in asking a validation because // there is no guarantee that the document will come with // a proper schemaLocation. parserFactory.setValidating(false); reader = parserFactory.newSAXParser().getXMLReader(); } catch( ParserConfigurationException e ) { throw new JAXBException(e); } catch( SAXException e ) { throw new JAXBException(e); } } return reader; } public Object unmarshal( Source source ) throws JAXBException { if( source == null ) { throw new IllegalArgumentException( Messages.format( Messages.MUST_NOT_BE_NULL, "source" ) ); } if(source instanceof SAXSource) return unmarshal( (SAXSource)source ); if(source instanceof StreamSource) return unmarshal( streamSourceToInputSource((StreamSource)source)); if(source instanceof DOMSource) return unmarshal( ((DOMSource)source).getNode() ); // we don't handle other types of Source throw new IllegalArgumentException(); } // use the client specified XMLReader contained in the SAXSource. private Object unmarshal( SAXSource source ) throws JAXBException { XMLReader reader = source.getXMLReader(); if( reader == null ) reader = getXMLReader(); return unmarshal( reader, source.getInputSource() ); } /** * Unmarshals an object by using the specified XMLReader and the InputSource. * * The callee should call the setErrorHandler method of the XMLReader * so that errors are passed to the client-specified ValidationEventHandler. */ protected abstract Object unmarshal( XMLReader reader, InputSource source ) throws JAXBException; public final Object unmarshal( InputSource source ) throws JAXBException { if( source == null ) { throw new IllegalArgumentException( Messages.format( Messages.MUST_NOT_BE_NULL, "source" ) ); } return unmarshal( getXMLReader(), source ); } private Object unmarshal( String url ) throws JAXBException { return unmarshal( new InputSource(url) ); } public final Object unmarshal( URL url ) throws JAXBException { if( url == null ) { throw new IllegalArgumentException( Messages.format( Messages.MUST_NOT_BE_NULL, "url" ) ); } return unmarshal( url.toExternalForm() ); } public final Object unmarshal( File f ) throws JAXBException { if( f == null ) { throw new IllegalArgumentException( Messages.format( Messages.MUST_NOT_BE_NULL, "file" ) ); } try { // copied from JAXP String path = f.getAbsolutePath(); if (File.separatorChar != '/') path = path.replace(File.separatorChar, '/'); if (!path.startsWith("/")) path = "/" + path; if (!path.endsWith("/") && f.isDirectory()) path = path + "/"; return unmarshal(new URL("file", "", path)); } catch( MalformedURLException e ) { throw new IllegalArgumentException(e.getMessage()); } } public final Object unmarshal( java.io.InputStream is ) throws JAXBException { if( is == null ) { throw new IllegalArgumentException( Messages.format( Messages.MUST_NOT_BE_NULL, "is" ) ); } InputSource isrc = new InputSource( is ); return unmarshal( isrc ); } public final Object unmarshal( Reader reader ) throws JAXBException { if( reader == null ) { throw new IllegalArgumentException( Messages.format( Messages.MUST_NOT_BE_NULL, "reader" ) ); } InputSource isrc = new InputSource( reader ); return unmarshal( isrc ); } private static InputSource streamSourceToInputSource( StreamSource ss ) { InputSource is = new InputSource(); is.setSystemId( ss.getSystemId() ); is.setByteStream( ss.getInputStream() ); is.setCharacterStream( ss.getReader() ); return is; } /** * Indicates whether or not the Unmarshaller is configured to validate * during unmarshal operations. * <p> * <i><b>Note:</b> I named this method isValidating() to stay in-line * with JAXP, as opposed to naming it getValidating(). </i> * * @return true if the Unmarshaller is configured to validate during * unmarshal operations, false otherwise * @throws JAXBException if an error occurs while retrieving the validating * flag */ public boolean isValidating() throws JAXBException { return validating; } /** * Allow an application to register a validation event handler. * <p> * The validation event handler will be called by the JAXB Provider if any * validation errors are encountered during calls to any of the * <tt>unmarshal</tt> methods. If the client application does not register * a validation event handler before invoking the unmarshal methods, then * all validation events will be silently ignored and may result in * unexpected behaviour. * * @param handler the validation event handler * @throws JAXBException if an error was encountered while setting the * event handler */ public void setEventHandler(ValidationEventHandler handler) throws JAXBException { if( handler == null ) { eventHandler = new DefaultValidationEventHandler(); } else { eventHandler = handler; } } /** * Specifies whether or not the Unmarshaller should validate during * unmarshal operations. By default, the <tt>Unmarshaller</tt> does * not validate. * <p> * This method may only be invoked before or after calling one of the * unmarshal methods. * * @param validating true if the Unmarshaller should validate during * unmarshal, false otherwise * @throws JAXBException if an error occurred while enabling or disabling * validation at unmarshal time */ public void setValidating(boolean validating) throws JAXBException { this.validating = validating; } /** * Return the current event handler or the default event handler if one * hasn't been set. * * @return the current ValidationEventHandler or the default event handler * if it hasn't been set * @throws JAXBException if an error was encountered while getting the * current event handler */ public ValidationEventHandler getEventHandler() throws JAXBException { return eventHandler; } /** * Creates an UnmarshalException from a SAXException. * * This is an utility method provided for the derived classes. * * <p> * When a provider-implemented ContentHandler wants to throw a * JAXBException, it needs to wrap the exception by a SAXException. * If the unmarshaller implementation blindly wrap SAXException * by JAXBException, such an exception will be a JAXBException * wrapped by a SAXException wrapped by another JAXBException. * This is silly. * * <p> * This method checks the nested exception of SAXException * and reduce those excessive wrapping. * * @return the resulting UnmarshalException */ protected UnmarshalException createUnmarshalException( SAXException e ) { // check the nested exception to see if it's an UnmarshalException Exception nested = e.getException(); if(nested instanceof UnmarshalException) return (UnmarshalException)nested; if(nested instanceof RuntimeException) // typically this is an unexpected exception, // just throw it rather than wrap it, so that the full stack // trace can be displayed. throw (RuntimeException)nested; // otherwise simply wrap it if(nested!=null) return new UnmarshalException(nested); else return new UnmarshalException(e); } /** * Default implementation of the setProperty method always * throws PropertyException since there are no required * properties. If a provider needs to handle additional * properties, it should override this method in a derived class. */ public void setProperty( String name, Object value ) throws PropertyException { if( name == null ) { throw new IllegalArgumentException( Messages.format( Messages.MUST_NOT_BE_NULL, "name" ) ); } throw new PropertyException(name, value); } /** * Default implementation of the getProperty method always * throws PropertyException since there are no required * properties. If a provider needs to handle additional * properties, it should override this method in a derived class. */ public Object getProperty( String name ) throws PropertyException { if( name == null ) { throw new IllegalArgumentException( Messages.format( Messages.MUST_NOT_BE_NULL, "name" ) ); } throw new PropertyException(name); } public Object unmarshal(XMLEventReader reader) throws JAXBException { throw new UnsupportedOperationException(); } public Object unmarshal(XMLStreamReader reader) throws JAXBException { throw new UnsupportedOperationException(); } public <T> JAXBElement<T> unmarshal(Node node, Class<T> expectedType) throws JAXBException { throw new UnsupportedOperationException(); } public <T> JAXBElement<T> unmarshal(Source source, Class<T> expectedType) throws JAXBException { throw new UnsupportedOperationException(); } public <T> JAXBElement<T> unmarshal(XMLStreamReader reader, Class<T> expectedType) throws JAXBException { throw new UnsupportedOperationException(); } public <T> JAXBElement<T> unmarshal(XMLEventReader reader, Class<T> expectedType) throws JAXBException { throw new UnsupportedOperationException(); } public void setSchema(Schema schema) { throw new UnsupportedOperationException(); } public Schema getSchema() { throw new UnsupportedOperationException(); } public void setAdapter(XmlAdapter adapter) { if(adapter==null) throw new IllegalArgumentException(); setAdapter((Class)adapter.getClass(),adapter); } public <A extends XmlAdapter> void setAdapter(Class<A> type, A adapter) { throw new UnsupportedOperationException(); } public <A extends XmlAdapter> A getAdapter(Class<A> type) { throw new UnsupportedOperationException(); } public void setAttachmentUnmarshaller(AttachmentUnmarshaller au) { throw new UnsupportedOperationException(); } public AttachmentUnmarshaller getAttachmentUnmarshaller() { throw new UnsupportedOperationException(); } public void setListener(Listener listener) { throw new UnsupportedOperationException(); } public Listener getListener() { throw new UnsupportedOperationException(); } }