Jersey框架二：Jersey对JSON的支持

最新推荐文章于 2024-12-20 16:57:04 发布
最新推荐文章于 2024-12-20 16:57:04 发布
阅读量749 收藏
点赞数
分类专栏： jersey

Jersey提供3种基本方式来使用JSON格式

无论使用何种方式，在原有包的基础上，都需要在客户端和服务端Maven配置文件中添加jersey-json包以支持JSON格式

[html]  view plain  copy
  1. <dependency>  
  2.     <groupId>com.sun.jersey</groupId>  
  3.     <artifactId>jersey-json</artifactId>  
  4.     <version>1.18</version>  
  5. </dependency>  

一，基于POJO

Request类和Response类（服务端和客户端都需要）都是基本的POJO：

[java]  view plain  copy
  1. package com.sean;  
  2.   
  3. public class Request {  
  4.     private String query;  
  5.   
  6.     public String getQuery() {  
  7.         return query;  
  8.     }  
  9.   
  10.     public void setQuery(String query) {  
  11.         this.query = query;  
  12.     }  
  13. }  
[java]  view plain  copy
  1. package com.sean;  
  2.   
  3. public class Response {  
  4.     private int respCode;  
  5.     private String respDesc;  
  6.       
  7.     public int getRespCode() {  
  8.         return respCode;  
  9.     }  
  10.       
  11.     public void setRespCode(int respCode) {  
  12.         this.respCode = respCode;  
  13.     }  
  14.       
  15.     public String getRespDesc() {  
  16.         return respDesc;  
  17.     }  
  18.       
  19.     public void setRespDesc(String respDesc) {  
  20.         this.respDesc = respDesc;  
  21.     }  
  22. }  

服务端代码：

[java]  view plain  copy
  1. package com.sean;  
  2.    
  3. import java.io.IOException;  
  4. import java.net.URI;  
  5.   
  6. import javax.ws.rs.Consumes;  
  7. import javax.ws.rs.POST;  
  8. import javax.ws.rs.Path;  
  9. import javax.ws.rs.Produces;  
  10. import javax.ws.rs.core.MediaType;  
  11. import javax.ws.rs.core.UriBuilder;  
  12.   
  13. import org.glassfish.grizzly.http.server.HttpServer;  
  14.   
  15. import com.sun.jersey.api.container.grizzly2.GrizzlyServerFactory;  
  16. import com.sun.jersey.api.core.PackagesResourceConfig;  
  17. import com.sun.jersey.api.core.ResourceConfig;  
  18. import com.sun.jersey.api.json.JSONConfiguration;  
  19.    
  20. @Path("query")   
  21. public class MyResource {  
  22.       
  23.     @POST  
  24.     @Consumes(MediaType.APPLICATION_JSON)  
  25.     @Produces(MediaType.APPLICATION_JSON)  
  26.     public Response query(Request req) {  
  27.         System.out.println(req.getQuery());  
  28.           
  29.         Response resp = new Response();  
  30.         resp.setRespCode(0);  
  31.         resp.setRespDesc(req.getQuery());  
  32.         return resp;  
  33.     }  
  34.       
  35.     public static void main(String[] args) {  
  36.         URI uri = UriBuilder.fromUri("http://127.0.0.1").port(10000).build();  
  37.         ResourceConfig rc = new PackagesResourceConfig("com.sean");  
  38.         //使用Jersey对POJO的支持，必须设置为true  
  39.          rc.getFeatures().put(JSONConfiguration.FEATURE_POJO_MAPPING, true);  
  40.         try {  
  41.             HttpServer server = GrizzlyServerFactory.createHttpServer(uri, rc);  
  42.             server.start();  
  43.         } catch (IllegalArgumentException e) {  
  44.             e.printStackTrace();  
  45.         } catch (NullPointerException e) {  
  46.             e.printStackTrace();  
  47.         } catch (IOException e) {  
  48.             e.printStackTrace();  
  49.         }  
  50.         try {  
  51.             Thread.sleep(1000*1000);  
  52.         } catch (InterruptedException e) {  
  53.             e.printStackTrace();  
  54.         }  
  55.     }  
  56. }  

