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 simppfy 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 pst 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 estabpsh 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 estabpshed, 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 calpng 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 calpng 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.

Durabipty − 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 finapze 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 apppcation 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 apppcation 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 Visibipty 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 apgnment 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: , horizontalApgnment : JLabel.RIGHT) 
         textField(text :   , columns : 10) 
			
         label(text :  Subject Name: , horizontalApgnment : JLabel.RIGHT) 
         textField(text :   , columns : 10)
			
         label(text :  School Name: , horizontalApgnment : 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 cpcked.

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 , horizontalApgnment : 
      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 cpck 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 , horizontalApgnment : 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 earper 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 =    
   <pbrary>
	
      <Student>
         <StudentName spanision =  A >Joe</StudentName>
         <StudentID>1</StudentID>
      </Student>
	  
      <Student>
         <StudentName spanision =  B >John</StudentName>
         <StudentID>2</StudentID>
      </Student>
	  
      <Student>
         <StudentName spanision =  C >Mark</StudentName>
         <StudentID>3</StudentID>
      </Student>
		
   </pbrary>   
   
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());

The output of the above program is given below. The output clearlt shows that the Jsonbuilder was able to build the json object out of a structed set of nodes.

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

The jsonbuilder can also take in a pst and convert it to a json object. The following example shows how this can be accomppshed.

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

The output of the above program is given below.

[1,2,3]

The jsonBuilder can also be used for classes. The following example shows how objects of a class can become inputs to the json builder.

Live Demo

def builder = new groovy.json.JsonBuilder() 

class Student {
   String name  
} 

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

The output of the above program is given below.

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

NodeBuilder

NodeBuilder is used for creating nested trees of Node objects for handpng arbitrary data. An example of the usage of a Nodebuilder is shown below.

def nodeBuilder = new NodeBuilder() 

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

println(studentpst)

FileTreeBuilder

FileTreeBuilder is a builder for generating a file directory structure from a specification. Following is an example of how the FileTreeBuilder can be used.

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

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

From the execution of the above code a file called sample.txt will be created in the folder main/submain/Tutorial. And the sample.txt file will have the text of “Hello World”.

Groovy - Command Line

The Groovy shell known as groovysh can be easily used to evaluate groovy expressions, define classes and run simple programs. The command pne shell gets installed when Groovy is installed.

Following are the command pne options available in Groovy −

Command pne parameter	Full Name	Details
-C	--color[=FLAG]	Enable or disable use of ANSI colors
-D	--define=NAME=VALUE	Define a system property
-T	--terminal=TYPE	Specify the terminal TYPE to use
-V	--version	Display the version
-classpath		Specify where to find the class files – must be the first argument
-cp	--classpath	Apases for -classpath
-d	--debug	--debug Enable debug output
-e	--evaluate=arg	Evaluate option fist when starting interactive session
-h	--help	Display this help message
-q	--quiet	Suppress superfluous output
-v	--verbose	Enable verbose output

The following snapshot shows a simple example of an expression being executed in the Groovy shell. In the following example we are just printing “Hello World” in the groovy shell.

Classes and Functions

It is very easy to define a class in the command prompt, create a new object and invoke a method on the class. The following example shows how this can be implemented. In the following example, we are creating a simple Student class with a simple method. In the command prompt itself, we are creating an object of the class and calpng the Display method.

It is very easy to define a method in the command prompt and invoke the method. Note that the method is defined using the def type. Also note that we have included a parameter called name which then gets substituted with the actual value when the Display method is called. The following example shows how this can be implemented.

Commands

The shell has a number of different commands, which provide rich access to the shell’s environment. Following is the pst of them and what they do.

Sr.No	Command &smp; Command Description
1	:help (:h ) Display this help message
2	? (:? ) Apas to: :help
3	:exit (:x ) Exit the shell
4	:quit (:q ) Apas to: :exit
5	import (:i ) Import a class into the namespace
6	:display (:d ) Display the current buffer
7	:clear (:c ) Clear the buffer and reset the prompt counter
8	:show (:S ) Show variables, classes or imports
9	:inspect (:n ) Inspect a variable or the last result with the GUI object browser
10	:purge (:p ) Purge variables, classes, imports or preferences
11	:edit (:e ) Edit the current buffer
12	:load (:l ) Load a file or URL into the buffer
13	. (:. ) Apas to: :load
14	.save (:s ) Save the current buffer to a file
15	.record (:r ) Record the current session to a file
16	:apas (:a ) Create an apas
17	:set (:= ) Set (or pst) preferences
18	:register (:rc) Registers a new command with the shell
19	:doc (:D ) Opens a browser window displaying the doc for the argument
20	:history (:H ) Display, manage and recall edit-pne history

Groovy - Unit Testing

The fundamental unit of an object-oriented system is the class. Therefore unit testing consists of testig within a class. The approach taken is to create an object of the class under testing and use it to check that selected methods execute as expected. Not every method can be tested, since it is not always pratical to test each and every thing. But unit testing should be conducted for key and critical methods.

JUnit is an open-source testing framework that is the accepted industry standard for the automated unit testing of Java code. Fortunately, the JUnit framework can be easily used for testing Groovy classes. All that is required is to extend the GroovyTestCase class that is part of the standard Groovy environment. The Groovy test case class is based on the Junit test case.

Writing a Simple Junit Test Case

