Web Services Development Using WebLogic Server v10
Course Length - 4 Days
Course Description
If you are a J2EE developer, you can gain complete mastery over Web Services development in WebLogic Server after taking this course. This course will teach you the theory behind XML schema, WSDL and SOAP. It will proceed to teach you various Java specifications that cover Web Services development (JAX-WS , JAXB and JSR 921).
All the labs are done using WebLogic Server 10 and WebLogic BEA Workshop for WebLogic 10.
You Will Learn How To:
Upon completion of this course, the participant should be able to:
Confidently design XML schema and WSDL.
Tell the difference between different SOAP styles (document literal, RPC literal etc.)
Implement a Web Service using WebLogic Server.
Write a Web Services client using standard Java specifications.
Register a service in a public or private UDDI registry.
Secure web services.
Learn the interoperability issues especially with the .NET platform.
Course Prerequisites
Java programming. Beginner level knowledge of J2EE and XML.
Who Should Attend?
J2EE developers who will like to learn about how to build a Web Services based solution. This class covers many advanced topics that will help them build a solution appropriate for a large business.
Course Outline
Introduction To Eclipse/WTP
The Eclipse Platform
Eclipse 3.0 Java IDE
Views, Perspective and Editor Areas
Basic Operations with Eclipse Views and Perspectives
The Java Perspective
The Debug Perspective
Navigator View
Build and Validation
Templates and Code Completion
Searching
WTP
BEA WebLogic Server
Summary
Java Enterprise Edition (EE) Overview
Introduction to Java Platform
Java Community Process (JCP)
Introduction to Java EE
Why Move to Java EE
Java EE - New and Enhanced Features
Java EE Software Packaging
Java EE Technologies
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
Advantages of Web Services
Web Service Business Models
Example: Internal System Integration
Example: Business Process Externalization
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
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
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
Basic XML Schemas
What is XML Schema ?
Goals of Schema
Converting DTDs to Schema
Recall: Namespaces
The equivalent schema
Sample instance document
Documents Needed
XML Schema Namespaces
Link Documents to Schemas
Inline element declarations
XSchema Data Types
XSchema Type Definitions
XSchema Simple Data Types
Primitive Data Types
Simple Types
Facet Restrictions on Element Content
Using the Facet
More Samples
Define Simple Element Type
Element Declaration
Element Occurrence Indicators
Complex Type
Attribute Declaration
Attribute Declarations
Occurrence of Attributes
Value Constraints on Attributes
Sequence Element
Element Choices
Express any order
Annotations
JAXB
Overview of JAXB
Advantages of JAXB
XML Parsing APIs
Validation using Schemas
Java Binding
Using JAXB
Step 1: Binding XML to a Schema
Binding compiler
Interfaces and Classes
Implementing Classes
Step 2: Compiling the files
Step 3: Use the generated files
Unmarshal
To Unmarshal
Retrieving data
Validation
ObjectFactory
Generating XML from JAXB
Step 1: Bind the schema
Step 2: Create the content tree
Step 3: Marshall the content tree
Marshall the content tree
Validation
Updating an XML
Customizing your application
Advantages
JAX-WS Introduction
JAX Attack
JAX-WS Origins
JAX-WS Architecture and Tools
Providing a Service
Service Source (Option 1)
Service-enabling Java
Service Source (Option 2)
Calling a Service
Client Source (Option 1)
Advanced Features
Declarative service configuration with Java 5
Configure Eclipse for Annotations
Start-from-Java
JSR-181 defines eight annotations
Core Annotations
Hello Word Example
@WebService Annotation Parameters
@WebMethod Annotation Parameters
@OneWay Annotation
@WebParm Annotation Parameters
@WebResult Annotation Parameters
More Annotations
@HandlerChain Annotation Parameters
@SoapBinding Annotation Parameters
Advanced Hello Word Example
Adv. Hello Word Example Cont.
WSDL Generated
WSDL Generated Cont.
JSR-109 Web Services for Java EE
Web Service Details
Servers
JSR-109
Why Use JSR-109?
JSR-109 Specification
JAX-RPC vs. JAX-WS
JAX-WS and JSR-109
JSR-109 Holes
Annotations
Implementation Classes
Implementation as a POJO
Implementation as an EJB
Dispatch Class
JSR-109 Advantages
Generated Components
Packaging A JSR-109 Service
Deployment
Web Service Client
JSR-109 Clients
Definitions
Client Lookup
Invoking the service
Handler Framework
Handler Implementation
Security
Coding WebLogic Server v10 Web Services
Introduction
JAX-RPC vs. JAX-WS
Web Service Scenarios
Web Service: Bottom-Up
Web Service: Top-Down
Ant
Example: Bottom-up
Annotate the JWS
Ant Script
Run The Script
Web Services Deployment Descriptor
The Generated WSDL File
The WSDL Editor
Other JWS Annotations
JWS Implementation
Creating A SSB Implementation
Top Down Implementations
wsdlc Created Artifacts
The Generated JWS
Generating A Client
Generated Client Classes
Using The Client Classes
Web services Description Language (WSDL)
WSDL Overview
WSDL Document Tags
WSDL Namespaces
Sample WSDL Document Structure
<definitions>
<import>
<types>
<message>
<portType>
<operation>
One-way <operation>
Request-Response <operation>
Solicit-Response <operation>
Notification <operation>
Modeling Simple Operation
Modeling Complex Operation
Modeling Complex Message
<binding>
More on <binding>
<binding> Syntax
SOAP Binding Example
<service> and <port>
More on <port>
WSDL SOAP Binding Extensions
soap:binding
soap:operation
RPC or Document Style?
WSDL API for Java
Simple Object Access Protocol (SOAP)
SOAP Overview
SOAP in Protocol Stack
SOAP Components
SOAP HTTP Request Example
SOAP HTTP Response Example
Message Envelope
The Header Element
Header Attributes
SOAP Body
SOAP Fault
Communication Style
RPC/Encoded Style
RPC/Literal Style
Enabling RPC Styles
Document/Literal Style
Document/Literal Wrapped Style
Details of the Wrapped Style
Enabling Document Literal Style
JAX WS 2.1 Details
JAX-WS
JAX-WS Scope
JAX-WS and JAXB
JAX-WS Implementers
WSDL-to-Java Mapping
WSDL Files
<definitions>
<portType>
<types>
<operation>
<operation> parameters
<fault>
Customization Binding
Java-to-WSDL Mapping
The Implementation Class
Package Name
Class Name
Methods and Types
JAXB Usage
Exceptions
Available API
Client API - Service
Service
Using Service
Dispatch
Provider
WebServiceContext
Exception Classes
WebServiceFeature
Annotation Support
JAX-WS Annotations
The Handler Framework
Handler Invocation
Handler Types
Using Handlers
Error Handling
Introduction
Fault
Designing Faults
System Problems
Business Rule Violation
Web Services Security
The Challenges
Public Key Infrastructure (PKI)
Digital Signature
Certificates
Overview of Web Services Security
SOAP Message Security
Message Integrity
Message Confidentiality
Authentication
Security Identity Propagation
Transport Level Security
Configuring Security in WebLogic
WebLogic Server v10 Note
Web Service Annotations
Policy Annotations
Integrity
Authority
Confidentiality
Coding the Client
Best Practices
Architecture Best Practices
Data Format Best Practices
Security Best Practices
Programming Model Best Practices
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
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
Introduction to Service Oriented Analysis & Design (SOAD)
Introduction to SOAD
Applying OOAD Principles
Abstraction
Abstraction in SOAD
Encapsulation
Encapsulation in SOAD
Modularity
Modularity in SOAD
Hierarchy
Hierarchy 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 Modeling
