简而言之

是否有任何 JAXB 绑定(bind)可以告诉 JAXB 代码生成器将 Java 类生成为 abstract 而不必在中将相应的 XML 类型标记为 abstract XSD?

描述

情况如下:

• 我在 XSD 中定义了一个模式:mySchema.xsd

• 我使用内联 JAXB 绑定(bind)(“内联”==“直接在模式中”)来指示应在其中生成 JAXB 类的包 (my.package.jaxb):

  <xs:annotation>
      <xs:appinfo>
          <jxb:schemaBindings>
              <jxb:package name="my.package.jaxb"/>
          </jxb:schemaBindings>
      </xs:appinfo>
  </xs:annotation>
  

• 我使用内联 JAXB 绑定(bind)来指示每个复杂类型的实现类的名称(在此示例中 my.package.impl.MyAbstractClass、my.package .impl.MyAClass 和 my.package.impl.MyBClass):

  <xs:complexType name="myAbstractType" abstract="true">
      <xs:annotation>
          <xs:appinfo>
              <jxb:class implClass="my.package.impl.MyAbstractClass"/>
          </xs:appinfo>
      </xs:annotation>
      ...
  </xs:complexType>
  
  <xs:complexType name="myAType">
      <xs:annotation>
          <xs:appinfo>
              <jxb:class implClass="my.package.impl.MyAClass"/>
          </xs:appinfo>
      </xs:annotation>
      <xs:complexContent>
          <xs:extension base="myAbstractType">
              ...
          </xs:extension>
      </xs:complexContent>
  </xs:complexType>
  
  <xs:complexType name="myBType">
      <xs:annotation>
          <xs:appinfo>
              <jxb:class implClass="my.package.impl.MyBClass"/>
          </xs:appinfo>
      </xs:annotation>
      <xs:complexContent>
          <xs:extension base="myAbstractType">
              ...
          </xs:extension>
      </xs:complexContent>
  </xs:complexType>
  

• 我从模式生成 JAXB 类。这导致:

  my.package.jaxb
     |- MyAbstractType
     |- MyAType (extends MyAbstractClass)
     |- MyBType (extends MyAbstractClass)
  

• 我自己写类:

  my.package.impl
     |- MyAbstractClass (extends MyAbstractType)
     |- MyAClass (extends MyAType)
     |- MyBClass (extends MyBType)
  

我这样做的原因是，通过这两个类层次结构，我可以将生成的代码 (my.package.jaxb.*) 与手册 (my .package.impl.*)。这样，当 XSD 发生变化时，我可以重新生成 my.package.jaxb.* 类并在我的手册 my.package.impl.* 中进行一些更改合并新行为的类。

到目前为止一切顺利。问题是在 MyAbstractClass 中我想定义一个抽象 方法...

protected abstract void doSomething();

...然后由 MyAClass 和 MyBClass 以不同方式实现。 但是，生成的 MyAType 和 MyBType 类现在有编译错误，因为它们没有声明为抽象但它们现在继承了一个抽象方法(注意它们都扩展了 MyAbstractClass)。

我不能在 XSD (abstract="true") 中将它们声明为抽象的，因为这样做会在我声明 myAType 类型的元素时导致以下错误或 XML 中的 myBType:

cvc-type.2: The type definition cannot be abstract for element someElementName.

我想要的是使用一些 JAXB 绑定(bind)来告诉 JAXB 代码生成器生成类 MyAType 和 MyBType 作为 abstract < em="">而不必将 XML 类型标记为 abstract。有这样的绑定(bind)吗？到目前为止我还没有找到它。

抱歉解释得太长了，在此先感谢您。

最佳答案

我最终创建了一个 XJC plugin .这是代码:

import java.lang.reflect.Method;

import javax.xml.namespace.QName;

import org.xml.sax.ErrorHandler;
import org.xml.sax.SAXException;

import com.sun.codemodel.JMod;
import com.sun.codemodel.JMods;
import com.sun.tools.xjc.Options;
import com.sun.tools.xjc.outline.ClassOutline;
import com.sun.tools.xjc.outline.Outline;
import com.sun.tools.xjc.reader.xmlschema.bindinfo.BIDeclaration;
import com.sun.tools.xjc.reader.xmlschema.bindinfo.BindInfo;
import com.sun.xml.xsom.XSAnnotation;

public class AbstractModifierPlugin extends com.sun.tools.xjc.Plugin {

    private static final QName ABSTRACT_QNAME = new QName("http://www.example.com/jaxb/abstract-modifier/1-0", "abstract");

    private static final String SET_FLAG_METHOD_NAME = "setFlag";

