Ajax Training for Java Developers (5 days)

Developing Ajax Applications with Java EE Course Overview

This course introduces the Ajax programming model for web applications, and guides Java developers through the sometimes bewildering array of approaches to adding Ajax functionality into their web applications.

We start with a tour of basic browser programming, using JavaScript, the HTML DOM, and CSS. Then, students learn how to establish communication between their on-page JavaScripts and server-side application components, and thus to develop richer, more user-friendly and responsive web applications. We pursue Ajax connectivity entirely from the client side in this first module, at several levels. From an initial study of the bare-bones approach using the XMLHttpRequest browser object, we move on to consider programming techniques for thread safety, and use of higher-level script libraries such as Prototype and Dojo.

Then we analyze the challenges of supporting Ajax from the server side, going beyond simple Ajax request-handling strategies to consider goals such as:

• Adhering to the model/view/controller pattern
• Minimizing duplication of business and presentation logic
• Providing Ajax code transparent access to the application's domain model

Reuse mechanisms such as JSP tag files and JSF facelets are also considered.

We then look at two of the dominant forms of Ajax framework: the RMI approach, and JSF component libraries. For each class of tool we investigate two popular options -- DWR and jabsorb; RichFaces and Trinidad -- and use that comparison to discover the broader architectural patterns of that approach.

Students will complete the course ready to make intelligent choices of Ajax tooling for their applications, and to start working with their chosen framework.

Developing Ajax Applications with Java EE Course Goals

• Use JavaScript in web pages to respond to user events.
• Manipulate an HTML page dynamically using the DOM.
• Make HTTP requests to the server side of an application from JavaScript, without causing the browser to reload the page.
• Use script libraries such as Prototype and Dojo to simplify coding tasks and improve UI functionality.
• Identify architectural and design challenges inherent in the use of Ajax for Java applications.
• Define a request-handling path that best addresses the needs of a given Java web application.
• Manage script content and bind scripts to graphical widgets using JSP.
• Use JSP tag files to consolidate presentation chunks such that they can be shared between pages and Ajax responses.
• Process and generate various Ajax wire formats, including text, HTML fragments, XML, and JSON, both client-side and server-side.
• Understand the impact of Ajax processing on session management and security.
• Use RMI frameworks including DWR and jabsorb to provide direct connectivity to Java domain and/or service classes.
• Use JSF componentn libraries including RichFaces and Trinidad to model Ajax functionality as part of the usual JSF UI model and processing lifecycle.

Developing Ajax Applications with Java EE Course Prerequisites

Experience in the following areas is required:

• Significant Java programming experience is required.
• Basic servlets and JSP programming experience is required.
• JSF experience will be helpful for the final unit, but is not required.

Developing Ajax Applications with Java EE Course Outline

1. Ajax Programming
   1. Overview of Ajax
      1. What is Ajax?
      2. Desktop vs. Browser-Based Applications
      3. Page Request/Response Issues
      4. The XMLHttpRequest Object
      5. Ajax Processing
      6. Client-Side Frameworks
      7. Server-Side Frameworks
      8. Criticism of Ajax
   2. JavaScript
      1. Syntax
      2. Variables
      3. Data Types
      4. Arithmetic and String Operators
      5. Conditionals and Loops
      6. Logical and Comparison Operators
      7. Functions
      8. Variables Scope
      9. Objects and Encapsulation
      10. Constructors
      11. Prototypes
      12. Closures
      13. Arrays
   3. The Document Object Model
      1. The Document Object Model
      2. The DOM Node Tree
      3. The Document and Window Objects
      4. Elements
      5. Attributes
      6. Text Nodes
      7. Walking the Tree
      8. DOM Events
      9. Modifying the DOM
      10. Using innerHTML
   4. Cascading Style Sheets
      1. Styling an Element
      2. Cascading Styles
      3. Elements, Classes, and IDs
      4. The Box Model
      5. CSS2 Positioning
      6. Controlling Visibility
   5. Making Remote Requests
      1. iFrames vs. XMLHttpRequest
      2. Getting an XHR Instance
      3. XHR Methods and Properties
      4. Synchronous vs. Asynchronous
      5. Data Formats
      6. Extensible Markup Language (XML)
      7. Receiving XML
      8. Building and Sending XML
      9. JavaScript Object Notation (JSON)
   6. Prototype & Co.
      1. Client-Side Frameworks
      2. Script Libraries
      3. Ajax Issues
      4. Prototype
      5. A Review of prototype.js
      6. Ajax.Request
      7. The Options Object
      8. The $ Function
      9. Other Convenience Functions
      10. String Functions
      11. Algorithmic Programming
   7. Dojo
      1. The Dojo Toolkit
      2. Architecture
      3. Dojo Namespaces
      4. Simplified DOM Manipulation
      5. dojo.xhrGet and dojo.xhrPost
      6. Response Content Types
      7. The Dojo Event System
      8. Event Registration
      9. Disconnecting Event Handlers
      10. Chaining Event Handlers
      11. The Dojo Widget System
      12. Built-In Widgets
      13. Custom Widgets
      14. Drag-and-Drop Support
2. Ajax in Java Applications
   1. Ajax Strategies
      1. The Simplest Solution
      2. Issues with Ajax Processing
      3. Model/View/Controller for Ajax
      4. Rendering Ajax Responses
      5. RMI Frameworks
      6. Ajax/JSF Frameworks
   2. Ajax Custom Tags
      1. JSP Custom Tags
      2. Tag Files
      3. Encapsulating UI Fragments
      4. Encapsulating Scripts
      5. Delivering Scripts Once
      6. Generating Unique Scripts
      7. Binding Scripts to Widgets
      8. Rendering Ajax Responses with JSP
   3. Handling Requests
      1. Ajax-Only Servlets
      2. Multi-Purpose Servlets
      3. Front Controllers
      4. Parsing Ajax Wire Formats
      5. Producing Ajax Wire Formats
      6. Session Management and Security
      7. Finding Domain Objects
      8. Impacts of Ajax on Page Processing
   4. RMI Frameworks
      1. Java Objects in JavaScript
      2. RMI for Ajax
      3. Direct Web Remoting
      4. jabsorb
      5. Serialization Issues
      6. Serialization vs. Remote Invocation
      7. Creating Objects on the Client Side
      8. Ajax RMI vs. Web Services
      9. Security Issues
   5. Introduction to JavaServer Faces
      1. MVC and Ajax
      2. JavaServer Faces
      3. UI Components
      4. The JSF Lifecycle
      5. What JSF Does for Ajax
   6. Facelets
      1. Issues with JSP and JSF
      2. JSP Custom Tags and JSF
      3. Facelets
   7. JSF Component Libraries
      1. Ajax Component Libraries
      2. RichFaces
      3. The Ajax4jsf Model
      4. Trinidad
      5. Partial Page Rendering
      6. Customizing Client-Side Logic
      7. Ajax-Aware Widgets
      8. Polling and Pushing
      9. JSF and User Events
   8. The State of the Art
      1. Comparison of Ajax Strategies
      2. Metrics: Code Efficiency
      3. Metrics: Runtime Efficiency
      4. Intangibles: Completeness and Correctness
      5. Intangibles: Ease of Development
      6. Whither Hence?

Developing Ajax Applications with Java EE Course Materials

In addition to a comprehensive set of materials, including course notes and all the programming examples, each student will also receive a one-year subscription to Webucator's online reference library, which contains hundreds of the most current electronic technology books - a $149.95 per student value.

Developing Ajax Applications with Java EE Course Technical Requirements and Setup Instructions

Click here for technical requirements and setup instructions