際際滷

Play2 Scalaを2定やっ
て僥んだこと

D3
��I參栖、互い室�g薦と�藺垉弔�UI/UXを冷匂に、弊の嶄に��､△襯稀`ビスを
伏み竃しているビズリ�`チ。
サ�`ビスの方が��えるにつれ、室�gの嫌がﾚがったため、そのスキルやノウハウ
を芙坪のみならず、
弊の嶄のエンジニアやデザイナ�`とも慌嗤すべく、
暴たちは仝D3�ディ�`キュ�`ブ�☆々というプロジェクトチ�`ムを羨ち貧げま
した。
D3では、たくさんのイベントや茶�氏を�_岸し、
弊のエンジニア?デザイナ�`と慌に、さらなる互みを朕峺します。
☆D3�DESIGNER & DEVELOPER DIVISION

徭失�B初
? 兆念�卅寒埼岻��
? ��I�プログラマ�`
? 幄塀氏芙ビズリ�`チインキュベ�`ションカンパニ�` スタンバイアプリ並�I何マネ�`ジャ�`
? 箸龍�徨工と柊�i、タイガ�`スの鮅�

書晩�すこと
? スタンバイの�B初
? 畠悶の�O�
? Slick3
? scalaz
? scalikeJDBC

スタンバイ
? https://jp.stanby.com
? 400嵐周參貧の箔繁をまとめて冥せる晩云恷寄�の
箔繁�碧�┘鵐献鵝�
? 二�I巷塀サイトや箔繁サイトのありとあらゆる箔
繁秤�鵑�修擦泙后�

スタンバイ?カンパニ�`
? https://stanby.co/
? スタンバイ?カンパニ�`は、�lでもかんたんに�o創
で箔繁を恬撹できるサ�`ビスです。
? 恬撹した箔繁はスタンバイに��dされます。
? また、魥謝澆肇船礇奪箸任笋蠅箸蠅鬚靴燭蝓�啝�
で中俊を佩うこともできます。

