ARCHITECTING AND DESIGNING JAVA EE APPLICATIONS– GTIT5

Course Description

This course provides the students with the prerequisite knowledge necessary to use J2EE in order to architect robust and maintainable enterprise applications.

^^

Duration

4 days

^^

Target Audience

The course is suitable for Architects, Senior Designers and Development and Product Managers.

^^

Course Prerequisites

Delegates attending this course should have an understanding of OOAD and J2EE to succeed in this course.

If you have any questions or doubts as to whether you meet the pre-requisites for this course, or indeed are wondering which course best suits you, please consult with us to discuss your suitability for course attendance.

^^

Suggested Follow on Courses

Please contact us for further details.

^^

Course Content

Chapter 1 – Fundamental Architectural Concepts

What is Architecture?

Architecture vs. Design

Qualities of Service (QoS)

Common Mechanisms

Architectural Description

What Architecture is Not

The Need for Architecture

The Architect

Roles of the Architect

Skills of the Architect

Chapter 2 – System Architecture Development Guidelines

Security Risks

Performance & Scalability Risks

Availability & Complexity Risks

Compatibility & Control Risks

Network Considerations

Latency and Bandwidth

Minimize Number of Network Calls

Minimize Network Call Size

Firewall Navigation

Secure Communication

Distributed Object Technologies

What is a Transaction?

Bank Example

Multiple Users Sharing Data

ACID Properties of Transactions

Architecture

Reference Architecture

Patterns

Development Methodologies

Open Standards

Frameworks

Chapter 3 – Quality of Service Requirements

What are Quality of Service Requirements?

Qualities of Service and Design

Quality of Service Inventory

Performance

Scalability

Reliability

Availability

Extensibility

Maintainability

Manageability

Security

Cultural Adaptability

Portability

Testability

Usability

Upgradeability

Recoverability

Prioritizing Quality of Service Requirements

Inspecting QoS Requirements for Trade-off Opportunities

Quality of Service Reviews

Chapter 4 – Software Architecture Tiers

System Architecture

Good Architecture

Cave Drawings to Modern Day

Information Systems Evolution

Continued Evolution

Present Day

Client-Server Computing

Client-Server Pros/Cons

Client-Server Example

Tiered Architectures

Three-tier Architecture

Three-tier Pros/Cons

Three-tier Example

N-Tier Architecture

N-Tier Pros/Cons

N-Tier Example

Chapter 5 – Client Tier Technologies

HTML5

HTML5 Main Objectives

Which Features of HTML 4 Changed

New Features of HTML 5

New Features of HTML 5

Browser-side Data Storage

Declaring HTML5

Detecting Support for HTML5

HTML5 Input Validation Example

HTML5 Date Form Widget

The Document Object Model

The Document Object Model

What the DOM is Not

Cascading Style Sheets

CSS Levels

What is JavaScript?

Working with JavaScript

Working with JavaScript

What is jQuery?

Benefits of Using a JavaScript Library

jQuery Example

jQuery Mobile

Apache Cordova (Adobe PhoneGap)

Apache Cordova History

Bootstrap

Responsive Web Design

Why Responsive Web Design Matters

Responsive Web Design Components

Mobile First

Backbone.js

Backbone Modules

MVC and Backbone

AngularJS

Chapter 6 – Managing Client Tier Considerations

Understand Client-tier Concerns

Types of Clients

JEE Client Responsibilities

Presenting the User Interface

Validating User Inputs

Communicating with the Server

Managing Conversational State

Understand Client-Tier Security

Client-Tier Security

Compare/Contrast User Interface Devices

Application of Reuse to the Client Tier

Strategies for Deploying Java Desktop Applications

Applet Usage

Chapter 7 – JEE Technology Servers

Server Types in JEE

JEE Servers

Java EE 6 Profiles

Popular Java EE Application Servers

Java EE Blueprint

JEE Containers

Enterprise Information Systems

ERP Systems

Mainframe Transaction Processing Systems

Relational and Legacy Databases

Legacy Integration

Selecting a JEE Server

Packaging and Deployment Definitions

Roles and Responsibilities

EJB Modules

EJB Module Packaging

Web Modules

Web Module Recommendations

Deployment Descriptors

Chapter 8 – JEE Technologies

Major Programming Technologies of Java EE

Servlets

Servlets Do the Following

The Web Container

JSP (Java Server Pages)

JSP Elements

JSP Standard Tag Library (JSTL)

Filters

Uses for Filters

JavaServer Faces (JSF)

JSF 2.0

Contexts and Dependency Injection for Java (CDI)

CDI Example

Bean Validation

Java Message Service (JMS)

What are EJBs?

Main Characteristics of EJBs

EJB Container

Data Persistence

Java Persistence API

Entities

Enterprise Java Beans

Session Beans

Session EJB vs JPA Entities

Asynchronous EJB

Singleton EJB

Message-Driven Beans

Remote vs. Local Session EJBs

Defining Services

Many Flavors of Services

Java Web Service Implementation Choices

Java Architecture for XML Binding (JAXB)

