import groovy.json.JsonOutput  
class Example {
   static void main(String[] args) {
      def output = JsonOutput.toJson([ new Student(name: ''John'',ID:1),
         new Student(name: ''Mark'',ID:2)])
      println(output);  
   } 
}
 
class Student {
   String name
   int ID; 
}

The output of the above program is given below −

[{"name":"John","ID":1},{"name":"Mark","ID":2}]

Groovy – DSLS

Groovy allows one to omit parentheses around the arguments of a method call for top-level statements. This is known as the “command chain” feature. This extension works by allowing one to chain such parentheses-free method calls, requiring neither parentheses around arguments, nor dots between the chained calls.

If a call is executed as a b c d, this will actually be equivalent to a(b).c(d).

DSL or Domain specific language is meant to simplify the code written in Groovy in such a way that it becomes easily understandable for the common user. The following example shows what exactly is meant by having a domain specific language.

def lst = [1,2,3,4] 
print lst

The above code shows a list of numbers being printed to the console using the println statement. In a domain specific language the commands would be as −

Given the numbers 1,2,3,4
 
Display all the numbers

So the above example shows the transformation of the programming language to meet the needs of a domain specific language.

Let’s look at a simple example of how we can implement DSLs in Groovy −

class EmailDsl {  
   String toText 
   String fromText 
   String body 
	
   /** 
   * This method accepts a closure which is essentially the DSL. Delegate the 
   * closure methods to 
   * the DSL class so the calls can be processed 
   */ 
   
   def static make(closure) { 
      EmailDsl emailDsl = new EmailDsl() 
      // any method called in closure will be delegated to the EmailDsl class 
      closure.delegate = emailDsl
      closure() 
   }
   
   /** 
   * Store the parameter as a variable and use it later to output a memo 
   */ 
	
   def to(String toText) { 
      this.toText = toText 
   }
   
   def from(String fromText) { 
      this.fromText = fromText 
   }
   
   def body(String bodyText) { 
      this.body = bodyText 
   } 
}

EmailDsl.make { 
   to "Nirav Assar" 
   from "Barack Obama" 
   body "How are things? We are doing well. Take care" 
}

When we run the above program, we will get the following result −

How are things? We are doing well. Take care

The following needs to be noted about the above code implementation −

• A static method is used that accepts a closure. This is mostly a hassle free way to implement a DSL.

• In the email example, the class EmailDsl has a make method. It creates an instance and delegates all calls in the closure to the instance. This is the mechanism where the “to”, and “from” sections end up executing methods inside the EmailDsl class.

• Once the to() method is called, we store the text in the instance for formatting later on.

• We can now call the EmailDSL method with an easy language that is easy to understand for end users.

Groovy – Database

Groovy’s groovy-sql module provides a higher-level abstraction over the current Java’s JDBC technology. The Groovy sql API supports a wide variety of databases, some of which are shown below.

• HSQLDB
• Oracle
• SQL Server
• MySQL
• MongoDB

In our example, we are going to use MySQL DB as an example. In order to use MySQL with Groovy, the first thing to do is to download the MySQL jdbc jar file from the mysql site. The format of the MySQL will be shown below.

mysql-connector-java-5.1.38-bin

Then ensure to add the above jar file to the classpath in your workstation.

Database Connection

Before connecting to a MySQL database, make sure of the followings −

• You have created a database TESTDB.
• You have created a table EMPLOYEE in TESTDB.
• This table has fields FIRST_NAME, LAST_NAME, AGE, SEX and INCOME.
• User ID “testuser” and password “test123” are set to access TESTDB.
• Ensure you have downloaded the mysql jar file and added the file to your classpath.
• You have gone through MySQL tutorial to understand MySQL Basics

The following example shows how to connect with MySQL database “TESTDB”.

import java.sql.*; 
import groovy.sql.Sql 

class Example {
   static void main(String[] args) {
      // Creating a connection to the database
      def sql = Sql.newInstance(''jdbc:mysql://localhost:3306/TESTDB'', 
         ''testuser'', ''test123'', ''com.mysql.jdbc.Driver'')
			
      // Executing the query SELECT VERSION which gets the version of the database
      // Also using the eachROW method to fetch the result from the database
   
      sql.eachRow(''SELECT VERSION()''){ row ->
         println row[0]
      }
		
      sql.close()  
   } 
} 

