Java ImportCustomizer类代码示例

import org.codehaus.groovy.control.customizers.ImportCustomizer; //导入依赖的package包/类
private void applyConfigurationScript(File configScript, CompilerConfiguration configuration) {
    VersionNumber version = parseGroovyVersion();
    if (version.compareTo(VersionNumber.parse("2.1")) < 0) {
        throw new GradleException("Using a Groovy compiler configuration script requires Groovy 2.1+ but found Groovy " + version + "");
    }
    Binding binding = new Binding();
    binding.setVariable("configuration", configuration);

    CompilerConfiguration configuratorConfig = new CompilerConfiguration();
    ImportCustomizer customizer = new ImportCustomizer();
    customizer.addStaticStars("org.codehaus.groovy.control.customizers.builder.CompilerCustomizationBuilder");
    configuratorConfig.addCompilationCustomizers(customizer);

    GroovyShell shell = new GroovyShell(binding, configuratorConfig);
    try {
        shell.evaluate(configScript);
    } catch (Exception e) {
        throw new GradleException("Could not execute Groovy compiler configuration script: " + configScript.getAbsolutePath(), e);
    }
}
 

import org.codehaus.groovy.control.customizers.ImportCustomizer; //导入依赖的package包/类
@Override
protected void prepareInterpreter() {
    ImportCustomizer importCustomizer = new ImportCustomizer();

    PROCESSOR_CLASSES
            .forEach((interfaceClass, scriptClass) -> addImport(importCustomizer, scriptClass, interfaceClass.getSimpleName()));
    addImport(importCustomizer, GroovyPlugin.class, Plugin.class.getSimpleName());

    getStandardImportClasses().forEach(cls -> addImport(importCustomizer, cls));

    CompilerConfiguration configuration = new CompilerConfiguration();
    configuration.addCompilationCustomizers(importCustomizer);

    binding = createBinding();
    shell = new GroovyShell(binding, configuration);
    scripts = Collections.synchronizedList(new ArrayList<>());

    setVariable(KnowledgeBaseConstants.VAR_ENGINE_OPERATIONS, getEngineOperations());

    setClasspath(getEngineOperations() != null ? getEngineOperations().getEngine() : null);
}
 

import org.codehaus.groovy.control.customizers.ImportCustomizer; //导入依赖的package包/类
private GroovyShell getGroovyShell() {
  if (this.groovySh == null) {
    // add some default imports to the script
    ImportCustomizer defaultImports = new ImportCustomizer();
    defaultImports
        .addStarImports("fr.ign.cogit.geoxygene.appli.render.primitive");
    defaultImports
        .addStarImports("fr.ign.cogit.geoxygene.appli.render.operator");
    defaultImports.addStarImports("fr.ign.cogit.geoxygene.appli.render.gl");
    defaultImports.addStarImports("fr.ign.cogit.geoxygene.appli.render");
    defaultImports.addStarImports("fr.ign.cogit.geoxygene.function");
    defaultImports.addStaticStars("org.lwjgl.opengl.GL11");
    defaultImports.addStaticStars("java.lang.Math");
    defaultImports.addStarImports("javax.vecmath");
    defaultImports.addStarImports("java.awt");
    final CompilerConfiguration config = new CompilerConfiguration();
    config.addCompilationCustomizers(defaultImports);
    final Binding binding = this.getBinding();

    this.groovySh = new GroovyShell(binding, config);
  }
  return this.groovySh;
}
 

import org.codehaus.groovy.control.customizers.ImportCustomizer; //导入依赖的package包/类
@Override
public void applyImports(ImportCustomizer imports) {
	imports.addImports("org.springframework.batch.repeat.RepeatStatus",
			"org.springframework.batch.core.scope.context.ChunkContext",
			"org.springframework.batch.core.step.tasklet.Tasklet",
			"org.springframework.batch.core.configuration.annotation.StepScope",
			"org.springframework.batch.core.configuration.annotation.JobBuilderFactory",
			"org.springframework.batch.core.configuration.annotation.StepBuilderFactory",
			"org.springframework.batch.core.configuration.annotation.EnableBatchProcessing",
			"org.springframework.batch.core.Step",
			"org.springframework.batch.core.StepExecution",
			"org.springframework.batch.core.StepContribution",
			"org.springframework.batch.core.Job",
			"org.springframework.batch.core.JobExecution",
			"org.springframework.batch.core.JobParameter",
			"org.springframework.batch.core.JobParameters",
			"org.springframework.batch.core.launch.JobLauncher",
			"org.springframework.batch.core.converter.JobParametersConverter",
			"org.springframework.batch.core.converter.DefaultJobParametersConverter");
}
 

