JAXB द्वारा उत्पन्न कोई @XmlRootElement नहीं है

Question

मैं FpML (वित्तीय उत्पाद मार्कअप भाषा) संस्करण 4.5 से जावा कक्षाएं उत्पन्न करने की कोशिश कर रहा हूं। एक टन कोड उत्पन्न होता है, लेकिन मैं इसका उपयोग नहीं कर सकता। एक सरल दस्तावेज़ प्राप्त करने की कोशिश कर रहा हूँ जो मुझे यह मिलता है:

javax.xml.bind.MarshalException
  - with linked exception: [com.sun.istack.SAXException2: unable
  to marshal type
  "org.fpml._2008.fpml_4_5.PositionReport"
  as an element because it is missing an
  @XmlRootElement annotation]

वास्तव में किसी भी वर्ग के पास @XmlRootElement एनोटेशन नहीं है, तो मैं क्या गलत कर सकता हूं? मैं xjc (JAXB 2.1) को इंगित कर रहा हूँ fpml-main-4-5.xsd, जिसमें तब सभी प्रकार शामिल हैं।

Answer 1

एक साथ टाई करने के लिए जो दूसरों ने पहले ही बता दिया है या संकेत दिया है, वह नियम जिनके द्वारा JAXB XJC यह तय करता है कि @XmlRootElementएनोटेशन को एक उत्पन्न वर्ग पर रखा जाए या नहीं, यह गैर तुच्छ है ( इस लेख को देखें )।

@XmlRootElementमौजूद है क्योंकि JAXB रनटाइम को दिए गए ऑब्जेक्ट को विशेष रूप से XML तत्व नाम और नामस्थान को मार्शल / अनमरश करने के लिए कुछ जानकारी की आवश्यकता होती है। आप किसी पुराने ऑब्जेक्ट को मार्शल के पास नहीं भेज सकते। @XmlRootElementयह जानकारी प्रदान करता है।

एनोटेशन सिर्फ एक सुविधा है, हालांकि - JAXB को इसकी आवश्यकता नहीं है। JAXBElementरैपर ऑब्जेक्ट्स का उपयोग करने का विकल्प है , जो एक ही जानकारी प्रदान करते हैं @XmlRootElement, लेकिन एक एनोटेशन के बजाय ऑब्जेक्ट के रूप में।

हालाँकि, JAXBElementऑब्जेक्ट निर्माण के लिए अजीब हैं, क्योंकि आपको एक्सएमएल तत्व नाम और नामस्थान को जानने की जरूरत है, जो कि व्यापार तर्क आमतौर पर नहीं करता है।

शुक्र है, जब XJC एक वर्ग मॉडल बनाता है, तो यह एक वर्ग भी उत्पन्न करता है जिसे कहा जाता है ObjectFactory। यह आंशिक रूप से JAXB v1 के साथ पश्चगामी संगतता के लिए है, लेकिन यह एक्सजेसी के लिए एक जगह के रूप में उत्पन्न कारखाने के तरीकों को लगाने के लिए भी है जो JAXBElementआपकी खुद की वस्तुओं के आसपास रैपर बनाते हैं। यह आपके लिए XML नाम और नाम स्थान को संभालता है, इसलिए आपको इसके बारे में चिंता करने की आवश्यकता नहीं है। आपको केवल उन ObjectFactoryतरीकों को देखने की ज़रूरत है (और बड़े स्कीमा के लिए, उनमें से सैकड़ों हो सकते हैं) जिस पर आपकी ज़रूरत है।

Comments

विशेष मामला समाधान: जब आप वर्ग पीढ़ी के लिए उपयोग किए गए xsd को संशोधित कर सकते हैं: इस उत्तर में दिए गए लिंक को पढ़ने के बाद मेरे मामले में समाधान कक्षाओं को उत्पन्न करने के लिए उपयोग की गई xsd फ़ाइल को संशोधित करना था: मैंने रूट तत्व की परिभाषा को बदल दिया है a एक प्रकार से अलग प्रकार से संदर्भ का उपयोग करने के बजाय इनलाइन परिभाषा। ये JAXB को इस तत्व को @XmlRootElement के रूप में सेट करने की अनुमति देता है, जो उस एलिमेंट के साथ संभव नहीं था, जो रूट एलिमेंट के लिए पहले इस्तेमाल किया गया था।

— आर्थर

