分页规范

最新推荐文章于 2024-04-12 19:02:18 发布

原创最新推荐文章于 2024-04-12 19:02:18 发布 · 1k 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#分页

本文介绍了部门内部统一的分页规范，包括请求参数的设置，如DTO对象、分页信息对象（limit、offset、sort、order），以及注意事项，如查询条件的组装，避免使用String直接拼接，推荐使用StringBuffer以提高性能。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

为了统一部门内开发中分页方式的统一，以下是分页传参、处理、响应结果封装的规范

1.请求参数

请求参数主要两个对象，一个是和数据库表结构对应的实体对象(最好采用自定义成DTO用于传参，因为查询很可能涉及复杂条件或关联查询)；另一个是分页信息对象，对象存放2个必要参数和2个非必要参数，必要参数是limit每页总条数，offset当页起始位置，非必要参数为sort需要排序的字段名，order排序方式(默认ASC)

/**
 * 分页数据封装类.
 */
public class Page implements java.io.Serializable {

	private static final long serialVersionUID = -5823482162101235168L;

	public static final String ORDER_ASC = "ASC";
	public static final String ORDER_DESC = "DESC";

	private int offset;
	private int limit;
	private String sort;
	private String order = ORDER_ASC;

	public Page() {
		this(0, Integer.MAX_VALUE);
	}

	public Page(int offset, int limit) {
		this.offset = offset;
		this.limit = limit;
	}

	public Page(int offset, int limit, String sort, String order) {
		this.offset = offset;
		this.limit = limit;
		this.sort = sort;
		this.order = order;
	}

	public int getOffset() {
		return offset;
	}

	public void setOffset(int offset) {
		this.offset = offset;
	}

	public int getLimit() {
		return limit;
	}

	public void setLimit(int limit) {
		this.limit = limit;
	}

	public String getSort() {
		return sort;
	}

	public void setSort(String sort) {
		this.sort = sort;
	}

	public String getOrder() {
		return order;
	}

	public void setOrder(String order) {
		this.order = order;
	}

	public int getOffsetLimit() {
		return this.offset + this.limit;
	}

	public String toString() {
		return "[Page: " + offset + ", " + limit + ", " + sort + ", " + order + "]";
	}
}

2.查询组装

先组装查询条件，若没有组装工具需要自己拼接时需注意拼接不要使用string做拼接，应使用StringBuffer，原因string拼接时每一次变动都会产生新的对象

SELECT count(*) as count from TABLENAME WHERE A=?
SELECT TABLENAME WHERE A=? ORDER BY ? ? limit ?,?

3.结果封装

将查询结果封装到如下对象中

import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;

/**
 * 数据列表返回格式封装实体
 * @param <T> 数据列表类型
 */
public class DataGrid<T> implements java.io.Serializable {

	private static final long serialVersionUID = -4353059775338989141L;

	// 总数量
	private Integer numRows;
	// 当前分页记录列表
	private Collection<T> items;
	// 标识字段
	private String identified = "id";
	// 统计信息
	private Map<String, Object> stats = new HashMap<String, Object>();

	public DataGrid() {

	}

	public DataGrid(Collection<T> items) {
		this(items, items.size());
	}

	public DataGrid(Collection<T> items, Integer numRows) {
		this.items = items;
		this.numRows = numRows;
	}

	public DataGrid(Collection<T> items, Integer numRows, String identified) {
		this(items, items.size());
		this.identified = identified;
	}

	public Integer getNumRows() {
		return numRows;
	}

	public void setNumRows(Integer numRows) {
		this.numRows = numRows;
	}

	public Collection<T> getItems() {
		return items;
	}

	public void setItems(Collection<T> items) {
		this.items = items;
	}

	public String getIdentified() {
		return identified;
	}

	public void setIdentified(String identified) {
		this.identified = identified;
	}

	public Map<String, Object> getStats() {
		return stats;
	}

	public void setStats(Map<String, Object> stats) {
		this.stats = stats;
	}

	/**
	 * 增加统计信息
	 * @param name
	 * @param value
	 */
	public void addStat(String name, Object value) {
		this.stats.put(name, value);
	}

	/**
	 * 返回一个空的数据列表。
	 * @return
	 */
	public static <T> DataGrid<T> empty() {
		Collection<T> items = Collections.emptyList();
		return new DataGrid<T>(items);
	}
}

4.lifery示例

