SCWCD Training Courses

For Sun Certified Web Component Developer Exam

“Wonderful. In 20 years,
this is the best organized,
most pragmatic and
enjoyable course I've taken.”

“The best instructor-led
course I have attended, by far.”

“Compared to the other
short courses I have taken,
this one completely
redefined my scale from 1-10.”

“Best short course ever!”

more student reviews

Here are the topics covered in the SCWCD course taught by Marty Hall. If you have a group of at least eight interested developers (10 for courses outside the US or Canada), contact Marty to arrange a course at your location.

This course can mostly be viewed as a combination of the intermediate and advanced servlet and JSP training courses. However, this course:

Adds two topics ("classic" old-style custom tags and six specific design patterns) that are not normally covered in either the intermediate or advanced courses, but that are required for the SCWCD exam.
In the interest of time, drops or speeds over a few of the best-practices topics that are not specifically part of the SCWCD exam. Omits all extra topics (JDBC, Ajax, Java 5 or Java 6 topics, Struts, JSF, etc.) that are not part of the exam objectives.
Ties each topic to specific objectives on the SCWCD exam.
Adds non-programming exercises relevant to the SCWCD exam.

If your only goal is attaining real-world developer skills, the intermediate or advanced courses (or a customized combination of topics!) are better options because there is more flexibility in the topics and the pace of coverage. Also, in the regular servlet and JSP courses, the exercises focus only on real-world skills, whereas some of the SCWCD exercises are about memorizing terminology, packages, and class names (because that is what the SCWCD exam asks). However, if you also want certification for your developers, this is the course for you.

Syllabus

Overview and Setup

Understanding the role of servlets
Evaluating servlets vs. other technologies
Understanding the role of JSP
Configuring the server
Configuring your development environment
Testing the server setup

Servlet Basics

The basic structure of servlets
A simple servlet that generates plain text
A servlet that generates HTML
Servlets and packages
Some utilities that help build HTML
The servlet life cycle
Servlet debugging strategies

Handling the Client Request: Form Data

The role of form data
Creating and submitting HTML forms
Reading individual request parameters
Reading the entire set of request parameters
Handling missing and malformed data
Dealing with incomplete form submissions
Filtering special characters out of the request parameters

Handling the Client Request: HTTP Request Headers

Reading HTTP request headers
Building a table of all the request headers
Understanding the various request headers
Reducing download times by compressing pages
Differentiating among types of browsers

Generating the Server Response: HTTP Status Codes

Format of the HTTP response
How to set status codes
What the status codes are good for
Shortcut methods for redirection and error pages
A servlet that redirects users to browser-specific pages
A front end to various search engines

Generating the Server Response: HTTP Response Headers

Format of the HTTP response
Setting response headers
Understanding what response headers are good for
Building Excel spread sheets
Generating JPEG images dynamically
Sending incremental updates to the browser

Handling Cookies

Understanding the benefits and drawbacks of cookies
Sending outgoing cookies
Receiving incoming cookies
Tracking repeat visitors
Specifying cookie attributes
Differentiating between session cookies and persistent cookies
Simplifying cookie usage with utility classes
Modifying cookie values
Remembering user preferences

Session Tracking

Implementing session tracking from scratch
Using basic session tracking
Understanding the session-tracking API
Differentiating between server and browser sessions
Encoding URLs
Storing immutable objects vs. storing mutable objects
Tracking user access counts
Accumulating user purchases
Implementing a shopping cart
Building an online store

JSP Intro and Overview

Understanding the need for JSP
Evaluating the benefits of JSP
Comparing JSP to other technologies
Avoiding JSP misconceptions
Understanding the JSP lifecycle
Installing JSP pages
Looking at JSP in the real world

Invoking Java Code with JSP Scripting Elements

Static vs. dynamic text
Dynamic code and good JSP design
JSP expressions
Servlets vs. JSP pages for similar tasks
JSP scriptlets
JSP declarations
Predefined variables
Comparison of expressions, scriptlets, and declarations

Controlling the Structure of Generated Servlets: The JSP page Directive

Understanding the purpose of the page directive
Designating which classes are imported
Specifying the MIME type of the page
Generating Excel spreadsheets
Participating in sessions
Setting the size and behavior of the output buffer
Designating pages to handle JSP errors
Controlling threading behavior

Including Files and Applets in JSP Pages

Using jsp:include to include pages at request time
Using <%@ include ... %> (the include directive) to include files at page translation time
Understanding why jsp:include is usually better than the include directive
Using jsp:plugin to include applets for the Java Plug-in

Using JavaBeans Components in JSP Documents

Understanding the benefits of beans
Creating beans
Installing bean classes on your server
Accessing bean properties
Explicitly setting bean properties
Automatically setting bean properties from request parameters
Sharing beans among multiple servlets and JSP pages

Integrating Servlets and JSP: The Model View Controller (MVC) Architecture

Understanding the benefits of MVC
Using RequestDispatcher to implement MVC
Forwarding requests from servlets to JSP pages
Handling relative URLs
Choosing among different display options
Comparing data-sharing strategies

Simplifying Access to Java Code: The JSP 2.0 Expression Language

Motivating use of the expression language
Understanding the basic syntax
Understanding the relationship of the expression language to the MVC architecture
Referencing scoped variables
Accessing bean properties, array elements, List elements, and Map entries
Using expression language operators
Evaluating expressions conditionally

Using and Deploying Web Applications

Purpose of Web applications
Structure of Web applications
Setting up Web applications with Tomcat
Giving custom addresses to servlets
Sharing data among Web applications

Controlling Web Application Behavior with web.xml

Location and purpose of web.xml
Custom URLs
Initialization parameters
Preloading pages
Welcome pages
Error pages

Servlet and JSP Filters

Filter basics
Accessing the servlet context
Using initialization parameters
Blocking responses
Modifying responses

Web Application Lifecyle Listeners

Reason for listeners
Monitoring creation and destruction of the servlet context
Detecting changes in servlet context attributes
Recognizing session creation and destruction
Watching for changes in session attributes
Combining activities

Creating Custom JSP Tag Libraries: The Basics

Java-based tags
- Components of a tag library
- Basic tags
- Tags that use body content
- Tags that optionally use body content
JSP-based tags (tag files)
- Components of a tag library
- Basic tags
- Tags that use attributes
- Tags that use body content