GR8Conf 2009: Groovy Usage Patterns by Dierk König

Seven Groovy usage patterns
for Java developers

Dierk König
dierk.koenig@canoo.com

søndag den 17. maj 2009

Welcome!

Dierk König
Canoo fellow, www.canoo.com
Rich Internet Applications

Committer to Groovy and Grails
Author: Groovy in Action


The 7 usage patterns

• Super Glue
• Liquid Heart
• Keyhole Surgery
• Smart Configuration
• Unlimited Openness
• House-Elf Scripts
• Prototype

Examples in Groovy


#1 Super Glue

• Build application from existing building blocks

• Java makes perfect infrastructure:
middleware, frameworks, widget sets, services
• Scripting makes a flexible (agile) applikation layer:
views und controller
• Grails, GSP, JBoss Seam, WebWork, Struts 2 Actions,...
• Example: combination of XML parser, Java networking
and Swing widget set in order to build a standard RSS
feed reader


Super Glue example: RSS Reader
def url ='http://www.groovyblogs.org/feed/rss'
def items = new XmlParser().parse(url).channel.item
def cols = 'pubDate title description'.tokenize()

groovy.swing.SwingBuilder.build {
frame(id:'f', title: 'Groovy Blogs', visible:true) {
scrollPane {
table {
tableModel(list: items) {
cols.each { col ->
closureColumn header: col, read: { it[col].text() }
}}}}}
f.pack()
}


#2 Liquid Heart

• Externalize business models

• Given application structure in Java
• Allow to learn about the business:
keep entities, relations, and behaviour flexible through
scripting
• Usages: Spring beans, JBoss components,rule engines
(groovyrules.dev.java.net, JSR-94), Grails,
enterprise risk management for world-leading insurances

• Example: calculation rules for bonus allocation


Liquid Heart example: bonus allocation
revenue = employee.revenue
switch(revenue / 1000) {
case 0..100 : return revenue * 0.04
case 100..200 : return revenue * 0.05
case {it > 200} : bonusClub.add(employee)
return revenue * 0.06
}

Binding binding = new Binding();
binding.setVariable("employee", employee);
binding.setVariable("bonusClub", bonusClub);
GroovyShell shell = new GroovyShell(binding);
File script = new File(filename);
float bonus = (float) shell.evaluate(script);


#3 Keyhole Surgery

• Minimal-invasive surgery "in vivo"

• Lots of need for runtime inspection
and modifications
• Ad-hoc queries are not foreseeable
• "Backdoor" for the live execution of scripts
• Particularly useful for
product support, failure analysis, hot fixes, emergencies
• Usages: Oracle JMX Beans, XWiki, SnipSnap, Ant, Canoo
WebTest, Grails Console, GAE, ULC Admin Console
• Example: a live Groovy Servlet


Surgery through a Servlet keyhole

Problems with the database connection?

def ds = Config.dataSource
ds.connection = new DebugConnection(ds.connection)

Remove malicious users from the servlet context

users = servletContext.getAttribute('users')
bad = users.findAll { user -> user.cart.items.any { it.price < 0 } }
servletContext.setAttribute('users', users - bad)


#4 Smart Configuration

• Enhance configuration with logic

• Replace dumb XML configs
• Use references, loops, conditionals, inheritance, execution
logic, runtime environment adaption, ...
• Typical scenario for domain specific languages (DSLs),
Groovy Builder, Grails plugins, product customization,
Groovy for OpenOffice:
Community Innovation Program Silver Award Winner

• Example: Navis SPARCS N4


Smart Config example: container routing