import org.codehaus.groovy.control.customizers.ImportCustomizer; //导入依赖的package包/类
@Override
public void call(SourceUnit source, GeneratorContext context, ClassNode classNode)
		throws CompilationFailedException {

	ImportCustomizer importCustomizer = new SmartImportCustomizer(source, context,
			classNode);
	ClassNode mainClassNode = MainClass.get(source.getAST().getClasses());

	// Additional auto configuration
	for (CompilerAutoConfiguration autoConfiguration : GroovyCompiler.this.compilerAutoConfigurations) {
		if (autoConfiguration.matches(classNode)) {
			if (GroovyCompiler.this.configuration.isGuessImports()) {
				autoConfiguration.applyImports(importCustomizer);
				importCustomizer.call(source, context, classNode);
			}
			if (classNode.equals(mainClassNode)) {
				autoConfiguration.applyToMainClass(GroovyCompiler.this.loader,
						GroovyCompiler.this.configuration, context, source,
						classNode);
			}
			autoConfiguration.apply(GroovyCompiler.this.loader,
					GroovyCompiler.this.configuration, context, source,
					classNode);
		}
	}
	importCustomizer.call(source, context, classNode);
}
 

import org.codehaus.groovy.control.customizers.ImportCustomizer; //导入依赖的package包/类
private static void applyConfigurationScript(File configScript, CompilerConfiguration configuration) {
  Binding binding = new Binding();
  binding.setVariable("configuration", configuration);

  CompilerConfiguration configuratorConfig = new CompilerConfiguration();
  ImportCustomizer customizer = new ImportCustomizer();
  customizer.addStaticStars("org.codehaus.groovy.control.customizers.builder.CompilerCustomizationBuilder");
  configuratorConfig.addCompilationCustomizers(customizer);

  try {
    new GroovyShell(binding, configuratorConfig).evaluate(configScript);
  }
  catch (Exception e) {
    e.printStackTrace();
  }
}
 

import org.codehaus.groovy.control.customizers.ImportCustomizer; //导入依赖的package包/类
private void configureCompiler() {
    if (scriptBaseClass!=null) {
        configuration.setScriptBaseClass(scriptBaseClass);
    }
    if (indy) {
        configuration.getOptimizationOptions().put("indy", Boolean.TRUE);
        configuration.getOptimizationOptions().put("int", Boolean.FALSE);
    }
    if (configscript!=null) {
        Binding binding = new Binding();
        binding.setVariable("configuration", configuration);

        CompilerConfiguration configuratorConfig = new CompilerConfiguration();
        ImportCustomizer customizer = new ImportCustomizer();
        customizer.addStaticStars("org.codehaus.groovy.control.customizers.builder.CompilerCustomizationBuilder");
        configuratorConfig.addCompilationCustomizers(customizer);

        GroovyShell shell = new GroovyShell(binding, configuratorConfig);
        File confSrc = new File(configscript);
        try {
            shell.evaluate(confSrc);
        } catch (IOException e) {
            throw new BuildException("Unable to configure compiler using configuration file: "+confSrc, e);
        }
    }
}
 

import org.codehaus.groovy.control.customizers.ImportCustomizer; //导入依赖的package包/类
private void addImport(final ImportCustomizer customizer, final Object value) {
    if (value==null) return;
    if (value instanceof Collection) {
        for (Object e : (Collection)value) {
            addImport(customizer, e);
        }
    } else if (value instanceof String) {
        customizer.addImports((String)value);
    } else if (value instanceof Class) {
        customizer.addImports(((Class) value).getName());
    } else if (value instanceof GString) {
        customizer.addImports(value.toString());
    } else {
        throw new RuntimeException("Unsupported import value type ["+value+"]");
    }
}
 

import org.codehaus.groovy.control.customizers.ImportCustomizer; //导入依赖的package包/类
public static GroovyFieldDelegate createFromScript(String script, ClassLoader classLoader) {
    CompilerConfiguration config = new CompilerConfiguration();

    SecureASTCustomizer secureAst = new SecureASTCustomizer();
    secureAst.setIndirectImportCheckEnabled(true);
    // TODO: Determine which classes should be accessible.
    secureAst.setImportsBlacklist(Arrays.asList("java.lang.Process"));
    secureAst.setReceiversClassesBlackList(Arrays.asList(String.class));

    ImportCustomizer imports = new ImportCustomizer();
    imports.addImport("Color", "com.dozingcatsoftware.vectorpinball.model.Color");

    config.addCompilationCustomizers(secureAst, imports);

    try (GroovyClassLoader gcl = new GroovyClassLoader(classLoader, config)) {
        @SuppressWarnings("unchecked")
        Class<? extends Script> groovyScriptClass = gcl.parseClass(script);
        return (new GroovyFieldDelegate()).initWithScript(groovyScriptClass.newInstance());
    }
    catch (IOException | InstantiationException | IllegalAccessException e) {
        throw new RuntimeException(e);
    }

}
 

