スケーラでスケジュールされたタスクをプレイ2.5で作成する

Question

プレイ2.5でスケジュールされたタスクを作成します。私はこのトピックに関連するいくつかのリソースを見つけましたが、どれもPlay 2.5のものではありませんでした。私が探しているものに関連するthis resourceが見つかりました。また、同じリンクに2.4から2.5の移行ガイドがあります。

古いバージョンの例では、GlobalSettingsがベースとして使用されていましたが、2.5では非推奨です。移行ガイドは、この特性を拡張するのではなく、依存性注入を使用する必要があるため、重要です。私はそれを行う方法がわかりません。

ガイダンスを教えてもらえますか？あなたがアッカの俳優の内側sheduledタスクを実行する必要が

Answer 1

：

SchedulerActor.scala

package scheduler 

import javax.inject.{Inject, Singleton} 

import akka.actor.Actor 
import org.joda.time.DateTime 
import play.api.Logger 

import scala.concurrent.ExecutionContext 

@Singleton 
class SchedulerActor @Inject()()(implicit ec: ExecutionContext) extends Actor { 
    override def receive: Receive = { 
    case _ => 
     // your job here 
    } 
} 

Scheduler.scala

package scheduler 

import javax.inject.{Inject, Named} 

import akka.actor.{ActorRef, ActorSystem} 
import play.api.{Configuration, Logger} 

import scala.concurrent.ExecutionContext 
import scala.concurrent.duration._ 

class Scheduler @Inject() (val system: ActorSystem, @Named("scheduler-actor") val schedulerActor: ActorRef, configuration: Configuration)(implicit ec: ExecutionContext) { 
    val frequency = configuration.getInt("frequency").get 
    var actor = system.scheduler.schedule(
    0.microseconds, frequency.seconds, schedulerActor, "update") 

} 

JobModule.scala

package modules 

import com.google.inject.AbstractModule 
import play.api.libs.concurrent.AkkaGuiceSupport 
import scheduler.{Scheduler, SchedulerActor} 

class JobModule extends AbstractModule with AkkaGuiceSupport { 
    def configure() = { 
    bindActor[SchedulerActor]("scheduler-actor") 
    bind(classOf[Scheduler]).asEagerSingleton() 
    } 
} 

application.conf

play.modules.enabled += "modules.JobModule" 

Answer 2

あなたがアッカを使用しない場合、あなたは、Javaを使用することができます。

• はScheduledFuture
• ScheduledExecutorService

DemoDaemon.scala：

import java.util.concurrent.{Executors, ScheduledFuture, TimeUnit} 
import javax.inject._ 
import play.Configuration 
import scala.util.Try 

class DemoDaemon @Inject() (conf: Configuration) { 

    val isEnabled = conf.getBoolean("daemon.enabled") 
    val delay = conf.getLong("daemon.delay") 

    private var scheduledTaskOption : Option[ScheduledFuture[_]] = None 

    def task(): Unit = { 

    Try { 
     println("doSomething") 
    } recover { 
     case e: Throwable => println(e.getMessage) 
    } 
    } 

    def start(): Unit = { 
    if (isEnabled) { 
     val executor = Executors.newScheduledThreadPool(1) 

     scheduledTaskOption = Some( 
     executor.scheduleAtFixedRate(
      new Runnable { 
      override def run() = task() 
      }, 
      delay, delay, TimeUnit.SECONDS 
     ) 
    ) 
    } else { 
     println("not enabled") 
    } 
    } 

    def stop(): Unit = { 
    scheduledTaskOption match { 
     case Some(scheduledTask) => 
     println("Canceling task") 
     val mayInterruptIfRunning = false 
     scheduledTask.cancel(mayInterruptIfRunning) 
     case None => println("Stopped but was never started") 
    } 
    } 
} 

DaemonService.scala

import javax.inject.Inject 
import play.api.inject.ApplicationLifecycle 
import scala.concurrent.Future 

class DaemonService @Inject() (appLifecycle: ApplicationLifecycle, daemon: DemoDaemon) { 

    daemon.start() 

    appLifecycle.addStopHook{() => 
    Future.successful(daemon.stop()) 
    } 
} 

JobModule.scala

import com.google.inject.AbstractModule 

class JobModule extends AbstractModule { 
    def configure(): Unit = { 
    bind(classOf[DaemonService]).asEagerSingleton() 
    } 
} 

application.conf

daemon.enabled = true 
daemon.delay = 10 
play.modules.enabled += "com.demo.daemon.JobModule"