Database Connection Class constructor

Question

I'm just getting started with OOP PHP and all of the information out there is about a car that is red or blue...it's hard to get my head around the database connection only object as such.

I have a haunting suspicion that my __construct() shouldn't have the connection string in it and instead be it's own method inside the class.. but it works so....

Is it incorrect to define my connection class like below.. If it is wrong - how should it look?

class dbConnect {

    // Declare connection info for PDO
    private $dbType = 'mysql';
    private $dbHost = 'localhost';
    private $dbUser = 'user';
    private $dbPass = 'password';
    private $dbName = 'db';
    
    // Declare connection variable for object
    private $dbConn;
    
    // Construct object
    private function __construct() {

        // Create Database connection and assign it to object as dbConn
        $this -> dbConn = new PDO( $this -> dbType . ':' . 'host=' . $this -> dbHost . ';' . 'dbname=' . $this -> dbName , $this -> dbUser , $this -> dbPass );    
    } 
}

Your constructor is private, so you won't be able to instantiate your class from outside. Also think about passing the connection info to the constructor... — nice ass
– nice ass, Commented Feb 26, 2013 at 1:47

PeeHaa · Accepted Answer · 2013-02-26 09:25:29Z

I don't think what I think you are doing is very useful. It looks like you are going to have a database class. I just cannot see the advantage of doing it like that because PDO already is a class, so there is no need to extend it unless you have a very good reason to do so.

A much better option imho would be the initialize the PDO instance at bootstrap phase and inject the connection in the classes that need it;

$dbConnection = new PDO('mysql:host=localhost;dbname=db', 'user', 'password');

$someInstance = new ClassThatNeedsDatabase($dbConnection);
$someInstance->doSomething();

class ClassThatNeedsDatabase
{
    private $dbConnection ;

    public function __construct(PDO $dbConnection)
    {
        $this->dbCOnnection = $dbConnection;
    }

    public function doSomething()
    {
        $stmt = $this->dbConnection->prepare('UPDATE....');

        // etc
    }

}

On a generic note you may want to avoid using the new keyword inside other classes, because they introduce tight coupling. Which will hurt maintainability (it's hard to tell the class is used by looking at the class signature), testablity (you cannot easily swap the class) etc. If you really need to build new instances inside other classes (which in this specific case is really not needed imo as stated above) you may want to implement the factory pattern:

class Foo
{
    public function doSomething()
    {
    }
}

class FooFactory
{
    public function build()
    {
        return new Foo();
    }
}

class Bar
{
    private $fooFactory;

    public function __construct(FooFactory $fooFactory)
    {
        $this->fooFactory = $fooFactory;
    }

    public function soSomethingWhichNeedsToBuildAnInstance()
    {
        $foo = $this->fooFactory->build();
    }
}

This also prevent tight coupling of code.

_{_{The above naming sucks, but it is just to illustrate the point. :-)}}

Thank you for setting me straight. I'll just use the PDO as is! Sometimes obvious is too obvious when learning.

Martin · Accepted Answer · 2013-02-26 01:52:00Z

0

Yes, you should be extending the existing PDO object.

How about this as your base:

define('DB_USER', 'username');
define('DB_PASS', 'password');
define('DB_DSN', 'dsn');

class dbConnect extends PDO {           
  public function __construct($user = DB_USER, $pass = DB_PASS, $dsn = DB_DSN) {
    parent::__construct($dsn, $user, $pass, $options);
  }
}

answered Feb 26, 2013 at 1:52

Martin

6,7054 gold badges28 silver badges28 bronze badges

4 Comments

Ironcraze Over a year ago

out of curiousity why use define() instead of a variable?

Martin Over a year ago

Because you shouldn't hardcode credentials into classes, this will quickly become a pain when dealing with multiple servers, databases, when re-using code and is generally bad practice.

Ironcraze Over a year ago

Thanks...about define() - are there any security implications of having the constant always about?

Martin Over a year ago

Well it's possible for 3rd party code to read them more readily, but at the same time malicious foreign code could do much worse (allow people to tunnel in, send out your entire codebase, etc) so it's not any less secure than private variables.

Collectives™ on Stack Overflow

Database Connection Class constructor

2 Answers 2

1 Comment

4 Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

1 Comment

4 Comments

Your Answer

Sign up or log in

Post as a guest

Related