PHP: Database Connection Class Constructor Method

Question

I'm new to OOP. Originally I was defining variables and assigning values to them within the class and outside of the constructor, but after an OOP lesson in Java today, I was told this is bad style and should be avoided.

Here is my original PHP database connection class that I mocked-up:

class DatabaseConnection {
    private $dbHost = "localhost";
    private $dbUser = "root";
    private $dbPass = "";
    private $dbName = "test";

    function __construct() {    
        $connection = mysql_connect($this->dbHost, $this->dbUser, $this->dbPass)
            or die("Could not connect to the database:<br />" . mysql_error());
        mysql_select_db($this->dbName, $connection) 
            or die("Database error:<br />" . mysql_error());
    }
}

Is the above considered okay? Or is the following a better way?

class DatabaseConnection {
    private $dbHost;
    private $dbUser;
    private $dbPass;
    private $dbName;

    function __construct() {
        $this->dbHost = "localhost";
        $this->dbUser = "root";
        $this->dbPass = "";
        $this->dbName = "test";

        $connection = mysql_connect($this->dbHost, $this->dbUser, $this->dbPass)
            or die("Could not connect to the database:<br />" . mysql_error());
        mysql_select_db($this->dbName, $connection) 
            or die("Database error:<br />" . mysql_error());
    }
}

What should I be focusing on to make sure I am understanding OOP correctly?

Solution 1

Well, it's not going to run quite yet. You need to change your variables so that they match your connection params:

$dbHost = "localhost";

Should be

$this->dbHost = 'localhost';

I normally don't put my login params inside of the class at all. I would pass them into the constructor when the object is created. Use an outside config file so you can actually use this class on more than one build. :)

Update::

Okay, so here are a few little OOP configuration gold-nuggets that help you build a dynamic Database class.

• Check out http://redbeanphp.com/ It will allow you to do a psuedo ORM style of data modelling. Super easy to install, and ridiculously easy to get your database up and running. http://redbeanphp.com/manual/installing

• Create a configuration file that contains things like constants, template setups, common functions, and an AUTOLOADER Configuration files are key when working in version controlled environments. :)

• Build your Database class as an abstract class http://php.net/manual/en/language.oop5.abstract.php

  abstract class Database
  {
    public function update()
    {
    }
  
    public function deactivate()
    {
    }
  
    public function destroy()
    {
    }
  
    //etc.
  }
  
  class MyAppObject extends Database
  {
  }
  

• Put all of your class files into a library folder, and then put your configuration file into that library. Now, to make your life easier you can use an autoloader function to bring your classes to life whenever you need them, without having to include any specific class. See below:

  //note: this is never explicitly instantiated
  //note: name your files like this: MyAppObject.class.php  
  function my_fancypants_autoloader( $my_class_name )
  {
    if( preg_match( "%^_(Model_)%", $my_class_name ) ) return;
    require_once( "$my_class_name.class.php" );
  }
  spl_autoload_register( 'my_fancypants_autoloader' );
  

  • Now all you have to do is include one configuration file in your .php files to access your classes.

Hope that points you in the right direction! Good luck!

Solution 2

First of all: this is pointless.

You are creating an object wrapper for the 10+ year old mysql_* function. This php extension is no longer maintained and the process of deprecation has already begun. You should not use this API for any new projects in 2012.

Instead you should learn how to use PDO or MySQLi and work with prepared statements.

That said .. lets take a look at your code:

• Constructor should receive all the parameters required for creating new instance, parameters should not be hard-coded in the class definition. What if you need to work with two databases at the same time ?
• When connection is created, it should be stored in object's scope variable. Something along the lines of $this->connection = mysql_conn.... Instead you store it in local variable, which you "loose" right after constructor is done.
• You should not use private variables for everything. They are not visible to classes which would extend your original class. Unless it is intentional, you should choose protected for this.
• The or die('..') bit most go. Do not stop the whole application if connection fails. Instead you should throw an exception, which then can be handled outside of the constructor.

Comments

[JT Smith]

and if at all possible (in most cases it is possible) don't use the root user!!! If ever a security breach, your DB is toast. Create a second account with minimal permissions. My secondary account can't even delete records. If I need to be able to delete records, I'll create another Database class, with a user with just that permission, and only call it for the methods I need.

[tereško]

If you use all-static classes, then it is not OOP. It's just same old procedural code with global variables. You just wrap it in a class, which acts like namespace.

[tereško]

And, please ! FFS, stop using the @ operator, where it is not required. Hiding errors is usually the worst thing you can do.

[JT Smith]

I use it there because my users don't need to know that I couldn't establish a db connection specifically just to 'Try again later'. This is the only instance I use @

[tereško]

Thats why we have ini_set('dispaly_errors', false); for the production code. User does not need to know, but maintainer needs. As for that "one connection" c**p, Please go and learn what dependency injection is ..

[Vikram]

mysql_connect is discouraged: php.net/manual/en/function.mysql-connect.php

[M H]

If he wants to connect to another database he can specify the database name in he query...don't be such a dick man. geez

[tereško]

@michaelhanon did you actually looks at his code? Just naming connection will have no benefit. And you probably should read about OCP to not sound like such a tool.

[dbf]

@michaelhanon I would have bashed far worse than terēsko did, specially those implying useless stuff in there comments ..