<scowl> जड़ तत्व को इनलाइन प्रकार का बदलना, हालांकि, सभी वर्गों को मूल प्रकार के आंतरिक वर्ग बनाता है। इसके अलावा, भले ही रूट तत्व प्रकार को मूल तत्व के रूप में परिभाषित किया गया हो (जाहिरा तौर पर स्कीमा द्वारा अनुमति दी गई), JAXB अभी भी @XmlRootElement के साथ एनोटेट नहीं करेगा।

— पावेल वेसलोव

यानी new ObjectFactory().createPositionReport(positionReport)रिटर्नJAXBElement<PositionReport>

— vikingsteve

क्या होगा यदि उत्पन्न ऑब्जेक्टफैक्टरी विधि एक विधि नहीं बनाती है जो तर्क को एक में लपेटती है JXBElement? मेरे मामले में, फैक्टरी विधि 0-एरीटी है और बस एक newवस्तु लौटाती है । (कुछ वर्गों को JAXBElement रैपर हेल्पर्स और अन्य क्यों नहीं दिए जाते हैं?) मुझे लगता है कि उस स्थिति में हमें स्वयं रैपर बनाना होगा?

— कार्ल जी

@CarlG मैं एक ही स्थिति में हूँ - कोई XmlRootElement और न ही JAXBElement मेरी कक्षाओं में दिखाई देता है। क्या आपने इस मामले का हल ढूंढ लिया है?

— मिकेल मारक

Answer 2

यह पहले से ही जुड़े ब्लॉग पोस्ट के निचले भाग में उल्लिखित है, लेकिन यह मेरे लिए एक उपचार की तरह काम करता है:

Marshaller marshaller = jc.createMarshaller();
marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, Boolean.TRUE);
marshaller.marshal(new JAXBElement<MyClass>(new QName("uri","local"), MyClass.class, myClassInstance), System.out);

Comments

मैं चिह्नित उत्तर पसंद करता हूं, लेकिन यह मेरे लिए भी काम करता है।

— पेड्रो डूसो

jcउपरोक्त स्निपेट में क्या है ?

— अरुण

@ अरुणराज यह JAXBContext क्लास है

— गर्नार्ड

Answer 3

जैसा कि उपरोक्त उत्तरों में से एक में संकेत दिया गया है, आपको अपने मूल तत्व पर XMLRootElement नहीं मिलेगा यदि XSD में इसका प्रकार एक नामित प्रकार के रूप में परिभाषित किया गया है, क्योंकि उस प्रकार का नाम आपके XSD में कहीं और इस्तेमाल किया जा सकता है। इसके बजाय, इसे एक अनाम प्रकार के रूप में बदलने की कोशिश करें:

<xsd:element name="myRootElement" type="MyRootElementType" />

<xsd:complexType name="MyRootElementType">
...
</xsd:complexType>

आप होंगे:

<xsd:element name="myRootElement">
    <xsd:complexType>
    ...
    <xsd:complexType>
</xsd:element>

Comments

मेरे लिए यह सच नहीं है। मेरा प्रकार अनाम है (मेरे मूल तत्व के अंदर एम्बेडेड) और कोई XmlRootElement एनोटेशन उत्पन्न नहीं हुआ है। कोई उपाय?

— मिकेल मार्राचे

Answer 4

@XmlRootElement को अनमर्सहॉलिंग के लिए आवश्यक नहीं है - यदि कोई अनमैर्सहेलर # अनमर्सहॉल के 2 पैरामीटर फॉर्म का उपयोग करता है।

इसलिए, अगर करने के बजाय:

UserType user = (UserType) unmarshaller.unmarshal(new StringReader(responseString));

एक करना चाहिए:

JAXBElement<UserType> userElement = unmarshaller.unmarshal(someSource, UserType.class);
UserType user = userElement.getValue();

बाद वाले कोड को UserType वर्ग स्तर पर @XmlRootElement एनोटेशन की आवश्यकता नहीं होगी।

Comments

क्या आप किसी वस्तु को मार्शल करने के लिए समान रूप से सुरुचिपूर्ण तरीके से जानते हैं जिसमें XmlRootElement नहीं है - इसे एक JAXBElement में लपेटे बिना, जैसा कि स्केफमैन, गर्नार्ड एट अल द्वारा उल्लेख किया गया है।

— क्रिस

