import org.gradle.api.NamedDomainObjectContainer; //导入依赖的package包/类
public AtlasExtension(@NonNull final ProjectInternal project,
                      @NonNull Instantiator instantiator,
                      @NonNull NamedDomainObjectContainer<T> buildTypes,
                      @NonNull NamedDomainObjectContainer<PatchConfig> patchConfigs,
                      @NonNull NamedDomainObjectContainer<DexConfig>dexConfigs) {

    logger = Logging.getLogger(this.getClass());
    this.project = project;

    this.patchConfigs = patchConfigs;
    this.dexConfigs = dexConfigs;
    this.buildTypes = buildTypes;
    this.multiDexConfigs = project.container(MultiDexConfig.class, new MultiDexConfigFactory(
        instantiator,project, project.getLogger()));

    tBuildConfig = (Z) instantiator.newInstance(TBuildConfig.class);
    manifestOptions = instantiator.newInstance(ManifestOptions.class);
    bundleConfig = instantiator.newInstance(BundleConfig.class);
}
 

import org.gradle.api.NamedDomainObjectContainer; //导入依赖的package包/类
public AtlasExtension createExtendsion(Project project, Instantiator instantiator) {

        AtlasExtension atlasExtension = getExtendsion(project);

        if (null != atlasExtension) {
            return atlasExtension;
        }

        final NamedDomainObjectContainer<TBuildType> buildTypeContainer = project.container(TBuildType.class,
                                                                                            new TBuildTypeFactory(
                                                                                                instantiator, project,
                                                                                                project.getLogger()));
        final NamedDomainObjectContainer<PatchConfig> patchConfigContainer = project.container(PatchConfig.class,
                                                                                               new PatchConfigFactory(
                                                                                                   instantiator,
                                                                                                   project, project
                                                                                                       .getLogger()));
        final NamedDomainObjectContainer<DexConfig>dexConfigContainer = project.container(DexConfig.class,new DexConfigFactory(instantiator,project,project.getLogger()));

        return project.getExtensions().create("atlas", AtlasExtension.class, project, instantiator,
                                              buildTypeContainer, patchConfigContainer,dexConfigContainer);

    }
 

import org.gradle.api.NamedDomainObjectContainer; //导入依赖的package包/类
@Override
public NamedDomainObjectContainer<ConfigurationVariant> getVariants() {
    if (variants == null) {
        // Create variants container only as required
        variants = new FactoryNamedDomainObjectContainer<ConfigurationVariant>(ConfigurationVariant.class, instantiator, new NamedDomainObjectFactory<ConfigurationVariant>() {
            @Override
            public ConfigurationVariant create(String name) {
                return instantiator.newInstance(DefaultVariant.class, name, parentAttributes, artifactNotationParser, fileCollectionFactory);
            }
        });
    }
    return variants;
}
 

import org.gradle.api.NamedDomainObjectContainer; //导入依赖的package包/类
@Finalize
public void addMarkerPublications(PublishingExtension publishing, GradlePluginDevelopmentExtension pluginDevelopment) {
    if (!pluginDevelopment.isAutomatedPublishing()) {
        return;
    }

    PublicationContainer publications = publishing.getPublications();
    NamedDomainObjectContainer<PluginDeclaration> declaredPlugins = pluginDevelopment.getPlugins();

    for (PluginDeclaration declaration : declaredPlugins) {
        createMavenMarkerPublication(declaration, (MavenPublication) publications.getByName("pluginMaven"), publications);
    }
}
 

import org.gradle.api.NamedDomainObjectContainer; //导入依赖的package包/类
@Finalize
public void addMarkerPublications(PublishingExtension publishing, GradlePluginDevelopmentExtension pluginDevelopment) {
    if (!pluginDevelopment.isAutomatedPublishing()) {
        return;
    }
    PublicationContainer publications = publishing.getPublications();
    NamedDomainObjectContainer<PluginDeclaration> declaredPlugins = pluginDevelopment.getPlugins();
    for (PluginDeclaration declaration : declaredPlugins) {
        createIvyMarkerPublication(declaration, (IvyPublication) publications.getByName("pluginIvy"), publications);
    }
}
 

