import com.mitchellbosecke.pebble.extension.Extension; //导入依赖的package包/类
@Bean
public PebbleEngine pebbleEngine() {
    PebbleEngine.Builder builder = new PebbleEngine.Builder();
    builder.loader(this.pebbleLoader);
    builder.extension(this.pebbleSpringExtension());
    if (this.extensions != null && !this.extensions.isEmpty()) {
        builder.extension(this.extensions.toArray(new Extension[this.extensions.size()]));
    }
    if (!this.properties.isCache()) {
        builder.cacheActive(false);
    }
    if (this.properties.getDefaultLocale() != null) {
        builder.defaultLocale(this.properties.getDefaultLocale());
    }
    builder.strictVariables(this.properties.isStrictVariables());
    return builder.build();
}
 

import com.mitchellbosecke.pebble.extension.Extension; //导入依赖的package包/类
public PebbleEngine getPebbleEngine() {

        final PebbleEngine.Builder builder = new PebbleEngine.Builder()
                .loader(this.loader)
                .extension(extensions.toArray(new Extension[extensions.size()]));

        if (cache) {
            builder.templateCache(CacheBuilder.newBuilder().maximumSize(cacheSize).build())
                    .tagCache(CacheBuilder.newBuilder().maximumSize(cacheSize).build());
        } else {
            builder.templateCache(CacheBuilder.newBuilder().maximumSize(0).build())
                    .tagCache(CacheBuilder.newBuilder().maximumSize(0).build());
        }

        log.debug("PebbleEngine built! 这里不写几个汉字不显眼！！！");
        return builder.build();
    }
 

import com.mitchellbosecke.pebble.extension.Extension; //导入依赖的package包/类
public Extension asExtension() {
	return new AbstractExtension() {
		@Override
		public List<AttributeResolver> getAttributeResolver() {
			return ImmutableList.of(CustomPebbleAttributeResolver.this);
		}
	};
}
 

import com.mitchellbosecke.pebble.extension.Extension; //导入依赖的package包/类
/**
 * Constructor for the Pebble Engine given an instantiated Loader. This
 * method does only load those userProvidedExtensions listed here.
 *
 * @param loader     The template loader for this engine
 * @param syntax     the syntax to use for parsing the templates.
 * @param extensions The userProvidedExtensions which should be loaded.
 */
private PebbleEngine(Loader<?> loader, Syntax syntax, boolean strictVariables, Locale defaultLocale,
                     Cache<BaseTagCacheKey, Object> tagCache, Cache<Object, PebbleTemplate> templateCache,
                     ExecutorService executorService, Collection<? extends Extension> extensions) {

    this.loader = loader;
    this.syntax = syntax;
    this.strictVariables = strictVariables;
    this.defaultLocale = defaultLocale;
    this.tagCache = tagCache;
    this.executorService = executorService;
    this.templateCache = templateCache;
    this.extensionRegistry = new ExtensionRegistry(extensions);
}
 

import com.mitchellbosecke.pebble.extension.Extension; //导入依赖的package包/类
@Override
protected void configure() {
    // Pebble Extensions
    addToSet(Extension.class,
            PebbleFunctionsExtension.class,
            PebbleTagsExtension.class);

    addToSet(OrchidEventListener.class,
            PebbleCompiler.class);
}
 

import com.mitchellbosecke.pebble.extension.Extension; //导入依赖的package包/类
@Inject
public PebbleCompiler(Provider<OrchidContext> contextProvider, PebbleTemplateLoader loader, Set<Extension> extensions) {
    super(10000);

    Extension[] extensionArray = new Extension[extensions.size()];
    extensions.toArray(extensionArray);

    this.contextProvider = contextProvider;
    this.executor = Executors.newFixedThreadPool(10);
    this.engine = new PebbleEngine.Builder()
            .loader(loader)
            .executorService(executor)
            .extension(extensionArray)
            .build();
}
 

import com.mitchellbosecke.pebble.extension.Extension; //导入依赖的package包/类
public PebbleEngineProvider(Extension... extensions) {
    this.extensions = extensions;
}
 

import com.mitchellbosecke.pebble.extension.Extension; //导入依赖的package包/类
public NinjaPebbleModule(Extension... extensions) {
  this.extensions = extensions;
}
 

import com.mitchellbosecke.pebble.extension.Extension; //导入依赖的package包/类
@Bean
public Extension testExtension() {
    return new TestExtension();
}
 

import com.mitchellbosecke.pebble.extension.Extension; //导入依赖的package包/类
public void registerExtension(final Object extension) {
    if (extension instanceof Extension) {
        this.extensions.add((Extension) extension);
    }
}