Scala on Stripes/Spring(II)

26 07 2009

Well the past chapter was very well received

Now we will continue with the DAO layer, and will learn more advanced Scala concepts

The DAO Layer

My friends know that I’m a “SQL Boy” I never need to learn ORM (I try many times, but the laziness beat me) so I’ll use Spring JDBC. If you don’t know this technology I’ll encourage you too take a look, this is one of the best parts of Spring. Spring JDBC take out the pain of JDBC in a very easy way, in fact I participate on a project where we migrate a bunch of Classic JDBC DAO’s for Spring DAO’s and the code was reduced in a 70%.


This class is a Support Class that extend SimpleJdbcDaoSupport to make more easy the work with Scala. In this class we are writing a little utility function in order to provide support for the methods with (Object… args) that SimpleJdbcTemplate have. Also we are writing some functions to wrap the SimpleJdbcTemplate; in a Real Case Scenario you need to write a lot of methods more

package com.simpletasks.dao.impl
import java.util.List
import org.springframework.jdbc.core.simple.{SimpleJdbcDaoSupport, ParameterizedRowMapper}
abstract class ScalaSimpleJdbcDaoSupport extends SimpleJdbcDaoSupport {
private def buildObjectArray(params: Any*): Array[Object] =[Object]).toArray
def queryForObject[T](sql: String, mapper: ParameterizedRowMapper[T], params: Any*): T =
getSimpleJdbcTemplate.queryForObject(sql, mapper, buildObjectArray(params: _*))
def query[T](sql: String, mapper: ParameterizedRowMapper[T], params: Any*): List[T] =
getSimpleJdbcTemplate.query(sql, mapper, buildObjectArray(params: _*))
def update(sql: String, params: Any*): Int =
getSimpleJdbcTemplate.update(sql, buildObjectArray(params: _*))

  • line 04 abstract: Same as Java
  • line 07 Any: Any is Scala as Object is a Java, all the Scala Classes including Basic Types are subclasses of Any
  • line 07 Repeated Parameters: The Asterisk (*) symbol is like Ellipsis/Varags (…) in Java. This means that you could add the parameters that you want, but is different in Java in some ways first of all, In Java you can call a method with an Array of the same type of the varargs argument, this isn’t possible in Scala; the second difference, In Java, in the method body the varargs argument is an Array, in Scala is a Seq. Seq is the base for a bunch of Collections in Scala, and provide some nice functions
  • line 07 Arrays: the Array in Scala is different from the Java Array; first of all the declaration type:
    In JavaString[]in ScalaArray[String]second, the access
    In JavamyArray[0]In ScalamyArray(0)Third, the implicit constructor
    In Java{0,1,2,3,4,5}In ScalaArray(0,1,2,3,4,5)
  • line 08 map function: the map function return a new Seq (remember that Scala is a OO/functional language, so you will be a lot of immutable classes like this) after applying some algorithm to all his members
  • line 08 High order functions:: A HOT feature, High order functions are lovely functions that take functions as parameters and/or return functions. (Geek Fun). In this case map take a function that will be applied in all the Seq’s members, (in our case, we are casting all the members to Object) this type of functions are very common in Scala Collections and produce a very neat and elegant code
  • line 08 The Placeholder strikes back: Our friend is representing the Seq member that we are casting.
  • line 08 Casting: The casting in Scala is a function invocation
  • line 08 Square Braces []: Most of the time that you’ll see Square Braces ([]) in Scala are around a Type, in fact this is the way that we define Type parameterization (Generics in Java) for that reason we declare Array[String] instead of String[]
  • line 08 (again) toArray function: toArray is a function that convert this little Seq in an Array (pretty evident), Look that I call this function without parenthesis.
  • line 10 Type parameterization [T]: This is the equivalent to <T> in Java, but Scala Type parameterization have enough power (and beautiful concepts like, variance, co-variance and contra-variance, I told you Scala is a funny language) too put Java Generics in shame (Martin Odersky, The Scala Father was the co-designer of Java Generics). But… sorry the whole power of Type Parameterization is outside of the scope of this humble tutorial.
  • line 13 : _* This is a little “syntactic hack”, if we call our function buildObjectArray with the params Seq, we are passing the Seq and not the Seq members. with : _*, we are passing the members one by one.

Well A lot of concepts for a simple class. This is all for now, in the next chapter we will use this class and learn about Traits, Bye, bye.




2 responses

7 08 2009
Ricardo Lima

Reading this post, it seems to me that when you are saying Set, you actually mean Seq (as in sequence).

7 08 2009


You’re right


Many Thanks

Leave a Reply

Fill in your details below or click an icon to log in: Logo

You are commenting using your account. Log Out /  Change )

Google+ photo

You are commenting using your Google+ account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )


Connecting to %s

%d bloggers like this: