J2EE & Weblogic

Duration :
Curriculum

Overview of Java EE Development

Chapter 1. History and Overview

Structured Programming
Object-Oriented Programming
4GLs and RAD
Java
Java EE and the Outside World
Versions Upon Versions

Chapter 2. Concepts

The Virtual Machine and Runtime

How Does It Work?
Containers and Components
Three Containers
Aspect-Oriented Programming
Java EE as an AOP Platform
Annotations
Deployment Descriptors
Remote Connectivity
Scalability
Availability
Security
Transactionality

Chapter 3. Technology

JDBC
Servlets
JavaServer Pages
Java Naming and Director Interface
The Component Environment
Multi-Tier Applications
JavaServer Faces
Enterprise JavaBeans
Java Persistence API
Ajax
Java Message Service
APIs for Web Services
Chapter 4. Tools, Standards, and Portability

Java IDEs
Web Servers and Containers
The WebLogic Server
Standards and Portability
What Is and Isn't Standardized
Beyond Java EE

Chapter 5. Development and Administration

Development Process
Assembling WARs and EJB JARs
Assembling EARs
Verifiers
External Resources
Administrative Tools
Administrative Tasks
Remote Administration and Domains

JavaServer Pages with WebLogic

Module 1. Introduction to JSP

Chapter 1. Web Applications

The World Wide Web

HTML
Web Servers
HTTP
Dynamic Web Pages
CGI
Java Web Technologies
Servlets
JSP
The WebLogic Server
Creating a Domain
Deploying to WebLogic

Chapter 2. JSP Architecture

JSP Containers
Servlet Architecture
Page Translation
Types of JSP Content
Directives
Content Type
Buffering
Scripting Elements
 JSP Expressions
Standard Actions
Custom Actions and JSTL
Objects and Scopes
Implicit Objects
JSP Lifecycle

Chapter 3. Scripting Elements

Translation of Template Content

Scriptlets
Expressions
Declarations
Dos and Don'ts
Implicit Objects for Scriptlets
The request Object
The response Object
The out Object

Chapter 4. Interactive JSP Applications

HTML Forms
Reading CGI Parameters
JSPs and Java Classes
Error Handling
Session Management
The Session API
Cookies and JSP

Chapter 5. Using JavaBeans

Separating Presentation and Business Logic

JSP Actions
JavaBeans
Working with Properties
<jsp:useBean>
<jsp:getProperty> and <jsp:setProperty>
Using Form Parameters with Beans
Objects and Scopes
Working with Vectors

Chapter 6. The Expression Language and the JSTL

Going Scriptless
The JSP Expression Language
EL Syntax
Type Coercion
Error Handling
Implicit Objects for EL
The JSP Standard Tag Library
Role of JSTL
The Core Actions
 Using Beans with JSTL
The Formatting Actions
Scripts vs. EL/JSTL

Chapter 7. Advanced JSP Features

Web Components
Forwarding
Inclusion
Passing Parameters
Custom Tag Libraries
Tag Library Architecture
Implementing in Java or JSP
Threads
Strategies for Thread Safety
XML and JSP
JSP for Web Services

Java Servlets with Weblogic

Chapter 1. Web Applications

Server-Side Programming
Web Protocols and Web Applications
Role of Web Servers
Application Servers
WebLogic
Java Servlets
Using Tomcat Web server
Structure of a Java Servlet

Chapter 2. Servlets Architecture

Servlets Architecture
Servlet and HttpServlet
Request and Response
Reading Request Parameters
Producing an HTML Response
Redirecting the Web Server
Deployment Descriptors
Servlets Life Cycle
Relationship to the Container

Chapter 3. Interactive Web Applications

Building an HTML Interface

HTML Forms
Handling Form Input
Application Architecture
Single-Servlet Model
 Multiple-Servlet Model
Routing Servlet Model
Template Parsers

Chapter 4. Session Management

Managing Client State

