读书笔记《gradle-effective-implementations-guide-second-edition》IDE支持

Chapter 12. IDE Support

我们在开发应用程序时，通常使用集成开发环境(IDE ）。 IDE 支持为我们的应用程序编写代码。我们可以用 Java、Groovy 或 Scala 编写代码。我们已经了解了如何使用 Gradle 来定义例如库依赖项来编译代码。我们希望在我们最喜欢的 IDE 中的项目中使用我们在 Gradle 构建文件中定义的相同信息。

在本章中，我们将讨论如何使用 Gradle 插件为 Eclipse 和 JetBrains IntelliJ IDEA 生成具有类路径依赖项的项目文件。我们还将讨论如何自定义文件生成以添加额外的配置数据。

接下来，我们将看到 Eclipse 和 IntelliJ IDEA 支持从 IDE 中运行 Gradle 任务。

在本章中，我们将介绍以下主题：

使用 Eclipse 插件
使用 IDEA 插件
将 Gradle 与 Eclipse 集成
从 IDEA IntelliJ 运行 Gradle 脚本

Using the Eclipse plugin

Eclipse 插件可以生成在 Eclipse 中导入项目所需的项目文件。在本节中，我们将看到插件添加的任务以及如何自定义生成的输出。

如果我们有一个 Java 项目，并且我们想将该项目导入 Eclipse，我们必须使用 Eclipse 插件来生成 Eclipse 项目文件。每个 Eclipse 项目至少有一个 .project 和 .classpath 文件。 .project 文件包含有关项目的元数据，例如项目名称。 .classpath 文件包含项目的类路径条目。 Eclipse 需要这个才能编译项目中的源文件。 Eclipse 插件也将尝试使用属于依赖项的源文件下载工件。所以，如果我们将项目导入Eclipse，并且有源文件，就可以直接看到依赖类文件的来源。

对于 Java 项目，额外的 Java 开发工具（JDT ) 配置文件在 .settings 文件夹中创建。文件名是 org.eclipse.jdt。 core.prefs。

让我们为 Java 项目创建一个简单的 Gradle 构建文件。构建文件的代码显示在以下代码片段中：

apply plugin: 'java' 
 
// Apply the Eclipse plugin. 
apply plugin: 'eclipse' 
 
version = 1.0 
 
sourceCompatibility = 1.8 
targetCompatibility = 1.8 
 
description = 'Sample project' 
 
ext { 
    slf4jVersion = '1.7.18' 
    slf4jGroup = 'org.slf4j' 
} 
 
configurations { 
    // Extra configuration. 
    extraLib 
} 
 
repositories { 
    jcenter() 
} 
 
dependencies { 
    testCompile 'junit:junit:4.11' 
 
    extraLib "$slf4jGroup:slf4j-api:$slf4jVersion", 
      "$slf4jGroup:slf4j-simple:$slf4jVersion" 
}

我们将为我们的项目应用 Java 和 Eclipse 插件。我们将设置一些项目属性，例如version、description、源和目标兼容性。我们将为 testCompile 配置定义对 JUnit 的依赖。此外，我们将添加一个额外的自定义配置，该配置依赖于 SLF4J 日志库。

首先，让我们看看 Eclipse 插件添加到我们项目中的任务。我们将调用 tasks 任务并查看我们插件中的所有任务，如以下命令输出所示：

$ gradle tasks --all
:tasks
...
IDE tasks
---------
cleanEclipse - Cleans all Eclipse files.
cleanEclipseClasspath
cleanEclipseJdt
cleanEclipseProject
eclipse - Generates all Eclipse files.
eclipseClasspath - Generates the Eclipse classpath file.
eclipseJdt - Generates the Eclipse JDT settings file.
eclipseProject - Generates the Eclipse project file.
...

eclipse 任务依赖于以下三个任务： eclipseClasspath, eclipseJdt 和 eclipseProject。每个任务都会生成一个文件。 eclipseClasspath 任务生成 .classpath 文件， eclipseProject生成 .project文件， eclipseJdt生成 org.eclipse.jdt。 core.prefs。

当我们从命令行执行 eclipse 任务时，我们得到以下输出：

$ gradle eclipse
:eclipseClasspath
:eclipseJdt
:eclipseProject
:eclipse
BUILD SUCCESSFUL
Total time: 1.223 secs

请注意，已下载 JUnit 库的源代码。现在，我们的项目文件夹中有 .classpath 和 .project 文件。在 .settings 文件夹中，我们有 org.eclipse.jdt.core.prefs 文件。

.project 文件有以下内容：

<?xml version="1.0" encoding="UTF-8"?> 
<projectDescription> 
    <name>eclipse</name> 
    <comment>Sample project</comment> 
    <projects/> 
    <natures> 
      <nature>org.eclipse.jdt.core.javanature</nature> 
    </natures> 
    <buildSpec> 
      <buildCommand> 
          <name>org.eclipse.jdt.core.javabuilder</name> 
          <arguments/> 
      </buildCommand> 
    </buildSpec> 
    <linkedResources/> 
</projectDescription>

name 元素填充了项目的文件夹名称。我们将在本章后面讨论如何改变它。 comment 元素包含我们的项目描述。我们已经将 Java 插件应用到我们的项目中，因此，Java nature 和 buildCommand 被添加到项目配置中。

