深入教程：JAX-RS 2.0与RESTful Java实战

需积分: 10 38 浏览量更新于2024-07-19 收藏 4.77MB PDF 举报

"RESTful Java with JAX-RS 2.0, 2nd Edition, Bill Burke" 本书《RESTful Java with JAX-RS 2.0》第二版由Bill Burke撰写，深入介绍了JAX-RS 2.0，提供了一个详尽的教程，帮助读者理解和充分利用这个新的API，同时遵循RESTful架构风格。本书旨在让读者在享受阅读的同时，能够熟练地运用JAX-RS进行RESTful服务的开发。 JAX-RS（Java API for RESTful Web Services）是Java平台上的一个标准，用于创建RESTful Web服务。它提供了基于注解的方式来简化Web服务的开发，使得开发者可以快速构建符合REST原则的接口。RESTful设计模式强调了资源的表述状态转移，通过HTTP协议中的方法（如GET、POST、PUT、DELETE等）来操作资源。本书中，作者Bill Burke将引导读者探索以下关键知识点： 1. **REST基础**：理解REST的基本概念，包括资源、URI、HTTP方法、状态码以及编码类型，这是使用JAX-RS的前提。 2. **JAX-RS注解**：学习如何使用诸如`@Path`、`@GET`、`@POST`、`@Produces`和`@Consumes`等注解来定义服务端点和服务行为。 3. **数据交换格式**：了解JSON和XML这两种常见的数据交换格式，以及如何在JAX-RS中处理它们，包括使用`@XmlRootElement`和`@JsonProperty`等注解。 4. **客户端API**：掌握JAX-RS提供的客户端API，允许在Java代码中方便地调用REST服务。 5. **错误处理**：学习如何优雅地处理服务端和客户端可能出现的错误，包括自定义异常和错误响应。 6. **过滤器与拦截器**：理解如何使用过滤器（Filter）和拦截器（Interceptor）进行请求预处理和响应后处理，以实现认证、日志记录、性能监控等功能。 7. **安全与认证**：探讨RESTful服务的安全性，包括基本认证、OAuth2和其他安全策略的实现。 8. **容器集成**：了解如何在各种Java应用服务器（如GlassFish、WildFly等）中部署和运行JAX-RS应用。 9. **测试与调试**：学习如何对JAX-RS服务进行单元测试和集成测试，以及利用工具进行调试。 10. **最佳实践**：获取关于设计高效、可维护的RESTful服务的实用建议，确保服务符合REST原则。本书第二版还可能包含了自第一版以来JAX-RS 2.0的更新内容和新特性，以及作者根据社区反馈和实际开发经验所做的改进。对于任何希望深入学习和应用RESTful服务的Java开发者来说，这是一本不可或缺的参考资料。此外，O'Reilly Media出版的书籍通常具有高质量的编辑和生产过程，包括专业编辑、校对、索引编制和设计团队的支持，以确保内容准确性和阅读体验。读者可以通过在线版本（如Safari Books Online）访问大部分O'Reilly的书籍，获取最新的更新和修订信息。

methods. Annotations are also used to provide static metadata to create responses. JAX-

RS also provides more traditional classes and interfaces for dynamic access to request

data and for customizing responses.

Bill Burke led the development of one of the JAX-RS implementations mentioned earlier

(RESTEasy) and was an active and attentive member of the expert group. His contri‐

butions to expert group discussions are too numerous to list, but a few of the areas where

his input was instrumental include rules for annotation inheritance, use of regular ex‐

pressions for matching request URIs, annotation-driven support for cookies and form

data, and support for streamed output.

This book, RESTful Java with JAX-RS 2.0, provides an in-depth tutorial on JAX-RS and

shows how to get the most from this new API while adhering to the REST architectural

style. I hope you enjoy the book and working with JAX-RS.

—Marc Hadley

JAX-RS 1.0 Specification Lead

xiv | Foreword

Preface

Author’s Note

The bulk of my career has been spent working with and implementing distributed

middleware. In the mid-’90s I worked for the parent company of Open Environment

Corporation working on DCE tools. Later on, I worked for Iona, developing its next-

generation CORBA ORB. Currently, I work for the JBoss division of Red Hat, which is

