Learn your way! Get started

J2SE 1.4: Java Web Development

with expert Noah Kriegel


Course at a glance

Included in these subscriptions:

  • Dev & IT Pro Video
  • Dev & IT Pro Power Pack
  • Power Pack Plus

Release date Release date 12/19/2006
Level Level Intermediate
Runtime Runtime 8h 47m
Closed captioning Closed captioning N/A
Transcript Transcript N/A
eBooks / courseware eBooks / courseware Included
Hands-on labs Hands-on labs Included
Sample code Sample code Included
Exams Exams Included
Platform Platform Internet Explorer Only


Enterprise Solutions
Enterprise Solutions

Need reporting, custom learning tracks, or SCORM? Learn More



Course description

This course covers the fundamental technologies and techniques required to create web applications using Java. It shows how to handle common servlet tasks such as setting and reading HTTP headers, threading requirements, techniques for storing state information (i.e. cookies, URL re-writing, hidden fields), the session management APIĀ“s, gathering parameters, handling different content (i.e. HTML, plain text, spreadsheets, images), database access from servlets, and more. In JSP technologies, this class covers the different types of JSP content (scriptlets vs. JSP tags), property management, using Java Beans within JSP, controlling scoping, and design techniques.

Meet the expert

Noah Kriegel Noah Kriegel is a software engineer and instructor with The DSW Group, Ltd. in Atlanta, Ga., specializing in the development of custom Web-based enterprise applications. During his career in the software industry, he has also developed many database and other distributed applications for clients of all sizes and in a variety of industries. Over the years, he has also instructed hundreds of developers with the languages that he has used in creating applications. His primary language proficiencies include Java, C#, C, and Pascal/Delphi.


Course outline



Module 1

Installation (20:20)
  • Introduction (01:08)
  • Overview: Web Basics (01:08)
  • Using Servlets (00:49)
  • Servlet Containers (00:57)
  • Overview: Install / Setup (01:02)
  • Install Java EE (03:04)
  • Install Apache Tomcat (03:07)
  • Initial Setup Tasks (01:51)
  • Create/Deploy a Servlet (06:43)
  • Summary (00:26)
Intro to HTTP Servlets (19:11)
  • Introduction (00:36)
  • HTTP Protocol (01:45)
  • HTTP Methods (00:56)
  • Servlet Architecture (01:19)
  • Program HTTP Servlets (01:12)
  • Passing Data (01:54)
  • Create a HTML Form (03:15)
  • Implement in Tomcat (02:12)
  • Edit the web.xml File (02:13)
  • Test the Servlet (00:56)
  • Use Post Method (02:09)
  • Summary (00:37)
Servlets and Containers (22:05)
  • Introduction (00:32)
  • Servlets in Containers (00:49)
  • Reload Servlets (00:50)
  • Create / Destroy Servlets (01:58)
  • Single-Thread Model (01:05)
  • Last Modified Times (01:08)
  • Servlet Lifecycle (02:46)
  • Browse Using Servlet (00:05)
  • Modify web.xml (02:20)
  • Persist Information (06:43)
  • Modify server.xml Document (01:23)
  • Modify a Servlet (01:46)
  • Summary (00:35)
Servlets / Client Info (36:18)
  • Introduction (00:32)
  • Servlet Information (01:02)
  • Server Information (03:04)
  • Client Information (01:00)
  • Path Information (00:57)
  • Request Information (01:05)
  • Create/Display App Info (03:25)
  • Add Servlet Parameters (01:36)
  • Declare Context Parameter (01:24)
  • Run the Servlet (01:09)
  • Methods to Retrieve Info (04:18)
  • Persistent Cookies (00:52)
  • Cookies and Servlet API (00:32)
  • Send Cookies (02:02)
  • Retrieve Cookies (01:16)
  • Cookie Attributes (03:12)
  • Use Cookies in Servlets (03:37)
  • Test Cookie Servlet (02:10)
  • setMaxAge() Method (02:12)
  • Summary (00:43)

Module 2

Respond to Client Requests (13:02)
  • Introduction (00:35)
  • Respond to Clients (00:39)
  • Normal Responses (01:01)
  • Keep-Alive Connections (01:24)
  • Buffered Response (01:35)
  • Status Codes (01:11)
  • Response Headers (01:38)
  • Set Headers / Redirect (04:19)
  • Summary (00:36)
