import groovy.text.markup.MarkupTemplateEngine; //导入依赖的package包/类
/**
 * Resolve a template from the given template path.
 * <p>The default implementation uses the Locale associated with the current request,
 * as obtained through {@link org.springframework.context.i18n.LocaleContextHolder LocaleContextHolder},
 * to find the template file. Effectively the locale configured at the engine level is ignored.
 * @see LocaleContextHolder
 * @see #setLocale
 */
protected URL resolveTemplate(ClassLoader classLoader, String templatePath) throws IOException {
	MarkupTemplateEngine.TemplateResource resource = MarkupTemplateEngine.TemplateResource.parse(templatePath);
	Locale locale = LocaleContextHolder.getLocale();
	URL url = classLoader.getResource(resource.withLocale(locale.toString().replace("-", "_")).toString());
	if (url == null) {
		url = classLoader.getResource(resource.withLocale(locale.getLanguage()).toString());
	}
	if (url == null) {
		url = classLoader.getResource(resource.withLocale(null).toString());
	}
	if (url == null) {
		throw new IOException("Unable to load template:" + templatePath);
	}
	return url;
}
 

import groovy.text.markup.MarkupTemplateEngine; //导入依赖的package包/类
/**
 * MarkupTemplateEngine could be loaded from groovy-templates or groovy-all.
 * Unfortunately it's quite common for people to use groovy-all and not actually
 * need templating support. This method check attempts to check the source jar so
 * that we can skip the {@code /template} folder check for such cases.
 * @return true if the groovy-all jar is used
 */
private boolean isUsingGroovyAllJar() {
	try {
		ProtectionDomain domain = MarkupTemplateEngine.class
				.getProtectionDomain();
		CodeSource codeSource = domain.getCodeSource();
		if (codeSource != null
				&& codeSource.getLocation().toString().contains("-all")) {
			return true;
		}
		return false;
	}
	catch (Exception ex) {
		return false;
	}
}
 

import groovy.text.markup.MarkupTemplateEngine; //导入依赖的package包/类
@Override
public URL resolveTemplate(final String templatePath) throws IOException {
	MarkupTemplateEngine.TemplateResource templateResource = MarkupTemplateEngine.TemplateResource
			.parse(templatePath);
	URL resource = this.templateClassLoader.getResource(templateResource
			.withLocale(LocaleContextHolder.getLocale().toString().replace("-", "_"))
			.toString());
	if (resource == null) {
		// no resource found with the default locale, try without any locale
		resource = this.templateClassLoader
				.getResource(templateResource.withLocale(null).toString());
	}
	if (resource == null) {
		throw new IOException("Unable to load template:" + templatePath);
	}
	return resource;
}
 

import groovy.text.markup.MarkupTemplateEngine; //导入依赖的package包/类
/**
 * Autodetect a MarkupTemplateEngine via the ApplicationContext.
 * Called if a MarkupTemplateEngine has not been manually configured.
 */
protected MarkupTemplateEngine autodetectMarkupTemplateEngine() throws BeansException {
	try {
		return BeanFactoryUtils.beanOfTypeIncludingAncestors(getApplicationContext(),
				GroovyMarkupConfig.class, true, false).getTemplateEngine();
	}
	catch (NoSuchBeanDefinitionException ex) {
		throw new ApplicationContextException("Expected a single GroovyMarkupConfig bean in the current " +
				"Servlet web application context or the parent root context: GroovyMarkupConfigurer is " +
				"the usual implementation. This bean may have any name.", ex);
	}
}
 

import groovy.text.markup.MarkupTemplateEngine; //导入依赖的package包/类
protected MarkupTemplateEngine createTemplateEngine() throws IOException {
	if (this.templateEngine == null) {
		ClassLoader templateClassLoader = createTemplateClassLoader();
		this.templateEngine = new MarkupTemplateEngine(templateClassLoader, this, new LocaleTemplateResolver());
	}
	return this.templateEngine;
}
 

import groovy.text.markup.MarkupTemplateEngine; //导入依赖的package包/类
@Test
public void defaultTemplateEngine() throws Exception {
	this.configurer.setApplicationContext(this.applicationContext);
	this.configurer.afterPropertiesSet();

	TemplateEngine engine = this.configurer.getTemplateEngine();
	assertNotNull(engine);
	assertEquals(MarkupTemplateEngine.class, engine.getClass());

	MarkupTemplateEngine markupEngine = (MarkupTemplateEngine) engine;
	TemplateConfiguration configuration = markupEngine.getTemplateConfiguration();
	assertNotNull(configuration);
	assertEquals(GroovyMarkupConfigurer.class, configuration.getClass());
}
 

import groovy.text.markup.MarkupTemplateEngine; //导入依赖的package包/类
@Test
public void customTemplateConfiguration() throws Exception {
	this.configurer.setApplicationContext(this.applicationContext);
	this.configurer.setCacheTemplates(false);
	this.configurer.afterPropertiesSet();

	TemplateEngine engine = this.configurer.getTemplateEngine();
	assertNotNull(engine);
	assertEquals(MarkupTemplateEngine.class, engine.getClass());

	MarkupTemplateEngine markupEngine = (MarkupTemplateEngine) engine;
	TemplateConfiguration configuration = markupEngine.getTemplateConfiguration();
	assertNotNull(configuration);
	assertFalse(configuration.isCacheTemplates());
}
 

