import com.github.jknack.handlebars.context.MapValueResolver; //导入依赖的package包/类
private String render(final boolean isInline, final String source, final Object data, final String languageCode) {
	try {
		final Template template = isInline ? handlebars.compileInline(source) : handlebars.compile(source);

		final Context context = Context.newBuilder(data).combine(LANGUAGE_PROPERTY, languageCode)
				.resolver(
						ScalaJsonValueResolver.INSTANCE,
						JsonNodeValueResolver.INSTANCE, 
						MapValueResolver.INSTANCE, 
						FieldValueResolver.INSTANCE)
				.build();

		return template.apply(context);

	} catch (Exception e) {
		throw new RuntimeException(e);
	}
}
 

import com.github.jknack.handlebars.context.MapValueResolver; //导入依赖的package包/类
@Override
protected void onRender(Node content, RenderableDefinition definition, RenderingContext renderingContext,
                        Map<String, Object> context, String templateScript) throws RenderException {

    final AppendableWriter out;
    try {
        out = renderingContext.getAppendable();
        AggregationState aggregationState = (AggregationState) context.get("state");
        Node node = aggregationState.getCurrentContentNode();
        Locale locale = aggregationState.getLocale();
        context.put("content", new ChainedContentMap(node, locale));
        Context combinedContext = Context.newBuilder(context)
                .resolver(JavaBeanValueResolver.INSTANCE, FieldValueResolver.INSTANCE, MapValueResolver.INSTANCE)
                .build();
        try {
            Template template = handlebars.compile(templateScript);
            template.apply(combinedContext, out);
        } finally {
            combinedContext.destroy();
        }
    } catch (IOException e) {
        LOGGER.error("Cannot render template", e);
    }
}
 

import com.github.jknack.handlebars.context.MapValueResolver; //导入依赖的package包/类
public Future<String> render(String template, String destination, JsonObject object) {
  Context context = Context.newBuilder(object.getMap()).resolver(MapValueResolver.INSTANCE).build();
  log.debug("Rendering template {} with object {}", object);
  Future future = Future.future();
  try {
    future.complete(writeFile(destination, handlebars.compile(template).apply(context)));
  } catch (IOException e) {
    log.error("Impossible to render template {}: ", template, e);
    future.fail(e.getCause());
  }
  return future;
}
 

import com.github.jknack.handlebars.context.MapValueResolver; //导入依赖的package包/类
public Future<String> render(String template, JsonObject object) {
    Context context = Context.newBuilder(object.getMap()).resolver(MapValueResolver.INSTANCE).build();
    log.debug("Rendering template {} with object {}", object);
    Future future = Future.future();
    try {
        future.complete(handlebars.compile(template).apply(context));
    } catch (IOException e) {
        log.error("Impossible to render template {}: ", template, e.getMessage());
        future.fail(e.getCause());
    }
    return future;
}
 

import com.github.jknack.handlebars.context.MapValueResolver; //导入依赖的package包/类
private void saveMeshUiConfig() {
	File parentFolder = new File(CONFIG_FOLDERNAME);
	if (!parentFolder.exists() && !parentFolder.mkdirs()) {
		throw error(INTERNAL_SERVER_ERROR, "Could not create configuration folder {" + parentFolder.getAbsolutePath() + "}");
	}
	File outputFile = new File(parentFolder, CONF_FILE);
	if (!outputFile.exists()) {
		InputStream ins = getClass().getResourceAsStream("/meshui-templates/mesh-ui-config.hbs");
		if (ins == null) {
			throw error(INTERNAL_SERVER_ERROR, "Could not find mesh-ui config template within classpath.");
		}
		try {
			Handlebars handlebars = new Handlebars();
			Template template = handlebars.compileInline(IOUtils.toString(ins));

			Map<String, Object> model = new HashMap<>();
			int httpPort = Mesh.mesh().getOptions().getHttpServerOptions().getPort();
			model.put("mesh_http_port", httpPort);

			// Prepare render context
			Context context = Context.newBuilder(model).resolver(MapValueResolver.INSTANCE).build();
			FileWriter writer = new FileWriter(outputFile);
			template.apply(context, writer);
			writer.close();
		} catch (Exception e) {
			log.error("Could not save configuration file {" + outputFile.getAbsolutePath() + "}");
		}
	}
}
 

