Gradle 用户指南

示例列表
List of Examples

6.1. The first build script

6.2. Execution of a build script

6.3. A task definition shortcut

6.4. Using Groovy in Gradle's tasks

6.5. Using Groovy in Gradle's tasks

6.6. Declaration of dependencies between tasks

6.7. Lazy dependsOn - the other task does not exist (yet)

6.8. Dynamic creation of a task

6.9. Accessing a task via API - adding a dependency

6.10. Accessing a task via API - adding behaviour

6.11. Accessing task as a property of the build script

6.12. Adding extra properties to a task

6.13. Using AntBuilder to execute ant.loadfile target

6.14. Using methods to organize your build logic

6.15. Defining a default tasks

6.16. Different outcomes of build depending on chosen tasks

7.1. Using the Java plugin

7.2. Building a Java project

7.3. Adding Maven repository

7.4. Adding dependencies

7.5. Customization of MANIFEST.MF

7.6. Adding a test system property

7.7. Publishing the JAR file

7.8. Eclipse plugin

7.9. Java example - complete build file

7.10. Multi-project build - hierarchical layout

7.11. Multi-project build - settings.gradle file

7.12. Multi-project build - common configuration

7.13. Multi-project build - dependencies between projects

7.14. Multi-project build - distribution file

8.1. Declaring dependencies

8.2. Definition of an external dependency

8.3. Shortcut definition of an external dependency

8.4. Usage of Maven central repository

8.5. Usage of a remote Maven repository

8.6. Usage of a remote Ivy directory

8.7. Usage of a local Ivy directory

8.8. Publishing to an Ivy repository

8.9. Publishing to a Maven repository

9.1. Groovy plugin

9.2. Dependency on Groovy 2.2.0

9.3. Groovy example - complete build file

10.1. War plugin

10.2. Running web application with Jetty plugin

11.1. Executing multiple tasks

11.2. Excluding tasks

11.3. Abbreviated task name

11.4. Abbreviated camel case task name

11.5. Selecting the project using a build file

11.6. Selecting the project using project directory

11.7. Obtaining information about projects

11.8. Providing a description for a project

11.9. Obtaining information about tasks

11.10. Changing the content of the task report

11.11. Obtaining more information about tasks

11.12. Obtaining detailed help for tasks

11.13. Obtaining information about dependencies

11.14. Filtering dependency report by configuration

11.15. Getting the insight into a particular dependency

11.16. Information about properties

12.1. Launching the GUI

13.1. Accessing property of the Project object

13.2. Using local variables

13.3. Using extra properties

13.4. Groovy JDK methods

13.5. Property accessors

13.6. Method call without parentheses

13.7. List and map literals

13.8. Closure as method parameter

13.9. Closure delegates

14.1. Directory creation with mkdir

14.2. Setting properties with a gradle.properties file

14.3. Configuring the project using an external build script

14.4. Configuring arbitrary objects

14.5. Configuring arbitrary objects using a script

15.1. Defining tasks

15.2. Defining tasks - using strings for task names

15.3. Defining tasks with alternative syntax

15.4. Accessing tasks as properties

15.5. Accessing tasks via tasks collection

15.6. Accessing tasks by path

15.7. Creating a copy task

15.8. Configuring a task - various ways

15.9. Configuring a task - with closure

15.10. Defining a task with closure

15.11. Adding dependency on task from another project

15.12. Adding dependency using task object

15.13. Adding dependency using closure

15.14. Adding a 'must run after' task ordering

15.15. Adding a 'should run after' task ordering

15.16. Task ordering does not imply task execution

15.17. A 'should run after' task ordering is ignored if it introduces an ordering cycle

15.18. Adding a description to a task

15.19. Overwriting a task

15.20. Skipping a task using a predicate

15.21. Skipping tasks with StopExecutionException

15.22. Enabling and disabling tasks

15.23. A generator task

15.24. Declaring the inputs and outputs of a task

15.25. Task rule

15.26. Dependency on rule based tasks

15.27. Adding a task finalizer

15.28. Task finalizer for a failing task

16.1. Locating files

16.2. Creating a file collection

16.3. Using a file collection

16.4. Implementing a file collection

16.5. Creating a file tree

16.6. Using a file tree

16.7. Using an archive as a file tree

16.8. Specifying a set of files

16.9. Specifying a set of files

16.10. Copying files using the copy task

16.11. Specifying copy task source files and destination directory

16.12. Selecting the files to copy

