Tutorial Grails #4

Seri tutorial Grails ini lanjutan dari sebelumnya, dimana pembahasan kita masih seputar groovy. Kali ini kita akan membahas tentang :

• Groovy Unit Testing
• XML di Groovy
• Expandos

Groovy Unit Testing

Sama seperti java, groovy mempunyai unit testing. Dimana kita tidak perlu men-download terpisah dan sudah terintegrasi dengan JUnit. Mari kita lihat contoh penggunaannya unit testing di groovy:

class RangeTest extends GroovyTestCase {

 def lowerCaseRange = 'a'..'z'
 def upperCaseRange = 'A'..'Z'

 void testLowerCaseRange() {
  assert 26 == lowerCaseRange.size()
  assertTrue(lowerCaseRange.contains('b'))
  assertFalse(lowerCaseRange.contains('B'))
 }

 void testUpperCaseRange() {
  assert 26 == upperCaseRange.size()
  assertTrue(upperCaseRange.contains('B'))
  assertFalse(upperCaseRange.contains('b'))
  }

 void testAlphaRange() {
   def alphaRange = lowerCaseRange + upperCaseRange
   assert 52 == alphaRange.size()
   assert alphaRange.contains('b')
   assert alphaRange.contains('B')
   }
}
      

cara menajalankan tinggal ketikkan groovy RangeTest di command line. Groovy Unit Testing di extend dari class GroovyTestCase dan setiap method menggunakan naming convention testXXX sebagai prefix.

XML di Groovy

Extensible Markup Language, biasa digunakan untuk persist atau share data di enterprise applications.

Kenapa harus XML ?

Karena XML adalah text-based, sudah ada standart dan sudah banyak yang framework atau libraries yang mendukung XML di berbagai platform. Mari kita compare pembuatan XML dengan java (complicated) dengan groovy (simple and elegant).

package com.yukibuwana.testing;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.transform.OutputKeys;
import javax.xml.transform.Result;
import javax.xml.transform.Source;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerException;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;

import org.w3c.dom.Document;
import org.w3c.dom.Element;

public class GenerateXML {

 /**
  * @param args
  * @throws ParserConfigurationException 
  * @throws TransformerException 
  */
 public static void main(String[] args) throws ParserConfigurationException, TransformerException {
  DocumentBuilder builder = DocumentBuilderFactory.newInstance().newDocumentBuilder();
  Document doc = builder.newDocument();
  
  Element todos = doc.createElement("todos");
  doc.appendChild(todos);
  
  Element task = doc.createElement("todo");
  task.setAttribute("id", "1");
  todos.appendChild(task);
  
  Element name = doc.createElement("name");
  name.setTextContent("Buy Beginning Groovy and Grails");
  task.appendChild(name);
  
  Element note = doc.createElement("note");
  note.setTextContent("Purchase book from Amazon.com for all co-workers.");
  task.appendChild(note);
  
  TransformerFactory tranFactory = TransformerFactory.newInstance();
  Transformer transformer = tranFactory.newTransformer();
  transformer.setOutputProperty(OutputKeys.INDENT, "yes");
  transformer.setOutputProperty(
    "{http://xml.apache.org/xslt}indent-amount", "2");
  
  Source src = new DOMSource(doc);
  Result dest = new StreamResult(System.out);
  transformer.transform(src, dest);
 }
}  

Mari kita lihat dengan groovy way

def writer = new StringWriter()
def builder = new groovy.xml.MarkupBuilder(writer)
builder.setDoubleQuotes(true)
builder.todos {
    todo (id:"1") {
        name "Buy Beginning Groovy and Grails"
        note "Purchase book from Amazon.com for all co-workers."
    }
}

println writer.toString()      

Lalu hasil dari kedua seperti ini

Simple XML

Expandos

Expando adalah class di groovy.util yang digunakan untuk dynamically expandable bean. Artinya, kita bisa menambahkan properties atau closure di saat runtime. Untuk lebih mudahnya, mari kita lihat contoh berikut ini :

class User {
    String firstName;
    String lastName;
}

def user = new User(firstName: "Yuki", lastName: "Buwana")

println user.firstName + " " + user.lastName

Disini kita membuat class User dengan properties firstName dan lastName diawal. Sekarang kita lihat jika kita menggunakan Expando class

