spring boot+jpa分页查询（搜索）（Specification、Predicate）

最新推荐文章于 2023-07-12 23:21:22 发布
最新推荐文章于 2023-07-12 23:21:22 发布
阅读量765 收藏 1
点赞数
分类专栏： Java知识总结
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LFWlfwl/article/details/108099148
版权

上代码：
NeElement实体：

package com.sunwave.grouping.domain;

import javax.persistence.*;

import com.alibaba.excel.annotation.ExcelIgnore;
import com.alibaba.excel.annotation.ExcelProperty;
import com.alibaba.excel.metadata.BaseRowModel;
import com.fasterxml.jackson.annotation.JsonBackReference;
import com.fasterxml.jackson.annotation.JsonIgnore;
import com.fasterxml.jackson.annotation.JsonManagedReference;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
//import com.sunwave.common.alarm.AlmAlarmlog;
//import com.sunwave.common.alarm.AlmAlarmlogHistory;
//import com.sunwave.common.alarm.AlmAlarmlogMask;
//import com.sunwave.common.platform.NeCompany;


/**
 * @author lfw
 * @date   2020年8月3日
 * @time   下午6:44:54
 * 
 */
@Entity
@Table(name = "ne_element")
public class NeElement extends BaseRowModel implements Serializable{

	/**
	 * extends BaseRowModel
	 */
	private static final long serialVersionUID = 1L;
	
	@Id
	@GeneratedValue(strategy = GenerationType.AUTO)
	private Long neNeid; //设备唯一标识
	@ExcelProperty(value="设备连接URL")
	private String coonReqUrl; //设备连接URL
	@ExcelProperty(value="设备序列号")
	private String serialNumber; //设备序列号
	@ExcelProperty(value="设备IP")
	private String deviceIp;  //设备IP
	@ExcelProperty(value="modelId")
	private String modelId;//modelName对应的id
	@ExcelProperty(value="描述")
	private String description;//描述
	@ExcelProperty(value="制造商")
	private String manufacturer;//制造商
	@ExcelProperty(value="软件版本")
	private String softwareVersion;//软件版本
	@ExcelProperty(value="创建时间")
	private Date creationTime;//创建时间
	@ExcelProperty(value="lastBootstrapTime")
	private Date lastBootstrapTime;
	@ExcelProperty(value="最后连接时间")
	private Date lastConnTime;//最后连接时间
	@ExcelProperty(value="更新时间")
	private Date updateTime;//更新时间
	@ExcelProperty(value="oui")
	private String oui;//oui
	@ExcelProperty(value="product")
	private String product;
	@ExcelProperty(value="是否需要认证")
	private Boolean authRequirement;//是否需要认证
	@ExcelProperty(value="dialectIP")
	private String dialectIP;
	@ExcelProperty(value="更新用户")
	private String updateUser;//更新用户
	@ExcelProperty(value="mac地址")
	private String macAddress;//mac地址
	@ExcelProperty(value="在线状态")
	private Integer onlineStatus;//在线状态
	@ExcelProperty(value="会话状态")
	private Integer sessionStatus;//会话状态
	@ExcelIgnore
    @ManyToMany(cascade=CascadeType.ALL, mappedBy = "elementList")
    @JsonIgnore
	private List<DeviceGroup> deviceGroupList=new ArrayList<DeviceGroup>();
   
   
	public List<DeviceGroup> getDeviceGroupList() {
	return deviceGroupList;
}
   public void setDeviceGroupList(List<DeviceGroup> deviceGroupList) {
	this.deviceGroupList = deviceGroupList;
}

	public String getDescription() {
		return description;
	}

	public void setDescription(String description) {
		this.description = description;
	}

	public String getManufacturer() {
		return manufacturer;
	}

	public void setManufacturer(String manufacturer) {
		this.manufacturer = manufacturer;
	}

	public String getSoftwareVersion() {
		return softwareVersion;
	}

	public void setSoftwareVersion(String softwareVersion) {
		this.softwareVersion = softwareVersion;
	}

	public Date getLastConnTime() {
		return lastConnTime;
	}

	public void setLastConnTime(Date lastConnTime) {
		this.lastConnTime = lastConnTime;
	}

	public String getModelId() {
		return modelId;
	}

	public void setModelId(String modelId) {
		this.modelId = modelId;
	}

