Dependency Injection or instantiating database class object - php

Question

this may seem like a broad question, but what are the practical uses of dependency injection vs instantiating the class inside a __construct() call?
I essentially instantiate my database object like this in classes that require it:
class Example {
private $db;
function __construct() {
$this->db = db::instance();
}
}
I've used dependency injection in the past and don't know if it's fine to simply share the resource, take the following for example from a Model.
Class ExampleModel extends Model {
function do_something() {
$user = new User($db);
$user->do_some_stuff();
}
}
So what would be more beneficial to use? Are there any performance related pros/cons? If you need more clarification to the questions, please ask.
There is a lot of positive & negative views on Dependency Injection:
Dependency Injection is EVIL
Dependency Injections Pros/Cons/Questions
Dependency Injection discourages object orientated programming
For anyone interested, this is what the db::instance() looks like:
public static function instance() {
if (!self::$instance) {
$config = get_config();
self::$instance = new self(
$config['database']['host'], $config['database']['user'], $config['database']['pass'], $config['database']['db']
);
}
return self::$instance;
}

Answer 1

Summarising my comments - for me, if you inject the dependency then Example doesn't need to know what the class you're injecting is. If you instantiate the class from within Example then you need to know exactly what the class is.
Is this a problem/benefit? Depends on you, your preferences and your application. I tend to prefer the more abstract approach.
For example, if you did the following:
class Example {
public function __construct(Injected $inj) {
$this->db = $inj;
}
}
... you can see that you type hint what you are expecting $inj to be. This can either be the type of the class that $inj directly is, or an interface that $inj implements - in which case you will know that $inj adheres to a set of instructions that you expect.
Take the following example:
interface Db {
public function fetch();
public function insert();
}
class MyDb implements Db {
public function fetch() {
// ...
}
public function insert() {
// ...
}
}
If you type hint the interface in your Example class, you don't need to know that $inj is a MyDb class, but that it implements Db - the important part is knowing that the class will follow a defined set of rules (an interface) e.g. that is will implement a fetch() and an insert() function. Nevermind the actual class - you just want the content.
class Example {
public function __construct(Db $inj) {
var_dump(get_class($inj)); // string(4) "MyDb"
}
}
This is all an example of injection and its benefits. The equivalent for direct instantiation would mean that your Example needs to know about MyDb:
class Example {
public function __construct() {
$this->db = new MyDb; // implements Db, but you need to know exactly
// what the class is
}
}
This method removes your flexibility for changing MyDb to YourDb without having to change the Example class.
Again, depends on your situation. If your application has the likelihood to change or has flexibility within components, you might want to use injection. If it's reasonably static then you could instantiate directly.
My final comment would be that when you are unit testing your code, it's much easier to mock an injected object than a directly instantiated one.