{"id":1182,"date":"2024-12-30T18:31:06","date_gmt":"2024-12-30T10:31:06","guid":{"rendered":"http:\/\/www.max-shu.com\/blog\/?p=1182"},"modified":"2024-12-30T18:31:08","modified_gmt":"2024-12-30T10:31:08","slug":"springboot-jpa%e5%ae%9e%e7%8e%b0%e5%af%b9%e6%95%b0%e6%8d%ae%e5%ba%93%e8%a1%a8%e7%bb%9f%e4%b8%80%e7%9a%84%e5%a2%9e%e5%88%a0%e6%94%b9%e6%9f%a5","status":"publish","type":"post","link":"http:\/\/www.max-shu.com\/blog\/?p=1182","title":{"rendered":"Springboot JPA\u5b9e\u73b0\u5bf9\u6570\u636e\u5e93\u8868\u7edf\u4e00\u7684\u589e\u5220\u6539\u67e5"},"content":{"rendered":"\n

\u9996\u5148\u5efa\u7acb\u4e00\u4e2a\u516c\u5171\u7684BaseEntity\u5bf9\u5e94\u6570\u636e\u5e93\u4e2d\u7684\u8868\u683c\u516c\u5171\u5b57\u6bb5\uff0c\u5176\u4ed6Entity\u90fd\u4ece\u5b83\u7ee7\u627f\uff1a<\/strong><\/p>\n\n\n\n

@Data
@MappedSuperclass
public class BaseEntity implements Serializable {
    private static final long serialVersionUID <\/em>= 1L;
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY<\/em>)
    @Column(name = \"_id\")
    protected Long id;

    @Column(name = \"create_time\", columnDefinition = \"datetime COMMENT '\u521b\u5efa\u65f6\u95f4'\")
    @Temporal(TIMESTAMP<\/em>)
    @CreationTimestamp
    protected Date createTime;

    @Column(name = \"update_time\", columnDefinition = \"datetime COMMENT '\u4fee\u6539\u65f6\u95f4\u65f6\u95f4'\")
    @Temporal(TIMESTAMP<\/em>)
    @UpdateTimestamp
    protected Date updateTime;
}<\/pre>\n\n\n\n
\u7136\u540e\u518d\u5efa\u7acb\u4e00\u4e2a\u516c\u5171\u7684BaseDto\uff0c\u7528\u4e8e\u5bf9\u5e94BaseEntity\u7684\u5404\u5b57\u6bb5\uff1a<\/strong><\/p>\n\n\n\n
@Data
public class BaseDTO implements Serializable {
    protected Long id;
    @JSONField(format = \"yyyy-MM-dd HH:mm:ss\")
    protected Date createdTime;
    @JSONField(format = \"yyyy-MM-dd HH:mm:ss\")
    protected Date updateTime;

    public String[] uniqueKeys() {
        return null;
    }

}<\/pre>\n\n\n\n
\u8fd8\u5f97\u5efa\u7acb\u4e00\u4e2aBaseRepository\u7684Repository\u63a5\u53e3\uff0c\u7528\u4e8e\u64cd\u4f5c\u6570\u636e\u5e93\uff1a<\/strong><\/p>\n\n\n\n
@NoRepositoryBean
public interface BaseRepository<T> extends JpaRepository<T, Long>, JpaSpecificationExecutor<T>, QueryByExampleExecutor<T> {
}

\u6700\u540e\u5efa\u7acbBaseController\u7c7b\uff08\u6216\u8005BaseService\u4e5f\u53ef\u4ee5\uff0c\u540e\u7eed\u6839\u636e\u63a7\u5236\u7c7b\u8fd8\u662f\u670d\u52a1\u7c7b\u53bb\u7ee7\u627f\u5c31\u597d\u4e86\uff09\uff0c\u7528\u4e8e\u5b9e\u73b0\u516c\u5171\u7684\u589e\u5220\u6539\u67e5\u64cd\u4f5c\uff1a<\/strong>
public class BaseController<E extends BaseEntity, S extends BaseRepository<E>, T extends BaseDTO> {
    private final Logger logger = LoggerFactory.getLogger(BaseController.class);
    private String classTName;
    private S repo;

    @Autowired
    private EntityManager entityManager;

    public BaseController(Class<?> classT, S repo){
        this.classTName = classT.getSimpleName();
        this.repo = repo;
    }

    public E dto2Entity(T dto){ \/\/\u5b9e\u9645\u8c03\u7528\u65f6\u5c06\u88ab\u5b50\u7c7b\u540c\u540d\u65b9\u6cd5\u66ff\u6362
        logger.error(\"Shoud not be called.\");
        return null;
    }

    public T entity2Dto(E entity){ \/\/\u5b9e\u9645\u8c03\u7528\u65f6\u5c06\u88ab\u5b50\u7c7b\u540c\u540d\u65b9\u6cd5\u66ff\u6362
        logger.error(\"Shoud not be called.\");
        return null;
    }


    @RequestMapping(value = \"\/all\", method = {RequestMethod.GET})
    public BaseBodyResponse all() {
        logger.info(\"All {}.\", classTName);
        List<E> entityList = repo.findAll();
        List<T> dtoList = new ArrayList<>();
        if(entityList != null) {
            for (E entity : entityList) {
                T dto = entity2Dto(entity);
                dtoList.add(dto);
            }
        }
        return new BaseBodyResponse(true, \"\", dtoList);
    }

    \/\/\u53ea\u652f\u6301String\u7c7b\u578b\u7684\u5b57\u6bb5\uff0c\u6839\u636e\u5b57\u6bb5\u540d\u8fd4\u56dedistinct list<string>\u3002
    @RequestMapping(value = \"\/allbyfield\", method = {RequestMethod.GET})
    public BaseBodyResponse allByField(@RequestParam String field) {
        logger.info(\"AllByField {}:{}\", classTName, field);
        Type genType = this.getClass().getGenericSuperclass();
        if(!(genType instanceof ParameterizedType)) {
            return new BaseBodyResponse(false, \"Server error!\");
        }
        Type[] params = ((ParameterizedType) genType).getActualTypeArguments();
        if (!(params[0] instanceof Class)){
            return new BaseBodyResponse(false, \"Server error!\");
        }
        Class entityClass = (Class)params[0]; \/\/0\u5c31\u662f\u5c31\u662f\u672c\u7c7b\u7684\u7b2c\u4e00\u4e2a\u53c2\u6570\u6a21\u677f\u7c7b\uff0c\u5373E\u3002
        CriteriaBuilder cb = entityManager.getCriteriaBuilder();
        CriteriaQuery<String> query = cb.createQuery(String.class);
        Root<String> root = query.from(entityClass);
        query.multiselect(root.get(field)).distinct(true);
        query.where(cb.equal(cb.literal(1), 1));
        List<String> fieldValueList = entityManager.createQuery(query).getResultList();
        return new BaseBodyResponse(true, \"\", fieldValueList);
    }


    @RequestMapping(value = \"\/add\", method = {RequestMethod.POST})
    public BaseResponse add(@RequestBody T model) {
        logger.info(\"Add {}:{}\", classTName, JSON.toJSONString(model));
        BaseResponse resp = new BaseResponse(false, \"\u6dfb\u52a0\u5931\u8d25\");
        T uniqueObj = getUniqueObj(model);
        if (null != uniqueObj) {
            logger.error(\"Data has exist, {}\", JSON.toJSONString(model));
            resp.update(false, \"\u6570\u636e\u5df2\u7ecf\u5b58\u5728\");
        }else {
            model.setId(null);
            repo.save(this.dto2Entity(model));
            resp.update(true, \"\u6dfb\u52a0\u6210\u529f\");
        }
        return resp;
    }

    private T getUniqueObj(T model) {
        String[] uniqueKeys = model.uniqueKeys();
        if (uniqueKeys != null && uniqueKeys.length > 0) {
            Specification<E> specification = (Root<E> root, CriteriaQuery<?> query, CriteriaBuilder cb) -> {
                List<Predicate> predicateList = new ArrayList<>();
                for (String fieldName : uniqueKeys) {
                    Object fieldValue = getFieldValueByName(model, fieldName);
                    predicateList.add(cb.equal(root.get(fieldName), fieldValue));
                }
                if(predicateList != null && !predicateList.isEmpty()) {
                    Predicate[] predicateArray = new Predicate[predicateList.size()];
                    predicateList.toArray(predicateArray);
                    query.where(cb.and(predicateArray));
                }
                return query.getRestriction();
            };
            Optional<E> entity = repo.findOne(specification); \/\/\u5b9e\u9645specification\u5728\u8fd9\u91cc\u624d\u4f1a\u53bb\u8ba1\u7b97\u3002
            if(entity.isPresent()) {
                return this.entity2Dto(entity.get());
            }
        }
        return null;
    }

    private Object getFieldValueByName(Object o, String fieldName){
        String firstLetter = fieldName.substring(0, 1).toUpperCase();
        String getter = \"get\" + firstLetter + fieldName.substring(1);
        try {
            Method method = o.getClass().getMethod(getter, new Class[]{});
            Object value = method.invoke(o, new Object[]{});
            return value;
        }catch (Exception e){
            logger.error(\"Exception: \"+e.getMessage(), e);
        }
        return null;
    }


    @RequestMapping(value = \"\/delete\", method = {RequestMethod.GET})
    public BaseResponse delete(@RequestParam Long id) {
        logger.info(\"Delete {}:{}\", classTName, id);
        Optional<E> entity = repo.findById(id);
        if (entity.isPresent()) {
            repo.deleteById(id);
            return new BaseResponse(true, \"\u5220\u9664\u6210\u529f\");
        } else {
            return new BaseResponse(false, \"\u6570\u636e\u4e0d\u5b58\u5728\");
        }
    }


    @RequestMapping(value = \"\/edit\", method = {RequestMethod.POST})
    public BaseResponse edit(@RequestBody T model) {
        logger.info(\"Edit {} :{}\", classTName, JSON.toJSONString(model));
        BaseResponse resp = new BaseResponse(false, \"\u4fee\u6539\u5931\u8d25\");
        T uniqueObj = getUniqueObj(model);
        if (null != uniqueObj && !uniqueObj.getId().equals(model.getId())) {
            logger.error(\"Data has exist And ID not match\", JSON.toJSONString(model));
            resp.setMessage(\"\u6570\u636e\u51b2\u7a81\");
        } else {
            E entity = this.dto2Entity(model);
            repo.save(entity);
            resp.update(true, \"\u4fee\u6539\u6210\u529f\");
        }
        return resp;
    }


    @RequestMapping(value = \"\/load\", method = {RequestMethod.GET})
    public BaseBodyResponse load(@RequestParam Long id) {
        logger.info(\"Load {}:{}\", classTName, id);
        Optional<E> entity = repo.findById(id);
        if(entity.isPresent()) {
            T dto = this.entity2Dto(entity.get());
            return new BaseBodyResponse(true, \"\", dto);
        }else {
            return new BaseBodyResponse(false, \"\u6570\u636e\u4e0d\u5b58\u5728\");
        }
    }

    @GetMapping(\"\/page\")
    public YunResult page(
        @RequestParam(name = \"pageSize\", required = true) Integer pageSize,
        @RequestParam(name = \"pageNum\", required = true) Integer pageNum,
        @RequestParam(name = \"total\", required = false) Integer total,
        @RequestParam(name = \"sidx\", required = false) List<String> sidx, \/\/\u6392\u5e8f\u5b57\u6bb5\u540d
        @RequestParam(name = \"sord\", required = false) List<String> sord, \/\/ desc \u6216 asc
        @RequestParam(name = \"filters\", required = false) String filters \/\/ \u8fc7\u6ee4\u5b57\u6bb5
    ) {
        \/\/ pageSize=15&pageNum=1
        \/\/ pageSize=15&pageNum=1&total=0&sidx=XX&sord=DESC&sidx=YY&sord=ASC&filters=
        \/\/ pageSize=15&pageNum=1&filters=%7B%22groupOp%22%3A%22AND%22%2C%22rules%22%3A%5B%7B%22groupOp%22%3A%22or%22%2C%22rules%22%3A%5B%7B%22field%22%3A%22channel%22%2C%22op%22%3A%22eq%22%2C%22data%22%3A%22facebook%22%7D%2C%7B%22field%22%3A%22opResult%22%2C%22op%22%3A%22eq%22%2C%22data%22%3A%22ALL%22%7D%5D%7D%2C%7B%22field%22%3A%22channel%22%2C%22op%22%3A%22eq%22%2C%22data%22%3A%22facebook%22%7D%2C%7B%22field%22%3A%22status%22%2C%22op%22%3A%22eq%22%2C%22data%22%3Atrue%7D%5D%7D
        \/\/ \u4e0a\u9762\u7684filters\u53c2\u6570\u662fjson\u65b9\u5f0f\uff0c\u7136\u540eurlEncode\u7f16\u7801\u540e\u7684\u503c\u3002
        logger.info(\"Page {}: pageSize: {}, pageNum: {}, total: {}, sidx: {}, sord: {}, filters: {}\",
            classTName, pageSize, pageNum, total, sidx, sord, filters);

        \/\/\u5904\u7406Page\u5206\u9875 \u3001Sort\u6392\u5e8f \u548cSpecification\u8fc7\u6ee4
        PageRequest pageRequest = this.getPageRequest(pageSize, pageNum, sidx, sord);
        Specification<E> specification = this.getSpecification(filters);

        \/\/\u5904\u7406\u7ed3\u679c
        Page<E> page = repo.findAll(specification, pageRequest); \/\/\u5b9e\u9645specification\u5728\u8fd9\u91cc\u624d\u4f1a\u53bb\u8ba1\u7b97\u3002
        SimplePageView<T> pageView = new SimplePageView<>(pageNum, pageSize);
        if (page != null) {
            List<T> dtoList = new ArrayList<>();
            List<E> entityList = page.getContent();
            for(E entity: entityList){
                dtoList.add(this.entity2Dto(entity));
            }
            pageView.setData(dtoList);
            pageView.setTotal(page.getTotalElements());
        } else {
            pageView.setData(null);
            pageView.setTotal(0L);
        }
        return YunResult.success(pageView);
    }

    \/\/\u5904\u7406Page\u5206\u9875 \u548cSort\u6392\u5e8f
    public PageRequest getPageRequest(Integer pageSize, Integer pageNum, List<String> sidx, List<String> sord){
        PageRequest pageRequest = null;
        if(sidx != null && (!sidx.isEmpty())) {
            List<Sort.Order> orderList = new ArrayList<>();
            for(int i = 0; i< sidx.size(); i++) {
                Sort.Order order = null;
                if(sord != null && (!sord.isEmpty()) && sord.get(i) != null) {
                    order = new Sort.Order(Sort.Direction.fromString(sord.get(i)), sidx.get(i));
                } else{
                    order = new Sort.Order(Sort.Direction.ASC, sidx.get(i));
                }
                orderList.add(order);
            }
            Sort sort = Sort.by(orderList);
            pageRequest = PageRequest.of(pageNum - 1, pageSize, sort);
        }else{
            pageRequest = PageRequest.of(pageNum - 1, pageSize);
        }
        return pageRequest;
    }

    \/\/\u5904\u7406Specification\u8fc7\u6ee4\uff08SQL\u7684where\u5b57\u53e5\uff09
    \/\/\u8bf4\u660e\uff1a
    \/\/\u8f93\u5165\u4f8b\u5b50\uff1a {\"groupOp\":\"AND\",\"rules\":[{\"groupOp\":\"or\",\"rules\":[{\"field\":\"channel\",\"op\":\"eq\",\"data\":\"facebook\"},{\"field\":\"opResult\",\"op\":\"eq\",\"data\":\"ALL\"}]},{\"field\":\"channel\",\"op\":\"eq\",\"data\":\"facebook\"},{\"field\":\"status\",\"op\":\"eq\",\"data\":true}]}
    \/\/\u76f8\u5f53\u4e8e\uff1a where (channel=facebook or op_result=ALL) and channel=facebook and status=TRUE
    \/\/\u679a\u4e3e\u5b57\u6bb5\u503c\u8981\u7528'String'\u65b9\u5f0f\u6620\u5c04\uff1bboolean\u5b57\u6bb5\u503c\u8981\u7528json\u7684true\/false\u6765\u4f20\u5165\u3002
    \/\/\u652f\u6301\u7684op\u64cd\u4f5c(\u4e0d\u533a\u5206\u5927\u5c0f\u5199)\uff1ais null, is not null, eq, neq, like, not like, in, not in, gt, ge, lt, le, \u4e0d\u652f\u6301between\u3002
    \/\/\u652f\u6301\u7684grougOp\u64cd\u4f5c(\u4e0d\u533a\u5206\u5927\u5c0f\u5199)\uff1aand, or, not\u3002
    public Specification<E> getSpecification(String filters) {
        return  (Root<E> root, CriteriaQuery<?> query, CriteriaBuilder cb) -> {
            Predicate predicate = this.buildPredicateRecursion(filters, root, cb);
            \/\/Predicate predicateTrue = cb.equal(cb.literal(1), 1);
            if(predicate != null) {
                query.where(cb.and(predicate));
                return query.getRestriction();
            }
            return null;
        };
    }
    private Predicate buildPredicateRecursion(String filters,
                                         Root<E> root, CriteriaBuilder cb) {
        Predicate predicate = null;
        if(StringUtils.isNoneBlank(filters)) {
            JSONObject jsonObject = JSONObject.parseObject(filters);
            String groupOp = jsonObject.getString(\"groupOp\");
            if(StringUtils.isNoneBlank(groupOp)){
                JSONArray rules = (JSONArray) jsonObject.get(\"rules\");
                if(rules != null){
                    List<Predicate> predicateListTmp = new ArrayList<Predicate>();
                    for(int i=0 ;i < rules.size(); i++){
                        JSONObject rule = rules.getJSONObject(i);
                        String groupOpTmp = rule.getString(\"groupOp\");
                        Predicate predicateTmp = null;
                        if(StringUtils.isNoneBlank(groupOpTmp)) { \/\/\u9012\u5f52\u5904\u7406\u5e26groupOn\u7684\u6761\u4ef6\uff0c\u5b9e\u9645\u5c31\u662f\u5b9e\u73b0\u4e86\u62ec\u53f7\u64cd\u4f5c\u7b26\u7684\u4f5c\u7528
                            predicateTmp = this.buildPredicateRecursion(rule.toString(), root, cb);
                        }else { \/\/\u5904\u7406\u4e0d\u5e26groupOn\u7684\u6761\u4ef6
                            predicateTmp = this.getPredicate(root, cb, rule);
                        }
                        if(predicateTmp != null) {
                            predicateListTmp.add(predicateTmp);
                        }else{
                            logger.error(\"{} predicateTmp is null or empty.\", classTName);
                        }
                    }
                    if(predicateListTmp != null && !predicateListTmp.isEmpty()) {
                        Predicate[] predicateArray = new Predicate[predicateListTmp.size()];
                        predicateListTmp.toArray(predicateArray);
                        switch (groupOp.toLowerCase()) {
                            case \"and\":
                                predicate = cb.and(predicateArray);
                                break;
                            case \"or\":
                                predicate = cb.or(predicateArray);
                                break;
                            case \"not\":
                                predicate = cb.not(predicateArray[0]);
                                break;
                            default:
                                logger.error(\"{} Not support groupOn: {}\", classTName, groupOp);
                                break;
                        }
                    }
                }else{
                    logger.error(\"{} rules is null or empty.\", classTName);
                }
            }else {
                logger.error(\"{} groupOn is null or empty.\", classTName);
            }
        }
        return predicate;
    }
    private Predicate getPredicate(Root<E> root, CriteriaBuilder cb, JSONObject jsonObject){
        String field = jsonObject.getString(\"field\");
        String op = jsonObject.getString(\"op\");
        Object data = jsonObject.get(\"data\");
        String className = jsonObject.get(\"data\").getClass().getSimpleName();
        Predicate predicate = null;
        switch (op.toLowerCase()) {
            case \"is null\":
                predicate = cb.isNull(root.get(field));
                break;
            case \"is not null\":
                predicate = cb.isNotNull(root.get(field));
                break;
            case \"eq\":
                predicate = cb.equal(root.get(field), data);
                break;
            case \"neq\":
                predicate = cb.notEqual(root.get(field), data);
                break;
            case \"like\":
                predicate = cb.like(root.get(field).as(String.class), jsonObject.getString(\"data\"));
                break;
            case \"not like\":
                predicate = cb.notLike(root.get(field).as(String.class), jsonObject.getString(\"data\"));
                break;
            case \"in\":
                if(className.toLowerCase().equals(\"string\")) {
                    CriteriaBuilder.In<String> inClause = cb.in(root.get(field).as(String.class));
                    for (String inStr : jsonObject.getString(field).split(\",\")) {
                        inClause.value(inStr);
                    }
                    predicate = inClause;
                }else{
                    logger.error(\"{} Only support string type for 'in' op.\", classTName);
                }
                break;
            case \"not in\":
                if(className.toLowerCase().equals(\"string\")) {
                    CriteriaBuilder.In<String> inClause = cb.in(root.get(field).as(String.class));
                    for (String inStr : jsonObject.getString(field).split(\",\")) {
                        inClause.value(inStr);
                    }
                    predicate = cb.not(inClause);
                }else{
                    logger.error(\"{} Only support string type for 'in' op.\", classTName);
                }
                break;
            case \"gt\":
                switch (className.toLowerCase()) {
                    case \"integer\":
                        Integer dataInt = jsonObject.getInteger(\"data\");
                        predicate = cb.gt(root.get(field).as(Integer.class), dataInt);
                        break;
                    case \"long\":
                        Long dataLong = jsonObject.getLong(\"data\");
                        predicate = cb.gt(root.get(field).as(Long.class), dataLong);
                        break;
                    case \"double\":
                        Double dataDouble = jsonObject.getDouble(\"data\");
                        predicate = cb.gt(root.get(field).as(Double.class), dataDouble);
                        break;
                    case \"float\":
                        Float dataFloat = jsonObject.getFloat(\"data\");
                        predicate = cb.gt(root.get(field).as(Float.class), dataFloat);
                        break;
                    default:
                        logger.error(\"{} Not support calssName: {}\", classTName, className);
                }
                break;
            case \"ge\":
                switch (className.toLowerCase()) {
                    case \"integer\":
                        Integer dataInt = jsonObject.getInteger(\"data\");
                        predicate = cb.ge(root.get(field).as(Integer.class), dataInt);
                        break;
                    case \"long\":
                        Long dataLong = jsonObject.getLong(\"data\");
                        predicate = cb.ge(root.get(field).as(Long.class), dataLong);
                        break;
                    case \"double\":
                        Double dataDouble = jsonObject.getDouble(\"data\");
                        predicate = cb.ge(root.get(field).as(Double.class), dataDouble);
                        break;
                    case \"float\":
                        Float dataFloat = jsonObject.getFloat(\"data\");
                        predicate = cb.gt(root.get(field).as(Float.class), dataFloat);
                        break;
                    default:
                        logger.error(\"{} Not support calssName: {}\", classTName, className);
                }
                break;
            case \"lt\":
                switch (className.toLowerCase()) {
                    case \"integer\":
                        Integer dataInt = jsonObject.getInteger(\"data\");
                        predicate = cb.lt(root.get(field).as(Integer.class), dataInt);
                        break;
                    case \"long\":
                        Long dataLong = jsonObject.getLong(\"data\");
                        predicate = cb.lt(root.get(field).as(Long.class), dataLong);
                        break;
                    case \"double\":
                        Double dataDouble = jsonObject.getDouble(\"data\");
                        predicate = cb.lt(root.get(field).as(Double.class), dataDouble);
                        break;
                    case \"float\":
                        Float dataFloat = jsonObject.getFloat(\"data\");
                        predicate = cb.gt(root.get(field).as(Float.class), dataFloat);
                        break;
                    default:
                        logger.error(\"{} Not support calssName: {}\", classTName, className);
                }
                break;
            case \"le\":
                switch (className.toLowerCase()) {
                    case \"integer\":
                        Integer dataInt = jsonObject.getInteger(\"data\");
                        predicate = cb.le(root.get(field).as(Integer.class), dataInt);
                        break;
                    case \"long\":
                        Long dataLong = jsonObject.getLong(\"data\");
                        predicate = cb.le(root.get(field).as(Long.class), dataLong);
                        break;
                    case \"double\":
                        Double dataDouble = jsonObject.getDouble(\"data\");
                        predicate = cb.le(root.get(field).as(Double.class), dataDouble);
                        break;
                    case \"float\":
                        Float dataFloat = jsonObject.getFloat(\"data\");
                        predicate = cb.gt(root.get(field).as(Float.class), dataFloat);
                        break;
                    default:
                        logger.error(\"{} Not support calssName: {}\", classTName, className);
                }
                break;
            default:
                logger.error(\"{} Not support op: {}\", classTName, op);
                break;
        }
        return predicate;
    }
}

\u540e\u7eed\u5177\u4f53\u5230\u5404\u4e2a\u8868\u65f6\u6269\u5c55\u4e0a\u9762\u7684\u5404\u4e2a\u7c7b\u5373\u53ef\uff0c\u6bd4\u5982\u6709\u4e2aTest\u8868\u9700\u8981\u589e\u5220\u6539\u67e5\uff0c\u90a3\u4e48\uff1a<\/strong>
TestEntity\u7c7b extends BaseEntity\uff1b
TestDto\u7c7b extends BaseDto;
TestRepo\u7c7b extends BaseRepository<TestEntity>

\u63a7\u5236\u7c7b\uff1a<\/em>
@RestController
@RequestMapping(\"\/a_database\/test\")
public class TestController extends BaseController<TestEntity, TestEntityRepo, TestDto>{
    private final Logger logger = LoggerFactory.getLogger(TestController.class);

    private TestEntityRepo repo;

    public TestController(TestEntityRepo repo){
        super(TestController.class, repo);
        this.repo = repo;
    }

    @Override
    public TestEntity dto2Entity(TestDto dto){ \/\/\u5fc5\u987b\u5b9e\u73b0
        TestEntity entity = new TestEntity();
        BeanUtils.copyProperties(dto, entity);
        return entity;
    }
    @Override
    public TestDto entity2Dto(TestEntity entity){ \/\/\u5fc5\u987b\u5b9e\u73b0
        TestDto dto = new TestDto();
        BeanUtils.copyProperties(entity, dto);
        return dto;
    }

}

\u8bf4\u660e\uff1a\u4e0a\u8ff0\u4ee3\u7801\u4e2d\u7684BaseResponse\u3001BaseBodyResponse\u3001YunResult\u53ea\u662f\u7528\u6765\u88c5\u8f7d\u8fd4\u56de\u7684\u6570\u636e\u7684\uff0c\u5c31\u4e0d\u518d\u5217\u51fa\u4ee3\u7801\u4e86\u3002

\u6d4b\u8bd5\uff1a<\/strong>
\u6839\u636e\u4e3b\u952eid\u5f97\u5230\u67d0\u6761\u5177\u4f53\u8bb0\u5f55\uff1ahttp:\/\/127.0.0.1:80\/a_database\/test\/load?id=2
\u5176\u4ed6\u5206\u9875page\u3001edit\u3001add\u3001delete\u3001all\u3001allbyfield\u64cd\u4f5c\u7c7b\u4f3c\uff0c\u53c2\u8003BaseController\u4ee3\u7801\u5373\u53ef\u3002

<\/pre>\n\n\n\n
<\/p>\n","protected":false},"excerpt":{"rendered":"
\u9996\u5148\u5efa\u7acb\u4e00\u4e2a\u516c\u5171\u7684BaseEntity\u5bf9\u5e94\u6570\u636e\u5e93\u4e2d\u7684\u8868\u683c\u516c\u5171\u5b57\u6bb5\uff0c\u5176\u4ed6Entity\u90fd\u4ece\u5b83\u7ee7\u627f\uff1a @Data@M …<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[63,13],"tags":[934,933,931,929,932,877,930,61],"class_list":["post-1182","post","type-post","status-publish","format-standard","hentry","category-63","category-13","tag-criterialbuilder","tag-criteriaquery","tag-entitymanager","tag-jpa","tag-specification","tag-springboot","tag-930","tag-61"],"views":736,"_links":{"self":[{"href":"http:\/\/www.max-shu.com\/blog\/index.php?rest_route=\/wp\/v2\/posts\/1182","targetHints":{"allow":["GET"]}}],"collection":[{"href":"http:\/\/www.max-shu.com\/blog\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"http:\/\/www.max-shu.com\/blog\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"http:\/\/www.max-shu.com\/blog\/index.php?rest_route=\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"http:\/\/www.max-shu.com\/blog\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=1182"}],"version-history":[{"count":1,"href":"http:\/\/www.max-shu.com\/blog\/index.php?rest_route=\/wp\/v2\/posts\/1182\/revisions"}],"predecessor-version":[{"id":1183,"href":"http:\/\/www.max-shu.com\/blog\/index.php?rest_route=\/wp\/v2\/posts\/1182\/revisions\/1183"}],"wp:attachment":[{"href":"http:\/\/www.max-shu.com\/blog\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=1182"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"http:\/\/www.max-shu.com\/blog\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=1182"},{"taxonomy":"post_tag","embeddable":true,"href":"http:\/\/www.max-shu.com\/blog\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=1182"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}