    private static final String OPTION_NAME = "Xabstract-modifier";

    @Override
    public String getOptionName() {
        return OPTION_NAME;
    }

    @Override
    public String getUsage() {
        return " -" + OPTION_NAME + " : marks as abstract the generated classes corresponding to XML types marked with "
                + "<xs:annotation><xs:appinfo><" + ABSTRACT_QNAME + "/></xs:appinfo></xs:annotation>";
    }

    @Override
    public boolean run(Outline outline, Options options, ErrorHandler errorHandler) throws SAXException {
        Method setFlagMethod = null;
        try {
            // There is no method to make a class abstract; we can only use setFlag, which is private, so
            // we must get it via reflection and make it accessible.
            setFlagMethod = JMods.class.getDeclaredMethod(SET_FLAG_METHOD_NAME, int.class, boolean.class);
            setFlagMethod.setAccessible(true);
        } catch (Throwable e) {
            System.err.println("There was an error retrieving the " + JMods.class.getName() + "." + SET_FLAG_METHOD_NAME
                    + " method (see below) => it will not be possible to set any class' abstract flag => this plugin will abort");
            e.printStackTrace();
            return false;
        }

        for (ClassOutline classOutline : outline.getClasses()) {
            if (hasAbstractAnnotation(classOutline)) {
                try {
                    setFlagMethod.invoke(classOutline.implClass.mods(), JMod.ABSTRACT, true);
                } catch (Throwable e) {
                    System.err.println("It was not possible to make " + classOutline.implClass.fullName()
                            + " abstract (see below)");
                    e.printStackTrace();
                }
            }
        }
        return true;
    }

    protected boolean hasAbstractAnnotation(ClassOutline classOutline) {
        XSAnnotation annotation = classOutline.target.getSchemaComponent().getAnnotation();
        if (annotation != null) {
            Object innerAnnotation = annotation.getAnnotation();
            if (innerAnnotation instanceof BindInfo) {
                for (BIDeclaration bindInfoDeclaration : (BindInfo) innerAnnotation) {
                    if (ABSTRACT_QNAME.equals(bindInfoDeclaration.getName())) {
                        return true;
                    }
                }
            }
        }
        return false;
    }

}

这是 abstract.xsd ，它定义了 <abstract>您需要使用的元素来指示生成的类应该是抽象的:

<?xml version="1.0" encoding="UTF-8"?>
<schema xmlns="http://www.w3.org/2001/XMLSchema"
    targetNamespace="http://www.example.com/jaxb/abstract-modifier/1-0"
    xmlns:tns="http://www.example.com/jaxb/abstract-modifier/1-0"
    elementFormDefault="qualified">

    <element name="abstract"/>

</schema>

用法(按照我原来问题中的例子):

<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
    ...
    xmlns:abstract="http://www.example.com/jaxb/abstract-modifier/1-0"
    ...>

    <xs:complexType name="myAbstractType" abstract="true">
        <xs:annotation>
            <xs:appinfo>
                <jxb:class implClass="my.package.impl.MyAbstractClass"/>
            </xs:appinfo>
        </xs:annotation>
        ...
    </xs:complexType>

    <xs:complexType name="myAType">
        <xs:annotation>
            <xs:appinfo>
                <jxb:class implClass="my.package.impl.MyAClass"/>
                <!-- This tells the AbstractModifierPlugin to make the
                generated class abstract -->
                <abstract:abstract/>
            </xs:appinfo>
        </xs:annotation>
        <xs:complexContent>
            <xs:extension base="myAbstractType">
                ...
            </xs:extension>
        </xs:complexContent>
    </xs:complexType>

    <xs:complexType name="myBType">
        <xs:annotation>
            <xs:appinfo>
                <jxb:class implClass="my.package.impl.MyBClass"/>
                <!-- This tells the AbstractModifierPlugin to make the
                generated class abstract -->
                <abstract:abstract/>
            </xs:appinfo>
        </xs:annotation>
        <xs:complexContent>
            <xs:extension base="myAbstractType">
                ...
            </xs:extension>
        </xs:complexContent>
    </xs:complexType>

我不得不说，我发现很难找到所有必要的文档来弄清楚如何做到这一点。如果我有时间，我会在这里发布更长的解释；现在我希望至少代码会有所帮助。 免责声明:我不知道这是否是执行此操作的最佳方法，但我不得不依赖的类的文档记录非常松散(恕我直言，设计不是很好)这是我能想到的最好方法。

希望对您有所帮助。如果有人想使用此代码，请继续。

关于xml - 用于从非抽象 XML 类型生成抽象 Java 类的 JAXB 绑定(bind)，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/30192253/