import org.gradle.api.artifacts.repositories.MavenArtifactRepository; //导入依赖的package包/类
private void createPublishTasksForEachMavenRepo(ModelMap<Task> tasks, PublishingExtension extension, final Task publishLifecycleTask, final MavenPublicationInternal publication,
                                                final String publicationName) {
    for (final MavenArtifactRepository repository : extension.getRepositories().withType(MavenArtifactRepository.class)) {
        final String repositoryName = repository.getName();

        String publishTaskName = "publish" + capitalize(publicationName) + "PublicationTo" + capitalize(repositoryName) + "Repository";

        tasks.create(publishTaskName, PublishToMavenRepository.class, new Action<PublishToMavenRepository>() {
            public void execute(PublishToMavenRepository publishTask) {
                publishTask.setPublication(publication);
                publishTask.setRepository(repository);
                publishTask.setGroup(PublishingPlugin.PUBLISH_TASK_GROUP);
                publishTask.setDescription("Publishes Maven publication '" + publicationName + "' to Maven repository '" + repositoryName + "'.");

            }
        });
        publishLifecycleTask.dependsOn(publishTaskName);
    }
}
 

import org.gradle.api.artifacts.repositories.MavenArtifactRepository; //导入依赖的package包/类
private ClassPath resolvePluginDependencies(final PluginUseMetaData metadata) {
    DependencyResolutionServices resolution = dependencyResolutionServicesFactory.create();

    RepositoryHandler repositories = resolution.getResolveRepositoryHandler();
    final String repoUrl = metadata.implementation.get("repo");
    repositories.maven(new Action<MavenArtifactRepository>() {
        public void execute(MavenArtifactRepository mavenArtifactRepository) {
            mavenArtifactRepository.setUrl(repoUrl);
        }
    });

    Dependency dependency = resolution.getDependencyHandler().create(metadata.implementation.get("gav"));

    ConfigurationContainerInternal configurations = (ConfigurationContainerInternal) resolution.getConfigurationContainer();
    ConfigurationInternal configuration = configurations.detachedConfiguration(dependency);

    try {
        Set<File> files = configuration.getResolvedConfiguration().getFiles(Specs.satisfyAll());
        return new DefaultClassPath(files);
    } catch (ResolveException e) {
        throw new DependencyResolutionException("Failed to resolve all plugin dependencies from " + repoUrl, e.getCause());
    }
}
 

import org.gradle.api.artifacts.repositories.MavenArtifactRepository; //导入依赖的package包/类
@Override
protected ArtifactRepository internalCreateArtifactRepository(RepositoryHandler repositoryHandler) {
    return repositoryHandler.maven(new Action<MavenArtifactRepository>() {
        @Override
        public void execute(MavenArtifactRepository mavenArtifactRepository) {
            mavenArtifactRepository.setName(getArtifactRepositoryName());
            mavenArtifactRepository.setUrl(getUrl());
            Credentials credentials = authenticationSupport().getConfiguredCredentials();
            if (credentials != null) {
                ((AuthenticationSupportedInternal)mavenArtifactRepository).setConfiguredCredentials(credentials);
                mavenArtifactRepository.authentication(new Action<AuthenticationContainer>() {
                    @Override
                    public void execute(AuthenticationContainer authenticationContainer) {
                        authenticationContainer.addAll(authenticationSupport().getConfiguredAuthentication());
                    }
                });
            }
        }
    });
}
 

import org.gradle.api.artifacts.repositories.MavenArtifactRepository; //导入依赖的package包/类
@Mutate
public void createAndroidTasks(
        ModelMap<Task> tasks,
        ModelMap<AndroidComponentSpec> androidSpecs,
        TaskManager taskManager,
        SdkHandler sdkHandler,
        Project project, AndroidComponentModelSourceSet androidSources) {
    // setup SDK repositories.
    for (final File file : sdkHandler.getSdkLoader().getRepositories()) {
        project.getRepositories().maven(new Action<MavenArtifactRepository>() {
            @Override
            public void execute(MavenArtifactRepository repo) {
                repo.setUrl(file.toURI());
            }
        });
    }
    // TODO: determine how to provide functionalities of variant API objects.
}
 

import org.gradle.api.artifacts.repositories.MavenArtifactRepository; //导入依赖的package包/类
private void createPublishTasksForEachMavenRepo(CollectionBuilder<Task> tasks, PublishingExtension extension, final Task publishLifecycleTask, final MavenPublicationInternal publication,
                                                final String publicationName) {
    for (final MavenArtifactRepository repository : extension.getRepositories().withType(MavenArtifactRepository.class)) {
        final String repositoryName = repository.getName();

        String publishTaskName = String.format("publish%sPublicationTo%sRepository", capitalize(publicationName), capitalize(repositoryName));

        tasks.create(publishTaskName, PublishToMavenRepository.class, new Action<PublishToMavenRepository>() {
            public void execute(PublishToMavenRepository publishTask) {
                publishTask.setPublication(publication);
                publishTask.setRepository(repository);
                publishTask.setGroup(PublishingPlugin.PUBLISH_TASK_GROUP);
                publishTask.setDescription(String.format("Publishes Maven publication '%s' to Maven repository '%s'.", publicationName, repositoryName));

                //Because dynamic rules are not yet implemented we have to violate input immutability here as an interim step
                publishLifecycleTask.dependsOn(publishTask);
            }
        });
    }
}
 