如果我们查看 .classpath 文件，我们可以看到一个具有 JUnit 依赖关系的classpathentry 元素，如下所示代码片段：

<?xml version="1.0" encoding="UTF-8"?>
<classpath>
    <classpathentry kind="output" path="bin"/>
    <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/ org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/ JavaSE-1.8/"/>
    <classpathentrysourcepath="/Users/mrhaki/.gradle/caches/
       modules-2/files-2.1/junit/junit/4.11/
       28e0ad201304e4a4abf999ca0570b7cffc352c3c/
       junit-4.11-sources.jar" kind="lib" 
       path="/Users/mrhaki/.gradle/caches/modules-2/files-
       2.1/junit/junit/4.11/
       4e031bb61df09069aeb2bffb4019e7a5034a4ee0/junit-4.11.jar"/>
    <classpathentry sourcepath="/Users/mrhaki/.gradle/caches/ modules-2/files-2.1/org.hamcrest/hamcrest-core/1.3/ 1dc37250fbc78e23a65a67fbbaf71d2e9cbc3c0b/hamcrest-core-1.3- sources.jar" kind="lib" path="/Users/mrhaki/.gradle/caches/ modules-2/files-2.1/org.hamcrest/hamcrest-core/1.3/ 42a25dc3219429f0e5d060061f71acb49bf010a0/ hamcrest-core-1.3.jar"/>
</classpath>

classpathentry 元素具有对下载的 JUnit 库的 Gradle 缓存中位置的引用。请注意 sourcepath 属性引用源文件。

最后生成的org.eclipse.jdt.core.prefs文件内容如下：

# 
#Mon Mar 14 21:28:13 CET 2016 
org.eclipse.jdt.core.compiler.debug.localVariable=generate 
org.eclipse.jdt.core.compiler.compliance=1.8 
org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve 
org.eclipse.jdt.core.compiler.debug.sourceFile=generate 
org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.8 
org.eclipse.jdt.core.compiler.problem.enumIdentifier=error 
org.eclipse.jdt.core.compiler.debug.lineNumber=generate 
eclipse.preferences.version=1 
org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled 
org.eclipse.jdt.core.compiler.source=1.8 
org.eclipse.jdt.core.compiler.problem.assertIdentifier=error

我们可以看到我们在 Gradle 构建文件中定义的源和目标兼容性用于 org.eclipse.jdt.core.compiler.source, org.eclipse.jdt.core.compiler.codegen.targetPlatform 和 org.eclipse.jdt。 core.compiler.compliance 属性。

Customizing generated files

我们有几个选项可以自定义生成文件中的配置。 Eclipse 插件添加了一个 DSL 来配置代表 Eclipse 配置对象的模型对象。如果我们使用 DSL 来配置对象，这些新配置的对象会在生成文件之前与现有配置合并。我们还可以挂钩到生成过程并直接在模型对象上工作，在合并配置和生成文件之前和之后。最后，我们甚至可以在配置文件生成之前使用钩子直接处理 XML 结构。

以下步骤描述了完整的配置文件生成生命周期：

首先，从磁盘读取文件，如果文件不可用，则使用默认文件。
接下来，调用beforeMerge 钩子。该钩子接受配置文件的模型对象作为参数。
Gradle 构建文件中的隐式配置信息和使用 DSL 定义的配置被合并。
然后， whenMerged 钩子被执行。该钩子接受配置文件的模型对象作为参数。
withXml 钩子被调用。 XML 操作可以在文件写入磁盘之前发生。
最后将配置文件写入磁盘。

Customizing using DSL

当 Eclipse 插件生成文件时，它将在 Gradle 构建文件中查找必要的信息。例如，如果我们设置 Project 对象的 description 属性， .project 文件将填充此属性的值。

Eclipse 插件还添加了一个名为 eclipse 的配置脚本块。可以使用简单的 DSL 来描述配置。在顶层，我们可以添加用于替换 classpath 条目中的绝对路径的路径变量。使用了 org.gradle.plugins.ide.eclipse.model.EclipseModel对象， pathVariables()方法必须使用此类的定义路径变量。

接下来，我们可以在project部分定义.project文件的配置信息。 org.gradle.plugins.ide.eclipse.model.EclipseProject 模型对象用于对 Eclipse 项目配置进行建模。例如，我们可以使用 name 属性在生成的 .project 文件中更改项目的名称。很高兴知道 Gradle 可以为多项目构建生成唯一的项目名称。在 Eclipse 中导入项目需要一个唯一的名称。在生成.project 文件期间，必须知道属于多项目的所有项目。因此，最好从项目的根目录运行 eclipse 或 eclipseProject 任务。此外，还提供了添加项目性质和新构建命令的方法。

要自定义 .classpath 文件生成，我们可以使用 Eclipse 配置闭包的 classpath 部分。在这里， org.gradle.plugins.ide.eclipse.model.EclipseClasspath 对象用于对 Eclipse 项目的类路径条目进行建模。我们可以使用 plusConfigurations 和 minusConfigurations 属性在生成的 .classpath 文件。默认情况下，会下载依赖项的关联源文件，但我们也可以将 downloadJavadoc属性设置为true进行下载与依赖项关联的 Javadoc。

