Scala EJB

Service.scala

package edu.wvu.its.myaccess.core.service

import javax.ejb.Stateless
import javax.persistence._
import javax.persistence.criteria._
import scala.collection.JavaConversions._
import scala.reflect._

@Stateless
class SService {
  @PersistenceContext
  protected var em: EntityManager = _
  
  def create[T](t: T)(implicit tag: ClassTag[T]): T = {
    em persist t;
    em flush;
    em refresh t;
    t;
  }
  
  def find[T](id: Long)(implicit manifest: ClassTag[T]) = {
    em.find(manifest.runtimeClass, id).asInstanceOf[T];    
  }
  
  def find[T]()(implicit manifest: ClassTag[T]) = {
    em.createNamedQuery("findAll" + manifest.runtimeClass.getSimpleName).getResultList().asInstanceOf[List[T]];
  }
  
  def delete[T](id: Any)(implicit manifest: ClassTag[T]) = {
    val ref: Any = em.getReference(manifest.runtimeClass, id);
    em remove ref;
  }
  
  def update[T](entity: T): T = {
    em merge entity;
  }
  
  def findWithQuery[T](query: String):java.util.List[T] = {
    em.createQuery(query).getResultList.asInstanceOf[List[T]];
  }
  
  def findSingleWithNamedQuery[T](queryName: String):Option[T] = {
    try {
      Some(em.createNamedQuery(queryName).getSingleResult().asInstanceOf[T])
    } catch {
      case e: Exception => None
    }
  }
  
  def findSingleWithNamedQuery[T](queryName: String, parameters: Map[String, Object]):Option[T] = {
    val query: Query = em.createNamedQuery(queryName);
    parameters.entrySet().foreach { parameter => 
      query.setParameter(parameter.getKey, parameter.getValue);
    }
    try {
      Some(em.createNamedQuery(queryName).getSingleResult().asInstanceOf[T])
    } catch {
      case e: Exception => None
    }
  }
  
  def findWithNamedQuery[T](queryName: String):List[T] = {
    em.createNamedQuery(queryName).getResultList().asInstanceOf[List[T]];
  }
  
  def findWithNamedQuery[T](queryName: String, resultLimit: Int):List[T] = {
    em.createNamedQuery(queryName).setMaxResults(resultLimit).getResultList().asInstanceOf[List[T]];
  }
  
  def findWithNamedQuery[T](queryName: String, parameters: Map[String, Object]):List[T] = {
    findWithNamedQuery(queryName, parameters, 0);
  }
  
  def findWithNamedQuery[T](queryName: String, parameters: Map[String, Object], resultLimit: Int):List[T] = {
    val query: Query = em.createNamedQuery(queryName);
    parameters.entrySet().foreach { parameter => 
      query.setParameter(parameter.getKey, parameter.getValue);
    }
    em.createNamedQuery(queryName).setMaxResults(resultLimit).getResultList().asInstanceOf[List[T]];
  }
}