public Object listLog(ResourceRequest request) {
		try {
			DispatchLog dispatchLog = new DispatchLogImpl();
			dispatchLog = (DispatchLog) ModelUtil.getModel(dispatchLog, request, null);
			Long startTime = ParamUtil.getLong(request, "startTime");
			Long endTime = ParamUtil.getLong(request, "endTime");
			int limit = ParamUtil.getInteger(request, "limit");
			int offset = ParamUtil.getInteger(request, "offset");
			Date startDateRes = null;
			Date endDateRes = null;
			if (startTime != null) {
				startDateRes = new java.util.Date(startTime);
			}
			if (endTime != null) {
				endDateRes = new java.util.Date(endTime);
			}
			DataGrid<DispatchLog> dataGrid = dispatchLogServiceUtil.list(getCompanyId(request), dispatchLog.getDevId(), dispatchLog.getIfSuccess(), dispatchLog.getActiveName(), dispatchLog.getCreateTime(),startDateRes,endDateRes,limit,offset);
			return new JsonResponse(true,JSON.toJSONString(dataGrid));
		} catch (Exception e) {
			return new JsonResponse(false, e.getMessage());
		}
	}

package com.flame.dispatcher.manger;

import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

import com.alibaba.fastjson.JSON;
import com.flame.dispatcher.service.dispatchlog.model.DispatchLog;
import com.flame.dispatcher.service.dispatchlog.model.impl.DispatchLogImpl;
import com.flame.dispatcher.util.DataGrid;
import com.flame.jkzx.service.rulesversion.service.RulesVersionLocalServiceUtil;
import com.liferay.portal.kernel.exception.SystemException;


public class DispatchLogServiceUtil {
	/**
	 * 获取列表
	 * 
	 * @param id
	 * @param searchable
	 * @return
	 */
	public DataGrid<DispatchLog> list(Long companyId,Long devId,String ifSuccess,String activeName,Date createTime,Date startTime,Date endTime,int limit,int offset) throws SystemException {
		
		DataGrid<DispatchLog> dataGrid = new DataGrid<DispatchLog>();
		List<DispatchLog> logs = new ArrayList<DispatchLog>();
		try {
			StringBuffer buffer = new StringBuffer();
			buffer.append("where");
			buffer.append(" fdl.companyId="+companyId);
			
			if (devId != null&& devId !=0)
				buffer.append(" and fdl.devId="+devId);
			if (ifSuccess != null && ifSuccess.length()>0)
				buffer.append(" and fdl.ifSuccess='"+ifSuccess+"'");
			if (activeName != null && activeName.length()>0)
				buffer.append(" and fdl.activeName like '"+activeName+"%'");
			if (startTime != null)
				buffer.append(" and fdl.createTime >='"+new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(startTime)+"'");
			if (endTime != null)
				buffer.append(" and fdl.createTime <='"+new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(endTime)+"'");
			
			String sql = "select fdl.id_,fdl.devId,fdl.companyId,fdl.direId,fdl.activeName,fdl.createTime,fdl.direType,fdl.ifSuccess,fdl.message from flame_dispatch_log fdl inner join flame_dispatch_group_detail fdgd on fdl.devId=fdgd.id_  "+buffer+" ORDER BY fdl.id_ asc limit "+offset+","+limit;
			List list = RulesVersionLocalServiceUtil.executeQuery(sql);

			if (list != null && list.size() > 0) {
				for (Object obj : list) {
					Object[] dto = (Object[]) obj;
					DispatchLog org = new DispatchLogImpl();
					org.setId(Long.parseLong(dto[0]+""));
					org.setDevId(Long.parseLong(dto[1]+""));
					org.setCompanyId(Long.parseLong(dto[2]+""));
					org.setDireId(Long.parseLong(dto[3]+""));
					org.setActiveName(dto[4].toString());
					org.setCreateTime((Date) dto[5]);
					org.setDireType(dto[6].toString());
					org.setIfSuccess(dto[7].toString());
					org.setMessage(dto[8].toString());
					logs.add(org);
				}
			}
			
			String sqlCount = "SELECT count(*) as count from flame_dispatch_log fdl inner join flame_dispatch_group_detail fdgd on fdl.devId=fdgd.id_ "+buffer;
			List list2 = RulesVersionLocalServiceUtil.executeQuery(sqlCount);
			int count = 0;
			if (list2 != null && list2.size() > 0) {
				for (Object obj : list2) {
					count=Integer.valueOf(obj.toString());
					break;
				}
			}
			dataGrid.setItems(logs);
			dataGrid.setNumRows(count);
		} catch (Exception e) {
			System.out.println(e);
			dataGrid.setItems(new ArrayList<DispatchLog>());
			dataGrid.setNumRows(0);
			return dataGrid;
		}
		return dataGrid;
	}

}