スタンバイアプリ
? ��d箔繁方は400嵐周參貧で晩云恷寄�。
? 1000參貧の箔繁?��サイトや二�Iサイトを罪僅�碧�
? 屎芙�Tからアルバイト?パ�`トまでのあらゆる�Pき圭やこだわり訳周で碧並を冥す
ことができます。
? 徭蛍のプロフィ�`ルを鞠�hしておくと、お糾や二�Iから碧並のお�Tいが曙きます。
? �d龍があれば、そのままお糾?二�Iの圭とチャットでやりとりをしていただき、音
苧泣などを�毫Xに�くことができます。
? そこで�Pいてみたいと房ったら、そのままチャットで中俊の晩殻�{屁をしたり、ス
タンバイアプリのビデオ宥��C嬬を聞えば、徭姙にいながらスマホで中俊もできま
す。

カンパニ�`アプリ
? たった3蛍 �o創で箔繁��d
? �Pきたいひとにスカウトを僕佚
? 魥爾�瓦燭蕕��蕕�

聞っている室�g(Client)
? Web
? HTML,CSS,JavaScript
? React,jQuery,Angular,TypeScript
? Android
? Java
? iOS
? Swift3

聞っている室�g(AWS)
? Scala(2.11.x)
? PlayFramework(2.3,2.5)
? MySQL(RDS)
? Redis,Memcache(ElastiCache)
? S3,SQS,SNS,Kinesis´

聞っている室�g(Firebase)
? RealTimeDatabase
? BigQuery
? ストレ�`ジ
? Remote Config

ア�`キテクチャ
(マイクロサ�`ビスの�蹌�
それぞれがRDSやCache、S3などを隔っています。
麿にも、バッチサ�`バ�`や、
砿尖鮫中喘のサ�`バ�`や、
ログ鹿�喘のサ�`バ�`があります

スタンバイ
? ElasticSeachから箔繁秤�鵑�碧�垢�
? クライアントはブラウザ(PC,Mobile)、Android、iOS
? ブラウザは�eサ�`バ�`
? ユ�`ザ�`の秤�鵑鮃楡蹐垢�
? 堕�s��碧��s、��E堕�s
? スカウトされるための秤��
? 箔繁ﾚ御を塘佚して借いでいます。
? Yahoo!しごと�碧�砲�API戻工しています

スタンバイカンパニ�`
? 二�Iやお糾が箔繁を恬撹したら、ElasticSearchに
インデックスします
? 箔�宀から魥爾�△辰燭箸④�蠶芝�鵑鮃楡蹐靴�
す。
? スカウトします

クロ�`ラ�`
? 箔繁サイトや、二�IHPの箔繁ペ�`ジをクロ�`リン
グして、ElasticSearchにインデックスします。
? よりよい�碧�Y惚をユ�`ザ�`に戻工できるように、
箔繁の坪否を僥�しているようです。

サ�`バ�`サイド
? 児云議にはPlay2 Scala
? ORM:Slick3 or ScalikeJDBC
? DBMigration:DBFlute or Flyway

サ�`バ�`アプリケ�`ションの
パッケ�`ジ��撹
? app
? controllers
? models
? アプリケ�`ション坪でつかうモデル(ユ�`ザ�`、箔繁、魥次∫��E堕�s、エラ�`)
? repositories
? 喟�A晒
? DBや麿のAPI、AWSのサ�`ビスとつなぐ叨護
? services
? コントロ�`ラ�`とレポジトリをつなぐ
? DBトランザクションの砿尖(リポジトリをまたいだトランザクションの�蕕函�repositoryのテストがし叟いため)
? utils
? views
? twirl喘のhtmlや、レスポンスがjsonの��呂�case classやwritesを崔く

? 和の�咾�呂�咾牧栖罎靴覆い茲Δ法�
? repository�咾�椶曳，襪里呂任④襪世吋廛螢潺�
ィブな侏
? 貧の�咾蕨造�咾鰆�蕕覆�討發いい茲Δ法�
? repository�咾�気垢里魯┘鵐謄�謄�

controllers
? �C嬬�阿縫僖奪羽`ジを蛍ける
? リクエストのバリデ�`ション
? メイン�I尖の柵び竃し
? レスポンスの�Mみ羨て
controllers/
players/
PlayerController
param/
Request
view/
Response
jobs/
applications/

DBFlute
? http://dbflute.seasar.org/
? EclipseでER�蹐鰈�辰董�DDLや、Alter猟を伏撹し
、DBをマイグレ�`ションする
? 返乏が佃しく、�えられないのでやめた。

Flyway
? project/plugins.sbt
? build.sbt
resolvers += "Flyway" at "https://flywaydb.org/repo"
addSbtPlugin("org.flywaydb" % "flyway-sbt" % "4.2.0")
flywayUrl := "jdbc:mysql://localhost:3306/tigers"
flywayUser := "root"

Flyway
? src/main/resources/db/migration/V1__Create_players_table.sql
? $ sbt flywayMigrate
CREATE TABLE players(
id INT NOT NULL PRIMARY KEY,
name VARCHAR(64) NOT NULL,
defence_position VARCHAR(64)
);
mysql> show tables;
+------------------+
| Tables_in_tigers |
+------------------+
| players |
| schema_version |
+------------------+

Slick3
? Play2.4からSlick3になった。
? MonadicでReactiveになった。
? db.run() して DBIO を Future にする

聞い圭
? マッピングを徭�喇敎匹垢�
package repositories.slick
import slick.jdbc.GetResult
import slick.jdbc.MySQLProfile.api._
/**
* Created by hiroyuki.ikawa on 2017/05/09.
*/
trait Tables{
case class Player(id: Int, name: String, defencePosition: Option[String] = None)
implicit val getPlayerResult = GetResult { r =>
Player(r.<<, r.<<, r.<<)
}
class Players(tag: Tag) extends Table[Player](tag, "players") {
def id = column[Int]("id", O.PrimaryKey)
def name = column[String]("name")
def defencePosition = column[Option[String]]("defence_position")
def * = (id, name, defencePosition) <> (Player.tupled, Player.unapply)
}
object Players extends TableQuery(new Players(_))
}
object Tables extends Tables

Repository
? DBから函誼する
? DBIO侏で卦す
? テストやりやすくする
? トランザクションの崙囮はservice�咾任垢�
package repositories.slick
import com.google.inject.Singleton
import repositories.slick.Tables._
/**
*/
@Singleton
class Players {
def getAllPlayers: DBIO[Seq[Player]] = {
Players.result
}
}

Service
? レポジトリからデ�`タを函誼して、コントロ�`ラ�`
に卦す
? Future侏で卦す
package services
import com.google.inject.{Inject, Singleton}
import repositories.slick.Players
import repositories.slick.Tables.Player
import scala.concurrent.Future
/**
*/
@Singleton
class PlayerService @Inject()(
val repo: Players
) {
val db = Database.forConfig("db.default")
def getPlayers: Future[Seq[Player]] = {
db.run(repo.getAllPlayers)
}
}

Controller
? デ�`タを函誼してViewを燕幣
package controllers
import play.api.mvc.{Action, Controller}
import services.PlayerService
import scala.concurrent.ExecutionContext
/**
*/
@Singleton
class PlayersController @Inject()(
val service: PlayerService
)(implicit val ed: ExecutionContext) extends Controller {
def list = Action.async {
service.getPlayers.map { players =>
Ok(views.html.player.list(players))
}
}
}

麿のAPIとの�B亊
? 麿のAPIサ�`バ�`からデ�`タを函誼する
package repositories.api
import com.google.inject.Singleton
import play.api.libs.ws.WS
/**
*/
@Singleton
class OutsideApi {
def battingAverage(name: String): Future[Double] = {
// WSで麿のAPIサ�`ビスからデ�`タを函ってくる
// WS.url("https://api.outside.internal/batting-average/:name")
// 書指はモックで�m輝に。
Future.successful(0.321)
}
}

Service
? ネストが侮くなってくる、、
@Singleton
val repo: Players,
val api: OutsideApi
)(implicit val ec: ExecutionContext) {
def getPlayers: Future[Seq[(Player, Double)]] = {
// DBから匯�Eを函誼
db.run(repo.getAllPlayers).flatMap { players =>
// �x返�阿法�
Future.sequence(players.map { player =>
// デ�`タを函誼して、
api.battingAverage(player.name).map { average =>
// レスポンスするデ�`タを恬る
(player, average)
}
})
}
}
}

(APIを俐屎しておく)
? �}方函誼できるAPIを喘吭する
? もしくは、repositoryで簾�Г垢�(Future.sequence)
@Singleton
class OutsideApi {
def battingAverage(name: String): Future[Double] = {
// WSで麿のAPIサ�`ビスからデ�`タを函ってくる
// WS.url("https://api.outside.internal/batting-average/:name")
// 書指はモックで�m輝に。
Future.successful(0.321)
}
// �}方の�x返の嬉楕を卦す
def battingAverages(names: Seq[String]): Future[Map[String, Double]] = {
Future.successful(
names.map { name =>
name -> 0.321
}.toMap
)
}
}

