Использование JDBC для вставки данных из XML в базу данных

Раздел 1. Введение

Нужен ли мне этот учебник?

Этот учебник создан для того, чтобы помочь тем Java-разработчикам, которым нужно выделить информацию из XML-документа и поместить ее в базу данных.

Этот учебник поможет вам понять тему даже, если вы только прочитаете примеры, не пытаясь выполнить их. Если вы хотите выполнять примеры по мере прохождения через этот учебник, убедитесь, что у вас установлены и корректно работают следующие инструменты:

Соглашения, используемые в данном учебнике

Для представления материала в данном учебнике используются некоторые соглашения:

• Текст, который должен печататься выделяется жирным моноширинным шрифтом. В некоторых кодовых примерах жирный шрифт используется, чтобы привлечь внимание к тегу или элементу, на который ссылается сопроводительный текст.
• Наклонный шрифт используется для привлечения внимания к окнам, диалогам и именам свойств.
• Моноширинный шрифт представляет имена файлов и маршруты.
• Везде в данном учебнике кодовые сегменты, не относящиеся к обсуждению, могут быть опущены и заменены многоточиями (...)

Об авторе

Раздел 2. Доступ к базе данных через JDBC

Что такое JDBC?

Нет необходимости иметь специфический драйвер JDBC для базы данных, если для нее доступен драйвер ODBC; вы можете использовать вместо этого мост JDBC-ODBC. Приложение вызывает мост, который переводит команды в ODBC, а драйвер ODBC переводит их в естественный API.

Мост JDBC-ODBC не является рекомендуемым способом обращения к базе данных по разным причинам, включая конфигурацию и производительность, - команды должны проходить через два API, и на каждом клиенте должен быть установлен и сконфигурирован драйвер ODBC - но он применим для тестирования и разработки, если нет чистого драйвера JDBC.

Процесс обращения к базе данных

Взаимодействие с базой данных при помощи Java обычно состоит из следующих шагов:

1. Загрузка драйвера базы данных. Это может быть драйвер JDBC или мост JDBC-ODBC.
2. Создание Connection с базой данных.
3. Создание объекта Statement. Этот объект реально выполняет SQL или хранимые процедуры.
4. Создание ResultSet и заполнение его результатами выполнения запроса (если целью является получение или непосредственное изменение данных).
5. Получение или изменение данных из ResultSet.

Пакет java.sql содержит JDBC 2.0 Core API для доступа к базе данных, как часть поставки Java^TM 2 SDK, Standard Edition. Пакет javax.sql, который поставляется, как часть Java 2 SDK, Enterprise Edition, содержит JDBC 2.0 Optional Package API.

Для обращения к базе данных сначала загрузите драйвер JDBC. В любой момент могут быть доступны много разных драйверов; имеется DriverManager, который знает о каждом драйвере и решает, какой из них будет использоваться для создания соединения. Первый, способный успешно создать соединение, будет использоваться приложением. Есть два способа, которыми DriverManager может узнать о существующих драйверах.

Первый способ - непосредственно загрузить его, используя Class.forName(), как показано в данном примере. Когда класс драйвера загружен, он регистрируется при помощи DriverManager, как показано здесь:

public class SaveOrders extends Object {
  public static void main (String args[]){
    //Для моста JDBC-ODBC используйте
    //driverName = "sun.jdbc.odbc.JdbcOdbcDriver"
    String driverName = "JData2_0.sql.$Driver";
    try {
      Class.forName(driverName);
    } catch (ClassNotFoundException e) {
      System.out.println("Error creating class: "+e.getMessage());
    }
  }
}

Успешно загрузив драйвер, приложение может соединиться с базой данных.

Когда вы загрузили драйвер, приложение может соединиться с базой данных. DriverManager выполняет соединение через статический метод getConnection(), который принимает в качестве аргумента URL базы данных. URL обычно представляется как:

jdbc:<sub-protocol>:имя базы данных

Однако, URL может быть написан в любом формате, который понимает драйвер. Посмотрите формат URL в документации для вашего драйвера JDBC.

Одной из причин введения под-протокола является соединение через ODBC. Если обращение к базе данных примера, с DSN pricing, выполняется через ODBC, URL может быть:

odbc:orders

Это означает, что для соединения через JDBC URL должен быть:

jdbc:odbc:orders

Реальное соединение создается ниже:

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
public class SaveOrders extends Object {
  public static void main (String args[]){
    //Для моста JDBC-ODBC используйте
    //driverName = "sun.jdbc.odbc.JdbcOdbcDriver"
    //и
    //connectURL = "jdbc:odbc:orders"
    String driverName = "JData2_0.sql.$Driver";
    String connectURL = "jdbc:JDataConnect://127.0.0.1/orders";
    Connection db = null;
    try {
      Class.forName(driverName);
      db = DriverManager.getConnection(connectURL);
    } catch (ClassNotFoundException e) {
      System.out.println("Error creating class: "+e.getMessage());
    } catch (SQLException e) {
      System.out.println("Error creating connection: "+e.getMessage());
    }
  }
}

Поскольку Statement и Connection являются объектами, Java будет включать их в сборку мусора, освобождая ресурсы базы данных, которые они занимают. Это может ввести вас в заблуждение и заставить думать, что вы не должны заботиться о закрытии этих объектов, но это не так.

