分页查询

一、封装返回的实体类

    Page<AuditEventLogSearchResponse> ，并利用model 封装请求数据 

Controller 层

	@GetMapping("/search")
	@PreAuthorize("hasRole('HIT_FINANCE')")
	public Page<AuditEventLogSearchResponse> getAuditEventLog(AuditEventLogSearchRequest request) {
		int curPage = request.getCurPage();
		int pageSize = request.getPageSize();
		String principal = request.getPrincipal();
		String timemin = request.getTimemin();
		String timemax = request.getTimemax();
		String type = request.getType();
		// params
		Map<String, String> params = new HashMap<>();
		params.put("principal", principal);
		params.put("timemin", timemin);
		params.put("timemax", timemax);
		params.put("type", type);
		// page
		BasePage page = new BasePage();
		page.setCurPage(curPage);
		page.setPageSize(pageSize);
		// add sort
		List<Sort.Order> orderList = new ArrayList<>();
		if (request.getCompositors() != null && request.getCompositors().size() != 0) {
			for (Compositor compositor : request.getCompositors()) {
				Sort.Order orders = new Sort.Order(compositor.getDirection(), compositor.getProperty());
				orderList.add(orders);
			}
		}
		else {
			Sort.Order order = Sort.Order.desc("timeStamp");
			orderList.add(order);
		}
		Pageable pageable = PageRequest.of(curPage, pageSize, Sort.by(orderList));
		Page<Audit> auditContent = auditTrailLogService.searchAuditTrailLog(params, pageable);
		return generalResponse(auditContent);

private Page<AuditEventLogSearchResponse> generalResponse(Page<Audit> auditContent) {
		Pageable pageable = auditContent.getPageable();
		long total = auditContent.getTotalElements();
		List<Audit> auditlogcontent = auditContent.getContent();
		List<AuditEventLogSearchResponse> content = new ArrayList<>();
		for (Audit audit : auditlogcontent) {
			AuditEventLogSearchResponse response = new AuditEventLogSearchResponse();
			response.setDatetime(audit.getTimeStamp());
			response.setPrincipal(audit.getPrincipal());
			response.setType(audit.getType());
			response.setData(audit.getData());
			content.add(response);
		}
		return new PageImpl<>(content, pageable, total);
	}

Service:

@Service
public class AuditTrailLogServiceImpl implements AuditTrailLogService {

	@Autowired
	private AuditRepository auditRepository;

	@Override
	public PageImpl<Audit> searchAuditTrailLog(Map<String, String> params, Pageable pageable) {

		return auditRepository.searchAuditSearchLog(params, pageable);
	}

}

Dao:

	@Override
	@Transactional
	public PageImpl<Audit> searchAuditSearchLog(Map<String, String> params, Pageable pageable) {

		Long count = countByCondition(params);
		CriteriaBuilder cb = entityManager.getCriteriaBuilder();
		CriteriaQuery<Audit> cq = cb.createQuery(Audit.class);
		Root<Audit> root = cq.from(Audit.class);
		List<Predicate> predicates = buildQueryPredicate(params, root, cb);
		if (!predicates.isEmpty()) {
			cq.where(predicates.toArray(new Predicate[0]));
		}
		List<Order> sortOrder;
		if (pageable != null) {
			sortOrder = QueryUtils.toOrders(pageable.getSort(), root, cb);
		}
		else {
			Sort.Order orderId = Sort.Order.desc("timeStamp");
			List<Sort.Order> orders = new ArrayList<>();
			orders.add(orderId);
			sortOrder = QueryUtils.toOrders(Sort.by(orders), root, cb);
		}
		cq.orderBy(sortOrder);

		TypedQuery<Audit> query = entityManager.createQuery(cq);
		if (pageable != null) {
			query.setMaxResults(pageable.getPageSize());
			query.setFirstResult((int) pageable.getOffset());
		}
		List<Audit> auditList = query.getResultList();
		return new PageImpl<>(auditList, pageable, count);

	}
@Override
	@Transactional
	public Long countByCondition(Map<String, String> params) {
		CriteriaBuilder cb = entityManager.getCriteriaBuilder();
		CriteriaQuery<Long> cq = cb.createQuery(Long.class);
		Root<Audit> root = cq.from(Audit.class);
		cq.select(cb.count(root));
		List<Predicate> predicateList = buildQueryPredicate(params, root, cb);
		if (!predicateList.isEmpty()) {
			cq.where(predicateList.toArray(new Predicate[0]));
		}
		return entityManager.createQuery(cq).getSingleResult();
	}

	private List<Predicate> buildQueryPredicate(Map<String, String> params, Root<Audit> root, CriteriaBuilder cb) {
		List<Predicate> predicates = new ArrayList<>();
		String type = params.get("type");
		String timemin = params.get("timemin");
		String timemax = params.get("timemax");
		String principal = params.get("principal");
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
		Date datetimeF = null;
		Date datetimeT = null;
		try {

			datetimeF = sdf.parse(timemin);
			datetimeT = sdf.parse(timemax);
		}
		catch (ParseException e) {
			e.getMessage();
		}
		Timestamp timestampF = new Timestamp(datetimeF.getTime());
		Timestamp timestampT = new Timestamp(datetimeT.getTime());

		if (!StringUtils.isEmpty(type)) {
			predicates.add(cb.equal(root.get("type"), type));
		}
		if (!StringUtils.isEmpty(principal)) {
			predicates.add(cb.like(root.get("principal"), "%" + principal + "%"));
		}
		if (!StringUtils.isEmpty(timemin)) {
			predicates.add(cb.greaterThanOrEqualTo(root.get("timeStamp").as(String.class), timestampF.toString()));
		}
		if (!StringUtils.isEmpty(timemax)) {
			String timeTo = timestampT.toString();
			String[] plit = timeTo.split(" ");
			timeTo = plit[0] + " 23:59:59";
			predicates.add(cb.lessThanOrEqualTo(root.get("timeStamp").as(String.class), timeTo));
		}
		return predicates;
	}