java - 使用XmlAdapter在JAXB生成的类中使用java.util.Locale

Question

问题：

根据Oracle提供的有关使用java.util.Locale的以下文档：[Internationalization: Understanding Locale in the Java Platform]，我有以下与JAXB和语言环境有关的问题。

我有一个看起来像这样的XML文件：

<?xml version="1.0" encoding="utf-8"?>
<dataschema>
  <delimited>
    <locale language="en" country="US" variant="SiliconValley" />
  </delimited>
</dataschema>

它基于以下XML模式：

<?xml version="1.0" encoding="utf-8" ?>
<xs:schema elementFormDefault="qualified" xmlns:xs="http://www.w3.org/2001/XMLSchema">
    <xs:element name="dataschema">
        <xs:complexType>
            <xs:choice>
                <xs:element minOccurs="1" maxOccurs="1" name="delimited" type="DelimitedSchemaType"/>
                <xs:element minOccurs="1" maxOccurs="1" name="fixedwidth" type="FixedWidthSchemaType"/>
            </xs:choice>
        </xs:complexType>
    </xs:element>
    <xs:complexType name="DelimitedSchemaType">
        <xs:sequence>
            <xs:element minOccurs="1" maxOccurs="1" name="locale" type="LocaleType"/>
        </xs:sequence>
    </xs:complexType>
    <xs:complexType name="FixedWidthSchemaType">
        <xs:sequence>
            <xs:element minOccurs="1" maxOccurs="1" name="locale" type="LocaleType"/>
        </xs:sequence>
    </xs:complexType>
    <xs:complexType name="LocaleType">
        <xs:attribute name="language" use="required">
            <xs:simpleType>
                <xs:restriction base="xs:string">
                    <xs:pattern value="[a-z]{2,3}"/>
                </xs:restriction>
            </xs:simpleType>
        </xs:attribute>
        <xs:attribute name="country" use="required">
            <xs:simpleType>
                <xs:restriction base="xs:string">
                    <xs:pattern value="[A-Z]{2}"/>
                </xs:restriction>
            </xs:simpleType>
        </xs:attribute>
        <xs:attribute name="variant" use="optional">
            <xs:simpleType>
                <xs:restriction base="xs:string">
                    <xs:pattern value="[A-Z]{2}"/>
                </xs:restriction>
            </xs:simpleType>
        </xs:attribute>
    </xs:complexType>
</xs:schema>

现在的问题是，我为LocaleType xml complexType获取了以下生成的类，该类似乎无法反映生成的DelimitedDataSchema类中的实际java.util.Locale数据类型。我曾希望这是java.util.Locale类型，而不是org.mylib.schema.LocaleType类型？

JAXB 2.x生成的类是：

Dataschema.java：

@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "", propOrder = {
    "delimited",
    "fixedwidth"
})
@XmlRootElement(name = "dataschema")
public class Dataschema {

    protected DelimitedDataSchema delimited;
    protected FixedWidthDataSchema fixedwidth;

    public DelimitedDataSchema getDelimited() {
        return delimited;
    }

    public void setDelimited(DelimitedDataSchema value) {
        this.delimited = value;
    }

    public FixedWidthDataSchema getFixedwidth() {
        return fixedwidth;
    }

    public void setFixedwidth(FixedWidthDataSchema value) {
        this.fixedwidth = value;
    }
}

DelimitedDataSchema.java：

@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "DelimitedSchemaType", propOrder = {
    "localeType"
})
public class DelimitedDataSchema {

    @XmlElement(required = true)
    protected LocaleType locale;

    public LocaleType getLocale() {
        return locale;
    }

    public void setLocale(LocaleType value) {
        this.locale = value;
    }
}

LocaleType：

@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "LocaleType")
public class LocaleType {

    @XmlAttribute(name = "language", required = true)
    protected String language;
    @XmlAttribute(name = "country", required = true)
    protected String country;
    @XmlAttribute(name = "variant")
    protected String variant;

    public String getLanguage() {
        return language;
    }

    public void setLanguage(String value) {
        this.language = value;
    }

    public String getCountry() {
        return country;
    }

    public void setCountry(String value) {
        this.country = value;
    }

