It is always an exciting time when you first start to use a new software framework. Spring 2, indeed,... more

It is always an exciting time when you first start to use a new software framework. Spring 2, indeed, is an exciting software framework in its own right. However, it is also a fairly large framework. In order to apply it effectively in your daily work you must first get some fundamental understanding of the following issues:

• Why Spring exists

• What problem it is trying to solve

• How it works

• What new techniques or concepts it embraces

• How best to use it

This chapter attempts to get these points covered as quickly as possible and get you using the Spring 2 framework on some code immediately. The following topics are covered in this chapter:

• A brief history of the Spring framework and design rationales

• A typical application of the Spring framework

• Wiring Java components to create applications using Spring

• Understanding Spring’s autowiring capabilities

• Understanding the inversion of control and dependency injection

• Understanding the available API modules of Spring 2

Having read this chapter, you will be equipped and ready to dive into specific areas of the Spring framework that later chapters cover.

... less

Chapter 1 provided you with a basic understanding of what the Spring framework is and how it is used.... more

Chapter 1 provided you with a basic understanding of what the Spring framework is and how it is used. This chapter shows how to go about designing a system that uses the Spring framework. One of the key benefits of using Spring, as you will appreciate from this chapter, is that it stays completely out of the way until you need it. Instead of thinking about how the application must fit the framework right at the start, and potentially constraining your design, you simply design your application and then add the Spring framework later!

This may sound a little incredible at first, especially if you are coming from the world of heavyweight frameworks such as J2EE. With Spring, you need not consider up front how clients will connect and access the application, how transactions are handled, how database connections must be managed, how authentication and authorization must be implemented, and so on. All of these concerns, having no direct relation to the application objects and the business logic, can be addressed on later with Spring. This is a benefit delivered by the Spring’s AOP (aspect-oriented programming) orientation.

When you design a Spring-based system, you can start by constructing a series of interacting POJOs (plain old Java objects), forming the domain model of the system. These POJOs become the core objects in the resulting system. You can then use Spring’s inversion of control mechanisms (via annotations and XML-based configuration, as shown in Chapter 1) to hook up other services to the set of POJOs.

To see how the Spring framework stays out of the way in your design, this chapter covers the design and initial coding of the domain model of a system called PIX. PIX is a Spring-based implementation of an Internet-based photo-album management system. The PIX system is introduced in this chapter, but its features are described and developed throughout later chapters in the book.

For this chapter, the focus is on the higher-level design of the PIX system. The chapter takes a step-by-step approach to describe the design. These steps include:

1. An overview of the PIX album-management system

2. Defining the requirements

3. Putting together the domain model

a. Identifying the POJOs

b. Creating the repositories

4. Identifying the relationships between the objects

5. Coding the objects and methods to support the relationships

6. Coding and running unit tests

Along with the descriptions, you'll find design rationale and Java code that implements the logic. The resulting body of code forms the domain model of the system, and is a core component of the source code for the final system.

By the end of the chapter, you will understand the following:

• POJO-based design fundamentals

• Design of a domain model for PIX

• The importance of unit testing

• How to write and run unit tests

This is the only chapter in this book that focuses on system design. It presents the POJO code that forms the domain model, and you get a chance to test out all the code when you run the all-important unit tests.

... less

Up until now, we haven't looked at the need for applications to store and preserve data. Many applications must store... more

Up until now, we haven't looked at the need for applications to store and preserve data. Many applications must store data beyond the application’s own lifetime. In fact, some business applications are created specifically to store, retrieve, and modify data. It is very important to understand how Spring can help in creating these applications.

The storage of data, in object-oriented systems, is called persistence. When a data object is saved to a database, the object has been persisted. Of course, you can persist your data objects to disk using your own custom-written code, perhaps calling a database’s published API. But when you use modern frameworks, such as Spring, there is often built-in support to make object persistence simple.

In the world of enterprise software development, component persistence is synonymous with entity Enterprise Java Beans (EJBs). Entity EJBs are business data components that can be automatically stored into and retrieved from a variety of relational databases. Unfortunately, you need to pay a hefty price for automated EJB persistence support: you must run a large server called the Java EE EJB container.

