Read on... and you'll discover that you can do the same in about half the time.
SwiXAT is a Swing-based authoring tool for the quick and easy development of GUI Java applications.
It implements out-of-box a true MVC framework and uses XML to define the view
(SwiXml is used as the XUL engine),
BeanShell as a scripting language for the controller, and
JXPath as the binding mechanism between
the view and model.
It provides a complete environment in which it is possible to almost write an entire Java Swing
application without writing Java compiled code.
The use of XPath makes it very simple to traverse the object tree of the application's business model.
You can start to build a new application in few minutes!
Read here to get started.
To learn more about SwiXAT you can read the
User Guide (pdf)
or the on line Tutorials.
It takes a lot of work to develop a Swing application, laying out and configuring GUI components,
and then integrating them with the application functionality. SwiXAT addresses both of these issues
by providing a framework based on a complete implementation of the MVC architectural pattern.
The benefits obtained by a such framework are the followings:
Architectural Correctness:
By adopting a true MVC (Model View Controller) based framework, it is very easy to correctly
implement any UI application. It's not difficult to write a Java/Swing application, but what's
very difficult is to build a good, well designed Swing application, where the adoption of the
MVC paradigm permits to reduce the maintenance costs, thanks to the clean separation between
the view and the application logic.
Development Speed:
The adoption of a framework reduces the development cost by providing out-of-box, well integrated
and easy to use common features, like wizards, plugins, support for MDI interfaces, etc. Moreover,
the use of XML to define the user interface, as well as the adoption of an interpreted scripting
language, permits to implement the 'Code&Test' development style, where the compilation time is reduced
to zero.
Code Reuse:
The net separation between the view and the control logic permits to write reusable modules that
can be combined in several manners. The developer is naturally induced to modularize the application
and write reusable code, minimizing the effort of building new applications or adding new functionality
to existing ones.
SwiXAT is all the above, and we hope you'll appreciate our effort.
Do not start from scratch, but climb on the shoulders of the Giants
SwiXAT represents simply the glue to combine together the last available java technologies based on
well known and accepted architectural patterns.
The following picture illustrates the overall architecture on which SwiXAT is based, in terms of the
libraries used and how they collaborate to make SwiXAT a complete and powerful framework:
The main elements involved in any application built on top of SwiXAT are the following:
The View is based on the XUL paradigm, where the design of the UI interface is made by
writing XML tags instead of Swing Java code. XML permits to write less code respect to the equivalent
java statements needed to build the same user interface. SwiXML is the XUL framework chosen for this
purpose, mainly due to its fundamental characteristics like the robustness and extensibility.
The Controller handles requests and creates or prepares the response. Typically controllers
need access both to the View and to the business logic (the Model). Controllers handle the request
by instantiating a command object, passing it request parameters. The Controller can delegate the execution
of the control logic either to script code based on the BeanShell
interpreter (as of SwiXAT 0.3.0 we have added the support for the Groovy language), or to
compiled java code, as we leave the developer free to choose how to write the control logic.
The Model, represented by your own data model and/or object model, is accessed by specific
data sources, that represent the bridge between the Model and the View/Controller parts.
Some pre-built data sources already exist, but they're easily extensible, and anyone can build a new
one to access to any specific data format. In order to permit to navigate the business model obtained
by a data source, we use XPath, a very powerful query language used to traverse DOM trees.
All the above components are kept together by the Spring Framework, a complete and powerful implementation of the Inversion of Control
(or "Dependency Injection") design pattern. The Spring IoC implementation permits to define
within an XML file all the components needed by the application (along with all their dependencies),
in order to define and access in a easy manner to all the application's parameters.
In order to build an application, the developers need only to write the external files containing
the needed XML code (to define both the application context and the views) and JavaScript code
(to write the control logic), depicted in the above figure with white boxes.