16.13. Copying files using the copy() method without up-to-date check

16.14. Copying files using the copy() method with up-to-date check

16.15. Renaming files as they are copied

16.16. Filtering files as they are copied

16.17. Nested copy specs

16.18. Using the Sync task to copy dependencies

16.19. Creating a ZIP archive

16.20. Creation of ZIP archive

16.21. Configuration of archive task - custom archive name

16.22. Configuration of archive task - appendix & classifier

17.1. Using an Ant task

17.2. Passing nested text to an Ant task

17.3. Passing nested elements to an Ant task

17.4. Using an Ant type

17.5. Using a custom Ant task

17.6. Declaring the classpath for a custom Ant task

17.7. Using a custom Ant task and dependency management together

17.8. Importing an Ant build

17.9. Task that depends on Ant target

17.10. Adding behaviour to an Ant target

17.11. Ant target that depends on Gradle task

17.12. Setting an Ant property

17.13. Getting an Ant property

17.14. Setting an Ant reference

17.15. Getting an Ant reference

18.1. Using stdout to write log messages

18.2. Writing your own log messages

18.3. Using SLF4J to write log messages

18.4. Configuring standard output capture

18.5. Configuring standard output capture for a task

18.6. Customizing what Gradle logs

20.1. Configuring an HTTP proxy

20.2. Configuring an HTTPS proxy

21.1. Applying a plugin

21.2. Applying a plugin by type

21.3. Applying a plugin by type

21.4. Tasks added by a plugin

21.5. Changing plugin defaults

21.6. Plugin convention object

23.1. Using the Java plugin

23.2. Custom Java source layout

23.3. Accessing a source set

23.4. Configuring the source directories of a source set

23.5. Defining a source set

23.6. Defining source set dependencies

23.7. Compiling a source set

23.8. Assembling a JAR for a source set

23.9. Generating the Javadoc for a source set

23.10. Running tests in a source set

23.11. Filtering tests in the build script

23.12. JUnit Categories

23.13. Grouping TestNG tests

23.14. Creating a unit test report for subprojects

23.15. Customization of MANIFEST.MF

23.16. Creating a manifest object.

23.17. Separate MANIFEST.MF for a particular archive

23.18. Separate MANIFEST.MF for a particular archive

24.1. Using the Groovy plugin

24.2. Custom Groovy source layout

24.3. Configuration of Groovy dependency

24.4. Configuration of Groovy test dependency

24.5. Configuration of bundled Groovy dependency

24.6. Configuration of Groovy file dependency

25.1. Using the Scala plugin

25.2. Custom Scala source layout

25.3. Declaring a Scala dependency for production code

25.4. Declaring a Scala dependency for test code

25.5. Enabling the Fast Scala Compiler

25.6. Adjusting memory settings

25.7. Activating the Zinc based compiler

26.1. Using the War plugin

26.2. Customization of war plugin

27.1. Using the Ear plugin

27.2. Customization of ear plugin

28.1. Using the Jetty plugin

29.1. Using the Checkstyle plugin

30.1. Using the CodeNarc plugin

31.1. Using the FindBugs plugin

32.1. Using the JDepend plugin

33.1. Using the PMD plugin

34.1. Applying the JaCoCo plugin

34.2. Configuring JaCoCo plugin settings

34.3. Configuring test task

34.4. Configuring test task

34.5. Using application plugin to generate code coverage data

34.6. Coverage reports generated by applicationCodeCoverageReport

35.1. Applying the Sonar plugin

35.2. Configuring Sonar connection settings

35.3. Configuring Sonar project settings

35.4. Global configuration in a multi-project build

35.5. Common project configuration in a multi-project build

35.6. Individual project configuration in a multi-project build

35.7. Configuring the language to be analyzed

35.8. Using property syntax

35.9. Analyzing custom source sets

35.10. Analyzing languages other than Java

35.11. Setting custom global properties

35.12. Setting custom project properties

35.13. Implementing custom command line properties

36.1. Applying the Sonar Runner plugin

36.2. Configuring Sonar connection settings

36.3. Global configuration settings

36.4. Shared configuration settings

36.5. Individual configuration settings

36.6. Skipping analysis of a project

36.7. Analyzing custom source sets

36.8. Analyzing languages other than Java

37.1. Using the OSGi plugin

37.2. Configuration of OSGi MANIFEST.MF file

38.1. Using the Eclipse plugin

38.2. Partial Overwrite for Classpath

