import org.gradle.internal.reflect.Instantiator; //导入依赖的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.internal.reflect.Instantiator; //导入依赖的package包/类
public DefaultBaseRepositoryFactory(LocalMavenRepositoryLocator localMavenRepositoryLocator,
                                    FileResolver fileResolver,
                                    Instantiator instantiator,
                                    RepositoryTransportFactory transportFactory,
                                    LocallyAvailableResourceFinder<ModuleComponentArtifactMetadata> locallyAvailableResourceFinder,
                                    FileStore<ModuleComponentArtifactIdentifier> artifactFileStore,
                                    MetaDataParser<MutableMavenModuleResolveMetadata> pomParser,
                                    AuthenticationSchemeRegistry authenticationSchemeRegistry,
                                    IvyContextManager ivyContextManager) {
    this.localMavenRepositoryLocator = localMavenRepositoryLocator;
    this.fileResolver = fileResolver;
    this.instantiator = instantiator;
    this.transportFactory = transportFactory;
    this.locallyAvailableResourceFinder = locallyAvailableResourceFinder;
    this.artifactFileStore = artifactFileStore;
    this.pomParser = pomParser;
    this.authenticationSchemeRegistry = authenticationSchemeRegistry;
    this.ivyContextManager = ivyContextManager;
}
 

import org.gradle.internal.reflect.Instantiator; //导入依赖的package包/类
BaseRepositoryFactory createBaseRepositoryFactory(LocalMavenRepositoryLocator localMavenRepositoryLocator, Instantiator instantiator, FileResolver fileResolver,
                                                  RepositoryTransportFactory repositoryTransportFactory, LocallyAvailableResourceFinder<ModuleComponentArtifactMetadata> locallyAvailableResourceFinder,
                                                  ArtifactIdentifierFileStore artifactIdentifierFileStore,
                                                  VersionSelectorScheme versionSelectorScheme,
                                                  AuthenticationSchemeRegistry authenticationSchemeRegistry,
                                                  IvyContextManager ivyContextManager) {
    return new DefaultBaseRepositoryFactory(
            localMavenRepositoryLocator,
            fileResolver,
            instantiator,
            repositoryTransportFactory,
            locallyAvailableResourceFinder,
            artifactIdentifierFileStore,
            new GradlePomModuleDescriptorParser(versionSelectorScheme),
            authenticationSchemeRegistry,
            ivyContextManager
    );
}
 

import org.gradle.internal.reflect.Instantiator; //导入依赖的package包/类
ConfigurationContainerInternal createConfigurationContainer(Instantiator instantiator, ConfigurationResolver configurationResolver, DomainObjectContext domainObjectContext,
                                                            ListenerManager listenerManager, DependencyMetaDataProvider metaDataProvider, ProjectAccessListener projectAccessListener,
                                                            ProjectFinder projectFinder, ConfigurationComponentMetaDataBuilder metaDataBuilder, FileCollectionFactory fileCollectionFactory,
                                                            GlobalDependencyResolutionRules globalDependencyResolutionRules, ComponentIdentifierFactory componentIdentifierFactory, BuildOperationExecutor buildOperationExecutor) {
    return instantiator.newInstance(DefaultConfigurationContainer.class,
            configurationResolver,
            instantiator,
            domainObjectContext,
            listenerManager,
            metaDataProvider,
            projectAccessListener,
            projectFinder,
            metaDataBuilder,
            fileCollectionFactory,
            globalDependencyResolutionRules.getDependencySubstitutionRules(),
            componentIdentifierFactory,
            buildOperationExecutor
        );
}
 

import org.gradle.internal.reflect.Instantiator; //导入依赖的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.internal.reflect.Instantiator; //导入依赖的package包/类
public DefaultScriptPluginFactory(ScriptCompilerFactory scriptCompilerFactory,
                                  Factory<LoggingManagerInternal> loggingManagerFactory,
                                  Instantiator instantiator,
                                  ScriptHandlerFactory scriptHandlerFactory,
                                  PluginRequestApplicator pluginRequestApplicator,
                                  FileLookup fileLookup,
                                  DirectoryFileTreeFactory directoryFileTreeFactory,
                                  DocumentationRegistry documentationRegistry,
                                  ModelRuleSourceDetector modelRuleSourceDetector,
                                  PluginRepositoryRegistry pluginRepositoryRegistry,
                                  PluginRepositoryFactory pluginRepositoryFactory) {
    this.scriptCompilerFactory = scriptCompilerFactory;
    this.loggingManagerFactory = loggingManagerFactory;
    this.instantiator = instantiator;
    this.scriptHandlerFactory = scriptHandlerFactory;
    this.pluginRequestApplicator = pluginRequestApplicator;
    this.fileLookup = fileLookup;
    this.directoryFileTreeFactory = directoryFileTreeFactory;
    this.documentationRegistry = documentationRegistry;
    this.modelRuleSourceDetector = modelRuleSourceDetector;
    this.pluginRepositoryRegistry = pluginRepositoryRegistry;
    this.pluginRepositoryFactory = pluginRepositoryFactory;
}
 

