Where to load controller dependency classes?

Question

I'm making my own primitive MVC framework with PHP, and I'm wondering where I should load/instantiate corresponding controller dependencies?

In the constructor of each controller (tightly coupled) or inject them (loosely coupled)?

The only part of the latter that I'm not too sure of is for the dependencies to be instantiated on bootstrap level, outside of the MVC paradigm, before being injected. Not every controller uses the exact same dependencies besides the default parent ones. I would have to instantiate them all, which would also create a lot of overhead.

I've seen some existing frameworks do it like $this->load->model('model'); // CodeIgniter in the constructor, but I have no clue on why they're doing it like that.

Answer 1

I would suggest you inject the dependencies, so your controllers are less coupled to your framework. This will make a switch to another framework easier.

About instantiating dependencies: I suggest you use (or implement) a dependency injection container. This container should contain factories that can instantiate services.

In an ideal situation your controllers are services too (meaning they too have factories in the dependency injection container).

This way only the controller you need for a particular request will be instantiated, and therefor only its dependencies are instantiated.
When building you own framework, this means that after the routing phase (when the correct controller is known), the framework should grab that controller from the container. The container itself will make sure all dependencies that are needed will be provided.

Have a look at Pimple for an example of a simple dependency injection container.

PS: That line from CodeIgniter looks a lot like the service locator pattern. This pattern is similar to dependency injection, but does not provide full inversion of control.

Answer 2

Q: Where should i load/instantiate corresponding controller dependencies?

There are multiple ways. The load and instantiation concepts are basically "before/outside" and "after/inside".

Before and outside means, that you load the file containing a class (which you want to instantiate and pass to the controller), before you load the controller. But how do you know, what the controller needs, before loading the controller? Uh..

• Dependency Description Files

A description file comes into play, describing the wiring between your controller and it's dependencies. In other words, you can see the dependencies of your controller by looking at it's dependency description file. This concept is often used by Dependency Injection tools, which analyze the object and pull the dependencies names out automatically. It's also possible to maintain such a wiring configuration file manually. But it's tedious.

• Service Locator

A Service Locator is a instantiation helper for dependencies. Basically, it contains the same information like a dependency description file, but this time in form of a registry. The link between parts of your application becomes this registry.

Both strategies introduce overhead. It's a trade-off. When you change the perspective and look at things from an application with maybe 500+ classes, then you realize that a dependency injection tool is sometimes worth it.

• Manual Injection

via Constructor Injection.

After and inside means, that you load the file containing your controller and then start to care about the dependencies.

At this point the class is not instantiated, yet, but the autoloader might do it's dirty deeds behind the scene. He evaluates the use statements at the top of your controller file. The use statements declare namespaced classes, which the autoloader resolves to actuall files and loads them. You might then start to use these classes as dependencies in your controller. This is probably the easiest way to solve your problem and i strongly suggest looking into the topics autoloading with namespaces and use-statements.

When the class is instantiated, you have the following possiblities: use might use Setter Injection or Reference Injection to set the dependencies to the object. This requires that your Constructor Dependencies are already solved or your constructor is empty. It's possible to combine these strategies.

Q: What does this do $this->load->model('model'); // CodeIgniter?

CodeIgniter is a legacy application framework. It was created in times, when namespaced autoloading wasn't available. $this->load is a basic class loading helper. This is the opposite of an "auto"loader, (which surprise, surprise) loads things automatically.

CodeIgniters loader class is used to load various other classes, like libraries or files from the view, helpers, models or user defined stuff. This is again the concept of a registry. Here the registry just knowns where things are in your application layout and resolves them. So $this->load->model('model'); means that the modelfunction must have some piecies of information, about the position of model files in your application. You provide a model name and the path for the file is constructed by model. And this is exaclty what it does (except a bit of overhead): https://github.com/EllisLab/CodeIgniter/blob/develop/system/core/Loader.php#L223.