JAX-RS 2.0 REST客户端编程实例

最新推荐文章于 2023-12-25 00:12:08 发布
最新推荐文章于 2023-12-25 00:12:08 发布
阅读量2.6k 收藏
点赞数
分类专栏： RESTful 文章标签： rest RESTFUL JAX-RS

导读

JAX-RS 2.0 又称 JSR 339 不仅定义了一套用于构建 RESTful 网络服务的 API，同时也通过增强客户端 API 功能简化了REST 客户端的构建过程。

JAX-RS: Java API for RESTful Web Services是一个Java编程语言的应用程序接口,支持按照 表象化状态转变 (REST)架构风格创建Web服务Web服务[1]. JAX-RS使用了Java SE 5引入的Java 标注来简化Web服务客户端和服务端的开发和部署 [wikipedia]。

在下面的教程中，我们将为一个预先设置好的 REST 服务构建一个客户端，并在这个过程中探索新的构建选项。例如，如何处理同步或者异步的请求，如何给一个请求注册一个回调，如何指定调用对象来构建一个请求使得请求可以被延迟执行。再或者比如，如何使用客户端请求和相应的过滤方法来过滤客户端与服务器之前的通信。

我们开始吧

对于想要重建下述客户端例子的读者，我已经使用 Maven 创建好了一个完整的 RESTful 网络服务程序。程序中有内嵌的应用程序服务器，以及一个可独立运行的应用服务器 （war-file 可以通过下文中的下载地址获取）。

请根据下面的一系列命令来下载并启动 REST 服务器 （下载所有依赖可能会耗费些时间……）：

1
clone https: //bitbucket .org /hascode/jaxrs2-client-tutorial .git && cd jaxrs2-client-tutorial && make rest-server

现在，让我们先来看看这个 REST 服务的一些实现细节和我们的客户端示例中要用到的对象。如果你对这些没什么兴趣，大可以略过服务端的细节直接去看客户端示例。

REST 服务

下面的代码就是个客户端提供服务的 REST 服务。这里的 BookRepository 就是一个由 @Singleton 和 @Startup 修饰的简单 session bean，这个 bean 用来模拟存储或获取 Book Entity。服务对外提供了保存一本书、删除一本书、根据标识查找书籍和获取所有可用书籍的接口。当一本书被保存在服务端时，服务器会为该书生成一个 id，并会返回一个 entity 或一组 entity 的 JSON 数据。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
package com.hascode.tutorial.jaxrs.server;
 
import java.util.List;
 
import javax.ejb.EJB;
import javax.ejb.Stateless;
import javax.ws.rs.Consumes;
import javax.ws.rs.DELETE;
import javax.ws.rs.GET;
import javax.ws.rs.POST;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;
import javax.ws.rs.core.GenericEntity;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Response;
 
import com.hascode.tutorial.jaxrs.entity.Book;
 
@Stateless
@Path ( "/book" )
public class BookStoreService {
     @EJB
     private BookRepository bookRepository;
 
     @POST
     @Consumes (MediaType.APPLICATION_JSON)
     @Produces (MediaType.APPLICATION_JSON)
     public Response saveBook( final Book book) {
         Book bookPersisted = bookRepository.saveBook(book);
         return Response.ok(bookPersisted).build();
     }
 
     @DELETE
     @Path ( "/{id}" )
     public Response deleteBook( final @PathParam ( "id" ) String id) {
         bookRepository.deleteBook(id);
         return Response.ok().build();
     }
 
     @GET
     @Produces (MediaType.APPLICATION_JSON)
     public Response getAll() {
         List<Book> books = bookRepository.getAll();
         GenericEntity<List<Book>> bookWrapper = new GenericEntity<List<Book>>(books) {};
         return Response.ok(bookWrapper).build();
     }
 
     @GET
     @Path ( "/{id}" )
     @Produces (MediaType.APPLICATION_JSON)
     public Response getById( final @PathParam ( "id" ) String id) {
         Book book = bookRepository.getById(id);
         return Response.ok(book).build();
     }
}

备注：我修改了应用服务器，以便使用 Jackson 提供的服务发现机制处理 JSON 数据。

Book Entity

下面代码中的 bean 就是贯穿本教程的 Book Entity，它包含id、书名、价格和出版日期属性。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package com.hascode.tutorial.jaxrs.entity;
 