    public String getVariant() {
        return variant;
    }

    public void setVariant(String value) {
        this.variant = value;
    }
}

我英勇地遵循了Blaise Doughan的以下博客文章中有关JAXB XmlAdapters的指示： JAXB and Package Level XmlAdapters以及 XmlAdapter - JAXB's Secret Weapon

因此，我自己创建了一个XmlAdapter，希望生成的类（DelimitedDataSchema）在getter中包含java.util.Locale返回数据类型，在setter中包含java.util.Locale参数数据类型。我错误地假设了。

LocaleXmlAdapter.java：

public class LocaleXmlAdapter extends XmlAdapter<org.mylib.schema.LocaleType, java.util.Locale> {
    @Override
    public java.util.Locale unmarshal(org.mylib.schema.LocaleType pSchemaLocale) throws Exception {
        if (pSchemaLocale == null) {
            throw new NullPointerException("LocaleXmlAdapter.unmarshal(...) received a NULL literal.");
        }

        java.util.Locale mLocale = null;
        String mLanguage = pSchemaLocale.getLanguage().toLowerCase();
        String mCountry = pSchemaLocale.getCountry().toUpperCase();
        String mVariant = pSchemaLocale.getVariant();

        if (mVariant == null) {
            mLocale = new java.util.Locale(mLanguage, mCountry);
        } else {
            mLocale = new java.util.Locale(mLanguage, mCountry, mVariant);
        }
        return mLocale;
    }

    @Override
    public org.mylib.schema.LocaleType marshal(java.util.Locale pJavaLocale) throws Exception {
        if (pJavaLocale == null) {
            throw new NullPointerException("LocaleXmlAdapter.marshal(...) received a NULL literal.");
        }

        org.mylib.schema.LocaleType mLocale = new org.mylib.schema.LocaleType();
        mLocale.setLanguage(pJavaLocale.getLanguage().toLowerCase());
        mLocale.setCountry(pJavaLocale.getCountry().toUpperCase());
        String mVariant = pJavaLocale.getVariant();
        if (mVariant != null) {
            mLocale.setVariant(mVariant);
        }

        return mLocale;
    }
}

为了让JAXB库知道它必须使用LocaleXmlAdapter，我为该库提供了一个外部绑定文件，其中为Locale类定义了LocaleXmlAdapter。

外部JAXB绑定文件：

<?xml version="1.0" encoding="utf-8"?>
<jaxb:bindings jaxb:version="2.1" xmlns:xs="http://www.w3.org/2001/XMLSchema"
               xmlns:jaxb="http://java.sun.com/xml/ns/jaxb"
               schemaLocation="dataschema.xsd" node="/xs:schema">

    <jaxb:schemaBindings>
        <jaxb:package name="org.mylib.schema">
            <jaxb:javadoc>
                Package level documentation for generated package org.mylib.schema.
            </jaxb:javadoc>
        </jaxb:package>
    </jaxb:schemaBindings>

    <jaxb:bindings node="//xs:complexType[@name='LocaleType']">
        <jaxb:class name="LocaleType"/>
        <jaxb:property>
            <jaxb:baseType name="org.mylib.schema.LocaleXmlAdapter"/>
        </jaxb:property>
    </jaxb:bindings>

    <jaxb:bindings node="//xs:complexType[@name='DelimitedSchemaType']">
        <jaxb:class name="DelimitedDataSchema"/>
    </jaxb:bindings>

    <jaxb:bindings node="//xs:complexType[@name='FixedWidthSchemaType']">
        <jaxb:class name="FixedWidthDataSchema"/>
    </jaxb:bindings>
</jaxb:bindings>

现在，我显然不会得到的怪异部分是，我期望JAXB库会将org.mylib.schema.LocaleType类型转换为DelimitedDataSchema类的java.util.Locale类型，因此您将请参见DelimitedDataSchema类中的以下方法签名：


公共java.util.Locale getLocale（）{}
公共无效setLocale（java.util.Locale值）{}


我要完成的工作是使用java.util.Locale数据类型而不是org.mylib.schema.LocaleType数据类型。如何在用户代码和JAXB生成的代码之间进行转换？我自己不能调用LocaleXmlAdapter类来为我翻译语言环境类型，这必须由JAXB库完成，但是我确实想调用：getLocale（）并返回一个java.util.Locale数据类型。

