Scala AkkaGuiceSupport类代码示例

//设置package包名称以及导入依赖的类
import java.time.Clock

import com.google.inject.AbstractModule
import errorhandler.ErrorHandler
import helpers.{SemesterModeCache, SessionCache}
import logic.actors.database.DatabaseActor
import logic.actors.fakeactivity.FakeActivityActor
import logic.actors.rss.{DeleteNewsActor, NewsReaderActor, RSSParseActor}
import logic.actors.schedule._
import logic.actors.spread.TweetActor
import model.schedule.data.MSchedule
import play.api.libs.concurrent.AkkaGuiceSupport
import services.{DatabaseService, FakeActivity, NewsFeedReader, ScheduleParser}


class Module extends AbstractModule with AkkaGuiceSupport {

  override def configure() = {
    // Use the system clock as the default implementation of Clock
    bind(classOf[Clock]).toInstance(Clock.systemDefaultZone)
    // bind actors
    bindActor[RSSParseActor]("rssParser")
    bindActor[NewsReaderActor]("NewsReader")
    bindActor[DeleteNewsActor]("deleteNews")
    // Ask Guice to create an instance of NewsFeedReader when the
    // application starts.
    bind(classOf[NewsFeedReader]).asEagerSingleton()


    bindActor[CheckScheduleDateActor]("checkSchedule")
    bind(classOf[ScheduleParser]).asEagerSingleton()
    bind(classOf[FakeActivity]).asEagerSingleton()

    bindActor[ScheduleDownloadActor]("scheduleDownloader")
    bindActor[ShortCutParseActor]("shortcutParser")
    bindActor[ScheduleParseActor]("parseActor")
    bind(classOf[MSchedule])
    bindActor[GroupParseActor]("groupParseActor")
    bindActor[TweetActor]("tweetActor")
    bindActor[FakeActivityActor]("fakeActivityActor")

    bind(classOf[SemesterModeCache])
    bind(classOf[SessionCache])

    bindActor[DatabaseActor]("databaseActor")
    bind(classOf[DatabaseService]).asEagerSingleton()
  }

} 

//设置package包名称以及导入依赖的类
package au.id.tmm.senatedb.api

import java.nio.file.Paths

import au.id.tmm.senatedb.api.persistence.population.DbPopulationActor
import au.id.tmm.senatedb.core.engine.{ParsedDataStore, TallyEngine}
import au.id.tmm.senatedb.core.model.flyweights.PostcodeFlyweight
import au.id.tmm.senatedb.core.rawdata.{AecResourceStore, RawDataStore}
import com.google.inject.{AbstractModule, Provides, Singleton}
import play.api.libs.concurrent.AkkaGuiceSupport
import scalikejdbc.{ConnectionPool, ConnectionPoolContext, MultipleConnectionPoolContext}

class Module extends AbstractModule with AkkaGuiceSupport {

  override def configure(): Unit = {
    bindActor[DbPopulationActor]("dbPopulationActor")
  }

  @Provides
  def provideConnectionPoolContext(): ConnectionPoolContext =
    MultipleConnectionPoolContext(ConnectionPool.DEFAULT_NAME -> ConnectionPool())

  @Provides
  @Singleton
  def providePostcodeFlyweight: PostcodeFlyweight = PostcodeFlyweight()

  @Provides
  @Singleton
  def provideParsedDataStore(rawDataStore: RawDataStore): ParsedDataStore = ParsedDataStore(rawDataStore)

  @Provides
  @Singleton
  def provideRawDataStore(aecResourceStore: AecResourceStore): RawDataStore = RawDataStore(aecResourceStore)

  @Provides
  @Singleton
  def provideAecResourceStore: AecResourceStore = AecResourceStore.at(Paths.get("rawData"))

  @Provides
  def provideTallyEngine: TallyEngine = TallyEngine

} 

//设置package包名称以及导入依赖的类
package modules


import play.api.{Configuration, Environment}
import play.api.inject.{Binding, Module}
import play.api.libs.concurrent.AkkaGuiceSupport

