public final TemplateResolution resolveTemplate( final IEngineConfiguration configuration, final String ownerTemplate, final String template, final Map<String, Object> templateResolutionAttributes) { Validate.notNull(configuration, "Engine Configuration cannot be null"); // ownerTemplate CAN be null Validate.notNull(template, "Template Name cannot be null"); // templateResolutionAttributes CAN be null if (!computeResolvable(configuration, ownerTemplate, template, templateResolutionAttributes)) { return null; } final ITemplateResource templateResource = computeTemplateResource(configuration, ownerTemplate, template, templateResolutionAttributes); if (templateResource == null) { return null; } if (this.checkExistence && !templateResource.exists()) { // will only check if flag set to true return null; } return new TemplateResolution( templateResource, this.checkExistence, computeTemplateMode(configuration, ownerTemplate, template, templateResolutionAttributes), this.useDecoupledLogic, computeValidity(configuration, ownerTemplate, template, templateResolutionAttributes)); }
private static TemplateData buildTemplateData( final TemplateResolution templateResolution, final String template, final Set<String> templateSelectors, final TemplateMode templateMode, final boolean useCache) { final TemplateMode definitiveTemplateMode = (templateMode == null ? templateResolution.getTemplateMode() : templateMode); final ICacheEntryValidity definitiveCacheEntryValidity = (useCache? templateResolution.getValidity() : NonCacheableCacheEntryValidity.INSTANCE); return new TemplateData( template, templateSelectors, templateResolution.getTemplateResource(), definitiveTemplateMode, definitiveCacheEntryValidity); }
if (!templateResolution.isTemplateResourceExistenceVerified()) { final ITemplateResource resource = templateResolution.getTemplateResource(); if (resource == null || !resource.exists()) { this.configuration, ownerTemplate, template, cleanTemplateSelectors, templateData.getTemplateResource(), templateData.getTemplateMode(), templateResolution.getUseDecoupledLogic(), builderHandler); if (templateResolution.getValidity().isCacheable()) { this.templateCache.put(cacheKey, templateModel);
final String resourceName = templateResolution.getResourceName(); final IResourceResolver resourceResolver = templateResolution.getResourceResolver(); logger.debug("[THYMELEAF][{}] Template \"{}\" was correctly resolved as resource \"{}\" in mode {} with resource resolver \"{}\"", new Object[] {TemplateEngine.threadIndex(), templateName, resourceName, templateResolution.getTemplateMode(), resourceResolver.getName()}); final String templateMode = templateResolution.getTemplateMode(); final String characterEncoding = templateResolution.getCharacterEncoding(); Reader reader = null; if (!StringUtils.isEmptyOrWhitespace(characterEncoding)) { if (templateResolution.getValidity().isCacheable()) { this.templateCache.put(templateName, template); return template.createDuplicate();
if (templateResolution.getValidity().isCacheable() && this.templateCache != null) { this.configuration, null, template, templateSelectors, templateData.getTemplateResource(), engineContext.getTemplateMode(), templateResolution.getUseDecoupledLogic(), builderHandler); this.configuration, null, template, templateSelectors, templateData.getTemplateResource(), engineContext.getTemplateMode(), templateResolution.getUseDecoupledLogic(), processingHandlerChain);
if (TemplateModeUtils.isHtml(arguments.getTemplateResolution().getTemplateMode()) && ArrayUtils.contains(Standards.HTML_CONDITIONAL_FIXED_VALUE_ATTR_NAMES, newAttributeName)) {
@Override protected ITemplateResource computeTemplateResource(final IEngineConfiguration configuration, final String ownerTemplate, final String template, final String resourceName, final String characterEncoding, final Map<String, Object> templateResolutionAttributes) { return this.resolvers .stream() .map(r -> r.resolveTemplate(configuration, ownerTemplate, template, templateResolutionAttributes)) .filter(resource -> resource != null && resource.isTemplateResourceExistenceVerified()) .findFirst() .map(TemplateResolution::getTemplateResource) .orElse(null); } }
public boolean checkIsValueStillValid( final String key, final Template value, final long entryCreationTimestamp) { return value.getTemplateResolution().getValidity().isCacheStillValid(); }
private boolean checkResource(String path) { TemplateResolution resolution = templateResolver.resolveTemplate(configuration, null, path, null); ITemplateResource resource = resolution.getTemplateResource(); return resource.exists(); }
private static Properties loadMessagesForTemplate( final Arguments arguments, final Properties defaultMessages) { Validate.notNull(arguments, "Arguments cannot be null"); Validate.notNull(arguments.getContext().getLocale(), "Locale in context cannot be null"); final String resourceName = arguments.getTemplateResolution().getResourceName(); final IResourceResolver resourceResolver = arguments.getTemplateResolution().getResourceResolver(); final Locale locale = arguments.getContext().getLocale(); final String templateBaseName = getTemplateFileNameBase(resourceName); return MessageResolutionUtils.loadCombinedMessagesFilesFromBaseName( arguments, resourceResolver, templateBaseName, locale, defaultMessages); }
/** * <p> * Returns the name of the template currently being processed. * </p> * * @return the template name */ public String getTemplateName() { return this.templateResolution.getTemplateName(); }
this.configuration, null, template, templateSelectors, templateData.getTemplateResource(), engineContext.getTemplateMode(), templateResolution.getUseDecoupledLogic(), builderHandler); final TemplateModel templateModel = builderHandler.getModel(); if (templateResolution.getValidity().isCacheable() && this.templateCache != null) {
final String templateMode = templateResolution.getTemplateMode();
final String templateName = arguments.getTemplateResolution().getTemplateName(); final String cacheKey = TEMPLATE_CACHE_PREFIX + templateName + '_' + locale.toString();
return new TemplateResolution( templateResource, true, // Test template resolver always verifies the existence of resources (might be improvable)
Validate.notNull(fragment, "Fragment cannot be null"); final String templateMode = arguments.getTemplateResolution().getTemplateMode(); final String cacheKey = computeFragmentCacheKey(templateMode, fragment);
return new TemplateResolution( templateResource, true, // Test template resolver always verifies the existence of resources (might be improvable)
public TemplateResolution resolveTemplate(final TemplateProcessingParameters templateProcessingParameters) { checkInitialized(); Validate.notNull(templateProcessingParameters, "Template Processing Parameters cannot be null"); if (!computeResolvable(templateProcessingParameters)) { return null; } return new TemplateResolution( templateProcessingParameters.getTemplateName(), computeResourceName(templateProcessingParameters), computeResourceResolver(templateProcessingParameters), computeCharacterEncoding(templateProcessingParameters), computeTemplateMode(templateProcessingParameters), computeValidity(templateProcessingParameters)); }
new TemplateResolution(templateName, "resource:"+templateName, new ClassLoaderResourceResolver(), "UTF-8", templateMode, new AlwaysValidTemplateResolutionValidity());