Java Artifact类代码示例

import org.apache.ivy.core.module.descriptor.Artifact; //导入依赖的package包/类
private void deployEffectivePom( ModuleRevisionId moduleRevisionId, Path artifactPath )
    throws IOException
{
    try
    {
        File pomFile = artifactPath.resolveSibling( artifactPath.getName( artifactPath.getNameCount() - 1 )
            + "-xmvn.pom" ).toFile();
        ModuleDescriptorParser parser = XmlModuleDescriptorParser.getInstance();
        ModuleDescriptor module =
            parser.parseDescriptor( getSettings(), artifactPath.toFile().toURI().toURL(), false );
        PomModuleDescriptorWriter.write( module, pomFile, new PomWriterOptions() );

        org.fedoraproject.xmvn.artifact.Artifact artifact = ivy2aether( moduleRevisionId, "pom" );
        deploy( artifact, null, artifactPath );
    }
    catch ( ParseException e )
    {
        throw new IOException( e );
    }
}
 

import org.apache.ivy.core.module.descriptor.Artifact; //导入依赖的package包/类
static void populateModuleDescriptorWithPublication(DefaultModuleDescriptor descriptor,
        JkMavenPublication publication, Instant publishDate) {

    final ModuleRevisionId moduleRevisionId = descriptor.getModuleRevisionId();
    final String artifactName = moduleRevisionId.getName();
    final Artifact mavenMainArtifact = toPublishedMavenArtifact(publication.mainArtifactFiles()
            .get(0), artifactName, null, moduleRevisionId, publishDate);
    final String mainConf = "default";
    populateDescriptorWithMavenArtifact(descriptor, mainConf, mavenMainArtifact);

    for (final JkClassifiedFileArtifact artifactEntry : publication.classifiedArtifacts()) {
        final Path file = artifactEntry.file();
        final String classifier = artifactEntry.classifier();
        final Artifact mavenArtifact = toPublishedMavenArtifact(file, artifactName, classifier,
                descriptor.getModuleRevisionId(), publishDate);
        populateDescriptorWithMavenArtifact(descriptor, classifier, mavenArtifact);
    }
}
 

import org.apache.ivy.core.module.descriptor.Artifact; //导入依赖的package包/类
private void populateArtifactsFromDescriptor() {
    Map<Artifact, ModuleComponentArtifactMetaData> artifactToMetaData = Maps.newLinkedHashMap();
    for (Artifact descriptorArtifact : getDescriptor().getAllArtifacts()) {
        ModuleComponentArtifactMetaData artifact = artifact(descriptorArtifact);
        artifactToMetaData.put(descriptorArtifact, artifact);
    }

    artifacts = Sets.newLinkedHashSet(artifactToMetaData.values());

    this.artifactsByConfig = LinkedHashMultimap.create();
    for (String configuration : getDescriptor().getConfigurationsNames()) {
        Artifact[] configArtifacts = getDescriptor().getArtifacts(configuration);
        for (Artifact configArtifact : configArtifacts) {
            artifactsByConfig.put(configuration, artifactToMetaData.get(configArtifact));
        }
    }
}
 

import org.apache.ivy.core.module.descriptor.Artifact; //导入依赖的package包/类
public void addArtifact(IvyArtifactName newArtifact, Set<String> configurations) {
    if (configurations.isEmpty()) {
        throw new IllegalArgumentException("Artifact should be attached to at least one configuration.");
    }

    MDArtifact unattached = new MDArtifact(module, newArtifact.getName(), newArtifact.getType(), newArtifact.getExtension(), null, newArtifact.getAttributes());
    //Adding the artifact will replace any existing artifact
    //This potentially leads to loss of information - the configurations of the replaced artifact are lost (see GRADLE-123)
    //Hence we attempt to find an existing artifact and merge the information
    Artifact[] allArtifacts = module.getAllArtifacts();
    for (Artifact existing : allArtifacts) {
        // Can't just compare the raw IvyArtifactName, since creating MDArtifact creates a bunch of attributes
        if (artifactsEqual(unattached, existing)) {
            if (!(existing instanceof MDArtifact)) {
                throw new IllegalArgumentException("Cannot update an existing artifact (" + existing + ") in provided module descriptor (" + module + ")"
                        + " because the artifact is not an instance of MDArtifact." + module);
            }
            attachArtifact((MDArtifact) existing, configurations, module);
            return; //there is only one matching artifact
        }
    }
    attachArtifact(unattached, configurations, module);
}
 

