RESTful API Jersey 2.0实例

最新推荐文章于 2020-07-22 14:00:41 发布
最新推荐文章于 2020-07-22 14:00:41 发布
阅读量1.2k 收藏 1
点赞数 1
分类专栏： REST 文章标签： jersey RESTful API REST
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dayu236/article/details/53674648
版权

最近在开发RESTful API，使用的是Jersey框架。引用百科：“Jersey RESTful 框架是开源的RESTful框架, 实现了JAX-RS (JSR 311 & JSR 339) 规范。它扩展了JAX-RS 参考实现， 提供了更多的特性和工具， 可以进一步地简化 RESTful service 和 client 开发。”网上关于Jersey的资料和实例很多，但是大多数是1.0版本，所以决定写个2.0版本的详细实例。

实例包括server和client，包括GET和POST（XML、JSON）方法。最后包括一个ApacheHttpClient的client程序。

Jersey Server

首先是pom文件 
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0   
            http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<groupId>JERSEY_SERVER</groupId>
	<artifactId>JERSEY_SERVER</artifactId>
	<version>1.0</version>
	<dependencies>
		<dependency>
			<groupId>org.glassfish.jersey.containers</groupId>
			<artifactId>jersey-container-servlet</artifactId>
			<version>2.20</version>
		</dependency>
		<dependency>
			<groupId>org.glassfish.jersey.core</groupId>
			<artifactId>jersey-server</artifactId>
			<version>2.20</version>
		</dependency>
		<!-- https://mvnrepository.com/artifact/org.glassfish.jersey.containers/jersey-container-grizzly2-http -->
		<dependency>
			<groupId>org.glassfish.jersey.containers</groupId>
			<artifactId>jersey-container-grizzly2-http</artifactId>
			<version>2.20</version>
		</dependency>
		<!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-core -->
		<dependency>
			<groupId>com.fasterxml.jackson.core</groupId>
			<artifactId>jackson-core</artifactId>
			<version>2.3.5</version>
		</dependency>
		<!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-annotations -->
		<dependency>
			<groupId>com.fasterxml.jackson.core</groupId>
			<artifactId>jackson-annotations</artifactId>
			<version>2.3.5</version>
		</dependency>
		<!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.jaxrs/jackson-jaxrs-json-provider -->
		<dependency>
			<groupId>com.fasterxml.jackson.jaxrs</groupId>
			<artifactId>jackson-jaxrs-json-provider</artifactId>
			<version>2.3.5</version>
		</dependency>
	</dependencies>
</project>

添加注册器，由于POST方法会使用JSON类型，所以注册JacksonJsonProvider

package jersey;

import org.glassfish.jersey.filter.LoggingFilter;
import org.glassfish.jersey.server.ResourceConfig;
import com.fasterxml.jackson.jaxrs.json.JacksonJsonProvider;

public class APIApplication extends ResourceConfig{
	
	public APIApplication() {  
		
		packages("jersey");

        //加载Resource  
        register(RESTResource.class);  
   
        //注册数据转换器  
        register(JacksonJsonProvider.class);  
   
        // Logging.  
        register(LoggingFilter.class);  
		
    }
}

添加Server 

package jersey;

import java.io.IOException;
import java.net.URI;

import org.glassfish.grizzly.http.server.HttpServer;
import org.glassfish.jersey.grizzly2.httpserver.GrizzlyHttpServerFactory;
 
public class JerseyServer {  
	   
    public static final String BASE_URI = "http://localhost:8080/jerseyserver/";
    
    public static HttpServer startServer() {  
        final APIApplication apiApplication = new APIApplication();
        return GrizzlyHttpServerFactory.createHttpServer(URI.create(BASE_URI), apiApplication);
    }
    
    public static void main(String[] args) throws IOException {  
        final HttpServer server = startServer();
        System.out.println("Jersey server started...\nHit enter to stop...");
        System.in.read();
        server.shutdownNow();
    }
}
添加服务 

package jersey;

import javax.ws.rs.Consumes;
import javax.ws.rs.PathParam;
import javax.ws.rs.GET;
import javax.ws.rs.POST;
import javax.ws.rs.Path;
import javax.ws.rs.Produces;
import javax.ws.rs.core.MediaType;

@Path("test")
public class RESTResource {
		    
    @GET
    @Path("get/{param:[a-zA-Z0-9]*}")  
    @Consumes({MediaType.TEXT_PLAIN, MediaType.APPLICATION_JSON})  
    @Produces(MediaType.TEXT_PLAIN)  
    public String getResourceName(  
            @PathParam("param") String requestParam) {  
        System.out.println("****** HTTP request get******");  
        System.out.println(requestParam);  
        String responseStr ="test get result";  
        return responseStr;  
    }
	
