Pollak D. Beginning Scala
Подождите немного. Документ загружается.
CHAPTER 7 ■ TRAITS AND TYPES AND GNARLY STUFF FOR ARCHITECTS
187
}
A Person is a Mammal with legs and knows its name:
class Person(val name: String) extends Mammal with
HasLegs with KnowsName {
def bodyTemperature: Double = 98.6
}
A Biker is a Person but may only be added to an Athlete:
trait Biker extends Person {
this: Athlete=>
def ride() {println("I'm riding my bike")}
}
And finally, let’s define some Genders:
trait Gender
trait Male extends Gender
trait Female extends Gender
We’ve defined a complex hierarchy of classes and traits. Let’s see what we can do with
these classes. First, let’s try to create a
Dog that’s also a Biker:
scala> val bikerDog = new Dog("biker") with Athlete with Biker
<console>:4: error: illegal inheritance; superclass Dog
is not a subclass of the superclass Person
of the mixin trait Biker
val bikerDog = new Dog("biker") with Athlete with Biker
Cool, the compiler enforced our rule about Bikers needing to be Persons. Let’s create
some valid
LivingThings. Please note that we can compose together different traits as part
of the object creation. So,
archer is an instance of a class that is a subclass of Dog that
implements
Athlete, Runner, and Male. The Scala compiler automatically creates this new,
anonymous class for you.
scala> val archer = new Dog("archer") with Athlete with Runner with Male
archer: Dog with Athlete with Runner with Male = $anon$1@18bbc98
19897ch07.fm Page 187 Monday, April 20, 2009 4:36 PM
188
CHAPTER 7
■ TRAITS AND TYPES AND GNARLY STUFF FOR ARCHITECTS
scala> val dpp = new Person("David") with Athlete with Biker with Male
dpp: Person with Athlete with Biker with Male = $anon$1@7b5617
scala> val john = new Person("John") with Athlete with Runner with Male
john: Person with Athlete with Runner with Male = $anon$1@cd927d
scala> val annette = new Person("Annette") with Athlete with Runner with
Female
annette: Person with Athlete with Runner with Female = $anon$1@1ec41c0
We’ve got a bunch of Animals. Let’s see what we can do with them:
scala> def goBiking(b: Biker) = println(b.name+" is biking")
goBiking: (Biker)Unit
scala> goBiking(dpp)
David is biking
What happens if we try to send Annette on a bike ride?
scala> goBiking(annette)
<console>:7: error: type mismatch;
found : Person with Athlete with Runner with Female
required: Biker
goBiking(annette)
19897ch07.fm Page 188 Monday, April 20, 2009 4:36 PM
CHAPTER 7 ■ TRAITS AND TYPES AND GNARLY STUFF FOR ARCHITECTS
189
This makes sense. The method requires a Biker, and Annette is not a Biker. However,
just as we can compose a class out of traits, we can require that a class implement more
than one trait in order to be the parameter to a method:
scala> def charityRun(r: Person with Runner) = r.run()
charityRun: (Person with Runner)Unit
The charityRun method can only be called with a parameter that is a subclass of Person
and also implements the
Runner trait.
scala> charityRun(annette)
I'm running
What if we try to call the method with a Runner that is not a Person?
scala> charityRun(archer)
<console>:7: error: type mismatch;
found : Dog with Athlete with Runner with Male
required: Person with Runner
charityRun(archer)
We can define the parameter in terms of traits. The womensRun method may only be
called with a parameter that’s both a
Runner and a Female:
scala> def womensRun(r: Runner with Female) = r.run()
womensRun: (Runner with Female)Unit
19897ch07.fm Page 189 Monday, April 20, 2009 4:36 PM
190
CHAPTER 7
■ TRAITS AND TYPES AND GNARLY STUFF FOR ARCHITECTS
scala> womensRun(annette)
I'm running
scala> val madeline = new Cat("Madeline") with Athlete with Runner with Female
madeline: Cat with Athlete with Runner with Female = $anon$1@11dde0c
scala> womensRun(madeline)
I'm running
In this way, we’ve modeled complex relationships. We’ve modeled things in a way that
you cannot model with Java. Scala’s compositional rules are very powerful tools for defining
very complex class hierarchies and for specifying the rules for composing classes as well
as the rules for passing parameters into methods. In this way, we can make sure that the
charityRun method can only be called with valid parameters rather than testing for param-
eter correctness at runtime and throwing an exception if the parameter is not correct. This
increased modeling flexibility combined with enhanced type safety gives the architect
another tool to help developers write correct code.
Types—It’s Beyond Generic
We’ve seen how Scala allows complex modeling and compile-time type checking that
allows us to build complex class hierarchies. What about things that make a developer’s
life easier? What about things that make a developer, a library consumer, think that Scala
is as easy and flexible as a scripting language? In this section, we’re going to write a data-
base abstraction layer that allows a developer to define a table mapping simply as follows:
class MyTable extends Table[MyTable] {
val table = "mytable"
val id = IntColumn("id")
val name = StringColumn("name")
val birthday = DateColumn("birthday")
19897ch07.fm Page 190 Monday, April 20, 2009 4:36 PM
CHAPTER 7 ■ TRAITS AND TYPES AND GNARLY STUFF FOR ARCHITECTS
191
type ColumnTypes = (Int, String, Date)
def columns = id ~ name ~ birthday
}
The class will allow type-safe queries such as this:
MyTable.findAll(By(MyTable.id, 33))
And the compiler will flag an error on a query such as this:
MyTable.findAll(By(MyTable.id, "33"))
Thus, the library consumer gets the benefits of type safety along with very lightweight
syntax for defining the mapping to the table and for defining queries. Scala’s type system
and type inferencer make this possible.
Table Code
Let’s look at the entire listing for the Query Builder (Listing 7-3). After that, we’ll slice and
dice it to understand how it works from the library-producer standpoint and see how it
makes a library consumer’s life easier.
Listing 7-3. Query Builder
import java.util.Date
import java.sql._
import scala.collection.mutable.ListBuffer
trait BasicColumn[TableType <: Table[TableType], T] {
def default: T
def name: String
def getField(rs: ResultSet): T
def set(st: PreparedStatement, offset: Int, value: T)
}
trait Table[MyType <: Table[MyType]] extends SuperTuple {
this: MyType =>
def table: String
type ColumnTypes <: Product
def columns: ColumnTypes with FieldProduct[MyType]
19897ch07.fm Page 191 Monday, April 20, 2009 4:36 PM
192
CHAPTER 7
■ TRAITS AND TYPES AND GNARLY STUFF FOR ARCHITECTS
trait MyColumn[T] extends BasicColumn[MyType, T] {
def ~[OT](p: MyColumn[OT]): MyTuple2[MyType, T, OT] = {
val col = this
new MyTuple2[MyType, T, OT](col.default, p.default) {
def fields = List(col, p)
def fieldProduct: (MyColumn[T], MyColumn[OT]) = (col, p)
}
}
}
case class IntColumn(name: String) extends MyColumn[Int] {
def default = 0
def set(st: PreparedStatement, offset: Int, value: Int) {
st.setInt(offset, value)
}
def getField(rs: ResultSet): Int = rs.getInt(name)
}
case class LongColumn(name: String) extends MyColumn[Long] {
def default = 0
def set(st: PreparedStatement, offset: Int, value: Long) {
st.setLong(offset, value)
}
def getField(rs: ResultSet): Long = rs.getLong(name)
}
case class StringColumn(name: String) extends MyColumn[String] {
def default = ""
def set(st: PreparedStatement, offset: Int, value: String) {
st.setString(offset, value)
}
def getField(rs: ResultSet): String = rs.getString(name)
}
case class DateColumn(name: String) extends MyColumn[Date] {
def default = new Date(0)
def set(st: PreparedStatement, offset: Int, value: Date) {
st.setDate(offset, new java.sql.Date(value.getTime))
}
def getField(rs: ResultSet): Date = rs.getDate(name)
}
19897ch07.fm Page 192 Monday, April 20, 2009 4:36 PM
CHAPTER 7 ■ TRAITS AND TYPES AND GNARLY STUFF FOR ARCHITECTS
193
def find[FT <: Product with FieldProduct[MyType]]
(cols: FT, query: QueryParam[MyType]*): List[FT#ReturnType] = {
val select = "SELECT "+cols.fields.map(f => table+"."+f.name).mkString(", ")
val by = query.flatMap{
case b @ By(_, _) => Some(b)
case _ => None
}.toList
val where = by match {
case Nil => ""
case xs => " WHERE "+xs.map(f => table+"."+
f.column.name+" = ?").mkString(" AND ")
}
val orderBy = query.flatMap{
case b @ OrderBy(_, _) => Some(b)
case _ => None
}.toList match {
case Nil => ""
case xs => " ORDER BY "+xs.map(f => table+"."+
f.column.name+
f.order.sql).mkString(", ")
}
using(getJDBCConnection) { conn =>
prepareStatement(conn, select + where + orderBy) { st =>
by.zipWithIndex.foreach{case (b, idx) => b.bind(st, idx + 1)}
executeQuery(st) {
cols.buildResult _
}
}
}
}
protected def getJDBCConnection: Connection
def using[T <: {def close(): Unit}, R](t: T)(f: T => R): R =
try {f(t)} finally {t.close()}
19897ch07.fm Page 193 Monday, April 20, 2009 4:36 PM
194
CHAPTER 7
■ TRAITS AND TYPES AND GNARLY STUFF FOR ARCHITECTS
protected def prepareStatement[T](conn: Connection, sql: String)
(f: PreparedStatement => T): T =
using(conn.prepareStatement(sql))(f)
protected def executeQuery[T](st: PreparedStatement)
(f: ResultSet => T): List[T] =
using(st.executeQuery){ rs =>
val ret = new ListBuffer[T]
while (rs.next) ret += f(rs)
ret.toList
}
}
trait QueryParam[TableType <: Table[TableType]]
case class OrderBy[TableType <: Table[TableType]]
(column: BasicColumn[TableType, _], order: SortOrder) extends
QueryParam[TableType]
sealed trait SortOrder {def sql: String}
case object Ascending extends SortOrder {def sql: String = " "}
case object Descending extends SortOrder {def sql = " DESC "}
case class By[TableType <: Table[TableType], T, PT]
(column: BasicColumn[TableType, T], param: PT)(implicit f: PT => T)
extends QueryParam[TableType] {
def bind(st: PreparedStatement, offset: Int): Unit = {
column.set(st, offset, param)
}
}
trait SuperTuple {
sealed trait FieldProduct[TableType <: Table[TableType]] {
def fields: List[BasicColumn[TableType, _]]
def fieldProduct: Product
def buildResult(rs: ResultSet): ReturnType
type ReturnType <: Product
}
19897ch07.fm Page 194 Monday, April 20, 2009 4:36 PM
CHAPTER 7 ■ TRAITS AND TYPES AND GNARLY STUFF FOR ARCHITECTS
195
abstract class MyTuple2[TableType <: Table[TableType],
A1, A2](a1: A1, a2: A2)
extends Tuple2[A1, A2](a1, a2) with FieldProduct[TableType] {
def fieldProduct: (BasicColumn[TableType, A1],
BasicColumn[TableType, A2])
type ReturnType = (A1, A2)
def buildResult(rs: ResultSet): ReturnType =
(fieldProduct._1.getField(rs),
fieldProduct._2.getField(rs))
def ~[OT](p: BasicColumn[TableType, OT]):
MyTuple3[TableType, A1, A2, OT] ={
val f = fields
val fp = fieldProduct
new MyTuple3[TableType, A1, A2, OT](this._1, this._2, p.default) {
val fields = f ::: List(p)
val fieldProduct = (fp._1, fp._2, p)
}
}
}
abstract class MyTuple3[TableType <: Table[TableType],
A1, A2, A3]
(a1: A1, a2: A2, a3: A3) extends
Tuple3[A1, A2, A3](a1, a2, a3) with FieldProduct[TableType] {
def buildResult(rs: ResultSet): ReturnType =
(fieldProduct._1.getField(rs),
fieldProduct._2.getField(rs),
fieldProduct._3.getField(rs))
type ReturnType = (A1, A2, A3)
def fieldProduct: (BasicColumn[TableType, A1],
BasicColumn[TableType, A2],
BasicColumn[TableType, A3])
def ~[OT](p: BasicColumn[TableType, OT]):
19897ch07.fm Page 195 Monday, April 20, 2009 4:36 PM
196
CHAPTER 7
■ TRAITS AND TYPES AND GNARLY STUFF FOR ARCHITECTS
MyTuple4[TableType, A1, A2, A3, OT] = {
val f = fields
val fp = fieldProduct
new MyTuple4[TableType, A1, A2, A3,
OT](
this._1, this._2, this._3, p.default) {
val fields = f ::: List(p)
val fieldProduct = (fp._1, fp._2, fp._3, p)
}
}
}
abstract class MyTuple4[TableType <: Table[TableType],
A1, A2, A3, A4]
(a1: A1, a2: A2, a3: A3, a4: A4) extends
Tuple4[A1, A2, A3, A4](a1, a2, a3, a4) with FieldProduct[TableType] {
def fieldProduct: (BasicColumn[TableType, A1],
BasicColumn[TableType, A2],
BasicColumn[TableType, A3],
BasicColumn[TableType, A4])
type ReturnType = (A1, A2, A3, A4)
def buildResult(rs: ResultSet): ReturnType =
(fieldProduct._1.getField(rs),
fieldProduct._2.getField(rs),
fieldProduct._3.getField(rs),
fieldProduct._4.getField(rs))
}
}
trait ConnectionSupplier {
protected def getJDBCConnection: Connection = null // do something better
}
class MyTable extends Table[MyTable] with ConnectionSupplier {
val table = "mytable"
val id = IntColumn("id")
val name = StringColumn("name")
val birthday = DateColumn("birthday")
19897ch07.fm Page 196 Monday, April 20, 2009 4:36 PM