how to use spring scala to decouple? - spring

Question

I like to add Spring to my Scala projects for educational purposes. But I do not understand the advantage of Spring Scala to decouple components.
I have created a simple configuration:
import org.springframework.scala.context.function.FunctionalConfiguration
class Configuration extends FunctionalConfiguration {
bean() {
new Service()
}
}
and a simple service:
class Service {
def method = "Bonjour tout le monde!"
}
and then an application which uses both:
import org.springframework.scala.context.function.FunctionalConfigApplicationContext
object Application extends App {
implicit val context = FunctionalConfigApplicationContext(classOf[Configuration])
val service = context.getBean(classOf[Service])
println(service.method)
}
This is just my interpretation and implementation of the Spring Scala examples.
My application still has knowledge of the Service class. I could just write:
val service = new Service() // instead of asking for a Bean which has classname Service
println(service.method)
with the same effect.
Am I missing something?

Answer 1

This does decouple your use of the Service from the instantiation of it. E.g. if in the future Service changes to depend on some other InnerService, or has some initialization that can't be done in the constructor for some reason but needs to happen in a method call before it's used (.connectToDatabase() or some such), or if you wanted to replace the Service with a mock one for testing, then you can do this without changing these two lines of code:
val service = context.getBean(classOf[Service])
println(service.method)
If you program to an interface rather than implementation, e.g.
trait IService {
def method: String
}
class Service extends IService...
val service = context.getBean(classOf[IService])
then you also make it easy to swap out the Service for a different implementation, though given the extra lines of code I probably wouldn't bother doing this until I actually had more than one implementation.
I'm not sure that Spring carries its own weight (it's a very large and complex library), particularly in Scala with its more concise constructor syntax. But whether you use Spring or not, it's worth separating the construction of your dependencies and "wiring up" of your application from their actual use. IMO a class Foo that uses Service should accept it, explicitly via its constructor, class Foo(service: Service), and leave the construction/initialization of Service to a class/or function dedicated to that.