客户端代码：

[java]  view plain  copy
  1. package com.sean;  
  2.   
  3. import javax.ws.rs.core.MediaType;  
  4.   
  5. import com.sun.jersey.api.client.Client;  
  6. import com.sun.jersey.api.client.ClientResponse;  
  7. import com.sun.jersey.api.client.WebResource;  
  8. import com.sun.jersey.api.client.config.ClientConfig;  
  9. import com.sun.jersey.api.client.config.DefaultClientConfig;  
  10. import com.sun.jersey.api.json.JSONConfiguration;  
  11.   
  12. public class JerseyClient {  
  13.   
  14.     public static void main(String[] args) {  
  15.         ClientConfig cc = new DefaultClientConfig();  
  16.         //使用Jersey对POJO的支持，必须设置为true  
  17.         cc.getFeatures().put(JSONConfiguration.FEATURE_POJO_MAPPING, Boolean.TRUE);  
  18.         Client client = Client.create(cc);  
  19.           
  20.         WebResource resource = client.resource("http://127.0.0.1:10000/query");  
  21.           
  22.         Request req = new Request();  
  23.         req.setQuery("name");  
  24.           
  25.         ClientResponse response = resource  
  26.                 .accept(MediaType.APPLICATION_JSON)  
  27.                 .type(MediaType.APPLICATION_JSON)  
  28.                 .post(ClientResponse.class, req);  
  29.           
  30.         Response resp = response.getEntity(Response.class);  
  31.         System.out.println(resp.getRespCode() + " " + resp.getRespDesc());  
  32.     }  
  33. }  

 

二，基于JAXB

使用JAXB的优点在于，无论使用XML格式还是JSON格式数据，都可以使用统一的JAVA模型

缺点很难找到一个合适的方式来生成特殊的JSON格式，这也是Jersey提供很多控制选项的原因

将Request类和Response类进行修改：

[java]  view plain  copy
  1. package com.sean;  
  2.   
  3. import javax.xml.bind.annotation.XmlRootElement;  
  4.   
  5. @XmlRootElement  
  6. public class Request {  
  7.     private String query;  
  8.   
  9.     public String getQuery() {  
  10.         return query;  
  11.     }  
  12.   
  13.     public void setQuery(String query) {  
  14.         this.query = query;  
  15.     }  
  16. }  
[java]  view plain  copy
  1. package com.sean;  
  2.   
  3. import javax.xml.bind.annotation.XmlRootElement;  
  4.   
  5. @XmlRootElement  
  6. public class Response {  
  7.     private int respCode;  
  8.     private String respDesc;  
  9.       
  10.     public int getRespCode() {  
  11.         return respCode;  
  12.     }  
  13.       
  14.     public void setRespCode(int respCode) {  
  15.         this.respCode = respCode;  
  16.     }  
  17.       
  18.     public String getRespDesc() {  
  19.         return respDesc;  
  20.     }  
  21.       
  22.     public void setRespDesc(String respDesc) {  
  23.         this.respDesc = respDesc;  
  24.     }  
  25. }  

服务端代码去掉下面的配置

[java]  view plain  copy
  1. //       rc.getFeatures().put(JSONConfiguration.FEATURE_POJO_MAPPING, true);  

客户端代码去掉下面的配置

[java]  view plain  copy
  1. //      cc.getFeatures().put(JSONConfiguration.FEATURE_POJO_MAPPING, Boolean.TRUE);  

Jersey提供很多控制选项以便更精细的控制JSON的解析、组装过程，但是就我个人来看，JAXB提供的标签足够使用了

 

三，基于底层JSONObject/JSONArray

最大的优势在于可以完全控制JSON的解析、组装过程，相应的，在处理数据对象时也要更复杂

服务端代码如下：