Eclipse 配置闭包的 jdt 部分可用于更改源和目标兼容性版本。默认情况下，使用 Gradle Java 插件设置，但我们可以在这里覆盖它。 org.gradle.plugins.ide.eclipse.model.EclipseJdt 对象用于对 Eclipse 配置进行建模。

在下面的构建文件中，我们将讨论可以与 DSL 一起使用的所有可能方法和属性的示例，以自定义生成的 .project, .classpath 和 org.eclipse.jdt.core.prefs 文件：

apply plugin: 'java' 
apply plugin: 'eclipse' 
 
version = 1.0 
 
description = 'Sample project' 
 
ext { 
    slf4jVersion = '1.7.18' 
    slf4jGroup = 'org.slf4j' 
} 
 
configurations { 
    extraLib 
} 
 
repositories { 
    jcenter() 
} 
 
dependencies { 
    testCompile 'junit:junit:4.11' 
 
    extraLib "$slf4jGroup:slf4j-api:$slf4jVersion", 
      "$slf4jGroup:slf4j-simple:$slf4jVersion" 
} 
 
eclipse { 
    pathVariables 'APPSERVER_HOME': file('/apps/appserver/1.0') 
 
    // Customize .project file. 
    project { 
      // Override default project name from project 
      // and set explicitly. 
      name = 'sample-eclipse' 
 
      // Set comment section in .project file. 
      comment = 'Eclipse project file build by Gradle' 
 
      // Add new natures like Spring nature.  
      natures 'org.springframework.ide.eclipse.core.springnature' 
 
     // Add build command for Spring. 
     buildCommand        'org.springframework.ide.eclipse.core.springbuilder' 
 
        // If using location attribute 
        // then type 1 is file, 2 is folder 
        linkedResource name: 'config', type: '2', 
          location: file('/opt/local/config') 
 
        // If using locationUri attribute 
        // then type 1 for file/folder, 2 is virtual folder 
        linkedResource name: 'config2', type: '1', 
          locationUri: 'file:../config' 
 
        // Define reference to other project. This is not 
        // a build path reference. 
        referencedProjects 'other-project' 
    } 
 
    // Customize .classpath file. 
    classpath { 
        // Add extra dependency configurations. 
        plusConfigurations += configurations.extraLib 
 
        // Remove dependency configurations. 
        minusConfigurations += configurations.testCompile 
 
        // Included configurations are not exported. 
        noExportConfigurations += configurations.testCompile 
 
        // Download associated source files. 
        downloadSources = true 
 
        // Download Javadoc for dependencies. 
        downloadJavadoc = true 
 
        // Add extra containers. 
        containers 'ApacheCommons' 
 
        // Change default output dir (${projectDir}/bin) 
        defaultOutputDir file("$buildDir/eclipse-classes") 
    } 
 
    // Customize org.eclipse.jdt.core.prefs file. 
    jdt { 
        sourceCompatibility = 1.8 
        targetCompatibility = 1.8 
    } 
}

Customizing with merge hooks

使用 DSL 自定义文件生成非常优雅。请记住，在配置文件生成步骤中，此信息是在 beforeMerged 钩子之后和 whenMerged 钩子之前使用的。这些钩子将模型对象作为我们可以用来自定义的参数。如果我们想做一些使用项目配置或 DSL 无法完成的事情，我们可以使用合并钩子。

可以在 Eclipse 配置闭包中定义合并挂钩。对于每个文件，我们可以为 beforeMerged 和 whenMerged 钩子定义一个配置闭包。这些方法是 org.gradle.plugins.ide.api.XmlFileContentMerger 类的一部分。 Gradle 会将配置闭包委托给此类的方法。 beforeMerged 挂钩对于覆盖或更改配置文件中的现有部分很有用。 cleanEclipse 任务清理配置文件中的所有部分；并且通过使用 beforeMerged钩子，我们可以自己定义需要清理或覆盖的部分。

whenMerged 钩子是更改模型对象的首选方式。调用此钩子时，模型对象已经配置了项目配置和 DSL 中的所有设置。

每个文件都由 Eclipse 配置闭包的文件属性表示。例如，要向 .project 文件生成添加合并挂钩，我们将使用 eclipse.project.file 属性。

下表显示了作为合并挂钩闭包参数传递的类：

模型	合并挂钩参数	说明
`项目`	`org.gradle.plugins.ide.eclipse.model.Project`	这是具有 `.project` 文件生成属性的模型对象
`类路径`	`org.gradle.plugins.ide.eclipse.model.Classpath`	这是具有 `.classpath` 文件生成属性的模型对象
`Jdt`	`org.gradle.plugins.ide.eclipse.model.Jdt`	这是具有 `org.eclipse.jdt.core.prefs` 文件生成属性的模型对象

对于 Jdt 模型，我们有一个额外的 withProperties() 方法来更改文件的内容。此方法有一个带有 java.util.Properties 类型参数的闭包。

在下面的示例构建文件中，我们将使用合并的钩子来更改 .project 中的配置， .classpath , 和org.eclipse.jdt.core.prefs 文件：

apply plugin: 'java' 
apply plugin: 'eclipse' 
 
version = 1.0 
 
description = 'Sample project' 
 