	@POST
	@Path("postxml")
    @Consumes(MediaType.APPLICATION_XML)  
    @Produces(MediaType.APPLICATION_XML)  
    public RESTResponse postXML(RESTRequest req) {  
		 System.out.println("****** HTTP request post xml******");  
		System.out.println(req.getType());  
        System.out.println(req.getParam()); 
        
        RESTResponse resp = new RESTResponse();  
        resp.setRespCode(0);  
        resp.setRespDesc("success");
        resp.setResult("test result");
        return resp;  
    }
	
	@POST
	@Path("postjson")
    @Consumes(MediaType.APPLICATION_JSON)  
    @Produces(MediaType.APPLICATION_JSON)  
    public RESTResponse postJSON(RESTRequest req) {  
		 System.out.println("****** HTTP request post json******");  
		System.out.println(req.getType());  
        System.out.println(req.getParam()); 
        
        RESTResponse resp = new RESTResponse();  
        resp.setRespCode(0);  
        resp.setRespDesc("success");
        resp.setResult("test result");
        return resp;  
    }
}

在服务中定义了两个类，由于POST方法会使用XML类型，所以添加@XmlRootElement注解，代码如下 

package jersey;

import javax.xml.bind.annotation.XmlRootElement;

@XmlRootElement 
public class RESTRequest {
	private String type; 
    private String param;
	public String getType() {
		return type;
	}
	public void setType(String type) {
		this.type = type;
	}
	public String getParam() {
		return param;
	}
	public void setParam(String param) {
		this.param = param;
	}
    
}

package jersey;
import javax.xml.bind.annotation.XmlRootElement;

@XmlRootElement 
public class RESTResponse {
    private int respCode;  
    private String respDesc;
    private String result;
	public int getRespCode() {
		return respCode;
	}
	public void setRespCode(int respCode) {
		this.respCode = respCode;
	}
	public String getRespDesc() {
		return respDesc;
	}
	public void setRespDesc(String respDesc) {
		this.respDesc = respDesc;
	}
	public String getResult() {
		return result;
	}
	public void setResult(String result) {
		this.result = result;
	}
    
}

Jersey Client

首先添加pom文件 

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0   
                http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<groupId>JERSEY_CLIENT</groupId>
	<artifactId>JERSEY_CLIENT</artifactId>
	<version>1.0</version>
	<dependencies>
		<dependency>
			<groupId>org.glassfish.jersey.containers</groupId>
			<artifactId>jersey-container-servlet-core</artifactId>
			<version>2.0.1</version>
		</dependency>
		<!-- https://mvnrepository.com/artifact/org.glassfish.jersey.core/jersey-client -->
		<dependency>
			<groupId>org.glassfish.jersey.core</groupId>
			<artifactId>jersey-client</artifactId>
			<version>2.0.1</version>
		</dependency>
		<!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-core -->
		<dependency>
			<groupId>com.fasterxml.jackson.core</groupId>
			<artifactId>jackson-core</artifactId>
			<version>2.3.5</version>
		</dependency>
		<!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-annotations -->
		<dependency>
			<groupId>com.fasterxml.jackson.core</groupId>
			<artifactId>jackson-annotations</artifactId>
			<version>2.3.5</version>
		</dependency>
		<!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.jaxrs/jackson-jaxrs-json-provider -->
		<dependency>
			<groupId>com.fasterxml.jackson.jaxrs</groupId>
			<artifactId>jackson-jaxrs-json-provider</artifactId>
			<version>2.3.5</version>
		</dependency>
		<dependency>
			<groupId>org.apache.httpcomponents</groupId>
			<artifactId>httpclient</artifactId>
			<version>4.5.2</version>
		</dependency>
	</dependencies>
</project>
添加Server中的自定义类RESTRequest和RESTResponse。
添加调用方法 

package jersey;
 
import javax.ws.rs.client.Client;
import javax.ws.rs.client.ClientBuilder;
import javax.ws.rs.client.Entity;
import javax.ws.rs.client.Invocation;
import javax.ws.rs.client.WebTarget;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Response;

import org.glassfish.jersey.client.ClientConfig;
import org.glassfish.jersey.filter.LoggingFilter;
  
public class JerseyClient {  
	
	public static void main(String[] args) {  
		//getScheduleJsonString();
		//postRequestResponse();
		//getTest();
		//postXMLTest();
		postJSONTest();
    }
	
	private static void getTest(){
		Client client = ClientBuilder.newClient( new ClientConfig().register( LoggingFilter.class ) );
		WebTarget webTarget = client.target("http://localhost:8080/jerseyserver/test/get/helloworld");
		Invocation.Builder invocationBuilder =  webTarget.request(MediaType.TEXT_PLAIN);
		Response response = invocationBuilder.get();	 
		String result = response.readEntity(String.class);
        System.out.println(result);
	}
	
