Java ImportCustomizer.addStarImports方法代码示例

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包/类
@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());
}
 

import org.codehaus.groovy.control.customizers.ImportCustomizer; //导入方法依赖的package包/类
@Override
public void applyImports(ImportCustomizer imports) {
	imports.addImports("javax.annotation.PostConstruct",
			"javax.annotation.PreDestroy", "groovy.util.logging.Log",
			"org.springframework.stereotype.Controller",
			"org.springframework.stereotype.Service",
			"org.springframework.stereotype.Component",
			"org.springframework.beans.factory.annotation.Autowired",
			"org.springframework.beans.factory.annotation.Value",
			"org.springframework.context.annotation.Import",
			"org.springframework.context.annotation.ImportResource",
			"org.springframework.context.annotation.Profile",
			"org.springframework.context.annotation.Scope",
			"org.springframework.context.annotation.Configuration",
			"org.springframework.context.annotation.ComponentScan",
			"org.springframework.context.annotation.Bean",
			"org.springframework.context.ApplicationContext",
			"org.springframework.context.MessageSource",
			"org.springframework.core.annotation.Order",
			"org.springframework.core.io.ResourceLoader",
			"org.springframework.boot.ApplicationRunner",
			"org.springframework.boot.ApplicationArguments",
			"org.springframework.boot.CommandLineRunner",
			"org.springframework.boot.context.properties.ConfigurationProperties",
			"org.springframework.boot.context.properties.EnableConfigurationProperties",
			"org.springframework.boot.autoconfigure.EnableAutoConfiguration",
			"org.springframework.boot.context.properties.ConfigurationProperties",
			"org.springframework.boot.context.properties.EnableConfigurationProperties");
	imports.addStarImports("org.springframework.stereotype",
			"org.springframework.scheduling.annotation");
}
 

import org.codehaus.groovy.control.customizers.ImportCustomizer; //导入方法依赖的package包/类
@Override
public void applyImports(ImportCustomizer imports) throws CompilationFailedException {
	imports.addStarImports("org.springframework.amqp.rabbit.annotation",
			"org.springframework.amqp.rabbit.core",
			"org.springframework.amqp.rabbit.config",
			"org.springframework.amqp.rabbit.connection",
			"org.springframework.amqp.rabbit.listener",
			"org.springframework.amqp.rabbit.listener.adapter",
			"org.springframework.amqp.core");
}
 

import org.codehaus.groovy.control.customizers.ImportCustomizer; //导入方法依赖的package包/类
@Override
public void applyImports(ImportCustomizer imports) {
	imports.addImports("org.springframework.messaging.Message",
			"org.springframework.messaging.MessageChannel",
			"org.springframework.messaging.PollableChannel",
			"org.springframework.messaging.SubscribableChannel",
			"org.springframework.messaging.MessageHeaders",
			"org.springframework.integration.support.MessageBuilder",
			"org.springframework.integration.channel.DirectChannel",
			"org.springframework.integration.channel.QueueChannel",
			"org.springframework.integration.channel.ExecutorChannel",
			"org.springframework.integration.core.MessagingTemplate",
			"org.springframework.integration.config.EnableIntegration");
	imports.addStarImports("org.springframework.integration.annotation");
}
 

import org.codehaus.groovy.control.customizers.ImportCustomizer; //导入方法依赖的package包/类
@Override
public void applyImports(ImportCustomizer imports) {
	imports.addStarImports("org.springframework.web.bind.annotation",
			"org.springframework.web.servlet.config.annotation",
			"org.springframework.web.servlet", "org.springframework.http",
			"org.springframework.web.servlet.handler", "org.springframework.http",
			"org.springframework.ui", "groovy.text");
	imports.addStaticImport(GroovyTemplate.class.getName(), "template");
}
 

import org.codehaus.groovy.control.customizers.ImportCustomizer; //导入方法依赖的package包/类
@Override
public void applyImports(ImportCustomizer imports) throws CompilationFailedException {
	imports.addStarImports("javax.jms", "org.springframework.jms.annotation",
			"org.springframework.jms.config", "org.springframework.jms.core",
			"org.springframework.jms.listener",
			"org.springframework.jms.listener.adapter");
}
 

