Jersey框架简单实践（一）

一、RESTful

REST（Representational State Transfer 表现层状态转化） 是一组架构约束，而不是协议或标准。通常定义：

• 每一个URI代表一种资源；
• 客户端和服务器之间，传递这种资源的某种表现层；
• 客户端通过四个HTTP动词，对服务器端资源进行操作，实现"表现层状态转化"。

一般实现了RESTful的架构更结构清晰、符合标准、易于理解、扩展方便，所以正得到越来越多网站的采用。

二、Jersey框架

Jersey是一个RESTful服务JAVA框架，与常规的JAVA编程使用的Struts框架类似，它主要用于处理业务逻辑层。Jersey是一个是 webservice框架。
通过简单的配置，即可打造极简主义的REST接口。其实就是可以把我们的服务层开放API供前端调用。

与SpringMVC的区别：

1. Jersey同样提供DI，是由glassfish hk2实现，也就是说，如果想单独使用Jersey一套，需要另外学习Bean容器；

2. MVC出发点是WEB，但Jersey出发点是RESTful，体现点在与接口的设计方面，如MVC返回复杂结构需要使用ModelAndView，而Jersey仅仅需要返回一个流或者文件句柄；

3. Jersey提供一种子资源的概念，这也是RESTful中提倡所有url都是资源；

4. Jersey直接提供application.wadl资源url说明；

5. MVC提供Session等状态管理，jersey没有，这个源自RESTFull设计无状态化；

6. Response方法支持更好返回结果，方便的返回Status，包括200，303，401，403；

7. 提供超级特别方便的方式访问RESTful;

以下是demo案例：

maven引用：

<?xml version="1.0" encoding="UTF-8"?>
<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">
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.4.RELEASE</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>jersey</artifactId>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jersey</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>
</project>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

Jersey配置，需要被Spring扫描到：
1、自定义资源配置类继承类ResourceConfig，通过register方法注册自己的资源。
2、在bean中新建资源配置类ResourceConfig，并返回此config。

注册我们的服务的时候有两种方式，一种是直接将类注册进去，一种是通过扫描包，建议是使用注册类的方式，比较好控制。如果服务非常多，使用包扫描的方式也可，自行定夺。

package org.self.zhlxf.config;

import org.glassfish.jersey.jackson.internal.jackson.jaxrs.json.JacksonJsonProvider;
import org.glassfish.jersey.server.ResourceConfig;
import org.self.zhlxf.service.impl.UserService;
import org.springframework.context.annotation.Configuration;


import javax.ws.rs.ApplicationPath;

@Configuration
@ApplicationPath("/") // 这里指定了路由的根路径，可自行配置，习惯用/
public class JerseyConfig extends ResourceConfig {
    public JerseyConfig() {
        // 注册json解析
        register(JacksonJsonProvider.class);
        // 通过类名单个注册
        register(UserService.class);
        // 通过扫描包注册包里面的所有服务
        // packages("org.self.zhlxf.service");
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

编写统一的返回对象：

package org.self.zhlxf.pojo;

public class ApiResponseBody<T> {
    private Integer code;
    private T data;
    private String message;

    public ApiResponseBody() {
    }

    public ApiResponseBody(Integer code, T data, String message) {
        this.code = code;
        this.data = data;
        this.message = message;
    }

    public Integer getCode() {
        return code;
    }

    public void setCode(Integer code) {
        this.code = code;
    }

    public T getData() {
        return data;
    }

    public void setData(T data) {
        this.data = data;
    }

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }

    @Override
    public String toString() {
        return "ApiResponseBody{" +
                "code=" + code +
                ", data=" + data +
                ", message='" + message + '\'' +
                '}';
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

编写服务类：

package org.self.zhlxf.service;

import org.self.zhlxf.pojo.ApiResponseBody;

public interface IUserService {
    ApiResponseBody allUser();

    String getUserById();
}

1
2
3
4
5
6
7
8
9
10

package org.self.zhlxf.service.impl;

import org.jvnet.hk2.annotations.Service;
import org.self.zhlxf.pojo.ApiResponseBody;
import org.self.zhlxf.pojo.User;
import org.self.zhlxf.service.IUserService;

import javax.ws.rs.GET;
import javax.ws.rs.Path;
import javax.ws.rs.Produces;
import javax.ws.rs.core.MediaType;
import java.util.ArrayList;
import java.util.List;

@Service
@Path("/user")
public class UserService implements IUserService {
    @GET
    @Override
    @Produces(MediaType.APPLICATION_JSON + ";charset=utf-8")
    public ApiResponseBody allUser() {
        List<User> ant = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            ant.add(new User("小明" + i + "号", 5 + i));
        }
        return new ApiResponseBody(200, ant, "success");
    }
    
    @GET
    @Path("/{id}")
    @Produces(MediaType.APPLICATION_JSON + ";charset=utf-8")
    @Override
    public String getUserById() {
        return "小明";
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

浏览器调用：localhost:8080/user

至此，一个基于jersey框架的RESTful简单demo就完毕了，更多的服务自行注册即可。