使用Chatgpt编写的PHP数据库pdo操作类（增删改查）

摘要

将PDO封装成PHP类进行调用有很多好处，包括：

1、封装性和抽象性： 通过将PDO封装到一个类中，您可以将数据库操作逻辑与应用程序的其他部分分离开来，提高了代码的组织性和可维护性。这样，您只需在一个地方维护数据库连接和查询逻辑，而不必在整个应用程序中散布数据库代码。

2、重用性： 将数据库操作封装成类使得这些操作可以在应用程序的不同部分重复使用，而无需重复编写相同的代码。这有助于减少代码冗余，提高效率。

3、安全性： 通过类的方法来执行数据库操作，可以轻松地实施预处理语句，从而减少了SQL注入攻击的风险。类还可以提供错误处理机制，使您能够更容易地处理数据库错误。

4、可扩展性： 使用类封装数据库操作，可以轻松地扩展和维护应用程序。如果需要添加新的数据库操作或更改现有的操作，只需修改类中的相应方法而不必更改应用程序的其他部分。

5、清晰的接口： 类提供了一个清晰的接口，使其他开发人员能够更容易地理解和使用数据库操作。这有助于团队协作和代码维护。

将PDO封装成PHP类可以提高代码的可维护性、可重用性和安全性，同时降低了代码的耦合度，使数据库操作更容易管理和扩展。这是一个良好的软件工程实践，特别适用于中大型和复杂的应用程序。

类文件

Database.php

以下是使用Chatgpt生成的操作类，但是我做了30%的修改和优化。

host = $host;
            $this->username = $username;
            $this->password = $password;
            $this->database = $database;
    
            $this->connect();
        }
        
        // 获取错误信息
        public function getError()
        {
            return $this->error;
        }
        
        // 连接数据库
        private function connect()
        {
            $dsn = "mysql:host={$this->host};dbname={$this->database}";
            try {
                $this->pdo = new PDO($dsn, $this->username, $this->password);
                $this->pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
            } catch (PDOException $e) {
                die("Connection failed: " . $e->getMessage());
            }
        }
        
        // 插入数据
        public function insert($table, $data)
        {
            try {
                
                $columns = implode(", ", array_keys($data));
                $values = ":" . implode(", :", array_keys($data));
                $sql = "INSERT INTO $table ($columns) VALUES ($values)";
                $stmt = $this->pdo->prepare($sql);
                $result = $stmt->execute($data);
                if (!$result) {
                    $this->error = $stmt->errorInfo();
                }
                return $result;
            } catch (PDOException $e) {
                
                // 处理数据库异常
                $this->error = $e->getMessage();
                return FALSE;
            }
        }
        
        // 更新数据
        public function update($table, $data, $where)
        {
            try {
                
                $set = "";
                foreach ($data as $key => $value) {
                    $set .= "$key = :$key, ";
                }
                $set = rtrim($set, ', ');
                $sql = "UPDATE $table SET $set WHERE $where";
                $stmt = $this->pdo->prepare($sql);
                $result = $stmt->execute($data);
                if (!$result) {
                    $this->error = $stmt->errorInfo();
                }
                return $result;
            } catch (PDOException $e) {
                
                // 处理数据库异常
                $this->error = $e->getMessage();
                return FALSE;
            }
        }
        
        // 删除数据
        public function delete($table, $where)
        {
            try {
                
                $sql = "DELETE FROM $table WHERE $where";
                $stmt = $this->pdo->prepare($sql);
                $result = $stmt->execute();
                
                if($stmt->rowCount() === 0) {
                    
                    // 没有受影响的记录
                    $this->error = '没有受影响的记录';
                    return FALSE;
                }else {
                    
                    return $result;
                }
            } catch (PDOException $e) {
                
                // 处理数据库异常
                $this->error = $e->getMessage();
                return FALSE;
            }
        }
        
        // 查询一条数据
        public function queryOne($table, $conditions = [])
        {
            $whereClause = $this->buildWhereClause($conditions);
            $sql = "SELECT * FROM $table $whereClause LIMIT 1";
    
            try {
                $stmt = $this->pdo->prepare($sql);
                $stmt->execute($conditions);
    
                return $stmt->fetch(PDO::FETCH_ASSOC);
            } catch (PDOException $e) {
                
                // 处理数据库异常
                $this->error = $e->getMessage();
                return FALSE;
            }
        }
        
        // 查询所有数据
        public function queryAll($table, $conditions = [])
        {
            $whereClause = $this->buildWhereClause($conditions);
            $sql = "SELECT * FROM $table $whereClause";
    
            try {
                $stmt = $this->pdo->prepare($sql);
                $stmt->execute($conditions);
    
                return $stmt->fetchAll(PDO::FETCH_ASSOC);
            } catch (PDOException $e) {
                
                // 处理数据库异常
                $this->error = $e->getMessage();
                return FALSE;
            }
        }
        
        // 执行原生SQL语句
        public function executeSQL($sql, $params = [])
        {
            try {
                $stmt = $this->pdo->prepare($sql);
                $result = $stmt->execute($params);
    
                if (!$result) {
                    
                    // 执行失败
                    $this->error = $stmt->errorInfo();
                    return FALSE;
                }
    
                return $stmt;
            } catch (PDOException $e) {
                
                // 处理数据库异常
                $this->error = $stmt->errorInfo();
                return FALSE;
            }
        }
        
        // 数据绑定
        private function buildWhereClause($conditions)
        {
            if (empty($conditions)) {
                return '';
            }
    
            $where = 'WHERE';
            foreach ($conditions as $key => $value) {
                $where .= " $key = :$key AND";
            }
            $where = rtrim($where, ' AND');
    
            return $where;
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196

实例

配置文件 Db.php

 'xxx', // 数据库服务器
        'db_name' => 'xxx', // 数据库名
        'db_user' => 'xxx', // 数据库账号
        'db_pwd' => 'xxx', // 数据库密码
    );
    
    include 'Database.php';