	public Long getNeNeid() {
		return neNeid;
	}

	public void setNeNeid(Long neNeid) {
		this.neNeid = neNeid;
	}

	public String getCoonReqUrl() {
		return coonReqUrl;
	}

	public void setCoonReqUrl(String coonReqUrl) {
		this.coonReqUrl = coonReqUrl;
	}

	public String getDeviceIp() {
		return deviceIp;
	}

	public void setDeviceIp(String deviceIp) {
		this.deviceIp = deviceIp;
	}



	public String getSerialNumber() {
		return serialNumber;
	}

	public void setSerialNumber(String serialNumber) {
		this.serialNumber = serialNumber;
	}

	public Date getCreationTime() {
		return creationTime;
	}

	public void setCreationTime(Date creationTime) {
		this.creationTime = creationTime;
	}

	public Date getLastBootstrapTime() {
		return lastBootstrapTime;
	}

	public void setLastBootstrapTime(Date lastBootstrapTime) {
		this.lastBootstrapTime = lastBootstrapTime;
	}

	public Date getUpdateTime() {
		return updateTime;
	}

	public void setUpdateTime(Date updateTime) {
		this.updateTime = updateTime;
	}

	public String getOui() {
		return oui;
	}

	public void setOui(String oui) {
		this.oui = oui;
	}

	public String getProduct() {
		return product;
	}

	public void setProduct(String product) {
		this.product = product;
	}

	public Boolean getAuthRequirement() {
		return authRequirement;
	}

	public void setAuthRequirement(Boolean authRequirement) {
		this.authRequirement = authRequirement;
	}

	public String getDialectIP() {
		return dialectIP;
	}

	public void setDialectIP(String dialectIP) {
		this.dialectIP = dialectIP;
	}

	public String getUpdateUser() {
		return updateUser;
	}

	public void setUpdateUser(String updateUser) {
		this.updateUser = updateUser;
	}

	public String getMacAddress() {
		return macAddress;
	}

	public void setMacAddress(String macAddress) {
		this.macAddress = macAddress;
	}

	public Integer getOnlineStatus() {
		return onlineStatus;
	}

	public void setOnlineStatus(Integer onlineStatus) {
		this.onlineStatus = onlineStatus;
	}

	public Integer getSessionStatus() {
		return sessionStatus;
	}

	public void setSessionStatus(Integer sessionStatus) {
		this.sessionStatus = sessionStatus;
	}

	@Override
	public String toString() {
		return "NeElement [neNeid=" + neNeid + ", coonReqUrl=" + coonReqUrl + ", serialNumber=" + serialNumber
				+ ", deviceIp=" + deviceIp + ", modelId=" + modelId + ", description=" + description + ", manufacturer="
				+ manufacturer + ", softwareVersion=" + softwareVersion + ", creationTime=" + creationTime
				+ ", lastBootstrapTime=" + lastBootstrapTime + ", lastConnTime=" + lastConnTime + ", updateTime="
				+ updateTime + ", oui=" + oui + ", product=" + product + ", authRequirement=" + authRequirement
				+ ", dialectIP=" + dialectIP + ", updateUser=" + updateUser + ", macAddress=" + macAddress
				+ ", onlineStatus=" + onlineStatus + ", sessionStatus=" + sessionStatus + ", deviceGroupList="
				+ deviceGroupList + "]";
	}
		
	
}

搜索辅助类1：用于根据什么条件搜索。

package com.sunwave.deviceManagement.query;


import org.springframework.data.domain.Sort;

import com.sunwave.common.dao.UUIDSupport;

public class NeElementQuery extends SearchQuery {
	
	
    private String serverName;
    private Long neNeid;
    private String deviceIp;  //设备IP
    private String manufacturer;//制造商
   

	public String getDeviceIp() {
		return deviceIp;
	}

	public void setDeviceIp(String deviceIp) {
		this.deviceIp = deviceIp;
	}

	public String getManufacturer() {
		return manufacturer;
	}

	public void setManufacturer(String manufacturer) {
		this.manufacturer = manufacturer;
	}

	public Long getNeNeid() {
		return neNeid;
	}

	public void setNeNeid(Long neNeid) {
		this.neNeid = neNeid;
	}

	public String getServerName() {
        return serverName;
    }

    public void setServerName(String serverName) {
        this.serverName = serverName;
    }