import actors.MailsendActor
import com.google.inject.AbstractModule
import schedulers.MailsendScheduler


class MailsendActorModule extends AbstractModule with AkkaGuiceSupport {
  override def configure() = {
    bindActor[MailsendActor]("mailsend-actor")
  }
}

class MailsendScheduleModule extends Module {
  override def bindings(environment: Environment, configuration: Configuration): Seq[Binding[_]] = {
    Seq(
      bind[MailsendScheduler].toSelf.eagerly
    )
  }
} 

//设置package包名称以及导入依赖的类
package modules


import play.api.{Configuration, Environment}
import play.api.inject.{Binding, Module}
import play.api.libs.concurrent.AkkaGuiceSupport

import actors.HelloWorldActor
import com.google.inject.AbstractModule
import schedulers.HelloWorldScheduler


class HelloWorldActorModule extends AbstractModule with AkkaGuiceSupport {
  override def configure() = {
    bindActor[HelloWorldActor]("hello-world-actor")
  }
}

class HelloWorldScheduleModule extends Module {
  override def bindings(environment: Environment, configuration: Configuration): Seq[Binding[_]] = {
    Seq(
      bind[HelloWorldScheduler].toSelf.eagerly
    )
  }
} 

//设置package包名称以及导入依赖的类
package modules


import play.api.{Configuration, Environment}
import play.api.inject.{Binding, Module}
import play.api.libs.concurrent.AkkaGuiceSupport

import actors.CustomerCountBatchActor
import com.google.inject.AbstractModule
import schedulers.CustomerCountBatchScheduler
import akka.actor.ActorSystem


class CustomerCountBatchActorModule extends AbstractModule with AkkaGuiceSupport {
  override def configure() = {
    bindActor[CustomerCountBatchActor]("CustomerCountBatch-actor")
  }
}

class CustomerCountBatchScheduleModule extends Module {

  override def bindings(environment: Environment, configuration: Configuration): Seq[Binding[_]] = {
    Seq(
      bind[CustomerCountBatchScheduler].toSelf.eagerly
    )
  }
} 

//设置package包名称以及导入依赖的类
import com.google.inject.AbstractModule
import java.time.Clock

import play.api.libs.concurrent.AkkaGuiceSupport
import services.actors.{UserFilesUpdateActor, NewUserActor}
import services.{ApplicationTimer, AtomicCounter, Counter, DropboxService}


class Module extends AbstractModule with AkkaGuiceSupport {

  override def configure() = {
    // Use the system clock as the default implementation of Clock
    bind(classOf[Clock]).toInstance(Clock.systemDefaultZone)
    // Ask Guice to create an instance of ApplicationTimer when the
    // application starts.
    bind(classOf[ApplicationTimer]).asEagerSingleton()
    bind(classOf[DropboxService]).asEagerSingleton()
    // Set AtomicCounter as the implementation for Counter.
    bind(classOf[Counter]).to(classOf[AtomicCounter])

    bindActor[NewUserActor]("new-user-actor")
    bindActor[UserFilesUpdateActor]("user-files-update-actor")
  }

} 

//设置package包名称以及导入依赖的类
import com.google.inject.AbstractModule
import java.time.Clock

import play.api.libs.concurrent.AkkaGuiceSupport
import services.{ApplicationTimer, AtomicCounter, Counter}


class Module extends AbstractModule with AkkaGuiceSupport {

  override def configure() = {
    // Use the system clock as the default implementation of Clock
    bind(classOf[Clock]).toInstance(Clock.systemDefaultZone)
    // Ask Guice to create an instance of ApplicationTimer when the
    // application starts.
    bind(classOf[ApplicationTimer]).asEagerSingleton()
    // Set AtomicCounter as the implementation for Counter.
    bind(classOf[Counter]).to(classOf[AtomicCounter])

//    bindActor[Character]("chatActor")
  }

} 

//设置package包名称以及导入依赖的类
package modules