import org.gradle.api.NamedDomainObjectContainer; //导入依赖的package包/类
public static void setProperty(Object object,
                               String fieldName,
                               String value)
    throws IllegalAccessException, InstantiationException, InvocationTargetException, NoSuchFieldException {

    String[] fieldNames = fieldName.split("\\.");

    Object last = object;
    for (int i = 0; i < fieldNames.length - 1; i++) {

        String field = fieldNames[i];

        if (last instanceof NamedDomainObjectContainer) {
            last = ((NamedDomainObjectContainer)last).maybeCreate(field);
        } else {
            Field declaredField = last.getClass().getField(field);
            declaredField.setAccessible(true);

            if (null == declaredField.get(last)) {
                Object newInstance = declaredField.getType()
                    .getConstructors()
                    .getClass()
                    .newInstance();
                declaredField.set(last, newInstance);
            }

            last = declaredField.get(last);
        }
    }

    BeanUtils.setProperty(last, fieldNames[fieldNames.length - 1], value);
}
 

import org.gradle.api.NamedDomainObjectContainer; //导入依赖的package包/类
private void configureForSourceSets(NamedDomainObjectContainer<AndroidSourceSet> sourceSets) {
    sourceSets.all(sourceSet -> {
        Task task = project.getTasks().create(getTaskName(sourceSet, getTaskBaseName(), null), getCastedTaskType());
        task.setGroup(JavaBasePlugin.VERIFICATION_GROUP);
        configureForSourceSet(sourceSet, (T)task);
    });
}
 

import org.gradle.api.NamedDomainObjectContainer; //导入依赖的package包/类
private SamConfig createConfigDsl() {
	log.debug("Setup serverless config DSL");
	final NamedDomainObjectContainer<Stage> stages = project.container(Stage.class);
	final SamConfigDsl samConfig = project.getExtensions().create("serverless", SamConfigDsl.class, project,
			stages);
	((ExtensionAware) samConfig).getExtensions().add("stages", stages);
	return new SamConfig(project, samConfig);
}
 

import org.gradle.api.NamedDomainObjectContainer; //导入依赖的package包/类
public TestedExtension(@NonNull ProjectInternal project, @NonNull Instantiator instantiator,
        @NonNull AndroidBuilder androidBuilder, @NonNull SdkHandler sdkHandler,
        @NonNull NamedDomainObjectContainer<BuildType> buildTypes,
        @NonNull NamedDomainObjectContainer<ProductFlavor> productFlavors,
        @NonNull NamedDomainObjectContainer<SigningConfig> signingConfigs,
        @NonNull ExtraModelInfo extraModelInfo, boolean isLibrary) {
    super(project, instantiator, androidBuilder, sdkHandler, buildTypes, productFlavors,
            signingConfigs, extraModelInfo, isLibrary);

    getSourceSetsContainer().create(ANDROID_TEST.getPrefix());
    getSourceSetsContainer().create(UNIT_TEST.getPrefix());
}
 

import org.gradle.api.NamedDomainObjectContainer; //导入依赖的package包/类
public TestExtension(@NonNull ProjectInternal project, @NonNull Instantiator instantiator,
        @NonNull AndroidBuilder androidBuilder, @NonNull SdkHandler sdkHandler,
        @NonNull NamedDomainObjectContainer<BuildType> buildTypes,
        @NonNull NamedDomainObjectContainer<ProductFlavor> productFlavors,
        @NonNull NamedDomainObjectContainer<SigningConfig> signingConfigs,
        @NonNull ExtraModelInfo extraModelInfo, boolean isLibrary) {
    super(project, instantiator, androidBuilder, sdkHandler, buildTypes, productFlavors,
            signingConfigs, extraModelInfo, isLibrary);
}
 

import org.gradle.api.NamedDomainObjectContainer; //导入依赖的package包/类
public AppExtension(@NonNull ProjectInternal project, @NonNull Instantiator instantiator,
        @NonNull AndroidBuilder androidBuilder, @NonNull SdkHandler sdkHandler,
        @NonNull NamedDomainObjectContainer<BuildType> buildTypes,
        @NonNull NamedDomainObjectContainer<ProductFlavor> productFlavors,
        @NonNull NamedDomainObjectContainer<SigningConfig> signingConfigs,
        @NonNull ExtraModelInfo extraModelInfo, boolean isLibrary) {
    super(project, instantiator, androidBuilder, sdkHandler, buildTypes, productFlavors,
            signingConfigs, extraModelInfo, isLibrary);
}
 