def ensureEvent = { change ->
if (! event.getMostRecentEvent(change) {
event.postNewEvent(change)
}
}

switch (event.REROUTE_CTR) {
case 'OutboundCarrierId' :
ensureEvent('CHANGE_VSL')
break
case 'POD' :
if (! event.CHANGE_VSL) ensureEvent('CHANGE_POD')
break
}


#5 Unlimited Openness

• Every line of code may be changed

• It's impossible (and not desirable!)
to design for every possible future
requirement
• Allow for easily changing the code
without tedious setup for compilation
and deployment
• Follow the lessons of Perl, PHP, Python,...

• Example: groovyblogs.org, PillarOne


#6 House Elf

• Delegate the housework

• Build automation, continuous integration, deployment,
installer, service monitoring, reports, statistics, automated
documentation, functional tests, HTML scraping, Web
remote control, XML-RPC, WebServices
• Usages with Ant, Maven, AntBuilder, Gant, Gradle, Canoo
WebTest, Grails scaffolding, ...

• Examples: hooking scripts into Ant


House Elf: musical Ant
<groovy>
import org.apache.tools.ant.*
import org.jfugue.*
project.addBuildListener(new PlayListener())
class PlayListener implements BuildListener {
def play = { new Player().play(new Pattern(it)) }
void buildStarted(event) {}
void buildFinished(event) { }
void messageLogged(event) { }
void targetStarted(event) { play("D E") }
void targetFinished(event) { play("C5maj") }
void taskStarted(event) {}
void taskFinished(event) {}
}
</groovy>


<groovy>
import org.jfugue.*
project.addBuildListener(new PlayListener())
class PlayListener implements BuildListener {


}
</groovy>


<groovy>
import org.jfugue.*



project.addBuildListener(player as BuildListener)
}
</groovy>


<groovy>
import org.jfugue.*


def player = [
targetStarted: { play("D E") },
targetFinished: { play("C5maj") }
]
}
</groovy>


<groovy>
import org.jfugue.*

def player = [
targetStarted : { play "D E" },
targetFinished : { play "C5maj" }
]
}
</groovy>


#7 Prototype

• Feasibility study on the target platform

• "Spikes" for technological or algorithmic ideas with more
expressiveness, quicker feedback, and enhanced analysis
capabilities
• Later port to Java is optional
• Usages: early user feedback about the domain model
through a functional Grails prototype,
algorithms for image manipulation

• Example: prime number disassembly


Prototype example: prime numbers
boolean isPrime(x) { return ! (2..<x).any { y -> x % y == 0 } }

int primeBelow(x) { (x..1).find { isPrime(it) } }

List primeFactors(x) {
if (isPrime(x)) return [x]
int p = primeBelow(x)
while (p > 1) {
if (x % p == 0) return [p, *primeFactors(x.intdiv(p))]
p = primeBelow(p-1)
}
}

for (n in 100..110) { println "$n : "+primeFactors(n)}


Prime numbers: counting modulo ops
class ModCountCategory {
static int count = 0
static int mod(Integer self, Integer argument) {
count++
return self - argument * self.intdiv(argument)
} }

use (ModCountCategory) {
for (n in 1000..1010) {
ModCountCategory.count = 0
factors = primeFactors(n)
println "$n : $factors".padRight(30) + "(in " +
"${ModCountCategory.count}".padLeft(5) + " steps)"
assert n == factors.inject(1){result, item -> result *= item }
} }


Pattern Summary

• Super Glue
• Liquid Heart
• Keyhole Surgery
• Smart Configuration
• Unlimited Openness
• House-Elf Scripts
• Prototype

Keep groovin' !


More
Information

• Groovy in Action groovy.canoo.com/gina
Manning, 2007, Foreword by James Gosling
König mit Glover, Laforge, King, Skeet
• groovy.codehaus.org, grails.org
groovyblogs.org, searchgroovy.org


Questions?

More patterns in the pipeline:

Lipstick
- API enhancements
Ghost
- generating invisible code

<your suggestion here>


GR8Conf 2009: Groovy Usage Patterns by Dierk König

More Related Content

What's hot (19)

Viewers also liked (9)

Similar to GR8Conf 2009: Groovy Usage Patterns by Dierk König (20)

More from GR8Conf (20)

Recently uploaded (20)

GR8Conf 2009: Groovy Usage Patterns by Dierk König