import org.gradle.internal.reflect.Instantiator; //导入依赖的package包/类
@Defaults
public static void addToolChain(NativeToolChainRegistryInternal toolChainRegistry, ServiceRegistry serviceRegistry) {
    final FileResolver fileResolver = serviceRegistry.get(FileResolver.class);
    final ExecActionFactory execActionFactory = serviceRegistry.get(ExecActionFactory.class);
    final Instantiator instantiator = serviceRegistry.get(Instantiator.class);
    final OperatingSystem operatingSystem = serviceRegistry.get(OperatingSystem.class);
    final BuildOperationProcessor buildOperationProcessor = serviceRegistry.get(BuildOperationProcessor.class);
    final VisualStudioLocator visualStudioLocator = serviceRegistry.get(VisualStudioLocator.class);
    final UcrtLocator ucrtLocator = serviceRegistry.get(UcrtLocator.class);
    final WindowsSdkLocator windowsSdkLocator = serviceRegistry.get(WindowsSdkLocator.class);

    toolChainRegistry.registerFactory(VisualCpp.class, new NamedDomainObjectFactory<VisualCpp>() {
        public VisualCpp create(String name) {
        return instantiator.newInstance(VisualCppToolChain.class, name, buildOperationProcessor, operatingSystem, fileResolver, execActionFactory, visualStudioLocator, windowsSdkLocator, ucrtLocator, instantiator);
        }
    });
    toolChainRegistry.registerDefaultToolChain(VisualCppToolChain.DEFAULT_NAME, VisualCpp.class);
}
 

import org.gradle.internal.reflect.Instantiator; //导入依赖的package包/类
public DefaultReportContainer(Class<? extends T> type, Instantiator instantiator) {
    super(type, instantiator, Report.NAMER);

    enabled = matching(new Spec<T>() {
        public boolean isSatisfiedBy(T element) {
            return element.isEnabled();
        }
    });

    beforeChange(new Runnable() {
        public void run() {
            throw new ImmutableViolationException();
        }
    });
}
 

import org.gradle.internal.reflect.Instantiator; //导入依赖的package包/类
public DefaultTaskContainer(MutableModelNode modelNode, ProjectInternal project, Instantiator instantiator, ITaskFactory taskFactory, ProjectAccessListener projectAccessListener) {
    super(Task.class, instantiator, project);
    this.modelNode = modelNode;
    this.taskFactory = taskFactory;
    this.projectAccessListener = projectAccessListener;
    this.instantiator = new TaskInstantiator(taskFactory);
}
 

import org.gradle.internal.reflect.Instantiator; //导入依赖的package包/类
private BinaryInfo(ComponentSpecIdentifier componentId, Class<? extends BinarySpec> publicType, MutableModelNode modelNode, MutableModelNode componentNode, ITaskFactory taskFactory, Instantiator instantiator) {
    this.componentId = componentId;
    this.publicType = publicType;
    this.modelNode = modelNode;
    this.componentNode = componentNode;
    this.taskFactory = taskFactory;
    this.instantiator = instantiator;
}
 

import org.gradle.internal.reflect.Instantiator; //导入依赖的package包/类
public DefaultTaskContainerFactory(ModelRegistry modelRegistry, Instantiator instantiator, ITaskFactory taskFactory, Project project, ProjectAccessListener projectAccessListener) {
    this.modelRegistry = modelRegistry;
    this.instantiator = instantiator;
    this.taskFactory = taskFactory;
    this.project = project;
    this.projectAccessListener = projectAccessListener;
}
 

import org.gradle.internal.reflect.Instantiator; //导入依赖的package包/类
@Model
public static VisualStudioExtensionInternal visualStudio(ServiceRegistry serviceRegistry, ProjectIdentifier projectIdentifier) {
    Instantiator instantiator = serviceRegistry.get(Instantiator.class);
    ProjectModelResolver projectModelResolver = serviceRegistry.get(ProjectModelResolver.class);
    FileResolver fileResolver = serviceRegistry.get(FileResolver.class);

    return instantiator.newInstance(DefaultVisualStudioExtension.class, projectIdentifier, instantiator, projectModelResolver, fileResolver);
}
 

import org.gradle.internal.reflect.Instantiator; //导入依赖的package包/类
public DefaultTestLoggingContainer(Instantiator instantiator) {
    for (LogLevel level: LogLevel.values()) {
        perLevelTestLogging.put(level, instantiator.newInstance(DefaultTestLogging.class));
    }

    setEvents(EnumSet.of(TestLogEvent.FAILED));
    setExceptionFormat(TestExceptionFormat.SHORT);

    getInfo().setEvents(EnumSet.of(TestLogEvent.FAILED, TestLogEvent.SKIPPED, TestLogEvent.STANDARD_OUT, TestLogEvent.STANDARD_ERROR));
    getInfo().setStackTraceFilters(EnumSet.of(TestStackTraceFilter.TRUNCATE));

    getDebug().setEvents(EnumSet.allOf(TestLogEvent.class));
    getDebug().setMinGranularity(0);
    getDebug().setStackTraceFilters(EnumSet.noneOf(TestStackTraceFilter.class));
}
 