ext { 
    slf4jVersion = '1.7.18' 
    slf4jGroup = 'org.slf4j' 
} 
 
configurations { 
    extraLib 
} 
 
repositories { 
    jcenter() 
} 
 
dependencies { 
    testCompile 'junit:junit:4.11' 
 
    extraLib "$slf4jGroup:slf4j-api:$slf4jVersion", 
             "$slf4jGroup:slf4j-simple:$slf4jVersion" 
} 
 
eclipse { 
    // Customize .project file. 
    project { 
        file { 
            beforeMerged { project -> 
                // We can access the internal object structure 
                // using merge hooks. 
                project.natures.clear() 
            } 
 
            // Instead of using the DSL we use the afterMerged 
            // hook to customize the .project and .classpath files. 
            afterMerged { project -> 
                // Set name. 
                project.name = 'sample-eclipse' 
 
                // Set comment for .project file. 
                project.comment = 'Eclipse project file build by Gradle' 
            } 
 
        } 
    } 
 
    // Customize .classpath file. 
    classpath { 
        file { 
            beforeMerged { classpath -> 
                // Remove lib classpath entries. 
                classpath.entries.removeAll { 
                    it.kind == 'lib' 
                } 
            } 
 
             
 
 
 
        } 
    } 
 
    // Customize org.eclipse.jdt.core.prefs file. 
    jdt { 
        file { 
             
 
            whenProperties { properties -> 
                properties.extraProperty = 'value' 
            } 
        } 
    } 
}

Customizing with an XML manipulation

我们已经了解了如何使用项目配置、DSL 和合并挂钩自定义配置文件生成。在最低级别，有一个挂钩可以在将 XML 结构写入磁盘之前更改它。因此，我们必须实现 withXml 钩子。我们将定义一个闭包，闭包的第一个参数是 org.gradle.api.XmlProvider类型。该类具有 asNode() 方法，该方法将 XML 的根作为 Groovy 节点返回。这是更改 XML 内容的最简单对象。 asString() 方法返回一个带有 XML 内容的 StringBuilder 实例。最后， asElement() 方法返回 an org.w3c.dom.Element 对象。

asNode() 方法返回 Groovy groovy.util.Node 类。使用这个节点类，我们可以轻松地添加、替换或删除节点和属性。

在以下示例构建文件中，我们可以看到操作 XML 结构的不同方法：

apply plugin: 'java' 
apply plugin: 'eclipse' 
 
version = 1.0 
 
description = 'Sample project' 
 
repositories { 
    jcenter() 
} 
 
dependencies { 
    testCompile 'junit:junit:4.11' 
} 
 
eclipse { 
    // Change .project file. 
    project { 
        file { 
            withXml { xml -> 
                def projectXml = xml.asNode() 
                projectXml.name = 'sample-eclipse' 
 
                def natures = projectXml.natures 
                natures.plus { 
                    nature { 
                        'org.springframework.ide.eclipse.core.springnature' 
                    } 
                } 
            } 
        } 
    } 
 
    // Change .classpath file. 
    classpath { 
        file { 
            withXml { xml -> 
                def classpathXml = xml.asNode() 
                classpathXml.classpathentry 
                    .findAll { it.@kind == 'con' }*.@exported = 'true' 
            } 
        } 
    } 
 
}

我们已经看到了更改配置文件的所有不同选项。我们通常在 Eclipse 中进行的配置更改现在可以在 Gradle 构建文件中以编程方式完成。

Merging configuration

如果文件已经存在，Gradle 将尝试将额外信息与现有信息合并。根据部分，信息将被修改为现有配置数据或将替换现有配置数据。这意味着如果我们在 Eclipse 中对项目设置进行更改，即使我们调用其中一个 Eclipse 任务，它们也不会被覆盖。

要完全重建项目文件，我们必须使用 cleanEclipse 任务。对于每个项目文件，都有一个对应的 cleanEclipse 任务。例如，要重建 .project文件，我们将在 cleanEclipseProject任务">eclipseProject。我们手动进行的任何更改都将被删除，Gradle 会生成一个新的.project 文件，其设置来自我们的 Gradle 构建文件。

Configuring WTP

我们可以在 Eclipse 中添加 Web Tools Platform (WTP)为了添加对 Java 企业应用程序的支持。我们将获得对 Web 应用程序 (WAR) 和企业应用程序 (EAR) 的支持。要生成正确的配置文件，我们必须在 Gradle 构建文件中添加另一个插件。我们将把 Eclipse WTP 插件和 War 或 Ear 插件添加到项目中。

让我们创建一个构建文件并添加 War 和 Eclipse WTP 插件，如下所示：

apply plugin: 'java' 
apply plugin: 'war' 
 
// Include the eclipse-wtp plugin. 
apply plugin: 'eclipse-wtp' 
 
version = 1.0 
 
description = 'Sample project' 
 
repositories { 
    jcenter() 
} 
 
dependencies { 
    testCompile 'junit:junit:4.11' 
}

Eclipse WTP 插件向我们的 Gradle 构建添加了几个新任务。在下面的代码片段中，我们将调用 tasks 任务来查看添加了哪些任务：

