jersey

时间 2019-12-09

标签 jersey 繁體版

原文原文链接

Java Jersey使用總結

簡介

Jersey是JAX-RS（JSR311）開源參考實現用於构建RESTful Web service，它包含三个部分：html

核心服務器（Core Server）：经过提供JSR 311中标准化的注释和API标准化，能够用直观的方式开发RESTful Web服务。java
核心客戶端(Core Client)：Jersey客户端API可以帮助开发者与RESTful服务轻松通讯；git
集成（Integration)：Jersey还提供能够轻松继承Spring、Guice、Apache Abdera的库。github

在本次开发中使用Jersey2.0，而且仅使用了核心服务器。web

設置Jersey環境

Maven

 
        01 
        <!--jersey--> 
      
        02 
        <dependency> 
      
        03 
            <groupId>org.glassfish.jersey.containers</groupId> 
      
        04 
            <artifactId>jersey-container-servlet-core</artifactId> 
      
        05 
            <version>2.0</version> 
      
        06 
        </dependency> 
      
        07 
          
        08 
        <!--JAXB API--> 
      
        09 
        <dependency> 
      
        10 
            <groupId>javax.xml.ws</groupId> 
      
        11 
            <artifactId>jaxws-api</artifactId> 
      
        12 
            <version>2.1</version> 
      
        13 
        </dependency> 
      
        14 
          
        15 
        <!-- Json支持 --> 
      
        16 
        <dependency> 
      
        17 
            <groupId>org.codehaus.jackson</groupId> 
      
        18 
            <artifactId>jackson-core-asl</artifactId> 
      
        19 
            <version>1.9.12</version> 
      
        20 
        </dependency> 
      
        21 
        <dependency> 
      
        22 
            <groupId>org.codehaus.jackson</groupId> 
      
        23 
            <artifactId>jackson-mapper-asl</artifactId> 
      
        24 
            <version>1.9.12</version> 
      
        25 
        </dependency> 
      
        26 
        <dependency> 
      
        27 
            <groupId>org.codehaus.jackson</groupId> 
      
        28 
            <artifactId>jackson-jaxrs</artifactId> 
      
        29 
            <version>1.9.12</version> 
      
        30 
        </dependency>

引入Jar文件方式

从Jersey开发包中将如下库复制的WEB-INF下的库目录：json

服务器：jersey-server.jar 、jersey-container-servlet-core.jar、jersey-container-servlet.jar、javax.ws.rs-api-2.0.jarapi
客户端：jersey-client.jar浏览器
common：jersey-common.jar服务器
json支持：在Jersey2.0中须要使用Jackson1.9才能支持json。app

Hello World

如下将展现一个Hello World

第一步：编写一个名为HelloResource的资源，它接受Http Get请求并响应“Hello Jersey”

 
        1 
        @Path("/hello") 
      
        2 
        public class HelloResource { 
      
        3 
            @GET 
      
        4 
            @Produces(MediaType.TEXT_PLAIN) 
      
        5 
            public String sayHello() { 
      
        6 
                return "Hello Jersey"; 
      
        7 
            } 
      
        8 
        }

第二步：编写JAX-RS application

 
        01 
        public class APIApplication extends ResourceConfig { 
      
        02 
            public APIApplication() { 
      
        03 
                //加载Resource 
      
        04 
                register(HelloResource.class); 
      
        05 
          
        06 
                //注册数据转换器 
      
        07 
                register(JacksonJsonProvider.class); 
      
        08 
          
        09 
                // Logging. 
      
        10 
                register(LoggingFilter.class); 
      
        11 
            } 
      
        12 
        }

