JPA中如何实现动态查询、动态更新、批量删除等操作？

JPA中实现动态查询、动态更新、批量删除等操作

一、新建一个实体类

@Data
@Entity
@Table(name = "organize")
public class Organize implements Serializable {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer id;

    private String name;

    private String linkName;

    private String linkPhone;

    private Boolean del;
}

二、创建对应的 Repostory 类

public interface OrganizeRepository extends JpaRepository<Organize, Integer>, JpaSpecificationExecutor<Organize> {
    //JpaSpecificationExecutor<Organize> 用来实现多条件动态查询的
}

三、创建对应的 Service 类

public interface OrganizeService {
    
    void deleteOrganizeById(Integer id) throws Exception;

    void deleteOrganizeByIds(List<Integer> ids)throws Exception;

    Organize saveOrganize(OrganizeForm form);

    List<Organize> getOrganizeList(OrganizeForm form);

    Organize updateOrganize(OrganizeForm form);
}

• 其中用到的 OrganizeForm 类

@Data
@ApiModel(value = "组织表单")
public class OrganizeForm implements Serializable {

    private Integer id;

    //@NotNull
    @ApiModelProperty(value = "用户名",example = "张三")
    private String name;

    @ApiModelProperty(value = "联系人",example = "xxx")
    private String linkName;

    @ApiModelProperty(value = "联系电话",example = "17770845325")
    private String linkPhone;

    @ApiModelProperty(value = "假删除",example = "1")
    private Boolean del;
}

四、创建 Service 的实现类

@Service
public class OrganizeServiceImpl implements OrganizeService {

    @Autowired
    private OrganizeRepository organizeRepository;


    @Autowired
    private EntityManager entityManager;

    @Override
    public void deleteOrganizeById(Integer id)throws Exception {
        organizeRepository.deleteById(id);
    }

    @Override
    public void deleteOrganizeByIds(List<Integer> ids)throws Exception {
        List<Organize> list =new ArrayList<>();
        for(Integer id : ids){
            Organize organize =new Organize();
            organize.setId(id);
            list.add(organize);
        }
        organizeRepository.deleteInBatch(list);
    }

    @Override
    public Organize saveOrganize(OrganizeForm form) {
        Organize organize =new Organize();
        BeanUtils.copyProperties(form,organize);
        return organizeRepository.save(organize);
    }


    @Override
    public List<Organize> getOrganizeList(OrganizeForm form) {
       //拼接sql 传统方法
       String sql = getSql(form);
       List<Organize> resultList = entityManager.createNativeQuery(sql, Organize.class).getResultList();
       return resultList;
    }
    
    public String getSql(OrganizeForm form){
        StringBuilder sql = new StringBuilder();
        sql.append("select * from organize where");
        //...
        return "";
    }

    /**
     * 动态多条件查询
     * @param form
     * @return
     */
    @Override
    public List<Organize> getOrganizeList(OrganizeForm form) {
        Specification<Organize> specification = new Specification<Organize>() {
            @Override
            public Predicate toPredicate(Root<Organize> root, CriteriaQuery<?> criteriaQuery, CriteriaBuilder criteriaBuilder) {
                List<Predicate> predicates =new ArrayList<>();
                if(form.getId() != null){
                    predicates.add(criteriaBuilder.equal(root.get("id").as(Integer.class), form.getId()));
                }
                if(form.getName() != null){
                    predicates.add(criteriaBuilder.like(root.get("name").as(String.class), "%"+form.getName()+"%"));
                }
                if(form.getLinkName() != null){
                    predicates.add(criteriaBuilder.equal(root.get("linkName").as(String.class), form.getLinkName()));
                }
                Predicate[] pre = new Predicate[predicates.size()];
                return criteriaQuery.where(predicates.toArray(pre)).getRestriction();
            }
        };
        List<Organize> list= organizeRepository.findAll(specification);
        return list;
    }
    