for塀を聞う
? ネストがなくなって�iみやすくなった
? �K双で�g佩できないか�
@Singleton
val repo: Players,
val api: OutsideApi
for {
// DBから函誼
players <- db.run(repo.getAllPlayers)
// APIから函誼
averages <- api.battingAverages(players.map(_.name))
} yield {
// デ�`タを伏撹
players.map { player =>
(player, averages(player.name))
}
}
}
}

APIが弖紗される
? チ�`ム畠�Tの嬉楕を卦すAPIが弖紗された
@Singleton
class OutsideApi {
// �}方の�x返の嬉楕を卦す
def battingAverages(names: Seq[String]): Future[Map[String, Double]] = {
Future.successful(
names.map { name =>
name -> 0.321
}.toMap
)
}
// チ�`ムの畠�x返の嬉楕を卦す
def battingAveragesByTeam(name: String): Future[Map[String, Double]] = {
Future.successful(
Map(
"�B紅" -> 0.321
)
)
}
}

forの�F
? 畠�Tのデ�`タをいっぺんに函ってくる
@Singleton
val repo: Players,
val api: OutsideApi
for {
// DBから函誼
players <- db.run(repo.getAllPlayers)
// APIから函誼
averages <- api.battingAveragesByTeam("tigers")
} yield {
players.map { player =>
(player, averages(player.name))
}
}
}
}

�K双
? 枠にFutureを�g佩する
@Singleton
val repo: Players,
val api: OutsideApi
// DBから函誼
val playersFuture = db.run(repo.getAllPlayers)
// APIから函誼
val averagesFuture = api.battingAveragesByTeam("tigers")
for {
players <- playersFuture
averages <- averagesFuture
} yield {
players.map(player => (player, averages(player.name)))
}
}
}

エラ�`を�Qいたい
? 翌何APIがエラ�`を卦してきたらどうする�
? エラ�`クラス
package models
/**
*/
trait Errors {
override def toString: String = this match {
case e: InternalServerError => e.msg
}
}
final case class InternalServerError(msg: String) extends Errors
object Errors {
def internalServerError(msg: String) = InternalServerError(msg)
}

