SaveIPInfo.java~2~
上传用户:liming9091
上传日期:2014-10-27
资源大小:3376k
文件大小:8k
源码类别:

Java编程

开发平台:

Java

  1. package tsinghuaip;
  2. import java.sql.Connection;
  3. import java.sql.DriverManager;
  4. import java.sql.SQLException;
  5. import java.sql.Statement;
  6. import java.sql.ResultSet;
  7. import java.sql.ResultSetMetaData;
  8. import java.sql.PreparedStatement;
  9. import org.w3c.dom.Document;
  10. import javax.xml.parsers.DocumentBuilder;
  11. import javax.xml.parsers.DocumentBuilderFactory;
  12. import org.w3c.dom.Element;
  13. import org.w3c.dom.Node;
  14. import org.w3c.dom.NodeList;
  15. public class SaveIPInfo {
  16.    public static void main (String args[]){
  17.        //Create the Document object
  18.       Document mapDoc = null;
  19.       //Define a new Document object
  20.       Document dataDoc = null;
  21.       //Create the new Document
  22.       Document newDoc = null;
  23.       try {
  24.          //Create the DocumentBuilderFactory
  25.          DocumentBuilderFactory dbfactory = DocumentBuilderFactory.newInstance();
  26.          //Create the DocumentBuilder
  27.          DocumentBuilder docbuilder = dbfactory.newDocumentBuilder();
  28.          //Parse the file to create the Document
  29.          mapDoc = docbuilder.parse("mapping.xml");
  30.          //Instantiate a new Document object
  31.          dataDoc = docbuilder.newDocument();
  32.          //Instantiate the new Document
  33.          newDoc = docbuilder.newDocument();
  34.       } catch (Exception e) {
  35.          System.out.println("Problem creating document: "+e.getMessage());
  36.       }
  37.       //Retrieve the root element
  38.       Element mapRoot = mapDoc.getDocumentElement();
  39.       //Retrieve the (only) data element and cast it to Element
  40.       Node dataNode = mapRoot.getElementsByTagName("data").item(0);
  41.       Element dataElement = (Element)dataNode;
  42.       //Retrieve the sql statement
  43.       String sql = dataElement.getAttribute("sql");
  44.       //Output the SQL statement
  45.       System.out.println(sql);
  46.       //For the JDBC-ODBC bridge, use
  47.       //driverName = "sun.jdbc.odbc.JdbcOdbcDriver"
  48.       //and
  49.       //connectURL = "jdbc:odbc:pricing"
  50.       String driverName = "JData2_0.sql.$Driver";
  51.       String connectURL = "jdbc:JDataConnect://127.0.0.1/pricing";
  52.       Connection db = null;
  53.       //Create the ResultSetMetaData object, which will hold information about
  54.       //the ResultSet
  55.       ResultSetMetaData resultmetadata = null;
  56.       //Create a new element called "data"
  57.       Element dataRoot = dataDoc.createElement("data");
  58.       try {
  59.          Class.forName(driverName);
  60.          db = DriverManager.getConnection(connectURL);
  61.       } catch (ClassNotFoundException e) {
  62.          System.out.println("Error creating class: "+e.getMessage());
  63.       } catch (SQLException e) {
  64.          System.out.println("Error creating connection: "+e.getMessage());
  65.       }
  66.       //Create the Statement object, used to execute the SQL statement
  67.       PreparedStatement statement = null;
  68.       //Create the ResultSet object, which ultimately holds the data retreived
  69.       ResultSet resultset = null;
  70.       try {
  71.          statement = db.prepareStatement("select * from products");
  72.          //Execute the query to populate the ResultSet
  73.          resultset = statement.executeQuery();
  74.          //Get the ResultSet information
  75.          resultmetadata = resultset.getMetaData();
  76.          //Determine the number of columns in the ResultSet
  77.          int numCols = resultmetadata.getColumnCount();
  78.          //Check for data by moving the cursor to the first record (if there is one)
  79.          while (resultset.next()) {
  80.             //For each row of data
  81.             //Create a new element called "row"
  82.             Element rowEl = dataDoc.createElement("row");
  83.             for (int i=1; i <= numCols; i++) {
  84.                //For each column index, determine the column name
  85.                String colName = resultmetadata.getColumnName(i);
  86.                //Get the column value
  87.                String colVal = resultset.getString(i);
  88.                //Determine if the last column accessed was null
  89.                if (resultset.wasNull()) {
  90.                   colVal = "and up";
  91.                }
  92.                //Create a new element with the same name as the column
  93.                Element dataEl = dataDoc.createElement(colName);
  94.                //Add the data to the new element
  95.                dataEl.appendChild(dataDoc.createTextNode(colVal));
  96.                //Add the new element to the row
  97.                rowEl.appendChild(dataEl);
  98.             }
  99.             //Add the row to the root element
  100.             dataRoot.appendChild(rowEl);
  101.          }
  102.       } catch (SQLException e) {
  103.          System.out.println("SQL Error: "+e.getMessage());
  104.       } finally {
  105.          System.out.println("Closing connections...");
  106.          try {
  107.             db.close();
  108.          } catch (SQLException e) {
  109.             System.out.println("Can't close connection.");
  110.          }
  111.       }
  112.       //Add the root element to the document
  113.       dataDoc.appendChild(dataRoot);
  114.       //Retrieve the root element (also called "root")
  115.       Element newRootInfo = (Element)mapRoot.getElementsByTagName("root").item(0);
  116.       //Retrieve the root and row information
  117.       String newRootName = newRootInfo.getAttribute("name");
  118.       String newRowName = newRootInfo.getAttribute("rowName");
  119.       //Retrieve information on elements to be built in the new document
  120.       NodeList newNodesMap = mapRoot.getElementsByTagName("element");
  121.       //Create the final root element with the name from the mapping file
  122.       Element newRootElement = newDoc.createElement(newRootName);
  123.       //Retrieve all rows in the old document
  124.       NodeList oldRows = dataRoot.getElementsByTagName("row");
  125.       for (int i=0; i < oldRows.getLength(); i++){
  126.          //Retrieve each row in turn
  127.          Element thisRow = (Element)oldRows.item(i);
  128.          //Create the new row
  129.          Element newRow = newDoc.createElement(newRowName);
  130.          for (int j=0; j < newNodesMap.getLength(); j++) {
  131.             //For each node in the new mapping, retrieve the information
  132.             //First the new information...
  133.             Element thisElement = (Element)newNodesMap.item(j);
  134.             String newElementName = thisElement.getAttribute("name");
  135.             //Then the old information
  136.             Element oldElement = (Element)thisElement.getElementsByTagName("content").item(0);
  137.             String oldField = oldElement.getFirstChild().getNodeValue();
  138.             //Get the original values based on the mapping information
  139.             Element oldValueElement = (Element)thisRow.getElementsByTagName(oldField).item(0);
  140.             String oldValue = oldValueElement.getFirstChild().getNodeValue();
  141.             //Create the new element
  142.             Element newElement = newDoc.createElement(newElementName);
  143.             newElement.appendChild(newDoc.createTextNode(oldValue));
  144.             //Retrieve list of new elements
  145.             NodeList newAttributes = thisElement.getElementsByTagName("attribute");
  146.             for (int k=0; k < newAttributes.getLength(); k++) {
  147.                //For each new attribute
  148.                //Get the mapping information
  149.                Element thisAttribute = (Element)newAttributes.item(k);
  150.                String oldAttributeField = thisAttribute.getFirstChild().getNodeValue();
  151.                String newAttributeName = thisAttribute.getAttribute("name");
  152.                //Get the original value
  153.                oldValueElement = (Element)thisRow.getElementsByTagName(oldAttributeField).item(0);
  154.                String oldAttributeValue = oldValueElement.getFirstChild().getNodeValue();
  155.                //Create the new attribute
  156.                newElement.setAttribute(newAttributeName, oldAttributeValue);
  157.             }
  158.             //Add the new element to the new row
  159.             newRow.appendChild(newElement);
  160.          }
  161.          //Add the new row to the root
  162.          newRootElement.appendChild(newRow);
  163.       }
  164.       //Add the new root to the document
  165.       newDoc.appendChild(newRootElement);
  166.       System.out.println(newRootElement.toString());
  167.    }
  168. }