CAN_NOT_UNWRAP
public static final Object CAN_NOT_UNWRAP
EXPOSE_ALL
public static final int EXPOSE_ALL
At this level of exposure, all methods and properties of the
wrapped objects are exposed to the template.
EXPOSE_NOTHING
public static final int EXPOSE_NOTHING
At this level of exposure, no bean properties and methods are exposed.
Only map items, resource bundle items, and objects retrieved through
the generic get method (on objects of classes that have a generic get
method) can be retrieved through the hash interface. You might want to
call
setMethodsShadowItems(boolean)
with
false value to
speed up map item retrieval.
EXPOSE_PROPERTIES_ONLY
public static final int EXPOSE_PROPERTIES_ONLY
At this level of exposure, only property getters are exposed.
Additionally, property getters that map to unsafe methods are not
exposed (i.e. Class.classLoader and Thread.contextClassLoader).
EXPOSE_SAFE
public static final int EXPOSE_SAFE
At this level of exposure, all methods and properties of the wrapped
objects are exposed to the template except methods that are deemed
not safe. The not safe methods are java.lang.Object methods wait() and
notify(), java.lang.Class methods getClassLoader() and newInstance(),
java.lang.reflect.Method and java.lang.reflect.Constructor invoke() and
newInstance() methods, all java.lang.reflect.Field set methods, all
java.lang.Thread and java.lang.ThreadGroup methods that can change its
state, as well as the usual suspects in java.lang.System and
java.lang.Runtime.
coerceBigDecimal
public static Object coerceBigDecimal(BigDecimal bd,
Class formalType)
coerceBigDecimals
public static void coerceBigDecimals(AccessibleObject callable,
Object[] args)
Converts any BigDecimal
s in the passed array to the type of
the corresponding formal argument of the method.
coerceBigDecimals
public static void coerceBigDecimals(Class[] formalTypes,
Object[] args)
Converts any BigDecimal
s in the passed array to the type of
the corresponding formal argument of the method.
getDefaultDateType
protected int getDefaultDateType()
getDefaultInstance
public static final BeansWrapper getDefaultInstance()
Returns the default instance of the wrapper. This instance is used
when you construct various bean models without explicitly specifying
a wrapper. It is also returned by
ObjectWrapper.BEANS_WRAPPER
and this is the sole instance that is used by the JSP adapter.
You can modify the properties of the default instance (caching,
exposure level, null model) to affect its operation. By default, the
default instance is not caching, uses the
EXPOSE_SAFE
exposure level, and uses null reference as the null model.
getEnumModels
public TemplateHashModel getEnumModels()
Returns a hash model that represents the so-called class enum models.
Every class' enum model is itself a hash through which you can access
enum value declared by the specified class, assuming that class is an
enumeration. To obtain an enum model for a class, get the element of this
hash with the fully qualified class name. For example, if you place this
hash model inside the root data model under name "enums", you can use
i.e. statics["java.math.RoundingMode"].UP
to access the
java.math.RoundingMode.UP
value.
- a hash model whose keys are fully qualified class names, and
that returns hash models whose elements are the enum models of the
classes.
getInstance
protected TemplateModel getInstance(Object object,
ModelFactory factory)
override getModelFactory(Class)
instead. Using this
method will now bypass wrapper caching (if it is enabled) and always
result in creation of a new wrapper. This method will be removed in 2.4
getModelFactory
protected ModelFactory getModelFactory(Class clazz)
getOuterIdentity
public ObjectWrapper getOuterIdentity()
By default returns this.
getStaticModels
public TemplateHashModel getStaticModels()
Returns a hash model that represents the so-called class static models.
Every class static model is itself a hash through which you can call
static methods on the specified class. To obtain a static model for a
class, get the element of this hash with the fully qualified class name.
For example, if you place this hash model inside the root data model
under name "statics", you can use i.e. statics["java.lang.
System"]. currentTimeMillis()
to call the java.lang.System.currentTimeMillis()
method.
- a hash model whose keys are fully qualified class names, and
that returns hash models whose elements are the static models of the
classes.
isExposeFields
public boolean isExposeFields()
- true if public instance fields are exposed, false otherwise.
isSimpleMapWrapper
public boolean isSimpleMapWrapper()
- true if Maps are exposed as simple hashes, false if they're
exposed as full JavaBeans.
isStrict
public boolean isStrict()
setDefaultDateType
public void setDefaultDateType(int defaultDateType)
Sets the default date type to use for date models that result from
a plain
java.util.Date instead of
java.sql.Date or
java.sql.Time or
java.sql.Timestamp. Default value is
TemplateDateModel.UNKNOWN
.
defaultDateType
- the new default date type.
setExposeFields
public void setExposeFields(boolean exposeFields)
Controls whether public instance fields of classes are exposed to
templates.
exposeFields
- if set to true, public instance fields of classes
that do not have a property getter defined can be accessed directly by
their name. If there is a property getter for a property of the same
name as the field (i.e. getter "getFoo()" and field "foo"), then
referring to "foo" in template invokes the getter. If set to false, no
access to public instance fields of classes is given. Default is false.
setExposureLevel
public void setExposureLevel(int exposureLevel)
Sets the method exposure level. By default, set to EXPOSE_SAFE
.
exposureLevel
- can be any of the EXPOSE_xxx
constants.
setMethodsShadowItems
public void setMethodsShadowItems(boolean methodsShadowItems)
Sets whether methods shadow items in beans. When true (this is the
default value), ${object.name}
will first try to locate
a bean method or property with the specified name on the object, and
only if it doesn't find it will it try to call
object.get(name)
, the so-called "generic get method" that
is usually used to access items of a container (i.e. elements of a map).
When set to false, the lookup order is reversed and generic get method
is called first, and only if it returns null is method lookup attempted.
setNullModel
public void setNullModel(TemplateModel nullModel)
Sets the null model. This model is returned from the
wrap(Object)
method whenever the underlying object
reference is null. It defaults to null reference, which is dealt
with quite strictly on engine level, however you can substitute an
arbitrary (perhaps more lenient) model, such as
TemplateScalarModel.EMPTY_STRING
.
setOuterIdentity
public void setOuterIdentity(ObjectWrapper outerIdentity)
When wrapping an object, the BeansWrapper commonly needs to wrap
"sub-objects", for example each element in a wrapped collection.
Normally it wraps these objects using itself. However, this makes
it difficult to delegate to a BeansWrapper as part of a custom
aggregate ObjectWrapper. This method lets you set the ObjectWrapper
which will be used to wrap the sub-objects.
outerIdentity
- the aggregate ObjectWrapper
setSimpleMapWrapper
public void setSimpleMapWrapper(boolean simpleMapWrapper)
By default the BeansWrapper wraps classes implementing
java.util.Map using
MapModel
. Setting this flag will
cause it to use a
SimpleMapModel
instead. The biggest
difference is that when using a
SimpleMapModel
, the
map will be visible as
TemplateHashModelEx
,
and the subvariables will be the content of the map,
without the other methods and properties of the map object.
simpleMapWrapper
- enable simple map wrapping
setStrict
public void setStrict(boolean strict)
Specifies if an attempt to read a bean property that doesn't exist in the
wrapped object should throw an
InvalidPropertyException
.
If this property is
false (the default) then an attempt to read
a missing bean property is the same as reading an existing bean property whose
value is
null. The template can't tell the difference, and thus always
can use
?default('something') and
?exists and similar built-ins
to handle the situation.
If this property is
true then an attempt to read a bean propertly in
the template (like
myBean.aProperty) that doesn't exist in the bean
object (as opposed to just holding
null value) will cause
InvalidPropertyException
, which can't be suppressed in the template
(not even with
myBean.noSuchProperty?default('something')). This way
?default('something') and
?exists and similar built-ins can be used to
handle existing properties whose value is
null, without the risk of
hiding typos in the property names. Typos will always cause error. But mind you, it
goes against the basic approach of FreeMarker, so use this feature only if you really
know what are you doing.
setUseCache
public void setUseCache(boolean useCache)
Sets whether this wrapper caches model instances. Default is false.
When set to true, calling
wrap(Object)
multiple times for
the same object will likely return the same model (although there is
no guarantee as the cache items can be cleared anytime).
wrap
public TemplateModel wrap(Object object)
throws TemplateModelException
Wraps the object with a template model that is most specific for the object's
class. Specifically:
- if the object is null, returns the
null model
, - if the object is a Number returns a
NumberModel
for it, - if the object is a Date returns a
DateModel
for it, - if the object is a Boolean returns
TemplateBooleanModel.TRUE
or
TemplateBooleanModel.FALSE
- if the object is already a TemplateModel, returns it unchanged,
- if the object is an array, returns a
ArrayModel
for it
- if the object is a Map, returns a
MapModel
for it
- if the object is a Collection, returns a
CollectionModel
for it
- if the object is an Iterator, returns a
IteratorModel
for it
- if the object is an Enumeration, returns a
EnumerationModel
for it
- if the object is a String, returns a
StringModel
for it
- otherwise, returns a generic
BeanModel
for it.
- wrap in interface ObjectWrapper