gradle编译安装

‘壹’ android sutdio 安装 gradle 目录在哪

不建议针对 Android Studio 的 Gradle 进行环境变量配置以及命令行的命令编译。

Android Studio 自带了项目编译所需的 Maven 依赖，通过 Android Studio 的 Gradle 选项卡，可以进行 Gradle 的命令操作。

如果你使用命令行的实行使用 Gradle 命令，它会从网络上下载依赖。而在中国，想成功下载这些依赖正常情况下是不可能的。所以，建议不要使用命令行的方式。

‘贰’ gradle bootrun cas-gradle-overlay-template项目失败

今天向大家介绍的是spring-boot，这个java框架在RESTful思想的背景下，也火了一把，而且还可能火下去。因此就研究了一下怎么搞。

实际上过程很简单。关键在于理解概念，以及在哪种情况下，使用哪种工具。如果这个可以在头脑中有一个清晰的逻辑概念，那就一切OK。

1. 先简介一下各种工具框架的作用

首先是Gradle,实际上这个工具在我的其他手记中已经有说道，就是一个自动化建构工具，为了解决依赖问题，同时构建项目和打包部署项目。这样就能拨开面纱，看她的脸了。Maven主要因为xml的繁琐，会被抛弃。但是现在的大多数项目还在使用Maven，因为路径依赖的问题，还是会存在一段时间的。（个人看法）

然后是spring-boot 这个框架，这个框架就需要我们打破web传统，可以没有web.xml,也可以不用装tomcat，所有的内容都在一个jar中就可以完成。只需运行java -jar xxx 就可以完成了。但是不知道效率、性能怎么样？ 不过就简单性，是OK的。而且一切又回归到main了，这不也是所有语言的开始吗？

至于，在spring-boot中结合jersey实现RESTful，也只用理解jersey只是一种实现而已，然后在spring-boot中注册一下，就可以了，不过具体细节还有很多，这个要在下一篇具体介绍。

2. 安装，创建项目

首先安利一个网站 start spring-boot，可以在网站上直接定制需要的技术，像AOP，JDBC，MYSQL，AMQP等都可以直接生成。其他步骤如下，首先安装好gradle，注意：配置好环境变量。切换到项目目录后，直接gradle init 即可，然后就是一些约定俗成的文件夹格式。可以自己手动创建好就行了。

修改gradle.bat 中的set DEFAULT_JVM_OPTS= 默认为空 修改为set DEFAULT_JVM_OPTS="-Dfile.encoding=UTF-8" 可以在上图中看到JVM参数一栏中这个参数GBK，然后直接修改。

3.2 热部署

spring-boot-devtools 可以参考一下这篇文章：springboot + devtools（热部署）

reload和restart的区别

restart：先stop 再start，服务会停止。如果重启了肯定就会reload的。

reload是只是重新加载文件，但是服务不停。重新加载，就像网页F5一样。

这些细微的区别才是关键。

3.3 debug

怎么实现debug运行

gradle bootRun --debug-jvm

在ide中的话直接右键单击debug运行java Application是不是异常的简单啊。

4. 重要文件分析

build.gradle

buildscript {
ext {
springBootVersion = '1.5.1.RELEASE'
}
repositories {
mavenCentral()
}
dependencies {
classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
}
}
apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'
jar {
baseName = 'spring-boot'
version = '0.0.1-SNAPSHOT'
}
repositories {
jcenter()
}
dependencies {
compile group: 'org.springframework.boot', name: 'spring-boot-starter-test', version: '1.5.1.RELEASE'
compile group: 'org.springframework.boot', name: 'spring-boot-starter-web', version: '1.5.1.RELEASE'
compile group: 'org.springframework.boot', name: 'spring-boot-devtools', version: '1.5.1.RELEASE'
compile group: 'org.springframework.boot', name: 'spring-boot-starter-jersey', version: '1.5.1.RELEASE'
testImplementation 'junit:junit:4.12'
}
sourceCompatibility = 1.8
targetCompatibility = 1.8
tasks.withType(JavaCompile) {
options.encoding = "UTF-8"
}

这个文件里面包含3块 构建脚本， 包依赖，编译打包。

Application.java 启动

