Jato & Struts

03-09-10 iceant

无意间看到 JATO 的作者写的这篇文章:

When I read your post, I was concerned that you were under some
misapprehensions, and so wanted to make some clarifications.

Before continuing, I want you to know that the decision to go with any
particular choice of architecture/implementation is entirely yours, and
we're fine with whatever you choose--if Struts is the right way to go in
your company, that's great. However, I'm not sure you're seeing the whole
picture when I hear you are considering a double migration, or a migration
from JATO to Struts.

> We use the STRUTS model-view-Controller implementation of APACHE. I
> believe it is quite possible to "take away" the JATO presentation
> layer and its taglibs. JATO offers a VIEWBEAN wrapper to contain the
> model object, which holds the STATE. The JATO presentation layer
> renders and manages this STATEobject/model through the wrapper.
> In STRUTS this is implemented quite similar. Has anybody tried to
> "take away" certain layers in JATO and replace them GRADUALLY to get
> to ANOTHER target architecture??

First, let me say that Struts is a fine set of classes for building your web
applications, and I have nothing against it--I don't want this message to be
viewed as a religious argument. However, I don't want you to hear Struts
say it's "MVC" and us say JATO is "MVC", and think that the two are
equivalent. Far from it. Let me explain some of the more obvious

Struts has a very different, narrower perspective of what makes up a view
than JATO does. In Struts, a view is nothing more than a JSP that uses the
Struts taglib. This is straightforward, and works great for simple pages,
but if you've used JSP at all, you realize that real world apps frequently
need to do much more complex rendering. JATO provides far richer facilities
to assist in the rendering of repeated/tiled regions a variable number of
times, perform conditional tests, dynamically rewrite large portions of HTML
at runtime, and construct complex HTML objects (combo, list boxes and radio
button groups).

JATO also provides an easy to use, powerful, and efficient event model which
allows developers to place more complex presentation logic inside of a
helper view bean class, where it belongs. Unlike Struts, this allows the
JSP itself to remain clean and free of code, which is consistent with widely
accepted best practices. The event model also promotes consistent,
structured develpment accross the application, since all developers will
work within the same well-defined development structure. Struts lacks an
event model of any kind, and therefore Struts developers will tend to embed
presentation control logic directly in the JSP. While this works for
simpler applications, it can easily get out of hand and lead to an
unmaintainable mixture of HTML and presentation logic.

While Struts does a good job of supporting localized dynamic values, it
doesn't provide any support for using localized parallel content. Parallel
content is the idea of using different JSPs localized for a different
language, or written using different markup than HTML, like XML or WML. For
example, if you need to add a parallel page that renders a French version of
a given page in Struts, the embedded display logic from the original page
would need to be included and maintained in the parallel page. This
compounds any maintentance issues with the original page. JATO, however, by
factoring display logic out of the JSP and allowing views to dynamically
decide which view to display to the client, allows transparent switching
between parallel content. This capability ensures that the presentation
logic of the application exists in only one location regardless of the
content rendered to the client.

Struts also has very little room for reusability beyond large, coarse chunks
of code (actions & form beans). There is no provision for hierarchies of
views or forms, fine grained view objects & events, nor any facility for
reusing portions of a view in other views. All of this, however, is built
into the core of JATO, meaning that you define building blocks (think "web
beans") that can be arbitrarily composited to form functional web
applications, much as you would composite Swing graphical components to
create a client-side Java application.

One example is that each HTML form in Struts must be associated with a
single, flat ActionForm bean, meaning that portions of that form cannot be
reused anywhere else in the application (or another application for that
matter). One real world application we encountered recently has a single
page with upward of 250 display fields, arranged in a hierarchy of over 30
tiled views. Imagine the complexity that would be necessary to replicate
this in a single Struts ActionForm bean, including all the necessary flags
needed to control conditional rendering of that form; however, the JATO
version has separate classes for each of the container views, providing
scope to the fields contained within, and which can be rearranged and reused
as desired.

Struts provides no formal notion of a model. Instead, anything not
specified by Struts is considered a "model"--a very loose definition prone
to interpretation by every project and developer. This leaves you, the
developer, to write all the manual code to obtain data, and hook up your
view so that it can display that data. It also provides no contract between
the Model and the View-Controller components of the architecture, so that
interaction between them is limited or custom to each project or page.

JATO, however, formalizes the concept of what a model is and does, and how
controlling logic interacts with it. Lots of different things can be viewed
as a model--a SQL query, an EJB, an individual EJB method, a SOAP procedure,
the HTTP session, a JavaBean... you get the idea. JATO provides a standard
way for controller *and* view logic to interact with a model, and thus this
interaction can be automated.

For example, JATO formalizes SQL queries as QueryModels. QueryModels can be
automatically executed in response to a high-level user action or on the
display of a page, without any developer code necessary to manage the
execution or its results. By contrast, if you want to execute a query in a
Struts application, you write regular JDBC code...and then you write it
again, and again, and so on, everywhere you need to access the database.
There is no facility for automatically managing SQL statements, dynamic
user-level WHERE clause criteria, multiple rows of result set data,
connections, etc. JATO provides all of this--if you want it--out of the
box. Or you can do exactly what you'd do with Struts (or for that matter,
what you'd do in any J2EE application) in JATO. The difference is that in
JATO, you have the choice, where with Struts, you always have the task if
implementing it yourself--and you *will* have to implement this in order for
enterprise development to scale.

Finally, realize that Struts and JATO, though very different, are compatible
in two ways. First, the JATO development model essentially collapses to the
Struts development model if you don't use any of the additional features
JATO has to offer. JATO gives you a wide range of features to choose from,
both low- and high-level, but only prescribes a very minimal set that is
equivalent to that prescribed by Struts. Second, both JATO and Struts
applications are just J2EE, so there doesn't have to be a pitched idea of
one versus the other within an application. The JATO 1.1 documentation
lists several ways of interoperating with a JATO application from outside or
within any other J2EE application.

In summary, J2EE development using Struts is a small subset of J2EE
development using JATO. If Struts is compatible with your internal
architecture, so is JATO, meaning that there's nothing in JATO that would
prevent you from doing the same things you would do in Struts. However,
JATO gives you much expanded options and a more logical and flexible
contract between application entities that make your applications more
consistent, quick to develop, and easy to maintain.

So, while you could probably find a way to rip out portions of your migrated
JATO application and replace them with Struts, I don't know how that would
be beneficial at all. Not only would you be giving up all the additional
power that JATO provides that Struts does not, but doing so for little more
than unnecessary consistency.

Inevitably, frameworks will differ based on the tasks and problems they try
to address. JATO was designed and built to be enterprise strength,
extensible, fast, and rich. In short, Struts and JATO are two very
different frameworks, and the two can't be compared as if they were
equivalent. Please don't make this mistake during your migration