使用JAX-RS 2.0构建RESTful Java应用

5星 · 超过95%的资源需积分: 10 178 浏览量更新于2024-07-24 7 收藏 7.12MB PDF 举报

"RESTful Java with JAX-RS 2.0" 本书《RESTful Java with JAX-RS 2.0》由Bill Burke撰写，详细介绍了如何使用Java API for RESTful Web Services (JAX-RS) 2.0标准来构建符合REST（Representational State Transfer）原则的Web服务。RESTful架构风格已经成为现代Web应用程序开发中的主流选择，它强调通过简单的HTTP协议进行资源的交互。JAX-RS是Java平台上的一个规范，它提供了一种简化RESTful服务开发的方法。 JAX-RS 2.0是该规范的一个重要版本，它在JAX-RS 1.1的基础上引入了许多新特性，提高了开发者的生产力和API的灵活性。以下是一些核心知识点： 1. **资源与URI**：RESTful服务的核心是资源，每个资源都有一个唯一的URI。JAX-RS 2.0允许开发者通过注解如`@Path`来定义资源的URI路径。 2. **HTTP方法映射**：JAX-RS支持HTTP方法（GET、POST、PUT、DELETE等），开发者可以使用`@GET`、`@POST`等注解将方法与HTTP操作关联起来。 3. **参数绑定**：JAX-RS提供了多种方式接收请求参数，包括查询参数、路径参数、头部参数、请求体和多部分数据。例如，`@QueryParam`用于获取URL查询参数，`@PathParam`用于从URI路径中提取值。 4. **内容协商**：通过`@Consumes`和`@Produces`注解，开发者可以声明资源能处理的输入媒体类型和返回的输出媒体类型，支持多种格式如JSON、XML、文本等。 5. **异常处理**：JAX-RS允许自定义错误处理，通过`@Provider`和`@ExceptionMapper`注解，可以将Java异常映射到HTTP响应状态码。 6. **客户端API**：JAX-RS 2.0提供了一个强大的客户端API，允许开发者像调用本地方法一样调用远程RESTful服务，简化了客户端开发。 7. **依赖注入**：结合Java EE的CDI (Contexts and Dependency Injection) 或其他依赖注入框架，JAX-RS支持注入服务和其他组件，提高代码的可测试性和可维护性。 8. **异步处理**：JAX-RS 2.0引入了异步处理能力，允许开发者处理非阻塞I/O，以适应高并发场景。 9. **安全与认证**：JAX-RS可以通过集成如OAuth、JWT等安全机制，实现身份验证和授权。 10. **聚合与分页**：使用`@Link`注解可以实现HATEOAS（超媒体作为应用状态引擎），帮助客户端发现和导航资源。分页可以通过返回包含链接到下一页或上一页的响应来实现。《RESTful Java with JAX-RS 2.0》这本书深入浅出地讲解了如何利用JAX-RS 2.0规范构建高效、灵活的RESTful服务，并提供了丰富的示例和最佳实践，是Java开发者学习RESTful服务开发的重要参考资料。

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页未读，继续阅读

Laurence

粉丝: 6441
资源: 94

使用JAX-RS 2.0构建RESTful Java应用

JAX-RS和spring的整合开发

Jax-RS所需要的依赖jar

[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？

jax-rs和restful

最新资源