public interface ObjectWrapper
TemplateModelinterfaces). Thus this is what decides what parts of the Java objects will be accessible in the templates and how.
For example, with a
BeansWrapper both the items of
Map and the JavaBean properties (the getters)
of an object are accessible in template uniformly with the
myObject.foo syntax, where "foo" is the map key or
the property name. This is because both kind of object is wrapped by
BeansWrapper into a
TemplateHashModel implementation that will call
Map.get(Object) or the getter method, transparently
to the template language.
|Modifier and Type||Field and Description|
No replacement as it was seldom if ever used by anyone; this instance isn't read-only and thus can't be trusted.
static final ObjectWrapper BEANS_WRAPPER
BeansWrapperBuilder.build()instead; this instance isn't read-only and thus can't be trusted.
ObjectWrapperthat exposes the object methods and JavaBeans properties as hash elements, and has custom handling for Java
ResourceBundle-s, etc. It doesn't treat
Node-s and Jython objects specially, however. As of 2.3.22, using
incompatibleImprovementsproperty set to 2.3.22 (or higher) is recommended instead.
static final ObjectWrapper DEFAULT_WRAPPER
DefaultObjectWrapperBuilder.build()instead; this instance isn't read-only and thus can't be trusted.
DefaultObjectWrapperfor more information.
static final ObjectWrapper SIMPLE_WRAPPER
SimpleXXXwrappers only. It behaves like the
DEFAULT_WRAPPER, but for objects that it does not know how to wrap as a
SimpleXXXit throws an exception. It makes no use of reflection-based exposure of anything, which may makes it a good candidate for security-restricted applications.
TemplateModel wrap(Object obj) throws TemplateModelException
TemplateModelout of a non-
TemplateModelobject, usually by "wrapping" it into a
TemplateModelimplementation that delegates to the original object.
obj- The object to wrap into a
TemplateModel. If it already implements
TemplateModel, it should just return the object as is. If it's
null, the method should return
BeansWrapper, has a legacy option for returning a null model object instead, but it's not a good idea).
TemplateModelwrapper of the object passed in. To support un-wrapping, you may consider the return value to implement
AdapterTemplateModel. The default expectation is that the
TemplateModelisn't less thread safe than the wrapped object. If the
ObjectWrapperreturns less thread safe objects, that should be clearly documented, as it restricts how it can be used, like, then it can't be used to wrap "shared variables" (