Java Template.execute方法代码示例

import com.samskivert.mustache.Template; //导入方法依赖的package包/类
@Override
protected Mono<Void> renderInternal(Map<String, Object> model, MediaType contentType,
                                    ServerWebExchange exchange) {
    Resource resource = resolveResource();
    if (resource == null) {
        return Mono.error(new IllegalStateException(
                "Could not find Mustache template with URL [" + getUrl() + "]"));
    }
    DataBuffer dataBuffer = exchange.getResponse().bufferFactory().allocateBuffer();
    try (Reader reader = getReader(resource)) {
        Template template = this.compiler.compile(reader);
        Charset charset = getCharset(contentType).orElse(getDefaultCharset());
        try (Writer writer = new OutputStreamWriter(dataBuffer.asOutputStream(),
                charset)) {
            template.execute(model, writer);
            writer.flush();
        }
    }
    catch (Exception ex) {
        DataBufferUtils.release(dataBuffer);
        return Mono.error(ex);
    }
    return exchange.getResponse().writeWith(Flux.just(dataBuffer));
}
 

import com.samskivert.mustache.Template; //导入方法依赖的package包/类
@Test
@SuppressWarnings("unchecked")
public void testMustasche() throws IOException {
	Yaml yaml = new Yaml();
	Map model = (Map) yaml.load(valuesResource.getInputStream());
	String templateAsString = StreamUtils.copyToString(nestedMapResource.getInputStream(),
			Charset.defaultCharset());
	Template mustacheTemplate = Mustache.compiler().compile(templateAsString);
	String resolvedYml = mustacheTemplate.execute(model);
	Map map = (Map) yaml.load(resolvedYml);

	logger.info("Resolved yml = " + resolvedYml);
	assertThat(map).containsKeys("apiVersion", "deployment");
	Map deploymentMap = (Map) map.get("deployment");
	assertThat(deploymentMap).contains(entry("name", "time"))
			.contains(entry("count", 10));
	Map applicationProperties = (Map) deploymentMap.get("applicationProperties");
	assertThat(applicationProperties).contains(entry("log.level", "DEBUG"), entry("server.port", 8089));
	Map deploymentProperties = (Map) deploymentMap.get("deploymentProperties");
	assertThat(deploymentProperties).contains(entry("app.time.producer.partitionKeyExpression", "payload"),
			entry("app.log.spring.cloud.stream.bindings.input.consumer.maxAttempts", 5));
}
 

import com.samskivert.mustache.Template; //导入方法依赖的package包/类
@RequestMapping(value = "/analytics_auth.js", method = RequestMethod.GET, produces = "application/javascript")
public @ResponseBody
ResponseEntity<String> getAnalyticsCodeForAuthUser(@AuthenticationPrincipal Client client) {

    Map<String, Object> model = new HashMap<>();
    model.put("trackingId", trackingId);
    if(client != null) {
        model.put("clientId", client.getClientId());
        model.put("unitId", client.getUnitId());
    }

    Template template = templateLoader.loadTemplate("analytics.mustache");
    String requestBody = template.execute(model);

    return new ResponseEntity<>(requestBody,  new HttpHeaders(), HttpStatus.OK);
}
 

import com.samskivert.mustache.Template; //导入方法依赖的package包/类
@RequestMapping(value = "/calendar.ics", method = RequestMethod.GET, produces = "text/calendar")
public @ResponseBody
ResponseEntity<String> getCalendarIcsFile(@AuthenticationPrincipal Client client) {
    final AppointmentDetails appointmentDetails = appointmentDetailsService.getExpectedAppointmentForClientForNextYear(client);

    Map<String, Object> model = new HashMap<>();
    model.put("id", UUID.randomUUID().toString());
    model.put("timeZone", appointmentDetails.getUnitTimeZoneIANA());

    DateTimeFormatter calendarDateNoZoneFormat = DateTimeFormatter.ofPattern("yyyyMMdd'T'HHmmss");
    model.put("startTime", appointmentDetails.getAppointmentDate().format(calendarDateNoZoneFormat));
    model.put("endTime", appointmentDetails.getAppointmentDate().plusHours(2L).format(calendarDateNoZoneFormat));
    model.put("location", appointmentDetails.getUnitAddress());

    Template template = templateLoader.loadTemplate("calendar_ics.mustache");
    String requestBody = template.execute(model);

    HttpHeaders responseHeaders = new HttpHeaders();
    responseHeaders.add("content-disposition", "attachment; filename=appointment.ics");
    responseHeaders.add("Content-Type","text/calendar");

    return new ResponseEntity<>(requestBody, responseHeaders,  HttpStatus.OK);
}
 

