PHP Recommend way to initiate database connection from Class Instance

Question

I have the following classes in PHP:

class Database {
    ...
}

class Product {
    public function __construct() {
        ...
    }
}

Currently I am thinking of having a global Instance of the database class in which in the __construct method of the Product class, I would check to see if the object had been initialized as follows:

class Product {
    public function __construct() {
         if (!isset($db)) {
            throw new Exception ('Database object not initialized.');
        }
        ...
    }
}

Is this a good implementation? If not, what do you recommend?

@tadman Would you recommend using an ORM for the development of an extensive Web application? — Omari Celestine, Aug 03 '18 at 16:45
Suggest researching more, then asking more specific question if needed. Here is a good resource: https://stackoverflow.com/questions/4595964/is-there-a-use-case-for-singletons-with-database-access-in-php/4596323#4596323 — ficuscr, Aug 03 '18 at 16:48
In my project [Grumpy-Free-Framework](https://github.com/GrumpyCrouton/grump-free-framework#models) I'm able to do this in Models by pulling saved database information from my base instance after declaring a variable that contains the database object. — GrumpyCrouton, Aug 03 '18 at 16:53

score 1 · Accepted Answer · answered Aug 03 '18 at 16:47

It seems to me that you are trying to build your own ORM and to practice is good. For large projects, and for greater comfort think about adopting some ORMs like Doctrine, Eloquent, etc (depending on the framework).

An approach that does not use dependency injection may need to instantiate the database object itself in a constructor. Let's give an example that utilizes a singleton to provide the DB object.

class Product {
    private $pdo = null;
    // other product properties here

    public function __construct() {
        // get db
        try {
            // set PDO object reference on this object
            $this->pdo =  PDOSingleton::getInstance();
        } catch (Exception $e) {
            error_log('Unable to get PDO instance. Error was: ' .
                $e->getMessage();
            // perhaps rethrow the exception to caller
            throw $e;
        }
        // query DB to get user record
    }

    // other class methods
}

// example usage
$product = new Product(1);

When using dependency injection, that might instead look like this:

class Product {
    private $pdo = null;
    // other product properties here

    // pass PDO object to the constructor. Enforce parameter typing
    public function __construct(PDO $pdo) {
        $this->pdo = $pdo;
        // query DB to get product record
    }

    // other class methods
}

// example usage
// instantiate PDO object. This probably happens near beginning
// of code execution and might be the single instance you pass around
// the application
try {
    $pdo = new PDO(...);
} catch (PDOException $e) {
    // perhaps log error and stop program execution
    // if this dependency is required
}

// somewhere later in code
$product = new Product($pdo);

This may seem like only a subtle difference, but developers who use this approach like it because it:

decouples the consuming class from the details of how to instantiate the dependency. Why should the user class have to know which singleton to use in order to get it's PDO dependency? All the class should care about is knowing how to work with the dependency (i.e what properties and methods it has), not how to create it. This more closely follows the single responsibility principle which is typically desired in OOP, as the user class only has to deal with instantiating a user representation, not also with instantiating its dependencies.
eliminates duplicate code across classes that need the dependency as you don't need all the handling in each class around instantiating/creating the dependency. In the example code, I eliminate the need to potentially handle failed DB instantiation within the constructor, as I know I already have a valid PDO object passed as parameter (if I did not get one passed, I would get invalid argument exception).

With reference to the second form what I want is to avoid having to pass the database instance everytime I instanciate the Product class. What if I have like an instance of the database class in a header file which is included on all pages and use `global $db;` in the constructor of the Product class? — Omari Celestine, Aug 03 '18 at 17:02

PHP Recommend way to initiate database connection from Class Instance

1 Answers1