JAXBModifier


1   /*
2    * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
3    *
4    * This software is open source.
5    * See the bottom of this file for the licence.
6    */
7   
8   package org.dom4j.jaxb;
9   
10  import java.io.File  ;
11  import java.io.FileInputStream  ;
12  import java.io.FileNotFoundException  ;
13  import java.io.FileOutputStream  ;
14  import java.io.IOException  ;
15  import java.io.InputStream  ;
16  import java.io.InputStreamReader  ;
17  import java.io.OutputStream  ;
18  import java.io.Reader  ;
19  import java.io.Writer  ;
20  import java.net.URL  ;
21  import java.nio.charset.Charset  ;
22  import java.util.HashMap  ;
23  import java.util.Iterator  ;
24  import java.util.Map  ;
25  
26  import org.dom4j.Document;
27  import org.dom4j.DocumentException;
28  import org.dom4j.io.ElementModifier;
29  import org.dom4j.io.OutputFormat;
30  import org.dom4j.io.SAXModifier;
31  import org.dom4j.io.XMLWriter;
32  
33  import org.xml.sax.InputSource  ;
34  
35  /**
36   * Reads an XML document using SAX and writes its content to the provided
37   * {@link org.dom4j.io.XMLWriter}. Modifications must be provided by {@link
38   * org.dom4j.jaxb.JAXBObjectModifier} objects, which are called prior to writing
39   * the XML fragment they are registered for.
40   * 
41   * @author Wonne Keysers (Realsoftware.be)
42   * 
43   * @see org.dom4j.io.SAXModifier
44   */
45  public class JAXBModifier extends JAXBSupport {
46      private SAXModifier modifier;
47  
48      private XMLWriter xmlWriter;
49  
50      private boolean pruneElements;
51  
52      private OutputFormat outputFormat;
53  
54      private HashMap   modifiers = new HashMap  ();
55  
56      /**
57       * Creates a new JAXBModifier for the given JAXB context path. This is the
58       * Java package where JAXB can find the generated XML classes. This package
59       * MUST contain jaxb.properties!
60       * 
61       * @param contextPath
62       *            JAXB context path to be used
63       * 
64       * @see javax.xml.bind.JAXBContext
65       */
66      public JAXBModifier(String   contextPath) {
67          super(contextPath);
68          this.outputFormat = new OutputFormat();
69      }
70  
71      /**
72       * Creates a new JAXBModifier for the given JAXB context path, using the
73       * given {@link java.lang.ClassLoader}. This is the Java package where JAXB
74       * can find the generated XML classes. This package MUST contain
75       * jaxb.properties!
76       * 
77       * @param contextPath
78       *            JAXB context path to be used
79       * @param classloader
80       *            the classloader to use
81       * 
82       * @see javax.xml.bind.JAXBContext
83       */
84      public JAXBModifier(String   contextPath, ClassLoader   classloader) {
85          super(contextPath, classloader);
86          this.outputFormat = new OutputFormat();
87      }
88  
89      /**
90       * Creates a new JAXBModifier for the given JAXB context path. The specified
91       * {@link org.dom4j.io.OutputFormat}will be used while writing the XML
92       * stream.
93       * 
94       * @param contextPath
95       *            JAXB context path to be used
96       * @param outputFormat
97       *            the DOM4J {@link org.dom4j.io.OutputFormat}to be used
98       * 
99       * @see javax.xml.bind.JAXBContext
100      */
101     public JAXBModifier(String   contextPath, OutputFormat outputFormat) {
102         super(contextPath);
103         this.outputFormat = outputFormat;
104     }
105 
106     /**
107      * Creates a new JAXBModifier for the given JAXB context path, using the
108      * specified {@link java.lang.Classloader}. The specified {@link
109      * org.dom4j.io.OutputFormat} will be used while writing the XML stream.
110      * 
111      * @param contextPath
112      *            JAXB context path to be used
113      * @param classloader
114      *            the class loader to be used to load JAXB
115      * @param outputFormat
116      *            the DOM4J {@link org.dom4j.io.OutputFormat}to be used
117      * 
118      * @see javax.xml.bind.JAXBContext
119      */
120     public JAXBModifier(String   contextPath, ClassLoader   classloader,
121             OutputFormat outputFormat) {
122         super(contextPath, classloader);
123         this.outputFormat = outputFormat;
124     }
125 
126     /**
127      * Parses the specified {@link java.io.File}with SAX
128      * 
129      * @param source
130      *            the file to parse
131      * 
132      * @return the resulting DOM4J document
133      * 
134      * @throws DocumentException
135      *             when an error occurs while parsing
136      * @throws IOException
137      *             when an error occurs while writing to the {@link
138      *             org.dom4j.io.XMLWriter}
139      */
140     public Document modify(File   source) throws DocumentException, IOException   {
141         return installModifier().modify(source);
142     }
143 
144     /**
145      * Parses the specified {@link java.io.File}with SAX, using the given
146      * {@link java.nio.charset.Charset}.
147      * 
148      * @param source
149      *            the file to parse
150      * @param charset
151      *            the character set to use
152      * 
153      * @return the resulting DOM4J document
154      * 
155      * @throws DocumentException
156      *             when an error occurs while parsing
157      * @throws IOException
158      *             when an error occurs while writing to the {@link
159      *             org.dom4j.io.XMLWriter}
160      */
161     public Document modify(File   source, Charset   charset)
162             throws DocumentException, IOException   {
163         try {
164             Reader   reader = new InputStreamReader  (new FileInputStream  (source),
165                     charset);
166 
167             return installModifier().modify(reader);
168         } catch (JAXBRuntimeException ex) {
169             Throwable   cause = ex.getCause();
170             throw new DocumentException(cause.getMessage(), cause);
171         } catch (FileNotFoundException   ex) {
172             throw new DocumentException(ex.getMessage(), ex);
173         }
174     }
175 
176     /**
177      * Parses the specified {@link org.xml.sax.InputSource}with SAX.
178      * 
179      * @param source
180      *            the input source to parse
181      * 
182      * @return the resulting DOM4J document
183      * 
184      * @throws DocumentException
185      *             when an error occurs while parsing
186      * @throws IOException
187      *             when an error occurs while writing to the {@link
188      *             org.dom4j.io.XMLWriter}
189      */
190     public Document modify(InputSource   source) throws DocumentException,
191             IOException   {
192         try {
193             return installModifier().modify(source);
194         } catch (JAXBRuntimeException ex) {
195             Throwable   cause = ex.getCause();
196             throw new DocumentException(cause.getMessage(), cause);
197         }
198     }
199 
200     /**
201      * Parses the specified {@link java.io.InputStream}with SAX.
202      * 
203      * @param source
204      *            the inputstream to parse
205      * 
206      * @return the resulting DOM4J document
207      * 
208      * @throws DocumentException
209      *             when an error occurs while parsing
210      * @throws IOException
211      *             when an error occurs while writing to the {@link
212      *             org.dom4j.io.XMLWriter}
213      */
214     public Document modify(InputStream   source) throws DocumentException,
215             IOException   {
216         try {
217             return installModifier().modify(source);
218         } catch (JAXBRuntimeException ex) {
219             Throwable   cause = ex.getCause();
220             throw new DocumentException(cause.getMessage(), cause);
221         }
222     }
223 
224     /**
225      * Parses the specified {@link java.io.InputStream}with SAX.
226      * 
227      * @param source
228      *            the inputstream to parse
229      * @param systemId
230      *            the URI of the given inputstream
231      * 
232      * @return the resulting DOM4J document
233      * 
234      * @throws DocumentException
235      *             when an error occurs while parsing
236      * @throws IOException
237      *             when an error occurs while writing to the {@link
238      *             org.dom4j.io.XMLWriter}
239      */
240     public Document modify(InputStream   source, String   systemId)
241             throws DocumentException, IOException   {
242         try {
243             return installModifier().modify(source);
244         } catch (JAXBRuntimeException ex) {
245             Throwable   cause = ex.getCause();
246             throw new DocumentException(cause.getMessage(), cause);
247         }
248     }
249 
250     /**
251      * Parses the specified {@link java.io.Reader}with SAX.
252      * 
253      * @param r
254      *            the reader to use for parsing
255      * 
256      * @return the resulting DOM4J document
257      * 
258      * @throws DocumentException
259      *             when an error occurs while parsing
260      * @throws IOException
261      *             when an error occurs while writing to the {@link
262      *             org.dom4j.io.XMLWriter}
263      */
264     public Document modify(Reader   r) throws DocumentException, IOException   {
265         try {
266             return installModifier().modify(r);
267         } catch (JAXBRuntimeException ex) {
268             Throwable   cause = ex.getCause();
269             throw new DocumentException(cause.getMessage(), cause);
270         }
271     }
272 
273     /**
274      * Parses the specified {@link java.io.Reader}with SAX.
275      * 
276      * @param source
277      *            the reader to parse
278      * @param systemId
279      *            the URI of the given reader
280      * 
281      * @return the resulting DOM4J document
282      * 
283      * @throws DocumentException
284      *             when an error occurs while parsing
285      * @throws IOException
286      *             when an error occurs while writing to the {@link
287      *             org.dom4j.io.XMLWriter}
288      */
289     public Document modify(Reader   source, String   systemId)
290             throws DocumentException, IOException   {
291         try {
292             return installModifier().modify(source);
293         } catch (JAXBRuntimeException ex) {
294             Throwable   cause = ex.getCause();
295             throw new DocumentException(cause.getMessage(), cause);
296         }
297     }
298 
299     /**
300      * Parses the the given URL or filename.
301      * 
302      * @param url
303      *            the URL or filename to parse
304      * 
305      * @return the resulting DOM4J document
306      * 
307      * @throws DocumentException
308      *             when an error occurs while parsing
309      * @throws IOException
310      *             when an error occurs while writing to the {@link
311      *             org.dom4j.io.XMLWriter}
312      */
313     public Document modify(String   url) throws DocumentException, IOException   {
314         try {
315             return installModifier().modify(url);
316         } catch (JAXBRuntimeException ex) {
317             Throwable   cause = ex.getCause();
318             throw new DocumentException(cause.getMessage(), cause);
319         }
320     }
321 
322     /**
323      * Parses the the given URL.
324      * 
325      * @param source
326      *            the URL to parse
327      * 
328      * @return the resulting DOM4J document
329      * 
330      * @throws DocumentException
331      *             when an error occurs while parsing
332      * @throws IOException
333      *             when an error occurs while writing to the {@link
334      *             org.dom4j.io.XMLWriter}
335      */
336     public Document modify(URL   source) throws DocumentException, IOException   {
337         try {
338             return installModifier().modify(source);
339         } catch (JAXBRuntimeException ex) {
340             Throwable   cause = ex.getCause();
341             throw new DocumentException(cause.getMessage(), cause);
342         }
343     }
344 
345     /**
346      * Sets the Output to write the (modified) xml document to.
347      * 
348      * @param file
349      *            the {@link java.io.File}to write to
350      * 
351      * @throws IOException
352      *             when the file cannot be found or when the outputformat
353      */
354     public void setOutput(File   file) throws IOException   {
355         createXMLWriter().setOutputStream(new FileOutputStream  (file));
356     }
357 
358     /**
359      * Sets the Output to write the (modified) xml document to.
360      * 
361      * @param outputStream
362      *            the {@link java.io.OutputStream}to write to
363      * 
364      * @throws IOException
365      *             when an error occurs
366      */
367     public void setOutput(OutputStream   outputStream) throws IOException   {
368         createXMLWriter().setOutputStream(outputStream);
369     }
370 
371     /**
372      * Sets the Output to write the (modified) xml document to.
373      * 
374      * @param writer
375      *            the {@link java.io.Writer}to write to
376      * 
377      * @throws IOException
378      *             when an error occurs
379      */
380     public void setOutput(Writer   writer) throws IOException   {
381         createXMLWriter().setWriter(writer);
382     }
383 
384     /**
385      * Adds the {@link JAXBObjectModifier}to be called when the specified xml
386      * path is encounted while parsing the source.
387      * 
388      * @param path
389      *            the element path to listen for
390      * @param mod
391      *            the modifier to register
392      */
393     public void addObjectModifier(String   path, JAXBObjectModifier mod) {
394         modifiers.put(path, mod);
395     }
396 
397     /**
398      * Removes the {@link JAXBObjectModifier}from the event based processor,
399      * for the specified element path.
400      * 
401      * @param path
402      *            the xml path to remove the modifier for
403      */
404     public void removeObjectModifier(String   path) {
405         modifiers.remove(path);
406         getModifier().removeModifier(path);
407     }
408 
409     /**
410      * Removes all registered {@link JAXBObjectModifier}instances from the
411      * event based processor.
412      */
413     public void resetObjectModifiers() {
414         modifiers.clear();
415         getModifier().resetModifiers();
416     }
417 
418     /**
419      * Returns true when the modified {@link org.dom4j.Document}is not kept in
420      * memory.
421      * 
422      * @return Returns true if elements are pruned.
423      */
424     public boolean isPruneElements() {
425         return pruneElements;
426     }
427 
428     /**
429      * Define whether the modified {@link org.dom4j.Document}must only be
430      * written to the output and pruned from the DOM4J tree.
431      * 
432      * @param pruneElements
433      *            When true, elements will not be kept in memory
434      */
435     public void setPruneElements(boolean pruneElements) {
436         this.pruneElements = pruneElements;
437     }
438 
439     private SAXModifier installModifier() throws IOException   {
440         modifier = new SAXModifier(isPruneElements());
441 
442         modifier.resetModifiers();
443 
444         Iterator   modifierIt = modifiers.entrySet().iterator();
445 
446         while (modifierIt.hasNext()) {
447             Map.Entry   entry = (Map.Entry  ) modifierIt.next();
448             ElementModifier mod = new JAXBElementModifier(this,
449                     (JAXBObjectModifier) entry.getValue());
450             getModifier().addModifier((String  ) entry.getKey(), mod);
451         }
452 
453         modifier.setXMLWriter(getXMLWriter());
454 
455         return modifier;
456     }
457 
458     private SAXModifier getModifier() {
459         if (this.modifier == null) {
460             modifier = new SAXModifier(isPruneElements());
461         }
462 
463         return modifier;
464     }
465 
466     private XMLWriter getXMLWriter() {
467         return xmlWriter;
468     }
469 
470     private XMLWriter createXMLWriter() throws IOException   {
471         if (this.xmlWriter == null) {
472             xmlWriter = new XMLWriter(outputFormat);
473         }
474 
475         return xmlWriter;
476     }
477 
478     private class JAXBElementModifier implements ElementModifier {
479         private JAXBModifier jaxbModifier;
480 
481         private JAXBObjectModifier objectModifier;
482 
483         public JAXBElementModifier(JAXBModifier jaxbModifier,
484                 JAXBObjectModifier objectModifier) {
485             this.jaxbModifier = jaxbModifier;
486             this.objectModifier = objectModifier;
487         }
488 
489         public org.dom4j.Element modifyElement(org.dom4j.Element element)
490                 throws Exception   {
491             javax.xml.bind.Element originalObject = jaxbModifier
492                     .unmarshal(element);
493             javax.xml.bind.Element modifiedObject = objectModifier
494                     .modifyObject(originalObject);
495 
496             return jaxbModifier.marshal(modifiedObject);
497         }
498     }
499 }
500 
501 /*
502  * Redistribution and use of this software and associated documentation
503  * ("Software"), with or without modification, are permitted provided that the
504  * following conditions are met:
505  * 
506  * 1. Redistributions of source code must retain copyright statements and
507  * notices. Redistributions must also contain a copy of this document.
508  * 
509  * 2. Redistributions in binary form must reproduce the above copyright notice,
510  * this list of conditions and the following disclaimer in the documentation
511  * and/or other materials provided with the distribution.
512  * 
513  * 3. The name "DOM4J" must not be used to endorse or promote products derived
514  * from this Software without prior written permission of MetaStuff, Ltd. For
515  * written permission, please contact dom4j-info@metastuff.com.
516  * 
517  * 4. Products derived from this Software may not be called "DOM4J" nor may
518  * "DOM4J" appear in their names without prior written permission of MetaStuff,
519  * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
520  * 
521  * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
522  * 
523  * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
524  * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
525  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
526  * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
527  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
528  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
529  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
530  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
531  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
532  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
533  * POSSIBILITY OF SUCH DAMAGE.
534  * 
535  * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
536  */
537
A to Z: JavaDoc & Examples Daily Java News & Articles Open Source Projects Open Source Codes Free Computer Books Remove Frame
Popular Tags