Gradle插件-DSL

DSL （Domain Specific Language）领域专用语言

使用DSL，可以扩展Gradle的语义，使用者可以通过DSL完成需要的配置，而不用关心具体的实现

主要涉及到的类

Extension

通过Extension实现向目标对象添加DSL扩展，一般通过ExtensionContainer.create进行创建，如

project.getExtensions().create('myExtension', CustomExtension.class)

NamedDomainObjectContainer

命名对象容器，对指定type的命名对象进行管理，指定的type必须有一个public的构造函数且参数名为name，类型为String，每个Object必须含有一个导出属性"name"

Creates a container for managing named objects of the specified type. The specified type must have a public constructor which takes the name as a String parameter.

All objects MUST expose their name as a bean property named "name". The name must be constant for the life of the object.

Instantiator

用来创建对象，与直接new一个对象的区别在于，使用Instantiator.newInstance创建的对象具有DSL特性

目标

实现在build.gradle进行如下配置

moreExtension{
    extensionName "i am moreExtension"
    innerExtension {
        innerExtensionName "i am innerExtensionName"
    }
    namedDomainExtension {
        extension1 {
            extensionName "NamedDomain1 i am moreExtension"
        }
        extension2{
            extensionName "NamedDomain2 i am moreExtension"
        }
    }
}

其中，moreExtension为 Extension，其会添加到project.extensions中，extensionName为简单类型String， innerExtension为简单对象，namedDomainExtension下是个对象列表，使用NamedDomainObjectContainer

1. 创建innerExtension对应的类

package com.lling.gradle.plugindemo.dsl;

public class InnerExtension {
    private String mInnerExtensionName;

    public String getInnerExtensionName() {
        return mInnerExtensionName;
    }

    public void setInnerExtensionName(String innerExtensionName) {
        this.mInnerExtensionName = innerExtensionName;
    }
}

    build.gradle配置中使用 innerExtensionName时调用的是其set方法，注意名字要对应

2. namedDomainExtension是NamedDomainObjectContainer，首先先定义列表中的对象类

package com.lling.gradle.plugindemo.dsl;

public class NamedDomainExtension {
    private String name;
    private String extensionName;

    public NamedDomainExtension(String name){
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getExtensionName() {
        return extensionName;
    }

    public void setExtensionName(String extensionName) {
        this.extensionName = extensionName;
    }
}

 注意， NamedDomainObjectContainer使用的类型必须含有一个String name属性，且有一个public 构造函数且参数为String name

3. 创建NamedDomainObjectContainer对象，需要借助NamedDomainExtensionFactory进行

 <T> NamedDomainObjectContainer<T> container(Class<T> var1, NamedDomainObjectFactory<T> var2);

package com.lling.gradle.plugindemo.dsl;

import org.gradle.api.NamedDomainObjectFactory;
import org.gradle.internal.reflect.Instantiator;

public class NamedDomainExtensionFactory implements NamedDomainObjectFactory<NamedDomainExtension>{
    private Instantiator instantiator;

    public NamedDomainExtensionFactory(Instantiator instantiator){
        this.instantiator = instantiator;
    }

    @Override
    public NamedDomainExtension create(String s) {
        return instantiator.newInstance(NamedDomainExtension.class, s);
    }
}

4. 创建 moreExtension对应的类

package com.lling.gradle.plugindemo.dsl;

import org.gradle.api.Action;
import org.gradle.api.NamedDomainObjectContainer;
import org.gradle.internal.reflect.Instantiator;

public class MoreExtension {
    private String mExtensionName;
    private InnerExtension mInnerExtension;
    private NamedDomainObjectContainer<NamedDomainExtension> mNamedDomianExtension;

    public MoreExtension(Instantiator instantiator, NamedDomainObjectContainer<NamedDomainExtension> namedDomainExtensions){
        mInnerExtension = instantiator.newInstance(InnerExtension.class);
        mNamedDomianExtension = namedDomainExtensions;
    }

    public String getExtensionName() {
        return mExtensionName;
    }

    public void setExtensionName(String extensionName) {
        this.mExtensionName = extensionName;
    }

    public InnerExtension getInnerExtension() {
        return mInnerExtension;
    }

    public void innerExtension(Action<InnerExtension> action) {
        action.execute(mInnerExtension);
    }

    public NamedDomainObjectContainer<NamedDomainExtension> getNamedDomianExtension() {
        return mNamedDomianExtension;
    }

    public void namedDomianExtension(Action< ? super NamedDomainObjectContainer<NamedDomainExtension>> action) {
        action.execute(mNamedDomianExtension);
    }
}

  从实现上来看，我们使用Intantiator.newInstance创建需要的对象实例，build.gradle文件中innerExtension的使用对应到其set方法，但是在使用时一直出错，最后直接将其set方法改为 innerExtension就好了。要是innerExtension能在build.gradle中被解析出来，需要借助Action

5. 在插件中将需要的Extension添加到ptoject.extensions中

package com.lling.gradle.plugindemo.dsl;

import org.gradle.api.NamedDomainObjectContainer;
import org.gradle.api.Plugin;
import org.gradle.api.Project;
import org.gradle.internal.reflect.Instantiator;
import org.gradle.invocation.DefaultGradle;

public class ExtensionPlugin implements Plugin<Project> {
    @Override
    public void apply(Project project) {
        Instantiator instantiator = ((DefaultGradle)project.getGradle()).getServices().get(Instantiator.class);
        NamedDomainObjectContainer<NamedDomainExtension> namedDomainExtensions = project.container(NamedDomainExtension.class,
                new NamedDomainExtensionFactory(instantiator));

        project.getExtensions().create("moreExtension", MoreExtension.class, new Object[]{instantiator, namedDomainExtensions});

    }
}

6. 发布插件，在需要的工程中引入使用

输出build.gradle中的配置

project.task("dsl"){
    println "------------------------------"
    println "the extensionName " + project.moreExtension.extensionName
    println "the extensionName In extension1 " + project.moreExtension.namedDomianExtension.extension1.extensionName
    println "the extensionName In extension2 " + project.moreExtension.namedDomianExtension.extension2.extensionName

}

输出结果为

------------------------------
the extensionName i am moreExtension
the extensionName In extension1 NamedDomain1 i am moreExtension
the extensionName In extension2 NamedDomain2 i am moreExtension

参考：https://www.jianshu.com/p/3c59eded8155