At Jobster, we are currently developing a rapid prototyping package that integrates the
JRuby dynamic language with the
Spring application framework. This post provides an introduction via examples.
The goals of the project are to permit rapid innovation and iteration, full reuse of our existing Spring and Hibernate business logic and objects, and a smooth transition from prototype to production code.
We were inspired by many of the benefits and philosophy of
Ruby on Rails, including avoiding configuration files and compilation. Make a change, and you’ll see it immediately. At the same time, if you’re already commited to Spring, the package doesn’t require you to learn a new framework or abandon your existing investment in Spring. The total size of the package is less than a 1000 lines, so it’s small and easily integrated into existing projects.
The key part of the system is a Spring controller that instantiates a JRuby script engine and executes a JRuby script to define the controller and the model. The view is provided by a standard JSP file. If the JRuby controller is replaced by a Java one, the view can be used as-is with no changes.
Hello World
The simplest possible example consists of a JRuby script “hello.rb” which returns a model object and a JSP view “hello.jsp” which uses that model. To try the example, I just need to drop these two files into the “rad” directory on my Tomcat server. No compilation, configuration files, or server restarts are required.
hello.rb
{ ‘greeting’ => ‘Hello world’}
hello.jsp
<html>
${command[’greeting’]}
</html>
Notice that rather than defining an explicit controller class, the script simply returns a model object. This is a shortcut for rapid prototyping. Equivilantly, we could have explicitly defined a controller object as follows:
hello.rb
class DemoController
def getModel(request)
{ ‘greeting’ => ‘Hello world’}
end
end
DemoController.new()
Reusing Spring Beans
Here’s a more interesting example that reuses business logic from a Spring bean implemented in Java. ($context represents the Spring application context.) Thanks to the magic of JRuby, we can interact and create Java objects just as easily as Ruby ones.
location.rb
locationCalculator = $context.getBean(’locationCalculator’)
{’locations’ => locationCalculator.getPointMatches(’seattle’)}
Hibernate Queries
The package also supports Hibernate. The follow example uses Hibernate to fetch a list of company objects starting with a given letter. Note that the query returns full fledged Java objects with behavior, not just data.
hibernate.rb
s = $request.getParameter(’s’)
companies = $helper.queryHibernate(”from jobster.model.Company where name>=?”, [s])
{’companies’ => companies, ‘label’ => “Companies starting with #{s}”}
The corresponding JSP view uses standard Spring conventions and could be used without changes with a Java controller.
hibernate.jsp
<div class=”left pad”>
<div class=”bold”>Companies: ${command.label}</div>
<ol>
<c:forEach var=”company” items=”${command.companies}”>
<li> ${company.name} <br />
</li></c:forEach>
</ol>
</div>
onSubmit Handlers
Our final example is a simple calculator controller. It implements an onSubmit handler to run business logic (computing the calculation) when the user submits the form and choose a new result view.
calculator.rb
class CalculatorController
def getModel(request)
{’x’ => 2, ‘y’ => 2}
end
def onSubmit(request, response, form, errors)
form[’total’] = form[’x'].to_i + form[’y'].to_i
form[’viewName’] = ‘/rad/calculator_results’
return form
end
end
CalculatorController.new()
Download
Read More and Download
