You do not need to be a groovy expert to complete your apps, but you’ll have to learn some groovy. My motivation for this lecture is to introduce you to the most commonly used syntax and operators in Groovy, so you can get started quickly. Another reason is that when I started using Grails, a lot of what I wrote seemed like magic, especially editing the configuration files. Sure, you can copy and paste a\u00a0line and then edit it. you’ll probably get the app running, but it is not very satisfying. If an error should happen, you are not well prepared to fix it. So, I hope that this lecture can\u00a0also demystify some of the groovy aspects that appear like magic.<\/p>\n
Much of the\u00a0material for\u00a0the lecture comes from the first chapter of Programming Grails by Burt Beckwith and the Groovy User Guide page.<\/p>\n
http:\/\/groovy-lang.org\/documentation.html<\/a><\/p>\n A reason why I chose Groovy and Grails framework for your projects is because Groovy is a scripting language built on top of Java, so I thought that the language should be somewhat familiar to you, but that is not always true. You can almost always use Java syntax and commands, but to do that would lose the power of Groovy.<\/p>\n The groovy compiler, groovyc, makes byte code similar to what javac does, but its parser is LL(3), which implies it can look ahead three tokens instead of two tokens as in a LL(2) parser. This allows it to parse “===” and I believe to do away with many brackets that delineate function argument list, maps and arrays.<\/p>\n During bye code generation the groovy compiler adds methods and properties to your classes. But, it also adds a MetaClass to the MetaClassRegistry for the execution context. There is only one MetaClassRegistry for a context, and it associates the MetaClass to the class defined in your code.<\/p>\n Method invocation is the term for how a compiler setups the method calls in your code. The method invocation in groovy is that the MetaClass for your class is called first. This permits the objects of your class to appear to be more dynamic, meaning that properties and methods can be added at run time.<\/p>\n You can run groovy code in your web app and test them with the Grails console. The Groovy Console is shipped with GGTS and IntelliJ IDEA. It allows you to run isolated groovy code. It is useful for developing algorithms or learning groovy.<\/p>\n http:\/\/groovy-lang.org\/groovyconsole.html<\/a><\/p>\n Make a “Groovy Project” in IntelliJ and then\u00a0 select Tools\u00a0-> “Groovy Console” will open a groovy console. \u00a0You can open as many as you like.<\/p>\n https:\/\/www.jetbrains.com\/help\/idea\/2016.3\/launching-groovy-interactive-console.html<\/a><\/p>\n Groovy has some nice groovy features that simplify your code.<\/p>\n If you see missing parentheses assume it is a method call and the arguments of the methods are the variables following the method name.<\/p>\n Groovy is a dynamic language which means that objects do not have to be typed and can appear to change their type. Groovy enables this by using “def” keyword to define an object, such as<\/p>\n the compiler replaces the definition with<\/p>\n In java, this would cause problems later in your code when you want to call a Person method on \u00a0a person object, you would have to cast person to the Person type<\/p>\n But in groovy you do not have to make the cast because the MetaClass for\u00a0 the person object is\u00a0called first, so the compiler knows the class of the object. Of course if you declare the object with “def” then the precompiler cannot warn you of potential syntax errors. I advise to type declare objects whenever you can.<\/p>\n The MetaClass also allows you to dynamically invoke methods or access properties, for example<\/p>\n In the above example the personName property of the person class is assessed using a string variable.<\/p>\n When you make an array in groovy, the compiler implements it as an ArrayList. The example below<\/p>\n is implemented as<\/p>\n Maps (key-value pairs) are implemented with a LinkedHashMap. You can make a Map using square bracket and colon notation.<\/p>\n In this case both the key and the value are Strings. Keys are always Strings, so if the key is a single word you can omit the quotation marks around the key.<\/p>\n Note groovy does not care if you use single or double quotation marks to represent strings. Items in a Map can be accessed by the key, index or using dot notation.<\/p>\n Whenever you see square brackets think, “The object being represented is a Collection, either a List, Set or Map.” If it is a Map you’ll also see colons.<\/p>\n Lists and Maps has many new groovy operators. You can see examples in the documentation.<\/p>\n http:\/\/www.groovy-lang.org\/groovy-dev-kit.html<\/a><\/p>\n Some of the more popular operators are ‘<<‘ and ‘+’ for adding to a collection. The star dot, ‘*.’ or ‘.each{\u2026}’ for traversing the collection.<\/p>\n http:\/\/www.groovy-lang.org\/operators.html<\/a><\/p>\n Many classes are simple and are composed of only attributes with getter and setter methods and have empty constructor. These are called Plain Old Groovy Objects (POGO). For example the Person class.<\/p>\n In groovy you would just code the class attributes without the scoping qualification, i.e. “private”.<\/p>\n The groovy compiler will make the class attributes private and write the setter and getter methods for you. If you needed to do something special in either of the setters and getters you would just overwrite the method.<\/p>\n You can control the auto generation of setters and getters by using private or final and overloading the get and set methods.<\/p>\n This automation can sometimes cause problems. If you make methods in a groovy class with prefix “set” or “get” then groovy will add the field to the class. For example, suppose you code<\/p>\n Groovy will make class like<\/p>\n Frequently this is not a problem, but it might lead to unaccepted behavior. Especially, if Person is a domain object then GORM and Hibernate will not see the “middleName”\u00a0field and give an error trying to setup the database.<\/p>\n Groovy like Java makes the empty constructor, but groovy also makes a constructor which accepts a map of the attributes and values. A Person instance can be made as below.<\/p>\n The above can be shorter.<\/p>\n Note that there is no need for both square brackets delinting the map. The map constructor is implemented by the MettaClass by first calling the default constructor and then calling the set methods for each key of the map.<\/p>\n Whenever you see colons, ‘:’, even without the square brackets think map.<\/p>\n The term closure is probably new to you and will appear mysterious. The formal definition of closure is that it is a segment of code that is\u00a0defined before it is\u00a0invoked and has\u00a0scope at the time that they are defined.<\/p>\n http:\/\/www.groovy-lang.org\/closures.html<\/a><\/p>\n Think of them as functions, and generally you just use them like autonomous classes. Closures can be assigned to a variable so you can throw them around like any object.<\/p>\n You can later call the closure.<\/p>\n Closures can have parameters and use the arrow, ‘->’, to separate the argument list from the body.<\/p>\n and use it thus<\/p>\n Frequently closures have only one argument then the argument’s name is ‘it’.<\/p>\n The “this”\u00a0 in a closure refers to the instance of the enclosing class.<\/p>\n The “owner” refers to the enclosing object. It can be the same as “this” or reference an enclosing closure.<\/p>\n The “delegate” is by default “owner” but can be set.<\/p>\n http:\/\/www.groovy-lang.org\/closures.html#closure-owner<\/a><\/p>\n Grails makes use of setting delegates of closures. Below is an example of a static closure for a Domain class.<\/p>\n It might appear that calling the above “mapping” closure should fail because the methods version<\/em> and table<\/em> are not defined in the PersonName. But, Grails expects the closure ‘mapping’ and will assign the mapping closure a delegate which then redefines the scope of version<\/em> and table<\/em>.<\/p>\n Whenever you see curly brackets think closure, function or method. Recall that the scope can be redefined.<\/p>\n Groovy will return true on more than a boolean object. It returns true for object that have value and false for null objects. Non empty arrays and maps return true, empty arrays and maps return false. This is very useful when checking if you can make a call.<\/p>\n Groovy uses the dollar sign, “$”, like many scripting languages, to represent the value of a\u00a0variable. But\u00a0in groovy it is only used as a string representation of the value.<\/p>\n These types of strings are called GStrings.<\/p>\nSome Mysteries of Groovy Unraveled<\/h1>\n
Groovy Console<\/h1>\n
Preliminary Groovy<\/h1>\n
\n
Groovy Reading Hint<\/h3>\n
Optional Typing<\/h2>\n
def person = new Person()<\/pre>\n
Object person = new Person()<\/pre>\n
(Person)person.personName()<\/pre>\n
String propertName = \"presonName\"\r\ndef name = person.\"$propertyName\"\r\n<\/pre>\n
Arrays and Maps<\/h2>\n
Declaring Collections<\/h3>\n
List<String> names = [\"Robert\", \"Nancy\", \"Bill\"]<\/pre>\n
List<String> names = new ArrayList<String>();\r\nnames.add(\"Robert\");\r\nnames.add(\"Nancy\");\r\nnames.add(\"Bill\");\r\n<\/pre>\n
name = [\"first name\": \"Robert\", \"last name\": \"Pastel\"]<\/pre>\n
name = [first: 'Robert', last: 'Pastel']<\/pre>\n
assert name['first'] == 'Robert'\r\nassert name[0] == 'Robert'\r\nassert name[-1] == 'Pastel'\r\nassert name.last == 'Pastel'\r\n<\/pre>\n
Groovy Reading Hint<\/h3>\n
Using Collections<\/h2>\n
Plain Old Groovy Object (POGO)<\/h2>\n
class Person {\r\n\r\n\/\/ class attributes\r\n private String firstName;\r\n private String lastName;\r\n\r\n \/\/ class setters and getters\r\n public String setFirstName(String name){this.firstName = name;}\r\n public String getFirstName(String name){return firstName;}\r\n public String setLastName(String name){this.lastName = name;}\r\n public String getLastName(String name){return lastName;}\r\n}\r\n<\/pre>\nclass Person{\r\n String firstName\r\n String lastName\r\n}\r\n<\/pre>\nclass Person{\r\n String firstName\r\n String lastName\r\n String gender\r\n\r\n public setGender(String g){\r\n \/\/ check that gender is male or female\r\n \u2026\r\n this.gender = g\r\n }\r\n}\r\n<\/pre>\nclass Person{\r\n String firstName\r\n String lastName\r\n\r\n def setMiddleName(){\r\n \/\/ do something, perhaps save in a hashmap.\r\n }\r\n}<\/pre>\nclass Person {\r\n\r\n\/\/ class attributes\r\n private String firstName;\r\n private String lastName;\r\n private String middleName;\r\n\r\n \/\/ class setters and getters\r\n public String setFirstName(String name){this.firstName = name;}\r\n public String getFirstName(String name){return firstName;}\r\n public String setLastName(String name){this.lastName = name;}\r\n public String getLastName(String name){return lastName;}\r\n \r\n public void setMiddleName{\r\n \/\/ do something\r\n }\r\n public String getLastName(String name) {return middleName;} \r\n}<\/pre>\nConstructors<\/h2>\n
def me = new Person([firstName: \"Robert\", lastName: \"Pastel\"])<\/pre>\n
def me = new Person(firstName: \"Robert\", lastName: \"Pastel\")<\/pre>\n
Groovy Reading Hint<\/h3>\n
Closures<\/h1>\n
Defining and Calling<\/h2>\n
def myClosure = {println \"Hello World\"}<\/pre>\nmyClosure.call()\r\nmyClosure()\r\n<\/pre>\n
def printFirstLastName = {first, last -> println first+\" \"+last}<\/pre>\nprintFristLastName(\"Robert\", \"Pastel\")<\/pre>\n
def printWord{println it}<\/pre>\nIn a Closure this, owner and delegate<\/h2>\n
\r\nclass PersonName{\r\n String firstName\r\n String lastName\r\n static mapping = {\r\n version false\r\n table 'person'\r\n }\r\n}\r\n<\/pre>\nGroovy Reading Hint<\/h3>\n
Groovy Truth<\/h1>\n
def myCollection = makeMe(\u2026)\r\nif (myCollection) { \/\/ then do something}\r\n<\/pre>\nGroovy Strings<\/h1>\n
String fullname = \"$person.fistName $person.lastName\"<\/pre>\n