import javax.inject.{Inject, Named}

import actors.bots.IncidentActor
import actors.systems.ServiceManagerActor
import akka.actor.{ActorRef, ActorSystem}
import com.google.inject.AbstractModule
import play.api.libs.concurrent.AkkaGuiceSupport

import scala.concurrent.duration._
import scala.concurrent.ExecutionContext.Implicits.global
import scala.concurrent.ExecutionContext


class IncidentModule extends AbstractModule with AkkaGuiceSupport {
  def configure() = {
    bindActor[ServiceManagerActor]("ServiceManager-actor")
    bindActor[IncidentActor]("Incident-actor")
    bind(classOf[IncidentScheduler]).asEagerSingleton()
  }
}


class IncidentScheduler @Inject()(val system: ActorSystem, @Named("Incident-actor") val incidentActor: ActorRef)(implicit ec: ExecutionContext)
{
 // system.scheduler.schedule(   0.microseconds, 1.minutes, incidentActor,IncidentActor.Tick)

} 

//设置package包名称以及导入依赖的类
package modules

import javax.inject.{Inject, Named}

import actors.systems.SlackTeamManager
import play.api.libs.concurrent.AkkaGuiceSupport
import akka.actor.{ActorRef, ActorSystem}
import com.google.inject.AbstractModule
import models.SlackSessionRepo
import play.api.Logger
import play.api.libs.concurrent.AkkaGuiceSupport

import scala.concurrent.duration._
import scala.concurrent.ExecutionContext.Implicits.global
import scala.concurrent.ExecutionContext


class SlackModule extends AbstractModule  with AkkaGuiceSupport {
  def configure() = {
    bindActor[SlackTeamManager]("SlackTeamManager-actor")
    bind(classOf[SlackTeamManagerLoader]).asEagerSingleton()
  }
}

class SlackTeamManagerLoader @Inject()(val system: ActorSystem,
                                       @Named("SlackTeamManager-actor") val teamManagerActor: ActorRef,
                                       @Named("DR-actor") val drActor: ActorRef,
                                       slackSessionRepo: SlackSessionRepo)(implicit ec: ExecutionContext)
{
  val logger = Logger.logger
  logger.warn("Slack Startup")
  //slackSessionRepo.createIt()

  teamManagerActor ! SlackTeamManager.Load(slackSessionRepo,drActor)

} 

//设置package包名称以及导入依赖的类
package com.yper.utils

import javax.inject.Inject

import akka.actor.{ActorRef, ActorSystem}
import com.google.inject.AbstractModule
import com.google.inject.name.Names
import com.yper.users.actors.UserActor
import play.api.libs.concurrent.AkkaGuiceSupport
import play.api.{Configuration, Environment}



class ActorFactoryModule @Inject() (
                                    environment: Environment,
                                    configuration: Configuration
                                   ) extends AbstractModule with AkkaGuiceSupport{

  override def configure(): Unit = {
    println(s"Configuring ActorFactoryModule!")
    val actorSystem = ActorSystem.create("YperActorSystem")

    lazy val userActor = actorSystem.actorOf(UserActor.props)
    bind(classOf[ActorRef])
      .annotatedWith(Names.named("userActor"))
      .toInstance(userActor);


    lazy val anotherUserActor = actorSystem.actorOf(UserActor.props)
    bind(classOf[ActorRef])
      .annotatedWith(Names.named("anotherUserActor"))
      .toInstance(anotherUserActor);

  }
} 

//设置package包名称以及导入依赖的类
import java.time.Clock

import com.google.inject.AbstractModule
import play.api.libs.concurrent.AkkaGuiceSupport
import modules.{Scheduler, SchedulerActor}
import services.{ApplicationTimer, AtomicCounter, Counter}

