Rich Web Syllabus - Developing Rich Web Applications with Spring -3 Days

Developing Rich Web Applications with Spring

This three-day course is a comprehensive overview of the techniques and tools you need to build and test modern Web applications. You will learn how the versatility of Spring MVC, as well as the elegance of its annotation-based configuration, make it an excellent server-side framework choice for tasks as diverse as serving AJAX toolkits and even building lightweight, Web service interactions. On the client side, Spring JavaScript adds a lightweight abstraction over popular AJAX toolkits and provides a clean programming model. On the server side, Spring Faces provides a similar stream-lined programming model with server-side Java Server Face (JSF)-based components.

You will learn how Spring Web Flow (SWF) can put the fun back into Web development and allow you to manage the state and navigational needs of your application. SWF provides such modern features as partial page rendering and AJAX pop-ups. SWF also makes it possible to tap into the best part of JSF – its component model – within a Spring MVC application. This makes JSF much more accessible and easier for developers with a Spring MVC, Struts or other request-driven framework background.

Completion of this course entitles you to waive the registration fee for the Rich Web Spring Application Developer Certification Examination.

Outline

A day-by-day outline of this web-focused Spring Web training course follows:

  • Day 1 - Java and Spring in the Web Layer
    • Overview of standard Java Web technologies and popular frameworks.
    • Best practices and recommended design for Web application development.
    • A tour of Spring in the Web layer - Spring MVC, Spring Web Flow, Spring Faces, Spring JavaScript.
    • How Spring fits into the Web layer and a Spring MVC overview.
    • Effective Web application testing - strategies, techniques, and tools.
  • Day 2 - Spring MVC for Scalable, Stateless Web Applications
    • Annotation-driven Web configuration, request processing and lifecycle.
    • Secure Web requests with Spring Security.
    • Building form pages, processing user input, data binding and validation.
    • Changing the language and the theme (look-and-feel) of a Web site.
    • Creating layouts with global navigation using Tiles 2.0
    • Adding the ability to produce Excel, PDF, XML and other output formats with Spring MVC.
    • AJAX toolkits and Spring MVC as server-side framework.
    • Using AJAX widget controls to improve the user experience.
    • Learning how to use Spring JavaScript as an abstraction over popular AJAX toolkits.
  • Day 3 - Spring MVC, Spring Web Flow, and JSF for Advanced Stateful Web Applications
    • Introduction to Web conversations, Spring Web Flow, and the continuations approach.
    • Turning multi-page form processing scenarios into flow definitions.
    • Overview of traditional JSF architecture, strengths and limitations.
    • Introduction of Spring Faces and the Spring Web facilities for using JSF in Spring MVC applications.
    • Creating flows with Web Flow managed JSF components and Spring Faces components.
    • AJAX features in Spring Web Flow for use with Spring MVC or with JSF views.
    • AJAX rich form processing, AJAX pop-ups, gracefully degradable JavaScript interfaces.

 

Day by day account

A detailed, day in the life account of each day follows:

Day 1 – General Web Development

Day 1 begins with brief review of Java technologies on the Web. You will review the basics of HTTP Servlets. This will cover project structure, the use and contents of the web.xml deployment description, the servlet API, servlet filters and the use of the servlet dispatcher and redirection. After a review of basic servlet technology, JSP basics will be covered. This includes understanding how to bind variables, use Expression Language (EL), creating custom tags and an overview of the JSTL. The review will end with a basic tutorial on using the eclipse IDE to create and deploy web applications. This tutorial includes the Web Tools Platform (WTP), dynamic projects and deploying to, and managing, the Tomcat web container.

Once the basics of Java Web technologies have been reviewed, you will learn foundational best practices and design patterns for rich web applications. Beginning with identifying an effective web architecture that may be a significant front end to a layered enterprise application, you will be introduced to the front controller, application controller, template view and the MVC designs patterns. The ideas of web layer objects versus exposing domain objects will be discussed. The pros and cons of a stateful versus stateless web layer will also be discussed. The web design discussion will conclude with best practices for integrating security into the web layer.

