Public paste
asd
By: asd | Date: Feb 9 2011 23:06 | Format: None | Expires: never | Size: 5.74 KB | Hits: 485

  1. import java.io.IOException;
  2.  
  3. import javax.xml.parsers.*;
  4. import java.io.*;
  5.  
  6. import javax.xml.parsers.DocumentBuilderFactory;
  7.  
  8.  
  9. import org.apache.xml.serialize.*;
  10. import org.w3c.dom.*;
  11.  
  12. import org.xml.sax.SAXException;
  13.  
  14.  
  15.  
  16. public class XMLAssignment1 {
  17.        
  18.  
  19. static Document dom;
  20.        
  21. static Document domNew;
  22.  
  23.        
  24.  
  25. public static void main(String[] args) {
  26.                
  27.  
  28. printStuff("Creating empty DOM document....");
  29.                
  30.  
  31. createDocument();
  32.                
  33.                
  34.  
  35. printStuff("Opening file and parsing XML");
  36.                
  37.  
  38. String xmlFile = "bookstore.xml";
  39.                
  40.        
  41.  
  42. parseXMLFile(xmlFile);
  43.                
  44.                
  45.  
  46. printStuff("Transversing XML file...");
  47.                
  48.  
  49. printStuff("Creating Nodes....Appending....");
  50.                
  51.  
  52. createDOMTree();
  53.                
  54.  
  55. printStuff("Writing to file");
  56.                
  57.  
  58. printToFile();
  59.                
  60.  
  61. printStuff("File book.xml");
  62.        
  63.  
  64. }
  65.  
  66.        
  67.  
  68.  
  69. public static void printStuff(String s) {
  70.                
  71.  
  72.  
  73. System.out.println(s);
  74.        
  75.  
  76. }
  77.        
  78.        
  79.  
  80.  
  81. private static void parseXMLFile(String fileName) {
  82.                
  83.  
  84. DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
  85.                
  86.  
  87. try {
  88.                                
  89.                
  90.  
  91. DocumentBuilder db = dbf.newDocumentBuilder();
  92.                
  93.  
  94. dom = db.parse(fileName);
  95.        
  96.                
  97.  
  98. }
  99.                
  100.  
  101. catch(ParserConfigurationException e) {
  102.                        
  103.  
  104. e.printStackTrace();
  105.                
  106.  
  107. }
  108.                
  109.  
  110. catch(SAXException e) {
  111.                        
  112.  
  113. e.printStackTrace();
  114.                
  115.  
  116. }
  117.                
  118.  
  119. catch(IOException e) {
  120.                        
  121.  
  122. e.printStackTrace();
  123.                
  124.  
  125. }
  126.        
  127.  
  128. }
  129.        
  130.        
  131.  
  132.  
  133. private static String getTextValue(Element e, String tag) {
  134.                
  135.  
  136.  
  137. String textVal = null;
  138.                
  139.                
  140.  
  141. NodeList nl = e.getElementsByTagName(tag);
  142.                
  143.  
  144.  
  145. if (nl != null && nl.getLength() > 0) {
  146.                        
  147.  
  148.  
  149. Element el = (Element)nl.item(0);
  150.                        
  151.  
  152. textVal = el.getFirstChild().getNodeValue();
  153.                
  154.  
  155. }
  156.                
  157.  
  158. return textVal;
  159.        
  160.  
  161. }
  162.        
  163.        
  164.  
  165.  
  166. private static int getIntValue(Element e, String tag) {
  167.                
  168.  
  169. return Integer.parseInt(getTextValue(e,tag));
  170.        
  171.  
  172. }
  173.        
  174.        
  175.  
  176. private static void createDocument() {
  177.  
  178.                 //get an instance of factory
  179.                
  180.  
  181. DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
  182.                
  183.  
  184. try {
  185.                 //get an instance of builder
  186.                
  187.  
  188. DocumentBuilder db = dbf.newDocumentBuilder();
  189.  
  190.                
  191.  
  192. //create an instance of DOM
  193.                
  194.  
  195. domNew = db.newDocument();
  196.                
  197.  
  198. //DomNew is a global
  199.  
  200.                
  201.  
  202. }
  203.  
  204. catch(ParserConfigurationException pce) {
  205.                        
  206.  
  207. //dump it
  208.                        
  209.  
  210. System.out.println("Error while trying to instantiate DocumentBuilder " + pce);
  211.                
  212.  
  213.        
  214.  
  215. System.exit(1);
  216.                
  217.  
  218. }
  219.  
  220.        
  221.  
  222. }
  223.        
  224.  
  225.  
  226. /**
  227.          * creates the XML structure
  228.          */
  229.        
  230.  
  231.  
  232. private static void createDOMTree() {
  233.                
  234.  
  235. String textVal;
  236.                
  237. Text t;
  238.                
  239.  
  240. //create the root element
  241.                
  242.  
  243. Element rootEle = domNew.createElement("bookstore");
  244.                
  245.  
  246. domNew.appendChild(rootEle);
  247.                
  248.  
  249. Element docRoot = dom.getDocumentElement();
  250.                
  251.  
  252. NodeList nodeList = docRoot.getElementsByTagName("book");
  253.                
  254.  
  255. //Check to make sure nodeList isn't empty
  256.                
  257.  
  258. if (nodeList != null && nodeList.getLength() > 0) {
  259.                        
  260.  
  261. //We need to loop all the books
  262.                        
  263.  
  264. for(int i=0; i < nodeList.getLength(); i++) {
  265.                                
  266.  
  267. //Gets book node
  268.                                
  269.  
  270. Element book = (Element)nodeList.item(i);
  271.                                
  272.  
  273. //Create new node
  274.                                
  275.  
  276. Element newEl = domNew.createElement("book");
  277.                                
  278.  
  279. //Add Attribute
  280.                                
  281.  
  282. newEl.setAttribute("category",book.getAttribute("category"));          
  283.                
  284.  
  285.                
  286.  
  287. //search book node for all authors
  288.                                
  289.  
  290. NodeList authors = book.getElementsByTagName("author");
  291.                                
  292.  
  293. for (int j=0; j< authors.getLength(); j++) {
  294.                                        
  295.  
  296. //Create Author node
  297.                                        
  298.  
  299. Element newAuthorEl = domNew.createElement("author");
  300.                                        
  301.  
  302. //List of author nodes
  303.                                        
  304.  
  305. Element authorNodes = (Element)authors.item(j);
  306.                                        
  307.  
  308. textVal = authorNodes.getFirstChild().getNodeValue();
  309.                                        
  310.  
  311. //printStuff("Author " + j + " : " + textVal);                         
  312.                
  313.  
  314.                        
  315.  
  316. t = domNew.createTextNode(textVal);
  317.                                        
  318. newAuthorEl.appendChild(t);
  319.                                        
  320.  
  321. //Append authornode to bookNode
  322.                                        
  323.  
  324. newEl.appendChild(newAuthorEl);
  325.                                
  326.  
  327. }
  328.                                
  329.  
  330. // We know that we have title, year, and price in any order
  331.                                
  332.  
  333. Element newTitleEl = domNew.createElement("title");
  334.                                
  335. NodeList orgTitle = book.getElementsByTagName("title");
  336.                                
  337. Element orgTitleEl = (Element)orgTitle.item(0);
  338.                                
  339. newTitleEl.setAttribute("lang", orgTitleEl.getAttribute("lang"));
  340.                        
  341.  
  342.        
  343. t = domNew.createTextNode(orgTitleEl.getFirstChild().getNodeValue());
  344.                        
  345.  
  346.        
  347. newTitleEl.appendChild(t);
  348.                                
  349.                                
  350.  
  351. //getPrice
  352.                                
  353.  
  354. Element newPriceEl = domNew.createElement("price");
  355.                                
  356.  
  357. Element orgPrice = (Element)book.getElementsByTagName("price").item(0);
  358.                        
  359.  
  360.        
  361.  
  362. t = domNew.createTextNode(orgPrice.getFirstChild().getNodeValue());
  363.                        
  364.  
  365.        
  366.  
  367. newPriceEl.appendChild(t);
  368.                                
  369.                                
  370.  
  371. //getYear
  372.                                
  373.  
  374. Element newYearEl = domNew.createElement("year");
  375.                                
  376.  
  377. Element orgYear = (Element)book.getElementsByTagName("year").item(0);
  378.                        
  379.  
  380.        
  381.  
  382. t = domNew.createTextNode(orgYear.getFirstChild().getNodeValue());
  383.                        
  384.  
  385.        
  386.  
  387. newYearEl.appendChild(t);
  388.                                
  389.                                
  390.  
  391. //Write children to book
  392.                                
  393.  
  394. newEl.appendChild(newTitleEl);
  395.                                
  396.  
  397. newEl.appendChild(newPriceEl);
  398.                                
  399.  
  400. newEl.appendChild(newYearEl);
  401.                                
  402.                                
  403.  
  404. //Append bookNode to bookstore
  405.                                
  406. rootEle.appendChild(newEl);
  407.        
  408.                
  409. }
  410.                
  411.  
  412. }              
  413.        
  414.  
  415. }
  416.        
  417.        
  418.  
  419. @SuppressWarnings("deprecation")
  420.        
  421.  
  422. private static void printToFile(){
  423.  
  424.                
  425.  
  426. try
  427.                 {
  428.                        
  429.  
  430. //print
  431.                        
  432.  
  433. OutputFormat format = new OutputFormat(domNew);
  434.                        
  435.  
  436. format.setIndenting(true);
  437.  
  438.                        
  439.  
  440. //to generate output to console use this serializer
  441.                        
  442.  
  443. //XMLSerializer serializer = new XMLSerializer(System.out, format);
  444.  
  445.                        
  446.  
  447. //to generate a file output use fileoutputstream instead of system.out
  448.                        
  449.  
  450. XMLSerializer serializer = new XMLSerializer(
  451. new FileOutputStream(new File
  452.  
  453. ("book.xml")), format);
  454.  
  455.  
  456.  
  457. serializer.serialize(domNew);
  458.  
  459.                
  460.  
  461. }
  462.                
  463.  
  464. catch(IOException ie) {
  465.                    
  466.  
  467. ie.printStackTrace();
  468.                
  469.  
  470. }
  471.        
  472.  
  473. }
  474.                
  475.  
  476.  
  477. }