Moving Beyond SOA and Frameworks with

JSFBuilder - The Next Step in Computing!

1. JSFBuilder Can Assist Business IT Departments to Move Beyond Service Oriented Architecture to Provide What is Really Needed - A Rewriting of Legacy Applications.

In the past several years, much has been written about the advantages of using a Service Oriented Architecture (SOA) in order to meet the business need presented by aging software and hardware. By putting an interface on top of old applications, SOA allows new software to more easily integrate with old legacy systems, allowing a maintenance upgrade without digging into the old code base. Since the old code base works well, but is written with software and hosted on hardware that is dated, it makes some sense to use a SOA approach to maintenance and upgrades. Expertise on the old systems is hard to come by, so SOA allows improvements while using modern skills and equipment.

But SOA has a weak underbelly that will, eventually, come back to cost businesses severely. Underlying the whole SOA principle is the fact that the aging software and hardware still forms a critical piece of the business technology stack. While SOA does allow the business to stop tweaking that portion of the stack, it does not replace that stack. Eventually the hardware that supports that stack will itself become a problem for the business. And the older it gets, the more difficult it is to find replacement parts and the people to work on it, adding great risk to the business.

In contrast, JSFBuilder Applications allow the business to get an enormous head start on the true need of business, which is that of REWRITING THEIR APPLICATIONS into a modern language that can be hosted on modern hardware. Once rewritten, the business intelligence no longer needs to rely on ancient hardware and software, assuring the business of ample supplies of both equipment and support staff available in the existing open markets. Having Java applications written against an Oracle database greatly reduces the cost and risk associated with critical business applications.

2. JSFBuilder Applications Do Not Involve Another New Framework and unlike Frameworks and Code Builders, JSFBuilder Provides Business with Fully Complete Applications.

The problem with code generators is that they usually only build a portion of what is needed, and may or may not integrate easily with other portions of the project. While they do save a lot of time and money, they are typically just one piece of the puzzle. Frameworks go further than simple code generators, by providing components as well as a layer of code structure for handling interactions between those components. But there is still a considerable development effort left when using frameworks, as the component code pieces must be assembled and integrated together by the development staff. Some development may also require access to the framework via the provided interfaces, which require the development staff to understand and learn the framework API. Nonetheless, frameworks are a significant step beyond code generators, in that they provide jars of code already in place and partially integrated with the application, and ideally frameworks provide a "plug and play" relationship for the components of the framework, thus greatly shortening the development cycle.

Due to the present state of the computational art, there may be some apprehension that JSFBuilder will employ another new computing framework that must be learned by the development staff. This is not the case. Instead, JSFBuilder makes use of two popular free frameworks.

One of the best thin-client UI frameworks in the market today is the freely available Java Server Faces (JSF). JSF has such a nice set of UI components for user interaction that the usual advantage of thick clients is mitigated, allowing the full advantages of thin-client architecture to be realized with minimal downside. JSF is superior in many ways to Struts, especially in the arena of its faces-config.xml file, which allows for very simple and intuitive rewiring of application page flow. JSF has a better separation of model, view and controller layers than Struts. JSF also has a better naming scheme that helps developers avoid confusion. (In Struts many of their classes contain the word "Action" which tends to be confusing).

Hibernate is a very good ORM framework and it, like JSF, is free. Hibernate is a framework with wide acceptance in the Java community.

But even with the use of the JSF and Hibernate frameworks, the development of a sophisticated java application can take years to develop - even with an excellent staff of java developers. Typically, the application must also provide some high level data filtering and a security layer as well, and all of this requires development time and effort. JSFBuilder is based on the fruits of two years of labor involved in building a complex JSF/Hibernate application. The essential pieces that are common to the vast majority of applications have been identified and we at JSFBuilder have written tools that can together build an entire JSF/Hibernate application with minimal hand coding. A front end application has been developed to enable users to easily specify their custom entities and relationships, and we can take that input and quickly produce both a deployable war file and a MyEclipse-compatible source code tree. After setting up the basics which include the Tomcat server, Java, and Oracle, the customer need only drag and drop two war files into place and run a few set-up scripts to have a completely functional application up and running. By additionally setting up MyEclipse,the customer will also have full access to the source code should any maintenance or upgrades be desired.