	/**
     * 动态更新多字段
     * @param form
     * @return
     */
    @Override
    public Organize updateOrganize(OrganizeForm form) {
        //先查询出 所要更新的记录
        Optional<Organize> byId = organizeRepository.findById(form.getId());
        if(byId.isPresent()){
            Organize organize = byId.get();
            //将传过来的 form 中的非NULL属性值复制到 organize 中
            copyPropertiesIgnoreNull(form, organize);
            //将得到的新的 organize 对象重新保存到数据库，因为数据库中已经存在该记录
            //所以JPA会很智能的 改为更新操作，更新数据库
            Organize save = organizeRepository.save(organize);
            return save;
        }
        return null;
    }
    
    public static void copyPropertiesIgnoreNull(Object src, Object target){
        BeanUtils.copyProperties(src, target, getNullPropertyNames(src));
    }

    public static String[] getNullPropertyNames (Object source) {
        final BeanWrapper src = new BeanWrapperImpl(source);
        java.beans.PropertyDescriptor[] pds = src.getPropertyDescriptors();

        Set<String> emptyNames = new HashSet<String>();
        for(java.beans.PropertyDescriptor pd : pds) {
            Object srcValue = src.getPropertyValue(pd.getName());
            if (srcValue == null) emptyNames.add(pd.getName());
        }
        String[] result = new String[emptyNames.size()];
        return emptyNames.toArray(result);
    }
}

五、创建相应的 Controller 类

@RestController
@Api(tags = "组织接口操作")
@RequestMapping("/organize")
public class OrganizeController {

    @Autowired
    private OrganizeService organizeService;

    @Autowired
    private RestTemplate restTemplate;

    @ApiOperation(value = "根据多条件动态查询组织信息")
    @GetMapping("/get")
    public Result getOrganize(OrganizeForm form){
        List<Organize> organizeList = organizeService.getOrganizeList(form);
        // TODO 分页
        return Result.success(organizeList);
    }

    @ApiOperation(value = "动态更新组织信息")
    @PutMapping("/update")
    public Result updateOrganize(OrganizeForm form){
        Organize organize = organizeService.updateOrganize(form);
        if(organize != null){
            return Result.success(organize);
        }
        return Result.error("更新失败");
    }


    @ApiOperation(value = "新增组织")
    @PostMapping("/save")
    public Result saveOrganize(@ApiParam(value = "组织表单",required = true) OrganizeForm form){
        Organize organize = organizeService.saveOrganize(form);
        if(organize != null){
            return Result.success(organize);
        }
        return Result.error("保存失败");
    }


    @ApiOperation(value = "根据ID进行删除组织", notes = "根据ID进行删除组织")
    @DeleteMapping("/delete/{id}")
    public Result deleteOrganizeById(@PathVariable(value = "id") Integer id){
        try {
            organizeService.deleteOrganizeById(id);
            return Result.success();
        } catch (Exception e) {
            e.printStackTrace();
            return Result.error("服务器错误");
        }
    }

    @ApiOperation(value = "删除多个组织", notes = "删除多个组织")
    @DeleteMapping("/delete")
    public Result deleteOrganizeByIds(@RequestParam(value = "ids")@ApiParam(required = true) String ids){
        String[] s = ids.split(",");
        List<Integer> list =new ArrayList<>();
        for(String ss : s){
            Integer id = Integer.valueOf(ss);
            list.add(id);
        }
        try {
            organizeService.deleteOrganizeByIds(list);
            return Result.success();
        } catch (Exception e) {
            e.printStackTrace();
            return Result.error("删除失败");
        }
    }

    @GetMapping("/api")
    @ApiOperation(value = "测试调用第三方API")
    public Object testApi(){
        String url = "http://localhost:8080/user/刘路生";
        Object object = restTemplate.getForObject(url, Object.class);
        return object;
    }
}

六、封装响应结果的类

• Result 类

/**
 * @Description TODO 响应结果统一封装
 */
@Data
public class Result<T> extends HashMap<String, Object> implements Serializable {
	
