Learn your way! Get started

Java EE, Part 2: Servlets, JSP, Security, and JS Faces

with expert Susan Bryant


Course at a glance

Included in these subscriptions:

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

Release date Release date 10/27/2010
Level Level Intermediate
Runtime Runtime 10h 24m
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


Enterprise Solutions
Enterprise Solutions

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



Course description

This course increases the skills of the Java EE developers learning about Servlets and JavaServer Pages (JSP). You will learn about servlet filters, event listeners, custom tags, and JSP tags. You will also take a look at more advanced Java EE programming concepts like security, annotations, and JavaServer Faces.

Prerequisites

This course is intended for Java programmers who build server-side web applications in leveraging Eclipse to streamline their development cycle. You should understand essential concepts of object-oriented programming and should be able to write simple Java programs with assistance.

Learning Paths

This course will help you prepare for the following certifications and exams:
Java EE 5 Web Component Developer
Java EE 6 Enterprise Architect
1Z0-866: Java Enterprise Architect Certified Master Essay Exam
1Z0-858: Java EE 5 Web Component Developer Certified Professional Exam

This course is part of the following LearnNowOnline SuccessPaths™:
Java Development

Meet the expert

Susan Bryant Susan Bryant is an experienced IT trainer and consultant with a broad array of skills. She has over 15 years experience in information systems with roles including systems consulting, project management, staff management, staff mentoring, and certified technical trainer. Susan has a strong technical knowledge of IBM WebSphere Application Server, WebSphere Portal Server, WebSphere Process Server, Lotus Domino, and web application development technologies including, Struts, JSF, EJBs and AJAX.


Course outline



Module 1

JSP Expression Language (24:25)
  • Introduction (02:27)
  • JSP Expression Language (EL) (00:54)
  • Basic Usage (02:27)
  • Unified Expression Language (01:30)
  • Built-in Objects (00:59)
  • Working with Arrays and Maps (01:41)
  • Operators (01:09)
  • Full Example (01:16)
  • Demo: Expression Language (11:28)
  • Summary (00:29)
JSP and JSTL (49:25)
  • Introduction (00:46)
  • JSP Standard Tag Library (03:28)
  • Run Time Version (01:05)
  • Basic Tags (02:14)
  • Condition Tags (03:29)
  • Iterator Tags (02:52)
  • Internationalization (01:58)
  • Setting Preferred Locale (04:00)
  • Specifying Resource Bundle (01:45)
  • Display Translated Text (02:05)
  • Display Number (01:04)
  • Display Date (01:05)
  • Demo: JSP and JSTL (23:01)
  • Summary (00:28)
Advanced Tag Libraries (28:23)
  • Introduction (00:38)
  • JDBC Tags (01:08)
  • Specify Data Source (01:15)
  • Performing a Query (01:45)
  • Display Result (01:44)
  • Pagination Example (02:41)
  • Function Tags (01:52)
  • fn Functions (01:07)
  • Demo: Tag Libraries (15:17)
  • Summary (00:51)

Module 2

Servlet Filter API (23:10)
  • Introduction (01:24)
  • What is a filter? (02:41)
  • Uses for Filtering (00:59)
  • Features of filters (00:51)
  • The Filter Interface (01:20)
  • How A Filter Works (01:20)
  • In What Order? (00:55)
  • A Simple Logging Filter (02:09)
  • Configuring The Filter (01:21)
  • Demo: Creating a Filter (09:37)
  • Summary (00:27)
Filter Mapping (19:18)
  • Introduction (00:43)
  • Mapping the Filter (01:01)
  • The Web Deployment Descriptor (00:42)
  • Common filter tasks (00:57)
  • Request and Response Wrappers (01:15)
  • Demo:Filter Mapping (13:46)
  • Summary (00:51)

Module 3

Servlet Listeners (34:17)
  • Introduction (01:13)
  • What are Listeners (01:52)
  • Types of Listeners (01:20)
  • Servlet Context Listener (01:03)
  • Servlet Context Attribute List (01:19)
  • Session Activation Listener (00:51)
  • Session Attribute Listener (01:00)
  • Registering Listeners (00:45)
  • Lifecycle of Listeners (00:39)
  • Demo: Creating a Listener (23:22)
  • Summary (00:48)

Module 4

JSP Custom Tag Basics (46:30)
  • Introduction (01:14)
  • What is a Custom Tag? (01:13)
  • Why Develop Custom Tags? (01:45)
  • The Nature of a Custom Tag (04:34)
  • Tag Body (03:40)
  • Fragment Attribute (01:27)
  • Dynamic Attributes (00:38)
  • Tag Library Descriptor (TLD) (04:03)
  • Tag Implementation Options (03:16)
  • The Simple Tag API (02:34)
  • Example Tag Class (01:49)
  • Life Cycle of a Simple Tag (01:54)
  • Demo: Custom Tag (17:47)
  • Summary (00:28)
Advanced Tags (21:31)
  • Introduction (01:15)
  • The JspContext Object (02:22)
  • Dealing with the Body (02:02)
  • Implementing an Iteration Tag (01:41)
  • Accessing a Parent Tag (02:32)
  • Demo: Iteration Tag (10:13)
  • Summary (01:24)