import org.codehaus.groovy.control.customizers.ImportCustomizer; //导入方法依赖的package包/类
@Override
public void applyImports(ImportCustomizer imports) {
	imports.addStarImports("org.springframework.transaction.annotation",
			"org.springframework.transaction.support");
	imports.addImports("org.springframework.transaction.PlatformTransactionManager",
			"org.springframework.transaction.support.AbstractPlatformTransactionManager");
}
 

import org.codehaus.groovy.control.customizers.ImportCustomizer; //导入方法依赖的package包/类
@Override
public void applyImports(ImportCustomizer imports) throws CompilationFailedException {
	imports.addImports(
			"org.springframework.boot.autoconfigure.security.oauth2.client.EnableOAuth2Sso");
	imports.addStarImports(
			"org.springframework.security.oauth2.config.annotation.web.configuration",
			"org.springframework.security.access.prepost");
}
 

import org.codehaus.groovy.control.customizers.ImportCustomizer; //导入方法依赖的package包/类
protected static void processImports(final ImportCustomizer ic, final Set<String> imports) {
    for (final String imp : imports) {
        if (imp.endsWith(DOT_STAR)) {
            ic.addStarImports(imp.replace(DOT_STAR, EMPTY_STRING));
        } else {
            ic.addImports(imp);
        }
    }
}
 

import org.codehaus.groovy.control.customizers.ImportCustomizer; //导入方法依赖的package包/类
private GroovyCodeBlockCompiler() {

        CompilerConfiguration conf = new CompilerConfiguration(CompilerConfiguration.DEFAULT);

        ImportCustomizer imports = new ImportCustomizer();
        imports.addStarImports("org.voltdb");
        imports.addImports(
                "org.voltdb.groovy.TableBuilder",
                "org.voltdb.groovy.Tuplerator",
                "org.voltdb.VoltProcedure.VoltAbortException"
                 );
        imports.addStaticStars("org.voltdb.VoltProcedure","org.voltdb.VoltType");

        conf.addCompilationCustomizers(imports);
        // conf.getOptimizationOptions().put("int", false);
        // conf.getOptimizationOptions().put("indy", true);
        conf.setScriptBaseClass(DelegatingScript.class.getName());

        File groovyOut = createGroovyOutDirectory();

        List<String> classPath = conf.getClasspath();
        classPath.add(groovyOut.getAbsolutePath());
        conf.setClasspathList(classPath);

        conf.setTargetDirectory(groovyOut);

        gcl = new GroovyClassLoader(Thread.currentThread().getContextClassLoader(), conf);
    }
 

import org.codehaus.groovy.control.customizers.ImportCustomizer; //导入方法依赖的package包/类
public static ImportCustomizer getImportCustomizer() {
    final ImportCustomizer ic = new DefaultImportCustomizerProvider().getImportCustomizer();
    for (final String imp : Imports.getImports()) {
        ic.addStarImports(imp.replace(DOT_STAR, EMPTY_STRING));
    }
    return ic;
}
 

import org.codehaus.groovy.control.customizers.ImportCustomizer; //导入方法依赖的package包/类
@Override
public void applyImports(ImportCustomizer imports) throws CompilationFailedException {
	this.integration.applyImports(imports);
	imports.addImports("org.springframework.boot.groovy.cloud.EnableBinding");
	imports.addImport("IntegrationMessageSource",
			"org.springframework.integration.core.MessageSource");
	imports.addStarImports("org.springframework.cloud.stream.annotation",
			"org.springframework.cloud.stream.messaging");
}
 

import org.codehaus.groovy.control.customizers.ImportCustomizer; //导入方法依赖的package包/类
/**
 * Get default compiler configuration for {@link GroovyShell}.
 */
public CompilerConfiguration getCompilerConfiguration() {
    CompilerConfiguration cc = new CompilerConfiguration();
    ImportCustomizer imports = new ImportCustomizer();
    for (String starImport: STAR_IMPORTS) {
        imports.addStarImports(starImport);
    }
    for (String staticStar: STATIC_IMPORTS) {
        imports.addStaticStars(staticStar);
    }
    cc.addCompilationCustomizers(imports);
    return cc;
}