泽西岛 Java 教程

欢迎来到Java Jersey教程. 最近,我开始使用JAX-RS Jersey框架开发一个Restful Web 服务项目。

什么是Java Jersey框架?

Java Jersey project tracks the JAX-RS API, which is used to create Restful web services in Java.

1、谁应该使用此教程?

本教程面向有兴趣开发和部署使用 JAX-RS API 和 JAXB 的 Java 程序员。

2、前提条件

本教程的范围是使用Jersey API创建RestfulWeb服务,并使用Java客户端程序调用Web服务,并使用该工具测试Web服务。

3、软件和工具

JDK 版本 1.8.0_131
Apache Maven 3.5.3
Mac OS X 10.13.4
Tomcat 8.5.16
Eclipse Java EE IDE Oxygen 4.7.3

创建 Jersey Eclipse Maven 项目

Create a "Dynamic Web Project" in Eclipse and then convert it to the maven project. This will provide us a maven based web application basic project. I have given GroupId as com.journaldev.jersey and artifactID as my-jersey-project but you can specify anything you like. Once we complete the development of our project, the project structure will look like the below image. jersey java tutorial eclipse project

Java Jersey Restful Web Service 项目解释

1. pom.xml*:项目配置细节,注意提供的衬衫依赖性,其他细节对于任何类似的maven项目都是常见的。

 1<project xmlns="https://maven.apache.org/POM/4.0.0"
 2    xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance"
 3    xsi:schemaLocation="https://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
 4    <modelVersion>4.0.0</modelVersion>
 5    <groupId>com.journaldev.jersey</groupId>
 6    <artifactId>my-jersey-project</artifactId>
 7    <version>0.0.1-SNAPSHOT</version>
 8    <packaging>war</packaging>
 9
10    <dependencies>
11    	<dependency>
12    		<groupId>com.sun.jersey</groupId>
13    		<artifactId>jersey-server</artifactId>
14    		<version>1.14</version>
15    	</dependency>
16    	<dependency>
17    		<groupId>com.sun.jersey</groupId>
18    		<artifactId>jersey-servlet</artifactId>
19    		<version>1.14</version>
20    	</dependency>
21    	<dependency>
22    		<groupId>com.sun.jersey</groupId>
23    		<artifactId>jersey-client</artifactId>
24    		<version>1.14</version>
25    	</dependency>
26    </dependencies>
27
28    <build>
29    	<finalName>My-Jersey-Project</finalName>
30    	<plugins>
31    		<plugin>
32    			<artifactId>maven-compiler-plugin</artifactId>
33    			<version>3.7.0</version>
34    			<configuration>
35    				<source>1.8</source>
36    				<target>1.8</target>
37    			</configuration>
38    		</plugin>
39    		<plugin>
40    			<artifactId>maven-war-plugin</artifactId>
41    			<version>3.0.0</version>
42    			<configuration>
43    				<warSourceDirectory>WebContent</warSourceDirectory>
44    			</configuration>
45    		</plugin>
46    	</plugins>
47    </build>
48</project>

EmpRequest.java**: Java Bean 用于请求对象. 这里要注意的重要事项是@XmlRootElement的注释,以将类绘制为 XML 元素。

 1package com.journaldev.model;
 2
 3import javax.xml.bind.annotation.XmlRootElement;
 4
 5@XmlRootElement(name = "empRequest")
 6public class EmpRequest {
 7    private int id;
 8    private String name;
 9
10    public int getId() {
11    	return id;
12    }
13
14    public void setId(int id) {
15    	this.id = id;
16    }
17
18    public String getName() {
19    	return name;
20    }
21
22    public void setName(String name) {
23    	this.name = name;
24    }
25}

EmpResponse.java:对应对象的Java Bean。

 1package com.journaldev.model;
 2
 3import javax.xml.bind.annotation.XmlRootElement;
 4
 5@XmlRootElement(name = "empResponse")
 6public class EmpResponse {
 7    private int id;
 8    private String name;
 9
10    public int getId() {
11    	return id;
12    }
13
14    public void setId(int id) {
15    	this.id = id;
16    }
17
18    public String getName() {
19    	return name;
20    }
21
22    public void setName(String name) {
23    	this.name = name;
24    }
25
26}

