Java MavenXpp3Writer类代码示例

import org.apache.maven.model.io.xpp3.MavenXpp3Writer; //导入依赖的package包/类
@And("^POM file with dependencies:$")
public void pomFileWithDependencies(List<MavenDependencySpec> dependencies) throws Throwable {
  for (MavenDependencySpec dependency : dependencies) {
    dependency.setExcludes(dependency.excludes);
  }

  Model model = new Model();
  model.setModelVersion("4.0.0");
  model.setGroupId("com.example");
  model.setArtifactId("example-artifact");
  model.setVersion("1.0.0-SNAPSHOT");
  model.setPackaging("pom");
  dependencies.forEach(model::addDependency);

  Path pomFile = projectDir.resolve("pom.xml");
  new MavenXpp3Writer().write(Files.newBufferedWriter(pomFile), model);
}
 

import org.apache.maven.model.io.xpp3.MavenXpp3Writer; //导入依赖的package包/类
public POMData(ParentData parentData, String groupId, String artifactId, String versionId,
               List<DependencyData>
        dependencies, List<RepositoryData> repositories) throws IOException {
    Model model = new Model();
    parentData.write(model);
    model.setGroupId(groupId);
    model.setArtifactId(artifactId);
    model.setVersion(versionId);
    model.setModelVersion("4.0.0");
    dependencies.forEach((dependencyData -> dependencyData.write(model)));
    repositories.forEach((repositoryData -> repositoryData.write(model)));
    this.dependencies = dependencies;
    this.repositories = repositories;
    this.groupId = groupId;
    this.artifactId = artifactId;
    this.version = versionId;
    StringWriter writer = new StringWriter();
    new MavenXpp3Writer().write(writer, model);
    this.xml = writer.toString();
}
 

import org.apache.maven.model.io.xpp3.MavenXpp3Writer; //导入依赖的package包/类
private File createPom( File targetPath, String filename, FileMetadata fileMetadata, String groupId,
                        String artifactId, String version, String packaging )
    throws IOException
{
    Model projectModel = new Model();
    projectModel.setModelVersion( "4.0.0" );
    projectModel.setGroupId( groupId );
    projectModel.setArtifactId( artifactId );
    projectModel.setVersion( version );
    projectModel.setPackaging( packaging );

    File pomFile = new File( targetPath, filename );
    MavenXpp3Writer writer = new MavenXpp3Writer();

    try (FileWriter w = new FileWriter( pomFile ))
    {
        writer.write( w, projectModel );
    }

    return pomFile;
}
 

import org.apache.maven.model.io.xpp3.MavenXpp3Writer; //导入依赖的package包/类
public String write(Manifest manifest, ArtifactDescriptor artifact) {
    MavenXpp3Writer writer = new MavenXpp3Writer();
    Model model = new Model();

    addProjectInformation(manifest, artifact, model);
    addRequiresDependency(manifest, model);
    addArchiveDependencies(manifest, model);
    addBinaryDependencies(manifest, model);
    addRepositories(manifest, model);

    StringWriter sw = new StringWriter();
    try {
        writer.write(sw, model);
    }
    catch (IOException e) {
    }
    return sw.toString();
}
 

import org.apache.maven.model.io.xpp3.MavenXpp3Writer; //导入依赖的package包/类
private static void generatePOM(Path pomFile, String groupId, String artifactId, List<String> dependencies)
        throws IOException {
    Model pom = new Model();
    pom.setModelVersion(MODEL_VERSION);

    pom.setGroupId(groupId);
    pom.setArtifactId(artifactId);
    pom.setVersion(VERSION.toString());
    pom.setPackaging("jar");
    pom.setName(artifactId + ": fabricated POM for testing");

    for (String dependency: dependencies) {
        pom.addDependency(createMavenDependency(dependency, TYPE));
        pom.addDependency(createMavenDependency(dependency, "jar"));
    }

    MavenXpp3Writer writer = new MavenXpp3Writer();
    try (OutputStream outputStream = Files.newOutputStream(pomFile)) {
        writer.write(outputStream, pom);
    }
}
 