The "heavyweight server" requirement was such a widespread industry problem that in June 2003 a JSR 220 expert group was chartered in order to simplify EJB container-managed persistence (CMP). The expert group decided that a simplification of EJB CMP was not sufficient, and that what was needed was a lightweight framework that can persist plain old Java objects (POJOs). The effort of the expert group resulted in the Java Persistence API (JPA) specification. JPA is the official persistence mechanism of the Java 5 EE platform.

JPA takes a revolutionary approach to object persistence by leaving the heavyweight Java EE container out of the equation. While JPA support can work well with the rest of the Java EE 5 engine machinery, it is its ability to work completely outside the container that makes it extremely versatile.

Before the arrival of JPA, the Spring framework supported a variety of persistence mechanisms. It supported the direct use of JDBC, the implementation of a unifying data access object (DAO) abstraction layer, and a variety of object-to-relational-mapping (ORM) technologies. However, it is with JPA that Spring-based POJO persistence really shines.

This chapter introduces you to the myriad means of data access and persistence support available to you within the Spring framework. You’ll see for yourself how Spring uses DAO, templates, and support classes to unify the programmatic access of data. Most importantly, you'll learn about JPA and how Spring allows you to persistence-enable any POJO component with almost no database-specific API programming.

The hands-on exercises in the chapter have you persistence-enabling the Pix domain model objects. You gain firsthand knowledge of storing, retrieving, and modifying Pix POJOs to and from relational databases — all without making a single relational database API call.

In this chapter you learn about the following:

• JDBC and Spring support for JDBC

• The data access objects (DAOs) and Spring support for them

• JPA and Spring support for JPA

• Persisting the Pix domain model using JPA

... less

In the previous chapters you built your photo album’s domain model, mapped it to a database,... more

In the previous chapters you built your photo album’s domain model, mapped it to a database, and made sure that everything worked properly with a series of unit and integration tests. In this chapter you are ready to start showing some pictures!

Before showing the pictures, however, you will need to understand what the MVC acronym stands for. Then you can jump into the details of configuring a Spring-based server, which will enable you to interact with the application using your favorite web browser. You’ll learn about all the magic that’s going on the moment you enter a URL and hit the server with a page request. After you have served your first simple web page, you will delve into the details of writing web forms that can be used to submit data to the database.

In this chapter, the following topics are covered:

• MVC concepts

• Spring and MVC

• Unit-testing of Spring controllers

• Forms with Spring MVC

• Validation with Spring

Exceptions with Spring MVC

... less

The previous chapter covered the basics of Spring MVC. Now you are ready to take Spring MVC one step further and dive... more

The previous chapter covered the basics of Spring MVC. Now you are ready to take Spring MVC one step further and dive into some of the more advanced capabilities that make it such a powerful means of building web applications.

First you'll learn how to submit a form that spans multiple pages. This feature comes in handy when you want to have your users navigate through a couple of pages rather than squeeze the entire form in a single page. While multiple pages are often used for complex forms such as tax declarations or insurance policy applications, in this example you'll use a multipage form to upload pictures to a photo album.

Once you know how to add images to a photo album, you use the MultiActionController class to group related actions for transforming pictures. Grouping related actions can spare you a lot of typing work as it saves having to code and configure a new controller for each individual action.

After the tour of advanced controllers you go beyond HTML and take a look at different views so that you can download data as a PDF or an Excel spreadsheet. You top this off with a hands-on exercise that teaches you how to set up an RSS news feed. After all, you’d want your friends to come back to the site whenever you upload new pictures.

In this chapter you will learn how to use Spring MVC to do the following:

• Submit web forms across multiple pages

• Upload files to the server

• Process related requests with the same controller

• Create PDF and RSS files

• Personalize a web application with themes

• Attract international users by adding translations to your site

... less

Web application page flow can become complex very easily, requiring you to have inside knowledge of an application's implementation... more

Web application page flow can become complex very easily, requiring you to have inside knowledge of an application's implementation just to understand the flow through the application. It is virtually guaranteed that anyone developing web applications will experience this problem at some point. By and large, the most common way to deal with page flow is to hard-code it into the application. However, hard-coding page flow is not a good idea for many reasons. The most important one is that understanding such a page flow requires a detailed comprehension of a web application's inner workings. Depending on the size of the web application and the complexity of its page flow, acquiring detailed knowledge of the architecture can be difficult and time-consuming. But what if you were able to capture all page flow details in a single location?