	private static void postXMLTest(){
		Client client = ClientBuilder.newClient( new ClientConfig().register( LoggingFilter.class ) );
		WebTarget webTarget = client.target("http://localhost:8080/jerseyserver/test/postxml");
		
		Invocation.Builder invocationBuilder =  webTarget.request(MediaType.APPLICATION_XML);
		RESTRequest request = new RESTRequest();
		request.setType("test");
		request.setParam("hello world");
		
		Response response = invocationBuilder.post(Entity.entity(request, MediaType.APPLICATION_XML));	 
		
		System.out.println(response.getStatus());
		RESTResponse result = response.readEntity(RESTResponse.class);
        System.out.println(result.getRespCode());
        System.out.println(result.getRespDesc());
        System.out.println(result.getResult());
	}
	
	private static void postJSONTest(){
		Client client = ClientBuilder.newClient( new ClientConfig().register( LoggingFilter.class ) );
		WebTarget webTarget = client.target("http://localhost:8080/jerseyserver/test/postjson");
		
		Invocation.Builder invocationBuilder =  webTarget.request(MediaType.APPLICATION_JSON);
		RESTRequest request = new RESTRequest();
		request.setType("test");
		request.setParam("hello world");
		
		Response response = invocationBuilder.post(Entity.entity(request, MediaType.APPLICATION_JSON));	 
		
		System.out.println(response.getStatus());
		RESTResponse result = response.readEntity(RESTResponse.class);
        System.out.println(result.getRespCode());
        System.out.println(result.getRespDesc());
        System.out.println(result.getResult());
	}
}

ApacheHttpClient

package apache;

import java.io.IOException;

import jersey.RESTRequest;
import jersey.RESTResponse;
import org.apache.http.HttpResponse;
import org.apache.http.client.HttpClient;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.HttpClientBuilder;
import org.apache.http.util.EntityUtils;

import com.fasterxml.jackson.databind.ObjectMapper;

public class ApacheHttpClientPost {

