Who wrote Struts?
Location: http://www.jguru.com/faq/view.jsp?EID=469786
Created: Aug 5, 2001
Author: Ted Husted (http://www.jguru.com/guru/viewbio.jsp?EID=462042)

Struts was created by Craig R. McClanahan, and donated to the Apache Software Foundation in May 2000. Craig actively leads the Struts project, and is also the lead developer on the Tomcat 4.0 project. There are now several committers to the Struts project, working cooperatively from around the globe. Other Java developers are invited to contribute to the project. Struts is an Apache Jakarta project, with the common mission to "provide commercial-quality server solutions based on the Java Platform that are developed in an open and cooperative fashion". 

How is Struts licensed?
Location: http://www.jguru.com/faq/view.jsp?EID=469787
Created: Aug 5, 2001
Author: Ted Husted (http://www.jguru.com/guru/viewbio.jsp?EID=462042)

Struts is copyrighted software available under a "free-to-use-license" by the Apache Software Foundation. The license appears at the head of every source code file. A reference copy of the license is available here.

Is Struts compatible with other Java technologies?
Location: http://www.jguru.com/faq/view.jsp?EID=471929
Created: Aug 8, 2001
Author: Ted Husted (http://www.jguru.com/guru/viewbio.jsp?EID=462042)

Yes. Struts is committed to supporting industry standards. Our lead developer is a member of  JSR052, Sun's Expert group for developing a standard library of custom JSP tags. A primary design criteria is that Struts must be compatible with Sun's J2EE platform for corporate enterprises. In fact, Struts really acts as an integrator of Java technologies, so that they can be used in the "real world".

Where can I get help with Struts?
Location: http://www.jguru.com/faq/view.jsp?EID=471930
Created: Aug 8, 2001
Author: Ted Husted (http://www.jguru.com/guru/viewbio.jsp?EID=462042)

The Struts package comes complete with a users guide to introduce people to the framework and its underlying technologies. Various components also have their own in-depth developers guide, to cover more advanced topics. Of course, standard "JavaDocs" are included along with the full source code. The Strut's mailing list is also very active, and welcomes posts from new users. As a testament to its growing popularity, Struts users are also posting their own tutorials and resource pages, including those at Husted dot Com and Bluestone Software. Articles about using Struts have appeared in JavaWorld, InformIt, and JavaReport. MyWebAppCarbaret also offers free hosting of Struts applications, complete access to a MySQL database.

Where I can I get a copy of Struts? 
Location: http://www.jguru.com/faq/view.jsp?EID=471931
Created: Aug 8, 2001
Author: Ted Husted (http://www.jguru.com/guru/viewbio.jsp?EID=462042)

The best place to download Struts is at jakarta.apache.org/struts. The nightly builds are very stable, and recommended as the best place to start today.

How do I install Struts?
Location: http://www.jguru.com/faq/view.jsp?EID=471932
Created: Aug 8, 2001
Author: Ted Husted (http://www.jguru.com/guru/viewbio.jsp?EID=462042)

To develop applications with Struts, you can usually just add the Struts JAR file to your Java development environment. You can then start using the Struts classes as part of your own application. A blank Struts application is provided, which you can just copy to get a quick-start on your own brainchild. Since the full source code for Struts is available, we also provide complete instructions for compiling your own Struts JAR from scratch. (This is actually easier that it looks!) Your Struts application can be usually be deployed using a standard WAR file. In most cases, you simply deposit the WAR file on your application server, and it is installed automatically. If not, step-by-step installation instructions for various servlet containers are available.

When do I need "struts.jar" on my classpath?
Location: http://www.jguru.com/faq/view.jsp?EID=471933
Created: Aug 8, 2001
Author: Ted Husted (http://www.jguru.com/guru/viewbio.jsp?EID=462042)

When you are compiling an application that uses the Struts classes, you must have the "struts.jar" on the classpath your compiler sees -- it does not have to be on your CLASSPATH environment variable. Why is that an important distinction? Because if you are using a servlet container on your development machine to test your application,  the "struts.jar" must not be on your CLASSPATH environment variable when running the ontainer. (This is because each Web application must also have their own copy of the Struts classes, and the container will become confused if it is on the environment path as well.) There are several general approaches to this issue:

• Use ANT for building your projects -- it can easily assemble classpaths for the compiler. (This is how Struts itself is built, along with Tomcat and most other Java-based projects).
• Use an IDE where you can configure the "class path" used for compilation independent of the CLASSPATH environment variable.
• Use a shell script that temporarily adds struts.jar to the classpath just for compilation, for example
   javac -classpath /path/to/struts.jar:$CLASSPATH $@

How do I authenticate users with Struts?
Location: http://www.jguru.com/faq/view.jsp?EID=471934
Created: Aug 8, 2001
Author: Ted Husted (http://www.jguru.com/guru/viewbio.jsp?EID=462042)

You can use either container-based security or form-based security to authenticate users. With container-based security, the Web browser will track the logins for you, and "replay" the credentials to the server whenever they are required. If a browser hasn't been authenticated yet, it will automatically display a simple login form. If the login passes, the user's original request will proceed. This will also work properly if a user tried to POST from a form to an action URI in a protected area. Once the browser is authenticated, the POST proceeds normally. For applications that manage their own logins, it is probably easier to insist that every single page test for an authenticated user first, and redirect to the login page if not. The Struts example application does this -- partially by use of an application-specific custom tag (app:checkLogon) that performs this check at the top of every page. The tag is application-specific, because the notion of what constitutes a "logged on user" is application specific as well.

Can I use precompiled JSPs with Struts?
Location: http://www.jguru.com/faq/view.jsp?EID=471935
Created: Aug 8, 2001
Author: Ted Husted (http://www.jguru.com/guru/viewbio.jsp?EID=462042)

There is nothing about Struts that would care about precompiled versus not precompiled JSP pages, but the details of how you set them up depends on the servlet container you are using. With Tomcat, for example, running the "jspc" command line tool will compile all your pages, but it will also create a bunch of lt;servlet> and <servlet-mapping> tags that need to go into your web.xml file. In particular (at least for Tomcat), though, the path of a JSP page does not change when you use precompiled pages. The reason this works is that the compiler generates a servlet mapping for "/jsp/awsMain.jsp" for you -- and, because this is an exact match, it has higher priority than extension mapping on "*.jsp", which would send the page back to the JSP servlet. Try leaving the path for the compiled case the same as the path for the uncompiled case, and make sure that you've included the necessary stuff in web.xml.

Can Struts be used in a commercial product?
Location: http://www.jguru.com/faq/view.jsp?EID=471936
Created: Aug 8, 2001
Author: Ted Husted (http://www.jguru.com/guru/viewbio.jsp?EID=462042)

Yes. The only requirements you must meet are those listed in the Apache Software Foundation license, which is included at the top of each source file and in the file LICENSE in the top-level directory of the distribution. In addition, contributions of patches, improved code, new features, or even just requests for features are also welcome.

How can I contribute to the development of Struts?
Location: http://www.jguru.com/faq/view.jsp?EID=471937
Created: Aug 8, 2001
Author: Ted Husted (http://www.jguru.com/guru/viewbio.jsp?EID=462042)

Struts is distributed by the Apache Software Foundation. These are the same people who distribute the Apache Web server. Like all ASF projects, Struts is managed as a "meritocracy", where everyone's contribution is welcome. Users can help other users on the mailing lists, report bugs, and request new features. Developers can contribute patches, new code, and documentation. The most active Developers may become Committers, who make the actual decisions about the Strut's codebase. You can start by joining the Struts User list. If you enjoy participating there, then sign up for the Struts Developer list too. If you find any problems with Struts, or find a missing feature, you can enter a record to our Bugzilla database.

What's the difference between Jakarta Struts and Jakarta Turbine?
Location: http://www.jguru.com/faq/view.jsp?EID=471938
Created: Aug 8, 2001
Author: Ted Husted (http://www.jguru.com/guru/viewbio.jsp?EID=462042)

See:  

• < http://www.mail-archive.com/struts-user@jakarta.apache.org/msg03206.html >
• < http://www.mail-archive.com/general@jakarta.apache.org/msg00495.html >
• < http://jakarta.apache.org/velocity/ymtd/ymtd.html >

Is there a large degree of XML in Struts? Can you swap a stylesheet and switch form HTML to WML?
Location: http://www.jguru.com/faq/view.jsp?EID=471939
Created: Aug 8, 2001
Author: Ted Husted (http://www.jguru.com/guru/viewbio.jsp?EID=462042)

The Struts form tags are very much HTML oriented, because they only know how to generate HTML-style forms. One of the major focuses of 1.1 will be better integration with XML in many directions, including an investigation of using things like XPath, XForms, and so on. For integrating XSLT transformations, I would suggest utilizing the "xsl" tag library in the Jakarta Taglibs project <http://jakarta.apache.org/taglibs>. The <xsl:apply> tag is very powerful and flexible, and can interoperate with Struts cleanly.

>Why aren't the Struts tags maintained as part of the Jakarta Taglibs project?
Location: http://www.jguru.com/faq/view.jsp?EID=471940
Created: Aug 8, 2001
Author: Ted Husted (http://www.jguru.com/guru/viewbio.jsp?EID=462042)

At first, it was to make it easier to develop the tags as the rest of the framework was developed. Placing the tags in another repository would mean that we would have to be more careful about changes and deprecations as people would be using them in other environment. Once the set of standard tags is published (this is in progress now), we will refactor the Struts tag libraries, and offer the remaining multi-use tags to Jakarta taglibs.

How can I set the locale for each individual user session before the first  page displays? I've tried putting the session.setAtttribute(Action.Locale_key,<locale>) but it always displays in the default locale of the machine? Changing the machine locale causes the correct properties file to be used so I know that  is not the problem.
Location: http://www.jguru.com/faq/view.jsp?EID=471941
Created: Aug 8, 2001
Author: Ted Husted (http://www.jguru.com/guru/viewbio.jsp?EID=462042)

In the Struts example app, this is done by including the following tag on the index.jsp page (actually, on every page):

<%@ taglib uri="/WEB-INF/struts-html.tld" prefix="html" %>
<html:html locale="true">
... page content ...
</html:html>

This causes that <html:html> tag to consult the "Accept-Language" header sent by the browser, and set up a Locale in the user's session if it is not already there -- exactly the same way that the controller servlet does this if you configure it to. NOTE: There are currently problems with this on servlet containers that do not correctly implement the JSP 1.1 requirements for converting custom tag attribute values. We have heard problem reports about JRun 3.0 and ATG in this regard.

I have a simple question about localisation: If there is multiple users using the same localisation parameters : do  they share a common ResourceBundle instance or do they have their own  one. It seems to me that each user has his own ResourceBundle instance but does that affect the performance of the application.
Location: http://www.jguru.com/faq/view.jsp?EID=471942
Created: Aug 8, 2001
Author: Ted Husted (http://www.jguru.com/guru/viewbio.jsp?EID=462042)

The application's message resource bundles are shared across all of the users of a particular Struts-based web application. The only thing that is unique to a particular user is the java.util.Locale object (stored in the user's session) that represents his or her current Locale preferences.

Why can't the Struts tags access the properties of my beans?
Location: http://www.jguru.com/faq/view.jsp?EID=471943
Created: Aug 8, 2001
Author: Ted Husted (http://www.jguru.com/guru/viewbio.jsp?EID=462042)

Struts uses JavaBeans Introspector to discover properties of beans. Introspector is pretty picky in the way it decides whether something is a property or not. Specifically, it requires that 

1. Both getter and setter be declared public and non-static 
2. The return type of the getter be the same as the type of the argument of the setter. 

So, first check if your property breaks one of these rules.

I usually need 'wrap="virtual"' as an attribute for my textareas. It isn't part of the HTML spec, but it's supported in both Netscape and IE, and it's pretty useful.
Location: http://www.jguru.com/faq/view.jsp?EID=471944
Created: Aug 8, 2001 Modified: 2001-10-27 01:52:10.919
Author: Ted Husted (http://www.jguru.com/guru/viewbio.jsp?EID=462042)

The Struts Action works through introspection. It doesn't know (or care) whether the value in a form was rendered by a Struts custom tag or not. This means if you use a standard textarea tag in your form, and give it a name that matches a property in your form bean, Struts will use that attribute just as if it had been rendered by a html:textarea tag. After all, this is all the Struts html:textarea tag does. To seed the textarea from the form bean, you could code something like:

<textarea name="article" rows="15" cols="60" wrap="soft"></textarea> 

And everything else will be automagical again.

How do I use Javascript with my Struts forms?
Location: http://www.jguru.com/faq/view.jsp?EID=471945
Created: Aug 8, 2001
Author: Ted Husted (http://www.jguru.com/guru/viewbio.jsp?EID=462042)

The relevant HTML tags provide support for the Javascript event handlers onblur, onchange, onclick, ondblclick, onfocus, onkeydown, onkeypress, onkeyup, onmousedown, onmousemove, onmouseout, onmouseover, onmouseup.

For more about Javascript events, see the Netscape Javascript Reference guide.

For more about HTML tags, see the Struts HTML Tag Guide.

As usual, the Javascript itself can then be placed:

1. Inline, if it is simple enough, like onclick="history.go(-1)" 
2. As a <SCRIPT> within your JSP 
3. As an included <SCRIPT src="my.js"> to your JSP 

Note that the Struts Javascript properties use all lowercase identifiers, for XML compatibility.

How do I use Javascript to perform validation in Struts?
Location: http://www.jguru.com/faq/view.jsp?EID=471946
Created: Aug 8, 2001
Author: Ted Husted (http://www.jguru.com/guru/viewbio.jsp?EID=462042)

The best way is using David Winderfeldt's Struts validator servlet. This provides seamless client-side and server-side validation using regular expressions.

Other than that, you can also attach other Javascript validation to the Struts form fields using the provided properties for Javascript event handling. Of course, these types of validations cannot be guaranteed if a browser has Javascript turned off.

Why doesn't Struts provide it's own facility for regex or Javascript validations?
David Winterfeldt's Validator is being integrated with Struts 1.1.

Is it possible to combine dynamic Javascript menu systems with Struts?
Location: http://www.jguru.com/faq/view.jsp?EID=471947
Created: Aug 8, 2001
Author: Ted Husted (http://www.jguru.com/guru/viewbio.jsp?EID=462042)

The challenge with doing this is that the JSP tags run on the server (as the page is being generated), while the JavaScript runs on the client side. To integrate the two, you need your tags (and other JSP code) to dynamically generate the JavaScript functions themselves -- sort of having a program write a program -- so that the JavaScript is customized to your particular need on this particular page. A very trivial example is the way that the <html:form> tag deals with the "focus" attribute. If you specify it, a dynamically generated bit of JavaScript is created to set the input focus, which includes the name of the field you want initial focus assigned to. For a more comprehensive scenario, consider that for most menuing systems you will need to configure the list of available options into a JavaScript array or something. You could use the <logic:iterate> tag to render the elements that get set in the array's initialization expression.

Under Netscape 4.7 for Windows, the html:form focus feature doesn't work properly. Is there a work around?
Location: http://www.jguru.com/faq/view.jsp?EID=471948
Created: Aug 8, 2001
Author: Ted Husted (http://www.jguru.com/guru/viewbio.jsp?EID=462042)

The problem is that the focus feature works all right at first, but when you press tab, it proceeds to the address bar, rather than the next field. After you tab around once, it starts working as expected. One work around is to use the "onblur" event on the initial field to select the second. After that, Bob's your uncle!

Example: 

<html:form action="/logon" focus="username">
<p>Username <html:text property="username"
onblur="this.form.password.focus();"/>
<p>Password <html:password property="password"/>
<p><html:submit property="submit" value="SIGN IN" />

To focus the first field on the first form, you can also do this 

<body  onload="document.forms[0].elements[0].focus();">

in all your form pages rather than use the Struts html:form focus property.

Is the Struts object-orientated appropriate for small, heavily-loaded servers?
Location: http://www.jguru.com/faq/view.jsp?EID=471949
Created: Aug 8, 2001
Author: Ted Husted (http://www.jguru.com/guru/viewbio.jsp?EID=462042)

Compared to embedding the application logic in your servlet, Struts doesn't cost very much in terms of object creation. Struts only creates an instance of an Action class once, and then reuses it continually. You will also find that, with more recent JVMs, object creation overhead has been dramatically reduced -- it may not longer be the dominant factor in performance. ActionForm beans in Struts can be stored in the user's session (this was the original design), but also as request attributes. This is particularly useful when the entire form is displayed on one page, and the page contains every property as either a hidden field or a visible field. In such cases, there is no need to keep the form bean instance around in between requests. At the end of the day, though, you have to have an incredibly small server for the performance issues like single object versus lots of objects matter very much.

Does anyone know the performance difference between a direct method call andintrospection like Struts uses?
Location: http://www.jguru.com/faq/view.jsp?EID=471950
Created: Aug 8, 2001
Author: Ted Husted (http://www.jguru.com/guru/viewbio.jsp?EID=462042)

Independant performance engineers have benchmarked JDK 1.3 and the difference is now insignificant.

Can we configure a separate log for each application?
Location: http://www.jguru.com/faq/view.jsp?EID=471951
Created: Aug 8, 2001
Author: Ted Husted (http://www.jguru.com/guru/viewbio.jsp?EID=462042)

There is a restriction in Tomcat 3.2 related to how you declare log files. In Tomcat 4.0 this has been enhanced, letting you declare a separate destination for the servlet log per application, instead of globally. If you need to run under Tomcat 3.2, I suggest that you add some sort of application identifier to the log messages being created. A common pattern creates log files like this:

[Application1] This event happened
[Application2] That other event happened

Is there is some kind of "j2ee compliant" way of doing user authentication and role-assignment - are there any standards one is supposed to use?
Location: http://www.jguru.com/faq/view.jsp?EID=471952
Created: Aug 8, 2001
Author: Ted Husted (http://www.jguru.com/guru/viewbio.jsp?EID=462042)

The J2EE recommendation for this is to use container-managed security (i.e. the <security-constraint> elements defined in web.xml) for user authentication and access control. Doing so means that the container is taking care of these issues for you, and (perhaps more importantly) that user identities are shared between the web layer and the EJB layer, because the server will be using the same underlying "database" of users and roles.

The only downside to this approach is that there is not yet a standardized API for portably accessing and maintaining a "database" of users and roles ("database" is in quotes because the actual implementation could be anything, including static text files or directory servers).

Instead, most servers provide a server-specific API to do this kind of thing. For example, in Tomcat you can implement an API called a Realm that talks to your existing database of users, and then tell Tomcat to use this Realm implementation for user authentication. In that way, new users added to the database (by whatever means) become instantly authorized for web use also. If you were to switch to a different engine, you would need to re-implement this function according to the APIs provided by the new server, but you would not need to update your applications.

How can you prevent users from accessing a JSP directly that is designed to be used from an Action?
Location: http://www.jguru.com/faq/view.jsp?EID=471953
Created: Aug 8, 2001
Author: Ted Husted (http://www.jguru.com/guru/viewbio.jsp?EID=462042)

Put those JSP pages in a directory under WEB-INF; for example, WEB-INF/jsp. Files under the WEB-INF directory cannot be directly accessed. Another approach is supported by the servlet API if you are using container-managed security for your application. You can define a security constraint that lists no roles as being allowed, which the servlet container will interpret as not allowing access to anyone directly from a request. You can forward to (or include) such a page -- just not request it directly.

Note that this behavior was not clearly specified in the 2.2 servlet spec, so your mileage might vary there -- but all 2.3 containers are required to act this way.

Consider the following security constraint:<security-constraint>

<web-resource-collection>
<web-resource-name>All JSP Pages</web-resource-name>
<url-pattern>/pages/*</url-pattern>
</web-resource-collection>

In a servlet 2.3 container (such as Tomcat 4.0), this is interpreted to mean that there is no direct access at all to any URL like:

http://localhost:8080/myapp/pages/menu.jsp

but you are allowed to use a request dispatcher to access them. This is because security constraints are to be checked only on the *original* URL, not on the forward/include. Thus, if you want to ensure that a page is accessed only via the controller servlet, you can give it a URL path within the "pages" subdirectory, and the container will take care of this for you.

Using action classes as adapters and session EJBs for business logic sounds like a good way to go. Is also using EJBs as actionforms is a good idea because they are a good target for object reuse/
Location: http://www.jguru.com/faq/view.jsp?EID=471954
Created: Aug 8, 2001
Author: Ted Husted (http://www.jguru.com/guru/viewbio.jsp?EID=462042)

ActionForms are not designed for reuse with an EJB. In fact, early on, the ActionForm was changed from an interface to an abstract class to discourage this idea.

The reasoning goes like this:

• An ActionForm is part of the view layer of MVC, not the model layer like an EJB (or a regular JavaBean that represents persistent data).
• The sole purpose of an ActionForm is to maintain the state of all the input variables on a particular form, so that you can reproduce the form pre-filled-in if the user made an error that they need to fix. This matches the expectations of users who are used to GUI-based client server apps, that never make you retype any input except the stuff you did wrong.
• Because of the above, the "domain" of an ActionForm does not necessarily match any existing EJBs or model layer JavaBeans. It is not uncommon to have inputs from a single form that will ultimately cause updates to more than one undelrying EJB or model bean.
• Using a separate class for the ActionForm means you can change the underlying organization of your model beans or EJBs without impacting the view layer (although there might be modest impacts on the Action classes that copy things back and forth).
• In addition, most EJBs and model beans have validation rules internally that prevent them from accepting semantically invalid data. Such rules would prevent you from accomplishing the primary purpose of an ActionForm -- storing all of the user's input fields, so that you can reproduce the input screen.
• Also, if your form is multiple pages and you were using the real EJB, let's say you start updating properties based on receiving the first page. Now, you've potentially started locking resources in the underlying database -- and you have to deal with the fact that the user may never come back and finish this transaction.

So, the bottom line recommendation is that you plan on building simple JavaBeans for your ActionForms. Most of the time, an ActionForm will have just getters and setters, with no error checking (other than a validate() method if you want to use it, plus the reset() method). PropertyUtils also has a convenience function that can copy properties with like names from your EJB to the ActionForm bean (or vice versa), to reduce the amount of tedious code that this approach implies. And, at some future point, it's reasonable to expect a development tool to be able to auto-generate ActionForm beans for you.

Using an EJB as a bean that provides data values used in the presentation, on the other hand, is pretty easy. Just store the client-side instance you get back from the EJB server as a request attribute or session attribute -- from the perspective of the Struts custom tags, this EJB just looks like a JavaBean with getter methods, so they don't care that it is really an EJB. NOTE: If the EJBs are really on a remote server this could have some performance impact -- you might be better served to copy data into local beans in that case.

Why is the form bean automatically created by both servlet and form tag?
Location: http://www.jguru.com/faq/view.jsp?EID=471955
Created: Aug 8, 2001
Author: Ted Husted (http://www.jguru.com/guru/viewbio.jsp?EID=462042)

It is valid for a user to enter the system either through the servlet or through the JSP form, and so the bean must be created in either place.

How can you tell if a form bean was automatically created?
Location: http://www.jguru.com/faq/view.jsp?EID=471956
Created: Aug 8, 2001
Author: Ted Husted (http://www.jguru.com/guru/viewbio.jsp?EID=462042)

In general, you can define a special member variable in the bean that indicates that it has just been created. On a manual create you would reset that yourself, but on an auto create it would remain set, and the validate method would detect it (or you could check manually).

Reset for validation
Location: http://www.jguru.com/faq/view.jsp?EID=471957
Created: Aug 8, 2001
Author: Ted Husted (http://www.jguru.com/guru/viewbio.jsp?EID=462042)

There is a reset() method on ActionForm that is called *before* Struts does the auto-populate trick. The contract is that this method should reset all relevant attributes for this particular form to default values. For checkboxes, you would want to set the corresponding boolean to false. It will be set to true by the auto-populate method *if and only if* the checkbox was checked (and therefore included in the POST).

For integers, it is technically feasible to distinguish an empty field ("") versus a zero ("0"). If we decide not to call the setter in this scenario, then the ActionForm property will remain at it's default value, so you can distinguish whether it was entered or not.

On the other hand, we could take the approach that the form should have displayed the default value in the first place, and the user would have had to erase the existing value to cause an empty string to be posted -- and that the bean should want to know about that. Because we have to generate a legal integer value, the decision is what value to use for indicating "no input". Zero is the current mechanism for this, but it's not the only choice.

Does an Action have to return an ActionForwarding?
Location: http://www.jguru.com/faq/view.jsp?EID=471958
Created: Aug 8, 2001
Author: Ted Husted (http://www.jguru.com/guru/viewbio.jsp?EID=462042)

No. Sometimes, it might be better for an Action to handle the request itself. For example, you might need to return dynamic content that would be impossible or impractical to create with a JavaServer Page. Or, you might need to return content using a special MIME type.

If the Action handles the request itself, and presents an appropriate view to the client, it can return null to the controller. 

How can Struts check for a set of global conditions before processing an action?
Location: http://www.jguru.com/faq/view.jsp?EID=471959
Created: Aug 8, 2001
Author: Ted Husted (http://www.jguru.com/guru/viewbio.jsp?EID=462042)

This often comes up in the context of authenticating users or with other control flow issues. 

The direct approach would be to subclass the ActionServlet controller servlet, and override a method like processActionPerform (which actually calls the selected Action) or processActionForward (which forwards control to the returned logical page name). You could then inspect the current state of the world, and inject flow-of-control changes like this still utilizing the superclass's basic functionality.

To make the types of things you inject somewhat configurable, you might also want to use your own custom ActionMapping subclass, with extra bean properties that describe (to your override method) what exceptional things to do and when to do them -- the selected ActionMapping instance is made available to most of the processing calls, so this information would be easily accessible.

If, as part of injecting control follow changes, you need to track where the user was in your application, you might have your ActionServlet subclass maintain a request-scope attribute with a well-known name, containing the value returned by request.getServletPath(). This would act something like the "referer" header in an HTTP request, and provide some history tracking.

How can I initialize custom "application scope" objects for use in a Struts application?
Location: http://www.jguru.com/faq/view.jsp?EID=471960
Created: Aug 8, 2001
Author: Ted Husted (http://www.jguru.com/guru/viewbio.jsp?EID=462042)

One way would be to subclass the ActionServlet, to to initialize whatever application scope objects you might need. Just remember to call the super.init() method!

A better approach would be to write another servlet, and auto-load both the Struts controller and your own servlet through the web.xml file. The Example application does this to load a "database" servlet, which is then accessed throughout the application. This way you can initialize application-specific things through your specialized servlet, and leave the normal Struts controller servlet alone. 

In a servlet 2.3 environment (such as Tomcat 4.0), you will also be able to use the new application event listener APIs to catch the contextInitialized() and contextDestroyed() events. This will become the preferred method, once servlet 2.3 containers are widely available.

In my Action subclass, rather than returning the results of mapping.findForward(...) I need to forward to a page determined at runtime. What is the *proper* way to forward to xxx.jsp? Should I construct an ActionForward? (tried that unsuccessfully).
Location: http://www.jguru.com/faq/view.jsp?EID=471961
Created: Aug 8, 2001
Author: Ted Husted (http://www.jguru.com/guru/viewbio.jsp?EID=462042)

You can create a new ActionForward dynamically:

String path = ... create context-relative path to new page ...
return (new ActionForward(path));

The path you calculate must be context relative and start with a slash, exactly like the "path" attributes to your standard <forward> elements.

Does Struts work with a secure SSL connection?
Location: http://www.jguru.com/faq/view.jsp?EID=471962
Created: Aug 8, 2001
Author: Ted Husted (http://www.jguru.com/guru/viewbio.jsp?EID=462042)

Yes. Once SSL is installed for your container, the Struts custom tags and Action Mappings will automatically insert the correct references so that all the page and image links operate in SSL mode.

How do I install SSL for my container?
Location: http://www.jguru.com/faq/view.jsp?EID=471963
Created: Aug 8, 2001
Author: Ted Husted (http://www.jguru.com/guru/viewbio.jsp?EID=462042)

See:

• installing the Sun Secure Socket extension
• keytool
• and the documentation for your container.

Here are some common configuration mistakes:

• When installing standard extensions, install them under $JAVAHOME\jre\lib\ext -- not under $JAVAHOME\lib\ext.
• If Struts links do not appear under SSL, see step 7 on the Secure Socket Extension page.
• You may need to add
  -Djava.protocol.handler.pkgs=com.sun.net.ssl.internal.www.protocol
  to the command line which loads your container.
• If you have trouble importing your license key, be sure that your text file is saved in standard UNIX file format

Here's a bird's eye overview

1. Install JSSE 

2. Create a new keystore for certificate requests, using template that ships with Java

cp cacerts MY_SERVER.keystore

3. Change the default password

keytool -storepasswd -storepass changeit -new MY_KEYSTORE_PASSWORD -keystore data.keystore

4. Generate a key, specifying an alias to use for this certificate

keytool -genkey -keyalg RSA -alias MY_SERVER_ALIAS -storepass MY_KEYSTORE_PASSWORD -keystore data.keystore

Answer the questions, using your machine's fully-qualified name (www.myserver.com) for "first and last name".

Use the same password for the key (using another password is not implemented).

5. Create a certificate request, based on the key created for the alias (step 2).

keytool -certreq -alias MY_SERVER_ALIAS -store pass MY_SERVER_PASSWORD -keystore MY_SERVER.keystore

Capture the output to a text file (MY_SERVER.crs), being sure to keep a backup copy in a safe place. This is your Certificate Request.

6. Generate a test certificate with Thawte, or another authority, to be sure everything works, and import the certificate returned (MY_SERVER.crt) for this alias.

keytool -import -alias MY_SERVER_ALAIS -storepass MY_SERVER_PASSWORD -keystore MY_SERVER.keystore -file MY_SERVER.crt

7. Repeat previous step to obtain a production certificate (unless you are self-signing for intranet use). When you import the production certificate, it will replace the test version.

How do I switch to SSL mode for logon, and then back again for the rest of the session?
Location: http://www.jguru.com/faq/view.jsp?EID=471964
Created: Aug 8, 2001
Author: Ted Husted (http://www.jguru.com/guru/viewbio.jsp?EID=462042)

This is still harder than it should be, but here's the drill:

The bad news is that you need to hardcode the schema to switch from standard to SSL mode and back again. The good news is that you can mitigate the damage and do most of it it all in the Struts-config.

<forward name="standard" redirect="true"
path="http://data.wxxi.org/wxxi-gavel/register/logon.jsp"/>
<forward name="secure"  redirect="true"
path="https://data.wxxi.org/wxxi-gavel/register/logon.jsp"/>

which are called with code like this in the action

return mapping.findForward(secureMode ? "secure" : "standard");

where "secureMode" is tracked as a session attribute.

If they login or register in secure mode,  you can end the process with a [[BIG LINK]] that routes them back to the http scheme.

Messy, but it gets you through the day.

I haven't had time to think about it, but it seems to me that we should be able to work this into the custom tags. Struts is very good about automagically converting the links when you switch schemes, so it seems to me we should be able to force the tags to one scheme or the other, when appropriate. 

You could also calculate an absolute URL for this web app, based on things like request.getServerName(), request.getContextPath(), and so on. So, another way to do this would be to have an action that calculated the new absolute URL, wrapped it in a new ActionForward with the "redirect" property set, and return that to the controller servlet. It looks pretty much like what you quoted in the mail message.

NOTE: Because the controller servlet calls encodeRedirectURL() for you on redirections, sessions should survive across this transfer whether or not you are using cookies.

If you're running on ports other than the default (80 and 443), you will probably also want a configuration parameter to define what the corresponding SSL and non-SSL ports are.

Form validation errors in different frame? Possible? I'm writing my first Struts application and want to use one frame containing the input form and another frame to display the results.

If I use validation in the ActionForm (or populate ActionErrors in the Action object), I know I can use <html:errors/> to display errors in the input form (same frame).

But do I HAVE to display the errors in the same frame as the input form? Could I do a <html:errors/> in the results frame and get them to display there?

I can't use TARGET="resultsframe" because if an error occurs, the input form will be displayed in the results frame. I'd need to refresh the results frame from the input frame. But if the errors collection is only stored in the request, it'd be too late to retrieve the errors I think.

Is there a solution? Can I get to the errors collection from a different frame to the one containing the input form?

Thanks
Location: http://www.jguru.com/faq/view.jsp?EID=531007
Created: Oct 26, 2001
Author: Rob Breeds (http://www.jguru.com/guru/viewbio.jsp?EID=524998) Question originally posed by Rob Breeds (http://www.jguru.com/guru/viewbio.jsp?EID=524998

The only thing I came up with was to do the input validation using JavaScript and dynamically set the TARGET if the validation succeeded.

I do have the error messages next to the corresponding input fields, but that only works if the TARGET is set to the same frame as the input. If the input validates OK, the response gets written to the input frame and not the results frame which is what I want.

If no errors I could ALWAYS return the input frame and check a session attribute to see if any results should be displayed, and if so change the results frame href so it loads the results from session.

I think the only way to do this is turn form validation off and have any error messages appear in the results frame. Not ideal, but it'll do for now!

Rob

Page caching by overriding the getOutputStream() and getWriter() methods. Reading this( see second answer)
I wonder how I can do this in
struts. I want to save the response
to my own stream so I can save it.
Which class do I extend in strus do
get this to work?
Location: http://www.jguru.com/faq/view.jsp?EID=531024
Created: Oct 26, 2001
Author: Ted Husted (http://www.jguru.com/guru/viewbio.jsp?EID=462042) Question originally posed by raffe paffe (http://www.jguru.com/guru/viewbio.jsp?EID=28822

In your Action, you can just return null instead of an ActionForward

    public ActionForward perform(ActionMapping mapping,
                 ActionForm form,
                 HttpServletRequest request,
                 HttpServletResponse response)
    throws IOException, ServletException {
        response.setContentType("text/plain");
        response.getWriter().print("Hello World");
        return (null);
    };

HTH -Ted

war file and directories structure for struts applications Could someone give me a sample structure of a simple application (2 or 3 jsp, 2 or 3 Action classes ...) including:

• the appropriate directories structure for the jsp, sources files and .class files, libs, and build.xml,web.xml, struts-config.xml etc...
• the corresponding "build.xml" file WITH the correct WAR tag in order to generate the proper .war file to be deployed into some servlet container like Tomcat.

In open source arenas, it's become a popular practice to put the source below WEB-INF/src/java but that's a matter of preference. Most people tend to keep the build.xml under WEB-INF where it's easy to find.

The build.xml was written with that assumption, but you could change it to run from or get the source from anywhere you like.

Likewise, where you put (or name) the struts-config.xml " and the tld's can be configured in the web.xml, and is also a matter a preference.

The ApplicationResource.properties file has to be on the classpath, and since classes is always on the classpath putting it there makes it easy for the container to find.

Putting the JSPs below WEB-INF can provide an extra layer of security, but can also make it harder to reference stylesheets and the like.

HTH - Ted.

Indexed Properties

Can we access members of an array like <form:select property="array[i]"> in a for loop... It works if I use constants but not expressions.. property="array[0]" is fine but not array[i] or array[<%=i>] for the property attribute of form:select. Any clues???

The property accessor syntax in Struts 1.0 supports only constants as array subscripts.

You might consider using some sort of runtime expression instead, to dynamically calculate the property to be retrieved. Assume that "i" is an integer variable, and you are inside a loop:

<form:select property='<%= "array[" + i + "]" %>'/>

In the Struts nightly build, indexed properties are supported directly, so that scriptlets like this are not needed

Has anyone had luck using radio buttons?

The idea behind a radio button is that you have a String field that has one of a fixed set of values, and you want to render one radio button for each of them.

Let's assume that your bean property "gender" can have property values "Male" or "Female". You might display them like this:

<html:radio property="gender" value="Male">

 <bean:message key="gender.male"/>

</html:radio>



<html:radio property="gender" value="Female">

 <bean:message key="gender.female"/>

</html:radio>

A particular radio button will be selected if the value returned for this property matches the "value" attribute of that button's <html:radio> element.

In the example above, we're also looking up the actual text of the strings displayed on the HTML page in a message resources bundle, so that it is suitably internationalized.

[Craig McClanahan]

ActionErrors,ActionError about display the error message. In the strut example, we should new ActionError("error.password.mismatch") "error.password.mismatch" define in the config file, if the property does not exit, then I can see nothing in the browser , I wanna to know whether I can display the property name even I does not define the property. thanks
Location: http://www.jguru.com/faq/view.jsp?EID=531811
Created: Oct 27, 2001
Author: Ted Husted (http://www.jguru.com/guru/viewbio.jsp?EID=462042) Question originally posed by Yang Liu (http://www.jguru.com/guru/viewbio.jsp?EID=527494

Actually, there is an ActionServlet property that governs this. In your web.xml, include this:

    <init-param>
      <param-name>null</param-name>
      <param-value>false</param-value>
    </init-param>

with the other settings for your ActionServlet.

See the Struts Javadoc for other ActionServlet settings

HTH - Ted

Should we be chaining action servlets?

We're putting together a series of screens where we would say... logon (to main menu), list parties (to list result screen), then add party (to party detail screen), submit add (back to list result screen).

An Action is intended as an adapter between the HTTP layer and the rest of your application. Generally, the rest of your application should be represented by business objects that have no dependancies on HTTP or Struts.

So, the business logic should not be *in* the Action, but something that the Action *calls*.

This makes it easier for Actions to handle more than one task. Since the logic is encapsulated elsewhere, each task is simpy a method call.

This also makes it easier for logic to be accessed by more than one Action (or from more than one application).

In this case, there could be a business method for the listResult page, that an Action could call before forwarding to that page.

If the correct prerequesites are still in the request, simply forwarding to another Action can also be a clean solution, so long as this is documented in the struts-config.

Where it gets iffy is when people start building dynamic query strings so they can call another Action. This is a retreat to Model 1, and smells like a kludge, since it implies that the business logic is not available outside the Action, where it could be cleanly called with a method (rather than a query string).

For an example of using business objects with Struts, see the early release of Artimus at http://husted.com/struts/resources.htm#new.

HTH -Ted

Struts post-1.0 and Tomcat 3.2.x My post-1.0 version of Struts crashes on tomcat 3.2.x. What can I do about this?
Location: http://www.jguru.com/faq/view.jsp?EID=533533
Created: Oct 30, 2001
Author: Tom Klaasen (http://www.jguru.com/guru/viewbio.jsp?EID=532427) Question originally posed by Tom Klaasen (http://www.jguru.com/guru/viewbio.jsp?EID=532427

Put xerces.jar in your TOMCAT_HOME/lib directory, and rename the files parser.jar and jaxp.jar in that same directory to zparser.jar and zjaxp.jar, respectively.

Multiple button support How should multiple button support be handled in Struts? Each button gets submitted with different text, but in order to separate the view from the controller that text should not appear in the Action. I'm curious how others have dealt with this situation.
Location: http://www.jguru.com/faq/view.jsp?EID=543699
Created: Nov 9, 2001
Author: Ted Husted (http://www.jguru.com/guru/viewbio.jsp?EID=462042) Question originally posed by Erik Hatcher PREMIUM (http://www.jguru.com/guru/viewbio.jsp?EID=405274

Without Javascript, I don't think there is another solution, since that is all the information that HTTP provides.

With Javascript, you can have the button set a hidden property on the form, and then key on that.

This example uses the property "forward", which could also be a property on the ActionForm.

<html:hidden property="forward" value="error"/>
<html:submit onclick="set('update');">UPDATE</html:submit>
<html:submit onclick="set('copy');">COPY</html:submit>
<html:cancel onclick="set('cancel');">CANCEL</html:cancel>

function set(target) {
     document.forms[0].forward.value=target;
};

A good trick here is to use a generic "routing" or "relay" action, so you don't have to hardcode some type of switch into the Action. It's just one line in the perform method:

return mapping.findForward(request.getParameter("forward"));

This can be used any number of times in a Struts application, just by changing the form bean and the local forwards in its mapping.

<action 
path="/prospect/Submit"
type="org.apache.scaffold.http.RelayAction"
name="prospectForm"
scope="request"
validate="false">
<forward 
name="update"  
path="/do/prospect/Store"/> 
<forward 
name="cancel"  
path="/do/prospect/Current"/> 

HTH - Ted

Multiple form beans per Action class Can I have multiple form beans per action class? If YES how would the struts config file look like?
Location: http://www.jguru.com/faq/view.jsp?EID=543700
Created: Nov 9, 2001
Author: Ted Husted (http://www.jguru.com/guru/viewbio.jsp?EID=462042) Question originally posed by Ranjiith Selvarjan (http://www.jguru.com/guru/viewbio.jsp?EID=421879

Not as such. The Action.perform() method only takes a single form bean as a parameter.

You can nest beans. See the Bean Developers guide for details, and Struts-simple for an example.

Of course, you can always create and populate whatever other beans you need in the Action. Typically, the ActionForm is just used to get the data into the Action, and then it is transferred to more capable beans, with typed data.

HTH - Ted

Dynamic Form Elements

I posted this earlier but I received no comments on specific current solutions that will address this problem. I was also wondering if the nightly build has the following ability within it.

Let me give an idea of what I am trying to accomplish and then see if you can feedback.

Using struts (obviously) I am creating a reusable contact form. It is configured through an xml-config file that defines where the contact form goes and the smtp server it is to use, etc.. I want to set it up so that it does not have to be recompiled upon alternate use. This is one part of a set of components that make it easy for web designers to add functionality to websites they are building using the struts framework (whether they know it or not). i.e. most web designers to not have ide for compiling java classes. So, with those design goals in mind let me share with you my issue.

The contact form by default captures the Name, Address, City, State, Phone Number, and any other basic contact form info needed. It has an ActionForm bean that captures the input of these predefined items and the data is then passed on to the Action and sent as an email to the recipient. My hangup is... I need to allow the flexibility of adding form elements to the form that are not defined in the ActionForm bean. I would also need to be able to pass the values back to the form in the event that a validation error occurs with the form. With the model the way it is I would have to specifically define the setters and getters in the ActionForm so that the Action could retrive the values of each form element and use them or route them back to the input form for errors or to another Action.

Is there a way to have a generic getter/setter that can capture any non defined data? For example say a company cleans linen and they want to add a form element that asks for the type of detergent the contactee prefers. The added form element is called "preferredDetergent" yet it is not specifically defined in my ActionForm bean. First, how would I avoid getting an error that says preferredDetergent is not defined in xxxForm? Next, how would I then capture that value in the ActionForm for use in error checking and/or usage in the Action class?

The ActionForms extend the html:form tags so that they can be populated, and repopulated, from the request.

The ActionForm properties and the tags are tightly coupled, and neither are designed to be used dynamically.

Of course, not every property has to be populated. So there could be the old trick of adding several "UserDefined" properties to form. In the JSP, the properties might be labled user1, user2, et cetera, but the external user labels could be anything at all.

Using the validator form, error checking can be performed by updating the validate.xml and Application resources and restarting the application.

In the Action itself, you would need to add some type of handler to check if the user defined fields were not null. To label them in your email message, you could do some type of "reverse lookup" on the application resources, to get the field labels from the validation messages.

HTH - Ted

How can I use the "options" tag with a collection of options stored in my ActionForm bean?
Location: http://www.jguru.com/faq/view.jsp?EID=549097
Created: Nov 16, 2001
Author: Ted Husted (http://www.jguru.com/guru/viewbio.jsp?EID=462042) Question originally posed by kriss j (http://www.jguru.com/guru/viewbio.jsp?EID=531542

The properties for options are very confusing, and there's talk on DEV of an alternate tag, optimized to use something like the LabelValue beans.

Here's how to use the current options tag when the LabelValue collection (from the Example) has been stored as a property on the ActionForm. If you want to provide the collection through an ActionForm method, you need to define a scripting variable first.

<bean:define id="myOptions" name="donorForm" 
        property="myOptions" type="java.util.Collection"/>

Then

<html:select property="image">
<html:options collection="myOptions" property="value"
labelProperty="label"/>
</html:select>

If you wanted to build the list from a static method in your business layer, a simple one could look like this:

    public static String getMyOptions(int image) {
        String text = null;
            switch (image) {
                case -5: text = "Photograph item"; break;
                case -4: text = "Clip from Website"; break;
                case -3: text = "Expect by email"; break;
                case -2: text = "Expect by mail"; break;
                case -1: text = "Do not use"; break;
                case 0: text = "No"; break;
                case 1: text = "Yes"; break;
                case 2: text = "Use icon"; break;
            }
        return text;
    }

    public static Collection getMyOptionss() {
        Collection list = (Collection) new ArrayList();
        for (int i=-5; i<2; i++) {
          list.add(new LabelValueBean(
              getMyOptions(i),
              String.valueOf(i)
          ));
        }
        return list;
    }

Then in the ActionForm, a wrapper method can be used:

    public Collection getMyOptions() {
        return app.StaticClass.getMyOptions();
    }

HTH - Ted

Can We Avoid JSP's in Struts FrameWork Hi,

Can We use Servlets to Paint Screen instead of JSP's in Struts Framework, if Yes What are its Disadvantages,Modifications needed etc...

The response object is passed to the Action perform method. You can use this to write your own response to the client, in the usual way. The standard Struts "reload" action does this to paint "OK" to screen after reloading the mappings.

For fancier pages, the best thing would be to have your servlet answer to it's own URI pattern. The Struts Action could then forward to that, the same as it does with JSPs.

Your serlvet can then look in the request context for the ActionForm, or whatever other objects you will use, and render the response from that. If your servlet just does what the HTML tag extensions do, then the rest of the framework will be none the wiser. And all they really do is populate the HTML control using the properties of an ActionForm found in the request context.

The other resources used by the tag extensions, like the mappings and messages, are available in application scope, so your servlet could use those too, if needed.

On an incoming request, the ActionServlet sets the values on the ActionForm bean via reflection. It doesn't now or care how the values got into the HTTP request. It's just looking for name=value pairs in the HTTP request that match the property names on the designated ActionForm.

The tag extensions know to look for the ActionForm in the request context, or instantiate one if it's missing. The latter part is so any default values can be given to the HTML controls. The tags also know how to look into the mappings to find out which ActionForm goes with which Action, but that's added value. You can always code that part by hand (and at one point, we did).

But so long as the names of the HTML controls match the ActionForm names, it doesn't matter who writes the HTML. HTTP is the great equalizer.

The JSPs are not tightly coupled with the framework, and anything they do could be done by another servlet. It is helpful, though, if your serlvet answers to its own URI pattern, as the JSP service does. Architecturally, this then makes it a drop-in replacement for JSPs.

I understand that there is a renewed interest on the Jakarta Velocity list about using their servlets with Struts. The strategies they use would probably work for you too.

HTH -Ted

Browsers reload button and url writing Hello, here is my problem :
JSP1 -> ActionClass1 -> ActionClass2 ->JSP2
When I'm on the JSP2, the url is that of the ActionClass1, so when I hit the reload button, the ActionClass1 is reloaded. (and I would like the ActionClass2 to be reloaded).
How can I do ?
Location: http://www.jguru.com/faq/view.jsp?EID=705837
Created: Dec 31, 2001
Author: Ted Husted (http://www.jguru.com/guru/viewbio.jsp?EID=462042) Question originally posed by jn dl (http://www.jguru.com/guru/viewbio.jsp?EID=466056

The reload button, by definition, is suppose to resubmit the last request. In this case, you would not like the last request to be resubmitted and reprocessed the same way. You would like ActionClass1 to skip ahead and forward the request to ActionClass2.

A good strategy to tell if a request has already been submitted is to use "tokens". Struts supports this directly with various *token methods in the Action class. To implement this, you would go back to "ActionClass0" that lead to JSP1. In this Action, put

saveToken(request) ;

Then in ActionClass1 put a call to

isTokenValid(request) 

If the token is not valid, you would want to forward to ActionClass2

If it is valid, you would want to finish the usual processing in ActionClass1 and call

resetToken(request);

to signal that the token has been used.

-Ted.

Submitting forms as a collection Using the <logic:iterate> tag i'de like to format several rows of recurring data for a user to change or add some values.

When the data is submitted back to the Action routine I see how it can arrive as an Action form.

Is there a way to submit the results as a collection of forms instead?

Thanks,

Mitch
Location: http://www.jguru.com/faq/view.jsp?EID=710844
Created: Jan 6, 2002
Author: Ted Husted (http://www.jguru.com/guru/viewbio.jsp?EID=462042) Question originally posed by Mitch Dresdner (http://www.jguru.com/guru/viewbio.jsp?EID=390316

HTML browsers can only submit results pursuant to the HTTP protocol. So everything comes in a hashtable of Strings.

There is a nice nesting pacakge for Struts that might help you organize the collections so that they can be submit back as Strings and put back into your collection

See Nested Struts Extension for details.

HTH -Ted.

What is URI? Can anybody help me What is URI please?
Location: http://www.jguru.com/faq/view.jsp?EID=741075
Created: Jan 30, 2002
Author: Pierre Sirolli (http://www.jguru.com/guru/viewbio.jsp?EID=724553) Question originally posed by Bhaskar Kommuru (http://www.jguru.com/guru/viewbio.jsp?EID=709748

A URI can be further classified as a locator, a name, or both. The
term "Uniform Resource Locator" (URL) refers to the subset of URI
that identify resources via a representation of their primary access
mechanism (e.g., their network "location"), rather than identifying
the resource by name or by some other attribute(s) of that resource.
The term "Uniform Resource Name" (URN) refers to the subset of URI
that are required to remain globally unique and persistent even when
the resource ceases to exist or becomes unavailable.
The following examples illustrate URI that are in common use.
ftp://ftp.is.co.za/rfc/rfc1808.txt
-- ftp scheme for File Transfer Protocol services

gopher://spinaltap.micro.umn.edu/00/Weather/California/Los%20Angeles
-- gopher scheme for Gopher and Gopher+ Protocol services

http://www.math.uio.no/faq/compression-faq/part1.html
-- http scheme for Hypertext Transfer Protocol services

mailto:mduerst@ifi.unizh.ch
-- mailto scheme for electronic mail addresses
news:comp.infosystems.www.servers.unix
-- news scheme for USENET news groups and articles telnet://melvyl.ucop.edu/ -- telnet scheme for interactive services via the TELNET Protocol

how to use a href in struts JSP? hi all, i try to pass dynamic data using a href but it seems fail to work in struts.

original JSP:

<href="/callfile.do?action=w&filename=<%=bean.getFILENAME()%>">

Struts JSP:

<html:link page="/callfile.do?action=w&filename=<%=bean.getFILENAME()%></html:link>;

i can't get the <%=bean.getFILENAME()%> value when using struts.can anyone help?

regards, CY
Location: http://www.jguru.com/faq/view.jsp?EID=741079
Created: Jan 30, 2002
Author: Ted Husted (http://www.jguru.com/guru/viewbio.jsp?EID=462042) Question originally posed by Ong CY (http://www.jguru.com/guru/viewbio.jsp?EID=447528

The html:link tag is designed so that you can do that without resorting to scriptlets. Try:
<html:link page="/callfile.do?action=w" paramName="bean" paramProperty="FILENAME" paramId="filename"/>

(Though, you may have problems unless the accessor is named getFilename, per the conventions.)

{soapbox}

Personally, I discourage use of the page form of html:link, and always use global forwards instead. This way all the entry points to your application are documented, and you don't have to expose API features like "action=w" in the JSP. You can give the action=w forward a logical name, and use that instead.

In struts-config:
<forward="callW" path="/callfile.do?action=w"/>
In your JSP:
<html:link forward="callW paramName="bean" paramId="filename"/>

In my own applications, the only place I expose the name of another Action is in the html:form tags (and I'm working on that;-)

{/soapbox}

HTH - Ted

Maintaining form data across pages... I am trying to setup a series of jsp pages (jsp1, jsp2, jsp3). Each of these adds or modifies properties (or collections) of object customerForm(supply name/address, add contacts, etc.) This is an "experimental" app I'm putting together to try out struts.

In struts-config.xml, I have the choice of setting the scope parameter for each action mapping. If I set scope to "request", then customerForm is instantiated each time the form is presented - data is lost across forms.

If I set to "session" then I can maintain the data across the various forms, but customerForm.reset() is still called.

My questions:

Jeff.
Location: http://www.jguru.com/faq/view.jsp?EID=749741
Created: Feb 6, 2002
Author: Jason Rosenblum (http://www.jguru.com/guru/viewbio.jsp?EID=740621) Question originally posed by Jeff Sprenger (http://www.jguru.com/guru/viewbio.jsp?EID=740521

here's an example: you have an HTML form. after it is filled out the user previews the results on a second JSP and then chooses to submit or edit the HTML form again. If the user submits, then he is forwarded to a confirmation page. In order to process this you do: 1) cache ActionForm in session after form submission. 2) I pass my Customer bean to the preview page via request. I was able to construct a Customer bean by calling a toXXXX() method in my ActionForm (e.g. toCustomer). 3) on the confirmation page i query the database and return the results as a Customer bean passed via request. I also clean out session using removeAttribute(). I hope that helps...

Switching the locale(language) of an application via a button on a page.

How can you change the locale of an application via a button on a web page. I am using struts and don't want the user to have to change their language from the browser (e.g. Tools-Internet Options-Languages in IE).

I want the user to be able to toggle languages from a button! This toggling only needs to be held throughout the lifecycle of the user's session. When the session ends the application will automatically use the browsers default language when a page is requested.

Struts places a locale object in the application scope, and it's just a matter of changing that.

David has a nice example in his sample Validator application.

HTH - Ted

select tag and options tag. How do I use the same info, but different variables? I followed the example previously given by Ted, allowing me to fill an options tag from a database, use helper classes. I have a situation where two select/option tags are filled from the same bean call. The following code is just under my <html:Form>

   <bean:define id="titles" name="DocRegForm" property="title"
    type="java.util.Collection"/>
  <bean:define id="specs" name="DocRegForm" property="spec"
    type="java.util.Collection"/> 

Specialty #1
   <html:select property="spec">
    <html:options collection="specs" property="value"
      labelProperty="label"/>
    </html:select>

Specialty #2
   <html:select property="spec">
    <html:options collection="specs" property="value"
      labelProperty="label"/>
    </html:select>

HTML does allow parameters with duplicate name, and Struts will captures those like any other property if an array is used.

private String[] spec = {"",""};
public String[] getSpec() {
    return this.spec;
}
public void setSpec(String spec[]) {
    this.spec = spec;
}

HTH -Ted

More control with <html:errors/>

I know you can specify header and footer in the prop file, but what if different pages have different needs in terms of displaying errors. E.g., In some cases its a list and in others I want sentences strung together with no header.

What if I want to list out errors but don't want to user

<ul>...</ul>

<html:errors/>

The message tag in the nightly build offers more flexibility

This might also be available in the Struts Validator library

The other alternative is leave the errors header and footer blank, so you can add the HTML yourself.

To test for the presence of error messages in Struts 1.0.x, you can use

<logic:present name="org.apache.struts.action.ERROR">

And then wrap (or not wrap) the messages with markup

To retrieve individual messages, you can specify the property in the html:error tag.

But, the new messages tag really does a much better job of this.

HTH -Ted

Any html:multibox samples out there?

Hi, can anybody please point me to a working sample using html:multibox?

ActionForm:

private String[] selectedItems = {};
private String[] items = {"UPS","FedEx","Airborne"};
public String[] getSelectedItems() {
    return this.selectedItems;
}
public void setSelectedItems(String[] selectedItems) {
    this.selectedItems = selectedItems;
}

JSP:

<logic:iterate id="item" property="items">
    <html:multibox property="selectedItems">
        <bean:write name="item"/>
    </html:multibox>
        <bean:write name="item"/>
</logic:iterate>

HTH -Ted

In order to run Struts, do I need to install a servlet container such as Tomcat?
Location: http://www.jguru.com/faq/view.jsp?EID=771298
Created: Feb 25, 2002
Author: Aron Tunzi (http://www.jguru.com/guru/viewbio.jsp?EID=446077) Question originally posed by Nguyen van Tin (http://www.jguru.com/guru/viewbio.jsp?EID=761500

Yes, you must!

See the installation requirement for Struts: http://jakarta.apache.org/struts/userGuide/installation.html

I found the following methods in Action.java which I think may help to control the session ID. That means if the user submits the page and press the back button and submit the page again it will throw an error.

generateToken(HttpServletRequest request)
saveToken(HttpServletRequest request)
isTokenValid(HttpServletRequest request)

Before going to a page you want to protect, route to an Action first and call SaveToken. This stores a token with a unique value in the user's session.

If the page uses the html:form tag, it will automatically include a hidden field with the token if it finds one in the session.

In the Action that receives the page, use isTokenValue to see if the token in the session matches the one from the form. Call resetToken to clear the token, so it can't be used again.

HTH -Ted.

How works the "/admin/reload.do" in struts? Hi!
Looking in the struts documentation i found the class ReloadAction, I though that this class reload the struts-config.xml and the application resources without restart the appserver (in my case Tomcat 4.0)...
I want do this because i want modify the MessagesResources file, but when i modify the file and call /admin/reload.do, it updates everything except the MessagesResources file!!
I`m doing something wrong or what?
Please help Me!
PS: There is another way to do it? I mean, update the MessagesResources file?
Location: http://www.jguru.com/faq/view.jsp?EID=779194
Created: Mar 2, 2002
Author: Ted Husted (http://www.jguru.com/guru/viewbio.jsp?EID=462042) Question originally posed by Adolfo De Unanue (http://www.jguru.com/guru/viewbio.jsp?EID=765312

The ReloadAction reloads and reparses the Struts configuration files. The resource bundle used by the MessageResource file is not actually part of the configuration, so it is not reloaded. Some containers do automatically reload property files, but this is not a Struts specific features. It would apply to any Web application using standard resource bundles.

A question to ask in the Tomcat circles might then be "How to configure Tomcat to reload resource bundles when they change.".

HTH -Ted

The Life of An ActionForm

Hi,

Struts uses ActionForms to both populate a HTML form, and then to capture the parameters when a form is submitted.

When a request is submitted, the ActionServlet matches the URI for the request against the path of an action-mapping. If there is a form-bean for that action-mapping, it looks for an ActionForm under the form-bean name. If it doesn't find one, a new one is created. The ActionServlet then calls reset() on the new or pre-existing ActionForm and populates it from the request. If the action-mapping has validate set to true, the ActionServlet calls the validate method. If this returns any error messages, the ActionServlet forwards to the URI indicated by the action-mappings error property. This is often a JSP, but it can also be another action-mapping. The latter being needed when there are drop-down controls to populate and so forth. If there are no errors, the ActionServlet passes the (populated and validated) ActionForm to the Action indicated by the action-mapping element.

When a JSP with an html:form tag is rendered, the html:form tag uses its action path to look-up its action-mapping. Like the ActionServlet, it uses the form-bean to check for a ActionForm in the appropriate servlet context. If it doesn't find one, it creates one. The new or pre-existing ActionForm is then used by the other html:tags to populate their elements.

It's important to note that the form-bean name is used as the default attribute name. Another attribute name can be specified in the action-mapping if needed. Likewise, the html tags default to using the ActionForm related to the html:form tag, but any bean can be specified for any html tag element (ActionForm or not).

When passing ActionForm beans between Actions it is important to note that the ActionServlet will try to populate it again between Actions. If you modify a value, you must be sure to protect it from autopopulate or reset. One way to do that is to add a mutable switch to your ActionForm bean. See SuperForm for an example

HTH, Ted

Passing values from a Collection to Action class Hello Friends, getter and setter functions of form bean work properly. also using the iterator tag, i am able to show values on the jsp page. but when the user changes those values and the control goes to the action class, the values are not changed inside the list. can any one explain why, or an alternative way of doing it, or struts does not support this and has to be done thru response object. Thanks, Suresh.
Location: http://www.jguru.com/faq/view.jsp?EID=827781
Created: Apr 6, 2002
Author: Ted Husted (http://www.jguru.com/guru/viewbio.jsp?EID=462042) Question originally posed by Suresh Bansal (http://www.jguru.com/guru/viewbio.jsp?EID=814148

If the list you are displaying is represented as an array, then it should be repopulated from the request. The usual way to go about handling duplicate parameters is

private String[] items = {"",""};
public String[] getItems() {
    return this.item;
}
public void setItem(String item[]) {
    this.item = item;
}

In the form, you can then write out the array out using the iterate tag

<logic:iterate name="logonForm" property="items" id="item">
<TR>
<TD>Item:</TD>
<TD>
<input type='text' name="item" value='<bean:write name="item"/>'></TD>
</TR>
</logic:iterate>

HTH, Ted

Struts with EJB Hi All, I have a set of EJBs written, I am planning to create a prototype based on struts/MVC concept and I need to use some of the Business Logic Beaans [entity/session beasn] in to prototype implementation, please ealaborate me on this like where exactly those ejb beans be implemented/plugged in to incorporate the business logic? Please post to me @ mushtaqm@covansys.com Thanks & Regards, Mushtaq
Location: http://www.jguru.com/faq/view.jsp?EID=827784
Created: Apr 6, 2002
Author: Ted Husted (http://www.jguru.com/guru/viewbio.jsp?EID=462042) Question originally posed by Mushtaq Mathur (http://www.jguru.com/guru/viewbio.jsp?EID=812586

Generally, EJBs, or any type of business logic, would be called from the Action. Struts brings the input in via the ActionForm bean, where it can be passed to the business tier. When the business operation completes, the Action can react to the outcome and indicate to the ActionServlet where to go next.

HTH, Ted.

ActionForms and Value Objects - Repetition of Code? I was very excited to start using ActionForms and Struts' forms tag library in order to lower the amount of code needed to handle all the forms in the current project I am working on, but then someone came and told me that if we created one ActionForm object for each form we had in the project, we would be repeating code since all those fields in each ActionForm object already existed in the application model's Value Objects.

I know we would be repeating code, but, in my point of view, the ActionForm objects are more connected to the View than the Model, and are a way of grouping all required data in a single place, so the Actions can access them easily.

What do you think about this? Do you think they are correct by saying the ActionForms are just a waste of time, and that they only make the application bigger and more difficult to maintain? They are proposing a solution of integrating the Value Objects with the Action Forms in some manner... which sounds too much time-consuming to me, and might not come to be a good solution at all. Less code doesn't always mean a better solution!

Please state your opinions on this.
Location: http://www.jguru.com/faq/view.jsp?EID=827787
Created: Apr 6, 2002
Author: Ted Husted (http://www.jguru.com/guru/viewbio.jsp?EID=462042) Question originally posed by Frederico Ferro Schuh (http://www.jguru.com/guru/viewbio.jsp?EID=802994

Struts doesn't really need an ActionForm for every form -- it needs a form-bean for every form. In most cases, you can simply define one master ActionForm for your application, with all the properties it uses, and then register it under different form-bean names. This will give each form its own attribute name in the servlet contexts, so that you can have more than one form on a page without anything colliding. The Struts-Validator also goes by the attribute name, so that you can have a different formset for each form-bean, even if they all share the same ActionForm type. Worst case, you can use a base "property bean" ActionForm and subclass it with different validate methods, if needed.

While ActionForms may resemble value objects, they fill a very different purpose. They are really buffers for the HTML controls, and give you a chance to validate untrusted input before passing it along to value objects. HTTP is a wild protoocol and exposing objects designed for another purpose to a Web browser may have unforseen results. Also, HTTP is string-based, everything comes in as a string and somebody has to cope with that.

See also
http://www.mail-archive.com/struts-user@jakarta.apache.org/msg19281.html
http://www.mail-archive.com/struts-user@jakarta.apache.org/msg19338.html
http://www.mail-archive.com/struts-user@jakarta.apache.org/msg20833.html

In Struts 1.1 beta, a Map can be used instead of individual properties on an ActionForm. In the future, I foresee Struts developers using the same base ActionForm in all their projects, without going through the hassle of defining all these String properites.

HTH, Ted

handling errors in file upload with struts

I am using struts and have an upload.jsp and its associated UploadForm.java and UploadAction.java. The jsp's form has an enctype=multipart/form-data and contains an html:file field to upload a file as well as a bunch of text fields for metadata associated with the file. If an error occurs during validation, the struts controller servlet forwards to the jsp with error messages. The problem is that the filepath the user specified is no longer present. Is there a way to restore this value so the user doesn't have to complete this field again (the other text fields remain filled in).
Location: http://www.jguru.com/faq/view.jsp?EID=877085
Created: May 13, 2002
Author: Ramon Gonzalez (http://www.jguru.com/guru/viewbio.jsp?EID=728508) Question originally posed by Pat Marsland (http://www.jguru.com/guru/viewbio.jsp?EID=296781

Not that I know of, but here is a simple solution using JavaScript

When a file is typed or selected using the "BROWSE" button, as soon as the field is populated, a function populates a hidden input text field with the value of the file name that was just selected. Whe you submit your form, you will have the name of the file as part of your request.getParameters("file1name") in your UploadForm.java.

The problem is that the <INPUT TYPE-"file"> will not take a default value, even if you try to force it thru JavaScript. I think this is probably a security feature in JavaScript to avoid "hidden" file uploads from your PC, but you can display the path they entered so they can cut-n-pate it into the INPUT field.

<INPUT TYPE="file" NAME="file1" SIZE="60" MAXLENGTH="60" onchange='return file1Value(this)'>
<INPUT TYPE="hidden" NAME="file1name" VALUE="">

<SCRIPT LANGUAGE="JavaScript1.2">
function file1Value(thisvalue) {
  thisvalue.form.file1name.value = thisvalue.form.file1.value.toString();
  return true;
}
</SCRIPT>

JUnit with singletons What do people think about adding the functionality into JUnit to enable one to load and unload singletons during tests. This can be very helpful, if, for example, several possible states of the singleton that cannot be achieved in succession need to be tested. I've come up against it recently. Perhaps using something like this: http://developer.java.sun.com/developer/ TechTips/2000/tt1027.html#tip3
Location: http://www.jguru.com/faq/view.jsp?EID=877088
Created: May 13, 2002
Author: Janne Nykänen (http://www.jguru.com/guru/viewbio.jsp?EID=874437) Question originally posed by Grisha Golberg (http://www.jguru.com/guru/viewbio.jsp?EID=868035

Well, one way to allow one JUnit testcase to test a singleton class with more that one initialization params is to use a custom classloader to load your singleton; every test-method needs to instantiate a new TestClassLoader instance (a class that extends the jdk ClassLoader). I did it like this:

public class TestClassLoader extends ClassLoader
{
    public Class findClass(String name) throws ClassNotFoundException
    {
        byte[] b = loadClassData(name);
        return defineClass(name, b, 0, b.length);
    }

    private byte[] loadClassData(String name)
        throws ClassNotFoundException
    {
        InputStream stream =
            getClass().getClassLoader()
               .getResourceAsStream(name + ".class");

        String path = null;
        try
        {
            ByteArrayOutputStream bOut = new ByteArrayOutputStream();
            int i;
            while ((i = stream.read()) != -1)
            {
                bOut.write(i);
            }
            return bOut.toByteArray();
        }
        catch (FileNotFoundException ex)
        {
            throw new ClassNotFoundException(
                "Class " + name + " could not be found from " + path,
                ex);
        }
        catch (IOException ex)
        {
            throw new ClassNotFoundException(
                "Class " + name + " could not be found", ex);
        }
    }
}

Multiple params with html:link tag?

How to code my Struts html:link tag such that I can apply multiple dynamic parameters?

<a href="/DeptInfo/do/ViewDept?setID=<%=deptForm.getSetID()%>&<%=deptForm.getDeptID%>">

<html:link forward="ViewDept" paramName="deptForm" paramProperty="setID" paramId="setID" />

If you want to add multipe params in the html:link, you have to save these params into a Map object. The Map's key are paramid and Map's value is paramProperty. And then you can do : <html:link page="ViewDept" name="xxx"/> with xxx is The name of a JSP bean that contains a Map representing the query parameters. You can see in Struts HTML tags for detail. Hope that can solve your problem. good luck, NVT

Using Map instead of String properties with ActionForm. How do you use a Map object with ActionForm with Struts 1.1-b1?

Mr. Husted, in a message posted on the FAQS you said:

In Struts 1.1 beta, a Map can be used instead of individual properties on an ActionForm.

Thanks.
Location: http://www.jguru.com/faq/view.jsp?EID=890992
Created: May 24, 2002
Author: Ted Husted (http://www.jguru.com/guru/viewbio.jsp?EID=462042) Question originally posed by Kevin Turner (http://www.jguru.com/guru/viewbio.jsp?EID=844420

Since 1.1b

    private Map values = null;

    public void setValues(Map values) {
        this.values = values;
    }
    public Map getValues() {
        return this.values;
    }

    public void setValue(String key, Object value) {
        getValues().put(key,value);
    }
    public Object getValue(String key) {
        return getValues().get(key);
    }

...

<html:text property="value(name)"/>

HTH -Ted

Struts Tip #1 - Use an ImageButtonBean to represent an image button.
Location: http://www.jguru.com/faq/view.jsp?EID=893423
Created: May 27, 2002 Modified: 2002-09-06 04:52:16.755
Author: Ted Husted (http://www.jguru.com/guru/viewbio.jsp?EID=462042)

An endless source of aggravation is the HTML input image element. The specification says that browsers should treat this control like an image map. Unlike other buttons, it does not submit a string representing the button's label, it submits the X and Y coordinates. If you look at the HTTP post for an image button, you'll see it looks something like this

myImageButton.x=200
myImageButton.y=300

For most other controls, a Struts developer can create a simple String property to represent the element. This clearly won't work with an image button, because it submits two "dotted" properties instead of a simple "name=value" entry like other elements.

Happily, Struts allows an ActionForm to contain, or nest, other JavaBeans, and will automatically populate the beans using the same syntax as the image element. (What a co-inky-dink!)

To represent an image input element in your ActionForm, say what you mean, and use an ImageButtonBean to capture the X and Y parameters.

public final class ImageButtonBean extends Object {

    private String x = null;
    private String y = null;

    public String getX() {
        return (this.x);
    }

    public void setX(String x) {
        this.x = x;
    }

    public String getY() {
         return (this.y);
    }

    public void setY(String y) {
        this.y = y;
    }

    public boolean isSelected() {
          return ((x!=null) || (y!=null));
    }

} // End ImageButtonBean

Note that we've included a helper method on this bean, isSelected(). This just returns true if either the x or y property is not null. If both are still null, then isSelected() returns false.

Here's how you could declare two ImageButtonBeans on an ActionForm.

// ..

    private ImageButtonBean logonButton = new ImageButtonBean();

    public void setLogonButton(ImageButtonBean button) {
        this.logonButton = button;
    }

    public ImageButtonBean getLogonButton() {
        return this.logonButton;
    }

    private ImageButtonBean cancelButton = new ImageButtonBean();

    public void setCancelButton(ImageButtonBean button) {
        this.cancelButton = button;
    }

    public ImageButtonBean getCancelButton() {
        return this.cancelButton;
    }


// ...

The next question will be "OK, which button did they push?", so let's define another helper method on the ActionForm to tell us.

    public String getSelected() {
            
        if (getLogonButton().isSelected()) {
                return Constants.LOGON;
        }
                
        if (getCancelButton().isSelected()) {
                return Constants.CANCEL;
        }
                
        return null; // nobody home
    }

In an Action, determining which button is pressed is then a simple matter of asking the form what was selected.

        String selected = ((myForm) form).getSelected();
        
        if (Constants.CANCEL.equals(selected)) ...

Of course selected doesn't need to be a String; it could be an int, a custom type to represent your API functions, or even the name of another method for use with a DispatchAction.

Using "API helper methods" on ActionForms, as we did with getSelected(), is a very useful technique. We'll use it again in Tip #2, when we discuss the standard Dispatch Actions.

HTH, Ted.

---

Struts Tips are excerpts from the book Java Web Development with Struts. The tips released twice weekly on the MVC-Programmers List. To subscribe, visit BaseBean Engineering.

About Ted. Ted Husted is an active Struts Committer and co-author of Java Web Development with Struts and Professional JSP Site Design. Ted also moderates the Struts mailing list and the JGuru Struts FAQ.

Copyright Ted Husted 2002. All rights reserved.

---

MVC-Programmers mailing list
MVC-Programmers@basebeans.com
http://www.basebeans.com:8081/mailman/listinfo/mvc-programmers

Struts Tip #2 - Use DispatchAction to organize related operations
Location: http://www.jguru.com/faq/view.jsp?EID=897290
Created: May 30, 2002 Modified: 2002-09-06 04:51:29.193
Author: Ted Husted (http://www.jguru.com/guru/viewbio.jsp?EID=462042)

Any software application is defined by the things it can do for you. In a Struts Web application, the things an application does is usually defined by its action-mapping elements. An action-mapping is designed to be the target of an HTML form, and is often used with hyperlinks as well.

Each action-mapping can specify a Struts Action class as its handler. In larger applications, developers can find themselves managing dozens or even hundreds of Action classes.

In practice, many of these Action classes handle related operations, often evidenced by their name. A package might include separate RegCreate, RegSave, and RegDelete Actions, which just perform different operations on the same RegBean object. Since all of these operations are usually handled by the same JSP page, it would be handy to also have them handled by the same Struts Action.

A very simple way to do this is to have the submit button modify a field in the form which indicates which operation to perform.

<html:hidden property="dispatch" value="error"/> 
<SCRIPT>function set(target) {document.forms[0].dispatch.value=target;}</SCRIPT>
<html:submit onclick="set('save');">SAVE</html:submit>
<html:submit onclick="set('create');">SAVE AS NEW</html:submitl> 
<html:submit onclick="set('delete);">DELETE</html:submit>

Then, in the Action you can setup different methods to handle the different operations, and branch to one or the other depending on which value is passed in the dispatch field.

String dispatch = myForm.getDispatch();
if ("create".equals(dispatch)) { ...
if ("save".equals(dispatch)) { ...

The Struts Dispatch Action [org.apache.struts.actions] is designed to do exactly the same thing, but without messy branching logic. The base perform method will check a dispatch field for you, and invoke the indicated method. The only catch is that the dispatch methods must use the same signature as perform. This is a very modest requirement, since in practice you usually end up doing that anyway.

To convert an Action that was switching on a dispatch field to a DispatchAction, you simply need to create methods like this

public ActionForward create(
    ActionMapping mapping, 
    ActionForm form, 
    HttpServletRequest request, 
    HttpServletResponse response) 
  throws IOException, ServletException { ...

public ActionForward save(
    ActionMapping mapping, 
    ActionForm form, 
    HttpServletRequest request, 
    HttpServletResponse response) 
  throws IOException, ServletException { ...

Cool. But do you have to use a property named dispatch? No, you don't. The only other step is to specify the name of of the dispatch property as the "parameter" property of the action-mapping. So a mapping for our example might look like this:

<action 
  path="/reg/dispatch" 
  type="app.reg.RegDispatch" 
  name="regForm" 
  scope="request" 
  validate="true" 
  parameter="dispatch"/>

If you wanted to use the property "o" instead, as in o=create, you would change the mapping to

<action 
  path="/reg/dispatch" 
  type="app.reg.RegDispatch" 
  name="regForm" 
  scope="request" 
  validate="true" 
  parameter="o"/>

Again, very cool. But why use a JavaScript button in the first place? Why not use several buttons named "dispatch" and use a different value for each?

You can, but the value of the button is also its label. This means if the page designers want to label the button something different, they have to coordinate the Action programmer. Localization becomes virtualy impossible.

If you prefer not to use JavaScript buttons, you can use the DispatchLookup Action instead. This works much like the DispatchAction, but requires more setup. We'll explore the DispatchLookup Action in Tip #3.

HTH, Ted.

---

Struts Tips are excerpts from the book Java Web Development with Struts. The tips released twice weekly on the MVC-Programmers List. To subscribe, visit BaseBean Engineering.

About Ted. Ted Husted is an active Struts Committer and co-author of Java Web Development with Struts and Professional JSP Site Design. Ted also moderates the Struts mailing list and the JGuru Struts FAQ.

Copyright Ted Husted 2002. All rights reserved.

---

MVC-Programmers mailing list
MVC-Programmers@basebeans.com
http://www.basebeans.com:8081/mailman/listinfo/mvc-programmers

Struts Tip #3 - Use LookupDispatchAction for a JavaScript-free dispatch
Location: http://www.jguru.com/faq/view.jsp?EID=900642
Created: Jun 3, 2002 Modified: 2002-09-06 04:50:22.724
Author: Ted Husted (http://www.jguru.com/guru/viewbio.jsp?EID=462042)

Many forms can be put to multiple uses. The fields we need to create a record are usually the same fields we use to update a record. Likewise, the same page can usually used to identify a record to delete, copy, or update a record. 

A DispatchAction (see Tip #2) is a convenient way to collect related operations like this into a single Struts Action class. A field in the request identifies the operation, and so all the developer has to do is get the right value into the field. The simplest way to do this is to label the buttons for the operation, and give each button the same name. But that ties the presentation label to the business operation and confounds localization. 

As an alternative, most developers use a JavaScript attached to the button to update the dispatch field, which in practice works quite well. If JavaScript is not enabled, the submit fails gracefully, and in practice most applications do rely JavaScript for essential operations. 

If JavaScript is not an option, another good alternative is the LookupDispatchAction [org.apache.struts.actions.LookupDispatchAction]. This object is a little more work to setup that the original DispatchAction, but lets you use this technique without using JavaScript as a crutch. 

As with the DispatchAction, the first step is to indicate the name of the dispatch parameter in the action-mapping element. In this case the parameter will the name given to each of the buttons, rather than a hidden field. Let's just call our buttons "submit", which is the default name the html:submit tag will use. 

<action path="/test"
type="org.example.MyAction"
name="MyForm"
scope="request"
input="/test.jsp"
parameter="submit"/>

In our JSP, we can refer to the buttons in the usual way 

<html:form action="/test">
<html:submit>
<bean:message key="button.add"/>
</html:submit>
<html:submit>
<bean:message key="button.delete"/>
</html:submit>
</html:form>

Later, when the user selects a button, the form will pass the submit parameter, along with whatever message is Struts finds for "button.add" or "button.delete" in the resource bundle. In a localized application, this message could vary by the user's selected locale. 

Using the conventional DispatchAction, this approach would problematic, since there would have to a Java method named for each message, and not all the messages might valid Java identifiers. This is where the magic of the LookupDispatchAction comes into play. 

When you create your LookupDispatchAction subclass, along with the methods for the dispatch operations (see Tip #20) you must also implement a getKeyMethodMap method. This is a "hotspot" that the LookupDispatchAction will call. 

Here's an example of the methods you might declare in your subclass:

protected Map getKeyMethodMap(ActionMapping mapping,
    ActionForm form,
    HttpServletRequest request) {
  Map map = new HashMap();
  map.put("button.add", "add");
  map.put("button.delete", "delete");
  return map;
}

public ActionForward add(ActionMapping mapping,
    ActionForm form,
    HttpServletRequest request,
    HttpServletResponse response)
  throws IOException, ServletException {
  // do add
  return mapping.findForward("success");
}

public ActionForward delete(ActionMapping mapping,
    ActionForm form,
    HttpServletRequest request,
    HttpServletResponse response)
    throws IOException, ServletException {
  // do delete
  return mapping.findForward("success");
}

Internally, the base action will lookup the messages for button.add and button.delete, and match those against the submit parameter. When it finds a match, it will then use either "add" or "delete" to call the corresponding methods. 

So while the LookupDispatchAction means adding an extra method to your Action, it lets you skip putting a JavaScript in your form.

Both the DispatchAction and LookupDispatchAction are an excellent way to streamline your Struts action classes, and group several related operations into a single umbrella action. 

So, how many dispatch actions do you need? Can you use a dispatch action to collect everything into a single action?

Most often not. In practice, you can easily use one dispatch action for any forms that share a common validation. Sharing a dispatch action between different form beans, or form beans that are validated differently, can start to make things harder rather than simpler. But the use of a dispatch action can easily half or quarter the number of action classes in most Struts application. 

HTH, Ted.

Credits. The LookupDispatchAction was originated by Erik Hatcher, one of Struts many volunteer contributors. The examples used in this tip relied heavily on Erik's documentation. (Yeah reuse! Yeah JavaDocs!)

-----

Struts Tips are released twice weekly on the MVC-Programmers List. To subscribe, visit BaseBean Engineering.

Struts Tips are excerpts from the book Java Web Development with Struts. The tips released twice weekly on the MVC-Programmers List. To subscribe, visit BaseBean Engineering.

About Ted. Ted Husted is an active Struts Committer and co-author of Java Web Development with Struts and Professional JSP Site Design. Ted also moderates the Struts mailing list and the JGuru Struts FAQ.

Copyright Ted Husted 2002. All rights reserved.

---

MVC-Programmers mailing list
MVC-Programmers@basebeans.com
http://www.basebeans.com:8081/mailman/listinfo/mvc-programmers

Struts Tip #4 - Formatting output with MessageResources
Location: http://www.jguru.com/faq/view.jsp?EID=915891
Created: Jun 17, 2002 Modified: 2002-11-09 19:41:09.511
Author: Ted Husted (http://www.jguru.com/guru/viewbio.jsp?EID=462042)

A common requirement of the presentation layer is to format information in a human-friendly way. While a numeral rendered as 1000000 works well for the software, most humans can't turn that data into information at a glance. Humans expect a numeral to be rendered as 1,000,000 - which they can interpret at a glance to be the value one million.

At least to Americans.

People in other countries might find the name rather strange, since it includes two decimal points, or what an American would render as 1.000.000.

Since many Struts applications are localized, this are important issues. When a page in a Struts application renderes a number, or a date, or a percentage, it should be able to do so according to each user's locale.

Struts already has localized messaging built-in, which most developers use for error messages, prompts, and field label names. A Struts applications refers to messages like this using a symbolic key, which is used to retrieve the actual messages from the Struts application resource bundle. The messages can also be used as templates, and the application can pass custom values to them at runtime. Often, there is a default template for an entire class of message, and the field name or other value is merged into the static text at runtime. Each locale can have it's own resource properties file, which

Now, it's important to note that Struts didn't invent any of this. Resource bundles, message templates, locales, and the rest of it are all part of the Java internationalization framework. Struts makes Java i18n an intregal part of its own framework, and provides support classes making it easier to use. But the core functionality is provided by the Java internationalization framework.

Including the abilty to apply formatting to a value a runtime.

Most message templates are created by just indicating the placeholder, like

ordering.authorized.range.staff=Staff is only authorized to requisition supplies that cost less than ${0}

It then becomes the application's responsiblility to supply whatever string is needed to replace {0}, which will be inserted into the message template, as-is.

However, you can also pass more than one parameter as the placeholder, and also include one of the standard message format classes: number, currency, percent - along with a default mask. This means you can just as easily render the template as

ordering.authorized.range.staff=Staff is only authorized to requisition supplies that cost less than {0,currency}

which will insert the appropriate thousands-delimter or decimal-separator for the user's locale. This example would also insert the monetary symbol for the user's country. If everything should be expressed in a single currency, then you'd use number instead

ordering.authorized.range.staff=Staff is only authorized to requisition supplies that cost less than ${0,number} USD

The same technique can be applied to dates and percentages. See the Java Internationalization Tutorial's page on the MessageFormat class for more

While the Struts application resource bundle is most often used when generating error messages, the <bean:message> tag can be used to access message templates throughout your application, and pass the replacement parameters at runtime to generate a customized display.

Here's the same example message coded for <bean:message>

<bean:message key="ordering.authorized.range.staff" arg0='<%= config.getStaffAuthAmnt() %>'/>

where there is a bean in some scope named "config" that can return the amount in question.

HTH, Ted.

-----

Struts Tips are excerpts from the book Java Web Development with Struts. The tips released twice weekly on the MVC-Programmers List. To subscribe, visit BaseBean Engineering.

About Ted. Ted Husted is an active Struts Committer and co-author of Struts in Action and Professional JSP Site Design. Ted also moderates the Struts mailing list and the JGuru Struts FAQ.

Copyright Ted Husted 2002. All rights reserved.

---

MVC-Programmers mailing list
MVC-Programmers@basebeans.com
http://www.basebeans.com:8081/mailman/listinfo/mvc-programmers

Struts Tip #5 - Use coarse-grained ActionForms
Location: http://www.jguru.com/faq/view.jsp?EID=915895
Created: Jun 17, 2002 Modified: 2002-09-06 04:43:12.545
Author: Ted Husted (http://www.jguru.com/guru/viewbio.jsp?EID=462042)

The biggest hassle for any Struts developer can maintaining the #@$!% ActionForms. The ActionForm provides several important services to an application, since it is

• a firewall, 
• a buffer for the HTML controls, and 
• a mutable transfer object.

As a firewall it keeps untrusted input from passing directly into your application. As a field buffer, it stores new input so it can verified before it is passed to more trusting parts of your application, As a mutable transfer object (fka value object), the ActionForm provides an extensible container where data can collected and passed in a batch to one or more business or resource layer objects.

But, in practice, you usually need a different form-bean for each HTML form in your application. This makes it easy to store the data for each form under its own attribute, and to fine-tune the validation for each form.

Hey -- what's that about form-beans? I thought we were talking about ActionForms?

This is an important distinction. Each HTML form typically needs its own form-bean, but a form-bean is not an ActionForm. A form-bean identifies which ActionForm to use, in the same way an action-mapping identifies which Action class to use. Many Struts developers share Actions between action-mapping, but tend to forget that you can share ActionForms between form-beans too.

While ActionForms are vital objects, they are not subtle. Typically, they are a pure data-only JavaBean, with nothing but accessors and mutators. Occasionally, there is a helper method to transform data from one type to another, but even those are a simple wrappers around standard library functions. With the Struts-Validator, most ActionForms don't even need to subclass validate(). All that's needed is to define a formset for each form-bean, or attribute, that needs validation.

So, why bother with more than one ActionForm class? The form-bean determines the runtime attribute name, and therefore the formset the Struts-Validator will use. Neither the validator nor the autopopulation utilities care if there are more properties a form than are used with a given request. And, null properties consume fewer resources that instantiating yet another class. So why not just put all the application's properties together in a single ActionForm?

Worst case, you can define a base ActionForm with all the properties you need, and subclass to provide any custom validations. Meanwhile, by aggregating your application's properties into a single ActionForm, several key benefits are realized.

• Better Manageability. Implementing ActionForms as fine-grained containers results in a large number of objects in the application, many of which have redundant properties. This consumes both system and developer resources, and can negatively impact application performance and long-term maintenance.
• Relationships are preserved. Most HTML forms represent, in part, a SQL view, which includes properties from several different tables. If an ActionForm contains properties for all the fields, any relationship can represented.
• Schema independance. When ActionForms are fine-grained, each ActionForm usually represents a single row in a database. This ties the presentation layer to the database schema, rather than to the greater business model. When the schema changes, fine-grained ActionForm objects may also need to changed. Coarse-grained ActionForms change less frequently, since if a field is moved from one table to another, it will still available the form. If a field is introduced or renamed, only one ActionForm object needs to adjusted.

In a larger application being developed by a team, you may want more than one ActionForm for the application (even if you don't "need" one). There may, for example, be one ActionForm each each major segment of the application being handled by a smaller group or pair of programmers within the team. The important thing is to try and group together all the properties that will be used together, so that they are not continually re-defined throughout several related classes. ActionForms are objects too and can be subclassed like any other object.

So the next time you need an ActionForm to go with a new form-bean, think twice before creating a new class. Maybe you already have one you can reuse.

HTH, Ted.

-----

For more about aggregate entities in J2EE applications, see < http://developer.java.sun.com/developer/restricted/patterns/AggregateEntity.html >.

Struts Tips are released twice weekly on the MVC-Programmers List. To subscribe, visit BaseBean Engineering.

Struts Tips are excerpts from the book Java Web Development with Struts. The tips released twice weekly on the MVC-Programmers List. To subscribe, visit BaseBean Engineering.

About Ted. Ted Husted is an active Struts Committer and co-author of Java Web Development with Struts and Professional JSP Site Design. Ted also moderates the Struts mailing list and the JGuru Struts FAQ.

Copyright Ted Husted 2002. All rights reserved.

---

MVC-Programmers mailing list
MVC-Programmers@basebeans.com
http://www.basebeans.com:8081/mailman/listinfo/mvc-programmers

Struts Tip #6 - Use an array to capture multiple parameters
Location: http://www.jguru.com/faq/view.jsp?EID=915898
Created: Jun 17, 2002 Modified: 2002-09-06 04:42:13.652
Author: Ted Husted (http://www.jguru.com/guru/viewbio.jsp?EID=462042)

In a perfect universe, our users would happily subscribe to the One True Workflow. In every case, we could list some records, select a record to view or edit, and list some records again. But in real life, users often want to do unreasonable things, like edit 17 records at once.

Usually, we'd already have a business procedure for saving one copy of the record. Perhaps something like this

String key= form.getKey();
String category = form.getCategory();
db.updateCategory(new Integer(key),category);

A very simple way to convert this to "multiple use" would to do something like this:

String[] key = form.getKey();
String[] category = form.getCategory();
for (int i=0; i<category.length; i++) { db.updateCategory(new Integer(key),category); }

Depending on what the db object did behind the scenes, and the scale of the application, this code fragment could too simple to be efficient, but for many small intranet applications, it could work just fine.

Of course, that still leaves the problem of where to get an array of keys and a matching array of categories.

Happily, HTTP supports submitting multiple parameters of the same name, and Struts will autopopulate a String array as easily as a single String. So, to represent the "multi-use" business operation in an ActionForm, we can do this:

private String[] key= null;
public String[] getKey() { return this.key; }
public void setKey(String[] key) { this.key = key; }

private String[] category = null;
public String[] getCategory() { return this.category; }
public void setCategory(String[] category) { this.category = category; }

Which is just the single-record version but with String[] instead of String.

In the JavaServer Page, the only real trick is to refer to the iterate id in the html form tags.

<TABLE><html:form action="/item/StoreCategory">
<logic:iterate name="RESULT" property="iterator" id="row">
<TR>
<TH>name</TH>
<TH>category</TH>
</TR>
<TR>
<TD><bean:write name="row" property="name"/></TD>
<TD><%-- REMEMBER TO SPECIFY THE ITERATE ID AS THE NAME --%>
<html:select name="row" property="category">
<html:option value="ART">Art</html:option>
<html:option value="AUT">Automotive</html:option>
<%-- ... --%>
</html:select>
<%-- REMEMBER TO SPECIFY THE ITERATE ID AS THE NAME --%>
<html:hidden name="row" property="key"/>
</TD>
</TR>
</logic:iterate>
<TR>
<TD colspan="2" align="right">
<html:submit/>
</TD>
</TR>
</html:form>
</TABLE>

Now when they submit the form, it will include several category=XYZ&key=123 pairs in the request. Struts will convert the category and key entries into individual arrays, and the arrays can be used with your business objects to make the appropriate update.

HTH, Ted.

-----

Struts Tips are excerpts from the book Java Web Development with Struts. The tips released twice weekly on the MVC-Programmers List. To subscribe, visit BaseBean Engineering.

About Ted. Ted Husted is an active Struts Committer and co-author of Java Web Development with Struts and Professional JSP Site Design. Ted also moderates the Struts mailing list and the JGuru Struts FAQ.

Copyright Ted Husted 2002. All rights reserved.

---

MVC-Programmers mailing list
MVC-Programmers@basebeans.com
http://www.basebeans.com:8081/mailman/listinfo/mvc-programmers