import groovy.grape.Grape; //导入依赖的package包/类
private void updateDependencyResolutionContext(
		List<Map<String, String>> bomDependencies) {
	URI[] uris = Grape.getInstance().resolve(null,
			bomDependencies.toArray(new Map[bomDependencies.size()]));
	DefaultModelBuilder modelBuilder = new DefaultModelBuilderFactory().newInstance();
	for (URI uri : uris) {
		try {
			DefaultModelBuildingRequest request = new DefaultModelBuildingRequest();
			request.setModelResolver(new GrapeModelResolver());
			request.setModelSource(new UrlModelSource(uri.toURL()));
			request.setSystemProperties(System.getProperties());
			Model model = modelBuilder.build(request).getEffectiveModel();
			this.resolutionContext.addDependencyManagement(
					new MavenModelDependencyManagement(model));
		}
		catch (Exception ex) {
			throw new IllegalStateException("Failed to build model for '" + uri
					+ "'. Is it a valid Maven bom?", ex);
		}
	}
}
 

import groovy.grape.Grape; //导入依赖的package包/类
@Override
public ModelSource resolveModel(String groupId, String artifactId, String version)
		throws UnresolvableModelException {
	Map<String, String> dependency = new HashMap<String, String>();
	dependency.put("group", groupId);
	dependency.put("module", artifactId);
	dependency.put("version", version);
	dependency.put("type", "pom");
	try {
		return new UrlModelSource(
				Grape.getInstance().resolve(null, dependency)[0].toURL());
	}
	catch (MalformedURLException e) {
		throw new UnresolvableModelException(e.getMessage(), groupId, artifactId,
				version);
	}
}
 

import groovy.grape.Grape; //导入依赖的package包/类
/**
 * {@inheritDoc}
 * <p/>
 * This method should be called after "expected" imports have been added to the {@code DependencyManager}
 * because adding imports with {@link #addImports(java.util.Set)} will reset the classloader and flush away
 * dependencies.
 */
@Override
public synchronized List<GremlinPlugin> use(final String group, final String artifact, final String version) {
    final Map<String, Object> dependency = new HashMap<String, Object>() {{
        put("group", group);
        put("module", artifact);
        put("version", version);
    }};

    final Map<String, Object> args = new HashMap<String, Object>() {{
        put("classLoader", loader);
    }};

    Grape.grab(args, dependency);

    // note that the service loader utilized the classloader from the groovy shell as shell class are available
    // from within there given loading through Grape.
    final List<GremlinPlugin> pluginsFound = new ArrayList<>();
    ServiceLoader.load(GremlinPlugin.class, loader).forEach(pluginsFound::add);

    artifactsToUse.add(new Artifact(group, artifact, version));

    return pluginsFound;
}
 

import groovy.grape.Grape; //导入依赖的package包/类
@Override
public boolean loadVersion(String version) {
    try {
        if (cacheDirectory != null) {
            System.setProperty("grape.root", cacheDirectory);
        }

        Grape.setEnableAutoDownload(true);

        Map<String, Object> param = new HashMap<>();
        param.put("classLoader", classLoader);
        param.put("group", "org.apache.camel");
        param.put("module", "camel-catalog");
        param.put("version", version);

        Grape.grab(param);

        this.version = version;
        return true;
    } catch (Exception e) {
        // ignore
        return false;
    }
}
 

import groovy.grape.Grape; //导入依赖的package包/类
@Override
public boolean loadRuntimeProviderVersion(String groupId, String artifactId, String version) {
    try {
        Grape.setEnableAutoDownload(true);

        Map<String, Object> param = new HashMap<>();
        param.put("classLoader", classLoader);
        param.put("group", groupId);
        param.put("module", artifactId);
        param.put("version", version);

        Grape.grab(param);

        this.runtimeProviderVersion = version;
        return true;
    } catch (Exception e) {
        // ignore
        return false;
    }
}
 

import groovy.grape.Grape; //导入依赖的package包/类
public static void install(GrapeEngine engine) {
	synchronized (Grape.class) {
		try {
			Field field = Grape.class.getDeclaredField("instance");
			field.setAccessible(true);
			field.set(null, engine);
		}
		catch (Exception ex) {
			throw new IllegalStateException("Failed to install GrapeEngine", ex);
		}
	}
}
 

import groovy.grape.Grape; //导入依赖的package包/类
/**
 * To add a 3rd party Maven repository.
 *
 * @param name the repository name
 * @param url  the repository url
 */
void addMavenRepository(String name, String url) {
    Map<String, Object> repo = new HashMap<>();
    repo.put("name", name);
    repo.put("root", url);
    Grape.addResolver(repo);
}
 

import groovy.grape.Grape; //导入依赖的package包/类
/**
 * Configure Groovy Grape engine to use local ivy instance
 */
public static void configureGrape(){
    GrapeIvy grape = (GrapeIvy) Grape.getInstance();
    IvySettings settings = new IvySettings();
    ClassLoader resourceClassLoader = VarScript.class.getClassLoader();
    File ivySettingsXmlFile = new File(VarScript.dataFolder, "ivysettings.xml");
    try {
        if (ivySettingsXmlFile.isFile()) settings.load(ivySettingsXmlFile);
        else settings.load(resourceClassLoader.getResource("ivysettings.xml"));
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
    grape.setIvyInstance(ivy);
    grape.setSettings(settings);
}
 

import groovy.grape.Grape; //导入依赖的package包/类
/**
 * Grab specified camel modules.
 *
 * @param moduleNames e.g. {@code jetty} for {@code camel-jetty}, {@code twitter} for {@code camel-twitter},
 * and so on
 * @see Grape#grab(java.util.Map, java.util.Map...)
 */
public void require(String... moduleNames) {
    List<Map<String, Object>> dependencies = new ArrayList<Map<String, Object>>();

    for (String moduleName : moduleNames) {
        Map<String, Object> artifact = new HashMap<String, Object>();
        artifact.put("group", "org.apache.camel");
        artifact.put("module", "camel-" + moduleName);
        artifact.put("version", camelVersion);

        dependencies.add(artifact);
    }

    Grape.grab(new HashMap<String, Object>(), dependencies.toArray(new Map[dependencies.size()]));
}
 

import groovy.grape.Grape; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
@Override
public Map[] dependencies() {
    return Grape.listDependencies(loader);
}