Хотя архитектура Java для связывания XML ( JAXB ) довольно проста в номинальном случае (особенно после Java SE 6 ), она также имеет множество нюансов. Некоторые из общих нюансов обусловлены неспособностью к точно соответствовать ( связывать ) XML — схемы Определение типов (XSD) для Java — типов . В этом посте рассматривается один конкретный пример этого, который также демонстрирует, как различные конструкции XSD, обеспечивающие одинаковую структуру XML, могут приводить к различным типам Java, когда компилятор JAXB генерирует классы Java.
Следующий листинг кода for Food.xsdопределяет схему для типов продуктов. XSD обязывает этот действительный XML иметь корневой элемент с именем «Food» с тремя вложенными элементами «Vegetable», «Fruit» и «Dessert». Хотя подход, используемый для указания элементов «Vegetable» и «Dessert», отличается от подхода, используемого для указания элемента «Fruit», оба подхода приводят к схожему «действительному XML». Элементы «Vegetable» и «Dessert» объявляются непосредственно как элементы предписанных simpleTypes, определенных позже в XSD. Элемент «Fruit» определяется через reference ( ref=) для другого определенного элемента, который состоит из simpleType.
Food.xsd
<?xml version="1.0" encoding="utf-8"?><xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"xmlns:dustin="http://marxsoftware.blogspot.com/foodxml"targetNamespace="http://marxsoftware.blogspot.com/foodxml"elementFormDefault="qualified"attributeFormDefault="unqualified"><xs:element name="Food"><xs:complexType><xs:sequence><xs:element name="Vegetable" type="dustin:Vegetable" /><xs:element ref="dustin:Fruit" /><xs:element name="Dessert" type="dustin:Dessert" /></xs:sequence></xs:complexType></xs:element><!--Direct simple type that restricts xs:string will become enum inJAXB-generated Java class.--><xs:simpleType name="Vegetable"><xs:restriction base="xs:string"><xs:enumeration value="Carrot"/><xs:enumeration value="Squash"/><xs:enumeration value="Spinach"/><xs:enumeration value="Celery"/></xs:restriction></xs:simpleType><!--Simple type that restricts xs:string but is wrapped in xs:element(making it an Element rather than a SimpleType) will become JavaString in JAXB-generated Java class for Elements that reference it.--><xs:element name="Fruit"><xs:simpleType><xs:restriction base="xs:string"><xs:enumeration value="Watermelon"/><xs:enumeration value="Apple"/><xs:enumeration value="Orange"/><xs:enumeration value="Grape"/></xs:restriction></xs:simpleType></xs:element><!--Direct simple type that restricts xs:string will become enum inJAXB-generated Java class.--><xs:simpleType name="Dessert"><xs:restriction base="xs:string"><xs:enumeration value="Pie"/><xs:enumeration value="Cake"/><xs:enumeration value="Ice Cream"/></xs:restriction></xs:simpleType></xs:schema>
Хотя Vegetable и Dessert элементы определены в схеме иначе , чем Fruit, в результате действительный XML то же самое. Действительный файл XML показан далее в листинге кода для food1.xml.
food1.xml
<?xml version="1.0" encoding="utf-8"?>
<Food xmlns="http://marxsoftware.blogspot.com/foodxml"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
<Vegetable>Spinach</Vegetable>
<Fruit>Watermelon</Fruit>
<Dessert>Pie</Dessert>
</Food>
На этом этапе я буду использовать простой скрипт Groovy для проверки вышеуказанного XML на соответствие вышеуказанному XSD. Код для этого скрипта проверки XML Groovy ( validateXmlAgainstXsd.groovy) показан далее.
validateXmlAgainstXsd.groovy
#!/usr/bin/env groovy
// validateXmlAgainstXsd.groovy
//
// Accepts paths/names of two files. The first is the XML file to be validated
// and the second is the XSD against which to validate that XML.
if (args.length < 2)
{
println "USAGE: groovy validateXmlAgainstXsd.groovy <xmlFile> <xsdFile>"
System.exit(-1)
}
String xml = args[0]
String xsd = args[1]
import javax.xml.validation.Schema
import javax.xml.validation.SchemaFactory
import javax.xml.validation.Validator
try
{
SchemaFactory schemaFactory =
SchemaFactory.newInstance(javax.xml.XMLConstants.W3C_XML_SCHEMA_NS_URI)
Schema schema = schemaFactory.newSchema(new File(xsd))
Validator validator = schema.newValidator()
validator.validate(new javax.xml.transform.stream.StreamSource(xml))
}
catch (Exception exception)
{
println "\nERROR: Unable to validate ${xml} against ${xsd} due to '${exception}'\n"
System.exit(-1)
}
println "\nXML file ${xml} validated successfully against ${xsd}.\n"
На следующем снимке экрана показано выполнение вышеуказанного скрипта Groovy XML для проверки food1.xmlи Food.xsd.
До сих пор целью этого поста было показать, как различные подходы в XSD могут привести к тому, что один и тот же XML будет действительным. Хотя эти разные подходы XSD предписывают один и тот же действительный XML, они приводят к разному поведению классов Java, когда JAXB используется для генерации классов на основе XSD. Следующий снимок экрана демонстрирует запуск JDK предоставленный JAXB XJC компилятор против Food.xsd генерировать классы Java.
Вывод из поколения JAXB, показанный выше, указывает, что классы Java были созданы для элементов «Vegetable» и «Dessert», но не для элемента «Fruit». Это потому, что «Овощ» и «Десерт» были определены иначе, чем «Фрукты» в XSD. Следующий листинг кода для Food.java класса, сгенерированного xjc компилятором. Из этого мы можем видеть, что сгенерированный Food.java класс ссылается на определенные сгенерированные типы Java для Vegetable и Dessert, но ссылается просто на общую строку Java для Fruit.
Food.java (генерируется JAXB JXC компилятором)
//
// This file was generated by the JavaTM Architecture for XML Binding(JAXB) Reference Implementation, v2.2.8-b130911.1802
// See <a href="http://java.sun.com/xml/jaxb">http://java.sun.com/xml/jaxb</a>
// Any modifications to this file will be lost upon recompilation of the source schema.
// Generated on: 2015.02.11 at 10:17:32 PM MST
//
package com.blogspot.marxsoftware.foodxml;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlSchemaType;
import javax.xml.bind.annotation.XmlType;
/**
* <p>Java class for anonymous complex type.
*
* <p>The following schema fragment specifies the expected content contained within this class.
*
* <pre>
* <complexType>
* <complexContent>
* <restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
* <sequence>
* <element name="Vegetable" type="{http://marxsoftware.blogspot.com/foodxml}Vegetable"/>
* <element ref="{http://marxsoftware.blogspot.com/foodxml}Fruit"/>
* <element name="Dessert" type="{http://marxsoftware.blogspot.com/foodxml}Dessert"/>
* </sequence>
* </restriction>
* </complexContent>
* </complexType>
* </pre>
*
*
*/
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "", propOrder = {
"vegetable",
"fruit",
"dessert"
})
@XmlRootElement(name = "Food")
public class Food {
@XmlElement(name = "Vegetable", required = true)
@XmlSchemaType(name = "string")
protected Vegetable vegetable;
@XmlElement(name = "Fruit", required = true)
protected String fruit;
@XmlElement(name = "Dessert", required = true)
@XmlSchemaType(name = "string")
protected Dessert dessert;
/**
* Gets the value of the vegetable property.
*
* @return
* possible object is
* {@link Vegetable }
*
*/
public Vegetable getVegetable() {
return vegetable;
}
/**
* Sets the value of the vegetable property.
*
* @param value
* allowed object is
* {@link Vegetable }
*
*/
public void setVegetable(Vegetable value) {
this.vegetable = value;
}
/**
* Gets the value of the fruit property.
*
* @return
* possible object is
* {@link String }
*
*/
public String getFruit() {
return fruit;
}
/**
* Sets the value of the fruit property.
*
* @param value
* allowed object is
* {@link String }
*
*/
public void setFruit(String value) {
this.fruit = value;
}
/**
* Gets the value of the dessert property.
*
* @return
* possible object is
* {@link Dessert }
*
*/
public Dessert getDessert() {
return dessert;
}
/**
* Sets the value of the dessert property.
*
* @param value
* allowed object is
* {@link Dessert }
*
*/
public void setDessert(Dessert value) {
this.dessert = value;
}
}
The advantage of having specific Vegetable and Dessert classes is the additional type safety they bring as compared to a general Java String. Both Vegetable.java and Dessert.java are actually enums because they come from enumerated values in the XSD. The two generated enums are shown in the next two code listings.
Vegetable.java (generated with JAXB xjc compiler)
//
// This file was generated by the JavaTM Architecture for XML Binding(JAXB) Reference Implementation, v2.2.8-b130911.1802
// See <a href="http://java.sun.com/xml/jaxb">http://java.sun.com/xml/jaxb</a>
// Any modifications to this file will be lost upon recompilation of the source schema.
// Generated on: 2015.02.11 at 10:17:32 PM MST
//
package com.blogspot.marxsoftware.foodxml;
import javax.xml.bind.annotation.XmlEnum;
import javax.xml.bind.annotation.XmlEnumValue;
import javax.xml.bind.annotation.XmlType;
/**
* <p>Java class for Vegetable.
*
* <p>The following schema fragment specifies the expected content contained within this class.
* <p>
* <pre>
* <simpleType name="Vegetable">
* <restriction base="{http://www.w3.org/2001/XMLSchema}string">
* <enumeration value="Carrot"/>
* <enumeration value="Squash"/>
* <enumeration value="Spinach"/>
* <enumeration value="Celery"/>
* </restriction>
* </simpleType>
* </pre>
*
*/
@XmlType(name = "Vegetable")
@XmlEnum
public enum Vegetable {
@XmlEnumValue("Carrot")
CARROT("Carrot"),
@XmlEnumValue("Squash")
SQUASH("Squash"),
@XmlEnumValue("Spinach")
SPINACH("Spinach"),
@XmlEnumValue("Celery")
CELERY("Celery");
private final String value;
Vegetable(String v) {
value = v;
}
public String value() {
return value;
}
public static Vegetable fromValue(String v) {
for (Vegetable c: Vegetable.values()) {
if (c.value.equals(v)) {
return c;
}
}
throw new IllegalArgumentException(v);
}
}
Dessert.java (generated with JAXB xjc compiler)
//
// This file was generated by the JavaTM Architecture for XML Binding(JAXB) Reference Implementation, v2.2.8-b130911.1802
// See <a href="http://java.sun.com/xml/jaxb">http://java.sun.com/xml/jaxb</a>
// Any modifications to this file will be lost upon recompilation of the source schema.
// Generated on: 2015.02.11 at 10:17:32 PM MST
//
package com.blogspot.marxsoftware.foodxml;
import javax.xml.bind.annotation.XmlEnum;
import javax.xml.bind.annotation.XmlEnumValue;
import javax.xml.bind.annotation.XmlType;
/**
* <p>Java class for Dessert.
*
* <p>The following schema fragment specifies the expected content contained within this class.
* <p>
* <pre>
* <simpleType name="Dessert">
* <restriction base="{http://www.w3.org/2001/XMLSchema}string">
* <enumeration value="Pie"/>
* <enumeration value="Cake"/>
* <enumeration value="Ice Cream"/>
* </restriction>
* </simpleType>
* </pre>
*
*/
@XmlType(name = "Dessert")
@XmlEnum
public enum Dessert {
@XmlEnumValue("Pie")
PIE("Pie"),
@XmlEnumValue("Cake")
CAKE("Cake"),
@XmlEnumValue("Ice Cream")
ICE_CREAM("Ice Cream");
private final String value;
Dessert(String v) {
value = v;
}
public String value() {
return value;
}
public static Dessert fromValue(String v) {
for (Dessert c: Dessert.values()) {
if (c.value.equals(v)) {
return c;
}
}
throw new IllegalArgumentException(v);
}
}
Having enums generated for the XML elements ensures that only valid values for those elements can be represented in Java.
Conclusion
JAXB makes it relatively easy to map Java to XML, but because there is not a one-to-one mapping between Java and XML types, there can be some cases where the generated Java type for a particular XSD prescribed element is not obvious. This post has shown how two different approaches to building an XSD to enforce the same basic XML structure can lead to very different results in the Java classes generated with the JAXB xjccompiler. In the example shown in this post, declaring elements in the XSD directly on simpleTypes restricting XSD’s string to a specific set of enumerated values is preferable to declaring elements as references to other elements wrapping a simpleType of restricted string enumerated values because of the type safety that is achieved when enums are generated rather than use of general Java Strings.