Spring Boot（四）通用CRUD案例、异常统一处理
项目GitHub地址 ：
https://github.com/FrameReserve/TrainingBoot
Spring Boot （三）集成spring security，标记地址：
https://github.com/FrameReserve/TrainingBoot/releases/tag/0.0.4
思路为：
BaseEntity
BaseDao，实现类分支：MyBatis、Redis
BaseService，实现类分支：MyBatis、Redis
BaseController，实现类分支：统一异常处理、MyBatis（增删改查，模糊分页）、MyBatis（读）、Redis（增删改查）
ResultDataDto，统一Json数据交互格式。
自定义异常类：业务逻辑异常；功能不完善；网络异常；其它异常。（权限异常由Spring Security处理，本章略）
------------------------------------------------------------------------------------------
BaseEntity，统一父类，实现反射，泛型动态实现统一增删改查。
src/main/java/com/training/core/entity/BaseEntity.java
package com.training.core.entity;
import java.io.Serializable;
import java.util.Date;
import com.fasterxml.jackson.annotation.JsonProperty;
import tk.mybatis.mapper.annotation.NameStyle;
import tk.mybatis.mapper.code.Style;
import javax.persistence.Column;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
@NameStyle(value = Style.camelhumpAndLowercase)
public class BaseEntity implements Serializable {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@JsonProperty("id")
private Integer id;
/**
* 创建时间
*/
@Column
private Date createTime;
/**
* 最后修改时间
*/
@Column
private Date lastModifyTime;
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public Date getCreateTime() {
return createTime;
}
public void setCreateTime(Date createTime) {
this.createTime = createTime;
}
public Date getLastModifyTime() {
return lastModifyTime;
}
public void setLastModifyTime(Date lastModifyTime) {
this.lastModifyTime = lastModifyTime;
}
}
定义BaseDao接口，统一增删改查规范：
src/main/java/com/training/core/dao/BaseDao.java
package com.training.core.dao;
import java.util.List;
import tk.mybatis.mapper.entity.Example;
import com.training.core.dto.FlexiPageDto;
import com.training.core.entity.BaseEntity;
public interface BaseDao<T extends BaseEntity> {
/**
* 根据Id查询实体
*/
public T getEntityById(final Class<T> cls, final Integer id);
/**
* 新增实体
*/
public void addEntity(final T entity);
/**
* 更新实体
*/
public void updateEntity(final T entity);
/**
* 根据Id删除实体
*/
public void deleteEntityById(final Class<T> cls, final Integer id);
/**
* 查询全部
*/
public List<T> selectAll(Class<T> cls);
/**
* 单表模糊查询
*/
public List<T> findByLike(Example example);
/**
* 根据模糊分页查询
*/
public List<T> findByPage(Example example, FlexiPageDto flexiPageDto);
/**
* 单表模糊查询总记录数
*/
public int findRowCount(Example example);
}
MyBatis BaseDao实现：
src/main/java/com/training/core/dao/impl/MyBatisBaseDaoImpl.java
package com.training.core.dao.impl;
import java.util.List;
import javax.annotation.Resource;
import org.apache.ibatis.session.RowBounds;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionTemplate;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Repository;
import tk.mybatis.mapper.common.Mapper;
import tk.mybatis.mapper.entity.Example;
import com.training.core.annotation.MapperClass;
import com.training.core.dao.BaseDao;
import com.training.core.dto.FlexiPageDto;
import com.training.core.entity.BaseEntity;
@Repository("myBatisBaseDao")
@SuppressWarnings("unchecked")
public class MyBatisBaseDaoImpl<T extends BaseEntity> implements BaseDao<T> {
@Resource
@Qualifier("sessionFactory")
private SqlSessionFactory sqlSessionFactory;
private SqlSession sqlSession;
@SuppressWarnings("rawtypes")
public <M extends Mapper<T>> M getMapper(Class cls){
MapperClass mapperClass = (MapperClass) cls.getAnnotation(MapperClass.class);
if(null == mapperClass){
throw new RuntimeException("没有注解MapperClass");
}
return (M) getSqlSession().getMapper(mapperClass.value());
}
@Override
public T getEntityById(Class<T> cls, Integer id) {
return this.getMapper(cls).selectByPrimaryKey(id);
}
@Override
public void addEntity(T entity) {
this.getMapper(entity.getClass()).insert(entity);
}
@Override
public void updateEntity(T entity) {
this.getMapper(entity.getClass()).updateByPrimaryKey(entity);
}
@Override
public void deleteEntityById(Class<T> cls, Integer id) {
this.getMapper(cls).deleteByPrimaryKey(id);
}
@Override
public List<T> selectAll(Class<T> cls) {
return this.getMapper(cls).selectAll();
}
@Override
public List<T> findByLike(Example example) {
return this.getMapper(example.getEntityClass()).selectByExample(example);
}
@Override
public List<T> findByPage(Example example, FlexiPageDto flexiPageDto) {
RowBounds rowBounds = new RowBounds(flexiPageDto.getOffset(), flexiPageDto.getRp());
return this.getMapper(example.getEntityClass()).selectByExampleAndRowBounds(example, rowBounds);
}
@Override
public int findRowCount(Example example) {
return this.getMapper(example.getEntityClass()).selectCountByExample(example);
}
public SqlSession getSqlSession(){
if (null == sqlSession){
synchronized (MyBatisBaseDaoImpl.class) {
this.sqlSession = new SqlSessionTemplate(sqlSessionFactory);
}
}
return this.sqlSession;
}
}
Redis统一增删改查，再下一章讲解，本章略。
定义BaseService接口，统一增删改查规范：
src/main/java/com/training/core/service/BaseService.java
package com.training.core.service;
import com.training.core.entity.BaseEntity;
import java.util.List;
public interface BaseService<T extends BaseEntity> {
/**
* 根据Id查询实体
*/
T getEntityById(final Integer id);
/**
* 新增实体
*/
void addEntity(final T entity);
/**
* 更新实体
*/
void updateEntity(final T entity);
/**
* 根据Id删除实体
*/
void deleteEntityById(final Integer id);
/**
* 查询所有
*/
List<T> selectAll();
}
MyBatis BaseService实现：
src/main/java/com/training/core/dao/impl/MyBatisBaseDaoImpl.java
package com.training.core.service.impl;
import javax.annotation.Resource;
import com.training.core.dao.BaseDao;
import com.training.core.dao.impl.MyBatisBaseDaoImpl;
import com.training.core.entity.BaseEntity;
import com.training.core.service.BaseService;
import com.training.core.util.GenericeClassUtils;
import tk.mybatis.mapper.common.Mapper;
import java.util.List;
public class MyBatisBaseServiceImpl<T extends BaseEntity> implements BaseService<T> {
@SuppressWarnings("unchecked")
protected Class<T> entityClass = (Class<T>) GenericeClassUtils.getSuperClassGenricType(this.getClass(), 0);
protected <M extends Mapper<T>> M getMapper(Class cls){
return ((MyBatisBaseDaoImpl<T>) baseDao).getMapper(cls);
}
@Resource(name = "myBatisBaseDao")
private BaseDao<T> baseDao;
@Override
public T getEntityById(Integer id) {
return baseDao.getEntityById(entityClass, id);
}
@Override
public void addEntity(T entity) {
baseDao.addEntity(entity);
}
@Override
public void updateEntity(T entity) {
baseDao.updateEntity(entity);
}
@Override
public void deleteEntityById(Integer id) {
baseDao.deleteEntityById(entityClass, id);
}
@Override
public List<T> selectAll() {
return baseDao.selectAll(entityClass);
}
}
定义Base Controller，统一异常处理：
为了兼容IE8，解决弹出下载文件框，使用传统流输出模式。
src/main/java/com/training/core/controller/BaseController.java
package com.training.core.controller;
import java.io.IOException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.web.bind.annotation.ExceptionHandler;
import com.google.gson.Gson;
import com.training.core.dto.ResultDataDto;
import com.training.core.entity.BaseEntity;
public class BaseController<T extends BaseEntity> {
// 异常信息拦截，统一处理返回，为了兼容IE8，用流方式输出
@ExceptionHandler(Exception.class) //在Controller类中添加该注解方法即可(注意：添加到某个controller，只针对该controller起作用)
public void exceptionHandler(Exception ex, HttpServletResponse response, HttpServletRequest request) throws IOException {
ResultDataDto resultDataDto = new ResultDataDto(ex);
response.setContentType("text/html;charset=utf-8");
response.getWriter().write(new Gson().toJson(resultDataDto));
}
}
Base Crud Controller，增删改查Controller，根据URL参数实现统一模糊、分页动态查询
src/main/java/com/training/core/controller/BaseCrudController.java
package com.training.core.controller;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiImplicitParams;
import io.swagger.annotations.ApiOperation;
import java.util.List;
import javax.annotation.Resource;
import org.springframework.transaction.annotation.Isolation;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;
import tk.mybatis.mapper.entity.Example;
import com.training.core.dao.BaseDao;
import com.training.core.dto.FlexiPageDto;
import com.training.core.dto.ResultDataDto;
import com.training.core.entity.BaseEntity;
import com.training.core.util.FilterUtil;
import com.training.core.util.GenericeClassUtils;
public class BaseCrudController<T extends BaseEntity> extends BaseController<T> {
@SuppressWarnings("unchecked")
protected Class<T> entityClass = (Class<T>) GenericeClassUtils.getSuperClassGenricType(this.getClass(), 0);
@Resource(name = "myBatisBaseDao")
protected BaseDao<T> baseDao;
/**
* 根据Id查询实体
*/
@ApiOperation(value="根据Id查询实体", notes="getEntityById")
@ApiImplicitParam(name = "id", value = "用户ID", required = true, dataType = "Integer")
@RequestMapping(value = "/getEntityById/{id}", method = RequestMethod.GET)
public @ResponseBody ResultDataDto getEntityById(@PathVariable(value = "id") final Integer id) {
T entity = baseDao.getEntityById(entityClass, id);
return new ResultDataDto(entity);
}
/**
* 新增实体
*/
@ApiOperation(value="新增实体", notes="addEntity")
@ApiImplicitParam(name = "entity", value = "实体Json", required = true, dataType = "application/json")
@RequestMapping(value = "/addEntity", method = RequestMethod.POST, consumes = "application/json")
@Transactional(isolation = Isolation.DEFAULT, propagation = Propagation.REQUIRED)
public @ResponseBody ResultDataDto addEntity(@RequestBody final T entity) {
baseDao.addEntity(entity);
return ResultDataDto.addAddSuccess();
}
/**
* 更新实体
*/
@ApiOperation(value="更新实体", notes="updateEntity")
@ApiImplicitParam(name = "entity", value = "实体Json", required = true, dataType = "application/json")
@RequestMapping(value = "/updateEntity", method = RequestMethod.PUT, consumes = "application/json")
@Transactional(isolation = Isolation.DEFAULT, propagation = Propagation.REQUIRED)
public @ResponseBody ResultDataDto updateEntity(@RequestBody final T entity) {
baseDao.updateEntity(entity);
return ResultDataDto.addUpdateSuccess();
}
/**
* 根据Id删除实体
*/
@ApiOperation(value="根据Id删除实体", notes="deleteEntityById")
@ApiImplicitParam(name = "id", value = "用户ID", required = true, dataType = "Integer")
@RequestMapping(value = "/deleteEntityById/{id}", method = RequestMethod.DELETE)
@Transactional(isolation = Isolation.DEFAULT, propagation = Propagation.REQUIRED)
public @ResponseBody ResultDataDto deleteEntityById(@PathVariable(value = "id") final Integer id) {
baseDao.deleteEntityById(entityClass, id);
return ResultDataDto.addDeleteSuccess();
}
/**
* 查询所有实体
*/
@ApiOperation(value="查询所有实体", notes="findAllEntitys")
@SuppressWarnings({ "rawtypes", "unchecked" })
@RequestMapping(value = "/findAllEntitys", method = RequestMethod.GET)
public @ResponseBody ResultDataDto findAllEntitys() {
List list = baseDao.selectAll(entityClass);
return new ResultDataDto(list);
}
/**
* 分页模糊查询
*
* @param pageNumber 当前页
* @param pageSize 每页显示数
* @param orderBy 排序条件
* &orderBy=name_desc,id_asc
*
* @param filter 模糊查询条件
*
* 查询条件说明：&filter=
* id_L_3_EQ__,
*
* 属性(id) _ 类型(Long) _ 值(3) _ EQ(精确查询) _ AND(默认And查询) _ ,
*
* 类型：
* S(String.class), I(Integer.class), L(Long.class), B(Boolean.class),
* C(Collection.class) 例：1,2,3,4,5。使用,间隔。
*
* 匹配模式：
* IN 例： select * from tableName where id in (1,2,3,4,5);
* EQ, 例： select * from tableName where id = 1;
* LIKE, 例： select * from tableName where name like '%张三%';
* LT, 例： select * from tableName where id < 100;
* GT, 例： select * from tableName where id > 100;
* LE, 例： select * from tableName where id <= 100;
* GE 例： select * from tableName where id >= 100;
*
*
* 完整案例：
* select * from tableName where id = 3 and name = '张三' limit 0, 10
* http://localhost:8080/syssetting/findLikePage?pageNumber=1&pageSize=10&orderBy=&filter=id_L_2_EQ__,name_S_资源_LIKE__&
*
* OR案例：
* select * from tableName where (id = 3 or name = '张三') or name = '李四' limit 0, 10
* &filter=id_L_3_EQ_OR_,name_S_张三_EQ_OR_,name_S_李四_EQ_OR_
*
*
*
*/
@ApiOperation(value="分页模糊查询", notes="findLikePage")
@ApiImplicitParams({
@ApiImplicitParam(name = "pageNumber", value = "当前页", required = true, dataType = "Integer"),
@ApiImplicitParam(name = "pageSize", value = "每页显示数", required = true, dataType = "Integer"),
@ApiImplicitParam(name = "orderBy", value = "排序：name_desc,id_asc", required = true, dataType = "String"),
@ApiImplicitParam(name = "filter", value = "过滤规则：&filter=id_L_3_EQ_OR_,name_S_张三_EQ_OR_,name_S_李四_EQ_OR_", required = true, dataType = "String")
})
@RequestMapping(value = "/findLikePage", method = RequestMethod.GET)
public @ResponseBody ResultDataDto findLikePage(@RequestParam("pageNumber") Integer pageNumber, @RequestParam("pageSize") Integer pageSize, @RequestParam("orderBy") String orderBy, @RequestParam("filter") String filterStr) {
Example example = FilterUtil.parsePropertyFilterExp(entityClass, filterStr, orderBy);
FlexiPageDto flexiPageDto = new FlexiPageDto(pageNumber, pageSize);
List<T> list = this.baseDao.findByPage(example, flexiPageDto);
return new ResultDataDto(list);
}
@ApiOperation(value="分页模糊查询总记录数", notes="findLikePageRowCount")
@ApiImplicitParams({
@ApiImplicitParam(name = "pageNumber", value = "当前页", required = true, dataType = "Integer"),
@ApiImplicitParam(name = "pageSize", value = "每页显示数", required = true, dataType = "Integer"),
@ApiImplicitParam(name = "orderBy", value = "排序：name_desc,id_asc", required = true, dataType = "String"),
@ApiImplicitParam(name = "filter", value = "过滤规则：&filter=id_L_3_EQ_OR_,name_S_张三_EQ_OR_,name_S_李四_EQ_OR_", required = true, dataType = "String")
})
@RequestMapping(value = "/findLikePageRowCount", method = RequestMethod.GET)
public @ResponseBody ResultDataDto findLikePageRowCount(@RequestParam("pageNumber") Integer pageNumber, @RequestParam("pageSize") Integer pageSize, @RequestParam("orderBy") String orderBy, @RequestParam("filter") String filterStr) {
Example example = FilterUtil.parsePropertyFilterExp(entityClass, filterStr, orderBy);
Integer count = this.baseDao.findRowCount(example);
return new ResultDataDto().setCode(ResultDataDto.CODE_SUCCESS).setDatas(count);
}
}
------------------------------------------------------------------------------------------
辅助类、自定义异常
统一Json传输对象ResultDataDto：
src/main/java/com/training/core/dto/ResultDataDto.java
package com.training.core.dto;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.sql.SQLException;
import java.util.List;
import java.util.Map;
import javax.servlet.http.HttpServletResponse;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlTransient;
import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.annotation.JsonRootName;
import com.google.gson.Gson;
import com.training.core.entity.BaseEntity;
import com.training.core.exception.RuntimeFunctionException;
import com.training.core.exception.RuntimeOtherException;
import com.training.core.exception.RuntimeServiceException;
import com.training.core.exception.RuntimeWebException;
@JsonAutoDetect(fieldVisibility = JsonAutoDetect.Visibility.ANY)
public class ResultDataDto {
/**
* 200-成功
*/
public final static String CODE_SUCCESS = "200";
/**
* 301-代表永久性转移
*/
public final static String CODE_PERMANENTLY_MOVED = "301";
/**
* 500-业务逻辑错误
*/
public final static String CODE_ERROR_SERVICE = "500";
/**
* 501-功能不完善，无对应方法
*/
public final static String CODE_ERROR_FUNCTION = "501";
/**
* 502-网络异常
*/
public final static String CODE_ERROR_WEB = "502";
/**
* 503-未知其它
*/
public final static String CODE_ERROR_OTHER = "503";
/**
* 文件流导入返回值，因IE不支持json返回
* @return
*/
public static void addImportSuccess(HttpServletResponse response, String message) {
try {
response.setContentType("text/html");
response.getWriter().write(new Gson().toJson(ResultDataDto.addSuccess(message)));
} catch (IOException e) {
throw new RuntimeServiceException(e);
}
}
/**
* 文件流导入返回值，因IE不支持json返回
* @return
*/
public static void addImportSuccess(HttpServletResponse response) {
try {
response.setContentType("text/html");
response.getWriter().write(new Gson().toJson(ResultDataDto.addSuccess("上传成功")));
} catch (IOException e) {
throw new RuntimeServiceException(e);
}
}
public static void addImportError(HttpServletResponse response, String message) {
try {
response.setContentType("text/html");
response.getWriter().write(new Gson().toJson(new ResultDataDto(CODE_ERROR_SERVICE, message)));
} catch (IOException e) {
throw new RuntimeServiceException(e);
}
}
public static ResultDataDto addSuccess() {
return new ResultDataDto(CODE_SUCCESS, null);
}
public static ResultDataDto addSuccess(String message) {
return new ResultDataDto(CODE_SUCCESS, message);
}
public static ResultDataDto addAddSuccess() {
return new ResultDataDto(CODE_SUCCESS, "新增成功");
}
public static ResultDataDto addUpdateSuccess() {
return new ResultDataDto(CODE_SUCCESS, "更新成功");
}
public static ResultDataDto addUpdateCheckSuccess() {
return new ResultDataDto(CODE_SUCCESS, "确定成功");
}
public static ResultDataDto addDeleteSuccess() {
return new ResultDataDto(CODE_SUCCESS, "删除成功");
}
public static ResultDataDto addOperationSuccess() {
return new ResultDataDto(CODE_SUCCESS, "操作成功");
}
public ResultDataDto() {
super();
}
public ResultDataDto(String code, String message) {
super();
this.code = code;
this.message = message;
}
public ResultDataDto(String message) {
super();
this.code = CODE_SUCCESS;
this.message = message;
}
/**
* 返回单个实体
*/
public<T extends BaseEntity> ResultDataDto(T entity) {
super();
this.code = CODE_SUCCESS;
this.datas = entity;
}
/**
* 返回集合类型
*/
public ResultDataDto(List<? extends BaseEntity> list) {
super();
this.code = CODE_SUCCESS;
this.datas = list;
}
/**
* 返回Map集合类型
*/
public ResultDataDto(Map<String, Object> map) {
super();
this.code = CODE_SUCCESS;
this.datas = map;
}
/**
* 返回分页集合
*/
public<T extends BaseEntity> ResultDataDto(List<T> list, FlexiPageDto flexiPageDto) {
super();
this.code = CODE_SUCCESS;
this.datas = list;
this.flexiPageDto = flexiPageDto;
}
/**
* 500-业务逻辑错误
*/
public ResultDataDto(RuntimeServiceException rex) {
super();
this.code = CODE_ERROR_SERVICE;
this.message = rex.getMessage();
}
/**
* 501-功能不完善，无对应方法
*/
public ResultDataDto(RuntimeFunctionException rex) {
super();
this.code = CODE_ERROR_FUNCTION;
this.message = rex.getMessage();
}
/**
* 502-网络异常
*/
public ResultDataDto(RuntimeWebException rex) {
super();
this.code = CODE_ERROR_WEB;
this.message = rex.getMessage();
}
/**
* 503-未知其它
*/
public ResultDataDto(RuntimeOtherException rex) {
super();
this.code = CODE_ERROR_OTHER;
this.message = rex.getMessage();
}
/**
* 异常
*/
public ResultDataDto(Exception ex) {
super();
this.code = CODE_ERROR_OTHER;
this.message = getErrorMessage(ex);
ex.printStackTrace();
}
/**
* 运行时异常
*/
public ResultDataDto(RuntimeException rex) {
super();
this.code = CODE_ERROR_OTHER;
this.message = rex.getMessage();
}
/**
* 运行时异常
*/
public ResultDataDto(Throwable tx) {
super();
this.code = CODE_ERROR_OTHER;
this.message = tx.getMessage();
}
/**
* 结果编码
*/
@XmlElement(name="code")
private String code;
/**
* 消息
*/
private String message;
/**
* 结果数据，单个实体 或 List<T>
*/
private Object datas;
/**
* 分页数据
*/
private FlexiPageDto flexiPageDto;
private static String getErrorMessage(Exception ex) {
if (ex instanceof ArithmeticException) {
return "系统异常：计算错误";
}
if (ex instanceof NullPointerException) {
return "系统异常：输入错误，缺少输入值";
}
if (ex instanceof ClassCastException) {
return "系统异常：类型转换错误";
}
if (ex instanceof NegativeArraySizeException) {
return "系统异常：集合负数";
}
if (ex instanceof ArrayIndexOutOfBoundsException) {
return "系统异常：集合超出范围";
}
if (ex instanceof FileNotFoundException) {
return "系统异常：文件未找到";
}
if (ex instanceof NumberFormatException) {
return "系统异常：输入数字错误";
}
if (ex instanceof SQLException) {
return "系统异常：数据库异常";
}
if (ex instanceof IOException) {
return "系统异常：文件读写错误";
}
if (ex instanceof NoSuchMethodException) {
return "系统异常：方法找不到";
}
return ex.getMessage();
}
// -------------------------- getter and setter -----------------------------
public String getCode() {
return code;
}
public ResultDataDto setCode(String code) {
this.code = code;
return this;
}
public Object getDatas() {
return datas;
}
public ResultDataDto setDatas(Object datas) {
this.datas = datas;
return this;
}
public String getMessage() {
return message;
}
public ResultDataDto setMessage(String message) {
this.message = message;
return this;
}
public FlexiPageDto getFlexiPageDto() {
return flexiPageDto;
}
public ResultDataDto setFlexiPageDto(FlexiPageDto flexiPageDto) {
this.flexiPageDto = flexiPageDto;
return this;
}
}
分页Dto传输对象，FlexiPageDto：
src/main/java/com/training/core/dto/FlexiPageDto.java
package com.training.core.dto;
public class FlexiPageDto {
public static final Integer MAX_PAGE_SIZE=3000;
public static final Integer SHORT_PAGE_SIZE=5;
public FlexiPageDto() {
super();
}
public FlexiPageDto(Integer page, Integer rp) {
super();
this.page = page;
this.rp = rp;
}
public FlexiPageDto(Integer page, Integer rp, String sortName) {
super();
this.page = page;
this.rp = rp;
this.sortName = sortName;
}
public FlexiPageDto(Integer page, Integer rp, String sortName, String sortOrder) {
super();
this.page = page;
this.rp = rp;
this.sortName = sortName;
this.sortOrder = sortOrder;
}
public static FlexiPageDto createMaxPageDto(){
FlexiPageDto flexiPageDto=new FlexiPageDto();
flexiPageDto.setRp(MAX_PAGE_SIZE).setPage(1);
return flexiPageDto;
}
public static FlexiPageDto generateFlexiPageDto(Integer page, Integer rp, String orderBy) {
FlexiPageDto flexiPageDto = new FlexiPageDto(page, rp);
if (null != orderBy && "" != orderBy.trim()) {
String[] orderBys = orderBy.split("_");
flexiPageDto.setSortName(orderBys[0]);
flexiPageDto.setSortOrder(orderBys[1]);
}
return flexiPageDto;
}
/**
* 当前页
*/
private Integer page;
/**
* 每页显示，默认:10
*/
private Integer rp = 10;
/**
* 总记录数
*/
private Integer rowCount;
/**
* 排序字段
*/
private String sortName;
/**
* 排序(asc/desc)
*/
private String sortOrder = "desc";
public static final String SORTORDER_ACS = "asc";
/**
* 数据开始坐标，Mysql从0开始
*/
public Integer getOffset(){
return (this.getPage()-1)*this.getRp();
}
/**
* 总页数
*/
public Integer getTotalPage() {
if (null == rowCount) {
return 0;
}
int totalPage = (rowCount / rp);
int remainder = rowCount % rp;
if (rowCount > 0 && totalPage == 0) {
totalPage = 1;
return totalPage;
}
if (remainder > 0) {
totalPage++;
return totalPage;
}
return totalPage;
}
// -------------------------- getter and setter -----------------------------
public Integer getRp() {
return rp;
}
public FlexiPageDto setRp(Integer rp) {
this.rp = rp;
return this;
}
public Integer getPage() {
return page;
}
public FlexiPageDto setPage(Integer page) {
this.page = page;
return this;
}
public String getSortName() {
return sortName;
}
public FlexiPageDto setSortName(String sortName) {
this.sortName = sortName;
return this;
}
public String getSortOrder() {
return sortOrder;
}
public FlexiPageDto setSortOrder(String sortOrder) {
this.sortOrder = sortOrder;
return this;
}
public Integer getRowCount() {
return rowCount;
}
public FlexiPageDto setRowCount(Integer rowCount) {
this.rowCount = rowCount;
return this;
}
public String getSortString(){
if (null == sortName) {
return null;
}
String[] fields = this.getSortName().split("_");
String[] fieldsorts = this.getSortOrder().split("_");
if(fields.length!=fieldsorts.length){
throw new RuntimeException("排序规则不一致");
}
String sql = "";
for(int index=0;index<fields.length;index++){
sql = sql+" "+fields[index]+" "+fieldsorts[index];
}
return sql;
}
}
自定义异常：
src/main/java/com/training/core/exception/RuntimeFunctionException.java
src/main/java/com/training/core/exception/RuntimeOtherException.java
src/main/java/com/training/core/exception/RuntimeServiceException.java
src/main/java/com/training/core/exception/RuntimeWebException.java
集成Runtime Exception，其余略。
package com.training.core.exception;
@SuppressWarnings("serial")
public class RuntimeFunctionException extends RuntimeException {
public RuntimeFunctionException() {
super();
}
public RuntimeFunctionException(String message, Throwable cause) {
super(message, cause);
}
public RuntimeFunctionException(String message) {
super(message);
}
public RuntimeFunctionException(Throwable cause) {
super(cause);
}
}
正文到此结束
- 本文标签：
- 版权声明： 本文由HARRIES原创发布，转载请遵循《署名-非商业性使用-相同方式共享 4.0 国际 (CC BY-NC-SA 4.0)》许可协议授权
- 本文海报： 生成海报一 生成海报二
热门推荐
相关文章
Loading...
![[HBLOG]公众号](http://www.liuhaihua.cn/img/qrcode_gzh.jpg)