import com.samskivert.mustache.Template; //导入方法依赖的package包/类
private ResponseWrapper sendRequestInternal(Template template, Map<String, String> messageParams, String serviceAddress, String messageId) {
    ApiSession apiSession = apiSessionService.createSession();

    try {
        messageParams.put("apiSessionId", apiSession.getApiSessionId());
        messageParams.put("currentUserId", apiSession.getUserId());
        messageParams.put("serviceAddress", serviceAddress);
        messageParams.put("messageUUID", messageId);
        String requestBody = template.execute(messageParams);
        return httpClient.post(serviceAddress, requestBody, messageId);
    } finally {
        if (apiSession != null) {
            apiSessionService.closeSession(apiSession.getApiSessionId());
        }
    }
}
 

import com.samskivert.mustache.Template; //导入方法依赖的package包/类
public void logout(String apiSessionId) {
    Resource resource = resourceLoader.getResource("classpath:request_templates/" + SIGN_OUT_TEMPLATE_PATH);
    InputStream inputStream = null;
    try {
        inputStream = resource.getInputStream();
    } catch (IOException e) {
        throw new RuntimeException("Problem reading request template: " + SIGN_OUT_TEMPLATE_PATH, e);
    }
    InputStreamReader inputStreamReader = new InputStreamReader(inputStream, StandardCharsets.UTF_8);
    Template tmpl = Mustache.compiler().compile(inputStreamReader);

    Map<String, String> messageParams = new HashMap<>();
    messageParams.put("apiSessionId", apiSessionId);
    String messageId = UUID.randomUUID().toString();
    messageParams.put("messageUUID", messageId);
    messageParams.put("serviceAddress", serviceAddressUser);
    String messageBody = tmpl.execute(messageParams);

    httpClient.post(serviceAddressUser, messageBody, messageId);
}
 

import com.samskivert.mustache.Template; //导入方法依赖的package包/类
/**
 * Gather fields that are referenced in the mustache template.
 *
 * @return the collection
 */
private Collection<String> gatherReferencedFields() {
	Collection<String> fields = new ArrayList<>();
	Collector collector = new DefaultCollector() {

		@Override
		public VariableFetcher createFetcher(Object ctx, String name) {
			fields.add(name);
			return super.createFetcher(ctx, name);
		}
	};

	Compiler compiler = Mustache.compiler().defaultValue("").withCollector(collector);
	Template mockTemplate = compiler.compile(mustacheTemplate);
	mockTemplate.execute(new HashMap<>());
	return fields;
}
 

import com.samskivert.mustache.Template; //导入方法依赖的package包/类
@Override
protected void writeRecords(String documentSourceName, JCas jCas, Map<String, Collection<ExtractedRecord>> records,
		Map<String, Object> fieldMap) {
	for (Collection<ExtractedRecord> extractedRecords : records.values()) {
		for (ExtractedRecord extractedRecord : extractedRecords) {
			String name = extractedRecord.getName();
			Template template = templates.get(StringUtils.lowerCase(name));
			if (template == null) {
				getMonitor().info("No template found for record {}", name);
				continue;
			}
			try (Writer writer = createOutputWriter(documentSourceName, name)) {
				template.execute(fieldMap, writer);
			} catch (IOException e) {
				getMonitor().warn("Failed to write record " + name + " for document " + documentSourceName, e);
			}
		}
	}
}
 

import com.samskivert.mustache.Template; //导入方法依赖的package包/类
private String getEmailText(Locale locale, String loginName, String link)
		throws IOException {
	String resource = "pwreset_email.mustache";
	if (locale != null && locale.getLanguage().toLowerCase().equals("de")) {
		resource = "pwreset_email_de.mustache";
	}
	ClassPathResource cp = new ClassPathResource(resource);
	try (InputStream is = cp.getInputStream()) {
		Template template = this.mustacheCompiler.compile(new InputStreamReader(is));

		Map<String, Object> data = new HashMap<>();
		data.put("loginName", loginName);
		data.put("link", link);

		return template.execute(data);
	}
}
 