第三步：在web.xml文件中定义servelt调度程序，目的是将全部REST请求发送到Jersey容器。除了声明Jersey Servlet外，还需定义一个初始化参数，指定JAX-RS application。

 
        01 
        <!--用于定义 RESTful Web Service 接口--> 
      
        02 
        <servlet> 
      
        03 
            <servlet-name>JerseyServlet</servlet-name> 
      
        04 
            <servlet-class>org.glassfish.jersey.servlet.ServletContainer</servlet-class> 
      
        05 
            <init-param> 
      
        06 
                <param-name>javax.ws.rs.Application</param-name> 
      
        07 
                <param-value>cn.com.mink.resource.APIApplication</param-value> 
      
        08 
            </init-param> 
      
        09 
          
        10 
            <load-on-startup>1</load-on-startup> 
      
        11 
        </servlet> 
      
        12 
        <servlet-mapping> 
      
        13 
            <servlet-name>JerseyServlet</servlet-name> 
      
        14 
            <url-pattern>/services/*</url-pattern> 
      
        15 
        </servlet-mapping>

第四步：测试程序

在命令终端中输入如下命令，将会看到“Hello Jersey”。

curl http://host:port/services/hello

或者在浏览器中输入如下URL，将会看到“Hello Jersey”

http://host:port/services/hello

使用

资源

Root Resource And Sub-Resource

资源是组成RESTful服务的关键部分，能够使用HTTP方法（如：GET、POST、PUT和DELETE）操做资源。在JAX-RX中，资源经过POJO实现，使用@Path 注释组成其标识符。资源能够有子资源，父资源是资源集合，子资源是成员资源。

在如下样例代码中，

Resources是”/services” URI组成是集合资源，UserResource是“/services/user” URI组成的成员资源;

 
        01 
        @Path("/services") 
      
        02 
        public class Resources { 
      
        03 
          
        04 
            @Path("/user") 
      
        05 
            public UserResource getUserResource() { 
      
        06 
                ... 
      
        07 
            } 
      
        08 
          
        09 
            @Path("/book") 
      
        10 
            public BookResource getBookResource() { 
      
        11 
                ... 
      
        12 
            } 
      
        13 
        }

UserResource是“/user” URI组成的集合资源，getUser是“/user/{username}” URI组成的资源方法

 
        1 
        @Path("/user") 
      
        2 
        public class UserResource { 
      
        3 
            @GET 
      
        4 
            @Path("{username"}) 
      
        5 
            @Produces("application/json") 
      
        6 
            public User getUser(@PathParam("username") String userName) { 
      
        7 
                ... 
      
        8 
            } 
      
        9 
        }

HTTP Methods

HTTP方法映射到资源的CRUD（建立、读取、更新和删除）操做，基本模式以下：

HTTP GET：读取/列出/检索单个或资源集合。
HTTP POST：新建资源。
HTTP PUT：更新现有资源或资源集合。
HTTP DELETE：删除资源或资源集合。

@Produces

@Produces注释用来指定将要返回给client端的数据标识类型（MIME）。@Produces能够做为class注释，也能够做为方法注释，方法的@Produces注释将会覆盖class的注释。

指定一个MIME类型

@Produces(“application/json”)
指定多个MIME类型

@Produces({“application/json”,“application/xml”})

@Consumes

@Consumes与@Produces相反，用来指定能够接受client发送过来的MIME类型，一样能够用于class或者method，也能够指定多个MIME类型，通常用于@PUT，@POST 。

参数（Parameter Annotations）

Parameter Annotations用于获取client发送的数据。本文只介绍经常使用的注解，更多详见Jersey用户手册

@PathParam

使用@PathParam能够获取URI中指定规则的参数，好比：

 
        1 
        @GET 
      
        2 
        @Path("{username"}) 
      
        3 
        @Produces(MediaType.APPLICATION_JSON) 
      
        4 
        public User getUser(@PathParam("username") String userName) { 
      
        5 
            ... 
      
        6 
        }

当浏览器请求http://localhost/user/jack时，userName值为jack。

@QueryParam

@QueryParam用于获取GET请求中的查询参数，如：

 
        1 
        @GET 
      
        2 
        @Path("/user") 
      
        3 
        @Produces("text/plain") 
      
        4 
        public User getUser(@QueryParam("name") String name, 
      
        5 
                            @QueryParam("age") int age) { 
      
        6 
            ... 
      
        7 
        }

当浏览器请求http://host:port/user?name=rose&age=25时，name值为rose，age值为25。若是须要为参数设置默认值，能够使用@DefaultValue，如：

 
        1 
        @GET 
      
        2 
        @Path("/user") 
      
        3 
        @Produces("text/plain") 
      
        4 
        public User getUser(@QueryParam("name") String name, 
      
        5 
                            @DefaultValue("26") @QueryParam("age") int age) { 
      
        6 
            ... 
      
        7 
        }

当浏览器请求http://host:port/user?name=rose时，name值为rose，age值为26。

@FormParam

@FormParam，顾名思义，从POST请求的表单参数中获取数据。如：

 
        1 
        @POST 
      
        2 
        @Consumes("application/x-www-form-urlencoded") 
      
        3 
        public void post(@FormParam("name") String name) { 
      
        4 
            // Store the message 
      
        5 
        }

@BeanParam

当请求参数不少时，好比客户端提交一个修改用户的PUT请求，请求中包含不少项用户信息。这时能够用@BeanParam。

 
        1 
        @POST 
      
        2 
        @Consumes("application/x-www-form-urlencoded") 
      
        3 
        public void update(@BeanParam User user) { 
      
        4 
            // Store the user data 
      
        5 
        }

User Bean定义以下：

 
        01 
        @XmlRootElement(name = "user") 
      
        02 
        public class User { 
      
        03 
            @PathParam("userName) 
      
        04 
            private String userName; 
      
        05 
          
        06 
            @FormParam("name") 
      
        07 
            private String name; 
      
        08 
          
        09 
            @FormParam("telephone") 
      
        10 
            private String telephone; 
      
        11 
          
        12 
            @FormParam("email") 
      
        13 
            private String email; 
      
        14 
          
        15 
            public String getUserName() { 
      
        16 
                return userName; 
      
        17 
            } 
      
        18 
          
        19 
            public void setUserName(String userName) { 
      
        20 
                this.userName = userName; 
      
        21 
            } 
      
        22 
            ... 
      
        23 
        }

使用Map

在一个大型的server中，由于参数的多变，参数结构的调整都会由于以上几种方式而遇到问题，这时能够考虑使用@Context 注释，并获取UriInfo实例，以下：

 
        1 
        @GET 
      
        2 
        public String get(@Context UriInfo ui) { 
      
        3 
            MultivaluedMap<String, String> queryParams = ui.getQueryParameters(); 
      
        4 
            MultivaluedMap<String, String> pathParams = ui.getPathParameters(); 
      
        5 
        }

一样还能够经过@Context 注释获取ServletConfig、ServletContext、HttpServletRequest、HttpServletResponse和HttpHeaders等，以下：

 
        01 
        @Path("/") 
      
        02 
        public class Resource { 
      
        03 
          
        04 
            @Context 
      
        05 
            HttpServletRequest req; 
      
        06 
          
        07 
            @Context 
      
        08 
            ServletConfig servletConfig; 
      
        09 
          
        10 
            @Context 
      
        11 
            ServletContext servletContext; 
      
        12 
          
        13 
            @GET 
      
        14 
            public String get(@Context HttpHeaders hh) { 
      
        15 
                MultivaluedMap<String, String> headerParams = hh.getRequestHeaders(); 
      
        16 
                Map<String, Cookie> pathParams = hh.getCookies(); 
      
        17 
            } 
      
        18 
        }

Jersey返回Json和Xml

JAX-RS支持使用JAXB（Java API for XML Binding）将JavaBean绑定到XML或JSON，反之亦然。JavaBean必须使用@XmlRootElement标注，没有@XmlElement注释的字段将包含一个名称与之相同的XML元素，以下：

 
        01 
        @XmlRootElement 
      
        02 
        public class OptionResult { 
      
        03 
            @XmlElement(name = "code") 
      
        04 
            private String result; 
      
        05 
          
        06 
            private String errorMsg; 
      
        07 
          
        08 
            public String getResult() { 
      
        09 
                return result; 
      
        10 
            } 
      
        11 
          
        12 
            public void setResult(String result) { 
      
        13 
                this.result = result; 
      
        14 
            } 
      
        15 
          
        16 
            public String getErrorMsg() { 
      
        17 
                return errorMsg; 
      
        18 
            } 
      
        19 
          
        20 
            public void setErrorMsg(String errorMsg) { 
      
        21 
                this.errorMsg = errorMsg; 
      
        22 
            } 
      
        23 
        }

而后在REST服务中使用：

 
        1 
        @Path("/user") 
      
        2 
        public class UserResource { 
      
        3 
            @POST 
      
        4 
            @Produces("application/json") 
      
        5 
            public OptionResult create(@BeanParam User user) { 
      
        6 
                ... 
      
        7 
            } 
      
        8 
        }

最后，要注册数据转换器，该转换器会自动将JavaBean转换为json数据：

 
        01 
        public class APIApplication extends ResourceConfig { 
      
        02 
            public APIApplication() { 
      
        03 
                //加载Model 
      
        04 
                register(OptionResult.class); 
      
        05 
          
        06 
                //加载与OptionResult同一个packge的Model 
      
        07