Java MustacheEngine.getMustache方法代码示例

import org.trimou.engine.MustacheEngine; //导入方法依赖的package包/类
@Test
public void testEncoding() {

    TemplateLocator locator = new ServletContextTemplateLocator(10,
            "/templates", "html");

    MustacheEngine engine = MustacheEngineBuilder.newBuilder()
            .addTemplateLocator(locator)
            .setProperty(EngineConfigurationKey.DEFAULT_FILE_ENCODING,
                    "windows-1250")
            .build();

    Mustache encoding = engine.getMustache("encoding");
    assertNotNull(encoding);
    assertEquals("Hurá ěščřřžžýá!", encoding.render(null));
}
 

import org.trimou.engine.MustacheEngine; //导入方法依赖的package包/类
@Test
public void testMultipleInheritance() {
    MapTemplateLocator locator = new MapTemplateLocator(
            ImmutableMap
                    .of("super",
                            "for {{$insert}}{{/insert}}",
                            "sub",
                            "And now {{<super}} {{$insert}}something {{$insert2}}{{/insert2}} different{{/insert}} {{/super}}.",
                            "subsub",
                            "{{<sub}} {{$insert2}}completely{{/insert2}} {{/sub}}"));
    MustacheEngine engine = MustacheEngineBuilder.newBuilder()
            .addTemplateLocator(locator).build();
    Mustache sub = engine.getMustache("subsub");
    assertEquals("And now for something completely different.",
            sub.render(null));
}
 

import org.trimou.engine.MustacheEngine; //导入方法依赖的package包/类
@Test
public void testLocate() {

    TemplateLocator locator1 = ServletContextTemplateLocator.builder()
            .setPriority(10).setRootPath("/WEB-INF/templates")
            .setSuffix("html").build();
    TemplateLocator locator2 = ServletContextTemplateLocator.builder()
            .setPriority(9).setRootPath("/templates").setSuffix("html")
            .build();
    TemplateLocator locator3 = ServletContextTemplateLocator.builder()
            .setPriority(8).setRootPath("/WEB-INF/templates").build();
    TemplateLocator locator4 = ServletContextTemplateLocator.builder()
            .setPriority(7).setRootPath("/").build();

    MustacheEngine engine = MustacheEngineBuilder.newBuilder()
            .addTemplateLocator(locator1).addTemplateLocator(locator2)
            .addTemplateLocator(locator3).addTemplateLocator(locator4).build();

    Mustache foo = engine.getMustache("foo");
    assertNotNull(foo);
    assertEquals("<html/>", foo.render(null));

    Mustache bar = engine.getMustache("bart");
    assertNotNull(bar);
    assertEquals("<html/>", bar.render(null));

    Mustache alpha = engine.getMustache("alpha.xml");
    assertNotNull(alpha);
    assertEquals("<xml/>", alpha.render(null));

    Mustache charlie = engine.getMustache("cool/charlie");
    assertNotNull(charlie);
    assertEquals("<html/>", charlie.render(null));

    charlie = engine.getMustache("templates/bart.html");
    assertNotNull(charlie);
    assertEquals("<html/>", charlie.render(null));
}
 

import org.trimou.engine.MustacheEngine; //导入方法依赖的package包/类
@Test
public void testLocator() {

    TemplateLocator locator1 = ClassPathTemplateLocator.builder(10)
            .setRootPath("templates").setSuffix("html").build();
    TemplateLocator locator2 = ClassPathTemplateLocator.builder(9)
            .setScanClasspath(false).build();
    TemplateLocator locator3 = ClassPathTemplateLocator.builder(8)
            .setSuffix("html").setRootPath("META-INF/templates")
            .setScanClasspath(false).build();

    // Just to init the locators
    MustacheEngine engine = MustacheEngineBuilder.newBuilder()
            .addTemplateLocator(locator1).addTemplateLocator(locator2)
            .addTemplateLocator(locator3).build();

    Set<String> locator1Ids = locator1.getAllIdentifiers();
    assertEquals(0, locator1Ids.size());
    Mustache foo = engine.getMustache("foo");
    assertNotNull(foo);
    assertEquals("<html/>", foo.render(null));

    Set<String> locator2Ids = locator2.getAllIdentifiers();
    assertEquals(0, locator2Ids.size());
    foo = engine.getMustache("templates/foo.html");
    assertNotNull(foo);
    assertEquals("<html/>", foo.render(null));

    Set<String> locator3Ids = locator3.getAllIdentifiers();
    assertEquals(0, locator3Ids.size());
    Mustache bar = engine.getMustache("bar");
    assertNotNull(bar);
    assertEquals("<xml/>", bar.render(null));
}
 

