a typed template engine for Java
type safe templating
Jamon has a rich feature set to support encapsulation,
parameterization, functional decomposition, and reuse of
Since rendering logic may be arbitrarily complicated
(e.g. rendering hierarchical data such as a recursive
directory structure), this logic needs to be expressable in a
Turing-complete language. Rather than invent yet another
language, use Java itself inside the presentation
framework. Jamon helps keep the rendering logic in the
presentation layer technology.
Jamon templates declare the arguments required for
rendering. This provides a well-defined contract between the
presentation layer and the application.
Jamon allows passing arbitrary objects between templates
(only Tea seems
to provide this capability). Jamon templates can pass
arbitrary dynamic content (i.e. template fragments) as
parameters to other templates. (In fact, Jamon allows
passing parameterized fragments, i.e. templates
can be "higher-order".)
Templates are compiled into Java and then into bytecode, and are
referred to in application code just like any other Java class.
See the overview for a simple but
complete working example.
Templates are translated into Java classes with public methods
whose signatures reflect the arguments declared in the
templates. This provides compile-time type-checking as well as
During development, changes to template sources at runtime
trigger dynamic retranslation and recompilation of the
templates. This dynamic recompilation can be turned off for
Jamon is general-use in the sense that it can produce any
arbitrary text output format (for contrast,
Enhydra XMLC and Zope are tied to HTML or
XML). Consider "views" such as generating text and / or
multipart MIME email, or program source code.