Tags and Fragments (26:19)
  • Introduction (01:07)
  • Working With Fragment Attributes (03:06)
  • TLD File (01:03)
  • Defining a Tag (02:33)
  • Packaging a Tag Library (02:14)
  • Using a Tag Library (01:42)
  • Demo: JSP Fragments (13:50)
  • Summary (00:40)
Tags and Fragments 2 (25:06)
  • Introduction (01:00)
  • The Tag File Approach (01:39)
  • Example Tag File (01:16)
  • The Tag Directive (01:15)
  • Defining Attributes (00:34)
  • Working With Variables (02:30)
  • Packaging Tag Files (01:06)
  • Creating TLD File (00:44)
  • Using a Tag File From a JSP (01:23)
  • Demo: Tag Files (13:13)
  • Summary (00:20)

Module 5

JavaEE Security (56:36)
  • Introduction (01:06)
  • JEE Authentication Mechanisms (01:46)
  • Basic Authentication (01:01)
  • Form-based Authentication (03:28)
  • Client Certificate (02:44)
  • JEE Authorization (01:32)
  • Declarative Security (04:30)
  • Programmatic Security (02:13)
  • Security Role Reference (01:34)
  • Defining Security Roles (03:50)
  • Delegation (07:07)
  • Demo: JavaEE Security (24:38)
  • Summary (01:01)

Module 6

JavaEE Annotations (28:15)
  • Introduction (01:15)
  • What are Annotations (01:33)
  • Example Annotation (01:46)
  • Java Metadata Specification (01:39)
  • Where can Annotations be Used (02:18)
  • Resource Annotations (00:31)
  • @Resource, @Resources (01:19)
  • @EJB (02:04)
  • @Persistence Annotations (00:44)
  • @PostConstruct, @PreDestroy (00:45)
  • @WebServiceRef (00:30)
  • Demo: Annotations (13:02)
  • Summary (00:43)

Module 7

JSF Intro (33:55)
  • Introduction (00:39)
  • What is JavaServer Faces (01:59)
  • Why Use JSF (03:35)
  • Nature of a JSF Application (01:55)
  • Sun Reference Implementation (02:05)
  • JSF and MVC (02:22)
  • JSF and MVC (00:38)
  • Faces Servlet (02:26)
  • Managed Bean (02:17)
  • The View (01:33)
  • Demo: JSF (13:56)
  • Summary (00:26)
JSF Simple App (35:25)
  • Introduction (00:49)
  • A Simple JSF Application (01:56)
  • The Input Form (03:51)
  • The Result (00:38)
  • The Controller (01:03)
  • Page Flow or Navigation Rule (01:40)
  • Demo: JSF App (18:45)
  • How Does the Application Work (03:19)
  • The Rendered Form HTML (01:47)
  • The Layout Tree (00:39)
  • Summary (00:53)

Module 8

Intro Managed Bean (43:07)
  • Introduction (00:34)
  • What is a Managed Bean (03:36)
  • Why Do You Need Managed Beans (02:23)
  • Managed Bean as a Controller (02:10)
  • Registering a Managed Bean (03:26)
  • Lifecycle of a Managed Bean (01:16)
  • Initializing a Managed Bean (01:23)
  • What Scope to Use (01:10)
  • Value Binding (03:25)
  • Property Data Conversion (01:53)
  • Advanced Property Types (02:33)
  • Component Binding (01:45)
  • Other Binding Types (01:20)
  • Demo: Managed Bean (15:34)
  • Summary (00:32)
Input and Expression (40:02)
  • Introduction (00:52)
  • Basic Input Processing (01:24)
  • Advanced Input Processing (02:41)
  • JSF Expression Language (01:38)
  • Language Basics (01:33)
  • Use of Expression in JSF (00:49)
  • Basic Expression (00:54)
  • Property Access Expression (01:02)
  • Map Access Expression (00:52)
  • Complex Access Expression (01:19)
  • Predefined Objects (01:26)
  • Operators (02:30)
  • Demo: Input and Expression (22:01)
  • Summary (00:56)

Module 9

EJB Overview (55:45)
  • Introduction (00:56)
  • Need for EJBs (01:21)
  • Distributed Computing (01:20)
  • Distributed Transaction (01:39)
  • Distributed Security (01:31)
  • What are EJBs (01:27)
  • Main Characteristics of EJBs (01:31)
  • EJB Architecture Components (00:46)
  • EJB Client (01:04)
  • EJB JAR File (02:08)
  • EJB Container (03:17)
  • EJB Server (01:33)
  • Enterprise JavaBeans (01:17)
  • Session Beans (01:41)
  • Entity Beans (01:54)
  • Message-Driven Beans (MDBs) (00:56)
  • EJB Specification (02:33)
  • Demo: EJB (28:05)
  • Summary (00:36)

Module 10

Struts Overview (32:55)
  • Introduction (00:55)
  • What is Struts (03:01)
  • Why Struts (01:52)
  • Struts Components (02:50)
  • The Controller Layer (01:38)
  • Chain of Command (01:09)
  • The Controller Layer: Diagram (00:54)
  • The View Layer (01:29)
  • The Form Bean (02:34)
  • A Simple Action (00:56)
  • Struts Configuration (01:40)
  • Define HelloAction (00:47)
  • Invoke HelloAction (02:20)
  • Demo: Struts (09:45)
  • Summary (00:58)