Java Plugin類代碼示例

import org.gradle.api.Plugin; //導入依賴的package包/類
private void configureExtensionRule() {
    final ConventionMapping extensionMapping = conventionMappingOf(extension);
    extensionMapping.map("sourceSets", Callables.returning(new ArrayList()));
    extensionMapping.map("reportsDir", new Callable<File>() {
        @Override
        public File call() {
            return project.getExtensions().getByType(ReportingExtension.class).file(getReportName());
        }
    });
    withBasePlugin(new Action<Plugin>() {
        @Override
        public void execute(Plugin plugin) {
            extensionMapping.map("sourceSets", new Callable<SourceSetContainer>() {
                @Override
                public SourceSetContainer call() {
                    return getJavaPluginConvention().getSourceSets();
                }
            });
        }
    });
}
 

import org.gradle.api.Plugin; //導入依賴的package包/類
public void apply(final Project project) {
    project.getPlugins().apply(GitHubPlugin.class);
    project.getPlugins().apply(BintrayReleasePlugin.class);
    project.getPlugins().apply(TravisPlugin.class);

    project.allprojects(new Action<Project>() {
        public void execute(final Project subproject) {
            subproject.getPlugins().withId("java", new Action<Plugin>() {
                @Override
                public void execute(Plugin plugin) {
                    subproject.getPlugins().apply(JavaBintrayPlugin.class);
                }
            });
        }
    });
}
 

import org.gradle.api.Plugin; //導入依賴的package包/類
@Override
public void apply(final Project project) {
    project.getPlugins().apply(GitHubContributorsPlugin.class);
    project.allprojects(new Action<Project>() {
        public void execute(final Project subproject) {
            subproject.getPlugins().withType(JavaPublishPlugin.class, new Action<Plugin>() {
                @Override
                public void execute(Plugin plugin) {
                    final Task fetcher = project.getTasks().getByName(GitHubContributorsPlugin.FETCH_CONTRIBUTORS);
                    //Because maven-publish plugin uses new configuration model, we cannot get the task directly
                    //So we use 'matching' technique
                    subproject.getTasks().matching(withName(POM_TASK)).all(new Action<Task>() {
                        public void execute(Task t) {
                            t.dependsOn(fetcher);
                        }
                    });
                }
            });
        }
    });
}
 

import org.gradle.api.Plugin; //導入依賴的package包/類
public void resolve(PluginRequest pluginRequest, PluginResolutionResult result) {
    PluginId id = pluginRequest.getId();

    if (!id.isQualified() || id.inNamespace(CorePluginRegistry.CORE_PLUGIN_NAMESPACE)) {
        try {
            Class<? extends Plugin> typeForId = pluginRegistry.getTypeForId(id.getName());
            if (pluginRequest.getVersion() != null) {
                throw new InvalidPluginRequestException(pluginRequest,
                        "Plugin '" + id + "' is a core Gradle plugin, which cannot be specified with a version number. "
                                + "Such plugins are versioned as part of Gradle. Please remove the version number from the declaration."
                );
            }
            result.found(getDescription(), new SimplePluginResolution(id, typeForId));
        } catch (UnknownPluginException e) {
            result.notFound(getDescription(), String.format("not a core plugin, please see %s for available core plugins", documentationRegistry.getDocumentationFor("standard_plugins")));
        }
    } else {
        result.notFound(getDescription(), String.format("plugin is not in '%s' namespace", CorePluginRegistry.CORE_PLUGIN_NAMESPACE));
    }
}
 

import org.gradle.api.Plugin; //導入依賴的package包/類
@Override
public Boolean load(@SuppressWarnings("NullableProblems") IdLookupCacheKey key) throws Exception {
    Class<?> pluginClass = key.pluginClass;

    // Plugin registry will have the mapping cached in memory for most plugins, try first
    try {
        Class<? extends Plugin<?>> typeForId = pluginRegistry.getTypeForId(key.id);
        if (typeForId.equals(pluginClass)) {
            return true;
        }
    } catch (UnknownPluginException ignore) {
        // ignore
    }

    PluginDescriptorLocator locator = new ClassloaderBackedPluginDescriptorLocator(pluginClass.getClassLoader());
    PluginDescriptor pluginDescriptor = locator.findPluginDescriptor(key.id);
    return pluginDescriptor != null && pluginDescriptor.getImplementationClassName().equals(pluginClass.getName());
}
 