While running this script, it is producing the following result −

5.7.10-log 
The Sql.newInstance method is used to establish a connection to the database.

Creating Database Table

The next step after connecting to the database is to create the tables in our database. The following example shows how to create a table in the database using Groovy. The execute method of the Sql class is used to execute statements against the database.

import java.sql.*; 
import groovy.sql.Sql 

class Example { 
   static void main(String[] args) {
      // Creating a connection to the database
      def sql = Sql.newInstance(''jdbc:mysql://localhost:3306/TESTDB'', ''testuser'',  
         ''test123'', ''com.mysql.jdbc.Driver'')
			
      def sqlstr = """CREATE TABLE EMPLOYEE ( 
         FIRST_NAME CHAR(20) NOT NULL,
         LAST_NAME CHAR(20),
         AGE INT,
         SEX CHAR(1),
         INCOME FLOAT )""" 
							
      sql.execute(sqlstr);
      sql.close() 
   } 
}

Insert Operation

It is required when you want to create your records into a database table.

Example

The following example will insert a record in the employee table. The code is placed in a try catch block so that if the record is executed successfully, the transaction is committed to the database. If the transaction fails, a rollback is done.

import java.sql.*; 
import groovy.sql.Sql 

class Example {
   static void main(String[] args) { 
      // Creating a connection to the database
      def sql = Sql.newInstance(''jdbc:mysql://localhost:3306/TESTDB'', ''testuser'', 
         ''test123'', ''com.mysql.jdbc.Driver'')
			
      sql.connection.autoCommit = false
		
      def sqlstr = """INSERT INTO EMPLOYEE(FIRST_NAME,
         LAST_NAME, AGE, SEX, INCOME) VALUES (''Mac'', ''Mohan'', 20, ''M'', 2000)""" 
      try {
         sql.execute(sqlstr);
         sql.commit()
         println("Successfully committed") 
      }catch(Exception ex) {
         sql.rollback()
         println("Transaction rollback") 
      }
		
      sql.close()
   } 
}

Suppose if you wanted to just select certain rows based on a criteria. The following codeshows how you can add a parameter placeholder to search for values. The above example can also be written to take in parameters as shown in the following code. The $ symbol is used to define a parameter which can then be replaced by values when the sql statement is executed.

import java.sql.*; 
import groovy.sql.Sql
 
class Example {
   static void main(String[] args) {
      // Creating a connection to the database
      def sql = Sql.newInstance(''jdbc:mysql://localhost:3306/TESTDB'', ''testuser'', 
         ''test123'', ''com.mysql.jdbc.Driver'')
			
      sql.connection.autoCommit = false  
      
      def firstname = "Mac"
      def lastname ="Mohan"
      def age = 20
      def sex = "M"
      def income = 2000  
		
      def sqlstr = "INSERT INTO EMPLOYEE(FIRST_NAME,LAST_NAME, AGE, SEX, 
         INCOME) VALUES " + "(${firstname}, ${lastname}, ${age}, ${sex}, ${income} )"
			
      try {
         sql.execute(sqlstr);
         sql.commit()
         println("Successfully committed") 
      } catch(Exception ex) {
         sql.rollback()
         println("Transaction rollback")
      }
		
      sql.close()
   }
}

READ Operation

READ Operation on any database means to fetch some useful information from the database. Once our database connection is established, you are ready to make a query into this database.

The read operation is performed by using the eachRow method of the sql class.

Syntax

eachRow(GString gstring, Closure closure) 

Performs the given SQL query calling the given Closure with each row of the result set.

Parameters

• Gstring − The sql statement which needs to be executed.

• Closure − The closure statement to process the rows retrived from the read operation. Performs the given SQL query calling the given Closure with each row of the result set.

The following code example shows how to fetch all the records from the employee table.

import java.sql.*; 
import groovy.sql.Sql
 