$ gradle tasks --all
:tasks
...
IDE tasks
---------
cleanEclipse - Cleans all Eclipse files. [cleanEclipseWtp]
cleanEclipseClasspath
cleanEclipseJdt
cleanEclipseProject
cleanEclipseWtp - Cleans Eclipse wtp configuration files.
cleanEclipseWtpComponent
cleanEclipseWtpFacet
eclipse - Generates all Eclipse files. [eclipseWtp]
eclipseClasspath - Generates the Eclipse classpath file.
eclipseJdt - Generates the Eclipse JDT settings file.
eclipseProject - Generates the Eclipse project file.
eclipseWtp - Generates Eclipse wtp configuration files.
eclipseWtpComponent - Generates the Eclipse WTP component settings file.
eclipseWtpFacet - Generates the Eclipse WTP facet settings file.
...

Eclipse WTP 插件也包括 Eclipse 插件。我们获得了之前看到的所有任务，但也为 WTP 配置文件添加了新任务。 eclipseWtp任务依赖 eclipseWtpComponent和 eclipseWtpFacet生成对应配置文件。请注意，现在 Eclipse 任务本身也依赖于 eclipseWtp。

对于这些任务中的每一个，都有一个对应的 clean 任务。这些清理任务将删除配置文件。

如果我们执行eclipse任务，会得到如下配置文件：.project, .classpath, <代码类="literal">org.eclipse.jdt.core.prefs。我们还在 .settings文件夹中获得了额外的配置文件，名称为 org.eclipse.wst.common.component和 org.eclipse.wst.common.project.facet.core.xml：

$ gradle eclipse
:eclipseClasspath
:eclipseJdt
:eclipseProject
:eclipseWtpComponent
:eclipseWtpFacet
:eclipseWtp
:eclipse
BUILD SUCCESSFUL
Total time: 0.926 secs

.project文件的内容显示Eclipse WTP插件添加了额外的性质和构建命令，如下所示：

<?xml version="1.0" encoding="UTF-8"?>
<projectDescription>
    <name>eclipse</name>
    <comment>Sample project</comment>
    <projects/>
    <natures>
      <nature>org.eclipse.jdt.core.javanature</nature>
      <nature>org.eclipse.wst.common.project.facet.core.nature
   </nature>
      <nature>org.eclipse.wst.common.modulecore.ModuleCoreNature
   </nature>
      <nature>org.eclipse.jem.workbench.JavaEMFNature</nature>
    </natures>
    <buildSpec>
      <buildCommand>
        <name>org.eclipse.jdt.core.javabuilder</name>
          <arguments/>
      </buildCommand>
      <buildCommand>
        <name>org.eclipse.wst.common.project.facet.core.builder
           </name>
            <arguments/>
      </buildCommand>
      <buildCommand>
        <name>org.eclipse.wst.validation.validationbuilder</name>
          <arguments/>
      </buildCommand>
    </buildSpec>
    <linkedResources/>
</projectDescription>

在.classpath配置文件中，多了一个 org.eclipse.jst.j2ee.internal.web.container容器，如以下代码片段所示：

<?xml version="1.0" encoding="UTF-8"?>
<classpath>
    <classpathentry kind="output" path="bin"/>
    <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/ org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/ JavaSE-1.8/"/>
    <classpathentry kind="con" path="org.eclipse.jst.j2ee.internal.web.container"/>
    <classpathentry sourcepath="/Users/mrhaki/.gradle/caches/ modules-2/files-2.1/junit/junit/ 4.11/28e0ad201304e4a4abf999ca0570b7cffc352c3c/ junit-4.11-sources.jar" kind="lib" path= "/Users/mrhaki/.gradle/caches/modules-2/files- 2.1/junit/junit/4.11/ 4e031bb61df09069aeb2bffb4019e7a5034a4ee0/ junit-4.11.jar">
      <attributes>
        <attribute name="org.eclipse.jst.component.nondependency" value=""/>
      </attributes>
    </classpathentry>
    <classpathentry sourcepath="/Users/mrhaki/.gradle/caches/ modules-2/files-2.1/org.hamcrest/hamcrest- core/1.3/1dc37250fbc78e23a65a67fbbaf71d2e9cbc3c0b/ hamcrest-core-1.3-sources.jar" kind="lib" path="/Users/mrhaki/.gradle/caches/modules-2/files- 2.1/org.hamcrest/hamcrest- core/1.3/42a25dc3219429f0e5d060061f71acb49bf010a0/ hamcrest-core-1.3.jar">
        <attributes>
          <attribute name="org.eclipse.jst.component.nondependency" value=""/>
        </attributes>
    </classpathentry>
</classpath>

.settings文件夹中的 org.eclipse.jdt.core.prefs文件内容与标准的 Eclipse 插件。 org.eclipse.wst.common.component文件内容如下：

<?xml version="1.0" encoding="UTF-8"?> 
<project-modules id="moduleCoreId" project-version="2.0"> 
    <wb-module deploy-name="eclipse"> 
        <property name="context-root" value="eclipse"/> 
    </wb-module> 
</project-modules>

在这里，我们找到了我们项目的 Web 部分的信息。

.settings 文件夹中最后生成的文件是 org.eclipse.wst.common.project.facet.core.xml 文件；在这里，我们看到了 servlet 和 Java 版本。该文件具有以下内容：