import org.apache.maven.model.io.xpp3.MavenXpp3Writer; //导入依赖的package包/类
/**
 * Add the Maven dependency to the new created project
 */
private void addDependency(Model model, IMavenProjectFacade facade) {
	String latestVersion = getLatestVersion();

	Dependency dependency = new Dependency();
	dependency.setGroupId(groupId);
	dependency.setArtifactId(artifactId);
	dependency.setVersion(latestVersion);

	model.addDependency(dependency);

	try {
		FileOutputStream fos = new FileOutputStream(facade.getPomFile());
		new MavenXpp3Writer().write(fos, model);
	} catch (IOException e) {
	}
}
 

import org.apache.maven.model.io.xpp3.MavenXpp3Writer; //导入依赖的package包/类
/**
 * org.apache.maven.plugins.help.EffectivePomMojo#writeEffectivePom
 */
private static void writeEffectivePom(MavenProject project, XMLWriter writer)
  throws MojoExecutionException {
  Model pom = project.getModel();
  cleanModel(pom);

  String effectivePom;

  StringWriter sWriter = new StringWriter();
  MavenXpp3Writer pomWriter = new MavenXpp3Writer();
  try {
    pomWriter.write(sWriter, pom);
  }
  catch (IOException e) {
    throw new MojoExecutionException("Cannot serialize POM to XML.", e);
  }

  effectivePom = addMavenNamespace(sWriter.toString(), true);

  writeComment(writer, "Effective POM for project \'" + project.getId() + "\'");

  writer.writeMarkup(effectivePom);
}
 

import org.apache.maven.model.io.xpp3.MavenXpp3Writer; //导入依赖的package包/类
@Test
public void testReadModel() throws IOException {

    // PREPARE
    final String expected = IOUtils.toString(getClass()
            .getResourceAsStream("/objects4j.xml"), Charset.forName("ISO-8859-1"));

    // TEST
    final Model model = MavenPomReader
            .readModel("org.fuin:objects4j:0.6.1");

    // VERIFY
    final MavenXpp3Writer writer = new MavenXpp3Writer();
    final StringWriter sw = new StringWriter();
    writer.write(sw, model);
    assertThat(sw.toString()).isEqualTo(expected);
    assertThat(model.getName()).isEqualTo("Objects4J");
    assertThat(model.getScm()).isNotNull();
    assertThat(model.getScm().getUrl()).isEqualTo("https://github.com/fuinorg/objects4j/");
    
    

}
 

import org.apache.maven.model.io.xpp3.MavenXpp3Writer; //导入依赖的package包/类
/**
 * method from org.apache.maven.plugins.help.EffectivePomMojo Method for writing the effective pom
 * informations of the current build.
 *
 * @param project the project of the current build, not null.
 * @param writer the XML writer , not null, not null.
 * @throws MojoExecutionException if any
 */
private static void writeEffectivePom(MavenProject project, XMLWriter writer)
    throws MojoExecutionException {
  Model pom = project.getModel();
  cleanModel(pom);

  String effectivePom;

  StringWriter sWriter = new StringWriter();
  MavenXpp3Writer pomWriter = new MavenXpp3Writer();
  try {
    pomWriter.write(sWriter, pom);
  } catch (IOException e) {
    throw new MojoExecutionException("Cannot serialize POM to XML.", e);
  }

  effectivePom = addMavenNamespace(sWriter.toString(), true);

  writeComment(writer, "Effective POM for project \'" + project.getId() + "\'");

  writer.writeMarkup(effectivePom);
}
 

import org.apache.maven.model.io.xpp3.MavenXpp3Writer; //导入依赖的package包/类
public String generatePOM(final GAV gav) {
    Model model = new Model();
    model.setGroupId(gav.getGroupId());
    model.setArtifactId(gav.getArtifactId());
    model.setVersion(gav.getVersion());
    model.setModelVersion("4.0.0");

    StringWriter stringWriter = new StringWriter();
    try {
        new MavenXpp3Writer().write(stringWriter,
                                    model);
    } catch (IOException e) {
        log.error(e.getMessage());
    }

    return stringWriter.toString();
}
 