+1 पूरी तरह से काम करता है! अधिक स्पष्टता के लिए एक संपादन ... आपके समाधान में 'someSource' बहुत अस्पष्ट शब्द है। विस्तृत करने के लिए: JAXBElement <TargetClazz> root = unmarshaller.unmarshal (नई StreamSource (नई फ़ाइल ("some.xml")), TargetClazz.class);

— सुपरनोवा

'SomeSource' का और विस्तार:String pathname = "file.xml"; InputStream stream = new FileInputStream(pathname); JAXBContext jaxbContext = JAXBContext.newInstance(UserType.class); Unmarshaller jaxbUnmarshaller = jaxbContext.createUnmarshaller(); XMLInputFactory factory = XMLInputFactory.newInstance(); XMLEventReader someSource = factory.createXMLEventReader(stream); JAXBElement<UserType> userElement = jaxbUnmarshaller.unmarshal(someSource, UserType.class); UserType user = userElement.getValue();

— स्टीव पिचर्स

Answer 5

जो का जवाब (जो जून 26 '09 पर 17:26) मेरे लिए करता है। इसका सरल उत्तर यह है कि यदि आप JAXBElement को मार्शल करते हैं तो @XmlRootElement एनोटेशन की अनुपस्थिति कोई समस्या नहीं है। जो चीज़ मुझे भ्रमित करती है, वह है उत्पन्न की गई ऑब्जेक्टफैक्ट्री में 2 createMyRootElement विधियां हैं - पहला कोई पैरामीटर नहीं लेता है और अलिखित ऑब्जेक्ट देता है, दूसरा अलिखित ऑब्जेक्ट लेता है और इसे एक JAXBElement में लिपटे देता है, और JAXBElement ठीक काम करता है। यहां मैंने जो मूल कोड का उपयोग किया है (मैं इसके लिए नया हूं, इसलिए क्षमा चाहता हूं कि यदि कोड इस उत्तर में सही ढंग से फ़ॉर्मेट नहीं किया गया है), तो मोटे तौर पर लिंक टेक्स्ट से प्रतिबंधित किया गया है :

ObjectFactory objFactory = new ObjectFactory();
MyRootElement root = objFactory.createMyRootElement();
...
// Set root properties
...
if (!writeDocument(objFactory.createMyRootElement(root), output)) {
    System.err.println("Failed to marshal XML document");
}
...

private boolean writeDocument(JAXBElement document, OutputStream output) {

  Class<?> clazz = document.getValue().getClass();
  try {
    JAXBContext context =
        JAXBContext.newInstance(clazz.getPackage().getName());
    Marshaller m = context.createMarshaller();
    m.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, Boolean.TRUE);
    m.marshal(document, output);
    return true;

  } catch (JAXBException e) {
    e.printStackTrace(System.err);
    return false;
  }
}

Comments

मेरे पास एक ऐसा मामला है जहां मेरा ऑब्जेक्टफैक्ट क्लास केवल उन तरीकों को परिभाषित करता है जो नियमित उदाहरणों को वापस करते हैं न कि JAXBElement के उदाहरणों को ...

— मिकेल मार्राचे

Answer 6

आप XSD में बेस टाइप्स के लिए @XmlRootElement Classes कैसे जेनरेट करें, इसका उपयोग करके आप इस समस्या को ठीक कर सकते हैं ? ।

यहाँ मावेन के साथ एक उदाहरण दिया गया है

        <plugin>
            <groupId>org.codehaus.mojo</groupId>
            <artifactId>jaxb2-maven-plugin</artifactId>
            <version>1.3.1</version>
            <executions>
                <execution>
                    <id>xjc</id>
                    <goals>
                        <goal>xjc</goal>
                    </goals>
                </execution>
            </executions>
            <configuration>
                <schemaDirectory>src/main/resources/xsd</schemaDirectory>
                <packageName>com.mycompany.schemas</packageName>
                <bindingFiles>bindings.xjb</bindingFiles>
                <extension>true</extension>
            </configuration>
        </plugin>

यहाँ binding.xjbफ़ाइल सामग्री है

<?xml version="1.0"?>
<jxb:bindings version="1.0" xmlns:jxb="http://java.sun.com/xml/ns/jaxb"
              xmlns:xjc= "http://java.sun.com/xml/ns/jaxb/xjc"
              jxb:extensionBindingPrefixes="xjc" xmlns:xs="http://www.w3.org/2001/XMLSchema">
    <jxb:bindings schemaLocation="path/to/myschema.xsd" node="/xs:schema">
        <jxb:globalBindings>
            <xjc:simple/>
        </jxb:globalBindings>
    </jxb:bindings>
