Scala近期正式發(fā)布了2.8版本，這門優(yōu)秀的編程語言將簡(jiǎn)潔、清晰的語法與面向?qū)ο蠛秃瘮?shù)式編程范式無縫融合起來，同時(shí)又完全兼容于Java，這樣Scala就能使用Java開發(fā)者所熟知的Java API和眾多的框架了。在這種情況下，我們可以通過Scala改進(jìn)并簡(jiǎn)化現(xiàn)有的Java框架。此外，Scala的學(xué)習(xí)門檻也非常低，因?yàn)槲覀兛梢暂p松將其集成到“眾所周知的Java世界中”。

51CTO推薦專題：Scala編程語言

本文將介紹如何通過Scala整合當(dāng)今世界最為流行的框架之一Spring。Spring不僅支持如依賴注入和面向方面的編程等高效的編程范式，還提供了大量的膠水代碼與Hibernate、Toplink等框架以及JEE環(huán)境交互，后者更是可以保證Scala能平滑地融入到企業(yè)當(dāng)中，毫無疑問，這是Spring的成功所在。

為了清楚地闡釋Scala與Spring的整合原理，本文將使用一個(gè)簡(jiǎn)單的示例應(yīng)用。這個(gè)應(yīng)用會(huì)使用到Scala、Spring和Hibernate/JPA，其領(lǐng)域模型如下圖所示：

該領(lǐng)域模型展示了一個(gè)簡(jiǎn)化的社交網(wǎng)絡(luò)應(yīng)用：人與人之間可以彼此鏈接起來。

第一步

后面的講解都將基于該領(lǐng)域模型。首先介紹如何實(shí)現(xiàn)一個(gè)泛型DAO，并通過Hibernate/JPA使用Scala為Person實(shí)體實(shí)現(xiàn)一個(gè)具體的DAO，該DAO的名字為PersonDao，里面封裝了CRUD操作。如下所示：

val p1 = new Person(“Rod Johnson”)   
val p2 = dao.findByName(“Martin Odersky”)   
p1.link(p2)  
personDao.save(p1) 

第二步

接下來介紹如何將Person實(shí)體轉(zhuǎn)換為一個(gè)“內(nèi)容豐富”的領(lǐng)域?qū)ο?，在調(diào)用link方法時(shí)，該對(duì)象內(nèi)部會(huì)使用NotificationService執(zhí)行額外的邏輯，這個(gè)服務(wù)會(huì)“神奇地”按需注入到對(duì)象中。下圖展示了這一切：

val p1 = Person(“Martin Odersky”) //the omission of the ‘new’ keyword is intentional   
val p2 = dao.findByName(“Rod Johnson”)   
p1.link(p2) //magic happens here  
personDao.save(p1)  

第三步

最后，本文將介紹Spring是如何從Scala的高級(jí)概念：特征（traits）中受益的。特征可以將內(nèi)容豐富的Person領(lǐng)域?qū)ο筠D(zhuǎn)換為羽翼豐滿的OO類，這個(gè)類能夠?qū)崿F(xiàn)所有的職責(zé)，包括CRUD操作。如下所示：

Person(“Martin Odersky”).save   

第一步：使用Scala、Spring和Hibernate/JPA實(shí)現(xiàn)DAO

需求

毫無疑問，DAO在設(shè)計(jì)上應(yīng)該有一個(gè)泛型DAO和一個(gè)針對(duì)Person實(shí)體的具體DAO。泛型DAO中應(yīng)該包含基本的CRUD方法，如save、remove、findById和findAll等。由于是泛型，因此它處理的是類型而不是具體的實(shí)體實(shí)現(xiàn)?？偟膩碚f，這個(gè)泛型DAO具有如下的接口定義：

trait GenericDao[T] {  
      def findAll():List[T]  
      def save(entity:T):T   
      def remove(entity:T):Unit  
      def findById(id:Serializable):T  
} 