    @Override
    public Sort.Direction getDirection() {
        Sort.Direction orderDirection = Sort.Direction.DESC;
        if (this.getOrderDesc() != null && !"".equals(this.getOrderDesc())) {
            if ("asc".equals(this.getOrderDesc().toLowerCase())) {
                orderDirection = Sort.Direction.ASC;
            }
        }
        return orderDirection;
    }

	@Override
	public String toString() {
		return "NeElementQuery [serverName=" + serverName + ", neNeid=" + neNeid + ", deviceIp=" + deviceIp
				+ ", manufacturer=" + manufacturer + "]";
	}
	
}

搜索辅助类2：用于根据什么条件搜索。

package com.sunwave.deviceManagement.query;

import org.springframework.data.domain.Sort;
import org.springframework.data.domain.Sort.Direction;

import com.sunwave.common.dao.UUIDSupport;


/**
 * @author fuwen_li
 * @date   2020年8月19日
 * @time   上午11:03:41
 * 
 */
public class SearchQuery extends UUIDSupport {
	
	/*关键字查询*/
	private String keyword;
	/*页码*/
	private int pageIndex;
	/*每页显示大小*/
	private int pageSize;
	
	private String orderName;
	
	private String orderDesc;//订单说明
		

	public String getKeyword() {
		return keyword;
	}

	public void setKeyword(String keyword) {
		this.keyword = keyword;
	}

	public int getPageIndex() {
		if(this.pageIndex<1){
			pageIndex = 0;
		}
		else{
			pageIndex = pageIndex-1;
		}
		return pageIndex;
	}

	public void setPageIndex(int pageIndex) {
		this.pageIndex = pageIndex;
	}

	public int getPageSize() {
		return pageSize;
	}

	public void setPageSize(int pageSize) {
		this.pageSize = pageSize;
	}

	public String getOrderName() {
		return orderName;
	}

	public void setOrderName(String orderName) {
		this.orderName = orderName;
	}

	public String getOrderDesc() {
		return orderDesc;
	}

	public void setOrderDesc(String orderDesc) {
		this.orderDesc = orderDesc;
	}
	
	
	public String getOrderName(String basicName) {
		if(this.orderName!=null&&!"".equals(this.orderName)) {
			return this.orderName;
		}else {
			return basicName;
		}
	}
	
	public Direction getDirection() {
		Direction orderDirection = Sort.Direction.ASC;
		if(this.orderDesc!=null&&!"".equals(this.orderDesc)) {
			if("desc".equals(this.orderDesc.toLowerCase())){
				orderDirection = Sort.Direction.DESC;
			};
		}
		return orderDirection;
	}
	
	
}

Repository层：

package com.sunwave.deviceManagement.repository;

import java.util.List;

import com.sunwave.grouping.domain.NeElement;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
import org.springframework.data.jpa.repository.Query;
import org.springframework.stereotype.Repository;

@Repository
public interface NeElementRepository extends JpaRepository<NeElement, Long>,  JpaSpecificationExecutor<NeElement> {

	 NeElement findByNeNeid(long neId);
	
}

service层：

package com.sunwave.deviceManagement.service;

import java.util.List;
import java.util.Map;
import java.util.Optional;

import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.data.jpa.domain.Specification;

import com.sunwave.deviceManagement.query.NeElementQuery;
import com.sunwave.grouping.domain.NeElement;

public interface NeElementService {
	
	public Page<NeElement> findNeElementPage(NeElementQuery query);//分页查询
	/* 根据id获取用户信息 */
	public NeElement getNeElement(Long id) throws Exception;
	
	     
}

service的实现层serviceImpl:

package com.sunwave.deviceManagement.service.impl;


import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Optional;

import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.JoinType;
import javax.persistence.criteria.Predicate;
import javax.persistence.criteria.Root;

import com.sunwave.grouping.domain.NeElement;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Sort;
import org.springframework.data.jpa.domain.Specification;
import org.springframework.stereotype.Service;

import com.sunwave.deviceManagement.query.NeElementQuery;
import com.sunwave.deviceManagement.repository.NeElementRepository;
import com.sunwave.deviceManagement.service.NeElementService;
import com.sunwave.grouping.domain.DeviceGroup;
import com.sunwave.grouping.domain.NeElement;
import com.sunwave.grouping.service.DeviceGroupService;

