JavaEnterprise JavaAn Introduction to Struts

An Introduction to Struts content and product recommendations are editorially independent. We may make money when you click on links to our partners. Learn More.


Welcome to the first in a series of articles on Jakarta Struts (or simply, “Struts”), the Java/JSP-based framework for building Web-based applications. While later articles will get deep into the technology behind Struts, this first article provides an introduction to Struts and evaluates the case for using it. It tries to cut through the technology and put its finger on the “value add” that Struts provides.

“What Is Struts and Why Should I Care?”

Struts is an application development framework that is designed for and used with the popular J2EE (Java 2, Enterprise Edition) platform. It cuts time out of the development process and makes developers more productive by providing them a series of tools and components to build applications with. It is non-proprietary and works with virtually any J2EE-compliant application server. Struts falls under the Jakarta subproject of the Apache Software Foundation and comes with an Open Source license (meaning it has no cost and its users have free access to all its internal source code).

In addition to helping you work faster and having no cost, Struts also helps make your end work products better. The main reason for this, to quote from Eric Raymond’s “The Cathedral and the Bazaar” (a classic book on open source development), is that “(g)iven a large enough beta-tester and co-developer base, almost every problem will be characterized quickly and the fix obvious to someone.” In other words, so many people are using and developing Struts that bugs are found and get fixed quickly.

“Struts is a Web Application ‘Framework’?”

The dictionary calls a framework “A structure for supporting or enclosing something else, especially a skeletal support used as the basis for something being constructed.” This perfectly describes Struts—a collection of Java code designed to help you build solid applications while saving time. It provides the basic skeleton and plumbing; you focus on the layout and look of each room.

Interestingly, the dictionary offers an alternative definition of a framework: “A set of assumptions, concepts, values, and practices that constitutes a way of viewing reality.” This describes Struts as well—it’s a way of looking at things. Struts saves you time by allowing you to view complex applications as a series of basic components: Views, Action Classes, and Model components.

“… And Frameworks Are Important Because?”

Using a framework means that you don’t have to spend time building your entire application. You can focus on coding the business logic and the presentation layer of the application—not the overhead pieces like figuring out how to capture user input or figuring out how to generate drop-down boxes on a Web page.

Using a framework also helps you encode best practices. The framework developers have put a lot of thought into the best approaches to application building—why reinvent this yourself?

Another benefit of using a framework is that it allows your code (at least in the case of Struts) to be highly platform independent. For example, the same Struts code should work under Tomcat on an old Windows machine as runs using Weblogic on Linux or Solaris in production. And this can be accomplished without even recompiling in many cases—the same Web application (or “. war” file) can simply be copied from one server to another.

Another extremely important benefit—especially if you’re relatively new to Web development—is that it gives you a place to start. Any developer will tell you it’s easier to take a basic application and modify it than it is to build something from scratch. This feature of Struts can save you days or weeks of planning and development.

Today, I create virtually nothing from scratch. Almost no one who is an experienced developer does. In fact, some of the greatest successes in software development were based on this exact idea. For example, in 1991 when Linus Torvalds began building the operating system that today is Linux, he began with the operating system Minix. He got a copy of the Minix source code, looked it over in detail, and used it as the basis for Linux. And while the first launch of Linux contained none of the original Minix code, Linus surely went further, faster because he had it to start with.

How Does Struts Work?

Struts is based on the time-proven Model-View-Controller (MVC) design pattern. The MVC pattern is widely recognized as being among the most well-developed and mature design patterns in use. By using the MVC design pattern, processing is broken into three distinct sections aptly named the Model, the View, and the Controller. These are described in the following subsections:

Model Components

Model components provide a “model” of the business logic or data behind a Struts program. For example, in a Struts application that manages customer information, it may be appropriate to have a “Customer” Model component that provides program access to information about customers.

It’s very common for Model components to provide interfaces to databases or back-end systems. For example, if a Struts application needs to access employee information that is kept in an enterprise HR information system, it might be appropriate to design an “Employee” Model component that acts as an interface between the Struts application and the HR information system.

Model components are generally standard Java classes. There is no specifically required format for a Model component, so it may be possible to reuse Java code written for other projects.

View Components

View components are those pieces of an application that present information to users and accept input. In Struts applications, these correspond to Web pages.

View components are used to display the information provided by Model components. For example, the “Customer” Model component discussed above would need a View component to display its information. Usually, there will one or more View components for each Web page in a Struts application.

View components are generally built using JavaServer Page (JSP) files. Struts provides a large number of “JSP Custom Tags” (sometimes referred to as Struts Tags) which extend the normal capabilities of JSP and simplify the development of View components.

Controller Components