entrenched in Java middleware, specifically Java EE. So, you could say that I have a pretty

rich perspective when it comes to middleware.

I must tell you that I was originally very skeptical of REST as a way of writing SOA

applications. It seemed way too simple and shortsighted, so I sort of blew it off for a

while. One day, though, back in mid-2007, I ran into my old Iona boss and mentor, Steve

Vinoski, while grabbing a sandwich at D’Angelo in Westford, Massachusetts, near Red

Hat’s offices. We ended up sitting down, having lunch, and talking for hours. The first

shocker for me was that Steve had left Iona to go work for a start-up. The second was

when he said, “Bill, I’ve abandoned CORBA and WS-* for REST.” For those of you who

don’t know Steve, he contributed heavily to the CORBA specification, wrote a book on

the subject (which is basically the CORBA bible), and is a giant in the distributed com‐

puting field, writing regularly for C++ Report and IEEE. How could the guy I looked

up to and who was responsible for my foundation in distributed computing abandon

CORBA, WS-*, and the distributed framework landscape he was instrumental in cre‐

ating? I felt a little betrayed and very unnerved. (OK, maybe I’m exaggerating a little…)

We ended up arguing for a few hours about which was better—WS-*/CORBA or REST.

This conversation spilled into many other lengthy email messages, with me trying to

promote WS-* and him defending REST. The funniest thing to me was that as I re‐

searched REST more and more I found that my arguments with Steve were just another

endless replay of debates that had been raging across the blogosphere for years. They

are still raging to this day.

It took months for me to change my mind and embrace REST. You would figure that

my distributed computing background was an asset, but it was not. DCE, CORBA,

WS-*, and Java EE were all baggage. All were an invisible barrier for me to accept REST

as a viable (and better) alternative for writing SOA applications. I think that’s what I

liked most about REST. It required me to rethink and reformulate the foundation of my

distributed computing knowledge. Hopefully your journey isn’t as difficult as mine and

you will be a little less stubborn and more open-minded than I was.

Who Should Read This Book

This book teaches you how to design and develop distributed web services in Java using

RESTful architectural principles on top of the HTTP protocol. It is mostly a compre‐

hensive reference guide on the JAX-RS specification, which is a JCP standardized an‐

notation framework for writing RESTful web services in Java.

While this book does go into many of the fundamentals of REST, it does not cover them

all and focuses more on implementation rather than theory. You can satisfy your craving

for more RESTful theory by obtaining RESTful Web Services by Leonard Richardson

and Sam Ruby (O’Reilly). If you are familiar with writing Java EE applications, you will

be very comfortable reading this book. If you are not, you will be at a disadvantage, but

some experience with web application development, HTTP, and XML is a huge plus.

Before reading this book, you should also be fairly fluent in the Java language and

specifically know how to use and apply Java annotations. If you are unfamiliar with the

Java language, I recommend Learning Java by Patrick Niemeyer and Jonathan Knudsen

(O’Reilly).

How This Book Is Organized

This book is organized into two parts: the technical manuscript, followed by the JAX-

RS workbook. The technical manuscript explains what REST and JAX-RS are, how they

work, and when to use them. The JAX-RS workbook provides step-by-step instructions

for installing, configuring, and running the JAX-RS examples from the manuscript with

the JBoss RESTEasy framework, an implementation of JAX-RS.

Part I, REST and the JAX-RS Standard

Part I starts off with a brief introduction to REST and HTTP. It then guides you through

the basics of the JAX-RS specification, and then in later chapters shows how you can

apply JAX-RS to build RESTful web services:

Chapter 1, Introduction to REST

This chapter gives you a brief introduction to REST and HTTP.

xvi | Preface

Chapter 2, Designing RESTful Services

This chapter walks you through the design of a distributed RESTful interface for an

ecommerce order entry system. For the second edition, this chapter has been revised

to include a simple client using the new JAX-RS 2.0 Client API.

Chapter 3, Your First JAX-RS Service

This chapter walks you through the development of a RESTful web service written

in Java as a JAX-RS service.

Chapter 4, HTTP Method and URI Matching

This chapter defines how HTTP requests are dispatched in JAX-RS and how you