我究竟做错了什么'？

更新：

到目前为止，我发现不应使用 。相反，应该在绑定文件中使用 作为 的子元素。
我还错误地假定 必须在LocaleType节点下定义，这是不正确的。它必须在DelimitedSchemaType节点和FixedWidthSchemaType节点的元素节点下定义。像这样：

...
<jaxb:bindings node="//xs:complexType[@name='DelimitedSchemaType']">
    <jaxb:property>
        <jaxb:baseType>
            <xjc:javaType name="org.mylib.schema.LocaleType" adapter="org.mylib.schema.LocaleXmlAdapter"/>
        </jaxb:baseType>
    </jaxb:property>
</jaxb:bindings>
...

这应该是正确的，但是XJC编译器会以某种方式产生编译错误。
发生以下错误：

[ERROR] Error while parsing schema(s).Location [ file:/C:/IdeaProjects/JaxbMarshalling/src/main/resources/dataschema.xjb{25,113}].
com.sun.istack.SAXParseException2; systemId: file:/C:/IdeaProjects/JaxbMarshalling/src/main/resources/dataschema.xjb; lineNumber: 25; columnNumber: 113; compiler was unable to honor this conversion customization. It is attached to a wrong place, or its inconsistent with other bindings.
    at com.sun.tools.xjc.ErrorReceiver.error(ErrorReceiver.java:86)
    etc.

它一直在抱怨“编译器无法执行此转换自定义。它被附加到错误的位置，或与其他绑定不一致。”，而在绑定文件中没有发现错误。

我已经改进了绑定文件，但是仍然有些不正确。我无法查明“错误”的确切位置。

顺便说一句：我正在使用以下工具：


Oracle Java JDK 64位版本1.8.0_112-b15
xjc，版本2.2.8-b130911.1802（随附上述JDK）
maven3版本3.3.9
IntelliJ IDEA 2016.3版本163.7743.44
maven-jaxb2-plugin，版本0.13.1


由于我为此苦苦挣扎了几天，所以我开始了赏金计划。使用外部绑定文件和正确的注释真正解决问题的人会得到我的赏识。

Answer 1

这个问题/问题有几个缺陷，必须首先解决该问题才能成功回答问题/问题。
由于您要求提供详细的规范答案，以解决所有问题，因此这里是：

首先，一些观察：


DelimitedDataSchema.java和FixedWidthDataSchema.java都包含数据类型为org.mylib.schema.LocaleType的对象字段“ locale”，必须将其更正为java.util.Locale数据类型。
DelimitedDataSchema.java和FixedWidthDataSchema.java中的对象字段“语言环境”必须包含@XmlJavaTypeAdapter批注，现在该批注不存在。
DelimitedDataSchema.java和FixedWidthDataSchema.java中的对象字段“ locale”已经包含一个@XmlElement批注，该批注现在仅指定“ required”元素。它还必须包含“ type”元素。
待编组的“区域设置” xml数据是complexType数据结构，即：LocaleType，仅具有xs：string类型的三个属性。当前的Xml Java编译器（= XJC）（尚未）不支持将complexTypes处理为正确的注释。
外部绑定文件中的节点LocaleType包含错误定义的属性。 “ localeType”仅具有三个未定义的属性。
定义的LocaleXmlAdapter错误定义，应将其移至DelimitedDataSchema和FixedWidthDataSchema类的属性（xml元素）。
DelimitedDataSchema和FixedWidthDataSchema类中的字段/元素“ locale”的 声明丢失。
您尚未在问题中指定maven pom.xml文件。下次问您的问题时，也请包括此内容。它为想要尽可能精确地回答您的问题的用户提供了有价值的信息。即使是对于新求职者，如果他们也遇到了同样的问题，他们也会在您的帖子中找到所需的答案。尽可能完整。


第二，一些修改/添加：


您的XML Schema文件定义明确。因此，此文件中不需要修改。
您的绑定文件（datasource.jxb）确实包含缺陷。


为了纠正这些缺陷，请执行以下操作：


