Java tutorial
/** * Copyright 2010 CosmoCode GmbH * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package de.cosmocode.palava.maven.ipcstub; import java.io.File; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; import java.net.MalformedURLException; import java.net.URL; import java.util.List; import java.util.Set; import org.apache.maven.artifact.DependencyResolutionRequiredException; import org.apache.maven.plugin.AbstractMojo; import org.apache.maven.plugin.MojoExecutionException; import org.apache.maven.plugin.MojoFailureException; import org.apache.maven.plugin.logging.Log; import org.apache.maven.project.MavenProject; import com.google.common.base.Function; import com.google.common.base.Joiner; import com.google.common.base.Predicate; import com.google.common.collect.Iterables; import com.google.common.collect.Lists; import com.google.common.collect.Sets; import com.google.gag.annotation.remark.OhNoYouDidnt; import de.cosmocode.commons.reflect.Classpath; import de.cosmocode.commons.reflect.Reflection; import de.cosmocode.palava.ipc.IpcCommand; /* CHECKSTYLE:OFF */ /** * Generates stub files for all found IpcCommands in the classpath. * * @description Generates stub files for all found IpcCommands in the classpath. * @goal generate-ipcstub * @requiresDependencyResolution runtime * @author Tobias Sarnowski */ public class GeneratorModule extends AbstractMojo { /* CHECKSTYLE:ON */ private final Log log = getLog(); /** * The maven project. * * @parameter expression="${project}" * @required * @readonly */ private MavenProject project; /** * List of all generators the use with their configuration. * * @parameter * @required */ private List<Generator> generators; /** * The generators. * * @return the configured generators */ public List<Generator> getGenerators() { return generators; } /** * Generates stub files for all found IpcCommands in the classpath. * * {@inheritDoc} */ @Override public void execute() throws MojoExecutionException, MojoFailureException { final File targetDirectory = new File(project.getBuild().getOutputDirectory(), "ipcstub"); // check configurations and aggregate all required packages final Set<String> allPackages = Sets.newHashSet(); for (Generator generator : generators) { generator.check(); allPackages.addAll(generator.getPackages()); } log.info("Searching for IpcCommands in:"); for (String pkg : allPackages) { log.info(" " + pkg); } // search for IpcCommands in all required packages final Set<Class<? extends IpcCommand>> foundClasses = Sets.newTreeSet(Reflection.orderByName()); Iterables.addAll(foundClasses, generateCommandList(allPackages)); log.info("Found " + foundClasses.size() + " IpcCommands; generating stubs..."); // filter classes and let the generators do their work for (Generator generator : generators) { final Set<Class<? extends IpcCommand>> filteredClasses = Sets.newLinkedHashSet(); for (Class<? extends IpcCommand> foundClass : foundClasses) { for (String requiredPackage : generator.getPackages()) { if (foundClass.getName().startsWith(requiredPackage + ".")) { filteredClasses.add(foundClass); break; } } } // whats the target directory? final File stubTargetDirectory = new File(targetDirectory, generator.getName()); // now call the generator generator.generate(log, filteredClasses, stubTargetDirectory); } } private Iterable<Class<? extends IpcCommand>> generateCommandList(Set<String> packages) throws MojoExecutionException { // create the classpath to use final List<File> locations = Lists.newArrayList(); try { for (Object element : project.getRuntimeClasspathElements()) { log.debug("Adding runtime classpath element: " + element); locations.add(new File((String) element)); } } catch (DependencyResolutionRequiredException e) { throw new MojoExecutionException("dependencies not resolved", e); } // hack: add the required files to the classloader boostrapClassloader(Iterables.transform(locations, new Function<File, URL>() { @Override public URL apply(File from) { try { return from.toURI().toURL(); } catch (MalformedURLException e) { throw new IllegalArgumentException(e); } } })); final String value = Joiner.on(File.pathSeparator).join(locations); final Classpath cp = Reflection.classpathOf(value); final Predicate<Class<?>> predicate = Reflection.isConcreteClass(); return cp.restrictTo(packages).filter(IpcCommand.class, predicate); } /** * WARNING: dirtiest maven hack ever! * @param classpath elements to add to the current classpath */ @OhNoYouDidnt private static void boostrapClassloader(Iterable<URL> classpath) { final Method method; try { final ClassLoader classloader = Thread.currentThread().getContextClassLoader(); final Class<? extends ClassLoader> classloaderClass = classloader.getClass(); method = classloaderClass.getSuperclass().getDeclaredMethod("addURL", URL.class); } catch (NoSuchMethodException e) { throw new IllegalStateException("used classloader has no addURL method", e); } final boolean accessible = method.isAccessible(); method.setAccessible(true); try { for (URL url : classpath) { method.invoke(Thread.currentThread().getContextClassLoader(), url); } } catch (IllegalAccessException e) { throw new IllegalStateException("cannot call classloader's addURL method", e); } catch (InvocationTargetException e) { throw new IllegalStateException("cannot call classloader's addURL method", e); } finally { method.setAccessible(accessible); } } }