<?xml version="1.0" encoding="UTF-8"?> 
<faceted-project> 
    <fixed facet="jst.java"/> 
    <fixed facet="jst.web"/> 
    <installed facet="jst.web" version="2.4"/> 
    <installed facet="jst.java" version="1.8"/> 
</faceted-project>

Using the IntelliJ IDEA plugin

JetBrains 的 IntelliJ IDEA 是我们可以用来开发应用程序的另一个 IDE。 Gradle 有 IDEA 插件来为 IntelliJ IDEA 生成项目文件。这意味着我们可以简单地在 IntelliJ IDEA 中打开项目。正确设置依赖项以在 IDE 中编译项目。在本节中，我们将看到如何生成这些文件并自定义文件生成。

IntelliJ IDEA 支持项目文件的基于文件夹和基于文件的格式。 IDEA 插件为基于文件的格式生成文件。项目文件的文件格式是 XML。工作区项目文件具有 .iws 扩展名并包含个人设置。项目信息存储在扩展名为 .ipr 的文件中。项目文件可以保存在版本控制系统中，因为它没有对本地路径的引用。工作区项目文件有很多个人设置，不应该放在版本控制系统中。

对于 Java 项目，我们有第三个扩展名为 .iml 的项目文件。此文件包含具有本地路径位置的依赖项引用。我们不应该将此文件放在版本控制系统中。 IDEA 插件可以像 Eclipse 插件一样，为依赖项下载相关的源文件。我们还可以配置和下载相关的 Javadoc 文件。 IDEA 插件与 Java 插件一起工作。如果我们有一个 Gradle 构建文件并且我们同时应用了 Java 和 IDEA 插件，则会将特定的 Java 配置添加到项目文件中。

让我们创建一个示例构建文件并应用 IDEA 插件，如以下代码片段所示：

apply plugin: 'java' 
apply plugin: 'idea' 
 
version = 1.0 
 
sourceCompatibility = 1.8 
targetCompatibility = 1.8 
 
description = 'Sample project' 
 
ext { 
    slf4jVersion = '1.7.18' 
    slf4jGroup = 'org.slf4j' 
} 
 
configurations { 
    extraLib 
} 
 
repositories { 
    jcenter() 
} 
 
dependencies { 
    testCompile 'junit:junit:4.11' 

    extraLib "$slf4jGroup:slf4j-api:$slf4jVersion", 
            "$slf4jGroup:slf4j-simple:$slf4jVersion" 
}

首先，我们执行tasks任务，看看插件添加了哪些任务，如下：

$ gradle tasks --all
:tasks
...
IDE tasks
---------
cleanIdea - Cleans IDEA project files (IML, IPR)
cleanIdeaModule
cleanIdeaProject
idea - Generates IDEA project files (IML, IPR, IWS)
ideaModule - Generates IDEA module files (IML)
ideaProject - Generates IDEA project file (IPR)
ideaWorkspace - Generates an IDEA workspace file (IWS)
...

我们有一个想法任务，它依赖于以下三个其他任务：ideaWorkspace、 ideaModule 和 ideaProject。这些任务中的每一个都可以生成一个项目文件。要删除模块和项目文件，我们可以执行 cleanIdeaModule 和 cleanIdeaProject 任务或干脆 cleanIdea 任务。没有 cleanIdeaWorkspace 任务，因为工作区文件包含个人设置。这些设置可能是通过 IntelliJ IDEA 的用户界面设置的，不应被 Gradle 任务删除。

当我们从命令行运行 idea 任务并查看输出时，如下所示；我们将看到所有任务都已执行，我们现在有三个项目文件：

$ gradle idea
:ideaModule
:ideaProject
:ideaWorkspace
:idea
BUILD SUCCESSFUL
Total time: 1.057 secs

Customizing file generation

IDEA 插件有几种方法可以自定义生成文件中的配置，就像 Eclipse 插件一样。该插件将查看项目设置并使用生成文件中的信息。例如，我们可以在 Gradle 项目中设置源和目标兼容版本，插件将使用它们在生成的项目文件中设置正确的值。

我们可以使用 DSL 在文件生成之前更改配置信息。 Gradle 还提供了钩子，我们可以在应用项目信息和 DSL 配置之前和之后操作模型对象。要更改生成的 XML 结构，我们可以实现 withXml 挂钩。我们可以在 XML 写入磁盘之前对其进行更改。要更改工作区文件的内容，我们应该使用 withXml 钩子。工作区文件有一个空的模型对象并且没有 DSL，因为内容非常具体并且包含很多个人设置。

Running Gradle in Eclipse

我们可以使用 Eclipse 插件生成 Eclipse 项目文件。我们还可以在 Eclipse 中导入 Gradle 构建文件，然后在 Eclipse 中执行 Gradle 任务。在本节中，我们将看到如何在 Eclipse 中安装 Gradle 插件，以及如何使用它来导入 Gradle 构建文件并执行任务。

Gradle 开发了一个名为 Buildship 的 Eclipse 插件。该插件将 Gradle 集成添加到 Eclipse IDE。该插件有一个导入向导来导入现有的 Gradle 构建。它还支持多项目构建。

该插件跟踪在 Gradle 构建文件中定义为项目依赖项的依赖项。这意味着如果我们更改构建文件中的依赖项，Eclipse 类路径将随着更改而更新，以便编译器可以使用它。

