GORM - 动态查询 - 分离标准？

Question

我有这样的工作代码：

def criteria = Instance.createCriteria()
def list = criteria.listDistinct {
    eq("saved", true)
    eq("client", client)

    and {
        basicValues {
            eq("fieldA", object.valueA())
            /** CODE BLOCK **/
        }

        customValues {
            eq("fieldB", object.valueB())
            /** CODE BLOCK **/
        }
    }

    or {
        basicValues {
            eq("fieldC", object.valueC())
            /** CODE BLOCK **/
        }

        customValues {
            eq("fieldD", object.valueD())
            /** CODE BLOCK **/
        }
    }
}

如您所见，我正在使用AND 和OR 部分创建一些标准。它们都加入了另一个条件（basicValues / customValues 与 Instance 处于 1:n 关系）。 /** 代码块 **/ 部分是一组始终相同的条件。

到目前为止，我在每个/** CODE BLOCK **/ 地方都设置了相同的条件（例如lt("field", 10) 等...）。

我可以把这个/** CODE BLOCK **/ 放到函数中吗？所以这些条件将在一个地方，代码将更具可读性???

Answer 1

这是一种您可以在纯 groovy 中将语句保存在闭包中的方法（class Deleg 的所有部分都是为了模拟您的场景）：

class Deleg {
  def invoked = []

  def execute(fn) {
    fn.delegate = this
    fn()
  }

  def and(closure) { execute(closure) }
  def or(closure) { execute(closure) }

  def methodMissing(String method, args) {
    invoked << [method, args]
  }
}

d = new Deleg()

commonOps = { closure -> 
  return {
    closure()
    lower("a")
    upper("b")
  }
}

fn = {
  and commonOps {
    eq("a")
  }

  or commonOps {
    eq("b")
  }
}

d.execute(fn)

assert d.invoked.size() == 6
assert d.invoked == [
  ["eq",    ["a"]],
  ["lower", ["a"]],
  ["upper", ["b"]],
  ["eq",    ["b"]],
  ["lower", ["a"]],
  ["upper", ["b"]],
]

我不太了解 GORM，但我认为您可以做类似的事情，而您只需要 commonOps 部分。注意它接收并返回一个闭包。

它的工作原理是返回一个闭包，该闭包执行特定语句，作为闭包参数传​​递，以及通用语句。请注意，返回的闭包不是由您的应用程序调用的，而是由 GORM 本身调用的。

Answer 2

如果您将/** CODE BLOCK**/ 设置为单独的闭包，则可以在您的条件中包含对它的调用。

def commonCriteria = {
    /** CODE BLOCK **/
}

def criteria = Instance.createCriteria()
def list = criteria.listDistinct {
    commonCriteria.delegate = delegate
    eq("saved", true)
    eq("client", client)

    and {
        basicValues {
            eq("fieldA", object.valueA())
            commonCriteria()
        }

        customValues {
            eq("fieldB", object.valueB())
            commonCriteria()
        }
    }
    ...
}