Pregunta Colapsar el padre POM en el niño


Dado un proyecto de Maven con un POM principal, que incluye principalmente versiones de plugin y dependencia, ¿cómo puedo generar un POM que tome la información del padre, la coloque en el hijo y elimine la referencia al padre?

Idealmente, esto se haría con el plugin de montaje de maven.


Actualizar: Necesito que esto se haga automáticamente, ya que manualmente es aburrido y tedioso.

Actualización 2: Estoy preparando el código fuente para un externo y quiero entregar solo un proyecto, no a toda la familia.


5
2018-06-04 16:26


origen


Respuestas:


Hace un tiempo tuve un problema similar, puede evitar que Maven sustituya las propiedades y resuelva las rutas, etc. definiendo un nuevo complemento de Maven para hacer lo siguiente.

  • Resuelve a cada padre usando la fábrica de artefactos estándar
  • Lee cada archivo pom (sin resolverlo) usando el MavenXpp3Reader
  • Fusionar los proyectos no resueltos.
  • Escribe el proyecto fusionado en un archivo

Aquí hay un código de prueba que utilicé para probar el proceso por mí mismo, obviamente necesitarías envolverlo en un complemento de Maven y vincularlo a alguna fase de tu proceso. El pom resuelto se envía al directorio de salida (es decir, destino) con el nombre resolvido-pom.xml de manera predeterminada, estas dos propiedades se pueden anular con el método habitual de configuración del complemento de Maven configurando las propiedades "outputDir" y / o "pomfileName" .

package name.seller.rich;

import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;
import java.util.Stack;

import org.apache.maven.artifact.Artifact;
import org.apache.maven.artifact.resolver.ArtifactNotFoundException;
import org.apache.maven.artifact.resolver.ArtifactResolutionException;
import org.apache.maven.model.Model;
import org.apache.maven.model.io.xpp3.MavenXpp3Reader;
import org.apache.maven.plugin.AbstractMojo;
import org.apache.maven.plugin.MojoExecutionException;
import org.apache.maven.plugin.MojoFailureException;
import org.apache.maven.project.MavenProject;
import org.apache.maven.project.inheritance.ModelInheritanceAssembler;
import org.codehaus.plexus.util.xml.pull.XmlPullParserException;

/**
 * @goal output-project
 * @phase process-resources
 * @requiresProject true
 */
public class OutputResolvedProjectMojo extends AbstractMojo {

    /**
     * Used to look up overlay the parent models on the project's model.
     * 
     * @parameter expression=
     *            "${component.org.apache.maven.project.inheritance.ModelInheritanceAssembler}"
     * @required
     * @readonly
     */
    private ModelInheritanceAssembler modelInheritanceAssembler;

    /**
     * Used to look up Artifacts in the remote repository.
     * 
     * @parameter expression=
     *            "${component.org.apache.maven.artifact.factory.ArtifactFactory}"
     * @required
     * @readonly
     */
    protected org.apache.maven.artifact.factory.ArtifactFactory factory;

    /**
     * Used to look up Artifacts in the remote repository.
     * 
     * @parameter expression=
     *            "${component.org.apache.maven.artifact.resolver.ArtifactResolver}"
     * @required
     * @readonly
     */
    protected org.apache.maven.artifact.resolver.ArtifactResolver artifactResolver;

    /**
     * List of Remote Repositories used by the resolver
     * 
     * @parameter expression="${project.remoteArtifactRepositories}"
     * @readonly
     * @required
     */
    protected java.util.List remoteRepos;

    /**
     * Location of the local repository.
     * 
     * @parameter expression="${localRepository}"
     * @readonly
     * @required
     */
    protected org.apache.maven.artifact.repository.ArtifactRepository local;

    /**
     * @parameter expression="${project}"
     * @required
     * @readonly
     */
    private MavenProject mavenProject;

    /**
     * The directory to output the resolved project to.
     * 
     * @parameter expression="${project.build.directory}"
     */
    private File outputDir;

    /**
     * The directory to output the resolved project to.
     * 
     * @parameter expression="resolved-pom.xml"
     */
    private String pomfileName;

