作为Android开发肯定熟悉Gradle，Gradle是什么呢？Gradle是一款基于Apache的Ant和Maven概念的项目自动化开源构建工具。说白了Gradle就是Android项目自动化构建工具，Gradle的核心是基于Java来实现的。 同时Gradle使用Groovy、Kotlin等语言编写自定义脚本，取代了Ant和Maven使用xml配置文件的方式，简化了开发时对项目构建要做的配置。 Gradle不仅作为Android项目的构建工具，而且在组件化、插件化、热修复等技术领域都需要通过Gradle来实现。所以在Android进阶必须要学习Gradle. Gradle 源码地址：https://github.com/gradle/gradle

自动化工具的发展：

  1. 石器时代：自己编写命令脚本，进行编译和打包
  2. 蒸汽时代：Make、Ant工具的出现
  3. 电气时代：Maven
  4. 信息时代：Gradle

    Gradle 作为现代的自动化工具，帮助开发者构建项目、打包等自动化处理。

项目构建

一个Android项目是如何构建的呢？Android是基于Java应用程序，那么Java代码需要编译成.class文件才能够执行，编译好的这些class文件，需要对其进行打包，打包不仅针对这些class文件，还有所有的资源文件等。例如java web工程打包成jar包或者war包就包含了自己的资源文件，放到服务器上运行。
而Android工程会将编译好的class文件还要打包到dex包，并且所有的资源文件进行合并处理，还需要对打包出来的文件加密和签名处理等等。

如下图Android的构建过程：
image.png

Gradle 提供了：

  • 对多工程的构建支持非常出色，尤其是工程依赖问题，并支持局部构建
  • 多种方式的依赖管理：如远程Maven仓库、nexus私服等
  • 支持传递性依赖管理
  • 轻松迁移项目工程
  • 基于Groovy等语言构建脚本，简便且灵活
  • 免费开源，并且整体设计是以作为一种语言为导向的，而非成为一个严格死板的框架

Groovy 基础

Groovy 是一种基于JVM的敏捷开发语言，它集合了Python、Ruby和Smalltalk的许多强大的特性，Groovy代码能够与java代码很好的结合，也能用于扩展现有代码。由于其运行在jvm上的特性，Groovy也可以使用其他非Java语言编写的库。

  • Groovy、Java及Kotlin都是基于JVM的开发语言
  • Groovy基于Java，在语法上基本相似，做了很过自己的扩展
  • Groovy和Kotlin都有自己支持的DSL语法，两者有许多共通之处
  • Groovy同时支持静态类型和动态类型
  • 支持运算符重载
  • 支持DSL语法特性
  • 本地语法列表和关联数组
  • 各种标记语言，如XML和HTML原生支持
  • 对正则表达式的本地支持
  • Groovy和Java语法非常相似，可以无缝衔接使用Java
  • 支持使用现有的Java库，并做了一定的扩展

了解Groovy与Java的差异

  1. package com.prim
  3. //注释掉class 就会变成脚本文件
  5. //常见java的写法
  6. //class Test01 {
  7. //    static void main(String[] args) {
  8. //        for (int i = 0;i<3;i++){
  9. //            System.out.print("ha ");
  10. //        }
  11. //    }
  12. //      void test(){
  13. //          System.out.print("test");
  14. //      }
  15. //}
  17. //groovy 执行一个脚本
  18. //groovy 的循环
  19. //groovy 可以不用写分号
  20. 3.times {
  21.     println "ha $it"
  22. }
  24. //groovy 跳过2个
  25. 0.step(10,2){
  26.     println it
  27. }
  29. println("hello groovy")
  31. //groovy 定义方法
  33. def test(str){
  34.     //安全导航操作符
  35.     str?.reverse()
  36. //    "hello groovy" //返回一个字符串 return可以省略掉的
  37. }
  39. println test("jake")
  40. println test(null)
  42. //异常处理 没有取强制处理异常，在java中都需要去try/catch
  43. def sleep(){
  44.     Thread.sleep(1000)
  45. }
  47. //groovy 可以在静态方法中返回this,而在java中是不可以的
  48. class A{
  49.     static A test1(){
  50.         this
  51.     }
  52.     static A test2(){
  53.         this
  54.     }
  55. }
  56. A.test1().test2()

Groovy map映射，很重要的类型

  1. //映射 [k1:v1] key是string类型 重要
  2. def map1 = [a:123,b:2]
  4. //遍历map
  5. map1.forEach{k,v->
  6.     println "key=$k,class:$k.class,value=$v"
  7. }
  9. //key=a,class:class java.lang.String,value=123
  10. //key=b,class:class java.lang.String,value=2
  11. //获取value
  12. def v = map1['a']//注意key是字符串
  13. println "v:$v" //v:123

