api接口的返回信息封装（code，message，data）与分页数据封装，通用。

源码来自github上一个Java的学习项目 mall-learning下的mall-tiny01
GitHub链接🔗

先看目录结构

• common
  • api
    • CommonPage （分页数据封装📦）
    • CommonResult （通用返回对象）
    • IErrorCode （interface，封装API的错误码）
    • ResultCode（枚举一些常用的API操作码）

一、

对于一个简单的api，最显而易见的就是 码（code） 和 信息（message），故对于这通用的方法，就写到接口里，接口里就只设置两个获取方法，获取 code和获取message

public interface IErrorCode{
	long getCode();
	String getMessage();
}

二、

新建枚举类ResultCode实现IErrorCode接口，主要内容几点

1. 继承接口里的两个方法（getCode和getMessage）
2. 既然有两个方法，所以必须也的有相关属性（code和message）
3. 构造函数（两个参数的）（构造函数会在类被使用前调用）
4. 枚举一些常用的api操作码和提示信息

public enum ResultCode implements IErrorCode{
	SUCCESS(200,"操作成功"),
	FAILED(500,"操作失败"),
	VALIDATE_FAILED(404,"参数校验失败")
	UNAUTHORIZED(401,"暂未登陆或token已经过期")
	FORBIDDEN(403,"没有相关权限");
	
	private long code;
	private String messsage;
	
	private ResultCode(long code,String message){
		this.code = code;
		this.message = message;
	}
	
	public long getCode(){ return code;}
	public String getMessage(){ return message;}
}

三、

新建返回对象类CommonResult< T >,该类比上面👆第二步的多了数据的处理（T data）

1. 首先还是写出三个基础属性（long code,String message,T data)
2. 给该类写无参和有参的构造方法
3. 给该类的三个属性编写get和set，来供其他类使用（获取或设值）
4. 最后编写通用的几种情况（根据不同的参数，重载几个方法）
   • 成功返回结果 Class.success(T data)//默认code默认message
   • 成功返回结果 Class.success(T data,String message)//默认code，传了message和data
   • 失败返回结果 Class.failed(IErrorCode errorCode)//默认code，默认message，无data
   • 失败返回结果 Class.failed(String message)//默认code，传了message，无data
   • 失败返回结果 Class.failed()
   • 参数验证失败返回结果 Class.validateFailed()
   • 参数验证失败返回结果 Class.validateFailed(String message)
   • 未登陆返回结果 Class.unauthorized(T data)
   • 未授权返回结果 Class.forbidden(T data)

1.成功返回结果

/**
*成功返回结果
*@param data 获取的数据
*/
public static<T> CommonResult<T> success(T data){
	return new CommonResult<T>(
		ResultCode.SUCCESS.getCode(),
		ResultCode.SUCCESS.getMessage(),
		data);
}

*方法名：success
*参数行参 data，参数类型T
*方法返回值类型 ComonResult //CommonResult就是上面定义的包含了code，message和data的类

*关于public static < T > CommonResult< T > success

CommonResult< T > 是返回值类型，很好理解。

然后这个success是方法名，

先看这个CommonResult类它的定义``public class CommonResult<T>``,我们把这个CommonResult叫做 声明了< T >的类（声明了范型的类）。

而对于声明了范型的类，该类下的方法就不用继续声明了（就是不用再继续添加< T >了，比如对于类里属性的get和set方法就不需要声明范型)。

success是类CommonResult类下的方法，按照上一句的理论来说它是不需要加范型的，但是这个方法被static修饰了，（被static修饰的方法严格来说就不是该类的一部分了），所以需要添加范型标志< T >。

（为什么要加static？我目前对static的理解是，被static修饰的，不需要依赖类来进行调用，只要类被加载了，直接调用类名即可）

2.成功返回结果

/**
*成功返回结果
*@param data 获取的数据
*@param message 提示信息
*/
public static <T> CommonResult<T> success(T data,String message){
	return new CommonResult<T>(ResultCode.SUCCESS.getCode(),message,data);
}

关于ResultCode类，就是前面提到的枚举类，枚举类一些常见的码还有默认的提示信息

3.失败返回结果

/**
*失败返回结果
*@param errorCode 错误码
*/
public static <T> CommonResult<T> failed(IErrorCode errorCode){
	return new CommonResult<T>(errorCode.getCode(),errorCode.getMessage(),null);
}

入参是errorCode，里面本身就有getCode方法和getMessage方法，所以对于传进来的对象，直接调用这两个方法就行了

4.失败返回结果

/**
*失败返回结果
*@param message 提示信息
*/
public static <T> CommonResult<T> failed(String message){
	return new CommonResult<T>(ResultCode.FAILED.getCode(),message,null);
}

这个也很好理解，入参是message（提示信息），那么码就用默认的

5.失败返回结果

/**
*失败返回结果
*/
public static <T> CommonResult<T> failed(){
	return failed(ResultCode.FAILED);
}

此处的failed调用了上述的第三个方法，参数是ResultCode.FAILED，

6.参数验证失败

/**
*参数验证失败
*/
public static <T> CommonResult<T> validateFailed(){
	return failed(ResultCode.VALIDATE_FAILED);
}

此处的failed也是调用的上述的第三个方法，参数是ResultCode.VALIDATE_FAILED

7.参数验证失败返回结果

/**
*参数验证失败返回结果
*@param message 提示信息
*/
public static <T> CommonResult<T> validateFailed(String message){
	return new CommonResult<T>(ResultCode.VALIDATE_FAILED.getCode(),message,null);
}

8.未登陆返回结果

/**
*未登陆返回结果
*@param data 获取数据
*/
public static <T> CommonResult<T> unauthorized(T data){
	return new CommonResult<T>(ResultCode.UNAUTHORIZED.getCode(),ResultCode.UNAUTHORIZED.getMessage(),data);
}

9.未授权返回结果

/**
*为授权返回结果
*@param data 获取数据
*/
public static <T> CommonResult<T> forbidden(T data){
	return new CommonResult<T>(ResultCode.FORBIDDEN.getCode(),ResultCode.FORBIDDEN.getMessage(),data);
}

四、

分页数据封装类 CommonPage< T >
分页数据就几个

• pageNum（页码，第几页）
• pageSize（页面大小，一页几条数据）
• totalPage（总页数，一共有多少页）
• total（条数，一共有多少条数据）
• List< T > list (分页数据）

public class CommonPage<T>{
	private Integer pageNum;
	private Integer pageSize;
	private Integer totalPage;
	private Long total;
	private List<T> list;

	//get and set

	public static <T> CommonPage<T> restPage(List<T> list){
		CommonPage<T> result = new CommonPage<>();
		PageInfo<T> pageInfo = new PageInfo<>(list);
		result.setPageNum(pageInfo.getPageNum());
		result.setPageSize(pageInfo.getPageSize());
		result.setTotalPage(pageInfo.getPages());
		result.setTotal(pageInfo.getTotal());
		result.setList(pageInfo.getLIst());
		return result;
	}
}

定义了一个静态方法restPage，
和前面说的一样，因为类的定义里面用了范型< T >，返回值是CommonPage< T >这很好理解，
然后该方法又需要被定义成static， 所以需要再将该方法指定成T类型的范型（也就是为什么要第一个< T >）

分页功能借助了工具类pageinfo，将数据传到pageInfo里，各个分页属性就会被封装好，然后再将pageInfo里的各个属性转移到我们自定义的CommonPage类里就行了