UMBC Training Centers logo

Web Services Development Using RAD v7.0

 

Course Description | Outline | IT Home

1 - Introduction to Rational Application Developer (RAD) v7.0
* The RAD 7 Product
* Eclipse Platform
* Rational Web Developer
* Rational Application Developer
* Key Features in RAD v7.0
* Views, Perspective, and Editor Areas
* Basic Operations with RAD Views and Perspectives
* The Java Perspective
* The Debug Perspective
* Navigator View
* Package Explorer
* Outline View
* Task and Problems View
* Build and Validation
* Import and Export Project
* Code Completion, Templates and Snippets
* Searching
* Setup Compiler Class Path
* JRE Switching
* Refactoring
* Changing Class Name
* Changing Method Name
* Changing Variable Name
* Moving a Class to a Different Package
* Extracting Code to a Method
* Pull Up and Push Down Methods
* Migrating Workspace from RAD v6 or WSAD v5.1.2
* Project Interchange Feature
* Migrating J2EE Applications
* J2EE Migration Wizard
* Summary

2 - J2EE Overview
* Introduction
* Why Do We Need J2EE?
* J2EE Components
* J2EE Technologies
* Useful J2SE Technologies
* Application Artifacts
* J2EE Architecture
* J2EE 1.4 Version Levels
* J2EE Software Packaging
* Deployment Descriptor
* Enterprise Archive (EAR)
* Web Modules and WAR
* EJB Modules
* Building Module Dependency

3 - J2EE Programming Tools
* Project Explorer
* Servers View
* The J2EE Perspective
* The Web Perspective
* Create an Enterprise Application
* Setup Utility JAR
* Create an EJB Project
* Create a Web Project
* Setup Dependent JAR Files
* Create Server Instance and Server Configuration
* Configure Server Instance
* Add an Enterprise Application Project to the Test Server
* Start and Stop the Server
* Test a Servlet
* Debug a Servlet
* Test a JSP
* Debug a JSP
* Summary

4 - Introduction to Web Services
* A Conceptual Look at Services
* Defining Services
* Service Communication Analogy
* Three Key Service Questions
* Connecting the Dots
* SOA: Runtime Implementation
* What Is a Web Service?
* Enterprise Assets as Services
* Typical Development Workflow
* Typical Development Workflow
* Advantages of Web Services
* Web Service Business Models
* Web Service Business Models
* Example: Internal System Integration
* Example: Business Process Externalization
* Web Services Standards
* Binding via SOAP
* SOAP in Protocol Stack
* SOAP Structure
* SOAP Message Architecture
* Applying SOAP
* Interface via WSDL
* WSDL Structure
* Applying WSDL
* Locating a Service
* UDDI Overview
* UDDI Terminology
* UDDI Structure
* Applying UDDI
* WS-I Overview
* WS-I Deliverables
* Summary

5 - XML Programming
* XML Overview
* Data and Document Structure
* An Employee Document
* Tags
* First XML Document
* Markup Languages
* What is XML ?
* Why XML?
* An Example of XML Document
* Well-Formed v. Valid XML Document
* Enforcing Validity: DTDs
* Presentation Style
* Sections of an XML Document
* Sections of an XML Document
* XML Elements
* Nesting and Hierarchy of XML Elements
* Tag Attributes
* Naming Rules
* Namespaces
* Using Namespaces
* Java API for XML
* The XML Example
* Example SAX Handler
* Example: Begin Parsing
* Once Again with Namespace
* Using DOM to Parse
* With Namespace Enabled
* Example: Build DOM Document
* Example: Save DOM Document in a File
* Persisting XML
* Summary

6 - Introduction to Schema
* What is an XML Schema?
* Instance Documents
* A Simple Instance Document
* Creating a Schema File
* Creating a Schema File
* Defining a Simple Element
* Defining a Complex Element
* Defining Element Attributes
* Referring to an Element From Another Element
* Adding Restrictions
* Putting It All Together
* Putting It All Together
* Referring to a Schema from an XML Document
* Referring to a Schema from an XML Document
* Global Elements vs. Local Elements
* Summary

7 - Web Services Description Language (WSDL)
* WSDL Overview
* WSDL Syntax Overview
* Summary

8 - Simple Object Access Protocol (SOAP)
* SOAP Overview
* SOAP in Protocol Stack
* SOAP Document Components
* Example SOAP Request Document
* Example SOAP Response Document
* The Element
* The Element
* The Element
* SOAP Communication Style
* Setting the Style in WSDL
* RPC/Encoded Style
* RPC/Literal Style
* Document/Literal Style
* Document/Literal Wrapped Style
* Summary