Session Tracking (18:27)
  • Introduction (00:51)
  • Tracking Users (01:02)
  • Anon. Session Tracking (01:33)
  • HTTPSession Object (03:07)
  • Session Lifecycle Details (01:19)
  • Session Binding (01:02)
  • Work with Session Tracking (05:31)
  • Test Session Tracking App (03:14)
  • Summary (00:42)
Servlet DB Connectivity (41:10)
  • Introduction (00:39)
  • JDBC API (01:27)
  • Using JDBC (00:52)
  • Open Connections to DBs (01:04)
  • Using Statements (01:19)
  • Prepared Statements (00:49)
  • More JDBC Basics (01:31)
  • JDBC in Servlets (02:42)
  • Access Data thru Servlet (05:52)
  • Modify the Servlet (02:24)
  • Optimize DB Connections (03:27)
  • Connection Pooling (02:12)
  • Create Conn. Pooling (04:27)
  • Use Conn. Pooling (04:24)
  • Return Conn. to Pool (00:54)
  • Implement Conn. Pooling (02:39)
  • Deploy the Servlet (03:40)
  • Summary (00:40)

Module 3

Servlet Workshop (40:08)
  • Introduction (00:39)
  • eMotherEarth DB (02:44)
  • Explore Demo Structure (00:38)
  • Welcome.java Servlet (01:21)
  • Create the Webpage (08:11)
  • Compile/Deploy/Test (02:27)
  • Login.java Servlet (07:08)
  • Check DB for User (03:37)
  • Add New User to DB (03:40)
  • HtmlSQLResult.java Servlet (04:16)
  • Compile/Deploy/Test (03:02)
  • Fixup web.xml File (01:51)
  • Summary (00:28)
Servlet Workshop (cont) (49:25)
  • Introduction (00:42)
  • Review Workshop so far (00:18)
  • Modify HtmlSQLResult class (05:32)
  • Create/Fill a Contents Table (11:49)
  • Catch any SQL Exceptions (00:16)
  • Return the StringBuilder (00:24)
  • Compile/Test (02:38)
  • Create ShowCart class (03:23)
  • Get Info about the User (01:56)
  • ShoppingCartItem class (00:24)
  • ShoppingCart class (00:51)
  • Create the Shopping Cart (05:18)
  • Modify ShowCart class (01:34)
  • Build up Item Info (05:44)
  • View the Cart Data (03:24)
  • Compile/Test (02:56)
  • Modify web.xml File (01:42)
  • Summary (00:24)

Module 4

Introduction to JSP (25:16)
  • Introduction (00:58)
  • Overview: JSP (01:55)
  • JSP Fundamentals (01:12)
  • Running JSP (00:53)
  • Simple JSP Page (03:46)
  • Overview: JSP Tags (00:55)
  • Page Directive (03:20)
  • JSP Scripting Elements (01:49)
  • JSP Comments (01:16)
  • Elements / Comments (03:31)
  • Scriptlets (01:13)
  • View in a Browser (01:17)
  • View Java Source File (02:28)
  • Summary (00:36)
JSP Actions and Objects (13:04)
  • Introduction (01:03)
  • Overview: Implicit Objects (03:41)
  • Overview: Actions (01:49)
  • Implicit Objects (00:46)
  • Forward Action (02:04)
  • Include Actions (03:09)
  • Summary (00:27)
JavaBeans (28:04)
  • Introduction (00:48)
  • Understanding JavaBeans (00:55)
  • Constructors / Properties (03:03)
  • Interfaces (00:54)
  • Mix Scriptlets and Bean Tags (01:08)
  • Demo: Simple JavaBean App (01:31)
  • JSP Component Model (00:36)
  • JavaBeans in Detail (01:39)
  • JSP Bean Tags in Detail (01:55)
  • Read Bean Properties (01:02)
  • Set Bean Properties (02:01)
  • Scope of Beans (02:12)
  • Examine a JavaBean App (01:06)
  • JavaBeans in a JSP Page (03:06)
  • View the JavaBean Page (02:16)
  • Setup JavaBean App (00:50)
  • Test the JavaBean App (02:10)
  • Summary (00:44)