import org.codehaus.groovy.control.customizers.ImportCustomizer; //导入依赖的package包/类
private GroovyShell getShell(Binding binding, GroovyInterceptor sandbox, GenericUserMessageEvent event) {
	binding.setVariable("eval", getEvalFunction(binding, sandbox, event));
	binding.setVariable("commands", new DynamicCommandHandler(this, event));
	CompilerConfiguration cc = new CompilerConfiguration();
	cc.addCompilationCustomizers(
			new SandboxTransformer(),
			new ASTTransformationCustomizer(ImmutableMap.of("value", TIMEOUT), TimedInterrupt.class),
			new ImportCustomizer()
				.addStarImports("java.lang.reflect")
				.addImports(HttpRequest.class.getName())
				.addImports(CommandCall.class.getName())
	);
	GroovyShell shell = new GroovyShell(manager.pluginClassLoader, binding, cc);
	sandbox.register();
	return shell;
}
 

import org.codehaus.groovy.control.customizers.ImportCustomizer; //导入依赖的package包/类
public static GroovyClassLoader newEvaluator(Imports imports, Classpath classpath, String outDir, ImportCustomizer icz,ClassLoader parent) {

    try {
      Class.forName("org.codehaus.groovy.control.customizers.ImportCustomizer");
    } catch (ClassNotFoundException e1) {
      String gjp = System.getenv(GROOVY_JAR_PATH);
      String errorMsg = null;
      if (gjp != null && !gjp.isEmpty()) {
        errorMsg = "Groovy libary not found, GROOVY_JAR_PATH = " + gjp;
      } else {
        errorMsg = "Default groovy libary not found. No GROOVY_JAR_PATH variable set.";
      }
      throw new GroovyNotFoundException(errorMsg);
    }

    icz = addImportsCustomizer(icz, imports);
    CompilerConfiguration config = new CompilerConfiguration().addCompilationCustomizers(icz);
    String acloader_cp = Joiner.on(File.pathSeparatorChar).join(classpath.getPathsAsStrings());
    config.setClasspath(acloader_cp);
    return new GroovyClassLoader(parent, config);
  }
 

import org.codehaus.groovy.control.customizers.ImportCustomizer; //导入依赖的package包/类
public GroovyConditionShell() {

        SecureASTCustomizer secureASTCustomizer = createSecureASTCustomizer();
        ImportCustomizer importCustomizer = createImportCustomizer();
        ASTTransformationCustomizer astTransformationCustomizer = createASTTransformationCustomizer();

        CompilerConfiguration compilerConfiguration = new CompilerConfiguration();
        compilerConfiguration.addCompilationCustomizers(secureASTCustomizer);
        compilerConfiguration.addCompilationCustomizers(importCustomizer);
        compilerConfiguration.addCompilationCustomizers(astTransformationCustomizer);

        this.shell = new GroovyShell(compilerConfiguration);
    }
 

import org.codehaus.groovy.control.customizers.ImportCustomizer; //导入依赖的package包/类
private static ImportCustomizer createImportCustomizer() {
    ImportCustomizer importCustomizer = new ImportCustomizer();
    importCustomizer.addImports(ResourceHandler.class.getCanonicalName());
    importCustomizer.addImports(SubjectHandler.class.getCanonicalName());
    importCustomizer.addImports(AbstractHandler.class.getCanonicalName());
    return importCustomizer;
}
 

import org.codehaus.groovy.control.customizers.ImportCustomizer; //导入依赖的package包/类
@PostConstruct
public void init() {
    ImportCustomizer importCustomizer = new ImportCustomizer();
    importCustomizer.addStarImports("net.dv8tion.jda.core.entities");

    configuration = new CompilerConfiguration();
    configuration.addCompilationCustomizers(importCustomizer);

    sharedData = new Binding();
    sharedData.setProperty("ctx", context);
    sharedData.setProperty("jda", discordService.getJda());
}
 

import org.codehaus.groovy.control.customizers.ImportCustomizer; //导入依赖的package包/类
private ConfigManager()
{
    CompilerConfiguration compilerConfiguration = new CompilerConfiguration();
    ImportCustomizer importCustomizer = new ImportCustomizer();
    importCustomizer.addStarImports("org.diorite.config", "org.diorite.config.serialization", "org.diorite", "org.diorite.config.exceptions");
    compilerConfiguration.addCompilationCustomizers(importCustomizer);
    GroovyClassLoader groovyClassLoader = new GroovyClassLoader(this.getClass().getClassLoader(), compilerConfiguration);
    this.groovy = new GroovyScriptEngineImpl(groovyClassLoader);
    DynamicClassLoader classLoader = DynamicClassLoader.injectAsSystemClassLoader();
    classLoader.addClassLoader(groovyClassLoader, 0);
    this.setImplementationProvider(GroovyImplementationProvider.getInstance());
}