After best practices and design patterns for rich web applications have been covered, you will learn about reusing the controller design to serve lightweight Web Services that utilize XML, JSON and REST. Moving from web services back to generic Web development, you will learn how to efficiently create a Web project structure in eclipse using the SpringSource Tool Suite. This web design and Best Practices section will conclude with a brief discussion of the merits of “Convention over configuration” followed by a best practices conversation concerning the unobtrusive use of JavaScript and “designer-friendly” HTML.

Day 1 will conclude by addressing testing web applications. You will learn various strategies for testing the web layer. You will be exposed to tools that are useful for debugging such as the eclipse HTTP monitor, Firebug, and the Firefox Developer. Performance testing with JMeter will be introduced. The day will conclude with the coverage of system testing with Selenium.

Day 1 introduces a realistic business case to fuel the hands-on application development throughout the course. Day 1 itself includes several labs where you will become familiar with the fundamentals that have been introduced throughout the day. The final lab will be a lab demonstrating system testing with the use of Selenium. The same business case will be used for the remaining two days of the course with labs covering the details of MVC and SWF 2.0.

Day 2 - Spring MVC

During Day 2 you will learn everything about Spring MVC with XML and annotation-based configuration. You will learn how to exploit MVC’s versatility in serving client-side AJAX toolkits. You will begin the day by learning how process requests with Spring MVC. This will include mapping requests to controllers, applying interceptors to pertinent entry points within the Spring MVC system, learning how to map exceptions effortlessly to error pages and additional behaviors and retrieving input parameters with the new annotation @RequestParameter.

Once you are comfortable with foundational request handling, you will finish this section by learning how to secure requests and seeing the ease with which file upload requests can be handled by MVC. The first lab of the day will enforce the lecture by having you configure global (XML) and method-level annotation request mappings, add handler interceptors, uploading files with a custom exception resolver, and configuring Spring Security 2.0.

After the lab, the next lectures will provide you information about handling form pages with Spring MVC. You will learn how Spring MVC can assist with data binding and with building model data for render via the new annotations @InitBinding and @ModelAttribute respectively. As with any well-thought form handling framework, the rich form handling capability of Spring MVC also provides a set of powerful bean-aware form tags and validation capabilities. After lecture, it’s back into another lab where you will build a sophisticated form page highlighting the data binding and validation features of Spring MVC.

The next lecture begins with building views with Spring MVC. You will learn about selecting views and using various view technologies such as Excel, PDF and Jasper. You will be introduced to popular layout technologies such as Mesh and Tiles. The lecture will conclude with a discussion about locale and theme resolution. As Mesh and Tiles facilitate a well organized structure to a sophisticated web presentation, your next lab will let you explore using tiles layouts, theme and locale switching as well as returning data in an Excel spread sheet.

Day 2 concludes with an introduction to Dojo, the JavaScript tool kit, extJs, jQuery, Direct Web Remoting (DWR) and other technologies that take your web form to a “rich” web form. You will learn how to use Spring MVC to serve AJAX request. You will learn about Java Script Object Notation (JSON), HTML snippets and more data binding. At the end of day 2, with a quick introduction to Spring JavaScript, you will understand the features and benefits of all of these capabilities so you can incorporate them into your own rich web applications. The last lab of day 2 has been specifically designed to help you work with many of these technologies. In this lab you will create a Dojo-enhanced search screen, use the Dojo's table widget and Spring MVC that will return JSON-formatted data.

Day 3

Day 3 is dedicated to Spring Web Flow 2.0. As SWF can be used with either Spring MVC or JSF, the day will start with using SWF with MVC. This lecture is also a great, albeit, brief review of the capabilities of MVC binding, validation, and the Spring form tags. You will provided an overview of JSF and you will learn how it can be used with SWF. The student will walk away from this lecture with the understanding that with SWF, the view technology chosen is decoupled, but yet fully supported, by SWF.

The day’s first lecture will begin with an overview of the conversational model. You will be introduced to various vocabulary and concepts such as “continuations.” You will easily see the advantage of using SWF with this model over the use of other technologies such as struts and, in some cases, MVC. You will be guided through various web architecture scenarios such as Spring MVC/Tiles and JSF/facelets for comparison to the built-in capabilities of SWF.