import org.apache.maven.model.io.xpp3.MavenXpp3Writer; //导入依赖的package包/类
public String generateParentPOM(final GAV gav) {
    Model model = new Model();
    model.setGroupId(gav.getGroupId());
    model.setArtifactId(gav.getArtifactId());
    model.setVersion(gav.getVersion());
    model.setPackaging("pom");
    model.setModelVersion("4.0.0");

    StringWriter stringWriter = new StringWriter();
    try {
        new MavenXpp3Writer().write(stringWriter,
                                    model);
    } catch (IOException e) {
        log.error(e.getMessage());
    }

    return stringWriter.toString();
}
 

import org.apache.maven.model.io.xpp3.MavenXpp3Writer; //导入依赖的package包/类
private String toString(final POM pom,
                        final Model model) throws IOException {
    model.setName(pom.getName());
    model.setDescription(pom.getDescription());
    model.setArtifactId(pom.getGav().getArtifactId());
    model.setModelVersion(pom.getModelVersion());

    model.setGroupId(pom.getGav().getGroupId());
    model.setVersion(pom.getGav().getVersion());

    model.setPackaging(pom.getPackaging());

    model.setParent(getParent(pom));
    model.setBuild(getBuild(pom,
                            model));
    model.setModules(getModules(pom));
    model.setRepositories(getRepositories(pom));
    new DependencyUpdater(model.getDependencies()).updateDependencies(pom.getDependencies());

    StringWriter stringWriter = new StringWriter();
    new MavenXpp3Writer().write(stringWriter,
                                model);
    return stringWriter.toString();
}
 

import org.apache.maven.model.io.xpp3.MavenXpp3Writer; //导入依赖的package包/类
private Path createPom( Path targetPath, String filename, FileMetadata fileMetadata, String groupId,
                        String artifactId, String version, String packaging )
    throws IOException
{
    Model projectModel = new Model();
    projectModel.setModelVersion( "4.0.0" );
    projectModel.setGroupId( groupId );
    projectModel.setArtifactId( artifactId );
    projectModel.setVersion( version );
    projectModel.setPackaging( packaging );

    Path pomFile = targetPath.resolve( filename );
    MavenXpp3Writer writer = new MavenXpp3Writer();

    try (FileWriter w = new FileWriter( pomFile.toFile() ))
    {
        writer.write( w, projectModel );
    }

    return pomFile;
}
 

import org.apache.maven.model.io.xpp3.MavenXpp3Writer; //导入依赖的package包/类
@Override
public void generate() {
    logger.info("Creating the pom file {}", POM_FILE);
    File pom = new File(baseDir, POM_FILE);
    OutputStreamWriter fileWriter = null;
    try {
        fileWriter = new OutputStreamWriter(new FileOutputStream(pom), Charsets.UTF_8);
        logger.debug("Writing the generated pom file {}", POM_FILE);
        MavenXpp3Writer writer = new MavenXpp3Writer();
        writer.write(fileWriter, model);
    } catch (Exception e) {
        throw new MinnalGeneratorException("Failed while writing the pom - " + pom.getName(), e);
    } finally {
        closeStream(fileWriter);
    }
}
 

import org.apache.maven.model.io.xpp3.MavenXpp3Writer; //导入依赖的package包/类
public void write( Writer output, Map<String, Object> options, Model model )
    throws IOException
{
    if ( output == null )
    {
        throw new IllegalArgumentException( "output writer missing" );
    }

    if ( model == null )
    {
        throw new IllegalArgumentException( "model missing" );
    }

    try
    {
        MavenXpp3Writer w = new MavenXpp3Writer();
        w.write( output, model );
    }
    finally
    {
        IOUtil.close( output );
    }
}