Utilisez XMLBeans pour lire et écrire facilement du XML

1. À propos de l'analyse XML

XML devient de plus en plus important dans les applications Java et est largement utilisé dans le stockage et l'échange de données. Par exemple, nos fichiers de configuration courants sont également tous stockés en XML. utilisé dans des technologies telles que Java Message Service et Web Services pour l'échange de données. Par conséquent, la lecture et l'écriture correctes de documents XML constituent la base des applications XML

Java fournit deux méthodes, SAX et DOM, pour analyser XML, mais. Même ainsi, ce n'est pas une tâche facile de lire et d'écrire un XML légèrement complexe

2. Introduction à XMLBean

Hibernate est devenue une base de données objet/relationnelle populaire pour les outils de cartographie. Avant l'émergence des outils de mappage de bases de données objet/relationnelles tels qu'Hibernate, les opérations sur la base de données étaient implémentées via JDBC. Pour toute opération sur la base de données, les développeurs devaient écrire eux-mêmes des instructions SQL. les opérations sur la base de données sont converties en opérations sur JavaBeans, ce qui facilite grandement le développement de bases de données. Par conséquent, s'il existe un outil similaire capable de convertir la lecture et l'écriture de XML en opérations sur JavaBeans, cela simplifiera la lecture et l'écriture de XML. Même les développeurs qui ne sont pas familiers avec XML peuvent facilement lire et écrire du XML. Cet outil est XMLBean

3. Préparez les documents XMLBean et XML

Téléchargez depuis http://www.apache.org. , la dernière version est la 2.0. Le répertoire décompressé est le suivant :

xmlbean2.0.0
     +---bin
     +---docs
     +---lib
     +---samples
     +---schemas

De plus, vous devez préparer un document XML (clients.xml),

Dans l'exemple de cet article , nous allons lire et écrire ce document. Le code source du document est le suivant :

<?xml version="1.0" encoding="UTF-8"?>
<Customers>
    <customer>
            <id>1</id>
            <gender>female</gender>
            <firstname>Jessica</firstname>
            <lastname>Lim</lastname>
            <phoneNumber>1234567</phoneNumber>
            <address>
                <PRimaryAddress>
                        <postalCode>350106</postalCode>
                        <addressLine1>#25-1</addressLine1>
                        <addressLine2>SHINSAYAMA 2-CHOME</addressLine2>
                </primaryAddress>
                <billingAddress>
                        <receiver>Ms Danielle</receiver>
                        <postalCode>350107</postalCode>
                        <addressLine1>#167</addressLine1>
                        <addressLine2>NORTH TOWER HARBOUR CITY</addressLine2>
                </billingAddress>
            </address>
    </customer>
    <customer>
            <id>2</id>
            <gender>male</gender>
            <firstname>David</firstname>
            <lastname>Bill</lastname>
            <phoneNumber>808182</phoneNumber>
            <address>
                <primaryAddress>
                        <postalCode>319087</postalCode>
                        <addressLine1>1033 WS St.</addressLine1>
                        <addressLine2>Tima Road</addressLine2>
                </primaryAddress>
                <billingAddress>
                        <receiver>Mr William</receiver>
                        <postalCode>672993</postalCode>
                        <addressLine1>1033 WS St.</addressLine1>
                        <addressLine2>Tima Road</addressLine2>
                </billingAddress>
            </address>
    </customer>
</Customers>

Il s'agit d'un modèle de données client. Chaque client a un numéro de client (ID), un nom, un sexe, un numéro de téléphone et. adresse, dont il y a deux adresses : Adresse principale et Adresse de facturation. Chaque adresse se compose du code postal, de l'Adresse 1 et de l'Adresse 2. L'adresse de facturation Il y a aussi le destinataire (destinataire) En outre, un fichier de configuration (nom du fichier). customer.xsdconfig) doit être préparé. Je parlerai de la fonction de ce fichier plus tard. Son contenu est le suivant :

<xb:config xmlns:xb="http://xml.apache.org/xmlbeans/2004/02/xbean/config">
  <xb:namespace>
    <xb:package>sample.xmlbean</xb:package>
  </xb:namespace>
</xb:config>

4. Les étapes d'utilisation de XMLBean

sont les mêmes. ainsi que les étapes d'utilisation d'autres outils de mappage de bases de données objet/relationnelles pour l'environnement Java. Avant d'utiliser officiellement XMLBean, nous devons effectuer deux préparations

1. Générer un fichier de schéma XML