?>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

以下实例使用一个名为artcles的数据库表进行操作演示。

插入数据 insert.php

 rand(100000,999999), 
        'title' => 'sdfgsadg',
        'tag' => 'ceshi',
        'content' => '这是内容',
        'author' => 'TANKING'
    ];
    $insertArtcle = $db->insert('artcles', $data);
    
    if($insertArtcle){
        echo '插入成功';
    }else{
        echo '失败！' . $db->getError();
    }

?>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

更新数据 update.php

 '测试'];
    $where = 'id = 19';
    $updateArtcle = $db->update('artcles', $updateData, $where);
    if($updateArtcle){
        echo '更新成功！';
    }else{
        echo '更新失败！' . $db->getError();
    }

?>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

删除数据 delete.php

delete('artcles', $where);
    if($deleteArtcle){
        echo '删除成功！';
    }else{
        echo '删除失败！' . $db->getError();
    }

?>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

查询一条数据 queryOne.php

 18];
    $getArtcle = $db->queryOne('artcles', $conditions);
    if($getArtcle){
        echo json_encode($getArtcle);
    }else{
        echo '查询失败！' . $db->getError();
    }

?>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

查询所有数据 queryAll.php

queryAll('artcles', $conditions);
    if($getArtcles){
        echo json_encode($getArtcles);
    }else{
        echo '查询失败！' . $db->getError();
    }

?>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

执行原生SQL语句

// 插入
$sql = "INSERT INTO artcles (aid, title, tag, content, author) VALUES (:aid, :title, :tag, :content, :author)";
$params = [
    ':aid' => rand(100000,999999), 
    ':title' => '这是标题' . uniqid(),
    ':tag' => 'tag' . rand(0,9),
    ':content' => '这是内容' . uniqid(),
    ':author' => 'TANKING'
];

// 更新
$sql = "UPDATE artcles SET title = :title WHERE id = :id";
$params = [
    ':id' => 22,
    ':title' => '这是标题_已更新',
];

// 删除
$sql = "DELETE FROM artcles WHERE id = :id";
$params = [
    ':id' => 20
];

// 查询
$sql = "SELECT * FROM artcles";
try {
    $stmt = $db->executeSQL($sql);

    if ($stmt) {
        $result = $stmt->fetchAll(PDO::FETCH_ASSOC);

        if (empty($result)) {

            // 没有匹配的结果
            echo "没有匹配的结果";
        } else {

            echo json_encode($result);
        }
    } else {

        echo "查询失败，错误信息：" . json_encode($db->getError());
    }
} catch (DatabaseException $e) {

    // 查询失败
    echo $e->getMessage();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

作者

TANKING