import org.gradle.api.artifacts.repositories.MavenArtifactRepository; //导入依赖的package包/类
public DependencyResolver mavenRepo(Map<String, ?> args, Closure configClosure) {
    DeprecationLogger.nagUserOfReplacedMethod("RepositoryHandler.mavenRepo()", "maven()");
    Map<String, Object> modifiedArgs = new HashMap<String, Object>(args);
    if (modifiedArgs.containsKey("urls")) {
        List<?> urls = flattenCollections(modifiedArgs.remove("urls"));
        if (!urls.isEmpty()) {
            modifiedArgs.put("url", urls.get(0));
            List<?> extraUrls = urls.subList(1, urls.size());
            modifiedArgs.put("artifactUrls", extraUrls);
        }
    }

    MavenArtifactRepository repository = repositoryFactory.createMavenRepository();
    ConfigureUtil.configureByMap(modifiedArgs, repository);
    DependencyResolver resolver = repositoryFactory.toResolver(repository);
    ConfigureUtil.configure(configClosure, resolver);
    addRepository(repositoryFactory.createResolverBackedRepository(resolver), "mavenRepo");
    return resolver;
}
 

import org.gradle.api.artifacts.repositories.MavenArtifactRepository; //导入依赖的package包/类
@TaskAction
public void publish() {
    MavenPublicationInternal publicationInternal = getPublicationInternal();
    if (publicationInternal == null) {
        throw new InvalidUserDataException("The 'publication' property is required");
    }

    MavenArtifactRepository repository = getRepository();
    if (repository == null) {
        throw new InvalidUserDataException("The 'repository' property is required");
    }

    doPublish(publicationInternal, repository);
}
 

import org.gradle.api.artifacts.repositories.MavenArtifactRepository; //导入依赖的package包/类
private void doPublish(final MavenPublicationInternal publication, final MavenArtifactRepository repository) {
    new PublishOperation(publication, repository.getName()) {
        @Override
        protected void publish() throws Exception {
            MavenPublisher remotePublisher = new MavenRemotePublisher(getLoggingManagerFactory(), getMavenRepositoryLocator(), getTemporaryDirFactory(), getRepositoryTransportFactory());
            MavenPublisher staticLockingPublisher = new StaticLockingMavenPublisher(remotePublisher);
            MavenPublisher validatingPublisher = new ValidatingMavenPublisher(staticLockingPublisher);
            validatingPublisher.publish(publication.asNormalisedPublication(), repository);
        }
    }.run();
}
 

import org.gradle.api.artifacts.repositories.MavenArtifactRepository; //导入依赖的package包/类
public GradleWagonMavenDeployAction(File pomFile, MavenArtifactRepository artifactRepository, RepositoryTransportFactory repositoryTransportFactory) {
    super(pomFile, null);
    this.artifactRepository = artifactRepository;
    this.repositoryTransportFactory = repositoryTransportFactory;

    registerWagonProtocols();
}
 

import org.gradle.api.artifacts.repositories.MavenArtifactRepository; //导入依赖的package包/类
public void publish(MavenNormalizedPublication publication, MavenArtifactRepository artifactRepository) {
    validateIdentity(publication);
    validateArtifacts(publication);
    checkNoDuplicateArtifacts(publication);

    delegate.publish(publication, artifactRepository);
}
 

import org.gradle.api.artifacts.repositories.MavenArtifactRepository; //导入依赖的package包/类
public void publish(MavenNormalizedPublication publication, MavenArtifactRepository artifactRepository) {
    STATIC_LOCK.lock();
    try {
        delegate.publish(publication, artifactRepository);
    } finally {
        STATIC_LOCK.unlock();
    }
}
 

import org.gradle.api.artifacts.repositories.MavenArtifactRepository; //导入依赖的package包/类
public MavenArtifactRepository gradle(final Action<? super MavenArtifactRepository> action) {
    return repositories.maven(new Action<MavenArtifactRepository>() {
        public void execute(MavenArtifactRepository repository) {
            repository.setName("gradleJs");
            repository.setUrl(GRADLE_PUBLIC_JAVASCRIPT_REPO_URL);
            action.execute(repository);
        }
    });
}
 

