JDBC, SERVLET, and JSP includes JSF and design patterns: black book / Santosh Kuumar K.

Introduction
Chapter 1: Getting Started with Web Appiications In Java
Introduction to Web Applications
Benefits of Web Applications
Technologies used in Web Applications
Describing JDBC
Exploring the JDBC Architecture
Describing Java Servlets
Advantages of Java Servlets
Describing JSP
Request Processing of a JSP Page
Describing the JSP Life-cycle
Introduction to Web Architecture Models
Describing the Model-1 Architecture
Limitations of the Model-1 Architecture...
Describing the Model-2 Architecture
Advantages of the Model-2 Architecture..
Introduction to the MVC Architecture
Describing the Model Component
Describing the View Component
Describing the Controller Component
Summary
Exercise
Chapter 2; Getting Started with JDBC ..
Introducing ODBC
Defining ODBC
Listing Features of ODBC
Table of Contents
Describing the ODBC Components
The Application Component
The DriverManager Component
The Driver Component
The Datasource Component
Describing the ODBC Architecture
The Single-tier ODBC Architecture
The Multiple-tier ODBC Architecture
Introducing JDBC
Describing Components of JDBC
Listing Features of JDBC
Listing New Features in JDBC 4.0
Exploring the JDBC Architecture
The Type-1 Driver
Advantages of the Type-1 Driver
Disadvantages of the Type-1 Driver
Situations to Use Ihe Type-1 Driver
The Type-2 Driver (Java to native API)
Advantages of ihe Type-2 Driver
Disadvantages of the Type-2 Driver
Examples of the Type-2 Driver
Situations to Use the Type-2 Driver
The Type-3 Driver Qava to Network Protocol/All Java Driver).
Advantages of the Type-3 Driver
Disadvantages of the Type-3 Driver
Examples of the Type-3 Driver
Situations to Use the T)fpe-3 Driver
The Type-4 Driver 0ava to Database protocol)
Summary
Exercise
Advantages of the Type-4 Driver
Disadvantage of the Type-4 Driver
Examples of the Type-4 Driver
State True or False
Chapter 3: Working with JDBC APIs,
Introducing JDBC API
Explaining the Types of JDBC APIs
The JDBC Core API
The JDBC Extension API
Listing the New APIs Added to JDBC 4.0
Describing the Major Classes and Interfaces
The DriverManager Class
The Driver Interface
The Connection Interface
The Statement Interface
Communicating with Databases by using JDBC APIs
Step 1: ObtJiining a Connection
Obtaining an Connection using Driver object
Step l.i: Registering a Driver object with DriverManager
Step l.ii: Establishing a Connection using DriverManager
Step 2: Creating a JDBC Statement Object
Step 3: Executing SQL Statements
Step 4: Closing the Connection
Creating a Simple Application
Configuring the Application
Creating a Table
Creating a DSN
Understanding Various JDBC Drivers
The OCI8 Driver for Oracle
The IDS Driver
Installing the IDS Server
Configuring IDS Driver
The Thin driver for Oracle
Summary
Exercise
Fill in the blanks with appropriate words or phrases:
Chapter 4: Implementing JDBC Statements and ResultSets
Describing JDBC Statement
Working with the Statement Interface
Exploring the Methods of Statement
The executeUpdate (String sqlStatement) Method
The executeQuery (String query) Method
The execute (String sqlStatement) Method
The getResultSet () Method
The getUpdateCoimt Q Method
Using Statement
Creating a Table
Inserting a Row i
Table of Contents