	/**
	 *  成功时候的调用
	 * */
	public static <T> Result<T> success(T data){
		return new Result<T>(data);
	}

	/**
	 *  成功时候的调用
	 * */
	public static <T> Result<T> success(){
		return new Result<T>();
	}

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

	
	/**
	 *  失败时候的调用
	 * */
	public static <T> Result<T> error(CodeMsg codeMsg){
		return new Result<T>(codeMsg);
	}

	public static Result error() {
		return error(HttpStatus.SC_INTERNAL_SERVER_ERROR, "未知异常，请联系管理员");
	}

	public static Result unAuthorized() {
		return error(HttpStatus.SC_UNAUTHORIZED, "");
	}

	public static Result error(String msg) {
		return error(HttpStatus.SC_INTERNAL_SERVER_ERROR, msg);
	}

	public static Result error(int code, String msg) {
		return new Result(code, msg, false);
	}

	public Result (){
		put("code", 200);
		put("flag", true);
		put("msg", "success");
	}

	private Result(T data) {
		put("code", 200);
		put("msg", "success");
		put("flag", true);
		put("data", data);
	}
	
	private Result(int code, String msg) {
		put("code", code);
		put("msg", msg);
	}

	private Result(int code, String msg, Boolean flag) {
		put("code", code);
		put("msg", msg);
		put("flag", flag);
	}
	
	private Result(CodeMsg codeMsg) {
		if(codeMsg != null) {
			put("code", codeMsg.getCode());
			put("msg", codeMsg.getMsg());
			put("flag", false);
		}
	}
}

• CodeMsg 类

/**
 * @Description TODO 通用错误码
 */
public class CodeMsg implements Serializable {
    private int code;
	private String msg;
	// 通用的错误码
	public static CodeMsg SUCCESS = new CodeMsg(0, "success");
	public static CodeMsg ERROR = new CodeMsg(1, "error");
	public static CodeMsg SERVER_ERROR = new CodeMsg(500100, "服务端异常");
	public static CodeMsg BIND_ERROR = new CodeMsg(500101, "参数校验异常：%s");
	public static CodeMsg INTERNAL_SERVER_ERROR = new CodeMsg(500102, "内部服务异常：%s");
	public static CodeMsg PARAM_EMPTY = new CodeMsg(500103, "参数为空：%s");
	public static CodeMsg METHOD_ARGUMENT_NOT_VALID = new CodeMsg(500104, "方法参数无效：%s");

	public static CodeMsg GATEWAY_EXCEPTION = new CodeMsg(403103, "网关异常：%s");

	// 认证授权相关
	public static CodeMsg UNAUTHORIZED = new CodeMsg(401100, "用户未认证");
	public static CodeMsg TOKEN_IS_EMPTY = new CodeMsg(401101, "token为空");

	public static CodeMsg FORBIDDEN_REQUEST = new CodeMsg(403100, "权限不足：%s");

	// 系统模块
	public static CodeMsg SYS_USER_NOT_EXIST = new CodeMsg(500201, "用户不存在");
	public static CodeMsg SYS_USERNAME_DUPLICATED = new CodeMsg(500202, "用户名重复");


	// 单据模块 (示例)
	public static CodeMsg BILL_XXX = new CodeMsg(500301, "单据异常");

	private CodeMsg() {

	}
			
	private CodeMsg( int code,String msg ) {
		this.code = code;
		this.msg = msg;
	}
	
	public int getCode() {
		return code;
	}
	public void setCode(int code) {
		this.code = code;
	}
	public String getMsg() {
		return msg;
	}
	public void setMsg(String msg) {
		this.msg = msg;
	}
	
	public CodeMsg fillArgs(Object... args) {
		int code = this.code;
		String message = String.format(this.msg, args);
		return new CodeMsg(code, message);
	}

	@Override
	public String toString() {
		return "CodeMsg [code=" + code + ", msg=" + msg + "]";
	}		
}

七、结果

1、动态查询

2、动态更新

3、批量删除