Java Pattern Oriented Framework (Jt 2.6)


News: Java Pattern Oriented Framework (Jt 2.6)

  1. Java Pattern Oriented Framework (Jt 2.6) (3 messages)

    Jt2.6 has been released. Jt is a pattern oriented framework for the rapid implementation of Java 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. Jt2.6 features several enhancements to the Jt components and a version of the Jt automated Wizard (JtWizard). The Jt Wizard is an application built on top of the Jt framework that provides automated capabilities for generating framework applications. The Jt Wizard is able to automatically generate application modules based on several design patterns including Jt Messaging, DAO, MVC and GoF. The current Jt Wizard implementation provides integration with MVC Struts and DAO Hibernate. DAO mapping files, Struts configurations files, Views (JSPs), Java classes are automatically built by the Jt Wizard. The Jt Wizard is also a reference web application implemented using the Jt framework. The framework addresses the following goals and requirements: A) The pattern oriented framework should implement and/or facilitate the implementation of well-known design patterns like GoF design patterns and J2EE Design patterns. The framework itself should be conceived and implemented based on design patterns (from the ground up). The framework should also facilitate and accelerate the implementation of applications based on design patterns. B) The framework architecture should be based on a messaging design pattern: framework objects should be able to interchange information and perform computations by sending, receiving and processing messages. A messaging API provides strong encapsulation and loose coupling; framework components can be easily plugged into complex framework applications using a “lego/messaging” architecture. The framework should take full advantage of the power and simplicity of the messaging design pattern. C) The framework lego/messaging architecture should provide transparent access to remote components: remote framework objects should be treated as local objects. Design patterns implemented by the framework (adapters, remote proxies and facades) should make this posible by hiding the complexities associated with remote APIs. D) The framework should provide transparent integration with other technologies via framework adapters, proxies and the implementation of related design patterns. These technologies include BPM, DAO implementations, MVC implementations, EJBs, JMS, XML and Web Services. E) The framework should be designed to be lightweight and fast in terms of performance (low overhead). F) The framework messaging/lego architecture should improve and simplify design/development efforts. There should be a tight correspondence between UML design diagrams and the framework messaging based applications and components needed for the implementation. Ideally, the framework should provide wizards and automated capabilities for generating framework applications. Framework components should be easily added to BPM process diagrams. In future versions of the framework, it should be possible for applications to be generated directly from the UML design diagrams. G) The framework messaging architecture should facilitate testing and debugging efforts. The framework should provide capabilities for testing components independently (each component as a unit) by sending messages and verifying the reply (output) messages. H) In order to provide additional productivity benefits, the framework should be integrated with open source IDEs. Most of these requirements are met by the current version of the framework (refer to list of features). Additional features include: * 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 implementing additional Jt adapters and helpers. * Web Services integration via the implementation of Web Services adapters and proxies. The Jt messaging API greatly simplifies the development and deployment of web services. * Integration with Ajax and the Struts implementation of MVC (Model View Controller)). 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. * Integration with the Hibernate implementation of Data Access Objects (DAO). A Jt adapter provides a transparent interface between the Jt framework and Hibernate DAOs. * JDBC integration via a JDBC adapter. * The Command pattern implementation supports a request log, a queueing mechanism and undoable operations. * JavaMail API integration via the implementation of a JavaMail adapter * Integration with J2EE Enterprise Java Beans (EJBs) via Jt Adapters and proxies. 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) integration. * Integration with the XML APIs via XML adapters, helpers and built-in bean/XML mapping capabilities. * Built-in logging/debugging capabilities. Messages between framework objects are automatically logged. This simplifies the debugging and testing tasks. * Built-in testing capabilities. * Efficient and lightweight in terms of memory utilization. * The Jt Framework provides a consistent way of handling and logging application messages, errors and exceptions. * Proven technology. The Jt framework has been used for the development of several large enterprise applications. * Integration with the asynchronous Java Message Service (JMS). Jt messages can be sent and received via JMS adapters. * Cross-platform, implemented using JavaTM technology. * Integration with the Eclipse environment. * Runs on any J2EE compatible application server. For additional information please refer to Jt online documentation can be found at
  2. Java Pattern Oriented Framework (Jt 2.6)[ Go to top ]

    I tried to download this from It does not work. How to download this
  3. URL for the link is wrong.[ Go to top ]

    the current URL is\ProjectDocumentList change to below url it will work
  4. Such a buzzword-rich announcement deserves attention. Being interested in magic wands of rapid development, I spent an hour or so on reviewing this, here are my findings. * The author tries to bring the message out of this, but there are still low public interest and replies according to the press announcements, * Jt release history ( ) is really good, with one release per month. I did not find any information of how many developers are working on this open source project. It seems this project does not use the mailing lists, which does not enable us to see developer activity, like 'have many commits been done the last months?' * The JtWizard guide shows how relatively easy it is to make a CRUD application with this framework. Impressive indeed. Coming short of many of the buzz words, I fail to really know how easy this framework makes the development. If this is as good as it smells, why aren't more people investigating it? Maybe the author should start replying to the comments to this thread? There are a few critics and they seems to largely go unnoticed by the author. I wish I had the knowledge of knowing all the buzz here. I indend to try the JtWizard on next occasion.