def user = new Expando()

user.firstName = "Yuki"
user.lastName = "Buwana"

println user.firstName + " " + user.lastName      

Yoooi... Kita bisa menambahkan properties pada saat runtime. It's amazing.

Banyak hal yang baru di groovy, seperti :

• MOP
• Generate Text with Template

Yang tidak kita bahas disini. Sebagai referensi groovy ada disini atau buku Groovy in Action. Disana dibahas lebih mendalam dan lebih detail.

Untuk tutorial selanjutnya, kita akan memulai dengan Grails itu sendiri.

Tutorial Grails #3

Tutorial ini lanjutan dari sebelumnya, dimana kita akan membahas tentang groovy lebih dalam. Disini kita akan membahas tentang :

• Groovy Shell dan Groovy Console
• Method dan closure
• Collection di Groovy

Groovy Shell dan Groovy Console

Groovy Shell ataupun Groovy Console adalah interactive command line yang digunakan untuk menjalan perintah-perintah groovy. Mulai dari create, save ataupun load groovy script.

Groovy Shell

Cara menjalankan cukup ketikkan groovysh di command line.

Groovy Console

Cara menjalankan Groovy Console juga cukup mudah, sama seperti Groovy Shell. Cukup ketikkan groovyConsole. Untuk pemula disarankan menggunakan Groovy Console dibandingkan Groovy Shell.

Method dan Closure

Di java kita mengenal method sedangkan di groovy kita mengenal closure. Mari kita lihat perbedaannya :

Method in Java way

public String hello(String name) {
   return "Hello, " + name;
}
      

Method in Groovy way

def hello(name) {
   "Hello, ${name}"
}
      

Closure

def name = "Chris"
def printClosure = { println "Hello, ${name}" }

printClosure()

name = "Joseph"
printClosure()
      

Jadi perbedaannya method dengan closure adalah closure adalah object sedangkan method tidak.

Collection di Groovy

Collection berlaku juga di groovy, seperti :

• List
• Ranges
• Sets
• Arrays
• Maps

Disini kita akan membahas Range Collection saja, karena range begitu mudah. Mari kita lihat contoh penggunaan range di groovy

def numRange = 0..9
println numRange.size()
numRange.each {print it}
println ""
println numRange.contains(5)

def alphaRange = 'a'..'z'
println alphaRange.size()
println alphaRange[1]

def reverseRange = 9..0
reverseRange.each {print it}

Sedangkan penggunaan range dalam pengulangan, seperti ini

println "Java style for loop"
for(int i=0;i<=9;i++) {
   println i
}

println "Groovy style for loop"
for (i in 0..9) {
   println i
}

println "Groovy range loop"
(0..9).each { i->
   println i
}
      

Jadi range adalah daftar uturan nilai. Range di implement dari java.lang.Comparable.

Banyak hal yang baru di groovy yang tidak bisa dituangkan disini. Next, kita akan membahas groovy lebih banyak lagi sebelum kita masuk ke grails.

Tutorial Grails #2

Tutorial ini melanjukan dari seri Tutorial Grails sebelumnya, yaitu Install Grails. Saat ini kita akan mempelajari Groovy.

Apa sih Groovy ?
Groovy adalah dynamic language yang berjalan diatas Java Virtual Language (JVM). Groovy diinspirasi oleh bahasa pemrograman lain seperti Ruby, Python, Perl dan Smaltalk. Groovy bisa berjalan sebagai interpreted atau compiled.

Cukup dengan teori, mari kita lanjutkan adalah Instalasi, yaitu:

1. Download groovy versi terbaru di sini.
2. Unzip groovy-binary-X.X.X.zip di lokasi yang anda inginkan.
3. Set GROOVY_HOME
4. Tambahkan GROOVY_HOME/bin di PATH

validate your installation