建议：将LocaleType的类名称重命名为XmlLocale，这样您就可以轻松地将XmlLocale.class和LocaleXmlAdapter.class匹配在一起，而不会在java.util.Locale和org.mylib.schema.Locale之间产生混淆（现在已将其重命名为org.mylib.schema.XmlLocale）
更正：完全删除元素和子元素，因为必须在LocaleType级别上指定这些元素和子元素，而不能在DelimitedSchemaType和FixedWidthSchemaType中指定“ locale”元素的级别。
更正：在complexType DelimitedSchemaType和FixedWidthSchemaType中定义一个子XPath节点，该节点表示在这些complexTypes中指定的“ locale”元素。
校正：在complextType DelimitedSchemaType和FixedWidthSchemaType内定义的'locale'元素节点下，放置 元素和子 元素。给属性命名。该名称可以与XML模式中指定的名称相同，但也可以使用不同的名称。如果您使用的名称与XML Schema的名称不同，请注意，对象字段的名称类似于 名称，而不是XML Schema元素名称。这也会影响getter和setter方法的名称。
更正：使用 名称定义属性的数据类型。所需对象字段数据类型的类型为java.util.Locale。这样就得到： 。您不要将org.mylib.schema.XmlLocale数据类型指定为名称！
另外：为了将@XmlJavaTypeAdapter添加到DelimitedDataSchema和FixedWidthDataSchema类中的元素“ locale”，通常可以使用 元素进行指定。但是由于Xml Java编译器（= XJC）尚未（尚未）处理以下类型的转换，
complexTypes和Java数据类型，您不能使用文档中所述的默认规范。这对于当前的XJC仍然不起作用：

<jaxb:baseType>
    <xjc:javaType name="org.mylib.schema.XmlLocale" adapter="org.mylib.schema.LocaleXmlAdapter"/>
</jaxb:baseType>

因此，您必须自己提供@XmlJavaTypeAdapter批注。这是jaxb2-basics-annotate插件 [link]派上用场的地方。使用此插件，您可以在Java类中的任何位置注释任何现有的Java注释：类级别，字段级别，方法级别等。
为了注释“ missing”注释，您必须设置一些内容，这些内容将在后面描述。
在绑定文件中，您必须指定以下设置：
a）在绑定文件的根目录中指定插件使用的名称空间（annox）；
b）在绑定文件的根目录中指定extensionBindingPrefixed；

<jaxb:bindings jaxb:version="2.1" xmlns:xs="http://www.w3.org/2001/XMLSchema"
    xmlns:jaxb="http://java.sun.com/xml/ns/jaxb"
    xmlns:annox="http://annox.dev.java.net"
    schemaLocation="dataschema.xsd" node="/xs:schema"
    jaxb:extensionBindingPrefixes="xjc annox">

c）使用元素指定首选注释。因为需要在DelimitedDataSchema和FixedWidthDataSchema类的对象字段“ locale”上指定适配器，所以必须在“ locale”的 节点内指定注释元素：

<jaxb:bindings node="//xs:complexType[@name='DelimitedSchemaType']">
    <jaxb:class name="DelimitedDataSchema"/>
    <jaxb:bindings node=".//xs:element[@name='locale']">
        <jaxb:property name="locale">
            <jaxb:baseType name="java.util.Locale" /> 
        </jaxb:property> 
        <annox:annotate target="field">
            @javax.xml.bind.annotation.adapters.XmlJavaTypeAdapter(value = org.mylib.schema.LocaleXmlAdapter.class)
        </annox:annotate>
    <jaxb:bindings> 
</jaxb:bindings>

对于FixedWidthSchemaType complexType同样。注意，必须指定FULL包名和类名，包括注释参数！
建议：确保已指定绑定文件中的所有节点并将其映射到XML Schema元素和属性。推荐这样做是因为在绑定文件中通过指定每个节点并为每个节点指定一个名称（可以与XML Schema名称相同或不同）。
您确保以自己喜欢的方式命名生成的类，字段，获取器/设置器。当有人决定重命名XML Schema名称时，这会阻止以后进行大量手动工作，这显然会导致Java类的重新编译以及与其他类不匹配的引用（手动
书面）类。例如：您手动编写的XmlAdapter类：LocaleXmlAdapter，它引用生成的XmlLocale类中的方法名称。您实际上所做的是使用一个绑定文件将XML模式名称与Java名称分离。这样可以节省很多
以后会遇到麻烦（请相信我：我已经在不同的开发团队中看到了很多次）！那只是浪费宝贵的时间和金钱。完全指定此绑定文件后，您只需采用XML Schema节点的名称，Java端就不会改变！

