CODEWITHSUNDEEP
phpoopormdoctrine-ormdoctrine
Dennis
Dennis

Reputation: 8101

How do I use Doctrine from within my application, considering modern OOP practices?

Doctrine examples usually make use of Doctrine's $entityManager. Hence, whenever I need to do anything in my app with Doctrine, I need to get the entity manager into my code. But how? .... I can inject it into my class, but still I need to create manager somewhere first. I can also make it use PHP's trait which I put into my class to make it Doctrine-enabled.

What I have done in my OOP code is something like this -- I defined a class DoctrineConnector in its own namespace of DoctrineConnector, and inside the class I have a static function getEntityManager. Inside, I read Doctrine configuration, paths, parameters, and create an $entityManager, and then I return it to the caller.

Whenever I need to read or persist something in my Doctrine-unaware code, I do this:

//Pricing.php
use DoctrineConnector\DoctrineConnector;

class Pricing
{
    public function getPricing()
    {
        $entityManager = DoctrineConnector::getEntityManager();
        //further Doctrine code to read DB
    }
}

DoctrineConnector is now a dependency of Pricing. Obvious answer may be "inject $entityManager into Pricing". But Pricing is called from another class, and that other class is called from another class, etc so I will have to make essentially every class I call be aware of the ORM variable. I want to avoid that.

Is what I currently have just fine or is there a better way?

How ZF2 module system does it

Out of curiosity I looked into how ZF2 manages Doctrine module and from DoctrineORMModule, it uses ServiceLocator pattern to call the inside of controller. So one of the leading framework module systems is not that far off from my implementation.

Upvotes: 1

Views: 283

Answers (2)

Dennis
Dennis

Reputation: 8101

Singleton Pattern

Adapted from http://www.phptherightway.com/pages/Design-Patterns.html

namespace ABC;

use Doctrine\ORM\Tools\Setup;
use Doctrine\ORM\EntityManager;

class DoctrineConnector
{
    private static $instance;

    public static function getEntityManager()
    {
        if (null === static::$instance)
        {
            // Doctrine Config (from Docs)
            include 'config/doctrine-config.php';
            $config = Setup::createAnnotationMetadataConfiguration($paths, $isDevMode);
            static::$instance = EntityManager::create($dbParams, $config);
        }

        return static::$instance;
    }

    protected function __construct()
    {}

    private function __clone()
    {}

    private function __wakeup()
    {}
}

//to call
$em  = DoctrineConnector::getEntityManager();

//if used later in the code - calls same instance
$em  = DoctrineConnector::getEntityManager();

Upvotes: 1

Karolis
Karolis

Reputation: 2618

There are a couple of popular ways to get a dependency inside the class.

  • make the class aware of project environment and let the class locate the dependency (what you did with DoctrineConnector)
  • use dependency injection (what you are trying to achieve)

In your case, your class now depends on DoctrineConnector and is going to work as long as it can find DoctrineConnector. If you port your class to another project where DoctrineConnector isn't defined, your code isn't going to work.

Normally dependency injection is a decision you make when you start your new project. If you already have a large hierarchy of classes, the injection code will bubble up your hierarchy and there is going to be a lot of work refactoring your code. You might want to think wether you really need that and wether it's going to be worth your time.

If you are writing code for one particular app and have no plans to migrate it to other projects, then you probably don't care about dependency injection. Actually, without injection your code is going to be shorter and easier (faster) to write and understand. On the other hand if you have pieces of code that you want to be independent of the app, you might use dependency injection only for those code segments.

If you haven't injected ORM yet, chances are that the rest of the code is tightly coupled with your app as well, and injecting entityManager isn't going to make your code much more portable.

Upvotes: 0

Related Questions