[java]  view plain  copy
  1. package com.sean;  
  2.    
  3. import java.io.IOException;  
  4. import java.net.URI;  
  5.   
  6. import javax.ws.rs.Consumes;  
  7. import javax.ws.rs.POST;  
  8. import javax.ws.rs.Path;  
  9. import javax.ws.rs.Produces;  
  10. import javax.ws.rs.core.MediaType;  
  11. import javax.ws.rs.core.UriBuilder;  
  12.   
  13. import org.codehaus.jettison.json.JSONException;  
  14. import org.codehaus.jettison.json.JSONObject;  
  15. import org.glassfish.grizzly.http.server.HttpServer;  
  16.   
  17. import com.sun.jersey.api.container.grizzly2.GrizzlyServerFactory;  
  18. import com.sun.jersey.api.core.PackagesResourceConfig;  
  19. import com.sun.jersey.api.core.ResourceConfig;  
  20.    
  21. @Path("query")   
  22. public class MyResource {  
  23.       
  24.     @POST  
  25.     @Consumes(MediaType.APPLICATION_JSON)  
  26.     @Produces(MediaType.APPLICATION_JSON)  
  27.     public JSONObject query(JSONObject query) {  
  28.         //{"query":"name"}  
  29.         System.out.println(query.toString());  
  30.           
  31.         JSONObject resp = new JSONObject();  
  32.         try {  
  33.             resp.put("respCode", 0);  
  34.             resp.put("respDesc", query.get("query"));  
  35.         } catch (JSONException e) {  
  36.             e.printStackTrace();  
  37.         }  
  38.         return resp;  
  39.     }  
  40.       
  41.     public static void main(String[] args) {  
  42.         URI uri = UriBuilder.fromUri("http://127.0.0.1").port(10000).build();  
  43.         ResourceConfig rc = new PackagesResourceConfig("com.sean");  
  44.         try {  
  45.             HttpServer server = GrizzlyServerFactory.createHttpServer(uri, rc);  
  46.             server.start();  
  47.         } catch (IllegalArgumentException e) {  
  48.             e.printStackTrace();  
  49.         } catch (NullPointerException e) {  
  50.             e.printStackTrace();  
  51.         } catch (IOException e) {  
  52.             e.printStackTrace();  
  53.         }  
  54.         try {  
  55.             Thread.sleep(1000*1000);  
  56.         } catch (InterruptedException e) {  
  57.             e.printStackTrace();  
  58.         }  
  59.     }  
  60. }  

客户端代码如下：

[java]  view plain  copy
  1. package com.sean;  
  2.   
  3. import javax.ws.rs.core.MediaType;  
  4.   
  5. import org.codehaus.jettison.json.JSONException;  
  6. import org.codehaus.jettison.json.JSONObject;  
  7.   
  8. import com.sun.jersey.api.client.Client;  
  9. import com.sun.jersey.api.client.ClientResponse;  
  10. import com.sun.jersey.api.client.WebResource;  
  11. import com.sun.jersey.api.client.config.ClientConfig;  
  12. import com.sun.jersey.api.client.config.DefaultClientConfig;  
  13.   
  14. public class JerseyClient {  
  15.   
  16.     public static void main(String[] args) {  
  17.         ClientConfig cc = new DefaultClientConfig();  
  18.         Client client = Client.create(cc);  
  19.           
  20.         WebResource resource = client.resource("http://127.0.0.1:10000/query");  
  21.           
  22.         JSONObject req = new JSONObject();  
  23.         try {  
  24.             req.put("query", "name");  
  25.         } catch (JSONException e) {  
  26.             e.printStackTrace();  
  27.         }  
  28.           
  29.         ClientResponse response = resource  
  30.                 .accept(MediaType.APPLICATION_JSON)  
  31.                 .type(MediaType.APPLICATION_JSON)  
  32.                 .post(ClientResponse.class, req);  
  33.           
  34.         JSONObject resp = response.getEntity(JSONObject.class);  
  35.         //{"respCode":0,"respDesc":"name"}  
  36.         System.out.println(resp.toString());  
  37.     }  
  38. }  

与JAXB相比，结果是相同的，但是处理过程（主要是组装JSON对象）要复杂

对于上面3种方式，均可使用String类代替Request类、Response类或JSONObject类，Jersey会自动将对象转换为JSON串

当然，如果客户端修改为String，服务端也要相应的修改为String类型

修改客户端代码：