	public static void main(String[] args) {
		postJson();
	}
	private static void postJson(){
		try {
			HttpClient httpClient = HttpClientBuilder.create().build();
			HttpPost httpPost = new HttpPost(
					"http://localhost:8080/jerseyserver/test/postjson");
			httpPost.addHeader("Content-Type", "application/json");
			// httpPost.addHeader("Accept", "text/plain");

			RESTRequest request = new RESTRequest();
			request.setType("test");
			request.setParam("hello world");
			
			String requestJsonString = new ObjectMapper().writeValueAsString(request);  
            StringEntity entity = new StringEntity(requestJsonString);  
            httpPost.setEntity(entity);  

			HttpResponse httpResponse = httpClient.execute(httpPost);
			String responseJsonString = EntityUtils.toString(httpResponse.getEntity());
			System.out.println(responseJsonString);
			RESTResponse response = new ObjectMapper().readValue(responseJsonString, RESTResponse.class);
			System.out.println(response.getRespCode());
			System.out.println(response.getRespDesc());
			System.out.println(response.getResult());
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}


rexzhao236
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
springboot基于jersey2.0与rs-api2.1实现上传下载文件
king的博客
07-18 414
网上找了大量的例子原因说明都不是特别准确，今天自己结合多方方案自己总结了一下 此文案说明指的是单个文件,PS:多个文件的话，应该也是大致不差，无非是压缩解压问题，目前还没有研究到，后续有需要会补充上。 直接上码说明 1.下载 @GET @Path("/download") @Produces(MediaType.APPLICATION_OCTET_STREAM) p...
jersey实现rest实例之二
check_null的专栏
01-11 1万+
之前有写过jersey1.18实现rest方式，这里介绍jersey2.x实现rest获取text，xml，json格式数据 测试项目开发部署环境 开发工具：eclipse-jee-juno-SR2-win32 JDK：jdk-7u3-windows-i586 应用服务器：glassfish-4.0 REST实现框架：jersey2.5.1 项目名称：TestJersey2.5
jersey2搭建流程
十五楼亮哥
12-24 3952
一：环境介绍  （1）Jersey2.5.1   （2）Eclipse 3.7 +Tomcat 7 +JDK 7 二：搭建步骤  （1）通过地址https://jersey.java.net/ 下载jaxrs-ri-2.5.1.zip。  （2）通过Eclipse 创建动态工程RestDemo。  （3）解压jaxrs-ri-2.5.1.zip，拷贝下图列表中的JAR包到RestD
jersey
liuliangsailor的专栏
03-26 968
Java Jersey使用總結 簡介 設置Jersey環境 Maven 引入Jar文件方式 Hello World 使用 资源 Root Resource And Sub-Resource HTTP Methods @Produces @Consumes 参数（Parameter Annotations） @PathParam @QueryParam @FormPar
jersey1.X与jersey2.X的区别
十五楼亮哥
12-24 7781
1：web.xml加载jersey的servlet容器 jersey1.X使用的是sun的com.sun.jersey.spi.container.servlet.ServletContainer jersey2.X使用的是glassfish的org.glassfish.jersey.servlet.ServletContainer 2：扫描jersey resour
Yii2.0 RESTful API 基础配置教程详解
10-17
主要介绍了Yii2.0 RESTful API 基础配置教程,小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
使用 Spring Boot 2.0 + WebFlux 实现 RESTful API功能
08-28
Spring Boot 2.0 结合 WebFlux 提供了一种现代且高效的构建 RESTful API 的方式，利用异步非阻塞特性，提升了系统在高并发环境下的性能。结合 Reactive Streams，可以更好地应对大数据量和高并发场景，降低了系统的...
yii2的restful api路由实例详解
01-02
使用yii\rest\UrlRule来自动映射控制器的 restful 路由，简单快捷，缺点是必须得按规定好的方法名去写业务。 映射的规则如下，当然，你可以修改源码为你的习惯： public $patterns = [ 'PUT,PATCH {id}' => '...
RESTful API设计规范.pdf
02-13
RESTful API设计规范.pdf RESTful API设计规范是指在软件架构和设计风格中，遵循一组设计原则和约束条件，以降低开发的复杂性，提高系统的可扩展性。RESTful架构的核心是面向资源，每个网址代表一种资源，因此网址...
RestfulApi服务端.zip
02-27
本项目提供了一个RestfulApi服务端的示例，帮助开发者了解如何构建这样的服务。 在RestfulApi服务端的实现中，通常会用到以下技术栈： 1. **服务器框架**：如Spring Boot或Express.js，它们为快速构建RESTful API...
一个简单的Jersey开发例子
06-15
一个完整的Jersey的开发小例子，在MyEclipse直接导入工程，运行即可。
jersey 实现restful服务
07-13
jersey构建简单的Restful服务！
jersey2.x 简单例子。
faicm的专栏
09-14 584
https://jersey.java.net/download.html  下载上面的2.x相关文件。
jersey实现的RESTful
sinat_34442346的博客
03-11 3439
Resultful架构 1.JAX-RS标准 2.0 JAX-RS是JAVA EE6引入的一个新技术。JAX-RS即JAVA APIfor RESTful Web services，是一个Java编程语言的应用程序接口，支持按照表述性状态转移(REST)架构风格创建Web服务。JAX-RS标准中定义了目标、非目标和元素等内容。 目标： 1) 基于POJO(Plain Ordinary
Jersey架构下的Restful接口学习笔记
zjutzmh的博客
09-11 1632
Restful接口学习笔记 框架：Jersey架构，Maven管理  前言：个人认为restful总体上采用的是MVC架构思想，但是Jersey这个框架体现的不明显。所以我在我的代码中模块逻辑操作处理（相当于代码中的resource文件夹），还有控制块数据操作处理（即代码中的server文件夹）完全分成两部分。而MVC架构中的视图部分由于没有需求暂时没有开发。REST 是一种架构原
Jersey Client api 基本使用
热门推荐
yanghanxiu的专栏
11-07 1万+
Jersey client api 基本使用。 1.必须通过ClientBuilder工厂初始化Client实例； Client client = ClientBuilder.newClient(); 2.创建目标，该目标构造参数可以是String ,URI,Link 形式的连接，这里用字符串。 WebTarget baseTarget= client.target("http://www
基于jersey的RESTful api搭建
weixin_44122710的博客
07-22 181
ide：idea 1.创建项目 首先创建一个web Application项目 创建完项目后我们再用Add Frameworks Support把maven项目的支持引入。 2.代码 2.1 环境配置 pom.xml <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XML
jersey实现rest实例
check_null的专栏
12-09 1万+
以前项目中采用的axis2发布webservice接口，近期用户要求提供rest方式来实现接口的发布，要求速度尽可能快的实现这种方式，所以就采用jersey来做rest的实现。以下就是在项目中采用jersey实现rest的步骤，仅供参考。   首先到jersey官网下载，目前最新的版本是jersey2.4.1，那会我下载用的版本是jersey1.18，这里也以1.18版本来做的集成。下载地址：
第一个Jersey实例--hello美好
FZZFFFFF的专栏
03-30 779
资源：jerseryJRA 项目目录： 步骤1：创建web工程 2.复制jar包到lib下 3.创建ReSOURCE类： import javax.ws.rs.GET; import javax.ws.rs.Path; import javax.ws.rs.PathParam; import javax.ws.rs.Produces; import javax.
java restful api接口实例
最新发布
12-05
一个简单的Java RESTful API接口实例可以是一个用于创建、读取、更新和删除用户数据的接口。通过这个接口，客户端可以发送HTTP请求来执行不同的操作，比如创建新用户、获取特定用户的信息、更新用户的信息或者删除...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值