The business rules driving the design of applications can run the gamut from very simple to highly complex. But generally there are three types of web applications:

• Web applications that start out with a simple set of goals and remain simple: These applications are made to fulfill a small but meaningful need and never grow beyond that. Simple and to the point, these applications have no need of additional features.

• Web applications that start out with a simple set of goals and grow in complexity over time: These applications aren't originally designed to conquer a massive set of complex goals. They typically have simple beginnings, maybe intended to solve a small part of a much larger, more complex problem. Examples of these applications run far and wide in the corporate world — for example, a small piece of a supply chain application, a minor addition to a customer relationship management (CRM) application, or even a simple integration of two systems. Over time, these applications can take on a life of their own and grow far beyond the original intentions of the designers. These applications typically are developed inside a business or an organization.

• Web applications that start out with a complex set of goals: These applications are usually tackled by an entire team of people and can have a fairly long implementation time. Examples of such applications might include a reservation system, a loan origination system, or even a system to categorize media. These systems are inherently complex in their design because they are designed to model each process in a way that allows humans to easily understand and interact with each one. Of course, the goal of making a process easier to understand is not always achieved, because simplifying a complex process is itself rather difficult.

Consider these three styles of web applications and then think about the page flow for each one. Style one probably has no need to define a formal page flow; styles two and three definitely do. But who's to say which applications need a formal page flow and which do not? There's no single test to determine this, so it's like anything else — a judgement call. The best way to decide is to understand the problems solved by a formal page flow mechanism to see if it will benefit your projects. This is exactly what this chapter helps you do. By the end of it you will understand the following:

• Web flow background

• The reasons for using a formal page flow mechanism, specifically Spring Web Flow

• The concepts that make up a web flow

• The configuration of Spring Web Flow

• Spring Web Flow components, such as views and actions

• How to construct an application using Spring Web Flow

• How to test your SWF application

... less

The Internet felt a little dated and boring until a set of recent events. The unveiling of two experimental projects by... more

The Internet felt a little dated and boring until a set of recent events. The unveiling of two experimental projects by Google—Google Maps and Google Earth—changed all that and the enthusiasm of the web application development communities was reignited. These applications present a new type of user interaction. Instead of user interactions being interleaved with page submissions and a wait for the server to reply, the application responds immediately. The so-called World Wide Wait (a cynical reinterpretation of the acronym WWW) is now over and Web 2.0 (coined for the radically different feel of these highly interactive applications) is here.

The underlying mechanism that enables these highly interactive web applications has actually been in the leading browser for several years; it just has not been exploited in the fashion demonstrated in the new Google applications. Without a fantastic name to describe the groundbreaking technology, practitioners have taken to describing the interaction exactly—Asynchronous JavaScript and XML. Thus was born Ajax.

This chapter provides a detailed description of the mechanism behind Ajax and shows how it works. You also get hands-on experience with wiring library components to implement a highly interactive album search page for the Pix system. The library component used is an open-source library called Direct Web Remoting 2.0, or DWR 2.

By the end of the chapter, you will:

• Appreciate the hype behind Web 2.0

• Understand how Ajax works

• Be familiar with DWR 2.0 and its API component

• Be able to use Spring to wire DWR components for your Ajax projects

• Be able to create highly interactive web-based applications using Spring, Ajax, and DWR

• Understand the difference between applications constructed with Ajax and those constructed with Web MVC and Web Flow

... less

Many enterprise applications throughout the world have a need to communicate reliably. In fact, many of these applications... more

Many enterprise applications throughout the world have a need to communicate reliably. In fact, many of these applications are part of our daily lives, dealing with things like banking, credit cards, financials, telecommunications, and travel reservations. Consider that when you make travel reservations using one of the many travel websites, many applications are behind the scenes to facilitate the creation of those reservations. In applications such as these, a request from one application to another must not fail. Those requests cannot be dropped or lost, even in times of system failure. For application-to-application communication, messaging is the best solution. Enterprise messaging solutions are known as message-oriented middleware (MOMs).

