在 JAX-RS 中将 JSON 解组为 Java POJO [英] Unmarshal JSON to Java POJO in JAX-RS

问题描述

我希望获取每个 Json 格式调用的键和值，并将它们用作 java 对象，例如 String 或 Integer ，在我会输入的休息客户端中

{名称":HelloWorld"}

我会取回映射到它的 Key 的 HelloWorld 到目前为止我见过的例子，但我只是无法找出每个标签的作用以及如何解析主体以给出上述结果

@POST@Path("/SetFeeds")@Consumes(MediaType.APPLICATION_JSON)@Produces(MediaType.APPLICATION_JSON)@JsonCreatorpublic String setFeed(String jsonBody,@Context UriInfo uriInfo){//操作请求体的代码返回响应；}

解决方案

首先需要了解的是请求正文解析是如何完成的.在 JAX-RS 解析(或解组/反序列化/任何)中，使用 (基本 getter/setter) 以匹配 JSON 属性.例如，如果你有这个 bean 属性

公共类HelloWorld {私人字符串名称；公共字符串 getName() {返回名称；}公共无效集名称(字符串名称){this.name = 名称；}}

JSON 应该类似于 {"name": "whatever"}.name" 键与 bean 属性相同.在 Bean 属性术语中，属性名称是 get/set 后面的所有字母，首字母小写.

这就是它的全部内容.现在你可以了

@Consumes("application/json")公共响应帖子(HelloWorld helloWorld){字符串名称 = helloWorld.getName();//应该 == 随便"返回 Response.ok(helloWorld).build();//我们也可以返回对象}

对于更复杂的 JSON 格式，您应该参考 Jackson 文档或在此处提出有关 SO 的问题.

至于JacksonJsonProvider的注册，如果您遇到问题，请提供我要求的信息，即应用程序配置(web.xml 或Java 配置)和您使用的服务器.

另见:

• JAX-RS Entity Provider 学习更多关于读者和作者的信息

I am looking to get the key and value to each Json formatted call and use them as java objects such as String or Integer ,in a rest client i would enter

{
  "Name":"HelloWorld"
}

And i would get back the HelloWorld mapped to its Key so far ive seen examples but im just having trouble finding out what each tag does and how to parse the body to give the above results

@POST
@Path("/SetFeeds")
@Consumes(MediaType.APPLICATION_JSON)   
@Produces(MediaType.APPLICATION_JSON) 
@JsonCreator
public String setFeed(String jsonBody,@Context UriInfo uriInfo){        
    // Code to manipulate the body of the request 
    return response;
}

解决方案

First thing you need to understand is how request body parsing is done. In JAX-RS parsing (or unmarshalling/deserializing/whatever) is done with MessageBodyReaders. There are different readers that can handle different Content-Type. For instance if you have Content-Type application/octet-stream, there is a reader that will unmarshal to byte[] or File or InputStream. So the following would work out the box

@Consumes("application/octet-stream")
public Response post(File file) {}  // or `byte[]` or `InputStream`

That being said, JAX-RS implementations come with very basic readers for "easily convertible" format. For example, most requests can be converted to String, so you get that free for most Content-Types, as you are with your current code.

If we want some more complex data types, like your HelloWorld for Content-Type application/json, there is no standard reader for this. For this to work, we either need to create our own reader or use a library that comes with a reader. Luckily, the most popular JSON library in Java, Jackson, has implemented a JAX-RS provider that has a reader and a writer (for serialization).

Now depending on what server/JAX-RS implementation you are using, different implementations create light wrappers around the core Jackson JAX-RS module. If I knew the JAX-RS implementation you were using, I could recommend which wrapper to use, or you can forget the wrapper and just go with the basic Jackson module, which is

<dependency>
  <groupId>com.fasterxml.jackson.jaxrs</groupId>
  <artifactId>jackson-jaxrs-json-provider</artifactId>
  <version>2.2.3</version>
</dependency>

The above is a Maven dependency. If you are not using Maven, then basically you need to download all these jars.

You can find all of them here. Just search for them individually.

Then you need to register the provider. Again it depends on your JAX-RS implementation and how you are handling the configuration of your resource classes. I would need to see your application configuration (either web.xml or Java code) and maybe the server you are using to help with that. For the most part, the JacksonJsonProvider (which is the reader and writer) needs to be registered.

Once you have it registered then you need to understand the basics of how Jackson handles the serialization. At most basic level, Jackson looks for JavaBean properties (basic getter/setter) to match with JSON properties. For instance, if you have this bean property

public class HelloWorld {
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
} 

The JSON should look like {"name": "whatever"}. The "name" key is the same as the bean property. In Bean property terms, the name of the property is all letters after the get/set with the first letter lowercased.

That's pretty much all there is to it. Now you can do

@Consumes("application/json")
public Response post(HelloWorld helloWorld) {
    String name = helloWorld.getName();     // should == "whatever"

    return Response.ok(helloWorld).build(); // we can also return objects
} 

For more complex JSON formats, you should refer to the Jackson documentation or ask a question here on SO.

As far as the registering of the JacksonJsonProvider, if you are having trouble, please provide the information I requested, i.e. application configuration (web.xml or Java config) and the server you are using.

See Also:

• JAX-RS Entity Provider to learn more about readers and writers

这篇关于在 JAX-RS 中将 JSON 解组为 Java POJO的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！