X-Git-Url: https://juplo.de/gitweb/?p=hibernate4-maven-plugin;a=blobdiff_plain;f=src%2Fmain%2Fjava%2Fde%2Fjuplo%2Fplugins%2Fhibernate%2FAbstractSchemaMojo.java;h=72ec9d4dccaf48085f1d9647662bd350c658bd9b;hp=6f3ff9763ef09bc76f0b352fd4b283efd65040c9;hb=9c64807d3af68465473aec442bd0d435c0032c3c;hpb=ef0947b306d9515d6af6dbc1fdfd675efcd9eca4 diff --git a/src/main/java/de/juplo/plugins/hibernate/AbstractSchemaMojo.java b/src/main/java/de/juplo/plugins/hibernate/AbstractSchemaMojo.java index 6f3ff976..72ec9d4d 100644 --- a/src/main/java/de/juplo/plugins/hibernate/AbstractSchemaMojo.java +++ b/src/main/java/de/juplo/plugins/hibernate/AbstractSchemaMojo.java @@ -27,7 +27,6 @@ import java.util.regex.Pattern; import javax.persistence.Embeddable; import javax.persistence.Entity; import javax.persistence.MappedSuperclass; -import javax.persistence.spi.PersistenceUnitTransactionType; import org.apache.maven.artifact.Artifact; import org.apache.maven.model.Resource; import org.apache.maven.plugin.AbstractMojo; @@ -485,13 +484,18 @@ public abstract class AbstractSchemaMojo extends AbstractMojo Properties properties = new Properties(); ConfigLoader configLoader = new ConfigLoader(bootstrapServiceRegitry); - /** Loading and merging configuration */ + /** Loading configuration */ properties.putAll(loadProperties(configLoader)); LoadedConfig config = loadConfig(configLoader); if (config != null) properties.putAll(config.getConfigurationValues()); + + /** Add the remaining class-path-elements */ + addDirectDependenciesClassPath(classLoader); + + /** Loading and merging configuration from persistence-unit(s) */ ParsedPersistenceXmlDescriptor unit = - loadPersistenceUnit(classLoaderService, properties); + loadPersistenceUnit(classLoader, properties); if (unit != null) properties.putAll(unit.getProperties()); @@ -518,7 +522,7 @@ public abstract class AbstractSchemaMojo extends AbstractMojo final MetadataSources sources = new MetadataSources(serviceRegistry); /** Add the remaining class-path-elements */ - completeClassPath(classLoader); + addAllDependenciesToClassPath(classLoader); /** Apply mappings from hibernate-configuration, if present */ if (config != null) @@ -534,6 +538,7 @@ public abstract class AbstractSchemaMojo extends AbstractMojo if (scanClasses == null) scanClasses = true; Set urls = new HashSet(); + getLog().debug("Compiling the dependencies, that are scanned for annotated classes"); if (scanClasses) addRoot(urls, outputDirectory); if (scanTestClasses) @@ -546,19 +551,28 @@ public abstract class AbstractSchemaMojo extends AbstractMojo /** Follow configuration in persisten unit */ if (scanClasses == null) scanClasses = !unit.isExcludeUnlistedClasses(); + getLog().debug("Compiling the dependencies, that are scanned for annotated classes"); + Set urls = new HashSet(); if (scanClasses) { + getLog().debug("Only dependencies relative to persistent-unit " + unit.getName() + " are scanned!"); /** * Scan the root of the persiten unit and configured jars for * annotated classes */ + getLog().debug(" - adding " + unit.getPersistenceUnitRootUrl()); urls.add(unit.getPersistenceUnitRootUrl()); for (URL url : unit.getJarFileUrls()) + { + getLog().debug(" - adding " + url); urls.add(url); + } + if (scanTestClasses) + addRoot(urls, testOutputDirectory); } - if (scanTestClasses) - addRoot(urls, testOutputDirectory); + else + getLog().debug("Scanning of unlisted classes is prohibited in persistent-unit " + unit.getName()); classes = scanUrls(urls); for (String className : unit.getManagedClassNames()) classes.add(className); @@ -591,9 +605,10 @@ public abstract class AbstractSchemaMojo extends AbstractMojo * Add mappings from files, that are explicitly configured in the * persistence unit */ + getLog().info("Adding mappings from persistence-unit " + unit.getName()); for (String mapping : unit.getMappingFileNames()) { - getLog().info("Adding explicitly configured mapping from " + mapping); + getLog().info(" - adding " + mapping); is = classLoader.getResourceAsStream(mapping); if (is != null) { @@ -741,6 +756,8 @@ public abstract class AbstractSchemaMojo extends AbstractMojo { builder.append("\n * "); builder.append(e.getMessage()); + AbstractSchemaMojo.printStrackTrace(builder, e); + builder.append("\n"); } String error = builder.toString(); getLog().error(error); @@ -826,20 +843,39 @@ public abstract class AbstractSchemaMojo extends AbstractMojo } } - private void completeClassPath(MutableClassLoader classLoader) + private void addDirectDependenciesClassPath(MutableClassLoader classLoader) throws MojoExecutionException { try { - getLog().debug("Completing class-paths of the ClassLoader for project-dependencies..."); - List classpathFiles = project.getCompileClasspathElements(); + getLog().debug("Adding all direct project-dependencies to the ClassLoader..."); + LinkedHashSet urls = new LinkedHashSet(); + addDependencies(urls); if (scanTestClasses) - classpathFiles.addAll(project.getTestClasspathElements()); + addRoot(urls, testOutputDirectory); + classLoader.add(urls); + } + catch (Exception e) + { + getLog().error("Error while creating ClassLoader!", e); + throw new MojoExecutionException(e.getMessage()); + } + } + + private void addAllDependenciesToClassPath(MutableClassLoader classLoader) + throws + MojoExecutionException + { + try + { + getLog().debug("Adding all project-dependencies to the ClassLoader..."); + List classpathFiles = project.getCompileClasspathElements(); + classpathFiles.addAll(project.getTestClasspathElements()); LinkedHashSet urls = new LinkedHashSet(); for (String pathElement : classpathFiles) { - getLog().debug("Dependency: " + pathElement); + getLog().debug(" - adding " + pathElement); urls.add(new File(pathElement).toURI().toURL()); } classLoader.add(urls); @@ -1158,9 +1194,9 @@ public abstract class AbstractSchemaMojo extends AbstractMojo // TODO: add support to read all mappings under a directory throw new MojoFailureException(file.getAbsolutePath() + " is a directory"); if (tracker.track(filename, new FileInputStream(file))) - getLog().debug("Found new or modified mapping-file: " + filename); + getLog().debug(" - found new or modified mapping-file: " + filename); else - getLog().debug("Mapping-file unchanged: " + filename); + getLog().debug(" - mapping-file unchanged: " + filename); sources.addFile(file); } @@ -1182,9 +1218,15 @@ public abstract class AbstractSchemaMojo extends AbstractMojo File dir = new File(path); if (dir.exists()) { - getLog().info("Adding " + dir.getAbsolutePath() + " to the list of roots to scan..."); + getLog().info(" - adding " + dir.getAbsolutePath()); urls.add(dir.toURI().toURL()); } + else + getLog().warn( + "The directory cannot be scanned for annotated classes, " + + "because it does not exist: " + + dir.getAbsolutePath() + ); } catch (MalformedURLException e) { @@ -1202,7 +1244,7 @@ public abstract class AbstractSchemaMojo extends AbstractMojo Matcher matcher = SPLIT.matcher(scanDependencies); while (matcher.find()) { - getLog().info("Adding dependencies from scope " + matcher.group() + " to the list of roots to scan"); + getLog().debug("Adding dependencies from scope " + matcher.group() + " to the list of roots to scan"); for (Artifact artifact : project.getDependencyArtifacts()) { if (!artifact.getScope().equalsIgnoreCase(matcher.group())) @@ -1212,7 +1254,7 @@ public abstract class AbstractSchemaMojo extends AbstractMojo getLog().warn("Cannot add dependency " + artifact.getId() + ": no JAR-file available!"); continue; } - getLog().info("Adding dependencies from scope " + artifact.getId() + " to the list of roots to scan"); + getLog().debug(" - adding " + artifact.getId()); urls.add(artifact.getFile().toURI().toURL()); } } @@ -1338,20 +1380,36 @@ public abstract class AbstractSchemaMojo extends AbstractMojo } private ParsedPersistenceXmlDescriptor loadPersistenceUnit( - ClassLoaderService classLoaderService, + ClassLoader classLoader, Properties properties ) throws MojoFailureException { - PersistenceXmlParser parser = - new PersistenceXmlParser( - classLoaderService, - PersistenceUnitTransactionType.RESOURCE_LOCAL - ); + Map settings = + Collections.singletonMap( + AvailableSettings.CLASSLOADERS, + Collections.singletonList(classLoader) + ); + // Find all available persistent unit descriptors + List descriptors = + PersistenceXmlParser.locatePersistenceUnits(settings); + // Find all persistent units in the located descriptors Map units = - parser.doResolve(properties); + new HashMap(); + for (ParsedPersistenceXmlDescriptor descriptor : descriptors) + { + String unit = descriptor.getName(); + if (units.containsKey(unit)) + getLog().warn( + "Persistence unit " + unit + + " from " + descriptor.getPersistenceUnitRootUrl() + + " overwrites unit with the same name from " + + units.get(unit).getPersistenceUnitRootUrl() + ); + units.put(unit, descriptor); + } if (persistenceUnit == null) { @@ -1389,4 +1447,24 @@ public abstract class AbstractSchemaMojo extends AbstractMojo throw new MojoFailureException("Could not find persistence-unit " + persistenceUnit); } + + + public static void printStrackTrace(StringBuilder builder, Throwable t) + { + while (t != null) + { + builder.append("\n\tCause: "); + builder.append(t.getMessage() == null ? "" : t.getMessage().replaceAll("\\s+", " ")); + for (StackTraceElement trace : t.getStackTrace()) + { + builder.append("\n\t"); + builder.append(trace.getClassName()); + builder.append("."); + builder.append(trace.getMethodName()); + builder.append("():"); + builder.append(trace.getLineNumber()); + } + t = t.getCause(); + } + } }