现在，您的绑定文件将生成以下完整的绑定文件：

<?xml version="1.0" encoding="utf-8"?>
<jaxb:bindings jaxb:version="2.1" xmlns:xs="http://www.w3.org/2001/XMLSchema"
       xmlns:jaxb="http://java.sun.com/xml/ns/jaxb"
       xmlns:annox="http://annox.dev.java.net"
       schemaLocation="dataschema.xsd" node="/xs:schema"
       jaxb:extensionBindingPrefixes="xjc annox">

    <jaxb:schemaBindings>
        <jaxb:package name="org.mylib.schema"/>
    </jaxb:schemaBindings>

    <jaxb:bindings node="//xs:complexType[@name='DelimitedSchemaType']">
        <jaxb:class name="DelimitedDataSchema"/>
        <jaxb:bindings node=".//xs:element[@name='locale']">
            <jaxb:property name="locale">
                <jaxb:baseType name="java.util.Locale" />
            </jaxb:property>
            <annox:annotate target="field">
                @javax.xml.bind.annotation.adapters.XmlJavaTypeAdapter(value = org.mylib.schema.LocaleXmlAdapter.class)
            </annox:annotate>
        </jaxb:bindings>
    </jaxb:bindings>

     <jaxb:bindings node="//xs:complexType[@name='FixedWidthSchemaType']">
        <jaxb:class name="FixedWidthDataSchema"/>
        <jaxb:bindings node=".//xs:element[@name='locale']">
            <jaxb:property name="locale">
                <jaxb:baseType name="java.util.Locale"/>
            </jaxb:property>
            <annox:annotate target="locale">
                @javax.xml.bind.annotation.adapters.XmlJavaTypeAdapter(value = org.mylib.schema.LocaleXmlAdapter.class)
            </annox:annotate>
        </jaxb:bindings>
    </jaxb:bindings>

    <jaxb:bindings node="//xs:complexType[@name='LocaleType']">
        <jaxb:class name="XmlLocale"/>
        <jaxb:bindings node=".//xs:attribute[@name='language']">
            <jaxb:property name="language"/>
        </jaxb:bindings>
        <jaxb:bindings node=".//xs:attribute[@name='country']">
            <jaxb:property name="country"/>
        </jaxb:bindings>
        <jaxb:bindings node=".//xs:attribute[@name='variant']">
            <jaxb:property name="variant"/>
        </jaxb:bindings>
    </jaxb:bindings>
</jaxb:bindings>

 3.未指定您的maven pom.xml文件，但为了完整
    此主题的概述，这里也提到。

使用maven生成JAXB类时，需要考虑一些事项。

