csfchh
csfchh

gradle快速入门

1. Groovy语法

1.1 变量

// groovy支持类型推断，def可以不写，但是规范一点还是带上
def a = 5;
def b = "groovy"

1.2 函数与闭包

1.2.1 函数

函数比较简单，就不赘述了。

下面的示例演示了函数的定义与调用：

def add(var1, var2){
	//函数的最后一行作为返回值，与kotlin一致，可以省略return
	var1+var2
}
// 传统的调用函数方式
println "test1: ${add(1, 2)}"
// 不用括号调用函数
println "test2: ${add 'a', 'b'}"

下面演示了利用groovy执行命令行的方法：

def gitVersion(){
	if(System.getenv('CI_BUILD')){
		return 1;
	}
	def cmd ='git rev-list HEAD --first-parent --count'
	cmd.execute().text.trim().toInteger()
}

android {
  defaultConfig {
    versionCode gitVersion()
  }
  ......
}

1.2.2 闭包

闭包是groovy的重要特性之一，详细的使用方法可以参考官网的相关介绍。闭包的定义及基本使用：

// 闭包的定义及调用
def closure = { String param ->
	println "param.len = ${param.length()}"
}
closure("abc")
closure.call("abc")

闭包作为函数入参：

def func(Closure closure){
	closure()
}

func {
	println 'closure as parameter'
}

闭包有this、owner、delegate三个属性，在闭包内调用方法时，由他们来确定使用哪个对象来处理。来看一个委托模式的示例：

class Person {
    String personName = '李四'  
    int personAge = 18
    def printPerson(){
        println "name is ${personName},age is ${personAge}"
    }
}

def person(Closure<Person> closure){
    Person p = new Person();
    // 将闭包与代理对象绑定，这一步是必须的
    closure.delegate = p    
    // 代理模式：
    // 0. Closure.OWNER_FIRST：自身优先，默认
    // 1. Closure.DELEGATE_FIRST：代理优先
    // 2. Closure.OWNER_ONLY：仅自身
    // 3. Closure.DELEGATE_ONLY：仅代理
    closure.setResolveStrategy(Closure.DELEGATE_FIRST);
    return closure
}
 
def closure = person {
    personName = '张三'
    personAge = 20
    printPerson()
}
 
task configClosure {
    doLast {
        closure()
    }
}

将ResolveStrategy分别设置为4种类型，运行：./gradlew configClosure 将得到下面的运行结果：

Closure.OWNER_FIRST Closure.DELEGATE_FIRST Closure.OWNER_ONLY Closure.DELEGATE_ONLY
> Task :configClosure name is 张三,age is 20 > Task :configClosure name is 张三,age is 20 Execution failed for task ':configClosure'. > Could not set unknown property 'personName' of type org.gradle.api.Project. > Task :configClosure name is 张三,age is 20

可见除了Closure.OWNER_ONLY其余结果都是我们希望得到的，如果想打印默认的“李四”该怎么办呢？很简单不要重写对应的属性即可：

def closure = person {
    // personName = '张三'
    // personAge = 20
    printPerson()
}

相信到这里你应该理解了闭包与代理对象间的相互关系了，Gradle中大量使用的Extension正是利用了这一特性，比如APG常见的：

  • Plugin com.android.application uses {@link AppExtension}
  • Plugin com.android.library uses {@link LibraryExtension}
  • Plugin com.android.test uses {@link TestExtension}
  • Plugin com.android.atom uses {@link AtomExtension}
  • Plugin com.android.instantapp uses {@link InstantAppExtension}

上述XXXExtension都继承自BaseExtension，我们覆写相关Extension的属性达到更新配置的目的。

闭包的写法也很有特色，现有如下接口原型：PublicationContainer#create(String name, Class type, Action configuration) ，下面两种写法都是可以的：

publishing {
    publications{ PublicationContainer it->
        libName(MavenPublication) {
            version "$libVersion"
            artifactId "$libArtifactId"
            groupId "$libGroupId"
        }
    }

    publications.create("$libArtifactId", MavenPublication) {
        version "$libVersion"
        artifactId "$libArtifactId"
        groupId "$libGroupId"
    }
}

1.3 操作符重载

操作符重载

1.4 拓展方法

參考：http://www.blogjava.net/johnnyjian/archive/2010/03/19/315962.html