import org.gradle.internal.reflect.Instantiator; //导入依赖的package包/类
@Defaults
void createDistributions(@Path("distributions") PlayDistributionContainer distributions, @Path("binaries") ModelMap<PlayApplicationBinarySpecInternal> playBinaries, PlayPluginConfigurations configurations, ServiceRegistry serviceRegistry) {
    FileOperations fileOperations = serviceRegistry.get(FileOperations.class);
    Instantiator instantiator = serviceRegistry.get(Instantiator.class);
    for (PlayApplicationBinarySpecInternal binary : playBinaries) {
        PlayDistribution distribution = instantiator.newInstance(DefaultPlayDistribution.class, binary.getProjectScopedName(), fileOperations.copySpec(), binary);
        distribution.setBaseName(binary.getProjectScopedName());
        distributions.add(distribution);
    }
}
 

import org.gradle.internal.reflect.Instantiator; //导入依赖的package包/类
@Inject
public MavenPublishPlugin(Instantiator instantiator, DependencyMetaDataProvider dependencyMetaDataProvider, FileResolver fileResolver,
                          ProjectDependencyPublicationResolver projectDependencyResolver, FileCollectionFactory fileCollectionFactory) {
    this.instantiator = instantiator;
    this.dependencyMetaDataProvider = dependencyMetaDataProvider;
    this.fileResolver = fileResolver;
    this.projectDependencyResolver = projectDependencyResolver;
    this.fileCollectionFactory = fileCollectionFactory;
}
 

import org.gradle.internal.reflect.Instantiator; //导入依赖的package包/类
private DefaultScriptPluginFactory defaultScriptPluginFactory() {
    return new DefaultScriptPluginFactory(
        get(ScriptCompilerFactory.class),
        getFactory(LoggingManagerInternal.class),
        get(Instantiator.class),
        get(ScriptHandlerFactory.class),
        get(PluginRequestApplicator.class),
        get(FileLookup.class),
        get(DirectoryFileTreeFactory.class),
        get(DocumentationRegistry.class),
        get(ModelRuleSourceDetector.class),
        get(PluginRepositoryRegistry.class),
        get(PluginRepositoryFactory.class));
}
 

import org.gradle.internal.reflect.Instantiator; //导入依赖的package包/类
@Inject
public EarPluginConvention(FileResolver fileResolver, Instantiator instantiator) {
    this.fileResolver = fileResolver;
    this.instantiator = instantiator;
    deploymentDescriptor = instantiator.newInstance(DefaultDeploymentDescriptor.class, fileResolver, instantiator);
    deploymentDescriptor.readFrom("META-INF/application.xml");
    deploymentDescriptor.readFrom(appDirName + "/META-INF/" + deploymentDescriptor.getFileName());
}
 

import org.gradle.internal.reflect.Instantiator; //导入依赖的package包/类
public DefaultSourceSetContainer(FileResolver fileResolver, TaskResolver taskResolver, Instantiator classGenerator, SourceDirectorySetFactory sourceDirectorySetFactory) {
    super(SourceSet.class, classGenerator, new Namer<SourceSet>() {
        public String determineName(SourceSet ss) {
            return ss.getName();
        }
    });
    this.fileResolver = fileResolver;
    this.taskResolver = taskResolver;
    this.instantiator = classGenerator;
    this.sourceDirectorySetFactory = sourceDirectorySetFactory;
}
 

import org.gradle.internal.reflect.Instantiator; //导入依赖的package包/类
DefaultPluginRepositoryFactory createPluginRepositoryFactory(PluginResolutionServiceResolver pluginResolutionServiceResolver, VersionSelectorScheme versionSelectorScheme,
                                                             final DependencyManagementServices dependencyManagementServices, final FileResolver fileResolver,
                                                             final DependencyMetaDataProvider dependencyMetaDataProvider, Instantiator instantiator,
                                                             final AuthenticationSchemeRegistry authenticationSchemeRegistry) {

    final Factory<DependencyResolutionServices> dependencyResolutionServicesFactory = makeDependencyResolutionServicesFactory(
        dependencyManagementServices, fileResolver, dependencyMetaDataProvider);
    return instantiator.newInstance(
        DefaultPluginRepositoryFactory.class, pluginResolutionServiceResolver,
        dependencyResolutionServicesFactory, versionSelectorScheme, instantiator,
        authenticationSchemeRegistry);
}
 

import org.gradle.internal.reflect.Instantiator; //导入依赖的package包/类
private AuthenticationContainer makeAuthenticationContainer(Instantiator instantiator, AuthenticationSchemeRegistry authenticationSchemeRegistry) {
    DefaultAuthenticationContainer container = instantiator.newInstance(DefaultAuthenticationContainer.class, instantiator);

    for (Map.Entry<Class<Authentication>, Class<? extends Authentication>> e : authenticationSchemeRegistry.getRegisteredSchemes().entrySet()) {
        container.registerBinding(e.getKey(), e.getValue());
    }

    return container;
}