Java JadeConfiguration.setCaching方法代码示例

import de.neuland.jade4j.JadeConfiguration; //导入方法依赖的package包/类
@Produces
@ViewEngineConfig
JadeConfiguration produce() {
    loadConfig();
    JadeConfiguration jade = new JadeConfiguration();
    jade.setMode(Mode.valueOf(property(MODE).orElse("XHTML")));
    jade.setCaching(Boolean.valueOf(property(CACHING).orElse("true")));
    jade.setPrettyPrint(Boolean.valueOf(property(PRETTY_PRINT).orElse("false")));
    for (Map.Entry<String, Object> filter : getExtensions(FILTER_QUALIFIER).entrySet()) {
        jade.setFilter(filter.getKey(), (Filter) filter.getValue());
    }
    jade.setSharedVariables(getExtensions(HELPER_QUALIFIER));
    String encoding = property(ENCODING).orElse("UTF-8");
    jade.setTemplateLoader(new ServletContextTemplateLoader(servletContext, encoding));
    return jade;
}
 

import de.neuland.jade4j.JadeConfiguration; //导入方法依赖的package包/类
@Override
public void init(Application application) {
    super.init(application);

    Router router = getRouter();
    PippoSettings pippoSettings = getPippoSettings();

    configuration = new JadeConfiguration();
    configuration.setTemplateLoader(new ClassTemplateLoader(JadeTemplateEngine.class, getTemplatePathPrefix()));
    configuration.setMode(Mode.HTML);
    if (pippoSettings.isDev()) {
        configuration.setPrettyPrint(true);
        configuration.setCaching(false); // disable cache
    }

    // set global template variables
    configuration.getSharedVariables().put("contextPath", router.getContextPath());
    configuration.getSharedVariables().put("appPath", router.getApplicationPath());

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

import de.neuland.jade4j.JadeConfiguration; //导入方法依赖的package包/类
private void configureJade4J() {
    jadeConfiguration = new JadeConfiguration();
    String srcDir = buildSrcDir();

    if ((ninjaProperties.isDev() || ninjaProperties.isTest())
            && new File(srcDir).exists()) {
        jadeConfiguration.setTemplateLoader(new FileTemplateLoader(srcDir,
                "UTF-8"));
        jadeConfiguration.setCaching(false);
        jadeConfiguration.setPrettyPrint(true);
    } else {
        jadeConfiguration.setTemplateLoader(new ClasspathTemplateLoader());
        jadeConfiguration.setCaching(true);
        jadeConfiguration.setPrettyPrint(false);
    }

    jadeConfiguration.setMode(Mode.HTML);

}
 

import de.neuland.jade4j.JadeConfiguration; //导入方法依赖的package包/类
@Bean
@ConditionalOnMissingBean(JadeConfiguration.class)
public JadeConfiguration jadeConfiguration(TemplateLoader jadeTemplateLoader) {
	JadeConfiguration configuration = new JadeConfiguration();
	configuration.setCaching(false); //Cache is handled by spring
	configuration.setPrettyPrint(properties.isPrettyPrint());
	configuration.setTemplateLoader(jadeTemplateLoader);
	//configuration.setSharedVariables(sharedVariables);
	//configuration.setFilter(name, filter);
	//configuration.setMode(mode);
	return configuration;
}
 

import de.neuland.jade4j.JadeConfiguration; //导入方法依赖的package包/类
@Bean
public JadeConfiguration jadeConfiguration(TemplateLoader jadeTemplateLoader) {
	JadeConfiguration configuration = new JadeConfiguration();
	configuration.setCaching(false); 
	configuration.setPrettyPrint(true);
	configuration.setTemplateLoader(jadeTemplateLoader);
	return configuration;
}
 

import de.neuland.jade4j.JadeConfiguration; //导入方法依赖的package包/类
@Override
public void renderString(String templateContent, Map<String, Object> model, Writer writer) {
    // prepare the locale-aware i18n method
    String language = (String) model.get(PippoConstants.REQUEST_PARAMETER_LANG);
    if (StringUtils.isNullOrEmpty(language)) {
        language = getLanguageOrDefault(language);
    }

    // prepare the locale-aware prettyTime method
    Locale locale = (Locale) model.get(PippoConstants.REQUEST_PARAMETER_LOCALE);
    if (locale == null) {
        locale = getLocaleOrDefault(language);
    }

    model.put("pippo", new PippoHelper(getMessages(), language, locale, getRouter()));
    try (StringReader reader = new StringReader(templateContent)) {
        ReaderTemplateLoader stringTemplateLoader = new ReaderTemplateLoader(reader, "StringTemplate");

        JadeConfiguration stringTemplateConfiguration = new JadeConfiguration();
        stringTemplateConfiguration.setCaching(false);
        stringTemplateConfiguration.setTemplateLoader(stringTemplateLoader);
        stringTemplateConfiguration.setMode(configuration.getMode());
        stringTemplateConfiguration.setPrettyPrint(configuration.isPrettyPrint());

        JadeTemplate stringTemplate = configuration.getTemplate("StringTemplate");
        configuration.renderTemplate(stringTemplate, model, writer);
        writer.flush();
    } catch (Exception e) {
        throw new PippoRuntimeException(e);
    }
}
 

import de.neuland.jade4j.JadeConfiguration; //导入方法依赖的package包/类
private JadeTemplate getJadeTemplate(String templatePath) throws IOException {
  JadeConfiguration config = new JadeConfiguration();
  if (isDebugEnabled) {
    config.clearCache();
    config.setCaching(false);
  }
  config.setTemplateLoader(new ClasspathTemplateLoader());
  return config.getTemplate(templatePath);
}
 

import de.neuland.jade4j.JadeConfiguration; //导入方法依赖的package包/类
@Bean
public JadeConfiguration defaultJadeConfiguration() {
  JadeConfiguration configuration = new JadeConfiguration();
  configuration.setCaching(this.environment.getProperty("caching", Boolean.class, true));
  configuration.setTemplateLoader(defaultSpringTemplateLoader());
  configuration.setPrettyPrint(this.environment.getProperty("prettyPrint", Boolean.class, false));
  configuration.setMode(this.environment.getProperty("mode", Jade4J.Mode.class, Jade4J.Mode.HTML));
  return configuration;
}
 

import de.neuland.jade4j.JadeConfiguration; //导入方法依赖的package包/类
@Override
public void configure(final Env env, final Config conf, final Binder binder) {
  JadeConfiguration jadeconf = new JadeConfiguration();
  boolean dev = env.name().equals("dev");
  boolean caching = conf.hasPath("jade.caching")
      ? conf.getBoolean("jade.caching")
      : !dev;
  boolean prettyPrint = conf.hasPath("jade.prettyprint")
      ? conf.getBoolean("jade.prettyprint")
      : dev;

  jadeconf.setCaching(caching);
  jadeconf.setPrettyPrint(prettyPrint);

  Map<String, Object> sharedVariables = new HashMap<>(2);
  sharedVariables.put("env", env);
  sharedVariables.put("xss", new XssHelper(env));
  jadeconf.setSharedVariables(sharedVariables);

  jadeconf.setTemplateLoader(new ClasspathTemplateLoader());

  if (callback != null) {
    callback.accept(jadeconf, conf);
  }

  // rewrite template loader avoid NPE
  jadeconf.setTemplateLoader(new IOTemplateLoader(jadeconf.getTemplateLoader()));

  binder.bind(JadeConfiguration.class)
      .toInstance(jadeconf);

  Multibinder.newSetBinder(binder, Renderer.class).addBinding()
      .toInstance(new Engine(jadeconf, suffix));
}
 

import de.neuland.jade4j.JadeConfiguration; //导入方法依赖的package包/类
@SuppressWarnings("unchecked")
private Block jade(final String suffix, final boolean caching, final boolean prettyPrint) {
  return unit -> {
    JadeConfiguration jadeConfiguration = unit.mockConstructor(JadeConfiguration.class);
    jadeConfiguration.setCaching(caching);
    jadeConfiguration.setPrettyPrint(prettyPrint);

    Env env = unit.get(Env.class);
    Map<String, Object> sharedVariables = unit.constructor(HashMap.class)
        .build(2);
    expect(sharedVariables.put(eq( "env"), eq(env))).andReturn(null);
    expect(sharedVariables.put(eq( "xss"), isA(XssHelper.class))).andReturn(null);
    jadeConfiguration.setSharedVariables(sharedVariables);

    ClasspathTemplateLoader classpathTemplateLoader = unit
        .mockConstructor(ClasspathTemplateLoader.class);
    jadeConfiguration.setTemplateLoader(classpathTemplateLoader);
    expect(jadeConfiguration.getTemplateLoader()).andReturn(classpathTemplateLoader);

    Jade.IOTemplateLoader safetl = unit
        .constructor(Jade.IOTemplateLoader.class)
        .build(classpathTemplateLoader);
    jadeConfiguration.setTemplateLoader(safetl);

    AnnotatedBindingBuilder<JadeConfiguration> configBB = unit
        .mock(AnnotatedBindingBuilder.class);
    configBB.toInstance(jadeConfiguration);

    Binder binder = unit.get(Binder.class);
    expect(binder.bind(JadeConfiguration.class)).andReturn(configBB);

    Engine engine = unit.mockConstructor(
        Engine.class, new Class[]{JadeConfiguration.class, String.class },
        jadeConfiguration, suffix);

    LinkedBindingBuilder<Renderer> ffLBB = unit.mock(LinkedBindingBuilder.class);
    ffLBB.toInstance(engine);

    Multibinder<Renderer> formatter = unit.mock(Multibinder.class);
    expect(formatter.addBinding()).andReturn(ffLBB);

    unit.mockStatic(Multibinder.class);
    expect(Multibinder.newSetBinder(binder, Renderer.class)).andReturn(formatter);
  };
}