import org.apache.ivy.core.module.descriptor.Artifact; //导入依赖的package包/类
public void publish(IvyNormalizedPublication publication, PublicationAwareRepository repository) {
    ModuleVersionPublisher publisher = repository.createPublisher();
    IvyPublicationIdentity projectIdentity = publication.getProjectIdentity();
    ModuleRevisionId moduleRevisionId = IvyUtil.createModuleRevisionId(projectIdentity.getOrganisation(), projectIdentity.getModule(), projectIdentity.getRevision());
    ModuleVersionIdentifier moduleVersionIdentifier = DefaultModuleVersionIdentifier.newId(moduleRevisionId);
    DefaultIvyModulePublishMetaData publishMetaData = new DefaultIvyModulePublishMetaData(moduleVersionIdentifier);

    try {
        for (IvyArtifact publishArtifact : publication.getArtifacts()) {
            Artifact ivyArtifact = createIvyArtifact(publishArtifact, moduleRevisionId);
            publishMetaData.addArtifact(ivyArtifact, publishArtifact.getFile());
        }

        Artifact artifact = DefaultArtifact.newIvyArtifact(moduleRevisionId, null);
        publishMetaData.addArtifact(artifact, publication.getDescriptorFile());

        publisher.publish(publishMetaData);
    } catch (IOException e) {
        throw new UncheckedIOException(e);
    }
}
 

import org.apache.ivy.core.module.descriptor.Artifact; //导入依赖的package包/类
public void publish(ModuleVersionPublishMetaData moduleVersion) throws IOException {
    boolean successfullyPublished = false;
    try {
        ModuleVersionIdentifier id = moduleVersion.getId();
        ModuleRevisionId ivyId = IvyUtil.createModuleRevisionId(id.getGroup(), id.getName(), id.getVersion());
        resolver.beginPublishTransaction(ivyId, true);
        for (ModuleVersionArtifactPublishMetaData artifactMetaData : moduleVersion.getArtifacts()) {
            Artifact artifact = artifactMetaData.toIvyArtifact();
            File artifactFile = artifactMetaData.getFile();
            resolver.publish(artifact, artifactFile, true);
        }
        resolver.commitPublishTransaction();
        successfullyPublished = true;
    } finally {
        if (!successfullyPublished) {
            resolver.abortPublishTransaction();
        }
    }
}
 

import org.apache.ivy.core.module.descriptor.Artifact; //导入依赖的package包/类
public Artifact createIvyArtifact(PublishArtifact publishArtifact, ModuleRevisionId moduleRevisionId) {
    Map<String, String> extraAttributes = new HashMap<String, String>();
    if (GUtil.isTrue(publishArtifact.getClassifier())) {
        extraAttributes.put(Dependency.CLASSIFIER, publishArtifact.getClassifier());
    }
    String name = publishArtifact.getName();
    if (!GUtil.isTrue(name)) {
        name = moduleRevisionId.getName();
    }
    return new DefaultArtifact(
            moduleRevisionId,
            publishArtifact.getDate(),
            name,
            publishArtifact.getType(),
            publishArtifact.getExtension(),
            extraAttributes);
}
 

import org.apache.ivy.core.module.descriptor.Artifact; //导入依赖的package包/类
public EnhancedArtifactDownloadReport download(Artifact artifact, ArtifactResourceResolver resourceResolver, ResourceDownloader resourceDownloader, CacheDownloadOptions options) {
    ResolvedResource resolvedResource = resourceResolver.resolve(artifact);
    long start = System.currentTimeMillis();
    EnhancedArtifactDownloadReport report = new EnhancedArtifactDownloadReport(artifact);
    if (resolvedResource == null) {
        report.setDownloadStatus(DownloadStatus.FAILED);
        report.setDownloadDetails(ArtifactDownloadReport.MISSING_ARTIFACT);
        report.setDownloadTimeMillis(System.currentTimeMillis() - start);
        return report;
    }
    assert resolvedResource.getResource().isLocal();
    File file = new File(resolvedResource.getResource().getName());
    assert file.isFile();

    ArtifactOrigin origin = new ArtifactOrigin(artifact, true, file.getAbsolutePath());
    report.setDownloadStatus(DownloadStatus.NO);
    report.setArtifactOrigin(origin);
    report.setSize(file.length());
    report.setLocalFile(file);
    return report;
}
 