import org.gradle.api.Plugin; //導入依賴的package包/類
private void configureSourceSetRule() {
    withBasePlugin(new Action<Plugin>() {
        @Override
        public void execute(Plugin plugin) {
            configureForSourceSets(getJavaPluginConvention().getSourceSets());
        }
    });
}
 

import org.gradle.api.Plugin; //導入依賴的package包/類
private void configureCheckTask() {
    withBasePlugin(new Action<Plugin>() {
        @Override
        public void execute(Plugin plugin) {
            configureCheckTaskDependents();
        }
    });
}
 

import org.gradle.api.Plugin; //導入依賴的package包/類
private Action<Plugin<Project>> createActionApplyingEclipseWtpPlugin() {
    return new Action<Plugin<Project>>() {
        @Override
        public void execute(Plugin<Project> plugin) {
            project.getPluginManager().apply(EclipseWtpPlugin.class);
        }

    };
}
 

import org.gradle.api.Plugin; //導入依賴的package包/類
public ObjectConfigurationAction plugin(final Class<? extends Plugin> pluginClass) {
    actions.add(new Runnable() {
        public void run() {
            applyPlugin(pluginClass);
        }
    });
    return this;
}
 

import org.gradle.api.Plugin; //導入依賴的package包/類
public DefaultPluginContainer(PluginRegistry pluginRegistry, final PluginManagerInternal pluginManager) {
    super(Plugin.class);
    this.pluginRegistry = pluginRegistry;
    this.pluginManager = pluginManager;

    // Need this to make withId() work when someone does project.plugins.add(new SomePlugin());
    whenObjectAdded(new Action<Plugin>() {
        public void execute(Plugin plugin) {
            pluginManager.addImperativePlugin(plugin.getClass());
        }
    });
}
 

import org.gradle.api.Plugin; //導入依賴的package包/類
public Plugin apply(String id) {
    PluginImplementation plugin = pluginRegistry.lookup(PluginId.unvalidated(id));
    if (plugin == null) {
        throw new UnknownPluginException("Plugin with id '" + id + "' not found.");
    }

    if (!Plugin.class.isAssignableFrom(plugin.asClass())) {
        throw new IllegalArgumentException("Plugin implementation '" + plugin.asClass().getName() + "' does not implement the Plugin interface. This plugin cannot be applied directly via the PluginContainer.");
    } else {
        return pluginManager.addImperativePlugin(plugin);
    }
}
 

import org.gradle.api.Plugin; //導入依賴的package包/類
public <P extends Plugin> P findPlugin(Class<P> type) {
    for (Plugin plugin : this) {
        if (plugin.getClass().equals(type)) {
            return type.cast(plugin);
        }
    }
    return null;
}
 

import org.gradle.api.Plugin; //導入依賴的package包/類
public Plugin getPlugin(String id) {
    Plugin plugin = findPlugin(id);
    if (plugin == null) {
        throw new UnknownPluginException("Plugin with id " + id + " has not been used.");
    }
    return plugin;
}
 

import org.gradle.api.Plugin; //導入依賴的package包/類
public void withId(final String pluginId, final Action<? super Plugin> action) {
    Action<DefaultPluginManager.PluginWithId> wrappedAction = new Action<DefaultPluginManager.PluginWithId>() {
        public void execute(final DefaultPluginManager.PluginWithId pluginWithId) {
            matching(new Spec<Plugin>() {
                public boolean isSatisfiedBy(Plugin element) {
                    return pluginWithId.clazz.equals(element.getClass());
                }
            }).all(action);
        }
    };

    pluginManager.pluginsForId(pluginId).all(wrappedAction);
}
 

import org.gradle.api.Plugin; //導入依賴的package包/類
@Override
public <S extends Plugin> PluginCollection<S> withType(Class<S> type) {
    // runtime check because method is used from Groovy where type bounds are not respected
    if (!Plugin.class.isAssignableFrom(type)) {
        throw new IllegalArgumentException(String.format("'%s' does not implement the Plugin interface.", type.getName()));
    }

    return super.withType(type);
}