Java ProjectConnection类代码示例

import org.gradle.tooling.ProjectConnection; //导入依赖的package包/类
private static void fetch(File buildDir, File gradleInstallDir, boolean embedded) {
    System.out.println("* Fetching model for " + buildDir);
    System.out.println("* Using tooling API " + GradleVersion.current().getVersion());

    Timer timer = new Timer();

    GradleConnector gradleConnector = GradleConnector.newConnector();
    gradleConnector.forProjectDirectory(buildDir);
    ((DefaultGradleConnector) gradleConnector).embedded(embedded);
    if (gradleInstallDir != null) {
        gradleConnector.useInstallation(gradleInstallDir);
    }

    ProjectConnection connect = gradleConnector.connect();
    try {
        for (int i = 0; i < 5; i++) {
            SyncAction.withProjectConnection(connect, null);
        }
    } finally {
        connect.close();
    }

    timer.stop();
    System.out.println("total time: " + timer.duration());
}
 

import org.gradle.tooling.ProjectConnection; //导入依赖的package包/类
private ProjectConnection createProjectConnection(ComparableGradleBuildExecuter executer) {
    GradleConnector connector = GradleConnector.newConnector();
    connector.forProjectDirectory(executer.getSpec().getProjectDir());
    File gradleUserHomeDir = gradle.getStartParameter().getGradleUserHomeDir();
    if (gradleUserHomeDir != null) {
        connector.useGradleUserHomeDir(gradleUserHomeDir);
    }

    GradleVersion gradleVersion = executer.getGradleVersion();
    if (gradleVersion.equals(GradleVersion.current())) {
        connector.useInstallation(gradle.getGradleHomeDir());
    } else {
        connector.useGradleVersion(gradleVersion.getVersion());
    }

    return connector.connect();
}
 

import org.gradle.tooling.ProjectConnection; //导入依赖的package包/类
@Override
public void generate(File targetDir, ProjectRequest projectRequest) {
    GradleConnector gradleConnector = GradleConnector.newConnector().forProjectDirectory(targetDir);

    if (projectRequest.getGradleVersion() != null) {
        gradleConnector.useGradleVersion(projectRequest.getGradleVersion());
    }

    ProjectConnection connection = gradleConnector.connect();

    try {
        connection.newBuild().forTasks(buildTasks(projectRequest)).run();
    } finally {
        connection.close();
    }
}
 

import org.gradle.tooling.ProjectConnection; //导入依赖的package包/类
void prepareCompileAndroidJava() {
  ProjectConnection connection = this.project.getProjectConnection();
  try {
    BuildLauncher buildLauncher = connection.newBuild();
    String genTask = this.project.getName() + this.genSourceTaskName;
    buildLauncher.forTasks(genTask).run();

    int size = this.project.getDependencies().size();

    String aar =
        Joiner.on(File.separator)
            .join(this.project.getProjectRoot(), BUILD_DIR, INTERMEDIATE_DIR, EXPLODED_DIR);
    List<File> jars = FileUtils.collectFiles(new File(aar), EXT_JAR);
    for (File jar : jars) {
      addAAR(jar);
    }

    int after = this.project.getDependencies().size();
    if (size != after) {
      CachedASMReflector.getInstance().createClassIndexes(jars);
      this.project.resetCachedClasspath();
    }
  } finally {
    connection.close();
  }
}
 

import org.gradle.tooling.ProjectConnection; //导入依赖的package包/类
ProjectConnection getProjectConnection() {
  final String gradleVersion = Config.load().getGradleVersion();
  GradleConnector connector;
  if (gradleVersion.isEmpty()) {
    connector = GradleConnector.newConnector().forProjectDirectory(this.rootProject);
  } else {
    log.debug("use gradle version:'{}'", gradleVersion);
    connector =
        GradleConnector.newConnector()
            .useGradleVersion(gradleVersion)
            .forProjectDirectory(this.rootProject);
  }

  if (connector instanceof DefaultGradleConnector) {
    final DefaultGradleConnector defaultGradleConnector = (DefaultGradleConnector) connector;
    defaultGradleConnector.daemonMaxIdleTime(1, TimeUnit.HOURS);
  }
  return connector.connect();
}
 

import org.gradle.tooling.ProjectConnection; //导入依赖的package包/类
public ProjectConnection createProject(String name) throws IOException {
	File projectDirectory = new File("target/" + name);
	projectDirectory.mkdirs();

	File gradleScript = new File(projectDirectory, "build.gradle");

	if (new File("src/test/resources", name).isDirectory()) {
		FileSystemUtils.copyRecursively(new File("src/test/resources", name),
				projectDirectory);
	}
	else {
		FileCopyUtils.copy(new File("src/test/resources/" + name + ".gradle"),
				gradleScript);
	}

	GradleConnector gradleConnector = GradleConnector.newConnector();
	gradleConnector.useGradleVersion(this.gradleVersion);

	((DefaultGradleConnector) gradleConnector).embedded(true);
	return gradleConnector.forProjectDirectory(projectDirectory).connect();
}
 