38.3. Partial Overwrite for Project

38.4. Export Dependencies

38.5. Customizing the XML

39.1. Using the IDEA plugin

39.2. Partial Overwrite for Module

39.3. Partial Overwrite for Project

39.4. Export Dependencies

39.5. Customizing the XML

40.1. Using the ANTLR plugin

40.2. Declare ANTLR version

42.1. Using the announce plugin

42.2. Configure the announce plugin

42.3. Using the announce plugin

43.1. Using the build announcements plugin

43.2. Using the build announcements plugin from an init script

44.1. Using the distribution plugin

44.2. Adding extra distributions

44.3. Configuring the main distribution

45.1. Using the application plugin

45.2. Configure the application main class

45.3. Configure default JVM settings

45.4. Include output from other tasks in the application distribution

45.5. Automatically creating files for distribution

46.1. Using the java library distribution plugin

46.2. Configure the distribution name

46.3. Include files in the distribution

49.1. Using the Build Dashboard plugin

50.1. Definition of a configuration

50.2. Accessing a configuration

50.3. Configuration of a configuration

50.4. Module dependencies

50.5. Artifact only notation

50.6. Dependency with classifier

50.7. Iterating over a configuration

50.8. Client module dependencies - transitive dependencies

50.9. Project dependencies

50.10. File dependencies

50.11. Generated file dependencies

50.12. Gradle API dependencies

50.13. Gradle's Groovy dependencies

50.14. Excluding transitive dependencies

50.15. Optional attributes of dependencies

50.16. Collections and arrays of dependencies

50.17. Dependency configurations

50.18. Dependency configurations for project

50.19. Configuration.copy

50.20. Accessing declared dependencies

50.21. Configuration.files

50.22. Configuration.files with spec

50.23. Configuration.copy

50.24. Configuration.copy vs. Configuration.files

50.25. Declaring a Maven and Ivy repository

50.26. Providing credentials to a Maven and Ivy repository

50.27. Adding central Maven repository

50.28. Adding Bintray's JCenter Maven repository

50.29. Adding the local Maven cache as a repository

50.30. Adding custom Maven repository

50.31. Adding additional Maven repositories for JAR files

50.32. Accessing password protected Maven repository

50.33. Flat repository resolver

50.34. Ivy repository

50.35. Ivy repository with named layout

50.36. Ivy repository with pattern layout

50.37. Ivy repository with multiple custom patterns

50.38. Ivy repository with Maven compatible layout

50.39. Ivy repository

50.40. Accessing a repository

50.41. Configuration of a repository

50.42. Definition of a custom repository

50.43. Forcing consistent version for a group of libraries

50.44. Using a custom versioning scheme

50.45. Blacklisting a version with a replacement

50.46. Changing dependency group and/or name at the resolution

50.47. Enabling dynamic resolve mode

50.48. 'Latest' version selector

50.49. Custom status scheme

50.50. Dynamic version cache control

50.51. Changing module cache control

51.1. Defining an artifact using an archive task

51.2. Defining an artifact using a file

51.3. Customizing an artifact

51.4. Map syntax for defining an artifact using a file

51.5. Configuration of the upload task

52.1. Using the Maven plugin

52.2. Creating a stand alone pom.

52.3. Upload of file to remote Maven repository

52.4. Upload of file via SSH

52.5. Customization of pom

52.6. Builder style customization of pom

52.7. Modifying auto-generated content

52.8. Customization of Maven installer

52.9. Generation of multiple poms

52.10. Accessing a mapping configuration

53.1. Using the Signing plugin

53.2. Signing a configuration

53.3. Signing a configuration output

53.4. Signing a task

53.5. Signing a task output

53.6. Conditional signing

53.7. Signing a POM for deployment

54.1. Defining a library component

54.2. Defining executable components

54.3. The 'cpp' plugin

54.4. C++ source set

54.5. The 'c' plugin

54.6. C source set

54.7. The 'assembler' plugin

54.8. The 'objective-c' plugin

54.9. The 'objective-cpp' plugin

54.10. Settings that apply to all binaries

54.11. Settings that apply to all shared libraries

54.12. Settings that apply to all binaries produced for the 'main' executable component

54.13. Settings that apply only to shared libraries produced for the 'main' library component

54.14. The 'windows-resources' plugin

54.15. Configuring the location of Windows resource sources

54.16. Building a resource-only dll

54.17. Providing a library dependency to the source set

54.18. Providing a library dependency to the binary