为了执行任务，插件向 Eclipse 添加了一个附加视图。从视图中，我们可以执行任务。 Eclipse 启动框架用于执行任务。

Installing the buildship plugin

以下步骤可用于安装 buildship 插件：

要安装插件，我们将使用 Eclipse 市场。从 Help 菜单中，我们将选择 Eclipse Marketplace... 。然后我们将看到一个新的对话窗口。在 Search字段中，我们将输入buildship并等待搜索结果，如图在以下屏幕截图中：

在 Eclipse Marketplace 中搜索 Buildship 插件
然后我们点击 Install 按钮在我们的 Eclipse IDE 中安装插件。在安装对话框窗口中，我们将选择插件功能并点击确认按钮：

选择 Buildship 插件功能
我们必须接受许可，然后 Eclipse 会下载插件组件。下载完所有插件组件后重启 Eclipse：

Buildship 插件的许可证

Importing a Gradle project

安装插件后，我们可以使用导入向导导入 Gradle 项目。我们将使用一个非常简单的 Java 项目和以下构建文件：

apply plugin: 'java' 
 
version = '1.0' 
group = 'sample.gradle' 
 
description = 'Sample Java project' 
 
repositories { 
    jcenter() 
} 
 
dependencies { 
    testCompile 'junit:junit:4.11' 
}

在 Eclipse 中，我们从文件<中选择 Import 选项/span> 菜单。
在 Import 对话框窗口中，我们将选择 Gradle Project 选项，然后单击 Next 按钮，如下图所示：

导入 Gradle 项目
在导入向导的下一步中，我们必须为 Gradle 项目指定根文件夹。对于多项目构建，我们应该选择根文件夹。如果我们只有一个项目，我们可以选择项目文件夹。
我们将点击下一步按钮查看其他选项。不过，我们也可以点击 Finish按钮将项目导入Eclipse：

导入 Gradle 项目概述
在Import Gradle Project对话框窗口中，我们可以指定一些额外的选项：

导入 Gradle 项目的配置
在 Gradle 分布部分中，我们可以指定要用于构建项目的 Gradle 位置和分布。我们使用默认的 Gradle wrapper (recommended) 选项来使用项目中的 wrapper find。我们也可以选择一个本地安装目录来引用我们计算机上的Gradle安装。使用远程分发位置选项，我们可以为 Gradle 分发设置下载位置。例如，这也可以是具有分布的公司 Intranet 站点。
最后，我们可以使用 Specific Gradle version来选择一个版本。如果我们还没有该版本，则会将其下载到我们的计算机上。
在高级选项部分，我们可以为运行 Gradle 指定更多选项。例如，更改 GRADLE_USER_HOME 目录或额外的命令行选项。
我们将点击下一步按钮，在项目导入前获得所有设置的概览：

导入 Gradle 项目的选项预览
接下来，我们将点击 Finish按钮将项目导入Eclipse：

在 Eclipse 中导入 Gradle 项目

Running tasks

要执行任务，我们将首先打开 Gradle Tasks 视图。通常，它已经在我们工作区的底部可见。如果没有，我们可以从 Window 菜单中打开它，我们将选择 Show View 然后其他...。我们将在搜索字段中键入 gradle 以搜索 Gradle Tasks 视图。

在我们的工作区中，我们现在将拥有 Gradle Tasks 视图。然后显示此项目的任务，如以下屏幕截图所示：

Gradle 任务视图中的 Gradle 任务概述
要执行任务，我们只需双击任务名称。在 Gradle Executions 视图中，我们可以看到执行的任务以及每个任务花费的时间：

运行 Gradle 任务后的结果
要查看任务的输出，我们将打开 Console 视图。在这里，我们可以看到执行任务的控制台输出：

运行 Gradle 任务后的控制台输出
我们也可以使用 Eclipse 的启动框架来运行任务。我们必须右键单击项目并选择 Gradle Build 或 Gradle Build... 选项来自 Run As 选项。启动配置打开，在这里我们可以配置要执行的任务，如下图所示：

将 Gradle 任务配置为运行配置
在这里，我们可以输入我们要执行的 Gradle 任务的名称。

Running Gradle in IntelliJ IDEA

我们可以在构建文件中使用 IDEA 插件生成 IDEA 项目文件。 IntelliJ IDEA 有一个 Gradle 插件，无需先创建项目文件即可导入 Gradle 项目。在本节中，我们将讨论如何将 Gradle 插件与 IntelliJ IDEA 15 Community Edition 或 Ultimate 一起使用。

我们使用与 Eclipse Gradle 插件一起使用的相同项目将项目导入 IntelliJ IDEA。

Installing the plugin

Gradle 插件可以通过 IntelliJ IDEA 插件管理器安装。我们需要进入设置窗口中的 IDE设置，如下图所示：

读书笔记《gradle-effective-implementations-guide-second-edition》IDE支持

从可用插件列表中选择 Gradle 插件

我们将选择 Gradle 插件将其安装在 IDE 中。一旦我们安装了插件，我们就可以导入一个项目。默认情况下，它已经安装。

Importing a project

要导入现有的 Gradle 项目，请执行以下步骤：