为了做“正确的事情”，请执行以下操作：
   -由于JAXB XJC特定于您编译和运行的Java版本，因此应指定必须将其编译到的源Java版本和目标Java版本。这可以通过maven-compiler-plugin完成。
     现在，您可以指定版本1.8，而不是让XJC用默认级别1.5版编译Java类。

    <?xml version="1.0" encoding="UTF-8"?>
    <project xmlns="http://maven.apache.org/POM/4.0.0"
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
        <modelVersion>4.0.0</modelVersion>

        <groupId>org.mylib</groupId>
        <artifactId>mytool</artifactId>
        <version>1.0-SNAPSHOT</version>
        <packaging>jar</packaging>
        <name>project-name</name>

        <properties>
            <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        </properties>

        <build>
            <resources>
                <resource>
                    <directory>${pom.basedir}/src/main/resources</directory>
                </resource>
            </resources>

            <plugins>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-compiler-plugin</artifactId>
                    <version>3.6.0</version>
                    <configuration>
                        <source>1.8</source>
                        <target>1.8</target>
                    </configuration>
                </plugin>

                <plugin>
                    <groupId>org.jvnet.jaxb2.maven2</groupId>
                    <artifactId>maven-jaxb2-plugin</artifactId>
                    <version>0.13.1</version>
                    <executions>
                        <execution>
                            <phase>generate-sources</phase>
                            <goals>
                                <goal>generate</goal>
                            </goals>
                            <configuration>
                                <!-- allow specific vendor extension bindings (jaxb:extensionBindingPrefixes) -->
                                <extension>true</extension>
                                <!-- Generate lots of output (for debug purposes) -->
                                <verbose>true</verbose>
                                <locale>en</locale>
                                <specVersion>2.2</specVersion>
                                <schemaLanguage>XMLSCHEMA</schemaLanguage>

                                <schemaDirectory>src/main/resources</schemaDirectory>
                                <schemaIncludes>
                                    <schemaInclude>dataschema.xsd</schemaInclude>
                                </schemaIncludes>

                                <bindingDirectory>src/main/resources</bindingDirectory>
                                <bindingIncludes>
                                    <bindingInclude>dataschema.xjb</bindingInclude>
                                </bindingIncludes>

                                <generateDirectory>${project.build.directory}/generated-sources/jaxb2</generateDirectory>
                                <args>
                                    <!-- covered by the jaxb2-basics-annotate plugin (YOU ONLY NEED THIS ONE IN YOUR SITUATION!) -->
                                    <arg>-Xannotate</arg>
                                    <!-- covered by the jaxb2-basics-plugin -->
                                    <arg>-Xsimplify</arg>
                                    <arg>-XtoString</arg>
                                    <arg>-Xequals</arg>
                                    <arg>-XhashCode</arg>
                                </args>
                                <plugins>
                                    <!-- plugin for generated toString, hashCode, equals methods -->
                                    <plugin>
                                        <groupId>org.jvnet.jaxb2_commons</groupId>
                                        <artifactId>jaxb2-basics</artifactId>
                                        <version>1.11.1</version>
                                    </plugin>
                                    <!-- plugin for adding specified annotations (YOU ONLY NEED THIS ONE IN YOUR SITUATION!) -->
                                    <plugin>
                                        <groupId>org.jvnet.jaxb2_commons</groupId>
                                        <artifactId>jaxb2-basics-annotate</artifactId>
                                        <version>1.0.2</version>
                                    </plugin>
                                </plugins>
                            </configuration>
                        </execution>
                    </executions>
                </plugin>
            </plugins>
        </build>
    </project>

第三，一些结果（之前和之后）：

在绑定文件和maven pom.xml文件中进行修改之前执行maven编译阶段时，您最终得到以下DelimitedDataSchema类（显示了摘录）：

package org.mylib.schema;

import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlType;

@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "DelimitedSchemaType", propOrder = {
   "locale"
})
public class DelimitedDataSchema {

@XmlElement(required = true)
protected XmlLocale locale; // XmlLocale instead of Locale (java.util.Locale)

}

在对绑定文件和maven pom.xml文件进行修改之后执行maven编译阶段时，您最终得到以下DelimitedDataSchema类（显示了摘录）：

package org.mylib.schema;

import java.util.Locale;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlType;
import javax.xml.bind.annotation.adapters.XmlJavaTypeAdapter;

@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "DelimitedSchemaType", propOrder = {
    "locale"
})
public class DelimitedDataSchema {

    @XmlElement(required = true, type = XmlLocale.class)
    @XmlJavaTypeAdapter(LocaleXmlAdapter.class)
    protected Locale locale;

}   

结果很明显：使用上述解决方案即可实现所需的解决方案。
请注意，@ XmlElement现在包含一个额外的参数：type = XmlLocale.class。
请注意，@ XmlJavaTypeAdapter仅包含LocaleXmlAdapter.class参数。
您还可以不同地编写相同的情况，例如：

@XmlElement(required = true)
@XmlJavaTypeAdapter(type = XmlLocale, value = LocaleXmlAdapter.class)

哪个完全一样。但是请记住，您必须指定 ，因为对象字段必须定义为java.util.Locale。当前，这是完成此操作的唯一方法。您不能仅使用jaxb2-basics-annotate插件指定@XmlJavaTypeAdapter（type = XmlLocale，value = LocaleXmlAdapter.class）批注，因为对象字段属性随后不会更改为java.util.Locale数据类型。