import org.apache.ivy.core.module.descriptor.Artifact; //导入依赖的package包/类
public ResolvedModuleRevision cacheModuleDescriptor(DependencyResolver resolver, ResolvedResource resolvedResource, DependencyDescriptor dd, Artifact moduleArtifact, ResourceDownloader downloader, CacheMetadataOptions options) throws ParseException {
    if (!moduleArtifact.isMetadata()) {
        return null;
    }

    assert resolvedResource.getResource().isLocal();
    File file = new File(resolvedResource.getResource().getName());
    assert file.isFile();

    ArtifactOrigin origin = new ArtifactOrigin(moduleArtifact, true, file.getAbsolutePath());
    MetadataArtifactDownloadReport report = new MetadataArtifactDownloadReport(moduleArtifact);
    report.setDownloadStatus(DownloadStatus.NO);
    report.setArtifactOrigin(origin);
    report.setSize(file.length());
    report.setLocalFile(file);
    report.setSearched(false);
    report.setOriginalLocalFile(file);

    ModuleDescriptor descriptor = parseModuleDescriptor(resolver, moduleArtifact, options, file, resolvedResource.getResource());
    return new ResolvedModuleRevision(resolver, resolver, descriptor, report);
}
 

import org.apache.ivy.core.module.descriptor.Artifact; //导入依赖的package包/类
public void resolveArtifact(ComponentArtifactMetaData artifact, ModuleSource moduleSource, BuildableArtifactResolveResult result) {
    Artifact ivyArtifact = ((ModuleVersionArtifactMetaData) artifact).toIvyArtifact();
    ArtifactDownloadReport artifactDownloadReport = resolver.download(new Artifact[]{ivyArtifact}, downloadOptions).getArtifactReport(ivyArtifact);
    if (downloadFailed(artifactDownloadReport)) {
        if (artifactDownloadReport instanceof EnhancedArtifactDownloadReport) {
            EnhancedArtifactDownloadReport enhancedReport = (EnhancedArtifactDownloadReport) artifactDownloadReport;
            result.failed(new ArtifactResolveException(artifact.getId(), enhancedReport.getFailure()));
        } else {
            result.failed(new ArtifactResolveException(artifact.getId(), artifactDownloadReport.getDownloadDetails()));
        }
        return;
    }

    File localFile = artifactDownloadReport.getLocalFile();
    if (localFile != null) {
        result.resolved(localFile);
    } else {
        result.notFound(artifact.getId());
    }
}
 

import org.apache.ivy.core.module.descriptor.Artifact; //导入依赖的package包/类
private Set<ModuleVersionArtifactMetaData> doGetCandidateArtifacts(ModuleVersionMetaData module, Class<? extends SoftwareArtifact> artifactType) {
    if (artifactType == IvyDescriptorArtifact.class) {
        Artifact metadataArtifact = module.getDescriptor().getMetadataArtifact();
        return ImmutableSet.of(module.artifact(metadataArtifact));
    }

    if (artifactType == JvmLibraryJavadocArtifact.class) {
        return createArtifactMetaData(module, "javadoc", "javadoc");
    }

    if (artifactType == JvmLibrarySourcesArtifact.class) {
        return createArtifactMetaData(module, "source", "sources");
    }

    throw new IllegalArgumentException(String.format("Cannot find artifacts of type %s in %s", artifactType.getName(), module));
}
 