@Service
public class NeElementServiceImpl implements  NeElementService{

	@Autowired
	NeElementRepository neElementRepository;
	
	@Autowired
	DeviceGroupService deviceGroupService;
		
	
	@Override
	public Page<NeElement> findNeElementPage(NeElementQuery query) {
		Sort sort = new Sort(query.getDirection(), query.getOrderName("neNeid"));
		Specification<NeElement> specification = getWhereClause(query);
		
		PageRequest page = new PageRequest(query.getPageIndex(), query.getPageSize(), sort);
		Page<NeElement> all = neElementRepository.findAll(specification, page);	
		return all;
	}
	   
	private Specification<NeElement> getWhereClause(final NeElementQuery searchquery) {
		 return new Specification<NeElement>() {
			public Predicate toPredicate(Root<NeElement> root, CriteriaQuery<?> query, CriteriaBuilder cb){
				List<Predicate> predicate = new ArrayList<>();
				if (searchquery != null) {
					System.out.println("searchquery.getId():"+searchquery.getId());															
					if(searchquery.getId() != null && !"".equals(searchquery.getId())) {					
//						DeviceGroup group = new DeviceGroup();
//						group.setId(searchquery.getId());	
//						System.out.println("group:"+group);
						 
						Predicate p = cb.equal( root.join(root.getModel().getList("deviceGroupList",DeviceGroup.class), JoinType.INNER).get("id").as(String.class), searchquery.getId());
	                    predicate.add(p);		                   			            
					//	 predicate.add( cb.equal(root.get("deviceGroupList").get,searchquery.getId()));
					}
                   if (searchquery.getDeviceIp()!= null){               	  
                	      predicate.add( cb.like(root.get("deviceIp"),"%"+searchquery.getDeviceIp()+"%"));
												
                	  }	
                   if(searchquery.getManufacturer() != null) {
                	 predicate.add( cb.like(root.get("manufacturer"),"%"+searchquery.getManufacturer()+"%"));	
                	 /*predicate.add( cb.equal(root.get("manufacturer"),searchquery.getManufacturer()));	*/
                }
                        
				}								
				Predicate[] pre = new Predicate[predicate.size()];
	            return query.where(predicate.toArray(pre)).getRestriction();
			}
		};		
	}


	  
}

最后是controller层：

package com.sunwave.deviceManagement.controller;

import static org.springframework.test.web.servlet.result.MockMvcResultHandlers.log;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Optional;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletResponse;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.redis.core.RedisTemplate;

import org.springframework.data.redis.serializer.StringRedisSerializer;
import org.springframework.web.bind.annotation.CrossOrigin;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
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 org.springframework.web.bind.annotation.RestController;

import com.alibaba.excel.metadata.Sheet;
import com.sunwave.common.EventType;
import com.sunwave.config.RedisService;
import com.sunwave.deviceManagement.domain.NeModelParam;
import com.sunwave.deviceManagement.query.NeElementQuery;
import com.sunwave.deviceManagement.service.NeElementService;
import com.sunwave.deviceManagement.service.NeModelParamService;
import com.sunwave.dto.OperationDto;
import com.sunwave.grouping.domain.NeElement;
import com.sunwave.sender.MessageSender;
import com.sunwave.utils.ExportUtil;
import com.sunwave.utils.HttpUtil;
import com.sunwave.utils.JacksonUtil;
import com.sunwave.vo.GroupVo;
import com.sunwave.vo.ParamVo;
import com.sunwave.vo.Result;

import io.swagger.annotations.ApiOperation;

/**
 * @author lfw
 * @date   2020年8月5日
 * @time   上午8:32:00
 * 
 */
@CrossOrigin//此注解可解决跨域问题
@RestController
@RequestMapping("/api/neElement")
public class NeElementController {
	
	private final static Logger logger = LoggerFactory.getLogger(NeElementController.class); 
	
	@Autowired
	NeElementService neElementService;
	
	 @Resource
	 RedisTemplate  redisTemplate;
	 
	 @Autowired
	 RedisService redisService;
	 
	 @Autowired
	 MessageSender messageSender;
	   
