Java Web服务：构建与运行（影印版）

.what good is a wsdl?
generating client-support code from a wsdl
the @webresult annotation
wsdl structure
a closer look at wsdl bindings
key features of document-style services
validating a soap message against a wsdl’s xml schema
the wrapped and unwrapped document styles
amazon’s e-commerce web service
an e-commerce client in wrapped style
an e-commerce client in unwrapped style
tradeoffs between the rpc and document styles
an asynchronous e-commerce client
the wsgen utility and jax-b artifacts
a jax-b example
marshaling and wsgen artifacts
an overview of java types and xml schema types
generating a wsdl with the wsgen utility
wsdl wrap-up
code first versus contract first
a contract-first example with wsimport
a code-first, contract-aware approach
limitations of the wsdl
what’s next?
3. soap handling
soap: hidden or not?
soap 1.1 and soap 1.2
soap messaging architecture
programming in the jws handler framework
the rabbitcounter example
injecting a header block into a soap header
configuring the client-side soap handler
adding a handler programmatically on the client side
generating a fault from a @webmethod
adding a logical handler for client robustness
adding a service-side soap handler
summary of the handler methods
the rabbitcounter as a soap 1.2 service
the messagecontext and transport headers
an example to illustrate transport-level access
web services and binary data
three options for soap attachments
using base64 encoding for binary data
using mtom for binary data
what’s next?
4. restful web services
what is rest?
verbs and opaque nouns
from @webservice to @webserviceprovider
a restful version of the teams service
the webserviceprovider annotation
language transparency and restful services
summary of the restful features
implementing the remaining crud operations
java api for xml processing
the provider and dispatch twins
a provider/dispatch example
more on the dispatch interface
a dispatch client against a soap-based service
implementing restful web services as httpservlets
the rabbitcounterservlet
requests for mime-typed responses
java clients against real-world restful services
the yahoo! news service
the amazon e-commerce service: rest style
the restful tumblr service
wadling with java-based restful services
jax-rs: wadling through jersey
the restlet framework
what’s next?
5. web services security
overview of web services security
wire-level security
https basics
symmetric and asymmetric encryption/decryption
how https provides the three security services
the httpsurlconnection class
securing the rabbitcounter service
adding user authentication
http basic authentication
container-managed security for web services
deploying a @webservice under tomcat
securing the @webservice under tomcat
application-managed authentication
container-managed authentication and authorization
configuring container-managed security under tomcat
using a digested password instead of a password
a secured @webserviceprovider
ws-security
securing a @webservice with ws-security under endpoint
the prompter and the verifier
the secured soap envelope
summary of the ws-security example
what’s next?
6. jax-ws in java application servers
overview of a java application server
deploying @webservices and @webserviceproviders
deploying @webserviceproviders
integrating an interactive website and a web service
a @webservice as an ejb
implementation as a stateless session ejb
the endpoint url for an ebj-based service
database support through an @entity
the persistence configuration file
the ejb deployment descriptor
servlet and ejb implementations of web services
java web services and java message service
ws-security under glassfish
mutual challenge with digital certificates
mcs under https
mcs under wsit
the dramatic soap envelopes
benefits of jas deployment
what’s next?
7. beyond the flame wars
a very short history of web services
the service contract in dce/rpc
xml-rpc
standardized soap
soap-based web services versus distributed objects
soap and rest in harmony
index

