The danceable/container package plays exactly this role: a central place to register, build, and manage all of an application's dependencies.

Service provider

A service provider is a concept used to organize the application's bootstrap and shutdown process.

If the service container is the warehouse of the application's services, the service provider is responsible for filling that warehouse and managing the lifecycle of those services.

Put simply:

• The container says: I hold the services and hand them to you whenever you want.
• The provider says: I determine which services get registered in the container, how the application gets ready to run, and how resources are released at the end.

Why do we need a service provider?

Suppose your application uses these services:

• Database
• Redis
• Logger
• Configuration
• HTTP Client
• Queue
• Cache

With no service provider, all the code for registering and starting these services ends up in main.go:

As the project grows, main.go turns into the home of every startup operation and becomes hard to maintain. A service provider takes that responsibility out of main.go.

What a service provider does

A service provider usually has three main responsibilities:

• Register the dependencies in the container.
• The boot stage, which covers checking configuration and starting up parts of the application such as queues, workers, or running database migrations.
• The shutdown stage, which happens right before the program exits. This is normally where resources are released.

The service provider lifecycle

Every service provider goes through three main stages over the life of the program:

1. The first stage is Register. Here the provider registers its services in the container. Normally no external resource (a database or Redis connection, say) is created at this point — only the recipes for building the services (the factories) are stored in the container. Once Register finishes, the container knows how to create each service on demand.
2. Once every provider has finished registering, the Boot stage begins and all providers are booted. Booting typically validates configuration and starts up parts of the services.
3. At the end of the program comes the Shutdown stage, where the provider is responsible for releasing all the resources used while the program was running.

The benefit of using service providers

Suppose your project consists of several independent parts:

Each provider is responsible only for its own part. For example:

• DatabaseProvider manages only the database.
• RedisProvider manages only Redis.
• LoggerProvider manages only the logger.

Responsibilities are therefore separated, and adding or removing a service has little effect on the rest of the application.

The danceable/provider package plays the service provider role: it takes on managing the lifecycle of the application's services, determining which services are registered in the container at runtime, what work is done to prepare and start them, and how the resources they used are released and cleaned up when the program ends.