Зачем использовать @Singleton над объектом Scala в Play Framework?

Я использую Играть! Рамки для Scala уже почти год. В настоящее время я использую версию 2.5.x.

Я знаю об эволюции контроллеров в Play и о том, как разработчики были вынуждены покинуть статические маршруты object.

Я также знаю об использовании Guice в игре.

Если вы загрузите activator и запустите:

activator new my-test-app play-scala

Активатор создаст для вас шаблонный проект. Мой вопрос определенно находится вокруг этого файла этого шаблона.

мой тест-приложение/приложения/услуги/Counter.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()
}

Вы также можете увидеть его использование в файле this:

мой тест-приложение/приложение/контроллеры/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]] 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) }

}

Это означает, что каждый контроллер, имеющий конструктор @Inject() (counter: Counter), получит тот же экземпляр Counter.

Итак, мой вопрос:

Зачем использовать @Singleton и затем @Inject его в контроллер, когда для этого примера вы можете просто использовать объект Scala?
Это намного меньше кода.

Пример:

мой тест-приложение/приложения/услуги/Counter.scala

package services

trait ACounter {
  def nextCount: Int
}

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

Используйте его так:

мой тест-приложение/приложение/контроллеры/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) }

}

В чем разница? Является ли инъекция предпочтительной, и почему?