.　　Chapter 2, All About WSDLs
　　This chapter focuses on the service contract, which is a WSDL (Web Service Def- inition Language) document in SOAP-based services. This chapter covers the standard issues of web service style (document versus rpc) and encoding (literal versus encoded). This chapter also focuses on the popular but unofficial distinction between the wrapped and unwrapped variations of document style. All of these issues are clarified through examples, including Java clients against Amazon's E-Commerce services. This chapter explains how the wsimport utility can ease the task of writing Java clients against commercial web services and how the wsgen utility figures in the distinction between document-style and rpc-style web services. The basics of JAX-B (Java APl for XML-Binding) are also covered. This chapter, like the others, is rich in code examples.
　　Chapter 3, SOAP Handling
　　This chapter introduces SOAP and logical handlers, which give the service-side and client-side programmer direct access to either the entire SOAP message or just its payload. The structure of a SOAP message and the distinction between SOAP 1.1 and SOAP 1.2 are covered. The messaging architecture of a SOAP-based service is discussed. Various code examples illustrate how SOAP messages can be processed in support of application logic. This chapter also explains how transport- level messages (for instance, the typical HTTP messages that carry SOAP payloads in SOAP-based web services) can be accessed and manipulated in JAX-WS. This chapter concludes with a section on JAX-WS support for transporting binary data, with emphasis on MTOM (Message Transmission Op- timization Mechanism).
　　Chapter 4, RESTful Web Services
　　This chapter opens with a technical analysis of what constitutes a REST-style serv- ice and moves quickly to code examples. The chapter surveys various approaches to delivering a Java-based RESTful service: WebServiceProvider, HttpServlet, Jer- sey Plain Old Java Object (POJO), and restlet among them. The use of a WADL (Web Application Definition Language) document as a service contract is explored through code examples. The JAX-P (Java API for XML-Processing) packages, which facilitate XML processing, are also covered. This chapter offers several ex- amples of Java clients against real-world REST-style services, including services hosted by Yahoo!, Amazon, and Tumblr. Chapter 5, Web Services Security
　　This chapter begins with an overview of security requirements for real-world web services, SOAP-based and REST-style. The overview covers central topics such as mutual challenge and message confidentiality, users-roles security, and WS-Security. Code examples clarify transport-level security, particularly under HTTPS. Container-managed security is introduced with examples deployed in the standalone Tomcat web container. The security material introduced in this chapter is expanded in the next chapter. Chapter 6, JAX-WS in Java Application Servers
　　This chapter starts with a survey of what comes with a Java Application Server (JAS): an EJB container, a messaging system, a naming service, an integrated database system, and so on. This chapter has a variety of code examples: a SOAP-based service implemented as a stateless Session EJB, WebService and WebServiceProvider instances deployed through embedded Tomcat, a web service deployed together with a traditional website application, a web service integrated withJMS (Java Message Service), a web service that uses an Entity to read and write from the Java DB database system included in GlassFish, and a WS-Security application under GlassFish. Chapter 7, Beyond the Flame Wars
　　This is a very short chapter that looks at the controversy surrounding SOAP-based and REST-style web services. My aim is to endorse both approaches, either of which is superior to what came before. This chapter traces modem web services from DCE/RPC in the early 1990s through CORBA and DCOM up to the Java EE and .NET frameworks. This chapter explains why either approach to web services is better than the distributed-object architecture that once dominated in distributed software systems.
　　Freedom of Choice: The Tools/IDE Issue
　　Java programmers have a wide choice of productivity tools such as Ant and Maven for scripting and IDEs such as Eclipse, NetBeans, and IntelliJ IDEA. Scripting tools and IDEs increase productivity by hiding grimy details. In a production environment, such tools and IDEs are the sensible way to go. In a learning environment, however, the goal is to understand the grimy details so that this understanding can be brought to good use during the inevitable bouts of debugging and application maintenance. Accord- ingly, my book is neutral with respect to scripting tools and IDEs. Please feel free to use whichever tools and IDE suit your needs. My how-to segments go over code com- pilation, deployment, and execution at the command line so that details such as class- path inclusions and compilation/execution flags are clear. Nothing in any example depends on a particular scripting tool or IDE.
　　Conventions Used in This Book
　　The following typographical conventions are used in this book:
　　Italic
　　Indicates new terms, URLs, filenames, file extensions, and emphasis.
　　Constant width
　　Used for program listings as well as within paragraphs to refer to program elements such as variable or method names, data types, environment variables, statements, and keywords.
　　Constant width bold
　　Used within program listings to highlight particularly interesting sections and in paragraphs to clarify acronyms.
　　This icon signifies a tip, suggestion, or general note.
　　Using Code Examples
　　This book is here to help you get your job done. In general, you may use the code in this book in your programs and documentation. You do not need to contact us for permission unless you're reproducing a significant portion of the code. For example, writing a program that uses several chunks of code from this book does not require permission. Selling or distributing a CD-ROM of examples from O'Reilly books does require permission. Answering a question by citing this book and quoting example code does not require permission. Incorporating a significant amount of example code from this book into your product's documentation does require permission.
　　We appreciate, but do not require, attribution. An attribution usually includes the title, author, publisher, and ISBN. For example: "Java Web Services: Up and Running, by Martin Kalin. Copyright 2009 Martin Kalin, 978-0-596-52112-7."
　　If you feel your use of code examples falls outside fair use or the permission given above, feel free to contact us at permissions@oreilly, com.
　　Safari Books Online
　　When you see a Safari Books Online icon on the cover of your favorite technology book, that means the book is available online through the O'Reilly Network Safari Bookshelf.
　　Safari offers a solution that's better than e-books. It's a virtual library that lets you easily search thousands of top tech books, cut and paste code samples, download chapters, and find quick answers when you need the most accurate, current information. Try it for free at http://safari.oreilly.com.
　　How to Contact Us
　　Please address comments and questions concerning this book to the publisher:
　　O'Reilly Media, Inc.
　　1005 Gravenstein Highway North
　　Sebastopol, CA 95472
　　800-998-9938 (in the United States or Canada)
　　707-829-0515 (international or local)
　　707-829-0104 (fax)
　　We have a web page for this book, where we list errata, examples, and any additional information. You can access this page at:
　　http://www.oreilly.com/catalog/9780596521127/
　　To comment or ask technical questions about this book, send email to:
　　bookquestions@oreilly, com
　　For more information about our books, conferences, Resource Centers, and the O'Reilly Network, see our website at:
　　http://www.oreilly.com/
　　Acknowledgments
　　Christian A. Kenyeres, Greg Ostravich, Igor Polevoy, and Ken Yu were kind enough to review this book and to offer insightful suggestions for its improvement. They made the book better than it otherwise would have been. I thank them heartily for the time and effort that they invested in this project. The remaining shortcomings are mine alone, of course.
　　I'd also like to thank Mike Loukides, my first contact at O'Reilly Media, for his role in shepherding my initial proposal through the process that led to its acceptance. Julie Steele, my editor, has provided invaluable support and the book would not be without her help. My thanks go as well to the many behind-the-scenes people at O'Reilly Media who worked on this project.
　　This book is dedicated to Janet.