如何配置Slick 3.0.0的Postgres DB（无论是与Hikari或没有）

Question

我有一个测试应用程序，与H2内存数据库工作正常。现在我正试着把它连接到我们真正的数据库。我要么得到一个内部Slick异常，要么得到一个“没有合适的驱动程序”异常，这取决于我的方法：

下面是我的简单测试（同样，在记忆中，它似乎工作得很好）：

"The glimple data model classes" should {
    "insert a glimple row in the database" in {
        val db = Database.forConfig("db.edb") // works on db.h2mem1
        val glimples = TableQuery[GPGlimpleModel]

        val insertGlimples = db.run(glimples += GPGlimple(None, None, 1, true, true, 1))

        val count = Await.result(insertGlimples, Duration.Inf)

        println(count)
        count must beEqualTo(1)
        ...

如果我打开连接池，如下所示：

db.edb = {
    driver = org.postgresql.Driver
    url = "jdbc:postgresql://db-server-1.hyrax.com:5444/CI_0"
    user = "xxx" // masked to protect the innocent
    password = "xxx" // masked to protect the innocent
    keepAliveConnection = true
    // connectionPool = disabled
}

我最终得到以下异常。在试图解释发生了什么时，我首先启用了一个连接池（如“connectionPool=enabled”或只是注释该行）。这导致了更多的问题和一个非常非常长的异常（如本文末尾所示）。

这一例外的主要原因是：

[错误][错误]java。lang.NoClassDefFoundError:com/zaxxer/hikari/HikariConfig[error]由java引起。lang.ClassNotFoundException:com。扎克塞尔。希卡里。HikariConfig

这对我来说毫无意义...因为同样，它在记忆中工作得很好。

这是构建。Postgres的sbt驱动线：

"org.postgresql" % "postgresql" % "9.4-1201-jdbc41",

以下是完全例外。。。我已经按照跟踪末尾的建议将其发布到github：

Answer 1

带有PGSimpleDataSource和指定连接池大小的我的配置：

myDb = {
  connectionPool = "HikariCP"
  dataSourceClass = org.postgresql.ds.PGSimpleDataSource
  properties = {
    url = "jdbc:postgresql://"${dbHostName}":"${dbPortNumber}"/"${dbName}
    user = "postgres"
    password = "1"
  }
  numThreads = 10
  minConnections = 10
  maxConnections = 50
  queueSize = 1000
}

Answer 2

我的工作示例：

应用形态

database {
  dataSourceClass = org.postgresql.ds.PGSimpleDataSource
  properties = {
    databaseName = "some_db"
    user = "local"
    password = "local"
  }
  numThreads = 10
}

建筑sbt

libraryDependencies ++= Seq(
  "com.typesafe.slick" %% "slick" % "3.0.0",
  "com.zaxxer" % "HikariCP" % "2.4.1",
  "org.postgresql" % "postgresql" % "9.4-1201-jdbc41",
  // ...
)

然后我就给你打电话

Database.forConfig("database")

使用Java7，Scala2.11。6和sbt 0.13。6.

Answer 3

一个在应用程序上具有基本用户的解决方案。形态

play.modules.enabled += "modules.DatabaseModule"

MyNameIs = {
  database = {
  driver = org.postgresql.Driver
  url = "jdbc:postgresql://localhost:5432/databasename"
  user = "postgreuser"
  password = ""
  numThreads = 10
  connectionTimeout = 5000
  validationTimeout = 5000
}

dispatcher {
  fork-join-executor {
    parallelism-factor = 2
    parallelism-max = 20
  }
}

在dir应用程序上，您可以创建如下数据库模块

import javax.inject.{Provider, Inject, Singleton}

import com.google.inject.AbstractModule
import com.typesafe.config.Config
import play.api.inject.ApplicationLifecycle
import play.api.{Configuration, Environment}
import slick.jdbc.JdbcBackend

import scala.concurrent.Future

class DatabaseModule(environment: Environment, configuration: Configuration)     
  extends AbstractModule {
override def configure(): Unit = {
  bind(classOf[Config]).toInstance(configuration.underlying)
  bind(classOf[slick.jdbc.JdbcBackend.Database]).toProvider(classOf[DatabaseProvider])
  bind(classOf[models.UserDAO]).asEagerSingleton()

  }
}

@Singleton
class DatabaseProvider @Inject() (config: Config, lifecycle: ApplicationLifecycle) extends Provider[slick.jdbc.JdbcBackend.Database] {

  private val db = slick.jdbc.JdbcBackend.Database.forConfig("MyNameIs.database", config)

  lifecycle.addStopHook { () =>
    Future.successful(db.close())
  }

  override def get(): JdbcBackend.DatabaseDef = db
}

在应用程序/模型：UserDAO

import java.sql.Date
import javax.inject.{Inject, Singleton}

import com.typesafe.config.Config
import slick.driver.PostgresDriver.api._
import scala.concurrent.Future
import scala.concurrent.ExecutionContext.Implicits.global

case class User(id: Option[Long] = None, name: String, firstname: String,    email: String, password: String, birthday: Option[Date] = None, signDate: Option[Date] = Some(new Date(System.currentTimeMillis)))

@Singleton
class UserDAO @Inject()(config: Config, db: Database) {


  private val users = TableQuery[Users]

  override def delete(ids: Long*): Future[Boolean] = {
    Future.sequence(for (id <- ids) yield {
      db.run(users.filter(_.id === id).delete).map(_ == 1)
    }).map {
      _.find(i => i == false) == None
    }
  }

  def insert(user: User): Future[Unit] = db.run(users += user).map{()}

  override def update(obj: User): Future[Boolean] = ???

  override def create(obj: User): Future[Boolean] = db.run(users += obj).map(_ == 1)

  override def all: Future[Seq[User]] = db.run(users.result)

  private class Users(tag: slick.lifted.Tag) extends Table[User](tag, "user") {


    type S = String
    type D = Date
    type L = Long
    // attribute name in table database
    def id = column[L](ID, O.AutoInc, O.PrimaryKey)

    def name = column[S](NAME)

    def password = column[S](PASSWORD)

    def firstname = column[S](FIRSTNAME)

    def email = column[S](EMAIL)

    def birthday = column[D](BIRTHDAY)

    def signDate = column[D](SIGN_DATE)

    override def * = (id.?, name, firstname, email, password, birthday.?, signDate.?) <> ((User.apply _)
  .tupled, User.unapply _)
  }

}

控制器Application.scala

@Singleton
class Application @Inject()(userdao: UserDAO) extends Controller { code } 

和路由文件：

# Home page
GET     /                           @controllers.Application.index