import com.github.jknack.handlebars.context.MapValueResolver; //导入依赖的package包/类
/**
 * @return A Handlebars context with useful default resolvers.
 */
public static Context.Builder newContextBuilder() {
    return Context.newBuilder(null).resolver(
            FieldValueResolver.INSTANCE,
            MethodValueResolver.INSTANCE,
            JavaBeanValueResolver.INSTANCE,
            MapValueResolver.INSTANCE);
}
 

import com.github.jknack.handlebars.context.MapValueResolver; //导入依赖的package包/类
private Context getMapContext(Map<String, Object> dataModel) {
    Context context = Context
            .newBuilder(dataModel)
            .resolver(MapValueResolver.INSTANCE)
            .build();
    return context;
}
 

import com.github.jknack.handlebars.context.MapValueResolver; //导入依赖的package包/类
/**
 * Creates a new {@link Hbs} module.
 *
 * @param prefix Template prefix.
 * @param suffix Template suffix.
 * @param helpers Optional list of helpers.
 */
public Hbs(final String prefix, final String suffix, final Class<?>... helpers) {
  this.hbs = new Handlebars(new ClassPathTemplateLoader(prefix, suffix));
  with(helpers);
  // default value resolvers.
  this.resolvers.add(MapValueResolver.INSTANCE);
  this.resolvers.add(JavaBeanValueResolver.INSTANCE);
  this.resolvers.add(MethodValueResolver.INSTANCE);
  this.resolvers.add(new RequestValueResolver());
  this.resolvers.add(new SessionValueResolver());
  this.resolvers.add(new ConfigValueResolver());
  this.resolvers.add(FieldValueResolver.INSTANCE);
}
 

import com.github.jknack.handlebars.context.MapValueResolver; //导入依赖的package包/类
protected List<ValueResolver> valueResolversInContext(final TemplateContext templateContext) {
    final SunriseJavaBeanValueResolver javaBeanValueResolver = createJavaBeanValueResolver(templateContext);
    return asList(MapValueResolver.INSTANCE, javaBeanValueResolver, playJavaFormResolver);
}
 

import com.github.jknack.handlebars.context.MapValueResolver; //导入依赖的package包/类
/**
 * Generates files from templates for a given application.
 * <p>
 * All the generated files for a given application are located
 * under <code>outputDirectory/application-name</code>. Even global templates
 * are output there.
 * </p>
 *
 * @param app an application (not null)
 * @param outputDirectory the output directory (not null)
 * @param templates a non-null collection of templates
 * @param logger a logger
 * @throws IOException if something went wrong
 */
public static void generate( Application app, File outputDirectory, Collection<TemplateEntry> templates, Logger logger )
throws IOException {

	// Create the context on the fly
	ApplicationContextBean appCtx = ContextUtils.toContext( app );
	Context wrappingCtx = Context
			.newBuilder( appCtx )
			.resolver(
				MapValueResolver.INSTANCE,
				JavaBeanValueResolver.INSTANCE,
				MethodValueResolver.INSTANCE,
				new ComponentPathResolver()
			).build();

	// Deal with the templates
	try {
		for( TemplateEntry template : templates ) {

			logger.fine( "Processing template " + template.getTemplateFile() + " to application " + app + "." );

			File target;
			String targetFilePath = template.getTargetFilePath();
			if( ! Utils.isEmptyOrWhitespaces( targetFilePath )) {
				target = new File( targetFilePath.replace( "${app}", app.getName()));

			} else {
				String filename = template.getTemplateFile().getName().replaceFirst( "\\.tpl$", "" );
				target = new File( outputDirectory, app.getName() + "/" + filename );
			}

			Utils.createDirectory( target.getParentFile());
			String output = template.getTemplate().apply( wrappingCtx );
			Utils.writeStringInto( output, target );

			logger.fine( "Template " + template.getTemplateFile() + " was processed with application " + app + ". Output is in " + target );
		}

	} finally {
		wrappingCtx.destroy();
	}
}