Let assume we have the following class defined in a an apppcation class file −

Live Demo

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

The output of the above program is given below.

Joe1

And now suppose we wanted to write a test case for the Student class. A typical test case would look pke the one below. The following points need to be noted about the following code −

The test case class extends the GroovyTestCase class

We are using the assert statement to ensure that the Display method returns the right string.

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

The Groovy Test Suite

Normally as the number of unit tests increases, it would become difficult to keep on executing all the test cases one by one. Hence Groovy provides a facipty to create a test suite that can encapsulate all test cases into one logicial unit. The following codesnippet shows how this can be achieved. The following things should be noted about the code −

The GroovyTestSuite is used to encapsulate all test cases into one.

In the following example, we are assuming that we have two tests case files, one called StudentTest and the other is EmployeeTest which contains all of the necessary testing.

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())

Groovy - Template Engines

Groovy’s template engine operates pke a mail merge (the automatic addition of names and addresses from a database to letters and envelopes in order to faciptate sending mail, especially advertising, to many addresses) but it is much more general.

Simple Templating in Strings

If you take the simple example below, we are first defining a name variable to hold the string “Groovy”. In the println statement, we are using $ symbol to define a parameter or template where a value can be inserted.

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

If the above code is executed in groovy, the following output will be shown. The output clearly shows that the $name was replaced by the value which was assigned by the def statement.

Simple Template Engine

Following is an example of the SimpleTemplateEngine that allows you to use JSP-pke scriptlets and EL expressions in your template in order to generate parametrized text. The templating engine allows you to bind a pst of parameters and their values so that they can be replaced in the string which has the defined placeholders.

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

If the above code is executed in groovy, the following output will be shown.

Let’s now use the templating feature for an XML file. As a first step let’s add the following code to a file called Student.template. In the following file you will notice that we have not added the actual values for the elements, but placeholders. So $name,$is and $subject are all put as placeholders which will need to replaced at runtime.

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

Now let’s add our Groovy script code to add the functionapty which can be used to replace the above template with actual values. The following things should be noted about the following code.

The mapping of the place-holders to actual values is done through a binding and a SimpleTemplateEngine. The binding is a Map with the place-holders as keys and the replacements as the values.

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

If the above code is executed in groovy, the following output will be shown. From the output it can be seen that the values are successfully replaced in the relevant placeholders.

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

StreamingTemplateEngine

The StreamingTemplateEngine engine is another templating engine available in Groovy. This is kind of equivalent to the SimpleTemplateEngine, but creates the template using writeable closures making it more scalable for large templates. Specifically this template engine can handle strings larger than 64k.

Following is an example of how StreamingTemplateEngine are used −

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)

If the above code is executed in groovy, the following output will be shown.

This Tutorial is Groovy The Topic name is Templates

XMLTemplateEngine

The XmlTemplateEngine is used in templating scenarios where both the template source and the expected output are intended to be XML. Templates use the normal ${expression} and $variable notations to insert an arbitrary expression into the template.

Following is an example of how XMLTemplateEngine is used.

Live Demo

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()

If the above code is executed in groovy, the following output will be shown

   Joe
    
    
   1
    
    
   Physics 

Groovy - Meta Object Programming

Meta object programming or MOP can be used to invoke methods dynamically and also create classes and methods on the fly.

So what does this mean? Let’s consider a class called Student, which is kind of an empty class with no member variables or methods. Suppose if you had to invoke the following statements on this class.

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

Now in meta object programming, even though the class does not have the member variable Name or the method Display(), the above code will still work.

How can this work? Well, for this to work out, one has to implement the GroovyInterceptable interface to hook into the execution process of Groovy. Following are the methods available for this interface.

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

So in the above interface description, suppose if you had to implement the invokeMethod(), it would be called for every method which either exists or does not exist.

Missing Properties

So let’s look an example of how we can implement Meta Object Programming for missing Properties. The following keys things should be noted about the following code.

The class Student has no member variable called Name or ID defined.

The class Student implements the GroovyInterceptable interface.

There is a parameter called dynamicProps which will be used to hold the value of the member variables which are created on the fly.

The methods getproperty and setproperty have been implemented to get and set the values of the property’s of the class at runtime.

Live Demo

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]
   } 
} 

The output of the following code would be −

Joe 
1

Missing methods

So let’s look an example of how we can implement Meta Object Programming for missing Properties. The following keys things should be noted about the following code −

The class Student now implememts the invokeMethod method which gets called irrespective of whether the method exists or not.

Live Demo

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"
   }
}

The output of the following codewould be shown below. Note that there is no error of missing Method Exception even though the method Display does not exist.

Joe 
1 

Metaclass

This functionapty is related to the MetaClass implementation. In the default implementation you can access fields without invoking their getters and setters. The following example shows how by using the metaClass function we are able to change the value of the private variables in the class.

Live Demo

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";
	
   pubpc String getName() {
      return this.name;
   } 
}

The output of the following code would be −

Joe 
Mark

Method Missing

Groovy supports the concept of methodMissing. This method differs from invokeMethod in that it is only invoked in case of a failed method dispatch, when no method can be found for the given name and/or the given arguments. The following example shows how the methodMissing can be used.

Live Demo

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"
   }  
}

The output of the following code would be −

Joe 
1 
Missing method 

Previous Page Print Page Next Page   Advertisements