在php面向对象编程中，频繁地在每个方法中创建新的pdo数据库连接会导致资源浪费和代码冗余。本教程将介绍如何通过在类的构造函数中一次性创建pdo连接，并将其存储为类属性，从而实现连接的复用。通过这种方式，不仅能提高代码效率和可维护性，还能确保数据库资源被有效管理，避免不必要的连接开销。
引言：重复创建数据库连接的问题
在开发PHP应用程序时，尤其是采用面向对象（OOP）范式时，数据库连接是不可或缺的一部分。然而，初学者常犯的一个错误是在每个需要与数据库交互的方法内部都重新实例化一个PDO对象，例如：
protected function insertUser(){
$connectionvar = new PDO('mysql:host='. $this->host .';dbname='.$this->db, $this->user, $this->password);
// 后续的SQL执行代码
}这种做法存在显著问题：
- 资源浪费： 每次调用该方法都会创建一个全新的数据库连接。数据库连接的建立是耗费资源的操作，频繁创建会增加服务器负载，降低应用程序性能。
- 代码冗余： 数据库连接的实例化代码在多个方法中重复出现，违反了DRY（Don't Repeat Yourself）原则，使得代码难以维护和修改。
- 连接管理复杂： 无法有效管理连接池或实现长连接，也难以统一处理连接错误。
核心解决方案：将PDO连接存储为类属性
解决上述问题的关键在于，只创建一次数据库连接，并将其存储在类的属性中，以便在整个对象生命周期中复用。 最常见且推荐的做法是在类的构造函数中初始化PDO连接，并将其赋值给一个受保护的（protected）或私有的（private）类属性。
以下是一个示例，展示如何构建一个基础的数据库连接类：
立即学习“PHP免费学习笔记（深入）”；
<?php
class DB
{
/**
* @var PDO 数据库连接实例
*/
protected PDO $connection;
/**
* 构造函数，在对象创建时建立数据库连接
*
* @param string $host 数据库主机名
* @param string $db 数据库名称
* @param string $user 数据库用户名
* @param string $password 数据库密码
*/
public function __construct(string $host, string $db, string $user, string $password)
{
try {
$dsn = "mysql:host={$host};dbname={$db};charset=utf8mb4";
$options = [
PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION, // 错误模式：抛出异常
PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC, // 默认获取模式：关联数组
PDO::ATTR_EMULATE_PREPARES => false, // 禁用模拟预处理语句
];
$this->connection = new PDO($dsn, $user, $password, $options);
} catch (PDOException $e) {
// 在生产环境中，应记录错误而非直接输出
throw new PDOException("数据库连接失败: " . $e->getMessage(), (int)$e->getCode());
}
}
}在这个DB类中：
- $connection 被声明为一个protected类型的PDO对象属性。
- __construct方法负责接收数据库连接参数，并在此处仅执行一次new PDO()操作。
- 连接成功后，将PDO实例赋值给$this->connection属性。
- 添加了try-catch块来捕获PDOException，以更好地处理连接错误。
在类方法中访问和使用连接
一旦PDO连接被存储为类属性，任何继承自DB类或通过依赖注入获得DB实例的类，都可以在其方法中通过$this->connection来访问这个已建立的连接，而无需再次实例化。
例如，如果你有一个用户管理类UserManager，它需要进行CRUD操作：
<?php
class UserManager extends DB
{
/**
* 插入新用户到数据库
*
* @param string $username 用户名
* @param string $email 邮箱
* @param string $password 密码（应加密存储）
* @return bool 插入是否成功
*/
public function insertUser(string $username, string $email, string $password): bool
{
// 直接使用父类中已建立的数据库连接
$stmt = $this->connection->prepare("INSERT INTO users (username, email, password) VALUES (?, ?, ?)");
return $stmt->execute([$username, $email, $password]);
}
/**
* 根据用户ID获取用户信息
*
* @param int $userId 用户ID
* @return array|false 用户信息数组或false
*/
public function getUserById(int $userId): array|false
{
$stmt = $this->connection->prepare("SELECT id, username, email FROM users WHERE id = ?");
$stmt->execute([$userId]);
return $stmt->fetch(); // 默认PDO::FETCH_ASSOC
}
// 其他CRUD方法...
}
// 示例使用
$dbHost = 'localhost';
$dbName = 'test_db';
$dbUser = 'root';
$dbPass = 'password';
try {
$userManager = new UserManager($dbHost, $dbName, $dbUser, $dbPass);
$isInserted = $userManager->insertUser('john_doe', 'john@example.com', 'hashed_password');
if ($isInserted) {
echo "用户插入成功！\n";
}
$user = $userManager->getUserById(1);
if ($user) {
echo "获取用户ID为1的信息：\n";
print_r($user);
} else {
echo "未找到用户ID为1的信息。\n";
}
} catch (PDOException $e) {
echo "操作失败: " . $e->getMessage() . "\n";
}
?>通过这种方式，UserManager类及其所有方法都可以共享同一个数据库连接，避免了重复实例化PDO对象。
最佳实践：构建专门的数据库交互层
为了进一步解耦和提高代码的复用性，最佳实践是让DB类不仅负责连接管理，还提供通用的数据库查询执行方法。这样，其他业务逻辑类（如UserManager）就不需要直接操作prepare、execute等方法，而是调用DB类提供的更高级别的接口。
修改DB类，添加一个通用的查询方法：
<?php
class DB
{
protected PDO $connection;
public function __construct(string $host, string $db, string $user, string $password)
{
try {
$dsn = "mysql:host={$host};dbname={$db};charset=utf8mb4";
$options = [
PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION,
PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC,
PDO::ATTR_EMULATE_PREPARES => false,
];
$this->connection = new PDO($dsn, $user, $password, $options);
} catch (PDOException $e) {
throw new PDOException("数据库连接失败: " . $e->getMessage(), (int)$e->getCode());
}
}
/**
* 执行一个SQL查询并返回所有结果（适用于SELECT）
*
* @param string $sql SQL查询语句
* @param array $parameters 绑定到SQL语句的参数数组
* @return array 查询结果集
*/
public function runQueryAndGetResult(string $sql, array $parameters = []): array
{
$statement = $this->connection->prepare($sql);
$statement->execute($parameters);
return $statement->fetchAll();
}
/**
* 执行一个SQL查询并返回单行结果（适用于SELECT单行）
*
* @param string $sql SQL查询语句
* @param array $parameters 绑定到SQL语句的参数数组
* @return array|false 单行结果数组或false
*/
public function runQueryAndGetSingleResult(string $sql, array $parameters = []): array|false
{
$statement = $this->connection->prepare($sql);
$statement->execute($parameters);
return $statement->fetch();
}
/**
* 执行一个SQL语句并返回受影响的行数（适用于INSERT, UPDATE, DELETE）
*
* @param string $sql SQL语句
* @param array $parameters 绑定到SQL语句的参数数组
* @return int 受影响的行数
*/
public function runStatement(string $sql, array $parameters = []): int
{
$statement = $this->connection->prepare($sql);
$statement->execute($parameters);
return $statement->rowCount();
}
/**
* 获取最后插入的ID
*
* @return string|false
*/
public function getLastInsertId(): string|false
{
return $this->connection->lastInsertId();
}
}现在，UserManager类可以不再继承DB类，而是通过依赖注入的方式接收DB实例。这是一种更灵活、更推荐的实践，因为它降低了类之间的耦合度。
<?php
// 假设 DB 类已定义如上
class UserManager
{
private DB $db; // 持有 DB 类的实例
/**
* 构造函数，通过依赖注入接收 DB 实例
*
* @param DB $db 数据库操作对象
*/
public function __construct(DB $db)
{
$this->db = $db;
}
public function insertUser(string $username, string $email, string $password): bool
{
$sql = "INSERT INTO users (username, email, password) VALUES (?, ?, ?)";
$affectedRows = $this->db->runStatement($sql, [$username, $email, $password]);
return $affectedRows > 0;
}
public function getUserById(int $userId): array|false
{
$sql = "SELECT id, username, email FROM users WHERE id = ?";
return $this->db->runQueryAndGetSingleResult($sql, [$userId]);
}
public function getAllUsers(): array
{
$sql = "SELECT id, username, email FROM users";
return $this->db->runQueryAndGetResult($sql);
}
// 其他CRUD方法...
}
// 示例使用
$dbHost = 'localhost';
$dbName = 'test_db';
$dbUser = 'root';
$dbPass = 'password';
try {
$db = new DB($dbHost, $dbName, $dbUser, $dbPass); // 只创建一次 DB 实例
$userManager = new UserManager($db); // 将 DB 实例注入 UserManager
$isInserted = $userManager->insertUser('jane_doe', 'jane@example.com', 'another_hashed_password');
if ($isInserted) {
echo "用户 Jane Doe 插入成功！\n";
}
$user = $userManager->getUserById(2);
if ($user) {
echo "获取用户ID为2的信息：\n";
print_r($user);
} else {
echo "未找到用户ID为2的信息。\n";
}
$allUsers = $userManager->getAllUsers();
echo "所有用户信息：\n";
print_r($allUsers);
} catch (PDOException $e) {
echo "操作失败: " . $e->getMessage() . "\n";
}
?>通过这种分层设计：
- DB类专注于数据库连接和底层查询执行。
- UserManager类专注于用户相关的业务逻辑，不关心数据库连接的具体实现。
- 应用程序的其他部分可以通过DB类的实例来执行各种数据库操作，而无需重复创建连接。
总结与注意事项
通过在类的构造函数中一次性创建并存储PDO数据库连接为类属性，可以有效避免重复创建连接带来的性能问题和代码冗余。进一步地，将数据库操作封装在一个专门的DB类中，并通过依赖注入的方式将其提供给其他业务逻辑类，是实现高内聚、低耦合、可维护和可测试代码的最佳实践。
注意事项：
- 错误处理： 始终在PDO连接和查询执行时使用try-catch块来捕获PDOException，并妥善处理或记录错误。
- 安全： 在生产环境中，数据库凭据不应硬编码在代码中，而应通过环境变量、配置文件或秘密管理服务进行安全管理。
- 连接池： 对于高并发应用，PHP的FPM模式下每个请求都会重新建立连接。更高级别的连接管理（如使用持久连接或连接池代理）可能需要更复杂的架构。
- 单例模式（Singleton）： 有些开发者可能会考虑使用单例模式来确保DB类只有一个实例。虽然它可以实现单一连接，但通常不推荐，因为它会引入全局状态，增加测试难度，并可能隐藏依赖关系。依赖注入通常是更好的选择。
- ORM/DBAL： 对于大型项目，可以考虑使用成熟的ORM（如Doctrine）或DBAL（数据库抽象层）库，它们提供了更高级别的抽象和更强大的功能。
