JavaWeb统一响应格式和请求格式简易实现

一. 统一请求格式(后台通用CURD), 适用于SpringDataJpa

1. 基础分页查询类

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 cn.zzzykj.common;

import org.springframework.data.domain.PageRequest;

/**
 * 分页查询基类
 * @author ZhuoQinghui
 */
public class SearchLimit {

    /**
     * 当前页数
     */
    private Integer page;
    /**
     * 每页条数
     */
    private Integer size;

    public SearchLimit() {
    }

    public SearchLimit(Integer page, Integer size) {
        this.page = page;
        this.size = size;
    }

    /**
     * 是否需要分页
     * @return
     */
    public boolean isPage() {
        return size != null && size != 0;
    }

    /**
     * 转化为分页对象
     * @return
     */
    public PageRequest toPage() {
        if (isPage()) {
            if (page == null) {
                page = 0;
            }
            return PageRequest.of(page, size);
        }
        return null;
    }

    public Integer getPage() {
        return page;
    }

    public SearchLimit setPage(Integer page) {
        this.page = page;
        return this;
    }

    public Integer getSize() {
        return size;
    }

    public SearchLimit setSize(Integer size) {
        this.size = size;
        return this;
    }

    @Override
    public String toString() {
        return "SearchLimit{" +
                "page=" + page +
                ", limit=" + size +
                '}';
    }
}

2. 带排序分页查询类

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
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
package cn.zzzykj.common;

import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Sort;

import java.util.ArrayList;
import java.util.List;
import java.util.Locale;
import java.util.Objects;

/**
 * 带排序的分页查询基类
 * @author ZhuoQinghui
 */
public class SortSearchLimit extends SearchLimit {

    /**
     * 排序字段集合
     */
    private List<OrderByItem> orders;

    public SortSearchLimit(List<OrderByItem> orders) {
        this.orders = orders;
    }

    public SortSearchLimit(Integer page, Integer size, List<OrderByItem> orders) {
        super(page, size);
        this.orders = orders;
    }

    public SortSearchLimit() {
    }

    public SortSearchLimit(Integer page, Integer size) {
        super(page, size);
    }

    /**
     * 是否需要排序
     * @return
     */
    public boolean isSort() {
        return orders != null && orders.size() > 0;
    }

    /**
     * 转化为排序对象
     * @return
     */
    public Sort toSort() {
        if (isSort()) {
            ArrayList<Sort.Order> sortOrders = new ArrayList<>(this.orders.size());
            for (OrderByItem order : orders) {
                if (order.getColumn() != null && !Objects.equals(order.getColumn(), "")) {
                    if (order.getOrderType() == null) {
                        sortOrders.add(Sort.Order.by(order.getColumn()));
                    } else if ("DESC".equals(order.getOrderType().toUpperCase(Locale.ROOT))) {
                        sortOrders.add(Sort.Order.desc(order.getColumn()));
                    } else if ("ASC".equals(order.getOrderType().toUpperCase(Locale.ROOT))){
                        sortOrders.add(Sort.Order.asc(order.getColumn()));
                    } else {
                        sortOrders.add(Sort.Order.by(order.getColumn()));
                    }
                }
            }
            return Sort.by(sortOrders);
        }
        return null;
    }

    /**
     * 转化为分页对象
     * @return
     */
    @Override
    public PageRequest toPage() {
        PageRequest page = super.toPage();
        if (page == null) {
            return null;
        }
        if (isSort()) {
            return PageRequest.of(page.getPageNumber(), page.getPageSize(), toSort());
        }
        return page;
    }

    public List<OrderByItem> getOrders() {
        return orders;
    }

    public SortSearchLimit setOrders(List<OrderByItem> orders) {
        this.orders = orders;
        return this;
    }

    @Override
    public String toString() {
        return super.toString() + "OrderSearchLimit{" +
                "orders=" + orders +
                '}';
    }
}

3. 带查询参数对象的可分页排序查询类

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

package cn.zzzykj.common;

import java.util.List;
import java.util.Objects;

/**
 * @author Lenovo
 */
public class BeanSortSearchLimit<T> extends SortSearchLimit {

    private T bean;

    public BeanSortSearchLimit() {
    }

    public BeanSortSearchLimit(List<OrderByItem> orders, T bean) {
        super(orders);
        this.bean = bean;
    }

    public BeanSortSearchLimit(Integer page, Integer size, List<OrderByItem> orders, T bean) {
        super(page, size, orders);
        this.bean = bean;
    }

    public BeanSortSearchLimit(T bean) {
        this.bean = bean;
    }

    public BeanSortSearchLimit(Integer page, Integer size, T bean) {
        super(page, size);
        this.bean = bean;
    }

    public T getBean() {
        return bean;
    }

    public BeanSortSearchLimit<T> setBean(T bean) {
        this.bean = bean;
        return this;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }
        if (o == null || getClass() != o.getClass()) {
            return false;
        }
        BeanSortSearchLimit<?> that = (BeanSortSearchLimit<?>) o;
        return Objects.equals(bean, that.bean);
    }

    @Override
    public int hashCode() {
        return Objects.hash(bean);
    }

    @Override
    public String toString() {
        return "BeanSortSearchLimit{" +
                "bean=" + bean +
                "} " + super.toString();
    }
}

二. 统一响应格式

1. 统一响应对象:

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

package cn.zzzykj.common;

import lombok.Data;
import lombok.experimental.Accessors;

/**
 * @author ZhuoQinghui
 */
@Data
@Accessors(chain = true)
public class Result<T> {

    private Integer code;
    private String msg;
    private T data;

    private Result() {
    }

    private Result(Integer code, String msg, T data) {
        this.code = code;
        this.msg = msg;
        this.data = data;
    }

    public static <T> Result<T> success(String msg, T t) {
        return new Result<>(2000, msg, t);
    }

    public static <T> Result<T> success(T t) {
        return success("SUCCESS", t);
    }

    public static <T> Result<T> success() {
        return success("SUCCESS", null);
    }

    public static <T> Result<T> error(Integer code, String msg, T t) {
        return new Result<>(code, msg, t);
    }

    public static <T> Result<T> error(String msg, T t) {
        return error(-1, msg, t);
    }

    public static <T> Result<T> error(Integer code) {
        return error(code, "ERROR", null);
    }

    public static <T> Result<T> error(String msg) {
        return error(-1, msg, null);
    }

    public static <T> Result<T> error(T t) {
        return error(-1, "ERROR", t);
    }

}

2. 分页接口返回对象

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

package cn.zzzykj.common;

import org.springframework.data.domain.Page;

import java.util.List;

/**
 * 分页请求响应结果格式
 * @author ZhuoQinghui
 * @param <T> 泛型
 */
public class PageResult<T> extends SearchLimit {

    private Integer total;

    private List<T> data;

    public static <T> PageResult<T> convert(SearchLimit searchLimit, Integer total, List<T> data) {
        PageResult<T> result = new PageResult<>();
        result.setTotal(total).setData(data).setPage(searchLimit.getPage()).setSize(searchLimit.getSize());
        return result;
    }

    public static <T> PageResult<T> convert(SearchLimit searchLimit, Page<T> page) {
        PageResult<T> result = new PageResult<>();
        result.setTotal((int) page.getTotalElements()).setData(page.getContent()).setPage(searchLimit.getPage()).setSize(page.getSize());
        return result;
    }

    public List<T> getData() {
        return data;
    }

    public PageResult<T> setData(List<T> data) {
        this.data = data;
        return this;
    }

    public Integer getTotal() {
        return total;
    }

    public PageResult<T> setTotal(Integer total) {
        this.total = total;
        return this;
    }
}