Qu'est-ce qu'un. Fichier de schéma XML ? Normalement, chaque fichier XML possède un fichier de schéma. Le fichier de schéma XML est un fichier de contraintes XML, qui définit la structure et les éléments du fichier XML ainsi que les éléments et les contraintes structurelles. Le fichier XML est un enregistrement dans une base de données, alors le schéma est une définition de structure de table

Pourquoi ce fichier est-il nécessaire pour que XMLBean connaisse la structure et les contraintes d'un fichier XML via ce fichier, telles que les types de données ? etc. En utilisant ce fichier de schéma, XMLBean générera une série de classes Java associées pour implémenter des opérations sur XML. En tant que développeur, vous utilisez les classes Java générées par XMLBean pour effectuer des opérations sur XML sans avoir besoin de SAX ou de DOM. ce fichier Schema ? Pour les développeurs qui sont familiers avec XML, ils peuvent écrire ce fichier Schema eux-mêmes. Pour les développeurs qui ne sont pas familiers avec XML, ils peuvent utiliser certains outils pour le compléter. Les plus connus sont les fichiers XMLSPY et Stylus Studio. peut être généré via des fichiers XML. Ajoutez que nous avons généré ce fichier de schéma (customer.xsd) :

  <?xml version="1.0" encoding="UTF-8"?>
       <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
                  elementFormDefault="qualified">
         <xs:element name="Customers">
           <xs:complexType>
             <xs:sequence>
               <xs:element maxOccurs="unbounded" name="customer"
                           type="customerType"/>
             </xs:sequence>
           </xs:complexType>
         </xs:element>
       <xs:complexType name="customerType">
             <xs:sequence>
               <xs:element name="id" type="xs:int"/>
               <xs:element name="gender" type="xs:string"/>
               <xs:element name="firstname" type="xs:string"/>
               <xs:element name="lastname" type="xs:string"/>
               <xs:element name="phoneNumber" type="xs:string"/>
               <xs:element name="address" type="addressType"/>
             </xs:sequence>
       </xs:complexType>
         <xs:complexType name="addressType">
             <xs:sequence>
               <xs:element name="primaryAddress" type="primaryAddressType"/>
               <xs:element name="billingAddress" type="billingAddressType"/>
             </xs:sequence>
         </xs:complexType>
         <xs:complexType name="primaryAddressType">
             <xs:sequence>
               <xs:element name="postalCode" type="xs:string"/>
               <xs:element name="addressLine1" type="xs:string"/>
               <xs:element name="addressLine2" type="xs:string"/>
             </xs:sequence>
         </xs:complexType>
         <xs:complexType name="billingAddressType">
             <xs:sequence>
                   <xs:element name="receiver" type="xs:string"/>
               <xs:element name="postalCode" type="xs:string"/>
               <xs:element name="addressLine1" type="xs:string"/>
               <xs:element name="addressLine2" type="xs:string"/>
             </xs:sequence>
         </xs:complexType>
       </xs:schema>

2 Utilisez scomp pour générer des classes Java

scomp est fourni par XMLBean A. outil de compilation, qui se trouve dans le répertoire bin. Grâce à cet outil, nous pouvons générer des classes Java à partir du fichier schéma ci-dessus. La syntaxe de scomp est la suivante : -

　　scomp [options] [dirs]* [schemaFile.xsd]* [service.wsdl]* [config.xsdconfig]*

Description du paramètre principal :

.

-src [dir] -- 生成的Java Classes存放目录
　　-srconly -- 不编译Java Classes,不产生Jar文件
　　-out [jarFileName] -- 生成的Jar文件,缺省是xmltypes.jar
　　-compiler -- Java编译器的路径,即Javac的位置
　　schemaFile.xsd -- XML Schema文件位置

config.xsdconfig -- l'emplacement du fichier xsdconfig. Ce fichier est principalement utilisé pour formuler certaines règles de nom de fichier pour la classe Java générée et le nom du package. Dans cet article, le package est un exemple. Dans cet article, je l'ai exécuté comme ceci :

Cette ligne de commande signifie dire à scomp de générer customerXmlBean.jar et de le placer dans le répertoire de construction. En même temps, le code source est généré et. placé sous buildsrc. Le fichier Schema est customer. Les fichiers xsd et xsdconfig sont customer.xsdconfig. En fait, le code source Java généré est de peu d'utilité. Ce que nous voulons, c'est le fichier jar. sous buildsrcsamplexmlbean.

 scomp -src build\src  -out build\customerXmlBean.jar schema\customer.xsd
             -compiler C:\jdk142_04\bin\javac customer.xsdconfig

D'accord, c'est parti. Maintenant, tout notre travail de préparation est terminé. Passons maintenant au point : utiliser le fichier jar que nous venons de générer pour lire et écrire du XML. > 5. Utilisez XMLBean pour lire les fichiers XML