[java]  view plain  copy
  1. public class JerseyClient {  
  2.   
  3.     public static void main(String[] args) {  
  4.         ClientConfig cc = new DefaultClientConfig();  
  5.         Client client = Client.create(cc);  
  6.           
  7.         WebResource resource = client.resource("http://127.0.0.1:10000/query");  
  8.           
  9.         JSONObject req = new JSONObject();  
  10.         try {  
  11.             req.put("query", "name");  
  12.         } catch (JSONException e) {  
  13.             e.printStackTrace();  
  14.         }  
  15.           
  16.         String response = resource  
  17.                 .accept(MediaType.APPLICATION_JSON)  
  18.                 .type(MediaType.APPLICATION_JSON)  
  19.                 .post(String.class, req.toString());  
  20.     }  
  21. }  
Jersey框架：自动JSON格式转换
机器熊的技术大杂烩
04-21 1036
问题的提出 一般情况下，资源方法的返回类型都是String，但如果我们指定了输出类型为标准的JSON格式，就需要借助JSON转换工具（如fastjson等）将对象转成JSON字符串再输出。 注意：虽然指定了@Produces(MediaType.APPLICATION_JSON)，但当输出不是标准JSON时，框架并不会报错，但这会造成前端程序处理的困惑，即前端程序明明拿到的是JSON格式，但处理...
Jersery Restful接口服务接收JSON对象的参数请求
热门推荐
kevin_pso的博客
06-09 1万+
这几天由于一个需求需要开发RestFul接口，在开发时过程中，Get请求比较简单也比较顺利，但时在开发Post请求，----客户端以JSON格式向服务端提交数据（客户端可能一次请求提交一条哦数据，也可能一次提价多条数据）时，遇到了一个难题，折腾了2天终于解决，在此记录下   一.客户端传递单条JSON数据          服务端代码public class IptvStblogResource
Jersey+Spring集成，后台接受或返回Json数据
04-22
NULL 博文链接：https://arthur8.iteye.com/blog/1954736
Jersey对返回Json数据格式的支持
t0m的专栏
04-26 1200
Jersey对与xml格式支持，除了在resource的对应方法上标注@Produces，另外在要返回的bean上设置为@XmlRootElement即可，但是默认未开启支持返回Json数据格式。                     我用的是2.25.1的archetype模板，对于支持json很简单，在生成的pom.xml中可以看到下面的内容：uncomment this to get
jersey实现完成文件和json参数请求，文件流返回等
最新发布
m0_60314891的博客
12-20 608
可以根据响应头的类型，来判断怎么处理，取出响应类型的方式const contentType = response.headers['content-type'];，取出文件名的方式let fileName = res.headers['content-disposition'].split('=')[1] 从返回值获取文件名。1.1java接受文件很json数据做为请求输入的写法，将参数设置为表单，从表单获取文字和文件参数，压缩流加一层压缩，返回普通文件直接往返回值写。1.2前端将参数设置为的表单的写法。
java jersey dto对象,SpringBoot + jersey 实现接受 json对象
weixin_28763005的博客
03-13 385
为什么使用Jersey?刚开始使用Jersey的时候,我也会有疑问,Spring家族已经很完善,为什么要用Jersey,但是后来做项目多了就感受到两者的差异.1.Jersey是JAX-RS标准的参考实现，是Java领域中开发REST式web/服务的"正统"工具,Spring属于自成一派,不是严格意义上的实现REST,但是springMVC已经支持RestFul风格,这个对我来说并不影响我开发项目....
Jersey Restful WebService 接收 JSON 数组
小鹰信息技术服务部
08-17 1万+
明天要给客户演示产品了，今天还有个问题没解决，就是一次上传N条记录到后台，存入数据库，用的是Jersey Restful WebService。 客户端提交的数据形式是JSON数组（原来的方案是每个JSON上传一次，但是发现这样程序容易卡死）。 反反复复测试了一整天，都不行。查遍了各种网站，也很难找到有用的信息。熬到晚上11点，无意中搜到了StackOverFlow上面的一个问答，收到了启发！
Jersey框架：JAX-RS实现与JSON/HTTPS支持详解
"Jersey框架是用于开发RESTful Web Services的开源Java框架，它基于JAX-RS API，是该标准的参考实现之一。 Jersey框架的特点包括但不限于： 1. **简介**：Jersey简化了Java开发RESTful Web Services的过程，尤其是...
Java使用Jersey框架构建 RESTful Web服务返回json数据所需的jar包
10-22
Java使用Jersey框架构建 RESTful Web服务返回json数据所需的jar包。Jackson-core-asl.jar / Jackson-jaxrs.jar / Jackson-mapper-asl.jar / Jackson-xc.jar / jersey-media-json-Jackson.jar
Jersey框架详解：RESTful服务的Java利器
深入了解JAVA Jersey框架 JAVA Jersey是一个强大的、轻量级的RESTful Web服务开发框架，它由Oracle公司（以前是Sun Microsystems）开发，旨在简化基于Java的Web服务创建过程，尤其是在处理RESTful API方面。与传统...
Jersey框架详解：Webservice入门与RESTful实践
Jersey作为Java的一个实现，提供了对REST（Representational State Transfer）架构风格的支持，这种风格强调使用HTTP方法（GET、POST、PUT、DELETE等）来操作资源，以及使用URI（统一资源标识符）来定位资源。...
jersey-json-1.9-API文档-中英对照版.zip
04-20
赠送jar包：jersey-json-1.9.jar； 赠送原API文档：jersey-json-1.9-javadoc.jar； 赠送源代码：jersey-json-1.9-sources.jar； 赠送Maven依赖信息文件：jersey-json-1.9.pom； 包含翻译后的API文档：jersey-json-1.9-javadoc-API文档-中文(简体)-英语-对照版.zip； Maven坐标：com.sun.jersey:jersey-json:1.9； 标签：jersey、json、sun、jar包、java、API文档、中英对照版； 使用方法：解压翻译后的API文档，用浏览器打开“index.html”文件，即可纵览文档内容。 人性化翻译，文档中的代码和结构保持不变，注释和说明精准翻译，请放心使用。 双语对照，边学技术、边学英语。
jersey - json(jsonp 跨域)格式交互
weixin_34082695的博客
03-31 213
JacksonFeature.class 在使用Tomcat作为HttpServer时，需要特别注意，实现java对象到json的解析时必须注册到JacksonFeature类，自己写的MyProvider不行。 //自己写MyProvider 不能用，不知道为什么 @Provider public class MyProvider implemen...
jersey--服务端接收客户端json数据
a879365197的专栏
03-10 5717
一、jersey从客户端接收post数据，当客户端json有数据名时，和客户端数据没有数据名时。 1、当客户端json数据有数据名时，   在服务端 用 HttpServletRequest req;                          req.getParameter(数据名); 2、当客户端json数据 没有数据名时候                 StringBuf
Jersey支持json格式
weixin_34392435的博客
01-14 139
Jersey支持json格式 官网上看得不太明白，好几种方法，有些要自动匹配，有些要写配置代码让jersey去识别json格式的数据。 在stack over flow上有个回答解决了困扰我的问题： http://stackoverflow.com/questions/29136404/severe-messagebodywriter-not-found-for-media-type-app...
使用jersey书写接口，如何接受json类型参数（springMVC同理）
m0_37897396的博客
05-11 6387
@POST @Path("/balance") @Produces(MediaType.APPLICATION_JSON) //定义了接收的请求 content-type 为 json               @Consumes(MediaType.APPLICATION_JSON) public Map&lt;String,Object&gt; openOnOff(...
java jersey 搭建_章二、jersey+json搭建服务器以及使用jersey搭建客户端
weixin_30647423的博客
02-24 1109
还是老规矩，直接上代码：1、服务器1.1 服务器所需JAR包： 上图中红色框中的三个JAR包是搭建jersey+json REST服务器的核心包，其中genson-1.3.jar比较重要，是对JSON数据处理的重要JAR包。另外json-lib-2.4-jdk15是第三方处理JSON数据的JAR包，博主在其他地方也喜欢用这个包来处理JSON数据，很方便。maven依赖：com.sun.jersey...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值