ErrorResponse.java**:如果出现异常,将发送作为响应的Java Bean。

 1package com.journaldev.model;
 2
 3import javax.xml.bind.annotation.XmlRootElement;
 4
 5@XmlRootElement(name = "errorResponse")
 6public class ErrorResponse {
 7
 8    private String errorCode;
 9    private int errorId;
10
11    public String getErrorCode() {
12    	return errorCode;
13    }
14
15    public void setErrorCode(String errorCode) {
16    	this.errorCode = errorCode;
17    }
18
19    public int getErrorId() {
20    	return errorId;
21    }
22
23    public void setErrorId(int errorId) {
24    	this.errorId = errorId;
25    }
26
27}

EmpNotFoundException.java:在Web服务中投放的正常例外类。

 1package com.journaldev.exception;
 2
 3public class EmpNotFoundException extends Exception {
 4
 5    private static final long serialVersionUID = 4351720088030656859L;
 6    private int errorId;
 7
 8    public int getErrorId() {
 9    	return errorId;
10    }
11
12    public EmpNotFoundException(String msg, int errorId) {
13    	super(msg);
14    	this.errorId = errorId;
15    }
16
17    public EmpNotFoundException(String msg, Throwable cause) {
18    	super(msg, cause);
19    }
20}

6. web.xml: Web 服务的部署描述器.因此,任何使用 URI https://<HOST>:<PORT>/My-Jersey-Project/rest/* 的请求都将由 Jersey ServletContainer servlet 处理。为 "com.sun.jersey.config.property.packages" 传递的 init-param 值定义了软件包将寻找 Web 服务类别。该属性必须指向您的资源类别。它还会搜索资源类别到子包中。

 1<?xml version="1.0" encoding="UTF-8"?>
 2<web-app xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance"
 3    xmlns="https://java.sun.com/xml/ns/javaee"
 4    xsi:schemaLocation="https://java.sun.com/xml/ns/javaee https://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
 5    id="WebApp_ID" version="3.0">
 6    <display-name>My Jersey Project</display-name>
 7
 8    <!-- Jersey Servlet configurations -->
 9    <servlet>