CustomersDocument.java -- 整个XML文档的Java Class映射
　　CustomerType.java -- 节点sustomer的映射
　　AddressType.java -- 节点address的映射
　　BillingAddressType.java -- 节点billingAddress的映射
　　PrimaryAddressType.java -- 节点primaryAddress的映射

Créez un nouveau projet Java, ajoutez le fichier Jar sous XMLBean2.0.0lib et le customerXmlBean.jar que nous venons de générer au ClassPath du projet.

Créer une nouvelle classe Java : CustomerXMLBean. Le code source est le suivant :

Exécutez-le, voyez les résultats de sortie :

 package com.sample.reader;
    import java.io.File;
    
    import sample.xmlbean.*;
    import org.apache.commons.beanutils.BeanUtils;
    import org.apache.xmlbeans.XmlOptions;
    public class CustomerXMLBean {
    private String filename = null;
    
    public CustomerXMLBean(String filename) {
            super();
            this.filename = filename;
    }
    public void customerReader() {
            try {
              File xmlFile = new File(filename);
              CustomersDocument doc = CustomersDocument.Factory.parse(xmlFile);
              CustomerType[] customers = doc.getCustomers().getCustomerArray();
          
              for (int i = 0; i < customers.length; i++) {
                CustomerType customer = customers[i];
                println("Customer#" + i);
                println("Customer ID:" + customer.getId());
                println("First name:" + customer.getFirstname());
                println("Last name:" + customer.getLastname());
                println("Gender:" + customer.getGender());
                println("PhoneNumber:" + customer.getPhoneNumber());
                // Primary address
                PrimaryAddressType primaryAddress = customer.getAddress().getPrimaryAddress();
                println("PrimaryAddress:");
                println("PostalCode:" + primaryAddress.getPostalCode());
                println("AddressLine1:" + primaryAddress.getAddressLine1());
                println("AddressLine2:" + primaryAddress.getAddressLine2());
                // Billing address
                BillingAddressType billingAddress = customer.getAddress().getBillingAddress();
                println("BillingAddress:");
                println("Receiver:" + billingAddress.getReceiver());
                println("PostalCode:" + billingAddress.getPostalCode());
                println("AddressLine1:" + billingAddress.getAddressLine1());
                println("AddressLine2:" + billingAddress.getAddressLine2());
            
              }
            } catch (Exception ex) {
                    ex.printStackTrace();
            }
    }
    private void println(String str) {
          System.out.println(str);
    }
   public static void main(String[] args) {
      String filename = "F://JavaTest//Eclipse//XMLBean//xml//customers.xml";
                   
     CustomerXMLBean customerXMLBean = new CustomerXMLBean(filename);
                   customerXMLBean.customerReader();
    }
    }

Et si, est-ce très simple ? puissance de XMLBean.

6. Utilisez XMLBean pour écrire des fichiers XML

  Customer#0
       Customer ID:1
       First name:Jessica
       Last name:Lim
       Gender:female
       PhoneNumber:1234567
       PrimaryAddress:
       PostalCode:350106
       AddressLine1:#25-1
       AddressLine2:SHINSAYAMA 2-CHOME
       BillingAddress:
       Receiver:Ms Danielle
       PostalCode:350107
       AddressLine1:#167
       AddressLine2:NORTH TOWER HARBOUR CITY
       Customer#1
       Customer ID:2
       First name:David
       Last name:Bill
       Gender:male
       PhoneNumber:808182
       PrimaryAddress:
       PostalCode:319087
       AddressLine1:1033 WS St.
       AddressLine2:Tima Road
       BillingAddress:
       Receiver:Mr William
       PostalCode:672993
       AddressLine1:1033 WS St.
       AddressLine2:Tima Road

Utiliser XMLBean pour créer une documentation XML est également un jeu d'enfant. Ajoutons une autre méthode,

Veuillez prendre une. regardez la classe Java :

