使用带有 JSON 和 Jersey 的 JAX-RS 的 Rest Service CRUD 操作

CRUD代表创建、读取、更新和删除操作

这些是我们在任何应用程序中执行的最常见的操作。

让我们使用带有 Jersey 和 JSON 的 Rest 服务来执行这些操作。

要求 ：

对 USER 对象执行 CRUD 操作。

我们有用户域对象，我们可以插入用户数据，读取插入的数据，

更新一些用户信息，最后删除用户数据。

在eclipse中新建一个Maven Web项目（参考Rest service Hello World 项目同理）

项目结构

第1步

使用以下依赖项更新 pom.xml

<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/maven-v4_0_0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>CRUDWithRestAndJson</groupId>
    <artifactId>CRUDWithRestAndJson</artifactId>
    <packaging>war</packaging>
    <version>0.0.1-SNAPSHOT</version>
    <name>CRUDWithRestAndJson Maven Webapp</name>
    <url>http://maven.apache.org</url>
    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>3.8.1</version>
            <scope>test</scope>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.glassfish.jersey.media/jersey-media-moxy -->
        <dependency>
            <groupId>org.glassfish.jersey.media</groupId>
            <artifactId>jersey-media-moxy</artifactId>
            <version>2.25</version>
        </dependency>
        <dependency>
            <groupId>org.glassfish.jersey.containers</groupId>
            <artifactId>jersey-container-servlet</artifactId>
            <version>2.24</version>
        </dependency>

    </dependencies>
    <build>
        <finalName>CRUDWithRestAndJson</finalName>
    </build>
</project>

我们在上面的pom文件中添加了Jersey servlet、jersey-media-moxy 和 Junit的依赖项。jersey-media-moxy依赖项用于自动JSON 支持，无需任何其他配置。

第2步

使用Jersey servlet 容器更新web.xml文件