Groovy 中的类

  1. class Car2{
  2.     //groovy 对于private修饰的变量没有强制性
  3.     private def miles
  4.     def year
  6.     //即便定义成私有的也不能阻止它的调用
  7.     private def getMiles() {
  8.         println "getMiles"
  9.         return miles
  10.     }
  12.     void setMiles(miles) {
  13.         println "setMiles"
  14.         this.miles = miles
  15.     }
  16. }
  18. //访问变量
  19. def car = new Car2()
  20. //调用了set和get方法
  21. car.miles = 2000
  22. println car.miles
  23. //打印结果如下：
  24. //setMiles
  25. //getMiles
  26. //2000

关于Groovy设置为private私有的由于其动态特性设置是无效的，一般不推荐这样使用，如果非要设置为私有的可以进行如下设置：

  1.     private void setMiles(miles) {
  2.         //如果必须要将set方法设置为私有的 可以抛出异常或者不进行赋值操作
  3.         throw new IllegalAccessError("can not set")
  4. //        println "setMiles"
  5. //        this.miles = miles
  6.     }

Groovy 还可以不需要访问set和get方法,通过@ 来进行直接操作变量

  1. def car = new Car2()
  2. //调用了set和get方法
  3. car.@miles = 2000 //@ 可以不用调用set方法 直接赋值
  4. println car.miles
  6. //打印结果如下：
  7. getMiles
  8. 2000

Groovy 还可以通过.'变量名' 进行访问

  1. //通过 . 变量名 进行访问
  2. println car.'miles' //2000
  3. def str = "year"
  4. println car."$str" //1000

Groovy 构造函数的坑

  1. class Car2{
  2.     //groovy 对于private修饰的变量没有强制性
  3.     def miles
  4.     def year
  6.     Car2(miles) {
  7.         this.miles = miles
  8.     }
  10.     //由于miles 和 year 都是object 所以必须给year一个类型才能进行构造
  11.     Car2(int year) {
  12.         this.year = year
  13.     }
  15.     //即便定义成私有的也不能阻止它的调用
  16.     private def getMiles() {
  17.         println "getMiles"
  18.         return miles
  19.     }
  21.     private void setMiles(miles) {
  22.         //如果必须要将set方法设置为私有的 可以抛出异常或者不进行赋值操作
  23. //        throw new IllegalAccessError("can not set")
  24.         println "setMiles"
  25.         this.miles = miles
  26.     }
  27. }
  29. def car2 = new Car2(miles: 20000,year: 1000) //当成了map 巨坑！！！ 因为重载的构造方法有动态类型，所以默认会调用Car2(miles)
  30. println car2.miles //[miles:20000, year:1000]
  31. //一般来说默认调用的无参的构造方法，还有调用set和get方法，如果定义全了一些重载的构造方法 需要注意这些问题

动态特性及元编程

动态特性如下代码所示：

  1. //Groovy 的动态特性
  2. class User {
  3.     def username //def动态类型
  4.     void setName(String name) {
  5.         println 'setName(String name)'
  6.     }
  8.     void setName(Object name) {
  9.         println 'setName(Object name)'
  10.     }
  11. }
  13. User user = new User()
  14. //def 动态的设置不同的类型，是在运行时决定的类型
  15. user.username = "123"
  16. println user.username.class //String
  17. user.username = new Object()
  18. println user.username.class //Object
  19. user.username = 123
  20. println user.username.class //Integer
  22. Object name = "sds"
  23. user.setName(name)//setName(String name)
  25. name = 123
  26. user.setName(name)//setName(Object name)
  29. //Groovy 设置类型安全检查
  30. class Person1 {
  31.     def dream() {
  32.         println "I have Person1 a dream"
  33.     }
  34. }
  36. class Person2 {
  37.     def dream() {
  38.         println "I have Person2 a dream"
  39.     }
  40. }
  42. def func(person) {
  43.     person.dream()//默认不会进行类型的安全检查
  44. }
  46. @TypeChecked
  47. //进行类型的安全检查,强制编译检查
  48. def func2(Person1 person) {
  49.     person.dream()
  50. }
  52. @TypeChecked //可以直接作用在类上
  53. class Person{
  54.     @TypeChecked(TypeCheckingMode.SKIP)//跳过类型检查
  55.     def func2(person) {
  56.         person.dream()
  57.     }
  58. }
  60. def person1 = new Person1()
  61. def person2 = new Person2()
  62. func(person1)
  63. func(person2)

Gradle 核心使用Java开发，脚本使用Groovy进行开发

MOP 元编程：Meta Object Protocol 元对象协议

Groovy 直接可以使用MOP进行元编程，我们可以基于应用当前的状态，动态的添加或者改变类的方法和行为。比如在某个Groovy类中并没有实现某个方法，这个方法的具体操作由服务器来控制，使用元编程，为这个类动态添加方法，或者替换原来的实现，然后可以进行调用。 Java中可以通过反射，在运行时动态的获取类的属性、方法等信息，然后反射调用。没有直接做到往类中添加属性、方法和行为，需要通过动态字节码技术ASM、javassist等技术来实现动态的修改class