Sessions
Session Implementations
HttpSession
Session Attributes
Session Events
Invalidating Sessions

Chapter 5. Database Access

JDBC
JDBC Drivers
Using JDBC in a Servlet
Data Access Objects
Transactions
Connection Pooling

Chapter 6. Configuration and Context

The Need for Configuration

Initialization Parameters
Properties Files
JNDI and the Component Environment
JDBC Data Sources
The WebLogic Administration Console
Configuring Data Sources for WebLogic
Working with XML Data

Chapter 7. Filters

Servlet Filters
Uses for Filters
Building a Filter
Filter Configuration and Context
Filter Chains
Deploying Filters

EJB:
Chapter 1. Overview

Enterprise Applications
Containers and Objects
Three Containers
 Remote Connectivity
Scalability and Availability
Security
Transaction Control

Chapter 2. Architecture

What is an EJB?
Types of Beans
Inversion of Control
The Bean-Type Annotations
Dependency Injection
The @EJB Annotation
The JBoss Application Server
The Administration Console
Deploying EJB Applications
Configuring Data Sources
Development Cycle and Roles

Chapter 3. Session Beans

Interface/Implementation Split
Stateful vs. Stateless
The @Stateless Annotation
Lifecycle and State Transitions
Session Context
The @Stateful Annotation
State Transitions
Singletons and Pools

Chapter 4. Entities

The Java Persistence API

Hibernate as a JPA Provider
Persistence Annotations
Configuration by Exception
ORM Annotations
The EntityManager
Acquiring and Using the EntityManager
persistence.xml
@Enumerated and @Temporal Types

Chapter 5. Associations

Associations, Cardinality, and Ownership

Annotations
Unidirectional vs. Bidirectional
The @Embedded Annotation

Chapter 6. Java Persistence Query Language

OO Query Languages
 The FROM Clause and Directionality
The WHERE Clause
The SELECT Clause
Joins
Aggregates and Grouping
Ordering

Chapter 7. Dependency Injection

Interdependent Systems
The Factory Pattern
The Service Locator Pattern
Dependency Injection
Injection by Magic?
Injection by Type
Injection by Name
The Component Environment
Deployment Descriptors
Impact on Stateful Session Beans
JNDI
Connecting to a Remote Bean
Using mappedName
Who Can Declare Dependencies

Chapter 8. Message-Driven Beans

Asynchronous Messaging
The Java Message Service
Message-Driven Beans
Message Types
Injecting JMS Queues
JMS Configuration in JBoss

Chapter 9. Transactions

ACID Transactions
The EntityTransaction Interface
EJB Transaction Attributes
Persistence Contexts
Extended Persistence Contexts
Isolation Levels
Application-Managed Persistence
The SessionSynchronization Interface
Impact on JMS and MDBs

Chapter 10. Exception Handling

Java Exceptions
Remote Exceptions
EJB Exception Handling
System Exceptions
Application Exceptions
 Transaction Control

Chapter 11. Security

Authentication and Authorization

Declarative Authorization
Abstract Roles
Concrete Realms
Configuring User Realms in JBoss
Programmatic Authorization
Run-As Identity

Chapter 12. Interceptors

EJB and AOP

The Intercepting Filter Pattern
EJB Interceptors
Annotating Interceptor Classes
The InvocationContext Interface
Binding Interceptors to Targets
Shared Lifecycle and Context
Interceptors and MDBs

Chapter 13. Timers

The EJB Timer Service

The TimerService Interface
The Timer Interface
Timeout Methods
Timer Handles
Transactions and Timers

JSF
Chapter 1. Overview

Java EE and Web Applications

Perspectives: Servlets and JSP
Perspectives: MVC Frameworks
Perspectives: AWT and JFC
JSF Value Proposition
JSF Configuration
Issues with JSP and JSF
Facelets

Chapter 2. Lifecycle

The JSF Request/Response Cycle