Person實(shí)體類的具體DAO應(yīng)該增加一個(gè)特定于Person實(shí)體的finder方法：

trait PersonDao extends GenericDao[Person] {  
  def findByName(name:String):List[Person]  
  //more finders here…  
}  

我們需要考慮如下具體的實(shí)現(xiàn)細(xì)節(jié)以便利用上Scala提供的眾多富有成效的特性：

◆關(guān)于集合：雖然底層的JPA實(shí)現(xiàn)并不知道所謂的Scala集合，但DAO接口返回的卻是Scala集合類型（scala.List）而不是Java集合。因?yàn)镾cala集合要比Java集合強(qiáng)大的多，因此DAO方法的調(diào)用者非常希望方法能夠返回Scala集合。這樣，我們需要將JPA返回的Java集合平滑地轉(zhuǎn)換為Scala集合。

◆關(guān)于回調(diào)：Spring用于粘合JPA、JMS等框架的大多數(shù)膠水代碼都是基于模板模式，比如JpaTemplate、JmsTemplate等。雖然這些模板通過一些便捷的方法在一定程度上隱藏了底層框架的復(fù)雜性，但很多時(shí)候我們還是不可避免地要直接訪問底層的實(shí)現(xiàn)類，如EntityManager、JmsSession等。在這種情況下，Spring通過JpaCallback等回調(diào)類來實(shí)現(xiàn)我們的愿望。回調(diào)方法doIn…(..)唯一的參數(shù)就是指向?qū)崿F(xiàn)類的引用，比如EntityManager。下面的示例闡述了這種編程模型：

 
 
jpaTemplate.execute(new JpaCallback() {  
 public Object doInJpa(EntityManager em) throws PersistenceException {  
 //… do something with the EntityManager  
 return null;  
}  
});  

上面的代碼有兩點(diǎn)值得我們注意：首先，匿名內(nèi)部回調(diào)類的實(shí)例化需要大量的樣板代碼。其次，還有一個(gè)限制：匿名內(nèi)部類JpaCallback之外的所有參數(shù)都必須是final的。如果從Scala的視角來看待這種回調(diào)模式，我們發(fā)現(xiàn)里面充斥的全都是某個(gè)“函數(shù)”的繁瑣實(shí)現(xiàn)。我們真正想要的只是能夠直接訪問EntityManager而已，并不需要匿名內(nèi)部類，而且還得實(shí)現(xiàn)里面的doInJpa(…)方法，這有點(diǎn)太小題大作了。換句話說，我們只需要下面這一行足矣：

 
 
