Generowanie skryptu DDL przy kompilacji MAVEN za pomocą Hibernate4/JPA 2.1

Question

Wygląda na to, że hibernate3-maven-plugin używany do generowania skryptów tworzenia/usuwania DDL nie jest już kompatybilny z Hibernate 4.3 i nowszymi wersjami (przy użyciu JPA 2.1).

używam takiej konfiguracji wtyczki:

  <plugin> 
       <groupId>org.codehaus.mojo</groupId> 
       <artifactId>hibernate3-maven-plugin</artifactId> 
       <version>3.0</version> 
       <executions> 
        <execution> 
         <id>generate-sql-schema</id> 
         <phase>process-sources</phase> 
         <goals> 
          <goal>hbm2ddl</goal> 
         </goals> 
         <configuration> 
          <hibernatetool> 
           <jpaconfiguration persistenceunit="${persistenceUnitName}" /> 
           <hbm2ddl update="true" create="true" export="false" 
            outputfilename="src/main/sql/schema.sql" format="true" 
            console="true" /> 
          </hibernatetool> 
         </configuration> 
        </execution> 
       </executions> 
      </plugin> 

Ale pojawia się następujący błąd:

[ERROR] Failed to execute goal org.codehaus.mojo:hibernate3-maven-plugin:3.0:hbm2ddl (generate-sql-schema) on project my-project: There was an error creating the AntRun task. 
An Ant BuildException has occured: java.lang.NoClassDefFoundError: org/hibernate/util/ReflectHelper: org.hibernate.util.ReflectHelper -> [Help 1] 

tej klasy jako przeniesione do nowego pakietu: org.hibernate.internal.util.ReflectHelper

Jednak nie znalazłem jasne sposób na generowanie DDL tworzyć skrypty przy kompilacji MAVEN.

Nie ma żadnego hibernate4-maven-plugin ani żadnego innego oficjalnego sposobu na zrobienie tego.

Co z tego? Czy nie jest to główna cecha, którą należy wspierać? Jak to zrobić ?

Answer 1

Jak Hibernate 4.3+ teraz realizuje JPA 2.1 odpowiedni sposób generowania skryptów DDL jest użycie następujący zestaw JPA 2.1 właściwości:

<property name="javax.persistence.schema-generation.scripts.action" value="create"/> 
<property name="javax.persistence.schema-generation.create-source" value="metadata"/> 
<property name="javax.persistence.schema-generation.scripts.create-target" value="target/jpa/sql/create-schema.sql"/> 

Miłym podsumowaniem innych właściwości i kontekście generowania schematu w JPA 2.1 można znaleźć tutaj: https://blogs.oracle.com/arungupta/entry/jpa_2_1_schema_generation

i oficjalnych specyfikacji JPA 2.1 tutaj: https://jcp.org/aboutJava/communityprocess/final/jsr338/index.html

Ponieważ zostanie to wygenerowane w czasie wykonywania, może być konieczne wykonanie tej generacji DDL przy kompilacji.

Oto podejście JPA 2.1 do wygenerowania tego skryptu programowo:

import java.io.IOException; 
import java.util.Properties; 

import javax.persistence.Persistence; 

import org.hibernate.jpa.AvailableSettings; 

public class JpaSchemaExport { 

    public static void main(String[] args) throws IOException { 
     execute(args[0], args[1]); 
     System.exit(0); 
    } 

    public static void execute(String persistenceUnitName, String destination) { 
     System.out.println("Generating DDL create script to : " + destination); 

     final Properties persistenceProperties = new Properties(); 

     // XXX force persistence properties : remove database target 
     persistenceProperties.setProperty(org.hibernate.cfg.AvailableSettings.HBM2DDL_AUTO, ""); 
     persistenceProperties.setProperty(AvailableSettings.SCHEMA_GEN_DATABASE_ACTION, "none"); 

     // XXX force persistence properties : define create script target from metadata to destination 
     // persistenceProperties.setProperty(AvailableSettings.SCHEMA_GEN_CREATE_SCHEMAS, "true"); 
     persistenceProperties.setProperty(AvailableSettings.SCHEMA_GEN_SCRIPTS_ACTION, "create"); 
     persistenceProperties.setProperty(AvailableSettings.SCHEMA_GEN_CREATE_SOURCE, "metadata"); 
     persistenceProperties.setProperty(AvailableSettings.SCHEMA_GEN_SCRIPTS_CREATE_TARGET, destination); 

     Persistence.generateSchema(persistenceUnitName, persistenceProperties); 
    } 

} 

Jak widać jest to bardzo proste!

Teraz można to wykorzystać w AntTask lub MAVEN budować tak (dla Maven):

<plugin> 
    <artifactId>maven-antrun-plugin</artifactId> 
    <version>1.7</version> 
    <executions> 
     <execution> 
      <id>generate-ddl-create</id> 
      <phase>process-classes</phase> 
      <goals> 
       <goal>run</goal> 
      </goals> 
      <configuration> 
       <target> 
        <!-- ANT Task definition --> 
        <java classname="com.orange.tools.jpa.JpaSchemaExport" 
         fork="true" failonerror="true"> 
         <arg value="${persistenceUnitName}" /> 
         <arg value="target/jpa/sql/schema-create.sql" /> 
         <!-- reference to the passed-in classpath reference --> 
         <classpath refid="maven.compile.classpath" /> 
        </java> 
       </target> 
      </configuration> 

     </execution> 
    </executions> 
</plugin> 

Zauważ, że oficjalna hibernate-maven-plugin też może, czy nie może załatwić sprawę w jakiś sposób:

<dependency> 
    <groupId>org.hibernate</groupId> 
    <artifactId>hibernate-maven-plugin</artifactId> 
    <version>4.3.1.Final</version> 
</dependency> 

Ciesz się! :)

Answer 2

Być może trochę się spóźniłem, ale Andrew Thompson ma inne rozwiązanie, które nie wymaga pliku persistence.xml ani prawdziwej bazy danych, mimo że jest specyficzne dla Hibernate.

http://jandrewthompson.blogspot.com/2009/10/how-to-generate-ddl-scripts-from.html

Niestety, wiąże się to trochę kodu, ale jego bardzo elastyczny.