has been released. Jt is a lightweight pattern oriented framework for the rapid implementation of J2EE applications. Jt has been utilized in several large mission critical systems. Jt implements many well-known patterns including Data Access Objects (DAO), GoF design patterns and J2EE patterns. This framework supports several BPM and J2EE technologies including Struts, Java Server Pages (JSPs), AJAX, JDBC, EJBs, JMS, JavaMail, XML and Web Services.
Jt1.8 features integration with the Hibernate implementation of Data Access Objects (DAO). A Jt adapter provides a transparent interface between the Jt framework and Hibernate DAOs.
Additional features include:
- Jt implements many well-known design patterns. This includes Data Access Objects (DAO), adapters for several J2EE APIs, Gang of Four (GoF) design patterns and J2EE patterns.
- Jt implements a messaging pattern/API: framework objects are able to interchange information and perform computations by sending, receiving and processing messages. The messaging paradigm provides additional encapsulation and software simplicity. The messaging API implemented by the Jt Framework is very simple: very few calls are required to create, manipulate and destroy messages and objects. On the other hand, this API is very powerful.
- Implemented J2EE design patterns include J2EE business delegate, J2EE Session Facade, J2EE Service Locator and J2EE Value Object.
- The framework can be easily extended by adding additional Jt adapters and helpers.
- Web Services support via the implementation of a Web Services adapter. The Jt messaging API greatly simplifies the development and deployment of web services.
- Support for business process modeling (BPM). A jBPM adapter is provided within the Jt framework. jBPM is an open source implementation of the BPM technology. A Jt application can now be modeled using a process graph. This provides users with a very powerful way of modeling business processes.
- Integration with the MVC (Model View Controller) design pattern and Ajax. Universal Jt components and adapters provide a transparent interface between the Jt framework API and these technologies. The business logic (controller piece) can be implemented using Jt framework components and/or BPM business processes.
- Support for the JDBC API via a JDBC adapter.
- The Command pattern implementation supports a request log, a queueing mechanism and undoable operations.
- JavaMail API support via the implementation of a JavaMail adapter.
- Support for J2EE Enterprise Java Beans (EJB) via Jt Adapters. EJB clients are able to gain transparent access to remote framework objects. No need to deal with the complexities of EJB application development. An implementation of the J2EE Service Locator pattern is also provided.
- Easy customization of framework applications. This is done via resource files: object attributes can be automatically loaded from a resource file.
- Java Server Pages (JSP) support.
- Support for the XML API via XML helpers. Framework objects can be converted to/from the XML format.
- Built-in logging/debugging capabilities. Messages between framework objects are automatically logged. This simplifies the debugging and testing tasks.
- Built-in testing capabilities.
- The Jt Framework provides a consistent way of handling and logging application errors and exceptions.
- Proven technology. The Jt framework has been used for the development of several large enterprise applications.
- Support for the asynchronous Java Message Service (JMS). Jt messages can be sent and received via JMS adapters.
- Cross-platform, implemented using JavaTM technology.
- Runs on any J2EE 1.4 compatible application server.
Jt's online documentation can be found at http://www.fsw.com/Jt/Jt.htm
. An excerpt:
Freedom Jt implements a messaging pattern: Jt Objects are able to interchange information and perform computations by sending, receiving and processing messages (i.e. Jt Messages). This pattern is similar to the Gang of Four (GoF) Command pattern. Jt Objects can send and receive messages to/from other objects. These messages, general in nature, may contain any type of information. Often, Jt Objects are instructed to perform computations based on these messages. After processing each message, a reply message is returned. Although quite simple, this messaging pattern is very powerful. It can be used to implement the functionality provided by many other design patterns and APIs. Additionally, it can be used as a wrapper (adapter) for other APIs such as EJBs, Web Services, JMS, etc. It also provides stronger encapsulation and loose coupling. Notice that by using this messaging pattern, we don’t need to know the methods implemented by a particular object or what methods and parameters are needed in order to perform a computation. We just need to know what messages the object is able to understand/process and what type of message (reply) should be expected. This is consistent with a black box type of behavior. Only the characteristics of the input and output messages are known.
Jt objects are basically Java beans with attributes and methods to set/get the value of these attributes. Jt Messages are Jt Objects. Jt Objects interchange messages by using this type of object. Jt Messages contain basic message information: (message ID, subject, content, etc.). Once the receiving object processes a Jt Message, a reply message is returned.