1 package de.juplo.plugins.hibernate;
4 import com.pyx4j.log4j.MavenLogAppender;
6 import java.io.FileInputStream;
7 import java.io.FileOutputStream;
8 import java.io.IOException;
9 import java.io.InputStream;
10 import java.net.MalformedURLException;
12 import java.security.NoSuchAlgorithmException;
13 import java.time.ZonedDateTime;
14 import java.util.Collections;
15 import java.util.EnumSet;
16 import java.util.HashMap;
17 import java.util.HashSet;
18 import java.util.Iterator;
19 import java.util.LinkedHashSet;
20 import java.util.List;
22 import java.util.Map.Entry;
23 import java.util.Properties;
25 import java.util.regex.Matcher;
26 import java.util.regex.Pattern;
27 import javax.persistence.Embeddable;
28 import javax.persistence.Entity;
29 import javax.persistence.MappedSuperclass;
30 import javax.persistence.spi.PersistenceUnitTransactionType;
31 import org.apache.maven.artifact.Artifact;
32 import org.apache.maven.model.Resource;
33 import org.apache.maven.plugin.AbstractMojo;
34 import org.apache.maven.plugin.MojoExecutionException;
35 import org.apache.maven.plugin.MojoFailureException;
36 import org.apache.maven.project.MavenProject;
37 import org.hibernate.boot.MetadataBuilder;
38 import org.hibernate.boot.MetadataSources;
39 import org.hibernate.boot.cfgxml.internal.ConfigLoader;
40 import org.hibernate.boot.cfgxml.spi.LoadedConfig;
41 import org.hibernate.boot.cfgxml.spi.MappingReference;
42 import org.hibernate.boot.model.naming.ImplicitNamingStrategy;
43 import org.hibernate.boot.model.naming.PhysicalNamingStrategy;
44 import org.hibernate.boot.registry.BootstrapServiceRegistry;
45 import org.hibernate.boot.registry.BootstrapServiceRegistryBuilder;
46 import org.hibernate.boot.registry.StandardServiceRegistry;
47 import org.hibernate.boot.registry.StandardServiceRegistryBuilder;
48 import org.hibernate.boot.registry.classloading.spi.ClassLoaderService;
49 import org.hibernate.boot.registry.classloading.spi.ClassLoadingException;
50 import org.hibernate.boot.registry.selector.spi.StrategySelector;
51 import org.hibernate.boot.spi.MetadataImplementor;
52 import org.hibernate.cfg.AvailableSettings;
53 import static org.hibernate.cfg.AvailableSettings.DIALECT;
54 import static org.hibernate.cfg.AvailableSettings.DRIVER;
55 import static org.hibernate.cfg.AvailableSettings.FORMAT_SQL;
56 import static org.hibernate.cfg.AvailableSettings.HBM2DDL_DELIMITER;
57 import static org.hibernate.cfg.AvailableSettings.HBM2DLL_CREATE_NAMESPACES;
58 import static org.hibernate.cfg.AvailableSettings.IMPLICIT_NAMING_STRATEGY;
59 import static org.hibernate.cfg.AvailableSettings.JPA_JDBC_DRIVER;
60 import static org.hibernate.cfg.AvailableSettings.JPA_JDBC_PASSWORD;
61 import static org.hibernate.cfg.AvailableSettings.JPA_JDBC_URL;
62 import static org.hibernate.cfg.AvailableSettings.JPA_JDBC_USER;
63 import static org.hibernate.cfg.AvailableSettings.PASS;
64 import static org.hibernate.cfg.AvailableSettings.PHYSICAL_NAMING_STRATEGY;
65 import static org.hibernate.cfg.AvailableSettings.SHOW_SQL;
66 import static org.hibernate.cfg.AvailableSettings.USER;
67 import static org.hibernate.cfg.AvailableSettings.URL;
68 import org.hibernate.engine.config.spi.ConfigurationService;
69 import org.hibernate.engine.jdbc.connections.spi.ConnectionProvider;
70 import org.hibernate.internal.util.config.ConfigurationException;
71 import org.hibernate.jpa.boot.internal.ParsedPersistenceXmlDescriptor;
72 import org.hibernate.jpa.boot.internal.PersistenceXmlParser;
73 import org.hibernate.tool.schema.TargetType;
74 import org.hibernate.tool.schema.internal.ExceptionHandlerCollectingImpl;
75 import org.hibernate.tool.schema.internal.exec.ScriptTargetOutputToFile;
76 import org.hibernate.tool.schema.spi.ExecutionOptions;
77 import org.hibernate.tool.schema.spi.SchemaManagementToolCoordinator;
78 import org.hibernate.tool.schema.spi.ScriptTargetOutput;
79 import org.hibernate.tool.schema.spi.TargetDescriptor;
80 import org.scannotation.AnnotationDB;
84 * Baseclass with common attributes and methods.
86 * @phase process-classes
88 * @requiresDependencyResolution runtime
90 public abstract class AbstractSchemaMojo extends AbstractMojo
92 public final static String EXECUTE = "hibernate.schema.execute";
93 public final static String OUTPUTDIRECTORY = "project.build.outputDirectory";
94 public final static String SCAN_CLASSES = "hibernate.schema.scan.classes";
95 public final static String SCAN_DEPENDENCIES = "hibernate.schema.scan.dependencies";
96 public final static String SCAN_TESTCLASSES = "hibernate.schema.scan.test_classes";
97 public final static String TEST_OUTPUTDIRECTORY = "project.build.testOutputDirectory";
98 public final static String SKIPPED = "hibernate.schema.skipped";
99 public final static String SCRIPT = "hibernate.schema.script";
101 private final static Pattern SPLIT = Pattern.compile("[^,\\s]+");
103 private final Set<String> packages = new HashSet<String>();
109 * Only needed internally.
111 * @parameter property="project"
115 private MavenProject project;
120 * Only needed internally.
122 * @parameter property="project.build.directory"
126 private String buildDirectory;
129 /** Parameters to configure the genaration of the SQL *********************/
132 * Excecute the generated SQL.
133 * If set to <code>false</code>, only the SQL-script is created and the
134 * database is not touched.
136 * <strong>Important:</strong>
137 * This configuration value can only be configured through the
138 * <code>pom.xml</code>, or by the definition of a system-property, because
139 * it is not known by Hibernate nor JPA and, hence, not picked up from
140 * their configuration!
142 * @parameter property="hibernate.schema.execute" default-value="true"
145 private Boolean execute;
150 * If set to <code>true</code>, the execution is skipped.
152 * A skipped execution is signaled via the maven-property
153 * <code>${hibernate.schema.skipped}</code>.
155 * The execution is skipped automatically, if no modified or newly added
156 * annotated classes are found and the dialect was not changed.
158 * <strong>Important:</strong>
159 * This configuration value can only be configured through the
160 * <code>pom.xml</code>, or by the definition of a system-property, because
161 * it is not known by Hibernate nor JPA and, hence, not picked up from
162 * their configuration!
164 * @parameter property="hibernate.schema.skip" default-value="${maven.test.skip}"
167 private boolean skip;
170 * Force generation/execution
172 * Force the generation and (if configured) the execution of the SQL, even if
173 * no modified or newly added annotated classes where found and the
174 * configuration was not changed.
176 * <code>skip</code> takes precedence over <code>force</code>.
178 * <strong>Important:</strong>
179 * This configuration value can only be configured through the
180 * <code>pom.xml</code>, or by the definition of a system-property, because
181 * it is not known by Hibernate nor JPA and, hence, not picked up from
182 * their configuration!
184 * @parameter property="hibernate.schema.force" default-value="false"
187 private boolean force;
192 * @parameter property="hibernate.dialect"
195 private String dialect;
198 * Delimiter in output-file.
200 * <strong>Important:</strong>
201 * This configuration value can only be configured through the
202 * <code>pom.xml</code>, or by the definition of a system-property, because
203 * it is not known by Hibernate nor JPA and, hence, not picked up from
204 * their configuration!
206 * @parameter property="hibernate.hbm2ddl.delimiter" default-value=";"
209 private String delimiter;
212 * Show the generated SQL in the command-line output.
214 * @parameter property="hibernate.show_sql"
217 private Boolean show;
220 * Format output-file.
222 * @parameter property="hibernate.format_sql"
225 private Boolean format;
228 * Specifies whether to automatically create also the database schema/catalog.
230 * @parameter property="hibernate.hbm2dll.create_namespaces" default-value="false"
233 private Boolean createNamespaces;
236 * Implicit naming strategy
238 * @parameter property="hibernate.implicit_naming_strategy"
241 private String implicitNamingStrategy;
244 * Physical naming strategy
246 * @parameter property="hibernate.physical_naming_strategy"
249 private String physicalNamingStrategy;
252 * Wether the project should be scanned for annotated-classes, or not
254 * This parameter is intended to allow overwriting of the parameter
255 * <code>exclude-unlisted-classes</code> of a <code>persistence-unit</code>.
256 * If not specified, it defaults to <code>true</code>
258 * @parameter property="hibernate.schema.scan.classes"
261 private Boolean scanClasses;
264 * Classes-Directory to scan.
266 * This parameter defaults to the maven build-output-directory for classes.
267 * Additionally, all dependencies are scanned for annotated classes.
269 * <strong>Important:</strong>
270 * This configuration value can only be configured through the
271 * <code>pom.xml</code>, or by the definition of a system-property, because
272 * it is not known by Hibernate nor JPA and, hence, not picked up from
273 * their configuration!
275 * @parameter property="project.build.outputDirectory"
278 private String outputDirectory;
281 * Dependency-Scopes, that should be scanned for annotated classes.
283 * By default, only dependencies in the scope <code>compile</code> are
284 * scanned for annotated classes. Multiple scopes can be seperated by
285 * white space or commas.
287 * If you do not want any dependencies to be scanned for annotated
288 * classes, set this parameter to <code>none</code>.
290 * The plugin does not scan for annotated classes in transitive
291 * dependencies. If some of your annotated classes are hidden in a
292 * transitive dependency, you can simply add that dependency explicitly.
294 * @parameter property="hibernate.schema.scan.dependencies" default-value="compile"
297 private String scanDependencies;
300 * Whether to scan the test-branch of the project for annotated classes, or
303 * If this parameter is set to <code>true</code> the test-classes of the
304 * artifact will be scanned for hibernate-annotated classes additionally.
306 * <strong>Important:</strong>
307 * This configuration value can only be configured through the
308 * <code>pom.xml</code>, or by the definition of a system-property, because
309 * it is not known by Hibernate nor JPA and, hence, not picked up from
310 * their configuration!
312 * @parameter property="hibernate.schema.scan.test_classes" default-value="false"
315 private Boolean scanTestClasses;
318 * Test-Classes-Directory to scan.
320 * This parameter defaults to the maven build-output-directory for
323 * This parameter is only used, when <code>scanTestClasses</code> is set
324 * to <code>true</code>!
326 * <strong>Important:</strong>
327 * This configuration value can only be configured through the
328 * <code>pom.xml</code>, or by the definition of a system-property, because
329 * it is not known by Hibernate nor JPA and, hence, not picked up from
330 * their configuration!
332 * @parameter property="project.build.testOutputDirectory"
335 private String testOutputDirectory;
338 /** Conection parameters *************************************************/
343 * @parameter property="hibernate.connection.driver_class"
346 private String driver;
351 * @parameter property="hibernate.connection.url"
359 * @parameter property="hibernate.connection.username"
362 private String username;
367 * @parameter property="hibernate.connection.password"
370 private String password;
373 /** Parameters to locate configuration sources ****************************/
376 * Path to a file or name of a ressource with hibernate properties.
377 * If this parameter is specified, the plugin will try to load configuration
378 * values from a file with the given path or a ressource on the classpath with
379 * the given name. If both fails, the execution of the plugin will fail.
381 * If this parameter is not set the plugin will load configuration values
382 * from a ressource named <code>hibernate.properties</code> on the classpath,
383 * if it is present, but will not fail if there is no such ressource.
385 * During ressource-lookup, the test-classpath takes precedence.
390 private String hibernateProperties;
393 * Path to Hibernate configuration file (.cfg.xml).
394 * If this parameter is specified, the plugin will try to load configuration
395 * values from a file with the given path or a ressource on the classpath with
396 * the given name. If both fails, the execution of the plugin will fail.
398 * If this parameter is not set the plugin will load configuration values
399 * from a ressource named <code>hibernate.cfg.xml</code> on the classpath,
400 * if it is present, but will not fail if there is no such ressource.
402 * During ressource-lookup, the test-classpath takes precedence.
404 * Settings in this file will overwrite settings in the properties file.
409 private String hibernateConfig;
412 * Name of the persistence-unit.
413 * If this parameter is specified, the plugin will try to load configuration
414 * values from a persistence-unit with the specified name. If no such
415 * persistence-unit can be found, the plugin will throw an exception.
417 * If this parameter is not set and there is only one persistence-unit
418 * available, that unit will be used automatically. But if this parameter is
419 * not set and there are multiple persistence-units available on,
420 * the class-path, the execution of the plugin will fail.
422 * Settings in this file will overwrite settings in the properties or the
423 * configuration file.
428 private String persistenceUnit;
431 * List of Hibernate-Mapping-Files (XML).
432 * Multiple files can be separated with white-spaces and/or commas.
434 * @parameter property="hibernate.mapping"
437 private String mappings;
441 public final void execute(String filename)
443 MojoFailureException,
444 MojoExecutionException
448 getLog().info("Execution of hibernate-maven-plugin was skipped!");
449 project.getProperties().setProperty(SKIPPED, "true");
453 ModificationTracker tracker;
456 tracker = new ModificationTracker(buildDirectory, filename, getLog());
458 catch (NoSuchAlgorithmException e)
460 throw new MojoFailureException("Digest-Algorithm MD5 is missing!", e);
463 final SimpleConnectionProvider connectionProvider =
464 new SimpleConnectionProvider(getLog());
468 /** Start extended logging */
469 MavenLogAppender.startPluginLog(this);
471 /** Load checksums for old mapping and configuration */
474 /** Create the ClassLoader */
475 MutableClassLoader classLoader = createClassLoader();
477 /** Create a BootstrapServiceRegistry with the created ClassLoader */
478 BootstrapServiceRegistry bootstrapServiceRegitry =
479 new BootstrapServiceRegistryBuilder()
480 .applyClassLoader(classLoader)
482 ClassLoaderService classLoaderService =
483 bootstrapServiceRegitry.getService(ClassLoaderService.class);
485 Properties properties = new Properties();
486 ConfigLoader configLoader = new ConfigLoader(bootstrapServiceRegitry);
488 /** Loading and merging configuration */
489 properties.putAll(loadProperties(configLoader));
490 LoadedConfig config = loadConfig(configLoader);
492 properties.putAll(config.getConfigurationValues());
493 ParsedPersistenceXmlDescriptor unit =
494 loadPersistenceUnit(classLoaderService, properties);
496 properties.putAll(unit.getProperties());
498 /** Overwriting/Completing configuration */
499 configure(properties, tracker);
501 /** Check configuration for modifications */
502 if(tracker.track(properties))
503 getLog().debug("Configuration has changed.");
505 getLog().debug("Configuration unchanged.");
507 /** Check, that the outputfile is writable */
508 final File output = getOutputFile(filename);
509 /** Check, if the outputfile is missing or was changed */
510 checkOutputFile(output, tracker);
512 /** Configure Hibernate */
513 final StandardServiceRegistry serviceRegistry =
514 new StandardServiceRegistryBuilder(bootstrapServiceRegitry)
515 .applySettings(properties)
516 .addService(ConnectionProvider.class, connectionProvider)
518 final MetadataSources sources = new MetadataSources(serviceRegistry);
520 /** Add the remaining class-path-elements */
521 completeClassPath(classLoader);
523 /** Apply mappings from hibernate-configuration, if present */
526 for (MappingReference mapping : config.getMappingReferences())
527 mapping.apply(sources);
533 /** No persistent unit: default behaviour */
534 if (scanClasses == null)
536 Set<URL> urls = new HashSet<URL>();
538 addRoot(urls, outputDirectory);
540 addRoot(urls, testOutputDirectory);
541 addDependencies(urls);
542 classes = scanUrls(urls);
546 /** Follow configuration in persisten unit */
547 if (scanClasses == null)
548 scanClasses = !unit.isExcludeUnlistedClasses();
549 Set<URL> urls = new HashSet<URL>();
553 * Scan the root of the persiten unit and configured jars for
556 urls.add(unit.getPersistenceUnitRootUrl());
557 for (URL url : unit.getJarFileUrls())
561 addRoot(urls, testOutputDirectory);
562 classes = scanUrls(urls);
563 for (String className : unit.getManagedClassNames())
564 classes.add(className);
566 * Add mappings from the default mapping-file
567 * <code>META-INF/orm.xml</code>, if present
569 boolean error = false;
571 is = classLoader.getResourceAsStream("META-INF/orm.xml");
574 getLog().info("Adding default JPA-XML-mapping from META-INF/orm.xml");
577 tracker.track("META-INF/orm.xml", is);
578 sources.addResource("META-INF/orm.xml");
580 catch (IOException e)
582 getLog().error("cannot read META-INF/orm.xml: " + e);
588 getLog().debug("no META-INF/orm.xml found");
591 * Add mappings from files, that are explicitly configured in the
594 for (String mapping : unit.getMappingFileNames())
596 getLog().info("Adding explicitly configured mapping from " + mapping);
597 is = classLoader.getResourceAsStream(mapping);
602 tracker.track(mapping, is);
603 sources.addResource(mapping);
605 catch (IOException e)
607 getLog().info("cannot read mapping-file " + mapping + ": " + e);
613 getLog().error("cannot find mapping-file " + mapping);
618 throw new MojoFailureException(
619 "error, while reading mappings configured in persistence-unit \"" +
625 /** Add the configured/collected annotated classes */
626 for (String className : classes)
627 addAnnotated(className, sources, classLoaderService, tracker);
629 /** Add explicitly configured classes */
630 addMappings(sources, tracker);
632 /** Skip execution, if mapping and configuration is unchanged */
633 if (!tracker.modified())
635 getLog().info("Mapping and configuration unchanged.");
637 getLog().info("Generation/execution is forced!");
640 getLog().info("Skipping schema generation!");
641 project.getProperties().setProperty(SKIPPED, "true");
647 /** Truncate output file */
650 new FileOutputStream(output).getChannel().truncate(0).close();
652 catch (IOException e)
655 "Error while truncating " + output.getAbsolutePath() + ": "
657 getLog().warn(error);
658 throw new MojoExecutionException(error);
661 /** Create a connection, if sufficient configuration infromation is available */
662 connectionProvider.open(classLoaderService, properties);
664 MetadataBuilder metadataBuilder = sources.getMetadataBuilder();
666 StrategySelector strategySelector =
667 serviceRegistry.getService(StrategySelector.class);
669 if (properties.containsKey(IMPLICIT_NAMING_STRATEGY))
671 metadataBuilder.applyImplicitNamingStrategy(
672 strategySelector.resolveStrategy(
673 ImplicitNamingStrategy.class,
674 properties.getProperty(IMPLICIT_NAMING_STRATEGY)
679 if (properties.containsKey(PHYSICAL_NAMING_STRATEGY))
681 metadataBuilder.applyPhysicalNamingStrategy(
682 strategySelector.resolveStrategy(
683 PhysicalNamingStrategy.class,
684 properties.getProperty(PHYSICAL_NAMING_STRATEGY)
689 /** Prepare the generation of the SQL */
690 Map settings = new HashMap();
693 .getService(ConfigurationService.class)
696 ExceptionHandlerCollectingImpl handler =
697 new ExceptionHandlerCollectingImpl();
698 ExecutionOptions options =
699 SchemaManagementToolCoordinator
700 .buildExecutionOptions(settings, handler);
701 final EnumSet<TargetType> targetTypes = EnumSet.of(TargetType.SCRIPT);
703 targetTypes.add(TargetType.DATABASE);
704 TargetDescriptor target = new TargetDescriptor()
707 public EnumSet<TargetType> getTargetTypes()
713 public ScriptTargetOutput getScriptTargetOutput()
718 .getService(ConfigurationService.class)
720 .get(AvailableSettings.HBM2DDL_CHARSET_NAME);
721 return new ScriptTargetOutputToFile(output, charset);
726 * Change class-loader of current thread.
727 * This is necessary, because still not all parts of Hibernate 5 use
728 * the newly introduced ClassLoaderService and will fail otherwise!
730 Thread thread = Thread.currentThread();
731 ClassLoader contextClassLoader = thread.getContextClassLoader();
734 thread.setContextClassLoader(classLoader);
735 build((MetadataImplementor)metadataBuilder.build(), options, target);
736 if (handler.getExceptions().size() > 0)
738 StringBuilder builder = new StringBuilder();
739 builder.append("Hibernate failed:");
740 for (Exception e : handler.getExceptions())
742 builder.append("\n * ");
743 builder.append(e.getMessage());
744 AbstractSchemaMojo.printStrackTrace(builder, e);
745 builder.append("\n");
747 String error = builder.toString();
748 getLog().error(error);
749 throw new MojoFailureException(error);
754 thread.setContextClassLoader(contextClassLoader);
755 /** Track, the content of the generated script */
756 checkOutputFile(output, tracker);
759 catch (MojoExecutionException e)
764 catch (MojoFailureException e)
769 catch (RuntimeException e)
776 /** Remember mappings and configuration */
779 /** Close the connection - if one was opened */
780 connectionProvider.close();
782 /** Stop Log-Capturing */
783 MavenLogAppender.endPluginLog(this);
789 MetadataImplementor metadata,
790 ExecutionOptions options,
791 TargetDescriptor target
794 MojoFailureException,
795 MojoExecutionException;
798 private MutableClassLoader createClassLoader() throws MojoExecutionException
802 getLog().debug("Creating ClassLoader for project-dependencies...");
803 LinkedHashSet<URL> urls = new LinkedHashSet<URL>();
806 file = new File(testOutputDirectory);
809 getLog().info("Creating test-output-directory: " + testOutputDirectory);
812 urls.add(file.toURI().toURL());
814 file = new File(outputDirectory);
817 getLog().info("Creating output-directory: " + outputDirectory);
820 urls.add(file.toURI().toURL());
822 return new MutableClassLoader(urls, getLog());
826 getLog().error("Error while creating ClassLoader!", e);
827 throw new MojoExecutionException(e.getMessage());
831 private void completeClassPath(MutableClassLoader classLoader)
833 MojoExecutionException
837 getLog().debug("Completing class-paths of the ClassLoader for project-dependencies...");
838 List<String> classpathFiles = project.getCompileClasspathElements();
840 classpathFiles.addAll(project.getTestClasspathElements());
841 LinkedHashSet<URL> urls = new LinkedHashSet<URL>();
842 for (String pathElement : classpathFiles)
844 getLog().debug("Dependency: " + pathElement);
845 urls.add(new File(pathElement).toURI().toURL());
847 classLoader.add(urls);
851 getLog().error("Error while creating ClassLoader!", e);
852 throw new MojoExecutionException(e.getMessage());
856 private Map loadProperties(ConfigLoader configLoader)
858 MojoExecutionException
860 /** Try to read configuration from properties-file */
861 if (hibernateProperties == null)
865 return configLoader.loadProperties("hibernate.properties");
867 catch (ConfigurationException e)
869 getLog().debug(e.getMessage());
870 return Collections.EMPTY_MAP;
877 File file = new File(hibernateProperties);
880 getLog().info("Reading settings from file " + hibernateProperties + "...");
881 return configLoader.loadProperties(file);
884 return configLoader.loadProperties(hibernateProperties);
886 catch (ConfigurationException e)
888 getLog().error("Error while reading properties!", e);
889 throw new MojoExecutionException(e.getMessage());
894 private LoadedConfig loadConfig(ConfigLoader configLoader)
895 throws MojoExecutionException
897 /** Try to read configuration from configuration-file */
898 if (hibernateConfig == null)
902 return configLoader.loadConfigXmlResource("hibernate.cfg.xml");
904 catch (ConfigurationException e)
906 getLog().debug(e.getMessage());
914 File file = new File(hibernateConfig);
917 getLog().info("Reading configuration from file " + hibernateConfig + "...");
918 return configLoader.loadConfigXmlFile(file);
922 return configLoader.loadConfigXmlResource(hibernateConfig);
925 catch (ConfigurationException e)
927 getLog().error("Error while reading configuration!", e);
928 throw new MojoExecutionException(e.getMessage());
933 private void configure(Properties properties, ModificationTracker tracker)
934 throws MojoFailureException
937 * Special treatment for the configuration-value "execute": if it is
938 * switched to "true", the genearation fo the schema should be forced!
940 if (tracker.check(EXECUTE, execute.toString()) && execute)
943 "hibernate.schema.execute was switched on: " +
944 "forcing generation/execution of SQL"
948 configure(properties, execute, EXECUTE);
951 * Configure the generation of the SQL.
952 * Overwrite values from properties-file if the configuration parameter is
953 * known to Hibernate.
955 configure(properties, dialect, DIALECT);
956 configure(properties, delimiter, HBM2DDL_DELIMITER);
957 configure(properties, format, FORMAT_SQL);
958 configure(properties, createNamespaces, HBM2DLL_CREATE_NAMESPACES);
959 configure(properties, implicitNamingStrategy, IMPLICIT_NAMING_STRATEGY);
960 configure(properties, physicalNamingStrategy, PHYSICAL_NAMING_STRATEGY);
961 configure(properties, outputDirectory, OUTPUTDIRECTORY);
962 configure(properties, scanDependencies, SCAN_DEPENDENCIES);
963 configure(properties, scanTestClasses, SCAN_TESTCLASSES);
964 configure(properties, testOutputDirectory, TEST_OUTPUTDIRECTORY);
967 * Special treatment for the configuration-value "show": a change of its
968 * configured value should not lead to a regeneration of the database
972 show = Boolean.valueOf(properties.getProperty(SHOW_SQL));
974 properties.setProperty(SHOW_SQL, show.toString());
977 * Configure the connection parameters.
978 * Overwrite values from properties-file.
980 configure(properties, driver, DRIVER, JPA_JDBC_DRIVER);
981 configure(properties, url, URL, JPA_JDBC_URL);
982 configure(properties, username, USER, JPA_JDBC_USER);
983 configure(properties, password, PASS, JPA_JDBC_PASSWORD);
985 if (properties.isEmpty())
987 getLog().error("No properties set!");
988 throw new MojoFailureException("Hibernate configuration is missing!");
991 getLog().info("Gathered configuration:");
992 for (Entry<Object,Object> entry : properties.entrySet())
993 getLog().info(" " + entry.getKey() + " = " + entry.getValue());
996 private void configure(
997 Properties properties,
1000 String alternativeKey
1003 configure(properties, value, key);
1005 if (properties.containsKey(alternativeKey))
1007 if (properties.containsKey(key))
1010 "Ignoring property " + alternativeKey + "=\"" +
1011 properties.getProperty(alternativeKey) +
1012 "\" in favour for property " + key + "=\"" +
1013 properties.getProperty(key) + "\""
1015 properties.remove(alternativeKey);
1019 value = properties.getProperty(alternativeKey);
1020 properties.remove(alternativeKey);
1022 "Using value \"" + value + "\" from property " + alternativeKey +
1023 " for property " + key
1025 properties.setProperty(key, value);
1030 private void configure(Properties properties, String value, String key)
1034 if (properties.containsKey(key))
1036 if (!properties.getProperty(key).equals(value))
1039 "Overwriting property " + key + "=\"" +
1040 properties.getProperty(key) +
1041 "\" with value \"" + value + "\""
1043 properties.setProperty(key, value);
1048 getLog().debug("Using value \"" + value + "\" for property " + key);
1049 properties.setProperty(key, value);
1054 private void configure(Properties properties, Boolean value, String key)
1056 configure(properties, value == null ? null : value.toString(), key);
1059 private File getOutputFile(String filename)
1061 MojoExecutionException
1063 File output = new File(filename);
1065 if (!output.isAbsolute())
1067 // Interpret relative file path relative to build directory
1068 output = new File(buildDirectory, filename);
1070 getLog().debug("Output file: " + output.getPath());
1072 // Ensure that directory path for specified file exists
1073 File outFileParentDir = output.getParentFile();
1074 if (null != outFileParentDir && !outFileParentDir.exists())
1079 "Creating directory path for output file:" +
1080 outFileParentDir.getPath()
1082 outFileParentDir.mkdirs();
1087 "Error creating directory path for output file: " + e.getMessage();
1088 getLog().error(error);
1089 throw new MojoExecutionException(error);
1095 output.createNewFile();
1097 catch (IOException e)
1099 String error = "Error creating output file: " + e.getMessage();
1100 getLog().error(error);
1101 throw new MojoExecutionException(error);
1104 if (!output.canWrite())
1107 "Output file " + output.getAbsolutePath() + " is not writable!";
1108 getLog().error(error);
1109 throw new MojoExecutionException(error);
1115 private void checkOutputFile(File output, ModificationTracker tracker)
1117 MojoExecutionException
1121 if (output.exists())
1122 tracker.track(SCRIPT, new FileInputStream(output));
1124 tracker.track(SCRIPT, ZonedDateTime.now().toString());
1126 catch (IOException e)
1129 "Error while checking the generated script: " + e.getMessage();
1130 getLog().error(error);
1131 throw new MojoExecutionException(error);
1135 private void addMappings(MetadataSources sources, ModificationTracker tracker)
1136 throws MojoFailureException
1138 getLog().debug("Adding explicitly configured mappings...");
1139 if (mappings != null)
1143 for (String filename : mappings.split("[\\s,]+"))
1145 // First try the filename as absolute/relative path
1146 File file = new File(filename);
1149 // If the file was not found, search for it in the resource-directories
1150 for (Resource resource : project.getResources())
1152 file = new File(resource.getDirectory() + File.separator + filename);
1159 if (file.isDirectory())
1160 // TODO: add support to read all mappings under a directory
1161 throw new MojoFailureException(file.getAbsolutePath() + " is a directory");
1162 if (tracker.track(filename, new FileInputStream(file)))
1163 getLog().debug("Found new or modified mapping-file: " + filename);
1165 getLog().debug("Mapping-file unchanged: " + filename);
1167 sources.addFile(file);
1170 throw new MojoFailureException("File " + filename + " could not be found in any of the configured resource-directories!");
1173 catch (IOException e)
1175 throw new MojoFailureException("Cannot calculate MD5 sums!", e);
1180 private void addRoot(Set<URL> urls, String path) throws MojoFailureException
1184 File dir = new File(path);
1187 getLog().info("Adding " + dir.getAbsolutePath() + " to the list of roots to scan...");
1188 urls.add(dir.toURI().toURL());
1192 "the directory cannot be scanned for annotated classes, " +
1193 "because it does not exist: " +
1194 dir.getAbsolutePath()
1197 catch (MalformedURLException e)
1199 getLog().error("error while adding the project-root to the list of roots to scan!", e);
1200 throw new MojoFailureException(e.getMessage());
1204 private void addDependencies(Set<URL> urls) throws MojoFailureException
1208 if (scanDependencies != null)
1210 Matcher matcher = SPLIT.matcher(scanDependencies);
1211 while (matcher.find())
1213 getLog().info("Adding dependencies from scope " + matcher.group() + " to the list of roots to scan");
1214 for (Artifact artifact : project.getDependencyArtifacts())
1216 if (!artifact.getScope().equalsIgnoreCase(matcher.group()))
1218 if (artifact.getFile() == null)
1220 getLog().warn("Cannot add dependency " + artifact.getId() + ": no JAR-file available!");
1223 getLog().info("Adding dependencies from scope " + artifact.getId() + " to the list of roots to scan");
1224 urls.add(artifact.getFile().toURI().toURL());
1229 catch (MalformedURLException e)
1231 getLog().error("Error while adding dependencies to the list of roots to scan!", e);
1232 throw new MojoFailureException(e.getMessage());
1236 private Set<String> scanUrls(Set<URL> scanRoots)
1238 MojoFailureException
1242 AnnotationDB db = new AnnotationDB();
1243 for (URL root : scanRoots)
1244 db.scanArchives(root);
1246 Set<String> classes = new HashSet<String>();
1247 if (db.getAnnotationIndex().containsKey(Entity.class.getName()))
1248 classes.addAll(db.getAnnotationIndex().get(Entity.class.getName()));
1249 if (db.getAnnotationIndex().containsKey(MappedSuperclass.class.getName()))
1250 classes.addAll(db.getAnnotationIndex().get(MappedSuperclass.class.getName()));
1251 if (db.getAnnotationIndex().containsKey(Embeddable.class.getName()))
1252 classes.addAll(db.getAnnotationIndex().get(Embeddable.class.getName()));
1258 getLog().error("Error while scanning!", e);
1259 throw new MojoFailureException(e.getMessage());
1263 private void addAnnotated(
1265 MetadataSources sources,
1266 ClassLoaderService classLoaderService,
1267 ModificationTracker tracker
1270 MojoFailureException,
1271 MojoExecutionException
1275 getLog().info("Adding annotated resource: " + name);
1276 String packageName = null;
1278 boolean error = false;
1281 Class<?> annotatedClass = classLoaderService.classForName(name);
1282 String resourceName = annotatedClass.getName();
1284 resourceName.substring(
1285 resourceName.lastIndexOf(".") + 1,
1286 resourceName.length()
1288 InputStream is = annotatedClass.getResourceAsStream(resourceName);
1291 if (tracker.track(name, is))
1292 getLog().debug("New or modified class: " + name);
1294 getLog().debug("Unchanged class: " + name);
1295 sources.addAnnotatedClass(annotatedClass);
1296 packageName = annotatedClass.getPackage().getName();
1300 getLog().error("cannot find ressource " + resourceName + " for class " + name);
1304 catch(ClassLoadingException e)
1310 throw new MojoExecutionException("error while inspecting annotated class " + name);
1313 while (packageName != null)
1315 if (packages.contains(packageName))
1317 String resource = packageName.replace('.', '/') + "/package-info.class";
1318 InputStream is = classLoaderService.locateResourceStream(resource);
1321 // No compiled package-info available: no package-level annotations!
1322 getLog().debug("Package " + packageName + " is not annotated.");
1326 if (tracker.track(packageName, is))
1327 getLog().debug("New or modified package: " + packageName);
1329 getLog().debug("Unchanged package: " + packageName);
1330 getLog().info("Adding annotations from package " + packageName);
1331 sources.addPackage(packageName);
1333 packages.add(packageName);
1334 int i = packageName.lastIndexOf('.');
1338 packageName = packageName.substring(0,i);
1343 getLog().error("Error while adding the annotated class " + name, e);
1344 throw new MojoFailureException(e.getMessage());
1348 private ParsedPersistenceXmlDescriptor loadPersistenceUnit(
1349 ClassLoaderService classLoaderService,
1350 Properties properties
1353 MojoFailureException
1355 PersistenceXmlParser parser =
1356 new PersistenceXmlParser(
1358 PersistenceUnitTransactionType.RESOURCE_LOCAL
1361 Map<String, ParsedPersistenceXmlDescriptor> units =
1362 parser.doResolve(properties);
1364 if (persistenceUnit == null)
1366 Iterator<String> names = units.keySet().iterator();
1367 if (!names.hasNext())
1369 getLog().info("Found no META-INF/persistence.xml.");
1373 String name = names.next();
1374 if (!names.hasNext())
1376 getLog().info("Using persistence-unit " + name);
1377 return units.get(name);
1380 StringBuilder builder = new StringBuilder();
1381 builder.append("No name provided and multiple persistence units found: ");
1382 builder.append(name);
1383 while(names.hasNext())
1385 builder.append(", ");
1386 builder.append(names.next());
1388 builder.append('.');
1389 throw new MojoFailureException(builder.toString());
1392 if (units.containsKey(persistenceUnit))
1394 getLog().info("Using configured persistence-unit " + persistenceUnit);
1395 return units.get(persistenceUnit);
1398 throw new MojoFailureException("Could not find persistence-unit " + persistenceUnit);
1402 public static void printStrackTrace(StringBuilder builder, Throwable t)
1406 builder.append("\n\tCause: ");
1407 builder.append(t.getMessage() == null ? "" : t.getMessage().replaceAll("\\s+", " "));
1408 for (StackTraceElement trace : t.getStackTrace())
1410 builder.append("\n\t");
1411 builder.append(trace.getClassName());
1412 builder.append(".");
1413 builder.append(trace.getMethodName());
1414 builder.append("():");
1415 builder.append(trace.getLineNumber());