Java SOAP Web Services with JAX-WS

Java REST Web Services with JAX-RS

REST vs SOAP Summary

JCA (JEE Connector Architecture)

Chapter 9 – JEE Technology Choices

Client Session State

Client Managed State

Web Tier Managed State

EJB Tier Managed State

Business Objects

When to Use EJB

Persistence Data Options

Client Types

Web Browser Clients

Java Clients

Model View Controller

Model View Controller in the Web-Tier

Web Application Frameworks

Web Presentation Layout

Java Presentation Layout

Message-Oriented Middleware and JMS

Messaging Domains

Characteristics of MOM

Advantages of Asynchronous Communication (e.g. MOM)

Implementing Asynchronous EJBs

Advantages of Synchronous Communication (e.g. RMI/IIOP)

Remote Access to Business Logic

Chapter 10 – SOA Concepts

Anatomy of an Enterprise

IT Nightmare

Understanding by Analogy

Service Oriented Architecture

Componentization and Reuse

Benefits of Service Orientation

Defining SOA

Aligning the Enterprise

What’s a Service?

Service Actors

Service Layering

Is SOA a Flash in the Pan?

Service Orienting the Enterprise

Service Oriented Thinking

Chapter 11 – Introduction to JAX-WS

What is JAX-WS?

Advantages of JAX-WS

Why Do We Need a Programming Model?

Basic Java to WSDL Mapping

Developing a Service Provider

The Service Implementation Class

The Service Endpoint Interface (SEI)

Service Implementation Options

Developing a Consumer

Static Client Development

The Service Class

The BindingProvider Interface

Chapter 12 – REST and JAX-RS Overview

Many Flavors of Services

Where SOAP Shines

Where REST Shines

Understanding REST

Principles of RESTful Services

Example: Catalog Service

Create a New Product

Retrieve a Product

Update a Product

Delete a Product

Introduction to JAX-RS

The Resource Class

The Entity Class

Retrieve a Product

Create a Product

Update and Delete

Content Negotiation

Retrieving a JSON Representation

Sending a JSON Representation

REST Service Clients

AJAX and XML

AJAX and JSON

Java REST Clients

Chapter 13 – JEE Security

JEE Authentication Mechanisms

Basic Authentication

Form-based Authentication

Client Certificate Authentication

JEE Authorization

Declarative Security on Web Resources

Programmatic Security on Web Resources

Security Role Reference

Defining Security Roles Using Annotations

Delegation

Declarative Security on EJB Resources

Protecting Beans Using Annotations

Protecting Beans Using the Deployment Descriptor

Programmatic Security on EJB Application

Delegation

Chapter 14 – Web Services Security (WS-Security)

The Challenges

Public Key Infrastructure (PKI)

Digital Signature

Certificates

Overview of Web Services Security

SOAP Message Security

Message Integrity

Message Confidentiality

Symmetric Encryption Example

Authentication Using Identity Token

Authentication

Transport Level Security

Audit Tracking

Identity Assertion Using SAML

SAML SOAP Example

Chapter 15 – Prototypes

What is a Prototype?

Conceptual Prototypes

Architectural Prototypes

Advantages of Prototyping

Deciding Whether to Build a Prototype or Not

Prototypes and the Software Development Lifecycle

Prototype Roles and Responsibilities

Throw-away vs. Evolutionary Prototypes

Spikes

Testing a Prototype

Chapter 16 – Describing and Evaluating Software Architecture

Architecture Description

Architectural Views

Subsystems

Layers

Example: Subsystems with Layers

Components

Decomposing the System Into Components

Software Partitioning Strategies

Managing Dependencies

Component Diagrams

Deployment Diagrams

Tiered Architectures

Managing Complexity

Evaluating the Architecture

 

Appendix A – Data Transfer in Distributed Computing

Data Transfer in Java Local Computing

Data Transfer in Java Distributed Computing

Comparing Data Transfer in Local and Distributed Computing

Appendix B – Transactions in EJB

Need for Transactions

Transactions

ACID Properties

Transaction Components

Distributed Transactions

Distributed Transaction Components – Two Phase Commit

Java Transaction API (JTA)

EJB Transaction Basics

Transaction Propagation

Transaction Outcome

Container-Managed Transaction

Transaction Attributes

Container-Managed Transaction Settings

Interacting with Container-Managed Transactions

Container-Managed Transaction – Example

Application Exceptions in Container-Managed Transactions

Transaction Attributes Support

Bean-Managed Transaction Management Type

 Appendix C – Business Tier Patterns – 1

Facade Pattern

Business Object Pattern

Application Service Pattern

Service Locator Pattern

Remote Service Locator Example

Dependency Injection in Servlets

Business Delegate Pattern

 Appendix D – Business Tier Patterns – 2

Data Transfer Object (DTO) Pattern

JPA Entity as DTO

JPA Lazy Loading

Message Facade

Fast Lane Pattern

Pagination (Value List Handler) Pattern

Version Number Pattern

Read for Update Pattern

Primary Key Generation

Data Access Object (DAO)

 

^^

See more Internet Technologies courses