can use the @Path annotation and subresources. For the second edition, I talk about

some of the ambiguities of the request matching algorithm.

Chapter 5, JAX-RS Injection

This chapter walks you through various annotations that allow you to extract in‐

formation from an HTTP request (URI parameters, headers, query parameters,

form data, cookies, matrix parameters, encoding, and defining default values). For

the second edition, this chapter has been revised to include the new @BeanParam

and ParamConverter features introduced in JAX-RS 2.0.

Chapter 6, JAX-RS Content Handlers

This chapter explains how to marshal HTTP message bodies to and from Java ob‐

jects using built-in handlers or writing your own custom marshallers.

Chapter 7, Server Responses and Exception Handling

This chapter walks through the JAX-RS Response object and how you use it to

return complex responses to your client (ResponseBuilder). It also explains how

exception and error handling work in JAX-RS. This chapter has been revised a little

bit to talk about the new exception hierarchy that was added in JAX-RS 2.0.

Chapter 8, JAX-RS Client API

This chapter is new to the second edition and describes in detail the new Client API

added to JAX-RS 2.0.

Chapter 9, HTTP Content Negotiation

This chapter explains how HTTP content negotiation works, its relationship to

JAX-RS, and how you can leverage this within RESTful architectures.

Chapter 10, HATEOAS

This chapter dives into Hypermedia As The Engine Of Application State

(HATEOAS) and how it relates to JAX-RS (UriInfo and UriBuilder). This chapter

has been revised for the second edition to include additions to the UriBuilder API

and the new classes for building links.

Preface | xvii

Chapter 11, Scaling JAX-RS Applications

This chapter explains how you can increase the performance of your services by

leveraging HTTP caching protocols. It also shows you how to manage concurrency

conflicts in high-volume sites.

Chapter 12, Filters and Interceptors

This chapter is new to the second edition. It talks about the new filter and interceptor

APIs added to JAX-RS 2.0 and how you can use them to write extensions to

JAX-RS.

Chapter 13, Asynchronous JAX-RS

This is a new chapter for the second edition. It walks you through the new server-

and client-side asynchronous interfaces available in JAX-RS 2.0.

Chapter 14, Deployment and Integration

This chapter explains how you can deploy and integrate your JAX-RS services

within Java Enterprise Edition, servlet containers, EJB, Spring, and JPA. It has been

revised in the second edition.

Chapter 15, Securing JAX-RS

This chapter walks you through the most popular mechanisms to perform authen‐

tication on the Web. It then shows you how to implement secure applications with

JAX-RS. It has been revised in the second edition to walk you through configuring

client-side SSL and also now includes an introduction to OAuth 2.0. I also talk about

JSON Web Signatures and encryption.

Chapter 16, Alternative Java Clients

This chapter talks about alternative Java clients you can use to communicate with

RESTful services (java.net.URL, Apache HTTP Client, and RESTEasy Proxy).

Part II, JAX-RS Workbook

The JAX-RS workbook shows you how to execute examples from chapters in the book

that include at least one significant example. You’ll want to read the introduction to the

workbook to set up RESTEasy and configure it for the examples. After that, just go to

the workbook chapter that matches the chapter you’re reading. For example, if you are

reading Chapter 3 on writing your first JAX-RS service, use Chapter 18 of the workbook

to develop and run the examples with RESTEasy.

Conventions Used in This Book

The following typographical conventions are used in this book:

Italic

Indicates new terms, URLs, email addresses, filenames, and file extensions.

xviii | Preface

剩余391页未读，继续阅读

litianren01

粉丝: 0
资源: 11

深入教程：JAX-RS 2.0与RESTful Java实战

RESTful Java with JAX-RS 2.0

RESTful Java with JAX-RS 2.0 无水印pdf

[Jax-RS] RESTful Java 开发 (Jax-RS 2.0 实现) (英文版)

Apache CXF 3.0：JAX-RS 2.0和Bean验证1.1最终一起

有REST API的书籍推荐吗

javaweb外文文献

class doesn't contain any jax-rs annotated methods

restfulapi中jax-rx的具体运用

jax-rs和restful

什么是JAX-RS？

最新资源