Initial commit

Author: anonymous

.gitignore

@@ -0,0 +1,23 @@
+# Extracted from https://github.com/ulrich/macaron-factory/blob/master/.gitignore
+# Ignore all dotfiles...
+.*
+# except for .gitignore
+!.gitignore
+
+# Ignore Play! working directory #
+/db
+/eclipse
+/lib
+/log
+/logs/
+/modules
+/precompiled
+/project/project/
+/project/target/
+/target/
+/tmp
+test-result
+server.pid
+*.iml
+*.eml
+activator*.sbt

LICENSE

@@ -0,0 +1,13 @@
+Copyright 2013 Typesafe, Inc.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

README.md

@@ -0,0 +1,14 @@
+play-scala-spring-data-jpa
+====================
+
+A sample application demonstrating Play Framework using Spring Data JPA with Hibernate as persistence provider.
+
+Used technologies:
+
+* Play Framework 2.3.9
+* Scala
+* Spring Core 4
+* Spring Data JPA 4
+* Hibernate 4
+
+Based on the play-java version: [https://github.com/huntc/play-spring-data-jpa](https://github.com/huntc/play-spring-data-jpa)

activator.properties

@@ -0,0 +1,4 @@
+name=play-scala-spring-data-jpa
+title=Play Framework using Scala, Spring Data JPA
+description=A starter application with Play Framework, Scala and Spring Data JPA with Hibernate
+tags=playframework,scala,spring,jpa,hibernate

app/Global.scala

@@ -0,0 +1,76 @@
+import javax.persistence.{Persistence, EntityManagerFactory}
+
+import org.springframework.context.annotation.AnnotationConfigApplicationContext
+import org.springframework.orm.hibernate3.HibernateExceptionTranslator
+import org.springframework.orm.jpa.JpaTransactionManager
+import play.api.{Application, GlobalSettings}
+import org.springframework.context.annotation.Configuration
+import org.springframework.data.jpa.repository.config.EnableJpaRepositories
+import org.springframework.context.annotation.Bean
+
+/**
+ * Application wide behaviour. We establish a Spring application context for the dependency injection system and
+ * configure Spring Data.
+ */
+object Global extends GlobalSettings {
+
+  /**
+   * Declare the application context to be used. AnnotationConfigApplicationContext cannot be refreshed so we can
+   * only do this once. We tell the context what packages to scan and then to refresh itself.
+   */
+  val ctx = new AnnotationConfigApplicationContext
+//  ctx.scan("controllers", "services")
+//  ctx.refresh()
+
+  /**
+   * Sync the context lifecycle with Play's.
+   */
+  override def onStart(app: Application) {
+    super.onStart(app)
+
+    // AnnotationConfigApplicationContext can only be refreshed once, but we do it here even though this method
+    // can be called multiple times. The reason for doing during startup is so that the Play configuration is
+    // entirely available to this application context.
+    ctx.register(classOf[SpringDataJpaConfiguration])
+    ctx.scan("controllers", "models")
+    ctx.refresh
+
+
+    ctx.start()
+  }
+
+  /**
+   * Sync the context lifecycle with Play's.
+   * @param app
+   */
+  override def onStop(app: Application) {
+    // This will call any destruction lifecycle methods and then release the beans e.g. @PreDestroy
+    ctx.close
+
+    super.onStop(app)
+  }
+
+  /**
+   * Controllers must be resolved through the application context. There is a special method of GlobalSettings
+   * that we can override to resolve a given controller. This resolution is required by the Play router.
+   * @param controllerClass
+   * @tparam A
+   * @return
+   */
+  override def getControllerInstance[A](controllerClass: Class[A]): A = ctx.getBean(controllerClass)
+}
+@Configuration
+@EnableJpaRepositories(Array("models"))
+class SpringDataJpaConfiguration {
+  @Bean def entityManagerFactory: EntityManagerFactory = {
+    return Persistence.createEntityManagerFactory("default")
+  }
+
+  @Bean def hibernateExceptionTranslator: HibernateExceptionTranslator = {
+    return new HibernateExceptionTranslator
+  }
+
+  @Bean def transactionManager: JpaTransactionManager = {
+    return new JpaTransactionManager
+  }
+}

app/controllers/Application.scala

@@ -0,0 +1,22 @@
+package controllers
+
+import javax.inject.Inject
+import javax.inject.Named
+
+import models.{Person, PersonRepository}
+import play.api.mvc.{Action, Controller}
+
+/**
+ * The main set of web services.
+ */
+@Named
+class Application @Inject() (personRepository: PersonRepository) extends Controller {
+  def index = Action {
+    val person: Person = new Person
+    person.firstname = "Bruce"
+    person.surname = "Smith"
+    val savedPerson: Person = personRepository.save(person)
+    val retrievedPerson: Person = personRepository.findOne(savedPerson.id)
+    Ok(views.html.index.render("Found id: " + retrievedPerson.id + " of person/people"))
+  }
+}

app/models/Person.scala

@@ -0,0 +1,20 @@
+package models
+
+import javax.persistence.Entity
+import javax.persistence.GeneratedValue
+import javax.persistence.Id
+
+/**
+ * This declares a model object for persistence usage. Model objects are generally anaemic structures that represent
+ * the database entity. Behaviour associated with instances of a model class are also captured, but behaviours
+ * associated with collections of these model objects belong to the PersonRepository e.g. findOne, findAll etc.
+ * Play Java will synthesise getter and setter methods for us and therefore keep JPA happy (JPA expects them).
+ */
+@Entity
+class Person {
+  @Id
+  @GeneratedValue
+  var id: Long = _
+  var firstname: String = _
+  var surname: String = _
+}

app/models/PersonRepository.scala

@@ -0,0 +1,13 @@
+package models
+
+import org.springframework.data.repository.CrudRepository
+import javax.inject.Named
+import javax.inject.Singleton
+
+/**
+ * Provides CRUD functionality for accessing people. Spring Data auto-magically takes care of many standard
+ * operations here.
+ */
+@Named
+@Singleton
+trait PersonRepository extends CrudRepository[Person, java.lang.Long] {}

app/views/index.scala.html

@@ -0,0 +1,7 @@
+@(message: String)
+
+@main("Welcome to Play 2.3") {
+    
+    @play20.welcome(message)
+    
+}

app/views/main.scala.html

@@ -0,0 +1,15 @@
+@(title: String)(content: Html)
+
+<!DOCTYPE html>
+
+<html>
+    <head>
+        <title>@title</title>
+        <link rel="stylesheet" media="screen" href="@routes.Assets.at("stylesheets/main.css")">
+        <link rel="shortcut icon" type="image/png" href="@routes.Assets.at("images/favicon.png")">
+        <script src="@routes.Assets.at("javascripts/jquery-1.9.0.min.js")" type="text/javascript"></script>
+    </head>
+    <body>
+        @content
+    </body>
+</html>

build.sbt

@@ -0,0 +1,21 @@
+name := "play-scala-spring-data-jpa"
+
+version := "1.0-SNAPSHOT"
+
+libraryDependencies ++= Seq(
+    javaJpa,
+//    "org.springframework" % "spring-context" % "3.2.2.RELEASE",
+    "javax.inject" % "javax.inject" % "1",
+    "org.springframework.data" % "spring-data-jpa" % "1.8.0.RELEASE",
+    "org.springframework" % "spring-core" % "4.1.4.RELEASE",
+    "org.hibernate" % "hibernate-core" % "4.3.9.Final",
+    "org.hibernate" % "hibernate-entitymanager" % "4.3.9.Final",
+//    "org.mockito" % "mockito-core" % "1.9.5" % "test",
+//    "mysql" % "mysql-connector-java" % "5.1.35"
+    "com.h2database" % "h2" % "1.4.187"
+)
+
+lazy val root = (project in file(".")).enablePlugins(PlayScala)
+
+// Possibly causes the error java.util.concurrent.TimeoutException: Futures timed out after [300000 milliseconds]. Disable if so.
+fork in run := true

conf/META-INF/persistence.xml

@@ -0,0 +1,16 @@
+<persistence xmlns="http://java.sun.com/xml/ns/persistence"
+             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+             xsi:schemaLocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd"
+             version="2.0">
+
+    <persistence-unit name="default" transaction-type="RESOURCE_LOCAL">
+        <provider>org.hibernate.ejb.HibernatePersistence</provider>
+        <non-jta-data-source>DefaultDS</non-jta-data-source>
+        <properties>
+            <!--<property name="hibernate.dialect" value="org.hibernate.dialect.MySQL5InnoDBDialect"/>-->
+            <property name="hibernate.dialect" value="org.hibernate.dialect.H2Dialect"/>
+            <property name="hibernate.hbm2ddl.auto" value="update"/>
+        </properties>
+    </persistence-unit>
+
+</persistence>

conf/application.conf

@@ -0,0 +1,71 @@
+# This is the main configuration file for the application.
+# ~~~~~
+
+# Secret key
+# ~~~~~
+# The secret key is used to secure cryptographics functions.
+# If you deploy your application to several instances be sure to use the same key!
+application.secret="GL/hbPrxueeoWtuqp^Z0P_lSs8wKDmuRiYfApHQQ]qDtRbxCebbJ[Jt/Hm?L8HoB"
+
+# The application languages
+# ~~~~~
+application.langs="en"
+
+# Global object class
+# ~~~~~
+# Define the Global object class for this application.
+# Default to Global in the root package.
+# application.global=Global
+
+# Router 
+# ~~~~~
+# Define the Router object to use for this application.
+# This router will be looked up first when the application is starting up,
+# so make sure this is the entry point. 
+# Furthermore, it's assumed your route file is named properly. 
+# So for an application router like `conf/my.application.Router`,
+# you may need to define a router file `my.application.routes`.
+# Default to Routes in the root package (and `conf/routes`)
+# application.router=my.application.Routes
+
+# Database configuration
+#
+db.default.driver=org.h2.Driver
+#db.default.driver=com.mysql.jdbc.Driver
+db.default.url="jdbc:h2:mem:play"
+#db.default.url="jdbc:mysql://localhost:3306/my-database-name"
+#db.default.user="my-username...."
+#db.default.password="my-password...."
+db.default.jndiName=DefaultDS
+
+# Evolutions
+# ~~~~~
+# You can disable evolutions if needed
+evolutionplugin=disabled
+
+# Logger
+# ~~~~~
+# You can also configure logback (http://logback.qos.ch/), by providing a logger.xml file in the conf directory .
+
+# Root logger:
+logger.root=INFO
+
+# Logger used by the framework:
+logger.play=INFO
+
+# Logger provided to your application:
+logger.application=DEBUG
+
+# Configure our user-code thread pool to something similar to servlets
+play {
+  akka {
+    actor {
+      default-dispatcher = {
+        fork-join-executor {
+          parallelism-factor = 1.0
+          parallelism-max = 200
+        }
+      }
+    }
+  }
+}

conf/evolutions/default/1.sql

@@ -0,0 +1,10 @@
+# Routes
+# This file defines all application routes (Higher priority routes first)
+# ~~~~
+
+# Home page - we use the @controllers syntax here so that the router knows we are referring to a class. In turn it
+# will call on the GlobalSettings.getController method to resolve the actual controller instance.
+GET     /                           @controllers.Application.index
+
+# Map static resources from the /public folder to the /assets URL path
+GET     /assets/*file               controllers.Assets.at(path="/public", file)

conf/routes

@@ -0,0 +1 @@
+sbt.version=0.13.5

project/build.properties

@@ -0,0 +1,3 @@
+// This plugin adds forked run capabilities to Play projects which is needed for Activator.
+
+addSbtPlugin("com.typesafe.play" % "sbt-fork-run-plugin" % "2.3.9")

project/play-fork-run.sbt

@@ -0,0 +1,8 @@
+// Comment to get more information during initialization
+logLevel := Level.Warn
+
+// The Typesafe repository
+resolvers += "Typesafe repository" at "http://repo.typesafe.com/typesafe/releases/"
+
+// Use the Play sbt plugin for Play projects
+addSbtPlugin("com.typesafe.play" % "sbt-plugin" % "2.3.9")

project/plugins.sbt

@@ -0,0 +1,3 @@
+// This plugin represents functionality that is to be added to sbt in the future
+
+addSbtPlugin("org.scala-sbt" % "sbt-core-next" % "0.1.1")