import org.gradle.api.artifacts.repositories.MavenArtifactRepository; //导入依赖的package包/类
@Override
public ArtifactRepository createArtifactRepository(RepositoryHandler repositoryHandler) {
    return repositoryHandler.maven(new Action<MavenArtifactRepository>() {
        @Override
        public void execute(MavenArtifactRepository mavenArtifactRepository) {
            mavenArtifactRepository.setUrl("https://plugins.gradle.org/m2");
        }
    });
}
 

import org.gradle.api.artifacts.repositories.MavenArtifactRepository; //导入依赖的package包/类
public MavenArtifactRepository createMavenLocalRepository() {
    MavenArtifactRepository mavenRepository = instantiator.newInstance(DefaultMavenLocalArtifactRepository.class, fileResolver, transportFactory,
            locallyAvailableResourceFinder, instantiator, artifactFileStore, pomParser, createAuthenticationContainer());
    final File localMavenRepository = localMavenRepositoryLocator.getLocalMavenRepository();
    mavenRepository.setUrl(localMavenRepository);
    return mavenRepository;
}
 

import org.gradle.api.artifacts.repositories.MavenArtifactRepository; //导入依赖的package包/类
@TaskAction
public void publish() {

    MavenPublicationInternal publicationInternal = getPublicationInternal();
    if (publicationInternal == null) {
        throw new InvalidUserDataException("The 'publication' property is required");
    }

    MavenArtifactRepository repository = getRepository();
    if (repository == null) {
        throw new InvalidUserDataException("The 'repository' property is required");
    }

    doPublish(publicationInternal, repository);
}
 

import org.gradle.api.artifacts.repositories.MavenArtifactRepository; //导入依赖的package包/类
@Override
public MavenArtifactRepository getRepository() {
    if (super.getRepository() == null) {
        // Instantiate the default MavenLocal repository if none has been set explicitly
        MavenArtifactRepository mavenLocalRepository = getBaseRepositoryFactory().createMavenLocalRepository();
        mavenLocalRepository.setName(ArtifactRepositoryContainer.DEFAULT_MAVEN_LOCAL_REPO_NAME);
        setRepository(mavenLocalRepository);
    }

    return super.getRepository();
}
 

import org.gradle.api.artifacts.repositories.MavenArtifactRepository; //导入依赖的package包/类
@Override
protected void doPublish(final MavenPublicationInternal publication, final MavenArtifactRepository repository) {
    new PublishOperation(publication, repository) {
        @Override
        protected void publish() throws Exception {
            MavenPublisher antBackedPublisher = new AntTaskBackedMavenLocalPublisher(getLoggingManagerFactory(), getTemporaryDirFactory());
            MavenPublisher staticLockingPublisher = new StaticLockingMavenPublisher(antBackedPublisher);
            MavenPublisher validatingPublisher = new ValidatingMavenPublisher(staticLockingPublisher);
            validatingPublisher.publish(publication.asNormalisedPublication(), repository);
        }
    }.run();
}
 

import org.gradle.api.artifacts.repositories.MavenArtifactRepository; //导入依赖的package包/类
protected void doPublish(final MavenPublicationInternal publication, final MavenArtifactRepository repository) {
    new PublishOperation(publication, repository) {
        @Override
        protected void publish() throws Exception {
            MavenPublisher antBackedPublisher = new AntTaskBackedMavenPublisher(getLoggingManagerFactory(), getTemporaryDirFactory());
            MavenPublisher staticLockingPublisher = new StaticLockingMavenPublisher(antBackedPublisher);
            MavenPublisher validatingPublisher = new ValidatingMavenPublisher(staticLockingPublisher);
            validatingPublisher.publish(publication.asNormalisedPublication(), repository);
        }
    }.run();
}
 

import org.gradle.api.artifacts.repositories.MavenArtifactRepository; //导入依赖的package包/类
public void publish(MavenNormalizedPublication publication, MavenArtifactRepository artifactRepository) {
    logger.info("Publishing to repository {}", artifactRepository);
    T deployTask = createDeployTask();
    deployTask.setProject(AntUtil.createProject());

    MavenSettingsSupplier mavenSettingsSupplier = new EmptyMavenSettingsSupplier();
    mavenSettingsSupplier.supply(deployTask);

    postConfigure(deployTask, artifactRepository);
    addPomAndArtifacts(deployTask, publication);
    execute(deployTask);

    mavenSettingsSupplier.done();
}
 

import org.gradle.api.artifacts.repositories.MavenArtifactRepository; //导入依赖的package包/类
public MavenArtifactRepository createMavenLocalRepository() {
    MavenArtifactRepository mavenRepository = instantiator.newInstance(DefaultMavenLocalArtifactRepository.class, fileResolver, createPasswordCredentials(), transportFactory,
            locallyAvailableResourceFinder, artifactFileStore);
    final File localMavenRepository = localMavenRepositoryLocator.getLocalMavenRepository();
    mavenRepository.setUrl(localMavenRepository);
    return mavenRepository;
}