Working with the PreparedStatement Interface
Comparing Statement and PreparedStatement Objects
Describing the setXXX methods of PreparedStatement
Listing the Advantages and Disadvantages of PreparedStatement.
Using PreparedStatement
Creating a PreparedStatement Object
Setting the Values for Parameters
Executing the PreparedStatement
Using PreparedStatement with Parameters
Exploring the Usage of the PreparedStatement Object
Working with the Callable Statement Interface
Describing Stored Procedures
Listing the Benefits of Working with a Stored Procedure
Using Callable Statement
Creating the Callable Statement object
Setting the Values of the Parameters
Registering the OUT Parameter Type
Executing the Stored Procedure or Function
Retrieving the Parameter Values
Using CallableStatement with Parameters
Executing a Stored Procedure with IN Parameters
Executing a Stored Procedure with OUT Parameters
Calling Functions by Using CallableStatement
Using Cursors in CallableStatement
Comparing Procedure and Function
Working with the ResuItSet Interface
Describing the Methods of ResuItSet
Using ResuItSet
Moving the Cursor Position
Reading the Column Values
Retrieving Ail the Rows from a Table
Retrieving a Particular Column Using ResuItSet
Handling NULL Values
Working with the ResultSetMetaData Interface
Describing ResultSetMetaData
Using ResultSetMetaData
Creating SQLEditor in Java
Creating the Command-Based SQLEditor
Creating the Windows-Based SQLEditor
Using Advanced Concepts of ResultSet
Exploring Characteristics of the ResultSet Object
ResultSet Types
ResultSet Concurrency
ResultSet Holdability
Setting the ResultSet Type and ResultSet Concurrency.
Using ResultSet Objects to Manipulate Data
Using the ResultSet Object to Update Data
Using the ResultSet Object to Delete a Row
Using a ResultSet Object to Insert a Row
Qosing the Connection
Closing the Statement and ResultSet
Working with the DatabaseMetaData Interface
Retrieving Database and Driver Details
Retrieving Table Description
Retrieving Column Details
Retrieving Data from a Microsoft Excel Sheet
Summary
Exercise
Chapter 5: Describing Advanced JDBC Concepts
Exploring the SQL 99 Data Types
The BLOB Data Type
Storing BLOB Values
Reading BLOB Values
The CLOB Data Type
Storing CLOB Values
Reading CLOB Values
The Struct (Object) Data Type
Using User-Defined Object Types in Java to Represent Database Object Types.
Creating a JDBC UDT
Mapping the JDBC UDT
Implementing UDT
Using the java.sql.Struct Interface
The Array Data Type
The Ref Data Type
Working with the ROWID Tjrpe
Working with Batch Updates
Using Batch Updates with the Statement Ol^'ect
The Batch Update Methods
Tabli
Table of Contents
The BatchUpdateException Exception
Using Batch Updates with the PreparedStatement Object
Describing SQL/XML and XML support
Retrieving Auto Generated Keys
Working with RowSets in JDBC
The Connected RowSets
The Disconnected RowSets
Using the RowSet at Design Time
Setting the Properties of the RowSet Instance
Working with RowSet Events
Using RowSets at Run Time
Setting Parameter Values of a RowSet Object
Executing RowSets
Traversing a RowSet
Exploring Connection Pooling
Working with Connection Pool
Working with Transactions
Describing ACID Properties
Atomicity
Consistency
Isolation
Durability
Types of Transactions
Performing Transaction Management
Describing the Wrapper Interface
The isWrapperPorQ Method
The unwrapQ Method
Describing SQLException
Summary —•
Exercise
Chapter 6: Understanding Java Servlet
X
Understanding the Need for Server-Side Extensions
Introducing CCI
Introducing Java Servlet
Advantages of a Servlet
New Features of Servlet 2.5
Exploring the Servlet Container
Describing the Request Processing Mechanism
Describing the Types of Servlet Container Configurations.
The Standalone Container
The In-Process Container
The Out-Process Containers
Introducing the Servlet API
Describing the javax.servlet Package
Describing the javax.servlet.http Package
Implementing a Servlet Object
The javeoc.servlet.Servlet Interface
The javax.servletServletConfig Interface<H2>
Understanding the Servlet LifeCycle
Describing the Stages of the Servlet LifeCycle
Loading a Servlet
Initializing a Servlet
Handling Request
Destroying a Servlet (End of service)
Exploring the Servlet Life Cycle Methods
The init 0 method
The service() Method
The destroy 0 Method
Developing the First Servlet Application
Creating the home.html Page
Creating the LifeCycleServlet
Creating the Deplo)nnent Descriptor
Deploying Web Application
Running the LifeCycle Application
Understanding the Request Processing Workflow
Request Navigation
Request Delegation
Working with the GenericServlet Class
Exploring Methods of the GenericServlet Class
Using the GenericServlet Oass
Summary
Exercise
Creating the Home.html Page
Developing the HelloServletjava Servlet
Deploying and Running the Application
Chapter 7: Understanding Request Processing and HTTP
Implementing the ServletRequest Interface
Managing the Servlet Olqect as a Throwaway Object
Table
XII
Managing the ServletRequest Object Pool
Working with Request Parameters
Creating the Login Form
Creating the LoginServlet Servlet
Creating the Deployment Descriptor File
Running the Application
Working with Initialization Parameters
Exploring the Need for Initialization Parameters
Retrieving Initialization Parameters
Handling Servlet Initialization Parameters
Creating the Home.html File
Creating the InitParamsServlet Servlet
Creating the Deployment Descriptor File
Running the Application
Working with Context Initialization Parameters
Retrieving Context Initialization Parameters
Using Context Initialization Parameters
Creating the Home.html File
Creating the Login.html File
Creating the Register.html File
Creating the RegistrationServlet Servlet
Creating the LoginServlet Servlet
Creating the Deployment Descriptor File
Running the Application
Understanding ServletResponse
Understanding Request Dispatching
Navigation
Delegation
Dispatching the Request
Getting a RequestDispatcher object
The getRequestOispatcherQ Method of ServletContext
The getNamedDispatcherQ Method of ServletContext
The getRequestDispatcherQ Method of ServletRequest
Comparing the getRequestDispatcherQ Methods of ServletContext and ServletRequest.
Comparing the getRequestDispatcherQ & getNamedDispatcherQ Methods
Understanding the includeQ and forwardQ Methods of RequestDispatcher
Describing the includeQ Method
Describing the forwardQ Method
Comparing the includeQ and forwardQ Methods
Considering the Situations to use the includeQ and forwardQ Methods.
Working widi RequestDispatcher
Creating the Home.html File
Grating the TestServletl Servlet
Geating the TestServIet2 Servlet
Creating die Deplo3nnent Descriptor File
Running the Application
Describing Request Attributes
Working with Request Attributes
Creating the Home.html File
Creating the ValidationServlet Servlet
Creating the AddServlet Servlet
Creating the SubServlet Servlet
Creating the ResponseServlet Servlet
Creating the Deployment Descriptor File
Running the Application
Describing HTTP Basic
Describing HTTP Status Codes
IXX - Informational
2XX - Success
3XX - Redirection
4XX - Client Error
5XX - Server Error
Describing the HttpServletRequest & HttpServletResponse Interfaces
Working with HttpServletRequest
Working with HttpServletResponse
Exploring die Methods for Response Headers
Exploring the Methods for Buffering
Comparing RequestDispatcher forward and sendRedirect...
Handling the HttpServletRequest and HttpServletResponse Interfaces
Creating the Home.html File
Creating the HttpServletRequestEx Servlet
Creating the Deployment Descriptor File
Running die Application
Describing Httf^ovlet.
The HttpServlet Lifecycle
Summary
Exercise
Tm
Table of Contents
Chapter 8: Handling Sessions in Servlet
Introducing Session Tracking
Describing URL Rewriting
Using Query String for URL Rewriting
Using Path Info for URL Rewriting
Listing the Disadvantages of URL Rewriting
Considering Situations to use URL Rewriting
Exploring Hidden Form Field
Listing the Advantages and Disadvantages of Hidden Form Field
Considering the Situations to use Hidden Form Fields
Working with URL Rewriting and Hidden Form Field
Creating the SiteHome.html Page
Creating the Login.html Page
Creating the Send.html Page
Creating the DriverConnection.java File
Creating the UserDAO.java File
Creating the LoginServlet.java Servlet
Creating the Mail.java File
Creating the MailsDAO.java File
Creating the InboxServlet.java Servlet
Creating the ViewMailServlet.java Servlet
Creating the SendReplyServlet.java Servlet
Creating the Deployment Descriptor File
Creating the Database Tables
Creating the Directory Structure
Running the Application
Describing Cookies
Listing the Advantages and Disadvantages of Cookies
Considering the Situations to use Cookies
Using Cookies
xlv
Creating the Home.html File
Creating the AddCookieServlet.java File
Creating the GetCookieServlet.java File
Creating the web.xml File
Ruiming the Application
Exploring HttpSession
Creating a Session Object
Locating a Session Object Associated with the Current Request
Difference between the getSessionQ and getSession(Boolean) Methods..
Storing Information in a Session
Attaching the Session Identity to the URLs
Looking up Information in a Session
Discarding Completed or Abandoned Sessions
Listing the Advantages and Disadvantages of HttpSession..
Considering the Situations to use HttpSession
Threading Issues of a Session
Sessions in a Clustered Environment
Working with HttpSession
Creating the Login.htmI File
Creating the DriverConnection.java File
Creating the UserDAO.java File
Creating the Product.java File
Creating the ProductsDAO.java File
Creating the LoginServletjava File
Creating the UserHomeServletjava File
Creating the GetProductsServIetjava File
Creating the AddProductServlet.java File
Creating the GetCartDetailsServIet.java File
Creating the LogoutServletjava File
Creating the web.xml File
Describing Servlet Context Attributes
Context Attributes in a Distributed Container
Differences Between Parameters and Attributes
Describing Scopes of the Web Application Objects
Exploring the Single Thread Model
Explaining the Need of Synchronization in Servlets
Implementing SingleThreadModel
Describing the ServletOutputStream Class
Using ServletOutputStream
Summary
Exercise
Chapter 9: Implementing Filters, Listeners, and Wrappers.
Exploring Filters
Filter Interception Design Pattern
FUter AH
The Filter Interface
The FilterConfig Interface
The FilterChain Interface
Ta
Table of Contents
XVI
Working With Filters
Creating the Home.html Page
Creating the TestServIet.java File
Creating the MyFilterl.java File
Creating the MyFilterZ.java File
Configuring the Filters Application
Running the Application
Changes in Servlet 2.4 in Filter Configurations
Using Filters with the forward() and include() Methods .
Describing Listeners
Need of Event Programming and Importance of Listeners
Types of Listeners
Describing the Listener Interfaces
The ServletContextListener Interface
The ServletContextAttributeListener Interface
The HttpSessionListener Interface
The HttpSessionAttributeListener Interface
The HttpSessionBindingListener Interface
The HttpSessionActivationListener Interface
The ServIetRequestListener Interface
The ServIetRequestAttributeListener Interface
Describing Wrappers
Need of Wrappers
Types of Wrapper Classes
The ServIetRequestWrapper Class
The ServletResponseWrapper Class
The HttpServletRequestWrapper Class
The HttpServletResponseWrapper Class
Using Wrappers
Creating the Home.html Page
Creating the TestServIet.java File
Creating the MyRequestWrapper.java File
Creating the MyResponseWrapper.java File
Creating the MyWrapperFilter.java File
Creating the Web.xml File
Deploying and Running the Application
Applet to Servlet Communication
An Example Using Applet in Servlet
Summary
Exercise
Chapter 10: Introduction to JSP...
Understanding JSP
Advantages of JSP over Servlets
Introducing the Tag-Based Approach
Describing the JSP Architecture
JSP Model I architecture
Describing the JSP Life-Cycle
The Page Translation Stage
The Compilation Stage
The Loading & Initialization Stage
The Request Handling Stage
The Destroying Stage
Creating Simple JSP Pages
Summary
Exercise
Chapter 11: Working with JSP Basic Tags and Implicit Objects
Exploring Scripting Tags
Types of Scripting Tags
The Scriptlet Tag
The Declcirative Tag
The Expression Tag
Working with JSP Scripting Tags
Exploring Implicit Objects
Features of Implicit Objects
Types of Implicit Objects
The request Object
The response Object
The out Object
The page Object
The pageContext Object
The application Object
The session Object
The config Object
The exception Object
Working with Implicit Objects
Exploring Directive Tags
Types of Directive Tags
The Page Directive Tag
The Include Directive
Table <
Table of Contents
The Taglib Directive
Working with JSP Directive Tags.
Summary
Exercise
Chapter 12: Working with JavaBeans and Action Tags in JSP
What is JavaBean?
Advantages of using JavaBeans
Action Tags
Describing the Include Tag
Difference Between Include Directive and Include Action..
Describing the Forward Tag
Describing the Param Tag
name
value
Describing the useBean Tag
Describing the Attributes of the <jsp:useBean> Tag
Using the <jsp:useBean> Tag Attributes
Generating Servlets with the <jsp:useBean> Tag
Describing the setProperty Tag
name
property
value
param
Describing the getProperty Tag
The name Attribute
The property Attribute
Plugin
Params
Fallback
Attribute
Body
Element
Text
Declaring a Bean in a JSP
XVIII
Creating a Bean
Declaring the Bean in a JSP
Accessing the Bean Properties
Generating Dynamic Content within a JSP
Deploying and Running Application
Summary
Exercise
Chapter 13: Enhancing the JSP Tags Support.
Custom Tags
Need of Custom Tags
Elements of Custom Tags
Tag Library Descriptor
Tag Handler
The Tag Extension API
Empty Tags
- Empty Tag Handler Life Cycle
Using Empty Tags
Body Content Tag Interface
Body Tag Handler Life Cycle
Using BodyContent Tag
Iteration tag Interface
Iteration Tag Handler Life Cycle
Simple Tags
Life Cycle of Simple Tag Handlers
Differences between Simple Tag and Classic Tag Handlers.
The TryCatchFinally Interface
Summary.....
Exercise
Chapter 14: Understanding JSP Expression Language
Basic Sjmtax of using EL
Types of EL Expressions
Immediate and Deferred Expressions
Value Expressions
Method Expressions
Tag Attribute Types
Resolving EL Expressions
Describing the EL Resolver Classes
EL Operators
T)^es of EL Operators
An Example of Using EL Operators
Implicit EL Objects
Example 1 of Using Implicit EL Objects...
Example 2 of Using Implicit EL Objects...
Table of Contents
Introducing Functions with EL.
Using EL Functions
Summary
Exercise
Chapter 15: Implementing Internationalization....
Introducing Internationalization
Java and Internationalization
Describing the Locale Class
Parameters of the Locale Object
Using the Locale Class
Describing the ResourceBundle Class
The PropertyResourceBundle Class
The ListResourceBundle Class
Internationalizing Web Applications
Creating the JSP Views
Creating the index.html View
Creating the Home.jsp View
Creating the IlSNServlet Class
Creating the Resource Bundles
Configuring the Application
Designing the Application Directory Structure ...
Running the Application
Summary
Exercise
Chapter 16: Working with JSP Standard Tag Library (JSTL)
XX
Describing JSTL Core Tags
General-Purpose Tags
The <c:out> tag
The <c:set> Tag
The <c:remove> Tag
The <c:catch> Tag
Conditional and Looping Tags
Types of Conditional eind Looping Tags
Using Conditional and Looping Tags
Networking Tags
The <c:import> Tag
The <c:url> Tag
The <c:redirect> Tag
The <c:param> Tag
Describing the JSTL SQL Tags
Types of JSTL SQL Tags
The <sql:query> Tag
The <sql:update> Tag
The <sql:param> Tag
The <sql:dateParam> Tag
The <sql:setDataSource> Tag
The <sql:transaction> Tag
Using JSTL SQL Tags
JSTL Formatting Tags
Basic Formatting Tags
Types of Basic Formatting Tags
Using Basic JSTL Formatting Tags
Number Formatting Tags
Types of Number Formatting Tags
Using Number Format Tags
Date Formatting Tags
Types of Date Formatting Tags
Using Date Formatting Tags
Time Zone Formatting Tags
Types of Time Zone Formatting Tags ...
Using TimeZone Formatting Tags
JSTL XML Tags
XML Core Tags
The <x;parse> Tag
The <x:out> Tag
The <x:set> Tag
XML Flow Control Tags
The <x:if> Tag
The <x:choose> Tag
The <x:when> Tag
The <x:otherwise> Tag
The <x:forEach> tag
XML Transformation Tags
The <x:transform> Tag
The <x:param> Tag
Implementing JSTL Tags
Summary
Exercise
Table of Contents
Chapter 17: Working with JavaServer Faces
Introducing JSF
Explaining the Features of JSF
Exploring the JSF Architecture
Describing JSF Elements
UI Component
Renderer
Validators
Backing Beans
Converters
Events and Listeners
Action Events
Value-change Events
Data Model Events
Phase Events
Message
Navigation
Exploring the JSF Request Processing Life cycle
The Restore View Phase
The Apply Request Values Phase
The Process Validations Phase
The Update Model Values Phase
The Invoke Application Phase
The Render Response Phase
Exploring JSF Tag Libraries
xxii
JSF HTML Tags
The <h:commandButton> Tag
The <h:commandLink> Tag
The <h:dataTable> Tag
The <h;form> Tag
The <h:graphiclmage > Tag
The <h:inputHidden> Tag
The <h:inputSecret> Tag
The <h:inputText> Tag
The <h:inputTextarea> Tag
The <h:message> Tag
The <h:messages> Tag
The <h:outputFormat> Tag
The <h:outputLabel> Tag
The <h:outputLink> Tag
The <h:outputText> Tag
The <h:panelGrid> Tag
The <h:panelGroup> Tag
The <h:selectbooleanCheckbox> Tag
The <h:selectManyCheckbox> Tag
The <h:selectManyListbox> Tag
The <h:selectManyMenu> Tag
The <h:selectOneListbox> Tag
The <h:selectOneMenu> Tag
The <h;selectOneRadio> Tag
The <h:coluinn> Tag
JSF Core Tags
The <f:actionListener> Tag
The <f:valueChangeListener> Tag
The <f:view> Tag
The <f:attribute> Tag
The <f:converter> Tag
The <f:convertDateTime> Tag
The <f:convertNumber> Tag
The <f:facet> Tag
The <f:loadBundle> Tag
The <f:param> Tag
The <f:selectltem> Tag
The <f:selectltems> Tag
The <f;subview> Tag
The <f:validateDoubleRange> Tag
The <f:validateLength> Tag
The <f:validateLongRange> Tag
The <f:validator> Tag
The <f;verbatini> Tag
The <f:phaseListener> Tag
The <f:setPropertyActionListener> Tag
Exploring Backing Beans
An Example of Using a Backing Bean
Using a Backing Bean Method as an Event Handler.
Working with Managed Beans
JSF Input Validation
Using the Validator Method
Table of Contents
Using Validators
Standard JSF Validators
JSF Type Conversion
Handling Page Navigation in JSF
Configuring JSF Applications
Setting the web.xml File
Configuring the faces-config.xml File
Creating a Simple JSF Application
Creating the views
Creating Backing Bean
Configuring the Application
Summary
Exercise
Chapter 18: Java EE Design Patterns
Describing the Java EE Application Architecture..
Introducing a Design Pattern
Discussing the Role of Design Patterns
Exploring Types of Patterns
xxiv
The Front Controller Pattern
Problem
Forces
Solution
Strategies
Consequences
The Composite View Pattern
Problem
Forces
Solution
Strategies
Consequences
The Composite Entity Pattern
Problem
Forces
Solution
Strategies
Consequences
The Intercepting Filter Pattern
Problem
Forces
Solution
Strategies
Ginsequences
The Transfer Olqect Pattern
Problem
Forces
Solution
Strategies
Consequences
The Session Facade Pattern
Problem
Forces
Solution
Strategies
Consequences
The Service Locator Pattern
Problem
Forces
Solution
Strategies
Consequences
The Data Access Olqect Pattern-
Problem
Forces
Solution
Strategies
Consequences
The View Helper Pattern
Problem
Forces
Solution
Strategies
Consequences
The Dispatcher View Pattern....
Problem
Forces
Solution
Strategies
Consequences
Table ol
Table of Contents
The Service To Worker Pattern
Problem
Forces
Solution
Strategies
Consequences
Summary
Exercise
Chapter 19: Implementing Security in Web Applications.
Exploring JAAS
Implementing Authentication with JAAS
Describing Authorization in Web Applications
Implementing Data Integrity with JAAS API
Exploring HTTP Authentication Mechanisms
Describing HTTP Basic Authentication
Describing Form-Based Authentication
Describing Client-Certificate Authentication
Describing HTTP Digest Authentication
Securing Web Applications
Describing Declarative Security
Using Declarative Security
Using Form-based Authentication for Declarative Security
Describing Programmatic Security
Using Programmatic Security
Summary
Exercise
Appendix A: Introduction to DBMS
Appendix B; Hospital Management System
Answers
Index
What's on CD-ROM