Lifecycle Phases
Phase Listeners
 The FacesContext Class
Who Does What
Partial Request Cycles

Chapter 3. UI Components

The UIComponent Class

Behavioral Interfaces
The Core and HTML Tag Libraries
Relationship to CSS
ID, Client ID, and Label
UISelectItem(s)
Navigating the UI Tree
The binding Attribute

Chapter 4. Page Navigation

View Selection
Navigation Rules
Implicit Navigation
Problems with POSTback
Post/Redirect/Get
Support for HTTP GET
Conditional Navigation

Chapter 5. Managed Beans

JavaBeans and JSF

Backing Beans
Configuring Managed Beans
@ManagedBean and Related Annotations
The Unified Expression Language
Value and Method Expressions
Implicit Objects

Chapter 6. Scopes

Managed-Bean Scopes
Lifecycle Annotations
View Parameters
The Flash

Chapter 7. Dependency Injection

Managed Properties
Values, Lists, and Maps
Using Dynamic Expressions
Dependencies and Bean Scopes
The @ManagedProperty Annotation

Chapter 8. Facelets
 Migrating from JSP
View Definition Languages
Facelets
Tag Libraries
Writing and Using Custom Tags

Chapter 9. Events and Listeners

JSF Event Model

Event Types and Timing
Event Queueing
ActionEvent and ActionListener
Action Methods
Connecting Controllers to Beans
ValueChangeEvent and ValueChangeListener
Deferring Event Processing
Limitations of FacesListeners

Java Message Services

Chapter 1. Fundamentals

Asynchronous Messaging
The Java Message Service
Point-to-Point Messaging
Publish-and-Subscribe Messaging
JNDI
Connections and Sessions
Working with Queues
Working with Topics
GlassFish JMS Administration
Expiration

Chapter 2. Message Content

Message Types
Header Fields
Properties
Message Selectors

Chapter 3. Reliability

Message Persistence
JMS from Web Applications
The Component Environment
Acknowledgement and Redelivery
Acknowledgement Modes
Session Recovery
Transactions
What JMS Transactions Are and Aren't
 Transaction Pitfalls
Batch Processing
Priority
JMS and EJB: Message-Driven Beans
JMS and Web Services: SOAP Messaging

JSTL with Weblogic

Chapter 1. JSTL Overview

The JSP Standard Tag Library

The JSP Expression Language
EL Syntax
Type Coercion
Error Handling
Implicit Objects for EL
JSTL Namespaces
Using JSTL in a Page
Installing WebLogic's JSTL Support
The Core Actions
Going Scriptless
Object Instantiation
Sharing Objects
Decomposition
Parameterization

Chapter 2. The Core Actions

The JSTL Core Library

<c:out>
<c:set>
Gotchas
Conditional Processing
Iterative Processing
Iterating Over Maps
Tokenizing Strings
Catching Exceptions
Resource Access

Chapter 3. The Formatting and i18n Actions

The JSTL Formatting Library

Locales
Determining Locale
Time Zones
Setting Locale and Time Zone
Formatting and Parsing Dates
Formatting and Parsing Numbers
Internationalization
Working with Resource Bundles
 Supporting Multiple Languages

Chapter 4. The SQL Actions

The JSTL SQL Library

Using Relational Data
Connecting with a DriverManager
Connecting via a DataSource
The WebLogic Administration Console
Configuring Data Sources for WebLogic
The Result Interface
Making a Query
Inserts, Updates and Deletes
Parameterized SQL
Transactions

Chapter 5. The XML Actions

The JSTL XML Library

Using XML
XML Data Sources
Parsing and Addressing
Using XPath in JSTL
XPath vs. EL
XPath Context
Implicit Objects for XPath
Conditional Processing
Iterative Processing
Changing XPath Context
Working with XML Namespaces
Using XSLT
Chaining Transformations
Reading XML from the Request Body
XML and SOAP Web Services