Gradle 简易入门教程

Posted 原力注入

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Gradle 简易入门教程相关的知识，希望对你有一定的参考价值。

点击蓝字


Gradle 是一种构建工具，它抛弃了基于XML的构建脚本，取而代之的是采用一种基于 Groovy（现在也支持 Kotlin）的内部领域特定语言。

Gradle特点

  1. Gradle是很成熟的技术，可以处理大规模构建

  2. Gradle对多语言、多平台支持性更好

  3. Gradle关注在构建效率上

  4. Gradle发布很频繁，重要feature开发计划透明化

  5. Gradle社区很活跃，并且增加迅速


安装Gradle

  • 从 官网 (https://gradle.org/install/)下载二进制文件。

  • 解压Zip文件，加入环境变量（在PATH中加入GRADLE_HOME/bin目录）

如果在安装过程中遇到问题，可以进一步查看官方的安装指南(https://gradle.org/install/)。最后验证一下 Gradle 是否工作正常

 
   
   
 
    
  
    
    
  
  1. gradle -v
    2. 
  
    
    
  
  2. ------------------------------------------------------------
    3. 
  
    
    
  
  3. Gradle 4.2.1
    4. 
  
    
    
  
  4. ------------------------------------------------------------
    5. 
  
    
    
  
    6. 
  
    
    
  
  6. Build time:   2017-10-02 15:36:21 UTC
    7. 
  
    
    
  
  7. Revision:     a88ebd6be7840c2e59ae4782eb0f27fbe3405ddf
    8. 
  
    
    
  
    9. 
  
    
    
  
  9. Groovy:       2.4.12
    10. 
  
    
    
  
  10. Ant:          Apache Ant(TM) version 1.9.6 compiled on June 29 2015
    11. 
  
    
    
  
  11. JVM:          1.8.0_162-ea (Oracle Corporation 25.162-b01)
    12. 
  
    
    
  
  12. OS:           Mac OS X 10.13.5 x86_64
    13. 
  
    
    
  

    14.

Gradle快速体验

初始化一个项目

  • 创建一个 demo 目录

 
   
   
 
    
  
    
    
  
  1. ❯ mkdir gradle-demo
    2. 
  
    
    
  

    3.

  • 初始化 Gradle 项目

 
   
   
 
    
  
    
    
  
  1. ❯ gradle init 
    2. 
  
    
    
  
  2. Starting a Gradle Daemon (subsequent builds will be faster)
    3. 
  
    
    
  
    4. 
  
    
    
  
    5. 
  
    
    
  
  5. BUILD SUCCESSFUL in 3s
    6. 
  
    
    
  
  6. 2 actionable tasks: 2 executed
    7. 
  
    
    
  

    8.



Gradle目录结构

我们看看上一步我们生成了什么文件

├── build.gradle  ❶
├── gradle
│   └── wrapper
│       ├── gradle-wrapper.jar    ➋
│       └── gradle-wrapper.properties  ➌
├── gradlew    ➍
├── gradlew.bat  ➎
└── settings.gradle  ➏

❶ 当前项目的配置脚本

➋ Gradle Wrapper 的执行jar包（后续介绍）➌ Gradle Wrapper 的配置文件➍ Gradle Wrapper Unix 系执行脚本➎ Gradle Wrapper Windows 系执行脚本➏ 项目脚本设置



创建一个Task

Gradle提供了用于通过基于Groovy或Kotlin的DSL创建和配置。项目包括一组Task，每个Task执行一些基本操作。

  • 创建一个目录叫 src

  • 在src目录创建一个 myfile.txt

  • 在构建文件中定义一个名为Copy的类型 Task ，该任务将src目录复制到名为dest的新目录

groovy代码：

 
   
   
 
    
  
    
    
  
  1. task copy(type: Copy, group: "Custom", description: "Copies sources to the dest directory") {
    2. 
  
    
    
  
    3. 
  
    
    
  
  3.     from "src"
    4. 
  
    
    
  
    5. 
  
    
    
  
  5.     into "dest"
    6. 
  
    
    
  
    7. 
  
    
    
  
  7. }
    8. 
  
    
    
  

    9.


kotlin代码：

 
   
   
 
    
  
    
    
  
  1. tasks.create<Copy>("copy") {
    2. 
  
    
    
  
    3. 
  
    
    
  
  3.     description = "Copies sources to the dest directory"
    4. 
  
    
    
  
    5. 
  
    
    
  
  5.     group = "Custom"
    6. 
  
    
    
  
    7. 
  
    
    
  
  7.     from("src")
    8. 
  
    
    
  
  8.     into("dest")
    9. 
  
    
    
  
    10. 
  
    
    
  
  10. }
    11. 
  
    
    
  

    12.

group 和 description 是自定义的任意值。现在让我们执行这个 task

 
   
   
 
    
  
    
    
  
  1. ❯ ./gradlew copy
    2. 
  
    
    
  
  2. > Task :copy
    3. 
  
    
    
  
    4. 
  
    
    
  
  4. BUILD SUCCESSFUL in 0s
    5. 
  
    
    
  
  5. 1 actionable task: 1 executed
    6. 
  
    
    
  

    7.


再一次 ls 我们就可以看见 gradle 为我们创建了一个新的 dest 目录并且将 文件复制进去

Gradle Task

在Gradle中，有两个基本概念：项目和任务。

  • 项目是指我们的构建产物（比如Jar包）或实施产物（将应用程序部署到生产环境）一个项目包含一个或多个任务。

  • 任务是指不可分的最小工作单元，执行构建工作（比如编译项目或执行测试）。


    Gradle 简易入门教程

在项目目录中的 build.gradle 指定了一个项目和它的任务。


Task执行顺序

任务可能依赖于其他任务，或者可能被安排为始终在另一个任务之后运行。

 
   
   
 
    
  
    
    
  
  1. project('projectA') {
    2. 
  
    
    
  
  2.     task taskX(dependsOn: ':projectB:taskY') {
    3. 
  
    
    
  
  3.         doLast {
    4. 
  
    
    
  
  4.             println 'taskX'
    5. 
  
    
    
  
  5.         }
    6. 
  
    
    
  
  6.     }
    7. 
  
    
    
  
  7. }
    8. 
  
    
    
  
    9. 
  
    
    
  
  9. project('projectB') {
    10. 
  
    
    
  
  10.     task taskY {
    11. 
  
    
    
  
  11.         doLast {
    12. 
  
    
    
  
  12.             println 'taskY'
    13. 
  
    
    
  
  13.         }
    14. 
  
    
    
  
  14.     }
    15. 
  
    
    
  
  15. }
    16. 
  
    
    
  

    17. 
 
   
   
 


 
   
   
 
    
  
    
    
  
  1. > gradle -q taskX
    2. 
  
    
    
  
  2. taskY
    3. 
  
    
    
  
  3. taskX  // taskx 在 y 之后
    4. 
  
    
    
  

    5.

我们可以用 dependsOn 让我们的 Task 有顺序的运行起来

Gradle插件

看到这里，如果每一件事情我们都需要写 Task 岂不是会累死，而且很多功能是可以被复用的，所以Gradle 提供一个 插件 功能，Gradle 默认就内置了大量的插件，比如在 base 中有一系列的功能。

groovy代码：

 
   
   
 
    
  
    
    
  
  1. plugins {
    2. 
  
    
    
  
    3. 
  
    
    
  
  3.     id "base"
    4. 
  
    
    
  
    5. 
  
    
    
  
  5. }
    6. 
  
    
    
  

    7.


kotlin代码：

 
   
   
 
    
  
    
    
  
  1. plugins {
    2. 
  
    
    
  
    3. 
  
    
    
  
  3.     id("base")
    4. 
  
    
    
  
    5. 
  
    
    
  
  5. }
    6. 
  
    
    
  

    7.

这个时候我们就可以利用一些额外的 Task，举个例子，我们要把一个目录中的东西都打成一个 ZIP 压缩包。

groovy代码：

 
   
   
 
    
  
    
    
  
  1. task zip(type: Zip, group: "Archive", description: "Archives sources in a zip file") {
    2. 
  
    
    
  
    3. 
  
    
    
  
  3.     from "src"
    4. 
  
    
    
  
    5. 
  
    
    
  
  5.     setArchiveName "basic-demo-1.0.zip"
    6. 
  
    
    
  
    7. 
  
    
    
  
  7. }
    8. 
  
    
    
  

    9.


kotlin代码：

 
   
   
 
    
  
    
    
  
  1. tasks.create<Zip>("zip") {
    2. 
  
    
    
  
    3. 
  
    
    
  
  3.     description = "Archives sources in a zip file"
    4. 
  
    
    
  
    5. 
  
    
    
  
  5.     group = "Archive"
    6. 
  
    
    
  
    7. 
  
    
    
  
  7.     from("src")
    8. 
  
    
    
  
  8.     setArchiveName("basic-demo-1.0.zip")
    9. 
  
    
    
  
    10. 
  
    
    
  
  10. }
    11. 
  
    
    
  

    12.

Gradle 的设计理念是

  • 在项目中添加新任务

  • 为新加入的任务提供默认配置，这个默认配置会在项目中注入新的约定（如源文件位置）。

  • 加入新的属性，可以覆盖插件的默认配置属性。

  • 为项目加入新的依赖。

Gradle Java

Gradle 内置了 Java 插件，Java插件将Java编译以及测试和捆绑功能添加到项目中。它是许多其他Gradle插件的基础。如果我们需要使用 Java 插件 修改 build.gradle

 
   
   
 
    
  
    
    
  
  1. plugins {
    2. 
  
    
    
  
  2.     id 'java'
    3. 
  
    
    
  
  3. }
    4. 
  
    
    
  

    5.

一旦导入了 Java 插件，就会有一系列的默认的配置值，并且会导入大量的 Task

Task 含义
compileJava(type: JavaCompile) Java 编译
processResources(type: Copy) 拷贝 Resources 资源
classes(type: Task) 组装 Java 类
compileTestJava(type: JavaCompile) Java Test 编译
processTestResources(type: Copy) 拷贝 Test Resources 资源
testClasses(type: Task) 组装 Test 类
jar(type: Jar) 合成Jar包
javadoc(type: Javadoc) 生成 doc 文档
test(type: Test) 运行测试
uploadArchives(type: Upload) 上传 jar 到仓库
clean(type: Delete) clean

我们从这些 Task 名字就可以看出来他们分别作作了， 和其他的设计理念类型，在 Task 也会嵌入一些生命周期，其实原理也就是我们之前看的执行顺序。

Gradle 简易入门教程

资源：Gradle插件仓库

Gradle依赖管理

先盗取一张官方的图

和 Maven 类似，Gradle 也会将依赖缓冲在本地中，方便在无网的环境使用，和依赖管理相关的有两个参数，举个例子。

 
   
   
 
    
  
    
    
  
  1. repositories {
    2. 
  
    
    
  
  2.     mavenCentral() // 定义仓库
    3. 
  
    
    
  
  3. }
    4. 
  
    
    
  
    5. 
  
    
    
  
  5. dependencies {
    6. 
  
    
    
  
  6.     compile 'org.springframework:spring-web:5.0.2.RELEASE' // 定义依赖
    7. 
  
    
    
  
  7. }
    8. 
  
    
    
  

    9.

Gradle支持以下仓库格式：

  • Ivy仓库

  • Maven仓库

  • Flat directory仓库

lvy仓库

 
   
   
 
    
  
    
    
  
  1. repositories {
    2. 
  
    
    
  
  2.     ivy {
    3. 
  
    
    
  
  3.         url "http://ivy.petrikainulainen.net/repo"
    4. 
  
    
    
  
  4.     }
    5. 
  
    
    
  
  5. }
    6. 
  
    
    
  
  6. //或者是本地
    7. 
  
    
    
  
  7. repositories {
    8. 
  
    
    
  
  8.     ivy {       
    9. 
  
    
    
  
  9.         url "../ivy-repo"
    10. 
  
    
    
  
  10.     }
    11. 
  
    
    
  
  11. }
    12. 
  
    
    
  

    13.

Maven仓库

 
   
   
 
    
  
    
    
  
  1. repositories {
    2. 
  
    
    
  
  2.     maven {
    3. 
  
    
    
  
  3.         url "http://maven.petrikainulainen.net/repo"
    4. 
  
    
    
  
  4.     }
    5. 
  
    
    
  
  5. }
    6. 
  
    
    
  

    7.

在加入Maven仓库时，Gradle提供了三种“别名”供我们使用，它们分别是

  • mavenCentral()别名，表示依赖是从Central Maven 2 仓库中获取的。

  • jcenter()别名，表示依赖是从Bintary’s JCenter Maven 仓库中获取的。

  • mavenLocal()别名，表示依赖是从本地的Maven仓库中获取的。


Flat Directory仓库

 
   
   
 
    
  
    
    
  
  1. repositories {
    2. 
  
    
    
  
  2.     flatDir {
    3. 
  
    
    
  
  3.         dirs 'lib'
    4. 
  
    
    
  
  4.     }
    5. 
  
    
    
  
  5. }
    6. 
  
    
    
  
    7. 
  
    
    
  
  7. //多个仓库
    8. 
  
    
    
  
  8. repositories {
    9. 
  
    
    
  
  9.     flatDir {
    10. 
  
    
    
  
  10.         dirs 'libA', 'libB'
    11. 
  
    
    
  
  11.     }
    12. 
  
    
    
  
  12. }
    13. 
  
    
    
  

    14.

依赖管理

在配置完项目仓库后，我们可以声明其中的依赖，首先 Java 插件指定了若干依赖配置项

  • compile 配置项中的依赖是依赖必须的。

  • runtime 配置项中包含的依赖在运行时是必须的。

  • testCompile 配置项中包含的依赖在编译项目的测试代码时是必须的。

  • testRuntime 配置项中包含的依赖在运行测试代码时是必须的。

在 Gradle 最新版本中更是增加

  • implementation 配置项中的实现类

  • api 配置项中的暴露API

 
   
   
 
    
  
    
    
  
  1. dependencies {
    2. 
  
    
    
  
  2.     api 'commons-httpclient:commons-httpclient:3.1'
    3. 
  
    
    
  
  3.     implementation 'org.apache.commons:commons-lang3:3.5'
    4. 
  
    
    
  
  4. }
    5. 
  
    
    
  

    6.

声明项目依赖

最普遍的依赖称为外部依赖，这些依赖存放在外部仓库中。一个外部依赖可以由以下属性指定：

  • group属性指定依赖的分组（在Maven中，就是groupId）

  • name属性指定依赖的名称（在Maven中，就是artifactId）

  • version属性指定外部依赖的版本（在Maven中，就是version）

 
   
   
 
    
  
    
    
  
  1. dependencies {
    2. 
  
    
    
  
  2.     compile group: 'foo', name: 'foo', version: '0.1'
    3. 
  
    
    
  
  3. }
    4. 
  
    
    
  
  4. // 我们也可以合并到一起去
    5. 
  
    
    
  
  5. dependencies {
    6. 
  
    
    
  
  6.     compile 'foo:foo:0.1'
    7. 
  
    
    
  
  7. }
    8. 
  
    
    
  

    9.

声明项目文件依赖

我们如何依赖本地的一些 jar 呢，正确的操作是如下

 
   
   
 
    
  
    
    
  
  1. dependencies {
    2. 
  
    
    
  
  2.     compile files('libs/commons-lang.jar', 'libs/log4j.jar')
    3. 
  
    
    
  
  3. }
    4. 
  
    
    
  

    5.


声明依赖排除项目

我们都知道在 Maven中我们有

 
   
   
 
    
  
    
    
  
  1.     <dependency>
    2. 
  
    
    
  
  2.         <groupId>sample.ProjectB</groupId>
    3. 
  
    
    
  
  3.         <artifactId>Project-B</artifactId>
    4. 
  
    
    
  
  4.         <version>1.0-SNAPSHOT</version>
    5. 
  
    
    
  
  5.         <exclusions>
    6. 
  
    
    
  
  6.             <exclusion>
    7. 
  
    
    
  
  7.                 <groupId>log4j</groupId>
    8. 
  
    
    
  
  8.                 <artifactId>log4j</artifactId>
    9. 
  
    
    
  
  9.             </exclusion>
    10. 
  
    
    
  
  10.         </exclusions>
    11. 
  
    
    
  
  11.     </dependency>
    12.

而在 Gradle 中，我们可以这么做。

 
   
   
 
    
  
    
    
  
  1. compile('com.example.m:m:1.0') {
    2. 
  
    
    
  
  2.     exclude group: 'org.unwanted', module: 'x 
    3. 
  
    
    
  
  3. }
    4. 
  
    
    
  

    5.



Gradle与Kotlin

我们想要在 gradle 中增加 kotlin 非常的简单，仅仅需要在 build.gradle 增加

 
   
   
 
    
  
    
    
  
  1. plugins {
    2. 
  
    
    
  
  2.      id "org.jetbrains.kotlin.jvm" version "x.x.xx" // 增加插件
    3. 
  
    
    
  
  3. }
    4. 
  
    
    
  
    5. 
  
    
    
  
  5. dependencies {
    6. 
  
    
    
  
  6.   compile "org.jetbrains.kotlin:kotlin-stdlib:x.xx.xx" // 增加依赖
    7. 
  
    
    
  
  7. }
    8. 
  
    
    
  

    9.

大功告成，对了，默认的 Kotlin 的源码路径是 src/main/kotlin, 测试源码是 src/text/kotlin 如果需要修改可以使用 

 
   
   
 
    
  
    
    
  
  1. sourceSets {
    2. 
  
    
    
  
  2.     main.kotlin.srcDirs += 'src/main/myKotlin'
    3. 
  
    
    
  
  3.     main.java.srcDirs += 'src/main/myJava'
    4. 
  
    
    
  
  4. }
    5. 
  
    
    
  

    6.


其他

Gradle Wrapper

Gradle Wrapper 做了三件事情

  • 解析参数传入 gradlew

  • 安装正确的 Gradle 版本

  • 调用 Gradle 执行命令

Ops，Gradle Wrapper 为什么还需要安装 Gradle，我们在用 Maven 都知道，我们需要自己先安装好一个 Maven版本，因为 Maven 发展多年，现在已经稳定，已经不存在很多个版本并存的现状了，但是我们依然需要去在每个机器上去安装，那我什么我们不能在自己的 构建脚本 中就指定我们的构建工具呢？所以我们在 wrapper/gradle-wrapper.properties 中就可以发现 distributionUrl=https\://services.gradle.org/distributions/gradle-4.2.1-bin.zip 这里也就是定义了我们的gradle所使用的版本。


Gradle In Real World 

 
   
   
 
    
  
    
    
  
  1. // 定义一堆基础插件
    2. 
  
    
    
  
  2. apply plugin: 'java'
    3. 
  
    
    
  
  3. apply plugin: 'maven'
    4. 
  
    
    
  
  4. apply plugin: "jacoco"
    5. 
  
    
    
  
  5. apply plugin: 'checkstyle'
    6. 
  
    
    
  
  6. apply plugin: 'pmd'
    7. 
  
    
    
  
  7. apply plugin: 'findbugs'
    8. 
  
    
    
  
  8. apply plugin: 'eclipse'
    9. 
  
    
    
  
  9. apply plugin: 'idea'
    10. 
  
    
    
  
  10. // 定义项目属性
    11. 
  
    
    
  
  11. group = 'Common'
    12. 
  
    
    
  
  12. version = '1.0.0'
    13. 
  
    
    
  
  13. description = """Giant common library"""
    14. 
  
    
    
  
    15. 
  
    
    
  
  15. // 定义依赖仓库
    16. 
  
    
    
  
  16. repositories {
    17. 
  
    
    
  
  17.     mavenCentral()
    18. 
  
    
    
  
  18. }
    19. 
  
    
    
  
    20. 
  
    
    
  
  20. // 额外增加source path
    21. 
  
    
    
  
  21. sourceSets {
    22. 
  
    
    
  
  22.     main {
    23. 
  
    
    
  
  23.         resources {
    24. 
  
    
    
  
  24.             srcDir "src/main/profiles/${profile}"
    25. 
  
    
    
  
  25.         }
    26. 
  
    
    
  
  26.     }
    27. 
  
    
    
  
  27. }
    28. 
  
    
    
  
  28. // project依赖
    29. 
  
    
    
  
  29. dependencies {
    30. 
  
    
    
  
  30.     compile 'ch.qos.logback:logback-core:1.0.13'
    31. 
  
    
    
  
  31.     compile 'ch.qos.logback:logback-classic:1.0.13'
    32. 
  
    
    
  
  32.     compile 'ch.qos.logback:logback-access:1.0.13'
    33. 
  
    
    
  
  33.     compile 'commons-io:commons-io:2.0.1'
    34. 
  
    
    
  
  34.     compile 'commons-lang:commons-lang:2.6'
    35. 
  
    
    
  
  35.     compile 'joda-time:joda-time:1.6.2'
    36. 
  
    
    
  
  36.     compile 'org.testng:testng:6.8.7'
    37. 
  
    
    
  
  37.     compile 'com.googlecode.jmockit:jmockit:1.5'
    38. 
  
    
    
  
  38.     ...
    39. 
  
    
    
  
  39. }
    40. 
  
    
    
  
  40. // task配置
    41. 
  
    
    
  
  41. checkstyle {
    42. 
  
    
    
  
  42.     ignoreFailures = true
    43. 
  
    
    
  
  43.     sourceSets = [sourceSets.main]
    44. 
  
    
    
  
  44. }
    45. 
  
    
    
  
  45. findbugs {
    46. 
  
    
    
  
  46.     ignoreFailures = true
    47. 
  
    
    
  
  47.     sourceSets = [sourceSets.main]
    48. 
  
    
    
  
  48. }
    49. 
  
    
    
  
  49. pmd {
    50. 
  
    
    
  
  50.     ruleSets = ["basic", "braces", "design"]
    51. 
  
    
    
  
  51.     ignoreFailures = true
    52. 
  
    
    
  
  52.     sourceSets = [sourceSets.main]
    53. 
  
    
    
  
  53. }
    54. 
  
    
    
  
  54. jacocoTestReport {
    55. 
  
    
    
  
  55.     reports {
    56. 
  
    
    
  
  56.         xml.enabled true
    57. 
  
    
    
  
  57.         html.enabled true
    58. 
  
    
    
  
  58.         csv.enabled false
    59. 
  
    
    
  
  59.     }
    60. 
  
    
    
  
  60.     sourceSets sourceSets.main
    61. 
  
    
    
  
  61. }
    62. 
  
    
    
  
  62. tasks.withType(Compile) {
    63. 
  
    
    
  
  63.     options.encoding = "UTF-8"
    64. 
  
    
    
  
  64. }
    65. 
  
    
    
  
  65. test {
    66. 
  
    
    
  
  66.     useTestNG()
    67. 
  
    
    
  
  67.     jacoco {
    68. 
  
    
    
  
  68.         excludes = ["org.*"]
    69. 
  
    
    
  
  69.     }
    70. 
  
    
    
  
  70. }
    71. 
  
    
    
  

    72.


Gradle常用指令

枚列所有可用任务

 
   
   
 
    
  
    
    
  
  1. ❯ gradle tasks
    2. 
  
    
    
  
    3. 
  
    
    
  
  3. ------------------------------------------------------------
    4. 
  
    
    
  
  4. All tasks runnable from root project
    5. 
  
    
    
  
  5. ------------------------------------------------------------
    6. 
  
    
    
  
    7. 
  
    
    
  
  7. Archive tasks
    8. 
  
    
    
  
  8. -------------
    9. 
  
    
    
  
  9. zip - Archives sources in a zip file
    10. 
  
    
    
  
    11. 
  
    
    
  
  11. Build tasks
    12. 
  
    
    
  
  12. -----------
    13. 
  
    
    
  
  13. assemble - Assembles the outputs of this project.
    14. 
  
    
    
  
  14. build - Assembles and tests this project.
    15. 
  
    
    
  
  15. clean - Deletes the build directory.
    16. 
  
    
    
  

    17.


构建配置属性

 
   
   
 
    
  
    
    
  
  1. ❯ gradle properties
    2. 
  
    
    
  

    3.


显示构建详情

在 build.gradle 设置

 
   
   
 
    
  
    
    
  
  1. logging.level = LogLevel.DEBUG
    2. 
  
    
    
  

    3.

或者在运行的

 
   
   
 
    
  
    
    
  
  1. ❯ gradle build --stacktrace 
    2. 
  
    
    
  

    3.
参考资料&推荐文档

  • Gradle入门教程(http://blog.jobbole.com/71999/)

  • Gradle介绍(https://www.jianshu.com/p/00d5469e25e7)

  • 官方教材(https://guides.gradle.org/creating-new-gradle-builds/)

点击“阅读原文”

以上是关于Gradle 简易入门教程的主要内容，如果未能解决你的问题，请参考以下文章

Gradle 引入本地定制 jar 包

Android第一行代码之制作简易版新闻应用

cinatra简易入门教程

Lua简易教程

makefile简易教程

最新翻译的官方 PyTorch 简易入门教程