jpaTemplate.execute((em:EntityManager) => em.createQuery(…)// etc. );   

問題在于如何通過優(yōu)雅的方式實(shí)現(xiàn)這個(gè)功能。

◆關(guān)于getter和setter：使用了Spring bean的類至少要有一個(gè)setter方法，該方法對(duì)應(yīng)于特定bean的名稱。毫無疑問，這些setter是框架所需的樣板代碼，如果不使用構(gòu)造器注入也能避免這一點(diǎn)豈不美哉？

實(shí)現(xiàn)

如果用Scala實(shí)現(xiàn)泛型與Person DAO，那么上面提到的一切問題都將迎刃而解，請(qǐng)看：

object GenericJpaDaoSupport {  
   
   implicit def jpaCallbackWrapper[T](func:(EntityManager) => T) = {  
    new JpaCallback {  
      def doInJpa(session:EntityManager ) = func(session).asInstanceOf[Object]}  
    }   
}  
 
import Scala.collection.jcl.Conversions._  
class GenericJpaDaoSupport[T](val entityClass:Class[T]) extends JpaDaoSupport with GenericDao[T] {  
 
      def findAll():List[T] = {   
            getJpaTemplate().find("from " + entityClass.getName).toList.asInstanceOf[List[T]]  
      }  
 
      def save(entity:T) :T = {  
        getJpaTemplate().persist(entity)  
        entity  
      }  
 
      def remove(entity:T) = {  
        getJpaTemplate().remove(entity);          
      }  
 
      def findById(id:Serializable):T = {  
        getJpaTemplate().find(entityClass, id).asInstanceOf[T];  
      }  
}  
 
class JpaPersonDao extends GenericJpaDaoSupport(classOf[Person]) with PersonDao {  
       
        def findByName(name:String) = { getJpaTemplate().executeFind( (em:EntityManager) => {  
            val query = em.createQuery("SELECT p FROM Person p WHERE p.name like :name");  
            query.setParameter("name", "%" + name + "%");  
            query.getResultList();  
      }).asInstanceOf[List[Person]].toList  
      }  
}  

使用：

class PersonDaoTestCase extends AbstractTransactionalDataSourceSpringContextTests {  
    @BeanProperty var personDao:PersonDao = null 
      
    override def getConfigLocations() = Array("ctx-jpa.xml", "ctx-datasource.xml")  
   
    def testSavePerson {  
        expect(0)(personDao.findAll().size)  
        personDao.save(new Person("Rod Johnson"))  
        val persons = personDao.findAll()  
        expect(1)( persons size)  
        assert(persons.exists(_.name ==”Rod Johnson”))  
    }  
} 

接下來解釋上面的代碼是如何解決之前遇到的那些問題的：

關(guān)于集合

Scala 2.7.x提供了一個(gè)方便的Java集合到Scala集合的轉(zhuǎn)換類，這是通過隱式轉(zhuǎn)換實(shí)現(xiàn)的。上面的示例將一個(gè)Java list轉(zhuǎn)換為Scala list，如下代碼所示：

導(dǎo)入Scala.collection.jcl.Conversions類的所有方法：

import Scala.collection.jcl.Conversions._  

這個(gè)類提供了隱式的轉(zhuǎn)換方法將Java集合轉(zhuǎn)換為對(duì)應(yīng)的Scala集合“包裝器”。對(duì)于java.util.List來說，Scala會(huì)創(chuàng)建一個(gè)Scala.collection.jcl.BufferWrapper。

調(diào)用BufferWrapper的toList()方法返回Scala.List集合的一個(gè)實(shí)例。

下面的代碼闡述了這個(gè)轉(zhuǎn)換過程：

def findAll() : List[T]  = {   
    getJpaTemplate().find("from " + entityClass.getName).toList.asInstanceOf[List[T]]  
} 

總是手工調(diào)用“toList”方法來轉(zhuǎn)換集合有些麻煩。幸好，Scala 2.8（在本文撰寫之際尚未發(fā)布最終版）將會(huì)解決這個(gè)瑕疵，它可以通過scala.collection.JavaConversions類將Java轉(zhuǎn)換為Scala，整個(gè)過程完全透明。

關(guān)于回調(diào)

可以通過隱式轉(zhuǎn)換將Spring回調(diào)輕松轉(zhuǎn)換為Scala函數(shù)，如GenericJpaDaoSupport對(duì)象中所示：

 
 
implicit def jpaCallbackWrapper[T](func:(EntityManager) => T) = {  
    new JpaCallback {  
def doInJpa(session:EntityManager ) = func(session).asInstanceOf[Object]}  
}  

借助于這個(gè)轉(zhuǎn)換，我們可以通過一個(gè)函數(shù)來調(diào)用JpaTemplate的execute方法而無需匿名內(nèi)部類JPACallback了，這樣就能直接與感興趣的對(duì)象打交道了：

jpaTemplate.execute((em:EntityManager) => em.createQuery(…)// etc. ); 

這么做消除了另一處樣板代碼。

關(guān)于getter和setter

默認(rèn)情況下，Scala編譯器并不會(huì)生成符合JavaBean約定的getter和setter方法。然而，可以通過在實(shí)例變量上使用Scala注解來生成JavaBean風(fēng)格的getter和setter方法。下面的示例取自上文的PersonDaoTestCase：

import reflect._  
@BeanProperty var personDao:PersonDao = _ 

@BeanProperty注解告訴Scala編譯器生成setPersonDao(…)和getPersonDao()方法，而這正是Spring進(jìn)行依賴注入所需的。這個(gè)簡(jiǎn)單的想法能為每個(gè)實(shí)例變量省掉3～6行的setter與getter方法代碼。

第二步：按需進(jìn)行依賴注入的富領(lǐng)域?qū)ο?/strong>

class Person   
{     @BeanProperty var notificationService:NotificationService = _    def link(relation:Person) =   
{       relations.add(relation)       notificationService.nofity(PersonLinkageNotification(this, relation))      
}     //other code omitted for readability   
  }    

 public class RichDomainObjectFactory implements BeanFactoryAware   
{         
pritic RichDomainObjectFactory singleton = new   
RichDomainObjectFactory();              
public static RichDomainObjectFactory autoWireFactory()   
{           
 return singleton;        
}   
public void autowire(Object instance)   
{            
factory.autowireBeanProperties(instance)  
}         
public void setBeanFactory(BeanFactory factory) throws BeansException {            
this.factory = (AutowireCapableBeanFactory) factory;       
 }         
 }   

<bean class="org.jsi.di.spring.RichDomainObjectFactory" factory-method="autoWireFactory"/> 

class DependencyInjectionInterceptor extends EmptyInterceptor {  
    override def onLoad(instance:Object, id:Serializable, propertieValues:Array[Object],propertyNames:Array[String], propertyTypes:Array[Type]) = {  
      RichDomainObjectFactory.autoWireFactory.autowire(instance)  
      false  
   }  
} 

<persistence-unit name="ScalaSpringIntegration" transaction-type="RESOURCE_LOCAL"> 
     <provider>org.hibernate.ejb.HibernatePersistence</provider> 
     <property name="hibernate.ejb.interceptor"                             value="org.jsi.domain.jpa.DependencyInjectionInterceptor" />   
     </properties> 
     <!-- more properties here--> 
</persistence-unit> 

import org.jsi.di.spring.RichDomainObjectFactory._  
object Person {  
    def apply(name:String) = {  
       autoWireFactory.autowire(new Person(name))  
    }  
} 

trait JpaPersistable[T] extends JpaDaoSupport  {  
   def getEntity:T;  
 
   def findAll():List[T] = {   
        getJpaTemplate().find("from " + getEntityClass.getName).toList.asInstanceOf[List[T]]     
   }  
 
   def save():T = {  
       getJpaTemplate().persist(getEntity)  
       getEntity  
   }  
 
   def remove() = {  
       getJpaTemplate().remove(getEntity);          
   }  
        
   def findById(id:Serializable):T = {  
        getJpaTemplate().find(getEntityClass, id).asInstanceOf[T];  
   }  
   //…more code omitted for readability        
}  

trait JpaPersistable[T] extends JpaDaoSupport  {  
   def getEntity:T;  
 
   def findAll():List[T] = {   
        getJpaTemplate().find("from " + getEntityClass.getName).toList.asInstanceOf[List[T]]     
   }  
 
   def save():T = {  
       getJpaTemplate().persist(getEntity)  
       getEntity  
   }  
 
   def remove() = {  
       getJpaTemplate().remove(getEntity);          
   }  
        
   def findById(id:Serializable):T = {  
        getJpaTemplate().find(getEntityClass, id).asInstanceOf[T];  
   }  
   //…more code omitted for readability        
}  

trait JpaPersistable[T] extends JpaDaoSupport  {  
def getEntity:T  
        
def remove() = {  
   getJpaTemplate().remove(getEntity);          
}  
//…more code omitted for readability  
) 

class Person extends JpaPersistable[Person] with java.io.Serializable {  
 
  def getEntity = this 
  //…more code omitted for readability  
}  

Person(“Martin Odersky”).save