Liaison des données XML avec Castor en Java

Castor permet le mappage d'objets XML-TO-Java via des conventions par défaut ou des fichiers de mappage explicite; 1) Définir les classes Java avec Getters / Setters; 2) Utilisez unmarshaller pour convertir XML en objets; 3) Utilisez Marshaller pour sérialiser les objets à XML; 4) Pour les cas complexes, configurez les mappages de champs dans mapping.xml; 5) Mappage de chargement via XMLContext pour un contrôle précis - cette approche fonctionne de manière fiable pour des systèmes simples ou hérités malgré un support moderne limité.

La liaison des données XML avec Castor en Java permet aux développeurs de mapper des données XML aux objets Java et vice versa sans analyser manuellement ni générer de XML. Castor est l'un des cadres de liaison de données open source précoces et largement utilisés pour Java, offrant un moyen simple de sérialiser les objets Java à XML et de désérialiser XML dans les objets.

Comment fonctionne Castor

Castor utilise des fichiers de mappage (ou introspection de classe) pour définir comment les classes Java correspondent aux éléments et attributs XML. Vous pouvez soit compter sur les conventions de dénomination (mappage par défaut), soit fournir un fichier de mappage XML explicite ( mapping.xml ) pour un contrôle à grain fin.

Composants clés:

• Source XML - Le document XML d'entrée ou de sortie.
• Classes Java - Old Java objets simples (POJOS) qui représentent le modèle de données.
• Fichier de mappage (facultatif) - Définit la liaison entre les champs XML et Java.
• Unmarshaller - convertit XML en objets Java.
• Marshaller - convertit les objets Java en xml.

Exemple étape par étape

Disons que vous avez un fichier XML représentant un livre:

 <book>
  <Title> Java efficace </TITME>
  <auteur> Joshua Bloch </auteur>
  <SBN> 978-0134685991 </SBN>
</book>

Et une classe Java correspondante:

 Livre de classe publique {
    titre de chaîne privée;
    auteur de chaîne privée;
    String privé ISBN;

    // Getters et Setters
    public String getTitle () {return title; }
    public void SettItle (String Title) {this.title = title; }

    public String getAuthor () {return auteur; }
    public void setAuthor (String Auteur) {this.author = auteur; }

    String public getisBn () {return isbn; }
    public void setisbn (String isbn) {this.isbn = isbn; }
}

Option 1: mappage par défaut (pas de fichier de mappage)

Si vos noms d'éléments XML correspondent aux noms de champ Java (ou suivez les conventions de JavaBean), Castor peut les faire automatiquement.

 import org.exolab.castor.xml.unmarshaller;
import org.exolab.castor.xml.marshaller;
import java.io.fileReader;
import java.io.filewriter;

// Unmarshal: XML à l'objet
Livre de livres = (livre) unmarshaller.unmarshal (book.class, nouveau fileReader ("book.xml"));

// Marshal: Object à XML
MARSHALLER.MARSHAL (Book, New FileWriter ("Output.xml"));

Cela fonctionne hors de la boîte si:

• Les noms d'élément correspondent aux noms de champ (sensibles à la casse par défaut).
• La classe a des setteurs et des getters publics.
• Pas de nidification complexe ou de types personnalisés.

Option 2: Utilisation d'un fichier de mappage (recommandé pour les cas complexes)

Lorsque la structure XML ne correspond pas à la classe Java, utilisez un mapping.xml :

 <mapping>
  <class name = "book">
    <map-to xml = "book" />
    <field name = "title" type = "java.lang.string">
      <bind-xml name = "title" node = "élément" />
    </FIELD>
    <field name = "auteur" type = "java.lang.string">
      <bind-xml name = "auteur" node = "élément" />
    </FIELD>
    <field name = "isbn" type = "java.lang.string">
      <bind-xml name = "isbn" node = "élément" />
    </FIELD>
  </class>
</ mapping>

Utilisez-le maintenant dans le code:

 import org.exolab.castor.mapping.mapping;
import org.exolab.castor.xml.xmlcontext;

// mappage de chargement
Mappage mappage = new mapping ();
mapping.loadMapping ("mapping.xml");

XmlContext context = new XmlContext ();
context.addmapping (mappage);

// Unmarshal avec cartographie
Unmarshaller unmarshaller = context.CreateunMarshaller ();
unmarshaller.setClass (book.class);
Livre de livres = (livre) unmarshaller.unmarshal (nouveau fileReader ("book.xml"));

// Maréchal avec cartographie
Marshaller Marshaller = context.CreateMarshaller ();
Marshaller.setWriter (new FileWriter ("output.xml"));
Marshaller.marshal (livre);

Avantages de Castor

• Configuration simple pour les cas d'utilisation de base.
• Mappage flexible via la configuration XML.
• Prend en charge les collections, les objets imbriqués et l'héritage.
• Peut générer des classes Java à partir de XSD (en utilisant castor-codegen ).

Pièges et conseils communs

• Les noms de champ doivent correspondre à moins que le mappage ne soit défini.
• Utilisez l'attribut type dans le mappage pour les types non primitifs ou personnalisés.
• Pour les collections (par exemple, List<Book> ), définissez field avec collection="arraylist" dans Mapping.
• Castor est moins activement maintenu maintenant; Considérez Jaxb ou Jackson pour de nouveaux projets.

Dépendances (maven)

Ajoutez Castor à votre pom.xml :

 <dépendance>
  <bandrandId> org.castor </rombandid>
  <ArtefactId> Castor-xml </letefactive>
  <version> 1.5.1 </ version>
</Dependance>

Alors que Castor était populaire au début des années 2000 du développement Java, des alternatives modernes comme Jaxb (intégrées à Java jusqu'à Java 9, maintenant séparées), Jackson XML ou Xstream offrent de meilleures performances et un soutien communautaire. Mais pour les systèmes hérités ou les tâches de liaison simples, Castor reste une option viable et sans fioritures.

Fondamentalement, si vous êtes coincé avec des outils plus anciens ou si vous avez besoin d'une liaison rapide XML-Java sans annotations, Castor fait le travail - ne vous attendez pas au vernis des nouvelles bibliothèques.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!