MOMs allow applications to communicate by sending and receiving messages. A message is a unit of business data (a payload) with some routing information that is used to advise other applications of business events. MOMs serve as an intermediary that facilitates the reliable exchange of messages using destinations. By means of the routing information, messages are sent to a destination provided by the MOM, not to any specific application. Applications that are interested in the messages register or subscribe to the destination to receive messages. This paradigm allows the applications sending messages and the applications receiving messages to be completely separate. This is the concept of loose coupling, where two systems don’t depend on any timing or even simultaneous availability. Use of MOMs provides this capability.

MOM vendors each provide an API for sending and receiving messages, but each MOM provides the same base functionality. This was the motivation for the Java Message Service (JMS). JMS provides a vendor-neutral API for enterprise messaging that any MOM vendor can implement. This means that the JMS API can be used to communicate with any many different MOMs instead of a vendor-specific API.

The Pix web application needs to integrate with an online photo-printing service. The photo-printing service application accepts photo-printing requests asynchronously, works on the order, and then ships printed copies to the user. The photo-printing service employs a MOM to facilitate asynchronous communication.

In this chapter, you'll look at how to realize the Pix requirement using the Spring JMS framework, which facilitates asynchronous communication using POJOs. In particular, this chapter covers the following:

• Basic JMS concepts

• Using the Spring JMS framework for JMS

• Configuring message-driven POJOs using Active MQ as the JMS provider.

• Creating JMS clients and testing message-driven POJOs

... less

A web service is software that is identified by a URI and whose interfaces and bindings are specified through XML.... more

A web service is software that is identified by a URI and whose interfaces and bindings are specified through XML. The web service can then be discovered by other distributed software systems and communicated with via XML-based messages. In its simplest form, a web service can be viewed as a client/server architecture that allows varying systems to interact with one another through the use of industry standards protocols. Web services is an interface or wrapper around disparate system implementations.

Because web services can operate over the Internet, they are accessible from anywhere Internet service is available. This enables applications as well as people to consume these web services in order to achieve business goals. Because web services can run over existing transport infrastructures and web standards, you don't need to install any new infrastructure to use them .

This chapter will cover the server aspect of web services. The next chapter will cover the client aspect. Specifically, this chapter covers the following:

• The concepts behind web services

• Why you want to use web services

• An analysis of the PIX services that need to be exposed

• XFire, an open-source web service container.

• Integrating Spring with XFire

• Exposing POJOs as web services

• Intercepting web service messages

• Creating web service clients and invoking web services

In this chapter, you add new Spring configurations and code to the PIX application to expose PIX functionality as web services to external affiliates systems.

... less

Web services technology enables computer systems to communicate over the Internet. Communication is performed over the... more

Web services technology enables computer systems to communicate over the Internet. Communication is performed over the universal standard HyperText Transfer Protocol (HTTP) protocol. Because HTTP is the same protocol that web browsers use to communicate with web servers, Web service consumers (clients) enjoy the same ubiquitous connections to Web service providers anywhere in the world.

The preceding chapter revealed how the Spring framework can be used to rapidly build Web services. These Web services can expose system features for network-wide consumption by Web service consumers. The main focus of this chapter is on the construction of Web service consumers. With Spring and XFire, Java-based Web service consumers can be created easily.

Chapter 9 showed you how to create a Web service consumer (in the form of a unit test) for Web services that you create in Java. This chapter shows you how to create consumers for Web services created by means of .NET-based technology. The very same techniques shown here can also be used to consume Web services that are created using any other programming language and platforms.

Specifically, this chapter shows the creation of a Spring-based Web service client for an e-mail validation Web service. The e-mail validation service itself is implemented by means of C# running on Microsoft’s .NET framework. As part of the PIX application's user-registration process, the e-mail validation Web service is integrated to validate the user’s e-mail.

The topics covered in the chapter include:

• Creating a Web service consumer

• Accessing an e-mail validation Web service over the Internet

• Describing Web services with Web Service Description Language (WSDL)

• Generating Web services stub code from WSDL using XFire

• Configuring a dynamic Web service consumer proxy with XFire and Spring

• Creating a standalone XFire/Spring-based Web service consumer for a .NET-based Web service

• Testing and running the Spring-based Web service consumer

• Integrating the Web service consumer into the PIX web application

