Spring Boot 学习记录笔记【 三 】
封装入参和出参
封装入参和出参，目的是因为我们的实体类，存放的字段有些是我们不需要返回或者返回的字段实体类里面并没有，这个时候我们就需要进行删除和添加，如果我们单独封装入参和出参就能解决，当然也有别的办法进行解决，还是因人而异，只为记录。觉得有用就点个赞吧！！！
- 首先封装了一个统一的返回公用类，格式统一，方便前后端调试。
package com.zcf.monitor.resp;
/**
* 通用返回类
* @param <T>
*/
public class CommonResp<T> {
/**
* 业务上的成功或失败
*/
private boolean success = true;
/**
* 返回信息
*/
private String message;
/**
* 返回泛型数据，自定义类型
*/
private T content;
public boolean getSuccess() {
return success;
}
public void setSuccess(boolean success) {
this.success = success;
}
public String getMessage() {
return message;
}
public void setMessage(String message) {
this.message = message;
}
public T getContent() {
return content;
}
public void setContent(T content) {
this.content = content;
}
@Override
public String toString() {
final StringBuffer sb = new StringBuffer("ResponseDto{");
sb.append("success=").append(success);
sb.append(", message='").append(message).append('\'');
sb.append(", content=").append(content);
sb.append('}');
return sb.toString();
}
}
修改前
修改后
可以看出来，修改前返回的是List，修改后返回的是CommonResp返回类，里面包含了返回状态success，返回信息内容message 可以带上一句话，返回content 里面包含了List，这个content 是一个泛型数据，可以自定义类型。
- 我定义了一个TestResp类
从这一次的返回结果和上面的返回结果进行对比，我们可以看出，Test表里面password字段并没有返回，这就是我在定义TestResp类的时候，没有添加password字段。
package com.zcf.monitor.resp.query;
import java.util.StringJoiner;
public class TestResp {
private Long id;
private String name;
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return new StringJoiner(", ", TestResp.class.getSimpleName() + "[", "]")
.add("id=" + id)
.add("name='" + name + "'")
.toString();
}
}
可以看出，把返回的List 转换成List ，我们可以在返回的 TestResp 类里面根据实际需要添加和删除我们需要的字段。注意：TestResp 类 和 Test 类 可以一样，也可以不一样。出参就是这样，那入参也是同样的道理。
package com.zcf.monitor.req.save;
import java.util.StringJoiner;
public class TestReq {
private Long id;
private String name;
private String password;
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
@Override
public String toString() {
return new StringJoiner(", ", TestReq.class.getSimpleName() + "[", "]")
.add("id=" + id)
.add("name='" + name + "'")
.add("password='" + password + "'")
.toString();
}
}
分页
看这个请求就是查询第1页，每页3条数据，返回结果就是总条数12条，展示3条数据。这就是分页的效果。由此，修改了查询代码，添加了分页进来。
从SQL日志可以看出，分页查询一共执行了两条sql，第一条是查询了一共有多少条数据，第二条是查询了第1页，每页3条的数据。
里面用到了TestQueryReq 类、PageResp 类，我们来看一下。
package com.zcf.monitor.req.query;
import com.zcf.monitor.req.PageReq;
import java.util.StringJoiner;
public class TestQueryReq extends PageReq {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return new StringJoiner(", ", TestQueryReq.class.getSimpleName() + "[", "]")
.add("name='" + name + "'")
.toString();
}
}
TestQueryReq 类主要是查询使用，可以看出，我的查询条件是name，分页主要用到是继承的PageReq 类
package com.zcf.monitor.req;
import javax.validation.constraints.Max;
import javax.validation.constraints.NotNull;
/**
* 分页
*/
public class PageReq {
@NotNull(message = "【页码】不能为空")
private int page;
@NotNull(message = "【每页条数】不能为空")
@Max(value = 1000,message = "【每页条数】不能超过1000")
private int size;
public int getPage() {
return page;
}
public void setPage(int page) {
this.page = page;
}
public int getSize() {
return size;
}
public void setSize(int size) {
this.size = size;
}
@Override
public String toString() {
return "PageReq{" +
"page=" + page +
", size=" + size +
'}';
}
}
PageReq 类就是作为分页的入参类，page表示当前页，size表示每页条数。此类一般都作为公用的父类，被其他类所继承使用。
package com.zcf.monitor.resp;
import java.util.List;
/**
* 分页返回
* @param <T>
*/
public class PageResp<T> {
private long total;
private List<T> list;
public long getTotal() {
return total;
}
public void setTotal(long total) {
this.total = total;
}
public List<T> getList() {
return list;
}
public void setList(List<T> list) {
this.list = list;
}
@Override
public String toString() {
return "PageResp{" +
"total=" + total +
", list=" + list +
'}';
}
}
PageResp 类是作为分页返回数据的一个类，一般是只返回总条数和分页的List数据，因为这个类可能会被很多List<实体类>使用，用到了 T 作为泛型使用。
工具类
之前新增的时候使用到一个snowFlake.nextId()，这是一个雪花算法的工具类，可以生成一组18位的雪花ID。
package com.zcf.monitor.utils;
import org.springframework.stereotype.Component;
import java.text.ParseException;
/**
* Twitter的分布式自增ID雪花算法
**/
@Component
public class SnowFlake {
/**
* 起始的时间戳
*/
private final static long START_STMP = 1609459200000L; // 2021-01-01 00:00:00
/**
* 每一部分占用的位数
*/
private final static long SEQUENCE_BIT = 12; //序列号占用的位数
private final static long MACHINE_BIT = 5; //机器标识占用的位数
private final static long DATACENTER_BIT = 5;//数据中心占用的位数
/**
* 每一部分的最大值
*/
private final static long MAX_DATACENTER_NUM = -1L ^ (-1L << DATACENTER_BIT);
private final static long MAX_MACHINE_NUM = -1L ^ (-1L << MACHINE_BIT);
private final static long MAX_SEQUENCE = -1L ^ (-1L << SEQUENCE_BIT);
/**
* 每一部分向左的位移
*/
private final static long MACHINE_LEFT = SEQUENCE_BIT;
private final static long DATACENTER_LEFT = SEQUENCE_BIT + MACHINE_BIT;
private final static long TIMESTMP_LEFT = DATACENTER_LEFT + DATACENTER_BIT;
private long datacenterId = 1; //数据中心
private long machineId = 1; //机器标识
private long sequence = 0L; //序列号
private long lastStmp = -1L;//上一次时间戳
public SnowFlake() {
}
public SnowFlake(long datacenterId, long machineId) {
if (datacenterId > MAX_DATACENTER_NUM || datacenterId < 0) {
throw new IllegalArgumentException("datacenterId can't be greater than MAX_DATACENTER_NUM or less than 0");
}
if (machineId > MAX_MACHINE_NUM || machineId < 0) {
throw new IllegalArgumentException("machineId can't be greater than MAX_MACHINE_NUM or less than 0");
}
this.datacenterId = datacenterId;
this.machineId = machineId;
}
/**
* 产生下一个ID
*
* @return
*/
public synchronized long nextId() {
long currStmp = getNewstmp();
if (currStmp < lastStmp) {
throw new RuntimeException("Clock moved backwards. Refusing to generate id");
}
if (currStmp == lastStmp) {
//相同毫秒内，序列号自增
sequence = (sequence + 1) & MAX_SEQUENCE;
//同一毫秒的序列数已经达到最大
if (sequence == 0L) {
currStmp = getNextMill();
}
} else {
//不同毫秒内，序列号置为0
sequence = 0L;
}
lastStmp = currStmp;
return (currStmp - START_STMP) << TIMESTMP_LEFT //时间戳部分
| datacenterId << DATACENTER_LEFT //数据中心部分
| machineId << MACHINE_LEFT //机器标识部分
| sequence; //序列号部分
}
private long getNextMill() {
long mill = getNewstmp();
while (mill <= lastStmp) {
mill = getNewstmp();
}
return mill;
}
private long getNewstmp() {
return System.currentTimeMillis();
}
}
CopyUtil 类是一个复制的工具类，当然也可以使用for循环替代。里面包含了单体复制和列表复制，简化了我们的代码编写。
package com.zcf.monitor.utils;
import org.springframework.beans.BeanUtils;
import org.springframework.util.CollectionUtils;
import java.util.ArrayList;
import java.util.List;
/**
* 复制工具类
*/
public class CopyUtil {
/**
* 单体复制
*/
public static <T> T copy(Object source, Class<T> clazz) {
if (source == null) {
return null;
}
T obj = null;
try {
obj = clazz.newInstance();
} catch (Exception e) {
e.printStackTrace();
return null;
}
BeanUtils.copyProperties(source, obj);
return obj;
}
/**
* 列表复制
*/
public static <T> List<T> copyList(List source, Class<T> clazz) {
List<T> target = new ArrayList<>();
if (!CollectionUtils.isEmpty(source)){
for (Object c: source) {
T obj = copy(c, clazz);
target.add(obj);
}
}
return target;
}
}
SpringBootAOP的使用
配置AOP，我们在之前pom.xml 添加了AOP的依赖。打印接口耗时、请求参数、返回参数
package com.zcf.monitor.aspect;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.support.spring.PropertyPreFilters;
import com.zcf.monitor.utils.RequestContext;
import com.zcf.monitor.utils.SnowFlake;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.slf4j.MDC;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
import org.springframework.web.multipart.MultipartFile;
import javax.annotation.Resource;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
@Aspect //切面
@Component
public class LogAspect {
private final static Logger LOG = LoggerFactory.getLogger(LogAspect.class);
@Resource
private SnowFlake snowFlake;
/** 定义一个切点 */
@Pointcut("execution(public * com.zcf.*.controller..*Controller.*(..))")
public void controllerPointcut() {}
//前置通知
@Before("controllerPointcut()")
public void doBefore(JoinPoint joinPoint) throws Throwable {
// 增加日志流水号
MDC.put("LOG_ID", String.valueOf(snowFlake.nextId()));
// 开始打印请求日志
ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
HttpServletRequest request = attributes.getRequest();
Signature signature = joinPoint.getSignature();
String name = signature.getName();
// 打印请求信息
LOG.info("------------- 开始 -------------");
LOG.info("请求地址: {} {}", request.getRequestURL().toString(), request.getMethod());
LOG.info("类名方法: {}.{}", signature.getDeclaringTypeName(), name);
LOG.info("远程地址: {}", request.getRemoteAddr());
RequestContext.setRemoteAddr(getRemoteIp(request));
// 打印请求参数
Object[] args = joinPoint.getArgs();
// LOG.info("请求参数: {}", JSONObject.toJSONString(args));
Object[] arguments = new Object[args.length];
for (int i = 0; i < args.length; i++) {
if (args[i] instanceof ServletRequest
|| args[i] instanceof ServletResponse
|| args[i] instanceof MultipartFile) {
continue;
}
arguments[i] = args[i];
}
// 排除字段，敏感字段或太长的字段不显示
String[] excludeProperties = {"password", "file"};
PropertyPreFilters filters = new PropertyPreFilters();
PropertyPreFilters.MySimplePropertyPreFilter excludefilter = filters.addFilter();
excludefilter.addExcludes(excludeProperties);
LOG.info("请求参数: {}", JSONObject.toJSONString(arguments, excludefilter));
}
// 环绕通知
@Around("controllerPointcut()")
public Object doAround(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
long startTime = System.currentTimeMillis();
Object result = proceedingJoinPoint.proceed();
// 排除字段，敏感字段或太长的字段不显示
String[] excludeProperties = {"password", "file"};
PropertyPreFilters filters = new PropertyPreFilters();
PropertyPreFilters.MySimplePropertyPreFilter excludefilter = filters.addFilter();
excludefilter.addExcludes(excludeProperties);
LOG.info("返回结果: {}", JSONObject.toJSONString(result, excludefilter));
LOG.info("------------- 结束 耗时：{} ms -------------", System.currentTimeMillis() - startTime);
return result;
}
}
从上面两个控制台的显示看出来，打印出请求地址，类名方法，远程地址，请求参数，以及执行一条分页查询，耗时时间。使用MDC.put，可以为logback增加自定义参数，绿色的是日志流水号，为今后查找报错能快速定位。
结尾
到这里，Spring Boot 项目封装了入参和出参，添加了分页，工具类，还继承了SpringBootAOP的使用，文章是记录自己的学习笔记，或多或少都有问题和遗漏，欢迎留言，一起进步。继续更新Spring Boot 学习记录笔记【 四 】
175
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
