JDynamiTe is a tool which allows you to dynamically create documents in any format from "template" documents.
And very few lines of code (or no line at all!) are needed to do that.
Some typical usage domains of JDynamiTe are:
- dynamic Web pages creation,
- text document generation,
- source code generation...
In fact, it can be useful in any case where pre-defined documents (templates) have to be dynamically populated with data.
The main benefit of JDynamiTe is to allow a true separation between data (content), presentation (container) and content generation code (written in Java).
JDynamiTe does not include a specific template language, and it is not a complete framework.
It is a simple "brick" in your software architecture, a "glue" between your data model and your presentation model.
JDynamiTe is a Java package, which is designed to be flexible and open.
For more details and a lot of examples, visit the homepage here: http://jdynamite.sourceforge.net
- You only need one class and few methods to parse and develop dynamic documents from templates (see examples).
- These template documents can be in any text (ascii, unicode...) format.
- There is no "template language", no control structure (such as "for", "while" ...) to add in templates.
- JDynamiTe only needs to recognize three kinds of tag in the template document ("Variable", "Begin Dynamic Element", and "End Dynamic Element").
- Any syntax can be redefined (using regular expressions), if needed, for these tags. For example, with HTML template document (default syntax), the tags are enclosed within HTML comments.
- A "Dynamic Element" is a "block" which can be dynamically developed. Examples of use: list, table, enumeration, etc... See documentation JDynamiTe API documentation for more details.
- Since JDynamiTe 2.0, there is a new kind of Dynamic Element: "XML Dynamic Elements" allow to automatically populate the template taking input from XML files. In other words: you can add special tags in your template, using standard XPath syntax, which refer to data contained in an external XML file. By this way, no need to programmatically populate this block of data: JDynamiTe parser automatically does it for you. Find several examples in the new dedicated examples page.
- JDynamiTe 2.0 provides a new tool : JDynTool, which is based on JDynamiTe package, and also usable by command line invocation.
- JDynamiTe enables template reuse (input template reading once for multiple dynamic generations).
- It also enables Dynamic Elements nesting (e.g. to create list of lists).
- An optional tag is available that allows inserting "ignored blocks" in the template document. You can insert in your template "real" data into this special kind of blocks, simulating a more realistic rendering, which can be a useful working document for designers. These block contents are completely ignored during template parsing.
Be the first to post a review of JDynamiTe, Dynamic Template in Java!