Production Web Services

Using Java and Apache Axis to create production quality web services

Summary
Why Apache Axis
What You'll Learn
Instructor Bio
Learning Experience
Course Duration
Equipment
Prerequisites
Course Outline
Training Schedule

Summary  

    Programming web services with Java can be a confusing, time-consuming activity.  Which development tools to choose?  What web service technologies are relevant to my project?  What standards are important?  How do I insure interoperability?  The questions can seem endless, but neither your budget nor your time is.  This course seeks to help programmers turn down the noise, and gain a clear understanding of the programming activities necessary to build solid, production ready web services. 

    Using the popular Apache Axis tools, you'll learn the ins and outs of architecting, developing, deploying, and testing web services.

    Much of what is written about Java Web Services is either too abstract or too code intensive to be useful to programmers.  If you've tried to learn web services in the past, but found yourself wandering around trying to figure out where the trail starts, you'll find that this course is perfect for you.  In this class you'll learn the basics and the terminology, without getting bogged down with irrelevant, abstract issues  You'll learn to code web services efficiently, by using high-level tools instead of starting from scratch.

    In the first hour of this course, you'll use the Apache Axis toolkit to implement a real web service.  From there we'll follow a well-marked path into web services development.  You'll constantly be challenged with hands-on material, which will give you a clear, unambiguous understanding of web services and web service development.  At the end of the class you'll be prepared to understand, architect and implement your own web services.

Why Apache Axis

    There are a number of Web services toolkits to choose from, many of them very nice.  We've chosen to use Apache Axis in our own Web Service projects.   Our initial choice was based on attempting to find a toolkit that would both save us time and would also be a likely standard.  In the Java world, this is always tough, but in general, when it comes to frameworks and toolkits, Apache is a great place to start.  After evaluating Axis, we found it to be an excellent product.  In production, Axis has continued to perform well (married with the JBoss J2EE server running the Jetty servlet container).  Just as importantly, it's saved our team countless hours of programming time, by wrapping up common web service functionality.  The fact that it's open source has been attractive to our customers.  Axis is also extremely flexible and extensible.  The flexibility of the Axis tools coupled with the sparse documentation can leave a new adopter confused and frustrated.  This class serves to eliminate that initial confusion, significantly reducing your initial startup investment with Axis.

What you'll learn

• Web Services standards and standards organizations
• SOAP - Simple Object Access Protocol
• WSDL - Web Service Description Language
• Web Service Type and Encoding
• The Apache Axis tools and framework
• How to Generate Java Web service clients
• How to write and implement Axis handlers
• Axis Web Service Deployment Descriptor (WSDD) in detail
• Integrating Ant, JUnit, and Log4J with your web service development
• Data types and Interoperability

Instructor Bio

  Bill Heitzeg is a hands-on consultant.  With over 10 years of experience in distributed systems, he has led many teams to success by continuously focusing on efficiency and productivity in the development cycle.  Most recently he lead a team of developers for a Fortune 100 company.  The team was responsible for creating a high volume web service to be used by outside customers.  Apache Axis and other tools used in this course were employed.  The project was brought in ahead of schedule and under budget.  Bill has developed and instructed on other training material including UML, Java, and J2EE.

Learning Experience

    This class is mix between lecture and hands-on labs.  The labs constitute well over half the class time.  The labs are further divided into tutorials and exercises.  A tutorial walks the student through each step of a particular activity, guiding them along the way to the proper result.  In contrast, an exercise defines an end goal and asks the student to come up with a solution.  In this way, students should be challenged throughout the course, walking away with a solid understanding of the concepts and a large set of working code.

Course Duration

3 days

Equipment

    Students are expected to bring their own laptops with the software installed as specified in the Pre-class material.

Prerequisites

  *   These prerequisites can be fulfilled by downloading and working the free tutorial "Production Java Tools".    

• Java - You should have a minimum of 1 year programming with Java.
• XML - Web Services and the configuration files for Axis require a reasonable knowledge of XML.  If you don't have this, it will slow you down quite a bit.
• XML Schema - Although not essential, understanding XML schema will help you to better understand how web services are described.
• * XML Editor - You should have installed and be familiar with an XML editor.  This should be an editor that at the very least insures that an XML document is well formed.
• * Ant -  We will be using Ant to build and deploy all the code that you'll write in this class.  You should have a working knowledge of how Ant works.
• * JUnit  - All the client code that created in the class is done in the form of Unit Tests.  You should have a working knowledge of Unit testing and JUnit.
• * Log4J -  We'll use Log4J at different points in the class.  You should understand what Log4J is and the basics of how it works.
• * Servlets -  Apache Axis is hosted inside of a servlet container.  We'll discuss servlets in the class, so a basic knowledge of their workings will be helpful.

Course Outline

    Pre-Class (material is emailed ahead of class)

• Install and test necessary tools
• Create a working HelloWorld application

    Class

• Review of pre-course material
• Introduction to Web Services
• W3C, WS-I, and OASIS
• Developing Web Services
• Create/Deploy HelloWorld Web Service
• Review of HelloWorld Web service
• Axis Architecture
• Axis Clients
• HelloWorld Web Service Client
• Using Axis Handlers
• Add Axis Logging Handler to the HelloWorld Web Service
• Axis Client side configuration
• Add client-config.wsdd to HelloWorld Web Service Client
• Add Axis Logging handler to HelloWorld WS client
• Pretty XML
• Enable Pretty XML on HelloWorld WS client and server
• SOAP History
• SOAP Message Structure
• Inventory Example and messages
• SOAP Encoding
• SOAP Styles
• RPC Literal
• Document Literal
• RPC Limitations
• Document Limitations
• Document/Literal - Wrapped
• Type and Encoding in Axis
• Style and Use Attributes in the service definition
• Investigate the SOAP messages for different encoding and styles using HelloWorld WS
• WSDL History
• WSDL Structure
• MyClass Service example
• WSDL types
• WSDL message(s)
• WSDL porttype
• WSDL binding
• WSDL service
• Investigate the WSDL for different encoding and styles using HelloWorld WS
• Writing and using a WSDL with Apache Axis
• Why understanding the WSDL is good
• The Inventory WSDL
• WSDL2Java - Generating skeleton code from a WSDL
• Hand code a WSDL for the StringUtilities Service
• Generate an Axis Skeleton for StringUtilities Service
• Implement StringUtilities truncate operation
• Build and deploy StringUtilities Service
• Test StringUtilities truncate operation
• Add and test StringUtilities concatenate
• Hosting your own WSDL/schemas using server-config.wsdd
• Hosting your own WSDL/schemas as part of the servlet distribution
• Host StringUtilities hand coded WSDL
• Why write a custom handler?
• How to write and deploy a custom handler
• Passing and retrieving custom handler parameters
• Accessing messages within a custom handler
• Create a simple Pizza Service and implement a custom handler
• Create a custom logger using Log4J
• Bare Minimum Service Definition
• The Service Definitions
• Web Service Data Types and their Java counterparts
• Create DataTypes Service for showing Java to WS Type mappings
• Arrays
• Add an Array to the Pizza Service
• Complex Types and Java Beans
• Extend the Pizza Service to use a Complex Type