我们在web.xml中定义了一个名为“jersey-serlvet”的特殊 servlet，并通过 URL 模式/rest/*映射它

因此，就像Web 应用程序中的任何其他servlet一样，任何与给定模式匹配的请求（即/rest/*）都将被重定向到“Jersey servelt”。

<!DOCTYPE web-app PUBLIC
 "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
 "http://java.sun.com/dtd/web-app_2_3.dtd" >

<web-app>
    <display-name>Archetype Created Web Application</display-name>
    <servlet>
        <servlet-name>jersey-serlvet</servlet-name>
        <servlet-class>org.glassfish.jersey.servlet.ServletContainer</servlet-class>
        <init-param>
            <param-name>jersey.config.server.provider.packages</param-name>
            <param-value>com.kb.rest.resource</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>

    <servlet-mapping>
        <servlet-name>jersey-serlvet</servlet-name>
        <url-pattern>/rest/*</url-pattern>
    </servlet-mapping>
</web-app>

我们还在init-param标签下提供了java 类的包（被限定为 Rest 服务） 。

当请求进来时，Jersey servlet 容器会考虑这个包来识别实际的服务。

第 3 步

创建一个表示数据的域类

我们将对这个对象执行CRUD 操作。

package com.kb.model;

public class User {

    private String id;
    private String name;
    private int age;

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

我们创建了一个带有id、name 和 age的User类来表示数据

该对象将被转换为JSON并从Jersey JSON 支持返回对象

第四步

创建将具有 URL 映射方法的资源映射类

package com.kb.rest.resource;

import java.util.List;

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

import com.kb.model.User;
import com.kb.service.UserService;

@Path("/userInfo")
public class UserResource {

    UserService userService = new UserService();

    // CRUD -- CREATE operation
    @POST
    @Produces(MediaType.APPLICATION_JSON)
    @Consumes(MediaType.APPLICATION_JSON)
    public User createUser(User user) {
        User userResponse = userService.createUser(user);
        return userResponse;
    }

    // CRUD -- READ operation
    @GET
    @Produces(MediaType.APPLICATION_JSON)
    public List<User> getAllUsers() {
        List<User> userList = userService.getAllUsers();
        return userList;
    }

    // CRUD -- READ operation
    @GET
    @Path("/{id}")
    @Produces(MediaType.APPLICATION_JSON)
    public User getUserForId(@PathParam("id") String id) {
        User user = userService.getUserForId(id);
        return user;
    }

    // CRUD -- UPDATE operation
    @PUT
    @Produces(MediaType.APPLICATION_JSON)
    @Consumes(MediaType.APPLICATION_JSON)
    public User updateUser(User user) {
        User userResponse = userService.updateUser(user);
        return userResponse;
    }

    // CRUD -- DELETE operation
    @DELETE
    @Path("/{id}")
    @Produces(MediaType.APPLICATION_JSON)
    public User deleteeUser(@PathParam("id") String id) {
        User userResponse = userService.deleteUser(id);
        return userResponse;
    }
}

我们在上面创建了 Rest 服务类，它将处理GET、POST、PUT 和 DELETE操作

@Path(“/userInfo”)

此注释有助于将请求 URL映射到适当的Rest 服务。 因此，任何带有/userInfo（相对于基本 URL）的请求都将映射到UserResource。
 

@POST

此注释指定此方法仅接受POST 请求。

@GET

此注解指定此方法只接受GET 请求

@PUT

此注解指定此方法只接受PUT 请求

@DELETE

此注释指定此方法仅接受DELETE 请求。

@Path(“/{id}”)

此注解用于指定 URL 将包含输入值以完全匹配。在此处
阅读有关路径变量的更多信息

@Produces(MediaType.APPLICATION_JSON)

此注解用于指定服务可以生成并将其发送给客户端的数据（MIME 类型）的表示。

此注解可以在类级别或方法级别使用。

如果在类级别应用此注解，则类中的所有方法默认可以产生相同的 MIME 类型数据。

但是，我们可以在方法级别使用不同的 MIME 类型覆盖它。

我们还可以指定多个 MIME 类型，如下所示@Produces({“application/xml”, “application/json”})

@Consumes(MediaType.APPLICATION_JSON)

此注释用于指定服务可以从客户端接受的数据（MIME 类型）的表示。

此注解可以在类级别或方法级别使用。

如果在类级别应用此注解，则类中的所有方法将默认接受来自客户端的相同 MIME 类型数据。

但是，我们可以在方法级别使用不同的 MIME 类型覆盖它。

我们还可以指定多个 MIME 类型，如下所示@Consumes({“application/xml”, “application/json”})

第 5 步

创建业务服务类

package com.kb.service;

import java.util.List;

import com.kb.dao.UserDAO;
import com.kb.model.User;

public class UserService {

    UserDAO userDao = new UserDAO();

    public List<User> getAllUsers() {
        List<User> userList = userDao.getAllUsers();
        return userList;
    }

    public User getUserForId(String id) {
        User user = userDao.getUserForId(id);
        return user;
    }

    public User createUser(User user) {
        User userResponse = userDao.createUser(user);
        return userResponse;
    }

    public User updateUser(User user) {
        User userResponse = userDao.updateUser(user);
        return userResponse;
    }

    public User deleteUser(String id) {
        User userResponse = userDao.deleteUser(id);
        return userResponse;
    }

}

我们在上面的类中定义了5个方法

getAllUsers() - 此方法用于获取所有用户，有助于服务GET请求

getUserForId(String id) - 此方法用于获取特定用户的用户详细信息，有助于为特定用户提供GET请求

createUser(User user) - 此方法用于插入新用户详细信息，有助于服务POST请求

updateUser(User user) - 此方法用于更新用户详细信息，有助于服务PUT请求

deleteUser(String id) - 此方法用于删除用户详细信息，有助于处理DELETE请求

第 6 步

创建 DAO 类

package com.kb.dao;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;

import com.kb.model.User;

//Just to avoid DB calls in this example, Assume below data is interacting with DB
public class UserDAO {

    static HashMap<String, User> usersMap = new HashMap<String, User>();

    public UserDAO() {
        User user1 = new User();
        user1.setId("1");
        user1.setAge(20);
        user1.setName("raj");

        User user2 = new User();
        user2.setId("2");
        user2.setAge(21);
        user2.setName("ram");

        usersMap.put("1", user1);
        usersMap.put("2", user2);
    }

    public List<User> getAllUsers() {

        List<User> userList = new ArrayList<User>(usersMap.values());
        return userList;
    }

    public User getUserForId(String id) {
        User user = usersMap.get(id);
        return user;
    }

    public User createUser(User user) {
        usersMap.put(user.getId(), user);
        return usersMap.get(user.getId());
    }

    public User updateUser(User user) {
        if (usersMap.get(user.getId()) != null) {
            usersMap.get(user.getId()).setName(user.getName());
        } else {
            usersMap.put(user.getId(), user);
        }
        return usersMap.get(user.getId());
    }

    public User deleteUser(String id) {
        User userResponse = usersMap.remove(id);
        return userResponse;
    }

}

我们创建了DAO类来支持所有的CRUD操作

我们使用usersMap来存储用户详细信息（只是为了避免数据库交互）

在构造函数中，我们在userMap中添加了2 个用户详细信息。

所有其他方法将使用此userMap来读取、插入、更新和删除用户详细信息。

第 7 步

构建和部署项目

第 8 步

让我们使用 Advanced Rest 客户端查看所有 CRUD 操作的输出
 

邮政

网址：
http://localhost:8080/CRUDWithRestAndJson/rest/userInfo

选择内容类型“ application/json ”

请求正文

{
"age": 30,
"id": "1",
"name": "John"
}

选择POST方法

我们可以在响应中看到200 状态。

得到

网址：
http://localhost:8080/CRUDWithRestAndJson/rest/userInfo

选择GET方法

 

使用特定用户 ID 获取

网址：
http://localhost:8080/CRUDWithRestAndJson/rest/userInfo/1

选择GET方法

 

放

网址：
http://localhost:8080/CRUDWithRestAndJson/rest/userInfo

选择内容类型“ application/json ”

请求正文

{
"age": 30,
"id": "3",
"name": "John"
}

选择PUT方法

 

我们可以在响应中看到200 状态。

删除

网址：
http://localhost:8080/CRUDWithRestAndJson/rest/userInfo/3

选择删除方法

 

现在尝试使用GET获取此记录以验证它是否被删除

我们可以看到记录被删除了。