Prabhu Sunderaraman

You will always learn something new, whenever you work with Grails. It doesn’t fail to surprise you everytime. Last week’s client visit made me sit up and notice few more useful methods in GORM.

failOnError:true.An useful property when applied while saving/updating an domain instance gives you the error messages in the console. Say you have a Person class that you want to instantiate and save to the database. You can write

p1 = new Person(name:"Sam")
p1.save(failOnError:true)

addToXXX method.An useful method to add collections in a domain class. Say Person class has a dogs collection and you can add Dog objects by using addToDogs method like shown below.

	p1 = new Person(name:"Sam")
	p1.addToDogs(new Dog(name:"Snoopy"))
	p1.save(failOnError:true)

These two options though very simple come in very handy in applications

In one of the earlier posts we created a simple query using Groovy DSL. Let’s implement another example as shown below using the DSL capabilities of Groovy. Let’s create User.groovy with the code shown below.

//User.groovy
Calculator.compute {
			addition 2,3
			subtraction 10,4
			multiplication 100,40	
		  }

You want to add two numbers, subtract 2 numbers, multiply 2 numbers and finally print the result of all these computations.

Understanding this code involves demystifying the Groovy syntax here. The decoded syntax is shown below.

Calculator.compute({
			addition(2,3)
			subtraction(10,4)
			multiplication(100,40)	
		  })

compute is a static method in Calculator class that accepts a closure as argument. The closure has calls to addition, subtraction and multiplication methods. Now let’s implement the Calculator class.

class Calculator {
	static results = []
	static compute(block){
		def calc = new Calculator()
		calc.with block//Key
		results.each {println it}
	}
	def addition(a,b){
		results << "Addition of ${a} and ${b} is ${a+b}"
	}
	def subtraction(a,b){
		results << "Subtraction of ${a} and ${b} is ${a-b}"
	}
	def multiplication(a,b){
		results << "Multiplication of ${a} and ${b} is ${a*b}"
	}
}

Calculator class has the addition, subtraction and multiplication methods that add the result to a collection. The compute method accepts the block of code as the argument. You can invoke the block of code by writing block(), but it would look for the addition… methods in the invoking class. In other words, the “delegate” for this closure would be the “User” class. Therefore it would look for addition… methods in the User class.

In order to change the delegate to Calculator instance, we create an instance of Calculator, clone the closure and invoke it with that Calculator instance. All these things can be implemented using one line of code using “with“.

calc.with block

The closure would now look for the addition… methods in the delegate class ie., the Calculator.