class Module extends AbstractModule with AkkaGuiceSupport{
  override def configure(): Unit = {
    // Use the system clock as the default implementation of Clock
    bind(classOf[Clock]).toInstance(Clock.systemDefaultZone)
    bind(classOf[ApplicationTimer]).asEagerSingleton()
    bind(classOf[Counter]).to(classOf[AtomicCounter])

    //akka scheduler
    bindActor[SchedulerActor]("scheduler-actor")
    bind(classOf[Scheduler]).asEagerSingleton()
  }
} 

//设置package包名称以及导入依赖的类
import com.google.inject.AbstractModule
import java.time.Clock

import services.{ApplicationTimer, WebSocketActor, WebSocketActorProvider, ListActor}
import play.api.{Environment, Configuration}
import play.api.libs.concurrent.AkkaGuiceSupport
import models.{UserRepository, SlickUserRepository, ItemRepository, SlickItemRepository}


class Module(environment: Environment, configuration: Configuration) extends AbstractModule with AkkaGuiceSupport {

  override def configure() = {
    // Use the system clock as the default implementation of Clock
    bind(classOf[Clock]).toInstance(Clock.systemDefaultZone)
    // Ask Guice to create an instance of ApplicationTimer when the
    // application starts.
    bind(classOf[ApplicationTimer]).asEagerSingleton()
    bind(classOf[UserRepository]).to(classOf[SlickUserRepository])
    bind(classOf[ItemRepository]).to(classOf[SlickItemRepository])

    bindActor[ListActor]("list-actor")
  }

} 

//设置package包名称以及导入依赖的类
import java.time.Clock

import com.google.inject.AbstractModule
import play.api.libs.concurrent.AkkaGuiceSupport
import services.{ApplicationTimer, SquarerTypedFactory, SquarerUntypedActor}


class Module extends AbstractModule with AkkaGuiceSupport {

  override def configure() = {
    // Use the system clock as the default implementation of Clock
    bind(classOf[Clock]).toInstance(Clock.systemDefaultZone)
    // Ask Guice to create an instance of ApplicationTimer when the
    // application starts.
    bind(classOf[ApplicationTimer]).asEagerSingleton()
    bindActor[SquarerUntypedActor]("squarerUntyped")
    bind(classOf[SquarerTypedFactory])
  }
} 

//设置package包名称以及导入依赖的类
package modules

import com.google.inject.AbstractModule
import com.ning.http.client.AsyncHttpClientConfigBean
import net.codingwell.scalaguice.ScalaModule
import play.api.libs.concurrent.AkkaGuiceSupport
import play.api.libs.ws.WSClient
import play.api.libs.ws.ning.NingWSClient
import services.{DCOSAuthTokenActor, DefaultMarathonClientFactory, MarathonClientFactory}

class MetaDefaultDCOS extends AbstractModule with ScalaModule with AkkaGuiceSupport {

  override def configure(): Unit = {
    bind[MarathonClientFactory].to[DefaultMarathonClientFactory]
    bindActor[DCOSAuthTokenActor](DCOSAuthTokenActor.name)

    val config = new AsyncHttpClientConfigBean()
    config.setAcceptAnyCertificate(true)
    config.setFollowRedirect(true)
    val permissiveClient = NingWSClient(config)
    bind[WSClient].annotatedWithName("permissive-wsclient").toInstance(permissiveClient)
  }



} 

//设置package包名称以及导入依赖的类
import com.google.inject.AbstractModule
import java.time.Clock
import play.api.libs.concurrent.AkkaGuiceSupport

import services.{ApplicationTimer, AtomicCounter, Counter}
import actors._


class Module extends AbstractModule with AkkaGuiceSupport {

  override def configure() = {
    // Use the system clock as the default implementation of Clock
    bind(classOf[Clock]).toInstance(Clock.systemDefaultZone)
    // Ask Guice to create an instance of ApplicationTimer when the
    // application starts.
    bind(classOf[ApplicationTimer]).asEagerSingleton()
    // Set AtomicCounter as the implementation for Counter.
    bind(classOf[Counter]).to(classOf[AtomicCounter])
    bindActor[TemperatureActor]("temp-actor")
  }

}