import org.gradle.tooling.ProjectConnection; //导入依赖的package包/类
@Test
public void defaultJvmArgsArePreservedWhenLoadedAgentIsConfigured()
		throws IOException {
	ProjectConnection project = new ProjectCreator()
			.createProject("spring-loaded-jvm-args");
	project.newBuild().forTasks("bootRun")
			.withArguments("-PbootVersion=" + BOOT_VERSION,
					"-PspringLoadedVersion=" + SPRING_LOADED_VERSION, "--stacktrace")
			.run();

	List<String> output = getOutput();
	assertOutputContains("-DSOME_ARG=someValue", output);
	assertOutputContains("-Xverify:none", output);
	assertOutputMatches("-javaagent:.*springloaded-" + SPRING_LOADED_VERSION + ".jar",
			output);
}
 

import org.gradle.tooling.ProjectConnection; //导入依赖的package包/类
public static void gradleBuild(IProject project, String task, IProgressMonitor monitor) throws CoreException {
	String taskName = String.format("Executing %s on project %s", task, project.getName());
	try {
		IConsoleService console = Activator.getService(IConsoleService.class);
		console.activate();
		console.writeOutput(String.format("\n%s\n\n", taskName)); //$NON-NLS-1$

		File projectDir = new File(project.getLocationURI());
		ProjectConnection connection = GradleConnector.newConnector().forProjectDirectory(projectDir).connect();
		connection.newBuild().forTasks(task).setStandardOutput(console.getOutputStream())
				.setStandardError(console.getErrorStream()).run();
		connection.close();
		project.refreshLocal(IResource.DEPTH_INFINITE, monitor);
	} catch (BuildException | IOException e) {
		throw new CoreException(new Status(IStatus.ERROR, Activator.getId(), taskName, e));
	}
}
 

import org.gradle.tooling.ProjectConnection; //导入依赖的package包/类
protected byte[] runTasks(String pathToRootOfProject, String... tasks) {
    ProjectConnection connection = GradleConnector.newConnector().forProjectDirectory(new File(pathToRootOfProject)).connect();
    ByteArrayOutputStream outputStream = new ByteArrayOutputStream();

    try {
        BuildLauncher build = connection.newBuild();
        build.forTasks(tasks);
        build.setStandardOutput(outputStream);
        build.setStandardError(outputStream);
        build.run();
    } catch (Exception e) {
        throw new RuntimeException(e);
    } finally {
        connection.close();
    }
    return outputStream.toByteArray();
}
 

import org.gradle.tooling.ProjectConnection; //导入依赖的package包/类
/**
 * Returns the project model without building.
 *
 * This will fail if the project is a multi-project setup.
 *
 * @param emulateStudio_1_0 whether to emulate an older IDE (studio 1.0) querying the model.
 * @param assertNoSyncIssues true if the presence of sync issues during the model evaluation
 *                           should raise a {@link AssertionError}s
 */
@NonNull
private AndroidProject getSingleModel(boolean emulateStudio_1_0, boolean assertNoSyncIssues) {
    ProjectConnection connection = getProjectConnection();
    try {
        Map<String, AndroidProject> modelMap = buildModel(
                connection,
                new GetAndroidModelAction(),
                emulateStudio_1_0);

        // ensure there was only one project
        assertEquals("Quering GradleTestProject.getModel() with multi-project settings",
                1, modelMap.size());

        AndroidProject androidProject = modelMap.get(":");
        if (assertNoSyncIssues) {
            assertNoSyncIssues(androidProject);
        }
        return androidProject;
    } finally {
        connection.close();
    }
}
 

import org.gradle.tooling.ProjectConnection; //导入依赖的package包/类
private void executeBuild(List<String> arguments, ProjectConnection connection,
        String[] tasks) {
    List<String> args = Lists.newArrayListWithCapacity(3 + arguments.size());
    args.add("-i");
    args.add("-u");
    args.addAll(arguments);

    BuildLauncher launcher = connection.newBuild()
            .forTasks(tasks)
            .withArguments(Iterables.toArray(args, String.class));

    setJvmArguments(launcher);

    if (stdout != null) {
        launcher.setStandardOutput(stdout);
    } else {
        launcher.setStandardOutput(System.out);
    }
    if (stderr != null) {
        launcher.setStandardError(stderr);
    } else {
        launcher.setStandardError(System.err);
    }
    launcher.run();
}
 