54.19. Declaring project dependencies

54.20. Defining build types

54.21. Configuring debug binaries

54.22. Defining platforms

54.23. Defining flavors

54.24. Targeting a component at particular platforms

54.25. Building all possible variants

54.26. Defining tool chains

54.27. Reconfigure tool arguments

54.28. Defining target platforms

54.29. Registering CUnit tests

54.30. Registering CUnit tests

54.31. Running CUnit tests

55.1. Single project build

55.2. Hierarchical layout

55.3. Flat layout

55.4. Modification of elements of the project tree

55.5. Modification of elements of the project tree

55.6. Adding of test task to each project which has certain property set

55.7. Notifications

55.8. Setting of certain property to all tasks

55.9. Logging of start and end of each task execution

56.1. Multi-project tree - water & bluewhale projects

56.2. Build script of water (parent) project

56.3. Multi-project tree - water, bluewhale & krill projects

56.4. Water project build script

56.5. Defining common behaviour of all projects and subprojects

56.6. Defining specific behaviour for particular project

56.7. Defining specific behaviour for project krill

56.8. Adding custom behaviour to some projects (filtered by project name)

56.9. Adding custom behaviour to some projects (filtered by project properties)

56.10. Running build from subproject

56.11. Evaluation and execution of projects

56.12. Evaluation and execution of projects

56.13. Running tasks by their absolute path

56.14. Dependencies and execution order

56.15. Dependencies and execution order

56.16. Dependencies and execution order

56.17. Declaring dependencies

56.18. Declaring dependencies

56.19. Cross project task dependencies

56.20. Configuration time dependencies

56.21. Configuration time dependencies - evaluationDependsOn

56.22. Configuration time dependencies

56.23. Dependencies - real life example - crossproject configuration

56.24. Project lib dependencies

56.25. Project lib dependencies

56.26. Fine grained control over dependencies

56.27. Build and Test Single Project

56.28. Partial Build and Test Single Project

56.29. Build and Test Depended On Projects

56.30. Build and Test Dependent Projects

57.1. Defining a custom task

57.2. A hello world task

57.3. A customizable hello world task

57.4. A build for a custom task

57.5. A custom task

57.6. Using a custom task in another project

57.7. Testing a custom task

57.8. Defining an incremental task action

57.9. Running the incremental task for the first time

57.10. Running the incremental task with unchanged inputs

57.11. Running the incremental task with updated input files

57.12. Running the incremental task with an input file removed

57.13. Running the incremental task with an output file removed

57.14. Running the incremental task with an input property changed

58.1. A custom plugin

58.2. A custom plugin extension

58.3. A custom plugin with configuration closure

58.4. Evaluating file properties lazily

58.5. A build for a custom plugin

58.6. Wiring for a custom plugin

58.7. Using a custom plugin in another project

58.8. Testing a custom plugin

58.9. Managing domain objects

59.1. Using inherited properties and methods

59.2. Using injected properties and methods

59.3. Custom buildSrc build script

59.4. Adding subprojects to the root buildSrc project

59.5. Running another build from a build

59.6. Declaring external dependencies for the build script

59.7. A build script with external dependencies

59.8. Ant optional dependencies

60.1. Using init script to perform extra configuration before projects are evaluated

60.2. Declaring external dependencies for an init script

60.3. An init script with external dependencies

60.4. Using plugins in init scripts

61.1. Wrapper task

61.2. Wrapper generated files

64.1. Applying the “ivy-publish” plugin

64.2. Publishing a java module to Ivy

64.3. Publishing additional artifact to Ivy

64.4. customizing the publication identity

64.5. Customizing the module descriptor file

64.6. Publishing multiple modules from a single project

64.7. Declaring repositories to publish to

64.8. Choosing a particular publication to publish

64.9. Publishing all publications via the “publish” lifecycle task

64.10. Generating the Ivy module descriptor file

64.11. Publishing a java module

64.12. Example generated ivy.xml

65.1. Applying the 'maven-publish' plugin

65.2. Adding a MavenPublication for a java component

65.3. Adding additional artifact to a MavenPublication

65.4. customizing the publication identity

65.5. Modifying the POM file

65.6. Publishing multiple modules from a single project

65.7. Declaring repositories to publish to

65.8. Publishing a project to a Maven repository

65.9. Publish a project to the Maven local repository

65.10. Generate a POM file without publishing

B.1. Variables scope: local and script wide

B.2. Distinct configuration and execution phase