Ajax for Java Developers

Course Description

This is a 4-day course that covers the emerging Ajax technology, with a focus on developing Ajax applications using Java on the server side. The course starts with a fairly comprehensive coverage of basic JavaScript. The coverage includes some of the techniques for creating modules and doing Object-Oriented style programming in JavaScript, because Ajax uses JavaScript so heavily, and it`s important that developers have some idea of how to write good JavaScript. This is not a thorough coverage of JavaScript - that is beyond the scope of the course. Students have enough so that they can write Ajax programs using JavaScript, and have some good foundations for doing it well. The course moves on to basic server side techniques for handling Ajax requests. Starting with a simple servlet, and then moving on to a Servlet/JSP combination. Then we go back to the client side to cover some of the major libraries that are in use today. Several libraries are represented, but your favorite may not be there due to time constraints. Detailed coverage of Dojo is not included. The course then moves on to more advanced techniques using JSON, XML, Direct Web Remoting, and JSF to create Ajax based Web applications. This takes the student to the next level in writing Ajax applications. Finally some general design and security issues are covered.
4 days
Contact us for pricing
Contact us for dates
Contact us for dates


Basic knowledge of HTML and JavaScript and practical Java and Servlet/JSP programming experience.

Ajax Overview

What are Rich Internet Applications?
RIA Technologies
Ajax Introduction
What is Ajax?
The Ajax Difference
Ajax, JavaScript, DHTML and More
What This Course Will Focus On

JavaScript Basics

Java Script Introduction
What is JavaScript
Exploring JavaScript
JavaScript Variables
JavaScript – Writing to the Web Page
JavaScript PopUp Boxes
JavaScript Functions
External JavaScript Files
Functions as Data
Standard JavaScript Functions
Accessing and Modifying HTML Elements
A More Complex HTML Page
Accessing Elements via the document Object
The innerHTML Property


XMLHttpRequest Basics
More about XMLHttpRequest
Creating an XMLHttpRequest Object
Submitting a Request
XMLHttpRequest Properties
Asynchronous Requests
Handling an Asynchronous Response
The ReadyState Property
onreadystatechange Event Handler
XMLHttpRequest Methods

Servlets and JSP with Ajax

Overview of Servlets
Java EE and Web Applications
Simple Web-centric Architecture
Java EE Web Applications
Web Application Structure
Using Servlets
A Simple HTTP Servlet
How a Servlet Works
The Web Archive (war) File
Deploying Web Applications
Servlets and Ajax
Accessing the Servlet Using Ajax
A Servlet Handling a Post Request
Overview of JavaServer Pages (JSP)
What is a JSP?
A Very Simple JSP – simple.jsp
JSPs Look like HTML
JSP Expressions
JSPs are Really Servlets
Lifecycle of a JSP
Object Buckets or Scopes
Predefined JSP Variables – Implicit Objects
Working with
How a Servlet Works With a JSP
Issues with JSP
Custom Tags
Custom Tags and Tag Libraries
TAGLIB Directive in JSP
A Servlet and JSP Cooperating
The Tag

More JavaScript and Ajax

Browser Events
Event Based programming
Event Handlers
Defined Browser Events
Defined Events
Form Validation
onload and onunload Events
Using Ajax and Events
Ajax and Events
JavaScript Objects and Arrays
Creating JavaScript Objects
Working with Objects and Functions
Working with Object Properties
Arrays in JavaScript
Working with Arrays
Array Methods
Objects as Arrays
Classes in JavaScript
JavaScript Constructors
The New Operator
More on Constructors
The Object Class
The prototype Property
Properties of the Prototype
A More Complete Class
Modules and Namespaces
Utility Modules

Client Side Frameworks

Framework Overview
No Need to Reinvent the Wheel
Capabilities of Client Side JavaScript Libraries
General Library Capabilities
Some Client Side JavaScript Libraries
Prototype Overview
About Prototype
Utility methods and DOM Extensions
Utility methods of Element Class
The $() Utility Function
Using $ and the DOM Extensions
Prototype Ajax Support
Ajax.Request – Additional Options
Other Prototype Capabilities
Much More Capability
Using script.aculo.us
The Scriptaculous Autocompleter
Other Frameworks and Libraries
Some Well Known Frameworks
Dojo Functionality
dojo.xhr* Functions
Using dojo.xhrGet()
Dojo.xhrGet Error Handling
Some Issues with Dojo
Yahoo User Interface Toolkit (YUI)
The YUI Dom Class
A Simple Application with YUI
YUI and Ajax
TabView and TreeView
Rich Text Editor and Calendar Control
Other YUI Capabilities
The Google Ajax Search API
Google Search API Code
Google Search Page Display
Much More Capability
Google Maps API
Maps API Display
Additional Google Maps API Capability

Cascading Style Sheets

Issues with Formatting in HTML
Cascading Style Sheets (CSS)
Declaring Style Information
Style Sheets
Using Style Sheets
Resulting Display
The Class Selector
Descendant Selectors
ID Selectors
Display and Visibility Style Properties
Other Style Properties
Scripting Styles
Scripting Classes
The ‘Cascading’ in CSS

JSON (JavaScript Object Notation)

What is JSON
Review of JavaScript Literals
Arrays and More Complex Objects
JSON Details
Creating JSON Strings in JavaScript
Parsing JSON Strings in JavaScript
Parsing Strings with JSON.parse()
JSON on the Server
Creating JSON Text on the Server
JSONObject and JSON
Creating JSON Text from POJOs
Creating jSON Text from Collections
Dealing with Dates
Custom Date Serialization
Other JSON-LIB Capabilities
An Input Field Generating Ajax Requests
Producing JSON in a Servlet
JavaScript Code Constructing Suggestions
Accessing the JSON Data We Want
JavaScript Code Constructing the Suggestions
Autocomplete at Work
Other JSON Tools
The JSON Universe


XML Overview
What is XML?
The Underlying Theme of XML
JavaTunes Purchase order Document – Body
The Document Body and Elements
Working with XML
Working with XML and Ajax
Accessing XML with Ajax
Working with XML Documents
JavaTunes Purchase Order Document
JavaTunes Order as a DOM Tree
More about the W3C DOM
Traversing a Document with JavaScript
Getting Node Information
Finding Nodes in a Document
White Space Handling and Other Issues
Creating XML Documents on the Server
Producing XML with a Servlet and JSP
The JSP Generating the XML
An Input Field Generating Ajax Requests
XML Document from Servlet/JSP
JavaScript Code Constructing the Suggestions
Accessing the XML Nodes We Want
Using the Suggestions
Autocomplete at Work
XML and JSON for Data Interchange

DWR (Direct Web Remoting) and Other Technologies

What is DWR?
How DWR Works
Getting Started with DWR
web.xml Configuration for DWR
dwr.xml Configuration File
Running the Test Pages - /dwr
Working with DWR
Including the DWR JavaScript Code
Using the DWR Proxies
Functions with Java Object Arguments
DWR Options
Reverse AJAX
Other Technologies
Using JSON-RPC-Java
Google Web Tooklit (GWT)
GWT Architecture
Hello World with GWT
The Generated Application
More about GWT
Pros/Cons of GWT


JSF Overview
JSF Purpose and Goals
JSF Views – Facelets
Facelets Defined
JavaBean Defined
Managed Beans as JSF Model
JSF Controller Components
Managed Beans – Part of JSF Controller
faces-config.xml Details
Your First JSF Application
Configuring FacesServlet in web.xml
JSF Controller
JSF HelloWorld – Facelet
JSF HelloWorld –Viewing the Facelet
Review of Managed Beans
Managed Beans Lifecycle
Declaring a Managed Bean
Examining the Logon Form
Linking Input Fields to Bean Properties
Submitting the Form
Method Binding Expressions
Dynamic Navigation Rule
Creating / Deploying a JSF Application
F:AJAX Details

Design and Best Practices

JavaScript Best Practices
JavaScript is a Key Ajax Technology
Object-Oriented Modular JavaScript
Dealing with Browsers
Separate Content, Behavior, & Presentation
JavaScript Tips and Techniques
Don’t Reinvent the Wheel
Ajax Design
Ajax is Still Evolving and Maturing
Basic Ajax Design Principles and Patterns
Basic Ajax Design Patterns
Use Ajax Where Appropriate
Network Usage Considerations
Ajax and the Back Button – The Problem
Ajax and the Back Button – Solutions
User Interface Design Considerations
Other Ajax Design Considerations
Ajax Security Ideas
General Security Issues for Ajax
Basic Security Guidelines
Scripting Vulnerabilities – Malicious Code
The Dangers of Code Injection
XSS – Same Origin Policy
Same Origin Policy – The Good and the Bad
Preventing Malicious Content
JSON Issues
Security Summary