    public void execute() throws MojoExecutionException, MojoFailureException {
        MavenProject parentProject = mavenProject.getParent();

        // get the unresolved project by reading the file
        MavenProject bareProject = readBareProject(mavenProject.getFile());

        Stack hierarchy = new Stack();
        hierarchy.push(bareProject);

        try {
            while (parentProject != null) {

                try {
                    // get Maven to resolve the parent artifact (download if
                    // needed)
                    Artifact pomArtifact = this.factory.createArtifact(
                            parentProject.getGroupId(), parentProject
                                    .getArtifactId(), parentProject
                                    .getVersion(), "", "pom");

                    artifactResolver.resolve(pomArtifact, this.remoteRepos,
                            this.local);

                    // get the file from the local repository and read the bare
                    // project
                    File parentPomFile = pomArtifact.getFile();

                    parentProject = readBareProject(parentPomFile);

                    hierarchy.push(parentProject);

                    parentProject = parentProject.getParent();
                } catch (ArtifactResolutionException e) {
                    getLog().error("can't resolve parent pom", e);
                } catch (ArtifactNotFoundException e) {
                    getLog().error("can't resolve parent pom", e);
                }
            }

            // merge each model starting with the oldest ancestors
            MavenProject currentParent = (MavenProject) hierarchy.pop();
            MavenProject currentProject = null;
            while (hierarchy.size() != 0) {
                currentProject = (MavenProject) hierarchy.pop();
                modelInheritanceAssembler.assembleModelInheritance(
                        currentProject.getModel(), currentParent.getModel());
                currentParent = currentProject;
            }

            // spit the merged model to the output file.
            Writer writer = getWriter(outputDir, pomfileName);

            if (writer != null) {
                currentProject.writeModel(writer);
                writer.close();
            }
        } catch (IOException e) {
            getLog().error("can't write resolved pom", e);
        }

    }

    /**
     * Creates and returns a writer for outputting the project to a pom file.
     * 
     * @param logDir
     *            the directory to output the file to.
     * @param logFileName
     *            name of the log file
     * @return the writer.
     * @throws IOException
     *             if the writer cannot be created.
     */
    private Writer getWriter(final File logDir, final String logFileName)
            throws IOException {
        if (!logDir.exists()) {
            logDir.mkdirs();
        }

        File pomLog = new File(logDir, logFileName);

        if (!pomLog.exists()) {
            pomLog.createNewFile();
        }

        return new FileWriter(pomLog);
    }

    /**
     * Read the mavenProject without resolving any inherited settings.
     * 
     * @return the MavenProject for the project's POM
     * @throws MojoExecutionException
     *             if the POM can't be parsed.
     */
    MavenProject readBareProject(final File file) {
        MavenXpp3Reader reader = new MavenXpp3Reader();
        Model model = null;
        try {
            model = reader.read(new FileReader(file));
        } catch (IOException e) {
            getLog().error("can't read pom file", e);
        } catch (XmlPullParserException e) {
            getLog().error("can't read pom file", e);
        }

        return new MavenProject(model);
    }
}

4
2018-06-16 13:42



haría mvn help:effective-pom hacer lo que necesitas? Puede enviar la salida a un archivo con -Doutput=new-pom.xml.


2
2018-06-05 12:46



Si no desea un padre, puede probar el patrón BOM (Lista de materiales) y seleccionar ese pom para importar en la sección de administración de dependencias.

Como no desea referencias a ninguna otra cosa, deberá crear una aplicación para analizar el xml de los "padres" y luego escribirlos en el archivo pom de destino en la sección de dependencias. No creo que haya ningún complemento para hacer lo que quieres, ya que parece ir en contra de la esencia misma de cómo se supone que Maven debe ayudarte. El punto central de Maven es para que pueda incluir todas sus dependencias mediante herencia o importándolas con el alcance de importación.

Otra opción, pero creo que lo ha excluido, es mantener su archivo POM liberable por separado. Aunque creo que puede encontrar un momento más fácil con esto si hace referencia a LATEST o SNAPSHOTS y luego usa el complemento de versión para resolverlos a las versiones publicadas.


1
2018-06-04 18:11