How to use jetbrick.template.resolver

public Class<?> resolveClass(String className) {
  Class<?> cls = null;
  if (localClassResolver != null) {
    cls = localClassResolver.resolveClass(className);
  }
  if (cls == null) {
    cls = globalResolver.resolveClass(className);
  }
  return cls;
}

/**
 * 注册 function 扩展
 */
public void registerFunctions(String className) {
  Class<?> cls = resolveClass(className);
  if (cls == null) {
    throw new TemplateException("@JetFunctions class not found: " + className);
  }
  functionInvokerResolver.register(cls);
}

/**
 * 注册 method 扩展
 */
public void registerMethods(String className) {
  Class<?> cls = resolveClass(className);
  if (cls == null) {
    throw new TemplateException("@JetMethods class not found: " + className);
  }
  methodInvokerResolver.register(cls);
}

  Class<?>[] argumentTypes = ParameterUtils.getParameterTypes(arguments);
  fn = ctx.getGlobalResolver().resolveFunction(name, argumentTypes);
    String signature = SignatureUtils.getFunctionSignature(name, argumentTypes);
    throw new InterpretException(Errors.FUNCTION_NOT_FOUND, signature).set(position);
  if (securityManager != null) {
    try {
      fn.checkAccess(securityManager);
    } catch (RuntimeException e) {
      throw new InterpretException(e).set(position);
  return fn.invoke(arguments);
} catch (InterpretException e) {
  throw e;
  throw new InterpretException(Errors.FUNCTION_INVOKE_ERROR, fn.getSignature()).cause(e).set(position);

  @Override
  public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
    if (bean != null && bean.getClass() == JetTemplateViewResolver.class) {
      JetEngine engine = ((JetTemplateViewResolver) bean).getJetEngine();
      // 注册Tags
      engine.getGlobalResolver().registerTags(SpringedTags.class);
    }
    return bean;
  }
};

  private void doInvoke(InterpretContext ctx, TagInvoker invoker, Object[] arguments) throws InterpretException {
    boolean useLatest = (invoker != null);

    if (invoker == null) {
      Class<?>[] argumentTypes = ParameterUtils.getParameterTypes(arguments);
      invoker = ctx.getGlobalResolver().resolveTag(name, argumentTypes);

      if (invoker == null) {
        String signature = SignatureUtils.getFunctionSignature(name, argumentTypes);
        throw new InterpretException(Errors.TAG_NOT_FOUND, signature).set(position);
      }

      this.last = invoker; // 找到一个新的 Invoker
    }

    try {
      invoker.invoke(tagContext, arguments);
    } catch (InterpretException e) {
      throw e;
    } catch (RuntimeException e) {
      if (useLatest && Errors.isReflectIllegalArgumentException(e)) {
        // 重新查找匹配的 Invoker
        doInvoke(ctx, null, arguments);
      }
      throw new InterpretException(e).set(position);
    }
  }
}

/**
 * 注册 tag 扩展
 */
public void registerTags(String className) {
  Class<?> cls = resolveClass(className);
  if (cls == null) {
    throw new TemplateException("@JetTags class not found: " + className);
  }
  tagInvokerResolver.register(cls);
}

/**
 * 根据参数类型，查找一个匹配的方法（带缓存）.
 * @param isStatic
 */
public MethodInvoker resolve(Class<?> clazz, String name, Class<?>[] argumentTypes, boolean isStatic) {
  String signature = SignatureUtils.getMethodSignature(clazz, name, argumentTypes);
  MethodInvoker found = cache.get(signature);
  if (found != null) {
    return found;
  }
  MethodInvoker method = doGetMethodInvoker(clazz, name, argumentTypes, isStatic);
  if (method != null) {
    cache.put(signature, method);
    return method;
  }
  return null;
}

@Override
public JetTemplateMacro resolveMacro(String name, Class<?>[] argumentTypes, boolean root) {
  JetTemplateMacro macro = macroResolver.resolve(name, argumentTypes, reloadable);
  if (macro == null && root) {
    macro = engine.getGlobalResolver().resolveMacro(name, argumentTypes, reloadable);
  }
  return macro;
}

/**
 * 查找属性访问
 */
@Override
public Getter resolve(Class<?> clazz, String name) {
  String signature = SignatureUtils.getFieldSignature(clazz, name);
  Getter found = cache.get(signature);
  if (found != null) {
    return found;
  }
  Getter getter = doGetGetter(clazz, name);
  if (getter != null) {
    cache.put(signature, getter);
    return getter;
  }
  return null;
}

/**
 * 根据参数类型，查找一个匹配的 Tag（带缓存）.
 */
public TagInvoker resolve(String name, Class<?>[] argumentTypes) {
  String signature = SignatureUtils.getFunctionSignature(name, argumentTypes);
  TagInvoker found = cache.get(signature);
  if (found != null) {
    return found;
  }
  TagInvoker tag = doGetTagInvoker(name, argumentTypes);
  if (tag != null) {
    cache.put(signature, tag);
    return tag;
  }
  return null;
}

/**
 * 根据参数类型，查找一个匹配的 function（带缓存）.
 */
public FunctionInvoker resolve(String name, Class<?>[] argumentTypes) {
  String signature = SignatureUtils.getFunctionSignature(name, argumentTypes);
  FunctionInvoker found = cache.get(signature);
  if (found != null) {
    return found;
  }
  FunctionInvoker function = doGetFunctionInvoker(name, argumentTypes);
  if (function != null) {
    cache.put(signature, function);
    return function;
  }
  return null;
}

  public void invoke(JetTagContext ctx, Object[] arguments) {
    arguments = ParameterUtils.getActualArguments(arguments, length, varArgsClass, 1);
    arguments[0] = ctx; // 第一个参数

    method.invoke(null, arguments);
  }
}

private void doLoadGlobalMacroFiles() {
  List<String> macroFiles = config.getImportMacros();
  for (String file : macroFiles) {
    JetTemplate template = getTemplate(file);
    globalResolver.registerMacros(template);
  }
}

private JetGlobalContext doCreateGlobalContext() {
  log.debug("Initializing global context ...");
  JetGlobalContext ctx = new JetGlobalContext();
  ctx.define(JetForIterator.class, Symbols.FOR);
  for (String define : config.getImportDefines()) {
    int pos = define.indexOf(' ');
    String type = define.substring(0, pos);
    String name = define.substring(pos + 1);
    Class<?> cls = globalResolver.resolveClass(type);
    ctx.define(cls, name);
  }
  return ctx;
}

public JetTemplateRenderFactory() {
  engine = JetWebEngine.create(JFinal.me().getServletContext());
  engine.getGlobalResolver().registerGetterResolver(new JFinalActiveRecordGetterResolver());
}

  @Override
  public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
    if (bean != null && bean.getClass() == JetTemplateViewResolver.class) {
      JetEngine engine = ((JetTemplateViewResolver) bean).getJetEngine();
      // 注册Tags
      engine.getGlobalResolver().registerTags(SpringedTags.class);
    }
    return bean;
  }
};

@Override
public Object invoke(Object object, Object[] arguments) {
  arguments = ParameterUtils.getActualArguments(arguments, length, varArgsClass, 1);
  arguments[0] = object; // 第一个参数
  return method.invoke(null, arguments);
}

@Override
public Object invoke(Object[] arguments) {
  arguments = ParameterUtils.getActualArguments(arguments, length, varArgsClass, 0);
  return method.invoke(null, arguments);
}

@Override
public Object invoke(Object object, Object[] arguments) {
  arguments = ParameterUtils.getActualArguments(arguments, length, varArgsClass, 0);
  return method.invoke(object, arguments);
}