Dependency Injection of Dynamically Called Class - php

Question

As part of my learning process, I'm building my own MVC framework which not only helps me learn, but hopefully it will help me keep my future code cleaner and more maintainable. Currently I'm trying to get my head around dependency injection.
Here's what I'm doing:
My ultra simple MVC framework explodes $_SERVER['REQUEST_URI'] and expects the first element to be the class, the second element to be the method, and any remaining elements to be an array of parameters. This all works splendidly.
I have a base Controller class which all my core classes extend. The sole functionality of this Controller class is to facilitate the requiring of and instantiating of Model classes and Views, like so:
class Controller {
protected $modelsPath = ROOT . 'app' . DS . 'models' . DS;
protected $viewsPath = ROOT . 'app' . DS . 'views' . DS;
public function model($model) {
$model = ucfirst(strtolower($model));
if (file_exists($this->modelsPath . $model . ".model.php")) {
require_once $this->modelsPath . $model . ".model.php";
return new $model;
} else {
return false;
}
}
public function view($view, $data = []) {
$view = strtolower($view);
if (file_exists($this->viewsPath . $view . DS. $view . "View.php")) {
require_once $this->viewsPath . $view . DS . $view . "View.php";
} else {
die('View does not exist');
}
}
This all works as anticipated.
Then it occurred to me that I could use the get_called_class() function in my Controller class to in essence auto-load a supporting Model class if it exists. So I added this code as a __construct function in my Controller class:
protected $modelToCall = null;
public function __construct() {
$modelToCall = ucfirst(strtolower(get_called_class()));
if (file_exists($this->modelsPath . $modelToCall . ".model.php")) {
require_once $this->modelsPath . $modelToCall . ".model.php";
$this->modelToCall = new $modelToCall;
}
}
Because this is called in my base controller which is extended by whatever class I've just called, this allows me to use my Model's methods like so from my parent class:
class Tests extends Controller {
public function test() {
$this->modelToCall->testsModelMethod();
}
}
Now my question:
Is this considered dependency injection? If not, is there a way to properly accomplish dependency injection from a model that has been dynamically loaded in such a way?
Perhaps there's no benefit in automatically instantiating in my base controller, versus simply instantiating from my parent controller?
As I said, I'm learning, and I guess in this case I'm simply seeking guidance from people FAR more experienced and knowledgeable than me so I hopefully get my head around this subject and avoid grave programming mistakes that will bite me later.
Thank you in advance for your consideration and your patience.

Answer 1

Ok, I think I've answered my own question.
It's perfectly normal and expected to call a model from the model's controller, which is what my Controller is automatically doing. But this is NOT dependency injection, as #yivi pointed out.
However, what follows IS dependency injection, I think.
I stepped back to the boostrap of my simple MVC framework and instantiated my Database class at the top. I was then able to pass this into my Controller class and thru that I am able to inject it into each model that is dynamically loaded, like so:
public $database;
protected $modelToCall;
public function __construct($database) {
$this->database = $database;
$tmpClass = strtolower(get_called_class());
$modelToCall = rtrim(ucfirst($tmpClass), 's');
if (file_exists($this->modelsPath . $modelToCall . ".php")) {
require_once $this->modelsPath . $modelToCall . ".php";
$this->modelToCall = new $modelToCall($database);
}
}
Now, from within any controller, I'm able to call that controller's model methods by simply using $this->modelToCall and I have full access to my Database class from each model, and I only had to instantiate it once.
It works, but do I have my terminology correct now?
Thanks in advance.