Gestione di classi generate da JAXB in un progetto Maven

Question

Ho un progetto basato su Maven, nel quale provo ad aggiungere alcune classi JAXB generate automaticamente dal plugin Maven "jaxb2-maven-plugin". Tuttavia, il mio primo taglio mi ha in un ciclo di dipendenza circolare:

• Poiché queste classi JAXB non vengono ancora generate, le mie altre fonti che li fanno riferimento hanno errori di compilazione.
• Poiché queste altre fonti presentano errori di compilazione, queste classi JAXB non vengono generate.

sembra che ci sono due possibilità ovvie per risolvere questo:

1. Commento-out i riferimenti rotti, in modo che il progetto si basa e le classi JAXB vengono generati automaticamente. Quindi copiare le sorgenti generate da /target in /src/main/java, in modo che i riferimenti ad esse non causino errori di compilazione.
2. Creare un progetto completamente separato, costituito da nient'altro che il materiale JAXB. Includilo come dipendenza nel mio progetto principale.

Mi manca qualcosa qui? L'opzione n. 1 sembra piatta ridicola ... che solo non può essere il modo in cui le persone usano JAXB. L'opzione n. 2 sembra più razionale, ma ancora piuttosto inefficiente e ingombrante. Devo davvero affrontare l'overhead di un progetto completamente separato solo per usare JAXB?

Esistono approcci più eleganti che gli sviluppatori utilizzano per fare riferimento a classi generate da JAXB nello stesso progetto in cui il plug-in Maven li genera?

UPDATE: Su richiesta, qui è la quota di competenza del mio POM:

<build> 
    <plugins> 
     <plugin> 
      <!-- configure the compiler to compile to Java 1.6 --> 
      <groupId>org.apache.maven.plugins</groupId> 
      <artifactId>maven-compiler-plugin</artifactId> 
      <configuration> 
       <source>1.6</source> 
       <target>1.6</target> 
      </configuration> 
     </plugin>  
     <plugin> 
      <groupId>org.codehaus.mojo</groupId> 
      <artifactId>jaxb2-maven-plugin</artifactId> 
      <version>1.4</version> 
      <executions> 
       <execution> 
        <phase>generate-sources</phase> 
        <goals> 
         <goal>xjc</goal> 
        </goals> 
       </execution> 
      </executions> 
      <configuration> 
       <!-- The name of your generated source package --> 
       <packageName>com.mypackage</packageName> 
      </configuration> 
     </plugin> 
    </plugins> 
</build> 

Quando eseguo mvn clean package, io vedo le mie fonti JAXB generati sotto il /target sottodirectory. Tuttavia, quelle sorgenti generate non vengono automaticamente aggiunte al classpath per la fase di compilazione.

POST-RISOLUZIONE UPDATE: Si scopre che i miei problemi di compilazione avevano più a che fare con il fatto che io correvo in Eclipse, e la sua integrazione Maven ha alcuni problemi con "jaxb2-maven-plugin". Vedi this StackOverflow question per maggiori dettagli su quel problema e la sua risoluzione.

Answer 1

Suggerisco di dividere le classi generate da jaxb (api) e le classi BL (implementazione) in 2 progetti maven con pom.xml separato per ciascuno, e il root pom.xml principale con l'ordine di compilazione. in questo modo, sarai in grado di creare api.jar, quindi Maven lo installerà all'interno del repository locale, dopodiché potrai utilizzarlo come dipendenza della tua implementazione. quindi sarà:

-API\ 
--pom.xml - for api, jaxb generation 
-IMPL\ 
--pom.xml - for impl, api dependency is here 
pom.xml - main pom.xml with references to the projects above 

Answer 2

Come hai configurato il tuo plugin jaxb maven? Normalmente viene eseguito nel ciclo di vita generate-sources, che precede il ciclo di vita della compilazione. Quindi le tue classi generate da JAXB dovrebbero già essere lì quando il tuo codice viene compilato, Maven le mette in target/generate-source e mette quella cartella sul classpath.

Edit: Questo è il mio codice che usiamo al lavoro (e che funziona come previsto):

<plugin> 
      <groupId>com.sun.tools.xjc.maven2</groupId> 
      <artifactId>maven-jaxb-plugin</artifactId> 
      <executions> 
       <execution> 
        <phase>generate-sources</phase> 
        <goals> 
         <goal>generate</goal> 
        </goals> 
       </execution> 
      </executions> 
      <configuration> 
       <schemaDirectory>src/main/resources/<companyname>/xsd</schemaDirectory> 
       <includeSchemas> 
        <includeSchema>retrieval.xsd</includeSchema> 
        <includeSchema>storage.xsd</includeSchema> 
       </includeSchemas> 
      </configuration> 
     </plugin> 

Apparentemente usiamo ancora un altro plugin JAXB ... (vedi anche questa discussione: Difference of Maven JAXB plugins) .

Answer 3

Forse provare a utilizzare il maven-jaxb2-plugin invece:

<plugin> 
    <groupId>org.jvnet.jaxb2.maven2</groupId> 
    <artifactId>maven-jaxb2-plugin</artifactId> 
    <version>0.8.2</version> 
    <executions> 
     <execution> 
      <goals> 
       <goal>generate</goal> 
      </goals> 
     </execution> 
    </executions> 
</plugin> 

La risposta da dfuse è corretta, però. Entrambi i plugin dovrebbero generare fonti prima della compilazione e il risultato della generazione di sorgenti sarà sul classpath. Ho provato questo con entrambi i plugin. È possibile pubblicare lo schema, o almeno lo schema per il tipo che il codice non riesce a rilevare sul classpath?