As you have already learned the services are all singletons, so that
    the container creates only one single instance of each service. The
    services are created by calling the constructors (called
    constructor injection). If there are only
    zero-arguments constructors (Foo public Foo(){}), there are no
    problems to be expected. That's easy.
But now look at OrganizationServiceImpl.java
This JDBC implementation of BaseOrganizationService interface has only one constructor:
public OrganizationServiceImpl(ListenerService listenerService, DatabaseService dbService);
You see this service depends on two other services. In order to be
    able to call this constructor the container first needs a
    ListenerService and a
    DatabaseService. Therefore these services must be
    instantiated before BaseOrganizationService,
    because BaseOrganizationService depends on
    them.
For this purpose the container first looks at the constructors of
    all services and creates a matrix of service dependencies in order to call
    the services in a proper order. If for any reason there are
    interdependencies or circular dependencies you will get a Java
    Exception. In this way the dependencies
    are injected by the container.
What happens if one service has more than one constructor? The container always tries first to use the constructor with a maximum number of arguments, if this is not possible the container continues step by step with constructors that have less arguments until arriving at the zero-argument constructor (if there is any).