Either
? repository
? APIがエラ�`だったとき、Eitherで卦すようにする
def battingAveragesByTeam(name: String): Future[Either[Errors, Map[String, Double]]] = {
Future(
Map(
"�B紅" -> 0.321
)
).map(Right(_))
}
def battingAveragesByTeam(name: String): Future[Map[String, Double]] = {
Future.successful(
Map(
"�B紅" -> 0.321
)
)
}

Service
? エラ�`をハンドリングして、LeftかRightで卦す
@Singleton
val repo: Players,
val api: OutsideApi
def getPlayers: Future[Either[Errors, Seq[(Player, Double)]]] = {
// DBから函誼
val playersFuture = db.run(repo.getAllPlayers)
// APIから函誼
val averagesFuture = api.battingAveragesByTeam("tigers")
for {
averagesEither <- averagesFuture
} yield {
averagesEither.fold(
error => Left(Errors.internalServerError("api error")),
averages => Right(players.map(player => (player, averages(player.name))))
)
}
}
}

Controller
? �m俳なエラ�`を卦せるようになる
? Future[Either[Errors, T]]とか中宜
? DBがEitherで卦すようになったらどうする�
@Singleton
class PlayersController @Inject()(
val service: PlayerService
)(implicit val ed: ExecutionContext) extends Controller
{
def list = Action.async {
service.getPlayers.map { result =>
result.fold(
e => InternalServerError(e.toString),
result => Ok(views.html.player.list(result))
)
}
}
}

scalaz.EitherT
? repository
? /,/-
def battingAveragesByTeam(name: String): Future[/[Errors, Map[String, Double]]] = {
Future(
Map(
"�B紅" -> 0.321
)
).map(/-(_))
}
def battingAveragesByTeam(name: String): Future[Either[Errors, Map[String, Double]]] = {
Future(
Map(
"�B紅" -> 0.321
)
).map(Right(_))
}

service
? EitherT
? for塀の嶄はスッキリしたけど、、、
@Singleton
val repo: Players,
val api: OutsideApi
def getPlayers: EitherT[Future, Errors, Seq[(Player, Double)]] = {
// DBから函誼
val playersFuture: Future[/[Errors, Seq[Player]]] = db.run(repo.getAllPlayers).map(/-(_))
val playersFutureEither: EitherT[Future, Errors, Seq[Player]] = EitherT.eitherT(playersFuture)
// APIから函誼
val averagesFuture: EitherT[Future, Errors, Map[String, Double]] =
EitherT.eitherT(api.battingAveragesByTeam("tigers"))
for {
players <- playersFutureEither
} yield {
}
}
}

FunctionalSyntaxHelper
? 畠何importするとcompileが嶷くなるので、駅勣なパッケ�`ジだけ
importしたtraitを喘吭しておいてそれだけを聞うようにする
? scalazを宴旋に聞えるようにする

package utils
import models.Errors
import scalaz.{Applicative, EitherT, /, /-}
import scalaz.syntax.ToEitherOps
/**
*/
trait FunctionalSyntaxHelper extends ToEitherOps {
implicit class ToEitherT[A](a: A) {
/**
* A を EitherT[F, Errors, A] に��Qする
*/
def toEitherT[F[_]](implicit F: Applicative[F]): EitherT[F, Errors, A] = {
val either: /[Errors, A] = /-(a)
EitherT(F.point(either))
}
}
implicit class RichEither[A, B](either: A / B) {
/**
* A / B を EitherT[F, A, B] に��Qする
*/
def toEitherT[F[_]](implicit F: Applicative[F]): EitherT[F, A, B] = {
EitherT(F.point(either))
}
}
implicit class RichEitherFuture[A, B](eitherF: Future[A / B]) {
/**
* Future[/[A, B]] を EitherT[[Future A, B]] に��Qする
*/
def toEitherT: EitherT[Future, A, B] = EitherT[Future, A, B](eitherF)
}
}

EitherT[Future,Errors,T]
? きれいになりました。
import scalaz.EitherT
import scalaz.Scalaz._
@Singleton
val repo: Players,
val api: OutsideApi
) (implicit val ec: ExecutionContext)
extends FunctionalSyntaxHelper {
// DBから函誼
val playersFuture = db.run(repo.getAllPlayers).map(_.right[Errors]).toEitherT
// APIから函誼
val averagesFuture = api.battingAveragesByTeam("tigers").toEitherT
for {
} yield {
}
}
}