我希望在不久的将来，Xml Java编译器（XJC）将支持complexTypes，并通过检查自定义编写的XmlAdapter参数和返回类型来区分被编组/解组的数据类型。

四，证据（编组和拆组）

有一句话说：“证明就是吃布丁”，意思是这样的：如果您创造了某种东西，并且看起来不错，那么唯一的办法就是知道它是否真的很好（即，它有效） ）通过测试。在这种情况下，将其进行编组/解组。
在布丁的情况下，品尝它是绝对可以确保食谱很棒的唯一方法！

Main.java：

package org.mylib;

import org.mylib.schema.Dataschema;
import org.mylib.schema.DelimitedDataSchema;
import org.mylib.schema.FixedWidthDataSchema;

import javax.xml.bind.JAXBContext;
import javax.xml.bind.JAXBException;
import javax.xml.bind.Unmarshaller;
import javax.xml.transform.stream.StreamSource;
import java.io.Reader;
import java.io.StringReader;

public class Main {

    public static void main(String[] args) throws Exception {
        Dataschema ds = null;

        Reader xmlFileDelimited = new StringReader("<dataschema>\n" +
                "  <delimited>\n" +
                "    <locale language=\"en\" country=\"us\" />\n" +
                "  </delimited>\n" +
                "</dataschema>");

        try {
            JAXBContext jc = JAXBContext.newInstance(Dataschema.class);
            Unmarshaller um = jc.createUnmarshaller();
            ds = (Dataschema) um.unmarshal(new StreamSource(xmlFileDelimited));
        } catch (JAXBException e) {
            e.printStackTrace();
        }

        if (ds == null) {
            throw new NullPointerException("null literal as output of marshaller!");
        }

        DelimitedDataSchema delimited = ds.getDelimited();
        FixedWidthDataSchema fixedwidth = ds.getFixedwidth();

        if (((fixedwidth == null) && (delimited == null)) || ((fixedwidth != null) && (delimited != null))) {
            throw new IllegalStateException("schemas cannot be both absent or be both present at the same time!"); // (because of <choice> xml schema)!
        }

        if (delimited != null) {
            // very primitive code for proving correctness
            System.out.println(delimited.getLocale().toString());
        }

        if (fixedwidth != null) {
            // very primitive code for proving correctness
            System.out.println(fixedwidth.getLocale().toString());
        }
    }
}

编组省略，即留给读者实施。

示例结束。

请注意，JAXB本身确实很好地使用LocaleXmlAdapter对org.mylib.schema.XmlLocale和java.util.Locale进行了编组和解组。因此，在这种情况下，麻烦者不是JAXB核心。 Xml Java编译器是尚未接受complexTypes的罪魁祸首。
这些是XJC当前的局限性/不足之处，并有望在不久的将来得到解决！

最后要考虑的问题：如果人迹罕至的地方无法带您到达目的地，那就走那条路。踏实和稳重是赢得比赛的关键！

一些脚注：
使用maven-compiler-plugin将源和目标编译器级别设置为1.8，而不是1.5（默认值）。

有关maven-compiler-plugin的重要说明：
“仅设置目标选项并不能保证您的代码实际在具有指定版本的JRE上运行。陷阱在于不希望使用的API，这些API仅存在于以后的JRE中，这会使您的代码在运行时失败，并出现链接错误。
为避免此问题，您可以将编译器的引导类路径配置为与目标JRE匹配，或者使用Animal Sniffer Maven插件来验证您的代码未使用意外的API。
同样，设置source选项不能保证您的代码实际在具有指定版本的JDK上编译。
要使用特定的JDK版本（与用于启动Maven的版本不同）来编译代码，请参阅使用不同的JDK进行编译的示例。”

参见： https://maven.apache.org/plugins/maven-compiler-plugin/examples/set-compiler-source-and-target.html

换句话说：如果要确保项目使用的是正确的Java版本，从而是正确的JAXB版本，请使用Animal Sniffer Maven插件。参见： http://www.mojohaus.org/animal-sniffer/animal-sniffer-maven-plugin/

就这样 ;）