In addition to examining the Spring/XFire Java-based Web service consumer, you will also look at how .NET consumer can access the PIX Affiliate Web services. This illustrates interoperability from the other way around — a .NET consumer calling Web services implemented by means of Spring and Java. This chapter shows the construction of a simple .NET Web service client that invokes the PIX Affiliate management Web service.

... less

There is no doubt that the Spring framework offers a lot of very useful and powerful features for Java development.... more

There is no doubt that the Spring framework offers a lot of very useful and powerful features for Java development. These features should be leverages in as noninvasive a way as possible: application code is not required to have any dependency on Spring APIs. All configuration of application and infrastructure components as well as their collaboration is done using one or several Spring bean definition files. Using Spring’s external configuration files enables you to separate configuration concerns from application code.

Spring bean definitions are XML files, based on DTD or XML schemas. You have already learned about the format and syntax of Spring bean definition files in the previous chapters, and you have seen that writing these definition files is very straightforward from the beginning on. It requires only a moderate amount of XML writing and some knowledge of Spring’s infrastructure XML elements and components.

But as your application grows the configuration will get more complex — most of all if you don’t break your bean definitions into different logical files depending on application layering. The bean definition will get hard to read, maintain, and test. More importantly, editing complex Spring configuration files could be an error-prone operation. For example, writing fully qualified Java class names or editing Spring bean references can result in mistakes that are not discovered until the execution of unit or integration tests that actually load a Spring ApplicationContext.

Back in late 2002 the Spring IDE (Integrated Development Environment) was born in order to address these issues. Spring IDE is an official subproject of the core Spring framework and is hosted as an open-source project at http://springide.org. The IDE consists of a set of plug-ins that bring support for Spring development to the Eclipse development platform. Spring IDE is distributed under the terms of the Eclipse Public License v1.0.

This chapter introduces the different features of Spring IDE and shows you how these will facilitate your Spring development.

By the end of this chapter, you will:

• Understand how to install Eclipse with Spring IDE

• Be able to enable the Spring support on Eclipse projects

• Understand Spring IDE’s core concepts, such as bean config and config set, and why these two are important for working with the plug-in

• Be familiar with Spring IDE’s tools for Spring bean definitions

• Be able to leverage Spring IDE to tools to develop powerful applications based on AOP

• Be able to use Spring IDE’s web flow support, such as the graphical editor

... less

Over the last seven years or so, aspect-oriented programming (AOP) has emerged as a superior programming methodology when... more

Over the last seven years or so, aspect-oriented programming (AOP) has emerged as a superior programming methodology when for a system. AOP addresses the pieces of a system that cannot be modularized with object-oriented programming (OOP) alone. As described by Ramnivas Laddad in his excellent book, AspectJ In Action:

In the evolutionary view of programming methodology, procedural programming introduced functional abstraction, OOP introduced object abstraction, and now AOP introduces concern abstraction.

This chapter will help you understand AOP and begin to apply it though the use of the Spring framework. By the end of this chapter, you will:

• Recognize the differences between AOP and OOP

• Comprehend the core concepts and terminology of AOP

• Understand how Spring AOP uses AspectJ

• Know the features of Spring AOP

• Be able to apply Spring AOP

So let’s get started by comparing some concepts within AOP and OOP.

... less

In the previous chapter you learned a great deal about AOP. One of most frequent uses of AOP in application design is... more

In the previous chapter you learned a great deal about AOP. One of most frequent uses of AOP in application design is in the area of transactions. In fact, transactions are a requirement in many business applications. Roughly speaking, transactions are sequences of activities that must be completed together. If any of the activities involved in the transaction fails, all the changes made by the sequence must be undone. Only if all the activities complete successfully will the transaction be considered successful.

In a business context, a common example of a transaction is the sequence of activities involved in an ATM cash withdrawal. Suppose you need to get a hundred dollars for dinner at the neighborhood ATM. You start by putting the ATM card in the machine, then enter your password and confirm it. After the ATM verifies your credentials, you select a withdrawal operation and enter $100 as the withdrawal amount. When you hit OK, the transaction begins. The ATM now needs to issue $100 in cash to you and deduct $100 from your account as a transaction. These two activities must be successfully completed together. If the dispenser jams and fails to provide you with the cash, you want to make sure that $100 are not deducted from your account. In that case, the transaction must be rolled back (undone) and your account balance must revert to the amount it contained before the transaction started.