	 @Autowired
	 NeModelParamService neModelParamService;
	 

	    
	    @SuppressWarnings("finally")
		@RequestMapping(value="/getNeElement",method = RequestMethod.POST)//分页查询
		@ResponseBody
		public Page<NeElement> getNeElement(@RequestBody NeElementQuery query){
	    	logger.info("Enter into NeElementController.getNeElement()");
	    	Page<NeElement> neElement= null;
			try {
				 neElement= neElementService.findNeElementPage(query);
				
			} catch (Exception e) {
				// TODO Auto-generated catch block
				logger.error("Error in NeElementController.getNeElement():"+e.getMessage());
			}	
			finally{
				logger.info("Exist NeElementController.getNeElement()");
							
				return neElement;
			}
		
	    }
	
  
	    @ResponseBody
		@ApiOperation(value = "导出excel",httpMethod="GET") 
	    @GetMapping("/exportExcel")
		public  Result exportExcel(HttpServletResponse response,@RequestBody GroupVo groupVo) {	
			logger.info("Enter into NeElementController.exportExcel");
			try { 
				List<NeElement> list=new ArrayList<NeElement>();
				for (int j = 0; j <groupVo.getNeIdList().size(); j++) {
					Long neId =  groupVo.getNeIdList().get(j);		         		           
				    NeElement element = neElementService.getElementExcel(neId);				
		       
			        list.add(element);
				}
				Sheet sheet = new Sheet(1, 0,NeElement.class);				
			  ExportUtil.doExportExcel(response, "Element", "sheet1", sheet, list);
				
			}catch (Exception e) {
			   logger.error("Error in NeElementController.exportExcel()" + e.getMessage());			   
			return Result.failure(100, "导出失败");
				   
		    }		
			logger.info("Exist NeElementController.exportExcel()");
			return 	 Result.ok("导出成功");
			
		}
	 

		
}

🆗了，自己把多余的代码去掉，核心在service的实现层。

最后加上几个实用工具类：
1、导出excel的工具类：

package com.sunwave.utils;

import java.io.IOException;
import java.util.List;

import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServletResponse;


import com.alibaba.excel.ExcelWriter;
import com.alibaba.excel.metadata.Sheet;
import com.alibaba.excel.support.ExcelTypeEnum;

/**
 *  阿里easyexcel  xlsx导出
 */
public class ExportUtil {

 /**
  *  xlsx导出
  * @param response   HttpServletResponse
  * @param fileName   文件名称
  * @param sheetName   sheet名称
  * @param sheet    Sheet sheet = new Sheet(1, 0,UserDTO.class);需要被导出的实体类，实体类需要继承BaseRowModel
  * @param list    需要导出的数据集
  * @throws IOException
  */
 @SuppressWarnings({ "deprecation", "rawtypes" }) 
 public static void doExportExcel(HttpServletResponse response,String fileName,String sheetName,Sheet sheet,List list) throws IOException
 {
   ServletOutputStream out = response.getOutputStream();
         ExcelWriter writer = new ExcelWriter(out, ExcelTypeEnum.XLSX, true);
         //设置自适应宽度      
         sheet.setAutoWidth(Boolean.TRUE);
         // 第一个 sheet 名称
         sheet.setSheetName(sheetName);
         writer.write(list, sheet);
         //通知浏览器以附件的形式下载处理，设置返回头要注意文件名有中文
         response.setHeader("Content-disposition", "attachment;filename=" + new String( fileName.getBytes("gb2312"), "ISO8859-1" ) + ".xlsx");
         writer.finish();
         response.setContentType("multipart/form-data");
         response.setCharacterEncoding("utf-8");
         out.flush();
 } 
}

2、返回值封装工具类：

package com.sunwave.vo;

import com.fasterxml.jackson.annotation.JsonIgnore;
import com.fasterxml.jackson.annotation.JsonInclude;

import java.util.HashMap;
import java.util.Map;

/**
 * 
 * @author  ylf
 * @date	2020年3月12日
 * @time	上午11:41:15
 * @param <T>
 */
@JsonInclude(JsonInclude.Include.NON_NULL)
public class Result<T> {

    private static final String CODE = "code";
    private static final String MSG = "msg";

    private Integer code=200;
    private String msg="操作成功";
    private String description;
    private T data;

    private HashMap<String,Object> exend;

    public Integer getCode() {
        return code;
    }

    public void setCode(Integer code) {
        this.code = code;
    }

    public String getMsg() {
        return msg;
    }

    public void setMsg(String msg) {
        this.msg = msg;
    }

    public T getData() {
        return data;
    }