import org.trimou.engine.MustacheEngine; //导入方法依赖的package包/类
/**
 *
 * @param templateId
 * @param engine
 * @param currentTemplate
 * @return the template or <code>null</code>
 */
public static Template lookupTemplate(String templateId, MustacheEngine engine,
        Template currentTemplate) {
    Template result = null;
    if (currentTemplate != null) {
        result = currentTemplate.getNestedTemplate(templateId);
    }
    if (result == null) {
        result = (Template) engine.getMustache(templateId);
    }
    return result;
}
 

import org.trimou.engine.MustacheEngine; //导入方法依赖的package包/类
@Test
public void testSimpleInheritance() {
    MapTemplateLocator locator = new MapTemplateLocator(
            ImmutableMap
                    .of("super", "Hello {{$insert}}Martin{{/insert}}",
                            "sub",
                            "And now... {{<super}} {{$insert}}{{name}}{{/insert}} {{/super}}!"));
    MustacheEngine engine = MustacheEngineBuilder.newBuilder()
            .addTemplateLocator(locator).build();
    Mustache sub = engine.getMustache("sub");
    assertEquals("And now... Hello Edgar!",
            sub.render(ImmutableMap.<String, Object> of("name", "Edgar")));
}
 

import org.trimou.engine.MustacheEngine; //导入方法依赖的package包/类
@Test
public void testMultipleInheritanceOverride() {
    MapTemplateLocator locator = new MapTemplateLocator(ImmutableMap.of(
            "super", "{{$insert}}{{/insert}}", "sub",
            "{{<super}} {{$insert}}false{{/insert}} {{/super}}", "subsub",
            "{{<sub}} {{$insert}}true{{/insert}} {{/sub}}"));
    MustacheEngine engine = MustacheEngineBuilder.newBuilder()
            .addTemplateLocator(locator).build();
    Mustache sub = engine.getMustache("subsub");
    assertEquals("true", sub.render(null));
}
 

import org.trimou.engine.MustacheEngine; //导入方法依赖的package包/类
@Test
public void testMultipleExtendSegments() {
    MapTemplateLocator locator = new MapTemplateLocator(
            ImmutableMap
                    .of("super",
                            "{{$insert}}baz{{/insert}}",
                            "sub",
                            "{{<super}}{{$insert}}foo{{/insert}}{{/super}}{{<super}}{{$insert}}bar{{/insert}}{{/super}}"));
    MustacheEngine engine = MustacheEngineBuilder.newBuilder()
            .addTemplateLocator(locator).build();
    Mustache sub = engine.getMustache("sub");
    assertEquals("foobar", sub.render(null));
}
 

import org.trimou.engine.MustacheEngine; //导入方法依赖的package包/类
@Test
public void testCachedPartialSegmentUsed() {
    Map<String, String> map = new HashMap<>();
    map.put("super", "{{$section1}}Martin{{/section1}}");
    map.put("sub", "{{<super}}{{$section1}}{{this}}{{/section1}}{{/super}}");
    MapTemplateLocator locator = new MapTemplateLocator(map);
    MustacheEngine engine = MustacheEngineBuilder.newBuilder()
            .addTemplateLocator(locator).build();
    Mustache mustache = engine.getMustache("sub");
    assertEquals("foo", mustache.render("foo"));
    map.put("super", "{{$section2}}Martin{{/section2}}");
    engine.invalidateTemplateCache();
    assertEquals("foo", mustache.render("foo"));
}
 

