PHP design pattern using Dependancy Injection and shared variable?

Question

I am going to try to explain this as best as I can, forgive me if parts don't make total sense. I am building a PHP library/framework for educational purposes. I was building it using the singleton pattern but ran into some problems and also seem to read lately that it shouldn't be used as it isn't very testable, (and although I am not worried about this being testable, I would like to learn how to do it) and instead should use dependency injection.

What I want is a shared variable, if you will, which houses many different classes. For instance $app->database; $app->views; $app->session; etc., and am not sure if I am doing this right. All classes are also being autoloaded.

I have the bootstrap/start.php which initializes the main variable (is there a name for this?) with:

$app = new App(new Database, new Views, new Session);

in the App.php class I am using essentially:

 public $database;
 public $views;
 public $session

public function __construct(Client $client, Views $views, Session $session)
{
     $this->database = $database;
     $this->views = $views;
     $this->session = $session;
}

My problem is this: Am I supposed to be initializing all of the classes in the constructor like that? And the big one...how do I use the $database variable in, for example, my Views.php class without creating a whole new instance which may overwrite some of the properties in the Database class?

Would appreciate some insight on this a lot.

Answer 1

What you should really know about MVC-like architectures, is that the entire point they are based on is called Separation of Concerns (SoC).

Why would you ever access a database connection in views? Obviously because you want to perform a query and display results right there. That's what breaks the SoC. In order to display the data, you have to access the database connection in your model, parse somehow if needed, and then simply pass prepared array to views, so that views don't even know that such thing as database exists, they only know that there's an array, which needs to be displayed somehow. That approach introduces one major advantage - you can easily swap database engines (with SOAP/REST, Mongo, whatever), without touching a view!

As for your problem, you can solve this by creating an abstract class, which is gonna be called AbstractApplication and put all those initialization logic there. And then you can simply inherit from this base class.

Another way you have, is to approach it with so-called Service Locator. You create one wrapper, put all your dependencies there, and then you simply inject the Service Locator for classes that require it. This is not the best way, but its the only way clean way to handle a large list of dependencies (in real world-scenario, you'd have more than 4 arguments to be injected)

Answer 2

Your code looks good but i would recommend these changes, make the variable private and produce getter and setters.

<?php
Class App {

private $database;
private $views;
private $client;
private $session;

/**
 * 
 * @param type $database
 * @param type $views
 * @param type $client
 * @param type $session
 */
function __construct($database, $views, $client, $session) {
    $this->database = new $database;
    $this->views = new $views;
    $this->client = new $client;
    $this->session = new $session;
}

/**
 * 
 * @return type
 */
function getDatabase() {
    return $this->database;
}

/**
 * 
 * @return type
 */
function getViews() {
    return $this->views;
}

/**
 * 
 * @return type
 */
function getClient() {
    return $this->client;
}

/**
 * 
 * @return type
 */
function getSession() {
    return $this->session;
}

/**
 * 
 * @param type $database
 */
function setDatabase($database) {
    $this->database = $database;
}

/**
 * 
 * @param type $views
 */
function setViews($views) {
    $this->views = $views;
}

/**
 * 
 * @param type $client
 */
function setClient($client) {
    $this->client = $client;
}


/**
 * 
 * @param type $session
 */
function setSession($session) {
    $this->session = $session;
}

}
//and in bootstrap or where you loading just do this and make database, view and all other singleton.
$database = database::getInstance();
$views = views::getInstance();
$client = client::getInstance();
$session = session::getInstance();
$App = new App($database, $views, $client, $session);