    public Result setData(T data) {
        this.data = data;
        return this;
    }

    public String getDescription() {
        return description;
    }

    public void setDescription(String description) {
        this.description = description;
    }

    @JsonIgnore
    public HashMap<String, Object> getExend() {
        return exend;
    }

    public void setExend(HashMap<String, Object> exend) {
        this.exend = exend;
    }

    public Result() {
        exend = new HashMap<>();
    }

    public static Result failure(int code, String msg) {
        Result result = new Result();
        result.setCode(code);
        result.setMsg(msg);
        return result;
    }

    public static Result ok(String msg) {
        Result result = new Result();
        result.put("msg", msg);
        return result;
    }

    public static Result ok(Map<String, Object> map) {
        Result result = new Result();
        result.exend.putAll(map);
        return result;
    }

    public static Result ok() {
        return new Result();
    }

    public Result put(String key, Object value) {
        exend.put(key, value);
        return this;
    }
}

3、json工具类：

package com.sunwave.utils;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

public class JacksonUtil {

    private static final Log logger = LogFactory.getLog(JacksonUtil.class);

    public static String parseString(String body, String field) {
        ObjectMapper mapper = new ObjectMapper();
        JsonNode node;
        try {
            node = mapper.readTree(body);
            JsonNode leaf = node.get(field);
            if (leaf != null)
                return leaf.asText();
        } catch (IOException e) {
            logger.error(e.getMessage(), e);
        }
        return null;
    }


    public static List<String> parseStringList(String body, String field) {
        ObjectMapper mapper = new ObjectMapper();
        JsonNode node;
        try {
            node = mapper.readTree(body);
            JsonNode leaf = node.get(field);

            if (leaf != null)
                return mapper.convertValue(leaf, new TypeReference<List<String>>() {
                });
        } catch (IOException e) {
            logger.error(e.getMessage(), e);
        }
        return null;
    }

    public static Integer parseInteger(String body, String field) {
        ObjectMapper mapper = new ObjectMapper();
        JsonNode node;
        try {
            node = mapper.readTree(body);
            JsonNode leaf = node.get(field);
            if (leaf != null)
                return leaf.asInt();
        } catch (IOException e) {
            logger.error(e.getMessage(), e);
        }
        return null;
    }

    public static List<Integer> parseIntegerList(String body, String field) {
        ObjectMapper mapper = new ObjectMapper();
        JsonNode node;
        try {
            node = mapper.readTree(body);
            JsonNode leaf = node.get(field);

            if (leaf != null)
                return mapper.convertValue(leaf, new TypeReference<List<Integer>>() {
                });
        } catch (IOException e) {
            logger.error(e.getMessage(), e);
        }
        return null;
    }


    public static Boolean parseBoolean(String body, String field) {
        ObjectMapper mapper = new ObjectMapper();
        JsonNode node;
        try {
            node = mapper.readTree(body);
            JsonNode leaf = node.get(field);
            if (leaf != null)
                return leaf.asBoolean();
        } catch (IOException e) {
            logger.error(e.getMessage(), e);
        }
        return null;
    }

    public static Short parseShort(String body, String field) {
        ObjectMapper mapper = new ObjectMapper();
        JsonNode node;
        try {
            node = mapper.readTree(body);
            JsonNode leaf = node.get(field);
            if (leaf != null) {
                Integer value = leaf.asInt();
                return value.shortValue();
            }
        } catch (IOException e) {
            logger.error(e.getMessage(), e);
        }
        return null;
    }

    public static Byte parseByte(String body, String field) {
        ObjectMapper mapper = new ObjectMapper();
        JsonNode node;
        try {
            node = mapper.readTree(body);
            JsonNode leaf = node.get(field);
            if (leaf != null) {
                Integer value = leaf.asInt();
                return value.byteValue();
            }
        } catch (IOException e) {
            logger.error(e.getMessage(), e);
        }
        return null;
    }

    public static <T> T parseObject(String body, String field, Class<T> clazz) {
        ObjectMapper mapper = new ObjectMapper();
        JsonNode node;
        try {
            node = mapper.readTree(body);
            node = node.get(field);
            return mapper.treeToValue(node, clazz);
        } catch (IOException e) {
            logger.error(e.getMessage(), e);
        }
        return null;
    }