class Example {
   static void main(String[] args) {
      // Creating a connection to the database
      def sql = Sql.newInstance(''jdbc:mysql://localhost:3306/TESTDB'', ''testuser'', 
         ''test123'', ''com.mysql.jdbc.Driver'')  
			
      sql.eachRow(''select * from employee'') {
         tp -> 
         println([tp.FIRST_NAME,tp.LAST_NAME,tp.age,tp.sex,tp.INCOME])
      }  
		
      sql.close()
   } 
}

The output from the above program would be −

[Mac, Mohan, 20, M, 2000.0]

Update Operation

UPDATE Operation on any database means to update one or more records, which are already available in the database. The following procedure updates all the records having SEX as ”M”. Here, we increase AGE of all the males by one year.

import java.sql.*; 
import groovy.sql.Sql 

class Example {
   static void main(String[] args){
      // Creating a connection to the database
      def sql = Sql.newInstance(''jdbc:mysql://localhost:3306/TESTDB'', ''testuser'', 
         ''test@123'', ''com.mysql.jdbc.Driver'')
			
      sql.connection.autoCommit = false
      def sqlstr = "UPDATE EMPLOYEE SET AGE = AGE + 1 WHERE SEX = ''M''" 
	  
      try {
         sql.execute(sqlstr);
         sql.commit()
         println("Successfully committed")
      }catch(Exception ex) {
         sql.rollback() 
         println("Transaction rollback")
      }
		
      sql.close()
   } 
}

DELETE Operation

DELETE operation is required when you want to delete some records from your database. Following is the procedure to delete all the records from EMPLOYEE where AGE is more than 20.

import java.sql.*; 
import groovy.sql.Sql 

class Example {
   static void main(String[] args) {
      // Creating a connection to the database
      def sql = Sql.newInstance(''jdbc:mysql://localhost:3306/TESTDB'', ''testuser'', 
         ''test@123'', ''com.mysql.jdbc.Driver'')
			
      sql.connection.autoCommit = false
      def sqlstr = "DELETE FROM EMPLOYEE WHERE AGE > 20"
   
      try {
         sql.execute(sqlstr);
         sql.commit()
         println("Successfully committed")
      }catch(Exception ex) {
         sql.rollback()
         println("Transaction rollback")
      }
   
      sql.close()
   } 
}

Performing Transactions

Transactions are a mechanism that ensures data consistency. Transactions have the following four properties −

• Atomicity − Either a transaction completes or nothing happens at all.

• Consistency − A transaction must start in a consistent state and leave the system in a consistent state.

• Isolation − Intermediate results of a transaction are not visible outside the current transaction.

• Durability − Once a transaction was committed, the effects are persistent, even after a system failure.

Here is a simple example of how to implement transactions. We have already seen this example from our previous topic of the DELETE operation.

def sqlstr = "DELETE FROM EMPLOYEE WHERE AGE > 20" 
 
try {
   sql.execute(sqlstr); 
   sql.commit()
   println("Successfully committed") 
}catch(Exception ex) {
   sql.rollback()
   println("Transaction rollback") 
} 
sql.close()

Commit Operation

The commit operation is what tells the database to proceed ahead with the operation and finalize all changes to the database.

In our above example, this is achieved by the following statement −

sql.commit()

Rollback Operation

If you are not satisfied with one or more of the changes and you want to revert back those changes completely, then use rollback method. In our above example, this is achieved by the following statement −

sql.rollback()

Disconnecting Databases

To disconnect Database connection, use the close method.

sql.close()

Groovy – Builders

During the process of software development, sometimes developers spend a lot of time in creating Data structures, domain classes, XML, GUI Layouts, Output streams etc.And sometimes the code used to create these specific requirements results in the repitition of the same snippet of code in many places. This is where Groovy builders come into play. Groovy has builders which can be used to create standard objects and structures. These builders saves time as developer dont need to write their own code to create these builders. In the couse of this chapter we will look at the different builders available in groovy.

Swing Builder

In groovy one can also create graphical user interfaces using the swing builders available in groovy. The main class for developing swing components is the SwingBuilder class. This class has many methods for creating graphical components such as −

• JFrame − This is for creating the frame element.

• JTextField − This is used for creating the textfield component.

Let’s look at a simple example of how to create a Swing application using the SwingBuilder class. In the following example, you can see the following points −