import com.samskivert.mustache.Template; //导入方法依赖的package包/类
private void render(String templatePath, File workingDirectory, Object toRender) throws IOException {
    FileWriter writer = null;

    try {
        File template = new File(workingDirectory.getPath(), templatePath);
        if (template.getParentFile() != null) {
            template.getParentFile().mkdirs();
        }

        writer = new FileWriter(template);

        Template mustacheTemplate = engine.compile(buildTemplateReader(templatePath));

        mustacheTemplate.execute(toRender, writer);
    } finally {
        IOUtils.closeQuietly(writer);
    }
}
 

import com.samskivert.mustache.Template; //导入方法依赖的package包/类
public String process(String name, Map<String, ?> model) {
	try {
		Template template = getTemplate(name);
		return template.execute(model);
	}
	catch (Exception e) {
		log.error("Cannot render: " + name, e);
		throw new IllegalStateException("Cannot render template", e);
	}
}
 

import com.samskivert.mustache.Template; //导入方法依赖的package包/类
public String format(final Document html, final ParserContext parserContext) {
	final ParserType parserType = ParserType.detect(html).orElseThrow(
			() -> new RuntimeException("Unsupported Wowhead article type"));
	final Object data = parserType.parse(html, parserContext);
	final Map<String, Object> context = new HashMap<>();
	
	context.put(parserType.getTemplateObjectPrefix(), data);
	
	Template template = TEMPLATES.computeIfAbsent(parserType, this::createTemplate);
	return template.execute(context);
}
 

import com.samskivert.mustache.Template; //导入方法依赖的package包/类
/**
 * Prepare a matching rule configuration file in the specified job folder
 * based on whether the run is Deduplication or Linkage.
 * 
 * @param isDeduplication
 *          true when deduplicating records in a single data set.
 * 
 * @param jobDir
 * @return
 * @throws IOException
 */
File prepareMatchingRuleConfiguration(boolean isDeduplication, File jobDir)
    throws IOException {
  final String templateFileStr = isDeduplication ? getDeduplicationTemplate()
      : getLinkageTemplate();
  if (templateFileStr == null) {
    throw new IllegalStateException("No Template File set for "
        + (isDeduplication ? "deduplication" : "linkage") + " mode");
  }

  final Template matchConfigTemplate = loadTemplate(templateFileStr);
  if (matchConfigTemplate == null) {
    final String msg = "Unable to load matching rule configuration template: "
        + templateFileStr;
    LOG.error(msg);
    throw new IllegalStateException(msg);
  }

  final File configFile = new File(jobDir, "config.xml");

  // Generate the configuration file that specifies matching rules and
  // data sources
  final Map<String, String> templateParams = new HashMap<String, String>();
  templateParams.put("jobDir", jobDir.getAbsolutePath());
  final Writer configWriter = new FileWriter(configFile);
  try {
    // Apply parameters to template and write result to file
    matchConfigTemplate.execute(templateParams, configWriter);
    configWriter.flush();
  } finally {
    try {
      configWriter.close();
    } catch (IOException e) {
      // ignore
    }
  }
  return configFile;
}
 

import com.samskivert.mustache.Template; //导入方法依赖的package包/类
@Override
public String toString() {
    StringWriter writer = new StringWriter();

    InputStream templateStream = getClass().getResourceAsStream(getTemplateName());
    Mustache.Compiler compiler = Mustache.compiler()
            .strictSections(false)
            .nullValue("");
    Template template = compiler.compile(new InputStreamReader(templateStream));
    template.execute(this, writer);

    return writer.toString();
}
 

import com.samskivert.mustache.Template; //导入方法依赖的package包/类
@Override
public HttpResponse doGet(HttpRequest request) {
    String html = HtmlReader.readAll(context, "download.html");

    Template template = Mustache.compiler().compile(html);

    Map<String, List<FileItem>> map = new HashMap<>();
    map.put("files", PreferenceUtil.getFileItemsToSend(context));

    html = template.execute(map);

    Log.i(TAG, html);
    return HttpResponse.newResponse(html);
}