我们将从启动屏幕启动导入项目向导。或者，我们将从文件<中选择 Project from existing sources...选项/strong> 菜单。 IntelliJ IDEA 显示一个对话框窗口，我们可以在其中选择新项目的源，如以下屏幕截图所示：

选择 Gradle 构建文件以导入 IDEA
我们将点击确定按钮。 IntelliJ IDEA 显示了一个新的对话框窗口，我们可以在其中填写一些额外的详细信息：

导入 Gradle 项目的选项概述
在这里，我们可以在将 Gradle 项目导入 IntelliJ IDEA 之前设置一些额外的选项。 Use auto-import 选项会自动将新模块添加到我们的项目中，用于多模块项目，或者在我们制作时再次执行构建文件更改，IDEA 项目会自动更新。
使用自动为空内容根目录创建目录选项，IntelliJ IDEA 将根据我们的 Gradle 构建中的源集创建目录。比如我们应用java插件的时候， src/main/java, src/main/resources, src/test/java和 src/test/resources目录被创建。
我们还可以指定需要使用的 Gradle 版本。我们可以选择为项目配置的包装器，如果它与使用默认的gradle包装器选项可用。但是，如果包装器不在我们的项目中，我们可以使用使用可自定义的 gradle 包装器选项创建一个。
最后，我们可以使用使用本地 gradle 发行版选择已经安装在我们计算机上的 Gradle 发行版。
如果我们需要另一个 Gradle 主目录，我们可以在 Gradle home 字段中设置一个值。我们也可以通过 Gradle JVM选项设置Gradle使用的JDK。
我们可以为 IntelliJ IDEA 项目使用两种格式：基于目录或基于文件。我们使用项目格式选择我们想要的选项。
如果我们点击 Global Gradle settings旁边的箭头，我们可以访问额外的选项。我们还可以使用离线工作复选框指定离线工作。
要更改 Gradle 用户主目录，我们可以设置服务目录路径的值。我们希望应用于所有构建任务的任何 Gradle VM 选项都将在 Gradle VM options 字段中设置。
要创建我们的项目，我们将单击确定按钮。
我们可以看到项目及其依赖项，如以下屏幕截图所示：

在 IntelliJ IDEA 中创建 Gradle 项目

Running tasks

要查看 Gradle 项目依赖结构，我们也可以打开 Gradle 窗口：

在这里，我们可以看到构建文件中定义的所有任务和依赖项。我们必须点击 Refresh按钮才能使用 build.gradle中的最新更改文件。例如，如果我们添加一个新的 org.slf4j:slf4j-api:1.7.18 编译依赖，我们必须点击刷新按钮才能看到更改。
在 Gradle 窗口中，我们可以双击任务名称来启动它。这些任务按 Gradle 构建文件中的任务组进行分组：

任务概述
例如，我们可以双击 build来启动 build任务。我们也可以点击运行按钮。我们得到一个新的对话窗口，我们可以在其中选择要运行的任务和项目：

运行 Gradle 任务的选项
输出是任务，如运行窗口所示。在这里我们可以看到任务的执行情况以及相应的状态和输出：

运行 Gradle 任务后的控制台输出
启动任务的另一种方法是通过 IntelliJ IDEA 的运行配置。首先，我们必须创建一个新配置。在工具栏中，我们点击配置列表框，选择Edit configurations...â€‹，如下图所示：

选择编辑配置选项
在对话框窗口中，我们可以指定运行构建所需的选项。我们可以在 Tasks字段中输入任务名称。如果我们点击 OK按钮，我们可以运行一个新的配置来执行任务：

为 Gradle 任务运行配置

Summary

当我们开发应用程序时，我们通常使用 IDE 开发代码。在本章中，我们看到了如何使用 Eclipse、Eclipse WTP 和 IDEA 中的 Gradle 插件为 Eclipse 和 IntelliJ IDEA 生成项目文件。

插件有一个 DSL 可以在生成文件之前更改配置。我们还可以使用钩子在应用 DSL 之前和之后更改模型对象。在最低级别，我们可以使用 withXml 挂钩在文件写入磁盘之前更改 XML 内容。

Eclipse 和 IntelliJ IDEA 都有用于导入现有 Gradle 项目的插件。然后，我们可以在 IDE 中处理该项目。额外的依赖项或更改会反映在类路径项目文件中，以便可以使用 IDE 的编译器编译代码。我们还可以在 IDE 中运行 Gradle 任务，因此如果我们想使用 Gradle，就不必离开我们最喜欢的 IDE。

在本书中，我们看到了 Gradle 作为构建工具的强大功能。 Gradle 语法非常一致且紧凑。如果我们知道基础知识，我们可以完成很多事情。我们讨论了如何将功能添加到带有任务的构建文件中。我们已经了解了如何在 Java、Groovy 和 Scala 项目中使用 Gradle。我们看到了 Gradle 处理多项目的特性。我们还讨论了如何创建自定义任务和插件以实现跨项目重用构建逻辑。阅读本书后，您将能够在软件开发中使用 Gradle。使用 Gradle，我们可以在我们的项目中拥有很大的灵活性，并且仍然依赖于出售的约定优于配置的默认值。我们可以从简单开始，逐步扩展构建脚本，使其具有更多功能。有了这本书，您将快速入门并在您的项目中成功实施 Gradle。

vlambda博客
学习文章列表