package web;
import org.glassfish.jersey.servlet.ServletContainer;
import org.glassfish.jersey.servlet.ServletProperties;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.boot.web.servlet.ServletRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import config.DatabaseProperties;
import config.JerseyConfig;
import config.RedisProperties;
@SpringBootApplication
public class Application {
@Bean
public ServletRegistrationBean jerseyServlet() {
ServletRegistrationBean registration =
new ServletRegistrationBean(new ServletContainer(), "/rest/*");
registration.addInitParameter(
ServletProperties.JAXRS_APPLICATION_CLASS, JerseyConfig.class.getName());
return registration;
}
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
}

中间的一串@Bean在这里可以无视，是注册jersey用的，后面再说。spring-boot在运行的时候会扫描有main方法的类，这里就是Application类，然后运行main方法，这里SpringApplication
Hello.java 访问

package web;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.core.env.Environment;
import org.springframework.web.bind.annotation.*;
import config.RedisProperties;

@RestController
public class Hello {

@RequestMapping("/")
public String hello() {
return "hello world";
}
}

‘叁’ myeclipse怎么配置gradle

myeclipse配置gradle过程如下：

1、在线安装地址：网络搜gradle官网地址

‘肆’ 如何在windows中安装gradle

一、路径不同
1.local.properties文件里的SDK路径
a) Windows上sdk.dir=D\: \\Android\\sdk，注意这里的转义字符，下同
b) linux上 sdk.dir=/home/adt-bundle-linux-x86/sdk
2.在gradle-wrapper.properties文件里的Gradle路径与版本
a) Windows 上distributionUrl=https\://services.gradle.org/distributions/gradle-2.8-all.zip
b) Linux上distributionUrl=https\://services.gradle.org/distributions/gradle-2.10-bin.zip
3.在keystore.properties文件里的签名文件路径不同
a) Windows上storeFile=\\keys\\JenkinsGradleTest.jks
b) Linux上storeFile=/keys/JenkinsGradleTest.jks
二、编译版本和编译工具版本不同
app/build.gradle文件里minSdkVersion、targetSdkVersion和 buildTools 版本号，需要调整
a) Windows 上minSdkVersion 14，targetSdkVersion 18，buildToolsVersion "23.0.2"
b) Linux 上minSdkVersion 14， targetSdkVersion 19， buildToolsVersion "21.0.2"
三、Gradle参数不同
当用户下.gradle/ gradle.properties文件内容不同，如果没有该就手动创建一个。
a) Windows上C:/Users/Kenny/.gradle/gradle.properties，设置如下：org.gradle.daemon=true
b) Linux上/home/tester/.gradle/gradle.properties，设置如下：org.gradle.daemon=false

‘伍’ minecraft我的世界gradle构建，总是失败，求告诉详细教程。不要发网址，要会的人。不会的

最近在项目中遇到一个不大，但是还蛮烦人的问题，在Maven的约定中，一个标准Java项目的代码结构如下：
project
--src
--main
--java
--resources
--test
--java
--resources

当‘gradle idea’构建intelliJ项目文件时，会自动帮忙设置好所有的Source Root，Test Source Root。但是，在我工作的部门中，我们希望可以把测试分为unit，intg2个类别，这样可以更加容易区分测试的目的，同时提供了Build Pipeline分别运行不同类别测试的能力。因此，我们部门内的标准Java项目结构如下：
project
--src
--main
--java
--resources
--test
--common
--java
--unit
--java
--resources
--intg
--java
--resources

有了这个目录结构之后我们剩下2个问题要解决：
1. 如何区分运行IntegrationTest和Unit Test
2. 如何保证‘gradle idea’以后，无需重新设置Test Source Root。因为gradle不具备识别新的代码结构的能力。

如何写一个Gradle Plugin

语言：
Java，Groovy，Scala都可，推荐用Groovy,毕竟Gradle本质上来说就是一个用Groovy写的DSL，使用Groovy可以更一致一点。

注入方式：
Gradle支持3种形式的定制Plugin注入：

1. 直接把Plugin源代码直接写在Build Script里面。
2. 把Pluigin源代码写到rootProjectDir/buildSrc/src/main/groovy目录下
3. 用一个单独的project来写Plugin源代码，然后以jar依赖的形式注入项目。