EitherT
? EitherTのTはTransformerのT
? トランスフォ�`マ�`は2つのモナドを�Mみ栽わせて
�eのモナドをつくるためのもの
? FutureとEitherから�eのモナドを恬っている
? なので、forできれいに��韻�

/, -/, /-
? /: Either
? -/: Left
? /-: Right

もう富し
? importを�pらす適薦
trait FunctionalSyntaxHelper extends ToEitherOps with FutureInstances {
// import を福待するためのショ�`トカット
type /[+A, +B] = scalaz./[A, B]
type -/[+A] = scalaz.-/[A]
type /-[+B] = scalaz./-[B]
type EitherT[F[_], A, B] = scalaz.EitherT[F, A, B]
val / : scalaz./.type = scalaz./
val -/ : scalaz.-/.type = scalaz.-/
val /- : scalaz./-.type = scalaz./-

importも�pらせる
@Singleton
val repo: Players,
val api: OutsideApi
// DBから函誼
val playersFuture = db.run(repo.getAllPlayers).map(_.right[Errors]).toEitherT
// APIから函誼
val averagesFuture = api.battingAveragesByTeam("tigers").toEitherT
for {
} yield {
}
}
}

scalazおまけ
? ToBooleanOps
? if猟を�pらせる
trait FunctionalSyntaxHelper extends ToEitherOps
with ToBooleanOps
with FutureInstances {
def useIf(is: Boolean): /[Errors, Boolean] = {
if (is) {
true.right
} else {
Errors.internalServerError("false").left
}
}
def useEither(is: Boolean): /[Errors, Boolean] = {
is either true or Errors.internalServerError("false")
}

Slick3のつらいところ
? DBIOとか、EitherTとか�yしい。
? �o�jに掲揖豚�I尖になって�y叟業が互い
? �k佩されるSQLがよくわからない(Slick3でマシなっ
たけど�
? SQLの�Mみ羨て圭も�yしい
? ScalikeJDBCでええやん

scalikeJDBCの聞い圭
sbt
? project/plugins.sbt
? build.sbt
libraryDependencies += "mysql" % "mysql-connector-java" % "5.1.26"
addSbtPlugin("org.scalikejdbc" %% "scalikejdbc-mapper-generator" % "2.5.0")
libraryDependencies ++= Seq(
jdbc, cache, ws,
"com.typesafe.play" % "play-slick_2.11" % "2.1.0",
"com.typesafe.slick" % "slick_2.11" % "3.2.0",
"mysql" % "mysql-connector-java" % "6.0.6",
"org.scalaz" %% "scalaz-core" % "7.2.12",
// Scalikejdbc
"org.scalikejdbc" %% "scalikejdbc" % "2.5.0",
"org.scalikejdbc" %% "scalikejdbc-config" % "2.5.0",
"org.scalikejdbc" %% "scalikejdbc-play-dbapi-adapter" % "2.5.1",
specs2 % Test )
scalikejdbcSettings

徭�喇敎�
? project/scalikejdbc.properties
? $ sbt ＾scalikejdbcGen players￣
# ---
# jdbc settings
jdbc.driver="com.mysql.jdbc.Driver"
jdbc.url="jdbc:mysql://localhost:3306/tigers"
jdbc.username="root"
jdbc.password=""
# ---
# source code generator settings
generator.packageName=repositories.scalikejdbc.jdbc
# generator.lineBreak: LF/CRLF
generator.lineBreak=LF
# generator.template: interpolation/queryDsl
generator.template=queryDsl
# generator.testTemplate: specs2unit/specs2acceptance/ScalaTestFlatSpec
generator.testTemplate=
# File Encoding
generator.encoding=UTF-8
# When you're using Scala 2.11 or higher, you can use case classes for 22+ columns tables
generator.caseClassOnly=true
# Set AutoSession for implicit DBSession parameter's default value
generator.defaultAutoSession=false
# Use autoConstruct macro (default: false)
generator.autoConstruct=false
# joda-time (org.joda.time.DateTime) or JSR-310 (java.time.ZonedDateTime java.time.OffsetDateTime)
generator.dateTimeClass=org.joda.time.DateTime

package repositories.scalikejdbc.jdbc
import scalikejdbc._
case class Players(
id: Int,
name: String,
defencePosition: Option[String] = None) {
def save()(implicit session: DBSession): Players = Players.save(this)(session)
def destroy()(implicit session: DBSession): Int = Players.destroy(this)(session)
}
object Players extends SQLSyntaxSupport[Players] {
override val tableName = "players"
override val columns = Seq("id", "name", "defence_position")
def apply(p: SyntaxProvider[Players])(rs: WrappedResultSet): Players = apply(p.resultName)(rs)
def apply(p: ResultName[Players])(rs: WrappedResultSet): Players = new Players(
id = rs.get(p.id),
name = rs.get(p.name),
defencePosition = rs.get(p.defencePosition)
)
val p = Players.syntax("p")
override val autoSession = AutoSession
def find(id: Int)(implicit session: DBSession): Option[Players] = {
withSQL {
select.from(Players as p).where.eq(p.id, id)
}.map(Players(p.resultName)).single.apply()
}
def findAll()(implicit session: DBSession): List[Players] = {
withSQL(select.from(Players as p)).map(Players(p.resultName)).list.apply()
}
def countAll()(implicit session: DBSession): Long = {
withSQL(select(sqls.count).from(Players as p)).map(rs => rs.long(1)).single.apply().get
}

def findBy(where: SQLSyntax)(implicit session: DBSession): Option[Players] = {
withSQL {
select.from(Players as p).where.append(where)
}.map(Players(p.resultName)).single.apply()
}
def findAllBy(where: SQLSyntax)(implicit session: DBSession): List[Players] = {
withSQL {
select.from(Players as p).where.append(where)
}.map(Players(p.resultName)).list.apply()
}
def countBy(where: SQLSyntax)(implicit session: DBSession): Long = {
withSQL {
select(sqls.count).from(Players as p).where.append(where)
}.map(_.long(1)).single.apply().get
}
def create(
id: Int,
name: String,
defencePosition: Option[String] = None)(implicit session: DBSession): Players = {
withSQL {
insert.into(Players).namedValues(
column.id -> id,
column.name -> name,
column.defencePosition -> defencePosition
)
}.update.apply()
Players(
id = id,
name = name,
defencePosition = defencePosition)
}

def batchInsert(entities: Seq[Players])(implicit session: DBSession): List[Int] = {
val params: Seq[Seq[(Symbol, Any)]] = entities.map(entity =>
Seq(
'id -> entity.id,
'name -> entity.name,
'defencePosition -> entity.defencePosition))
SQL("""insert into players(
id,
name,
defence_position
) values (
{id},
{name},
{defencePosition}
)""").batchByName(params: _*).apply[List]()
}
def save(entity: Players)(implicit session: DBSession): Players = {
withSQL {
update(Players).set(
column.id -> entity.id,
column.name -> entity.name,
column.defencePosition -> entity.defencePosition
).where.eq(column.id, entity.id)
}.update.apply()
entity
}
def destroy(entity: Players)(implicit session: DBSession): Int = {
withSQL { delete.from(Players).where.eq(column.id, entity.id) }.update.apply()
}
}

repository
package repositories.scalikejdbc
import repositories.scalikejdbc.jdbc.Players
import scalikejdbc._
/**
*/
class PlayerRepository {
Class.forName("com.mysql.jdbc.Driver")
ConnectionPool.singleton("jdbc:mysql://localhost:3306/tigers?useSSL=false", "root", "")
implicit val session = AutoSession
def getAllPlayers: Seq[Players] = {
Players.findAll
}
}

service
package services
import models.Errors
import repositories.api.OutsideApi
import repositories.scalikejdbc.PlayerRepository
import repositories.scalikejdbc.jdbc.Players
import utils.FunctionalSyntaxHelper
import scala.concurrent.{ExecutionContext, Future}
/**
*/
@Singleton
val repo: PlayerRepository,
val api: OutsideApi
def getPlayers: Future[/[Errors, Seq[(Players, Double)]]] = {
// DBから函誼
val players = repo.getAllPlayers
// APIから函誼
api.battingAveragesByTeam("tigers").map { averagesEither =>
averagesEither.map { averages =>
}
}
}
}

ScalikeJDBC
? SQLがわりと岷湖議に��韻�
? bindとかいらない
? �o�jに掲揖豚�I尖じゃないので、DBIOとか深えなくていい
? DBIOとかbindがあるかとか深えなくていいので、レビュ�`し
やすい
? DBについてあまり深えなくて措くなるので、アプリケ�`ショ
ンの�O�や、ビジネスロジックのことを深えられるようになる

ありがとうございました

際際滷

Play2 scalaを2定やって僥んた?こと

More Related Content

Play2 scalaを2定やって僥んた?こと