Вполне возможно, что само Java-приложение имеет достаточно доступных ресурсов, что означает редкое выполнение сборки мусора. Возможно также, что хотя Java-приложение имеет достаточно ресурсов, ресурсы базы данных ограничены. Много ресурсов базы данных могут быть забраны объектами Java, которые легко могут быть закрыты приложением.

Важно быть уверенным, что эти объекты закрыты, независимо от того, были или не были ошибки, так что добавим блок finally к уже имеющемуся блоку try-catch:

...
    Connection db = null;
    try {
      Class.forName(driverName);
      db = DriverManager.getConnection(connectURL);
    } catch (ClassNotFoundException e) {
      System.out.println("Error creating class: "+e.getMessage());
    } catch (SQLException e) {
      System.out.println("Error creating connection: "+e.getMessage());
    } finally {
      System.out.println("Closing connections...");
      try {
        db.close();
          } catch (SQLException e) {
        System.out.println("Can't close connection.");
      }
    }
  }
}

Раздел 3. Чтение XML-файла

Файл orders.xml

Данные заказов для данного учебника находятся в файле orders.xml. Каждый заказ содержит информацию, специфичную собственно для заказа, такую как номер заказа, id пользователя и общую сумму. Каждый заказ содержит также информацию об отдельных составляющих заказа, такую как id товара, цена за единицу и количество. Файл orders.xml приводится ниже:

<?xml version="1.0" encoding="UTF-8"?>
<orders>
  <order orderid="1">
    <customerid>12341</customerid>
    <status>pending</status>
    <product productid="SA15">
      <name>Silver Show Saddle, 16 inch</name>
      <price>825.00</price>
      <qty>1</qty>
    </product>
    <product productid="C49">
      <name>Premium Cinch</name>
      <price>49.00</price>
      <qty>1</qty>
    </product>
  </order>
  <order orderid="2">
    <customerid>251222</customerid>
    <status>pending</status>
    <product productid="WB78">
      <name>Winter Blanket (78 inch)</name>
      <price>20</price>
      <qty>10</qty>
    </product>
    <product productid="C49">
      <name>Premium Cinch</name>
      <price>49.00</price>
      <qty>5</qty>
    </product>
  </order>
</orders>

Разбор файла

Чтение XML-данных начинается с разбора файла и создания объекта Document:

...
import org.w3c.dom.Document;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory; 
public class SaveOrders extends Object {
  public static void main (String args[]){
    //Determine the file location
    String ordersFile = "orders.xml";
    //Создание XML-документа
    Document ordersDoc = null;
    try {
      //Создание экземпляра парсера и разбор файла
      DocumentBuilderFactory docbuilderfactory =   
            DocumentBuilderFactory.newInstance();
      DocumentBuilder docbuilder = 
            docbuilderfactory.newDocumentBuilder();
      ordersDoc = docbuilder.parse(ordersFile);
    } catch (Exception e) {
      System.out.println("Cannot read the orders file: "+e.getMessage());
    }
    Connection db = null;
...

Этот пример показывает создание объекта Document для XML-документа при помощи Java API for XML Processing (JAXP). Сначала создайте DocumentBuilderFactory, затем используйте его для создания DocumentBuilder. Этот DocumentBuilder и является парсером, который берет файл orders.xml и читает каждый элемент для создания объекта Document.

Прежде, чем вы сможете построить приложение, которое читает XML-файл на основе файла отображения, вам нужно сначала прочитать XML без файла отображения.

В данном примере элемент order содержит каждый заказ, а элемент product содержит каждую составляющую в заказе. Чтобы обратиться к этим данным, конструируется цикл:

...
import org.w3c.dom.NodeList;
import org.w3c.dom.Node;
import org.w3c.dom.Element; 
public class SaveOrders extends Object {
  ...
    Connection db = null;
    try {
      Class.forName(driver);
      db = DriverManager.getConnection(connectURL);
      //Получить корневой элемент и все элементы заказов
      Element ordersRoot = ordersDoc.getDocumentElement();
      NodeList orders = ordersRoot.getElementsByTagName("order");
      for (int i = 0; i < orders.getLength(); i++) {
        //Для каждого заказа получить элемент order 
        Element thisOrder = (Element)orders.item(i);
        //Цикл по товарам в заказе
        NodeList products = thisOrder.getElementsByTagName("product");
        for (int j=0; j < products.getLength(); j++) {
        }
      }
    } catch (ClassNotFoundException e) {
    System.out.println("Error creating class: "+e.getMessage());
...

Чтобы выбрать информацию из Document, вам нужно выбрать корневой элемент, который содержит все данные. Если вы имеете этот элемент, приложение может выбирать данные по имени элемента, используя getElementsByTagName(). Этот метод возвращает NodeList, который может быть использован для обращения к каждому элементу.

Поскольку каждый order содержит элементы product, повторите процесс для создания второго цикла для каждого order.

Выборка действительных данных включает в себя комбинацию getElementsByTagName() и аккуратное обращение к потомкам узла, как показано здесь:

...
      Element ordersRoot = ordersDoc.getDocumentElement();
      NodeList orders = ordersRoot.getElementsByTagName("order");
      for (int i = 0; i < orders.getLength(); i++) {
      //Для каждого заказа получить элемент order 
          Element thisOrder = (Element)orders.item(i);
          //Получение информации заказа
          String thisOrderid = thisOrder.getAttribute("orderid");
          System.out.println("Order: " + thisOrderid);
          //Получение информации о покупателе
          String thisCustomerid = thisOrder.getElementsByTagName("customerid")
                  .item(0)
                  .getFirstChild().getNodeValue();
          System.out.println("Customer: " + thisCustomerid); 
          //Цикл по товарам в заказе
          NodeList products = thisOrder.getElementsByTagName("product");
          for (int j=0; j < products.getLength(); j++) {
              //Выборка каждого товара
              Element thisProduct = (Element)products.item(j);
              // Получение информации о товаре для 
              // атрибутов и дочерних элементов
              String thisProductid = thisProduct.getAttribute("productid");
              System.out.println(" Product: " + thisProductid);
              String priceStr = thisProduct.getElementsByTagName("price")
                      .item(0)
                      .getFirstChild().getNodeValue();
              System.out.println(" Price: " + priceStr);
              String qtyStr = thisProduct.getElementsByTagName("qty")
                      .item(0)
                      .getFirstChild().getNodeValue();
              System.out.println(" Quantity: " + qtyStr);
              System.out.println();
          }
      }
  } catch (ClassNotFoundException e) {
    System.out.println("Error creating class: "+e.getMessage());
...

Сначала выберите атрибут orderid из элемента order. Это значение просто возвращается методом getAttribute().

Выборка значений дочерних элементов чуть более сложна. Сначала выберите NodeList всех дочерних элементов с желаемыми именами, такими как customerid и productid. Таким образом вы обходите все потенциальные текстовые узлы. Но поскольку есть только один нужный для нас потомок, выбирайте item(0). Это обеспечивает нужные элементы. Чтобы получить действительное значение, нужно значение текстового узла первого потомка элемента.

Раздел 4. Изменение базы данных при помощи SQL

Создание оператора

Наиболее очевидным способом добавить любые данные в базу данных является применение оператора SQL. Наиболее общий объект, используемый для выполнения SQL-оператора на базе данных - Statement.

Объект Statement создается Connection:

...
import java.sql.Statement;
public class SaveOrders extends Object {
  ...  
    Connection db = null;
    try {
      Class.forName(className);
      db = DriverManager.getConnection(connectURL);
      //Создание объекта Statement 
      Statement statement = db.createStatement();
      Element ordersRoot = ordersDoc.getDocumentElement();
...

Вставка данных при помощи SQL предполагает использование оператора INSERT. Рассмотрим такой пример:

insert into orders (orderid, userid) values (2333, 'nchase')

• insert into orders: Показывает таблицу, в которую добавляются данные.
• (orderid, userid): Хотя в некоторых ситуациях это не обязательно, но стоит перечислить столбцы в базе данных, которые будут принимать вставляемые данные, в том же порядке, в каком они появляются в фразе values.
• values (2333, 'nchase'): Фраза values перечисляет фактические значения, которые должны быть добавлены в базу данных. Если в этот оператор не были включены имена столбцов, фраза values должна перечислять значения для всех столбцов таблицы в том порядке, в каком они появляются в определении таблицы в базе данных.

В общем случае для выполнения SQL-оператора при помощи объекта Statement используется один из четырех методов:

• executeQuery(): Используется для выполнения оператора выборки, который будет возвращать единственный ResultSet.
• executeUpdate(): Используется для выполнения оператора, который выполняет изменения в базе данных. Возвращает целое число, которое представляет число записей, затронутых изменением.
• executeBatch(): Используется для посылки в база данных нескольких операторов за раз. Возвращает массив результирующих счетчиков.
• execute(): Используется для более сложных операций над базой данных, которые могут возвращать более одного ResultSet.

В данном учебнике будет использоваться executeUpdate():

    ...
        String qtyStr = thisProduct.getElementsByTagName("qty")
            .item(0)
            .getFirstChild()
            .getNodeValue();
        //Создание и выполнение SQL-оператора
        String sqlTxt = "insert into orders "+
        "(orderid, userid, productid, unitprice, quantity) "+
        "values ("+thisOrderid+", "+thisCustomerid+", '"+
        thisProductid+"', "+priceStr+", "+qtyStr+")";
        int results = statement.executeUpdate(sqlTxt); 
      }
    }
  } catch (ClassNotFoundException e) {
...

Создайте оператор INSERT на базе таблицы orders и значений, взятых из файла orders.xml.

Раздел 5. Использование XML-файла отображения

Структура файла отображения

Теперь, когда вы успешно ввели данные в базу данных, пора обобщить эту информацию так, чтобы можно было использовать то, что есть в XML-файле отображения.

Назначением файла отображения является задание всех аспектов передачи данных, включая структуру и имя файла, содержащего заказы, и местоположение и структуру базы данных.

Файл отображения может быть весьма сложным, так что в данном учебнике мы сделаем определенные допущения:

• Таблицы базы данных: В наш проект включены только две таблицы. Одна содержит информацию по всем заказам, включая запись для каждого заказанного товара; другая содержит агрегированную информацию с общим доходом по каждому товару. В большинстве ситуаций агрегированную информацию - рассматриваемая как производные данные - будет выбираться программно из первой таблицы. Но для целей данного учебника для нее есть собственная таблица.
• Типы базы данных: Хотя разные базы данных обычно имеют разные имена определенных типов данных, они обычно сводятся к общим категориям текстов, чисел и дат.

  В данном учебнике предполагается, что даже если действительные типы данных несколько различаются, они остаются в пределах общей классификации.

• Структура XML: Хотя XML-файл может иметь любое число уровней предок-потомок и может быть организован многими способами, в данном учебнике предполагается, что товары всегда будут потомками первого уровня для заказов, даже при разных названиях. Данные могут быть атрибутами или элементами.

Файл отображения должен различать два разных типа информации: информацию базы данных и информацию XML-файла. Это может быть сделано при помощи двух дочерних элементов корня. Первый имеет дело с информацией базы данных:

<?xml version="1.0"?>
<map>
<!-- Для моста JDBC-ODBC используйте
driver = "sun.jdbc.odbc.JdbcOdbcDriver"
и
url = "jdbc:odbc:orders" -->
  <database url="jdbc:JDataConnect://127.0.0.1/orders"
          driver="JData2_0.sql.$Driver">
    <order_table>orders</order_table>
    <order_orderid>orderid</order_orderid>
    <order_customer>userid</order_customer>
    <order_productid>productid</order_productid>
    <order_quantity>quantity</order_quantity>
    <order_price>unitprice</order_price>
    <products_table>productOrders</products_table>
    <products_productid>productid</products_productid>
    <products_quantity>quantity</products_quantity>
    <products_total>revenue</products_total>
  </database>
...

Элемент database содержит информация о URL базы данных и об используемом драйвере. Это может быть для вас полезным, если вы не уверены в том, какой вид базы данных будет использован для хранения информации. Добавление ее в файл отображения предохраняет вас от необходимости перекомпиляции приложения при изменении баз данных.

Столбцы базы данных и таблицы будут представляться как переменные String, поскольку они будут использоваться только для построения строк SQL. В файле отображения перечислены все переменные и таблицы или столбцы, которым они соответствуют в базе данных. Заметьте, что в существующих таблицах, orders и products есть общие имена столбцов, но файл отображения делает это неважным.

XML-порция файла содержит несколько больше информации; данные могут быть в элементах или в атрибутах:

...
  <xmlfile url="orders.xml">
    <order>order</order>
    <orderid type="attribute">orderid</orderid>
    <customer type="element">customerid</customer>
    <products>product</products>
    <productid type="attribute">productid</productid>
    <quantity type="element">qty</quantity>
    <unitprice type="element">price</unitprice>
  </xmlfile>
</map>

Файл отображения содержит даже информацию о том, в каком файле содержатся заказы и с какой базой данных нужно соединяться. В результате этого этот файл нужно разобрать и проанализировать до того, как вы сможете выполнить что-либо еще.

Данный пример показывает, как выбрать информацию файла заказов:

...
  //Создание элементов для использования их в методах
  static Element databaseEl = null;
  static Element xmlfileEl = null; 
  public static void main (String args[]){
    //Обявление элементов отображения и документа
    String mapFile = "map.xml";
    Document mapDoc = null;
    Element mapRoot = null; 
    Document ordersDoc = null;
    try {
      DocumentBuilderFactory docbuilderfactory =     
            DocumentBuilderFactory.newInstance();
      DocumentBuilder docbuilder = 
            docbuilderfactory.newDocumentBuilder();
      //Разбор файла отображения и получение корневого элемента
      mapDoc = docbuilder.parse(отображениеFile);
      mapRoot = mapDoc.getDocumentElement();
      //Выборка базы данных и элементов и информации XML-файла 
      databaseEl = (Element)mapRoot.getElementsByTagName("database").item(0);
      xmlfileEl = (Element)mapRoot.getElementsByTagName("xmlfile").item(0); 
      System.out.println("Reading orders file...");
      String ordersFile = xmlfileEl.getAttribute("url");
      ordersDoc = docbuilder.parse(ordersFile);
    } catch (Exception e) {
      System.out.println("Cannot read the orders file:"+e.getMessage());
    }
...

Первое, что нужно отметить, что databaseEl, который хранит главный элемент отображения база данных, и xmlfileEl, который хранит главный элемент отображения XML-файла, объявлены как static вне метода main, так что их можно использовать в методах, создаваемых позже.

В предыдущих примерах ordersFile была первой главной переменной, устанавливаемой приложением. Теперь такой переменной является mapFile, которая указывает на действительный файл отображения, где может быть найдено значение ordersFile. Вам также понадобится создать основные XML-структуры, такие как mapRoot, вне блока try-catch, поскольку они тоже понадобятся вам позже.

В блоке try-catch сначала DocumentBuilder разбирает файл отображения, а не файл заказов, и заполняет два главных элемента отображение, databaseEl и xmlfileEl. Вы затем можете использовать xmlfileEl, чтобы определить имя файла заказов и наконец разобрать его.

Получение основной информации базы данных понятно, поскольку драйвер и URL являются атрибутами элемента databaseEl:

...
    } catch (Exception e) {
      System.out.println("Cannot read the orders file:"+e.getMessage());
    }
    String driverName = databaseEl.getAttribute("driver");
    String connectURL = databaseEl.getAttribute("url");
    Connection db = null;
    try {
      Class.forName(driverName);
      db = DriverManager.getConnection(connectURL);
      //Создание объекта Statement 
      Statement statement = db.createStatement();
      Element ordersRoot = ordersDoc.getDocumentElement();
      NodeList orders = ordersRoot.getElementsByTagName("order");
...

Заметьте, что в динамической загрузке класса есть одно преимущество. Если вы меняете драйверы JDBC, вам не нужна перекомпиляция; только измените файл отображения.

Все переменные базы данных хранятся как дочерние элементы одного и того же элемента, так что для выборки их подходит отдельный метод:

...
public class SaveOrders extends Object {
  static Element databaseEl = null;
  static Element xmlfileEl = null;
  private static String getDatabaseInfo (String varname) {
    //Выборока текстового узла заданного элемента
    String tempStr = databaseEl.getElementsByTagName(varname)
            .item(0)
            .getFirstChild().getNodeValue();
    return tempStr;
  }
  public static void main (String args[]){
...
    } catch (Exception e) {
      System.out.println("Cannot read the orders file:"+e.getMessage());
    }
    String driverName = databaseEl.getAttribute("driver");
    String connectURL = databaseEl.getAttribute("url");
    //Выборка имен столбцов
    String order_table = getDatabaseInfo("order_table");
    String order_orderid = getDatabaseInfo("order_orderid");
    String order_customer = getDatabaseInfo("order_customer");
    String order_productid = getDatabaseInfo("order_productid");
    String order_quantity = getDatabaseInfo("order_quantity");
    String order_price = getDatabaseInfo("order_price");
    String products_table = getDatabaseInfo("products_table");
    String products_productid = getDatabaseInfo("products_productid");
    String products_quantity = getDatabaseInfo("products_quantity");
    String products_total = getDatabaseInfo("products_total");
    Connection db = null;
    try {
...

Метод getDatabaseInfo() просто получает дочерний элемент с заданным именем и возвращает значение его дочернего текстового узла. Используйте этот метод для заполнения других переменных базы данных, чтобы они могли быть использованы в приложении.

Чтобы использовать переменные, просто замените жестко закодированные их эквиваленты в SQL-операторе:

...
    String qtyStr = thisProduct.getElementsByTagName("qty")
            .item(0)
            .getFirstChild().getNodeValue();
    //Создание и выполнение SQL-оператора
    String sqlTxt = "insert into "+order_table+
            " ("+order_orderid+", "+order_customer+", "+
            order_productid+", "+order_price+", "+order_quantity+") "+
            "values ("+thisOrderid+", "+thisCustomerid+", '"+
            thisProductid+"', "+priceStr+", "+qtyStr+")";
    int results = statement.executeUpdate(sqlTxt);
...

Получение основных переменных XML-файла отображение достаточно просто благодаря допущениям, сделанным выше. Общая структура документа предопределена, так что все, что вам нужно, чтобы начать, это имена элементов, хранящих заказы и товары. Эта информация имеется в файле отображения как текст в элементах order и product. Это все делает основные отображения легкими в использовании:

...
    try {
      Class.forName(driverName);
      db = DriverManager.getConnection(connectURL);
      Statement statement = db.createStatement();
      //Получение имен элементов product и order 
      String orderElName = xmlfileEl.getElementsByTagName("order").item(0)
            .getFirstChild().getNodeValue();
      String productElName = xmlfileEl.getElementsByTagName("products").item(0)
            .getFirstChild().getNodeValue();
      //Получение корневого элемента и всех элементов order
      Element ordersRoot = ordersDoc.getDocumentElement();
      NodeList orders = ordersRoot.getElementsByTagName(orderElName);
      for (int i = 0; i < orders.getLength(); i++) {
        //Для каждого заказа получить элемент order
        Element thisOrder = (Element)orders.item(i);
        //Получение информации заказа
        String thisOrderid = thisOrder.getAttribute("orderid");
        System.out.println("Order: " + thisOrderid);
        //Получение информации покупателя
        String thisCustomerid = thisOrder.getElementsByTagName("customerid")
              .item(0)
              .getFirstChild().getNodeValue();
        System.out.println("Customer: " + thisCustomerid);
        //Перебор всех товаров для заказа
        NodeList products = thisOrder.getElementsByTagName(productElName);
        for (int j=0; j < products.getLength(); j++) {
          Element thisProduct = (Element)products.item(j);
          String thisProductid = thisProduct.getAttribute("productid");
...

Сами элементы отображения сами должны также быть выделены в метод по двум причинам. Во-первых, эта логика будет использоваться многократно. Во-вторых, поскольку включается логика, в ваших же интересах обеспечить модульность операций. Таким образом, если вы решите изменить структуру файлов отображения или заказов, изменить логику чтения файла отображения будет легче.

Сама логика принимает во внимание тот факт, что данные, которые вы ищете, могут находиться и в элементах, и в атрибутах:

...
public class SaveOrders extends Object {
...
  private static String getDatabaseInfo (String varname) {
    String tempStr = databaseEl.getElementsByTagName(varname).item(0)
          .getFirstChild().getNodeValue();
    return tempStr;
  }
  private static String getXMLInfo (Element start, String varname) {
    //Получение заданного элемента и типа
    Element mapEl = (Element)xmlfileEl.getElementsByTagName(varname).item(0);
    String type = mapEl.getAttribute("type");
    String mappedName = mapEl.getFirstChild().getNodeValue();
    //Определение, возвращается ли атрибут или текстовый узел
    String tempStr = null;
    if (type.equals("attribute")) {
      tempStr = start.getAttribute(mappedName);
    } else if (type.equals("element")) {
      tempStr = start.getElementsByTagName(mappedName)
            .item(0)
            .getFirstChild().getNodeValue();
    }
    return tempStr;
  }
  public static void main (String args[]){
...
    Element ordersRoot = ordersDoc.getDocumentElement();
    NodeList orders = ordersRoot.getElementsByTagName(orderElName);
    for (int i = 0; i < orders.getLength(); i++) {
      Element thisOrder = (Element)orders.item(i);
      //Получение информации заказа и покупателя
      String thisOrderid = getXMLInfo(thisOrder, "orderid");
      String thisCustomerid = getXMLInfo(thisOrder, "customer");
      NodeList products = thisOrder.getElementsByTagName(productElName);
      for (int j=0; j < products.getLength(); j++) {
        //Выборка всех товаров
        Element thisProduct = (Element)products.item(j);
        //Получение информации товара
        String thisProductid = getXMLInfo(thisProduct, "productid");
        String priceStr = getXMLInfo(thisProduct, "unitprice");
        String qtyStr = getXMLInfo(thisProduct, "quantity");
        //Создание и выполнение SQL-оператора
        String sqlTxt = "insert into "+order_table+
              " ("+order_orderid+", "+order_customer+", "+
              order_productid+", "+order_price+", "+order_quantity+") "+
              "values ("+thisOrderid+", "+thisCustomerid+", '"+
              thisProductid+"', "+priceStr+", "+qtyStr+")";
...

Предыдущие примеры показывали данные, находящиеся на фиксированных местах, но этот пример выбирает данные из многих узлов. К счастью, вы всегда имеете базовый узел, либо thisOrder, либо thisProduct. Передавайте этот узел в метод и, когда вы определите, ищете вы атрибут или элемент, выбирайте данный, относящиеся к этому узлу.

Теперь вы должны сделать операцию типовой. Используя файл отображения, вы можете изменить имена таблиц и столбцов или даже самой базы данных. Возможно также изменить структуру файла orders.xml. Пока вы модифицируете map.xml, приложение будет по-прежнему работать так, как ожидается.

Раздел 6. Использование транзакций и пакетных операций

Что такое транзакция?

Теперь, когда приложение собрано, есть несколько относительно простых вещей, которые могут сделать его более надежным.

Часто при манипуляциях с базой данных существует точка зрения "все или ничего". Когда запись изменяется, частичные изменения нежелательны; трудно вернуть частично измененную запись в "исправное" состояние. Так что, когда изменяется запись базы данных, приложение должно либо сохранять все изменения, либо иметь средства возврата записи в предыдущее состояние. В контексте нашего примера, если вы вставляете заказы, и один из операторов приводит к ошибке, вы захотите иметь инструмент для отмены других изменений, которые вы уже сделали.

Возможность делать это известна как использование транзакций. В транзакциях все операторы, которые выполняются на базе данных, существуют в состоянии "неопределенности", пока они либо не зафиксируются и изменения не сделаются постоянными, либо не откатятся и изменения не будут отменены. Реальная транзакция начинается либо с первого SQL-оператора, либо немедленно после фиксации или отката.

Обычно Statement автоматически фиксирует каждый SQL-оператор, но эти установки можно изменить, используя объект Connection. Определенные действия, такие как изменение структуры базы данных или закрытие объекта Statement, также будут фиксировать транзакцию немедленно - даже без выполнения метода commit().

Группирование отдельных вставок в транзакция просто. В данном примере приложение просто отслеживает, есть ли какие-либо ошибки, и, если есть, откатывает транзакцию:

...
    Connection db = null;
    //Установка флага ошибки
    boolean dbErrors = false; 
    try {
...
    } catch (ClassNotFoundException e) {
      System.out.println("Error creating class: "+e.getMessage());
    } catch (SQLException e) {
      System.out.println("Error creating connection: "+e.getMessage());
      //Произошла ошибка, устанавливается флаг ошибки
      dbErrors = true; 
    } finally {
      System.out.println("Closing connections...");
      try {
        //Определяется, были ли ошибки и, соответственно
        //фиксируется или откатывается транзакция
        if (dbErrors) {
          db.rollback();
        } else {
          db.commit();
        }
      db.close();
      } catch (SQLException e) {
        System.out.println("Can't close connection.");
      }
...

Чтобы отслеживать, есть ли ошибки, создайте переменную типа boolean вне блока try-catch-finally и установите ее в false. Если все операторы завершились без ошибок, приложение получит блок finally с boolean-переменной, все еще установленной в false. В этом случае транзакция может быть зафиксирована. Если, с другой стороны, произошли ошибки, блок catch установит dbErrors в true, и приложение откатит все операции.

Поскольку вы непосредственно управляете тем, что транзакция фиксируется, на это решение могут влиять любые действия, которые могут выбрасывать исключения. Например, вы хотите добавлять каждый заказ в базу данных только один раз, так что вы можете захотеть удалить файл orders.xml, когда вы закончите работу с ним. Если это удаление почему-то будет неудачным, вы захотите откатить транзакцию.

Фактически, вы можете установить приложение так, что любая ошибка приведет к откату:

...
    } catch (SQLException e) {
      System.out.println("Error creating connection: "+e.getMessage());
      //Произошла ошибка, устанавливается флаг ошибки
      dbErrors = true;
    } catch (Exception e) {
      //Display the error message and set the error flag for any errors
      System.out.println(e.getMessage());
      dbErrors = true; 
    } finally {
      System.out.println("Closing connections...");
      try {
        //Определяется, были ли ошибки и, соответственно
        //фиксируется или откатывается транзакция
        if (dbErrors) {
          db.rollback();
        } else {
          db.commit();
        }
...

Таким образом, любое исключение будет устанавливать dbErrors в true. Вы можете также устанавливать значение этой переменной программно по любым причинам, относящимся к бизнес-логике.

Не все базы данных и драйверы поддерживают транзакции, так что перед встраиванием этой возможности в ваше приложение вы должны убедиться, что ваши это делают.

Вы можете определить поддержку транзакций и другие продвинутые свойства, проверив метаданные базы данных. Выберите эту информацию из Connection:

...
import java.sql.DatabaseMetaData; 
public class SaveOrders extends Object {
...
    Connection db = null;
    DatabaseMetaData dbmeta = null; 
    //Установка флага ошибок
    boolean dbErrors = false;
    try {
      Class.forName(driverName);
      db = DriverManager.getConnection(connectURL);
      //Получение метаданных базы данных
      dbmeta = db.getMetaData();
      //Если транзакции поддерживаются, выключить autocommit
      if (dbmeta.supportsTransactions()) {
        db.setAutoCommit(false);
      }
      Statement statement = db.createStatement();
      Element ordersRoot = ordersDoc.getDocumentElement();
      NodeList orders = ordersRoot.getElementsByTagName(orderElName);
...
    } catch (Exception e) {
      System.out.println(e.getMessage());
      dbErrors = true;
    } finally {
      System.out.println("Closing connections...");
      try {
        //Определяется, были ли ошибки и, соответственно,
        //фиксируется или откатывается транзакция
        if (dbmeta.supportsTransactions()) {
          if (dbErrors) {
            db.rollback();
          } else {
            db.commit();
          }
        }
        db.close();
      } catch (SQLException e) {
        System.out.println("Can't close connection.");
      }
...

В данном приложении, есть на самом деле только два места, где имеет значение, поддерживаются ли транзакции: когда выключается autocommit и когда транзакция либо фиксируется, либо откатывается. Все остальное обрабатывается обычным образом, исключая то, что без транзакций операции фиксируются немедленно.

Раз вы фиксируете все или никакие вставки, зачем использовать пропускную способность для базы данных для каждой единичной операции? Вместо этого вы можете создать пакет операций, который весь будет выполняться как один шаг на сервере:

...
    Element ordersRoot = ordersDoc.getDocumentElement();
    NodeList orders = ordersRoot.getElementsByTagName(orderElName);
    for (int i = 0; i < orders.getLength(); i++) {
      Element thisOrder = (Element)orders.item(i);
...
      NodeList products = thisOrder.getElementsByTagName(productElName);
      for (int j=0; j < products.getLength(); j++) {
...
        //Если транзакции поддерживаются, добавить в пакет.
        //Иначе выполнить оператор
        if (dbmeta.supportsBatchUpdates()) {
          statement.addBatch(sqlTxt);
        } else {
          int results = statement.executeUpdate(sqlTxt);
        }
      }
      //Если есть пакет, выполнить его
      if (dbmeta.supportsBatchUpdates()) {
        System.out.println("Executing batch ...");
        statement.executeBatch();
      }
    }
  } catch (ClassNotFoundException e) {
...

Если база данных и драйвер поддерживают пакетные изменения, добавляйте операторы в пакет вместо того, чтобы выполнять их. Когда цикл закончится, если есть поддержка, выполните пакет. Если нет поддержки, операторы уже должны быть выполнены.

Раздел 7. Изменяемые ResultSet'ы

Использование ResultSet

Чтобы собрать воедино информацию заказов, вам нужно интергировать ее с информацией, которая уже существует в базе данных, а не просто создавать и выполнять SQL-операторы. Одним из способов делать это являются изменяемые ResultSet'ы.

ResultSet является объектом, который возвращает запрос к базе данных. Это структура данных, позволяющая вам перебирать ее в цикле, обращаясь к данным по индексу или по имени столбца. Например, вы можете перебирать в цикле содержимое таблицы товаров:

    ResultSet resultset = statement.executeQuery("select * from productorders");
    while (resultset.next()) {
      System.out.print(resultset.getString("productid"));
      System.out.print("|");
      System.out.print(resultset.getString("quantity"));
      System.out.print("|");
      System.out.println(resultset.getString("revenue"));
    }

Созданный с установками по умолчанию, ResultSet является объектом одноразовым, только-читаемым, читаемым только вперед. Вы получаете одну порцию данных и, если она вам нужна опять, вы должны опять запросить базу данных. Однако не обязательно следовать именно таким путем. Устанавливая параметры объекта Statement, вы можете управлять теми ResultSet'ами, которые он вырабатывает. Например:

...
    Class.forName(driverName);
    db = DriverManager.getConnection(connectURL);
    Statement statement = 
        db.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,
            ResultSet.CONCUR_UPDATABLE);
    String orderElName = xmlfileEl.getElementsByTagName("order").item(0)
          .getFirstChild().getNodeValue();
...

Этот Statement теперь будет вырабатывать ResultSet'ы, которые могут быть изменены и которые будут подхватывать изменения, сделанные другими пользователями базы данных. Вы также можете двигаться по этому ResultSet вперед и назад.

Первый параметр задает тип ResultSet. Варианты такие:

• TYPE_FORWARD_ONLY: Тип по умолчанию. Позволяет только двигаться вперед и на него не влияют изменения, которые делают в базе данных другие пользователи.
• TYPE_SCROLL_INSENSITIVE: Позволяет двигаться вперед и назад и даже на заданную позицию, например, перейти на четвертую запись в списке или вернуться на две записи назад от текущей позиции. На него не влияют изменения, которые делают в базе данных другие пользователи.
• TYPE_SCROLL_SENSITIVE: Похож на TYPE_SCROLL_INSENSITIVE, позволяет позиционироваться на записи. На этот тип влияют изменения, которые делают в базе данных другие пользователи. Если пользователь удаляет запись после того, когда запрос выполнился, эта запись будет удалена из ResultSet. Аналогично и изменения в значениях данных будут отражаться в ResultSet.

Второй параметр устанавливает признак, определяющий, может ли ResultSet быть изменен. Варианты такие:

• CONCUR_READ_ONLY: Значение по умолчанию, задает, что ResultSet не может быть изменен.
• CONCUR_UPDATABLE: Задает, что ResultSet может быть изменен.

Создание и изменение ResultSet многом похоже на создание и изменение ResultSet в предыдущем примере:

...
import java.sql.ResultSet;
public class SaveOrders extends Object {
...
            int results = statement.executeUpdate(sqlTxt);
          }
          //Выборка данного товара из таблицы productOrders 
          String updateSqlTxt = "select * from productOrders where productid = '"+
                thisProductid +"'";
          ResultSet updateRs = statement.executeQuery(updateSqlTxt);
          //Получение нового количества и изменение ResultSet
          int oldQty = updateRs.getInt("quantity");
          updateRs.updateInt("quantity", getSum(oldQty, qtyStr));
          double oldRev = updateRs.getDouble("revenue");
          updateRs.updateInt("revenue", getRev(oldRev, qtyStr, priceStr));
          //Отсылка изменений в базу данных
          updateRs.updateRow();
        }
      }
    } catch (ClassNotFoundException e) {
...

Создайте ResultSet, как обычно, но вместо чтения столбцов при помощи таких методов, как getString и getInt, измените поля ResultSet при помощи таких методов, как updateString и updateInt (в зависимости от типа в базе данных). Первым параметром является имя поля (хотя вы можете использовать также и индекс поля), а вторым - устанавливаемое значение. (getSum() и getRev() просто выполняют преобразования типа и математические вычисления.)

Эти изменения не воздействуют на базу данных, пока не будет вызван метод updateRow(). Они, однако, воздействуют на значения, хранимые в ResultSet. (Вы можете также отменить изменения прежде, чем они будут посланы в базу данных, при помощи cancelRowUpdates().)

Одним из преимуществ использования изменяемого ResultSet является легкость, с которой он может быть преобразован для использования переменных из файла отображения:

...
import java.sql.ResultSet;
public class SaveOrders extends Object {
...
          int results = statement.executeUpdate(sqlTxt);
          //Выборка данного товара из таблицы productOrders
          String updateSqlTxt = "select * from " + products_table
                + " where " + products_productid
                + " = '" + thisProductid + "'";
          ResultSet updateRs = statement.executeQuery(updateSqlTxt);
          //Получение нового количества и изменение ResultSet
          int oldQty = updateRs.getInt(products_quantity);
          updateRs.updateInt(products_quantity, getSum(oldQty, qtyStr));
          double oldRev = updateRs.getDouble(products_total);
          updateRs.updateDouble(products_total, getSum(oldRev, qtyStr, priceStr));
          //Отсылка изменений в базу данных
          updateRs.updateRow();
        }
      }
    } catch (ClassNotFoundException e) {
...

Если не существует записи для данного товара, вам понадобится вставить новую запись в базу данных. Вы проделываете это со специальной строкой в ResultSet, называемой строкой вставки. Строка вставки является специальной строкой, созданной как временное пространство для сохранения изменений - аналогично изменениям при модификации записи - пока эти изменения не зафиксированы в базе данных.

Данный пример показывает, как проверить существование текущей записи и как создать новую, если проверка показала, что ее нет:

...
    String updateSqlTxt = "select * from " + products_table
          + " where " + products_productid
          + " = '" + thisProductid + "'";
    ResultSet updateRs = statement.executeQuery(updateSqlTxt);
    if (updateRs.next()) {
      //Получение нового количества и модификация ResultSet
      int oldQty = updateRs.getInt(products_quantity);
      updateRs.updateInt(products_quantity, getSum(oldQty, qtyStr));
      double oldRev = updateRs.getDouble(products_total);
      updateRs.updateDouble(products_total, getRev(oldRev, qtyStr, priceStr));
      //Отсылка изменений в базу данных
      updateRs.updateRow();
    } else {
      //Создание новой строки вставки
      updateRs.moveToInsertRow();
      //Добавление данных в строку вставки
      updateRs.updateInt(products_productid, getSum(0, thisProductid));
      updateRs.updateInt(products_quantity, getSum(0, qtyStr));
      updateRs.updateDouble(products_total, getRev(0, qtyStr, priceStr));
      //Отсылка новой строки в базу данных
      updateRs.insertRow();
    }
...

Как и при модификации, никакие изменения в базе данных на самом деле при вызове методов updateXXX не производятся. Только когда вы выполняете insertRow(),база данных получает новые данные. (В данном случае getSum() и getRev использованы для преобразования тиров.)

Раздел 8. Итоги по вставке данных при помощи JDBC/XML

Резюме

Хотя XML-файлы превосходны для хранения небольших объемов данных, в конечном счете, вы захотите использовать XML вместе с базой данных. В этом учебнике обсуждены основы соединения с базой данных при помощи JDBC, а также вставка данных в базу данных через JDBC и создание транзакций базы данных.

Данные вводятся в базу данных на основе внешнего XML-файла отображения, который определяет имена базы данных, таблиц, столбцов и имена элементов и атрибутов в XML-файле, хранящем данные, вставляемые в базу данных.

И JDBC, и XML являются мощными инструментами, каждый в своем роде. Места, где можно найти дополнительную информацию, такие: