Spring boot JPA QueryDSL 다 중 조건 부 페이지 조회, 전 송 된 값 만 업데이트, 동적 바 인 딩 실현

이루어지다
PagingAndSortingRepository, QueryDslPredicateExecutor, JpaSpecificationExecutor
패 키 징 클래스 를 작 성 했 습 니 다. 일반적인 조건 1 을 조회 하고 동적 바 인 딩 enity 의 임 의 속성 을 실현 하여 조회 하거나 정렬 2 를 실현 합 니 다. update 에 도 적용 된다 면 요청 한 값 만 업데이트 하고 update 를 합 니 다. 다른 변 함 없 는 3, 동적 으로 PageRequest 를 구축 하여 다 중 정렬 조건 4, 동적 구축 Specification 을 실현 하고 다 중 조건 으로 다음 인 스 턴 스 코드 를 조회 합 니 다.

package base

import com.alibaba.fastjson.JSON
import com.alibaba.fastjson.JSONObject
import com.querydsl.core.types.ExpressionUtils
import com.querydsl.core.types.Ops
import com.querydsl.core.types.Predicate
import com.querydsl.core.types.dsl.BooleanExpression
import com.querydsl.core.types.dsl.Expressions
import com.querydsl.core.types.dsl.StringPath
import org.springframework.data.domain.PageRequest
import org.springframework.data.domain.Sort
import org.springframework.data.jpa.domain.Specification
import org.springframework.web.bind.annotation.ExceptionHandler
import java.io.BufferedReader
import java.lang.reflect.Method
import java.util.ArrayList
import javax.persistence.criteria.CriteriaBuilder
import javax.persistence.criteria.CriteriaQuery
import javax.persistence.criteria.Root


/**
 * Created by liushuhua on 25/03/2017.
 *
 * @ControllerAdvice will only kick in if an exception is thrown from within a controller method
 *
 **/

internal class EntityBuilder {
    companion object Factory {

        /**
         *   query   Expression
         *            Entity 
         *
         * @param  Any
         * @return BooleanExpression
         */
        @ExceptionHandler(Throwable::class)
        fun matchSelectiveAttrExpressions(obj: Any): BooleanExpression? {
            val c = obj.javaClass
            var rv: BooleanExpression? = null
            val fs = c.getDeclaredFields()
            for (i in fs.indices) {
                val f = fs[i]
                f.isAccessible = true //           
                val `val` = f.get(obj)//       
                if (`val` != null) {
                    val ce1 = Expressions.stringPath(lowerCaseClassName(c.getSimpleName()) + "." + f.name)
                    val ce2 = ExpressionUtils.toExpression(`val`)
                    val pred = Expressions.booleanOperation(Ops.EQ, ce1, ce2)
                    rv = if (rv != null) rv.and(pred) else pred
                }
            }

            return rv
        }

        /**
         *   update Enity
         *           id Entity ，
         *      Entity，id  ，     update
         *
         * @param Any1, Any2
         * @return Any2
         */
        @Throws(Exception::class)
        fun matchSelectiveEntity(obj1: Any, obj2: Any): Any {
            val fields = obj1.javaClass.declaredFields
            //       
            for (j in fields.indices) {
                val name = fields[j].name
                if (fields[j].get(obj1) != null && !"createdAt".equals(name) && !"createdBy".equals(name)) {
                    val args = arrayOfNulls>(1)
                    args[0] = fields[j].type
                    val c = obj1.javaClass
                    val methodName = "set" + upperCaseClassName(name)
                    var method: Method? = null
                    method = c.getMethod(methodName, *args)
                    method!!.invoke(obj2, fields[j].get(obj1))
                }
            }
            return obj2
        }

        /**
         *       .
         * pageNumber   1   
         */
        @Throws(Exception::class)
        fun buildPageRequest(jsonObject: JSONObject): PageRequest {
            val pageNumber = Integer.parseInt(jsonObject["pageNumber"].toString())
            val pagzSize = Integer.parseInt(jsonObject["pageSize"].toString())

            val sortArray = jsonObject.getJSONArray("sort")
            val sortList = ArrayList()
            for (i in sortArray.indices) {
                val ascFlag = sortArray.getJSONObject(i)["asc"].toString()
                var order: Sort.Order? = null
                if ("true" == ascFlag) {
                    order = Sort.Order(Sort.Direction.ASC, sortArray.getJSONObject(i)["field"].toString())
                } else {
                    order = Sort.Order(Sort.Direction.DESC, sortArray.getJSONObject(i)["field"].toString())
                }
                sortList.add(order)
            }
            return PageRequest(pageNumber - 1, pagzSize, Sort(sortList))
        }

        /**
         *           .
         */
        @Throws(Exception::class)
        fun  buildSpecification(jsonObject: JSONObject): Specification {
            val criteriaArray = jsonObject.getJSONArray("criteria")
            val spec = Specification { root, criteriaQuery, criteriaBuilder ->
                val predicates = ArrayList()
                for (i in criteriaArray.indices) {
                    val field = criteriaArray.getJSONObject(i)["field"].toString()
                    val value = criteriaArray.getJSONObject(i)["value"].toString()
                    val operator = criteriaArray.getJSONObject(i)["operator"].toString()

                    if ("eq" == operator) {
                        predicates.add(criteriaBuilder.equal(root.get(field), value))
                    }
                }
                criteriaBuilder.and(*predicates.toTypedArray())
            }
            return spec
        }


        private fun lowerCaseClassName(name: String): String {
            return name.substring(0, 1).toLowerCase() + name.substring(1)
        }

        private fun upperCaseClassName(name: String): String {
            return name.substring(0, 1).toUpperCase() + name.substring(1)
        }
    }
}

호출 조회 방법

override fun listCustomer(jsonObject: JSONObject): MutableIterable {
    val pageable = EntityBuilder.buildPageRequest(jsonObject)
    val spec = EntityBuilder.buildSpecification(jsonObject)
    return customerRepository.findAll(spec, pageable)
}

  jsonObject ：
{
  "pageNumber": "1",
  "pageSize": "10",
  "criteria": [{"operator": "like", "field": "name", "value": "aaa"}],
  "sort": [{"field":"id","asc":"true"}]
}

업데이트 방법 호출

override fun save(customer: Customer) : Customer {
    if(customer.id == null){
        return customerRepository.save(customer)
    }else{
        val oldCustomer = findById(customer.id)
        if(oldCustomer == null){
            throw Exception("The entity not found")
        }
        val customer = EntityBuilder.matchSelectiveEntity(customer, oldCustomer!!) as Customer
        return customerRepository.save(customer)
    }
}