</jxb:bindings>

Comments

दरअसल, बाइंडिंग.xjb फाइल में <xjc: simple> का उपयोग कर चाल चली गई। यदि आप अपने मार्शलिंग कोड या अपने WSDL को बदलना नहीं चाहते हैं तो बहुत बढ़िया समाधान। ध्यान दें कि xjc: सरल संग्रह पाने वालों के लिए अलग-अलग विधि के नाम (बहुवचन) उत्पन्न करता है (उदाहरण के लिए getOrder के बजाय getOrders)

— dvtoever

Answer 7

जैसा कि आप जानते हैं कि उत्तर ObjectFactory () का उपयोग करना है। यहाँ उस कोड का एक नमूना है जो मेरे लिए काम करता है :)

ObjectFactory myRootFactory = new ObjectFactory();

MyRootType myRootType = myRootFactory.createMyRootType();

try {

        File file = new File("./file.xml");
        JAXBContext jaxbContext = JAXBContext.newInstance(MyRoot.class);
        Marshaller jaxbMarshaller = jaxbContext.createMarshaller();

        //output pretty printed
        jaxbMarshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);

        JABXElement<MyRootType> myRootElement = myRootFactory.createMyRoot(myRootType);

        jaxbMarshaller.marshal(myRootElement, file);
        jaxbMarshaller.marshal(myRootElement, System.out);

    } catch (JAXBException e) {
        e.printStackTrace();
    }

Comments

अपनी बात के लिए ... मैं JAXBElement का उपयोग कैसे करूँ <?> बनाएँ ... () नेस्टेड तत्वों के लिए ObjectFactory से तरीके? यानी: <SOAP-ENV: Header> <wsse: Security> <wsse: UsernameToken> </ wsse: UsernameToken> </ wsse: सुरक्षा> </ SOAP-ENV: हैडर> मुझे मिलता है: "marshal प्रकार" में असमर्थ "UsernameTokenType" एक तत्व के रूप में क्योंकि यह एक @ xmlRootElement एनोटेशन याद कर रहा है "

— एंजेलिना

Answer 8

यह हमारे लिए भी काम नहीं कर रहा है। लेकिन हमें एक व्यापक रूप से उद्धृत लेख मिला जो कुछ पृष्ठभूमि जोड़ता है ... मैं इसे अगले व्यक्ति की खातिर यहां लिंक करूंगा: http://weblogs.java.net/blog/kohsuke/archive/2006/03 /why_does_jaxb_p.html

Comments

इसने मेरे लिए अच्छा काम किया, धन्यवाद। मैंने यह भी पाया कि मैं इसके माध्यम से जाने की प्रक्रिया में गलत JAXB ऑब्जेक्ट (जैसा मैंने सोचा था कि रूट नहीं) की नकल कर रहा था। मैं एक JAXBElement बनाना भूल गया और बाध्यकारी ऑब्जेक्ट से प्राप्त ऑब्जेक्ट क्लास से बस लौटी हुई वस्तु को मार्शल करने की कोशिश कर रहा था। यह मूल रूप से पूरी तरह से समस्या का ध्यान रखता था (यदि कोई और भी उसी समस्या के खिलाफ चलता है)।

— जो बैन

404: "हमें खेद है कि java.net साइट बंद हो गई है। पहले java.net पर होस्ट किए गए अधिकांश ओपन सोर्स प्रोजेक्ट्स को स्थानांतरित कर दिया गया है।"

— ट्रिस्टन

web.archive.org/web/20070812073809/http://weblogs.java.net/blog/…

— D-Klotz

Answer 9

दो दिनों के लिए sruggling के बाद मैंने पाया problem.You के लिए समाधान का उपयोग कर सकते ObjectFactory वर्ग है जो नहीं है के लिए वैकल्पिक हल के लिए कक्षा @XmlRootElement । ObjectFactory ने JAXBElement के चारों ओर इसे लपेटने के लिए ओवरलोड तरीके हैं।

विधि: 1 वस्तु का सरल निर्माण करता है।

विधि: 2 ऑब्जेक्ट को @JAXBElement के साथ लपेटेगा ।

हमेशा javax.xml.bind.MarshalException से बचने के लिए विधि का उपयोग करें - लिंक किए गए अपवाद के साथ एक @ xmlRootElement एनोटेशन गायब है।

कृपया नीचे दिए गए सैंपल कोड को देखें