3. What JSFBuilder Provides.

3.1. JSFBuilder does the jobs of JSF Framework Developers in the View Layer:

3.1.1. Assembling the JSF framework components into Java Server Faces pages (written as Java Server Pages, using Java Expression Language, JSF tags, JSP tags and custom JSF tags see section 3.3 where appropriate);

3.1.2. Writing the JSF config files (which identifies the routing of requests to the servlet engine, declaring the managed beans to the JSF framework, declaring renderers to the JSF framework, and providing the wiring instructions for page to page navigational control);

3.1.3. Writing the properties file that identifies labels used in the application (for single point of change control over labels, rather than having them embedded throughout the source code);

3.1.4. Writing the "glue beans" or "backing beans" necessary to serve as a link between calls on the jsp page and access of the data within the DTO layer. (All backing beans are architected from a solid abstract and base class hierarchy for both the stand alone and master/detail varieties);

3.1.5. Writing of a custom validation layer for user-input validation; with code shells in place so that developers can fill in specific business validation rules, if desired.

3.1.6. Writing of cascading style sheets for easy global customization of the application's "look and feel".

3.2. JSFBuilder does the jobs of Hibernate Framework Developers in the Model Layer:

3.2.1. Writing DTO bean classes for encapsulated data entities;

3.2.2. Writing DAO classes that handle the population of the DTO bean classes through use of the Hibernate Framework.

3.2.3. Writing the Hibernate mapping file(s) to link the DTO beans to database tables through the Hibernate Framework engine;

3.2.4. Writing the Hibernate config file(s) to configure the Hibernate Framework for proper database connections and other specifications.

3.3. JSFBuilder does the jobs of Custom Tag Developers:

3.3.1. Writing a Menu Bar custom JSF tag;

3.3.2. Writing a Bottom Scroll Bar custom JSF tag;

3.3.3. Writing a custom JSF tag to handle security;

3.3.4. Writing a custom JSF tag to handle column sorting on the List Screen;

3.3.5. Writing a custom JSF tag to handle tab functions on child view screens.

3.4. JSFBuilder does the jobs of Application Integrators:

3.4.1. Writing of the web.xml file;

3.4.2. Writing of the config.xml file;

3.4.3. Including the datasource definition within the web.xml and config.xml files to allow communication with the database;

3.4.4. Importing of all appropriate jar files into the code base of the project;

3.4.5. Preparation of build.xml and build.properties files for automated project builds.

3.5. JSFBuilder does the jobs of Application Integrators:

3.5.1. Putting all of the above efforts into coordinated projects directly readable by MyEclipse, a widely used, inexpensive IDE, to allow for ready extension. The result is a fully functional, fully integrated application wherein all the above parts work together seamlessly, with a clear and easy path for future upgrades if desired.

3.6. JSFBuilder does the job of a DBA:

3.6.1. Writing the statements needed to set up Administrator roles for each top level filter grouping of the data. The statements are run against an associated security schema that has its own user-friendly application wherein access level can be set on a page by page basis for roles, with roles assigned to users.

4. Summary.

In the end, JSFBuilder provides the customer with a complete application, including high level filtering of data and a fully populated, page by page, security system. Of course, JSFBuilder has made many specific choices in the application that it produces. And while these choices are those that are typically needed for a wide variety of applications, in many cases some extension of the application may be desired. But even in those cases where it is desired to extend the JSFBuilder written application, JSFBuilder will save enormous development effort for the following reasons: 1) Since JSFBuilder writes the application with standard, freely available, JSF and Hibernate frameworks, it is readily extendable by developers familiar with those frameworks should further customization be desired; 2) large swaths of applications typically need an administrator and user layer that has the database access and security features provided out-of-the-box by JSFBuilder; and 3) the existing code produced by JSFBuilder can serve as an excellent starting point for any extensions, and it is in a format readily importable into a widely used and popular IDE.

JSFBuilder produces a fully functional, extendable, application for a fraction of normal development cost, and with an absolute minimum of development time. JSFBuilder truly is the next step in application development. Start saving money and time today!




Contact Information

Send an e-mail to sales@jsfbuilder.com to start the process of ordering your custom software.