spring boot项目经验技术总结（一）
一、在查询列表的时候，增加相应实体，以完成单字段搜索功能
下图是controller的实现效果
/**
* 根据条件进行筛选返回列表数据
*
* @param product 实体类
* @return 封装响应体
*/
@GetMapping("/list")
public PageInfo list(Product product) {
startPage();
return response(productService.selectProductList(product));
}
下图是mapper.xml关于列表查询搜索的实现
<select id="selectProductList" parameterType="Product" resultMap="baseResultMap">
select * from product
<where>
<if test="title != null and title != '' ">
title like concat('%', #{title}, '%')
if>
...
if>
<if test="time != null ">
and time like concat('%', #{time}, '%')
if>
where>
select>
二、controller抽取出返回前端的判断
相信可能大家一开始会跟我一样，在service层或者controller重复的判断访问mapper的结果之后，就会出现一堆重复的if判断语句，不仅揉余而且不美观
好的解决思路是编写一个BaseController，然后每一个Controller都去实现这个，以达到简洁高效
所有的service返回都用response() 去封装
**
* web层通用数据处理
*
* @author ruige
* @date 2019-08-13 11:06
*/
public class BaseController {
/**
* 响应返回前端结果集
*
* @param rows 影响行数
* @return 操作结果集
*/
protected Result response(int rows) {
return rows > 0 ? Result.success() : Result.fail();
}
/**
* 响应返回前端结果集
*
* @param entity 影响行数
* @return 操作结果集
*/
protected Result response(Object entity) {
return entity != null ? Result.success(entity) : Result.fail();
}
/**
* 响应返回前端列表结果集
*
* @param list
* @return
*/
protected PageInfo response(List<?> list) {
return new PageInfo(list);
}
}
Result响应封装类
/**
* 用于返回成功失败错误的结果信息及状态
*
* @author ruige
* @date 2019-08-13 11:06
*/
public class Result {
/**
* 状态码
*/
private Integer status;
/**
* 返回内容
*/
private Object msg;
/**
* 数据对象
*/
private Object data;
public Result() {
}
/**
* 初始化一个新创建的 Result 对象
*
* @param status
* @param msg
*/
public Result(Integer status, Object msg) {
this.status = status;
this.msg = msg;
}
/**
* 初始化一个新创建的 Result 对象
*
* @param msg
* @param data
*/
public Result(Integer status, Object msg, Object data) {
this.status = status;
this.msg = msg;
this.data = data;
}
/**
* 返回成功消息
*
* @return 成功消息
*/
public static Result success() {
return Result.success("操作成功");
}
/**
* 返回成功数据
*
* @return 成功消息
*/
public static Result success(Object data) {
return Result.success("操作成功", data);
}
/**
* 返回成功消息
*
* @param msg 返回内容
* @return 成功消息
*/
public static Result success(String msg) {
return Result.success(msg, null);
}
/**
* 返回成功消息
*
* @param msg 返回内容
* @param data 数据对象
* @return 成功消息
*/
public static Result success(String msg, Object data) {
return new Result(Constants.SUCCESS, msg, data);
}
/**
* 返回失败消息
*
* @return 失败消息
*/
public static Result fail() {
return Result.fail("操作失败");
}
/**
* 返回失败消息
*
* @param msg 返回内容
* @return 失败消息
*/
public static Result fail(String msg) {
return Result.fail(msg, null);
}
/**
* 返回失败消息
*
* @param msg 返回内容
* @param data 数据对象
* @return 失败消息
*/
public static Result fail(String msg, Object data) {
return new Result(Constants.FAIL, msg, data);
}
/**
* 返回错误消息
*
* @return 错误消息
*/
public static Result error() {
return Result.error("操作错误");
}
/**
* 返回错误消息
*
* @param msg 返回内容
* @return 错误消息
*/
public static Result error(String msg) {
return Result.error(msg, null);
}
/**
* 返回错误消息
*
* @param msg 返回内容
* @param data 数据对象
* @return 错误消息
*/
public static Result error(String msg, Object data) {
return new Result(Constants.ERROR, msg, data);
}
public Integer getStatus() {
return status;
}
public void setStatus(Integer status) {
this.status = status;
}
public Object getMsg() {
return msg;
}
public void setMsg(Object msg) {
this.msg = msg;
}
public Object getData() {
return data;
}
public void setData(Object data) {
this.data = data;
}
}
三、在列表搜索的基础上，无侵入的加入分页操作
道理原理也是很简单，使用框架的时候spring mvc只是会为我们包装属于实体类拥有set方法的字段，而其他字段，不会被封装上，所有不是说不存在，我们还是可以用原始的方法拿到这些字段，这里的分页，就是运用这个方法，不破坏原有的类方法的结构，达到分页效果
import com.github.pagehelper.PageHelper;
import com.gentest.demo.util.ServletUtils;
import java.util.List;
/**
* web层通用数据处理
*
* @author ruige
* @date 2019-08-13 11:06
*/
public class BaseController {
/**
* 设置请求分页数据
*/
protected void startPage() {
PageDomain pageDomain = getPageDomain();
Integer pageNum = pageDomain.getPageNum();
Integer pageSize = pageDomain.getPageSize();
String orderBy = pageDomain.getOrderBy();
if (pageNum != null && pageSize != null) {
PageHelper.startPage(pageNum, pageSize, orderBy);
}
}
/**
* 获取前端传递的分页信息
*
* @return pageDomain 分页单排序类
*/
public static PageDomain getPageDomain() {
PageDomain pageDomain = new PageDomain();
pageDomain.setPageNum(ServletUtils.getParameterToInt(Constants.PAGE_NUM));
pageDomain.setPageSize(ServletUtils.getParameterToInt(Constants.PAGE_SIZE));
pageDomain.setOrderBy(ServletUtils.getParameter(Constants.ORDER_BY_COLUMN));
pageDomain.setIsAsc(ServletUtils.getParameter(Constants.IS_ASC));
return pageDomain;
}
}
PageDomain类
import org.springframework.util.StringUtils;
/**
* 分页单排序类
*
* @author ruige
* @date 2019-08-13 11:06
*/
public class PageDomain {
/**
* 当前记录起始索引
*/
private Integer pageNum;
/**
* 每页显示记录数
*/
private Integer pageSize;
/**
* 排序列
*/
private String orderBy;
/**
* 排序的方向 "desc" 或者 "asc".
*/
private String isAsc;
public String getOrderBy() {
if (StringUtils.isEmpty(orderBy)) {
return "";
}
return orderBy + " " + isAsc;
}
public Integer getPageNum() {
return pageNum;
}
public void setPageNum(Integer pageNum) {
this.pageNum = pageNum;
}
public Integer getPageSize() {
return pageSize;
}
public void setPageSize(Integer pageSize) {
this.pageSize = pageSize;
}
public void setOrderBy(String orderBy) {
this.orderBy = orderBy;
}
public String getIsAsc() {
return isAsc;
}
public void setIsAsc(String isAsc) {
this.isAsc = isAsc;
}
}
ServletUtils类
import org.springframework.web.context.request.RequestAttributes;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
/**
* 客户端工具类
*
* @author ruige
* @date 2019-08-13 11:06
*/
public class ServletUtils {
/**
* 获取Integer参数
*/
public static Integer getParameterToInt(String name) {
String parameter = getRequest().getParameter(name);
return parameter != null ? Integer.valueOf(getRequest().getParameter(name)) : null;
}
/**
* 获取String参数
*/
public static String getParameter(String name) {
return getRequest().getParameter(name);
}
/**
* 获取request
*/
public static HttpServletRequest getRequest() {
return getRequestAttributes().getRequest();
}
/**
* 获取response
*/
public static HttpServletResponse getResponse() {
return getRequestAttributes().getResponse();
}
/**
* 获取session
*/
public static HttpSession getSession() {
return getRequest().getSession();
}
public static ServletRequestAttributes getRequestAttributes() {
RequestAttributes attributes = RequestContextHolder.getRequestAttributes();
return (ServletRequestAttributes) attributes;
}
}
最后一个通用常亮类 Constants
/**
* 通用常量信息
*
* @author ruige
* @date 2019-08-13 11:06
*/
public class Constants {
/**
* 成功状态码
*/
public static final Integer SUCCESS = 1;
/**
* 失败状态码
*/
public static final Integer FAIL = 0;
/**
* 错误状态码
*/
public static final Integer ERROR = -1;
/**
* 当前记录起始索引
*/
public static final String PAGE_NUM = "pageNum";
/**
* 每页显示记录数
*/
public static final String PAGE_SIZE = "pageSize";
/**
* 排序列
*/
public static final String ORDER_BY_COLUMN = "orderByColumn";
/**
* 排序的方向 "desc" 或者 "asc".
*/
public static final String IS_ASC = "isAsc";
}
四、对于double类型的计算
使用过double进行计算的人都应该遇到，double在进行计算时，会有精度损失问题，所以在进行小数计算时，不推荐用double直接计算，而应该采用BigDecimal，用这个类计算就不存在精度问题，下面是我们项目采用的BigDecimal封装类
import java.math.BigDecimal;
/**
* 精确的浮点数运算
*
*/
public class Arith
{
// 默认除法运算精度
private static final int DEF_DIV_SCALE = 10;
// 这个类不能实例化
private Arith()
{
}
/**
* 提供精确的加法运算。
* @param v1 被加数
* @param v2 加数
* @return 两个参数的和
*/
public static double add(double v1, double v2)
{
BigDecimal b1 = new BigDecimal(Double.toString(v1));
BigDecimal b2 = new BigDecimal(Double.toString(v2));
return b1.add(b2).doubleValue();
}
/**
* 提供精确的减法运算。
* @param v1 被减数
* @param v2 减数
* @return 两个参数的差
*/
public static double sub(double v1, double v2)
{
BigDecimal b1 = new BigDecimal(Double.toString(v1));
BigDecimal b2 = new BigDecimal(Double.toString(v2));
return b1.subtract(b2).doubleValue();
}
/**
* 提供精确的乘法运算。
* @param v1 被乘数
* @param v2 乘数
* @return 两个参数的积
*/
public static double mul(double v1, double v2)
{
BigDecimal b1 = new BigDecimal(Double.toString(v1));
BigDecimal b2 = new BigDecimal(Double.toString(v2));
return b1.multiply(b2).doubleValue();
}
/**
* 提供（相对）精确的除法运算，当发生除不尽的情况时，精确到
* 小数点以后10位，以后的数字四舍五入。
* @param v1 被除数
* @param v2 除数
* @return 两个参数的商
*/
public static double div(double v1, double v2)
{
return div(v1, v2, DEF_DIV_SCALE);
}
/**
* 提供（相对）精确的除法运算。当发生除不尽的情况时，由scale参数指
* 定精度，以后的数字四舍五入。
* @param v1 被除数
* @param v2 除数
* @param scale 表示表示需要精确到小数点以后几位。
* @return 两个参数的商
*/
public static double div(double v1, double v2, int scale)
{
if (scale < 0)
{
throw new IllegalArgumentException(
"The scale must be a positive integer or zero");
}
BigDecimal b1 = new BigDecimal(Double.toString(v1));
BigDecimal b2 = new BigDecimal(Double.toString(v2));
if (b1.compareTo(BigDecimal.ZERO) == 0)
{
return BigDecimal.ZERO.doubleValue();
}
return b1.divide(b2, scale, BigDecimal.ROUND_HALF_UP).doubleValue();
}
/**
* 提供精确的小数位四舍五入处理。
* @param v 需要四舍五入的数字
* @param scale 小数点后保留几位
* @return 四舍五入后的结果
*/
public static double round(double v, int scale)
{
if (scale < 0)
{
throw new IllegalArgumentException(
"The scale must be a positive integer or zero");
}
BigDecimal b = new BigDecimal(Double.toString(v));
BigDecimal one = new BigDecimal("1");
return b.divide(one, scale, BigDecimal.ROUND_HALF_UP).doubleValue();
}
}