Java GStringTemplateEngine类代码示例

import groovy.text.GStringTemplateEngine; //导入依赖的package包/类
public GroovyDocTemplateEngine(GroovyDocTool tool, ResourceManager resourceManager,
                               String[] docTemplates,
                               String[] packageTemplates,
                               String[] classTemplates,
                               Properties properties) {
    this.resourceManager = resourceManager;
    this.properties = properties;
    this.docTemplatePaths = Arrays.asList(docTemplates);
    this.packageTemplatePaths = Arrays.asList(packageTemplates);
    this.classTemplatePaths = Arrays.asList(classTemplates);
    this.docTemplates = new LinkedHashMap<String, Template>();
    this.packageTemplates = new LinkedHashMap<String, Template>();
    this.classTemplates = new LinkedHashMap<String, Template>();
    engine = new GStringTemplateEngine();

}
 

import groovy.text.GStringTemplateEngine; //导入依赖的package包/类
public static String generateScript(GroovyMap groovyMap, String templateName) throws GFacException {
    URL templateUrl = ApplicationSettings.loadFile(templateName);
    if (templateUrl == null) {
        String error = "Template file '" + templateName + "' not found";
        throw new GFacException(error);
    }
    File template = new File(templateUrl.getPath());
    TemplateEngine engine = new GStringTemplateEngine();
    Writable make;
    try {
        make = engine.createTemplate(template).make(groovyMap);
    } catch (Exception e) {
        throw new GFacException("Error while generating script using groovy map", e);
    }
    return make.toString();
}
 

import groovy.text.GStringTemplateEngine; //导入依赖的package包/类
protected String applySearchFormat(String searchString, String format) {
    if (StringUtils.isNotEmpty(format)) {
        GStringTemplateEngine engine = new GStringTemplateEngine();
        StringWriter writer = new StringWriter();
        try {
            engine.createTemplate(format).make(ParamsMap.of("searchString", searchString)).writeTo(writer);
            return writer.toString();
        } catch (ClassNotFoundException | IOException e) {
            throw new IllegalStateException(e);
        }
    }
    return searchString;
}
 

import groovy.text.GStringTemplateEngine; //导入依赖的package包/类
public GroovyTemplateGenerator(final String template) {
    try {
        this.template = new GStringTemplateEngine().createTemplate(template);
    } catch (ClassNotFoundException | IOException e) {
        throw new BootException(e);
    }
    this.templateText = template;
}
 

import groovy.text.GStringTemplateEngine; //导入依赖的package包/类
static String parseCommands(String value, GroovyMap bindMap) {
    TemplateEngine templateEngine = new GStringTemplateEngine();
    try {
        return templateEngine.createTemplate(value).make(bindMap).toString();
    } catch (ClassNotFoundException | IOException e) {
        throw new IllegalArgumentException("Error while parsing command " + value
                + " , Invalid command or incomplete bind map");
    }
}
 

import groovy.text.GStringTemplateEngine; //导入依赖的package包/类
public Map getConfig() {
    GStringTemplateEngine engine = new GStringTemplateEngine();
    String yaml = null;

    try {
        yaml = engine.createTemplate(config).make(new MissingPropForwardingMap(envVars)).toString();
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
    return (Map) new Yaml().load(yaml);
}
 

import groovy.text.GStringTemplateEngine; //导入依赖的package包/类
public static String template(String name, Map<String, ?> model)
		throws IOException, CompilationFailedException, ClassNotFoundException {
	return template(new GStringTemplateEngine(), name, model);
}
 

import groovy.text.GStringTemplateEngine; //导入依赖的package包/类
@Bean
public TemplateEngine groovyTemplateEngine() {
	return new GStringTemplateEngine();
}
 

import groovy.text.GStringTemplateEngine; //导入依赖的package包/类
@Override
public void initialize(VisitorContext context, Object rootNode) {
	this.context = context;
	engine = new GStringTemplateEngine(context.getClassLoader());
	super.initialize(context, rootNode);
}
 

import groovy.text.GStringTemplateEngine; //导入依赖的package包/类
public GroovyTemplateTestResource(TestResource<String> template, Map<String, String> variables) {
    this(new GStringTemplateEngine(), template, variables);
}
 

import groovy.text.GStringTemplateEngine; //导入依赖的package包/类
/**
 * A way of paramaterizing resources so that values are updated according to Groovy GStrings
 *
 * @param template   A template of the string resource containing GString variables for substitution
 * @param dataSource A list of name=value pairs that will be used for var substitution. Each entry in the
 *                   list will result in another resource being returned
 */
default GroovyTemplateTestResource[] groovy(TestResource<String> template, List<Map<String, String>> dataSource) {
    return groovy(template, dataSource, GStringTemplateEngine.class);
}