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版本號更改完成！