Collasso POM genitore nel bambino

Question

Dato un progetto Maven con un POM genitore - tra cui la maggior parte dei plugin e le versioni con le dipendenze -? Come posso generare un POM, che prende le informazioni dal genitore, la pone nel bambino e rimuove il riferimento al genitore

Idealmente questo sarebbe stato fatto con l'esperto di montaggio-plugin.

---

Aggiorna :. Ho bisogno di questo fatto automaticamente, in quanto manualmente è noioso e noioso

Aggiorna 2 :. Sto preparando il codice sorgente per una esterna e si desidera fornire un solo progetto, non tutta la famiglia

Answer 1

Ho avuto un problema simile un po 'indietro, si può evitare di Maven sostituendo le proprietà e la risoluzione dei percorsi, ecc definendo un nuovo plugin Maven fare quanto segue.

• Risolvere ciascun genitore con la fabbrica manufatto di serie
• Leggi ogni file pom (senza risolverlo) utilizzando il MavenXpp3Reader
• Unisci i progetti irrisolti
• Scrivi il progetto fuse in un file

Ecco alcuni codice di prova che ho usato per dimostrare il processo per me, avresti ovviamente bisogno di avvolgere questo in un plugin Maven e si legano che in una certa fase del processo. Il pom risolto è uscita nella directory di output (cioè di destinazione) con il nome risolto-pom.xml per impostazione predefinita, queste due proprietà possono essere sostituite con la consueta Maven plug approccio configurazione impostando il "OutputDir" e / o "pomfileName" proprietà .

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);
    }
}

Answer 2

Sarebbe mvn help:effective-pom fai quello che ti serve? È possibile inviare l'output in un file con -Doutput=new-pom.xml.

Answer 3

Se non si desidera che un genitore si può provare il BOM (Bill of materiali) modello e selezionare il pom per l'importazione nella tua sezione di gestione dipendenza.

Dal momento che si desidera alcun riferimento a qualsiasi altra cosa, è necessario costruire un app per analizzare il codice XML dai "genitori" e poi scrivere il file di destinazione pom nella sezione dipendenze. Io non credo che ci sia alcun plugin per fare quello che vuoi in quanto sembra andare contro il cuore di come si suppone Maven per aiutarvi. Il punto di Maven è così che è possibile includere tutte le dipendenze utilizzando successione o di importarli con lo scopo di importazione.

Un'altra opzione, ma penso che hai escluso che, è quello di mantenere il file POM rilasciabile separatamente. Anche se penso che si può trovare un tempo più facile con questo se si fa riferimento ULTIME o snapshot e quindi utilizzare il plugin di rilascio per risolverli a versioni rilasciate.