├── .gitattributes ├── .gitignore ├── README.md ├── SUMMARY.md ├── TOC.md ├── about_this_user_guide.md ├── book.json ├── build_script_basics ├── README.md ├── a_shortcut_task_definition.md ├── build_scripts_are_code.md ├── configure_by_dag.md ├── default_tasks.md ├── dynamic_tasks.md ├── extra_task_properties.md ├── hello_world.md ├── manipulating_existing_tasks.md ├── projects_and_tasks.md ├── shortcut_notations.md ├── task_dependencies.md ├── using_ant_tasks.md └── using_methods.md ├── cover.jpg ├── cover_small.jpg ├── dependency_management_basics ├── README.md ├── a_basic_java_project.md ├── dependency_configurations.md ├── external_dependencies.md ├── publishing_artifacts.md ├── repositories.md ├── what_is_dependency_management.md └── where_to_next.md ├── earcha-jian.md ├── gradle_plugins ├── README.md ├── applying_plugins.md ├── applying_plugins_with_the_buildscript_block.md ├── applying_plugins_with_the_plugins_dsl.md ├── binary_plugins.md ├── can_only_be_used_in_build_scripts.md ├── cannot_be_used_in_conjunction.md ├── constrained_syntax.md ├── finding_community_plugins.md ├── limitations_of_the_plugins_dsl.md ├── locations_of_binary_plugins.md ├── more_on_plugins.md ├── script_plugins.md ├── types_of_plugins.md └── what_plugins_do.md ├── groovy_quickstart ├── README.md ├── a_basic_groovy_project.md └── summary.md ├── installing_gradle ├── README.md ├── download.md ├── environment_variables.md ├── jvm_options.md ├── prerequisites.md ├── running_and_testing_your_installation.md └── unpacking.md ├── introduction.md ├── java.md ├── java_quickstart ├── README.md ├── a_basic_java_project.md ├── building_the_project.md ├── common_configuration.md ├── creating_a_distribution.md ├── creating_an_eclipse_project.md ├── customizing_the_project.md ├── defining_a_multi-project_build.md ├── dependencies_between_projects.md ├── external_dependencies.md ├── multi-project_java_build.md ├── publishing_the_jar_file.md ├── summary.md └── the_java_plugin.md ├── logging ├── changing_what_gradle_logs.md ├── choosing_a_log_level.md ├── logging.md ├── logging_from_external_tools_and_libraries.md └── writing_your_own_log_messages.md ├── more_about_tasks ├── README.md ├── adding_a_description_to_a_task.md ├── adding_dependencies_to_a_task.md ├── cache.md ├── config_any_object.md ├── configuring_tasks.md ├── defining_tasks.md ├── extra.md ├── finalizer_tasks.md ├── gradle_properties_and_system_properties.md ├── locating_tasks.md ├── ordering_tasks.md ├── replacing_tasks.md ├── skipping_tasks.md ├── skipping_tasks_that_are_up-to-date.md ├── task_rules.md ├── use_other_script_to_config_any_object.md └── use_other_script_to_config_project.md ├── npm-debug.log ├── overview ├── README.md ├── features.md └── why_groovy.md ├── standard_gradle_plugins ├── README.md ├── base_plugins.md ├── incubating_integration_plugins.md ├── incubating_language_plugins.md ├── incubating_software_development_plugins.md ├── integration_plugins.md ├── language_plugins.md ├── software_development_plugins.md └── third_party_plugins.md ├── the_gradle_daemon ├── README.md ├── how_can_i_stop_a_daemon.md ├── how_do_i_disable_the_gradle_daemon.md ├── how_do_i_enable_the_gradle_daemon.md ├── how_do_i_suppress_the_please_consider_using_the_gradle_daemon_message.md ├── how_does_the_gradle_daemon_make_builds_faster.md ├── how_much_memory_does_the_daemon_use_and_can_i_give_it_more.md ├── management_and_configuration.md ├── potential_future_enhancements.md ├── tools_&_ides.md ├── what_can_go_wrong_with_daemon.md ├── what_is_the_gradle_daemon.md ├── when_should_i_not_use_the_gradle_daemon.md └── why_is_there_more_than_one_daemon_process_on_my_machine.md ├── the_java_plugin ├── README.md ├── java_plugin_clean.md ├── java_plugin_compile_java.md ├── java_plugin_compilejava.md ├── java_plugin_convention_properties.md ├── java_plugin_defining_new_source_sets.md ├── java_plugin_dependency_management.md ├── java_plugin_incremental_java_compilation.md ├── java_plugin_jar.md ├── java_plugin_javadoc.md ├── java_plugin_manifest.md ├── java_plugin_project_layout.md ├── java_plugin_resources.md ├── java_plugin_source_set_properties.md ├── java_plugin_source_sets.md ├── java_plugin_tasks.md ├── java_plugin_test.md ├── java_plugin_uploading.md ├── java_plugin_usage.md ├── java_plugin_working_with_source_sets.md ├── java_plugins_some_source_set_examples.md ├── test_convention_values.md ├── test_debugging.md ├── test_detection.md ├── test_execution.md ├── test_filtering.md ├── test_grouping.md ├── test_reporting.md ├── test_single_test_execution_via_system_properties.md └── test_testNG_parameterized_methods_and_reporting.md ├── the_war_plugin ├── convention_properties.md ├── customizing.md ├── dependency_management.md ├── project_layout.md ├── tasks.md ├── the_war_plugin.md ├── usage.md └── war.md ├── troubleshooting ├── README.md ├── getting_help.md └── working_through_problems.md ├── tutorial_-_this_and_that └── caching.md ├── tutorials ├── README.md └── getting_started.md ├── using_ant_from_gradle ├── API.md ├── ant_properties_and_references.md ├── importing_an_ant_build.md ├── using_ant_from_gradle.md ├── using_ant_tasks_and_types_in_your_build.md └── using_custom_ant_tasks_in_your_build.md ├── using_the_gradle_command-line ├── README.md ├── continuing_the_build_when_a_failure_occurs.md ├── excluding_tasks.md ├── executing_multiple_tasks.md ├── getting_the_insight_into_a_particular_dependency.md ├── listing_project_dependencies.md ├── listing_project_properties.md ├── listing_projects.md ├── listing_tasks.md ├── listing_taskss.md ├── profiling_a_build.md ├── selecting_which_build_to_execute.md ├── show_task_usage_details.md └── task_name_abbreviation.md ├── using_the_gradle_graphical_user_interface ├── README.md ├── command_line.md ├── favorities.md ├── setup.md └── task_tree.md ├── web_application_quickstart ├── README.md ├── building_a_war_file.md ├── running_your_web_application.md └── summary.md ├── working_with_files ├── README.md ├── copying_files.md ├── creating_archives.md ├── file_collections.md ├── file_trees.md ├── java.md ├── locating_files.md ├── specifying_a_set_of_input_files.md ├── using_a_file_collection.md ├── using_the_contents_of_an_archive_as_a_file_tree.md └── using_the_sync_task.md └── writing_build_scripts ├── README.md ├── closure_delegate.md ├── closures_as_the_last_parameter_in_a_method.md ├── declaring_variables.md ├── extra_properties.md ├── groovy_jdk.md ├── list_and_map_literals.md ├── local_variables.md ├── optional_parentheses_on_method_calls.md ├── property_accessors.md ├── some_groovy_basics.md ├── standard_project_properties.md ├── the_gradle_build_language.md ├── the_project_api.md └── the_script_api.md /.gitattributes: -------------------------------------------------------------------------------- 1 | # Auto detect text files and perform LF normalization 2 | * text=auto 3 | 4 | # Custom for Visual Studio 5 | *.cs diff=csharp 6 | *.sln merge=union 7 | *.csproj merge=union 8 | *.vbproj merge=union 9 | *.fsproj merge=union 10 | *.dbproj merge=union 11 | 12 | # Standard to msysgit 13 | *.doc diff=astextplain 14 | *.DOC diff=astextplain 15 | *.docx diff=astextplain 16 | *.DOCX diff=astextplain 17 | *.dot diff=astextplain 18 | *.DOT diff=astextplain 19 | *.pdf diff=astextplain 20 | *.PDF diff=astextplain 21 | *.rtf diff=astextplain 22 | *.RTF diff=astextplain 23 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | # Windows image file caches 2 | Thumbs.db 3 | ehthumbs.db 4 | 5 | # Folder config file 6 | Desktop.ini 7 | 8 | # Recycle Bin used on file shares 9 | $RECYCLE.BIN/ 10 | 11 | # Windows Installer files 12 | *.cab 13 | *.msi 14 | *.msm 15 | *.msp 16 | 17 | # ========================= 18 | # Operating System Files 19 | # ========================= 20 | 21 | # OSX 22 | # ========================= 23 | 24 | .DS_Store 25 | .AppleDouble 26 | .LSOverride 27 | 28 | # Icon must ends with two \r. 29 | Icon 30 | 31 | # Thumbnails 32 | ._* 33 | 34 | # Files that might appear on external disk 35 | .Spotlight-V100 36 | .Trashes 37 | 38 | #GitBook Edit builed files 39 | _book/ 40 | 41 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Gradle User Guide 中文版 2 | 3 | ### [阅读地址](http://dongchuan.gitbooks.io/gradle-user-guide-/) 4 | 5 | * Gradle User Guide 中文版 目前正在更新到官方**4.6**版本 \(branch/\#22\), 将会在翻译完主要内容后合并的该分支. 因工作量大, 希望大家耐心等待, 也欢迎大家一起加入和完善. 6 | * 如果发现不通顺或者有歧义的地方, 可以在评论里指出来, 我们会及时改正的. 7 | * [Github托管地址](https://github.com/DONGChuan/GradleUserGuide) 8 | * [原文地址](https://docs.gradle.org/current/userguide/userguide.html) 9 | * [查看4.6翻译进度](https://github.com/DONGChuan/GradleUserGuide/tree/changes/22) 10 | 11 | --- 12 | 13 | ### 如何参与&联系我们 14 | 15 | * 邮箱: dongchuanyz@163.com 16 | * 微信: dongchuan55 17 | * QQ群: 324020116 18 | 19 | 任何问题都欢迎直接联系我们 20 | 21 | Gitbook 提供了非常棒的在线编辑功能, 所以想贡献的同学可以直接联系我申请权限！ 22 | 23 | --- 24 | 25 | ### 许可证 26 | 27 | 本作品采用 Apache License 2.0 国际许可协议 进行许可. 传播此文档时请注意遵循以上许可协议. 关于本许可证的更多详情可参考 [http://www.apache.org/licenses/LICENSE-2.0](http://www.apache.org/licenses/LICENSE-2.0) 28 | 29 | --- 30 | 31 | ### 贡献者列表 32 | 33 | | 成员 | 联系方式 | Github | 34 | | :--- | :--- | :--- | 35 | | dongchuan55 | dongchuan55@gmail.com | [Github](https://github.com/DONGChuan) | 36 | | UFreedom | sunfreedomsun@gmail.com | [Github](https://github.com/UFreedom) | 37 | | 张扬 | zhangyang911120@gmail.com | [Github](https://github.com/dreamkidd) | 38 | | d0048 | d0048@foxmail.com | [Github](https://github.com/D0048) | 39 | 40 | 41 | 42 | -------------------------------------------------------------------------------- /SUMMARY.md: -------------------------------------------------------------------------------- 1 | # Summary 2 | 3 | * [关于本书](README.md) 4 | * [安装Gradle](installing_gradle/README.md) 5 | * [准备阶段](installing_gradle/prerequisites.md) 6 | * [下载与安装](installing_gradle/download.md) 7 | * [JVM选项](installing_gradle/jvm_options.md) 8 | * [排除故障](troubleshooting/README.md) 9 | * [构建脚本基础](build_script_basics/README.md) 10 | * [Projects 和 tasks](build_script_basics/projects_and_tasks.md) 11 | * [Hello world](build_script_basics/hello_world.md) 12 | * [快捷的任务定义](build_script_basics/a_shortcut_task_definition.md) 13 | * [构建脚本代码](build_script_basics/build_scripts_are_code.md) 14 | * [任务依赖](build_script_basics/task_dependencies.md) 15 | * [动态任务](build_script_basics/dynamic_tasks.md) 16 | * [使用已经存在的任务](build_script_basics/manipulating_existing_tasks.md) 17 | * [短标记法](build_script_basics/shortcut_notations.md) 18 | * [自定义任务属性](build_script_basics/extra_task_properties.md) 19 | * [调用 Ant 任务](build_script_basics/using_ant_tasks.md) 20 | * [使用方法](build_script_basics/using_methods.md) 21 | * [默认任务](build_script_basics/default_tasks.md) 22 | * [通过 DAG 配置](build_script_basics/configure_by_dag.md) 23 | * [Java 构建入门](java_quickstart/README.md) 24 | * [Java 插件](java_quickstart/the_java_plugin.md) 25 | * [一个基础的 Java 项目](java_quickstart/a_basic_java_project.md) 26 | * [建立项目](java_quickstart/building_the_project.md) 27 | * [外部的依赖](java_quickstart/external_dependencies.md) 28 | * [定制项目](java_quickstart/customizing_the_project.md) 29 | * [发布 JAR 文件](java_quickstart/publishing_the_jar_file.md) 30 | * [创建 Eclipse 项目](java_quickstart/creating_an_eclipse_project.md) 31 | * [总结](java_quickstart/summary.md) 32 | * [多项目的 Java 构建](java_quickstart/multi-project_java_build.md) 33 | * [定义一个多项目构建](java_quickstart/defining_a_multi-project_build.md) 34 | * [通用配置](java_quickstart/common_configuration.md) 35 | * [项目之间的依赖](java_quickstart/dependencies_between_projects.md) 36 | * [创建一个发行版本](java_quickstart/creating_a_distribution.md) 37 | * [依赖管理的基础知识](dependency_management_basics/README.md) 38 | * [什么是依赖管理](dependency_management_basics/what_is_dependency_management.md) 39 | * [声明你的依赖](dependency_management_basics/a_basic_java_project.md) 40 | * [依赖配置](dependency_management_basics/dependency_configurations.md) 41 | * [外部的依赖](dependency_management_basics/external_dependencies.md) 42 | * [仓库](dependency_management_basics/repositories.md) 43 | * [发布 artifacts](dependency_management_basics/publishing_artifacts.md) 44 | * [下一步?](dependency_management_basics/where_to_next.md) 45 | * [Groovy 快速入门](groovy_quickstart/README.md) 46 | * [一个基本的 Groovy 项目](groovy_quickstart/a_basic_groovy_project.md) 47 | * [总结](groovy_quickstart/summary.md) 48 | * [网页应用快速入门](web_application_quickstart/README.md) 49 | * [构建一个 WAR 文件](web_application_quickstart/building_a_war_file.md) 50 | * [运行 Web 应用](web_application_quickstart/running_your_web_application.md) 51 | * [总结](web_application_quickstart/summary.md) 52 | * [使用 Gradle 命令行](using_the_gradle_command-line/README.md) 53 | * [多任务调用](using_the_gradle_command-line/executing_multiple_tasks.md) 54 | * [排除任务](using_the_gradle_command-line/excluding_tasks.md) 55 | * [失败后继续执行构建](using_the_gradle_command-line/continuing_the_build_when_a_failure_occurs.md) 56 | * [简化任务名](using_the_gradle_command-line/task_name_abbreviation.md) 57 | * [选择文件构建](using_the_gradle_command-line/selecting_which_build_to_execute.md) 58 | * [获取构建信息](using_the_gradle_command-line/listing_tasks.md) 59 | * [项目列表](using_the_gradle_command-line/listing_projects.md) 60 | * [任务列表](using_the_gradle_command-line/listing_taskss.md) 61 | * [获取任务具体信息](using_the_gradle_command-line/show_task_usage_details.md) 62 | * [获取依赖列表](using_the_gradle_command-line/listing_project_dependencies.md) 63 | * [查看特定依赖](using_the_gradle_command-line/getting_the_insight_into_a_particular_dependency.md) 64 | * [获取项目属性列表](using_the_gradle_command-line/listing_project_properties.md) 65 | * [构建日志](using_the_gradle_command-line/profiling_a_build.md) 66 | * [使用 Gradle 图形界面](using_the_gradle_graphical_user_interface/README.md) 67 | * [任务树](using_the_gradle_graphical_user_interface/task_tree.md) 68 | * [收藏夹](using_the_gradle_graphical_user_interface/favorities.md) 69 | * [命令行](using_the_gradle_graphical_user_interface/command_line.md) 70 | * [设置](using_the_gradle_graphical_user_interface/setup.md) 71 | * [编写构建脚本](writing_build_scripts/README.md) 72 | * [Gradle 构建语言](writing_build_scripts/the_gradle_build_language.md) 73 | * [项目 API](writing_build_scripts/the_project_api.md) 74 | * [标准项目属性](writing_build_scripts/standard_project_properties.md) 75 | * [脚本 API](writing_build_scripts/the_script_api.md) 76 | * [声明变量](writing_build_scripts/declaring_variables.md) 77 | * [局部变量](writing_build_scripts/local_variables.md) 78 | * [扩展属性](writing_build_scripts/extra_properties.md) 79 | * [Groovy 基础](writing_build_scripts/some_groovy_basics.md) 80 | * [Groovy JDK](writing_build_scripts/groovy_jdk.md) 81 | * [属性存取器](writing_build_scripts/property_accessors.md) 82 | * [可有可无的圆括号](writing_build_scripts/optional_parentheses_on_method_calls.md) 83 | * [List 和 Map 集合](writing_build_scripts/list_and_map_literals.md) 84 | * [闭合作为方法的最后一个参数](writing_build_scripts/closures_as_the_last_parameter_in_a_method.md) 85 | * [闭合委托对象](writing_build_scripts/closure_delegate.md) 86 | * [深入了解 Tasks](more_about_tasks/README.md) 87 | * [定义 tasks](more_about_tasks/defining_tasks.md) 88 | * [定位 tasks](more_about_tasks/locating_tasks.md) 89 | * [配置 tasks](more_about_tasks/configuring_tasks.md) 90 | * [给 task 加入依赖](more_about_tasks/adding_dependencies_to_a_task.md) 91 | * [给 tasks 排序](more_about_tasks/ordering_tasks.md) 92 | * [给 task 加入描述](more_about_tasks/adding_a_description_to_a_task.md) 93 | * [替换 tasks](more_about_tasks/replacing_tasks.md) 94 | * [跳过 tasks](more_about_tasks/skipping_tasks.md) 95 | * [跳过 up-to-date 的任务](more_about_tasks/skipping_tasks_that_are_up-to-date.md) 96 | * [Task 规则](more_about_tasks/task_rules.md) 97 | * [终止 tasks](more_about_tasks/finalizer_tasks.md) 98 | * [补充](more_about_tasks/extra.md) 99 | * [Gradle 属性 和 system 属性](more_about_tasks/gradle_properties_and_system_properties.md) 100 | * [使用其他的脚本配置项目](more_about_tasks/use_other_script_to_config_project.md) 101 | * [使用其他的脚本配置任意对象](more_about_tasks/use_other_script_to_config_any_object.md) 102 | * [配置任意对象](more_about_tasks/config_any_object.md) 103 | * [缓存](more_about_tasks/cache.md) 104 | * [文件操作](working_with_files/README.md) 105 | * [定位文件](working_with_files/locating_files.md) 106 | * [文件集合](working_with_files/file_collections.md) 107 | * [文件树](working_with_files/file_trees.md) 108 | * [使用一个归档文件的内容作为文件树](working_with_files/using_the_contents_of_an_archive_as_a_file_tree.md) 109 | * [指定一组输入文件](working_with_files/specifying_a_set_of_input_files.md) 110 | * [复制文件](working_with_files/copying_files.md) 111 | * [使用同步任务](working_with_files/using_the_sync_task.md) 112 | * [创建归档文件](working_with_files/creating_archives.md) 113 | * [使用 Ant 插件](using_ant_from_gradle/using_ant_from_gradle.md) 114 | * [使用 Ant 任务和 Ant 类型的构建](using_ant_from_gradle/using_ant_tasks_and_types_in_your_build.md) 115 | * [在构建中使用自定义 Ant 任务](using_ant_from_gradle/using_custom_ant_tasks_in_your_build.md) 116 | * [导入一个 Ant 构建](using_ant_from_gradle/importing_an_ant_build.md) 117 | * [Ant 的属性与引用](using_ant_from_gradle/ant_properties_and_references.md) 118 | * [API](using_ant_from_gradle/API.md) 119 | * [Logging](logging/logging.md) 120 | * [选择日志等级](logging/choosing_a_log_level.md) 121 | * [编写自己的日志信息](logging/writing_your_own_log_messages.md) 122 | * [外部工具和库的log](logging/logging_from_external_tools_and_libraries.md) 123 | * [改变 Gradle 记录的内容](logging/changing_what_gradle_logs.md) 124 | * [Gradle的守护进程](the_gradle_daemon/README.md) 125 | * [什么是Gradle的守护进程](the_gradle_daemon/what_is_the_gradle_daemon.md) 126 | * [管理和配置](the_gradle_daemon/management_and_configuration.md) 127 | * [如何启用的摇篮守护进程](the_gradle_daemon/how_do_i_enable_the_gradle_daemon.md) 128 | * [如何禁用Gradle的守护进程](the_gradle_daemon/how_do_i_disable_the_gradle_daemon.md) 129 | * [怎样抑制“please consider using the Gradle Daemon”消息](the_gradle_daemon/how_do_i_suppress_the_please_consider_using_the_gradle_daemon_message.md) 130 | * [为什么会在机器上出现不只一个守护进程](the_gradle_daemon/why_is_there_more_than_one_daemon_process_on_my_machine.md) 131 | * [守护进程占用多大内存并且能不能给它更大的内存?](the_gradle_daemon/how_much_memory_does_the_daemon_use_and_can_i_give_it_more.md) 132 | * [如何停止守护进程](the_gradle_daemon/how_can_i_stop_a_daemon.md) 133 | * [守护进程何时会出错](the_gradle_daemon/what_can_go_wrong_with_daemon.md) 134 | * [什么时候使用Gradle守护进程](the_gradle_daemon/when_should_i_not_use_the_gradle_daemon.md) 135 | * [工具和集成开发环境](the_gradle_daemon/tools_&_ides.md) 136 | * [摇篮守护进程如何使构建速度更快](the_gradle_daemon/how_does_the_gradle_daemon_make_builds_faster.md) 137 | * [未来可能的改进](the_gradle_daemon/potential_future_enhancements.md) 138 | * [Gradle Plugins](gradle_plugins/README.md) 139 | * [插件的作用](gradle_plugins/what_plugins_do.md) 140 | * [插件的类型](gradle_plugins/types_of_plugins.md) 141 | * [应用插件](gradle_plugins/applying_plugins.md) 142 | * [脚本插件](gradle_plugins/script_plugins.md) 143 | * [二进制插件](gradle_plugins/binary_plugins.md) 144 | * [二进制插件的位置](gradle_plugins/locations_of_binary_plugins.md) 145 | * [使用构建脚本块应用插件](gradle_plugins/applying_plugins_with_the_buildscript_block.md) 146 | * [使用插件的插件DSL](gradle_plugins/applying_plugins_with_the_plugins_dsl.md) 147 | * [插件DSL的限制](gradle_plugins/limitations_of_the_plugins_dsl.md) 148 | * [约束语法](gradle_plugins/constrained_syntax.md) 149 | * [只能在构建脚本中使用](gradle_plugins/can_only_be_used_in_build_scripts.md) 150 | * [不能与subjects{},allprojects{}等结合使用](gradle_plugins/cannot_be_used_in_conjunction.md) 151 | * [查找社区插件](gradle_plugins/finding_community_plugins.md) 152 | * [更多关于插件](gradle_plugins/more_on_plugins.md) 153 | * [Gradle插件规范](standard_gradle_plugins/README.md) 154 | * [语言插件](standard_gradle_plugins/language_plugins.md) 155 | * [孵化中的语言插件](standard_gradle_plugins/incubating_language_plugins.md) 156 | * [集成插件](standard_gradle_plugins/integration_plugins.md) 157 | * [孵化中的集成插件](standard_gradle_plugins/incubating_integration_plugins.md) 158 | * [软件开发插件](standard_gradle_plugins/software_development_plugins.md) 159 | * [孵化中的软件开发插件](standard_gradle_plugins/incubating_software_development_plugins.md) 160 | * [基础插件](standard_gradle_plugins/base_plugins.md) 161 | * [第三方插件](standard_gradle_plugins/third_party_plugins.md) 162 | * [Java 插件](the_java_plugin/README.md) 163 | * [使用](the_java_plugin/java_plugin_usage.md) 164 | * [资源集](the_java_plugin/java_plugin_source_sets.md) 165 | * [任务](the_java_plugin/java_plugin_tasks.md) 166 | * [项目布局](the_java_plugin/java_plugin_project_layout.md) 167 | * [依赖管理](the_java_plugin/java_plugin_dependency_management.md) 168 | * [公共配置](the_java_plugin/java_plugin_convention_properties.md) 169 | * [使用资源集工作](the_java_plugin/java_plugin_working_with_source_sets.md) 170 | * [资源集属性](the_java_plugin/java_plugin_source_set_properties.md) 171 | * [定义新的资源集](the_java_plugin/java_plugin_defining_new_source_sets.md) 172 | * [资源集例子](the_java_plugin/java_plugins_some_source_set_examples.md) 173 | * [Javadoc](the_java_plugin/java_plugin_javadoc.md) 174 | * [清除](the_java_plugin/java_plugin_clean.md) 175 | * [资源](the_java_plugin/java_plugin_resources.md) 176 | * [编译 Java](the_java_plugin/java_plugin_compile_java.md) 177 | * [增量 Java 编译](the_java_plugin/java_plugin_incremental_java_compilation.md) 178 | * [测试](the_java_plugin/java_plugin_test.md) 179 | * [测试执行](the_java_plugin/test_execution.md) 180 | * [测试调试](the_java_plugin/test_debugging.md) 181 | * [测试过滤](the_java_plugin/test_filtering.md) 182 | * [通过系统属性执行单独测试](the_java_plugin/test_single_test_execution_via_system_properties.md) 183 | * [测试检测](the_java_plugin/test_detection.md) 184 | * [测试分组](the_java_plugin/test_grouping.md) 185 | * [测试报告](the_java_plugin/test_reporting.md) 186 | * [TestNG 的参数化方法和报告](the_java_plugin/test_testNG_parameterized_methods_and_reporting.md) 187 | * [公共值](the_java_plugin/test_convention_values.md) 188 | * [Jar](the_java_plugin/java_plugin_jar.md) 189 | * [Manifest](the_java_plugin/java_plugin_manifest.md) 190 | * [上传](the_java_plugin/java_plugin_uploading.md) 191 | * [War插件](the_war_plugin/the_war_plugin.md) 192 | * [使用](the_war_plugin/usage.md) 193 | * [任务](the_war_plugin/tasks.md) 194 | * [项目布局](the_war_plugin/project_layout.md) 195 | * [依赖管理](the_war_plugin/dependency_management.md) 196 | * [公共配置](the_war_plugin/convention_properties.md) 197 | * [War](the_war_plugin/war.md) 198 | * [定制War](the_war_plugin/customizing.md) 199 | * [Ear插件](earcha-jian.md) 200 | 201 | -------------------------------------------------------------------------------- /about_this_user_guide.md: -------------------------------------------------------------------------------- 1 | # 关于这本指南 2 | 3 | 这本用户指南还并不完善, 4 | 就像 Gradle 一样还在开发当中. 5 | 6 | 在这本指南中, 7 | Gradle 的一些功能并没有被完整的展示出来. 8 | 一些内容的解释也并不是十分的清楚, 9 | 或者假设关于 Gradle 你知道得更多. 10 | 我们需要你的帮助来完善这本指南. 11 | 在 Gradle 网站上你可以找到更多关于完善这本指南的信息. 12 | 13 | 通过这本指南, 14 | 你将会看到一些代表 Gradle 任务之间依赖关系的图表. 15 | 类似于 UML 依赖关系的表示方法, 16 | 从一个任务 A 指向另一个任务 B 的箭头代表A依赖于B. 17 | -------------------------------------------------------------------------------- /book.json: -------------------------------------------------------------------------------- 1 | { 2 | "plugins": ["disqus"], 3 | "pluginsConfig": { 4 | "disqus": { 5 | "shortName": "gradleuserguide" 6 | } 7 | } 8 | } -------------------------------------------------------------------------------- /build_script_basics/README.md: -------------------------------------------------------------------------------- 1 | # 构建脚本的基础知识 2 | 3 | 这一章主要讲解以下内容 4 | 5 | * Projects 和 tasks 6 | * Hello world 7 | * 快捷的任务定义 8 | * 构建脚本代码 9 | * 任务依赖 10 | * 动态任务 11 | * 使用已经存在的任务 12 | * 快捷注释 13 | * 附加的 task 属性 14 | * 使用 Ant 任务 15 | * 使用方法 16 | * 默认的任务 17 | * 通过 DAG 配置 18 | 19 | 20 | 21 | -------------------------------------------------------------------------------- /build_script_basics/a_shortcut_task_definition.md: -------------------------------------------------------------------------------- 1 | # 快捷的任务定义 2 | 3 | 有一种比我们之前定义的 hello 任务更简明的方法 4 | 5 | **例子 6.3. 快捷的任务定义** 6 | 7 | *build.gradle* 8 | 9 | task hello << { 10 | println 'Hello world!' 11 | } 12 | 13 | 它定义了一个叫做 hello 的任务, 14 | 这个任务是一个可以执行的闭包. 15 | 我们将使用这种方式来定义这本指南里所有的任务. 16 | 17 | **翻译者补充** 18 | 19 | 与前面的例子比较, 20 | doLast 被替换成了 <<. 21 | 它们有一样的功能, 22 | 但看上去更加简洁了, 23 | 会在后续章节 (6.7) 详细讲解它们的功能. 24 | -------------------------------------------------------------------------------- /build_script_basics/build_scripts_are_code.md: -------------------------------------------------------------------------------- 1 | # 构建脚本代码 2 | 3 | Gradle 的构建脚本展示了 Groovy 的所有能力. 作为开胃菜, 来看看这个: 4 | 5 | **例子 6.4. 在 Gradle 任务里使用 Groovy** 6 | 7 | *build.gradle* 8 | 9 | task upper << { 10 | String someString = 'mY_nAmE' 11 | println "Original: " + someString 12 | println "Upper case: " + someString.toUpperCase() 13 | } 14 | 15 | **gradle -q upper** 命令的输出 16 | 17 | > gradle -q upper 18 | Original: mY_nAmE 19 | Upper case: MY_NAME 20 | 21 | 或者 22 | 23 | **例子 6.5. 在 Gradle 任务里使用 Groovy** 24 | 25 | *build.gradle* 26 | 27 | task count << { 28 | 4.times { print "$it " } 29 | } 30 | 31 | **gradle -q count** 命令的输出 32 | 33 | > gradle -q count 34 | 0 1 2 3 35 | -------------------------------------------------------------------------------- /build_script_basics/configure_by_dag.md: -------------------------------------------------------------------------------- 1 | # 通过 DAG 配置 2 | 3 | 正如我们之后的详细描述 (参见第55章，构建的生命周期), Gradle 有一个配置阶段和执行阶段. 4 | 在配置阶段后, 5 | Gradle 将会知道应执行的所有任务. 6 | Gradle 为你提供一个"钩子", 7 | 以便利用这些信息. 8 | 举个例子, 9 | 判断发布的任务是否在要被执行的任务当中. 10 | 根据这一点, 11 | 你可以给一些变量指定不同的值. 12 | 13 | 在接下来的例子中, 14 | distribution 任务和 release 任务将根据变量的版本产生不同的值. 15 | 16 | **例子 6.16. 根据选择的任务产生不同的输出** 17 | 18 | *build.gradle* 19 | 20 | task distribution << { 21 | println "We build the zip with version=$version" 22 | } 23 | 24 | task release(dependsOn: 'distribution') << { 25 | println 'We release now' 26 | } 27 | 28 | gradle.taskGraph.whenReady {taskGraph -> 29 | if (taskGraph.hasTask(release)) { 30 | version = '1.0' 31 | } else { 32 | version = '1.0-SNAPSHOT' 33 | } 34 | } 35 | 36 | **gradle -q distribution** 命令的输出 37 | 38 | > gradle -q distribution 39 | We build the zip with version=1.0-SNAPSHOT 40 | Output of gradle -q release 41 | > gradle -q release 42 | We build the zip with version=1.0 43 | We release now 44 | 45 | 最重要的是 whenReady 在 release 任务执行之前就已经影响了 release 任务. 46 | 甚至 release 任务不是首要任务 (i.e., 首要任务是指通过 gradle 命令的任务). 47 | 48 | 49 | -------------------------------------------------------------------------------- /build_script_basics/default_tasks.md: -------------------------------------------------------------------------------- 1 | # 默认任务 2 | 3 | Gradle 允许在脚本中定义一个或多个默认任务. 4 | 5 | **例子 6.15. 定义默认任务** 6 | 7 | *build.gradle* 8 | 9 | defaultTasks 'clean', 'run' 10 | 11 | task clean << { 12 | println 'Default Cleaning!' 13 | } 14 | 15 | task run << { 16 | println 'Default Running!' 17 | } 18 | 19 | task other << { 20 | println "I'm not a default task!" 21 | } 22 | 23 | **gradle -q** 命令的输出 24 | 25 | > gradle -q 26 | Default Cleaning! 27 | Default Running! 28 | 29 | 等价于 **gradle -q clean run**. 30 | 在一个多项目构建中, 每一个子项目都可以有它特别的默认任务. 如果一个子项目没有特别的默认任务, 父项目的默认任务将会被执行. 31 | 32 | 33 | -------------------------------------------------------------------------------- /build_script_basics/dynamic_tasks.md: -------------------------------------------------------------------------------- 1 | # 动态任务 2 | 3 | Groovy 不仅仅被用来定义一个任务可以做什么. 4 | 举个例子, 5 | 你可以使用它来动态的创建任务. 6 | 7 | **例子 6.8. 动态的创建一个任务** 8 | 9 | *build.gradle* 10 | 11 | 4.times { counter -> 12 | task "task$counter" << { 13 | println "I'm task number $counter" 14 | } 15 | } 16 | 17 | 这里动态的创建了 task0, task1, task2, task3 18 | 19 | **gradle -q task1** 命令的输出 20 | 21 | > gradle -q task1 22 | I'm task number 1 23 | -------------------------------------------------------------------------------- /build_script_basics/extra_task_properties.md: -------------------------------------------------------------------------------- 1 | # 自定义任务属性 2 | 3 | 你可以给任务加入自定义的属性. 4 | 列如加入一个叫做 myProperty 属性, 5 | 设置一个初始值给 ext.myProperty. 6 | 然后, 7 | 该属性就可以像一个预定义的任务属性那样被读取和设置了. 8 | 9 | **例子 6.12. 给任务加入自定义属性** 10 | 11 | *build.gradle* 12 | 13 | task myTask { 14 | ext.myProperty = "myValue" 15 | } 16 | 17 | task printTaskProperties << { 18 | println myTask.myProperty 19 | } 20 | 21 | **gradle -q printTaskProperties** 命令的输出 22 | 23 | > gradle -q printTaskProperties 24 | myValue 25 | 26 | 给任务加自定义属性是没有限制的. 你可以在 13.4.2, “自定义属性” 里获得更多的信息. 27 | 28 | -------------------------------------------------------------------------------- /build_script_basics/hello_world.md: -------------------------------------------------------------------------------- 1 | # Hello world 2 | 3 | 你可以通过 **gradle** 命令运行一个 Gradle 构建. 4 | 5 | **gradle** 命令会在当前目录中查找一个叫 **build.gradle** 的文件. 6 | 我们称这个 build.gradle 文件为一个构建脚本 (build script), 但是严格来说它是一个构建配置脚本 (build configuration script). 这个脚本定义了一个 project 和它的 tasks. 7 | 8 | 让我们来先看一个例子, 9 | 创建一个名为build.gradle的构建脚本. 10 | 11 | **例子 6.1 第一个构建脚本** 12 | 13 | *build.gradle* 14 | 15 | task hello { 16 | doLast { 17 | println 'Hello world!' 18 | } 19 | } 20 | 21 | 在命令行里, 进入脚本所在的文件夹然后输入 **gradle -q hello** 来执行构建脚本: 22 | 23 | **gradle -q hello** 的输出 24 | > gradle -q hello 25 | Hello world! 26 | 27 | 这里发生了什么? 这个构建脚本定义了一个独立的 task, 28 | 叫做 hello, 29 | 并且加入了一个 action. 30 | 当你运行 **gradle hello**, 31 | Gradle 执行叫做 hello 的 task, 32 | 也就是执行了你所提供的 action. 33 | 这个 action 是一个包含了一些 Groovy 代码的闭包(closure 这个概念不清楚的同学好好谷歌下). 34 | 35 | 如果你认为这些看上去和 Ant 的 targets 很相像, 36 | 好吧, 37 | 你是对的. 38 | Gradle tasks 和 Ant 的 targets 是对等的. 39 | 但是你将会会看到, 40 | Gradle tasks 更加强大. 41 | 我们使用一个不同于 Ant 的术语 task, 42 | 看上去比 target 更加能直白. 43 | 不幸的是这带来了一个术语冲突, 44 | 因为 Ant 称它的命令, 45 | 比如 javac 或者 copy, 46 | 叫 tasks. 47 | 所以当我们谈论 tasks, 48 | 是指 Gradle 的 tasks. 49 | 如果我们讨论 Ant 的 tasks (Ant 命令), 我们会直接称呼 ant task. 50 | 51 | ####补充一点命令里的 **-q** 是干什么的? 52 | 53 | 这个指南里绝大多说的例子会在命令里加入 **-q**. 54 | 代表 quiet 模式. 55 | 它不会生成 Gradle 的日志信息 (log messages), 56 | 所以用户只能看到 tasks 的输出. 57 | 它使得的输出更加清晰. 58 | 你并不一定需要加入这个选项. 59 | 参考第 18 章, 60 | 日志的 Gradle 影响输出的详细信息. 61 | 62 | 63 | 64 | -------------------------------------------------------------------------------- /build_script_basics/manipulating_existing_tasks.md: -------------------------------------------------------------------------------- 1 | # 使用已经存在的任务 2 | 3 | 当任务创建之后, 4 | 它可以通过API来访问. 5 | 这个和 Ant 不一样. 6 | 举个例子, 7 | 你可以创建额外的依赖. 8 | 9 | **例子 6.9. 通过API访问一个任务 - 加入一个依赖** 10 | 11 | *build.gradle* 12 | 13 | 4.times { counter -> 14 | task "task$counter" << { 15 | println "I'm task number $counter" 16 | } 17 | } 18 | task0.dependsOn task2, task3 19 | 20 | **gradle -q task0** 命令的输出 21 | 22 | > gradle -q task0 23 | I'm task number 2 24 | I'm task number 3 25 | I'm task number 0 26 | 27 | 或者你可以给一个已经存在的任务加入行为. 28 | 29 | **例子 6.10. 通过API访问一个任务 - 加入行为** 30 | 31 | 32 | *build.gradle* 33 | 34 | task hello << { 35 | println 'Hello Earth' 36 | } 37 | hello.doFirst { 38 | println 'Hello Venus' 39 | } 40 | hello.doLast { 41 | println 'Hello Mars' 42 | } 43 | hello << { 44 | println 'Hello Jupiter' 45 | } 46 | 47 | **gradle -q hello** 命令的输出 48 | 49 | > gradle -q hello 50 | Hello Venus 51 | Hello Earth 52 | Hello Mars 53 | Hello Jupiter 54 | 55 | doFirst 和 doLast 可以被执行许多次. 他们分别可以在任务动作列表的开始和结束加入动作. 56 | 当任务执行的时候, 57 | 在动作列表里的动作将被按顺序执行. 58 | 这里第四个行为中 << 操作符是 doLast 的简单别称. 59 | 60 | -------------------------------------------------------------------------------- /build_script_basics/projects_and_tasks.md: -------------------------------------------------------------------------------- 1 | # Projects 和 tasks 2 | 3 | Gradle 里的任何东西都是基于这两个基础概念: 4 | 5 | * projects ( 项目 ) 6 | * tasks ( 任务 ) 7 | 8 | 每一个构建都是由一个或多个 projects 构成的. 9 | 一个 project 到底代表什么取决于你想用 Gradle 做什么. 举个例子, 10 | 一个 project 可以代表一个 JAR 或者一个网页应用. 它也可能代表一个发布的 ZIP 压缩包, 11 | 这个 ZIP 可能是由许多其他项目的 JARs 构成的. 12 | 但是一个 project 不一定非要代表被构建的某个东西. 它可以代表一件**要做的事, 13 | 比如部署你的应用. 14 | 15 | 不要担心现在看不懂这些说明. 16 | Gradle 的合约构建可以让你来具体定义一个 project 到底该做什么. 17 | 18 | 每一个 project 是由一个或多个 tasks 构成的. 19 | 一个 task 代表一些更加细化的构建. 20 | 可能是编译一些 classes, 21 | 创建一个 JAR, 22 | 生成 javadoc, 23 | 或者生成某个目录的压缩文件. 24 | 25 | 目前, 26 | 我们先来看看定义构建里的一些简单的 task. 以后的章节会讲解多项目构建以及如何通过 projects 和 tasks 工作. 27 | -------------------------------------------------------------------------------- /build_script_basics/shortcut_notations.md: -------------------------------------------------------------------------------- 1 | # 短标记法 2 | 3 | 正如同你已经在之前的示例里看到, 4 | 有一个短标记 $ 可以访问一个存在的任务. 也就是说每个任务都可以作为构建脚本的属性: 5 | 6 | **例子 6.11. 当成构建脚本的属性来访问一个任务** 7 | 8 | *build.gradle* 9 | 10 | task hello << { 11 | println 'Hello world!' 12 | } 13 | hello.doLast { 14 | println "Greetings from the $hello.name task." 15 | } 16 | 17 | **gradle -q hello** 命令的输出 18 | 19 | > gradle -q hello 20 | Hello world! 21 | Greetings from the hello task. 22 | 23 | 这里的 name 是任务的默认属性, 24 | 代表当前任务的名称, 25 | 这里是 hello. 26 | 27 | 这使得代码易于读取， 28 | 特别是当使用了由插件（如编译）提供的任务时尤其如此. 29 | 30 | -------------------------------------------------------------------------------- /build_script_basics/task_dependencies.md: -------------------------------------------------------------------------------- 1 | # 任务依赖 2 | 3 | 就像你所猜想的那样, 4 | 你可以声明任务之间的依赖关系. 5 | 6 | **例子 6.6. 申明任务之间的依赖关系** 7 | 8 | *build.gradle* 9 | 10 | task hello << { 11 | println 'Hello world!' 12 | } 13 | 14 | task intro(dependsOn: hello) << { 15 | println "I'm Gradle" 16 | } 17 | 18 | **gradle -q intro** 命令的输出 19 | 20 | > gradle -q intro 21 | Hello world! 22 | I'm Gradle 23 | 24 | intro 依赖于 hello, 25 | 所以执行 intro 的时候 hello 命令会被优先执行来作为启动 intro 任务的条件. 26 | 27 | 在加入一个依赖之前, 28 | 这个依赖的任务不需要提前定义, 29 | 来看下面的例子. 30 | 31 | **例子 6.7. Lazy dependsOn - 其他的任务还没有存在** 32 | 33 | *build.gradle* 34 | 35 | task taskX(dependsOn: 'taskY') << { 36 | println 'taskX' 37 | } 38 | task taskY << { 39 | println 'taskY' 40 | } 41 | 42 | **gradle -q taskX** 命令的输出 43 | 44 | > gradle -q taskX 45 | taskY 46 | taskX 47 | 48 | taskX 到 taskY 的依赖在 taskY 被定义之前就已经声明了. 这一点对于我们之后讲到的多任务构建是非常重要的. 49 | 任务依赖将会在 14.4 具体讨论. 50 | 51 | 请注意你不能使用快捷注释 (参考 6.8, “快捷注释”) 当所关联的任务还没有被定义. 52 | 53 | -------------------------------------------------------------------------------- /build_script_basics/using_ant_tasks.md: -------------------------------------------------------------------------------- 1 | # 调用 Ant 任务 2 | 3 | Ant 任务是 Gradle 的一等公民. 4 | Gradle 通过 Groovy 出色的集成了 Ant 任务. 5 | Groovy 自带了一个 AntBuilder. 6 | 相比于从一个 build.xml 文件中使用 Ant 任务, 7 | 在 Gradle 里使用 Ant 任务更为方便和强大. 从下面的例子中, 8 | 你可以学习如何执行 Ant 任务以及如何访问 ant 属性： 9 | 10 | **例子 6.13. 使用 AntBuilder 来执行 ant.loadfile 任务** 11 | 12 | *build.gradle* 13 | 14 | task loadfile << { 15 | def files = file('../antLoadfileResources').listFiles().sort() 16 | files.each { File file -> 17 | if (file.isFile()) { 18 | ant.loadfile(srcFile: file, property: file.name) 19 | println " *** $file.name ***" 20 | println "${ant.properties[file.name]}" 21 | } 22 | } 23 | } 24 | 25 | **gradle -q loadfile** 命令的输出 26 | 27 | > gradle -q loadfile 28 | *** agile.manifesto.txt *** 29 | Individuals and interactions over processes and tools 30 | Working software over comprehensive documentation 31 | Customer collaboration over contract negotiation 32 | Responding to change over following a plan 33 | *** gradle.manifesto.txt *** 34 | 35 | -------------------------------------------------------------------------------- /build_script_basics/using_methods.md: -------------------------------------------------------------------------------- 1 | # 使用方法 2 | 3 | Gradle 能很好地衡量你编写脚本的逻辑能力. 首先要做的是如何提取一个方法. 4 | 5 | **例子 6.14. 使用方法组织脚本逻辑** 6 | 7 | *build.gradle* 8 | 9 | task checksum << { 10 | fileList('../antLoadfileResources').each {File file -> 11 | ant.checksum(file: file, property: "cs_$file.name") 12 | println "$file.name Checksum: ${ant.properties["cs_$file.name"]}" 13 | } 14 | } 15 | 16 | task loadfile << { 17 | fileList('../antLoadfileResources').each {File file -> 18 | ant.loadfile(srcFile: file, property: file.name) 19 | println "I'm fond of $file.name" 20 | } 21 | } 22 | 23 | File[] fileList(String dir) { 24 | file(dir).listFiles({file -> file.isFile() } as FileFilter).sort() 25 | } 26 | 27 | **adle -q loadfile** 命令的输出 28 | 29 | > gradle -q loadfile 30 | I'm fond of agile.manifesto.txt 31 | I'm fond of gradle.manifesto.txt 32 | 33 | 34 | 稍后你看到, 35 | 这种方法可以在多项目构建的子项目之间共享. 如果你的构建逻辑变得更加复杂, 36 | Gradle 为你提供了其他非常方便的方法. 请参见第59章，组织构建逻辑。 37 | 38 | -------------------------------------------------------------------------------- /cover.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DONGChuan/GradleUserGuide/e0b911cef94295e1dcb07f5e9a1a7242b3e3cdff/cover.jpg -------------------------------------------------------------------------------- /cover_small.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DONGChuan/GradleUserGuide/e0b911cef94295e1dcb07f5e9a1a7242b3e3cdff/cover_small.jpg -------------------------------------------------------------------------------- /dependency_management_basics/README.md: -------------------------------------------------------------------------------- 1 | # 依赖管理的基础知识 2 | 3 | * 什么是依赖管理 4 | 5 | * 声明你的依赖 6 | 7 | * 依赖配置 8 | 9 | * 外部的依赖 10 | 11 | * 仓库 12 | 13 | * 发布 artifacts 14 | 15 | -------------------------------------------------------------------------------- /dependency_management_basics/a_basic_java_project.md: -------------------------------------------------------------------------------- 1 | # 声明你的依赖 2 | 3 | 让我们看一下一些依赖的声明. 下面是一个基础的构建脚本: 4 | 5 | **例子 8.1. 声明依赖** 6 | 7 | **build.gradle** 8 | 9 | apply plugin: 'java' 10 | 11 | repositories { 12 | mavenCentral() 13 | } 14 | 15 | dependencies { 16 | compile group: 'org.hibernate', name: 'hibernate-core', version: '3.6.7.Final' 17 | testCompile group: 'junit', name: 'junit', version: '4.+' 18 | } 19 | 20 | 这里发生了什么? 这个构建脚本声明 Hibernate core 3.6.7.最终 被用来编译项目的源代码. 言外之意是, 在运行阶段同样也需要 Hibernate core 和它的依赖. 构建脚本同样声明了需要 junit >= 4.0 的版本来编译项目测试. 它告诉 Gradle 到 Maven 中央仓库里找任何需要的依赖. 接下来的部分会具体说明. 21 | 22 | 23 | -------------------------------------------------------------------------------- /dependency_management_basics/dependency_configurations.md: -------------------------------------------------------------------------------- 1 | # 依赖配置 2 | 3 | 在 Gradle 里, 依赖可以组合成*configurations(配置)*. 一个配置简单地说就是一系列的依赖. 我们称它们为*(dependency configuration)依赖配置*. 你可以使用它们声明项目的外部依赖. 正如我们将在后面看到, 它们也被用来声明项目的发布. 4 | 5 | Java 插件定义了许多标准的配置. 下面列出了一些, 你也可以在[Table 23.5, “Java 插件 - 依赖管理”](https://dongchuan.gitbooks.io/gradle-user-guide-/content/the_java_plugin/java_plugin_dependency_management.html)里发现更多具体的信息. 6 | 7 | **compile** 8 | 9 | 用来编译项目源代码的依赖. 10 | 11 | **runtime** 12 | 13 | 在运行时被生成的类使用的依赖. 默认的, 也包含了编译时的依赖. 14 | 15 | **testCompile** 16 | 17 | 编译测试代码的依赖. 默认的, 包含生成的类运行所需的依赖和编译源代码的依赖. 18 | 19 | **testRuntime** 20 | 21 | 运行测试所需要的依赖. 默认的, 包含上面三个依赖. 22 | 23 | 各种各样的插件加入许多标准的配置. 你也可以定义你自己的配置. 参考 [Section 52.3, “配置依赖”](https://docs.gradle.org/current/userguide/dependency_management.html#sub:configurations)可以找到更加具体的定义和定制一个自己的依赖配置. 24 | 25 | -------------------------------------------------------------------------------- /dependency_management_basics/external_dependencies.md: -------------------------------------------------------------------------------- 1 | # 外部的依赖 2 | 3 | 你可以声明许多种依赖. 其中一种是*external dependency(外部依赖)*. 这是一种在当前构建之外的一种依赖, 它被存放在远程或本地的仓库里, 比如 Maven 的库, 或者 Ivy 库, 甚至是一个本地的目录. 4 | 5 | 下面的例子讲展示如何加入外部依赖 6 | 7 | *例子 8.2. 定义一个外部依赖* 8 | 9 | *build.gradle* 10 | 11 | dependencies { 12 | compile group: 'org.hibernate', name: 'hibernate-core', version: '3.6.7.Final' 13 | } 14 | 15 | 引用一个外部依赖需要使用 group, name 和 version 属性. 根据你想要使用的库, group 和 version 可能会有所差别. 16 | 17 | 有一种简写形式, 只使用一串字符串 `"group:name:version"`. 18 | 19 | *例子 8.3. 外部依赖的简写形式* 20 | 21 | *build.gradle* 22 | 23 | dependencies { 24 | compile 'org.hibernate:hibernate-core:3.6.7.Final' 25 | } 26 | 27 | 28 | 要了解跟多关于定义并使用依赖工作的信息,参见[Section 52.4,"How to declare you dependencies"](https://docs.gradle.org/current/userguide/dependency_management.html#sec:how_to_declare_your_dependencies). 29 | 30 | -------------------------------------------------------------------------------- /dependency_management_basics/publishing_artifacts.md: -------------------------------------------------------------------------------- 1 | # 发布 artifacts 2 | 依赖配置也可以用来发布文件[3]. 我们称这些文件`publication artifacts`, 或者就叫 *artifacts*. 3 | 4 | 插件可以很好的定义一个项目的 artifacts, 所以你并不需要做一些特别的工作来让 Gradle 需要发布什么. 你可以通过在 uploadArchives 任务里加入仓库来完成. 下面是一个发布远程 Ivy 库的例子: 5 | 6 | **例子 8.8. 发布一个 Ivy 库** 7 | 8 | **build.gradle** 9 | 10 | uploadArchives { 11 | repositories { 12 | ivy { 13 | credentials { 14 | username "username" 15 | password "pw" 16 | } 17 | url "http://repo.mycompany.com" 18 | } 19 | } 20 | } 21 | 22 | 现在, 当你运 `gradle uploadArchives`, Gradle 将构建和上传你的 Jar. Gradle 也会生成和上传 ivy.xml . 23 | 24 | 你也可以发布到 Maven 库.语法是稍有不同[4]. 请注意你需要加入 Maven 插件来发布一个 Maven 库. 在下面的例子里, Gradle 将生成和上传 pom.xml. 25 | 26 | *例子 8.9. 发布 Maven 库* 27 | 28 | *build.gradle* 29 | 30 | apply plugin: 'maven' 31 | 32 | uploadArchives { 33 | repositories { 34 | mavenDeployer { 35 | repository(url: "file://localhost/tmp/myRepo/") 36 | } 37 | } 38 | } 39 | 40 | 在[Chapter 53, Publishing artifacts](https://docs.gradle.org/current/userguide/artifact_management.html), 发布 artifacts 里有更加具体的介绍. 41 | 42 | > [3] 我们认为这令人困惑,我们正在在Gradle DSL中逐步的区别这两个概念. 43 | 44 | > [4] 我们正在努力解决从Maven仓库发布,获取的语法一致性. 45 | 46 | -------------------------------------------------------------------------------- /dependency_management_basics/repositories.md: -------------------------------------------------------------------------------- 1 | # 仓库 2 | 3 | Gradle 是怎样找到那些外部依赖的文件的呢? Gradle 会在一个*repository(仓库)*里找这些文件. 仓库其实就是文件的集合, 通过 `group`, `name` 和 `version` 整理分类. Gradle 能解析好几种不同的仓库形式, 比如 Maven 和 Ivy, 同时可以理解各种进入仓库的方法, 比如使用本地文件系统或者 HTTP. 4 | 5 | 默认地, Gradle 不提前定义任何仓库. 在使用外部依赖之前, 你需要自己至少定义一个库. 比如使用下面例子中的 Maven central 仓库: 6 | 7 | *例子 8.4. Maven central 仓库* 8 | 9 | *build.gradle* 10 | 11 | repositories { 12 | mavenCentral() 13 | } 14 | 15 | 或者使用一个远程的 Maven 仓库: 16 | 17 | *例子 8.5. 使用远程的 Maven 仓库* 18 | 19 | *build.gradle* 20 | 21 | repositories { 22 | maven { 23 | url "http://repo.mycompany.com/maven2" 24 | } 25 | } 26 | 27 | 或者一个远程的 Ivy 仓库: 28 | 29 | *例子 8.6. 使用远程的 Ivy 仓库* 30 | 31 | *build.gradle* 32 | 33 | repositories { 34 | ivy { 35 | url "http://repo.mycompany.com/repo" 36 | } 37 | } 38 | 39 | 你也可以使用本地的文件系统里的库. Maven 和 Ivy 都支持下载的本地. 40 | 41 | *例子 8.7. 使用本地的 Ivy 目录* 42 | 43 | build.gradle 44 | 45 | repositories { 46 | ivy { 47 | // URL can refer to a local directory 48 | url "../local-repo" 49 | } 50 | } 51 | 52 | 一个项目可以有好几个库. Gradle 会根据依赖定义的顺序在各个库里寻找它们, 在第一个库里找到了就不会再在第二个库里找它了. 53 | 54 | 可以在[Section 50.6 章, “仓库”](https://docs.gradle.org/current/userguide/dependency_management.html#sec:repositories)里找到更详细的信息. 55 | 56 | 57 | -------------------------------------------------------------------------------- /dependency_management_basics/what_is_dependency_management.md: -------------------------------------------------------------------------------- 1 | # 什么是依赖管理? 2 | 3 | 粗略的讲, 依赖管理由两部分组成. 首先, Gradle 需要了解你的项目需要构建或运行的东西, 以便找到它们. 我们称这些传入的文件为项目的 *dependencies(依赖项)*. 其次, Gradle 需要构建并上传你的项目产生的东西. 我们称这些传出的项目文件为 *publications(发布项)*. 让我们来看看这两条的详细信息： 4 | 5 | 大多数项目都不是完全独立的. 它们需要其它项目进行编译或测试等等. 举个例子, 为了在项目中使用 Hibernate, 在编译的时候需要在 `classpath` 中添加一些 Hibernate 的 jar 路径. 要运行测试的时候, 需要在 `test classpath` 中包含一些额外的 jar, 比如特定的 JDBC 驱动或者 `Ehcache jars`. 6 | 7 | 这些传入的文件构成上述项目的依赖. Gradle 允许你告诉它项目的依赖关系, 以便找到这些依赖关系, 并在你的构建中维护它们. 依赖关系可能需要从远程的 Maven 或者 Ivy 仓库中下载, 也可能是在本地文件系统中, 或者是通过多项目构建另一个构建. 我们称这个过程为 *dependency resolution(依赖解析)*. 8 | 9 | 这一特性与 Ant 相比效率提高了许多. 使用 Ant, 你只有指定 jar 的绝对路径或相对路径才能读取 jar. 使用 Gradle, 你只需要申明依赖的名称, 然后它会通过其它的设置来决定在哪里获取这些依赖关系, 比如从 Maven 库. 你可以为 Ant 添加 Apache Ivy 库或得类似的方法, 但是 Gradle 做的更好. 10 | 11 | 通常, 一个项目本身会具有依赖性. 举个例子, 运行 Hibernate 的核心需要其他几个类库在 classpath 中. 因此, Gradle 在为你的项目运行测试的时候, 它会找到这些依赖关系, 并使其可用. 我们称之为*transitive dependencies(依赖传递)*. 12 | 13 | 大部分项目的主要目的是要建立一些文件, 在项目之外使用. 比如, 你的项目产生一个 Java 库,你需要构建一个jar, 可能是一个 jar 和一些文档, 并将它们发布在某处. 14 | 15 | 这些传出的文件构成了项目的发布. Gradle 当然会为你负责这个重要的工作. 你声明项目的发布, Gradle 会构建并发布在某处. 究竟什么是"发布"取决于你想做什么. 可能你希望将文件复制到本地目录, 或者将它们上传到一个远程 Maven 或者 Ivy 库.或者你可以使用这些文件在多项目构建中应用在其它的项目中. 我们称这个过程为 *publication(发布)* 16 | 17 | 18 | -------------------------------------------------------------------------------- /dependency_management_basics/where_to_next.md: -------------------------------------------------------------------------------- 1 | # 下一步? 2 | 3 | 对于依赖关系的所有细节,参见[Chapter 52, 依赖管理](https://docs.gradle.org/current/userguide/dependency_management.html),artifact发布细节,参见[Chapter 53, Publishing artifacts](https://docs.gradle.org/current/userguide/artifact_management.html). 4 | 5 | 如果你对这里提及的DSL元素感兴趣,看看[Project.configurations{}](https://docs.gradle.org/current/dsl/org.gradle.api.Project.html#org.gradle.api.Project:configurations(groovy.lang.Closure)),[Project.repositories{}]https://docs.gradle.org/current/dsl/org.gradle.api.Project.html#org.gradle.api.Project:repositories(groovy.lang.Closure)和[Project.dependencies{}](https://docs.gradle.org/current/dsl/org.gradle.api.Project.html#org.gradle.api.Project:dependencies(groovy.lang.Closure)). 6 | 7 | 否则,继续到其他[tutorials](https://docs.gradle.org/current/userguide/tutorials.html). 8 | -------------------------------------------------------------------------------- /earcha-jian.md: -------------------------------------------------------------------------------- 1 | # Ear 插件 (未完成) 2 | 3 | Ear插件添加了对组装Web应用程序EAR文件的支持。 它将添加默认EAR文件生成任务。 它不需要Java插件，对于使用Java插件的项目，它会禁用默认的JAR文件生成。 4 | 5 | ## 51.1.使用 6 | 使用ear插件需要在构建脚本下包括以下内容 7 | 8 | **例51.1.使用ear插件** 9 | 10 | **build.gradle** 11 | 12 | ``` 13 | apply plugin 'ear' 14 | ``` 15 | 16 | ## 51.2.任务 17 | War插件会添加下列任务到项目. 18 | 19 | **表51.2.War插件-任务** 20 | 21 | 任务名 | 依赖于 | 类型 | 描述 22 | --------- | ---------- | ---- | ----------- 23 | ear | compile (仅在java插件存在时) | [Ear](https://docs.gradle.org/current/dsl/org.gradle.plugins.ear.Ear.html) | 组装应用程序Ear文件 24 | 25 | Ear插件由其他已存在的插件添加下列依赖任务. 26 | 27 | **表51.2.Ear插件-附加的依赖任务** 28 | 29 | 任务名 | 依赖于 30 | -------- | ------ 31 | assemble | ear 32 | 33 | 34 | ## 51.3.项目布局 35 | 36 | **表25.3.Ear插件-项目布局** 37 | 38 | 文件夹 | 含义 39 | -------- | ------ 40 | src/main/application | Ear资源,比如**META-INF**目录 41 | 42 | ## 51.4.依赖管理 43 | Ear插件添加了两个依赖配置：**deploy**和**earlib**。 **deploy**中的所有依赖关系都放在EAR存档的根目录中，并且是不可传递的（not transitive）。 **earlib**配置中的所有依赖关系都放在EAR存档中的'lib'目录中，并且是可传递的（transitive）。 44 | 45 | ## 51.5.常用配置 46 | 47 | **表51.4.Ear插件-目录配置** 48 | 49 | 属性名称 | 类型 | 默认值 | 描述 50 | ----- | ---- | ---- | ---- 51 | appDirName | String | src/main/application | 应用的资源文件夹，为与项目的相对路径 52 | libDirName | String | lib | 生成的ear文件中lib目录的名字 53 | deploymentDescriptor | org.gradle.plugins.ear.descriptor.DeploymentDescriptor | 在一个默认的构部署配置文件里：application.xml | 生成部署描述符文件的元数据，例如 application.xml。 如果此文件已存在于appDirName / META-INF中，则将使用现有文件内容，并忽略ear.deploymentDescriptor中的显式配置。 54 | 55 | 这些属性由一个[EarPluginConvention](https://docs.gradle.org/current/dsl/org.gradle.plugins.ear.EarPluginConvention.html)公共对象提供 56 | ## 51.6.Ear 57 | War任务默认会把`src/main/application`的内容复制到归档目录的根目录。如果配置文件**META-INF/application.xml**不存在，它将被自动生成。 58 | 59 | API文档中有更多关于[Ear](https://docs.gradle.org/current/dsl/org.gradle.plugins.ear.Ear.html)的信息. 60 | 61 | ## 51.7.定制Ear 62 | 下面的例子中有一些重要的自定义选项 63 | 64 | **例25.2.定制Ear插件** 65 | 66 | **build.gradle** 67 | 68 | ``` 69 | pply plugin: 'ear' 70 | apply plugin: 'java' 71 | 72 | repositories { mavenCentral() } 73 | 74 | dependencies { 75 | // The following dependencies will be the ear modules and 76 | // will be placed in the ear root 77 | deploy project(path: ':war', configuration: 'archives') 78 | 79 | // The following dependencies will become ear libs and will 80 | // be placed in a dir configured via the libDirName property 81 | earlib group: 'log4j', name: 'log4j', version: '1.2.15', ext: 'jar' 82 | } 83 | 84 | ear { 85 | appDirName 'src/main/app' // use application metadata found in this folder 86 | // put dependent libraries into APP-INF/lib inside the generated EAR 87 | libDirName 'APP-INF/lib' 88 | deploymentDescriptor { // custom entries for application.xml: 89 | // fileName = "application.xml" // same as the default value 90 | // version = "6" // same as the default value 91 | applicationName = "customear" 92 | initializeInOrder = true 93 | displayName = "Custom Ear" // defaults to project.name 94 | // defaults to project.description if not set 95 | description = "My customized EAR for the Gradle documentation" 96 | // libraryDirectory = "APP-INF/lib" // not needed, above libDirName setting does this 97 | // module("my.jar", "java") // won't deploy as my.jar isn't deploy dependency 98 | // webModule("my.war", "/") // won't deploy as my.war isn't deploy dependency 99 | securityRole "admin" 100 | securityRole "superadmin" 101 | withXml { provider -> // add a custom node to the XML 102 | provider.asNode().appendNode("data-source", "my/data/source") 103 | } 104 | } 105 | } 106 | ``` 107 | 你也可以使用一些**Ear**任务提供的自定义选项，如**from**和**metaInf**. 108 | ## 51.8.使用自定义的配置文件 109 | **-/-/-/-/-//-/-/-/--/-/-/-/-/-当前进度↑↑-/-/-/-/-/--/-/-/-/-/-/-/-/-/** 110 | 111 | 112 | -------------------------------------------------------------------------------- /gradle_plugins/README.md: -------------------------------------------------------------------------------- 1 | # Gradle 插件 2 | 3 | Gradle 的核心为真实世界提供了很少的自动化. 4 | 所有的实用特性,类似编译java源码的能力, 是由*插件*提供的. 插件添加了新的任务(如:[JavaCompile](https://docs.gradle.org/current/dsl/org.gradle.api.tasks.compile.JavaCompile.html)),域对象(如:[SourceSet](https://docs.gradle.org/current/dsl/org.gradle.api.tasks.SourceSet.html)),公约(如:Java资源位置是`src/main/java`)以及来自其他插件延伸核心对象和对象。 5 | 6 | 在本章中，我们将讨论如何使用插件和关于插件的周边概念和术语。 7 | -------------------------------------------------------------------------------- /gradle_plugins/applying_plugins.md: -------------------------------------------------------------------------------- 1 | # 应用插件 2 | 3 | 插件需要声明*被应用*,通过[Project.apply()](https://docs.gradle.org/current/dsl/org.gradle.api.Project.html#org.gradle.api.Project:apply(java.util.Map)方法完成.应用的插件是*idempotent*[注1](),即相同的插件可以应用多次.如果插件先前以被应用,任何后来的应用是安全的,不会有任何影响的. 4 | 5 | 6 | [1]译注:英文直接翻译的意思是幂等(denoting an element of a set that is unchanged in value when multiplied or otherwise operated on by itself.),上下中的大意应该是不会受其他因素的影响. 7 | -------------------------------------------------------------------------------- /gradle_plugins/applying_plugins_with_the_buildscript_block.md: -------------------------------------------------------------------------------- 1 | # 使用构建脚本块应用插件 2 | 3 | 项目可以通过添加向构建脚本中加入插件的类路径然后在应用插件,添加作为外部JAR文件的二进制插件.外部jar可以使用`buildscrip{}`块添加到构建脚本类路径就像[Section 62.6, “External dependencies for the build script”](https://docs.gradle.org/current/userguide/organizing_build_logic.html#sec:external_dependencies)中描述的一样. 4 | 5 | **Example 21.4. Applying a plugin with the buildscript block** 6 | 7 | **build.gradle** 8 | 9 | ```gradle 10 | buildscript { 11 | repositories { 12 | jcenter() 13 | } 14 | dependencies { 15 | classpath "com.jfrog.bintray.gradle:gradle-bintray-plugin:0.4.1" 16 | } 17 | } 18 | 19 | apply plugin: "com.jfrog.bintray" 20 | ``` 21 | 22 | 23 | -------------------------------------------------------------------------------- /gradle_plugins/applying_plugins_with_the_plugins_dsl.md: -------------------------------------------------------------------------------- 1 | # 使用插件的插件DSL 2 | 3 | > 插件DSL正在孵化([incubating](https://docs.gradle.org/current/userguide/feature_lifecycle.html))中,请注意,在以后的Gradle版本中,DSL和其它配置可能会改变. 4 | 5 | 新的插件DSL提供了更为简洁,方便的方式来声明插件的依赖关系。它的适用于与新的[Gradle Plugin Portal](http://plugins.gradle.org/)，同时提供了方便的核心和社区插件.该插件脚本块配置[PluginDependenciesSpec](https://docs.gradle.org/current/dsl/org.gradle.plugin.use.PluginDependenciesSpec.html)的实例. 6 | 7 | 要应用的核心插件,可以使用短名称: 8 | 9 | **Example 21.5. Applying a core plugin** 10 | 11 | **build.gradle** 12 | 13 | ```gradle 14 | plugins { 15 | id 'java' 16 | } 17 | ``` 18 | 19 | 要从插件门户应用一个社区插件,必须使用插件的完全限定id: 20 | 21 | **Example 21.6. Applying a community plugin** 22 | 23 | **build.gradle** 24 | 25 | ```gradle 26 | plugins { 27 | id "com.jfrog.bintray" version "0.4.1" 28 | } 29 | ``` 30 | 31 | 不必要进行进一步的配置,就是说没有必要配置buildscript的类路径,Gradle会从插件门户找到该插件,并使构建可用. 32 | 33 | 参见[PluginDependenciesSpec](https://docs.gradle.org/current/dsl/org.gradle.plugin.use.PluginDependenciesSpec.html)查看关于使用插件DSL的更多信息。 34 | -------------------------------------------------------------------------------- /gradle_plugins/binary_plugins.md: -------------------------------------------------------------------------------- 1 | # 二进制插件 2 | 3 | **Example 21.2. Applying a binary plugin** 4 | 5 | **build.gradle** 6 | ```gradle 7 | apply plugin: 'java' 8 | ``` 9 | 10 | 插件可以使用*插件ID*应用.插件的id作为给定的插件的唯一标识符.核心插件注册一个可以用作插件的id的短名称.在上述情况下,我们可以使用简称`java`的插件以应用[JavaPlugin](https://docs.gradle.org/current/javadoc/org/gradle/api/plugins/JavaPlugin.html).社区插件,一方面会使用一个完全合格的形式的插件id(如`com.github.foo.bar`),但还是有一些传统的插件可能仍然使用很短的，不合格的格式. 11 | 12 | 不使用一个插件的id，插件也可以通过简单地指定类来应用插件： 13 | 14 | **Example 21.3. Applying a binary plugin by type** 15 | 16 | **build.gradle** 17 | 18 | ```gradle 19 | apply plugin: JavaPlugin 20 | ``` 21 | 22 | 在上面的例子中,JavaPlugin是指[JavaPlugin](https://docs.gradle.org/current/javadoc/org/gradle/api/plugins/JavaPlugin.html),此类不是严格需要导入org.gradle.api.plugins包中的所有自动导入构建脚本（见:[附录E，现有的IDE支持，以及如何没有它应付](https://docs.gradle.org/current/userguide/ide_support.html)).此外，这是没有必要追加的.class以识别一个类常量在Groovy，因为它是在Java中。 23 | 24 | -------------------------------------------------------------------------------- /gradle_plugins/can_only_be_used_in_build_scripts.md: -------------------------------------------------------------------------------- 1 | # 只能在构建脚本中使用 2 | 3 | 插件`{}`块目前只能在一个项目的构建脚本中使用.他不能在脚本插件,`settings.gradle`和出书画脚本中使用. 4 | 5 | *Gradle的未来版本将删除此限制.* 6 | -------------------------------------------------------------------------------- /gradle_plugins/cannot_be_used_in_conjunction.md: -------------------------------------------------------------------------------- 1 | # 不能与subjects{},allprojects{}等结合使用 2 | 3 | 目前不能使用一次添加一个插件到多个项目中的模式,如使用`subprojects{}`等方式.目前没有机制可以应用一次插件到多个项目.目前,每个项目都必须在自己的构建脚本中的`plugins{}`块中声明应用的插件. 4 | 5 | *Gradle的未来版本将删除此限制.* 6 | 7 | 如果新语法的限制让人望而却步,推荐使用[buildscript{} block](https://docs.gradle.org/current/userguide/plugins.html#sec:applying_plugins_buildscript). 8 | 9 | 10 | -------------------------------------------------------------------------------- /gradle_plugins/constrained_syntax.md: -------------------------------------------------------------------------------- 1 | # 约束语法 2 | 3 | 新插件`{}`块不支持任意Groovy代码.被限制的原因是为幂等(每次产生相同的结果)和无副作用(为了Gradle随时执行的安全). 4 | 5 | 6 | 形式是: 7 | 8 | ```Gradle 9 | plugins{ 10 | id «plugin id» version «plugin version» 11 | } 12 | ``` 13 | 14 | `«plugin id»`和`«plugin version»`必须是常量,字面量,字符串.其他语句都是不允许的;他们的存在会导致编译错误. 15 | 16 | 插件`{}`块也必须在构建脚本的顶部声明.它不能被嵌套在另一个结构(例如,if语句或for循环). 17 | -------------------------------------------------------------------------------- /gradle_plugins/finding_community_plugins.md: -------------------------------------------------------------------------------- 1 | # 查找社区插件 2 | 3 | Gradle有一个充满活力的,卡法人员做出不用贡献的插件社区.该Gradle[插件门户](http://plugins.gradle.org/)提供搜索和探索社区插件的接口. 4 | -------------------------------------------------------------------------------- /gradle_plugins/limitations_of_the_plugins_dsl.md: -------------------------------------------------------------------------------- 1 | # 插件DSL的限制 2 | 3 | 想项目中添加插件的新方法不仅仅是一种更为方便的语法.新的DSL语法处理与老方法有很大的不同.新的机制允许Gradle更早更快的确定插件.这允许做更智能的事,如: 4 | 5 | * 优化插件类的加载和重用. 6 | * 允许不同的插件使用不同版本的依赖关系. 7 | * 为编辑构建脚本提供关于隐含属性和值的详细信息 8 | 9 | 这要求插件被指定使Gradle在执行之前剩下的构建脚本前可以很容易并且很快的提取它.还要求插件使用一些静态的定义。 10 | 11 | 新的插件机制与"传统的"`apply()`方法有一些关键区别.也有一些限制,其中一些限制是临时的,随着机制的成熟会逐渐没有,还有一些是方法固有的. 12 | -------------------------------------------------------------------------------- /gradle_plugins/locations_of_binary_plugins.md: -------------------------------------------------------------------------------- 1 | # 二进制插件的位置 2 | 3 | 一个插件是一个简单的实现了[插件](https://docs.gradle.org/current/javadoc/org/gradle/api/Plugin.html)接口的类.Gradle提供的核心插件作为其分布的一部分,因此,你需要做的仅仅是应用上述的插件.然而,非核心二进制插件需要到构建类路径才能应用它们.这可以以多种方式，包括以下方式实现: 4 | 5 | * 定义插件作为构建脚本中内嵌类的声明. 6 | * 定义插件为在项目中buildSrc目录下的一个源文件.(参见[Section 62.4, “Build sources in the buildSrc project”](https://docs.gradle.org/current/userguide/organizing_build_logic.html#sec:build_sources)) 7 | * 包含来自外部jar定义的构建脚本依赖插件(参见[Section 21.4, “Applying plugins with the buildscript block”](https://docs.gradle.org/current/userguide/plugins.html#sec:applying_plugins_buildscript)) 8 | * 包含插件DSL语言组成的插件门户网站([Section 21.5, “Applying plugins with the plugins DSL”](https://docs.gradle.org/current/userguide/plugins.html#sec:plugins_block)) 9 | 10 | 欲了解有关自定义插件的跟多信息,参见[Chapter 61, Writing Custom Plugins](https://docs.gradle.org/current/userguide/custom_plugins.html) 11 | -------------------------------------------------------------------------------- /gradle_plugins/more_on_plugins.md: -------------------------------------------------------------------------------- 1 | # 更多关于插件 2 | 3 | 本章旨在作为介绍插件和Gradle,以及他们扮演的角色.要了解更过关于插件内部的工作原理,参见[Chapter 61, Writing Custom Plugins](https://docs.gradle.org/current/userguide/custom_plugins.html). 4 | -------------------------------------------------------------------------------- /gradle_plugins/script_plugins.md: -------------------------------------------------------------------------------- 1 | # 脚本插件 2 | 3 | **Example 21.1. Applying a script plugin** 4 | 5 | **build.gradle** 6 | 7 | ```gradle 8 | apply from: 'other.gradle' 9 | ``` 10 | 11 | 脚本插件可以从本地文件系统或在远程位置的脚本中*应用*.文件系统的位置是相对于项目目录,而远程脚本位置的是由一个`HTTP URL`指定的.多个脚本插件（两种形式之一）可以被*应用*到给定的构建。 12 | -------------------------------------------------------------------------------- /gradle_plugins/types_of_plugins.md: -------------------------------------------------------------------------------- 1 | # 插件的类型 2 | 3 | 在Gradle中一般有两种类型的插件,*脚本*插件和*二进制*插件.*脚本*插件是额外的构建脚本,它会进一步配置构建,通常实行声明的方式操纵的构建.尽管他们可以外部化并且从远程位置访问,它们通常还是会在构建内部中使用.*二进制*插件是实现了[Plugin](https://docs.gradle.org/current/javadoc/org/gradle/api/Plugin.html)接口的类,并且采用编程的方式来操纵构建.*二进制*插件可以驻留在构建脚本,项目层级内或外部的插件jar. 4 | 5 | 6 | -------------------------------------------------------------------------------- /gradle_plugins/what_plugins_do.md: -------------------------------------------------------------------------------- 1 | # 插件的作用是什么 2 | 3 | 应用插件到项目允许插件来扩展项目的能力。它可以做的事情，如： 4 | 5 | * 扩展摇篮模型（如:添加可配置新的DSL元素） 6 | * 按照惯例配置项目(如:添加新的任务或配置合理的默认值) 7 | * 应用特定的配置（如:增加组织库或执行标准） 8 | 9 | 通过应用插件,而不是向项目构建脚本添加逻辑,我们可以收获很多好处.应用插件: 10 | 11 | * 促进重用和减少维护在多个项目类似的逻辑的开销 12 | * 允许更高程度的模块化，提高综合性和组织 13 | * 封装必要的逻辑，并允许构建脚本尽可能是声明性地 14 | 15 | 16 | -------------------------------------------------------------------------------- /groovy_quickstart/README.md: -------------------------------------------------------------------------------- 1 | # Groovy 快速入门 2 | 3 | 构建 Groovy 项目时, 你需要使用 `Groovy plugin (Groovy插件)`. 这个插件扩展了 Java 插件, 加入了编译 Groovy 的依赖. 你的项目可以包含 Groovy 的源代码, Java 源代码, 或者它们的混合.在其他方面,一个Groovy项目与Java项目是相同的,就像我们在[Chapter 7, Java Quickstart](https://docs.gradle.org/current/userguide/tutorial_java_projects.html)见到的一样. 4 | 5 | -------------------------------------------------------------------------------- /groovy_quickstart/a_basic_groovy_project.md: -------------------------------------------------------------------------------- 1 | # 一个基本的 Groovy 项目 2 | 3 | 让我们看一个例子. 为了使用 Groovy 插件, 加入下面的代码: 4 | 5 | **例子 8.1. Groovy 插件** 6 | 7 | **build.gradle** 8 | 9 | apply plugin: 'groovy' 10 | 11 | > 注意:这个例子的代码可以在 `samples/groovy/quickstart` 在Gradle分布的 `"-all"` 中找到. 12 | 13 | 它也会同时把 Java 插件加入到你的项目里. Groovy 插件扩展了编译任务, 这个任务会在 src/main/groovy 目录里寻找源代码文件, 并且加入了编译测试任务来寻找 src/test/groovy 目录里的测试源代码. 编译任务使用 联合编译 (joint compilation) 来编译这些目录, 这里的联合指的是它们混合有 java 和 groovy 的源文件. 14 | 15 | 使用 groovy 编译任务, 你必须声明 Groovy 的版本和 Groovy 库的位置. 你可以在配置文件里加入依赖, 编译配置会继承这个依赖, 然后 groovy 库将被包含在 classpath 里. 16 | 17 | *例子 8.2. Groovy 2.2.0* 18 | 19 | *build.gradle* 20 | 21 | repositories { 22 | mavenCentral() 23 | } 24 | 25 | dependencies { 26 | compile 'org.codehaus.groovy:groovy-all:2.3.3' 27 | } 28 | 29 | 下面是完整的构建文件: 30 | 31 | *例子 8.3. 完整的构建文件* 32 | 33 | *build.gradle* 34 | 35 | apply plugin: 'eclipse' 36 | apply plugin: 'groovy' 37 | 38 | repositories { 39 | mavenCentral() 40 | } 41 | 42 | dependencies { 43 | compile 'org.codehaus.groovy:groovy-all:2.3.3' 44 | testCompile 'junit:junit:4.11' 45 | } 46 | 47 | 运行 **gradle build** 命令将会开始编译, 测试和创建 JAR 文件. 48 | -------------------------------------------------------------------------------- /groovy_quickstart/summary.md: -------------------------------------------------------------------------------- 1 | # 总结 2 | 3 | 这一章描述了一个非常简单的 Groovy 项目. 通常, 一个真正的项目要比这个复杂的多. 因为 Groovy 项目是一个 Java 项目, 任何你可以对 Java 项目做的配置也可以对 Groovy 项目做. 4 | 5 | [Chapter 24,The Groovy Plugin](https://docs.gradle.org/current/userguide/groovy_plugin.html)有更加详细的描述, 你也可以在 samples/groovy 目录里找到更多的例子. 6 | -------------------------------------------------------------------------------- /installing_gradle/README.md: -------------------------------------------------------------------------------- 1 | # 安装 Gradle 2 | 3 | * 先决条件 4 | * 下载 5 | * 解压缩 6 | * 环境变量 7 | * 运行并测试您的安装 8 | * JVM选项 9 | -------------------------------------------------------------------------------- /installing_gradle/download.md: -------------------------------------------------------------------------------- 1 | ### 2 | # 下载与安装 3 | 4 | 你可以从 [Gradle网站](http://www.gradle.org/downloads) 下载任意一个已经发布的版本 5 | 6 | # 解压缩 7 | 8 | Gradle 发布的版本为 ****ZIP 格式. 所有文件包含: 9 | 10 | * Gradle 的二进制文件. 11 | * 用户指南 (HTML 和 PDF). 12 | * DSL参考指南. 13 | * API文档 (Javadoc和 Groovydoc). 14 | * 扩展的例子,包括用户指南中引用的实例，以及一些更复杂的实例来帮助用户构建自己的build. 15 | * 二进制源码.此代码仅供参考. 16 | 17 | # 设置环境变量 18 | 19 | 然后我们需要设置环境变量 20 | 21 | 1. 添加一个 **GRADLE_HOME** 环境变量来指明 Gradle 的安装路径 22 | 2. 添加 **GRADLE_HOME/bin** 到您的 *PATH* 环境变量中. 通常, 这样已经足够运行Gradle了. 23 | 24 | **扩充教程** 25 | 26 | **Max OX**: 27 | 28 | 假设您下载好的 Gradle 文件在 /Users/UFreedom/gradle 目录 29 | 30 | 1.vim ~/.bash_profile 31 | 32 | 2.添加下面内容： 33 | export GRADLE_HOME = /Users/UFreedom/gradle 34 | export export PATH=$PATH:$GRADLE_HOME/bin 35 | 36 | 3.source ~/.brash_profile 37 | 38 | 实际配置中，您需要将上面的目录换成您的 Gradle 文件在系统中的目录. 39 | 40 | 41 | 42 | 43 | # 运行并测试您的安装 44 | 45 | 然后我们需要测试 Gradle 是否已经正确安装. 您可以通过在控制台输入 **gradle** 命令来运行Gradle. 通过 **gradle -v** 命令来检测Gradle是否已经正确安装. 如果正确安装，会输出Gradle版本信息以及本地的配置环境 ( groovy 和 JVM 版本等). 显示的版本信息应该与您所下载的 gradle 版本信息相匹配. 46 | 47 | -------------------------------------------------------------------------------- /installing_gradle/environment_variables.md: -------------------------------------------------------------------------------- 1 | # 环境变量 2 | 3 | 1. 添加一个 **GRADLE_HOME** 环境变量来指明 Gradle 的安装路径 4 | 5 | 2. 添加 **GRADLE_HOME/bin** 到您的 *PATH* 环境变量中. 通常, 这样已经足够运行Gradle了. 6 | 7 | 8 | 9 | -------------------------------------------------------------------------------- /installing_gradle/jvm_options.md: -------------------------------------------------------------------------------- 1 | # JVM 选项 2 | 3 | JVM 选项可以通过设置环境变量来更改. 您可以使用 GRADLE_OPTS 或者 JAVA_OPTS. 4 | 5 | * JAVA_OPTS 是一个用于 JAVA 应用的环境变量. 一个典型的用例是在 JAVA_OPTS 里设置HTTP代理服务器(proxy), 6 | * GRADLE_OPTS 是内存选项. 这些变量可以在 gradle 的一开始就设置或者通过 gradlew 脚本来设置. 7 | -------------------------------------------------------------------------------- /installing_gradle/prerequisites.md: -------------------------------------------------------------------------------- 1 | # 准备阶段 2 | 3 | Gradle 需要运行在一个 Java 环境里 4 | 5 | * 安装一个 Java JDK 或者 JRE. 而且 Java 版本必须至少是 6 以上. 6 | * Gradle 自带 Groovy 库, 所以没必要安装 Groovy. 任何已经安装的 Groovy 会被 Gradle 忽略. 7 | 8 | Gradle 使用任何已经存在在你的路径中的 JDK (可以通过 **java -version** 检查, 如果有就说明系统已经安装了 Java 环境). 或者, 你也可以设置 JAVA_HOME 环境参数来指定希望使用的JDK的安装目录. 9 | -------------------------------------------------------------------------------- /installing_gradle/running_and_testing_your_installation.md: -------------------------------------------------------------------------------- 1 | # 运行并测试您的安装 2 | 3 | 您可以通过 **gradle** 命令来运行Gradle. 通过 **gradle -v** 命令来检测Gradle是否已经正确安装. 如果正确安装，会输出Gradle版本信息以及本地的配置环境 ( groovy 和 JVM 版本等). 显示的版本信息应该与您所下载的gradle版本信息相匹配. 4 | 5 | -------------------------------------------------------------------------------- /installing_gradle/unpacking.md: -------------------------------------------------------------------------------- 1 | # 解压缩 2 | 3 | Gradle 发布的版本为 ****ZIP 格式. 所有文件包含: 4 | 5 | * Gradle 的二进制文件. 6 | * 用户指南 (HTML 和 PDF). 7 | * DSL参考指南. 8 | * API文档 (Javadoc和 Groovydoc). 9 | * 扩展的例子,包括用户指南中引用的实例，以及一些更复杂的实例来帮助用户构建自己的build. 10 | * 二进制源码.此代码仅供参考. 11 | -------------------------------------------------------------------------------- /introduction.md: -------------------------------------------------------------------------------- 1 | # 介绍 2 | 3 | 很高兴能向大家介绍 Gradle, 4 | 这是一个构建系统, 5 | 我们认为它是 java ( JVM ) 世界中构建技术的一个飞跃. 6 | 7 | Gradle 提供了: 8 | 9 | * 一个像 Ant 一样的非常灵活的通用构建工具 10 | * 一种可切换的, 像 maven 一样的基于合约构建的框架 11 | * 支持强大的多工程构建 12 | * 支持强大的依赖管理(基于 ApacheIvy ) 13 | * 支持已有的 maven 和 ivy 仓库 14 | * 支持传递性依赖管理, 而不需要远程仓库或者 pom.xml 或者 ivy 配置文件 15 | * 优先支持 Ant 式的任务和构建 16 | * 基于 groovy 的构建脚本 17 | * 有丰富的领域模型来描述你的构建 18 | 19 | -------------------------------------------------------------------------------- /java.md: -------------------------------------------------------------------------------- 1 | # Java插件 2 | -------------------------------------------------------------------------------- /java_quickstart/README.md: -------------------------------------------------------------------------------- 1 | # Java 构建入门 2 | 3 | * Java 插件 4 | * 一个基础的 Java 项目 5 | * 多项目的 Java 构建 6 | 7 | 8 | 9 | 10 | 11 | -------------------------------------------------------------------------------- /java_quickstart/a_basic_java_project.md: -------------------------------------------------------------------------------- 1 | # 一个基础的 Java 项目 {#revision1} 2 | 3 | 让我们先来看一个简单的例子. 4 | 5 | 我们可以加入下面的代码来使用 Java 插件: 6 | 7 | **例子 7.1. 使用 Java 插件** 8 | 9 | _build.gradle_ 10 | 11 | ``` 12 | apply plugin: 'java' 13 | ``` 14 | 15 | （注：此例子的代码可以再所有“-all”结尾的发行版的samples/java/quickstart目录下找到） 16 | 17 | 它将会把 Java 插件加入到你的项目中, 这意味着许多预定制的任务会被自动加入到你的项目里. 18 | 19 | Gradle 默认在 **src/main/java** 目录下寻找到你的正式（生产）源码, 在 **src/test/java** 目录下寻找到你的测试源码, 并在**src/main/resources**目录下寻找到你准备打包进jar的资源文件。测试代码会被加入到环境变量中设置的目录里运行。所有的输出文件都会被创建在构建目录里, 生成的JAR文件会被存放在 **build/libs** 目录下. 20 | 21 | **都加了什么可以执行的任务呢?** 22 | 23 | 请在项目目录下使用 **gradle tasks** 来列出该项目的所有任务。 24 | 25 | -------------------------------------------------------------------------------- /java_quickstart/building_the_project.md: -------------------------------------------------------------------------------- 1 | # 建立项目 2 | 3 | 尽管Java 插件在你的项目里加入了许多任务，只有几个会在项目构建中经常用到。 4 | 5 | 最常用的任务是 **build** 任务, 用于完全构建你的项目.运行 **gradle build** 命令执行后,Gradle 将会编译和测试你的代码,并生成一个包含所有类与资源的 JAR 文件: 6 | 7 | **例子 7.2. 建立一个 Java 项目** 8 | 9 | **gradle build** 命令的输出： 10 | 11 | > gradle build 12 | :compileJava 13 | :processResources 14 | :classes 15 | :jar 16 | :assemble 17 | :compileTestJava 18 | :processTestResources 19 | :testClasses 20 | :test 21 | :check 22 | :build 23 | 24 | BUILD SUCCESSFUL 25 | 26 | Total time: 1 secs 27 | 28 | 其余一些有用的任务是: 29 | 30 | **clean** 31 | 32 | 删除 **build** 目录和所有为build生成的文件. 33 | 34 | **assemble** 35 | 36 | 编译并打包你的代码, 但是并不运行单元测试.其他插件会在这个任务里加入更多的步骤.举个例子,如果你使用 War 插件,这个任务还将根据你的项目生成一个 WAR 文件. 37 | 38 | **check** 39 | 40 | 编译并测试你的代码. 其他的插件会加入更多的检查步骤.举个例子, 如果你使用 checkstyle 插件, 这个任务将会运行 Checkstyle 来检查你的代码. 41 | 42 | 43 | -------------------------------------------------------------------------------- /java_quickstart/common_configuration.md: -------------------------------------------------------------------------------- 1 | # 通用配置 2 | 3 | 对于绝大多数多项目构建, 有一些配置对所有项目都是常见的或者说是通用的. 在我们的例子里, 我们将在根项目里定义一个这样的通用配置, 使用一种叫做配置注入的技术 (configuration injection). 这里, 根项目就像一个容器, subprojects 方法遍历这个容器的所有元素并且注入指定的配置 . 通过这种方法, 我们可以很容易的定义所有档案和通用依赖的内容清单: 4 | 5 | *Example 7.12. 多项目构建 - 通用配置* 6 | 7 | build.gradle 8 | 9 | subprojects { 10 | apply plugin: 'java' 11 | apply plugin: 'eclipse-wtp' 12 | 13 | repositories { 14 | mavenCentral() 15 | } 16 | 17 | dependencies { 18 | testCompile 'junit:junit:4.11' 19 | } 20 | 21 | version = '1.0' 22 | 23 | jar { 24 | manifest.attributes provider: 'gradle' 25 | } 26 | } 27 | 28 | 注意我们例子中, Java 插件被应用到了每一个子项目中plugin to each. 这意味着我们前几章看到的任务和属性都可以在子项目里被调用. 所以, 你可以通过在根目录里运行 **gradle build** 命令编译, 测试, 和 JAR 所有的项目. 29 | 30 | 31 | -------------------------------------------------------------------------------- /java_quickstart/creating_a_distribution.md: -------------------------------------------------------------------------------- 1 | # 创建一个发行版本 2 | 3 | (该章需加入更多内容。。。原稿写的太简单了)我们同时也加入了一个发行版本, 将会送到客户端: 4 | 5 | *Example 7.14. 多项目构建 - 发行文件* 6 | 7 | *api/build.gradle* 8 | 9 | task dist(type: Zip) { 10 | dependsOn spiJar 11 | from 'src/dist' 12 | into('libs') { 13 | from spiJar.archivePath 14 | from configurations.runtime 15 | } 16 | } 17 | 18 | artifacts { 19 | archives dist 20 | } 21 | -------------------------------------------------------------------------------- /java_quickstart/creating_an_eclipse_project.md: -------------------------------------------------------------------------------- 1 | # 创建 Eclipse 项目 2 | 3 | 为了把你的项目导入到 Eclipse, 你需要加入另外一个插件: 4 | 5 | *Example 7.8. Eclipse 插件* 6 | 7 | *build.gradle* 8 | 9 | apply plugin: 'eclipse' 10 | 11 | 现在运行 **gradle eclipse** 命令来生成 Eclipse 的项目文件. Eclipse 任务将在第 38 章, Eclipse 插件里详细讨论. 12 | 13 | 14 | -------------------------------------------------------------------------------- /java_quickstart/customizing_the_project.md: -------------------------------------------------------------------------------- 1 | # 定制项目 2 | 3 | Java 插件给项目加入了一些属性 (propertiy).这些属性已经被赋予了默认的值,已经足够来开始构建项目了.如果你认为不合适,改变它们的值也是很简单的.让我们看下这个例子.这里我们将指定 Java 项目的版本号,以及我们所使用的 Java 的版本.我们同样也加入了一些属性在 **jar** 的**manifest**里. 4 | 5 | **例子 7.5. 定制 MANIFEST.MF 文件** 6 | 7 | *build.gradle* 8 | 9 | sourceCompatibility = 1.5 10 | version = '1.0' 11 | jar { 12 | manifest { 13 | attributes 'Implementation-Title': 'Gradle Quickstart', 'Implementation-Version': version 14 | } 15 | } 16 | 17 | Java 插件加入的任务是常规性的任务,准确地说,就如同它们在构建文件里声明地一样. 这意味着你可以使用任务之前的章节提到的方法来定制这些任务.举个例子,你可以设置一个任务的属性,在任务里加入行为,改变任务的依赖, 18 | 或者完全重写一个任务,我们将配置一个测试任务,当测试执行的时候它会加入一个系统属性: 19 | 20 | **例子 7.6. 测试阶段加入一个系统属性** 21 | 22 | *build.gradle* 23 | 24 | test { 25 | systemProperties 'property': 'value' 26 | } 27 | 28 | **哪些属性是可用的?** 29 | 30 | 你可以使用 **gradle properties** 命令来列出项目的所有属性. 31 | 这样你就可以看到 Java 插件加入的属性以及它们的默认值. 32 | -------------------------------------------------------------------------------- /java_quickstart/defining_a_multi-project_build.md: -------------------------------------------------------------------------------- 1 | # 定义一个多项目构建 2 | 3 | 为了定义一个多项目构建, 你需要创建一个设置文件 ( settings file). 设置文件放在源代码的根目录, 它指定要包含哪个项目. 它的名字必须叫做 **settings.gradle**. 在这个例子中, 我们使用一个简单的分层布局. 下面是对应的设置文件: 4 | 5 | *Example 7.11. 多项目构建 - settings.gradle file* 6 | 7 | *settings.gradle* 8 | 9 | include "shared", "api", "services:webservice", "services:shared" 10 | 11 | 在第56章. 多项目构建, 你可以找到更多关于设置文件的信息. 12 | 13 | 14 | -------------------------------------------------------------------------------- /java_quickstart/dependencies_between_projects.md: -------------------------------------------------------------------------------- 1 | # 项目之间的依赖 2 | 3 | 你可以在同一个构建里加入项目之间的依赖, 举个例子, 一个项目的 JAR 文件被用来编译另外一个项目. 在 api 构建文件里我们将加入一个由 shared 项目产生的 JAR 文件的依赖. 由于这个依赖, Gradle 将确保 shared 项目总是在 api 之前被构建. 4 | 5 | *Example 7.13. 多项目构建 - 项目之间的依赖* 6 | 7 | *api/build.gradle* 8 | 9 | dependencies { 10 | compile project(':shared') 11 | } 12 | 13 | 14 | 15 | -------------------------------------------------------------------------------- /java_quickstart/external_dependencies.md: -------------------------------------------------------------------------------- 1 | # 外部的依赖 2 | 3 | 通常, 4 | 一个 Java 项目的依赖许多外部的 JAR 文件.为了在项目里引用这些 JAR 文件,你需要告诉 Gradle 去哪里找它们.在 Gradle 中,JAR 文件位于一个仓库中，这里的仓库类似于 MAVEN 的仓库，可以被用来提取依赖,或者放入依赖。 5 | 6 | 举个例子，我们将使用开放的 Maven 仓库: 7 | 8 | **例子 7.3. 加入 Maven 仓库** 9 | 10 | *build.gradle* 11 | 12 | repositories { 13 | mavenCentral() 14 | } 15 | 16 | 接下来让我们加入一些依赖. 17 | 这里, 18 | 我们假设我们的项目在编译阶段有一些依赖: 19 | 20 | *例子 6.4. 加入依赖* 21 | 22 | *build.gradle* 23 | 24 | dependencies { 25 | compile group: 'commons-collections', name: 'commons-collections', version: '3.2' 26 | testCompile group: 'junit', name: 'junit', version: '4.+' 27 | } 28 | 29 | 可以看到 commons-collections 被加入到了编译阶段, 30 | junit 也被加入到了测试编译阶段. 31 | 32 | 你可以在第 8 章里看到更多这方面的内容. 33 | 34 | 35 | -------------------------------------------------------------------------------- /java_quickstart/multi-project_java_build.md: -------------------------------------------------------------------------------- 1 | # 多项目的 Java 构建 2 | 3 | 现在让我们看一个典型的多项目构建. 下面是项目的布局: 4 | 5 | *Example 7.10. 多项目构建 - 分层布局* 6 | 7 | *构建布局* 8 | 9 | multiproject/ 10 | api/ 11 | services/webservice/ 12 | shared/ 13 | 14 | 15 | 注意: 这个例子的代码可以在 samples/java/multiproject 里找到. 16 | 17 | 现在我们能有三个项目. 项目的应用程序接口 (API) 产生一个 JAR 文件, 这个文件将提供给用户, 给用户提供基于 XML 的网络服务. 项目的网络服务是一个网络应用, 它返回 XML. shared 目录包含被 api 和 webservice 共享的代码. 18 | 19 | 20 | -------------------------------------------------------------------------------- /java_quickstart/publishing_the_jar_file.md: -------------------------------------------------------------------------------- 1 | # 发布 JAR 文件 2 | 3 | 通常 JAR 文件需要在某个地方发布. 为了完成这一步, 你需要告诉 Gradle 哪里发布 JAR 文件. 在 Gradle 里, 生成的文件比如 JAR 文件将被发布到仓库里. 在我们的例子里, 我们将发布到一个本地的目录. 你也可以发布到一个或多个远程的地点. 4 | 5 | *Example 7.7. 发布 JAR 文件* 6 | 7 | *build.gradle* 8 | 9 | uploadArchives { 10 | repositories { 11 | flatDir { 12 | dirs 'repos' 13 | } 14 | } 15 | } 16 | 17 | 运行 **gradle uploadArchives** 命令来发布 JAR 文件. 18 | 19 | 20 | -------------------------------------------------------------------------------- /java_quickstart/summary.md: -------------------------------------------------------------------------------- 1 | # 总结 2 | 3 | 下面是一个完整的构建文件的样本: 4 | 5 | *Example 7.9. Java 例子 - 完整的构建文件* 6 | 7 | *build.gradle* 8 | 9 | apply plugin: 'java' 10 | apply plugin: 'eclipse' 11 | 12 | sourceCompatibility = 1.5 13 | version = '1.0' 14 | jar { 15 | manifest { 16 | attributes 'Implementation-Title': 'Gradle Quickstart', 'Implementation-Version': version 17 | } 18 | } 19 | 20 | repositories { 21 | mavenCentral() 22 | } 23 | 24 | dependencies { 25 | compile group: 'commons-collections', name: 'commons-collections', version: '3.2' 26 | testCompile group: 'junit', name: 'junit', version: '4.+' 27 | } 28 | 29 | test { 30 | systemProperties 'property': 'value' 31 | } 32 | 33 | uploadArchives { 34 | repositories { 35 | flatDir { 36 | dirs 'repos' 37 | } 38 | } 39 | } 40 | -------------------------------------------------------------------------------- /java_quickstart/the_java_plugin.md: -------------------------------------------------------------------------------- 1 | # Java 插件 2 | 3 | 如你所见, 4 | Gradle 是一种多用途的构建工具. 5 | 它可以在你的构建脚本里构建任何你想要实现的东西. 6 | 但前提是你必须先在构建脚本里加入代码, 7 | 不然它什么都不会执行. 8 | 9 | 大多数 Java 项目是非常相似的: 10 | 你需要编译你的 Java 源文件, 11 | 运行一些单元测试, 12 | 同时创建一个包含你类文件的 JAR. 13 | 如果你可以不需要为每一个项目重复执行这些步骤, 14 | 我想你会非常乐意的. 15 | 16 | 幸运的是, 你现在不再需要做这些重复劳动了. 17 | Gradle 通过使用插件解决了这个问题. 18 | 插件是 Gradle 的扩展, 19 | 它会通过某种方式配置你的项目, 20 | 典型的有加入一些预配置任务. 21 | Gradle 自带了许多插件, 22 | 你也可以很简单地编写自己的插件并和其他开发者分享它. 23 | Java 插件就是一个这样的插件. 24 | 这个插件在你的项目里加入了许多任务， 25 | 这些任务会编译和单元测试你的源文件, 26 | 并且把它们都集成一个 JAR 文件里. 27 | 28 | Java 插件是基于合约的. 29 | 这意味着插件已经给项目的许多方面定义了默认的参数, 30 | 比如 Java 源文件的位置. 31 | 如果你在项目里遵从这些合约, 32 | 你通常不需要在你的构建脚本里加入太多东西. 33 | 如果你不想要或者是你不能遵循合约, 34 | Gradle 也允许你自己定制你的项目. 35 | 事实上, 36 | 因为对 Java 项目的支持是通过插件实现的, 37 | 如果你不想要的话, 38 | 你一点也不需要使用这个插件来构建你的项目. 39 | 40 | 在后面的章节, 41 | 我们有许多机会来让你深入了解 Java 插件, 依赖管理和多项目构建. 在本章中，先来初步认识如何使用Java插件来构建一个Java项目. 42 | 43 | 44 | 45 | 46 | -------------------------------------------------------------------------------- /logging/changing_what_gradle_logs.md: -------------------------------------------------------------------------------- 1 | # 改变Gradle的记录内容 2 | 3 | 你可以用自己的内容取代大部分摇篮的UI记录.你可以这样做，例如，如果你想以某种方式定制UI,如:记录更多或更少的信息，或更改log的格式.你可以使用[Gradle.useLogger()](https://docs.gradle.org/current/dsl/org.gradle.api.invocation.Gradle.html#org.gradle.api.invocation.Gradle:useLogger(java.lang.Object))方法替换日志.可从一个构建脚本或初始化脚本，或通过嵌入API替换.注意，这会完全禁用Gradle的默认输出.下面的初始化脚本改变任务执行和完成构建后日志的输出. 4 | 5 | **例 17.6.定制Gradle logs** 6 | 7 | **init.gradle** 8 | 9 | ```gradle 10 | useLogger(new CustomEventLogger()) 11 | 12 | class CustomEventLogger extends BuildAdapter implements TaskExecutionListener { 13 | 14 | public void beforeExecute(Task task) { 15 | println "[$task.name]" 16 | } 17 | 18 | public void afterExecute(Task task, TaskState state) { 19 | println() 20 | } 21 | 22 | public void buildFinished(BuildResult result) { 23 | println 'build completed' 24 | if (result.failure != null) { 25 | result.failure.printStackTrace() 26 | } 27 | } 28 | } 29 | ``` 30 | `gradle -I init.gradle build`的输出 31 | 32 | > \> gradle -I init.gradle build 33 | > [compile] 34 | > compiling source 35 | > 36 | > [testCompile] 37 | > compiling test source 38 | > 39 | > [test] 40 | > running unit tests 41 | > 42 | > [build] 43 | > 44 | > build completed 45 | 46 | 你的`logger`可以实现下面列出的任何监听器接口.仅它实现接口被替换,其他接口保持不变。你可以在[Section 56.6, “Responding to the lifecycle in the build script”](https://docs.gradle.org/current/userguide/build_lifecycle.html#build_lifecycle_events)中找到更多相关信息. 47 | 48 | + [BuildListener](https://docs.gradle.org/current/javadoc/org/gradle/BuildListener.html) 49 | + [ProjectEvaluationListener](https://docs.gradle.org/current/javadoc/org/gradle/api/ProjectEvaluationListener.html) 50 | + [TaskExecutionGraphListener](https://docs.gradle.org/current/javadoc/org/gradle/api/execution/TaskExecutionGraphListener.html) 51 | + [TaskExecutionListener](https://docs.gradle.org/current/javadoc/org/gradle/api/execution/TaskExecutionListener.html) 52 | + [TaskActionListener](https://docs.gradle.org/current/javadoc/org/gradle/api/execution/TaskActionListener.html) 53 | -------------------------------------------------------------------------------- /logging/choosing_a_log_level.md: -------------------------------------------------------------------------------- 1 | # Choosing a log level 2 | 3 | 你可以在命令行中选择如[表 17.2.Log 等级命令行选项]()所示的选项选择不同的日志级别.如[表 17.3.堆栈信息选项]()中所示的选项来选择堆栈信息. 4 | 5 | **表17.2.Log 等级命令行选项** 6 | 7 | | 选项 | 输出日志等级 | 8 | | -- | -- | 9 | | no logging options | LIFECYCLE及更高 | 10 | | -q or --quiet | QUIET及更高 | 11 | | -i or --info | INFO及更高 | 12 | | -d or --debug | DEBUG及更高(所有日志信息) | 13 | 14 | 15 | **表 17.3.堆栈信息选项** 16 | 17 | | 选项 | 含义 | 18 | | -- | -- | 19 | | No stacktrace options | 无堆栈踪迹输出到控制台的情况下生成错误信息(如编译错误) ,仅在内部异常时打印堆栈信息.如果选择DEBUG日志等级,总会打印截断堆栈信息| 20 | | -s or --stacktrace | 打印截断堆栈信息,我们推荐这个而不是`full stacktrace` ,Groovy的`full stacktrace`非常详细.(由于底层的动态调用机制。然而，他们通常不包含你的代码出了什么错的相关信息) | 21 | | -S or --full-stacktrace | 打印全部堆栈信息 | 22 | 23 | 24 | -------------------------------------------------------------------------------- /logging/logging.md: -------------------------------------------------------------------------------- 1 | # Logging 2 | 3 | Log 是构建的主要"UI"工具. 如果日志太过冗长, 那么真正的警告和问题会隐藏其中, 另一方面, 如果你出错了,你又需要搞清楚相关错误信息. Gradle 提供了6个等级的 log, 如[表17.1.Logs Level]()所示.出了那些你可能经常看到的, 还有两个是 Gradle 特定级别的日志,被称为*QUIET*和*LIFECYCLE*.后者是默认的, 并用于报告生成进度. 4 | 5 | **表17.1.Logs Level** 6 | 7 | | Level | 用途 | 8 | | -- | -- | 9 | | ERROR | 错误信息 | 10 | | QUIET | 重要消息信息 | 11 | | WARNING | 警告信息 | 12 | | LIFECYCLE | 进度消息信息 | 13 | | INFO | 信息消息 | 14 | | DEBUG | 调试信息 | 15 | 16 | 17 | -------------------------------------------------------------------------------- /logging/logging_from_external_tools_and_libraries.md: -------------------------------------------------------------------------------- 1 | # 从外部工具和库记录日志 2 | 3 | 在内部, Gradle 使用 Ant 和 lvy , 4 | 都有自己的 log 系统, 5 | Gradle 重定向他们的日志输出到 Gradle 日志系统. 6 | 除了Ant/lvy的`TRACE`级别的日志, 映射到Gradle的`DEBUG`级别, 其余的都会有一个1:1的映射从 Ant/lvy 的日志等级到 Gradle 的日志等级. 7 | 这意味着默认的 Gradle 日志级别将不会显示任何的 Ant /lvy 的输出, 除非它是一个错误或警告. 8 | 9 | 有许多工具仍然使用标准输出记录,默认的,Gradle将标准输出重定向到`QUIET`的日志级别和标准错误的`ERROR`级别.该行为是可配置的.该项目对象提供了一个[LoggerManager](https://docs.gradle.org/current/javadoc/org/gradle/api/logging/LoggingManager.html),当你构建脚本进行评估的时候,允许你改变标准输出或错误重定向的日志级别。 10 | 11 | **例 17.4.配置标准输出捕获** 12 | 13 | **build.gradle** 14 | 15 | ```gradle 16 | logging.captureStandardOutput LogLevel.INFO 17 | println 'A message which is logged at INFO level' 18 | ``` 19 | 20 | 任务同样提供了[LoggingManager](https://docs.gradle.org/current/javadoc/org/gradle/api/logging/LoggingManager.html)去更改任务执行过程中的标准输出或错误日志级别。 21 | 22 | **例 17.5.为任务配置标准输出捕获** 23 | 24 | **build.gradle** 25 | 26 | ```gradle 27 | task logInfo { 28 | logging.captureStandardOutput LogLevel.INFO 29 | doFirst { 30 | println 'A task message which is logged at INFO level' 31 | } 32 | } 33 | ``` 34 | 35 | Gradle同样提供了`Java Util Logging`,`Jakarta Commons Logging`和` Log4j logging`的集成工具. 36 | 37 | 使用这些工具包编写的构建的类的记录的任何日志消息都将被重定向到Gradle的日志记录系统。 38 | 39 | -------------------------------------------------------------------------------- /logging/writing_your_own_log_messages.md: -------------------------------------------------------------------------------- 1 | # 编写自己的日志信息 2 | 3 | 用于记录在你的构建文件的简单方法是将消息写入标准输出.Gradle重定向任何东西写入到标准输出到它的log系统作为`QUITE`级别的log. 4 | 5 | **例 17.1.使用标准输出写入log信息** 6 | 7 | **build.gradle** 8 | 9 | ```gradle 10 | println 'A message which is logged at QUIET level' 11 | ``` 12 | 13 | 摇篮还提供了一个`logger`属性来构建脚本，这是[Logger](https://docs.gradle.org/current/javadoc/org/gradle/api/logging/Logger.html)的一个实例.这个接口继承自`SLF4J`接口并且加入了一F些Gradle的具体方法.下面是如何在构建脚本中使用此方法的例子： 14 | 15 | **例 17.2.写入自己的log信息** 16 | 17 | **build.gradle** 18 | 19 | ```gradle 20 | logger.quiet('An info log message which is always logged.') 21 | logger.error('An error log message.') 22 | logger.warn('A warning log message.') 23 | logger.lifecycle('A lifecycle info log message.') 24 | logger.info('An info log message.') 25 | logger.debug('A debug log message.') 26 | logger.trace('A trace log message.') 27 | ``` 28 | 29 | 你还可以在构建中将其他类直接挂接到Gradle的log系统中(例如`buildSrc`目录下的类).只使用`SLF4J logger`,使用这个`logger`的方式与构建脚本提供的`logger`方式相同. 30 | 31 | **例 17.3.使用SLF4J写入log信息** 32 | 33 | **build.gradle** 34 | 35 | ```gradle 36 | import org.slf4j.Logger 37 | import org.slf4j.LoggerFactory 38 | 39 | Logger slf4jLogger = LoggerFactory.getLogger('some-logger') 40 | slf4jLogger.info('An info log message logged using SLF4j') 41 | ``` 42 | -------------------------------------------------------------------------------- /more_about_tasks/README.md: -------------------------------------------------------------------------------- 1 | # 深入了解 Tasks 2 | 3 | 在这本教程的一开始 (第 6 章, 构建脚本基础) 你已经学习了如何创建简单的任务. 然后你也学习了如何给这些任务加入额外的行为, 以及如何在任务之间建立依赖关系. 4 | 这些仅仅是用来构建简单的任务. 5 | Gradle 可以创建更为强大复杂的任务. 这些任务可以有它们自己的属性和方法. 6 | 这一点正是和 Ant targets 不一样的地方. 这些强大的任务既可以由你自己创建也可以使用 Gradle 内建好的. 7 | 8 | -------------------------------------------------------------------------------- /more_about_tasks/adding_a_description_to_a_task.md: -------------------------------------------------------------------------------- 1 | # 给 task 加入描述 2 | 3 | 你可以给你的任务加入一段描述性的文字. 它将会在任务执行的时候显示出来. 4 | 5 | **例子 15.18. 给任务加入描述** 6 | 7 | **build.gradle** 8 | 9 | ``` 10 | task copy(type: Copy) { 11 | description 'Copies the resource directory to the target directory.' 12 | from 'resources' 13 | into 'target' 14 | include('**/*.txt', '**/*.xml', '**/*.properties') 15 | } 16 | ``` 17 | -------------------------------------------------------------------------------- /more_about_tasks/adding_dependencies_to_a_task.md: -------------------------------------------------------------------------------- 1 | # 给 task 加入依赖 2 | 3 | 有许多种加入依赖的方式. 在 6.5 小节, “任务依赖”里, 你已经学习了如何使用任务的名称定义依赖. 任务名称可以指向同一个项目里的任务, 或者其他项目里的任务. 为了指向其他项目, 你必须在任务的名称前加入项目的路径. 下面的例子给 projectA:taskX 加入依赖 projectB:taskY : 4 | 5 | **例子 15.11. 从另外一个项目给任务加入依赖** 6 | 7 | **build.gradle** 8 | 9 | ``` 10 | project('projectA') { 11 | task taskX(dependsOn: ':projectB:taskY') << { 12 | println 'taskX' 13 | } 14 | } 15 | 16 | project('projectB') { 17 | task taskY << { 18 | println 'taskY' 19 | } 20 | } 21 | ``` 22 | 23 | **gradle -q taskX** 的输出 24 | 25 | ``` 26 | > gradle -q taskX 27 | taskY 28 | taskX 29 | ``` 30 | 31 | 除了使用任务名称, 你也可以定义一个依赖对象y: 32 | 33 | **例子 15.12. 通过任务对象加入依赖** 34 | 35 | **build.gradle** 36 | 37 | ``` 38 | task taskX << { 39 | println 'taskX' 40 | } 41 | 42 | task taskY << { 43 | println 'taskY' 44 | } 45 | 46 | taskX.dependsOn taskY 47 | ``` 48 | 49 | **gradle -q taskX** 的输出 50 | 51 | ``` 52 | > gradle -q taskX 53 | taskY 54 | taskX 55 | ``` 56 | 57 | 更加先进的用法, 你可以通过闭包定义一个任务依赖. 闭包只能返回一个单独的 Task 或者 Task 对象的 collection, 这些返回的任务就将被当做依赖. 接下来的例子给 taskX 加入了一个复杂的依赖, 所有以 lib 开头的任务都将在 taskX 之前执行: 58 | 59 | **例子 15.13. 通过闭包加入依赖** 60 | 61 | **build.gradle** 62 | ``` 63 | 64 | task taskX << { 65 | println 'taskX' 66 | } 67 | 68 | taskX.dependsOn { 69 | tasks.findAll { task -> task.name.startsWith('lib') } 70 | } 71 | 72 | task lib1 << { 73 | println 'lib1' 74 | } 75 | 76 | task lib2 << { 77 | println 'lib2' 78 | } 79 | 80 | task notALib << { 81 | println 'notALib' 82 | } 83 | ``` 84 | 85 | **gradle -q taskX** 的输出 86 | 87 | ``` 88 | > gradle -q taskX 89 | lib1 90 | lib2 91 | taskX 92 | ``` 93 | 94 | 95 | For more information about task dependencies, see the Task API. 96 | -------------------------------------------------------------------------------- /more_about_tasks/cache.md: -------------------------------------------------------------------------------- 1 | # 缓存 2 | 3 | 为了提高响应能力，Gradle 默认缓存了所有编译后的脚本. 包括所有的构建脚本，初始化脚本，还有其他脚本. Gradle 创建了一个 .gradle 目录来存放编译后的脚本，下次您运行构建脚本时，如果这个脚本自从它被编译后就再也没有被改动过，Gradle 会先使用编译后的脚本. 否则 Gradle 会重新编译脚本，然后将新编译后的文件缓存起来. 如果您使用 Gradle --recompile--scripts 运行脚本，缓存的脚本就会被删除，然后新编译后的文件就会再被缓存. 这种方法可以强制 Gradle 重新编译脚本并缓存. 4 | 5 | -------------------------------------------------------------------------------- /more_about_tasks/config_any_object.md: -------------------------------------------------------------------------------- 1 | # 配置任意对象 2 | 您可以使用下面方法配置任意的对象. 3 | 4 | **例子 14.4.配置任意对象** 5 | 6 | **build.gradle** 7 | 8 | task configure << { 9 | def pos = configure(new java.text.FieldPosition(10)) { 10 | beginIndex = 1 11 | endIndex = 5 12 | } 13 | 14 | println pos.beginIndex 15 | println pos.endIndex 16 | 17 | } 18 | 19 | **使用 gradle -q configure 输出** 20 | 21 | > gradle -q configure 22 | 1 23 | 5 24 | -------------------------------------------------------------------------------- /more_about_tasks/configuring_tasks.md: -------------------------------------------------------------------------------- 1 | # 配置 tasks 2 | 3 | 举一个例子, 让我们看一看 Gradle 自带的 Copy task. 为了创建一个 Copy task, 你需要在你的构建脚本里先声明它: 4 | 5 | **例子 15.7. 创建一个 copy task** 6 | 7 | **build.gradle** 8 | 9 | ``` 10 | task myCopy(type: Copy) 11 | ``` 12 | 13 | 它创建了一个没有默认行为的 copy task. 这个 task 可以通过它的 API 来配置(参考 [Copy](https://docs.gradle.org/current/dsl/org.gradle.api.tasks.Copy.html)). 接下来例子展示了不同的实现方法. 14 | 15 | 补充说明一下, 这个 task 的名字是 “myCopy”, 但是它是 “Copy” 类(type). 你可以有许多同样 type 不同名字的 tasks. 这个在实现特定类型的所有任务的 cross-cutting concerns 时特别有用. 16 | 17 | **例子 15.8. 配置一个任务 - 不同的方法** 18 | 19 | **build.gradle** 20 | 21 | ``` 22 | Copy myCopy = task(myCopy, type: Copy) 23 | myCopy.from 'resources' 24 | myCopy.into 'target' 25 | myCopy.include('**/*.txt', '**/*.xml', '**/*.properties') 26 | ``` 27 | 28 | 这个我们通过 Java 配置对象是一样的形式. 但是你每次都必须在语句里重复上下文 (myCopy). 这种方式可能读起来并不是那么的漂亮. 29 | 30 | 下面一种方式就解决了这个问题. 是公认的最具可读性的方式. 31 | 32 | **例子 15.9. 配置一个任务 - 通过闭包 closure** 33 | 34 | **build.gradle** 35 | 36 | ``` 37 | task myCopy(type: Copy) 38 | 39 | myCopy { 40 | from 'resources' 41 | into 'target' 42 | include('**/*.txt', '**/*.xml', '**/*.properties') 43 | } 44 | ``` 45 | 46 | 上面例子里的第三行是 tasks.getByName() 方法的一个简洁的写法. 特别要注意的是, 如果你通过闭包的形式来实现 getByName() 方法, 这个闭包会在 task 配置的时候执行而不是在 task 运行的时候执行. 47 | 48 | 你也可以直接在定义 task 时使用闭包. 49 | 50 | **例子 15.10. 通过定义一个任务** 51 | 52 | ``` 53 | build.gradle 54 | 55 | task copy(type: Copy) { 56 | from 'resources' 57 | into 'target' 58 | include('**/*.txt', '**/*.xml', '**/*.properties') 59 | } 60 | ``` 61 | 62 | 请不要忘了构建的各个阶段. 63 | 64 | 一个任务有配置和动作. 当使用 << 时, 你只是简单的使用捷径定义了动作. 定义在配置区域的代码只会在构建的配置阶段执行, 而且不论执行哪个任务. 可以参考第 55 章, The Build Lifecycle for more details about the build lifecycle. 65 | 66 | -------------------------------------------------------------------------------- /more_about_tasks/defining_tasks.md: -------------------------------------------------------------------------------- 1 | # 定义 tasks 2 | 3 | 我们已经在第 6 章学习了定义任务的形式 (keyword 形式). 当然也会有一些定义形式的变化来适应某些特殊的情况. 比如下面的例子中任务名被括号括起来了. 这是因为之前定义简单任务的形式 (keyword 形式) 在表达式里是不起作用的. 4 | 5 | **例子 15.1. 定义 tasks** 6 | 7 | **build.gradle** 8 | ``` 9 | task(hello) << { 10 | println "hello" 11 | } 12 | 13 | task(copy, type: Copy) { 14 | from(file('srcDir')) 15 | into(buildDir) 16 | } 17 | ``` 18 | 你也可以使用 strings 来定义任务的名字: 19 | 20 | **例子 15.2. 例子 tasks - 使用 strings 来定义任务的名字** 21 | 22 | **build.gradle** 23 | ``` 24 | task('hello') << 25 | { 26 | println "hello" 27 | } 28 | 29 | task('copy', type: Copy) { 30 | from(file('srcDir')) 31 | into(buildDir) 32 | } 33 | ``` 34 | 35 | 还有另外一种语法形式来定义任务, 更加直观: 36 | 37 | **例子 15.3. 另外一种语法形式** 38 | 39 | **build.gradle** 40 | 41 | ``` 42 | tasks.create(name: 'hello') << { 43 | println "hello" 44 | } 45 | 46 | tasks.create(name: 'copy', type: Copy) { 47 | from(file('srcDir')) 48 | into(buildDir) 49 | } 50 | ``` 51 | 52 | 这里实际上我们把任务加入到 tasks collection 中. 可以看一看 [TaskContainer](https://docs.gradle.org/current/javadoc/org/gradle/api/tasks/TaskContainer.html) 来深入了解下. 53 | 54 | -------------------------------------------------------------------------------- /more_about_tasks/extra.md: -------------------------------------------------------------------------------- 1 | # 补充 2 | #### 下面补充的部分原本是第 14 章，最新的 Gradle 文档将其移除，所以将其作为补充放到这一章节。 3 | 4 | -------------------------------------------------------------------------------- /more_about_tasks/finalizer_tasks.md: -------------------------------------------------------------------------------- 1 | # 终止 tasks 2 | 3 | >终止任务是一个正在开发的功能. 4 | 5 | 这里的终止任务并不是指终止一个任务, 而是指一个无论运行结果如何最后都会被执行的任务. 6 | 7 | **例子 15.27. 加入一个任务终止器** 8 | 9 | **build.gradle** 10 | 11 | ``` 12 | task taskX << { 13 | println 'taskX' 14 | } 15 | task taskY << { 16 | println 'taskY' 17 | } 18 | 19 | taskX.finalizedBy taskY 20 | ``` 21 | 22 | **gradle -q taskX** 的输出 23 | 24 | ``` 25 | > gradle -q taskX 26 | taskX 27 | taskY 28 | ``` 29 | 30 | 即使要终止的任务失败了, 终止任务仍会继续执行. 31 | 32 | **例子 14.28. 当任务失败时k** 33 | 34 | **build.gradle** 35 | ``` 36 | task taskX << { 37 | println 'taskX' 38 | throw new RuntimeException() 39 | } 40 | task taskY << { 41 | println 'taskY' 42 | } 43 | 44 | taskX.finalizedBy taskY 45 | ``` 46 | **gradle -q taskX** 的输出 47 | ``` 48 | > gradle -q taskX 49 | taskX 50 | taskY 51 | ``` 52 | 53 | 另外, 如果要终止的任务并没有被执行 (比如上一节讲的 up-to-date) 那么终止任务并不会执行. 54 | 55 | 当构建创建了一个资源, 无论构建失败或成功时这个资源必须被清除的时候, 终止任务就非常有用. 56 | 57 | 要使用终止任务, 你必须使用 [Task.finalizedBy()](https://docs.gradle.org/current/dsl/org.gradle.api.Task.html#org.gradle.api.Task:finalizedBy(java.lang.Object[])) 方法. 一个任务的实例, 任务的名称, 或者任何 Task.dependsOn() 可以接收的输入都可以作为这个任务的输入. 58 | -------------------------------------------------------------------------------- /more_about_tasks/gradle_properties_and_system_properties.md: -------------------------------------------------------------------------------- 1 | # Gradle 属性 和 system 属性 2 | Gradle 提供了多种的方法让您可以在构建脚本中添加属性. 使用 -D 命令选项，您可以向运行 Gradle 的 JVM 传递一个 system 属性 . **Gradle** 命令的 -D 选项 和 **Java** 命令的 -D 选项有些相同的效果. 3 | 4 | 您也可以使用属性文件向您的 Project 对象中添加属性. 您可以在 Gradle 用户目录( 如果您没有在 *USER_HOME*/.gradle 配置默认设置,则由"GRADLE_USER_HOME" 环境变量定义) 或者项目目录放置一个 gradle.properties 文件.如果是多项目的话，您可以在每个子目录里都放置一个 gradle.properties 文件. gradle.properties 文件内容里的属性能够被 Project 对象访问到. 不过有一点，用户目录中的 gradle.properties 文件优先权大于项目目录中的 gradle.properties 文件. 5 | 6 | 您也可以通过 -P 命令选项直接向Project 对象中添加属性. 7 | 8 | 另外，当 Gradle 看到特别命名的 system 属性或者环境变量时，Gradle 也可以设置项目属性. 比如当您没有管理员权限去持续整合服务，还有您需要设置属性值但是不容易时，这个特性非常有用. 出于安全的原因，在这种情况下，您没法使用 -P 命令选项，您也不能修改系统级别的文件. 确切的策略是改变您持续继承构建工作的配置，增加一个环境变量设置令它匹配一个期望的模式. 对于当前系统来说，这种方法对于普通用户来说是不可见的. [\[6]](#md-anchor) 9 | 10 | 如果环境变量的名字是 ORG_GRADLE_PROJECT=somevalue, Gradle 会使用值为 somevalue 在您的 Project 对象中设定一个支持属性. 另外 Gradle 也支持 system 属性，但是使用不同的名字模式，例如 org.gradle.project.prop . 11 | 12 | 您也可以在 gradle.properties 文件中设置 system 属性.如果一个属性名的前缀为 “systemProp”，那么这个属性和它的属性值会被设置为 system 属性. 如果没有这个前缀，在多项目构建中，除了根项目会被忽略外，“systemProp.” 属性会在任何项目中设置.也就是说仅仅根项目的 gradle.properties 文件会被检查其属性的前缀是否是 “systemProp”. 13 | 14 | **例子 14.2.通过 gradle.properties 文件设置属性 15 | 16 | **gradle.properties** 17 | 18 | gradlePropertiesProp=gradlePropertiesValue 19 | sysProp=shouldBeOverWrittenBySysProp 20 | envProjectProp=shouldBeOverWrittenByEnvProp 21 | systemProp.system=systemValue 22 | 23 | **build.gradle** 24 | 25 | task printProps << { 26 | println commandLineProjectProp 27 | println gradlePropertiesProp 28 | println systemProjectProp 29 | println envProjectProp 30 | println System.properties['system'] 31 | 32 | } 33 | 34 | [6]. *Jenkins*, *Teamcity*, or *Bamboo* 都是 提供这个功能的 CI 服务. 35 | 36 | **使用 gradle -q -PcommandLineProjectProp=commandLineProjectPropValue -Dorg.gradle.project.systemProjectProp=systemPropertyValue printProps 输出** 37 | 38 | > gradle -q -PcommandLineProjectProp=commandLineProjectPropValue -Dorg.gradle.project.systemProjectProp=systemPropertyValue printProps 39 | commandLineProjectPropValue 40 | gradlePropertiesValue 41 | systemPropertyValue 42 | envPropertyValue 43 | systemValue 44 | 45 | -------------------------------------------------------------------------------- /more_about_tasks/locating_tasks.md: -------------------------------------------------------------------------------- 1 | # 定位 tasks 2 | 3 | 你经常需要在构建文件里找到你定义的 tasks, 4 | 举个例子, 5 | 为了配置它们或者使用它们作为依赖. 有许多种方式都可以来实现定位. 6 | 首先, 7 | 每一个任务都必须是一个 project 的有效属性, 8 | 并使用任务名来作为属性名: 9 | 10 | **例子 15.4. 通过属性获取 tasks** 11 | 12 | **build.gradle** 13 | ``` 14 | task hello 15 | 16 | println hello.name 17 | println project.hello.name 18 | ``` 19 | 20 | Tasks 也可以通过 tasks collection 来得到. 21 | 22 | **例子 15.5. 通过 tasks collection 获取 tasks** 23 | 24 | **build.gradle** 25 | 26 | ``` 27 | task hello 28 | 29 | println tasks.hello.name 30 | println tasks['hello'].name 31 | ``` 32 | 33 | 你也可以使用 tasks.getByPath() 方法通过任务的路径来使用任何 project 里的任务. 34 | 你可以通过使用任务的名字, 任务的相对路径或者绝对路径作为 getByPath() 方法的输入. 35 | 36 | **例子 15.6. 通过路径获取 tasks** 37 | 38 | **build.gradle** 39 | 40 | ``` 41 | project(':projectA') { 42 | task hello 43 | } 44 | 45 | task hello 46 | 47 | println tasks.getByPath('hello').path 48 | println tasks.getByPath(':hello').path 49 | println tasks.getByPath('projectA:hello').path 50 | println tasks.getByPath(':projectA:hello').path 51 | ``` 52 | 53 | **gradle -q hello** 的输出 54 | 55 | ``` 56 | > gradle -q hello 57 | :hello 58 | :hello 59 | :projectA:hello 60 | :projectA:hello 61 | ``` 62 | 参考 63 | [TaskContainer](https://docs.gradle.org/current/javadoc/org/gradle/api/tasks/TaskContainer.html) 可以知道跟多关于定位 tasks 的选项. 64 | 65 | 66 | -------------------------------------------------------------------------------- /more_about_tasks/ordering_tasks.md: -------------------------------------------------------------------------------- 1 | # 给 tasks 排序 2 | 3 | >任务的排序功能正在测试和优化. 请注意, 这项功能在 Gradle 之后的版本里可能会改变. 4 | 5 | 在某些情况下, 我们希望能控制任务的的执行顺序, 这种控制并不是向上一张那样去显示地加入依赖关系. 最主要的区别是我们设定的排序规则不会影响那些要被执行的任务, 只是影响执行的顺序本身. 好吧, 我知道可能有点抽象. 6 | 7 | 我们来看看以下几种有用的场景: 8 | 9 | * 执行连续的任务: eg. 'build' 从来不会在 'clean' 之前执行. 10 | * 在 build 的一开始先运行构建确认 (build validations): eg. 在正式的发布构建前先确认我的证书是正确的. 11 | * 在运行长时间的检测任务前先运行快速的检测任务来获得更快的反馈: eg. 单元测试总是应该在集成测试之前被执行. 12 | * 一个聚集 (aggregates) 某种特定类型的所有任务结果的任务: eg. 测试报告任务 (test report task) 包含了所有测试任务的运行结果. 13 | 14 | 目前, 有 2 种可用的排序规则: **"must run after"** 和 **"should run after"**. 15 | 16 | 当你使用 “must run after” 时即意味着 taskB 必须总是在 taskA 之后运行, 无论 taskA 和 taskB 是否将要运行: 17 | 18 | ``` 19 | taskB.mustRunAfter(taskA) 20 | ``` 21 | 22 | "should run after" 规则其实和 "must run after" 很像, 只是没有那么的严格, 在 2 种情况下它会被忽略: 23 | 24 | 1. 使用规则来阐述一个执行的循环. 25 | 2. 当并行执行并且一个任务的所有依赖除了 “should run after” 任务其余都满足了, 那么这个任务无论它的 “should run after” 依赖是否执行, 它都可以执行. (编者: 翻译待商榷, 提供具体例子) 26 | 27 | 总之, 当要求不是那么严格时, “should run after” 是非常有用的. 28 | 29 | 即使有目前的这些规则, 我们仍可以执行 taskA 而不管 taskB, 反之亦然. 30 | 31 | **例子 15.14. 加入 'must run after' ** 32 | 33 | **build.gradle** 34 | ``` 35 | task taskX << { 36 | println 'taskX' 37 | } 38 | task taskY << { 39 | println 'taskY' 40 | } 41 | taskY.mustRunAfter taskX 42 | ``` 43 | 44 | **gradle -q taskY taskX** 的输出 45 | 46 | ``` 47 | > gradle -q taskY taskX 48 | taskX 49 | taskY 50 | ``` 51 | 52 | **例子 15.15. 加入 'should run after'** 53 | 54 | **build.gradle** 55 | 56 | ``` 57 | task taskX << { 58 | println 'taskX' 59 | } 60 | task taskY << { 61 | println 'taskY' 62 | } 63 | taskY.shouldRunAfter taskX 64 | ``` 65 | 66 | **gradle -q taskY taskX** 的输出 67 | 68 | ``` 69 | > gradle -q taskY taskX 70 | taskX 71 | taskY 72 | ``` 73 | 74 | 在上面的例子里, 我们仍可以直接执行 taskY 而不去 taskX : 75 | 76 | **例子 15.16. 任务排序不影响任务执行** 77 | 78 | **gradle -q taskY** 的输出 79 | 80 | ``` 81 | > gradle -q taskY 82 | taskY 83 | ``` 84 | 85 | 为了在 2 个任务间定义 “must run after” 或者 “should run after” 排序, 我们需要使用 Task.mustRunAfter() 和 Task.shouldRunAfter() 方法. 这些方法接收一个任务的实例,　任务的名字或者任何 Task.dependsOn()可以接收的输入. 86 | 87 | 注意 “B.mustRunAfter(A)” 或者 “B.shouldRunAfter(A)” 并不影响任何任务间的执行依赖: 88 | 89 | * tasks A 和 B 可以被独立的执行. 排序规则只有当 2 个任务同时执行时才会被应用. 90 | * 在运行时加上 --continue, 当 A 失败时 B 仍然会执行. 91 | 92 | 之前提到过, “should run after” 规则在一个执行循环中将被忽略: 93 | 94 | **例子 15.17. 'should run after' 任务的忽略** 95 | 96 | **build.gradle** 97 | 98 | ``` 99 | task taskX << { 100 | println 'taskX' 101 | } 102 | task taskY << { 103 | println 'taskY' 104 | } 105 | task taskZ << { 106 | println 'taskZ' 107 | } 108 | taskX.dependsOn taskY 109 | taskY.dependsOn taskZ 110 | taskZ.shouldRunAfter taskX 111 | ``` 112 | 113 | **gradle -q taskX** 的输出 114 | 115 | ``` 116 | > gradle -q taskX 117 | taskZ 118 | taskY 119 | taskX 120 | ``` 121 | 122 | -------------------------------------------------------------------------------- /more_about_tasks/replacing_tasks.md: -------------------------------------------------------------------------------- 1 | # 替换 tasks 2 | 3 | 有时候你想要替换一个任务. 举个例子, 如果你想要互换一个通过 java 插件定义的任务和一个自定义的不同类型的任务: 4 | 5 | 例子 14.19. 覆写一个任务 6 | 7 | **build.gradle** 8 | 9 | ``` 10 | task copy(type: Copy) 11 | 12 | task copy(overwrite: true) << { 13 | println('I am the new one.') 14 | } 15 | ``` 16 | 17 | **gradle -q copy** 的输出 18 | 19 | ``` 20 | > gradle -q copy 21 | I am the new one. 22 | ``` 23 | 24 | 这种方式将用你自己定义的任务替换一个 Copy 类型的任务, 因为它使用了同样的名字. 25 | 但你定义一个新的任务时, 你必须设置 overwrite 属性为 true. 否则的话 Gradle 会抛出一个异常, task with that name already exists. 26 | 27 | -------------------------------------------------------------------------------- /more_about_tasks/skipping_tasks.md: -------------------------------------------------------------------------------- 1 | # 跳过 tasks 2 | 3 | Gradle 提供了好几种跳过一个任务的方式. 4 | 5 | ### 1. 使用判断条件 (predicate) 6 | 7 | 你可以使用 onlyIf() 方法来为一个任务加入判断条件. 就和 Java 里的 if 语句一样, 任务只有在条件判断为真时才会执行. 你通过一个闭包来实现判断条件. 闭包像变量一样传递任务, 如果任务应该被执行则返回真, 反之亦然. 判断条件在任务执行之前进行判断. 8 | 9 | **例子 15.20. 使用判断条件跳过一个任务** 10 | 11 | **build.gradle** 12 | 13 | ``` 14 | task hello << { 15 | println 'hello world' 16 | } 17 | 18 | hello.onlyIf { !project.hasProperty('skipHello') } 19 | ``` 20 | 21 | **gradle hello -PskipHello** 的输出 22 | 23 | ``` 24 | > gradle hello -PskipHello 25 | :hello SKIPPED 26 | BUILD SUCCESSFUL 27 | 28 | Total time: 1 secs 29 | ``` 30 | 31 | ### 2. 使用 StopExecutionException 32 | 33 | 如果想要跳过一个任务的逻辑并不能被判断条件通过表达式表达出来, 你可以使用 StopExecutionException. 如果这个异常是被一个任务要执行的动作抛出的, 这个动作之后的执行以及所有紧跟它的动作都会被跳过. 构建将会继续执行下一个任务. 34 | 35 | **例子 15.21. 通过 StopExecutionException 跳过任务** 36 | 37 | **build.gradle** 38 | 39 | ``` 40 | task compile << { 41 | println 'We are doing the compile.' 42 | } 43 | 44 | compile.doFirst { 45 | // Here you would put arbitrary conditions in real life. 46 | // But this is used in an integration test so we want defined behavior. 47 | if (true) { throw new StopExecutionException() } 48 | } 49 | task myTask(dependsOn: 'compile') << { 50 | println 'I am not affected' 51 | } 52 | ``` 53 | 54 | **gradle -q myTask** 的输出 55 | 56 | ``` 57 | > gradle -q myTask 58 | I am not affected 59 | ``` 60 | 61 | 如果你直接使用 Gradle 提供的任务, 这项功能还是十分有用的. 它允许你为内建的任务加入条件来控制执行. [6] 62 | 63 | ### 3. 激活和注销 tasks 64 | 65 | 每一个任务都有一个已经激活的标记(enabled flag), 这个标记一般默认为真. 将它设置为假, 那它的任何动作都不会被执行. 66 | 67 | **例子 15.22. 激活和注销 tasks** 68 | 69 | **build.gradle** 70 | 71 | ``` 72 | task disableMe << { 73 | println 'This should not be printed if the task is disabled.' 74 | } 75 | disableMe.enabled = false 76 | ``` 77 | 78 | **gradle disableMe** 的输出 79 | 80 | ``` 81 | > gradle disableMe 82 | :disableMe SKIPPED 83 | 84 | BUILD SUCCESSFUL 85 | 86 | Total time: 1 secs 87 | ``` 88 | 89 | -------------------------------------------------------------------------------- /more_about_tasks/skipping_tasks_that_are_up-to-date.md: -------------------------------------------------------------------------------- 1 | # 跳过 up-to-date 的任务 2 | 3 | 如果你正在使用一些附加的任务, 比如通过 Java 插件加入的任务, 你可能会注意到 Gradle 会跳过一些任务, 这些任务后面会标注 **up-to-date**. 代表这个任务已经运行过了或者说是最新的状态, 不再需要产生一次相同的输出. 不仅仅是这些内建任务, 其实你在运行自己的任务时, 也会碰到这种情况. 4 | 5 | ### 1. 声明一个任务的输入和输出 6 | 7 | 让我们先看一个例子. 这里我们的任务会根据一个 XML 文件生成好几个输出文件. 让我们运行这个任务 2 次. 8 | 9 | **例子 15.23. A generator task** 10 | 11 | **build.gradle** 12 | 13 | ``` 14 | task transform { 15 | ext.srcFile = file('mountains.xml') 16 | ext.destDir = new File(buildDir, 'generated') 17 | doLast { 18 | println "Transforming source file." 19 | destDir.mkdirs() 20 | def mountains = new XmlParser().parse(srcFile) 21 | mountains.mountain.each { mountain -> 22 | def name = mountain.name[0].text() 23 | def height = mountain.height[0].text() 24 | def destFile = new File(destDir, "${name}.txt") 25 | destFile.text = "$name -> ${height}\n" 26 | } 27 | } 28 | } 29 | ``` 30 | 31 | **gradle transform** 的输出 32 | 33 | ``` 34 | > gradle transform 35 | :transform 36 | Transforming source file. 37 | ``` 38 | 39 | **gradle transform** 的输出 40 | 41 | ``` 42 | > gradle transform 43 | :transform 44 | Transforming source file. 45 | ``` 46 | 47 | 这里 Gradle 执行了这个任务两次, 即使什么都没有改变, 它也没有跳过这个任务. 这个例子里的任务, 它的行为是通过闭包定义的. Gradle 并不知道闭包会做什么, 也并不能自动指出是否这个任务是 up-to-date. 为了使用 Gradle 的 up-to-date 检测, 你需要**定义任务的输入和输出**. 48 | 49 | 每个任务都有输入和输出属性, 你需要使用这些属性来声明任务的输入和输出. 下面的例子中, 我们将声明 XML 文件作为输入, 并且把输出放在一个指定的目录. 让我们运行这个任务 2 次. 50 | 51 | **例子 15.24. 声明任务的输入和输出** 52 | 53 | **build.gradle** 54 | 55 | ``` 56 | task transform { 57 | ext.srcFile = file('mountains.xml') 58 | ext.destDir = new File(buildDir, 'generated') 59 | inputs.file srcFile 60 | outputs.dir destDir 61 | doLast { 62 | println "Transforming source file." 63 | destDir.mkdirs() 64 | def mountains = new XmlParser().parse(srcFile) 65 | mountains.mountain.each { mountain -> 66 | def name = mountain.name[0].text() 67 | def height = mountain.height[0].text() 68 | def destFile = new File(destDir, "${name}.txt") 69 | destFile.text = "$name -> ${height}\n" 70 | } 71 | } 72 | } 73 | ``` 74 | 75 | **gradle transform** 的输出 76 | ``` 77 | > gradle transform 78 | :transform 79 | Transforming source file. 80 | ``` 81 | **gradle transform** 的输出 82 | ``` 83 | > gradle transform 84 | :transform UP-TO-DATE 85 | ``` 86 | 87 | 现在, Gradle 就能够检测出任务是否是 up-to-date 状态. 88 | 89 | 任务的输入属性是 [TaskInputs 类型](https://docs.gradle.org/current/javadoc/org/gradle/api/tasks/TaskInputs.html). 任务的输出属性是 [TaskOutputs 类型](https://docs.gradle.org/current/javadoc/org/gradle/api/tasks/TaskOutputs.html). 90 | 91 | 一个任务如果没有定义输出的话, 那么它永远都没用办法判断 up-to-date. 对于某些场景, 比如一个任务的输出不是文件, 或者更复杂的场景, [TaskOutputs.upToDateWhen()](https://docs.gradle.org/current/javadoc/org/gradle/api/tasks/TaskOutputs.html#upToDateWhen(groovy.lang.Closure)) 方法会计算任务的输出是否应被视为最新. 92 | 93 | 总而言之, **如果一个任务只定义了输出, 如果输出不变的话, 它就会被视为 up-to-date.** 94 | 95 | ### 2. 它是如何工作的? 96 | 97 | 当一个任务是首次执行时, Gradle 会取一个输入的快照 (snapshot). 该快照包含组输入文件和每个文件的内容的散列. 然后当 Gradle 执行任务时, 如果任务成功完成，Gradle 会获得一个输出的快照. 该快照包含输出文件和每个文件的内容的散列. Gradle 会保留这两个快照用来在该任务的下一次执行时进行判断. 98 | 99 | 之后, 每次在任务执行之前, Gradle 都会为输入和输出取一个新的快照, 如果这个快照和之前的快照一样, Gradle 就会假定这个任务已经是最新的 (up-to-date) 并且跳过任务, 反之亦然. 100 | 101 | 需要注意的是, 如果一个任务有指定的输出目录, 自从该任务上次执行以来被加入到该目录的任务文件都会被忽略, 并且不会引起任务过时 (out of date). 这是因为不相关任务也许会共用同一个输出目录. 如果这并不是你所想要的情况, 可以考虑使用 [TaskOutputs.upToDateWhen()](https://docs.gradle.org/current/javadoc/org/gradle/api/tasks/TaskOutputs.html#upToDateWhen(groovy.lang.Closure)) 102 | 103 | 104 | -------------------------------------------------------------------------------- /more_about_tasks/task_rules.md: -------------------------------------------------------------------------------- 1 | # Task 规则 2 | 3 | 有时候也想要一个任务的行为是基于已经定义好的取值范围或者特定规则, 下面的例子就提供了一种很直观漂亮的方式: 4 | 5 | **例子 15.25. 任务规则** 6 | 7 | **build.gradle** 8 | 9 | ``` 10 | tasks.addRule("Pattern: ping") { String taskName -> 11 | if (taskName.startsWith("ping")) { 12 | task(taskName) << { 13 | println "Pinging: " + (taskName - 'ping') 14 | } 15 | } 16 | } 17 | ``` 18 | 19 | **gradle -q pingServer1** 的输出 20 | 21 | ``` 22 | > gradle -q pingServer1 23 | Pinging: Server1 24 | ``` 25 | 26 | 这里的 String 参数就是用来定义规则的. 27 | 28 | 规则并不只是在通过命令行使用任务的时候执行. 你也可以基于规则来创建依赖关系: 29 | 30 | **例子 15.26. 基于规则的任务依赖** 31 | 32 | **build.gradle** 33 | 34 | ``` 35 | tasks.addRule("Pattern: ping") { String taskName -> 36 | if (taskName.startsWith("ping")) { 37 | task(taskName) << { 38 | println "Pinging: " + (taskName - 'ping') 39 | } 40 | } 41 | } 42 | 43 | task groupPing { 44 | dependsOn pingServer1, pingServer2 45 | } 46 | ``` 47 | 48 | **gradle -q groupPing** 的输出 49 | 50 | ``` 51 | > gradle -q groupPing 52 | Pinging: Server1 53 | Pinging: Server2 54 | ``` 55 | 56 | 如果你运行 “gradle -q tasks”, 你并不能找到名叫 “pingServer1” 或者 “pingServer2” 的任务, 但是这个脚本仍然会执行这些任务. 57 | -------------------------------------------------------------------------------- /more_about_tasks/use_other_script_to_config_any_object.md: -------------------------------------------------------------------------------- 1 | # 使用其他的脚本配置任意对象 2 | 3 | 您也可以使用其他的构建脚本配置任意的对象. 4 | 5 | **例子: 14.5.使用别的脚本配置配置对象** 6 | 7 | **build.gradle** 8 | 9 | task config << { 10 | def pos = new java.text.FieldPosition(10) 11 | 12 | // 使用另一个脚本 13 | apply from: 'other.gradle', to: pos 14 | println pos.beginIndex 15 | println pos.endIndex 16 | 17 | } 18 | 19 | **other.gradle** 20 | 21 | beginIndex = 1 22 | endIndex = 5 23 | 24 | 25 | **使用 gradle -q configure 输出** 26 | 27 | > gradle -q configure 28 | 1 29 | 5 30 | 31 | 32 | -------------------------------------------------------------------------------- /more_about_tasks/use_other_script_to_config_project.md: -------------------------------------------------------------------------------- 1 | # 使用其他的脚本配置项目 2 | 您还可以使用其他的构建脚本来配置当前的项目，Gradle 构建语言的所有的内容对于其他的脚本都是可以使用的. 您甚至可以在别的脚本中再使用其他的脚本. 3 | 4 | **例子 14.3.使用其他的构建脚本配置项目** 5 | 6 | **build.gradle** 7 | 8 | apply from: 'other.gradle' 9 | 10 | **other.gradle** 11 | 12 | println "configuring $project" 13 | task hello << { 14 | println' 'hello form other srcipt' 15 | } 16 | 17 | **使用 gradle -q hello 输出** 18 | 19 | > gradle -q hello 20 | configuring root project 'configureProjectUsingScript' 21 | hello from other script 22 | 23 | -------------------------------------------------------------------------------- /npm-debug.log: -------------------------------------------------------------------------------- 1 | 0 info it worked if it ends with ok 2 | 1 verbose cli [ 'C:\\Program Files (x86)\\nodejs\\\\node.exe', 3 | 1 verbose cli 'C:\\Program Files (x86)\\nodejs\\node_modules\\npm\\bin\\npm-cli.js', 4 | 1 verbose cli 'install', 5 | 1 verbose cli 'gitbook-plugin-disqus' ] 6 | 2 info using npm@1.4.28 7 | 3 info using node@v0.10.35 8 | 4 verbose node symlink C:\Program Files (x86)\nodejs\\node.exe 9 | 5 error Error: ENOENT, stat 'C:\Users\dchuan\AppData\Roaming\npm' 10 | 6 error If you need help, you may report this *entire* log, 11 | 6 error including the npm and node versions, at: 12 | 6 error 13 | 7 error System Windows_NT 6.1.7601 14 | 8 error command "C:\\Program Files (x86)\\nodejs\\\\node.exe" "C:\\Program Files (x86)\\nodejs\\node_modules\\npm\\bin\\npm-cli.js" "install" "gitbook-plugin-disqus" 15 | 9 error cwd D:\Userfiles\dchuan\Documents\GitHub\GradleUserGuide\book 16 | 10 error node -v v0.10.35 17 | 11 error npm -v 1.4.28 18 | 12 error path C:\Users\dchuan\AppData\Roaming\npm 19 | 13 error code ENOENT 20 | 14 error errno 34 21 | 15 verbose exit [ 34, true ] 22 | -------------------------------------------------------------------------------- /overview/README.md: -------------------------------------------------------------------------------- 1 | # 概述 2 | 3 | * 特点 4 | * 为什么用 Groovy? 5 | 6 | -------------------------------------------------------------------------------- /overview/features.md: -------------------------------------------------------------------------------- 1 | # 特点 2 | 3 | 这里简述下 Gradle 的特点. 4 | 5 | **1. 声明式构建和合约构建** 6 | 7 | Gradle 的核心是基于 Groovy 的 8 | 领域特定语言 (DSL), 具有十分优秀的扩展性. Gradle 通过提供可以随意集成的声明式语言元素将声明性构建推到了一个新的高度. 这些元素也为 Java, Groovy, OSGi, Web 和Scala 等项目提供基于合约构建的支持. 而且, 这种声明式语言是可扩展的. 你可以添加自己的语言元素或加强现有的语言元素, 从而提供简洁, 易于维护和易于理解的构建. 9 | 10 | 11 | **2. 基于依赖的编程语言** 12 | 13 | 声明式语言位于通用任务图 ( general purpose task graph ) 的顶端，它可以被充分利用在你的构建中. 它具有强大的灵活性, 可以满足使用者对 Gradle 的一些特别的需求. 14 | 15 | 16 | **3. 让构建结构化** 17 | 18 | Gradle 的易适应性和丰富性可让你在构建里直接套用通用的设计原则. 例如, 你可以非常容易地使用一些可重用的组件来构成你的构建. 但是不必要的间接内联内容是不合适的. 不要强行拆分已经结合在一起的部分 (例如, 在你的项目层次结构中). 避免使构建难以维护. 总之, 你可以创建一个结构良好，易于维护和易于理解的构建. 19 | 20 | **4. API深化** 21 | 22 | 你会非常乐意在整个构建执行的生命周期中使用 Gradle, 因为Gradle 允许你管理和定制它的配置和执行行为. 23 | 24 | **5. Gradle 扩展** 25 | 26 | Gradle 扩展得非常好. 不管是简单的独立项目还是大型的多项目构建, 它都能显著的提高效率. 27 | 这是真正的结构构建. 顶尖水平的构建功能，还可以解决许多大公司碰到的构建 性能低下的问题. 28 | 29 | 30 | **6. 多项目构建** 31 | 32 | Gradle 对多项目的支持是非常出色的. 项目依赖是很重要的部分. 它允许你模拟在多项目构建中项目的关系，这正是你所要关注的地方. Gradle 可以适应你的项目的结构, 而不是反过来. 33 | 34 | Gradle 提供了局部构建的功能. 如果你构建一个单独的子项目, Gradle 会构建这个子项目依赖的所有子项目. 你也可以选择依赖于另一个特别的子项目重新构建这些子项目. 这样在一些大型项目里就可以节省非常多的时间. 35 | 36 | **7. 多种方式来管理你的依赖** 37 | 38 | 不同的团队有不同的管理外部依赖的方法. Gradle 对于任何管理策略都提供了合适的支持. 从远程 Maven 和 Ivy 库的依赖管理到本地文件系统的 jars 或者 dirs. 39 | 40 | **8. Gradle 是第一个构建整合工具** 41 | 42 | Ant 的 tasks是 Gradle 中很重要的部分, 更有趣是 Ant 的 projects 也是十分重要的部分. Gradle 可以直接引入Ant 项目, 并在运行时直接将 Ant targets 转换成 Gradle tasks. 43 | 你可以从 Gradle 中依赖它们, 并增强它们的功能, 甚至可以在 build.xml 文件中声明 Gradle tasks 的依赖. 并且properties, paths 等也可以通过同样的方法集成进来. 44 | 45 | Gradle 完全支持你已有的 Maven 或者 lvy 仓库来构造发布或者提取依赖. Gradle 也提供了一个转化器, 用来将 maven 的 pom.xml 文件转换成 Gradle 脚本. 在运行时引入 Maven 项目也会在稍后推出. 46 | 47 | **9. 易于迁移** 48 | 49 | Gradle 可以兼容任何结构. 因此你可以直接在你的产品构建的分支上开发你的 Gradle 构建, 并且二者可以并行. 我们通常建议编写一些测试代码来确保它们的功能是相同的. 50 | 通过这种方式, 51 | 在迁移的时候就不会显得那么混乱和不可靠, 52 | 这是通过婴儿学步的方式来获得最佳的实践. 53 | 54 | **10. Groovy** 55 | 56 | Gradle 的构建脚本是通过 Groovy 编写的而不是 XML. 57 | 但是并不像其他方式, 58 | 这并不是为了简单的展示用动态语言编写的原始脚本有多么强大. 59 | 不然的话, 60 | 只会导致维护构建变得非常困难. 61 | Gradle 的整个设计是朝着一种语言的方向开发的, 62 | 并不是一种死板的框架. 63 | Groovy 就像胶水一样, 把你想实现的构想和抽象的 Gradle 粘在一起. Gradle提供了一些标准的构想, 但是他们并不享有任何形式的特权. 相比于其他声明式构建系统，对我们来说这是一个比较突出的特点. 64 | 65 | **10. Gradle 包装器** 66 | 67 | Gradle 包装器允许你在没有安装 Gradle 的机器上运行 Gradle 构建. 68 | 在一些持续集成的服务器上, 69 | 这个功能将非常有用. 70 | 它同样也能降低使用一个开源项目的门槛, 71 | 也就是说构建它将会非常简单. 72 | 这个包装器对于公司来说也是很有吸引力的. 73 | 它并不需要为客户机提供相应的管理防范. 74 | 这种方式同样也能强制某一个版本 Gradle 的使用从而最小化某些支持问题. 75 | 76 | **11. 免费和开源** 77 | 78 | Gradle 是一个开源项目, 遵循 ASL 许可. 79 | -------------------------------------------------------------------------------- /overview/why_groovy.md: -------------------------------------------------------------------------------- 1 | # 为什么用 Groovy? 2 | 3 | 我们认为在脚本构建时, 4 | 一个内部的 DSL（基于一个动态语言）相对于 XML 的优势是巨大的. 有这么多的动态语言, 5 | 为什么选择 Groovy? 6 | 答案在于 Gradle 的运行环境. 7 | 虽然 Gradle 以一个通用构建工具为核心, 但是它的重点是Java项目. 8 | 在这样的项目中, 9 | 显然团队每个成员都对 Java 非常熟悉. 我们认为构建应尽可能对所有团队成员都是透明的, 所以选择了 Groovy. 10 | 11 | 你可能会说，为什么不直接使用 Java 作为构建脚本的语言. 我们认为这是一个很有用的问题. 12 | 对于你的团队, 13 | 它要有最高的透明度和最低的学习曲线, 14 | 也就是说容易掌握. 15 | 但由于 Java 的限制, 16 | 这样的构建语言不会那么完美和强大. 17 | 而像 Python，Groovy 或 Ruby 语言用来作为构建语言会更好. 18 | 我们选择了 Groovy 是因为它给 Java 开发人员提供了迄今为止最大的透明度. 其基本的符号和类型与 Java 是一样的，其封装结构和许多其他的地方也是如此. 19 | Groovy 在这基础上提供了更多的功能, 20 | 而且与 java 有共同的基础. 21 | 22 | 对于那些同时是或者即将是 Python 或 Ruby 开发者的 Java 开发人员来说, 23 | 上述的讨论并不适用. 24 | Gradle 的设计非常适合在 JRuby 和 Jython 中创建另一个构建脚本引擎. 它对于我们来说只是目前开发中没有最高优先级. 我们十分支持任何人来做贡献, 25 | 创建额外的构建脚本引擎. 26 | -------------------------------------------------------------------------------- /standard_gradle_plugins/README.md: -------------------------------------------------------------------------------- 1 | # Standard Gradle plugins 2 | 3 | 许多包括在Gradle分布的插件。这些在下面列出。 4 | -------------------------------------------------------------------------------- /standard_gradle_plugins/base_plugins.md: -------------------------------------------------------------------------------- 1 | # 基础插件 2 | 3 | 这些插件是形成其他插件的基本构建模块.你可以在你的构建文件中使用它们,在下面李处完整地列表,然而,注意它们还不是Gradle的公用API的一部分.因此,这些插件未记录在用户指南中.你可能会参考他们的API文档,详细了解它们. 4 | 5 | **Table 22.7. Base plugins** 6 | 7 | #### base 8 | 9 | 添加标准的生命周期任务和配置合理的默认归档任务: 10 | + 增加*ConfigurationName*任务.这些任务组装指定配置的工件。 11 | + 增加了上传*ConfigurationName*任务,这些任务组装并上传指定配置的工件。 12 | + 对所有归档任务配置合理的默认值(如继承[AbstractArchiveTask](https://docs.gradle.org/current/dsl/org.gradle.api.tasks.bundling.AbstractArchiveTask.html)的任务).如归档类型的任务:[Jar](https://docs.gradle.org/current/dsl/org.gradle.api.tasks.bundling.Jar.html),[Tar](https://docs.gradle.org/current/dsl/org.gradle.api.tasks.bundling.Tar.html),[Zip](https://docs.gradle.org/current/dsl/org.gradle.api.tasks.bundling.Zip.html).特别的,归档的`destinationDir`,`baseName`和`version`属性是预先配置的默认值.这是非常有用的,因为它推动了跨项目的一致性;关于档案的命名规则和完成构建后的位置的一致性。 13 | 14 | #### java-base 15 | 16 | + 增加资源集的概念到项目中.不添加特定的资源. 17 | 18 | #### groovy-base 19 | 20 | + 增加了Groovy的源集理念到项目中. 21 | 22 | #### scala-base 23 | 24 | + 添加scala源集合概念到项目中. 25 | 26 | #### reporting-base 27 | 28 | + 为项目增加了一些涉及到生产报告的公约性质的属性, 29 | 30 | 31 | > 译者注:实在不会使用MarkDown在表格中加入列表,好在只表格只有两列,故本节不能按照官网的User Guide表格给出.而是以列表形式完成 32 | -------------------------------------------------------------------------------- /standard_gradle_plugins/incubating_integration_plugins.md: -------------------------------------------------------------------------------- 1 | # 孵化中的集成插件 2 | 3 | 这些插件提供的各种运行时的技术的集成. 4 | 5 | **Table 22.4. Incubating integration plugins** 6 | 7 | | Plugin Id | 自动应用 | 协同工作 | 描述 | 8 | | -- | -- | -- | -- | 9 | | [distribution](https://docs.gradle.org/current/userguide/distribution_plugin.html) | - | - | 对构建增加对ZIP和TAR的支持 | 10 | | [java-library-distribution](https://docs.gradle.org/current/userguide/javaLibraryDistribution_plugin.html) | java, distribution | - | 增加了对建筑ZIP和TAR的一个Java库的支持. | 11 | | [ivy-publish](https://docs.gradle.org/current/userguide/publishing_ivy.html) | - | java, war | 这个插件提供了一个新的DSL支持发布artifacts ivy存储库，它改善了现有的DSL. | 12 | | [maven-publish](https://docs.gradle.org/current/userguide/publishing_maven.html) | - | java, war | 这个插件提供了一个新的DSL支持发布artifacts Maven仓库，它改善了现有的DSL。 | 13 | -------------------------------------------------------------------------------- /standard_gradle_plugins/incubating_language_plugins.md: -------------------------------------------------------------------------------- 1 | # 孵化中的语言插件 2 | 3 | 这些插件增加对各种语言的支持: 4 | 5 | **Table 22.2. Language plugins** 6 | 7 | | Plugin Id | 自动应用 | 协同工作 | 描述 | 8 | | -- | -- | -- | -- | 9 | | [assembler](https://docs.gradle.org/current/userguide/nativeBinaries.html) | - | - | 增加了原生的汇编语言能力的项目。 | 10 | | [c](https://docs.gradle.org/current/userguide/nativeBinaries.html) | - | - | 添加C源代码编译能力的项目. | 11 | | [cpp](https://docs.gradle.org/current/userguide/nativeBinaries.html) | - | - | 增加C ++源代码编译能力的项目. | 12 | | [objective-c](https://docs.gradle.org/current/userguide/nativeBinaries.html) | - | - | 添加的Objective-C ++源代码编译能力的项目. | 13 | | [windows-resources](https://docs.gradle.org/current/userguide/nativeBinaries.html) | - | - | 增加了对包括Windows资源的本机二进制文件的支持. | 14 | -------------------------------------------------------------------------------- /standard_gradle_plugins/incubating_software_development_plugins.md: -------------------------------------------------------------------------------- 1 | # 孵化中的软件开发插件 2 | 3 | 这些插件在您的软件开发过程中提供帮助. 4 | 5 | **Table 22.6. Software development plugins** 6 | 7 | | Plugin Id | 自动应用 | 协同工作 | 描述 | 8 | | -- | -- | -- | -- | 9 | | [build-dashboard](https://docs.gradle.org/current/userguide/buildDashboard_plugin.html) | reporting-base | - | 生成构建仪表板报告. | 10 | | [build-init](https://docs.gradle.org/current/userguide/build_init_plugin.html) | wrapper | - | 对Gradle初始化一个新构建提供支持.将一个Maven构建转换为Gradle构建 | 11 | | [cnuit](https://docs.gradle.org/current/userguide/nativeBinaries.html) | - | - | 提供运行[CUnit](http://cunit.sourceforge.net/)测试支持 | 12 | | [jacoco](https://docs.gradle.org/current/userguide/jacoco_plugin.html) | reporting-base | java | 对面向Java的[JaCoCo](http://www.eclemma.org/jacoco/)代码库整合 | 13 | | [sonar-runner](https://docs.gradle.org/current/userguide/sonar_runner_plugin.html) | -| java-base, java, jacoco | 提供与[Sonar](http://www.sonarsource.org/)代码质量平台的整合.取代[sonar](https://docs.gradle.org/current/userguide/sonar_plugin.html)插件 | 14 | | [visual-studio](https://docs.gradle.org/current/userguide/nativeBinaries.html) | - | - | 增加了与Visual Studio集成. | 15 | | [wrapper](https://docs.gradle.org/current/userguide/wrapper_plugin.html) | - | - | 增加一个[Wrapper](https://docs.gradle.org/current/dsl/org.gradle.api.tasks.wrapper.Wrapper.html)任务来生成Gradle打包文件. | 16 | | [java-gradle-plugin](https://docs.gradle.org/current/userguide/javaGradle_plugin.html) | java | - | 通过提供标准的插件生成配置和验证,协助Gradle发展. | 17 | 18 | -------------------------------------------------------------------------------- /standard_gradle_plugins/integration_plugins.md: -------------------------------------------------------------------------------- 1 | # 集成插件 2 | 3 | 这些插件提供的各种运行时的技术的集成. 4 | 5 | **Table 22.3. Integration plugins** 6 | 7 | | Plugin Id | 自动应用 | 协同工作 | 描述 | 8 | | -- | -- | -- | -- | 9 | | [application](https://docs.gradle.org/current/userguide/application_plugin.html) | java, distribution | - | 增加了对运行绑定Java项目作为命令行应用的任务. | 10 | | [ear](https://docs.gradle.org/current/userguide/ear_plugin.html) | - | java | 增加了对构建J2EE应用程序的支持. | 11 | | [jetty](https://docs.gradle.org/current/userguide/jetty_plugin.html) | war | - | 在构建中嵌入Jetty web容器可以部署web应用.参见[Chapter 10, Web Application Quickstart](https://docs.gradle.org/current/userguide/web_project_tutorial.html) | 12 | | maven | - | java, war | 增加了对发布artifacts到Maven仓库的支持. | 13 | | [sogi](https://docs.gradle.org/current/userguide/osgi_plugin.html) | java-base | java | 增加了对构建OSGi支持 | 14 | | [war](https://docs.gradle.org/current/userguide/war_plugin.html) | java | - | 增加了对组装Web应用程序WAR文件的支持.参见[Chapter 10, Web Application Quickstart](https://docs.gradle.org/current/userguide/web_project_tutorial.html) | 15 | -------------------------------------------------------------------------------- /standard_gradle_plugins/language_plugins.md: -------------------------------------------------------------------------------- 1 | # 语言插件 2 | 3 | 这些插件添加了可以被编译并在JVM中执行的各种语言的支持 4 | 5 | **Table 22.1. Language plugins** 6 | 7 | | Plugin Id | 自动应用 | 协同工作 | 描述 | 8 | | -- | -- | -- | -- | 9 | | [java](https://docs.gradle.org/current/userguide/java_plugin.html) | java-base | - | 为项目添加java编译,测试及绑定能力,作为许多Gradle插件的基础.参见[Chapter 7, Java Quickstart](https://docs.gradle.org/current/userguide/tutorial_java_projects.html) | 10 | | [groovy](https://docs.gradle.org/current/userguide/groovy_plugin.html) | java, groovy-base | - | 为Groovy项目构建增加支持,参见[Chapter 9, Groovy Quickstart](https://docs.gradle.org/current/userguide/tutorial_groovy_projects.html) | 11 | | [scala](https://docs.gradle.org/current/userguide/scala_plugin.html) | java, scala-base | - | 增加了对Scala项目构建的支持 | 12 | | [antlr](https://docs.gradle.org/current/userguide/antlr_plugin.html) | java | - | 增加了对使用ANTLR的生成解析器的支持. | 13 | 14 | 15 | -------------------------------------------------------------------------------- /standard_gradle_plugins/software_development_plugins.md: -------------------------------------------------------------------------------- 1 | # 软件开发插件 2 | 3 | 这些插件在您的软件开发过程中提供帮助. 4 | 5 | **Table 22.5. Software development plugins** 6 | 7 | | Plugin Id | 自动应用 | 协同工作 | 描述 | 8 | | -- | -- | -- | -- | 9 | | [announce](https://docs.gradle.org/current/userguide/announce_plugin.html) | - | - | 消息发布到自己喜欢的平台，如Twitter或Growl. | 10 | | [build-announcements](https://docs.gradle.org/current/userguide/build_announcements_plugin.html) | announce | - | 发送本地通知关于有趣的事件在构建生命周期到你的桌面. | 11 | | [checkstyle](https://docs.gradle.org/current/userguide/checkstyle_plugin.html) | java-base | - | 使用[Checksytle](http://checkstyle.sourceforge.net/index.html)对项目的Java源码执行质量检测,并生成报告. | 12 | | [codenarc](https://docs.gradle.org/current/userguide/codenarc_plugin.html) | groovy-base | - | 使用[CodeNarc](http://codenarc.sourceforge.net/index.html)对项目的Groovy的源文件进行质量检测,并生成检测报告 | 13 | | [eclipse](https://docs.gradle.org/current/userguide/eclipse_plugin.html) | - | java,groovy, scala | 生成Eclipse IDE的文件,从而能够以导入项目到Eclipse.参见[Chapter 7, Java Quickstart](https://docs.gradle.org/current/userguide/tutorial_java_projects.html) | 14 | | [eclipse-wtp](https://docs.gradle.org/current/userguide/eclipse_plugin.html) | - | ear, war | 与eclipse插件一样,生成eclipse WPT(Web Tools Platform)配置文件, 导入到Eclipse中war/ear项目应配置与WTP工作.参见参见[Chapter 7, Java Quickstart](https://docs.gradle.org/current/userguide/tutorial_java_projects.html)| 15 | | [findbugs](https://docs.gradle.org/current/userguide/findbugs_plugin.html) | java-base | - | 使用[FindBugs](http://findbugs.sourceforge.net/)执行项目的Java源文件质量检测,并生成检测报告 | 16 | | [idea](https://docs.gradle.org/current/userguide/idea_plugin.html) | - | java | 生成[Intellij IDEA IDE](http://www.jetbrains.com/idea/index.html)配置文件,从而可以将项目导入IDEA。 | 17 | | [jdepend](https://docs.gradle.org/current/userguide/jdepend_plugin.html) | java-base | - | 使用[JDepend](http://clarkware.com/software/JDepend.html)执行项目的源文件质量检测,并生成检测报告 | 18 | | [pmd](https://docs.gradle.org/current/userguide/pmd_plugin.html) | java-base | - | 使用[PMD](http://pmd.sourceforge.net/)执行项目的源文件质量检测,并生成检测报告 | 19 | | [project-report](https://docs.gradle.org/current/userguide/project_reports_plugin.html) | reporting-base | - | 生成一个包含关于您的Gradle构建有用信息的报告。 | 20 | | [signing](https://docs.gradle.org/current/userguide/signing_plugin.html) | base | - | 添加数字签名档案和artifacts的能力。 | 21 | | [sonar](https://docs.gradle.org/current/userguide/sonar_plugin.html) | - | java-base, java, jacoco | 与[Sonar](http://www.sonarsource.org/)代码质量平台整合.由[sonar-runner](https://docs.gradle.org/current/userguide/sonar_runner_plugin.html)插件提供 | 22 | 23 | -------------------------------------------------------------------------------- /standard_gradle_plugins/third_party_plugins.md: -------------------------------------------------------------------------------- 1 | # 第三方插件 2 | 3 | 你可以在[Gradle Plugins site]()找到外部插件. 4 | -------------------------------------------------------------------------------- /the_gradle_daemon/README.md: -------------------------------------------------------------------------------- 1 | # The Gradle Daemon 2 | 3 | -------------------------------------------------------------------------------- /the_gradle_daemon/how_can_i_stop_a_daemon.md: -------------------------------------------------------------------------------- 1 | # 如何停止守护进程 2 | 3 | 守护进程会在闲置3小时后自动终止.如果想在这之前停止守护进程,也可以通过操作系统运行`gradle --stop`命令终止后台进程.`--stop`选项会要求*所有*运行*相同版本*的守护进程终止. 4 | 5 | 6 | -------------------------------------------------------------------------------- /the_gradle_daemon/how_do_i_disable_the_gradle_daemon.md: -------------------------------------------------------------------------------- 1 | # 如何禁用Gradle的守护进程 2 | 3 | 一般Gradle守护进程默认不启用.然而,一旦它被启用,有事希望对某些项目或某些构建禁用守护进程. 4 | 5 | `--no-daemon`命令行选项可用于强制守护进程不能用于该构建.这很少使用,但是在调试具有一定的构建或Gradle插件问题时,有时会很有用.在构建环境中,此命令行选项具有*最高*优先级. 6 | 7 | 8 | -------------------------------------------------------------------------------- /the_gradle_daemon/how_do_i_enable_the_gradle_daemon.md: -------------------------------------------------------------------------------- 1 | # 如何启动Gradle的守护进程 2 | 3 | 在使用Gradle命令行接口时,`--daemon`和`--no-daemon`命令行选项调用在单个构建时选择启用或禁用后台守护进程.通常,允许后台守护进程在一个环境中(例如一个用户账户)更为方便,可以使所有构建使用守护进程,而不需要记住`--daemon`开关. 4 | 5 | 6 | 有两种推荐的方式使守护进程持续与环境： 7 | 8 | 1. 通过环境变量 - 给`GRADLE_OPTS`环境变量添加`-Dorg.gradle.daemon=true`标识 9 | 2. 通过属性文件 - 给`<>/gradle.properties`文件添加`org.gradle.daemon=true` 10 | 11 | > 注意:`<>`默认为`<>/.gradle`,`<>为当前用户home目录`,这个位置可以通过`-g`和`-gradle-user-home`命令行选项,以及由`GRADLE_USER_HOME`环境变量`org.gradle.user.home` JVM系统属性配置。 12 | 13 | 这两种方法有同样的效果,使用哪一个是由个人喜好.大多数Gradle用户选择第二个方式,给gradle.properties并添加条目. 14 | 15 | 在Windows中，该命令将使当前用户启用守护： 16 | 17 | `(if not exist "%HOMEPATH%/.gradle" mkdir "%HOMEPATH%/.gradle") && (echo foo >> "%HOMEPATH%/.gradle/gradle.properties")` 18 | 19 | 在类Unix操作系统，以下的Bash shell命令将使当前用户启用守护进程： 20 | 21 | `touch ~/.gradle/gradle.properties && echo "org.gradle.daemon=true" >> ~/.gradle/gradle.properties` 22 | 23 | 一旦以这种方式在构建环境中启用了守护进程,所有的构建将隐含一个守护进程. 24 | 25 | -------------------------------------------------------------------------------- /the_gradle_daemon/how_do_i_suppress_the_please_consider_using_the_gradle_daemon_message.md: -------------------------------------------------------------------------------- 1 | # 怎样抑制“please consider using the Gradle Daemon”消息 2 | 3 | Gradle可能会在构建结束时发出建议您使用Gradle守护进程的末尾警告.为了避免这个警告,您可以通过上述的这些方法使用守护进程,或者明确禁用守护进程.您可以通过上述的`--no daemon`的命令行选项明确禁用守护进程,或使用上述的`org.gradle.deamon`的值设置为`false`代替`trie`. 4 | 5 | 因为不建议在持续集成构建中使用守护进程,如果`CI`环境变量已存在,Gradle不会发出此消息. 6 | -------------------------------------------------------------------------------- /the_gradle_daemon/how_does_the_gradle_daemon_make_builds_faster.md: -------------------------------------------------------------------------------- 1 | # 摇篮守护进程如何使构建速度更快 2 | 3 | Gradle守护进程是一个*常驻*构建进程.在两个构建之间的空闲期间会等待着下次构建.与每个构建加载Gradle到内存相比,对于多个构建只需要加载一次Gradle到内存具有明显的好处.这本身就是对性能的显著优化,但是不止这些. 4 | 5 | 现代JVM的显著优化是运行时代码优化.例如,热点(HotSpot)(由Oracle提供并作为OpenJDK的基础的JVM实现)适用于优化运行时代码.优化是渐进的，而不是瞬间的。也就是说,代码在运行期间逐步优化,这意味着后续版本纯粹是基于这个优化过程变得更快.HotSpot实验表明,它需要5至10某处构建以优化至稳定.在一个守护进程的第一个构建和第十之间感知的编译时间的差异可以说是相当巨大的. 6 | 7 | 守护程序还允许更有效地在内存中缓存整个构建。例如，需要构建（如插件，构建脚本）的类可以在内存中举行的构建。同样，摇篮可保持在内存中缓存的构建数据的诸如的任务输入和输出的哈希值，用于增量构建。 8 | 9 | 10 | -------------------------------------------------------------------------------- /the_gradle_daemon/how_much_memory_does_the_daemon_use_and_can_i_give_it_more.md: -------------------------------------------------------------------------------- 1 | # 守护进程占用多大内存并且能不能给它更大的内存? 2 | 3 | 如果需求构建环境没有指定最大堆内存,守护进程会使用多达1G的堆内存.它将会使用默认的JVM的最小堆内存.1G内存足够应付大多数构建.有数百个子项的构建,大量配置或者源码需求,或者要求有更好的表现,则需要更多地内存 4 | 5 | 为了提高守护进程可以使用的内存,指定相应的标志作为需求构建环境的一部分,请参见[Chapter 20. The Build Environment](https://docs.gradle.org/current/userguide/build_environment.html)的详细信息. 6 | 7 | 8 | -------------------------------------------------------------------------------- /the_gradle_daemon/management_and_configuration.md: -------------------------------------------------------------------------------- 1 | # 管理和配置 2 | -------------------------------------------------------------------------------- /the_gradle_daemon/potential_future_enhancements.md: -------------------------------------------------------------------------------- 1 | # 未来可能的改进 2 | 3 | 目前，守护使构建速度更快有效地支持在内存中缓存和由JVM优化使代码更快。在未来的Gradle版本中，守护进程将变得更加聪明，预先完成工作。它可能，例如，在编辑完构建脚本后就开始下载依赖生成是将要运行的假设下后立即和新改变或添加的依赖性是必需的。 4 | 5 | 有许多方式使得在未来的版本的gradle的gradle守护进程。 6 | 7 | 8 | 9 | -------------------------------------------------------------------------------- /the_gradle_daemon/tools_&_ides.md: -------------------------------------------------------------------------------- 1 | # 工具和集成开发环境 2 | 3 | Gradle工具API(参见[Chapter.65.Embedding Gradle](https://docs.gradle.org/current/userguide/embedding.html)),用于IDEs和其他工具整合Gradle,*总*是使用Gradle守护进程执行构建.如果你是从IDE内部执行构建,那么你是在使用守护进程,而且不需要在你的环境中允许Gradle守护进程. 4 | 5 | 但是，除非您已明确启用的Gradle守护进程在你的环境的,你在命令行中的构建不会使用摇篮守护进程。 6 | -------------------------------------------------------------------------------- /the_gradle_daemon/what_can_go_wrong_with_daemon.md: -------------------------------------------------------------------------------- 1 | # 守护进程何时会出错 2 | 3 | 许多工程设计已经加入守护进程使得守护进程在日常的开发中变得更加健壮,透明和不起眼.无论如何,守护进程偶尔也会损坏或者枯竭.一个Gradle构建执行源自多个来源的任意代码.即使Gradle本身与守护进程的设计是经过严格的测试的,但是用户的构建脚本,或第三方插件可以通过诸如内存泄露,或腐化全局声明等缺陷来动摇守护进程. 4 | 5 | 另外,也可以通过构建时进行不正确的资源释放,也可能会动摇守护进程(构建环境正常).在在Microsoft Windows下是一个特别尖锐的问题,在程序读写文件后关闭失败的处理是非常随意的. 6 | 7 | 如果出现守护进程不稳定情况,可以简单的终止.回顾一下`--no-daemon`的选项可以用于构建阻止使用守护进程,这对于检验一个问题的罪魁祸首是不是守护进程很有帮助. 8 | 9 | 10 | 11 | -------------------------------------------------------------------------------- /the_gradle_daemon/what_is_the_gradle_daemon.md: -------------------------------------------------------------------------------- 1 | # 什么是 Gradle 的守护进程 2 | 3 | 维基百科中守护进程的解释 4 | 5 | > *守护进程是一个运行后台进程, 非交互式用户直接控制的在计算机程序* 6 | 7 | Gradle 守护进程是一个后台进程, 8 | 它运行着繁重的构建, 然后在构建等待下一次构建的之间保持自身存在. 这使得数据和代码在下一次构建前已经准备好,并存入内存中. 这*显著*的提高了后续构建的性能. 启用Gradle守护进程是一种节约构建时间的廉价方式. 9 | 10 | *强烈建议在所有开发机器上启用Gradle的守护进程*.但是*不推荐*在持续集成和构建服务器环境下启用守护进程(参见 [Section 18.3, “When should I not use the Gradle Daemon?”](https://docs.gradle.org/current/userguide/gradle_daemon.html#when_should_i_not_use_the_gradle_daemon)). 11 | 12 | Gradle自动管理守护进程.如果构建环境配置为利用后台程序,如果在没有可用守护进程,就会自动启动一个守护进程,或者使用现有的空闲的*兼容*守护进程.如果一个守护进程在3个小时内没有使用,它将会自我终结.一旦配置开发环境为使用的守护进程,守护进程通常是隐形的,容易被遗忘的. 13 | 14 | 15 | 16 | 17 | -------------------------------------------------------------------------------- /the_gradle_daemon/when_should_i_not_use_the_gradle_daemon.md: -------------------------------------------------------------------------------- 1 | # 什么时候不使用Gradle守护进程 2 | 3 | 建议在开发环境中使用Gradle的守护进程,*不建议*在持续集成环境和构建服务器环境中使用守护进程. 4 | 5 | 守护进程可以更快的构建,这对于一个正坐在椅子前构建项目的人来说非常重要.对于CI构建来说,稳定性和可预见性是最重要的.为每个构建运行时用一个新的,完全孤立于以前的版本的程序,更加可靠。 6 | -------------------------------------------------------------------------------- /the_gradle_daemon/why_is_there_more_than_one_daemon_process_on_my_machine.md: -------------------------------------------------------------------------------- 1 | # 为什么会在机器上出现不只一个守护进程 2 | 3 | 有几个原因Gradle会创建一个新的守护进程代替使用一个已存在的守护进程.如果守护进程没有*闲置*,*兼容*,则会启动一个新的守护进程. 4 | 5 | *空闲*的守护进程是当前未执行构建或做其他有用的工作. 6 | 7 | *兼容*的守护进程是一个可以（或者可以达到）满足要求的编译环境的要求。Java安装程序运行的构建是构建环境方面的一个例子。构建运行时所需的JVM系统属性是另一个例子。 8 | 9 | 一个已经运行的Java进程可能不能满足所需的构建环境的某些方面。如果守护进程由Java7启动，但要求的环境要求为Java8,则守护进程是不兼容的，必须另外启动。再者，在运行的JVM不能改变一个运行时的某些性能。如内存分配（如-Xmx1024m），默认文本编码运行的JVM中，默认的语言环境，等等一个JVM不能改变的运行环境。 10 | 11 | "Required build environment"通常在构建客户端(如Gradle命令行,IDE等)方面隐含构建环境,并明确通过命令行选项设置.参见[Chapter 20,The Build Environment](https://docs.gradle.org/current/userguide/build_environment.html)有关如何指定和控制构建环境的详细信息. 12 | 13 | 一下JVM系统属性是有效不变的.如果需求编译环境需要这些属性,不同的守护进程JVM在下列属性中有不同的值时,守护进程不兼容. 14 | 15 | + file.encoding 16 | + user.language 17 | + user.country 18 | + user.variant 19 | + com.sun.management.jmxremote 20 | 21 | 下列JVM属性,通过启动参数控制,也是有效不变的.在需求构建环境和守护进程环境的对应属性必须按顺序完全匹配,才可兼容. 22 | 23 | + 最大堆大小(即 -Xmx JVM参数) 24 | + 最小堆大小(即 -Xms JVM参数) 25 | + 引导类路径(即 -Xbootclasspath JVM参数) 26 | + "assertion"状态(即 -ea 参数) 27 | 28 | 所需的Gradle版本是需求构建环境的另一个方面.守护进程被耦合到特定Gradle运行时,多个正在运行的守护进程产生的原因是使用使用不同版本的Gradle会在会话过程中处理多个项目. 29 | 30 | 31 | 32 | -------------------------------------------------------------------------------- /the_java_plugin/README.md: -------------------------------------------------------------------------------- 1 | # 第 22 章 Java 插件 2 | 3 | Java 插件给项目增加了编译, 4 | 测试以及打包的能力, 5 | Gradle 的许多其他插件都需要以 Java 插件为基础. 6 | -------------------------------------------------------------------------------- /the_java_plugin/java_plugin_clean.md: -------------------------------------------------------------------------------- 1 | ## 22.9.Clean 2 | 3 | clean 任务是一个 [Delete](https://docs.gradle.org/current/dsl/org.gradle.api.tasks.Delete.html) 的实例. 它只是删除 dir 属性指定的目录. 4 | 5 | **表22.11.java 插件 - Clean 的属性** 6 | 7 | 任务属性 | 类型 | 默认值 8 | ---- | ---- | -------- 9 | dir | File | buildDir 10 | -------------------------------------------------------------------------------- /the_java_plugin/java_plugin_compile_java.md: -------------------------------------------------------------------------------- 1 | ## 22.11.编译 java 2 | java 插件为项目的每一个 source set 增加了一个 [JavaCompile](https://docs.gradle.org/current/dsl/org.gradle.api.tasks.compile.JavaCompile.html) 实例, 最常见的配置选项如下所示: 3 | 4 | **表22.13.java 插件-编译配置** 5 | 6 | 任务属性 | 类型 | 默认值 7 | -------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------- 8 | classpath | [FileCollection](https://docs.gradle.org/current/javadoc/org/gradle/api/file/FileCollection.html) | sourceSet.compileClasspath 9 | source | [FileTree](https://docs.gradle.org/current/javadoc/org/gradle/api/file/FileTree.html),可以在[Section 15.6, “Copying files”](https://docs.gradle.org/current/userguide/working_with_files.html#sec:copying_files)中查看可以设置什么. | sourceSet.java 10 | destinationDir | File.| sourceSet.output.classesDir 11 | 12 | 默认情况下 java 的编译运行在 Gradle 中的进程. 设置 option.fork 为 true 会使编译在一个单独的进程中运行,在Ant中运行 javac任务意味着一个新进程将被拆封为多个编译任务，这会减慢编译。相反的,Gradle的直接编译集成（见上文）在编译过程中将尽可能地重复使用相同的进程.在所有情况下由options.forkOptions指定的选项会被实现. 13 | -------------------------------------------------------------------------------- /the_java_plugin/java_plugin_compilejava.md: -------------------------------------------------------------------------------- 1 | # Java Plugin CompileJava 2 | -------------------------------------------------------------------------------- /the_java_plugin/java_plugin_convention_properties.md: -------------------------------------------------------------------------------- 1 | # 公共属性 2 | 3 | Java 插件会为项目添加一系列的公共属性, 如下所示, 你可以在构建脚本中像项目属性那样直接使用它们 (see [???](https://docs.gradle.org/current/userguide/java_plugin.html)). 4 | 5 | **表22.7.Java插件-目录属性** 6 | 7 | 属性名称 | 类型 | 默认值 | 描述 8 | ----- | ---- | ---- | ---- 9 | reportsDirName | String | reports | 在构建目录的生成报告的文件夹名 10 | reportsDir | File (read-only) | buildDir/reportsDirName | 该目录下会生成报告 11 | testResultsDirName | String | test-results | 在构建目录的测试结果的result.xml的存放目录名 12 | testResultsDir | File (read-only) | buildDir/testResultsDirName | 测试结果的 result.xml 文件会存放在该文件夹中 13 | testReportDirName | String |tests | 在构建目录的测试报告的文件夹名 14 | testReportDir | File (read-only) | reportsDir/testReportDirName | 测试的测试报告会存放在该目录下 15 | libsDirName | String | libs | 在构建目录下的类库文件夹名 16 | libsDir | File (read-only) | buildDir/libsDirName | 该目录下存放类库 17 | distsDirName | String | distributions | 在构建目录下的distributions文件夹名 18 | distsDir | File (read-only) | buildDir/distsDirName | 该目录下存放生成的distributions 19 | docsDirName | String | 在构建目录下的doc文件夹名 20 | docsDir | File (read-only) | buildDir/docsDirName | 该目录下存放生成的文档 21 | dependencyCacheDirName | String | dependency-cache | 在构建目录下的依赖缓存文件夹名 22 | dependencyCacheDir | File (read-only) | buildDir/dependencyCacheDirName | 该目录用来缓存源依赖信息。 23 | 24 | **表22.8.Java插件-其他配置** 25 | 26 | 属性名称 | 类型 | 默认值 | 描述 27 | ----- | ---- | ---- | ---- 28 | sourceSets | [SourceSetContainer](https://docs.gradle.org/current/javadoc/org/gradle/api/tasks/SourceSetContainer.html) | Not null | 包含项目的资源设置 29 | sourceCompatibility | [JavaVersion](https://docs.gradle.org/current/javadoc/org/gradle/api/JavaVersion.html).也可以使用String类型或Number类型,如'1.5' 或 1.5 | 当前使用的JVM版本 | 编译Java源码时所使用的Java兼容版本 30 | targetCompatibility | [JavaVersion](https://docs.gradle.org/current/javadoc/org/gradle/api/JavaVersion.html).也可以使用String类型或Number类型,如'1.5' 或 1.5 | sourceCompatibility | 生成class文件的Java版本 31 | archivesBaseName | String | projectName | 用于.jar文件或者.zip存档的基本名称 32 | manifest | [Mainfest](https://docs.gradle.org/current/javadoc/org/gradle/api/java/archives/Manifest.html) | an empty manifest | 该清单中包括所有的JAR文件 33 | 34 | 按照[JavaPluginConvention](https://docs.gradle.org/current/dsl/org.gradle.api.plugins.JavaPluginConvention.html)和[BasePluginConvention](https://docs.gradle.org/current/dsl/org.gradle.api.plugins.BasePluginConvention.html)类型提供这些属性. 35 | -------------------------------------------------------------------------------- /the_java_plugin/java_plugin_defining_new_source_sets.md: -------------------------------------------------------------------------------- 1 | ### 22.7.2.定义一个新的 source set 2 | 3 | 要定义一个新的源组, sourceSets {} 块中引用它.下面是一个例子： 4 | 5 | **例22.5.定义一个新的 source set** 6 | 7 | **build.gradle** 8 | 9 | ``` 10 | sourceSets { 11 | intTest 12 | } 13 | ``` 14 | 15 | 当你定义一个新的 source set, java 插件会为该 source set 添加一些如[Table 22.6, "Java plugin - source set dependency configurations"](https://docs.gradle.org/current/userguide/java_plugin.html#java_source_set_configurations)中所示的依赖配置关系.可以使用这些配置来定义source set的编译和运行时依赖。 16 | 17 | **例22.6.定义 source set 的依赖** 18 | 19 | **build.gradle** 20 | 21 | ``` 22 | sourceSets { 23 | intTest 24 | } 25 | 26 | dependencies { 27 | intTestCompile 'junit:junit:4.12' 28 | intTestRuntime 'org.ow2.asm:asm-all:4.0' 29 | } 30 | ``` 31 | 32 | java 插件增加了一些如[Table 22.2, "Java plugin - source set tasks"](https://docs.gradle.org/current/userguide/java_plugin.html#java_source_set_tasks)为该source set组装classes文件的任务,例如，对于一个叫intTest的source set，为此source set编译classes任务运行`gradle intTestClasses`完成。 33 | 34 | **例22.7.编译一个 source set** 35 | 36 | `gradle intTestClasses`命令的输出 37 | 38 | ``` 39 | > gradle intTestClasses 40 | :compileIntTestJava 41 | :processIntTestResources 42 | :intTestClasses 43 | 44 | BUILD SUCCESSFUL 45 | 46 | Total time: 1 secs 47 | ``` 48 | -------------------------------------------------------------------------------- /the_java_plugin/java_plugin_dependency_management.md: -------------------------------------------------------------------------------- 1 | # 依赖管理 2 | 3 | Java 插件给项目增加了许多关于依赖的配置, 如下所示, 这些配置被分配给许多任务, 比如 compileJava 和 test 等配置 4 | 5 | **表22.5.Java插件-依赖配置** 6 | 7 | 名称 | 扩展 | 被使用时运行的任务 | 含义 8 | --------- | ---------- | ---- | ----------- 9 | compile | - | compileJava | 编译时的依赖 10 | runtime | compile | - | 运行时的依赖 11 | testCompile | compile | compileTestJava | 编译测试所需的额外依赖 12 | testRuntime | runtime | test | 仅供运行测试的额外依赖 13 | archives | - | uploadArchives | 项目产生的信息单元（如:jar包） 14 | default | runtime | - | 使用其他项目的默认依赖项，包括该项目产生的信息单元以及依赖 15 | 16 | **图22.2.Java插件-依赖配置** 17 | ![java plugin-dependency configurations](https://docs.gradle.org/current/userguide/img/javaPluginConfigurations.png) 18 | 19 | 对于每个添加到该项目的资源设置，java 插件会添加以下的依赖配置 20 | 21 | **表22.6.Java插件-资源设置依赖关系配置** 22 | 23 | 名称 | 扩展 | 被使用时运行的任务 | 含义 24 | --------- | ---------- | ---- | ----------- 25 | sourceSetCompile | - | compileSourceSetJava | 编译时给定资源设置的依赖 26 | sourceSetRuntime | - | - |运行时给定资源设置的依赖 27 | 28 | -------------------------------------------------------------------------------- /the_java_plugin/java_plugin_incremental_java_compilation.md: -------------------------------------------------------------------------------- 1 | ## 22.12.增量Java编译 2 | 3 | 从Gradle2.1开始,可以使用Java增量编译,此功能正在孵化,参见[JavaCompile](https://docs.gradle.org/current/dsl/org.gradle.api.tasks.compile.JavaCompile.html)如何启用这个功能. 增量编译的主要目标如下: 4 | - 避免在没必要编译的java编译资源上浪费时间.这意味着更快构建,尤其是在改变一些class与jar的时候,不需要再次编译那些不依赖这些class与jar的文件. 5 | - 尽可能地少输出class.类不需要重新编译意味着保持输出目录不变。一个示例场景中，真正使用JRebel的真正有用的是 - 越少的输出类被改变，JVM可以使用越快刷新。 6 | 7 | 更高级的增量编译: 8 | - 检测陈旧类的设置是否正确是以牺牲速度为代价的,该算法分析字节码并与编译器直接交互(非私有常量内联),依赖传递等.举个例子:当一个类的公共常量改变后,我们希望避免由编译器编译内联常数产生的问题,我们将调整算法和缓存以便增量Java编译可以是每编译任务的默认设置。 9 | - 为了使增量编译快，我们缓存会分析class的结果和jar快照。最初的增量编译应该会慢于cold caches. 10 | -------------------------------------------------------------------------------- /the_java_plugin/java_plugin_jar.md: -------------------------------------------------------------------------------- 1 | ## 22.14.Jar 2 | 3 | jar 任务创建包含项目的类文件和资源的 JAR 文件. JAR 文件在 archives 的依赖配置中是作为一个 artifact 的声明. 这意味着, JAR 是相关项目一个可用的 classpath. 如果您上传您的项目到存储库, 这个 JAR 会被声明为依赖描述符的一部分. 可以再[Section 15.8, “Creating archives”](https://docs.gradle.org/2.4/userguide/working_with_files.html#sec:archives)与[Chapter 51, Publishing artifacts](https://docs.gradle.org/2.4/userguide/artifact_management.html)中了解更多关于 JAR 与 archives 与 artifact configurations 协同工作的更多细节. 4 | -------------------------------------------------------------------------------- /the_java_plugin/java_plugin_javadoc.md: -------------------------------------------------------------------------------- 1 | ## 22.8.Javadoc 2 | 3 | Javadoc task 是 [Javadoc](https://docs.gradle.org/current/dsl/org.gradle.api.tasks.javadoc.Javadoc.html) 的一个实例. 它支持 Javadoc 的核心选项和可执行的 Javadoc 的 [reference documentation](http://download.oracle.com/javase/1.5.0/docs/tooldocs/windows/javadoc.html#referenceguide) 中描述的标准 J avaTOC 的选项. 有关支持 Javadoc 选项的完整列表, 请参阅以下类的API文档：[CoreJavadocOptions](https://docs.gradle.org/current/javadoc/org/gradle/external/javadoc/CoreJavadocOptions.html) 和 [StandardJavadocDocletOptions](https://docs.gradle.org/current/javadoc/org/gradle/external/javadoc/StandardJavadocDocletOptions.html). 4 | 5 | **表22.10.java 插件- javadoc 配置** 6 | 7 | 任务属性 | 类型 | 默认值 8 | -------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------- 9 | classpath | [FileCollection](https://docs.gradle.org/current/javadoc/org/gradle/api/file/FileCollection.html) | sourceSets.main.output + sourceSets.main.compileClasspath 10 | source | [FileTree](https://docs.gradle.org/current/javadoc/org/gradle/api/file/FileTree.html).可以设置为在[Section 15.5, “Specifying a set of input files”](https://docs.gradle.org/current/userguide/working_with_files.html#sec:specifying_multiple_files)中描述的任何值 | sourceSets.main.allJava 11 | destinationDir | File | docsDir/javadoc 12 | title | String | project 的 name 和 version 13 | -------------------------------------------------------------------------------- /the_java_plugin/java_plugin_manifest.md: -------------------------------------------------------------------------------- 1 | ### 22.14.1.Manifest 2 | 3 | 每个 jar 或 war 对象有一个 manifest 属性做为[Manifest](https://docs.gradle.org/2.4/javadoc/org/gradle/api/java/archives/Manifest.html)单独的实例, 4 | 当生成存档, 一个对应MANIFEST.MF文件被写入到档案中. 5 | 6 | **例22.15.MANIFEST.MF的定​​制** 7 | **build.gradle** 8 | ``` 9 | jar { 10 | manifest { 11 | attributes("Implementation-Title": "Gradle", 12 | "Implementation-Version": version) 13 | } 14 | } 15 | ``` 16 | 你可以创建一个 manifest 的独立实例. 17 | 您可以使用如共享 jar 之间的 manifest 的信息. 18 | 19 | **例22.16.创建一个manifest对象** 20 | **build.gradle** 21 | ``` 22 | ext.sharedManifest = manifest { 23 | attributes("Implementation-Title": "Gradle", 24 | "Implementation-Version": version) 25 | } 26 | task fooJar(type: Jar) { 27 | manifest = project.manifest { 28 | from sharedManifest 29 | } 30 | } 31 | ``` 32 | 您可以合并其他 manifest 到任何 Manifest 对象. 其它清单可能是通过文件路径描述或着像上所述, 引用另一个Manifest对象. 33 | 34 | **例22.17.独立的MANIFEST.MF一个特定的归档** 35 | **build.gradle** 36 | ``` 37 | task barJar(type: Jar) { 38 | manifest { 39 | attributes key1: 'value1' 40 | from sharedManifest, 'src/config/basemanifest.txt' 41 | from('src/config/javabasemanifest.txt', 42 | 'src/config/libbasemanifest.txt') { 43 | eachEntry { details -> 44 | if (details.baseValue != details.mergeValue) { 45 | details.value = baseValue 46 | } 47 | if (details.key == 'foo') { 48 | details.exclude() 49 | } 50 | } 51 | } 52 | } 53 | } 54 | ``` 55 | 清单合并的顺序与声明语句的顺序相同,如果基本清单和合并的清单都为相同的密钥定义值，那么那么合并清单将会被合并,您可以通过添加在其中您可以使用一个[ManifestMergeDetails](https://docs.gradle.org/2.4/javadoc/org/gradle/api/java/archives/ManifestMergeDetails.html)实例为每个条目实体完全自定义的合并行为。声明不会立即被来自触发合并。这是延迟执行的，要么产生jar时，或要求写入effectiveManifest时. 56 | 你可以很容易地写一个清单到磁盘。 57 | **例22.17.独立的MANIFEST.MF一个特定的存档** 58 | **build.gradle** 59 | ``` 60 | jar.manifest.writeTo("$buildDir/mymanifest.mf") 61 | ``` 62 | -------------------------------------------------------------------------------- /the_java_plugin/java_plugin_project_layout.md: -------------------------------------------------------------------------------- 1 | # 项目布局 2 | 3 | Java 插件的默认布局如下图所示, 无论这些文件夹中有没有内容, Java 插件都会编译里面的内容, 并处理任何缺失的内容. 4 | 5 | **表22.4.java 插件-默认布局** 6 | 7 | 目录 | 含义 8 | --— | --- 9 | src/main/java | 主要 Java 源码 10 | src/main/resources | 主要资源 11 | src/test/java | 测试 Java 源码 12 | src/test/resources | 测试资源 13 | src/sourceSet/java | 指定资源设置的 Java 源码 14 | src/sourceSet/resources | 指定资源设置的资源 15 | 16 | ### 1. 改变项目布局 17 | 18 | 可以通过配置适当的资源设置来配置项目布局, 更多细节会在后面的章节中讨论, 下面是一个配置了 java 和 resource 的简单的例子 19 | 20 | 21 | **例22.2.自定义 Java 源码布局** 22 | 23 | **build.gradle** 24 | 25 | ``` 26 | sourceSet{ 27 | main{ 28 | java{ 29 | srcDir 'src/java' 30 | } 31 | resources{ 32 | srcDir 'src/resources' 33 | } 34 | } 35 | } 36 | ``` 37 | -------------------------------------------------------------------------------- /the_java_plugin/java_plugin_resources.md: -------------------------------------------------------------------------------- 1 | ## 22.10.资源 2 | 3 | Java 插件使用 [Copy](https://docs.gradle.org/current/dsl/org.gradle.api.tasks.Copy.html) 任务处理资源. 它为项目每个 source set 都增加了一个实例. 可以参考[Section 15.6, "Copying files"](https://docs.gradle.org/current/userguide/working_with_files.html#sec:copying_files) 获取关于copy任务的信息. 4 | 5 | **表22.12.java 插件- ProcessResources 的属性** 6 | 7 | 任务属性 | 类型 | 默认值 8 | -------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------- 9 | srcDirs | Object.可以在[Section 15.5, “Specifying a set of input files”](https://docs.gradle.org/current/userguide/working_with_files.html#sec:specifying_multiple_files)中查看使用什么 | sourceSet.resources 10 | destinationDir | File.可以再[Section 15.1, “Locating files”](https://docs.gradle.org/current/userguide/working_with_files.html#sec:locating_files)查看使用什么 | sourceSet.output.resourcesDir 11 | -------------------------------------------------------------------------------- /the_java_plugin/java_plugin_source_set_properties.md: -------------------------------------------------------------------------------- 1 | ### 22.7.1.Source Set 属性 2 | 下表列出了 Source Set 的一些重要属性, 更多细节请查看 [SourceSet](https://docs.gradle.org/current/dsl/org.gradle.api.tasks.SourceSet.html) 的 API 文档. 3 | 4 | **表22.9.java 插件- Source Set 属性** 5 | 6 | 配置名称 | 类型 | 默认值 | 描述 7 | ------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------- | -------------------------------------------------------------------------------------------- 8 | name | String (read-only) | Not null | 用来识别source set的名称 9 | output | [SourceSetOutput](https://docs.gradle.org/current/dsl/org.gradle.api.tasks.SourceSetOutput.html)(read-only) | Not null | source set的输出文件,包含其编译的classes和resources 10 | output.classesDir | File | buildDir/classes/name | 在该目录下生成存放这个source set的classes文件 11 | output.resourcesDir | File | buildDir/resources/name | 在该目录下生成存放这个source set的resources文件 12 | compileClasspath | [FileCollection](https://docs.gradle.org/current/javadoc/org/gradle/api/file/FileCollection.html) | compileSourceSet configuration | 这个source set编译时使用的classpath 13 | runtimeClasspath | [FileCollection](https://docs.gradle.org/current/javadoc/org/gradle/api/file/FileCollection.html) | output + runtimeSourceSet configuration | 执行当前source set的classes文件时的classpath 14 | java | [SourceDirectorySet](https://docs.gradle.org/current/javadoc/org/gradle/api/file/SourceDirectorySet.html)(read-only) | Not null | 当前source set的java源文件,仅包含存在于java目录下的所有.java文件,排除其他任何文件. 15 | java.srcDirs | Set.可以设置为在[Section 15.5, “Specifying a set of input files”](https://docs.gradle.org/current/userguide/working_with_files.html#sec:specifying_multiple_files)中描述的任何值 | [projectDir/src/name/java] | 该source set的包含java源文件的目录 16 | resources | [SourceDirectorySet](https://docs.gradle.org/current/javadoc/org/gradle/api/file/SourceDirectorySet.html)(read-only) | Not null | 该source set的资源,只包含存在于resource目录吓得资源文件,会排除在resource下的所有.java文件,其他插件,如Groovy插件会在该集合中排除一些其他的文件. 17 | resources.srcDirs | Set.可以设置为在[Section 15.5, “Specifying a set of input files”](https://docs.gradle.org/current/userguide/working_with_files.html#sec:specifying_multiple_files)中描述的任何值 | [projectDir/src/name/resources] | 该source set的包含资源文件的目录 18 | allJava | [SourceDirectorySet](https://docs.gradle.org/current/javadoc/org/gradle/api/file/SourceDirectorySet.html)(read-only) | java | 该source set的所有.java文件。一些插件，如Groovy插件，添加额外的Java源文件到这个集合。 19 | allSource | [SourceDirectorySet](https://docs.gradle.org/current/javadoc/org/gradle/api/file/SourceDirectorySet.html)(read-only) | resources + java | 该source set的所有源文件。这包括所有的资源文件和所有Java源文件。一些插件，如Groovy插件，添加额外的源文件到这个集合。 20 | -------------------------------------------------------------------------------- /the_java_plugin/java_plugin_source_sets.md: -------------------------------------------------------------------------------- 1 | # 资源设置 2 | 3 | Java 插件引入了资源设置 (Source Set) 的概念, 资源设置就是一组被编译和执行在一起的源文件. 4 | 这些源文件可能包含 Java 的源文件以及一些资源文件. 5 | 其他的插件可能还会在资源设置中包含 Groovy 和 Scala 的源文件. 资源设置有一个与之关联的关于编译的 classpath 和有关运行的 classpath. 6 | 7 | 资源设置的用法之一就是将源文件归档到描述它们目的的各个逻辑组, 8 | 举个例子, 9 | 你可以使用一个资源设置来定义一个集成测试套件 10 | 也可以使用另外的资源设来定义你项目的 API 和实现类. 11 | 12 | Java 插件定义了两个标准资源设置, 分别称为`main`和`test`, `main`资源设置中包含最终面向客户的代码, 也就是编译和集成为一个 Jar 文件. 13 | `test`资源设置包括了测试阶段的代码, 也就是使用 JUnit 或者 TestNG 编译和执行的代码. 它们可以是单元测试, 集成测试, 验收测试或者任何对你有用的测试集. 14 | -------------------------------------------------------------------------------- /the_java_plugin/java_plugin_tasks.md: -------------------------------------------------------------------------------- 1 | # 任务 2 | 3 | Java 插件引入了许多任务到项目当中, 具体如下表所示 4 | 5 | **表22.1 java 插件-任务** 6 | 7 | 任务名 | 依赖 | 类型 | 描述 8 | --------- | ---------- | ---- | ----------- 9 | compileJava | 所有产生编译 classpath 的任务，包括编译配置项目的所依赖的 jar 文件 | [JavaCompile](https://docs.gradle.org/current/dsl/org.gradle.api.artifacts.Configuration.html) | 使用 javac 命令编译产生 java源文件 10 | processResources | - | [Copy](https://docs.gradle.org/current/dsl/org.gradle.api.tasks.Copy.html) | 复制生产资源到生产 class 文件目录 11 | classes | compileJava任务和processResources任务。有一些插件添加额外的编译任务 | [Task](https://docs.gradle.org/current/dsl/org.gradle.api.Task.html) | 组装生产class文件目录 12 | compileTestJava | compile任务加上所有产生测试编译的classpath的任务 | [JavaCompile](https://docs.gradle.org/current/dsl/org.gradle.api.artifacts.Configuration.html) | 使用 javac编译产生 java 测试源文件 13 | processTestResources | - | [Copy](https://docs.gradle.org/current/dsl/org.gradle.api.tasks.Copy.html) | 复制测试资源到测试 class 文件目录 14 | testClasses | compileTestJava 和 processTestResources 任务。一些插件会添加额外的测试编译任务 | [Task](https://docs.gradle.org/current/dsl/org.gradle.api.Task.html) | 组装测试class文件目录 15 | jar | compile | [Jar](https://docs.gradle.org/current/dsl/org.gradle.api.tasks.bundling.Jar.html) | 组装 Jar 文件 16 | javadoc | compile | [javadoc](https://docs.gradle.org/current/dsl/org.gradle.api.tasks.javadoc.Javadoc.html) | 使用 javadoc 命令为 Java 源码生产 API 文档 17 | test | compile，compileTest，加上所有产生 test runtime classp 的任务 | [Test](https://docs.gradle.org/current/dsl/org.gradle.api.tasks.testing.Test.html) | 使用 JUnit或者TestNG 进行单元测试 18 | uploadArchives | 在archives配置中产生信息单元的文件，包括了 jar | [Upload](https://docs.gradle.org/current/dsl/org.gradle.api.tasks.Upload.html) | 上传信息单元在archives配置中，包括 Jar 文件 19 | clean | - | [Delete](https://docs.gradle.org/current/dsl/org.gradle.api.tasks.Delete.html) | 删除项目构建目录 20 | clean*TaskName* | - | [Delete](https://docs.gradle.org/current/dsl/org.gradle.api.tasks.Delete.html) | 删除指定任务名所产生的项目构建目录，CleanJar会删除jar任务创建的jar 文件，cleanTest将会删除由 test 任务创建的测试结果 21 | 22 | 对于添加到项目中的每个资源设置, java 插件将会加入以下编译任务 23 | 24 | **表22.2.java 插件-资源设置任务** 25 | 26 | 任务名 | 依赖 | 类型 | 描述 27 | --------- | ---------- | ---- | ----------- 28 | compile*SourceSet*Java | 产生资源设置编译 classpath 的所有任务 | [JavaCompile](https://docs.gradle.org/current/dsl/org.gradle.api.artifacts.Configuration.html) | 使用 javac 命令编译给定资源设置的 Java 源文件 29 | processSourceSetResources | - | [Copy](https://docs.gradle.org/current/dsl/org.gradle.api.tasks.Copy.html) | 复制给定资源设置的资源到classes目录下。 30 | sourceSetClasses | compileSourceSetJava任务和processSourceSetResources任务。一些插件给资源设置添加额外的编译工作。 | [Task](https://docs.gradle.org/current/dsl/org.gradle.api.Task.html) | 组装资源设置的class目录 31 | 32 | Java 插件同时也增加了一些为项目生命周期服务的任务 33 | 34 | **表22.3.java 插件-生命周期任务** 35 | 36 | 任务名 | 依赖 | 类型 | 描述 37 | --------- | ---------- | ---- | ----------- 38 | assemble | 项目中的所有归档任务，包括 jar 任务。一些插件给项目增加的额外归档任务 | [Task](https://docs.gradle.org/current/dsl/org.gradle.api.Task.html) | 组装项目的所有档案 39 | check | 项目中的所有验证任务，包括 test 任务。一些插件给项目增加的额外验证任务 | [Task](https://docs.gradle.org/current/dsl/org.gradle.api.Task.html) | 执行项目中的所有验证任务 40 | build | assemble任务和 check 任务 | | [Task](https://docs.gradle.org/current/dsl/org.gradle.api.Task.html) | 构建完整地项目 41 | buildNeeded | build 任务和buildNeeded 任务的testRuntime任务配置的所有项目的依赖库 | [Task](https://docs.gradle.org/current/dsl/org.gradle.api.Task.html) | 构建完整地项目并且构建该项目依赖的所有项目 42 | buildDependents | build and buildDependents tasks in all projects with a project lib dependency on this project in a testRuntime configuration. | [Task](https://docs.gradle.org/current/dsl/org.gradle.api.Task.html) | 构建完整项目并且构建所有依赖该项目的项目 43 | buildConfigName | 产生由ConfigName配置的信息单元的任务。 | [Task](https://docs.gradle.org/current/dsl/org.gradle.api.Task.html) | 根据指定的配置组装信息单元。这个任务是由 Java 插件隐式添加的基础插件添加的。 44 | uploadConfigName | 上传由ConfigName配置的信息单元的任务。 | [Upload](https://docs.gradle.org/current/dsl/org.gradle.api.tasks.Upload.html) | 根据指定的配置组装并上传信息单元。 45 | 。这个任务是由 Java 插件隐式添加的基础插件添加的。 46 | 47 | 下图显示了这些任务之间的关系 48 | 49 | **图22.1.java 插件-任务** 50 | 51 | ![java plugin-tasks](https://docs.gradle.org/current/userguide/img/javaPluginTasks.png) 52 | -------------------------------------------------------------------------------- /the_java_plugin/java_plugin_test.md: -------------------------------------------------------------------------------- 1 | ## 22.13.测试 2 | 3 | test任务是[Test](https://docs.gradle.org/current/dsl/org.gradle.api.tasks.testing.Test.html)的一个实例.它会在测试source set自动检测并执行所有的单元测试,并且在测试执行完成后会生成一份测试报告.task任务支持JUnit和TestNG.在[Test](https://docs.gradle.org/current/dsl/org.gradle.api.tasks.testing.Test.html)查看完整地API. 4 | -------------------------------------------------------------------------------- /the_java_plugin/java_plugin_uploading.md: -------------------------------------------------------------------------------- 1 | ## 22.15.上传 2 | 3 | 如何上传archives在[Chapter 51, Publishing artifacts](https://docs.gradle.org/2.4/userguide/artifact_management.html) 4 | ------- 5 | [[9](https://docs.gradle.org/2.4/userguide/java_plugin.html#N12A26)]JUnit的维基包含有关如何使用JUnit类工作的详细说明:https://github.com/junit-team/junit/wiki/Categories. 6 | 7 | [[10](https://docs.gradle.org/2.4/userguide/java_plugin.html#N12A26)]TestNG的文档包含关于测试组的更多详细信息:http://testng.org/doc/documentation-main.html#test-groups. 8 | -------------------------------------------------------------------------------- /the_java_plugin/java_plugin_usage.md: -------------------------------------------------------------------------------- 1 | # 用法 2 | 3 | 要使用 Java 插件, 4 | 需要在构建脚本中加入如下内容 5 | 6 | **例子 22.1.使用 Java 插件** 7 | 8 | **bulid.gradle** 9 | 10 | ``` 11 | apply plugin: 'java' 12 | ``` 13 | -------------------------------------------------------------------------------- /the_java_plugin/java_plugin_working_with_source_sets.md: -------------------------------------------------------------------------------- 1 | # 使用资源设置 2 | 3 | 你可以通过 sourceSets 属性来使用资源设置. 它其实是一个项目资源设置的容器, 它的类型是 [SourceSetContainer](https://docs.gradle.org/current/javadoc/org/gradle/api/tasks/SourceSetContainer.html). 同时也有 sourceSets { } 脚本模块, 在这个模块里, 你可以通过闭包配置资源设置容器. 资源设置容器的工作方式和其余容器几乎一模一样, 比如 tasks. 4 | 5 | **例 22.3. 进入资源设置** 6 | 7 | **build.gradle** 8 | 9 | ``` 10 | // Various ways to access the main source set 11 | println sourceSets.main.output.classesDir 12 | println sourceSets['main'].output.classesDir 13 | sourceSets { 14 | println main.output.classesDir 15 | } 16 | sourceSets { 17 | main { 18 | println output.classesDir 19 | } 20 | } 21 | 22 | // Iterate over the source sets 23 | sourceSets.all { 24 | println name 25 | } 26 | ``` 27 | 28 | 为了配置一个已经存在的资源集, 你只需要使用上面提及的访问方法来设置资源集的属性. 下面就是一个配置 Java 资源目录的例子: 29 | 30 | **例 22.4. 配置资源集的源目录** 31 | 32 | **build.gradle** 33 | ``` 34 | sourceSets { 35 | main { 36 | java { 37 | srcDir 'src/java' 38 | } 39 | resources { 40 | srcDir 'src/resources' 41 | } 42 | } 43 | } 44 | ``` -------------------------------------------------------------------------------- /the_java_plugin/java_plugins_some_source_set_examples.md: -------------------------------------------------------------------------------- 1 | ### 22.7.3.一些 source set 的例子 2 | 3 | 加入含有类文件的 sorce set 的 JAR： 4 | 5 | **例22.8.为 source set 组装 JAR** 6 | 7 | **build.gradle** 8 | 9 | ``` 10 | task intTestJar(type: Jar) { 11 | from sourceSets.intTest.output 12 | } 13 | ``` 14 | 15 | 为 source set 生成 javadoc: 16 | 17 | **例22.9.为 source set 生成 javadoc** 18 | 19 | **build.gradle** 20 | 21 | ``` 22 | task intTestJavadoc(type: Javadoc) { 23 | source sourceSets.intTest.allJava 24 | } 25 | ``` 26 | 27 | 为 source set 添加一个测试套件运行测试： 28 | 29 | **例22.8.source set 运行测试** 30 | 31 | **build.gradle** 32 | 33 | ```gradle 34 | task intTest(type: Test) { 35 | testClassesDir = sourceSets.intTest.output.classesDir 36 | classpath = sourceSets.intTest.runtimeClasspath 37 | } 38 | ``` 39 | -------------------------------------------------------------------------------- /the_java_plugin/test_convention_values.md: -------------------------------------------------------------------------------- 1 | ### 22.13.8.公共值 2 | **表22.14.Java插件-测试属性** 3 | 4 | 任务属性 | 类型 | 默认值 5 | -------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------- 6 | testClassesDir | File | sourceSets.test.output.classesDir 7 | classpath | [FileCollection](https://docs.gradle.org/2.4/javadoc/org/gradle/api/file/FileCollection.html) | sourceSets.test.runtimeClasspath 8 | testResultsDir | File | testResultsDir 9 | testReportDir | File | testReportDir 10 | testSrcDirs | List | sourceSets.test.java.srcDirs 11 | -------------------------------------------------------------------------------- /the_java_plugin/test_debugging.md: -------------------------------------------------------------------------------- 1 | ### 22.13.2.调试 2 | 测试任务提供了[Test.getDebug()](https://docs.gradle.org/current/dsl/org.gradle.api.tasks.testing.Test.html#org.gradle.api.tasks.testing.Test:debug)属性，可使JVM等待调试器附加到5005端口后在进行调试. 3 | 4 | 通过调用`--debug-JVM`任务选项，这也可以启用调试任务（since Gradle1.12）。 5 | -------------------------------------------------------------------------------- /the_java_plugin/test_detection.md: -------------------------------------------------------------------------------- 1 | ### 22.13.5.测试检测 2 | 测试任务检测哪些类是通过检查编译测试类的测试类。默认情况下它会扫描所有.calss文件.可以自定义包含/排除哪些类需不要要被扫描.所使用不同的测试框架（JUnit/ TestNG）时测试类检测使用不同的标准。 3 | 当使用JUnit，我们扫描的JUnit3和JUnit4的测试类。如果任一下列条件匹配，类被认为是一个JUnit测试类： 4 | * 类或父类集成自TestCase或GroovyTestCase 5 | * 类或父类有@RunWith注解 6 | * 类或者父类中的方法有@Test注解 7 | 8 | 当使用TestNG的，我们扫描注解了@Test的方法。 9 | 10 | 需要注意的是抽象类不执行。Gradle还扫描了继承树插入测试classpath中的jar文件。 11 | 12 | 如果你不想使用测试类的检测，可以通过设置scanForTestClasses为false禁用它。这将使得测试任务只使用包含/排除找到测试类。如果scanForTestClasses是false而且额并没有包含/排除指定模式,"\*\*/\*Tests.class","\*\*/\*Test.class",与"\*\*/\*Abstract\*.class"分别为包含/排除的默认值. 13 | -------------------------------------------------------------------------------- /the_java_plugin/test_execution.md: -------------------------------------------------------------------------------- 1 | ### 22.13.1.执行测试 2 | 测试从main构建过程中分离出来的,运行在一个单独的JVM中执行.[Test](https://docs.gradle.org/current/dsl/org.gradle.api.tasks.testing.Test.html)任务允许控制这些如何发生. 有许多属性用于控制测试过程如何启动.这包括使用诸如系统属性，JVM参数和Java可执行文件。 3 | 4 | 可以指定是否要并行执行测试.Gradle通过同时运行多个测试进程提供并行执行测试.每个测试进程在同一时间只能执行一个测试,为了充分利用这一特性,一般不需要为tests任务做什么特别的设置,`maxParallelForks`属性指定测试进程在同一时间运行的最大进程数.默认值是1,意味着不执行并行测试. 5 | 6 | 测试过程中设置org.gradle.test.worker系统属性为该测试过程的唯一标识符,例如，在文件名或其他资源标识符的唯一标识符。 7 | 8 | 你可以指定一些测试任务在已执行了一定数量的测试后重新运行.这可能是一个非常好的方式替代测试进程中的大量的堆.forkEvery属性指定测试类的在测试过程执行的最大数目。默认的是执行在各测设进程中不限数量的测试。 9 | 10 | 该任务有一个ignoreFailures属性来控制在测试失败时的行为。测试任务总是执行每一个检测试验.它停止构建之后，如果ignoreFailures是false，说明有失败的测试。ignoreFailures的默认值是false。 11 | 12 | testLogging属性允许你配置哪个测试事件将被记录，并设置其log等级。默认情况下，将记录每一个失败的测试简明消息。详见[TestLoggingContainer](https://docs.gradle.org/current/dsl/org.gradle.api.tasks.testing.logging.TestLoggingContainer.html)如何按需求调整测试记录。 13 | -------------------------------------------------------------------------------- /the_java_plugin/test_filtering.md: -------------------------------------------------------------------------------- 1 | ### 22.13.3.测试过滤 2 | 从Gradle1.10开始,可以根据测试任务名进行特点的任务测试,过滤与在构建脚本的段落中引入/排除测试任务(-Dtest.single, test.include and friends)是两种不同的机制.后者是基于文件,如测试实现类的物理位置.选择文件级的测试会不支持那些被测试等级过滤掉的一些有趣的测试脚本.下面的这些有些已经被实现,有些是将来会实现的: 3 | - 过滤特定等级的试验方法;执行单个测试方法 4 | - 通配符"*"支持任意字符匹配 5 | - 命令行选项"--tests"用以设置测试过滤器.对经典的'执行单一测试方法'用例尤其有用.当使用命令行选项的时候,在构建脚本中声明的包含过滤器被忽略。 6 | - Gradle过滤测试框架API的限制.一些高级的综合性测试无法完全兼容测试过滤,但是,绝大多是测试和用例可以被熟练地处理. 7 | - 测试过滤取代基于选择文件的测试,后者在未来可能会完全被取代.我们会完善测试过滤的API,并增加不同的过滤器 8 | 9 | **例22.11.过滤测试的构建脚本吗** **build.gradle** 10 | 11 | ``` 12 | test{ 13 | filter{ 14 | //包括在测试的任何具体方法 15 | includeTestsMatching "*UiCheck" 16 | 17 | //包括所有包种的测试 18 | includeTestsMatching "org.gradle.internal.*" 19 | 20 | //包括所有的集成测试 21 | includeTestsMatching "*IntegTest" 22 | } 23 | } 24 | ``` 25 | 26 | 要了解更多详细信息和示例，请参见[TestFilter](https://docs.gradle.org/current/javadoc/org/gradle/api/tasks/testing/TestFilter.html)。 使用命令行选项的一些例子: 27 | * gradle test --tests org.gradle.SomeTest.someSpecificFeature 28 | * gradle test --tests \*SomeTest.someSpecificFeature 29 | * gradle test --tests \*SomeSpecificTest 30 | * gradle test --tests all.in.specific.package\* 31 | * gradle test --tests \*IntegTest 32 | * gradle test --tests \*IntegTest\*ui\* 33 | * gradle someTestTask --tests \*UiTest someOtherTestTask --tests \*WebTest\*ui 34 | -------------------------------------------------------------------------------- /the_java_plugin/test_grouping.md: -------------------------------------------------------------------------------- 1 | ### 22.13.6.测试分组 2 | JUnit和TestNG允许为测试方法精密分组. 3 | 4 | 对于分组JUnit的测试类与测试方法,JUnit4.8引入了类别的概念.[9](https://docs.gradle.org/current/userguide/java_plugin.html#ftn.N12A10)该测试任务允许您设定JUnit包括或者排除某些类的规范。 5 | 6 | **例22.12.JUnit分类** 7 | **build.gradle** 8 | ``` 9 | test { 10 | useJUnit { 11 | includeCategories 'org.gradle.junit.CategoryA' 12 | excludeCategories 'org.gradle.junit.CategoryB' 13 | } 14 | } 15 | ``` 16 | 17 | TestNG的框架有一个非常类似的概念。在TestNG的，你可以指定不同的测试组。 [[10](https://docs.gradle.org/current/userguide/java_plugin.html#ftn.N12A26)]测试分组应包括或排除在测试任务进行配置了的测试执行. 18 | 19 | **例22.13.TestNG分组测试** 20 | **build.gradle** 21 | ``` 22 | test { 23 | useTestNG { 24 | excludeGroups 'integrationTests' 25 | includeGroups 'unitTests' 26 | } 27 | } 28 | ``` 29 | -------------------------------------------------------------------------------- /the_java_plugin/test_reporting.md: -------------------------------------------------------------------------------- 1 | ### 22.13.7.测试报告 2 | 测试任务默认生成以下结果. 3 | + 一份HTML测试报告 4 | + 一个与Ant的JUnit测试报告任务兼容的XML.这个格式与许多其他服务兼容,如CI serves 5 | + 结果是有效的二进制,测试任务会从这些二进制结果生成其他结果。 6 | 有一个独立的[TestReport](https://docs.gradle.org/2.4/dsl/org.gradle.api.tasks.testing.TestReport.html)任务类型会根据一些Test任务实例生成的二进制源码生成一个HTML报告.使用这种测试类型,需要定义一个destinationDir,里面包括测试结果的报告.下面是一个示例，它产生一个从子项目的单元测试组合而成的报告： 7 | **例22.14.创建单元测试报告子项目** 8 | **build.gradle** 9 | ``` 10 | subprojects { 11 | apply plugin: 'java' 12 | 13 | // Disable the test report for the individual test task 14 | test { 15 | reports.html.enabled = false 16 | } 17 | } 18 | 19 | task testReport(type: TestReport) { 20 | destinationDir = file("$buildDir/reports/allTests") 21 | // Include the results from the `test` task in all subprojects 22 | reportOn subprojects*.test 23 | } 24 | ``` 25 | 应该注意的是，TestReport型组合来自多个测试任务的结果，需要聚集个别测试类的结果。这意味着，如果一个给定的测试类是由多个测试任务执行时，测试报告将会包括那些类,但是很难区分该输出结果分别是出自哪个类. 26 | -------------------------------------------------------------------------------- /the_java_plugin/test_single_test_execution_via_system_properties.md: -------------------------------------------------------------------------------- 1 | ### 22.13.4.通过系统属性执行单独测试 2 | > 如上所述该机制已经被测试过滤取代 3 | 4 | > **译者注:被取代的东西就先不翻译了** 5 | 6 | Setting a system property of taskName.single = testNamePattern will only execute tests that match the specified testNamePattern. The taskName can be a full multi-project path like “:sub1:sub2:test” or just the task name. The testNamePattern will be used to form an include pattern of “\*\*/testNamePattern\*.class”;. If no tests with this pattern can be found an exception is thrown. This is to shield you from false security. If tests of more than one subproject are executed, the pattern is applied to each subproject. An exception is thrown if no tests can be found for a particular subproject. In such a case you can use the path notation of the pattern, so that the pattern is applied only to the test task of a specific subproject. Alternatively you can specify the fully qualified task name to be executed. You can also specify multiple patterns. Examples: 7 | 8 | * gradle -Dtest.single=ThisUniquelyNamedTest test 9 | * gradle -Dtest.single=a/b/ test 10 | * gradle -DintegTest.single=\*IntegrationTest integTest 11 | * gradle -Dtest.single=:proj1:test:Customer build 12 | * gradle -DintegTest.single=c/d/ :proj1:integTest 13 | -------------------------------------------------------------------------------- /the_java_plugin/test_testNG_parameterized_methods_and_reporting.md: -------------------------------------------------------------------------------- 1 | #### 22.13.7.1.TestNG 的参数化方法和报告 2 | TestNG支持[参数化方法](http://testng.org/doc/documentation-main.html#parameters),允许一个特定的测试方法使用不同的输入被执行多次。Gradle会在测试报告中包含该方法的参数值. 3 | 给出一个叫aTestMethod的测试方法,该方法有两个参数,在测试报告中会根据名字报告:aTestMethod(toStringValueOfParam1, toStringValueOfParam2). 这很容易识别的参数值的特定迭代. 4 | -------------------------------------------------------------------------------- /the_war_plugin/convention_properties.md: -------------------------------------------------------------------------------- 1 | # 公共配置 2 | 3 | **表25.4.War插件-目录配置** 4 | 5 | 属性名称 | 类型 | 默认值 | 描述 6 | ----- | ---- | ---- | ---- 7 | webAppDirName | String | src/main/webapp | 在项目目录的web应用的资源文件夹名 8 | webAppDir | File (read-only) | projectDir/webAppDirName | Web应用的资源路径 9 | 10 | 这些属性由一个[WarPluginConvention](https://docs.gradle.org/current/dsl/org.gradle.api.plugins.WarPluginConvention.html)公共对象提供 11 | -------------------------------------------------------------------------------- /the_war_plugin/customizing.md: -------------------------------------------------------------------------------- 1 | # 定制War 2 | 3 | 下面的例子中有一些重要的自定义选项 4 | 5 | **例25.2.定制War插件** 6 | 7 | **build.gradle** 8 | 9 | ``` 10 | configuration{ 11 | moreLibs 12 | } 13 | 14 | respositories{ 15 | faltDir {dirs "lib"} 16 | mavenCentral() 17 | } 18 | 19 | dependencies{ 20 | compile module(":compile:1.0") { 21 | dependency ":compile-transitive-1.0@jar" 22 | dependency ":providedCompile-transitive:1.0@jar" 23 | } 24 | providedCompile "javax.servlet:servlet-api:2.5" 25 | providedCompile module(":providedCompile:1.0") { 26 | dependency ":providedCompile-transitive:1.0@jar" 27 | } 28 | runtime ":runtime:1.0" 29 | providedRuntime ":providedRuntime:1.0@jar" 30 | testCompile "junit:junit:4.12" 31 | moreLibs ":otherLib:1.0" 32 | } 33 | 34 | war{ 35 | from 'src/rootContent' // 增加一个目录到归档根目录 36 | webInf {from 'src/additionalWebInf'} // 增加一个目录到 WEB-INF 下 37 | classpath fileTree('additionalLibs') // 增加一个目录到 WEB-INF/lib下. 38 | classpath configurations.moreLibs // 增加更多地设置到 WEB-INF/lib 下. 39 | webXml = file('src/someWeb.xml') // 复制xml文件到 WEB-INF/web.xml. 40 | } 41 | ``` 42 | 43 | 当然,可以用一个封闭的标签定义一个文件是否存打包到War文件中. 44 | -------------------------------------------------------------------------------- /the_war_plugin/dependency_management.md: -------------------------------------------------------------------------------- 1 | # 依赖管理 2 | 3 | War插件增加了名为providedCompile和providedRuntime的两个依赖配置.这两个配置有相同的作用域在编译或者运行时的配置,不同之处在于是否会将war文件归档.很重要的一点是它们都会提供配置传递.比如在任意的provided配置中添加了`commons-httpclient:commons-httpclient:3.0`,该依赖依赖于`commons-codec`,因为这个一个"provided"的配置,意味着这两个依赖都不会被加入你的WAR中,即使`commons-codec`库是一个显式的编译配置.如果不希望出现这种传递行为,`commons-httpclient:commons-httpclient:3.0@jar`这样声明provided依赖即可. 4 | -------------------------------------------------------------------------------- /the_war_plugin/project_layout.md: -------------------------------------------------------------------------------- 1 | # 项目布局 2 | 3 | **表25.3.War插件-项目布局** 4 | 5 | 文件夹 | 含义 6 | -------- | ------ 7 | src/main/webapp | Web应用资源 8 | -------------------------------------------------------------------------------- /the_war_plugin/tasks.md: -------------------------------------------------------------------------------- 1 | # 任务 2 | <<<<<<< HEAD 3 | ======= 4 | 5 | War插件会添加下列任务到项目. 6 | 7 | **表25.1.War插件-任务** 8 | 9 | 任务名 | 依赖 | 类型 | 描述 10 | --------- | ---------- | ---- | ----------- 11 | war | compile | [War](https://docs.gradle.org/current/dsl/org.gradle.api.tasks.bundling.War.html) | 组装应用程序War文件 12 | 13 | War插件由Java插件添加下列依赖任务. 14 | 15 | **表25.2.War插件-附加的依赖任务** 16 | 17 | 任务名 | 依赖 18 | -------- | ------ 19 | assemble | war 20 | 21 | **图25.1.War插件-任务** 22 | ![war plugin-tasks](https://docs.gradle.org/current/userguide/img/warPluginTasks.png) 23 | >>>>>>> a655fa4be4421004591827ae70fee579703794dd 24 | -------------------------------------------------------------------------------- /the_war_plugin/the_war_plugin.md: -------------------------------------------------------------------------------- 1 | # War 插件 (未完成) 2 | 3 | WAR插件扩展了Java插件,支持web应用组装成War文件.它默认禁用了Java插件JAR归档任务，并增加了一个默认的WAR归档任务。 4 | 5 | ## 25.1.使用 6 | 使用war插件需要在构建脚本下包括以下内容 7 | 8 | **例25.1.使用war插件** 9 | 10 | **build.gradle** 11 | 12 | ``` 13 | apply plugin 'war' 14 | ``` 15 | 16 | ## 25.2.任务 17 | War插件会添加下列任务到项目. 18 | 19 | **表25.1.War插件-任务** 20 | 21 | 任务名 | 依赖 | 类型 | 描述 22 | --------- | ---------- | ---- | ----------- 23 | war | compile | [War](https://docs.gradle.org/current/dsl/org.gradle.api.tasks.bundling.War.html) | 组装应用程序War文件 24 | 25 | War插件由Java插件添加下列依赖任务. 26 | 27 | **表25.2.War插件-附加的依赖任务** 28 | 29 | 任务名 | 依赖 30 | -------- | ------ 31 | assemble | war 32 | 33 | **图25.1.War插件-任务** 34 | ![war plugin-tasks](https://docs.gradle.org/current/userguide/img/warPluginTasks.png) 35 | 36 | ## 25.3.项目布局 37 | 38 | **表25.3.War插件-项目布局** 39 | 文件夹 | 含义 40 | -------- | ------ 41 | src/main/webapp | Web应用资源 42 | 43 | ## 25.4.依赖管理 44 | War插件增加了名为providedCompile和providedRuntime的两个依赖配置.这两个配置有相同的作用域在编译或者运行时的配置,不同之处在于是否会将war文件归档.很重要的一点是它们都会提供配置传递.比如在任意的provided配置中添加了`commons-httpclient:commons-httpclient:3.0`,该依赖依赖于`commons-codec`,因为这个一个"provided"的配置,意味着这两个依赖都不会被加入你的WAR中,即使`commons-codec`库是一个显式的编译配置.如果不希望出现这种传递行为,`commons-httpclient:commons-httpclient:3.0@jar`这样声明provided依赖即可. 45 | 46 | ## 25.5.公共配置 47 | 48 | **表25.4.War插件-目录配置** 49 | 50 | 属性名称 | 类型 | 默认值 | 描述 51 | ----- | ---- | ---- | ---- 52 | webAppDirName | String | src/main/webapp | 在项目目录的web应用的资源文件夹名 53 | webAppDir | File (read-only) | projectDir/webAppDirName | Web应用的资源路径 54 | 55 | 这些属性由一个[WarPluginConvention](https://docs.gradle.org/current/dsl/org.gradle.api.plugins.WarPluginConvention.html)公共对象提供 56 | 57 | ## 25.6.War 58 | War任务默认会把`src/main/webapp`的内容复制到归档目录的根目录.webapp文件夹下会包含一个`WEB-INF`子文件夹,里面可能会有一个web.xml文件.编译后的class文件会在`WEB-INF/classes`下,所有runtime[[13](https://docs.gradle.org/current/userguide/war_plugin.html#ftn.N1325D)]的依赖配置会被拷贝至`WEB-INF/lib`下. 59 | 60 | API文档中有更多关于[War](https://docs.gradle.org/current/dsl/org.gradle.api.tasks.bundling.War.html)的信息. 61 | 62 | ## 25.7.定制War 63 | 下面的例子中有一些重要的自定义选项 64 | 65 | **例25.2.定制War插件** 66 | 67 | **build.gradle** 68 | 69 | ``` 70 | configuration{ 71 | moreLibs 72 | } 73 | 74 | respositories{ 75 | faltDir {dirs "lib"} 76 | mavenCentral() 77 | } 78 | 79 | dependencies{ 80 | compile module(":compile:1.0") { 81 | dependency ":compile-transitive-1.0@jar" 82 | dependency ":providedCompile-transitive:1.0@jar" 83 | } 84 | providedCompile "javax.servlet:servlet-api:2.5" 85 | providedCompile module(":providedCompile:1.0") { 86 | dependency ":providedCompile-transitive:1.0@jar" 87 | } 88 | runtime ":runtime:1.0" 89 | providedRuntime ":providedRuntime:1.0@jar" 90 | testCompile "junit:junit:4.12" 91 | moreLibs ":otherLib:1.0" 92 | } 93 | 94 | war{ 95 | from 'src/rootContent' // 增加一个目录到归档根目录 96 | webInf {from 'src/additionalWebInf'} // 增加一个目录到 WEB-INF 下 97 | classpath fileTree('additionalLibs') // 增加一个目录到 WEB-INF/lib下. 98 | classpath configurations.moreLibs // 增加更多地设置到 WEB-INF/lib 下. 99 | webXml = file('src/someWeb.xml') // 复制xml文件到 WEB-INF/web.xml. 100 | } 101 | ``` 102 | 103 | 当然,可以用一个封闭的标签定义一个文件是否存打包到War文件中. 104 | 105 | --- 106 | [[13](https://docs.gradle.org/current/userguide/war_plugin.html#N1325D)]`runtime`配置将会继承`compile`配置. 107 | -------------------------------------------------------------------------------- /the_war_plugin/usage.md: -------------------------------------------------------------------------------- 1 | # 使用 2 | <<<<<<< HEAD 3 | ======= 4 | 5 | 使用war插件需要在构建脚本下包括以下内容 6 | 7 | **例25.1.使用war插件** 8 | 9 | **build.gradle** 10 | 11 | ``` 12 | apply plugin 'war' 13 | ``` 14 | >>>>>>> a655fa4be4421004591827ae70fee579703794dd 15 | -------------------------------------------------------------------------------- /the_war_plugin/war.md: -------------------------------------------------------------------------------- 1 | # War 2 | 3 | War任务默认会把`src/main/webapp`的内容复制到归档目录的根目录.webapp文件夹下会包含一个`WEB-INF`子文件夹,里面可能会有一个web.xml文件.编译后的class文件会在`WEB-INF/classes`下,所有runtime[[13](https://docs.gradle.org/current/userguide/war_plugin.html#ftn.N1325D)]的依赖配置会被拷贝至`WEB-INF/lib`下. 4 | 5 | API文档中有更多关于[War](https://docs.gradle.org/current/dsl/org.gradle.api.tasks.bundling.War.html)的信息. 6 | 7 | --- 8 | [[13](https://docs.gradle.org/current/userguide/war_plugin.html#N1325D)]`runtime`配置扩展了`compile`配置. 9 | -------------------------------------------------------------------------------- /troubleshooting/README.md: -------------------------------------------------------------------------------- 1 | # 排除故障 2 | 3 | 当使用 Gradle 时, 你肯定会碰到许多问题. 4 | 5 | # 解决遇到的问题 6 | 7 | 如果你碰到了问题, 首先要确定你使用的是最新版本的 Gradle. 我们会经常发布新版本, 解决一些 bug 并加入新的功能. 所以你遇到的问题可能就在新版本里解决了. 8 | 9 | 如果你正在使用 Gradle Daemon, 先暂时关闭 daemon (你可以使用 **switch --no-daemon** 命令). 在第19章我们可以了解到更多关于 daemon 的信息. 10 | 11 | # 获得帮助 12 | 13 | 可以浏览 http://forums.gradle.org 获得相关的帮助. 在 Gradle 论坛里, 你可以提交问题, 当然也可以回答其他 Gradle 开发人员和使用者的问题. 14 | 15 | 如果你碰到不能解决的问题, 请在论坛里报告或者提出这个问题, 通常这是解决问题最快的方法. 你也可以提出建议或者一些新的想法. 通过论坛, 你当然也可以获得 Gradle 最新的开发信息. 16 | 17 | 18 | 19 | 20 | 21 | -------------------------------------------------------------------------------- /troubleshooting/getting_help.md: -------------------------------------------------------------------------------- 1 | # 获得帮助 2 | 3 | 可以去 http://forums.gradle.org 获得相关的帮助. 在 Gradle 论坛里, 你可以提交问题, 当然也可以回答其他 Gradle 开发人员和使用者的问题. 4 | 5 | 如果你碰到不能解决的问题, 请在论坛里报告或者提出这个问题, 通常这是解决问题最快的方法. 您也可以提出建议或者一些新的想法. 开发团队会经常性的发布新的东西或者发布通知, 通过论坛, 您可以获得 Gradle 最新的开发信息. 6 | -------------------------------------------------------------------------------- /troubleshooting/working_through_problems.md: -------------------------------------------------------------------------------- 1 | # 解决遇到的问题 2 | 3 | 如果你碰到了问题, 首先要确定你使用的是最新版本的 Gradle. 我们会经常发布新版本, 解决一些 bug 并加入新的功能. 所以你遇到的问题可能就在新版本里解决了. 4 | 5 | 如果你正在使用 Gradle Daemon, 先暂时关闭 daemon (你可以使用 **switch --no-daemon** 命令). 在第19章我们可以了解到更多关于 daemon 的信息. 6 | 7 | 8 | -------------------------------------------------------------------------------- /tutorial_-_this_and_that/caching.md: -------------------------------------------------------------------------------- 1 | # 缓存 2 | 3 | 为了提高响应能力，Gradle 默认缓存了所有编译后的脚本. 包括所有的构建脚本，初始化脚本，还有其他脚本. Gradle 创建了一个 .gradle 目录来存放编译后的脚本，下次您运行构建脚本时，如果这个脚本自从它被编译后就再也没有被改动过，Gradle 会先使用编译后的脚本. 否则 Gradle 会重新编译脚本，然后将新编译后的文件缓存起来. 如果您使用 Gradle --recompile--scripts 运行脚本，缓存的脚本就会被删除，然后新编译后的文件就会再被缓存. 这种方法可以强制 Gradle 重新编译脚本并缓存. 4 | -------------------------------------------------------------------------------- /tutorials/README.md: -------------------------------------------------------------------------------- 1 | # 教程 2 | 3 | 接下来的教程讲先介绍Gradle的基础知识 4 | 5 | #### Chapter 4, 安装 Gradle 6 | 7 | 描述如何安装 Gradle. 8 | 9 | #### Chapter 5, 脚本构建基础 10 | 11 | 介绍脚本构建的基础元素: projects 和 tasks. 12 | 13 | #### Chapter 6, Java 快速入门 14 | 15 | 展示如何使用 Gradle 来构建 Java 项目. 16 | 17 | #### Chapter 7, 依赖管理基础 18 | 19 | 展示如何使用 Gradle 的依赖管理功能. 20 | 21 | #### Chapter 8, Groovy 快速入门 22 | 23 | 展示如何使用 Gradle 来构建 Groovy 项目. 24 | 25 | #### Chapter 9, 网页应用快速入门 26 | 27 | 展示如何使用 Gradle 来构建网页应用项目. 28 | 29 | #### Chapter 10, 使用 Gradle 命令行 30 | 31 | -------------------------------------------------------------------------------- /tutorials/getting_started.md: -------------------------------------------------------------------------------- 1 | # 入门 2 | 3 | 接下来的教程讲先介绍Gradle的基础知识 4 | 5 | #### Chapter 3, 安装 Gradle 6 | 7 | 描述如何安装 Gradle. 8 | 9 | #### Chapter 5, 脚本构建基础 10 | 11 | 介绍脚本构建的基础元素: projects 和 tasks. 12 | 13 | #### Chapter 6, Java 快速入门 14 | 15 | 展示如何开始使用 Gradle 的合约构建来构建 Java 项目. 16 | 17 | #### Chapter 7, 依赖管理基础 18 | 19 | 展示如何开始使用 Gradle 的依赖管理. 20 | 21 | #### Chapter 8, Groovy 快速入门 22 | 23 | 使用 Gradle 的合约构建来构建 Groovy 项目. 24 | 25 | #### Chapter 9, 网页应用快速入门 26 | 27 | 使用 Gradle 的合约构建来构建网页应用项目. 28 | 29 | -------------------------------------------------------------------------------- /using_ant_from_gradle/API.md: -------------------------------------------------------------------------------- 1 | ## API 2 | 3 | Ant 集成是由 [AntBuilder](https://docs.gradle.org/current/javadoc/org/gradle/api/AntBuilder.html) 提供的.git 4 | -------------------------------------------------------------------------------- /using_ant_from_gradle/ant_properties_and_references.md: -------------------------------------------------------------------------------- 1 | ## Ant的属性与引用 2 | 3 | 有许多方法可以设定 Ant 属性,可以通过Ant任务使用属性.您可以直接在`AntBuilder`的实例设置属性。Ant的属性也可以作为一个可改变的`Map`.也可以使用Ant的任务属性,如下例所示: 4 | 5 | **例16.13.设置Ant属性** 6 | 7 | **build.gradle** 8 | ```gradle 9 | ant.buildDir = buildDir 10 | ant.properties.buildDir = buildDir 11 | ant.properties['buildDir'] = buildDir 12 | ant.property(name: 'buildDir', location: buildDir) 13 | ``` 14 | **build.xml** 15 | ```xml 16 | buildDir = ${buildDir} 17 | ``` 18 | 19 | 许多任务会在执行时设置属性.下面有几种方法来获取属性值,可以直接从`AntBuilder`实例获得属性,如下所示,ant的属性仍然是作为一个map: 20 | 21 | **例16.14.获取Ant属性** 22 | 23 | **build.xml** 24 | ```xml 25 | 26 | ``` 27 | **build.gradle** 28 | ```gradle 29 | println ant.antProp 30 | println ant.properties.antProp 31 | println ant.properties['antProp'] 32 | ``` 33 | 34 | 设置一个ant引用的方法: 35 | 36 | **例16.15.设置一个Ant引用** 37 | 38 | **build.gradle** 39 | ```gradle 40 | ant.path(id: 'classpath', location: 'libs') 41 | ant.references.classpath = ant.path(location: 'libs') 42 | ant.references['classpath'] = ant.path(location: 'libs') 43 | ``` 44 | **build.xml** 45 | ```xml 46 | 47 | ``` 48 | 49 | 获取Ant引用的方法: 50 | 51 | **例16.16.获取一个Ant引用** 52 | 53 | **build.xml** 54 | ```xml 55 | 56 | ``` 57 | **build.gradle** 58 | ```gradle 59 | println ant.references.antPath 60 | println ant.references['antPath'] 61 | ``` 62 | -------------------------------------------------------------------------------- /using_ant_from_gradle/importing_an_ant_build.md: -------------------------------------------------------------------------------- 1 | ## 导入一个Ant构建 2 | 3 | 你可以在你的gradle项目中通过`ant.importBuild()`来导入一个ant构建,当你导入了一个ant构建,每一个`ant target`都会被视为一个Gradle任务.这意味着你可以像操作,执行gradle任务一样操作,执行`ant target` 4 | 5 | **例 16.8.导入ant构建** 6 | 7 | **build.gradle** 8 | ```gradle 9 | ant.importBuild 'build.xml' 10 | ``` 11 | **build.xml** 12 | ```xml 13 | 14 | 15 | Hello, from Ant 16 | 17 | 18 | ``` 19 | 20 | `gradle hello`的输出 21 | 22 | ``` 23 | >\> gradle hello 24 | >:hello 25 | >[ant:echo] Hello, from Ant 26 | > 27 | >BUILD SUCCESSFUL 28 | > 29 | >Total time: 1 secs 30 | ``` 31 | 32 | 你可以添加一个依赖于`ant target`的任务: 33 | **例 16.9.依赖于ant target的任务** 34 | 35 | **build.gradle** 36 | ```gradle 37 | ant.importBuild 'build.xml' 38 | 39 | task intro(dependsOn: hello) << { 40 | println 'Hello, from Gradle' 41 | } 42 | ``` 43 | 44 | >`gradle intro`的输出 45 | >\> gradle intro 46 | >:hello 47 | >[ant:echo] Hello, from Ant 48 | >:intro 49 | >Hello, from Gradle 50 | > 51 | >BUILD SUCCESSFUL 52 | > 53 | >Total time: 1 secs 54 | 55 | 或者,你可以为`ant target`添加动作 56 | 57 | **例 16.10.为Ant target添加动作** 58 | 59 | **build.gradle** 60 | ```gradle 61 | ant.importBuild 'build.xml' 62 | 63 | hello << { 64 | println 'Hello, from Gradle' 65 | } 66 | ``` 67 | 68 | `gradle hello`的输出 69 | >\> gradle hello 70 | >:hello 71 | >[ant:echo] Hello, from Ant 72 | >Hello, from Gradle 73 | > 74 | >BUILD SUCCESSFUL 75 | > 76 | >Total time: 1 secs 77 | 78 | 当然,一个`ant target`也可以依赖于gradle的任务 79 | 80 | **例 16.11.为Ant target添加动作** 81 | 82 | **build.gradle** 83 | ```gradle 84 | ant.importBuild 'build.xml' 85 | 86 | task intro << { 87 | println 'Hello, from Gradle' 88 | } 89 | ``` 90 | **build.xml** 91 | ```xml 92 | 93 | 94 | Hello, from Ant 95 | 96 | 97 | ``` 98 | 99 | `gradle hello`的输出 100 | >\> gradle hello 101 | >:intro 102 | >Hello, from Gradle 103 | >:hello 104 | >[ant:echo] Hello, from Ant 105 | > 106 | >BUILD SUCCESSFUL 107 | > 108 | >Total time: 1 secs 109 | 110 | 有时候可能需要'重命名'`ant target`以避免与现有的gradle任务冲突.需要使用[AntBuilder.importBuilder()](https://docs.gradle.org/current/javadoc/org/gradle/api/AntBuilder.html#importBuild(java.lang.Object, org.gradle.api.Transformer))方法. 111 | 112 | **例 16.12.重命名导入的ant target** 113 | 114 | **build.gradle** 115 | ```gradle 116 | ant.importBuild('build.xml') { antTargetName -> 117 | 'a-' + antTargetName 118 | } 119 | ``` 120 | **build.xml** 121 | ```xml 122 | 123 | 124 | Hello, from Ant 125 | 126 | 127 | ``` 128 | 129 | `gradle a-hello`的输出 130 | >\> gradle a-hello 131 | >:a-hello 132 | >[ant:echo] Hello, from Ant 133 | > 134 | >BUILD SUCCESSFUL 135 | > 136 | >Total time: 1 secs 137 | 138 | 注意,方法的二个参数应该是一个[TransFormer](https://docs.gradle.org/current/javadoc/org/gradle/api/Transformer.html),在Groovy编程的时候，由于[Groovy的支持自动闭包单抽象方法的类型](http://mrhaki.blogspot.ie/2013/11/groovy-goodness-implicit-closure.html)。我们可以简单地使用闭包取代匿名内部类， 139 | 140 | -------------------------------------------------------------------------------- /using_ant_from_gradle/using_ant_from_gradle.md: -------------------------------------------------------------------------------- 1 | ## 在 Gradle中使用Ant 2 | 3 | Gradle 出色的集成了 Ant. 你可以在 Gradle 构建时使用单独的 Ant 任务或完整的 Ant 构建. 事实上, 你会发现在 Gradle 构建脚本中使用Ant任务远比直接使用 Ant 的 XML 格式更加容易和强大. 你甚至可以将 Gradle 仅仅作为一个强大的 Ant 脚本工具. 4 | 5 | Ant 可以分为两层. 第一层是 Ant 语言. 它给 build.xml 文件, 处理目标, 像 macrodefs 的特殊构造等提供语法支持. 换句话说, 除了 Ant 任务和类型, 其余一切都支持. Gradle 了解这种语言, 并允许用户直接导入 Ant 的 build.xml 到 Gradle 的项目下. 然后, 你可以 像 Gradle 任务一样直接使用这些 Ant 构建. 6 | 7 | 第二层是 Ant 丰富的任务和类型, 如 javac, copy 或 jar. Gradle 提供了基于 Groovy 的集成以及梦幻般的 AntBuilder. 8 | 9 | 最后，由于构建脚本是 Groovy 脚本, 你总是可以执行一个 Ant 构建作为一个外部进程. 构建脚本可能会含有类似的语句：“ant clean compile”.execute().[[7](https://docs.gradle.org/current/userguide/ant.html#ftn.N1135F)] 10 | 11 | 你可以使用 Gradle 的 Ant 集成，作为迁移路径将构建 Ant 迁移到 Gradle. 例如, 你可以从通过导入现有的 Ant 构建开始, 然后将你的依赖声明从 Ant 脚本迁移到你的 build 文件. 最后, 你可以将任务迁移到你的构建文件, 或者用一些 Gradle 插件代替他们. 随着时间的推移, 这部分工作会一步一步地完成, 并且你可以在整个进程中有一个运行良好的 Gradle 构建. 12 | -------------------------------------------------------------------------------- /using_ant_from_gradle/using_ant_tasks_and_types_in_your_build.md: -------------------------------------------------------------------------------- 1 | ## 16.1.使用 Ant 任务和 Ant 类型的构建 2 | 3 | 在构建脚本中, Ant 属性是由 Gradle提供的. 这是一个用于参考的 [AntBuilder](https://docs.gradle.org/current/javadoc/org/gradle/api/AntBuilder.html) 实例. AntBuilder 用于从构建脚本访问 Ant 任务, 类型和属性. 下面的例子解释了从 Ant 的 `build.xml` 格式到 Grooy 的映射. 4 | 5 | 你可以通过调用 AntBuilder 实例的方法执行 Ant 任务. 你可以使用任务名称作为方法名, 比如, 可以通过调用 `anto.echo()` 任务执行 Ant `echo` 任务. Ant 任务属性通过 Map 参数传递给方法. 下面是一个 `echo` 任务的例子, 注意我们也可以混合使用 Groovy 代码和 Ant 任务标记, 这点个功能非常强大. 6 | 7 | **例 16.1.使用 Ant 任务** 8 | 9 | **build.gradle** 10 | 11 | ```gradle 12 | task hello << { 13 | String greeting = 'hello from Ant' 14 | ant.echo(message: greeting) 15 | } 16 | ``` 17 | 18 | `gradle hello` 的输出 19 | ``` 20 | >\> gradle hello 21 | >:hello 22 | >[ant:echo] hello from Ant 23 | > 24 | >BUILD SUCCESSFUL 25 | > 26 | >Total time: 1 secs 27 | ``` 28 | 29 | 你可以添加嵌套元素添加到一个封闭的 Ant 任务的内部. 定义嵌套元素跟定义任务的方式相同, 通过与调用我们要定义的元素名相同的方法. 30 | 31 | **例 16.3.添加嵌套元素到一个Ant任务** 32 | 33 | **build.gradle** 34 | ```gradle 35 | task zip << { 36 | ant.zip(destfile: 'archive.zip') { 37 | fileset(dir: 'src') { 38 | include(name: '**.xml') 39 | exclude(name: '**.java') 40 | } 41 | } 42 | } 43 | ``` 44 | 45 | 你可以像访问任务一样访问 Ant type,只需要将 type 名作为方法名即可. 该方法调用返回的 Ant 数据类型，可以直接在构建脚本中使用.下面的例子中,我们创建了一个`ant path`对象,然后遍历他的内容. 46 | 47 | **例 16.4.使用 Ant 类型** 48 | 49 | **build.gradle** 50 | ```gradle 51 | task list << { 52 | def path = ant.path { 53 | fileset(dir: 'libs', includes: '*.jar') 54 | } 55 | path.list().each { 56 | println it 57 | } 58 | } 59 | ``` 60 | 61 | 更多关于 AntBuilder 的信息可以参考 'Groovy in Action'8.4 或者[Groovy Wiki](http://groovy.codehaus.org/Using+Ant+from+Groovy). 62 | 63 | -------------------------------------------------------------------------------- /using_ant_from_gradle/using_custom_ant_tasks_in_your_build.md: -------------------------------------------------------------------------------- 1 | ## 在构建中使用自定义Ant任务 2 | 3 | 为了让你的构建可以自定义任务, 你可以使用 `taskdef(通常更容易)` 或者 `typedef` Ant 任务, 就像你在一个`build.xml`文件中一样. 然后，你可以参考内置 Ant 任务去定制 Ant 任务. 4 | 5 | **例 16.5.使用自定义 Ant 任务** 6 | 7 | **build.gradle** 8 | ```gradle 9 | task check << { 10 | ant.taskdef(resource: 'checkstyletask.properties') { 11 | classpath { 12 | fileset(dir: 'libs', includes: '*.jar') 13 | } 14 | } 15 | ant.checkstyle(config: 'checkstyle.xml') { 16 | fileset(dir: 'src') 17 | } 18 | } 19 | ``` 20 | 21 | 你可以使用 Gradle 的依赖管理去组装你自定义任务所需要的 classpath. 要做到这一点, 你需要定义一个自定义配置类路径, 然后添加一些依赖配置.在[Section 51.4, “How to declare your dependencies”](https://docs.gradle.org/current/userguide/dependency_management.html#sec:how_to_declare_your_dependencies)部分有更详细的说明. 22 | 23 | **例 16.6.声明类路径的自定义 Ant 任务** 24 | 25 | **build.gradle** 26 | ```gradle 27 | configurations { 28 | pmd 29 | } 30 | 31 | dependencies { 32 | pmd group: 'pmd', name: 'pmd', version: '4.2.5' 33 | } 34 | ``` 35 | 36 | 要使用 classpath 配置, 使用自定义配置的`asPath`属性。 37 | 38 | **例 16.7.一起使用自定义Ant任务和依赖管理** 39 | 40 | **build.gradle** 41 | 42 | ```gradle 43 | task check << { 44 | ant.taskdef(name: 'pmd', 45 | classname: 'net.sourceforge.pmd.ant.PMDTask', 46 | classpath: configurations.pmd.asPath) 47 | ant.pmd(shortFilenames: 'true', 48 | failonruleviolation: 'true', 49 | rulesetfiles: file('pmd-rules.xml').toURI().toString()) { 50 | formatter(type: 'text', toConsole: 'true') 51 | fileset(dir: 'src') 52 | } 53 | } 54 | ``` 55 | -------------------------------------------------------------------------------- /using_the_gradle_command-line/README.md: -------------------------------------------------------------------------------- 1 | # 使用 Gradle 命令行 2 | 3 | 本章介绍了命令行的一些基本功能.正如在前面的章节里你所见到的调用 **gradle** 命令来运行一个构建. 4 | -------------------------------------------------------------------------------- /using_the_gradle_command-line/continuing_the_build_when_a_failure_occurs.md: -------------------------------------------------------------------------------- 1 | # 失败后继续执行构建 2 | 3 | 默认情况下, 只要有任务调用失败, Gradle就会中断执行. 这可能会使调用过程更快, 但那些后面隐藏的错误就没有办法发现了. 所以你可以使用 `--continue` 选项在一次调用中尽可能多的发现所有问题. 4 | 5 | 6 | 采用 `--continue` 选项, Gralde 会调用*每一个*任务以及它们依赖的任务. 而不是一旦出现错误就会中断执行.所有错误信息都会在最后被列出来. 7 | 8 | 9 | 一旦某个任务执行失败,那么所有依赖于该任务的子任务都不会被调用.例如由于 test 任务依赖于 complie 任务,所以如果 compile 调用出错, test 便不会被直接或间接调用. 10 | 11 | 12 | -------------------------------------------------------------------------------- /using_the_gradle_command-line/excluding_tasks.md: -------------------------------------------------------------------------------- 1 | # 排除任务 2 | 3 | 你可以用命令行选项-x来排除某些任务,让我们用上面的例子来示范一下. 4 | 5 | *例子 11.2. 排除任务* 6 | 7 | `gradle dist -x test` 命令的输出 8 | 9 | > gradle dist -x test 10 | :compile 11 | compiling source 12 | :dist 13 | building the distribution 14 | 15 | BUILD SUCCESSFUL 16 | 17 | Total time: 1 secs 18 | 19 | 可以看到, test 任务并没有被调用,即使它是 dist 任务的依赖. 同时 test 任务的依赖任务 compileTest 也没有被调用,而像 compile 被 test 和其它任务同时依赖的任务仍然会被调用. 20 | 21 | 22 | -------------------------------------------------------------------------------- /using_the_gradle_command-line/executing_multiple_tasks.md: -------------------------------------------------------------------------------- 1 | # 多任务调用 2 | 3 | 你可以以列表的形式在命令行中一次调用多个任务. 4 | 例如 **gradle compile test** 命令会依次调用 compile 和 test 任务, 它们所依赖的任务也会被调用. 这些任务只会被调用一次, 无论它们是否被包含在脚本中:即无论是以命令行的形式定义的任务还是依赖于其它任务都会被调用执行.来看下面的例子. 5 | 6 | 下面定义了四个任务 dist和test 都 依赖于 compile ,只用当 compile 被调用之后才会调用 `gradle dist test` 任务 7 | 8 | 9 | **示例图 11.1. 任务依赖** 10 | 11 | ![Task dependencies](http://pkaq.github.io/gradledoc/docs/userguide/img/commandLineTutorialTasks.png) 12 | 13 | **例子 11.1. 多任务调用** 14 | 15 | **build.gradle** 16 | 17 | task compile << { 18 | println 'compiling source' 19 | } 20 | 21 | task compileTest(dependsOn: compile) << { 22 | println 'compiling unit tests' 23 | } 24 | 25 | task test(dependsOn: [compile, compileTest]) << { 26 | println 'running unit tests' 27 | } 28 | 29 | task dist(dependsOn: [compile, test]) << { 30 | println 'building the distribution' 31 | } 32 | 33 | **gradle dist test** 命令的输出 34 | 35 | > gradle dist test 36 | :compile 37 | compiling source 38 | :compileTest 39 | compiling unit tests 40 | :test 41 | running unit tests 42 | :dist 43 | building the distribution 44 | 45 | BUILD SUCCESSFUL 46 | 47 | Total time: 1 secs 48 | 49 | 由于每个任务仅会被调用一次,所以调用**gradle test test**与调用**gradle test**效果是相同的. 50 | 51 | -------------------------------------------------------------------------------- /using_the_gradle_command-line/getting_the_insight_into_a_particular_dependency.md: -------------------------------------------------------------------------------- 1 | # 查看特定依赖 2 | 3 | 执行 `gradle dependencyInsight` 命令可以查看指定的依赖. 如下面的例子. 4 | 5 | **例 11.15. 获取特定依赖** 6 | 7 | `gradle -q webapp:dependencyInsight --dependency groovy --configuration compile` 的输出结果 8 | 9 | ``` 10 | > gradle -q webapp:dependencyInsight --dependency groovy --configuration compile 11 | org.codehaus.groovy:groovy-all:2.3.3 12 | \--- project :api 13 | \--- compile 14 | ``` 15 | 16 | 17 | 这个 task 对于了解依赖关系、了解为何选择此版本作为依赖十分有用.了解更多请参阅 [DependencyInsightReportTask](https://docs.gradle.org/current/dsl/org.gradle.api.tasks.diagnostics.DependencyInsightReportTask.html). 18 | 19 | dependencyInsight 任务是'Help'任务组中的一个. 这项任务需要进行配置才可以使用. Report 查找那些在指定的配置里特定的依赖. 20 | 21 | 如果用了Java相关的插件, 那么 dependencyInsight 任务已经预先被配置到'compile'下了. 你只需要通过 `'--dependency'` 参数来制定所需查看的依赖即可. 如果你不想用默认配置的参数项你可以通过`'--configuration'`参数来进行指定.了解更多请参阅 [DependencyInsightReportTask](https://docs.gradle.org/current/dsl/org.gradle.api.tasks.diagnostics.DependencyInsightReportTask.html). 22 | -------------------------------------------------------------------------------- /using_the_gradle_command-line/listing_project_dependencies.md: -------------------------------------------------------------------------------- 1 | # 获取依赖列表 2 | 3 | 执行 `gradle dependencies` 命令会列出项目的依赖列表, 所有依赖会根据任务区分,以树型结构展示出来. 4 | 如下例: 5 | 6 | **例 11.13. 获取依赖信息** 7 | 8 | *gradle -q dependencies api:dependencies webapp:dependencies 的输出结果* 9 | 10 | > gradle -q dependencies api:dependencies webapp:dependencies 11 | ------------------------------------------------------------ 12 | Root project 13 | ------------------------------------------------------------ 14 | 15 | No configurations 16 | 17 | ------------------------------------------------------------ 18 | Project :api - The shared API for the application 19 | ------------------------------------------------------------ 20 | 21 | compile 22 | \--- org.codehaus.groovy:groovy-all:2.3.3 23 | 24 | testCompile 25 | \--- junit:junit:4.11 26 | \--- org.hamcrest:hamcrest-core:1.3 27 | 28 | ------------------------------------------------------------ 29 | Project :webapp - The Web application implementation 30 | ------------------------------------------------------------ 31 | 32 | compile 33 | +--- project :api 34 | | \--- org.codehaus.groovy:groovy-all:2.3.3 35 | \--- commons-io:commons-io:1.2 36 | 37 | testCompile 38 | No dependencies 39 | 40 | 虽然输出结果很多, 41 | 但这对于了解构建任务十分有用, 42 | 当然你可以通过 `--configuration` 参数来查看 指定构建任务的依赖情况: 43 | 44 | **例 11.14. 过滤依赖信息** 45 | 46 | `gradle -q api:dependencies --configuration testCompile` 的输出结果 47 | 48 | > gradle -q api:dependencies --configuration testCompile 49 | ------------------------------------------------------------ 50 | Project :api - The shared API for the application 51 | ------------------------------------------------------------ 52 | 53 | testCompile 54 | \--- junit:junit:4.11 55 | \--- org.hamcrest:hamcrest-core:1.3 56 | -------------------------------------------------------------------------------- /using_the_gradle_command-line/listing_project_properties.md: -------------------------------------------------------------------------------- 1 | # 获取项目属性列表 2 | 3 | 执行 `gradle properties` 可以获取项目所有属性列表. 如下例: 4 | 5 | **例 11.16. 属性信息** 6 | 7 | `gradle -q api:properties` 的输出结果 8 | 9 | ``` 10 | > gradle -q api:properties 11 | ------------------------------------------------------------ 12 | Project :api - The shared API for the application 13 | ------------------------------------------------------------ 14 | 15 | allprojects: [project ':api'] 16 | ant: org.gradle.api.internal.project.DefaultAntBuilder@12345 17 | antBuilderFactory: org.gradle.api.internal.project.DefaultAntBuilderFactory@12345 18 | artifacts: org.gradle.api.internal.artifacts.dsl.DefaultArtifactHandler@12345 19 | asDynamicObject: org.gradle.api.internal.ExtensibleDynamicObject@12345 20 | baseClassLoaderScope: org.gradle.api.internal.initialization.DefaultClassLoaderScope@12345 21 | buildDir: /home/user/gradle/samples/userguide/tutorial/projectReports/api/build 22 | buildFile: /home/user/gradle/samples/userguide/tutorial/projectReports/api/build.gradle 23 | ``` 24 | 25 | -------------------------------------------------------------------------------- /using_the_gradle_command-line/listing_projects.md: -------------------------------------------------------------------------------- 1 | # 项目列表 2 | 3 | 执行 `gradle projects` 命令会为你列出子项目名称列表. 4 | 5 | **例 11.7. 收集项目信息** 6 | 7 | **gradle -q projects** 命令的输出结果 8 | 9 | > gradle -q projects 10 | ------------------------------------------------------------ 11 | Root project 12 | ------------------------------------------------------------ 13 | 14 | Root project 'projectReports' 15 | +--- Project ':api' - The shared API for the application 16 | \--- Project ':webapp' - The Web application implementation 17 | 18 | To see a list of the tasks of a project, run gradle :tasks 19 | For example, try running gradle :api:tasks 20 | 21 | 这份报告展示了每个项目的描述信息. 22 | 当然你可以在项目中用 **description** 属性来指定这些描述信息. 23 | 24 | **例 10.8. 为项目添加描述信息** 25 | 26 | *build.gradle* 27 | 28 | description = 'The shared API for the application' 29 | -------------------------------------------------------------------------------- /using_the_gradle_command-line/listing_tasks.md: -------------------------------------------------------------------------------- 1 | # 获取构建信息 2 | 3 | Gradle提供了许多内置任务来收集构建信息. 4 | 这些内置任务对于了解依赖结构以及解决问题都是很有帮助的. 5 | 6 | 了解更多, 7 | 可以参阅[项目报告插件](http://www.gradle.org/docs/current/userguide/userguide_single.html#project_reports_plugin)以为你的项目添加构建报告 8 | -------------------------------------------------------------------------------- /using_the_gradle_command-line/listing_taskss.md: -------------------------------------------------------------------------------- 1 | # 任务列表 2 | 3 | 执行 `gradle tasks` 命令会列出项目中所有任务. 4 | 这会显示项目中所有的默认任务以及每个任务的描述. 5 | 6 | 例 11.9 获取任务信息 7 | 8 | **gradle -q tasks** 命令的输出 9 | 10 | ``` 11 | > gradle -q tasks 12 | ------------------------------------------------------------ 13 | All tasks runnable from root project 14 | ------------------------------------------------------------ 15 | 16 | Default tasks: dists 17 | 18 | Build tasks 19 | ----------- 20 | clean - Deletes the build directory (build) 21 | dists - Builds the distribution 22 | libs - Builds the JAR 23 | 24 | Build Setup tasks 25 | ----------------- 26 | init - Initializes a new Gradle build. [incubating] 27 | wrapper - Generates Gradle wrapper files. [incubating] 28 | 29 | Help tasks 30 | ---------- 31 | dependencies - Displays all dependencies declared in root project 'projectReports'. 32 | dependencyInsight - Displays the insight into a specific dependency in root project 'projectReports'. 33 | help - Displays a help message 34 | projects - Displays the sub-projects of root project 'projectReports'. 35 | properties - Displays the properties of root project 'projectReports'. 36 | tasks - Displays the tasks runnable from root project 'projectReports' (some of the displayed tasks may belong to subprojects). 37 | 38 | To see all tasks and more detail, run with --all.``` 39 | 40 | 默认情况下,这只会显示那些被分组的任务. 41 | 你可以通过为任务设置 **group** 属性和 **description** 来把 这些信息展示到结果中. 42 | 43 | **例 11.10. 更改任务报告内容** 44 | 45 | **build.gradle** 46 | 47 | ``` 48 | dists { 49 | description = 'Builds the distribution' 50 | group = 'build' 51 | }``` 52 | 53 | 当然你也可以用 **--all** 参数来收集更多任务信息. 54 | 这会列出项目中所有任务以及任务之间的依赖关系. 55 | 56 | 例 11.11 获得更多的任务信息 57 | 58 | **gradle -q tasks --all** 命令的输出 59 | 60 | ``` 61 | > gradle -q tasks --all 62 | ------------------------------------------------------------ 63 | All tasks runnable from root project 64 | ------------------------------------------------------------ 65 | 66 | Default tasks: dists 67 | 68 | Build tasks 69 | ----------- 70 | clean - Deletes the build directory (build) 71 | api:clean - Deletes the build directory (build) 72 | webapp:clean - Deletes the build directory (build) 73 | dists - Builds the distribution [api:libs, webapp:libs] 74 | docs - Builds the documentation 75 | api:libs - Builds the JAR 76 | api:compile - Compiles the source files 77 | webapp:libs - Builds the JAR [api:libs] 78 | webapp:compile - Compiles the source files 79 | 80 | Build Setup tasks 81 | ----------------- 82 | init - Initializes a new Gradle build. [incubating] 83 | wrapper - Generates Gradle wrapper files. [incubating] 84 | 85 | Help tasks 86 | ---------- 87 | dependencies - Displays all dependencies declared in root project 'projectReports'. 88 | api:dependencies - Displays all dependencies declared in project ':api'. 89 | webapp:dependencies - Displays all dependencies declared in project ':webapp'. 90 | dependencyInsight - Displays the insight into a specific dependency in root project 'projectReports'. 91 | api:dependencyInsight - Displays the insight into a specific dependency in project ':api'. 92 | webapp:dependencyInsight - Displays the insight into a specific dependency in project ':webapp'. 93 | help - Displays a help message 94 | api:help - Displays a help message 95 | webapp:help - Displays a help message 96 | projects - Displays the sub-projects of root project 'projectReports'. 97 | api:projects - Displays the sub-projects of project ':api'. 98 | webapp:projects - Displays the sub-projects of project ':webapp'. 99 | properties - Displays the properties of root project 'projectReports'. 100 | api:properties - Displays the properties of project ':api'. 101 | webapp:properties - Displays the properties of project ':webapp'. 102 | tasks - Displays the tasks runnable from root project 'projectReports' (some of the displayed tasks may belong to subprojects). 103 | api:tasks - Displays the tasks runnable from project ':api'. 104 | webapp:tasks - Displays the tasks runnable from project ':webapp'.``` 105 | 106 | -------------------------------------------------------------------------------- /using_the_gradle_command-line/profiling_a_build.md: -------------------------------------------------------------------------------- 1 | # 构建日志 2 | 3 | **--profile** 参数可以收集一些构建期间的信息并保存到 build/reports/profile 目录下. 并且会以构建时间命名这些文件. 4 | 5 | 下面是一份日志. 6 | 这份日志记录了总体花费时间以及各过程花费的时间. 7 | 并以时间大小倒序排列. 8 | 并且记录了任务的执行情况. 9 | 10 | 如果采用了 buildSrc, 11 | 那么在 buildSrc/build 下同时也会生成一份日志记录记录. 12 | 13 | ![](http://gradle.org/docs/current/userguide/img/profile.png) 14 | -------------------------------------------------------------------------------- /using_the_gradle_command-line/selecting_which_build_to_execute.md: -------------------------------------------------------------------------------- 1 | # 选择执行构建 2 | 3 | 调用 gradle 命令时, 4 | 默认情况下总是会构建当前目录下的文件, 可以使用 **-b** 参数选择其他目录的构建文件, 5 | 并且当你使用此参数时 settings.gradle 将不会生效, 6 | 看下面的例子: 7 | 8 | **例 11.5. 选择文件构建** 9 | 10 | **subdir/myproject.gradle** 11 | 12 | task hello << { 13 | println "using build file '$buildFile.name' in '$buildFile.parentFile.name'." 14 | } 15 | 16 | **gradle -q -b subdir/myproject.gradle hello** 的输出 17 | 18 | gradle -q -b subdir/myproject.gradle hello 19 | using build file 'myproject.gradle' in 'subdir'. 20 | 21 | 另外,你可以使用 **-p** 参数来指定构建的目录,例如在多项目构建中你可以用 -p 来替代 -b 参数 22 | 23 | 例 10.6. 选择构建目录 24 | 25 | **gradle -q -p subdir hello** 命令的输出 26 | 27 | gradle -q -p subdir hello 28 | using build file 'build.gradle' in 'subdir'. 29 | 30 | **-b** 参数用以指定脚本具体所在位置, 31 | 格式为 dirpwd/build.gradle. 32 | 33 | **-p** 参数用以指定脚本目录即可. 34 | -------------------------------------------------------------------------------- /using_the_gradle_command-line/show_task_usage_details.md: -------------------------------------------------------------------------------- 1 | # 获取任务具体信息 2 | 3 | 执行 **gradle help --task someTask** 可以显示指定任务的详细信息. 或者多项目构建中相同任务名称的所有任务的信息. 4 | 如下例. 5 | 6 | *例 11.12. 获取任务帮助* 7 | 8 | *gradle -q help --task libs的输出结果* 9 | 10 | > gradle -q help --task libs 11 | Detailed task information for libs 12 | 13 | Paths 14 | :api:libs 15 | :webapp:libs 16 | 17 | Type 18 | Task (org.gradle.api.Task) 19 | 20 | Description 21 | Builds the JAR 22 | 23 | 这些结果包含了任务的路径、类型以及描述信息等. 24 | -------------------------------------------------------------------------------- /using_the_gradle_command-line/task_name_abbreviation.md: -------------------------------------------------------------------------------- 1 | # 简化任务名 2 | 3 | 当你试图调用某个任务的时候, 4 | 你并不需要输入任务的全名. 5 | 只需提供足够的可以唯一区分出该任务的字符即可. 6 | 例如, 7 | 上面的例子你也可以这么写. 8 | 用 `gradle di` 来直接调用 dist 任务: 9 | 10 | **例 11.3. 简化任务名** 11 | 12 | `gradle di` 命令的输出 13 | 14 | > gradle di 15 | :compile 16 | compiling source 17 | :compileTest 18 | compiling unit tests 19 | :test 20 | running unit tests 21 | :dist 22 | building the distribution 23 | 24 | BUILD SUCCESSFUL 25 | 26 | Total time: 1 secs 27 | 28 | 你也可以用在驼峰命名方式 (通俗的说就是每个单词的第一个字母大写,除了第一个单词) 的任务中每个单词的首字母进行调用. 29 | 例如, 30 | 可以执行 `gradle compTest` 或者 `gradle cT` 来调用 compileTest 任务 31 | 32 | **例 11.4. 简化驼峰方式的任务名** 33 | 34 | `gradle cT` 命令的输出 35 | 36 | > gradle cT 37 | :compile 38 | compiling source 39 | :compileTest 40 | compiling unit tests 41 | 42 | BUILD SUCCESSFUL 43 | 44 | Total time: 1 secs 45 | 46 | 简化后你仍然可以使用-x参数. 47 | 48 | -------------------------------------------------------------------------------- /using_the_gradle_graphical_user_interface/README.md: -------------------------------------------------------------------------------- 1 | # 使用 Gradle 图形界面 2 | 3 | 为了辅助传统的命令行交互，Gradle还提供了一个图形界面.我们可以使用Gradle命令中**--gui**选项来启动它. 4 | 5 | 例子 12.1. 启动图形界面 6 | 7 | gradle --gui 8 | 9 | **注意：**这个命令执行后会使得命令行一直处于封锁状态，直到我们关闭图形界面. 10 | 不过我们可以另外加上**“&”**让它在后台执行： 11 | 12 | gradle --gui& 13 | 14 | 如果我们从自己的Gradle项目目录中启动这个图形界面，我们应该会看到任务树. 15 | 16 | 图 12.1. 任务树 17 | 18 | ![](http://gradle.org/docs/current/userguide/img/guiTaskTree.png) 19 | 20 | 我们建议您从当前的Gradle项目目录启动图形界面，因为这种方式可以将有关于界面的一些设置存储到您目录里面.不过您也可以在启动它后切换工作目录，方式：通过界面中**“Setup”**选项卡可以设置. 21 | 22 | 如您所见，这个界面在顶部有4个选项卡和底部一个输出窗口. 23 | 24 | -------------------------------------------------------------------------------- /using_the_gradle_graphical_user_interface/command_line.md: -------------------------------------------------------------------------------- 1 | # 命令行 2 | 3 | 4 | 在**“Command Line”**选项卡，您只需将命令填入到**gradle**输入框. 就可以直接执行单个的Gradle命令. 或者说在您将某个命令添加到收藏夹之前，您想看看是什么效果的话，不妨来这里试试. 5 | 6 | -------------------------------------------------------------------------------- /using_the_gradle_graphical_user_interface/favorities.md: -------------------------------------------------------------------------------- 1 | # 收藏夹 2 | 3 | **"Favorites"**选项卡是个好地方. 您可以收藏常用的命令. 即使是复杂的命令集，只要它符合**Gradle规范**，您都可以添加收藏，而且您还可以为它起个通俗易懂的别名. 这个方法逼格是不是很高. 一个一眼看上去就让人明白的自定义的命令，我们可以称它为“侩子手”（fast build）. 4 | 5 | 6 | 您还可以对收藏的任务进行排序，或者您可以导出它们到磁盘，然后将导出的命令分享给别的小伙伴使用. 如果您想编辑它们，如您所见，我们会看到有个**"Always Show Live Output"**选项，如果您勾选了，可以强制命令在执行时显示在输出窗口. 7 | 8 | -------------------------------------------------------------------------------- /using_the_gradle_graphical_user_interface/setup.md: -------------------------------------------------------------------------------- 1 | # 设置 2 | 3 | 在设置界面，你可以配置一些常用的设置. 4 | 5 | 图 12.2 设置界面 6 | 7 | ![](http://gradle.org/docs/current/userguide/img/guiSetup.png) 8 | 9 | 10 | * **“Current Directory”** 图形界面会默认设置您的Gradle项目的根目录(build.gradle 文件所在的目录)为当前目录. 11 | 12 | * **“Stack Trace Output“** 这个选项可以指定当错误发生时，有多少信息可以写入到轨迹栈中，注意：在您设定轨迹栈级别后，如果"Command Line"(命令行)选项卡中，或者在"Favorites"（收藏夹）选项卡中的命令发生错误,这个设置就不会起作用了. 13 | 14 | * **”Only Show Output When Errors Occur”** 设定当编译出问题时输出窗口才显示相关信息. 15 | 16 | * **"Use Custom Gradle Executor"** 高级功能，您可以指定一个路径启动Gradle命令代替默认的设置，例如您的项目需要在别的批处理文件或者shell脚本进行额外的配置（例如指定一个初始化脚本），这种情况您就可以使用它. 17 | 18 | -------------------------------------------------------------------------------- /using_the_gradle_graphical_user_interface/task_tree.md: -------------------------------------------------------------------------------- 1 | # 任务树 2 | 3 | 任务树使用分层方式显示了所有的项目和它们的任务，双击一个任务，您就可以执行它. 4 | 5 | 6 | 另外我们还可以使用过滤器过滤掉不常用的任务. 您可以点击 **Filter** 按钮来设置过滤条件. 设定哪些任务和项目可以显示. 隐藏的任务会使用红色来标记. 7 | 8 | **注意：**最新被创建的任务会默认被显示出来(相反是被隐藏). 9 | 10 | 11 | 如您所见，在任务树界面我们可以做以下几种事情： 12 | 13 | 14 | * 执行任务时忽略依赖性，而且并不需要重新编译独立的项目. 15 | 16 | * 添加自己喜欢的任务，将其收藏(具体请看**“Favorities”**选项卡). 17 | 18 | 19 | * 隐藏自己不想看到的任务，这个操作会将他们添加到过滤器中. 20 | 21 | 22 | * 编辑 build.gradke 文件， 23 | 注意：这个需要你的jdk版本为1.6以上，而且你的操作系统需要关联 .gradle 文件. 24 | 25 | 26 | 27 | -------------------------------------------------------------------------------- /web_application_quickstart/README.md: -------------------------------------------------------------------------------- 1 | # 网页应用快速入门 2 | 3 | > 本章是一项正在进行中的工作. 4 | 5 | Gradle 提供了两个插件用来支持网页应用: War 插件和 Jetty 插件. War 插件是在 Java 插件的基础上扩充的用来构建 WAR 文件. Jetty 插件是在 War 插件的基础上扩充的, 允许用户将网页应用发布到一个介入的 Jetty 容器里. 6 | 7 | -------------------------------------------------------------------------------- /web_application_quickstart/building_a_war_file.md: -------------------------------------------------------------------------------- 1 | # 构建一个 WAR 文件 2 | 3 | 为了构建一个 WAR 文件, 需要在项目中加入 War 插件: 4 | 5 | *例子 9.1. War 插件* 6 | 7 | *build.gradle* 8 | 9 | apply plugin: 'war' 10 | 11 | > 注意:项目代码可以在`samples/webApplication/quickstart` 在Gradle的发行包`"-all"`中找到. 12 | 13 | 这个插件也会在你的项目里加入 Java 插件. 运行 **gradle build** 将会编译, 测试和创建项目的 WAR 文件. Gradle 将会把源文件包含在 WAR 文件的 src/main/webapp 目录里. 编译后的 classe , 和它们运行所需要的依赖也会被包含在 WAR 文件里. 14 | -------------------------------------------------------------------------------- /web_application_quickstart/running_your_web_application.md: -------------------------------------------------------------------------------- 1 | # Running your web application 2 | 3 | 要启动Web工程,在项目中加入Jetty plugin即可: 4 | 5 | *例 9.2. 采用Jetty plugin启动web工程* 6 | 7 | *build.gradle* 8 | 9 | apply plugin: 'jetty' 10 | 11 | 由于Jetty plugin继承自War plugin.使用 `gradle jettyRun` 命令将会把你的工程启动部署到jetty容器中. 调用 `gradle jettyRunWar` 命令会打包并启动部署到jetty容器中. 12 | 13 | > **Groovy web applications** 14 | > 你可以结合多个插件在一个项目中,所以你可以一起使用`War` 和 `Groovy`插件构建一个 Groovy 基础 web 应用.合适的 Groovy 类库会添加到你的 `WAR` 文件中. 15 | 16 | TODO: which url, configure port, uses source files in place and can edit your files and reload. 17 | -------------------------------------------------------------------------------- /web_application_quickstart/summary.md: -------------------------------------------------------------------------------- 1 | # 总结 2 | 3 | 了解更多关于War plugin和Jetty plugin的应用请参阅[Chapter 26,The War Plugin](https://docs.gradle.org/current/userguide/war_plugin.html)以及[Chapter 28,The Jetty Plugin](https://docs.gradle.org/current/userguide/jetty_plugin.html). 4 | 5 | 你可以在发行包的samples/webApplication下找到更多示例. 6 | -------------------------------------------------------------------------------- /working_with_files/README.md: -------------------------------------------------------------------------------- 1 | # 文件操作 2 | 3 | 大多数构建工作需要操作文件，Gradle 增加了一些API帮助您处理这些工作。 4 | -------------------------------------------------------------------------------- /working_with_files/copying_files.md: -------------------------------------------------------------------------------- 1 | #复制文件 2 | 3 | 你可以使用复制任务( `Copy` )去复制文件. 复制任务扩展性很强,能够过滤复制文件的内容, 映射文件名. 4 | 5 | 使用复制任务时需要提供想要复制的源文件和一个目标目录,如果你要指定文件被复制时的转换方式，可以使用 _复制规则_. 复制规则被 `CopySpec` 接口抽象,复制任务实现了这个接口. 使用 `CopySpec.from()` 方法指定源文件.使用 `CopySpec.into()` 方法指定目标目录. 6 | 7 | **例 15.10. 使用复制任务复制文件** 8 | 9 | **build.gradle** 10 | ``` 11 | task copyTask(type: Copy) { 12 | from 'src/main/webapp' 13 | into 'build/explodedWar' 14 | } 15 | 16 | ``` 17 | 18 | `from()` 方法接收任何 `files()` 方法支持的参数. 当参数被解析为一个目录时,在这个目录下的任何文件都会被递归地复制到目标目录(但不是目录本身).当一个参数解析为一个文件时,该文件被复制到目标目录中.当参数被解析为一个不存在的文件时,这个参数就会忽略.如果这个参数是一个任务,任务的输出文件(这个任务创建的文件)会被复制,然后这个任务会被自动添加为复制任务的依赖. 19 | 20 | **例 15.11 指定复制任务的源文件和目标目录** 21 | 22 | **build.gradle** 23 | ``` 24 | task anotherCopyTask(type: Copy) { 25 | // 复制 src/main/webapp 目录下的所有文件 26 | from 'src/main/webapp' 27 | // 复制一个单独文件 28 | from 'src/staging/index.html' 29 | // 复制一个任务输出的文件 30 | from copyTask 31 | // 显式使用任务的 outputs 属性复制任务的输出文件 32 | from copyTaskWithPatterns.outputs 33 | // 复制一个 ZIP 压缩文件的内容 34 | from zipTree('src/main/assets.zip') 35 | // 最后指定目标目录 36 | into { getDestDir() } 37 | } 38 | 39 | ``` 40 | 41 | 你可以使用`Ant-style` 规则或者一个闭合选择要复制的文件. 42 | 43 | **例 15.12 选择要复制文件** 44 | 45 | **build.gradle** 46 | ``` 47 | task copyTaskWithPatterns(type: Copy) { 48 | from 'src/main/webapp' 49 | into 'build/explodedWar' 50 | include '**/*.html' 51 | include '**/*.jsp' 52 | exclude { details -> details.file.name.endsWith('.html') && 53 | details.file.text.contains('staging') } 54 | } 55 | ``` 56 | 你也可以使用 `Project.copy()` 方法复制文件,它的工作方式有一些限制,首先该方法不是增量的,请参考 [第 14.9节 跳过最新的任务](https://docs.gradle.org/current/userguide/more_about_tasks.html#sec:up_to_date_checks).第二,当一个任务被用作复制源时(例如 from() 方法的参数), `copy()` 方法不能够实现任务依赖,因为它是一个普通的方法不是一个任务.因此,如果你使用 `copy()`方法作为一个任务的一部分功能,你需要显式的声明所有的输入和输出以确保获得正确的结果. 57 | 58 | **例 15.13 不使用最新检查方式下用 copy() 方法复制文件** 59 | 60 | **build.gradle** 61 | ``` 62 | task copyMethod << { 63 | copy { 64 | from 'src/main/webapp' 65 | into 'build/explodedWar' 66 | include '**/*.html' 67 | include '**/*.jsp' 68 | } 69 | } 70 | ``` 71 | 72 | 73 | 74 | **例 15.14 使用最新的检查方式下用 copy() 方法复制文件** 75 | 76 | **build.gradle** 77 | 78 | ``` 79 | task copyMethodWithExplicitDependencies{ 80 | 81 | // 对输入做最新检查,添加 copyTask 作为依赖 82 | inputs.file copyTask 83 | outputs.dir 'some-dir' //对输出做最新检查 84 | doLast{ 85 | copy { 86 | // 复制 copyTask 的输出 87 | from copyTask 88 | into 'some-dir' 89 | } 90 | } 91 | } 92 | 93 | ``` 94 | 95 | 建议尽可能的使用复制任务,因为它支持增量化的构建和任务依赖推理，而不需要去额外的费力处理这些.不过 `copy()` 方法可以用作复制任务实现的一部分.即该 方法被在自定义复制任务中使用,请参考 [第60章 编写自定义任务](https://docs.gradle.org/current/userguide/custom_tasks.html).在这样的场景下，自定义任务应该充分声明与复制操作相关的输入/输出。 96 | 97 | ##15.6.1 重命名文件 98 | 99 | **例 15.15 在复制时重命名文件** 100 | 101 | **build.gradle** 102 | 103 | ``` 104 | task rename(type: Copy) { 105 | from 'src/main/webapp' 106 | into 'build/explodedWar' 107 | // 使用一个闭合映射文件名 108 | rename { String fileName -> 109 | fileName.replace('-staging-', '') 110 | } 111 | // 使用正则表达式映射文件名 112 | rename '(.+)-staging-(.+)', '$1$2' 113 | rename(/(.+)-staging-(.+)/, '$1$2') 114 | } 115 | 116 | ``` 117 | 118 | ##15.6.2 过滤文件 119 | 120 | **例 15.16 在复制时过滤文件** 121 | 122 | **build.gradle** 123 | 124 | ``` 125 | import org.apache.tools.ant.filters.FixCrLfFilter 126 | import org.apache.tools.ant.filters.ReplaceTokens 127 | 128 | task filter(type: Copy) { 129 | from 'src/main/webapp' 130 | into 'build/explodedWar' 131 | // 在文件中替代属性标记 132 | expand(copyright: '2009', version: '2.3.1') 133 | expand(project.properties) 134 | // 使用 Ant 提供的过滤器 135 | filter(FixCrLfFilter) 136 | filter(ReplaceTokens, tokens: [copyright: '2009', version: '2.3.1']) 137 | // 用一个闭合来过滤每一行 138 | filter { String line -> 139 | "[$line]" 140 | } 141 | // 使用闭合来删除行 142 | filter { String line -> 143 | line.startsWith('-') ? null : line 144 | } 145 | } 146 | 147 | ``` 148 | 在源文件中扩展和过滤操作都会查找的某个标志 `token`,如果它的名字是 `tokenName` , 它的格式应该类似于 `@tokenName@`. 149 | 150 | ## 15.6.3 使用 CopySpec 类 151 | 152 | 复制规范来自于层次结构,一个复制规范继承其目标路径,包括模式,排除模式，复制操作,名称映射和过滤器. 153 | 154 | **例 15.17. 嵌套复制规范** 155 | 156 | **build.gradle** 157 | 158 | ``` 159 | task nestedSpecs(type: Copy) { 160 | into 'build/explodedWar' 161 | exclude '**/*staging*' 162 | from('src/dist') { 163 | include '**/*.html' 164 | } 165 | into('libs') { 166 | from configurations.runtime 167 | } 168 | } 169 | 170 | 171 | ``` 172 | 173 | 174 | 175 | 176 | 177 | 178 | 179 | 180 | 181 | 182 | 183 | 184 | 185 | 186 | 187 | 188 | 189 | 190 | 191 | 192 | 193 | 194 | 195 | 196 | 197 | 198 | 199 | 200 | 201 | 202 | 203 | 204 | 205 | 206 | 207 | 208 | 209 | 210 | 211 | 212 | 213 | -------------------------------------------------------------------------------- /working_with_files/creating_archives.md: -------------------------------------------------------------------------------- 1 | # 创建归档文件 2 | 3 | 一个项目可以有很多 JAR 文件,你可以向项目中添加 WAR , ZIP 和 TAR 文档,使用归档任务可以创建这些文档: Zip , Tar , Jar , War 和Ear. 它门都以同样的机制工作. 4 | 5 | **例 15.19 创建一个 ZIP 文档 ** 6 | 7 | **build.gradle** 8 | 9 | ``` 10 | apply plugin: 'java' 11 | 12 | task zip(type: Zip) { 13 | from 'src/dist' 14 | into('libs') { 15 | from configurations.runtime 16 | } 17 | } 18 | 19 | ``` 20 | 21 | 所有的归档任务的工作机制和复制任务相同,它们都实现了 `CopySpec` 接口,和 `Copy` 任务一样,使用 `from()` 方法指定输入文件,可以选择性的使用 `into()` 方法指定什么时候结束.你还可以过滤文件内容,重命名文件等等,就如同使用复制规则一样. 22 | 23 | ##重命名文档 24 | 25 | 26 | 27 | `projectName-vsersion.type` 格式可以被用来生成文档名,例如: 28 | 29 | **例 15.20 创建压缩文档** 30 | 31 | **build.gradle** 32 | 33 | ``` 34 | apply plugin: 'java' 35 | 36 | version = 1.0 37 | 38 | task myZip(type: Zip) { 39 | from 'somedir' 40 | } 41 | 42 | println myZip.archiveName 43 | println relativePath(myZip.destinationDir) 44 | println relativePath(myZip.archivePath) 45 | 46 | ``` 47 | 使用 `gradle -q myZip` 命令进行输出: 48 | ``` 49 | > gradle -q myZip 50 | zipProject-1.0.zip 51 | build/distributions 52 | build/distributions/zipProject-1.0.zip 53 | 54 | ``` 55 | 56 | 上面例子使用一个名为 myZip的 Zip 归档任务生成名称为 zipProject-1.0.zip 的 ZIP 文档,区分文档任务名和最终生成的文档名非常的重要 57 | 58 | 可以通过设置项目属性 `archivesBaseName` 的值来 修改生成文档的默认名.当然,文档的名称也可以通过其他方法随时更改. 59 | 60 | 归档任务中有些属性可以配置,如表 15.1 所示: 61 | 62 | **表 15.1 归档任务-属性名** 63 | 64 | 65 | 属性名 | 类型 | 默认值 | 描述 66 | -------|------|---------|---- 67 | archiveName | String | baseName-appendix-version-classifier.extension,如果其中任何一个都是空的,则不添加名称|归档文件的基本文件名 68 | archivePath | File | destinationDir/archiveName |生成归档文件的绝对路径。 69 | destinationDir | File | 取决于文档类型, JAR 和 WAR 使用project.buildDir/distributions. project.buildDir/libraries.ZIP 和 TAR|归档文件的目录 70 | baseName | String | project.name|归档文件名的基础部分。 71 | appendix | String | null|归档文件名的附加部分。 72 | version | String | project.version|归档文件名的版本部分。 73 | classifier | String | null|归档文件名的分类部分 74 | extension | String | 取决于文档类型和压缩类型: zip, jar, war, tar, tgz 或者 tbz2.|归档文件的扩展名 75 | 76 | 77 | **例 15.21 配置归档文件-自定义文档名** 78 | 79 | **build.gradle** 80 | 81 | ``` 82 | apply plugin: 'java' 83 | version = 1.0 84 | 85 | task myZip(type: Zip) { 86 | from 'somedir' 87 | baseName = 'customName' 88 | } 89 | 90 | println myZip.archiveName 91 | 92 | ``` 93 | 94 | 使用 `gradle -q myZip` 命令进行输出: 95 | 96 | ``` 97 | > gradle -q myZip 98 | customName-1.0.zip 99 | ``` 100 | 更多配置: 101 | 102 | **例 15.22 配置归档任务- 附加其他后缀** 103 | 104 | **build.gradle** 105 | 106 | ``` 107 | apply plugin: 'java' 108 | archivesBaseName = 'gradle' 109 | version = 1.0 110 | 111 | task myZip(type: Zip) { 112 | appendix = 'wrapper' 113 | classifier = 'src' 114 | from 'somedir' 115 | } 116 | 117 | println myZip.archiveName 118 | 119 | ``` 120 | 121 | 使用 `gradle -q myZip` 命令进行输出: 122 | 123 | ``` 124 | > gradle -q myZip 125 | gradle-wrapper-1.0-src.zip 126 | 127 | ``` 128 | 129 | ##多个文档共享内容 130 | 131 | 你可以使用 `Project.copySpec()` 在不用归档文件间共享内容. 132 | 如果你想发布一个文档,然后在另一个项目中使用，这部分将在第 53 章 [发布文档](https://docs.gradle.org/current/userguide/artifact_management.html) 中讲述. 133 | 134 | 135 | 136 | 137 | 138 | 139 | 140 | 141 | 142 | 143 | 144 | 145 | 146 | 147 | 148 | 149 | 150 | 151 | 152 | 153 | 154 | 155 | 156 | 157 | 158 | 159 | 160 | 161 | 162 | 163 | 164 | 165 | 166 | 167 | 168 | 169 | 170 | 171 | 172 | 173 | -------------------------------------------------------------------------------- /working_with_files/file_collections.md: -------------------------------------------------------------------------------- 1 | # 文件集合 2 | 3 | 文件集合表示一组文件，Gradle 使用 `FileCollection` 接口表示文件集合, Gradle API 中的许多项目都实现了这个接口,例如 [dependency configurations ](https://docs.gradle.org/current/userguide/dependency_management.html#sub:configurations). 4 | 5 | 获取 `FileCollection` 实例的一种方法是使用 `Project.files()` 方法.你可以传递任何数量的对象参数,这个方法能将你传递的对象集合转换为一组文件对象.`files()` 方法接收任何类型对象参数.每一个 `file()` 方法都依赖于项目目录(在第 15 章,第一小节中介绍).`files()`方法也接收 `collections `, `iterables`, `maps` 和 `arrays` 类型参数.这些参数的内容会被解析，然后被转换为文件对象. 6 | 7 | **例 15.2 创建文件集合 ** 8 | 9 | **build.gradle** 10 | ``` 11 | FileCollection collection = files('src/file1.txt', 12 | new File('src/file2.txt'), 13 | ['src/file3.txt', 'src/file4.txt']) 14 | ``` 15 | 16 | 文件集合可以被迭代器,使用迭代操作能够将其转换为其他的一些类型.你可以使用 `+` 操作将两个文件集合合并,使用 `-` 操作能够对一个文件集合做减法.下面一些例子介绍如何操作文件集合. 17 | 18 | **例 15.3 使用文件集合** 19 | 20 | **build.gradle** 21 | 22 | ``` 23 | // 对文件集合进行迭代 24 | collection.each {File file -> 25 | println file.name 26 | } 27 | 28 | // 转换文件集合为其他类型 29 | Set set = collection.files 30 | Set set2 = collection as Set 31 | List list = collection as List 32 | String path = collection.asPath 33 | File file = collection.singleFile 34 | File file2 = collection as File 35 | 36 | // 增加和减少文件集合 37 | def union = collection + files('src/file3.txt') 38 | def different = collection - files('src/file3.txt') 39 | 40 | ``` 41 | 42 | 你也可以向 `files()` 方法专递一个闭合或者可回调的实例参数.当查询集合的内容时就会调用它,然后将返回值转换为一些文件实例.返回值可以是 `files()` 方法支持的任何类型的对象.下面有个简单的例子来演示实现 `FileCollection` 接口 43 | 44 | **例 15.4 实现一个文件集合** 45 | 46 | **build.gradle** 47 | ``` 48 | task list << { 49 | File srcDir 50 | 51 | // 使用闭合创建一个文件集合 52 | collection = files { srcDir.listFiles() } 53 | 54 | srcDir = file('src') 55 | println "Contents of $srcDir.name" 56 | collection.collect { relativePath(it) }.sort().each { println it } 57 | 58 | srcDir = file('src2') 59 | println "Contents of $srcDir.name" 60 | collection.collect { relativePath(it) }.sort().each { println it } 61 | } 62 | 63 | ``` 64 | 使用 `gradle -q list` 输出结果 65 | 66 | ``` 67 | > gradle -q list 68 | Contents of src 69 | src/dir1 70 | src/file1.txt 71 | Contents of src2 72 | src2/dir1 73 | src2/dir2 74 | 75 | ``` 76 | 77 | 另外, `files()` 方法也接收其他类型的参数: 78 | 79 | **FileCollection** 80 | 81 | 内容损坏的文件包含在文件集合中. 82 | 83 | **Task** 84 | 85 | 任务的输出文件包含在文件集合中. 86 | 87 | **TaskOutputs** 88 | 89 | `TaskOutputs` 的输出文件包含在文件集合中 90 | 91 | 值得注意的是当有需要时文件集合的内容会被被惰性处理,就比如一些任务在需要的时候会创建一个 `FileCollecion` 代表的文件集合. 92 | 93 | 94 | 95 | 96 | 97 | 98 | 99 | 100 | 101 | 102 | -------------------------------------------------------------------------------- /working_with_files/file_trees.md: -------------------------------------------------------------------------------- 1 | # 文件树 2 | 3 | 文件树就是一个按照层次结构分布的文件集合,例如,一个文件树可以代表一个目录树结构或者一个 ZIP 压缩文件的内容.它被抽象为 `FileTree` 结构,`FileTree` 继承自 `FileCollection`,所以你可以像处理文件集合一样处理文件树, Gradle 有些对象实现了`FileTree` 接口,例如 [源集合](https://docs.gradle.org/current/userguide/java_plugin.html#sec:source_sets). 4 | 使用 `Project.fileTree()` 方法可以得到 `FileTree` 的实例,它会创建一个基于基准目录的对象,然后视需要使用一些 `Ant-style` 的包含和去除规则. 5 | 6 | **例 15.5 创建文件树** 7 | **build.gradle** 8 | 9 | ``` 10 | /以一个基准目录创建一个文件树 11 | FileTree tree = fileTree(dir: 'src/main') 12 | 13 | // 添加包含和排除规则 14 | tree.include '**/*.java' 15 | tree.exclude '**/Abstract*' 16 | 17 | // 使用路径创建一个树 18 | tree = fileTree('src').include('**/*.java') 19 | 20 | // 使用闭合创建一个数 21 | tree = fileTree('src') { 22 | include '**/*.java' 23 | } 24 | 25 | // 使用map创建一个树 26 | tree = fileTree(dir: 'src', include: '**/*.java') 27 | tree = fileTree(dir: 'src', includes: ['**/*.java', '**/*.xml']) 28 | tree = fileTree(dir: 'src', include: '**/*.java', exclude: '**/*test*/**') 29 | 30 | ``` 31 | 32 | 就像使用文件集合一样,你可以访问文件树的内容,使用 `Ant-style` 规则选择一个子树。 33 | 34 | **例 15.6 使用文件树** 35 | **build.gradle** 36 | 37 | ``` 38 | // 遍历文件树 39 | tree.each {File file -> 40 | println file 41 | } 42 | 43 | // 过滤文件树 44 | FileTree filtered = tree.matching { 45 | include 'org/gradle/api/**' 46 | } 47 | 48 | // 合并文件树A 49 | FileTree sum = tree + fileTree(dir: 'src/test') 50 | 51 | // 访问文件数的元素 52 | tree.visit {element -> 53 | println "$element.relativePath => $element.file" 54 | } 55 | 56 | ``` 57 | 58 | 59 | 60 | 61 | 62 | 63 | 64 | 65 | 66 | 67 | 68 | -------------------------------------------------------------------------------- /working_with_files/java.md: -------------------------------------------------------------------------------- 1 | # Java插件 2 | -------------------------------------------------------------------------------- /working_with_files/locating_files.md: -------------------------------------------------------------------------------- 1 | # Locating files 2 | 3 | 使用 `Project.file()` 方法能够相对项目目录定位一个文件 4 | 5 | **例 16.1. 定位文件** 6 | 7 | **build.gradle** 8 | ``` 9 | // 使用一个相对路径 10 | 11 | File configFile = file('src/config.xml') 12 | 13 | // 使用一个绝对路径 14 | 15 | configFile = file(configFile.absolutePath) 16 | 17 | // 使用一个项目路径的文件对象 18 | 19 | configFile = file(new File('src/config.xml'))` 20 | ``` 21 | 22 | 23 | `file()` 方法接收任何形式的对象参数.它会将参数值转换为一个绝对文件对象,一般情况下，你可以传递一个 `String` 或者一个 `File` 实例.如果传递的路径是个绝对路径,它会被直接构造为一个文件实例.否则,会被构造为项目目录加上传递的目录的文件对象.另外,`file()函数`也能识别`URL`,例如 file:/some/path.xml. 24 | 25 | 26 | 这个方法非常有用,它将参数值转换为一个绝对路径文件.所以请尽量使用 `new File(somePath)` , 因为 `file()` 总是相对于当前项目路径计算传递的路径,然后加以矫正.因为当前工作区间目录依赖于用户以何种方式运行 Gradle. 27 | 28 | 29 | 30 | 31 | 32 | 33 | 34 | 35 | 36 | 37 | 38 | 39 | 40 | -------------------------------------------------------------------------------- /working_with_files/specifying_a_set_of_input_files.md: -------------------------------------------------------------------------------- 1 | # 指定一组输入文件 2 | 3 | 4 | 在 `Gradle` 中有一些对象的某些属性可以接收一组输入文件.例如,`JavaComplile` 任务有一个 `source` 属性,它定义了编译的源文件,你可以设置这个属性的值,只要 `files()` 方法支持. 这意味着你可以使用 `File` , `String` , `collection` , `FileCollection` 5 | 甚至是使用一个闭合去设置属性的值. 6 | 7 | **例 15.8 指定文件** 8 | 9 | **build.gradle** 10 | ``` 11 | //使用一个 File 对象设置源目录 12 | compile { 13 | source = file('src/main/java') 14 | } 15 | 16 | //使用一个字符路径设置源目录 17 | compile { 18 | source = 'src/main/java' 19 | } 20 | 21 | // 使用一个集合设置多个源目录 22 | compile { 23 | source = ['src/main/java', '../shared/java'] 24 | } 25 | 26 | // 使用 FileCollection 或者 FileTree 设置源目录 27 | compile { 28 | source = fileTree(dir: 'src/main/java').matching { include 'org/gradle/api/**' } 29 | } 30 | 31 | // 使用一个闭合设置源目录 32 | compile { 33 | source = { 34 | // Use the contents of each zip file in the src dir 35 | file('src').listFiles().findAll {it.name.endsWith('.zip')}.collect { zipTree(it) } 36 | } 37 | } 38 | ``` 39 | 40 | Usually, there is a method with the same name as the property, which appends to the set of files. Again, this method accepts any of the types supported by the files() method. 41 | 42 | 通常情况下,会有一个方法名和属性名相同的方法能够附加一组文件,这个方法接收 `files()` 方法支持的任何类型的值. 43 | 44 | ** 例 15.9 指定文件** 45 | 46 | **build.gradle** 47 | ``` 48 | compile { 49 | // 使用字符路径添加源目录 50 | source 'src/main/java', 'src/main/groovy' 51 | 52 | // 使用 File 对象添加源目录 53 | source file('../shared/java') 54 | 55 | // 使用闭合添加源目录 56 | source { file('src/test/').listFiles() } 57 | } 58 | 59 | ``` 60 | -------------------------------------------------------------------------------- /working_with_files/using_a_file_collection.md: -------------------------------------------------------------------------------- 1 | # Using a file collection 2 | A file collection is iterable, and can be converted to a number of other types using the as operator. You can also add 2 file collections together using the + operator, or subtract one file collection from another using the - operator. Here are some examples of what you can do with a file collection. 3 | 4 | 文件集合可以被迭代器,使用迭代操作能够将其转换为其他的一些类型.你可以使用`+`将两个文件集合合并,使用`-`能够对一个文件集合做减法.下面一些例子介绍如何操作文件集合. 5 | **例子 15.3 使用文件集合** 6 | 7 | ***build.gradle** 8 | 9 | ``` 10 | // 对文件集合进行迭代 11 | collection.each {File file -> 12 | println file.name 13 | } 14 | 15 | // 转换文件集合为其他类型 16 | Set set = collection.files 17 | Set set2 = collection as Set 18 | List list = collection as List 19 | String path = collection.asPath 20 | File file = collection.singleFile 21 | File file2 = collection as File 22 | 23 | // 增加和减少文件集合 24 | def union = collection + files('src/file3.txt') 25 | def different = collection - files('src/file3.txt') 26 | 27 | ``` 28 | 29 | You can also pass the files() method a closure or a Callable instance. This is called when the contents of the collection are queried, and its return value is converted to a set of File instances. The return value can be an object of any of the types supported by the files() method. This is a simple way to 'implement' the FileCollection interface. 30 | 31 | 你也可以向 `files()` 方法专递一个闭合或者可回调的实例参数.当查询集合的内容时就会调用它,然后将返回值转换为一些文件实例.返回值可以是`files()`方法支持的任何类型的对象.下面有个简单的例子来演示实现`FileCollection`接口 32 | 33 | **例子15.4 实现一个文件集合** 34 | **build.gradle** 35 | ``` 36 | task list << { 37 | File srcDir 38 | 39 | // 使用闭合创建一个文件集合 40 | collection = files { srcDir.listFiles() } 41 | 42 | srcDir = file('src') 43 | println "Contents of $srcDir.name" 44 | collection.collect { relativePath(it) }.sort().each { println it } 45 | 46 | srcDir = file('src2') 47 | println "Contents of $srcDir.name" 48 | collection.collect { relativePath(it) }.sort().each { println it } 49 | } 50 | 51 | ``` 52 | 使用`gradle -q list`输出结果 53 | 54 | ``` 55 | > gradle -q list 56 | Contents of src 57 | src/dir1 58 | src/file1.txt 59 | Contents of src2 60 | src2/dir1 61 | src2/dir2 62 | 63 | ``` 64 | 65 | `files()`方法也接收其他类型的参数: 66 | 67 | **FileCollection** 68 | These are flattened and the contents included in the file collection. 69 | **Task** 70 | The output files of the TaskOutputs are included in the file collection. 71 | 72 | **TaskOutputs** 73 | The output files of the TaskOutputs are included in the file collection. 74 | 75 | It is important to note that the content of a file collection is evaluated lazily, when it is needed. This means you can, for example, create a FileCollection that represents files which will be created in the future by, say, some task. 76 | 77 | 值得注意的是文件集合的内容是被惰性,当你需要的时候，就比如创建一个`FileCollecion`代表文件集合会被一些`task`在需要的时候被创建. 78 | 79 | 80 | 81 | 82 | 83 | 84 | 85 | 86 | 87 | 88 | 89 | 90 | 91 | 92 | 93 | 94 | -------------------------------------------------------------------------------- /working_with_files/using_the_contents_of_an_archive_as_a_file_tree.md: -------------------------------------------------------------------------------- 1 | # 使用一个归档文件的内容作为文件树 2 | 3 | 你可以使用 ZIP 或者 TAR 等压缩文件的内容作为文件树, `Project.zipTree()` 和 `Project.tarTree()` 方法返回一个 `FileTree` 实例, 你可以像使用其他文件树或者文件集合一样使用它.例如,你可以使用它去扩展一个压缩文档或者合并一些压缩文档. 4 | 5 | **例 15.7 使用压缩文档作为文件树** 6 | **build.gradle** 7 | ``` 8 | // 使用路径创建一个 ZIP 文件 9 | FileTree zip = zipTree('someFile.zip') 10 | 11 | // 使用路径创建一个 TAR 文件 12 | FileTree tar = tarTree('someFile.tar') 13 | 14 | //tar tree 能够根据文件扩展名得到压缩方式,如果你想明确的指定压缩方式,你可以使用下面方法 15 | FileTree someTar = tarTree(resources.gzip('someTar.ext')) 16 | ``` 17 | 18 | 19 | 20 | 21 | 22 | 23 | 24 | 25 | -------------------------------------------------------------------------------- /working_with_files/using_the_sync_task.md: -------------------------------------------------------------------------------- 1 | # 使用同步任务 2 | 同步任务 ( `Sync` ) 任务继承自复制任务 ( `Copy` ) , 当它执行时,它会复制源文件到目标目录中,然后从目标目录中的删除所有非复制的文件,这种方式非常有用,比如安装一个应用,创建一个文档的副本,或者维护项目的依赖关系副本. 3 | 4 | 下面有一个例子,维护 `build/libs` 目录下项目在运行时的依赖 5 | 6 | **例 15.7 使用 Sync 任务复制依赖关系** 7 | 8 | **build.gradle** 9 | 10 | ``` 11 | task libs(type: Sync) { 12 | from configurations.runtime 13 | into "$buildDir/libs" 14 | } 15 | 16 | ``` 17 | 18 | -------------------------------------------------------------------------------- /writing_build_scripts/README.md: -------------------------------------------------------------------------------- 1 | # 编写构建脚本 2 | 这一章我们将要深入的学习如何编写构建脚本. 3 | -------------------------------------------------------------------------------- /writing_build_scripts/closure_delegate.md: -------------------------------------------------------------------------------- 1 | # 闭包委托对象 2 | 每个闭包都有一个委托对象，当闭包既不是局部变量也不是作为方法参数时，Groovy 使用委托对象查找变量和方法引用. 当委托对象被用来管理时，Gradle 使用它来管理闭包. 3 | 4 | **例子 13.9.闭包引用** 5 | 6 | **build.gradle** 7 | 8 | dependencies { 9 | assert delegate == project.dependencies 10 | testCompile('junit:junit:4.11') 11 | delegate.testCompile('junit:junit:4.11') 12 | } 13 | -------------------------------------------------------------------------------- /writing_build_scripts/closures_as_the_last_parameter_in_a_method.md: -------------------------------------------------------------------------------- 1 | # 闭包作为方法的最后一个参数 2 | Gradle DSL 在很多地方使用闭包，这里我们将讨论更多关于闭包的使用. 当一个方法的最后一个参数是一个闭包时，您可以在方法调用后放置一个闭包. 3 | 4 | **例子: 13.8.闭包作为方法的参数** 5 | 6 | **build.gradle** 7 | 8 | repositories { 9 | println "in a closure" 10 | } 11 | repositories() { println "in a closure" } 12 | repositories({println "in a closure" }) 13 | -------------------------------------------------------------------------------- /writing_build_scripts/declaring_variables.md: -------------------------------------------------------------------------------- 1 | # 声明变量 2 | 在 Gradle 构建脚本中有两种类型的变量可以声明：局部变量 ( local ) 和 扩展属性 ( extra ) . 3 | 4 | -------------------------------------------------------------------------------- /writing_build_scripts/extra_properties.md: -------------------------------------------------------------------------------- 1 | # 扩展属性 2 | 在 Gradle 领域模型中所有被增强的对象能够拥有自己定义的属性. 这包括，但不仅限于 projects , tasks , 还有 source sets . Project 对象可以添加，读取，更改扩展的属性. 另外，使用 ext 扩展块可以一次添加多个属性. 3 | 4 | **例子 13.3. 使用扩展属性** 5 | 6 | **build.gradle** 7 | 8 | apply plugin: "java" 9 | 10 | ext { 11 | springVersion = "3.1.0.RELEASE" 12 | emailNotification = "build@master.org" 13 | } 14 | 15 | sourceSets.all { ext.purpose = null } 16 | 17 | sourceSets { 18 | main { 19 | purpose = "production" 20 | } 21 | test { 22 | purpose = "test" 23 | } 24 | plugin { 25 | purpose = "production" 26 | } 27 | 28 | } 29 | 30 | task printProperties << { 31 | println springVersion 32 | println emailNotification 33 | sourceSets.matching { it.purpose == "production" }.each { println it.name } 34 | } 35 | 36 | 使用**gradle -q printProperties**输出结果 37 | 38 | > gradle -q printProperties 39 | 3.1.0.RELEASE 40 | build@master.org 41 | main 42 | plugin 43 | 44 | 在上面的例子中，一个 ext 扩展块向 Project 对象添加了两个扩展属性. 名为 perpose 的属性被添加到每个 source set，然后设置 ext.purpose 等于 null ( null值是被允许的 ). 当这些扩展属性被添加后，它们就像预定义的属性一样可以被读取，更改值. 45 | 46 | 例子中我们通过一个特殊的语句添加扩展属性，当您试图设置一个预定义属性或者扩展属性，但是属性名拼写错误或者并不存在时，操作就会失败. Project 对象可以在任何地方使用其扩展属性 ，它们比局部变量有更大的作用域. 一个项目的扩展属性对其子项目也可见. 47 | 48 | 关于扩展属性更多的细节还有它的API，请看 [ExtraPropertiesExtension](http://gradle.org/docs/current/dsl/org.gradle.api.plugins.ExtraPropertiesExtension.html) 类的 API 文档说明. 49 | 50 | 51 | 52 | 53 | 54 | 55 | -------------------------------------------------------------------------------- /writing_build_scripts/groovy_jdk.md: -------------------------------------------------------------------------------- 1 | # Groovy JDK 2 | Groovy 在 Java 基础上添加了很多有用的方法. 例如，Iterable 有一个 each 方法， 通过使用 each 方法,我们可以迭代出 Iterable 中的每一个元素: 3 | 4 | **例子: 13.4.Groovy JDK 方法** 5 | 6 | **build.gradle** 7 | 8 | configuration.runtime.each { File f -> println f } 9 | 10 | 更多内容请阅读 http://groovy.codehaus.org/groovy-jdk/ 11 | 12 | -------------------------------------------------------------------------------- /writing_build_scripts/list_and_map_literals.md: -------------------------------------------------------------------------------- 1 | # List 和 Map 集合 2 | Groovy 为预定义的 List 和 Map 集合提供了一些操作捷径，这两个字面值都比较简单易懂，但是 Map 会有一些不同. 3 | 4 | 例如，当您使用 "apply" 方法使用插件时，apply 会自动加上 Map 的一个参数，当您这样写 " apply plugin: 'java' "时，实际上使用的是 name 参数(name-value)，只不过在 Groovy 中 使用 Map 没有 < > ,当方法被调用的时候，name 参数就会被转换成 Map 键值对，只不过在 Groovy 中看起来不像一个 Map. 5 | 6 | **例子 13.7.List 和 Map 集合 7 | 8 | **build.gradle** 9 | 10 | // List 集合 11 | test.includes = ['org/gradle/api/**', 'org/gradle/internal/**'] 12 | 13 | List list = new ArraryList() 14 | list.add('org/gradle/api/**') 15 | list.add('org/gradle/internal/**') 16 | test.includes = list 17 | 18 | // Map 集合 19 | Map map = [key1:'value1', key2:'valu2'] 20 | 21 | // Groovy 会强制将Map的键值对转换为只有value的映射 22 | apply plugin: 'java' 23 | 24 | -------------------------------------------------------------------------------- /writing_build_scripts/local_variables.md: -------------------------------------------------------------------------------- 1 | # 局部变量 2 | 局部变量使用关键字 def 来声明，其只在声明它的地方可见 . 局部变量是 Groovy 语言的一个基本特性. 3 | 4 | **例子 13.2 . 使用局部变量** 5 | 6 | def dest = "dest" 7 | 8 | task copy(type: Copy) { 9 | form "source" 10 | into dest 11 | 12 | } 13 | 14 | 15 | 16 | -------------------------------------------------------------------------------- /writing_build_scripts/optional_parentheses_on_method_calls.md: -------------------------------------------------------------------------------- 1 | # 可有可无的圆括号 2 | 在调用方法时，圆括号可有可无，是个可选的. 3 | 4 | **例子: 13.6.不使用圆括号调用方法** 5 | 6 | **build.gradle** 7 | 8 | test.systemProperty 'some.prop', 'value' 9 | test.systemProperty('some.prop', 'value') 10 | 11 | 12 | -------------------------------------------------------------------------------- /writing_build_scripts/property_accessors.md: -------------------------------------------------------------------------------- 1 | # 属性存取器 2 | Groovy 自动将一个属性的引用转换为相应的 getter 或 setter 方法. 3 | 4 | **例子: 13.5. 属性存取器** 5 | 6 | // 使用 getter 方法 7 | println project.buildDir 8 | println getProject().getBuildDir() 9 | 10 | // 使用 setter 方法 11 | project.buildDir = 'target' 12 | getProject().setBuildDir('target') 13 | 14 | 15 | -------------------------------------------------------------------------------- /writing_build_scripts/some_groovy_basics.md: -------------------------------------------------------------------------------- 1 | # Groovy 基础 2 | Groovy 提供了大量的特性用来创建 DSL. Gradle 构建语言知道 Groovy 语言的工作原理，并利用这些特性帮助您编写构建脚本，特别是您在编写 plugin 或者 task 的时候，你会觉得很方便. 3 | -------------------------------------------------------------------------------- /writing_build_scripts/standard_project_properties.md: -------------------------------------------------------------------------------- 1 | # 标准项目属性 2 | Project 对象提供了一些标准的属性，您可以在构建脚本中很方便的使用他们. 下面列出了常用的属性: 3 | 4 | Name | Type | Default Value 5 | :------|:------|:------ 6 | project | [Project](http://gradle.org/docs/current/dsl/org.gradle.api.Project.html)|Project 实例对象 7 | name | String | 项目目录的名称 8 | path | String | 项目的绝对路径 9 | description| String | 项目描述 10 | projectDir | File | 包含构建脚本的目录 11 | build | File | *projectDir*/build 12 | group | Object | 未具体说明 13 | version | Object | 未具体说明 14 | ant |[AntBuilder](http://gradle.org/docs/current/javadoc/org/gradle/api/AntBuilder.html) | Ant实例对象 15 | 16 | **建议：** 17 | 18 | 不要忘记我们的构建脚本只是个很简单的 Groovy 代码 ，不过它会再调用 **Gradle API**，[Project](http://gradle.org/docs/current/dsl/org.gradle.api.Project.html) 接口通过调用 ** Gradle API ** 让我们可以操作任何事情，因此如果你想知道哪个标签('tags') 可以在构建脚本种使用，您可以翻阅 Project 接口的的说明文档. 19 | 20 | 21 | -------------------------------------------------------------------------------- /writing_build_scripts/the_gradle_build_language.md: -------------------------------------------------------------------------------- 1 | # Gradle 构建语言 2 | 3 | Gradle 是以 Groovy 语言为基础, 基于DSL (领域特定语言) 语法的自动化构建工具,但是它增加了一些额外的特性,这使得Gradle更加的容易去阐释构建. 4 | 5 | 一个构建脚本能够包含任何Groovy语言的元素 ( Any language element except for statement labels ), 每个构建脚本都使用UTF-8编码. 6 | 7 | 8 | -------------------------------------------------------------------------------- /writing_build_scripts/the_project_api.md: -------------------------------------------------------------------------------- 1 | # 项目 API 2 | 3 | 在第七章 Java构建入门那部分我们使用了 apply() 方法，这个方法是从哪里来的呢? 我们之前说过Gradle在构建脚本中定义了一个项目. 对于构建脚本中每个项目，Gradle 都创建了一个 [Project](http://gradle.org/docs/current/dsl/org.gradle.api.Project.html) 类型的对象用来关联此项目. 当构建脚本执行时，它会去配置所关联的工程对象. 4 | 5 | * 构建脚本中每个被调用的方法（这些方法并未在构建脚本中定义）都被委托给当前工程对象（使用工程对象引用方法）。 6 | 7 | * 构建脚本中每个被操作的属性（这些属性并未在构建脚本中定义）都被委托给当前工程对象（使用工程对象引用属性）. 8 | 9 | 让我们尝试下如何操作工程对象的属性. 10 | 11 | 例子：13.1 操作工程对象的属性 12 | 13 | **build.gradle** 14 | 15 | println name 16 | println project.name 17 | 18 | 19 | 使用 **gradle -q check** 命令输出结果: 20 | 21 | > gradle -q check 22 | projectApi 23 | projectApi 24 | 25 | 如您所见，两个 **println** 语句都输出了相同的属性，第一个输出使用的是自动委托 ( auto-delegation ), 因为当前属性并没有在构建脚本中定义. 另一个语句使用了项目一个属性，这个属性在任何构建脚本中都可用，它的返回值是被关联的工程对象. 只有当您定义了一个属性或者一个方法, 它的名字和工程对象的某个成员的名字相同时, 你应该使用项目属性. 26 | 27 | 28 | 29 | 30 | 31 | 32 | 33 | -------------------------------------------------------------------------------- /writing_build_scripts/the_script_api.md: -------------------------------------------------------------------------------- 1 | # 脚本 API 2 | 当 Gradle 执行一个脚本时，它会将这个脚本编译为实现了 [Script](http://gradle.org/docs/current/dsl/org.gradle.api.Script.html) 的类. 也就是说所有的属性和方法都是在 Script 接口中声明的，由于你的脚本实现了 Script 接口，所以你可以在自己的脚本中使用它们. 3 | --------------------------------------------------------------------------------