Accessing classes in custom maven reporting plugin

问题:

I've written a custom maven reporting plugin to output some basic information about spring-mvc classes. In my internal tests I can see that code like this :

public Set<Class<?>> findControllerClasses(File buildOutputDir) throws IOException, ClassNotFoundException {

    Collection<URL> urls = ClasspathHelper.forJavaClassPath();
    if (buildOutputDir != null) {
        urls.add(buildOutputDir.toURI().toURL());
    }

    Reflections reflections = new Reflections(new ConfigurationBuilder().setUrls(urls));
    Set<Class<?>> types = reflections.getTypesAnnotatedWith(Controller.class);
    return types;
}

Works well at pulling in annotated classes. However, when I use the reporting plugin in another project, annotated classes are not picked up.

Can someone shed some light on how to access the compiled classes for reporting purposes? Or whether this is even possible ??

EDIT : partially solved using the answer to: Add maven-build-classpath to plugin execution classpath

However, this only loads classes if they have no dependencies outside the runtimeClasspathElements var for maven. Is there any way to merge these classes in to the classrealm too ?

回答1:

Maybe use

/**
 * The classpath elements of the project.
 * 
 * @parameter expression="${project.runtimeClasspathElements}"
 * @required
 * @readonly
 */
private List<String> classpathElements;

with

private ClassLoader getProjectClassLoader()
    throws DependencyResolutionRequiredException, MalformedURLException
{
    List<String> classPath = new ArrayList<String>();
    classPath.addAll( classpathElements );
    classPath.add( project.getBuild().getOutputDirectory() );
    URL[] urls = new URL[classPath.size()];
    int i = 0;
    for ( String entry : classPath )
    {
        getLog().debug( "use classPath entry " + entry );
        urls[i] = new File( entry ).toURI().toURL();
        i++; // Important
    }
    return new URLClassLoader( urls );
}

回答2:

Ok. Expanding on the answer in the above comment, the full solution is to use a Configurer that takes into account both the runtime classpath AND the urls from the poms dependencies. Code shown below

/**
 * 
 * @plexus.component 
 *                   role="org.codehaus.plexus.component.configurator.ComponentConfigurator"
 *                   role-hint="include-project-dependencies"
 * @plexus.requirement role=
 *                     "org.codehaus.plexus.component.configurator.converters.lookup.ConverterLookup"
 *                     role-hint="default"
 * 
 */
public class ClassRealmConfigurator extends AbstractComponentConfigurator {

    private final static Logger logger = Logger.getLogger(ClassRealmConfigurator.class.getName());

    public void configureComponent(Object component, PlexusConfiguration configuration, ExpressionEvaluator expressionEvaluator, ClassRealm containerRealm, ConfigurationListener listener) throws ComponentConfigurationException {

        addProjectDependenciesToClassRealm(expressionEvaluator, containerRealm);

        converterLookup.registerConverter(new ClassRealmConverter(containerRealm));

        ObjectWithFieldsConverter converter = new ObjectWithFieldsConverter();

        converter.processConfiguration(converterLookup, component, containerRealm.getClassLoader(), configuration, expressionEvaluator, listener);
    }

    private void addProjectDependenciesToClassRealm(ExpressionEvaluator expressionEvaluator, ClassRealm containerRealm) throws ComponentConfigurationException {
        Set<String> runtimeClasspathElements = new HashSet<String>();
        try {
            runtimeClasspathElements.addAll((List<String>) expressionEvaluator.evaluate("${project.runtimeClasspathElements}"));

        } catch (ExpressionEvaluationException e) {
            throw new ComponentConfigurationException("There was a problem evaluating: ${project.runtimeClasspathElements}", e);
        }

        Collection<URL> urls = buildURLs(runtimeClasspathElements);
        urls.addAll(buildAritfactDependencies(expressionEvaluator));
        for (URL url : urls) {
            containerRealm.addConstituent(url);
        }
    }

    private Collection<URL> buildAritfactDependencies(ExpressionEvaluator expressionEvaluator) throws ComponentConfigurationException {
        MavenProject project;
        try {
            project = (MavenProject) expressionEvaluator.evaluate("${project}");
        } catch (ExpressionEvaluationException e1) {
            throw new ComponentConfigurationException("There was a problem evaluating: ${project}", e1);
        }
        Collection<URL> urls = new ArrayList<URL>();
        for (Object a : project.getArtifacts()) {
            try {
                urls.add(((Artifact) a).getFile().toURI().toURL());
            } catch (MalformedURLException e) {
                throw new ComponentConfigurationException("Unable to resolve artifact dependency: " + a, e);
            }
        }
        return urls;
    }

    private Collection<URL> buildURLs(Set<String> runtimeClasspathElements) throws ComponentConfigurationException {

        List<URL> urls = new ArrayList<URL>(runtimeClasspathElements.size());
        for (String element : runtimeClasspathElements) {
            try {
                final URL url = new File(element).toURI().toURL();
                urls.add(url);
            } catch (MalformedURLException e) {
                throw new ComponentConfigurationException("Unable to access project dependency: " + element, e);
            }
        }

        return urls;
    }

}