GR8Conf US 2016 Recap

This was my first time attending GR8Conf and it was a really great experience. I primarily focus on Android Development now, but I enjoy dabbling in some API Development when I find the time. This conference was very inspiring and I plan on investigating many of the new things that I learned. Here are a few highlights of the event:

Storing JSON in External EhCache Server

If you would like to store JSON data in an external EhCache Server you would need to use either REST or SOAP calls.  The below example uses REST calls and the HTTPBuilder library.  It assumes that you have your EhCache Server running at the following location:
http://localhost:8080/ehcache/rest.

The name of the cache that I'm using in this example is just sampleCache.

def getCachedItem(key) {
    def uri = "http://localhost:8080/ehcache/rest/sampleCache/"
    def restClient = new RESTClient(uri)

    def res
    try {
      res = restClient.get(path:key)
    }
    catch (Exception e) {
      log.error("Error retrieving item from cache for this key: $key")
    }
    
    return res?.data
  }

  def putCachedItem(key, html) {
    def url = "http://localhost:8080/ehcache/rest/sampleCache/"

    try {
      def json = html as grails.converters.JSON

      def http = new HTTPBuilder(url)
      http.request(Method.PUT) { req ->
        uri.path = key
        send('application/json', grails.converters.JSON.parse(json?.toString()))
        
        response.'201' = { resp ->
          log.info("success in adding item to cache: ${resp.status}")
        }

        response.success = { resp, object ->
          log.info("success in adding item to cache: ${resp.status}")
        }

        response.failure = { resp ->
          log.error("error adding item to cache: ${resp.statusLine}")
        }
      }
    }
    catch (Exception e) {
      log.error("Error setting the cache for this key: $key")
    }
  }

Mocking Hibernate Criteria in Grails App

Testing is always a sore spot in many applications, and Grails is no exception, but mocking objects and methods is actually not as bad as you think. Here is a simple way to mock the Hibernate Criteria object that is available from Grails domain classes.

Example:
If this is the code that you want to test, and for this particular test you want to have no results, this how you would mock it out.

Code:


Test Code:


The key piece of code is the creation of the bookCriteria object, in this case it is a member of the test class that is why it is not declared locally in the function. However, you will notice that the bookCriteria is simply a HashMap that returns a empty list for the 'list' parameter. This way when testing 'c.list' a empty list will be returned. Simple hunh!

Using ConfigSlurper Scripts in Grails

In Java .properties files are used to configure an application. You can use similar notation to configure Grails applications as well.
A sample appName-config.groovy file that sets up the configuration items that we need.

abtesting {
   amazon = new Double(0.5)
   ebay = new Double(0.5)
}

A sample function in a controller that will access the configuration properties and modify them.

def abtesting = {
 def propValue = grailsApplication.config.abtesting.amazon
 println propValue


 grailsApplication.config.abtesting.amazon = new Double(1.0)
 println grailsApplication.config.abtesting.amazon
}

This code produces the following output:
>> 0.5
>> 1.0

Using Grails' JSON and HTML Builders

In order to generate JSON in groovy that can then be passed to a Grails controller you should use the JSONBuilder class. This class is part of the Grails util package. The code below demonstrates how to generate JSON and HTML.

Resulting JSON that is produced:

ResultSet {['text':'google', 'url':'http://www.google.com'], ...}

def writer = new StringWriter();
new grails.util.JSonBuilder(writer).json {
  ResultSet {
    links.each { link ->
      Links(text: link.text, url: link.url)
    }
  }
}
writer.toString()

This is the code to do the same with HTML, you would use the Groovy XML MarkupBuilder instead.

StringWriter w = new StringWriter()
def builder = new groovy.xml.MarkupBuilder(w)

builder.div (class: 'className'){
  links.each { link ->
    p {
      b 'Title: '
      builder.yield link.text
    }
  }
}
w.toString()

Resulting HTML that is produced:
<div class="className">
<p><b>Title: </b>google</p>
</div>

Rendering XML from a Grails Controller

I have been trying to render a simple XML file from a Grails Controller and I've found tons of blogs that provided the most complicated examples or examples that were too basic. After much tinkering around this is the code that will generate an XML file in the following format based on the items contained in the list.

<resultset>
<result>happy</result>
<result>sad</result>
<result>angry</result>
</resultset>

inside the Controller action...
def finalList = ['happy', 'sad', 'angry']

render(contentType: 'application/xml') {           
  resultSet(){               
     finalList.each { item ->                   
       result(item)               
     }           
   }         
}