import org.apache.ivy.core.module.descriptor.Artifact; //导入依赖的package包/类
public void publish(IvyNormalizedPublication publication, PublicationAwareRepository repository) {
    ModuleVersionPublisher publisher = repository.createPublisher();
    IvyPublicationIdentity projectIdentity = publication.getProjectIdentity();
    ModuleRevisionId moduleRevisionId = IvyUtil.createModuleRevisionId(projectIdentity.getOrganisation(), projectIdentity.getModule(), projectIdentity.getRevision());
    ModuleVersionIdentifier moduleVersionIdentifier = DefaultModuleVersionIdentifier.newId(moduleRevisionId);
    DefaultModuleVersionPublishMetaData publishMetaData = new DefaultModuleVersionPublishMetaData(moduleVersionIdentifier);

    try {
        for (IvyArtifact publishArtifact : publication.getArtifacts()) {
            Artifact ivyArtifact = createIvyArtifact(publishArtifact, moduleRevisionId);
            publishMetaData.addArtifact(ivyArtifact, publishArtifact.getFile());
        }

        Artifact artifact = DefaultArtifact.newIvyArtifact(moduleRevisionId, null);
        publishMetaData.addArtifact(artifact, publication.getDescriptorFile());

        publisher.publish(publishMetaData);
    } catch (IOException e) {
        throw new UncheckedIOException(e);
    }
}
 

import org.apache.ivy.core.module.descriptor.Artifact; //导入依赖的package包/类
private void populateArtifactsFromDescriptor() {
    Map<Artifact, ModuleComponentArtifactMetaData> artifactToMetaData = Maps.newLinkedHashMap();
    for (Artifact descriptorArtifact : getDescriptor().getAllArtifacts()) {
        IvyArtifactName artifactName = DefaultIvyArtifactName.forIvyArtifact(descriptorArtifact);
        ModuleComponentArtifactMetaData artifact = new DefaultModuleComponentArtifactMetaData(getComponentId(), artifactName);
        artifactToMetaData.put(descriptorArtifact, artifact);
    }

    this.artifactsByConfig = LinkedHashMultimap.create();
    for (String configuration : getDescriptor().getConfigurationsNames()) {
        Artifact[] configArtifacts = getDescriptor().getArtifacts(configuration);
        for (Artifact configArtifact : configArtifacts) {
            artifactsByConfig.put(configuration, artifactToMetaData.get(configArtifact));
        }
    }
}
 

import org.apache.ivy.core.module.descriptor.Artifact; //导入依赖的package包/类
/**
 * Test a simple artifact publish, with overwrite set to true.
 *
 * @throws IOException if something goes wrong
 */
@Test
public void testPublishWithOverwrite() throws IOException {
    // we expect the overwrite settings to be passed through the event listeners and into the
    // publisher.
    this.expectedOverwrite = true;

    // set overwrite to true. InstrumentedResolver will verify that the correct argument value
    // was provided.
    publishOptions.setOverwrite(true);
    Collection<Artifact> missing = publishEngine.publish(publishModule.getModuleRevisionId(),
        publishSources, "default", publishOptions);
    assertEquals("no missing artifacts", 0, missing.size());

    // if all tests passed, all of our counter variables should have been updated.
    assertEquals("pre-publish trigger fired and passed all tests", 2, preTriggers);
    assertEquals("post-publish trigger fired and passed all tests", 2, postTriggers);
    assertEquals("resolver received a publish() call, and passed all tests", 2, publications);
    assertEquals("all expected artifacts have been published", 0, expectedPublications.size());
}
 

import org.apache.ivy.core.module.descriptor.Artifact; //导入依赖的package包/类
@Test
public void testSimple() throws Exception {
    ModuleDescriptor md = PomModuleDescriptorParser.getInstance().parseDescriptor(settings,
        getClass().getResource("test-simple.pom"), false);
    assertNotNull(md);

    ModuleRevisionId mrid = ModuleRevisionId.newInstance("org.apache", "test", "1.0");
    assertEquals(mrid, md.getModuleRevisionId());

    assertNotNull(md.getConfigurations());
    assertEquals(Arrays.asList(PomModuleDescriptorBuilder.MAVEN2_CONFIGURATIONS),
        Arrays.asList(md.getConfigurations()));

    Artifact[] artifact = md.getArtifacts("master");
    assertEquals(1, artifact.length);
    assertEquals(mrid, artifact[0].getModuleRevisionId());
    assertEquals("test", artifact[0].getName());
    assertEquals("jar", artifact[0].getExt());
    assertEquals("jar", artifact[0].getType());
}