10    	<servlet-name>Jersey REST Service</servlet-name>
11    	<servlet-class>com.sun.jersey.spi.container.servlet.ServletContainer</servlet-class>
12    	<init-param>
13    		<param-name>com.sun.jersey.config.property.packages</param-name>
14    		<param-value>com.journaldev</param-value>
15    	</init-param>
16    	<load-on-startup>1</load-on-startup>
17    </servlet>
18    <servlet-mapping>
19    	<servlet-name>Jersey REST Service</servlet-name>
20    	<url-pattern>/rest/*</url-pattern>
21    </servlet-mapping>
22    <!-- Jersey Servlet configurations -->
23
24</web-app>

EmpRouter.java:资源类处理不同类型的请求。

@Path("/emp") - 使用 URI 的所有请求 https://<HOST>:<PORT>/My-Jersey-Project/rest/emp/ 将由此资源类处理
@Path("/getEmp") - 使用 URI 的所有请求 https://<HOST>:<PORT>/My-Jersey-Project/rest/emp/getEmp 将由此方法处理
@POST - 此注释定义了使用的 HTTP 方法应该是 POST。其他一些可能的值是 @GET, @PUT, @DELETE( )* @Consumes(MediaType.APPLICATION_XML) - 该方法接受 XML 元素(_

 1package com.journaldev.router;
 2
 3import com.journaldev.exception.EmpNotFoundException;
 4import com.journaldev.model.*;
 5
 6import javax.ws.rs.Consumes;
 7import javax.ws.rs.POST;
 8import javax.ws.rs.Path;
 9import javax.ws.rs.Produces;
10import javax.ws.rs.core.MediaType;
11import javax.ws.rs.core.Response;
12import javax.xml.bind.JAXBElement;
13
14@Path("/emp")
15public class EmpRouter {
16
17    @POST
18    @Path("/getEmp")
19    @Consumes(MediaType.APPLICATION_XML)
20    @Produces(MediaType.APPLICATION_XML)
21    public Response getEmp(JAXBElement<EmpRequest> empRequest)
22    		throws EmpNotFoundException {
23    	EmpResponse empResponse = new EmpResponse();
24    	if (empRequest.getValue().getId() == 1) {
25    		empResponse.setId(empRequest.getValue().getId());
26    		empResponse.setName(empRequest.getValue().getName());
27    	} else {
28    		throw new EmpNotFoundException("Wrong ID", empRequest.getValue()
29    				.getId());
30    	}
31    	return Response.ok(empResponse).build();
32    }
33}

8. EmpNotFoundExceptionMapper.java:将Exception Mapper 类将 EmpNotFoundException 映射为响应对象。该类应具有 @Provider 注释。该类应在 web.xml 中的资源类提供的包中。实施 toResponse() 方法会生成 ErrorResponse 对象,并将其设置为响应对象中的实体,其状态为 INTERNAL_SERVER_ERROR。

 1package com.journaldev.exceptionmapper;
 2
 3import javax.ws.rs.core.MediaType;
 4import javax.ws.rs.core.Response;
 5import javax.ws.rs.ext.ExceptionMapper;
 6import javax.ws.rs.ext.Provider;
 7
 8import com.journaldev.exception.EmpNotFoundException;
 9import com.journaldev.model.ErrorResponse;
10
11@Provider
12public class EmpNotFoundExceptionMapper implements
13    	ExceptionMapper<EmpNotFoundException> {
14
15    public EmpNotFoundExceptionMapper() {
16    }
17    
18    public Response toResponse(
19    		EmpNotFoundException empNotFoundException) {
20    	ErrorResponse errorResponse = new ErrorResponse();
21    	errorResponse.setErrorId(empNotFoundException.getErrorId());
22    	errorResponse.setErrorCode(empNotFoundException.getMessage());
23    	return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(
24    			errorResponse).type(
25    			MediaType.APPLICATION_XML).build();
26
27    }
28
29}

我们的 Web 服务已经准备好了,只需构建它来创建 WAR 文件并部署到应用程序服务器上。

杰西克客户的例子

我们可以使用Jersey客户端来拨打我们的Web服务,并通过程序获得响应。 EmpClient.java:这是一个样本的Java程序,通过它我们正在召唤我们的Web服务. 我们正在使用Jersey客户端API来召唤服务,并根据响应状态,我们正在分析响应实体到EmpResponse或ErrorResponse类。

 1package com.journaldev.client;
 2
 3import javax.ws.rs.core.MediaType;
 4
 5import com.journaldev.model.EmpRequest;
 6import com.journaldev.model.EmpResponse;
 7import com.journaldev.model.ErrorResponse;
 8import com.sun.jersey.api.client.Client;
 9import com.sun.jersey.api.client.ClientResponse;
10import com.sun.jersey.api.client.WebResource;
11
12public class EmpClient {
13
14    /**
15     * @param args
16     */
17    public static void main(String[] args) {
18    	String uri = "https://localhost:8080/My-Jersey-Project/rest/emp/getEmp";
19    	EmpRequest request = new EmpRequest();
20    	// set id as 1 for OK response
21    	request.setId(2);
22    	request.setName("PK");
23    	try {
24    		Client client = Client.create();
25    		WebResource r = client.resource(uri);
26    		ClientResponse response = r.type(MediaType.APPLICATION_XML).post(ClientResponse.class, request);
27    		System.out.println(response.getStatus());
28    		if (response.getStatus() == 200) {
29    			EmpResponse empResponse = response.getEntity(EmpResponse.class);
30    			System.out.println(empResponse.getId() + "::" + empResponse.getName());
31    		} else {
32    			ErrorResponse exc = response.getEntity(ErrorResponse.class);
33    			System.out.println(exc.getErrorCode());
34    			System.out.println(exc.getErrorId());
35    		}
36    	} catch (Exception e) {
37    		System.out.println(e.getMessage());
38    	}
39    }
40
41}

Success Response Jersey Client Example Error Response Jersey Client Exception Example

摘要

在本文中,我们了解了如何使用Jersey API创建REST网络服务,我们还研究了Jersey客户端,通过Java程序调用我们的REST API。

您可以从我们的 GitHub 存储库中查阅完整的项目代码。