import org.trimou.engine.MustacheEngine; //导入方法依赖的package包/类
@Test
public void testCachedPartialSegmentNotUsed() {
    Map<String, String> map = new HashMap<>();
    map.put("super", "{{$section1}}Martin{{/section1}}");
    map.put("sub", "{{<super}}{{$section1}}{{this}}{{/section1}}{{/super}}");
    MapTemplateLocator locator = new MapTemplateLocator(map);
    MustacheEngine engine = MustacheEngineBuilder.newBuilder()
            .addTemplateLocator(locator).setProperty(EngineConfigurationKey.DEBUG_MODE, true).build();
    Mustache mustache = engine.getMustache("sub");
    assertEquals("foo", mustache.render("foo"));
    map.put("super", "{{$section2}}Martin{{/section2}}");
    engine.invalidateTemplateCache();
    assertEquals("Martin", mustache.render("foo"));
}
 

import org.trimou.engine.MustacheEngine; //导入方法依赖的package包/类
@Test
public void testCachedPartialSegmentUsed() {
    Map<String, String> map = new HashMap<>();
    map.put("alpha", "{{>bravo}}");
    map.put("bravo", "{{this}}");
    MapTemplateLocator locator = new MapTemplateLocator(map);
    MustacheEngine engine = MustacheEngineBuilder.newBuilder()
            .addTemplateLocator(locator).build();
    Mustache mustache = engine.getMustache("alpha");
    assertEquals("foo", mustache.render("foo"));
    map.put("bravo", "NOTHING");
    engine.invalidateTemplateCache();
    assertEquals("foo", mustache.render("foo"));
}
 

import org.trimou.engine.MustacheEngine; //导入方法依赖的package包/类
@Test
public void testCachedPartialSegmentNotUsed() {
    Map<String, String> map = new HashMap<>();
    map.put("alpha", "{{>bravo}}");
    map.put("bravo", "{{this}}");
    MapTemplateLocator locator = new MapTemplateLocator(map);
    MustacheEngine engine = MustacheEngineBuilder.newBuilder()
            .addTemplateLocator(locator)
            .setProperty(EngineConfigurationKey.DEBUG_MODE, true).build();
    Mustache mustache = engine.getMustache("alpha");
    assertEquals("foo", mustache.render("foo"));
    map.put("bravo", "NOTHING");
    assertEquals("NOTHING", mustache.render("foo"));
}
 

import org.trimou.engine.MustacheEngine; //导入方法依赖的package包/类
public static void main(String[] args) {

        // We will always start like this - building an engine
        MustacheEngineBuilder builder = MustacheEngineBuilder.newBuilder();

        // Add a template locator so that the template contents is automatically
        // loaded
        builder.addTemplateLocator(
                ClassPathTemplateLocator.builder().setSuffix("trimou").build());

        // Add some extra built-in helpers
        builder.registerHelpers(HelpersBuilder.extra()
                .add("log",
                        LogHelper.builder().setDefaultLevel(Level.WARN).build())
                .build());

        // Global data are available in all templates
        builder.addGlobalData("footer", "© 2014 Trimou team");

        // HTML is not necessary
        builder.setProperty(EngineConfigurationKey.SKIP_VALUE_ESCAPING, true);

        // Now we are ready to build the engine...
        MustacheEngine engine = builder.build();

        // Note that it's not necessary to cache templates - engine has its own
        // cache enabled by default
        Mustache test = engine.getMustache("items");

        // Prepare some data
        List<Item> items = new ArrayList<>();
        items.add(new Item("Foo", 5l, true));
        items.add(new Item("Bar", 15l, true));
        items.add(new Item("Qux", -1l, false));
        items.add(new Item("Baz", 5000l, true));

        System.out.println(
                String.format("Start rendering of %s...", test.getName()));

        long start = System.nanoTime();
        // And now render the data
        String output = test.render(items);
        long end = System.nanoTime() - start;

        System.out.println(String.format("Template %s rendered in %s ms:\n",
                test.getName(), end / 1000000));
        System.out.println(output);
    }