Metaclass就是Class的Class，Class定義了該類實例的行為，Metaclass則定義了該類及其實例的行為(http://en.wikipedia.org/wiki/Metaclass))。Groovy通過Metaclass使程序可以在運行時修改/添加類的方法、屬性等（動態性）。

在Groovy中，每個Class都有一個對應的Metaclass，通過這個Metaclass可以給這個Class添加方法或屬性：

示例：為String類添加新方法

 String.metaClass.capitalize = {  delegate[0].toUpperCase() + delegate[1..-1] }
 println("very".capitalize())  // 首字母大寫

2. 基本概念

2.0 获取帮助

// 获取指定task的帮助说明
gradle help --task "taskName"

// 获取所有task
gradle tasks --all

Tips

  • 执行指定task
// 默认对rootProject执行命令
gradle assembleRelease
// 指定subProject执行命令
gradle :app:assembleRelease
  • task支持缩写
// gradle支持驼峰缩写执行命令：等同于执行gradle assembleRelease
gradle aR
  • task批量执行

来源：经验:Android批量打包APK并批量安装

./gradlew :B:assembleRelease
./gradlew :C:assembleDebug
./gradlew :D:assembleAndroidTest

// 三个任务可以合并为下面
./gradlew clean :B:assembleRelease :C:assembleRelease :D:assembleAndroidTest

2.1 gradle构建周期

  1. Initialization
    此阶段会根据setting.gradle创建Project对象，默认至少有个rootProject，可以添加更多子项目，如：
// 创建3个子项目
include ':app', ':a', ':b'
  1. Configuration
    执行每个Project的build.gradle脚本，完成脚本的构建流程。该阶段执行完毕后，整个脚本有多少个task以及task之间的依赖关系就确定了。需要注意的是该阶段不会执行task的执行内容（doFirst {}/ doLast {}），但是会执行task的构建内容。
  2. Execution
    task 的执行阶段。先执行 doFirst {} 闭包中的内容，最后执行 doLast {} 闭包中的内容。

例如下build.gradle文件：

task printString {
    group 'test'
    description 'this is a task grouped as test.'
	println "block run during configuration."
	doLast {
		println "doLast group:$group, description:$description"
	}
	doFirst {
		println "doFirst group:$group, description:$description"
	}
}

我们在命令行执行：gradle printString，结果如下：

Starting a Gradle Daemon (subsequent builds will be faster)

> Configure project :
block run during configuration.

> Task :printString
doFirst group:test, description:this is a task grouped by test
doLast group:test, description:this is a task grouped by test

BUILD SUCCESSFUL in 8s
1 actionable task: 1 executed
  • gradle的执行入口文件默认是build.gradle文件，也称为构建脚本。执行gradle命令时从当前目录下寻找 build.gradle 文件来执行构建。
  • project中的全局变量可以通过在rootProject的build.gradle中定义 ext{…}来配置，需要引用的地方直接$varName即可。

2.2 构建周期hook入口

前面提到了在Configuration执行完毕后才建立起task graph，因此如果我们想做一些依赖于非gradle自带task的操作时，就要等待Configuration执行完毕，并且是自动执行。gradle为我们提供了这样的hook入口：
gradle快速入门_第1张图片
在上面的示例build.gradle中继续增加：

afterEvaluate { Project project ->
	println "afterEvaluate ${project.name}"
}

task hook {
	afterEvaluate { Project project ->
		println "afterEvaluate2 ${project.name}"
	}
}

gradle.projectsEvaluated {
	println "projectsEvaluated"
	tasks.findByName("printString").doFirst {
		println 'hook printString from projectsEvaluated'
	}
}

然后执行gradle printString，输出结果为：

> Configure project :
block run during configuration.
afterEvaluate test1
afterEvaluate2 test1
projectsEvaluated

> Task :printString
hook printString from projectsEvaluated
doFirst group:test, description:this is a task grouped by test
doLast group:test, description:this is a task grouped by test

BUILD SUCCESSFUL in 1s
1 actionable task: 1 executed

2.3 三个对象

在gradle执行的时候，会将三种不同的脚本文件转换成对应的三个对象：

  1. Gradle对象：当我们执行gradle xxx命令的时候，gradle会从默认的配置脚本中构造出一个Gradle对象。在整个执行过程中，只有这么一个对象。Gradle对象的数据类型就是Gradle。我们一般很少去定制这个默认的配置脚本。
  2. Project对象：每一个build.gradle会转换成一个Project对象。
  3. Settings对象：每一个settings.gradle都会转换成一个Settings对象。
initialization
configuration
settings.gradle
Settings对象
build.gradle
Project对象

3. gradle插件

gradle插件分为：

  1. 脚本插件：
    一个.gradle为后缀的脚本文件，定义一些函数或执行一些逻辑，使用方法：eg. apply from: ‘xxx.gradle’。
  2. 对象插件：
    通过编写一个自定义类实现Plugin接口，重写其@Override void apply(Project project) {…}方法，使用方法：eg. apply plugin: PluginFullClassname或者PluginID 。

gradle插件本质上为一系列task的集合，通过插件的形式实现gradle task的复用和传播，相当于开发中的lib。例如作为安卓研发，谷歌为我们开发的com.android.tools.build:gradle:version插件（gradle-plugin与gradle版本关系）就包含了com.android.application和com.android.library两大功能，涵盖了安卓开发汇总涉及到的各种task，熟练掌握这些task将获得很多我们“一般认知”之外的开发能力，可以查阅文末参考资料进一步学习。

3.1 常用插件简介

3.1.1 Gradle Plugin

在gradle官方用户文档中，特别强调了要熟悉核心插件的使用。java和android插件的通用task体包括：

  • assemble：执行打包动作
  • check：执行测试动作
  • build = assemble + check；
  • clean：清除build生成物

这里有几点需要注意：

  • assemble和check不执行具体任务，而是一个统一的抽象入口，在不同类型的插件中组织调用对应具体task，比如assemble对于Java插件是调用jar这个task，而Android插件则是aar；Java check会调用test这个task，Android test会调用lint、等。
  • 由于java插件和android插件存在功能的重合区，因此同时添加将会报错；
java插件

用于构建任何java项目，提供了’implementation’, 'testImplementation’等依赖方法。

  • 官方文档：
    The Java Plugin

  • 引用方式：
    apply plugin:‘java’

  • 项目结构：

src
main
test
java
resources
java-library插件

此插件是java插件的拓展，用于构建java库文件。

  • 官方文档：
    The Java Library Plugin

  • 引用方式：
    apply plugin:‘java-library’

groovy插件

扩展了java插件，提供了对groovy开发的支持。

  • 官方文档
    The Groovy Plugin

  • 引用方式
    apply plugin:'groovy'

maven插件

用于发布成果物到maven仓库

  • 官方文档

  • 引用方式
    apply plugin:'maven'

3.1.2 Android Gradle Plugin

AGP需要读取Android SDK的路径以调用相关工具，因此需要相关配置，可以通过以下几种方式之一进行：

  1. local.properties中指定sdk.dir；
  2. 配置ANDROID_HOME环境变量；
  3. 在gradle文件中配置android.sdkDirectory；

需要用到NDK时同样需要通过下述方式指定NDK路径：

  1. local.properties中指定ndk.dir；
  2. 在gradle文件中配置android.ndkDirectory；

【参考Gradle官方说明】。由于AGP不是gradle自带的插件，需要在buildScript.dependencies中引入：classpath 'com.android.tools.build:gradle:4.1.0'。

除此之外还应当熟悉安卓的工程结构：

src
main
test
androidTest
java
kotlin
res
assets
aidl
jni
rs
AndroidManifest.xml
com.android.application插件

用于构建安卓apk等安装包。

  • 引用方式：
apply plugin:'com.android.application'
  • extension:
android {
    // 指定构建工具版本，有默认值
    buildToolsVersion 'version'
	defaultConfig{ 
        applicationId	 '**.**.**'
        applicationIdSuffix '.two'  
        minSdkVersion 14
        targetSdkVersion 25
        versionCode  1
        versionName "1.0"
        versionNameSuffix ".0" 
        //用于Library中，可以将混淆文件输出到aar中，供Application混淆时使用。
        consumerProguardFiles 'proguard-rules.pro' 
        //给渠道一个分组加维度的概念，比如现在有三个渠道包，分成免费和收费两种类型，可以添加一个dimension, 
        //打渠道包的时候会自动打出6个包，而不需要添加6个渠道，详细的说明可见 https://developer.android.com/studio/build/build-variants.html#flavor-dimensions。
	    dimensions 'api', 'fee' 
        //ndk的配置，AS2.2之后推荐切换到cmake的方式进行编译。
        externalNativeBuild {   
            cmake {
                cppFlags "-frtti -fexceptions"
                arguments "-DANDROID_ARM_NEON=TRUE"
                buildStagingDirectory "./outputs/cmake"
                path "CMakeLists.txt"
                version "3.7.1"
            }
            ndkBuild {
                path "Android.mk"
                buildStagingDirectory "./outputs/ndk-build"
            }
        }
		ndk{ 
            //只保留特定的api输出到apk文件中。
            abiFilters 'x86', 'x86_64', 'armeabi'   
        }
		javaCompileOptions{
            annotationProcessorOptions {    //注解的配置。
                includeCompileClasspath true //需要使用注解功能。
                arguments = [ eventBusIndex : 'org.greenrobot.eventbusperf.MyEventBusIndex' ]   //AbstractProcessor中可以读取到该参数。
                classNames 
            }
        }

		splits { 
			abi {
                enable true  //开启abi分包
                universalApk true  //是否创建一个包含所有有效动态库的apk
                reset()  //清空defaultConfig配置
                include 'x86','armeabi' //打出包含的包 这个是和defaultConfig累加的
                exclude 'mips'   //排除指定的cpu架构
            }
			density{
                enable true  //开启density分包
                reset()  //清空所有默认值
                include 'xhdpi','xxhdpi'   //打出包含的包 这个是和默认值累加的
                exclude 'mdpi' //排除指定
            }
            language {
              enable true  //开启language分包
              include 'en','cn'  // 指定语言
            }
		}
        //manifest占位符 定义参数给manifest调用，如不同的渠道id。
        manifestPlaceholders = [key:'value']     
        //开启multiDex
        multiDexEnabled true      
        //手动拆包，将具体的类放在主DEX。
        multiDexKeepFile  file('multiDexKeep.txt')    
        //支持Proguard语法，进行一些模糊匹配。
        multiDexKeepProguard  file('multiDexKeep.pro')  
        //混淆文件的列表，如默认的android混淆文件及本地proguard文件，
        proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro' 

        //代码中可以通过BuildConfig.IS_RELEASE 调用。
        buildConfigField('boolean','IS_RELEASE','false')   
        //在res/value 中添加demo。
        resValue('string','appname','demo')  
        //指定特定资源，可以结合productFlavors实现不同渠道的最小的apk包。
        resConfigs "cn", "hdpi"  
        // 给每个模块指定一个特定的资源前缀，可以避免多模块使用相同的文件命名后合并冲突，在build.gradle中指定了这个配置后，AS会检查不合法的资源命名并报错
        resourcePrefix 'xxx_'
	}
	buildTypes{
        debug {
            applicationIdSuffix   '.debug'
            versionNameSuffix '.1'
            //生成的apk是否可以调试 debug默认是true   release默认false
            debuggable true  
            //是否可以调试NDK代码 使用lldb进行c和c++代码调试
            jniDebuggable true   
            //是否开启png优化，会对png图片做一次最优压缩，影响编译速度，debug默认是false，release默认true
            crunchPngs   true  
            //Android Wear的支持
            embedMicroApp true  
            //是否开启混淆
            minifyEnabled  true 
            //是否开启渲染脚本
            renderscriptDebuggable false   
            //渲染脚本等级 默认是5
            renderscriptOptimLevel 5        
            //是否zip对齐优化 默认就是true
            zipAlignEnabled true   
        }
        release {......}
    }
	productFlavors{ 
        // 配置所有风味，可以覆盖defaultConfig的参数配置
        free { 
            dimension 'fee' 
            ......
        }
        vip {
            dimension 'fee'
            ......
        }
    }
	sourceSets{
        main  {
            res.srcDirs 'src/main/res' 
            jniLibs.srcDirs = ['libs'] 
            aidl.srcDirs 'src/main/aidl'
            assets.srcDirs 'src/main/assets'
            java.srcDirs 'src/main/java'
            jni.srcDirs 'src/main/jni'
            renderscript.srcDirs 'src/main/renderscript' 
            resources.srcDirs 'src/main/resources'
            manifest.srcFile 'src/main/AndroidManifest.xml'
        }
 
        free  {   //除了main,也可以给不同的风味指定不同的配置
 
        }

    }
	signingConfigs{ 
        //签名文件的路径
        storeFile file('debug.keystore')
        //签名文件密码
        storePassword 'android'
        //别名
        keyAlias 'androiddebygkey'
        //key的密码
        keyPassword 'android'
    }
	compileOptions{
        //java源文件的编码格式 默认UTF-8
        encoding 'UTF-8'  
        //java编译是否使用gradle新的增量模式 
        incremental true    
        //java源文件编译的jdk版本 
        sourceCompatibility JavaVersion.VERSION_1_7    
        //编译出的class的版本
        targetCompatibility JavaVersion.VERSION_1_7   
    }
	lintOptions{ 
        // 设置为 true时lint将不报告分析的进度
        quiet true 
        // 如果为 true，则当lint发现错误时停止 gradle构建
        abortOnError false    
        // 如果为 true，则只报告错误
        ignoreWarnings true   
        // 如果为 true，则当有错误时会显示文件的全路径或绝对路径 
        absolutePaths true   
        // 如果为 true，则检查所有的问题，包括默认不检查问题
        checkAllWarnings true  
        // 如果为 true，则将所有警告视为错误
        warningsAsErrors true  
        // 不检查给定的问题id
        disable 'TypographyFractions','TypographyQuotes'  
        // 检查给定的问题 id
        enable 'RtlHardcoded','RtlCompat', 'RtlEnabled'   
        // 仅检查给定的问题 id
        check 'NewApi', 'InlinedApi'    
        // 如果为true，则在错误报告的输出中不包括源代码行
        noLines true  
        // 如果为 true，则对一个错误的问题显示它所在的所有地方，而不会截短列表，等等。
        showAll true  
        // 重置 lint 配置（使用默认的严重性等设置）。
        lintConfig file("default-lint.xml")  
        // 如果为 true，生成一个问题的纯文本报告（默认为false）
        textReport true  
        // 配置写入输出结果的位置；它可以是一个文件或 “stdout”（标准输出）
        textOutput 'stdout' 
        // 如果为真，会生成一个XML报告，以给Jenkins之类的使用
        xmlReport false 
        // 用于写入报告的文件（如果不指定，默认为lint-results.xml）
        xmlOutput file("lint-report.xml")  
        // 如果为真，会生成一个HTML报告（包括问题的解释，存在此问题的源码，等等）
        htmlReport true 
        // 写入报告的路径，它是可选的（默认为构建目录下的 lint-results.html ）
        htmlOutput file("lint-report.html")  
        // 设置为 true， 将使所有release 构建都以issus的严重性级别为fatal（severity=false）的设置来运行lint，并且，如果发现了致命（fatal）的问题，将会中止构建（由上面提到的 abortOnError 控制.
        checkReleaseBuilds true   
        //设置给定问题的严重级别（severity）为fatal （这意味着他们将会在release构建的期间检查 （即使 lint 要检查的问题没有包含在代码中)
        fatal 'NewApi', 'InlineApi'  
        // 设置给定问题的严重级别为error
        error 'Wakelock', 'TextViewEdits'   
        // 设置给定问题的严重级别为warning
        warning 'ResourceAsColor'   
        // 设置给定问题的严重级别（severity）为ignore（和不检查这个问题一样）
        ignore 'TypographyQuotes'    
    }
	testOptions{ }
	aaptOptions{
        //aapt执行时的额外参数 
        additionalParameters '--rename-manifest-package',
                'cct.cn.gradle.lsn13','-S','src/main/res2','--auto-add-overlay'  
        //对png进行优化检查，buildTypes中配置也可
        cruncherEnabled true    
        //对res目录下的资源文件进行排除 把res文件夹下面的所有.jpg格式的文件打包到apk中
        ignoreAssets '*.jpg'  
        //对所有.jpg文件不进行压缩
        noCompress '.jpg'   
    }
	dexOptions{
        //dx命令附加参数
        additionalParameters '--minimal-main-dex','--set-max-idx-number=10000'  
        //执行dx时java虚拟机可用的最大内存大小
        javaMaxHeapSize '2048m'    
        //开启大模式，所有的class打到一个dex中，可以忽略65535方法数的限制，低于14版本不可运行
        jumboMode true   
        //在dex中是否保留Runtime注解 默认是true
        keepRuntimeAnnotatedClasses true 
        //默认dex中的进程数  默认是4 
        maxProcessCount 4   
        //默认的线程数
        threadCount 4  
        //对library预编译 提高编译效率 但是clean的时候比较慢  默认开启的
        preDexLibraries true  
    }
    packagingOptions{ 
        //pickFirsts做用是 当有重复文件时 打包会报错 这样配置会使用第一个匹配的文件打包进入apk
        pickFirsts = ['META-INF/LICENSE']    
        //重复文件会合并打包入apk
        merge 'META-INF/LICENSE'  
        //打包时排除匹配文件
        exclude 'META-INF/LICENSE'    
    }
    //指定自定义的adb路径，可以配置在环境变量中
    adbExecutable '/xx/yyy'
    adbOptions {
        //调用adb install命令时默认传递的参数
        installOptions '-r' '-d'  
        //执行adb命令的超时时间
        timeOutInMs 1000   
    }
    dataBinding  {
      enabled = true   //开启databinding
      version = "1.0"
      addDefaultAdapters = true
    }
    // applicationVariants是AppExtension继承自BaseExtension唯一拓展的成员变量
    // 其参数类型是DefaultDomainObjectSet，是不同buildType及Flavor的集合
    // applicationVariants最常用的是它的all方法
	applicationVariants.all { v ->
        if (v.buildType.name == 'release') {
            v.outputs.all {
                outputFileName = "app_V${v.versionName}+${v.versionCode}_${buildTime()}_${v.flavorName}.apk"
            }
        }
    }
    // flavor*buildType会构建出大量的apk，可以动态设置忽略一些产出
    variantFilter { variant ->
        def buildTypeName = variant.buildType.name
        def flavorName = variant.flavors.name
        if (flavorName.contains("360") && buildTypeName.contains("debug")) {
            // Tells Gradle to ignore each variant that satisfies the conditions above.
            setIgnore(true)
        }
    }
}
com.android.library插件

用于构建安卓依赖库（aar），大部分功能与com.android.application重合，使用方法参见上面。

  • 引用方式：
    classpath ‘com.android.tools.build:gradle:4.1.0’ # 由于不是gradle自带，所以需要在构建工具的classpath中额外引入
    apply plugin:‘com.android.library’

  • 独有属性：

android.libraryVariants.all { variant ->
    def mergedFlavor = variant.getMergedFlavor()
    // Defines the value of a build variable you can use in the manifest.
    mergedFlavor.manifestPlaceholders = [hostName:"www.example.com"]
}

3.2 开发工具选择

可以使用Android Studio或者IDEA进行开发，不同的是IDEA支持创建Gradle Plugin类型的工程，而AS完全需要手工引入相关依赖，因此需要对Gradle Plugin工程目录结构有所了解。以AS开发为例，其

创建一个Java Library Module
修改build.gradle引入groovy依赖
删除libs目录等无关目录 重命名java目录为groovy
创建groovy文件 开始编码和调试
发布插件
项目rootProject的build.gradle中引入插件 module的build.gradle中apply插件

补充说明：插件的编码语言不一定必须为groovy，也可以是kotlin、java

关键步骤截图：

名称 截图
module工程目录结构 gradle快速入门_第2张图片
build.gradle 得gradle快速入门_第3张图片也可以自定义sourceSets 等属性
插件properties文件 注意文件名规则：pluginId.properties，pluginId可以与包名不一致在这里插入图片描述

3.3 自定义插件方式

3.3.1 build.gradle编写

直接在rootProject build.gradle编写下编写自定义Plugin，然后在脚本头部引用：

// 演示一个最简单的Gradle插件
class SimpleTestExt {
    String msg
    String code
}

class SimpleTestPlugin implements Plugin<Project> {

    void apply(Project project){
        def extension = project.extensions.create('simpleTest', SimpleTestExt)
        project.task('showSimpleTest'){
            doFirst {
                println "${extension.msg} from ${extension.code}"
            }
        }
    }
}

// 在gradle脚本中引入插件
apply plugin: SimpleTestPlugin
 
simpleTest {
    msg = 'Hi，Gradle'
    code = '0'
}

3.3.2 创建插件module

如上面【使用AS开发】章节所示的方式，创建一个java module，添加groovy依赖进行开发，添加maven插件结合resource资源文件实现插件的发布和使用。这是一种方式，便于插件的传播与共享，有时我们仅希望在当前工程使用一些定制功能，此时可以使用下面buildSrc的方式。

3.3.3 创建buildSrc module

同样创建一个java module，但名称必须是buildSrc，同样修改java目录为groovy，具体流程如下：

创建一个Java Library Module 名称为buildSrc
修改build.gradle引入groovy依赖
删除libs目录等无关目录 重命名java目录为groovy
创建groovy文件 开始编码和调试
module的build.gradle中apply插件

与一般的创建插件工程的方式相比，区别是：

  1. 不需要发布插件和rootProject中引入插件，可在module中直接apply；
  2. 常规是apply plugin: pluginId，而这种方式只需apply plugin: 类名。

补充说明：buildSrc也可以创建pluginId.properties，然后通过apply plugin: pluginId方式进行导入，区别是不需要发布到仓库。其实不难发现，buildSrc的本质就是把这个module作为rootProject的构建时的依赖的源码，所以相关代码可以使用。

关键操作截图：

名称 截图
工程结构 gradle快速入门_第4张图片

3.4 插件调试

出了log日志这种被动方式，还是使用debug进行调试。开启方法为：

  • 在AndroidStudio => Edit Configurations… 中增加一个 Remote 配置：
    gradle快速入门_第5张图片
    只需要输入配置名称，其余保持默认即可
  • 在命令行以debug模式执行assemble命令
./gradlew --no-daemon -Dorg.gradle.debug=true :app:assembleRelease
  • 代码打好断点
  • 选中我们创建的configuration，然后按Debug按钮

4. 核心API

4.1 Extension

用于在gradle脚本中定义参数。

定义Extension实体：

class FileSizer {
    boolean includeCode = true
    boolean includeResource = true
    boolean enableBuildLog = false


    @Override
    String toString() {
        return "FileSizer{" +
                "includeCode=" + includeCode +
                ", includeResource=" + includeResource +
                ", enableBuildLog=" + enableBuildLog +
                '}';
    }
}

gradle中设置实体：

apply plugin: 'me.plugin.filesizer'
fileSizer {
    includeResource true
    includeCode false
    enableBuildLog false
}

插件中读取实体：

def fileSizer = project.extensions.create('fileSizer', FileSizer)

4.2 Task

构建Task

在org.gradle.api.Project中定义了task方法，返回一个Task对象。共有5个方法的重载，如下图所示：
gradle快速入门_第6张图片

最复杂的是入参含有Map参数的重构方法（术语为：map-style notation），Map参数包括：

Option Description Default Value
“name” The name of the task to create. None. Must be specified.
“type” The class of the task to create. DefaultTask
“action” The closure or Action to execute when the task executes. See Task.doFirst(Action). null
“overwrite” Replace an existing task? false
“dependsOn” The dependencies of the task. See here for more details. []
“group” The group of the task. null
“description” The description of the task. null
“constructorArgs” The arguments to pass to the task class constructor. null
简单构建示例

从上可知，task支持如下形式进行创建：

  • 调用task方法创建Task
// 只传一个name参数
task myTask
task(name: myTask)  //调用map重载方法

// name + closure
task myTask { /* logic */}

// name+action
task(name: myTask, action: new Action<Task>() {
  @Override
  void execute(Task task) {
    /* logic */
  }
})
task myTask {
 doFirst {
 	/* logic */
 }
}

task myTask << { /* logic */ }

操作符 << 在Gradle 4.x中被弃用（deprecated），并且在Gradle 5.0 被移除（removed），使用会报：Could not find method leftShift() for arguments .

  • 简单的自定义Task类
/**
 * 第一步：自定义类继承DefaultTask，用@TaskAction标记task任务实体
 */
class MyTask extends DefaultTask {
    String msg='hello from myTask'
    List<String> list = new ArrayList<>()
    /** 
    方法名可以随意取，重点是执行入口需要用@TaskAction进行注解
    TaskAction在doFirst之后，doLast之前执行
     */
    @TaskAction
    def doWork(){
        println msg
        list.forEach{ e-> println e}
    }

    def add(String... args){
        list.addAll(args)
    }
}

/**
 * 第二步：向gradle注册我们自定义的task，这样我们可以从AS的gradle面板中看到这个task
 */
task callMyTask(type: MyTask){
    group 'test'
    msg = 'hello task'  //重写了msg属性
    add 'a','b','c'     //调用了add方法
}
Task依赖

Task的一个不可忽视的属性就是其依赖关系，是一种有向无环图接口。通过上面构造参数中的dependsOn指定所需依赖的任务：

task A << {println 'Hello from A'}
task B << {println 'Hello from B'}
task C << {println 'Hello from C'}
B.dependsOn A
C.dependsOn B

我们可以通过下面的方式查看指定task的依赖：

afterEvaluate {
    project.tasks.findByName('assembleDebug').taskDependencies.getDependencies().each {
        println "dependOn: ${it.name}"
        it.taskDependencies.getDependencies().each {
            println "        : ${it.name}"
        }
    }
}

前面提到了使用task.doFirst{...}来hook目标任务，这里又多了一种方式，即：taskA.dependsOn taskB

增量构建

在Gradle中，每一个task都有inputs和outputs，如果在执行一个Task时，如果它的输入和输出与前一次执行时没有发生变化，那么Gradle便会认为该Task是最新的，因此Gradle将不予执行而是在控制台打印[UP-TO-DATE]，这就是增量构建的概念。

一个task的inputs和outputs可以是一个或多个文件，可以是文件夹，还可以是project的某个property，甚至可以是某个闭包所定义的条件。自定义task默认每次执行，但通过指定inputs和outputs，可以达到增量构建的效果。

示例：查看dependencies任务的输入输出

def dp = tasks.findByName("dependencies")
println "dp.inputs = ${dp.inputs}"
println "dp.outputs = ${dp.outputs}"

打印结果：

> Configure project :app
dp.inputs = org.gradle.api.internal.tasks.DefaultTaskInputs@2d417d27
dp.outputs = org.gradle.api.internal.tasks.DefaultTaskOutputs@6cddd0c3

可以使用附加参数-- rerun-taks来强制执行task，忽略增量编译

常用Task

JavaCompile
Copy
// 创建一个独立的task
task copyTask(type: Copy) {
    from 'src/main/resources'   //必填，原型：CopySpec.from(java.lang.Object[])
    into 'build/config'   		//必填，原型：CopySpec.into(java.lang.Object)
    include '**/*.html'    		//可选，仅拷贝符合规则的文件
    include '**/*.jsp'			//可选
    exclude { details -> 		//可选，剔除符合规则的文件
    	details.file.name.endsWith('.html') &&
        details.file.text.contains('staging') 
    }
}
// 更常用的做法是直接调用Project.copy(org.gradle.api.Action)函数去复制文件
copy {
	from 'src/main/resources'
    into 'build/config'
    rename { String oldName->  //配合重命名函数使用
		return "newName"
	}
	// 使用正则表达示来映射文件名
    rename '(.+)-staging-(.+)', '$1$2'
    rename(/(.+)-staging-(.+)/, '$1$2')
}
// 嵌套形式的拷贝
task nestedSpecs(type: Copy) {
    into 'build/explodedWar'
    exclude '**/*staging*'
    from('src/dist') {
    	eachFile {
            println(it)
        }
        include '**/*.html'
    }
    // 将运行时的依赖库拷贝到libs目录下
    into('libs') {
        from configurations.runtime
    }
}

from()方法接受的参数和文件集合时files()一样：

  1. 当参数为一个目录时，该目录下所有的文件都会被拷贝到指定目录下（目录自身不会被拷贝），如：from 'src/main/webapp'；
  2. 当参数为一个文件时，该文件会被拷贝到指定目录，如：from 'src/staging/index.html'；
  3. 如果参数指定的文件不存在，就会被忽略；
  4. 当参数为一个 Zip 压缩文件，该压缩文件的内容会被拷贝到指定目录，如from zipTree('src/main/assets.zip')。
Sync

同步拷贝：在拷贝的时候，把原文件拷贝到目标目录时，会把目标目录下之前的全部清除，这种方式很适合项目的依赖库拷贝

task libs(type: Sync) {
    from configurations.runtime
    // 拷贝之前会把$buildDir/libs目录下所有的清除
    into "$buildDir/libs"
}
Delete
// 删除文件夹
task myClean(type: Delete) {
    delete buildDir
}
// 删除符合规则的文件
task cleanTempFiles(type: Delete) {
    delete fileTree("src").matching {
        include "**/*.tmp"
    }
}
Zip
apply plugin: 'java'

task zip(type: Zip) {
    from 'src/dist'
    // 方式一：通过into指定文件目录
    into('libs') {
        from configurations.runtime
    }
    // 方式二：通过指定文件目录和文件名指定
    baseName = 'myGame'  // 设置文件名称，效果：myGame-1.0.zip
    archiveName = "my-distribution.zip"  // 完整文件名
    destinationDir = file("${buildDir}/dist") // 文件目录
}

解压缩用的是Copy：

task unpackFiles(type: Copy) {
    from zipTree("${buildDir}/dist/my-distribution.zip")
    into "${buildDir}/resources"
}
Jar/Tar/War/Ear
plugins {
    id 'java'
}
tasks.jar{
    manifest {
        attributes( "Main-Class": "gradle.test.App")
    }
}

不借助插件：

task buildJar {
    mkdir("jar")
    copy {
        from(layout.buildDirectory.dir("classes/java/main"))
        into("./jar")
    }
    Files.write(Paths.get(layout.projectDirectory.file("jar/MANIFEST.MF").asFile.absolutePath),"Main-Class: gradle.test.App\r".getBytes())
    copy {
        from(layout.projectDirectory.file("MANIFEST.MF"))
        into(layout.projectDirectory.file("app/jar"))
    }
    this.exec {
        workingDir("./jar")
        executable("jar")
        args("-cvfe" ,"test.jar", "gradle.test.App" ,"./")
    }
}
Exec
task taskCompressPngs(type: Exec) {
    def compressPngs = 1
    // 不同task传入不同的入参
    if("task_2" in gradle.startParameter.taskNames){
    	compressPngs = 0
    }
    // 命令主体
    commandLine "myshell.sh $compressPngs".tokenize()
    // 命令参数
    // args compressPngs
}

自定义Task示例

class FileSizerTask extends DefaultTask {
    private Set<File> paths
    private final List<RecordItem> codeRecordItems = new ArrayList<>()
    private final List<RecordItem> resRecordItems = new ArrayList<>()
    private final isWindows = org.gradle.internal.os.OperatingSystem.current().isWindows()

    void addPaths(Set<File> paths) {
        this.paths = paths
    }

    @TaskAction
    def start() {
        codeRecordItems.clear()
        resRecordItems.clear()

        if (paths != null && !paths.isEmpty()) {
            paths.forEach { f ->
                calcFileSizeInDir(f)
            }
        }

        printResult()
    }

    void printResult() {
        File dstFile = new File("${project.buildDir.path}/${FileSizerPlugin.GROUP}/filesizer.json")
        if (!dstFile.exists()) {
            if (!dstFile.parentFile.exists()) {
                dstFile.parentFile.mkdirs()
            }
            dstFile.createNewFile()
        }
        JsonObject json = new JsonObject()
        if (!codeRecordItems.isEmpty()) {
            def array = new JsonArray()
            for (RecordItem item : codeRecordItems) {
                array.add(item.toJson())
            }
            json.add("codeRecordItems", array)
        }
        if (!resRecordItems.isEmpty()) {
            def array = new JsonArray()
            for (RecordItem item : resRecordItems) {
                array.add(item.toJson())
            }
            json.add("resRecordItems", array)
        }


        BufferedWriter writer = null
        try {
            writer = new BufferedWriter(new FileWriter(dstFile))
            writer.write(json.toString())
        } catch (IOException e) {
            e.printStackTrace()
        } finally {
            if (writer != null)
                writer.close()
        }
    }

    void calcFileSizeInDir(File dir) {
        def files = dir.listFiles()
        for (File file : files) {
            if (file.isFile()) {
                if (isResource(file)) {
                    resRecordItems.add(new RecordItem(file.length(), file.path))
                } else {
                    codeRecordItems.add(new RecordItem(file.length(), file.path))
                }
            } else {
                calcFileSizeInDir(file)
            }
        }
    }

    boolean isResource(File file) {
        return isWindows?file.path.contains('main\\res'):file.path.contains('main/res')
    }

}

插件中注册task：

project.afterEvaluate {
    project.task("fileSizer", type: FileSizerTask) {
                group GROUP
                description 'statistic files size including resource and code.'
                project.logger.println fileSizer
                addPaths resolveFilePaths(project, fileSizer)
            }
            if (fileSizer.enableBuildLog){
                BuildCycleListener listener = new BuildCycleListener()
                project.gradle.addListener(listener)
            }

}

4.3 Variant

android gradle plugin V3.x 之后，每个 flavor 必须对应一个 dimension。Variants 共有三种类型：

  1. applicationVariants：只适用于 app plugin；
  2. libraryVariants：只适用于 library plugin；
  3. testVariants：在 app plugin 与 libarary plugin 中都适用；

这三种变量的公有属性【参考资料】：

属性名 属性类型 说明
name String Variant的名字，必须是唯一的。
description String Variant的描述说明。
dirName String Variant的子文件夹名，必须也是唯一的。可能也会有不止一个子文件夹，例如“debug/flavor1”
baseName String Variant输出的基础名字，必须唯一。
outputFile File Variant的输出，这是一个可读可写的属性。
processManifest ProcessManifest 处理Manifest的task。 vaidlCompile AidlCompile 编译AIDL文件的task。
renderscriptCompile RenderscriptCompile 编译Renderscript文件的task。
mergeResources MergeResources 混合资源文件的task。
mergeAssets MergeAssets 混合asset的task。
processResources ProcessAndroidResources 处理并编译资源文件的task。
generateBuildConfig GenerateBuildConfig 生成BuildConfig类的task。
javaCompile JavaCompile 编译Java源代码的task。
processJavaResources Copy 处理Java资源的task。
assemble DefaultTask Variant的标志性assemble task。

ApplicationVariant类还有以下附加属性：

属性名 属性类型 说明
buildType BuildType Variant的BuildType。
productFlavors List Variant的ProductFlavor。一般不为空但也允许空值。
mergedFlavor ProductFlavor android.defaultConfig和variant.productFlavors的合并。
signingConfig SigningConfig Variant使用的SigningConfig对象。
isSigningReady boolean 如果是true则表明这个Variant已经具备了所有需要签名的信息。
testVariant BuildVariant 将会测试这个Variant的TestVariant。
dex Dex 将代码打包成dex的task。如果这个Variant是个库，这个值可以为空。
packageApplication PackageApplication 打包最终APK的task。如果这个Variant是个库，这个值可以为空。
zipAlign ZipAlign zip压缩APK的task。如果这个Variant是个库或者APK不能被签名，这个值可以为空。
install DefaultTask 负责安装的task，不能为空。
uninstall DefaultTask 负责卸载的task。

LibraryVariant类还有以下附加属性：

属性名 属性类型 说明
buildType BuildType Variant的BuildType.
mergedFlavor ProductFlavor The defaultConfig values
testVariant BuildVariant 用于测试这个Variant。
packageLibrary Zip 用于打包库项目的AAR文件。如果是个库项目，这个值不能为空。

TestVariant类还有以下属性：

属性名 属性类型 说明
buildType BuildType Variant的Build Type。
productFlavors List Variant的ProductFlavor。一般不为空但也允许空值。
mergedFlavor ProductFlavor android.defaultConfig和variant.productFlavors的合并。
signingConfig SigningConfig Variant使用的SigningConfig对象。
isSigningReady boolean 如果是true则表明这个Variant已经具备了所有需要签名的信息。
testedVariant BaseVariant TestVariant测试的BaseVariant
dex Dex 将代码打包成dex的task。如果这个Variant是个库，这个值可以为空。
packageApplication PackageApplication 打包最终APK的task。如果这个Variant是个库，这个值可以为空。
zipAlign ZipAlign zip压缩APK的task。如果这个Variant是个库或者APK不能被签名，这个值可以为空。
install DefaultTask 负责安装的task，不能为空。
uninstall DefaultTask 负责卸载的task。
connectedAndroidTest DefaultTask 在连接设备上行执行Android测试的task。
providerAndroidTest DefaultTask 使用扩展API执行Android测试的task。

productFlavors

示例：让“demo”版应用仅支持 API 级别 23 及更高级别，使用 variantFilter 代码块过滤掉所有将“minApi21”和“demo”产品变种组合在一起的构建变体配置：

android {
  ...
  buildTypes {...}

  flavorDimensions "api", "mode"
  productFlavors {
    demo {
    	dimension "mode"
        matchingFallbacks = ["debug", "release"]
	}
    full {...}
    minApi24 {...}
    minApi23 {...}
    minApi21 {...}
  }

  variantFilter { variant ->
      def names = variant.flavors*.name
      // To check for a certain build type, use variant.buildType.name == ""
      if (names.contains("minApi21") && names.contains("demo")) {
          // Gradle ignores any variants that satisfy the conditions above.
          setIgnore(true)
      }
  }
}
...

Variant常见用法：

this.afterEvaluate {
	// 评估完成后可以获取到所有的变体
	// 当然这里applicationVariants也可以是上述的另外两种
    this.android.applicationVariants.all { variant ->
    	def name = variant.name  //比如：douyinDebug
    	def baseName = variant.baseName  //对应：douyin-debug
        variant.outputs.each {
            // 由于我们当前的变体是 application 类型的，所以
            // 这个 output 就是我们 APK 文件的输出路径，我们
            // 可以通过重命名这个文件来修改我们最终输出的 APK 文件
            outputFileName = "app-${variant.baseName}-${variant.versionName}.apk"
            println outputFileName
        }
        // 获取变体的task，taskName支持拼接，所以非常灵活
        def task = variant.checkManifest
        println task.name
        checkTask.doFirst {
        	// hook目标task，做一些特殊操作
            def bt = variant.buildType.name
            if (bt == 'qa' || bt == 'preview'
                    || bt == 'release') {
                update_plugin(bt)
            }
        }

    }
}

4.4 Transform

Transform是Android Gradle V1.5.0 版本以后提供的API，此类用于在class文件被转化为dex文件之前去修改字节码以实现插桩需求。Transform最终会在AGP中被转化成对应的TransformTask，被TaskManager管理。

自定义Transform需要依赖implementation 'com.android.tools.build:gradle:1.5.0+'。

注册Transform：

/* registerTransform必须在评估完成前进行注册，afterEvaluate阶段注册是无效的 */

// 方式一：
// def android = project.extensions.findByType(AppExtension);
// android.registerTransform(new TransformerTransform(project))

// 方式二：也可以简写如下，但是就没有代码提示了
project.android.registerTransform(new TransformerTransform(project))

Transform的5个重写方法：

  1. 重写 getName 方法：返回对应的 Task 名称。
  2. 重写 getInputTypes 方法：确定对那些类型的结果进行转换。
  3. 重写 getScopes 方法：指定插件的适用范围。
  4. 重写 isIncremental 方法：表示是否支持增量更新。
  5. 重写 transform 方法：进行具体的转换过程。

重点是transform方法 ，在这个方法中去修改class文件注入我们的逻辑，通常有两种方式：Javassist和ASM，其中Javassist更接近java编码习惯，因此比较容易入门，ASM则比较复杂。

  • 查看更多接口信息：transform-api
  • 相关资料：深入理解Transform

4.5 File

构建过程中处理代码另一个重要的操作对象就是文件了，参考Working With Files学习如何使用gradle task体系复制、创建、移动、删除文件（夹），以及压缩/解压文件、构建jar包等。

相关接口

  • file
  • mkdir

文件遍历：

// 浅层遍历
file("/home/HouXinLin/test/").listFiles().each{
    println(it)
}

// 深层遍历
Files.walkFileTree(Paths.get("/home/HouXinLin/test/"),new SimpleFileVisitor<java.nio.file.Path>(){
    @Override
    FileVisitResult visitFile(java.nio.file.Path file, BasicFileAttributes attrs) throws IOException {
        println(file)
        return super.visitFile(file, attrs)
    }
})

FileCollection

FileCollection collection = project.files(
		'src/test1.txt',
        new File('src/test2.txt'),
        ['src/test3.txt', 'src/test4.txt'])
// 遍历所有集合
collection.each { File file ->
    println file.name
}

// 把文件集合转换为Set类型
Set set1 = collection.files
Set set2 = collection as Set
// 把文件集合转换为List类型
List list = collection as List
// 把文件集合转换为String类型
String path = collection.asPath
// 把文件集合转换为File类型
File file1 = collection.singleFile
File file2 = collection as File

// 添加或者删除一个集合
def union = collection + files('src/test5.txt')
def different = collection - files('src/test3.txt')

注意：文件集合中的文件对象都是延迟操作的，也就是说你可以创建一个 FileCollection 对象，它所包含的所有文件都是在未来被其它任务调用时才会真正的创建。

FileTree

创建文件树：

// 指定目录创建文件树对象
FileTree tree = fileTree(dir: 'src/main')

// 给文件树对象添加包含指定文件
tree.include '**/*.java'
// 给文件树对象添加排除指定文件
tree.exclude '**/Abstract*'

// 使用路径创建文件树对象，同时指定包含的文件
tree = fileTree('src').include('**/*.java')

// 通过闭包创建文件树
tree = fileTree('src') {
    include '**/*.java'
}

// 通过map创建文件树
tree = fileTree(dir: 'src', include: '**/*.java')
tree = fileTree(dir: 'src', includes: ['**/*.java', '**/*.xml'])
tree = fileTree(dir: 'src', include: '**/*.java', exclude: '**/*test*/**')

操作文件树：

// 遍历文件树的所有文件
tree.each {File file ->
    println file
}

// 过虑生成新的文件树对象
FileTree filtered = tree.matching {
    include 'org/gradle/api/**'
}

// 使用“+”号合并两个文件树，同文件集合的“+”操作一样
FileTree sum = tree + fileTree(dir: 'src/test')

// 访问文件树中各项内容
tree.visit {element ->
    println "$element.relativePath => $element.file"
}

IO

def file = file('./test.txt')
def string = file.text  //读取全文
def input = file.newDataInputStream()
def output = file.newDataOutputStream()
output << input  //IO读写语法糖
input.close()
output.close()

XML

Groovy Xml 操作

5. 字节码编辑工具

5.1 Javassist

gradle依赖：

implementation 'org.javassist:javassist:3.28.0-GA'

使用教程和示例参见：https://github.com/jboss-javassist/javassist

5.2 ASM

gradle依赖：

implementation "org.ow2.asm:asm:6.0"
implementation "org.ow2.asm:asm-util:6.0"
implementation "org.ow2.asm:asm-commons:6.0"

使用教程和示例参见：https://asm.ow2.io/。 由于classpath中引入了classpath 'com.android.tools.build:gradle:version'，而gradle依赖gradle-core，gradle-core依赖lint，lint依赖lint-checks，lint-checks最后依赖到了asm，所以如果其他build.gradle中要引用asm相关的类，不用设置classpath，直接import就可以了。但是其他other.gradle不享有这种传递性，需要自己配置buildscript：

buildscript {
    repositories {
       jcenter()
    }
    dependencies {
        classpath 'com.android.tools.build:gradle:$version$'
    }
}
  1. ASM的语法虽然比较难以读懂，但是仍然有一些技巧，比如可以先用Java写出你想要实现的插桩后的代码，然后使用Asm bytecode viewer、ASM Bytecode Outline等插件查看其对应的ASM字节码，然后对照着最终结果反过去写实现过程。然后在build\intermedates\transforms\yourTransform去找到修改后的class文件，使用jd-gui.jar等工具查看生成的代码是否正确。
  2. 目前的这些AS插件都是支持Java转ASM bytecode，而不支持kotlin转ASM bytecode，因此如果想要对kotlin进行插桩，可以先将kotlin编译成class，然后使用asm-all.jar工具将class转为ASM bytecode。

5.3 AspectJ

aspectJ同样可以在JavaCompile结束后对生成的字节码二次编辑修改从而实现AOP。

6. 参考资料

  • Groovy官方文档
  • Gradle从入门到实战 - Groovy基础
  • Android Plugin DSL Reference
  • Gradle Android插件用户指南翻译
  • 深入理解Android之Gradle
  • ASOP Gradle 源码
  • 写给 Android 开发者的 Gradle 系列
  • 深度探索 Gradle 自动化构建技术
  • Android Gradle 插件版本说明
  • Android Gradle Plugin源码解析

7. 相关开源项目

  • Mess 四大组件及view混淆
  • ThinRPlugin R文件瘦身
  • tinker-patch-gradle-plugin热修复
  • butterknife-gradle-plugin 控件绑定
  • gradle-small-plugin 轻量级插件化
  • 本文示例项目

你可能感兴趣的:(android,Gradle,android,gradle)

  • android系统selinux中添加新属性property 辉色投像
    1.定位/android/system/sepolicy/private/property_contexts声明属性开头：persist.charge声明属性类型：u:object_r:system_prop:s0图12.定位到android/system/sepolicy/public/domain.te删除neverallow{domain-init}default_prop:property
  • 2.2.6 通知类控件 Toast、Menu 常思行
    本文例程下载：WillFlow_Toast、WillFlowMenu一、什么是Toast？Toast也被叫做吐司，是Android系统提供的一种非常好的提醒方式，在程序中可以使用它将一些短小的信息通知给用户，它有如下两个特点：Toast是没有焦点的Toast显示的时间有限过一定的时间就会自动消失所以一般来讲Toast的使用并不会影响我们的正常操作，并且它通常不会占用太大的屏幕空间，有着良好的用户体
  • mac 备份android 手机通讯录导入iphone,iphone如何导出通讯录（轻松教你iPhone备份通讯录的方法）... weixin_39762838 mac备份android手机通讯录导入iphone
    在日新月异的手机更替中，换手机已经成为一个非常稀松平常的事情，但将旧手机上面的通讯录导入到新手机还是让不少小伙伴为难，本篇将给大家详细讲解这方面的知识：“苹果手机通讯录怎么导入到新手机”及“安卓手机通讯录导入到新手机”的方法。一、苹果手机通讯录导入到新手机常用方法(SIM卡导入)在苹果手机主频幕上找到“设置”，单击进入设置菜单，下拉菜单列表，点击“邮件、通讯录、日历”，然后找到“导入SIM卡通讯录
  • android 更改窗口的层次,浮窗开发之窗口层级 Ms.Bu android更改窗口的层次
    最近在项目中遇到了这样的需求：需要在特定的其他应用之上悬浮自己的UI交互(拖动、输入等复杂的UI交互)，和九游的浮窗类似，不过我们的比九游的体验更好，我们越过了很多授权的限制。浮窗效果很多人都知道如何去实现一个简单的浮窗，但是却很少有人去深入的研究背后的流程机制，由于项目中浮窗交互比较复杂，遇到了些坑查看了很多资料，故总结浮窗涉及到的知识点：窗口层级关系(浮窗是如何“浮”的)？浮窗有哪些限制，如何
  • Android应用性能优化 轻口味 Android
    Android手机由于其本身的后台机制和硬件特点，性能上一直被诟病，所以软件开发者对软件本身的性能优化就显得尤为重要；本文将对Android开发过程中性能优化的各个方面做一个回顾与总结。Cache优化ListView缓存：ListView中有一个回收器，Item滑出界面的时候View会回收到这里，需要显示新的Item的时候，就尽量重用回收器里面的View；每次在getView函数中inflate新
  • Android实现监听事件的方法 Amy木婉清
    1.通过内部类实现2.通过匿名内部类实现3.通过事件源所在类实现4.通过外部类实现5.布局文件中onclick属性(针对点击事件)1.通过内部类实现代码:privateButtonmBtnEvent;//oncreate中mBtnEvent.setOnClickListener(newOnClick());//内部类实现监听classOnClickimplementsView.OnClickLis
  • 高级UI<第二十四篇>：Android中用到的矩阵常识 NoBugException
    （1）定义在数学中，矩阵（Matrix）是一个按照长方阵列排列的复数或实数集合。由m×n个数aij排成的m行n列的数表称为m行n列的矩阵，简称m×n矩阵。记作：图片.png这m×n个数称为矩阵A的元素，简称为元，数aij位于矩阵A的第i行第j列，称为矩阵A的(i,j)元，以数aij为(i,j)元的矩阵可记为(aij)或(aij)m×n，m×n矩阵A也记作Amn。元素是实数的矩阵称为实矩阵，元素是复
  • RK3229_Android9.0_Box 4G模块EC200A调试 suifen_ 网络
    0、kernel修改这部分完全可以参考Linux的移植：RK3588EC200A-CN【4G模块】调试_rkec200a-cn-CSDN博客1、修改device/rockchip/rk322xdiff--gita/device.mkb/device.mkindexec6bfaa..e7c32d1100755---a/device.mk+++b/device.mk@@-105,6+105,8@@en
  • kt文件和java文件_Java与Kotlin之间怎样进行互操作 铭空间 kt文件和java文件
    Java与Kotlin之间怎样进行互操作发布时间：2021-02-0210:50:43来源：亿速云阅读：98作者：小新这篇文章主要介绍了Java与Kotlin之间怎样进行互操作，具有一定借鉴价值，感兴趣的朋友可以参考下，希望大家阅读完这篇文章之后大有收获，下面让小编带着大家一起了解一下。前言目前kotlin是谷歌首推的开发Android的语言，但由于历史原因，我们绝大部分项目依旧还是以Java为主
  • Android shell 常用 debug 命令 晨春计 Audiodebugandroidlinux
    目录1、查看版本2、am命令3、pm命令4、dumpsys命令5、sed命令6、log定位查看APK进程号7、log定位使用场景1、查看版本1.1、Android串口终端执行getpropro.build.version.release#获取Android版本uname-a#查看linux内核版本信息uname-r#单独查看内核版本1.2、linux服务器执行lsb_release-a#查看Lin
  • 2024年最全Flutter如何和Native通信-Android视角，Electron开发Android界面 2401_84544531 程序员android面试学习
    总结【Android详细知识点思维脑图（技能树）】其实Android开发的知识点就那么多，面试问来问去还是那么点东西。所以面试没有其他的诀窍，只看你对这些知识点准备的充分程度。so，出去面试时先看看自己复习到了哪个阶段就好。虽然Android没有前几年火热了，已经过去了会四大组件就能找到高薪职位的时代了。这只能说明Android中级以下的岗位饱和了，现在高级工程师还是比较缺少的，很多高级职位给的薪
  • 分享一个基于python的电子书数据采集与可视化分析 hadoop电子书数据分析与推荐系统 spark大数据毕设项目（源码、调试、LW、开题、PPT) 计算机源码社 Python项目大数据大数据pythonhadoop计算机毕业设计选题计算机毕业设计源码数据分析spark毕设
    作者：计算机源码社个人简介：本人八年开发经验，擅长Java、Python、PHP、.NET、Node.js、Android、微信小程序、爬虫、大数据、机器学习等，大家有这一块的问题可以一起交流！学习资料、程序开发、技术解答、文档报告如需要源码，可以扫取文章下方二维码联系咨询Java项目微信小程序项目Android项目Python项目PHP项目ASP.NET项目Node.js项目选题推荐项目实战|p
  • android ndk 开发jni调用对象方法，数组参数 wulongkou 开发问题安卓的事ndkandroidstudiojni
    一、JNI和NDK关系JNI是Java语言提供的Java和C/C++相互沟通的机制，Java可以通过JNI调用本地的C/C++代码，本地的C/C++的代码也可以调用java代码。JNI是本地编程接口，Java和C/C++互相通过的接口。Java通过C/C++使用本地的代码的一个关键性原因在于C/C++代码的高效性。NDK是一系列工具的集合。它提供了一系列的工具，帮助开发者快速开发C（或C++）的动
  • Android jni中数组参数的传递方式 lokeyme Andriodandroid开发JNINDKjavac语言
    1、背景今天调试了一下Androidjni关于Java中调用C代码的程序，发现我的数组参数传递方式不对，导致值传递不正确，我的方法是：C代码，入口函数#include#includejintJava_sony_MedicalRecordDemo_MainActivity_decryptionSuccess(JNIEnv*env,jobjectthiz,jintAttr[]){returnAttr[
  • 1-1.Jetpack 之 Navigation 简单编码模板 我命由我12345 Android-Jetpack简化编程javajava-eeandroid-studioandroidstudio安卓androidjetpack
    一、Navigation1、Navigation概述Navigation是Jetpack中的一个重要成员，它主要是结合导航图（NavigationGraph）来控制和简化Fragment之间的导航，即往哪里走，该怎么走2、Navigate引入在模块级build.gradle中引入相关依赖implementation'androidx.navigation:navigation-fragment:2
  • Android JetPack架构——结合记事本Demo一篇打通对Sqlite的增删改查结合常用jetpack架构应用 erhtre 程序员androidjetpack架构sqlite
    为什么要用Jetpack?========================================================================关于为什么要用Jetpack，我参考了许多的博客和官方文档，开阔了我对Android生态圈的理解和认识，在Jetpack推出前出现的许许多多强大的第三方框架与语言，典型代表无疑是强大的RxJava在Jetpack仍然有许多粉丝在一
  • Android干净架构MVI模板使用指南 井美婵Toby
    Android干净架构MVI模板使用指南android-clean-architecture-mvi-boilerplateAforkofourcleanarchitectureboilerplateusingtheModel-View-Intentpattern项目地址:https://gitcode.com/gh_mirrors/an/android-clean-architecture-mv
  • ⭐Unity 安卓环境中正确地读取和处理 XML 文件 惊鸿醉 Unityunityandroidxml
    写了一个选择题Demo，电脑包和编辑器内无问题，但是打包安卓手机之后题目无法正常使用，想到的是安卓环境中正确地读取文件的问题改进方案：1.由于XmlDocument.Load方法在Android上的路径问题（由于文件位于APK内部，无法像在文件系统中那样直接访问），需要先使用UnityWebRequest来异步加载文件内容，然后再解析XML。2.异步处理：修改你的代码，以支持异步文件加载和处理，这
  • 《Android进阶之光》读书笔记 soleil雪寂 读书笔记#Android进阶之光
    文章目录第1章Android新特性1.1.Android5.0新特性1.2.RecyclerView1.1.4.3种Notification1.1.5.Toolbar与Palette1.1.6.Palette1.2.Android6.0新特性1.2.2.运行时权限机制1.3.Android7.0新特性第2章MaterialDesign2.2.DesignSupportLibrary常用控件详解第3
  • 《Android进阶之光》— Android 书籍 王睿丶 Android永无止境《Android进阶之光》Android书籍Androidphoenix移动开发
    文章目录第1章Android新特性1第2章MaterialDesign48第3章View体系与自定义View87第4章多线程编程165第5章网络编程与网络框架204第6章设计模式271第7章事件总线308第8章函数响应式编程333第9章注解与依赖注入框架382第10章应用架构设计422第11章系统架构与MediaPlayer框架460出版年:2017-7简介：《Android进阶之光》是一本And
  • 《android进阶之光》——多线程编程（上） TAING要一直努力 读书笔记
    今天了解了下多线程编程，知识点如下：进程与线程：进程是什么？线程是什么？进程可以看作是程序的实体，是线程的容器，是受操作系统管理的基本运行单元，例如exe文件就是一个进程。线程是进程运行的一些子任务，是操作系统调度的最小单元，各线程拥有自己的计数器，堆栈，局部变量等，也可以访问线程间共享的内存。线程的状态有哪些？新创建，可运行，等待，超时等待，阻塞，终止怎么创建一个线程？-三种方法第一种，MyTr
  • android进阶之光！Android面试必备的集合源码详解，系列篇 程序员Sunbu 程序员Android
    前言面试：如果不准备充分的面试，完全是浪费时间，更是对自己的不负责。文末会给大家分享下我整理的Android面试专题及答案其中大部分都是大企业面试常问的面试题，可以对照这查漏补缺，当然了，这里所列的肯定不可能覆盖全部方式，不过对大家找工作肯定是有帮助！本月飞机到达上海，到今天第6天了，四家大公司华为，小米，映客，抖音，还有二家中小型公司。有几家已经面了几轮，下周还要面，挂了几家，不过目前已经选择了
  • Android-悬浮窗功能的实现（附Java、KT实现源码）(1) egrhef 程序员androidjava开发语言
    //获取服务的操作对象valbinder=serviceasFloatWinfowServices.MyBinderbinder.service}overridefunonServiceDisconnected(name:ComponentName){}}overridefunonActivityResult(requestCode:Int,resultCode:Int,data:Intent){
  • Visual Studio中的Android模拟器使用详解 wurui8 androidandroidstudioandroidandroid应用
    关注微信号：javalearns随时随地学Java或扫一扫随时随地学JavaMicrosoft本周发布了VisualStudio2015预览版,里面包含Android开发工具.安装的时候,如果选Android开发,VisualStudio会把调试Android应用程序用的VisualStudio模拟器也装上.在介绍这个新模拟器之前,我们先来聊一聊,为什么需要一个新的Android模拟器–当然,你也
  • Unity 热更 之 【HybirdCLR】+【YooAsset】 [安卓 Android端] [代码 + 资源热更] 功能的 简单实现演示 仙魁XAN Unity进阶unityHybirdCLRYooAssetHotUpdate热更新
    Unity热更之【HybirdCLR】+【YooAsset】[安卓Android端][代码+资源热更]功能的简单实现演示目录Unity热更之【HybirdCLR】+【YooAsset】[安卓Android端][代码+资源热更]功能的简单实现演示一、简单介绍二、HybridCLR三、YooAsset四、HybirdCLR引入工程五、YooAsset引入工程六、Python服务器简单构建七、Hybir
  • Android 用线程池实现一个简单的任务队列(Kotlin) 深海呐 Android#Android进阶#Kotlinandroidkotlin线程池延时任务队列线程池延时任务
    关于线程池,Kotlin和java的使用方式一样在Android中,很多人喜欢用Handler的postDelayed()去实现延时任务.要使用postDelayed(),去实现延时任务队列,就不可避免要使用递归.但是这样做,代码的简洁性,和书写的简易,就远不如使用线程池.使用线程池的简单程度:privatevalmThreadPool=Executors.newSingleThreadSched
  • （小白入门）Windows环境下搭建React Native Android开发环境 码农老黑 前端ReactNative移动开发Androidstudio
    ReactNative(简称RN)是Facebook于2015年4月开源的跨平台移动应用开发框架，是Facebook早先开源的UI框架React在原生移动应用平台的衍生产物，目前支持iOS和Android两大平台。RN的环境搭建在RN的中文社区有所介绍，但是对于小白来说还是有些太过简略了。RN中文社区详见参考，本文不涉及的问题也许在其中能够有所解答。ReactNative思想底层引擎是JavaSc
  • Android Dialog圆角设置无效的问题 ly969434341 android
    一，参考AndroidDialog圆角设置无效的问题https://blog.csdn.net/woshi_awei/article/details/99664527Android自定义Dialog实现通用圆角对话框https://cloud.tencent.com/developer/article/1740956二，原因Diallog的默认背景是白色（直角背景），我自定义的Dialog背景也是
  • MultiSnapRecyclerView：让Android RecyclerView的滚动停靠更灵活 技术无疆 Androidandroiduiandroidstudioandroid-studiojavaandroidx
    在Android应用开发中，RecyclerView是一个强大且灵活的组件，用于展示大量数据集合。然而，标准的RecyclerView只支持单一的滚动停靠点，这在某些场景下可能不够灵活。为了解决这个问题，TakuSemba开发了一个名为MultiSnapRecyclerView的库，它允许开发者在RecyclerView中实现多个滚动停靠点。文章目录什么是MultiSnapRecyclerView
  • Android界面特效全汇总 小飞鹤 Android开发详解android
    （一）Activity页面切换的效果Android2.0之后有了overridePendingTransition（），其中里面两个参数，一个是前一个activity的退出两一个activity的进入，Java代码1.@OverridepublicvoidonCreate(BundlesavedInstanceState){2.super.onCreate(savedInstanceState);
  • JAVA中的Enum 周凡杨 javaenum枚举
    Enum是计算机编程语言中的一种数据类型---枚举类型。 在实际问题中，有些变量的取值被限定在一个有限的范围内。     例如，一个星期内只有七天 我们通常这样实现上面的定义： public String monday; public String tuesday; public String wensday; public String thursday
  • 赶集网mysql开发36条军规 Bill_chen mysql业务架构设计mysql调优mysql性能优化
    (一)核心军规 (1)不在数据库做运算    cpu计算务必移至业务层； (2)控制单表数据量    int型不超过1000w，含char则不超过500w；    合理分表；    限制单库表数量在300以内； (3)控制列数量    字段少而精，字段数建议在20以内
  • Shell test命令 daizj shell字符串test数字文件比较
    Shell test命令 Shell中的 test 命令用于检查某个条件是否成立，它可以进行数值、字符和文件三个方面的测试。 数值测试 参数 说明 -eq 等于则为真 -ne 不等于则为真 -gt 大于则为真 -ge 大于等于则为真 -lt 小于则为真 -le 小于等于则为真 实例演示： num1=100 num2=100if test $[num1]
  • XFire框架实现WebService(二) 周凡杨 javawebservice
       有了XFire框架实现WebService(一)，就可以继续开发WebService的简单应用。 Webservice的服务端(WEB工程)： 两个java bean类： Course.java    package cn.com.bean; public class Course {     private
  • 重绘之画图板 朱辉辉33 画图板
           上次博客讲的五子棋重绘比较简单，因为只要在重写系统重绘方法paint（）时加入棋盘和棋子的绘制。这次我想说说画图板的重绘。        画图板重绘难在需要重绘的类型很多，比如说里面有矩形，园，直线之类的，所以我们要想办法将里面的图形加入一个队列中，这样在重绘时就
  • Java的IO流 西蜀石兰 java
    刚学Java的IO流时，被各种inputStream流弄的很迷糊，看老罗视频时说想象成插在文件上的一根管道，当初听时觉得自己很明白，可到自己用时，有不知道怎么代码了。。。 每当遇到这种问题时，我习惯性的从头开始理逻辑，会问自己一些很简单的问题，把这些简单的问题想明白了，再看代码时才不会迷糊。 IO流作用是什么？ 答：实现对文件的读写，这里的文件是广义的； Java如何实现程序到文件
  • No matching PlatformTransactionManager bean found for qualifier 'add' - neither 林鹤霄
    java.lang.IllegalStateException: No matching PlatformTransactionManager bean found for qualifier 'add' - neither qualifier match nor bean name match!   网上找了好多的资料没能解决，后来发现：项目中使用的是xml配置的方式配置事务，但是
  • Row size too large (> 8126). Changing some columns to TEXT or BLOB aigo column
    原文：http://stackoverflow.com/questions/15585602/change-limit-for-mysql-row-size-too-large   异常信息： Row size too large (> 8126). Changing some columns to TEXT or BLOB or using ROW_FORMAT=DYNAM
  • JS 格式化时间 alxw4616 JavaScript
    /** * 格式化时间 2013/6/13 by 半仙 [email protected] * 需要 pad 函数 * 接收可用的时间值. * 返回替换时间占位符后的字符串 * * 时间占位符:年 Y 月 M 日 D 小时 h 分 m 秒 s 重复次数表示占位数 * 如 YYYY 4占4位 YY 占2位<p></p> * MM DD hh mm
  • 队列中数据的移除问题 百合不是茶 队列移除
         队列的移除一般都是使用的remov();都可以移除的,但是在昨天做线程移除的时候出现了点问题,没有将遍历出来的全部移除,  代码如下;      // package com.Thread0715.com; import java.util.ArrayList; public class Threa
  • Runnable接口使用实例 bijian1013 javathreadRunnablejava多线程
    Runnable接口 a.       该接口只有一个方法：public void run(); b.       实现该接口的类必须覆盖该run方法 c.       实现了Runnable接口的类并不具有任何天
  • oracle里的extend详解 bijian1013 oracle数据库extend
    扩展已知的数组空间，例： DECLARE TYPE CourseList IS TABLE OF VARCHAR2(10); courses CourseList; BEGIN -- 初始化数组元素，大小为3 courses := CourseList('Biol 4412 ', 'Psyc 3112 ', 'Anth 3001 '); --
  • 【httpclient】httpclient发送表单POST请求 bit1129 httpclient
    浏览器Form Post请求 浏览器可以通过提交表单的方式向服务器发起POST请求，这种形式的POST请求不同于一般的POST请求 1. 一般的POST请求，将请求数据放置于请求体中，服务器端以二进制流的方式读取数据，HttpServletRequest.getInputStream()。这种方式的请求可以处理任意数据形式的POST请求，比如请求数据是字符串或者是二进制数据 2. Form
  • 【Hive十三】Hive读写Avro格式的数据 bit1129 hive
     1. 原始数据 hive> select * from word; OK 1 MSN 10 QQ 100 Gtalk 1000 Skype      2. 创建avro格式的数据表   hive> CREATE TABLE avro_table(age INT, name STRING)STORE
  • nginx+lua+redis自动识别封解禁频繁访问IP ronin47
    在站点遇到攻击且无明显攻击特征，造成站点访问慢，nginx不断返回502等错误时，可利用nginx+lua+redis实现在指定的时间段 内，若单IP的请求量达到指定的数量后对该IP进行封禁，nginx返回403禁止访问。利用redis的expire命令设置封禁IP的过期时间达到在 指定的封禁时间后实行自动解封的目的。 一、安装环境： CentOS x64 release 6.4(Fin
  • java-二叉树的遍历-先序、中序、后序（递归和非递归）、层次遍历 bylijinnan java
    import java.util.LinkedList; import java.util.List; import java.util.Stack; public class BinTreeTraverse { //private int[] array={ 1, 2, 3, 4, 5, 6, 7, 8, 9 }; private int[] array={ 10,6,
  • Spring源码学习-XML 配置方式的IoC容器启动过程分析 bylijinnan javaspringIOC
    以FileSystemXmlApplicationContext为例，把Spring IoC容器的初始化流程走一遍： ApplicationContext context = new FileSystemXmlApplicationContext ("C:/Users/ZARA/workspace/HelloSpring/src/Beans.xml&q
  • [科研与项目]民营企业请慎重参与军事科技工程 comsci 企业
         军事科研工程和项目 并非要用最先进，最时髦的技术，而是要做到“万无一失”    而民营科技企业在搞科技创新工程的时候，往往考虑的是技术的先进性，而对先进技术带来的风险考虑得不够，在今天提倡军民融合发展的大环境下，这种“万无一失”和“时髦性”的矛盾会日益凸显。。。。。。所以请大家在参与任何重大的军事和政府项目之前，对
  • spring 定时器-两种方式 cuityang springquartz定时器
    方式一： 间隔一定时间 运行 <bean id="updateSessionIdTask" class="com.yang.iprms.common.UpdateSessionTask" autowire="byName" /> <bean id="updateSessionIdSchedule
  • 简述一下关于BroadView站点的相关设计 damoqiongqiu view
    终于弄上线了，累趴，戳这里http://www.broadview.com.cn   简述一下相关的技术点   前端：jQuery+BootStrap3.2+HandleBars，全站Ajax（貌似对SEO的影响很大啊！怎么破？），用Grunt对全部JS做了压缩处理，对部分JS和CSS做了合并（模块间存在很多依赖，全部合并比较繁琐，待完善）。   后端：U
  • 运维 PHP问题汇总 dcj3sjt126com windows2003
    1、Dede(织梦)发表文章时,内容自动添加关键字显示空白页 解决方法： 后台>系统>系统基本参数>核心设置>关键字替换（是/否），这里选择“是”。 后台>系统>系统基本参数>其他选项>自动提取关键字，这里选择“是”。   2、解决PHP168超级管理员上传图片提示你的空间不足 网站是用PHP168做的，反映使用管理员在后台无法
  • mac 下 安装php扩展 - mcrypt dcj3sjt126com PHP
    MCrypt是一个功能强大的加密算法扩展库，它包括有22种算法，phpMyAdmin依赖这个PHP扩展，具体如下： 下载并解压libmcrypt-2.5.8.tar.gz。 在终端执行如下命令： tar zxvf libmcrypt-2.5.8.tar.gz cd libmcrypt-2.5.8/ ./configure --disable-posix-threads --
  • MongoDB更新文档 [四] eksliang mongodbMongodb更新文档
    MongoDB更新文档 转载请出自出处：http://eksliang.iteye.com/blog/2174104 MongoDB对文档的CURD，前面的博客简单介绍了，但是对文档更新篇幅比较大，所以这里单独拿出来。 语法结构如下： db.collection.update( criteria, objNew, upsert, multi) 参数含义 参数   
  • Linux下的解压，移除，复制，查看tomcat命令 y806839048 tomcat
    重复myeclipse生成webservice有问题删除以前的，干净 1、先切换到：cd usr/local/tomcat5/logs 2、tail -f catalina.out 3、这样运行时就可以实时查看运行日志了 Ctrl+c 是退出tail命令。 有问题不明的先注掉   cp /opt/tomcat-6.0.44/webapps/g
  • Spring之使用事务缘由(3-XML实现) ihuning spring
      用事务通知声明式地管理事务   事务管理是一种横切关注点。为了在 Spring 2.x 中启用声明式事务管理，可以通过 tx Schema 中定义的 <tx:advice> 元素声明事务通知，为此必须事先将这个 Schema 定义添加到 <beans> 根元素中去。声明了事务通知后，就需要将它与切入点关联起来。由于事务通知是在 <aop:
  • GCD使用经验与技巧浅谈 啸笑天 GC
    前言 GCD(Grand Central Dispatch)可以说是Mac、iOS开发中的一大“利器”，本文就总结一些有关使用GCD的经验与技巧。 dispatch_once_t必须是全局或static变量 这一条算是“老生常谈”了，但我认为还是有必要强调一次，毕竟非全局或非static的dispatch_once_t变量在使用时会导致非常不好排查的bug，正确的如下： 1
  • linux（Ubuntu）下常用命令备忘录1 macroli linux工作ubuntu
    在使用下面的命令是可以通过--help来获取更多的信息1,查询当前目录文件列表：ls ls命令默认状态下将按首字母升序列出你当前文件夹下面的所有内容，但这样直接运行所得到的信息也是比较少的，通常它可以结合以下这些参数运行以查询更多的信息：  ls / 显示/.下的所有文件和目录  ls -l 给出文件或者文件夹的详细信息 ls -a 显示所有文件，包括隐藏文
  • nodejs同步操作mysql qiaolevip 学习永无止境每天进步一点点mysqlnodejs
    // db-util.js var mysql = require('mysql'); var pool = mysql.createPool({ connectionLimit : 10, host: 'localhost', user: 'root', password: '', database: 'test', port: 3306 });
  • 一起学Hive系列文章 superlxw1234 hiveHive入门
      [一起学Hive]系列文章 目录贴，入门Hive，持续更新中。   [一起学Hive]之一—Hive概述，Hive是什么 [一起学Hive]之二—Hive函数大全-完整版 [一起学Hive]之三—Hive中的数据库(Database)和表(Table) [一起学Hive]之四-Hive的安装配置 [一起学Hive]之五-Hive的视图和分区 [一起学Hive
  • Spring开发利器：Spring Tool Suite 3.7.0 发布 wiselyman spring
    Spring Tool Suite(简称STS)是基于Eclipse，专门针对Spring开发者提供大量的便捷功能的优秀开发工具。   在3.7.0版本主要做了如下的更新：   将eclipse版本更新至Eclipse Mars 4.5 GA Spring Boot(JavaEE开发的颠覆者集大成者，推荐大家学习)的配置语言YAML编辑器的支持(包含自动提示，
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他