检索页面内的连接：PDO和PHP类

Question

I'm new to classes and PDO as well. I'm trying to write a class with separate functions for connecting to the db and closing the connection so that, in a page, I can:

1. Open the connection with the $db->connOpen
2. Perform all the queries I need inside the page

3. Close the connection at the end of the script with $db->connClose

    class database { private $host = ''; private $db_name = ''; private $charset = ''; private $username = ''; private $password = ''; public function setHost($host) { $this->host = $host; } public function setDbName($db_name) { $this->db_name = $db_name; } public function setUser($username, $password) { $this->username = $username; $this->password = $password; } public function connOpen() { try { $dsn = "mysql:host=$this->host;dbname=$this->db_name;charset=$this->charset"; $db = new PDO($dsn, $this->username, $this->password, array(PDO::ATTR_PERSISTENT => true)); $db->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION); } catch (PDOException $e) { echo $e->getMessage(); } } public function connClose() { $db = null; } } 

I guess the problem is regarding more the classes syntax than the PDO, since to fire a query like the one below into the page I would need to instantiate again the class PDO , doubling the connection to the db.

$stmt = $dbo->prepare('SELECT * FROM products WHERE id=:id');
$stmt->execute(array(':id' => $id));
$res  = $stmt->fetchAll(PDO::FETCH_ASSOC);

My questions are:

1. How can achieve what I want using a class like the one above?
2. Is it correct, in this case, using a persistent connection ?

Thanks

Answer 1

I am using this with one singlton class which give me db ojbect and then I am using that object to query in other classes;

    <?php
    class db{
    /*** Declare instance ***/
    private static $instance = NULL;
    /**
     *
     * the constructor is set to private so
     * so nobody can create a new instance using new
     *
     */
    private function __construct() {
        /*** maybe set the db name here later ***/
    }
    /**
     *
     * Return DB instance or create intitial connection
     *
     * @return object (PDO)
     *
     * @access public
     *
     */
    public static function getInstance() {
        if (!self::$instance)
        {
            self::$instance = new \PDO("mysql:host=".databaseHost.";dbname=".databaseName."", databaseUserName,databasePassword);;
            self::$instance-> setAttribute(\PDO::ATTR_ERRMODE, \PDO::ERRMODE_EXCEPTION);
            self::$instance-> setAttribute(\PDO::ATTR_EMULATE_PREPARES, false);
        }
        return self::$instance;
    }
    /**
     *
     * Like the constructor, we make __clone private
     * so nobody can clone the instance
     *
     */
    private function __clone(){
    }
} /*** end of class ***/
?>

class where i am querying using db object

<?php
class posts {

    public function getPostOfUserId($userId,$offset=0,$limit=NULL){
        $helperString=" ";
        if(!empty($limit))
            $helperString=" LIMIT $offset, $limit ";
        $executor= db::getInstance()->prepare("SELECT posts.*,users.facebook_id, users.first_name as post_by FROM posts JOIN tagged_friends ON posts.id = tagged_friends.post_id JOIN users ON posts.user_id = users.id WHERE tagged_friends.user_id = :user_id ORDER BY posts.id DESC ".$helperString, array(\PDO::ATTR_CURSOR => \PDO::CURSOR_FWDONLY));
        $executor->execute(array(':user_id'=>$userId));
        $posts=$executor->fetchAll(\PDO::FETCH_ASSOC);
        if(!empty($posts))
            return $posts;
        else
            return ;
    }
}

Answer 2

For some reason, most people who wants to learn OOP starts with a database wrapper that implements singleton and interferes with error handling.

My tip is that you treat the database connection as any other variable:

class Post {
    function getByUserId(PDO $connection, $user_id) {
    }
}

$database = new PDO(...);
$post->getByUserId($database, 123);

This is called dependency injection.

And don't waste time and energy writing code to avoid useful features, such as:

• Centralised error handling
• Being able to connect to more than one database

Only care about writing a database wrapper when you really have real features to add on top of PDO. I can think of:

• Convert dates to DateTime objects automatically
• Pass all queries to a logger
• Throw custom exceptions on interesting events, such as duplicate index violation

... and even then be extremely careful to not make PDO worse ;-)