MOP 方法拦截

通过实现接口的方式重载invokeMethod方法实现方法的拦截，类似java中的AOP动态代理，但是这里和动态代理是不一样的。

  1. //MOP 元编程
  2. //方法拦截实现：GroovyInterceptable
  3. class UserTest implements GroovyInterceptable{
  5.     def func(){
  6.         System.out.println "I have a dream!"
  7.     }
  9.     //必须重载invokeMethod方法
  10.     @Override
  11.     Object invokeMethod(String name, Object args) {
  12.         System.out.println "$name invokeMethod"
  13.         //使用metaClass 判断某个方法是否存在
  14.         if(metaClass.invokeMethod(this,'respondsTo',name,args)){
  15.             System.out.println "$name 存在"
  16.             System.out.println "$name 执行前..."
  17.             metaClass.invokeMethod(this,name,args)
  18.             System.out.println "$name 执行后..."
  19.         }
  20. //        respondsTo(name)//判断方法是否存在
  21. //        return super.invokeMethod(name, args)
  22.     }
  23. }
  25. new UserTest().func()

通过MetaClass实现方法的覆盖和注入新的方法

  1. //MOP 元编程 使用MetaClass
  2. class UserTest2 {
  3.     def func(){
  4.         System.out.println "I have a dream!"
  5.     }
  6. }
  8. def user2 = new UserTest2()
  9. // 只拦截某个对象的某一个方法，如果方法存在就会覆盖，否则就会注入新方法
  10. user2.metaClass.func = {
  11.     System.out.println "I have a new dream!"
  12. }
  14. //等价于实现拦截接口 只针对当前实例
  15. //等价于实现拦截接口 只针对当前实例
  16. user2.metaClass.invokeMethod = {
  17.     String name, Object args ->
  18.         MetaMethod metaMethod =delegate.metaClass.getMetaMethod(name)
  19.         //拦截某个方法
  20.         if (metaMethod != null && name == "func"){
  21.             //匹配方法和参数
  22.             println "$name 1 被拦截"
  23.         }
  24. }
  26. // 针对所有的实例
  27. UserTest2.metaClass.invokeMethod = {
  28.     String name,Object args ->
  29.         //匹配方法和参数
  30.         println "$name 被拦截"
  31. }
  33. user2.func()

MOP 方法注入

  1. // MOP 方法注入
  2. class Person {
  3.     def func() {
  4.         println "I Have a dream!"
  5.     }
  6. }
  8. def person = new Person()
  9. // 1. 通过metaClass 如果不存在该方法就会注入
  10. person.metaClass.func1 = {
  11.     println "func1 调用"
  12. }
  14. person.func1()
  16. // 2. 使用ExpandoMetaClass 注入方法,不推荐使用其实和上述的类似
  17. def expandoMetaClass = new ExpandoMetaClass(Person)
  18. expandoMetaClass.func2 = {
  19.     println "func2 调用"
  20. }
  21. expandoMetaClass.initialize()
  22. Person.metaClass = expandoMetaClass
  24. new Person().func2()
  26. // 3. 使用分类注入方法
  27. class StringUtils {
  28. //    public static String isEmpty() {
  29. //
  30. //    }
  32.     static def isEmpty(String self) {
  33.         println "isEmpty"
  34.         self.length() == 0 || self == null
  35.     }
  36. }
  38. //必须要通过use
  39. use(StringUtils) {
  40.     println "".isEmpty()
  41. }
  43. // 4. 使用分类注入方法的写法2
  44. @Category(String)
  45. class StringUtils2 {
  46.     def isEmpty() {
  47.         println "StringUtils2 isEmpty"
  48.         this.length() == 0 || this == null
  49.     }
  50. }
  52. use(StringUtils2) {
  53.     println "".isEmpty()
  54. }

处理类中的不存在属性和方法进行访问操作时：

  1. class Person5 {
  2.     def username
  4.     //get操作 propertyMissing方法 当访问的属性不存在的时候 不会报错可以给返回一个默认值
  5.     def propertyMissing(String name) {
  6.         println 'propertyMissing'
  7.         if (name == 'age') {
  8.             "19"
  9.         }
  10.         "default"
  11.     }
  13.     //set 操作，对不存在的变量
  14.     def propertyMissing(String name, def arg) {
  15.         println "${name} arg:${arg}"
  16.         return "default"
  17.     }
  19.     //当访问不存在的方法可以进行特殊的处理
  20.     def methodMissing(String name, def arg) {
  21.         println "methodMissing $name"
  22.         if (name == 'getName') {
  23.             "default"
  24.         }
  25.     }
  26. }
  28. def p = new Person5()
  29. println p.age = 12
  30. println p.age
  31. println p.getName()

Expando 动态生成类：

  1. //动态生成类
  2. def e = new Expando(name:"Aaa",func:{
  3.     println "func"
  4. })
  5. e.a = 123
  6. e.func()
  7. println e.a