Read an Excerpt
Java became a powerful development platform for Service-Oriented Architecture (SOA) in 2006. Java EE 5, released in May 2006, significantly enhanced the power and usability of the Web Services capabilities on the application server. Then Java SE 6, released in December 2006, incorporated the majority of those capabilities into the standard edition of the Java programming language.
Because robust Web Services technology is the foundation for implementing SOA, Java now provides the tools modern enterprises require to integrate their Java applications into SOA infrastructures.
Of course, Java has had basic Web Services capabilities for some time. JAX-RPC 1.0 was released in June 2002. J2EE 1.4, finalized in November 2003, included JAX-RPC 1.1. So what is significant about the latest versions of the Java Web Services (JWS) APIs?
The answers are power and ease of use. Programmers will find it much easier to build enterprise-class applications with Web Services in Java EE 5 than in J2EE 1.4. Evidence of that is contained in Chapters 9 and 10, which describe an application I developed to integrate online shopping across eBay, Yahoo! Shopping, and Amazon. It’s a pure Java EE 5 application, called SOAShopper, that consumes REST and SOAP services from those shopping sites. SOAShopper also provides its own SOAP and REST endpoints for cross-platform search, and supports an Ajax front-end. SOAShopper would have been a struggle to develop using J2EE 1.4 and JAX-RPC. With the new Java Web Services standards, it was a pleasure to write.
This book focuses on the following standards comprising the new Java Web Services:
- JAX-WS 2.0 JSR 224—The Java API for
- JAXB2.0 JSR 222—The Java Architecture for
- WS-Metadata JSR 181—Web Services Metadata for the Java Platform. WS-Metadata provides annotations that facilitate the flexible definition and deployment of Java Web Services.
- WSEE 1.2 JSR 109—Web Services for Java EE. WSEE defines the programming model and run-time behavior of Web Services in the Java EE container.
These standards contain a few big improvements and many little enhancements that add up to a significantly more powerful Web Services programming platform. New annotations, for example, make it easier to write Web Services applications. And the delegation, in JAX-WS 2.0 JSR 224, of the Java/
Chapters 1 and 2 review these JWS standards in detail and describe how they improve on the previous set of JWS standards. Chapters 3 through 10 focus on writing code. To really understand the power and ease of use of the new Java Web Services, you need to start writing code. And that is primarily what this book is about. Chapters 3 through 10 are packed with code examples showing you how to best take advantage of the powerful features, avoid some of the pitfalls, and work around some of the limitations.
Chapter 11 looks to the future and offers some ideas, along with a prototype implementation, for a WSDL-centric approach to creating Web Services that might further improve JWS as a platform for Service-Oriented Architecture.
I started writing this book in 2002, when JAX-RPC first appeared on the scene. I soon ran into trouble, though, because I wanted it to be a book for programmers and I had a hard time writing good sample code with JAX-RPC. Four years later, when I started playing around with beta versions of the GlassFish Java EE 5 application server, I noticed that things had significantly improved. It was now fun to program Web Services in Java and I recommitted myself to finishing this book.
The result is a book with lots of code showing you how to deal with SOAP, WSDL, and REST from inside the Java programming language. Hopefully this code, and the writing that goes with it, will help you master Java Web Services and enable you to start using Java as a powerful platform for SOA.About This BookAn Unbiased Guide to Java Web Services for SOA
My primary goal in this book is to offer an unbiased guide to using the Java Web Services (JWS) standards for SOA. Of course, any author has a bias, and I admit to believing that the JWS standards are quite good. Otherwise, I would not have written this book.
Having admitted my bias, I also freely admit that JWS has weaknesses, particularly when it comes to the development approach known as Start from WSDL and Java. As you will see described in many different ways in this book, the JWS standards present a Java-centric approach to Web Services. That approach can be troublesome when you need to work with established SOA standards and map your Java application to existing
In such situations, it’s helpful to be able to take a WSDL-centric approach to Web Services development. In this area, JWS is less strong. Throughout the book, I point out those shortcomings, and offer strategies you can use to overcome them. Chapter 11 even offers a prototype framework, called SOA-J, that illustrates an alternative, WSDL-centric approach to Java Web Services.Written for Java Developers and Architects
This is a book for people who are interested in code—primarily the developers who write systems and the architects who design them. There are a lot of coding examples you can download, install, and run.
Being a book for Java programmers working with Web Services, the discussion and examples provided within assume you have a working knowledge of Java and a basic understanding of
Knowledge of J2SE 5.0 Is Assumed
This book assumes you have a basic understanding of J2SE 5.0—particularly the Java language extensions generics and annotations. If you are not familiar with generics or annotations, you can learn all you need to know from the free documentation and tutorials available at http://java.sun.com.
Don’t be intimidated by these topics. Generics and annotations are not hard to master—and you need to understand them if you are going to do Web Services with Java EE 5 and Java SE 6. The reason I have not written an introduction to generics and annotations as part of this book is that there is so much good, free information available on the Web. My focus in this book is to go beyond what is freely available in the online tutorials and documentation.Why GlassFish?
All the code examples presented in this book have been developed and tested using the GlassFish GLASSFISH open source Java EE 5 reference implementation. At the time I wrote this, it was the only implementation available. Now that the book is going to press, there are more, and the code should run on all these platforms without change. The only changes that will need to be made have to do with the build process where GlassFish specific tools (e.g., the wsimport WSDL to Java compiler, the asadmin deployment utility) are used.
I plan to test the example code on other platforms as they become available and to post instructions for running them on JBoss, BEA, IBM, and so on, as these vendors support the JWS standards. Check the book’s forthcoming Web site (http://soabook.com) for updates on progress with other platforms.
If you haven’t tried GlassFish, I suggest you check it out at https://glassfish.dev.java.net. It supports the cutting edge in Java EE and the community is terrific. In particular, I’ve had good experiences getting technical support on the mailing lists. It’s not uncommon to post a question there and have one of the JSR specification leads respond with an answer within minutes!Why Some Topics Aren’t Covered
Both SOA and Web Services are vast topics. Even when restricting the discussion to Java technology, it is impossible to cover everything in one book. Faced with that reality, I decided to focus on what I consider to be the core issues that are important to Java developers and architects. The core issues involve creating, deploying, and invoking Web Services in a manner that enables them to be composed into loosely coupled SOA applications.
In narrowing the book’s focus, it is inevitable that I will have disappointed some readers because a particular topic of interest to them isn’t covered. Some of these topics, pointed out by my reviewers, are listed here, along with the reasons why I didn’t include them.SOA Design Principles
This is not a book that covers the concepts and design philosophy behind SOA. It is a how-to book that teaches Java developers to code SOA components using Java Web Services. For a thorough introduction to SOA concepts and design, I recommend Thomas Erl’s Service-Oriented Architecture Erl.UDDI
UDDI is very important. And Java EE 5 includes the JAX-R standard interface to UDDI repositories. But JAX-R hasn’t changed since J2EE 1.4. And it is covered well in many other books and online tutorials. So, in an effort to keep this book to a manageable size, I have left it out. Enterprise Messaging
I wish I could have included a chapter on Enterprise Messaging. After all, it is a cornerstone of SOA. However, this book restricts itself to the capabilities provided by JWS. JWS does not support WS-Reliable Messaging WS-RM or any other SOAP/WSDL-oriented reliable messaging mechanism. Of course, Java EE 5 includes support for the Java Message Service API (JMS). And JMS is a useful tool for implementing SOA applications. But by itself, JMS isn’t a Web Services tool. So, in the interest of focus, I have left it out.WS-Addressing, WS-Security, and the Many Other WS-* Standards
Explaining the myriad standards for the Web Services stack would require many thousands of pages. Since these WS-* standards are not yet part of JWS, I have not covered them. In addition, my sense is that most Java developers are still mastering SOAP over HTTP. The need for a programmer’s guide to WS-* is probably several years away.Fonts and Special Characters
Courier font is used for Java types,
Italics indicate that a term is defined in the glossary. I don’t always use italics—only when a term may not have been used before and I think the reader might want to know it is defined in the Glossary. Italics are also used for emphasis. < > indicates an environment-specific directory location. Code Fragments in Text
The text contains lots of code fragments to illustrate the discussion. At the bottom of each code fragment is the file path showing where it came from. Moreover, there are line numbers to show you the line number in the file where the code comes from.