There are typically two ways to use transactions in any application: programmatically or declaratively. Programmatic transaction requires the hard-coding of transaction logic within the code of the application, using standard transactional APIs. Declarative transaction requires no application code modification, but the transaction behavior is configured externally — often using XML-based configuration files. Spring applications can use either programmatic or declarative transactions. The Spring framework implements a lightweight declarative transaction mechanism using AOP.

In this chapter you learn how to add transactional behaviors to Spring applications. The Pix application is enhanced by the addition of transactional behaviors to the domain POJOs. Through hands-on coding, you become familiar with working with transaction configurations using Spring AOP.

In particular, this chapter covers:

• An overview of transactions

• Programmatic transactions

• Local versus global transactions

• Transactions in Spring

• Managing Spring transactions

• Configuring Spring transaction managers

• Adding transactions to Pix domain layer POJOs

• Unit-testing the transaction-enabled domain layer

• Configuring global transactions

... less

To compile and build the Pix project in this book, you need to use Maven 2, a powerful project building and management... more

To compile and build the Pix project in this book, you need to use Maven 2, a powerful project building and management tool, capable of handling anything from the simplest single-source file project to huge projects over the Internet involving thousands of source files and hundreds of developers all over the world.

If you have worked with Ant, make, or nmake before, you already know the ins and outs of a build tool. Maven 2 has the same general objectives as most:

• To manage source code, configuration, and resource files in the project

• To orchestrate the compilation of source and unit-test code

• To run the actual suite of unit tests and report the results

• To assemble the final application

• To assist or to carry out integration tests (optional)

• To help deploy the final application (optional)

This appendix shows how to use Maven 2 to build the Pix project. The same techniques can apply to any of your Java and/or Spring framework projects.

... less

Current users of Java EE may have specific questions about how the Spring framework is different from the implementations... more

Current users of Java EE may have specific questions about how the Spring framework is different from the implementations that they are already using in their day-to-day business application development. On the surface, there appear to be differences in architecture, design, and philosophy between Java EE and the Spring framework. As a matter of fact, the entire idea behind the Spring framework came from Rod Johnson and Juergen Holler’s desire to prove that there is a better approach to enterprise Java application development.

The initial differences have diminished over time, mainly because the core audience for both technologies is essentially the same. The needs and feature requirements for the enterprise developer are the same and both technology streams must satisfy these requirements. The evolution of Java EE from the venerable workhorse J2EE 1.4 with EJB 2.1 to today’s Java EE 5 with EJB 3.0 has brought the Java EE environment closer to that provided by the Spring framework. On the flip side, the user demand for robust persistence and transaction support has driven the Spring framework to support and embrace key Java EE 5 technologies such as the Java Persistence API.

As both frameworks evolve together into the future, they will likely continue to complement one another, rather than compete. System architects and web applications developers will continue to be the best judges of the most appropriate combination of technology for their individual applications.

This appendix outlines the visible differences between the Spring framework and the Java Enterprise Editions, both Java 2 Enterprise Edition 1.4 (with EJB 2.1), and Java Enterprise Edition 5 (with EJB 3). The aim is to provide you with an understanding of how these frameworks differ from one another so you can make informed design and deployment decisions. The material covered in this book serves as a prerequisite for people already involved with the operation of Java EE, but not with the Spring framework.

In this appendix, you examine:

• Java EE as a heavyweight container

• Spring as a lightweight framework

• The complexity of Java EE programming

• The simplicity of POJO-centric Spring programming

• Java EE and Spring in the open-source world

• A convergence of ideas between EJB 3 and Spring

• How Java EE 5 and EJB 3 are similar to Spring

... less

Perform the following steps to run the Pix system on your machine:

1. Download Spring.

2. Start an instance of... more

Perform the following steps to run the Pix system on your machine:

1. Download Spring.

2. Start an instance of the HSQLDB database server.

3. Download and install Tomcat.

4. Download and compile the source code.

5. Deploy the web application to Tomcat.

6. Start Tomcat and access the application.

... less