import org.gradle.tooling.ProjectConnection; //导入依赖的package包/类
/**
 * Returns a project model for each sub-project without building.
 *
 * @param connection the opened ProjectConnection
 * @param action the build action to gather the model
 * @param emulateStudio_1_0 whether to emulate an older IDE (studio 1.0) querying the model.
 */
@NonNull
private <K,V> Map<K, V> buildModel(
        @NonNull ProjectConnection connection,
        @NonNull BuildAction<Map<K, V>> action,
        boolean emulateStudio_1_0) {

    BuildActionExecuter<Map<K, V>> executor = connection.action(action);

    List<String> arguments = Lists.newArrayListWithCapacity(emulateStudio_1_0 ? 2 : 3);
    arguments.add("-P" + AndroidProject.PROPERTY_BUILD_MODEL_ONLY + "=true");
    arguments.add("-P" + AndroidProject.PROPERTY_INVOKED_FROM_IDE + "=true");
    if (!emulateStudio_1_0) {
        arguments.add("-P" + AndroidProject.PROPERTY_BUILD_MODEL_ONLY_ADVANCED + "=true");
    }

    setJvmArguments(executor);

    executor.withArguments(Iterables.toArray(arguments, String.class));

    executor.setStandardOutput(System.out);
    executor.setStandardError(System.err);

    return executor.run();
}
 

import org.gradle.tooling.ProjectConnection; //导入依赖的package包/类
@Override
public void setUp() throws Exception {
  super.setUp();
  myIdeaProject = new IdeaProjectStub("multiProject");
  myAndroidProject = TestProjects.createBasicProject(myIdeaProject.getRootDir());

  myAndroidModule = myIdeaProject.addModule(myAndroidProject.getName(), "androidTask");
  myUtilModule = myIdeaProject.addModule("util", "compileJava", "jar", "classes");
  myIdeaProject.addModule("notReallyAGradleProject");

  ProjectImportAction.AllModels allModels = new ProjectImportAction.AllModels(myIdeaProject);
  allModels.addExtraProject(myAndroidProject, AndroidProject.class, myAndroidModule);

  ExternalSystemTaskId id = ExternalSystemTaskId.create(SYSTEM_ID, RESOLVE_PROJECT, myIdeaProject.getName());
  String projectPath = FileUtil.toSystemDependentName(myIdeaProject.getBuildFile().getParent());
  ExternalSystemTaskNotificationListener notificationListener = new ExternalSystemTaskNotificationListenerAdapter() {};
  myResolverCtx = new ProjectResolverContext(id, projectPath, null, createMock(ProjectConnection.class), notificationListener, true);
  myResolverCtx.setModels(allModels);

  myProjectResolver = new AndroidGradleProjectResolver(createMock(ProjectImportErrorHandler.class));
  myProjectResolver.setProjectResolverContext(myResolverCtx);

  GradleProjectResolverExtension next = new BaseGradleProjectResolverExtension();
  next.setProjectResolverContext(myResolverCtx);
  myProjectResolver.setNext(next);
}
 

import org.gradle.tooling.ProjectConnection; //导入依赖的package包/类
/**
 * Returns the {@link com.android.builder.model.AndroidProject} given the gradle project root.
 * Note that this works only single module projects (only one build.gradle)
 */
@Nullable
private static AndroidProject getAndroidProject(String projectPath) {
  File androidPlugin = new File(AndroidTestBase.getAndroidPluginHome());
  File projectDir = new File(androidPlugin, BASE_PATH + projectPath);
  GradleConnector connector = GradleConnector.newConnector();
  connector.forProjectDirectory(projectDir);
  connector.useDistribution(new DistributionLocator().getDistributionFor(GradleVersion.version("2.2.1")));

  AndroidProject model = null;
  ProjectConnection connection = connector.connect();
  try {
    model = connection.getModel(AndroidProject.class);
  } finally {
    connection.close();
  }

  return model;
}
 

import org.gradle.tooling.ProjectConnection; //导入依赖的package包/类
private static void addGradleClassPath(@NotNull final List<String> classpath) {
  String gradleLibDirPath = null;
  String gradleToolingApiJarPath = PathUtil.getJarPathForClass(ProjectConnection.class);
  if (!StringUtil.isEmpty(gradleToolingApiJarPath)) {
    gradleLibDirPath = PathUtil.getParentPath(gradleToolingApiJarPath);
  }
  if (gradleLibDirPath == null || gradleLibDirPath.isEmpty()) return;

  File gradleLibDir = new File(gradleLibDirPath);
  if (!gradleLibDir.isDirectory()) return;

  File[] children = FileUtil.notNullize(gradleLibDir.listFiles());
  for (File child : children) {
    final String fileName = child.getName();
    if (fileName.endsWith(".jar") && child.isFile()) {
      classpath.add(child.getAbsolutePath());
    }
  }
}