import java.io.Serializable;
import java.math.BigDecimal;
import java.util.Calendar;
 
public class Book implements Serializable {
     private static final long serialVersionUID = 1L;
 
     private String id;
     private String title;
     private BigDecimal price;
     private Calendar published;
 
     // getter+setter..
}

创建并绑定一个客户端

我们可以创建一个 REST 客户端，将其绑定到一个特定的目标 URL 上。并且为它指定专属的、参数化的路径。具体步骤如下：

  • 通过 ClientBuilder 获取一个客户端的引用：Client client = ClientBuilder.newClient();
  • 使用 target() 方法将客户端绑定到 REST 服务上提供的某个 URL：client.target(“http://localhost:8080/myrestservice”);
  • 通过 path() 和 resolveTemplate() 方法来处理动态的 URL 路径参数：client.target(..).path(“{id}”).resolveTemplate(“id”, someId);
  • 使用 request() 函数来初始化一个请求并用后续的 post 或者 get 等方法来指定请求的类型，例如：client.target(..).request().get();
  • 每一步都提供了多样的可选择的参数和配置选项，稍后的教程中我将用到其中的一些配置像异步请求、回调处理、还有过滤器注册和特性类等。

现在，让我们先看一些具备说明性的例子。

客户端例子

由于我把所有客户端示例都融进了 jUnit 和 Hamcrest 驱动的测试用例，因此下面的代码实际上在每一个测试用例中都有使用。不过为了让文章尽量简练，重复代码将在后面的代码示例中省略。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
private static final String REST_SERVICE_URL = "http://localhost:8080/tutorial/rs/book" ;
 
private static final String TITLE = "One big book" ;
private static final BigDecimal PRICE = new BigDecimal( "20.0" );
private static final GregorianCalendar PUBLISHED = new GregorianCalendar(
         2013 , 12 , 24 );
 
Client client = ClientBuilder.newClient().register(JacksonFeature. class );
 
public Book mockBook() {
     Book book = new Book();
     book.setTitle(TITLE);
     book.setPrice(PRICE);
     book.setPublished(PUBLISHED);
     return book;
}

唯一值得注意的是，我在客户端运行时中加入了 Jackson 框架，因此可以通过 javax.ws.rs.client.ClientBuilder 来获取客户端实例。

Maven 整合

所有代码示例运行都需要用到下面依赖：

1
2
3
4
5
6
7
8
9
10
< dependency >
     < groupId >org.glassfish.jersey.core</ groupId >
     < artifactId >jersey-client</ artifactId >
     < version >2.5</ version >
</ dependency >
< dependency >
     < groupId >org.glassfish.jersey.media</ groupId >
     < artifactId >jersey-media-json-jackson</ artifactId >
     < version >2.5</ version >
</ dependency >

基础操作

下面的示例中我们首先将一个书本实体的信息序列化成 JSON 格式，通过 POST 请求发送到服务端来保存这本书。

之后，我们使用客户端提供的 path() 和 resolveTemplate() 方法通过匹配服务端返回值的协议来获取该本书的标识。

第三步， 我们获取所有可用图书的列表，并在最后删除掉刚才保存的那本书。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
@Test
public void crudExample() {
     // 1. Save a new book
     Book book = mockBook();
     Book bookPersisted = client
             .target(REST_SERVICE_URL)
             .request()
             .post(Entity.entity(book, MediaType.APPLICATION_JSON),
                     Book. class );
 
     String bookId = bookPersisted.getId();
     assertThat(bookId, notNullValue());
 
     // 2. Fetch book by id
     Book book2 = client.target(REST_SERVICE_URL).path( "/{bookId}" )
             .resolveTemplate( "bookId" , bookId).request().get(Book. class );
     assertThat(book2, notNullValue());
     assertThat(book2.getTitle(), equalTo(TITLE));
     assertThat(book2.getPrice(), equalTo(PRICE));
     assertThat(book2.getPublished().getTime(), equalTo(PUBLISHED.getTime()));
 
     // 3. Fetch all books
     GenericType<List<Book>> bookType = new GenericType<List<Book>>() {
     }; // generic type to wrap a generic list of books
     List<Book> books = client.target(REST_SERVICE_URL).request()
             .get(bookType);
     assertThat(books.size(), equalTo( 1 ));
 
     // 4. Delete a book
     client.target(REST_SERVICE_URL).path( "/{bookId}" )
             .resolveTemplate( "bookId" , bookId).request().delete();
     List<Book> books2 = client.target(REST_SERVICE_URL).request()
             .get(bookType);
     assertThat(books2.isEmpty(), equalTo( true ));
}

异步处理

只要给请求构造器加一个简单的 async() 方法，我们就可以使用 Java 的 Future API 提供的多种途径来异步地处理请求。

下面的例子中，我们在第一个请求中添加一本书，然后再删除它。最后获取所有可用图书的列表。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
@Test
public void asyncExample() throws Exception {
     Book book = mockBook();
 
     Future<Book> fb = client
             .target(REST_SERVICE_URL)
             .request()
             .async()
             .post(Entity.entity(book, MediaType.APPLICATION_JSON),
                     Book. class );
 
     Book bookPersisted = fb.get();
 
     String bookId = bookPersisted.getId();
     assertThat(bookId, notNullValue());
 
     client.target(REST_SERVICE_URL).path( "/{bookId}" )
             .resolveTemplate( "bookId" , bookId).request().async().delete()
             .get();
 
     Future<List<Book>> bookRequest = client.target(REST_SERVICE_URL)
             .request().async().get( new GenericType<List<Book>>() {
             });
     List<Book> books2 = bookRequest.get();
     assertThat(books2.isEmpty(), equalTo( true ));
}

发起回调

在客户端与服务器通信过程中，我们还有另一种方式可以对服务器的相应进行修改，那就是在请求中加入一个 InvocationCallback 回调处理。

可以看到，下面代码段中有着很多缩进那部分就是我们的回调函数了，这些回调可以打印保存成功的图书的完整信息，或者在出现错误的情况下则打印错误和堆栈信息。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
@Test
public void invocationCallbackExample() throws Exception {
     Book book = mockBook();
     client.target(REST_SERVICE_URL)
             .request()
             .async()
             .post(Entity.entity(book, MediaType.APPLICATION_JSON),
                     new InvocationCallback<Book>() {
                         @Override
                         public void completed( final Book bookPersisted) {
                             System.out.println( "book saved: "
                                     + bookPersisted);
                             assertThat(bookPersisted.getId(),
                                     notNullValue());
                         }
 
                         @Override
                         public void failed( final Throwable throwable) {
                             throwable.printStackTrace();
                         }
                     }).get();
 
     client.target(REST_SERVICE_URL).request().async()
             .get( new InvocationCallback<List<Book>>() {
                 @Override
                 public void completed( final List<Book> books) {
                     System.out.println(books.size() + " books received" );
                     assertThat(books.size(), greaterThanOrEqualTo( 1 ));
                 }
 
                 @Override
                 public void failed( final Throwable throwable) {
                     throwable.printStackTrace();
                 }
             }).get();
}

延迟调用 / 请求构建

通过 javax.ws.rs.client.Invocation 类，我们可以先构建一个请求而不用即时发送。这个请求可以是同步的, 也可以是异步的。

在下面的示例中，我们构建了两个调用但并不马上使用—— 一个请求用来保存图书，另一个请求则是获取所有可用的图书。然后，我们在后面调用时才使用这两个构建好的请求。

我们应当使用 invoke() 方法来同步地调用一个请求。当需要使用异步请求时，则需要用 submit() 方法——两种调用都会返回一个 javax.ws.rs.core.Response 对象。如果调用者在调用参数中给定了返回实体的类，则上述方法会返回该类。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
@Test
public void requestPreparationExample() throws Exception {
     Book book = mockBook();
     Invocation saveBook = client.target(REST_SERVICE_URL).request()
             .buildPost(Entity.entity(book, MediaType.APPLICATION_JSON));
     Invocation listBooks = client.target(REST_SERVICE_URL).request()
             .buildGet();
 
     Response response = saveBook.invoke();
     Book b1 = response.readEntity(Book. class );
 
     // alternative: Book b1 = saveBook.invoke(Book.class);
     assertThat(b1.getId(), notNullValue());
 
     // async invocation
     Future<List<Book>> b = listBooks.submit( new GenericType<List<Book>>() {
     });
     List<Book> books = b.get();
     assertThat(books.size(), greaterThanOrEqualTo( 2 ));
}

客户端请求过滤器

JAX-RS 允许我们使用请求过滤器来截获客户端发送到服务器的请求。

为了达成这个目标，只需要实现 javax.ws.rs.client.ClientRequestFilter 这个接口。当创建客户端时，使用客户端的 register() 方法将 ClientRequestFilter 的具体实现注册到客户端中。

javax.ws.rs.client.ClientRequestContext 对象将赋予访问信息请求足够的权限。

下面就是一个客户端请求过滤的例子。这个例子中，所有客户端发出的 POST 请求中如果包含书籍实体，则书籍价格都会被这个过滤器修改（虽然这不是一个好的实际示例）。对价格的修改则依据相应的税率。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
package com.hascode.tutorial.client;
 
import java.io.IOException;
import java.math.BigDecimal;
 
import javax.ws.rs.client.ClientRequestContext;
import javax.ws.rs.client.ClientRequestFilter;
 
import com.hascode.tutorial.jaxrs.entity.Book;
 
public class TaxAdjustmentFilter implements ClientRequestFilter {
     public static final BigDecimal TAX_RATE = new BigDecimal( "2.5" );
 
     @Override
     public void filter( final ClientRequestContext rc) throws IOException {
         String method = rc.getMethod();
         if ( "POST" .equals(method) && rc.hasEntity()) {
             Book book = (Book) rc.getEntity();
             BigDecimal priceWithTaxes = book.getPrice().multiply(TAX_RATE);
             book.setPrice(priceWithTaxes);
             rc.setEntity(book);
         }
     }
 
}

在我们的测试用例中，只要把这个过滤器注册到客户端上，随后就会看到：保存书籍时候，书本的价格就会根据税率进行的调整。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
@Test
public void clientRequestFilterExample() {
     Book book = mockBook();
 
     Client client = ClientBuilder.newClient()
             .register(JacksonFeature. class )
             .register(TaxAdjustmentFilter. class );
     Book bookPersisted = client
             .target(REST_SERVICE_URL)
             .request()
             .post(Entity.entity(book, MediaType.APPLICATION_JSON),
                     Book. class );
 
     String bookId = bookPersisted.getId();
     assertThat(bookId, notNullValue());
     assertThat(bookPersisted.getPrice(),
             equalTo(PRICE.multiply(TaxAdjustmentFilter.TAX_RATE)));
 
}

客户端响应过滤器

为了获得对服务器相应的控制，有一个十分类似的办法：客户端相应过滤器。

同样地，只要实现 javax.ws.rs.client.ClientResponseFilter 这个接口，就能够修改或者截获服务器返回的响应。

下面这个响应过滤器能够将一些 HTTP 响应头打印到标准输出（STDOUT）：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
package com.hascode.tutorial.client;
 
import java.io.IOException;
import java.util.List;
import java.util.Map.Entry;
 
import javax.ws.rs.client.ClientRequestContext;
import javax.ws.rs.client.ClientResponseContext;
import javax.ws.rs.client.ClientResponseFilter;
 
public class ClientResponseLoggingFilter implements ClientResponseFilter {
 
     @Override
     public void filter( final ClientRequestContext reqCtx,
             final ClientResponseContext resCtx) throws IOException {
         System.out.println( "status: " + resCtx.getStatus());
         System.out.println( "date: " + resCtx.getDate());
         System.out.println( "last-modified: " + resCtx.getLastModified());
         System.out.println( "location: " + resCtx.getLocation());
         System.out.println( "headers:" );
         for (Entry<String, List<String>> header : resCtx.getHeaders()
                 .entrySet()) {
             System.out.print( "\t" + header.getKey() + " :" );
             for (String value : header.getValue()) {
                 System.out.print(value + ", " );
             }
             System.out.print( "\n" );
         }
         System.out.println( "media-type: " + resCtx.getMediaType().getType());
     }
 
}

要使用这个过滤器，只需要把它注册到我们的客户端程序中：

1
2
3
4
5
6
7
8
9
10
11
12
@Test
public void clientResponseFilterExample() {
     Book book = mockBook();
 
     Client client = ClientBuilder.newClient()
             .register(JacksonFeature. class )
             .register(ClientResponseLoggingFilter. class );
     client.target(REST_SERVICE_URL)
             .request()
             .post(Entity.entity(book, MediaType.APPLICATION_JSON),
                     Book. class );
}

使用内嵌的 GlassFish 服务，POST 请求将有如下结果：

1
2
3
4
5
6
7
8
9
10
11
status: 200
date : Sat Dec 28 18:50:16 CET 2013
last-modified: null
location: null
headers:
  Date :Sat, 28 Dec 2013 17:50:16 GMT,
  Transfer-Encoding :chunked,
  Content-Type :application /json ,
  Server :GlassFish Server Open Source Edition 3.1,
  X-Powered-By :Servlet /3 .0 JSP /2 .2 (GlassFish Server Open Source Edition 3.1 Java /Oracle Corporation /1 .7),
media- type : application

译注：GlassFish是SUN所研发的开放源代码应用服务器，GlassFish以Java编写以增加跨平台性[wikipedia]。

教程源码

欢迎下载本教程中的源码，你可以用 Git 来 Fork 或者直接 Clone：Bitbucket代码仓库。

下载 war-File REST 服务器

你可以从这里下载 war-file 然后运行自己的 RESTful 服务：https://bitbucket.org/hascode/jaxrs2-client-tutorial/downloads

JAX-RS 1.0 and JAX-B

如果你对旧版本的协议感兴趣，这篇文章正是你需要的。

原文链接：  hascode  翻译：  ImportNew.com  -  靳禹
译文链接：  http://www.importnew.com/8939.html
zheng963
关注
专栏目录
sample-jaxrs:一个示例JAX-RS应用程序
03-20
一个不太简单的JAX-RS示例 用法 查看完整的样本集 编译，打包和运行集成测试（验证）。启动REST服务器。 git clone \ https://github.com/emmanuelbruno/cours-java-librarymanager-rest.git mvn clean verify && \ mvn exec:java 取得你好消息 curl -s -D - http://localhost:9998/myapp/biblio 用两位作者初始化数据库 curl -s -D - -X PUT " http://localhost:9998/myapp/biblio/init " 获取JSON中的作者1 curl -s -D - -H " Accept: application/json " \ http://localhost:9998/myapp/b
深入解析JAX-RS 2.0客户端API：从入门到实践
最新发布
m0_62153576的博客
09-03 494
JAX-RS 2.0的客户端API基于SPI（Service Provider Interface）模式，这意味着实际的工作是由底层的实现完成的，而我们的代码只依赖于JAX-RS API。这样做的好处是，即使底层实现发生变化，我们的代码也可以保持不变，大大提高了代码的可维护性和可移植性。
jax-rs示例
aipiannian6725的博客
09-20 158
compile 'org.glassfish.jersey.core:jersey-client:2.9.1' @Path("/{appId}/{env}/downloadSDK") @GET @Produces(MediaType.APPLICATION_OCTET_STREAM) Response downloadSDK(@PathParam("app...
jax-rs的客户端完整实例
04-22 282
本地接口： @Override public Response formsubGet(String accountContent, char inputContent, String opEntrustWay, String opStation, String sysName,String sdkType,String comsFunc,String p...
jax rs mysql_JAX-RS示例（Jersey）
weixin_39676972的博客
02-26 163
我们可以通过 jersey 实现创建JAX-RS示例。 为此，需要加载 jersey相关jar文件或使用Maven框架。在这个例子中，我们使用jersey jar文件来实现JAX-RS jersey示例。打开Eclipse，创建一个Web工程: restfuljersey，如下图所示 -JAX-RS创建了4个文件示例：Hello.javaweb.xmlindex.htmlHelloWorldCli...
JAXRS2.0REST客户端编程实例Java开发Java
11-22
**JAX-RS 2.0 RESTful 客户端编程实例** 在Java开发中，JAX-RS（Java API for RESTful Web Services）是一种用于创建RESTful Web服务的标准API。JAX-RS 2.0是这个标准的第二版，它引入了许多新特性和改进，使得开发...
RESTful Java 2.0实战指南：JAX-RS权威教程
JAX-RS（Java API for RESTful Web Services）是Java社区推荐的RESTful Web服务API规范，它提供了一套编程接口，使得开发人员能够轻松地将Java应用与RESTful架构相结合。在本书中，作者详细讲解了如何使用JAX-RS 2.0...
JAX-RS与Jersey：创建RESTful服务客户端的全攻略
![JAX-RS与Jersey：创建RESTful服务客户端的全攻略]...JAX-RS 为开发者提供了一组易于使用的注解来简化REST服务的开发，并允许开发者利用现
JAX-RS微服务架构：构建高效分布式系统的单组件解决方案
JAX-RS（Java API for RESTful Web Services）作为Java社区的一个标准，它提供了一种简便的方式来开发遵循REST原则的Web服务。本章将简要介绍JAX-RS及其在微服务架构中的作用。 ## 1.1 JAX-RS的作用与优势 JAX-RS...
深入解析Java JAX-RS：揭秘RESTful架构风格的实现细节与高级特性
Java API for RESTful Web Services (JAX-RS) 是一个Java编程语言的应用程序接口，用于开发RESTful Web服务。JAX-RS 使用了一组注解，使Java开发者能够轻松地将类和方法映射到特定的HTTP请求和响应。R
java-jaxrs:Java JAX-RS示例集合
04-03
Java JAX-RS示例 根据MIT许可获得许可。 请参阅文件LICENSE。 Java JAX-RS示例的集合。 示例包括用Java编写的代码。 链接 一般的 -用Java测试和验证REST服务 阿帕奇 （实现JAX-RS等）
JAX-RS之rest接口实例
12-08
com.rest.restlet.RestJaxRsServer 服务启动类 com.rest.restlet.client.Client 客户端调用类 eclipse项目直接使用。
Maven和开发JAX-RS Web应用的基本示例
yiyeguhu的博客
10-27 3470
English Version: Basic Example of JAX-RS Web Application with Maven and Glassfish JAX-RS的含义是“Java API for RESTful Web Services”。本文将介绍如何用Maven、Glassfish、Intellij (IDE)这些工具来创建JAX-RS Web应用。 创建Maven工程
CXF-JAX-RS开发（一）入门案例
Purpleangle4321的博客
12-20 387
一、简介 　　资源驱动。基于HTTP协议[按照标准指定URL，就可以访问数据]以XML|JSON格式传输数据。 二、quickstart 　　1、创建mavenproject[Packaging:jar] 　　　　 　　　　 　　2、导入依赖 1 <!-- CXF的rs开发 --> 2 <dependency> 3 &l...
JAX-RS基本概念理解
Spring , Hadoop, Spark , BI , ML
07-08 6530
JAX-RS,全称为Java API for RESTful Web Services.的核心概念是resource，即面向资源。JAX-RS的JavaDoc可以在这里找到。 JAX-RS的标准可以在这里找到。1. Root Resource Classes满足下列2个条件的POJO类被称为Root Resource Class： 使用@Path注解 至少有一个方法使用@Path或者资源方法注解（
JAX-RS(java restful实现讲解)（转）
Better Me的博客
07-31 5520
JAX-RS入门 一 ：基础 博客分类：  JAX-RS   简介 JAX-RS是一套用java实现REST服务的规范，提供了一些标注将一个资源类，一个POJOJava类，封装为Web资源。标注包括： @Path，标注资源类或方法的相对路径@GET，@PUT，@POST，@DELETE，标注方法是用的HTTP请求的类型@Produces，标注返回的MIME媒
WebService——JAX-RS2（Jersey）注解详解
吴声子夜歌的博客
12-25 1371
虽然WebDAV对HTTP方法做出了功能性扩展，使之提供更强大服务，但是从ROA角度讲，因为WebDAV在HTTP标准方法的基础上增加了特殊的方法名称，WebDAV破坏了统一接口的原则。资源地址的路径变量是用来表达逻辑上的层次结构的，资源和子资源的形式是自左至右、斜杠分割的名词。DELETE方法是幂等的，即多次删除同一份数据（通常请求中传递的参数是数据的主键值)，在服务器端产生的改变是相同的。注解来定义相关的资源方法。PathInfo是资源路径信息，与资源类、子类以及类中的方法定义的@Path注解有关。
使用JAX-RS 2.0构建RESTful Java应用
本书《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架构...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值