• You need to import the groovy.swing.SwingBuilder and the javax.swing.* classes.

• All of the componets displayed in the Swing application are part of the SwingBuilder class.

• For the frame itself, you can specify the initial location and size of the frame. You can also specify the title of the frame.

• You need to set the Visibility property to true in order for the frame to be shown.

import groovy.swing.SwingBuilder 
import javax.swing.* 

// Create a builder 
def myapp = new SwingBuilder()

// Compose the builder 
def myframe = myapp.frame(title : ''Tutorials Point'', location : [200, 200], 
   size : [400, 300], defaultCloseOperation : WindowConstants.EXIT_ON_CLOSE {         
      label(text : ''Hello world'')
   } 
	
// The following  statement is used for displaying the form 
frame.setVisible(true)

The output of the above program is given below. The following output shows a JFrame along with a JLabel with a text of Hello World.

Let’s look at our next example for creating an input screen with textboxes. In the following example, we want to create a form which has text boxes for Student name, subject and School Name. In the following example, you can see the following key points −

• We are defining a layout for our controls on the screen. In this case we are using the Grid Layout.
• We are using an alignment property for our labels.
• We are using the textField method for displaying textboxes on the screen.

import groovy.swing.SwingBuilder 
import javax.swing.* 
import java.awt.*
 
// Create a builder 
def myapp = new SwingBuilder() 

// Compose the builder 
def myframe = myapp.frame(title : ''Tutorials Point'', location : [200, 200], 
   size : [400, 300], defaultCloseOperation : WindowConstants.EXIT_ON_CLOSE) { 
      panel(layout: new GridLayout(3, 2, 5, 5)) { 
         label(text : ''Student Name:'', horizontalAlignment : JLabel.RIGHT) 
         textField(text : '''', columns : 10) 
			
         label(text : ''Subject Name:'', horizontalAlignment : JLabel.RIGHT) 
         textField(text : '''', columns : 10)
			
         label(text : ''School Name:'', horizontalAlignment : JLabel.RIGHT) 
         textField(text : '''', columns : 10) 
      } 
   } 
	
// The following  statement is used for displaying the form 
myframe.setVisible(true)

The output of the above program is given below −

Event Handlers

Now let’s look at event handlers. Event handlers are used for button to perform some sort of processing when a button is pressed. Each button pseudomethod call includes the actionPerformed parameter. This represents a code block presented as a closure.

Let’s look at our next example for creating a screen with 2 buttons. When either button is pressed a corresponding message is sent to the console screen. In the following example, you can see the following key points −

• For each button defined, we are using the actionPerformed method and defining a closure to send some output to the console when the button is clicked.

import groovy.swing.SwingBuilder 
import javax.swing.* 
import java.awt.* 

def myapp = new SwingBuilder()
  
def buttonPanel = {
   myapp.panel(constraints : BorderLayout.SOUTH) {
	
      button(text : ''Option A'', actionPerformed : {
         println ''Option A chosen''
      })
		
      button(text : ''Option B'', actionPerformed : {
         println ''Option B chosen''
      })
   }
}
  
def mainPanel = {
   myapp.panel(layout : new BorderLayout()) {
      label(text : ''Which Option do you want'', horizontalAlignment : 
      JLabel.CENTER,
      constraints : BorderLayout.CENTER)
      buttonPanel()
   }
}
  
def myframe = myapp.frame(title : ''Tutorials Point'', location : [100, 100],
   size : [400, 300], defaultCloseOperation : WindowConstants.EXIT_ON_CLOSE){
      mainPanel()
   }
	
myframe.setVisible(true)

The output of the above program is given below. When you click on either button, the required message is sent to the console log screen.

Another variation of the above example is to define methods which can can act as handlers. In the following example we are defining 2 handlers of DisplayA and DisplayB.

import groovy.swing.SwingBuilder 
import javax.swing.* 
import java.awt.* 

def myapp = new SwingBuilder()
  
def DisplayA = {
   println("Option A") 
} 

def DisplayB = {
   println("Option B")
}

def buttonPanel = {
   myapp.panel(constraints : BorderLayout.SOUTH) {
      button(text : ''Option A'', actionPerformed : DisplayA) 
      button(text : ''Option B'', actionPerformed : DisplayB)
   }
}  

def mainPanel = {
   myapp.panel(layout : new BorderLayout()) {
      label(text : ''Which Option do you want'', horizontalAlignment : JLabel.CENTER,
      constraints : BorderLayout.CENTER)
      buttonPanel()
   }
}  

def myframe = myapp.frame(title : ''Tutorials Point'', location : [100, 100],
   size : [400, 300], defaultCloseOperation : WindowConstants.EXIT_ON_CLOSE) {
      mainPanel()
   } 
	
myframe.setVisible(true) 

The output of the above program would remain the same as the earlier example.

DOM Builder

The DOM builder can be used for parsing HTML, XHTML and XML and converting it into a W3C DOM tree.

The following example shows how the DOM builder can be used.

String records = ''''''
   <library>
	
      <Student>
         <StudentName division = ''A''>Joe</StudentName>
         <StudentID>1</StudentID>
      </Student>
	  
      <Student>
         <StudentName division = ''B''>John</StudentName>
         <StudentID>2</StudentID>
      </Student>
	  
      <Student>
         <StudentName division = ''C''>Mark</StudentName>
         <StudentID>3</StudentID>
      </Student>
		
   </library>''''''
   
def rd = new StringReader(records) 
def doc = groovy.xml.DOMBuilder.parse(rd)

JsonBuilder

The JsonBuilder is used for creating json type objects.

The following example shows how the Json builder can be used.

def builder = new groovy.json.JsonBuilder() 

def root = builder.students {
   student {
      studentname ''Joe''
      studentid ''1''
		
      Marks(
         Subject1: 10,
         Subject2: 20,
         Subject3:30,
      )
   } 
} 
println(builder.toString());

{"students":{"student":{"studentname":"Joe","studentid":"1","Marks":{"Subject1":10,
"S ubject2":20,"Subject3":30}}}}

def builder = new groovy.json.JsonBuilder() 
def lst = builder([1, 2, 3]) 
println(builder.toString());

[1,2,3]

def builder = new groovy.json.JsonBuilder() 

class Student {
   String name  
} 

def studentlist = [new Student (name: "Joe"), new Student (name: "Mark"), 
   new Student (name: "John")] 
	
builder studentlist, { Student student ->name student.name} 
println(builder)

[{"name":"Joe"},{"name":"Mark"},{"name":"John"}] 

def nodeBuilder = new NodeBuilder() 

def studentlist = nodeBuilder.userlist {
   user(id: ''1'', studentname: ''John'', Subject: ''Chemistry'')
   user(id: ''2'', studentname: ''Joe'', Subject: ''Maths'')
   user(id: ''3'', studentname: ''Mark'', Subject: ''Physics'') 
} 

println(studentlist)

tmpDir = File.createTempDir() 
def fileTreeBuilder = new FileTreeBuilder(tmpDir) 

fileTreeBuilder.dir(''main'') {
   dir(''submain'') {
      dir(''Tutorial'') {
        file(''Sample.txt'', ''println "Hello World"'')
      }
   } 
}

class Example {
   static void main(String[] args) {
      Student mst = new Student();
      mst.name = "Joe";
      mst.ID = 1;
      println(mst.Display())
   } 
} 
 
public class Student {
   String name;
   int ID;
	
   String Display() {
      return name +ID;
   }  
}

Joe1

class StudentTest extends GroovyTestCase {
   void testDisplay() {
      def stud = new Student(name : ''Joe'', ID : ''1'')
      def expected = ''Joe1''
      assertToString(stud.Display(), expected)
   }
}

import groovy.util.GroovyTestSuite 
import junit.framework.Test 
import junit.textui.TestRunner 

class AllTests { 
   static Test suite() { 
      def allTests = new GroovyTestSuite() 
      allTests.addTestSuite(StudentTest.class) 
      allTests.addTestSuite(EmployeeTest.class) 
      return allTests 
   } 
} 

TestRunner.run(AllTests.suite())

def name = "Groovy" 
println "This Tutorial is about ${name}"

def text =''This Tutorial focuses on $TutorialName. In this tutorial you will learn 

about $Topic''  

def binding = ["TutorialName":"Groovy", "Topic":"Templates"]  
def engine = new groovy.text.SimpleTemplateEngine() 
def template = engine.createTemplate(text).make(binding) 

println template

<Student> 
   <name>${name}</name> 
   <ID>${id}</ID> 
   <subject>${subject}</subject> 
</Student>

import groovy.text.* 
import java.io.* 

def file = new File("D:/Student.template") 
def binding = [''name'' : ''Joe'', ''id'' : 1, ''subject'' : ''Physics'']
				  
def engine = new SimpleTemplateEngine() 
def template = engine.createTemplate(file) 
def writable = template.make(binding) 

println writable

<Student> 
   <name>Joe</name> 
   <ID>1</ID> 
   <subject>Physics</subject> 
</Student>

def text = ''''''This Tutorial is <% out.print TutorialName %> The Topic name 

is ${TopicName}'''''' 
def template = new groovy.text.StreamingTemplateEngine().createTemplate(text)
  
def binding = [TutorialName : "Groovy", TopicName  : "Templates",]
String response = template.make(binding) 
println(response)

This Tutorial is Groovy The Topic name is Templates

def binding = [StudentName: ''Joe'', id: 1, subject: ''Physics''] 
def engine = new groovy.text.XmlTemplateEngine() 

def text = ''''''
   <document xmlns:gsp=''http://groovy.codehaus.org/2005/gsp''>
      <Student>
         <name>${StudentName}</name>
         <ID>${id}</ID>
         <subject>${subject}</subject>
      </Student>
   </document> 
'''''' 

def template = engine.createTemplate(text).make(binding) 
println template.toString()

   Joe
    
    
   1
    
    
   Physics 

Def myStudent = new Student() 
myStudent.Name = ”Joe”; 
myStudent.Display()

Public interface GroovyInterceptable { 
   Public object invokeMethod(String methodName, Object args) 
   Public object getproperty(String propertyName) 
   Public object setProperty(String propertyName, Object newValue) 
   Public MetaClass getMetaClass() 
   Public void setMetaClass(MetaClass metaClass) 
}

class Example {
   static void main(String[] args) {
      Student mst = new Student();
      mst.Name = "Joe";
      mst.ID = 1;
		
      println(mst.Name);
      println(mst.ID);
   }
}

class Student implements GroovyInterceptable { 
   protected dynamicProps=[:]
	
   void setProperty(String pName,val) {
      dynamicProps[pName] = val
   }
   
   def getProperty(String pName) {
      dynamicProps[pName]
   } 
} 

Joe 
1

class Example {
   static void main(String[] args) {
      Student mst = new Student();
      mst.Name = "Joe";
      mst.ID = 1;
		
      println(mst.Name);
      println(mst.ID);
      mst.AddMarks();
   } 
}
 
class Student implements GroovyInterceptable {
   protected dynamicProps = [:]  
    
   void setProperty(String pName, val) {
      dynamicProps[pName] = val
   } 
   
   def getProperty(String pName) {
      dynamicProps[pName]
   }
   
   def invokeMethod(String name, Object args) {
      return "called invokeMethod $name $args"
   }
}

Joe 
1 

class Example {
   static void main(String[] args) {
      Student mst = new Student();
      println mst.getName()
      mst.metaClass.setAttribute(mst, ''name'', ''Mark'')
      println mst.getName()
   } 
} 

class Student {
   private String name = "Joe";
	
   public String getName() {
      return this.name;
   } 
}

Joe 
Mark

class Example {
   static void main(String[] args) {
      Student mst = new Student();
      mst.Name = "Joe";
      mst.ID = 1;
		
      println(mst.Name);
      println(mst.ID);
      mst.AddMarks();
   } 
} 

class Student implements GroovyInterceptable {
   protected dynamicProps = [:]  
    
   void setProperty(String pName, val) {
      dynamicProps[pName] = val
   }
   
   def getProperty(String pName) {
      dynamicProps[pName]
   }
   
   def methodMissing(String name, def args) {         
      println "Missing method"
   }  
}

Joe 
1 
Missing method