Pourquoi utiliser @Singleton sur L'objet de Scala dans Play Framework?

j'ai utilisé Jouer! Framework Scala depuis près d'un an maintenant. J'utilise actuellement la version 2.5.x.

je suis conscient de l'évolution des contrôleurs en jeu et de la façon dont les développeurs ont été forcés de s'éloigner de la statique object itinéraires.

je suis également conscient de l' Guice utilisation en jeu.

Si vous téléchargez activateur et exécuter:

activator new my-test-app play-scala

activateur produira un projet de modèle pour vous. Ma question est spécifiquement autour de fichier de ce modèle.

mon-test-app/app/services/Compteur.scala

package services

import java.util.concurrent.atomic.AtomicInteger
import javax.inject._

/**
 * This trait demonstrates how to create a component that is injected
 * into a controller. The trait represents a counter that returns a
 * incremented number each time it is called.
 */
trait Counter {
  def nextCount(): Int
}

/**
 * This class is a concrete implementation of the [[Counter]] trait.
 * It is configured for Guice dependency injection in the [[Module]]
 * class.
 *
 * This class has a `Singleton` annotation because we need to make
 * sure we only use one counter per application. Without this
 * annotation we would get a new instance every time a [[Counter]] is
 * injected.
 */
@Singleton
class AtomicCounter extends Counter {  
  private val atomicCounter = new AtomicInteger()
  override def nextCount(): Int = atomicCounter.getAndIncrement()
}

vous pouvez aussi voir son utilisation dans fichier:

my-test-app/app/controllers / CountController.scala

package controllers

import javax.inject._
import play.api._
import play.api.mvc._
import services.Counter

/**
 * This controller demonstrates how to use dependency injection to
 * bind a component into a controller class. The class creates an
 * `Action` that shows an incrementing count to users. The [[Counter]]
 * object is injected by the Guice dependency injection system.
 */
@Singleton
class CountController @Inject() (counter: Counter) extends Controller {

  /**
   * Create an action that responds with the [[Counter]]'s current
   * count. The result is plain text. This `Action` is mapped to
   * `GET /count` requests by an entry in the `routes` config file.
   */
  def count = Action { Ok(counter.nextCount().toString) }

}

cela signifie Chaque contrôleur qui a le constructeur de @Inject() (counter: Counter) recevrez la même instance de Counter.

alors ma question Est:

Pourquoi utiliser @Singleton et @Inject dans un contrôleur, quand dans cet exemple vous pouvez juste utiliser un objet Scala?

Son beaucoup moins de code.

Exemple:

mon-test-app/app/services/Compteur.scala

package services

trait ACounter {
  def nextCount: Int
}

object Counter with ACounter {
  private val atomicCounter = new AtomicInteger()
  def nextCount(): Int = atomicCounter.getAndIncrement()
}

Utiliser comme donc:

my-test-app/app/controllers / CountController.scala

package controllers

import javax.inject._
import play.api._
import play.api.mvc._

import services.{Counter, ACounter}

/**
 * This controller demonstrates how to use dependency injection to
 * bind a component into a controller class. The class creates an
 * `Action` that shows an incrementing count to users. The [[Counter]]
 * object is injected by the Guice dependency injection system.
 */
@Singleton
class CountController extends Controller {
  //depend on abstractions
  val counter: ACounter = Counter

  def count = Action { Ok(counter.nextCount().toString) }

}

Quelle est la différence? L'injection est-elle préférable, et pourquoi?