The second lecture is a “quick start” for SWF. You will learn, step-by-step, how to configure SWF, create flow definitions and how to map flow URLs. As a side effect, you will also learn the SWF package structure and conventions. Once you understand the fundamentals, you will understand how to set up a flow-scoped persistence context and how to secure a flow. You will learn about Flow input and using flow variables. After you are introduced to an action, you will understand how to evaluate actions and set actions. Once the “internal” aspects of the flow are understood, you will be provided with the information necessary to create View states, render actions and you will see how SWF utilizes MVC’s model binding. With model data comes the notion of validating the data and internationalizing messages. These are both valuable capabilities in an enterprise-level web application.

The last part of the quick start introduces the transition object between one or more nodes in a flow. To tie the pieces together and to test the assembled flow, you will learn how to test flows using standard testing techniques. This information will be re-enforced with a lab that will ask you to create a “Search/Results page utilizing data binding, validation and transitions.

Day 3 continues with showing how SWF works with JSF. So the first thing you will learn are the basics of JSF’s UI component architecture. While JSF is a robust framework, there are shortcomings for which SWF can compensate. You will learn about Spring Faces and the JSF facilities it provides while learning the standard JSF components such as tables, commands, messages, etc. You will learn about Facelets and how to configure SWF to render JSF views. Prior to the lab, you will be introduced to SWF’s expression language support for such languages as Unified EL and OGNL. The last topic to which you will be introduced before going into another lab is that of “execution scopes.”

The next lecture will introduce you to Spring Java Script and the resources servlet. You will learn about Spring Faces components. You will understand how to handle AJAX events and rendering JSF and Spring MVC fragments. The lecture will continue with presenting Rich web forms and it will instruct you how to prevent invalid form submission. Prior to the lab, you will learn about AJAX pop-ups with JSF and Spring MVC.

After the lab (in which you will learn how to enhance SWF with Spring Faces components, use client-side validation and understand how to render fragments and use AJAX popups), you will begin with a lecture that covers building modular flows.

Building modular flows will be the last topic and lab for the day. You will learn about abstract flows, flow-level and state-level inheritance. Your knowledge of SWF will be completed with the introduction of flow register hierarchies, flow locations, identifiers and meta-attributes.

You will learn when it is “best practice” to define a subflow. You will learn about flow input/output and using mock to test flow definitions. As the day comes to a close you will learn about flow redirects, flow exception handling, flow handlers and controllers and to summarize all the you have learned, the lecture will end with flow design best practices.

General Information

Approach

Through our trainings, you will benefit from the wide experience and architectural expertise of our team. We bring that experience to you in a highly interactive, intensely hands-on setting.

The “Developing Rich Web Applications with Spring” course not only focuses on explaining Spring features and how to use them, but also on fundamental architectural issues. It's important to know how to use certain parts of a framework, but it's even more important to be able to decide when to use them.

Assumptions

We assume participants have a good understanding of the core Java APIs as well as basic development proficiency with the Spring Framework POJO-development model, the Spring dependency injection container and the application context object. As this course is web-focused, we assume basic knowledge of a JEE Web container and the HttpServlet API. After you register, a SpringSource staff member will be happy to recommend any necessary reading to ensure that you get maximum value from this training.

Lab Work

Since this class focuses on Spring Web technologies as well as the theory of developing effective web-based applications using these technologies, the course is 50% theory-oriented and 50% lab-work.

Since lab work is a major part of the course, you use a computer when taking this course. For scheduled public training events, we generally (unless otherwise indicated) provide a fully configured lab PC for your use. You may bring your laptop, but it is not necessary. For on-site trainings, SpringSource also offers the possibility of arranging a development machine for you. More information about the availability of computers is available when registering for this course.

Learning Resources

During the training the instructor may recommend additional resources. In addition, the supporting training material you receive in class, and code you develop as part of the course, is yours to take back for your self-study and review.

Contact Us

If you would like more information on this training, please contact us.