public class BeanModel extends Object implements TemplateHashModelEx, AdapterTemplateModel, WrapperTemplateModel, TemplateModelWithAPISupport
TemplateHashModel
interface allowing calls to arbitrary property getters and invocation of
accessible methods on the object from a template using the
object.foo to access properties and object.bar(arg1, arg2) to
invoke methods on it. You can also use the object.foo[index] syntax to
access indexed properties. It uses Beans Introspector
to dynamically discover the properties and methods.| Modifier and Type | Field and Description |
|---|---|
protected Object |
object |
protected BeansWrapper |
wrapper |
NOTHING| Constructor and Description |
|---|
BeanModel(Object object,
BeansWrapper wrapper)
Creates a new model that wraps the specified object.
|
| Modifier and Type | Method and Description |
|---|---|
TemplateModel |
get(String key)
Uses Beans introspection to locate a property or method with name
matching the key name.
|
Object |
getAdaptedObject(Class hint)
Returns the same as
getWrappedObject(); to ensure that, this method will be final starting from 2.4. |
TemplateModel |
getAPI()
Returns the model that exposes the (Java) API of the value.
|
Object |
getWrappedObject()
Retrieves the original object wrapped by this model.
|
protected boolean |
hasPlainGetMethod()
Whether the model has a plain get(String) or get(Object) method
|
protected TemplateModel |
invokeGenericGet(Map keyMap,
Class clazz,
String key) |
boolean |
isEmpty()
Tells whether the model is empty.
|
TemplateCollectionModel |
keys() |
protected Set |
keySet()
Helper method to support TemplateHashModelEx.
|
int |
size() |
String |
toString() |
protected Object |
unwrap(TemplateModel model) |
TemplateCollectionModel |
values() |
protected TemplateModel |
wrap(Object obj) |
protected final Object object
protected final BeansWrapper wrapper
public BeanModel(Object object, BeansWrapper wrapper)
BeansWrapper.wrap(Object).object - the object to wrap into a model.wrapper - the BeansWrapper associated with this model.
Every model has to have an associated BeansWrapper instance. The
model gains many attributes from its wrapper, including the caching
behavior, method exposure level, method-over-item shadowing policy etc.public TemplateModel get(String key) throws TemplateModelException
TemplateMethodModelEx (for a method or
indexed property), or evaluated on-the-fly and the return value wrapped
into appropriate model (for a simple property) Models for various
properties and methods are cached on a per-class basis, so the costly
introspection is performed only once per property or method of a class.
(Side-note: this also implies that any class whose method has been called
will be strongly referred to by the framework and will not become
unloadable until this class has been unloaded first. Normally this is not
an issue, but can be in a rare scenario where you create many classes on-
the-fly. Also, as the cache grows with new classes and methods introduced
to the framework, it may appear as if it were leaking memory. The
framework does, however detect class reloads (if you happen to be in an
environment that does this kind of things--servlet containers do it when
they reload a web application) and flushes the cache. If no method or
property matching the key is found, the framework will try to invoke
methods with signature
non-void-return-type get(java.lang.String),
then non-void-return-type get(java.lang.Object), or
alternatively (if the wrapped object is a resource bundle)
Object getObject(java.lang.String).get in interface TemplateHashModelkey - the name by which the TemplateModel
is identified in the template.TemplateModelException - if there was no property nor method nor
a generic get method to invoke.protected boolean hasPlainGetMethod()
protected TemplateModel invokeGenericGet(Map keyMap, Class clazz, String key) throws IllegalAccessException, InvocationTargetException, TemplateModelException
protected TemplateModel wrap(Object obj) throws TemplateModelException
TemplateModelExceptionprotected Object unwrap(TemplateModel model) throws TemplateModelException
TemplateModelExceptionpublic boolean isEmpty()
isEmpty in interface TemplateHashModelpublic Object getAdaptedObject(Class hint)
getWrappedObject(); to ensure that, this method will be final starting from 2.4.
This behavior of BeanModel is assumed by some FreeMarker code.getAdaptedObject in interface AdapterTemplateModelhint - the desired class of the returned value. An implementation
should make reasonable effort to retrieve an object of the requested
class, but if that is impossible, it must at least return the underlying
object as-is. As a minimal requirement, an implementation must always
return the exact underlying object when
hint.isInstance(underlyingObject) holds. When called
with java.lang.Object.class, it should return a generic Java
object (i.e. if the model is wrapping a scripting language object that is
further wrapping a Java object, the deepest underlying Java object should
be returned).public Object getWrappedObject()
WrapperTemplateModelgetWrappedObject in interface WrapperTemplateModelpublic int size()
size in interface TemplateHashModelExpublic TemplateCollectionModel keys()
keys in interface TemplateHashModelExTemplateScalarModel
(as the keys of hashes are always strings).public TemplateCollectionModel values() throws TemplateModelException
values in interface TemplateHashModelExTemplateModel-s.TemplateModelExceptionprotected Set keySet()
public TemplateModel getAPI() throws TemplateModelException
TemplateModelWithAPISupportObjectWrapperWithAPISupport.wrapAsAPI(Object).getAPI in interface TemplateModelWithAPISupportTemplateModelExceptionCopyright © 2020. All Rights Reserved.