More Than 1 __construct($db) 会尝试连接多个数据库吗？

Question

I have a PDO object which connect to database and I have 5 classes which requires database connection for their methods. For every class I'm constructing a $db . Is it true approach? If not, what should I do?

try {
    $config['db'] = array(
        'host'     => 'localhost',
        'username' => 'xxxxxx',
        'password' => 'xxxxxx',
        'dbname'   => 'table_name'
    );
    $db = new PDO('mysql:host=' . $config['db']['host'] . ';dbname=' . $config['db']['dbname'], $config['db']['username'], $config['db']['password'], array(PDO::MYSQL_ATTR_INIT_COMMAND => "SET NAMES utf8"));
} catch (Exception $e) {
    echo "!";
}

//classA
class ClassA{
    private $db;
    public function __construct(PDO $db){
        $this->db = $db;
    }

    public function methodA1($someId){
        $res = $this->db->query("SELECT * FROM bla WHERE id = $someId ");
        return $res->fetchAll(PDO::FETCH_ASSOC);
    }
}

//classB
class ClassB{
    private $db;
    public function __construct(PDO $db){
        $this->db = $db;
    }

    public function methodB1($someId){
        $res = $this->db->query("SELECT * FROM bla WHERE id = $someId ");
        return $res->fetchAll(PDO::FETCH_ASSOC);
    }
}

Then I crate new objects for these classes like

$classAObject = new ClassA($db);
$classBObject = new ClassB($db);

While I creating my object, Am I connecting to DB 2 times?

Answer 1

It connects once.

You are using the same PDO object so it will just use the object you initialize when you include the file.

I suggest you make it a singleton so when you are using the PDO object you always get the object that has been initialized which would be used by all connections.

Model class

class Model {
    private $_mysql;

    public function __construct() {
        //Get "singleton" instance of the DatabaseConnector (shared between all Models)
        $this->_mysql = DatabaseConnector::getInstance();
    }
}

DatabaseConnector class

class DatabaseConnector extends Singleton {
    private $_mysql;

    public function __construct() {
        $this->_mysql = new PDO(...);
    }

    public function beginTransaction() { 
        return $this->_mysql->beginTransaction();
    }

    public function commit() { 
        return $this->_mysql->commit();
    }

    public function rollback() { 
        return $this->_mysql->rollback();
    }
}

Singleton class

class Singleton
{
 /**
 * @var Singleton The reference to *Singleton* instance of this class
 */
 private static $instance;

 /**
 * Returns the *Singleton* instance of this class.
 *
 * @return Singleton The *Singleton* instance.
 */
public static function getInstance()
{
    if (null === static::$instance) {
        static::$instance = new static();
    }

    return static::$instance;
}

/**
 * Protected constructor to prevent creating a new instance of the
 * *Singleton* via the `new` operator from outside of this class.
 */
protected function __construct(){}

/**
 * Private clone method to prevent cloning of the instance of the
 * *Singleton* instance.
 *
 * @return void
 */
private function __clone(){}

/**
 * Private unserialize method to prevent unserializing of the *Singleton*
 * instance.
 *
 * @return void
 */
private function __wakeup(){}

}

You can check this for more detail singleton

Besides, you'd better separate your files to have only one single class in one file.

Answer 2

如果你给每个对象传递一个对同一个$db对象的引用，你所做的就是初始化对象的属性， PDO $db等于传递的 PDO 对象，所以不，我不相信你会连接到数据库不止一次。