Databases and JSP (11:47)
  • Introduction (00:40)
  • JSP and JDBC (01:09)
  • Beans and Data Tables (00:50)
  • Handle Connections (01:01)
  • ResultSets in Memory (01:31)
  • Connect to / Retrieve Data (05:58)
  • Retrieve Data (00:14)
  • Summary (00:21)

Module 5

Error Handling / Debugging (25:09)
  • Introduction (00:56)
  • Syntax Errors (01:27)
  • Handle Errors (01:26)
  • Recover from Errors (01:14)
  • Record Errors (01:06)
  • Inform the Client (03:58)
  • Catch Errors (01:32)
  • Debug Code (02:59)
  • Simple Error Handling (02:05)
  • Generate an Error (00:53)
  • Exception Error (00:44)
  • Custom Error Page (02:23)
  • Handle Errors in JSP (03:42)
  • Summary (00:37)
Architecture of JSP Apps (24:56)
  • Introduction (01:07)
  • Web App Design (01:23)
  • Page-Centric Design (01:48)
  • Servlet-Centric Design (00:51)
  • Request Dispatcher (02:05)
  • Pass Data (00:42)
  • Control Application Flow (01:18)
  • Pass Errors (01:12)
  • Create Dispatch Servlet (01:12)
  • useBean Tag (00:53)
  • Use RequestDispatcher (00:47)
  • Deploy/Test the Servlet (02:45)
  • Modify the Bean Page (02:08)
  • Modify Dispatch Servlet (03:46)
  • Support doGet and doPost (00:55)
  • Test Modified Servlet (01:34)
  • Summary (00:22)
Deploy Web Applications (16:59)
  • Introduction (00:32)
  • Web File Structure (03:24)
  • Web Archive Files (WAR) (00:52)
  • Deployment Descriptor (03:31)
  • Review: web.xml File (02:34)
  • Set Context Parameters (01:38)
  • Deploy a WAR File (03:51)
  • Summary (00:34)
Ant Build Files (21:26)
  • Introduction (00:52)
  • Make Utilities (00:31)
  • Apache Ant (00:30)
  • Use Ant for Web Development (00:42)
  • Install Ant (01:12)
  • Ant Buildfiles (00:46)
  • Build File Targets (01:21)
  • Tasks in Ant (01:07)
  • Properties in Ant (00:56)
  • Demo: Install Ant (01:41)
  • Create a Dev Directory (01:00)
  • Construct a Build File (01:54)
  • Examine the Build File (06:11)
  • Compile/Deploy Using Ant (02:08)
  • Summary (00:28)

Module 6

Custom Tag Libs and JSTL (31:16)
  • Introduction (00:46)
  • Custom Tags (01:29)
  • Custom Tag Libraries (02:26)
  • Create a tld File (00:35)
  • Use Custom Tag Library (03:43)
  • Implement doStartTag() (02:59)
  • Implement Custom Tag (01:52)
  • Deploy Custom Tag (04:27)
  • JSP Standard Tag Libs (02:05)
  • Expression Language (01:53)
  • Install the JSTL (00:50)
  • Install Tag Libraries (02:03)
  • Use Actions in JSTL (00:46)
  • Use JSTL Core Lib Elements (04:47)
  • Summary (00:29)
JSP Workshop (34:10)
  • Introduction (00:49)
  • Workshop Overview (00:28)
  • Workshop Model Classes (08:54)
  • Create a Welcome Servlet (00:05)
  • Request Dispatcher Object (04:58)
  • Create WelcomeView.jsp (00:15)
  • View JSP Error Page (03:02)
  • Create Table Header Row (02:45)
  • Use the Department Bean (04:26)
  • Setup Editing Records (03:13)
  • Compile/Test (04:39)
  • Summary (00:31)
JSP Workshop (cont) (34:51)
  • Introduction (00:40)
  • Progress so Far (00:37)
  • Create EditView.jsp (02:38)
  • Create an Edit Form (07:49)
  • Add Submit/Reset to Form (01:18)
  • Deploy/test EditView (01:22)
  • View/Modify Action.java (00:54)
  • View the Action Model (00:24)
  • Process HTTP Get Request (09:05)
  • Add Code to Allow Edit (01:24)
  • Send to ResultsView page (02:22)
  • View/Modify ResultsView.jsp (01:53)
  • Compile/Test Final App (03:52)
  • Summary (00:25)