import groovy.text.markup.MarkupTemplateEngine; //导入依赖的package包/类
public GroovyMarkupConfiguration(ApplicationContext applicationContext,
		GroovyTemplateProperties properties,
		ObjectProvider<MarkupTemplateEngine> templateEngineProvider) {
	this.applicationContext = applicationContext;
	this.properties = properties;
	this.templateEngine = templateEngineProvider.getIfAvailable();
}
 

import groovy.text.markup.MarkupTemplateEngine; //导入依赖的package包/类
@Test
public void renderTemplate() throws Exception {
	registerAndRefreshContext();
	GroovyMarkupConfig config = this.context.getBean(GroovyMarkupConfig.class);
	MarkupTemplateEngine engine = config.getTemplateEngine();
	Writer writer = new StringWriter();
	engine.createTemplate(new ClassPathResource("templates/message.tpl").getFile())
			.make(new HashMap<String, Object>(
					Collections.singletonMap("greeting", "Hello World")))
			.writeTo(writer);
	assertThat(writer.toString()).contains("Hello World");
}
 

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

import groovy.text.markup.MarkupTemplateEngine; //导入依赖的package包/类
@Test
public void renderTemplate() throws Exception {
	registerAndRefreshContext();
	GroovyMarkupConfig config = this.context.getBean(GroovyMarkupConfig.class);
	MarkupTemplateEngine engine = config.getTemplateEngine();
	Writer writer = new StringWriter();
	engine.createTemplate(new ClassPathResource("templates/message.tpl").getFile())
			.make(new HashMap<String, Object>(
					Collections.singletonMap("greeting", "Hello World")))
			.writeTo(writer);
	assertThat(writer.toString(), containsString("Hello World"));
}
 

import groovy.text.markup.MarkupTemplateEngine; //导入依赖的package包/类
public MarkupTemplateEngine getEngine(Locale locale) {
    String localeString = locale.toString();
    MarkupTemplateEngine engine = engines.get(localeString);
    if (engine!=null) {
        return engine;
    }
    return lazyLoadEngine(locale);
}
 

import groovy.text.markup.MarkupTemplateEngine; //导入依赖的package包/类
@Override
public void init(Application application) {
    super.init(application);

    PippoSettings pippoSettings = getPippoSettings();

    TemplateConfiguration configuration = new TemplateConfiguration();
    configuration.setBaseTemplateClass(PippoGroovyTemplate.class);
    configuration.setAutoEscape(true);

    if (pippoSettings.isDev()) {
        // Do not cache templates in dev mode
        configuration.setCacheTemplates(false);
    } else {
        configuration.setAutoIndent(true);
        configuration.setAutoNewLine(true);
        configuration.setAutoIndentString("  ");
    }

    String pathPrefix = getTemplatePathPrefix();
    pathPrefix = StringUtils.removeStart(pathPrefix, "/");
    pathPrefix = StringUtils.removeEnd(pathPrefix, "/");

    GroovyTemplateResolver cachingResolver = new GroovyTemplateResolver(pathPrefix);

    ClassLoader classLoader = getClass().getClassLoader();

    // allow custom initialization
    init(application, configuration);

    engine = new MarkupTemplateEngine(classLoader, configuration, cachingResolver);
}
 

import groovy.text.markup.MarkupTemplateEngine; //导入依赖的package包/类
public PippoGroovyTemplate(final MarkupTemplateEngine templateEngine, final Map model,
        final Map<String, String> modelTypes, final TemplateConfiguration configuration) {
    super(templateEngine, model, modelTypes, configuration);

    this.modelTypes = modelTypes;
    this.engine = templateEngine;
    this.webjarsPatternRef = new AtomicReference<>();
    this.publicPatternRef = new AtomicReference<>();
}
 

import groovy.text.markup.MarkupTemplateEngine; //导入依赖的package包/类
private void initializeTemplateEngine() {
    templateEngine = new MarkupTemplateEngine(MarkupTemplateEngine.class.getClassLoader(),templatesPath,templateConfiguration);
}
 

import groovy.text.markup.MarkupTemplateEngine; //导入依赖的package包/类
public MarkupTemplateEngine getTemplateEngine() {
	return templateEngine;
}
 

import groovy.text.markup.MarkupTemplateEngine; //导入依赖的package包/类
public CustomBaseTemplate(
        final MarkupTemplateEngine templateEngine,
        final Map model,
        final Map modelTypes, final TemplateConfiguration configuration) {
    super(templateEngine, model, modelTypes, configuration);
}
 

import groovy.text.markup.MarkupTemplateEngine; //导入依赖的package包/类
private String createTemplatePath(final String viewName, final Locale locale) {
    MarkupTemplateEngine.TemplateResource resource = MarkupTemplateEngine.TemplateResource.parse(viewName);
    resource.withLocale(locale.toString().replace("-", "_"));
    return resource.toString();
}
 

import groovy.text.markup.MarkupTemplateEngine; //导入依赖的package包/类
/**
 * Set the MarkupTemplateEngine to use in this view.
 * <p>If not set, the engine is auto-detected by looking up up a single
 * {@link GroovyMarkupConfig} bean in the web application context and using
 * it to obtain the configured {@code MarkupTemplateEngine} instance.
 * @see GroovyMarkupConfig
 */
public void setTemplateEngine(MarkupTemplateEngine engine) {
	this.engine = engine;
}
 

import groovy.text.markup.MarkupTemplateEngine; //导入依赖的package包/类
/**
 * Return the Groovy {@link MarkupTemplateEngine} for the current
 * web application context. May be unique to one servlet, or shared
 * in the root context.
 * @return the Groovy MarkupTemplateEngine engine
 */
MarkupTemplateEngine getTemplateEngine();