9 - JAX-RPC (JSR 101)
* JAX-RPC Overview
* JAX-RPC Framework
* JAX-RPC Framework
* Java to XML Data Conversion
* Main Goals of JAX-RPC
* Supported Protocols
* JAX-RPC Supported Types
* JAX-RPC Server
* Server Side Artifacts
* Generating Server Artifacts
* JAX-RPC and WS-I
* JAX-RPC Clients
* JAX-RPC Client Model
* JAX-RPC Client: Static Stub
* Generating Client Side Code
* Client Programming Model
* JAX-RPC Client: Dynamic Proxy
* Dynamic Invocation Interface (DII)
* Dynamic Invocation Interface
* JAX-RPC Type Mapping
* 1. Mapping XML Types to Java Types: Simple Types
* 1. Mapping XML Types to Java Types: Simple Types
* 1. Mapping XML Types to Java Types: Simple Types
* 1. Mapping XML Types to Java Types: Complex Types
* Complex Type Mapping: Example
* 1. Mapping XML Types to Java Types: Arrays
* Mapping Arrays: Example
* Schema Mapping Restrictions
* Schema Mapping Restrictions
* 2. Mapping Abstract WSDL Definitions to Java
* 2. Mapping Abstract WSDL Definitions to Java
* 2. Mapping Abstract WSDL Definitions to Java
* 2. Mapping Abstract WSDL Definitions to Java
* 3. Mapping Concrete WSDL Types to Java Types
* 3. Mapping Concrete WSDL Types to Java Types
* Java to WSDL/XML Mapping
* Mapping Tools
* Summary

10 - Web Services for J2EE
* Introduction
* JSR-109: Motivation
* When Do You Use JSR 109?
* JSR-109 Roles
* JSR-109 Roles
* The Server Programming Model
* The Service Endpoint Interface
* Service Endpoint Interface - Example
* Web Module Service
* Web Module Service - Example
* Web Module Port Component Definition - Example
* Accessing the Service
* The Mapping File
* Mapping File - Example
* Implementation Class Details
* Lifecycle Callback
* EJB Module Service
* Session Bean Entry – Example
* EJB Module Service
* EJB Module Port Component Definition – Example
* EJB Module Service
* The Client Programming Model
* Developing a Client
* Service Reference – Example
* The Service Interface
* Service Entry in WSDL – Example
* Writing a Client
* Handlers
* Handlers (Server-Side) - Example
* Handlers (Client-Side) – Example
* Summary

11 - WebSphere V6.1 Support for Web Services
* Introduction
* Web Service Runtimes
* Service in a Web Container
* Example Java Class
* Generated Artifacts
* How Does the Wizard Generate All That?
* Web Services Deployment Descriptor
* Example: webservices.xml
* webservices.xml Editor
* The Generated WSDL File
* The WSDL Editor
* Service in an EJB Container
* Generated Artifacts
* Web Services Deployment Descriptor
* Client Development
* Generated Artifacts
* The Service Reference
* The Proxy Class
* Summary

12 - Error Handling
* Introduction
* Fault
* Designing Faults
* System Problems
* Business Rule Violation
* Summary

13 - 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
* Message Confidentiality
* Symmetric Encryption Example
* Authentication Using Identity Token
* Authentication
* Transport Level Security
* Audit Tracking
* Audit Tracking
* Identity Assertion Using SAML
* SAML SOAP Example

14 - Introduction to UDDI
* UDDI Overview
* UDDI in Web Services Architecture
* UDDI
* Businesses and Services in UDDI
* Static and Dynamic Web Services
* UDDI Registry Structure
* UDDI Registry Structure - tModel
* UDDI Interactions
* UDDI in WebSphere
* Summary

15 - Web Services Interoperability (WS-I)
* Introduction
* Goal
* What Comes Out of WS-I?
* Profiles
* Basic Profile 1.1 Highlights
* Simple SOAP Binding Profile 1.0 Highlights
* Basic Security Profile 1.0
* .NET Interoperability

16 - Introduction to Service Oriented Analysis & Design (SOAD)
* Introduction to SOAD
* Applying OOAD Principles
* Encapsulation
* Encapsulation in SOAD
* Inheritance
* Inheritance in SOAD
* Polymorphism
* Polymorphism in SOAD
* Why OOAD Is Not Enough
* Granularity
* The Need for Loose Coupling
* The SOAD Methodology
* The SOAD Methodology Steps
* Stage 1: Requirements Gathering & Process or Message Flow Modeling
* Stage 1: Requirements Gathering & Process Modeling
* Stage 2: Service Identification
* Stage 3: Service Implementation
* Stage 4: Process Implementation
* SOAD Stages and SOA Lifecycle
* Summary

17 - Service Analysis and Design
* How Is a Service Developed?
* Bottom-Up Development
* Web Service Implementation Choices
* Bottom-Up Technology Choices (Java)
* Example: JAX-WS Service
* Bottom-Up Technology Choices (Java)
* Example: JCA-Based Service
* Bottom-Up Technology Choices (.NET)
* Example: ASMX Service
* Example: Adapter-Based Service
* Data Mapping
* Interface Mapping
* Top Down Development
* Apply OOAD in New Development
* Top-Down Summary
* Top-down or Bottom-up?
* Service Design Approaches
* Summary

18 - Best Practices
* Architecture Best Practices
* Data Format Best Practices
* Security Best Practices
* Programming Model Best Practices
* Summary