个人觉得，都想到要自己写一个Plugin了，那么一定是有多个项目公用这个Plugin了，否则的话，直接把Plugin的代码直接写到脚本里就好了。因此，要定制Plugin，在我看来，一定是需要以一个单独的jar形式注入的。

写project-structure Plugin:
在Gradle中，写一个Plugin非常简单，首先，添加项目依赖，我使用Groovy来写插件，所以添加了localGroovy依赖。

Gradle代码
apply plugin: 'groovy'

dependencies {
compile gradleApi()
compile localGroovy()
}

然后写Plugin的实现代码，实现代码只需要实现Plugin<Project>接口即可，在我的实现代码中，做了两件事，一是定制了项目的代码结构，二是添加了integrationTest Task，该Task只运行*IntegrationTest.class, 这样可以在Build Pipeline分阶段运行Unit Test和IntegrationTest。

Groovy代码
import org.gradle.api.Plugin
import org.gradle.api.Project
import org.gradle.api.tasks.testing.Test

class ProjectStructurePlugin implements Plugin<Project> {
@Override
void apply(Project project) {
project.logger.info "Configuring Project Structure for $project.name"

project.configurations {
integrationTestCompile { extendsFrom testCompile }
integrationTestRuntime { extendsFrom integrationTestCompile, testRuntime }
}
configureSourceSets(project)
addIntegrationTestTask(project)
}

private void addIntegrationTestTask(Project project) {
Test intgTest = project.getTasks().create("integrationTest", Test.class);
intgTest.testClassesDir = project.sourceSets.integrationTest.output.classesDir
intgTest.includes = ["**/*IntegrationTest.class"]
intgTest.inputs.dir 'src'
intgTest.outputs.dir project.sourceSets.integrationTest.output.classesDir
project.check.dependsOn project.integrationTest
intgTest.dependsOn project.test
}

private void configureSourceSets(Project project) {
project.sourceSets {
test {
java {
srcDir 'src/test/unit/java'
srcDir 'src/test/common/java'
}
resources {
srcDir 'src/test/unit/resources'
}
}

integrationTest {
java {
srcDir 'src/test/intg/java'
srcDir 'src/test/common/java'
}
resources {
srcDir 'src/test/intg/resources'
}
compileClasspath = project.sourceSets.main.output + project.sourceSets.test.output + project.configurations.integrationTestCompile
runtimeClasspath = output + compileClasspath + project.configurations.integrationTestRuntime
}
}
}
}

接着，在项目的src/main/resources/META-INF/gradle-plugins目录下，创建一个文件：<plugin-name>.properties,在该文件中指定Plugin的实现类：

Java代码
implementation-class=com.xianlinbox.plugins.ProjectStructurePlugin

在项目中使用该Plugin
首先，需要在build.gradle脚本中引入该Plugin的jar包依赖，可以是以文件的形式，当然个人更推荐的是把jar包发布到Maven库中，以Maven依赖的形式的注入，本例中使用的是本地文件依赖：

Groovy代码
buildscript {
dependencies {
classpath fileTree(dir: 'libs', include: '*.jar')
}
}
然后，注入编写的插件，注意，该插件必须和java plugin一起使用，因为其中使用到SourceSets属性是从该插件中引入进来的：

Groovy代码
apply plugin: 'java'
apply plugin: 'project-structure'

有了这个插件之后，就可以通过‘gradle test’和‘gradle integrationtTest’区别运行UnitTest和IntrgrationTest了。

最后，解决自动设置Test Source Root的问题，只需要在build.gradle为ideaMole Task增加识别Test Source Root的能力即可：

Groovy代码
apply plugin: 'idea'
...
idea {
mole {
testSourceDirs += file('src/test/intg/java')
testSourceDirs += file('src/test/intg/resources')
}
}

当然，我们也可以把它写到Plugin中去，在设置为Project-Structrue之后：