import org.gradle.api.NamedDomainObjectContainer; //导入依赖的package包/类
public LibraryExtension(@NonNull ProjectInternal project, @NonNull Instantiator instantiator,
        @NonNull AndroidBuilder androidBuilder, @NonNull SdkHandler sdkHandler,
        @NonNull NamedDomainObjectContainer<BuildType> buildTypes,
        @NonNull NamedDomainObjectContainer<ProductFlavor> productFlavors,
        @NonNull NamedDomainObjectContainer<SigningConfig> signingConfigs,
        @NonNull ExtraModelInfo extraModelInfo, boolean isLibrary) {
    super(project, instantiator, androidBuilder, sdkHandler, buildTypes, productFlavors,
            signingConfigs, extraModelInfo, isLibrary);
}
 

import org.gradle.api.NamedDomainObjectContainer; //导入依赖的package包/类
@Override
public void createDefaultComponents(
        @NonNull NamedDomainObjectContainer<BuildType> buildTypes,
        @NonNull NamedDomainObjectContainer<ProductFlavor> productFlavors,
        @NonNull NamedDomainObjectContainer<SigningConfig> signingConfigs) {
    // don't call super as we don't want the default app version.
    // must create signing config first so that build type 'debug' can be initialized
    // with the debug signing config.
    signingConfigs.create(BuilderConstants.DEBUG);
    buildTypes.create(BuilderConstants.DEBUG);
}
 

import org.gradle.api.NamedDomainObjectContainer; //导入依赖的package包/类
@Override
public void createDefaultComponents(
        @NonNull NamedDomainObjectContainer<BuildType> buildTypes,
        @NonNull NamedDomainObjectContainer<ProductFlavor> productFlavors,
        @NonNull NamedDomainObjectContainer<SigningConfig> signingConfigs) {
    // must create signing config first so that build type 'debug' can be initialized
    // with the debug signing config.
    signingConfigs.create(DEBUG);
    buildTypes.create(DEBUG);
    buildTypes.create(RELEASE);
}
 

import org.gradle.api.NamedDomainObjectContainer; //导入依赖的package包/类
public AndroidConfigAdaptor(
        AndroidConfig model,
        NamedDomainObjectContainer<AndroidSourceSet> sourceSetsContainer) {
    this.model = model;
    this.sourceSetsContainer = sourceSetsContainer;
    applyProjectSourceSet();
}
 

import org.gradle.api.NamedDomainObjectContainer; //导入依赖的package包/类
public void apply(final Project project) {
    NamedDomainObjectContainer<BeanstalkDeployment> deployments = project.container(BeanstalkDeployment.class);
    BeanstalkPluginExtension beanstalk = project.getExtensions().create("beanstalk", BeanstalkPluginExtension.class);

    ((ExtensionAware) beanstalk).getExtensions().add("deployments", deployments);

    project.getTasks().addRule(new DeployRule(deployments, project, beanstalk));
}
 

import org.gradle.api.NamedDomainObjectContainer; //导入依赖的package包/类
@Override
public void variants(Action<? super NamedDomainObjectContainer<ConfigurationVariant>> configureAction) {
    configureAction.execute(getVariants());
}
 

import org.gradle.api.NamedDomainObjectContainer; //导入依赖的package包/类
public DefaultNativeComponentExtension(NamedDomainObjectContainer<NativeExecutableSpec> executables, NamedDomainObjectContainer<NativeLibrarySpec> libraries) {
    this.executables = executables;
    this.libraries = libraries;
}
 

import org.gradle.api.NamedDomainObjectContainer; //导入依赖的package包/类
@Override
public NamedDomainObjectContainer<NativeExecutableSpec> getExecutables() {
    return executables;
}
 

import org.gradle.api.NamedDomainObjectContainer; //导入依赖的package包/类
@Override
public void executables(Action<? super NamedDomainObjectContainer<? super NativeExecutableSpec>> action) {
    action.execute(executables);
}