    public static <T> T parseObject(String body, Class<T> clazz) {
        ObjectMapper mapper = new ObjectMapper();
        JsonNode node;
        try {
            node = mapper.readTree(body);
            return mapper.treeToValue(node, clazz);
        } catch (IOException e) {
            logger.error(e.getMessage(), e);
        }
        return null;
    }

    public static <T>  List<T> parseObjectList(String body, String field, Class<T> tClass) {
        ObjectMapper mapper = new ObjectMapper();
        JsonNode node;
        List<T> result = new ArrayList<>();
        try {
            node = mapper.readTree(body);
            JsonNode leaf = node.get(field);
            if (leaf != null){
                List list = mapper.convertValue(leaf, new TypeReference<List<T>>() {
                });
                for (Object o : list) {
                    String s = toJson(o);
                    T t = mapper.convertValue(toNode(s), tClass);
                    result.add(t);
                }
                return result;
            }


        } catch (IOException e) {
            logger.error(e.getMessage(), e);
        }
        return null;
    }

    public static Object toNode(String json) {
        if (json == null) {
            return null;
        }
        ObjectMapper mapper = new ObjectMapper();
        try {

            return mapper.readTree(json);
        } catch (IOException e) {
            logger.error(e.getMessage(), e);
        }

        return null;
    }

    public static Map<String, String> toMap(String data) {
        ObjectMapper objectMapper = new ObjectMapper();
        try {
            return objectMapper.readValue(data, new TypeReference<Map<String, String>>() {
            });
        } catch (IOException e) {
            logger.error(e.getMessage(), e);
        }
        return null;
    }

    public static String toJson(Object data) {
        ObjectMapper objectMapper = new ObjectMapper();
        try {
            return objectMapper.writeValueAsString(data);
        } catch (JsonProcessingException e) {
            e.printStackTrace();
        }
        return null;
    }
}

以后继续分享。