Groovy代码
......
compileClasspath = project.sourceSets.main.output + project.sourceSets.test.output + project.configurations.integrationTestCompile
runtimeClasspath = output + compileClasspath + project.configurations.integrationTestRuntime
project.idea {
mole {
testSourceDirs = testSourceDirs + new File('src/test/intg/java') + new File('src/test/intg/resources')
}
}
1、安装
Gradle安装和Maven一样方便，只需要，下载(http://www.gradle.org/downloads )==》解压==》配置环境变量(GRADLE_HOME & PATH)，配置好环境变量之后记得使用 source命令使新的环境变量生效。配置成功之后，可以在命令行通过 “gradle -v"验证是否安装成功。

2、Gradle编译Maven风格的java项目
首先，在项目根目录创建"build.gradle"文件，编译java项目需要使用gradle的java插件
Groovy代码
apply plugin: 'java'
,因为要集成maven的功能，需要添加maven插件
Groovy代码
apply plugin: 'maven'[
。
接着，配置项目的Repository，风格如下
Groovy代码
repositories{
mavenCentral();
}
，上面例子使用的是默认的maven的中央库，如果想用自己的本地库，可通过如下方式配置
Groovy代码
def localMavenRepo = 'file://' + new File(System.getProperty('user.home'), '.m2/repository').absolutePath
repositories {
// Use local Maven repo location. We don't need this if we only want to install
// an artifact, but we do need it if we want to use dependencies from the local
// repository.
mavenRepo urls: localMavenRepo
mavenCentral()
}

再然后，配置项目依赖的第三方库，配置模板如下:
Groovy代码
dependencies{
compile group: '<group-id>',name:'<artifact-id>',version:'<version>'
}
，举个例子，假设项目依赖了4.10版本的junit，那么配置就是
Groovy代码
compile group: 'junit',name:'junit',version:'4.10'
另外Depencies还可以按如下方式简写
Groovy代码
compile '<group-id>:<artifact-id>:<version>'
例子
Groovy代码
compile 'junit:junit:4.10'

最后，如何把自己的项目发布到Repository中，
Groovy代码
uploadArchives {
repositories {
mavenDeployer {
repository(url: "file://localhost/tmp/myRepo/")
}
}

‘陆’ eclipse怎么配置gradle

一、Gradle简介

Gradle 是以 Groovy 语言为基础，面向Java应用为主。基于DSL（领域特定语言）语法的自动化构建工具。

二、配置步骤如下：

1、资源下载：

Grandle官网下载Gradle

‘柒’ 如何在 Eclipse 下用 Gradle 构建 Web Application

使用的环境是: Eclipse IDE for Java EE Developers Kepler + JDK 1.7.

好, 下面正式开始:

1.安装 Gradle 插件. 在 Eclipse Marketplace 中搜索 Gradle, 选择安装 Gradle Integration for Eclipse

2.新建一个 Dynamic Web Project, 在项目根目录下新建 build.gradle 文件, 并向其中写入如下内容:

importorg.gradle.plugins.ide.eclipse.model.Facet

applyplugin:'java'
applyplugin:'war'
applyplugin:'eclipse-wtp'

sourceCompatibility=1.7//设置JDK版本
webAppDirName='WebContent'//设置WebApp根目录
sourceSets.main.java.srcDir'src'//设置Java源码所在目录

//设置maven库地址
repositories{
mavenCentral()//中央库
//maven{url'http://maven.oschina.net/content/groups/public/'}//自定义库地址
}

//设置依赖
dependencies{
providedCompile'javax.servlet:servlet-api:2.5'//编译期
providedRuntime'javax.servlet:jstl:1.2'//运行时
}

//设置ProjectFacets
eclipse{
wtp{
facet{
facetname:'jst.web',type:Facet.FacetType.fixed
facetname:'wst.jsdt.web',type:Facet.FacetType.fixed
facetname:'jst.java',type:Facet.FacetType.fixed
facetname:'jst.web',version:'3.0'
facetname:'jst.java',version:'1.7'
facetname:'wst.jsdt.web',version:'1.0'
}
}
}

3.接下来在项目上右击 -> configure -> convert to Gradle project

4.再次在项目上右击 -> Gradle -> Refresh All

5.如果没有 web.xml 文件的话, 再右击项目 -> Java EE Tools -> Generate Deployment Descriptor Stub

6.最后看下效果如何, 在 WebContent 下新建 index.jsp 里面随便写点什么, 然后项目上右击 -> Run As -> Run on Server

如果成功显示的话那么就一切 OK 了.

‘捌’ gradle配置不成功，求助贴

近项目遇蛮烦问题Maven约定标准Java项目代码结构：
project
--src
--main
--java
--resources
--test
--java
--resources

‘gradle idea’构建intelliJ项目文件自帮忙设置所Source RootTest Source Root我工作部门我希望测试unitintg2类别更加容易区测试目同提供Build Pipeline别运行同类别测试能力我部门内标准Java项目结构：
project
--src
--main
--java
--resources
--test
--common
--java
--unit
--java
--resources
--intg
--java
--resources

目录结构我剩2问题要解决：
1. 何区运行IntegrationTestUnit Test
2. 何保证‘gradle idea’需重新设置Test Source Rootgradle具备识别新代码结构能力

何写Gradle Plugin

语言：
JavaGroovyScala都推荐用Groovy,毕竟Gradle本质说用Groovy写DSL使用Groovy更致点

注入式：
Gradle支持3种形式定制Plugin注入：

1. 直接Plugin源代码直接写Build Script面
2. Pluigin源代码写rootProjectDir/buildSrc/src/main/groovy目录
3. 用单独project写Plugin源代码jar依赖形式注入项目

觉都想要自写Plugin定项目公用Plugin否则直接Plugin代码直接写脚本要定制Plugin我看定需要单独jar形式注入

写project-structure Plugin:
Gradle写Plugin非简单首先添加项目依赖我使用Groovy写插件所添加localGroovy依赖

Gradle代码
apply plugin: 'groovy'

dependencies {
compile gradleApi()
compile localGroovy()
}

写Plugin实现代码实现代码需要实现Plugin接口即我实现代码做两件事定制项目代码结构二添加integrationTest Task该Task运行*IntegrationTest.class, Build Pipeline阶段运行Unit TestIntegrationTest

Groovy代码
import org.gradle.api.Plugin
import org.gradle.api.Project
import org.gradle.api.tasks.testing.Test

class ProjectStructurePlugin implements Plugin {
@Override
void apply(Project project) {
project.logger.info "Configuring Project Structure for $project.name"

project.configurations {
integrationTestCompile { extendsFrom testCompile }
integrationTestRuntime { extendsFrom integrationTestCompile, testRuntime }
}
configureSourceSets(project)
addIntegrationTestTask(project)
}

private void addIntegrationTestTask(Project project) {
Test intgTest = project.getTasks().create("integrationTest", Test.class);
intgTest.testClassesDir = project.sourceSets.integrationTest.output.classesDir
intgTest.includes = ["**/*IntegrationTest.class"]
intgTest.inputs.dir 'src'
intgTest.outputs.dir project.sourceSets.integrationTest.output.classesDir
project.check.dependsOn project.integrationTest
intgTest.dependsOn project.test
}

private void configureSourceSets(Project project) {
project.sourceSets {
test {
java {
srcDir 'src/test/unit/java'
srcDir 'src/test/common/java'
}
resources {
srcDir 'src/test/unit/resources'
}
}

integrationTest {
java {
srcDir 'src/test/intg/java'
srcDir 'src/test/common/java'
}
resources {
srcDir 'src/test/intg/resources'
}
compileClasspath = project.sourceSets.main.output + project.sourceSets.test.output + project.configurations.integrationTestCompile
runtimeClasspath = output + compileClasspath + project.configurations.integrationTestRuntime
}
}
}
}

接着项目src/main/resources/META-INF/gradle-plugins目录创建文件：.properties,该文件指定Plugin实现类：

Java代码
implementation-class=com.xianlinbox.plugins.ProjectStructurePlugin

项目使用该Plugin
首先需要build.gradle脚本引入该Pluginjar包依赖文件形式更推荐jar包发布Maven库Maven依赖形式注入本例使用本文件依赖：

Groovy代码
buildscript {
dependencies {
classpath fileTree(dir: 'libs', include: '*.jar')
}
}
注入编写插件注意该插件必须java plugin起使用其使用SourceSets属性该插件引入进：

Groovy代码
apply plugin: 'java'
apply plugin: 'project-structure'

插件通‘gradle test’‘gradle integrationtTest’区别运行UnitTestIntrgrationTest

解决自设置Test Source Root问题需要build.gradleideaMole Task增加识别Test Source Root能力即：

Groovy代码
apply plugin: 'idea'
...
idea {
mole {
testSourceDirs += file('src/test/intg/java')
testSourceDirs += file('src/test/intg/resources')
}
}

我写Plugin设置Project-Structrue：

Groovy代码
......
compileClasspath = project.sourceSets.main.output + project.sourceSets.test.output + project.configurations.integrationTestCompile
runtimeClasspath = output + compileClasspath + project.configurations.integrationTestRuntime
project.idea {
mole {
testSourceDirs = testSourceDirs + new File('src/test/intg/java') + new File('src/test/intg/resources')
}
}
1、安装
Gradle安装Maven便需要载( )==》解压==》配置环境变量(GRADLE_HOME & PATH)配置环境变量记使用 source命令使新环境变量效配置功命令行通 gradle -v"验证否安装功

2、Gradle编译Maven风格java项目
首先项目根目录创建"build.gradle"文件编译java项目需要使用gradlejava插件
Groovy代码
apply plugin: 'java'
,要集maven功能需要添加maven插件
Groovy代码
apply plugin: 'maven'[

接着配置项目Repository风格
Groovy代码
repositories{
mavenCentral();
}
面例使用默认maven央库想用自本库通式配置
Groovy代码
def localMavenRepo = 'file://' + new File(System.getProperty('user.home'), '.m2/repository').absolutePath
repositories {
// Use local Maven repo location. We don't need this if we only want to install
// an artifact, but we do need it if we want to use dependencies from the local
// repository.
mavenRepo urls: localMavenRepo
mavenCentral()
}

再配置项目依赖第三库配置模板:
Groovy代码
dependencies{
compile group: '',name:'',version:''
}
举例假设项目依赖4.10版本junit配置
Groovy代码
compile group: 'junit',name:'junit',version:'4.10'
另外Depencies按式简写
Groovy代码
compile '::'
例
Groovy代码
compile 'junit:junit:4.10'

何自项目发布Repository
Groovy代码
uploadArchives {
repositories {
mavenDeployer {
repository(url: "file://localhost/tmp/myRepo/")
}
}

‘玖’ gradle可以编译android源码吗

方法/步骤

1
（可以省略）通过cmd命令行下载gradle源码：
git clone https://github.com/spring-guides/gs-gradle-android.git
2
下载最新的gradle安装包，地址：
http://gradle.org/downloads
点击下载二进制文件

3
解压到d盘，路径为：D:\gradle-2.4
4
打开“计算机”-“右键”-“属性”-“更改设置”-“高级”-“环境变量”，
在系统变量中，点击新建，属性名为GRADLE_HOME，属性值为"D:\gradle-2.4"

5
打开“计算机”-“右键”-“属性”-“更改设置”-“高级”-“环境变量”，
在系统变量中，找到Path，将";D:\gradle-2.4\bin"加入到Path中

6
打开cmd命令行，执行gradle，如果出现如图所示，则说明gradle安装成功

7
打开cmd命令行，进入android工程目录，找到build.gradle文件，在目录执行执行
gradle build
既可开始使用gradle打包apk，在成功后会在同目录生成build文件夹，

‘拾’ android studio更新gradle在哪个目录下

方法/步骤

下载Gradle新版本
选择进入官网下载Gradle新版，我这里选择的是Gradle 2.10版本，然后根据网上其它经验进行安装；

发现编译问题
进入Android studio之后，由于本地电脑已经安装了gradle2.10,Android studio项目依旧配置的是老版本gradle2.4;编译项目的时候，遇到如下图所示问题；

找到项目build.gradle文件
定位到Android studio 里面的项目，找到项目下面的build.gradle文件，gradle 2.4版本所对应的 com.android.tools.build:gradle插件为1.3.0，gradle 2.10对应的插件版本是2.1.0；在build.gradle文件里面更改即可；

找到文件 gradle-wrapper.properties
定位到 项目gradle目录下gradle-wrapper.properties文件，把"distributionUrl= "更改为“ ”；请按照具体版本号进行更改；

点击设置按钮
在Android studio主界面点击设置“setting”,进入Android studio的设置界面；

设置加载本地Gradle
进入设置界面，在左侧搜索框中输入gradle，就可以定位到gradle，然后点击选中选择本地的Gradle版本；如图所示；这样，项目进行编译运行，编译成功，Gradle版本号更改完成！