Java SimpleTemplateEngine.createTemplate方法代码示例

import groovy.text.SimpleTemplateEngine; //导入方法依赖的package包/类
@Override
public void generate() {
    try {
        target.getParentFile().mkdirs();
        SimpleTemplateEngine templateEngine = new SimpleTemplateEngine();
        String templateText = Resources.asCharSource(templateURL, CharsetToolkit.getDefaultSystemCharset()).read();
        Template template = templateEngine.createTemplate(templateText);
        Writer writer = Files.asCharSink(target, Charsets.UTF_8).openStream();
        try {
            template.make(bindings).writeTo(writer);
        } finally {
            writer.close();
        }
    } catch (Exception ex) {
        throw new GradleException("Could not generate file " + target + ".", ex);
    }
}
 

import groovy.text.SimpleTemplateEngine; //导入方法依赖的package包/类
protected Template getTemplate(SimpleTemplateEngine templateEngine, String templateString) {
    Template bodyTemplate;
    try {
        bodyTemplate = templateEngine.createTemplate(templateString);
    } catch (Exception e) {
        throw new RuntimeException("Unable to compile Groovy template", e);
    }
    return bodyTemplate;
}
 

import groovy.text.SimpleTemplateEngine; //导入方法依赖的package包/类
public static String generateModuleCodeFromTemplate(String moduleName, String codeTemplate) {
    try {
        Map bindings = new HashMap();
        bindings.put("moduleName", moduleName);
        SimpleTemplateEngine simpleTemplateEngine = new SimpleTemplateEngine();
        Template template = simpleTemplateEngine.createTemplate(codeTemplate);
        Writable writable = template.make(bindings);
        String finalScript = writable.toString();
        return finalScript;
    } catch (Exception ex) {
        logger.log(Level.SEVERE, ex.getMessage(), ex);
    }
    return null;
}
 

import groovy.text.SimpleTemplateEngine; //导入方法依赖的package包/类
public static String fillTemplate(String templateString, Map bindings) throws RuntimeException {
    try {
        SimpleTemplateEngine simpleTemplateEngine = new SimpleTemplateEngine();
        Template template = simpleTemplateEngine.createTemplate(templateString);
        Writable writable = template.make(bindings);
        String finalScript = writable.toString();
        return finalScript;
    } catch (CompilationFailedException | ClassNotFoundException | IOException ex) {
        ex.printStackTrace();
        throw new RuntimeException(ex.getMessage());
    }
}
 

import groovy.text.SimpleTemplateEngine; //导入方法依赖的package包/类
public void execCliModule(ApplicationArgs args) throws Exception {
	if (args.getParamExist("-githistory")) {
		IGitInfo git = GitInfo.getFromRoot();
		
		String from = args.getSimpleParamValue("-githistory");
		if (from == null) {
			from = git.getLastTag();
			System.out.println(" == Get history from tag " + from + " ==");
		}
		
		GithubIssuesList issues_list = new GithubIssuesList();
		
		List<GithubIssue> current_issues = git.getRevisionsFrom(from).stream().map(r -> {
			return r.extractIssueIdFromCommitMessage();
		}).flatMap(a -> {
			return a.stream();
		}).distinct().map(issueid -> {
			return issues_list.getById(issueid);
		}).collect(Collectors.toList());
		issues_list.save();
		
		if (current_issues.isEmpty()) {
			return;
		}
		
		SimpleTemplateEngine template_engine = new SimpleTemplateEngine();
		template_engine.setVerbose(false);
		Template template = template_engine.createTemplate(new File(MyDMAM.APP_ROOT_PLAY_CONF_DIRECTORY.getAbsolutePath() + File.separator + "tools" + File.separator + "git-history-export.groovy"));
		HashMap<String, Object> vars = new HashMap<>();
		TemplateWriter tw = new TemplateWriter(System.out);
		
		Consumer<GithubIssue> process_template = issue -> {
			vars.put("issue", issue);
			try {
				template.make(vars).writeTo(tw);
			} catch (IOException e) {
				throw new RuntimeException("Can't make template", e);
			}
		};
		
		Predicate<GithubIssue> all_not_bug = issue -> {
			return issue.isBug() == false;
		};
		
		current_issues.stream().filter(all_not_bug).forEach(process_template);
		
		Predicate<GithubIssue> all_bugs = issue -> {
			return issue.isBug();
		};
		
		if (current_issues.stream().anyMatch(all_bugs)) {
			System.out.println("");
			System.out.println("");
			System.out.println("Bugs");
			current_issues.stream().filter(all_bugs).forEach(process_template);
			System.out.println("");
		}
		
		return;
	}
	
	showFullCliModuleHelp();
}