LFW福哥
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JPA内将时间作为查询条件，分页查询当天的数据库数据的两种写法(涉及Specification、Predicate、CriteriaBuilder)
qq_40788668的博客
12-19 2199
JPA内将时间作为查询条件，分页查询当天的数据库数据的两种写法(涉及Specification、Predicate、CriteriaBuilder) 最近做项目时公司要用jpa,遇到关于时间的查询条件的问题，总结如下：废话不多说，直接上代码 1. 使用localDateTime //可以按照某个条件排序，比如 “auditUnique” Sort sort = new Sort(Sort.Dir...
springboot jpa Predicate 的使用，实现多条件的复杂查询。
qq_36872322的博客
07-10 9845
在springboot jpa中 我们可以使用Example.of(entity) 来进行条件的查询（这个之前已经介绍过了），但是这个方法不是太灵活，无法使条件灵活的变化。今天在看公司大佬写的代码时发现了一个特别实用的类，Predicate 。下面介绍一下他的用法，因为本人也在学习过程当中，这篇文章会做一定的改善。 1 我们首先定义一个接口继承PagingAndSortingRepository...
jpa多条件查询重写Specification的toPredicate方法
Tiger_Paul的博客
01-21 1538
Spring Data JPA支持JPA2.0的Criteria查询，相应的接口是JpaSpecificationExecutor。Criteria 查询：是一种类型安全和更面向对象的查询 。这个接口基本是围绕着Specification接口来定义的。
springboot jpa 使用Predicate进行in条件查询
wangjw.bug
05-21 5202
if (list != null && list.size() > 0){ Expression<Long> exp = root.<Long>get("xxx"); predicateList.add(exp.in(list)); }
JPA-Specification常用条件查询构造方式
职业炮灰的博客
09-25 3297
使用JAP的JpaSpecificationExecutor常用条件查询方式
spring boot+jpa+redis集群
04-22
spring boot + jpa + redis集群。压缩包中包含工程代码（直接运行即可，需要修改yml文件中数据库地址和redis部署机器IP地址）、部署文档和redis 3.0+ruby的安装包
spring boot + jpa + kotlin入门实例详解
08-29
主要介绍了spring boot + jpa + kotlin入门实例详解 ,需要的朋友可以参考下
采用Spring Boot + JPA + Thymeleaf实现的旅游之旅系统
最新发布
04-26
采用Spring Boot + JPA + Thymeleaf实现的旅游之旅系统是一款为用户提供丰富旅游信息和服务的网络平台。该系统整合了Spring Boot框架的快速开发特性、JPA技术的对象关系映射和数据库操作能力，以及Thymeleaf模板引擎...
java + spring boot +jpa 拦截器分库分表demo
03-30
针对spring boot 集成jpa sql操作进行自定义分库分表逻辑
基于spring boot + JPA的进销存管理系统源码
05-12
本项目用的是spring tool suite + maven的集成开发环境，java作为开发语言，使用spring boot 内置tomcat作为web服务器，数据库使用的是mysql，加上使用spring boot + JPA框架。结合mysql数据库存储的优点，体积小，...
JPA多条件复杂查询Specification方法
alinekang的博客
12-24 1529
JPA多条件复杂查询时，使用Predicate复杂查询多字段排序的实现，这种是不分页的排序查询 public List<A> getData(Condition condition){ //condition是查询条件 return ADao.findAll((Specification<A>) (root, query, cb) -...
JPA重写Specification的toPredicate多条件查询
Dp888888的博客
03-30 843
一、JPA如何使用Spcification dao层继承 public interface JpaSpecificationExecutor<T> 由此接口源码，看出有可以分页按条件查询和不分页按条件查询的功能 public interface JpaSpecificationExecutor<T> { T findOne(Specification<T> var1); List<T> findAll(Specification&lt...
【自我提升】Spring Data JPA之Specification动态查询详解
習習君的博客
07-12 4506
刷完Spring Data JPA的课后，发现Specification动态查询还挺有意思的，还应用到了规约设计模式，在此记录下学习过程和见解。Specification是一个设计模式，常常用于企业级应用开发中，其主要目的是将业务规则从业务逻辑中分离出来。在数据查询方面，Specification可以定义复杂的查询，使其更易于重用和测试。
学习总结Specification接口里的toPredicate(Root<T> root, CriteriaQuery<?> query, CriteriaBuilder cb)
热门推荐
ppppoooo6的博客
10-10 1万+
其中 Root是查询结果的一个实体对象，也就是查询结果返回的主要对象，其中一对多OR多对一就是从这个对象开始计算的，具体层级关系 javax.persistence.TupleElement javax.persistence.criteria.Selection javax.persistence.criteria.Expression javax.persistence.criteri
springdatajpa条件查询
qq_37361401的博客
04-14 283
首先当然是在controller中增加一个方法: @RequestMapping(value = "/search",method = RequestMethod.POST) public Result findSearch(@RequestBody Label label){ List<Label> list = labelService.findSearch...
spring data jpa之动态条件查询（搜索）
qq_41346335的博客
02-27 3224
前言 在开发的时候，我们难免会遇到搜索，接下来让我们来实现搜索功能的实现。 思路 首先在Repository类上不仅要继承JpaRepository，还要继承JpaSpecificationExecutor这个类实现条件查询。 在service的findAll方法中中new一个Specification方法，实现里面的toPredicate方法。 排序的我们可以使用page = new Page...
Spring Boot Jpa之构建动态SQL查询语句
江湖人称黑哥的博客
08-28 1256
Spring Boot Jpa之构建动态SQL查询语句 引入依赖包： <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-jpa</artifactId> </dependency> DAO接口继承JpaSpecificationExecutor。 该接口允许基于JPA标准的API规范
SpringBoot：整合JPA-Specifications动态查询：
记录点点滴滴的成长。
08-02 1150
有时我们在查询某个实体的时候，给定的条件是不固定的，这时就需要动态构建相应的查询语句，在Spring Data JPA中可以通过JpaSpecificationExecutor接口查询。CriteriaBuilder：构造查询条件的，内部封装了很多的查询条件（模糊匹配，精准匹配））1.实现Specification接口（提供泛型：查询的对象类型）2.实现toPredicate方法构造查询条件）。root：获取需要查询的对象属性。...
JPA(一) 常用查询方法
得已
10-18 811
以这张表为例： +-------------+--------------+------+-----+-------------------+----------------+ | Field | Type | Null | Key | Default | Extra | +-------------+-------------...
spring boot + jpa
07-28
回答: Spring Boot与JPA的结合可以通过添加相应的依赖来实现。在pom.xml文件中，可以添加以下依赖来引入JPA的核心依赖：\[1\] ``` <groupId>org.springframework.boot <artifactId>spring-boot-starter-data-jpa ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值