Modifiez la méthode principale

 public void createCustomer() {
    try {
        // Create Document
        CustomersDocument doc = CustomersDocument.Factory.newInstance();
        // Add new customer
        CustomerType customer = doc.addNewCustomers().addNewCustomer();
        // set customer info
        customer.setId(3);
        customer.setFirstname("Jessica");
        customer.setLastname("Lim");
        customer.setGender("female");
        customer.setPhoneNumber("1234567");
        // Add new address
        AddressType address = customer.addNewAddress();
        // Add new PrimaryAddress
        PrimaryAddressType primaryAddress = address.addNewPrimaryAddress();
        primaryAddress.setPostalCode("350106");
        primaryAddress.setAddressLine1("#25-1");
        primaryAddress.setAddressLine2("SHINSAYAMA 2-CHOME");
        // Add new BillingAddress
        BillingAddressType billingAddress = address.addNewBillingAddress();
        billingAddress.setReceiver("Ms Danielle");
        billingAddress.setPostalCode("350107");
        billingAddress.setAddressLine1("#167");
        billingAddress.setAddressLine2("NORTH TOWER HARBOUR CITY");
        File xmlFile = new File(filename);
        doc.save(xmlFile);
        } catch (Exception ex) {
                ex.printStackTrace();
        }
  }

Exécutez, ouvrez customer_new.xml :

   public static void main(String[] args) {
    String filename = "F://JavaTest//Eclipse//XMLBean//xml//customers_new.xml";
        CustomerXMLBean customerXMLBean = new CustomerXMLBean(filename);
        customerXMLBean.createCustomer();
    }

7. Utilisez XMLBean pour. modifier le fichier XML

Nous ajoutons une autre méthode :

 <?xml version="1.0" encoding="UTF-8"?>
    <Customers>
    <customer>
            <id>3</id>
            <gender>female</gender>
            <firstname>Jessica</firstname>
            <lastname>Lim</lastname>
            <phoneNumber>1234567</phoneNumber>
            <address>
                    <primaryAddress>
                         <postalCode>350106</postalCode>
                         <addressLine1>#25-1</addressLine1>
                                       <addressLine2>SHINSAYAMA 2-CHOME</addressLine2>
                    </primaryAddress>
                    <billingAddress>
                        <receiver>Ms Danielle</receiver>
                        <postalCode>350107</postalCode>
                       <addressLine1>#167</addressLine1>
                       <addressLine2>NORTH TOWER HARBOUR CITY</addressLine2>
                    </billingAddress>
                    </address>
            </customer>
    </Customers>

Après l'exécution, nous verrons que le nom de famille du client avec le numéro de client 3 a été modifié pour durer.

8. Utilisez XMLBean pour supprimer un client

public void updateCustomer(int id,String lastname) {
         try {
        File xmlFile = new File(filename);
        CustomersDocument doc = CustomersDocument.Factory.parse(xmlFile);
        CustomerType[] customers = doc.getCustomers().getCustomerArray();
      
        for (int i = 0; i < customers.length; i++) {
           CustomerType customer = customers[i];
          if(customer.getId()==id){
                customer.setLastname(lastname);
                break;
            }
        }
        doc.save(xmlFile);
         } catch (Exception ex) {
          ex.printStackTrace();
         }
           }
　　main method:
    public static void main(String[] args) {
     String filename = "F://JavaTest//Eclipse//XMLBean//xml//customers_new.xml";
                    
    CustomerXMLBean customerXMLBean = new CustomerXMLBean(filename);
                    
    customerXMLBean.updateCustomer(3,"last");
    }

et ajoutez une autre méthode :

public void deleteCustomer(int id) {
     try {
      File xmlFile = new File(filename);
     CustomersDocument doc = CustomersDocument.Factory.parse(xmlFile);
    CustomerType[] customers = doc.getCustomers().getCustomerArray();
   for (int i = 0; i < customers.length; i++) {
        CustomerType customer = customers[i];
        if(customer.getId()==id){
                        customer.setNil() ;
                        break;
               }
   }
   doc.save(xmlFile);
   } catch (Exception ex) {
        ex.printStackTrace();
        }
   }
　　main method:
    public static void main(String[] args) {
    String filename = "F://JavaTest//Eclipse//XMLBean//xml//customers_new.xml";
                    
    CustomerXMLBean customerXMLBean = new CustomerXMLBean(filename);
                    
    customerXMLBean.deleteCustomer(3);
    }

运行,我们将会看到客户编号为3的客户的资料已经被删除.

　　九、查询XML

　　除了本文在以上讲述的,利用XMLBean能轻轻松松完成XML的读写操作外,结合XPath和XQuery,XMLBean还能完成象SQL查询数据库一样方便地查询XML数据. 关于XML查询以及如何创建XML数据库, 我将在另一篇文章里讨论.

　　十、结束语

　　XMLBean能帮助我们轻易读写XML,这将有助于我们降低XML的学习和使用,有了这个基础,开发人员将为学习更多地XML相关技术和Web Services,JMS等其他J2EE技术打下良好地基础.

 以上就是利用XMLBean轻轻松松读写XML的内容，更多相关内容请关注PHP中文网（www.php.cn）！