Next, kita akan melihat mudahkan migrasi dari java ke groovy. Berikut contoh program menggunakan java (Todo.java).

       
package com.yukibuwana.testing;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class Todo {
 private String name;
 private String note;
 
 public Todo(String name, String note) {
  this.name = name;
  this.note = note;
 }
 
 public String getName() {
  return name;
 }

 public void setName(String name) {
  this.name = name;
 }

 public String getNote() {
  return note;
 }

 public void setNote(String note) {
  this.note = note;
 }

 public static void main(String[] args) {
  List<Todo> todos = new ArrayList<Todo>();
  todos.add(new Todo("1", "one"));
  todos.add(new Todo("2", "two"));
  todos.add(new Todo("3", "three"));
  
  for (Iterator<Todo> iterator = todos.iterator(); iterator.hasNext();) {
   Todo todo = (Todo) iterator.next();
   System.out.println(todo.getName() + " " + todo.getNote());
   
  }

 }

}
 

Setelah kita compile dan dijalankan, hasilnya seperti ini

       
1 one
2 two
3 three
 

Groovy-nya gimana ?

Cara termudah mengubah dari java menjadi groovy, yaitu :

1. Ubah extensions file dari .java menjadi .groovy
2. Compile file groovy (groovyc xxx.groovy).
3. Hasil dari compile groovy adalah class, sama seperti java.
4. Jalankan class file tersebut.

Yups... Hasil dari compile groovy adalah class file. 

Jadi apa yang dilakukan oleh groovy ? 

Mari kita lihat hasil dari decompiler dari file class tersebut.

       
package com.yukibuwana.testing;

import groovy.lang.GroovyObject;
import groovy.lang.MetaClass;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import org.codehaus.groovy.runtime.ScriptBytecodeAdapter;
import org.codehaus.groovy.runtime.callsite.CallSite;
import org.codehaus.groovy.runtime.typehandling.DefaultTypeTransformation;

public class Todo
  implements GroovyObject
{
  private String name;
  private String note;

  public Todo()
  {
    Todo this;
    CallSite[] arrayOfCallSite = $getCallSiteArray();
    MetaClass localMetaClass = $getStaticMetaClass();
    this.metaClass = localMetaClass;
  }

  public static void main(String[] args)
  {
    CallSite[] arrayOfCallSite = $getCallSiteArray(); List todos = (List)ScriptBytecodeAdapter.castToType(arrayOfCallSite[0].callConstructor(ArrayList.class), List.class);
    arrayOfCallSite[1].call(todos, arrayOfCallSite[2].callConstructor(Todo.class, ScriptBytecodeAdapter.createMap(new Object[] { "name", "1", "note", "one" })));
    arrayOfCallSite[3].call(todos, arrayOfCallSite[4].callConstructor(Todo.class, ScriptBytecodeAdapter.createMap(new Object[] { "name", "2", "note", "two" })));
    arrayOfCallSite[5].call(todos, arrayOfCallSite[6].callConstructor(Todo.class, ScriptBytecodeAdapter.createMap(new Object[] { "name", "3", "note", "three" })));

    for (Iterator iterator = (Iterator)ScriptBytecodeAdapter.castToType(arrayOfCallSite[7].call(todos), Iterator.class); DefaultTypeTransformation.booleanUnbox(arrayOfCallSite[8].call(iterator)); ) {
      Todo todo = (Todo)ScriptBytecodeAdapter.castToType(arrayOfCallSite[9].call(iterator), Todo.class);
      arrayOfCallSite[10].call(arrayOfCallSite[11].callGetProperty(System.class), arrayOfCallSite[12].call(arrayOfCallSite[13].call(arrayOfCallSite[14].call(todo), " "), arrayOfCallSite[15].call(todo)));
    }
  }

  static
  {
    __$swapInit();
  }
}
       

Yups... Banyak code yang di inject oleh groovy.

Bedanya dengan java apa donk ?

Betul.. Setelah di compile dengan groovy, file class jadi lebih rumit. Tetapi, groovy make java code become art. Mari kita lihat coding bergaya groovy

package com.yukibuwana.testing

import java.util.Iterator;

public class GroovySimple {
 String name
 String note
 
 public static void main(String[] args) {
  def todos = new ArrayList()
  todos.add(new GroovySimple(name:"1", note:"one"))
  todos.add(new GroovySimple(name:"2", note:"two"))
  todos.add(new GroovySimple(name:"3", note:"three"))
  
  for (Iterator iterator = todos.iterator(); iterator.hasNext();) {
   def todo = iterator.next()
   
   println "${todo.name} ${todo.note}"
   
  }
  
 }

}

Dan wooola... Groovy make it code become art and simple..