विधि: 1 वस्तु का सरल निर्माण करता है

public GetCountry createGetCountry() {
        return new GetCountry();
    }

विधि: 2 ऑब्जेक्ट को @JAXBElement के साथ लपेटेगा ।

 @XmlElementDecl(namespace = "my/name/space", name = "getCountry")
 public JAXBElement<GetCountry> createGetCountry(GetCountry value) {
        return new JAXBElement<GetCountry>(_GetCountry_QNAME, GetCountry.class, null, value);
    }

काम कोड नमूना:

ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
WebServiceTemplate springWSTemplate = context.getBean(WebServiceTemplate.class);

GetCountry request = new GetCountry();
request.setGuid("test_guid");

JAXBElement<GetCountryResponse> jaxbResponse = (JAXBElement<GetCountryResponse>)springWSTemplate .marshalSendAndReceive(new ObjectFactory().createGetCountry(request));

GetCountryResponse response = jaxbResponse.getValue();

Comments

वसंत webservice टेम्पलेट के साथ कोड संदर्भ देने के लिए धन्यवाद, जैसा कि काफी समय से यह पता लगाने के लिए संघर्ष कर रहा था!

— RRR_J

Answer 10

यदि इस समस्या का मेरा अनुभव किसी को यूरेका देता है! पल .. मैं निम्नलिखित जोड़ देंगे:

मुझे यह समस्या भी हो रही थी, जब मैंने एक xsd फ़ाइल का उपयोग किया था जिसे मैंने IntelliJ के "जेनरेट xsd से इंस्टेंस दस्तावेज़" मेनू विकल्प का उपयोग करके उत्पन्न किया था।

जब मैंने इस टूल के सभी डिफॉल्ट्स को स्वीकार कर लिया, तो इसने एक xsd फाइल जेनरेट की, जब jaxb के साथ प्रयोग किया जाता है, तो बिना java फाइल जेनरेट किए @XmlRootElement। जब मैंने मार्शल की कोशिश की तो मुझे इस प्रश्न में चर्चा के समान अपवाद मिला।

मैं IntellJ टूल में वापस गया, और "Desgin Type" ड्रॉप डाउन में डिफ़ॉल्ट विकल्प को देखा (जो मुझे समझ नहीं आया था .. और फिर भी अगर मैं ईमानदार हूं तो नहीं था):

Desgin प्रकार:

"स्थानीय तत्व / वैश्विक जटिल प्रकार"

मैंने इसे बदल दिया

"स्थानीय तत्व / प्रकार"

, अब यह एक (काफी) अलग xsd उत्पन्न करता है, जो @XmlRootElementजब jaxb के साथ प्रयोग किया जाता है। यह नहीं कह सकता कि मैं इसके बारे में और बाहर समझता हूँ, लेकिन इसने मेरे लिए काम किया।

Answer 11

मावेन बिल्ड के साथ, आप @XmlRootElementएनोटेशन जोड़ सकते हैं

" jaxb2-basics-annotate" प्लग-इन के साथ।

अधिक जानकारी देखें: देखें

JAXB का उपयोग करके XML स्कीमा से कक्षाएं उत्पन्न करने के लिए मावेन को कॉन्फ़िगर करें

और JAXB XJC कोड जनरेशन

Answer 12

JAXBElement रैपर उन मामलों के लिए काम करता है, जहाँ @XmlRootElementJAXB द्वारा कोई जनरेट नहीं किया गया है। ये रैपर ObjectFactoryद्वारा उत्पन्न वर्ग में उपलब्ध हैं maven-jaxb2-plugin। उदाहरण के लिए:

     public class HelloWorldEndpoint {
        @PayloadRoot(namespace = NAMESPACE_URI, localPart = "person")
        @ResponsePayload
        public JAXBElement<Greeting> sayHello(@RequestPayload JAXBElement<Person> request) {

        Person person = request.getValue();

        String greeting = "Hello " + person.getFirstName() + " " + person.getLastName() + "!";

        Greeting greet = new Greeting();
        greet.setGreeting(greeting);

        ObjectFactory factory = new ObjectFactory();
        JAXBElement<Greeting> response = factory.createGreeting(greet);
        return response;
      }
 }

Answer 13

क्या आपने अपने xsd को इस तरह बदलने की कोशिश की?

<!-- create-logical-system -->
<xs:element name="methodCall">
  <xs:complexType>
    ...
  </xs:complexType>
</xs:element>

Comments