Controller components coordinate activities in the application. This may mean taking data from the user and updating a database through a Model component, or it may mean detecting an error condition with a back-end system and directing the user through special error processing. Controller components accept data from the users, decide which Model components need to be updated, and then decide which View component needs to be called to display the results.

One of the major contributions of Controller components is that they allow the developer to remove much of the error handling logic from the JSP pages in their application. (After all, if errors in processing occur, the Controller component forwards to an error-processing View component, not the primary results View component.) This can significantly simplify the logic in the pages and make them easier to develop and maintain.

Controller components in Struts are Java classes and must be built using specific rules. They are usually referred to as “Action classes.”

“Bottom Line Benefits of MVC”

Remember the earlier definition that described a Framework as “A set of assumptions, concepts, values, and practices that constitutes a way of viewing reality?” This is one of the most powerful benefits of the MVC pattern. It allows developers to think about (and design) complex applications as a series of relatively simple Model, View, and Controller components. This leads to better, more consistent, and more easily maintainable designs. In addition, it helps avoid the common pitfall of having each developer on a project choose a different approach for their work.

Case Study: Right Hand Manager Software

When Dennis Doubleday and others on his team at Right Hand Manager Software ( were evaluating how they wanted to do development, they decided right away that they wanted to use a framework that was based on the MVC design pattern. This decision came after having built a number of applications based on the J2EE platform. On previous projects, Dennis says “We spent a lot of time developing the re-usable framework and not our application.”

In other words, they wanted a framework that allowed them to focus on building their application without spending a lot of time writing the code that organized and coordinated processing. After reviewing a number of other competing frameworks, they settled on Struts for a number of reasons—some technical and some not. The Struts technical features that were important to them were:

  • Struts performs well.
  • Struts has a sound architectural model with a modest learning curve.
  • Struts is very solid and stable.
  • Struts has a strong set of custom tag libraries that simplify JSP development.

Also, according to Dennis, “Struts is very competitive technically, but to my mind the biggest advantages Struts has over competing technologies are practical.” These features are:

  • ongoing development by a large number of committed users/developers
  • knowledgeable and responsive project leadership
  • generally quick (and sometimes near-instant) problem resolution via the Struts mailing list or archives
  • access to source code
  • strong connection to and commitment to future integration with forward-looking technologies like JSTL and Java Server Faces
  • increasing mind share that we expect will make it easier to hire new developers already familiar with the framework”

How have things worked out for them? Again, according to Dennis, “We are very happy with the way it is working out so far. There is very little burden on us to understand or implement the plumbing of our application; we simply create our Action and Form class extensions and our application Model beans.”

Their results have been faster, more consistent development, and have excellent support. Plus, the platform they are building on is stable and constantly being improved. Oh—and by the way—it’s free and you can get all the source code if you want it.


So, the question arises, should you consider adopting Struts? Of course, your answer depends on your particular circumstances and environment, but here are some criteria to consider:

  • Are you using the J2EE platform (that is, developing applications using J2EE-compliant servers such as Weblogic Server, Websphere Application Server, Jakarta Tomcat, JBoss, iPlanet, and so forth)? If the answer to this is yes, Struts is likely worth considering.
  • Do your developers have Java expertise? Although this isn’t a “make or break” criterion, it helps. If your developers don’t have Java experience but you are dedicated to moving to Java anyway, Struts may actually make the transition easier.
  • Are you building applications that need to work in a Web browser? This is the niche that Struts fills. If the answer is no, Struts isn’t for you. Unless you have requirements for browser-based application delivery, Struts won’t add much value.
  • Are you building applications now that use JavaServer Pages (JSP)? If so, you should definitely be looking at Struts. It may increase your developer productivity significantly.
  • Is your development team considering building a “custom framework” for building Web-based applications? If so, ask them to justify not using Struts. Anything they would build on their own would likely not undergo near the amount of testing and development that Struts has. While they may have good reasons for not using it, Struts should definitely be on their radar.

To summarize, Struts is an application “Framework” for building Web-based applications in Java using the J2EE platform. Struts makes developers more productive by giving them prebuilt components to assemble applications from. Struts was built using industry best practices including the MVC design pattern and it can be deployed in a wide range of environments.

If you are using the Java/J2EE platform—and especially if you are currently developing applications using JavaServer Pages (JSP)—you should be considering Struts for the development of browser-based applications.

About the Author

Kevin Bedell has a degree in Engineering from Michigan Tech and an MBA from the Crummer Graduate School of Business at Rollins College. Portions of this article were adapted from material in his upcoming book for SAMS Publishing, Struts Kick Start (ISBN: 0-672-32472-5). A companion PowerPoint presentation suitable for presenting these ideas to a management group is available at

Get the Free Newsletter!

Subscribe to Developer Insider for top news, trends & analysis

Latest Posts

Related Stories