इसने मेरे लिए JDK 1.7u71 के साथ काम किया। एक शीर्ष स्तर के तत्व को xjc द्वारा @XmlRootElement सौंपा गया है। प्रारंभ में मेरे पास केवल एक शीर्ष स्तरीय जटिल प्रकार था। एक JAXBElement में लपेटने के बाद सादे बदसूरत है।

— सर्ज मेरालियाकोव

Answer 14

इसे सॉल्व करने के लिए आपको wsimport के साथ संकलन करने से पहले एक xml बाइंडिंग को कॉन्फ़िगर करना चाहिए, जिससे जेनरेटमेंटप्रॉपर्टी को असत्य के रूप में सेट किया जा सके।

     <jaxws:bindings wsdlLocation="LOCATION_OF_WSDL"
      xmlns:jaxws="http://java.sun.com/xml/ns/jaxws"
      xmlns:xjc="http://java.sun.com/xml/ns/jaxb/xjc" 
      xmlns:xs="http://www.w3.org/2001/XMLSchema"
      xmlns:jxb="http://java.sun.com/xml/ns/jaxb"
      xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/">
         <jaxws:enableWrapperStyle>false</jaxws:enableWrapperStyle>
    <jaxws:bindings  node="wsdl:definitions/wsdl:types/xs:schema[@targetNamespace='NAMESPACE_OF_WSDL']">
      <jxb:globalBindings xmlns:jxb="http://java.sun.com/xml/ns/jaxb" xmlns:xs="http://www.w3.org/2001/XMLSchema">
            <xjc:generateElementProperty>false</xjc:generateElementProperty> 
      </jxb:globalBindings>
  </jaxws:bindings>
</jaxws:bindings>

Comments

रैपिंग टैग होना चाहिए<jaxb:bindings> ... <jaxws:bindings> ... </jaxws:bindings> ... </jaxb:bindings>

— एलिओपी

Answer 15

विषय काफी पुराना है, लेकिन उद्यम व्यवसाय संदर्भों में अभी भी प्रासंगिक है। मैंने भविष्य में उन्हें आसानी से अपडेट करने के लिए xsds को छूने से बचने की कोशिश की। यहाँ मेरे समाधान हैं ..

1. ज्यादातर xjc:simpleपर्याप्त है

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<jxb:bindings version="2.0" xmlns:jxb="http://java.sun.com/xml/ns/jaxb"
    xmlns:xjc="http://java.sun.com/xml/ns/jaxb/xjc"
    jxb:extensionBindingPrefixes="xjc">

    <jxb:globalBindings>
        <xjc:simple/> <!-- adds @XmlRootElement annotations -->
    </jxb:globalBindings>

</jxb:bindings>

यह ज्यादातर xmlRootElements xsd परिभाषाओं के आयात के लिए बनाएगा।

2. अपने jaxb2-maven-pluginनिष्पादन को विभाजित करें

मैंने पाया है कि अगर आप एक्सएसडी प्रति निष्पादन परिभाषा के बजाय कई xsd परिभाषाओं से कक्षाएं उत्पन्न करने का प्रयास करते हैं तो इससे बहुत बड़ा अंतर पड़ता है।

इसलिए यदि आपके पास कई <source>की परिभाषा है , तो बस उन्हें विभाजित करने का प्रयास करें:

          <execution>
            <id>xjc-schema-1</id>
            <goals>
              <goal>xjc</goal>
            </goals>
            <configuration>
              <xjbSources>
                <xjbSource>src/main/resources/xsd/binding.xjb</xjbSource>
              </xjbSources>
              <sources>
                <source>src/main/resources/xsd/definition1/</source>
              </sources>
              <clearOutputDir>false</clearOutputDir>
            </configuration>
          </execution>

          <execution>
            <id>xjc-schema-2</id>
            <goals>
              <goal>xjc</goal>
            </goals>
            <configuration>
              <xjbSources>
                <xjbSource>src/main/resources/xsd/binding.xjb</xjbSource>
              </xjbSources>
              <sources>
                <source>src/main/resources/xsd/definition2/</source>
              </sources>
              <clearOutputDir>false</clearOutputDir>
            </configuration>
          </execution>

जनरेटर इस तथ्य को नहीं पकड़ेगा कि एक वर्ग पर्याप्त हो सकता है और इसलिए प्रति निष्पादन कस्टम कक्षाएं बनाता है। और ठीक वैसा ही जैसा मुझे चाहिए;)