# 1. SSL连接配置
# 1.1 生成SSL证书（服务器端）
$ mkdir -p /mysql/ssl
$ cd /mysql/ssl
$ openssl genrsa 2048 > ca-key.pem
$ openssl req -new -x509 -nodes -days 3650 -key ca-key.pem > ca.pem
$ openssl req -newkey rsa:2048 -days 3650 -nodes -keyout server-key.pem > server-req.pem
$ openssl rsa -in server-key.pem -out server-key.pem
$ openssl x509 -req -in server-req.pem -days 3650 -CA ca.pem -CAkey ca-key.pem -set_serial 01 >
server-cert.pem

# 1.2 配置MySQL服务器使用SSL
$ vi /etc/my.cnf
[mysqld]
ssl-ca=/mysql/ssl/ca.pem
ssl-cert=/mysql/ssl/server-cert.pem
ssl-key=/mysql/ssl/server-key.pem
require_secure_transport=ON

# 1.3 重启MySQL服务器
$ systemctl restart mysqld

# 1.4 验证服务器SSL配置
mysql> SHOW VARIABLES LIKE ‘%ssl%’;
+————————————-+—————————-+
| Variable_name | Value |
+————————————-+—————————-+
| have_openssl | YES |
| have_ssl | YES |
| require_secure_transport | ON |
| ssl_ca | /mysql/ssl/ca.pem |
| ssl_cert | /mysql/ssl/server-cert.pem |
| ssl_cipher | |
| ssl_key | /mysql/ssl/server-key.pem |
+————————————-+—————————-+

# 2. PHP客户端SSL连接配置
PDO::ERRMODE_EXCEPTION,
PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC,
PDO::ATTR_EMULATE_PREPARES => false,
PDO::MYSQL_ATTR_SSL_CA => ‘/path/to/ca.pem’,
PDO::MYSQL_ATTR_SSL_VERIFY_SERVER_CERT => true,
];

try {
$pdo = new PDO($dsn, ‘app_user’, ‘SecurePassword123!’, $options);
echo “SSL连接成功！\n”;
} catch (PDOException $e) {
die(“连接失败: ” . $e->getMessage());
}
?>

# 3. Java客户端SSL连接配置
// JDBC SSL连接配置
String url =
“jdbc:mysql://localhost:3306/fgedudb?useSSL=true&requireSSL=true&verifyServerCertificate=true&serverSslCert=classpath:ca.pem”;
Properties props = new Properties();
props.setProperty(“user”, “app_user”);
props.setProperty(“password”, “SecurePassword123!”);
props.setProperty(“useSSL”, “true”);
props.setProperty(“requireSSL”, “true”);
props.setProperty(“verifyServerCertificate”, “true”);
props.setProperty(“serverSslCert”, “/path/to/ca.pem”);

try {
Connection conn = DriverManager.getConnection(url, props);
System.out.println(“SSL连接成功！”);
conn.close();
} catch (SQLException e) {
e.printStackTrace();
}

# 4. Python客户端SSL连接配置
# PyMySQL SSL连接配置
import pymysql

conn = pymysql.connect(
host=’localhost’,
user=’app_user’,
password=’SecurePassword123!’,
database=’fgedudb’,
ssl={
‘ca’: ‘/path/to/ca.pem’,
‘verify_mode’: ssl.CERT_REQUIRED
}
)

print(“SSL连接成功！”)
conn.close()

# 5. Go客户端SSL连接配置
// Go database/sql SSL连接配置
package main

import (
“database/sql”
“fmt”
“crypto/tls”
“crypto/x509”
“io/ioutil”
_ “github.com/go-sql-driver/mysql”
)

func main() {
// 读取CA证书
caCert, err := ioutil.ReadFile(“/path/to/ca.pem”)
if err != nil {
panic(err)
}
caCertPool := x509.NewCertPool()
caCertPool.AppendCertsFromPEM(caCert)

// 配置TLS
tlsConfig := &tls.Config{
RootCAs: caCertPool,
InsecureSkipVerify: false,
}

// 打开数据库连接
db, err := sql.Open(“mysql”, “app_user:SecurePassword123!@tcp(localhost:3306)/fgedudb?tls=custom”)
if err != nil {
panic(err)
}
defer db.Close()

// 注册TLS配置
mysql.RegisterTLSConfig(“custom”, tlsConfig)

// 测试连接
err = db.Ping()
if err != nil {
panic(err)
}

fmt.Println(“SSL连接成功！”)
}

# 6. 验证客户端SSL连接
# 6.1 查看连接状态
mysql> SHOW STATUS LIKE ‘Ssl_cipher’;
+—————+—————————+
| Variable_name | Value |
+—————+—————————+
| Ssl_cipher | TLS_AES_256_GCM_SHA384 |
+—————+—————————+

# 6.2 查看连接详细信息
mysql> SHOW PROCESSLIST;
+—-+———-+—————–+——–+———+——+———-+——————+
| Id | User | Host | db | Command | Time | State | Info |
+—-+———-+—————–+——–+———+——+———-+——————+
| 12 | app_user | 192.168.1.100:54321 | fgedudb | Sleep | 10 | | NULL |
+—-+———-+—————–+——–+———+——+———-+——————+

mysql> SELECT * FROM performance_schema.threads WHERE processlist_id = 12\G
…
SSL_version: TLSv1.3
SSL_cipher: TLS_AES_256_GCM_SHA384
…

# 1. PHP参数化查询实现
PDO::ERRMODE_EXCEPTION,
PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC,
PDO::ATTR_EMULATE_PREPARES => false,
];

try {
$pdo = new PDO($dsn, ‘app_user’, ‘SecurePassword123!’, $options);

// 1.1 插入数据
$sql = “INSERT INTO users (username, email, password) VALUES (?, ?, ?)”;
$stmt = $pdo->prepare($sql);
$stmt->execute([‘john_doe’, ‘john@example.com’, password_hash(‘SecurePass123!’, PASSWORD_DEFAULT)]);
echo “插入数据成功，ID: ” . $pdo->lastInsertId() . “\n”;

// 1.2 查询数据
$sql = “SELECT * FROM users WHERE username = ?”;
$stmt = $pdo->prepare($sql);
$stmt->execute([‘john_doe’]);
$user = $stmt->fetch();
print_r($user);

// 1.3 更新数据
$sql = “UPDATE users SET email = ? WHERE id = ?”;
$stmt = $pdo->prepare($sql);
$stmt->execute([‘john.doe@example.com’, $user[‘id’]]);
echo “更新数据成功，影响行数: ” . $stmt->rowCount() . “\n”;

// 1.4 删除数据
$sql = “DELETE FROM users WHERE id = ?”;
$stmt = $pdo->prepare($sql);
$stmt->execute([$user[‘id’]]);
echo “删除数据成功，影响行数: ” . $stmt->rowCount() . “\n”;

} catch (PDOException $e) {
die(“数据库操作失败: ” . $e->getMessage());
}
?>

# 2. Java参数化查询实现
// JDBC PreparedStatement参数化查询
import java.sql.*;

public class ParameterizedQueryExample {
public static void main(String[] args) {
String url =
“jdbc:mysql://localhost:3306/fgedudb?useSSL=true&requireSSL=true&verifyServerCertificate=true&serverSslCert=/path/to/ca.pem”;
String user = “app_user”;
String password = “SecurePassword123!”;

try (Connection conn = DriverManager.getConnection(url, user, password)) {
// 2.1 插入数据
String sql = “INSERT INTO users (username, email, password) VALUES (?, ?, ?)”;
PreparedStatement pstmt = conn.prepareStatement(sql, Statement.RETURN_GENERATED_KEYS);
pstmt.setString(1, “john_doe”);
pstmt.setString(2, “john@example.com”);
pstmt.setString(3, “hashed_password”);
pstmt.executeUpdate();

ResultSet rs = pstmt.getGeneratedKeys();
if (rs.next()) {
System.out.println(“插入数据成功，ID: ” + rs.getInt(1));
}

// 2.2 查询数据
sql = “SELECT * FROM users WHERE username = ?”;
pstmt = conn.prepareStatement(sql);
pstmt.setString(1, “john_doe”);
rs = pstmt.executeQuery();

while (rs.next()) {
System.out.println(“ID: ” + rs.getInt(“id”));
System.out.println(“Username: ” + rs.getString(“username”));
System.out.println(“Email: ” + rs.getString(“email”));
}

// 2.3 更新数据
sql = “UPDATE users SET email = ? WHERE username = ?”;
pstmt = conn.prepareStatement(sql);
pstmt.setString(1, “john.doe@example.com”);
pstmt.setString(2, “john_doe”);
int rowsAffected = pstmt.executeUpdate();
System.out.println(“更新数据成功，影响行数: ” + rowsAffected);

// 2.4 删除数据
sql = “DELETE FROM users WHERE username = ?”;
pstmt = conn.prepareStatement(sql);
pstmt.setString(1, “john_doe”);
rowsAffected = pstmt.executeUpdate();
System.out.println(“删除数据成功，影响行数: ” + rowsAffected);

} catch (SQLException e) {
e.printStackTrace();
}
}
}

# 3. Python参数化查询实现
# PyMySQL参数化查询
import pymysql
import hashlib

# 连接数据库
conn = pymysql.connect(
host=’localhost’,
user=’app_user’,
password=’SecurePassword123!’,
database=’fgedudb’
)

# 创建游标
cursor = conn.cursor()

# 3.1 插入数据
password = ‘SecurePass123!’
hashed_password = hashlib.sha256(password.encode()).hexdigest()
sql = “INSERT INTO users (username, email, password) VALUES (%s, %s, %s)”
cursor.execute(sql, (‘john_doe’, ‘john@example.com’, hashed_password))
conn.commit()
print(“插入数据成功，ID:”, cursor.lastrowid)

# 3.2 查询数据
sql = “SELECT * FROM users WHERE username = %s”
cursor.execute(sql, (‘john_doe’,))
user = cursor.fetchone()
print(“查询结果:”, user)

# 3.3 更新数据
sql = “UPDATE users SET email = %s WHERE id = %s”
cursor.execute(sql, (‘john.doe@example.com’, user[0]))
conn.commit()
print(“更新数据成功，影响行数:”, cursor.rowcount)

# 3.4 删除数据
sql = “DELETE FROM users WHERE id = %s”
cursor.execute(sql, (user[0],))
conn.commit()
print(“删除数据成功，影响行数:”, cursor.rowcount)

# 关闭连接
cursor.close()
conn.close()

# 4. Go参数化查询实现
// Go database/sql参数化查询
package main

import (
“database/sql”
“fmt”
_ “github.com/go-sql-driver/mysql”
)

func main() {
// 连接数据库
db, err := sql.Open(“mysql”, “app_user:SecurePassword123!@tcp(localhost:3306)/fgedudb”)
if err != nil {
panic(err)
}
defer db.Close()

// 4.1 插入数据
sql := “INSERT INTO users (username, email, password) VALUES (?, ?, ?)”
result, err := db.Exec(sql, “john_doe”, “john@example.com”, “hashed_password”)
if err != nil {
panic(err)
}

id, err := result.LastInsertId()
if err != nil {
panic(err)
}
fmt.Println(“插入数据成功，ID:”, id)

// 4.2 查询数据
sql = “SELECT id, username, email FROM users WHERE username = ?”
row := db.QueryRow(sql, “john_doe”)

var userID int
var username, email string
err = row.Scan(&userID, &username, &email)
if err != nil {
panic(err)
}
fmt.Printf(“查询结果: ID=%d, Username=%s, Email=%s\n”, userID, username, email)

// 4.3 更新数据
sql = “UPDATE users SET email = ? WHERE id = ?”
result, err = db.Exec(sql, “john.doe@example.com”, userID)
if err != nil {
panic(err)
}

rowsAffected, err := result.RowsAffected()
if err != nil {
panic(err)
}
fmt.Println(“更新数据成功，影响行数:”, rowsAffected)

// 4.4 删除数据
sql = “DELETE FROM users WHERE id = ?”
result, err = db.Exec(sql, userID)
if err != nil {
panic(err)
}

rowsAffected, err = result.RowsAffected()
if err != nil {
panic(err)
}
fmt.Println(“删除数据成功，影响行数:”, rowsAffected)
}

# 5. 测试参数化查询防御SQL注入
# 5.1 模拟SQL注入攻击
# 攻击者输入: ‘ OR ‘1’=’1
username = “‘ OR ‘1’=’1”;

# 不安全的查询（字符串拼接）
sql = “SELECT * FROM users WHERE username = ‘$username'”;
# 实际执行的SQL: SELECT * FROM users WHERE username = ” OR ‘1’=’1′

# 安全的参数化查询
sql = “SELECT * FROM users WHERE username = ?”;
# 参数化查询会将输入作为普通字符串处理，不会执行恶意SQL代码

# 5.2 测试参数化查询
# PHP测试示例
prepare(“SELECT * FROM users WHERE username = ?”);
$stmt->execute([$username]);
$users = $stmt->fetchAll();

// 结果为空，因为没有用户名为 ” OR ‘1’=’1′ 的用户
echo “查询到 ” . count($users) . ” 个用户\n”;
?>

# 1. PHP输入验证与过滤
array(‘min_range’ => 1, ‘max_range’ => 120)));

// 1.3 使用正则表达式验证输入
$password = “SecurePass123!”;
$pattern = ‘/^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\d@$!%*?&]{8,}$/’;

if (preg_match($pattern, $password)) {
echo “密码强度符合要求\n”;
} else {
echo “密码强度不符合要求，至少需要8个字符，包含大小写字母、数字和特殊字符\n”;
}

// 1.4 自定义验证函数
function validate_username($username) {
// 用户名长度在3-20个字符之间，只能包含字母、数字和下划线
if (preg_match(‘/^[a-zA-Z0-9_]{3,20}$/’, $username)) {
return true;
}
return false;
}

$username = “john_doe123”;
if (validate_username($username)) {
echo “用户名格式正确\n”;
} else {
echo “用户名格式错误\n”;
}
?>

# 2. Java输入验证与过滤
// Java输入验证与过滤
import java.util.regex.*;

public class InputValidationExample {
public static void main(String[] args) {
// 2.1 使用正则表达式验证输入
String email = “john@example.com”;
String password = “SecurePass123!”;
String username = “john_doe123”;

// 验证邮箱
String emailPattern = “^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,6}$”;
if (Pattern.matches(emailPattern, email)) {
System.out.println(“邮箱格式正确: ” + email);
} else {
System.out.println(“邮箱格式错误: ” + email);
}

// 验证密码
String passwordPattern = “^(?=.*[a-z])(?=.*[A-Z])(?=.*\\d)(?=.*[@$!%*?&])[A-Za-z\\d@$!%*?&]{8,}$”;
if (Pattern.matches(passwordPattern, password)) {
System.out.println(“密码强度符合要求”);
} else {
System.out.println(“密码强度不符合要求”);
}

// 验证用户名
String usernamePattern = “^[a-zA-Z0-9_]{3,20}$”;
if (Pattern.matches(usernamePattern, username)) {
System.out.println(“用户名格式正确: ” + username);
} else {
System.out.println(“用户名格式错误: ” + username);
}

// 2.2 使用第三方库进行验证
// 例如：Apache Commons Validator、Hibernate Validator等
}
}

# 3. Python输入验证与过滤
# Python输入验证与过滤
import re

# 3.1 使用正则表达式验证输入
email = “john@example.com”
password = “SecurePass123!”
username = “john_doe123″

# 验证邮箱
email_pattern = r’^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,6}$’
if re.match(email_pattern, email):
print(f”邮箱格式正确: {email}”)
else:
print(f”邮箱格式错误: {email}”)

# 验证密码
password_pattern = r’^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\d@$!%*?&]{8,}$’
if re.match(password_pattern, password):
print(“密码强度符合要求”)
else:
print(“密码强度不符合要求”)

# 验证用户名
username_pattern = r’^[a-zA-Z0-9_]{3,20}$’
if re.match(username_pattern, username):
print(f”用户名格式正确: {username}”)
else:
print(f”用户名格式错误: {username}”)

# 3.2 使用第三方库进行验证
# 例如：validators、wtforms等
import validators

if validators.email(email):
print(f”Validators邮箱验证通过: {email}”)
else:
print(f”Validators邮箱验证失败: {email}”)

# 4. Go输入验证与过滤
// Go输入验证与过滤
package main

import (
“fmt”
“regexp”
)

func main() {
// 4.1 使用正则表达式验证输入
email := “john@example.com”
password := “SecurePass123!”
username := “john_doe123”

// 验证邮箱
emailRegex := regexp.MustCompile(`^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,6}$`)
if emailRegex.MatchString(email) {
fmt.Printf(“邮箱格式正确: %s\n”, email)
} else {
fmt.Printf(“邮箱格式错误: %s\n”, email)
}

// 验证密码
passwordRegex := regexp.MustCompile(`^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\d@$!%*?&]{8,}$`)
if passwordRegex.MatchString(password) {
fmt.Println(“密码强度符合要求”)
} else {
fmt.Println(“密码强度不符合要求”)
}

// 验证用户名
usernameRegex := regexp.MustCompile(`^[a-zA-Z0-9_]{3,20}$`)
if usernameRegex.MatchString(username) {
fmt.Printf(“用户名格式正确: %s\n”, username)
} else {
fmt.Printf(“用户名格式错误: %s\n”, username)
}

// 4.2 使用第三方库进行验证
// 例如：github.com/go-playground/validator/v10等
}

# 5. 输入过滤示例
# 5.1 PHP过滤特殊字符

# 5.2 Java过滤特殊字符
// Java过滤HTML标签
public static String sanitizeHtml(String input) {
return input.replaceAll(“<[^>]*>”, “”);
}

String input = ”
“;
String filtered = sanitizeHtml(input);
System.out.println(“过滤后: ” + filtered);
// 输出: 过滤后: alert(‘XSS攻击’)

# 5.3 Python过滤特殊字符
import html

input = ”
”

# 过滤HTML标签
filtered = re.sub(r’<[^>]*>’, ”, input)
print(f”过滤后: {filtered}”)
# 输出: 过滤后: alert(‘XSS攻击’)

# 转义HTML特殊字符
escaped = html.escape(input)
print(f”转义后: {escaped}”)
# 输出: 转义后: <script>alert('XSS攻击')</script>

# 1. PHP密码管理
= 8) {
$strength++;
}

// 包含小写字母
if (preg_match(‘/[a-z]/’, $password)) {
$strength++;
}

// 包含大写字母
if (preg_match(‘/[A-Z]/’, $password)) {
$strength++;
}

// 包含数字
if (preg_match(‘/\d/’, $password)) {
$strength++;
}

// 包含特殊字符
if (preg_match(‘/[^a-zA-Z0-9]/’, $password)) {
$strength++;
}

return $strength;
}

$password = “SecurePass123!”;
$strength = check_password_strength($password);
echo “密码强度: $strength/5\n”;
?>

# 2. Java密码管理
// Java密码管理（使用BCrypt）
import org.mindrot.jbcrypt.BCrypt;

public class PasswordManagementExample {
public static void main(String[] args) {
// 2.1 密码哈希
String password = “SecurePass123!”;
String hashedPassword = BCrypt.hashpw(password, BCrypt.gensalt());
System.out.println(“密码哈希: ” + hashedPassword);
// 输出示例: $2a$10$N9qo8uLOickgx2ZMRZoMyeIjZAgcfl7p92ldGxad68LJZdL17lhWy

// 2.2 密码验证
String inputPassword = “SecurePass123!”;
if (BCrypt.checkpw(inputPassword, hashedPassword)) {
System.out.println(“密码验证通过”);
} else {
System.out.println(“密码验证失败”);
}

// 2.3 密码强度检查
int strength = checkPasswordStrength(password);
System.out.println(“密码强度: ” + strength + “/5”);
}

public static int checkPasswordStrength(String password) {
int strength = 0;

// 长度检查
if (password.length() >= 8) {
strength++;
}

// 包含小写字母
if (password.matches(“.*[a-z].*”)) {
strength++;
}

// 包含大写字母
if (password.matches(“.*[A-Z].*”)) {
strength++;
}

// 包含数字
if (password.matches(“.*\\d.*”)) {
strength++;
}

// 包含特殊字符
if (password.matches(“.*[^a-zA-Z0-9].*”)) {
strength++;
}

return strength;
}
}

# 3. Python密码管理
# Python密码管理（使用bcrypt）
import bcrypt
import re

# 3.1 密码哈希
password = “SecurePass123!”.encode(‘utf-8’)
hashed_password = bcrypt.hashpw(password, bcrypt.gensalt())
print(f”密码哈希: {hashed_password.decode(‘utf-8’)}”)
# 输出示例: $2b$12$VZ8X5q8Z8X5q8Z8X5q8Z8X5q8Z8X5q8Z8X5q8Z8X5q8Z8X5q8Z8

# 3.2 密码验证
input_password = “SecurePass123!”.encode(‘utf-8′)
if bcrypt.checkpw(input_password, hashed_password):
print(“密码验证通过”)
else:
print(“密码验证失败”)

# 3.3 密码强度检查
def check_password_strength(password):
strength = 0

# 长度检查
if len(password) >= 8:
strength += 1

# 包含小写字母
if re.search(r'[a-z]’, password):
strength += 1

# 包含大写字母
if re.search(r'[A-Z]’, password):
strength += 1

# 包含数字
if re.search(r’\d’, password):
strength += 1

# 包含特殊字符
if re.search(r'[^a-zA-Z0-9]’, password):
strength += 1

return strength

password = “SecurePass123!”
strength = check_password_strength(password)
print(f”密码强度: {strength}/5″)

# 4. Go密码管理
// Go密码管理（使用bcrypt）
package main

import (
“fmt”
“golang.org/x/crypto/bcrypt”
“regexp”
)

func main() {
// 4.1 密码哈希
password := “SecurePass123!”
hashedPassword, err := bcrypt.GenerateFromPassword([]byte(password), bcrypt.DefaultCost)
if err != nil {
panic(err)
}
fmt.Printf(“密码哈希: %s\n”, string(hashedPassword))
// 输出示例: $2a$10$N9qo8uLOickgx2ZMRZoMyeIjZAgcfl7p92ldGxad68LJZdL17lhWy

// 4.2 密码验证
inputPassword := “SecurePass123!”
err = bcrypt.CompareHashAndPassword(hashedPassword, []byte(inputPassword))
if err == nil {
fmt.Println(“密码验证通过”)
} else {
fmt.Println(“密码验证失败”)
}

// 4.3 密码强度检查
strength := checkPasswordStrength(password)
fmt.Printf(“密码强度: %d/5\n”, strength)
}

func checkPasswordStrength(password string) int {
strength := 0

// 长度检查
if len(password) >= 8 {
strength++
}

// 包含小写字母
if regexp.MustCompile(`[a-z]`).MatchString(password) {
strength++
}

// 包含大写字母
if regexp.MustCompile(`[A-Z]`).MatchString(password) {
strength++
}

// 包含数字
if regexp.MustCompile(`\d`).MatchString(password) {
strength++
}

// 包含特殊字符
if regexp.MustCompile(`[^a-zA-Z0-9]`).MatchString(password) {
strength++
}

return strength
}

# 5. 密码存储最佳实践
# 5.1 不要硬编码密码
// 错误示例
String password = “mysecretpassword”;

// 正确示例
// 从配置文件或环境变量中读取密码
String password = System.getenv(“DB_PASSWORD”);

# 5.2 不要以明文形式存储密码
// 错误示例
INSERT INTO users (username, password) VALUES (‘john’, ‘SecurePass123!’);

// 正确示例
INSERT INTO users (username, password) VALUES (‘john’,
‘$2y$10$92IXUNpkjO0rOQ5byMi.Ye4oKoEa3Ro9llC/.og/at2.uheWG/igi’);

# 5.3 使用强哈希算法
// 推荐使用：bcrypt、PBKDF2、Argon2等
// 不推荐使用：MD5、SHA-1等

# 5.4 为每个用户使用唯一的盐值
echo password_hash(‘same_password’, PASSWORD_DEFAULT);
echo password_hash(‘same_password’, PASSWORD_DEFAULT);
// 输出不同的哈希值，因为每次使用不同的盐值

# 1. PHP错误处理与日志
prepare(“SELECT * FROM non_existent_table”);
$stmt->execute();
} catch (PDOException $e) {
// 记录详细错误信息到日志
error_log(“数据库错误: ” . $e->getMessage() . ” in ” . $e->getFile() . ” on line ” . $e->getLine());

// 向用户显示友好的错误信息
echo “服务器繁忙，请稍后再试。错误代码: DB-001”;
}

// 1.3 自定义错误处理函数
function custom_error_handler($errno, $errstr, $errfile, $errline) {
error_log(“[$errno] $errstr in $errfile on line $errline”);
return true; // 阻止默认错误处理
}

// 注册自定义错误处理函数
set_error_handler(‘custom_error_handler’);

// 1.4 日志记录
// 使用Monolog库记录日志
require_once ‘vendor/autoload.php’;

use Monolog\Logger;
use Monolog\Handler\StreamHandler;

// 创建日志记录器
$log = new Logger(‘app’);
$log->pushHandler(new StreamHandler(‘/var/log/app/app.log’, Logger::DEBUG));

// 记录不同级别的日志
$log->debug(‘调试信息’);
$log->info(‘普通信息’);
$log->warning(‘警告信息’);
$log->error(‘错误信息’);
$log->critical(‘严重错误信息’);
?>

# 2. Java错误处理与日志
// Java错误处理与日志
import java.sql.*;
import java.util.logging.*;

public class ErrorHandlingExample {
// 创建日志记录器
private static final Logger logger = Logger.getLogger(ErrorHandlingExample.class.getName());

public static void main(String[] args) {
// 2.1 异常处理
try {
// 数据库操作
Connection conn = DriverManager.getConnection(“jdbc:mysql://localhost:3306/fgedudb”, “app_user”,
“SecurePassword123!”);
Statement stmt = conn.createStatement();
ResultSet rs = stmt.executeQuery(“SELECT * FROM non_existent_table”);

conn.close();
} catch (SQLException e) {
// 记录详细错误信息到日志
logger.log(Level.SEVERE, “数据库错误: ” + e.getMessage(), e);

// 向用户显示友好的错误信息
System.out.println(“服务器繁忙，请稍后再试。错误代码: DB-001”);
}

// 2.2 配置日志格式
try {
// 配置文件处理器
FileHandler fileHandler = new FileHandler(“/var/log/app/app.log”);
fileHandler.setFormatter(new SimpleFormatter());
logger.addHandler(fileHandler);

// 配置控制台处理器
ConsoleHandler consoleHandler = new ConsoleHandler();
consoleHandler.setFormatter(new SimpleFormatter());
logger.addHandler(consoleHandler);
} catch (Exception e) {
e.printStackTrace();
}

// 2.3 记录不同级别的日志
logger.severe(“严重错误信息”);
logger.warning(“警告信息”);
logger.info(“普通信息”);
logger.config(“配置信息”);
logger.fine(“详细信息”);
logger.finer(“更详细信息”);
logger.finest(“最详细信息”);
}
}

# 3. Python错误处理与日志
# Python错误处理与日志
import logging
import pymysql

# 3.1 配置日志
logging.basicConfig(
filename=’/var/log/app/app.log’,
level=logging.DEBUG,
format=’%(asctime)s – %(name)s – %(levelname)s – %(message)s’
)

logger = logging.getLogger(‘app’)

# 3.2 异常处理
try:
# 数据库操作
conn = pymysql.connect(
host=’localhost’,
user=’app_user’,
password=’SecurePassword123!’,
database=’fgedudb’
)
cursor = conn.cursor()
cursor.execute(“SELECT * FROM non_existent_table”)

cursor.close()
conn.close()
except pymysql.MySQLError as e:
# 记录详细错误信息到日志
logger.error(f”数据库错误: {e}”)
logger.exception(“完整的错误堆栈信息”)

# 向用户显示友好的错误信息
print(“服务器繁忙，请稍后再试。错误代码: DB-001″)
except Exception as e:
# 记录其他错误
logger.critical(f”未知错误: {e}”)
logger.exception(“完整的错误堆栈信息”)
print(“服务器繁忙，请稍后再试。错误代码: UNKNOWN-001”)

# 3.3 记录不同级别的日志
logger.debug(“调试信息”)
logger.info(“普通信息”)
logger.warning(“警告信息”)
logger.error(“错误信息”)
logger.critical(“严重错误信息”)

# 4. Go错误处理与日志
// Go错误处理与日志
package main

import (
“database/sql”
“fmt”
“log”
“os”
_ “github.com/go-sql-driver/mysql”
)

func main() {
// 4.1 配置日志
logFile, err := os.OpenFile(“/var/log/app/app.log”, os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0666)
if err != nil {
log.Fatal(“无法打开日志文件: “, err)
}
defer logFile.Close()

// 设置日志输出到文件和控制台
multiWriter := io.MultiWriter(os.Stdout, logFile)
log.SetOutput(multiWriter)
log.SetFlags(log.Ldate | log.Ltime | log.Lshortfile)

// 4.2 错误处理
db, err := sql.Open(“mysql”, “app_user:SecurePassword123!@tcp(localhost:3306)/fgedudb”)
if err != nil {
log.Fatalf(“连接数据库失败: %v”, err)
}
defer db.Close()

rows, err := db.Query(“SELECT * FROM non_existent_table”)
if err != nil {
// 记录详细错误信息到日志
log.Printf(“数据库查询错误: %v”, err)

// 向用户显示友好的错误信息
fmt.Println(“服务器繁忙，请稍后再试。错误代码: DB-001”)
return
}
defer rows.Close()

// 4.3 记录不同级别的日志
log.Printf(“普通信息”)
log.Println(“调试信息”)
log.Fatalf(“严重错误，程序退出”)
}

# 5. 错误处理最佳实践
# 5.1 不要向用户暴露详细错误信息
// 错误示例
echo “数据库错误: ” . $e->getMessage();

// 正确示例
error_log(“数据库错误: ” . $e->getMessage());
echo “服务器繁忙，请稍后再试。”;

# 5.2 记录详细的错误信息
// 记录错误信息、文件、行号、堆栈跟踪等
logger.error(“错误信息”, e);

# 5.3 对不同类型的错误进行分类处理
// 数据库错误、网络错误、输入错误等分别处理

try {
// 操作
} catch (SQLException e) {
// 处理数据库错误
} catch (IOException e) {
// 处理网络错误
} catch (ValidationException e) {
// 处理输入错误
}

# 5.4 使用错误代码
// 使用错误代码标识不同类型的错误
echo “错误代码: DB-001”;

# 5.5 实现适当的错误恢复机制
// 对于可恢复的错误，实现自动恢复机制
try {
// 数据库操作
} catch (SQLException e) {
// 重试操作
for (int i = 0; i < 3; i++) { try { // 重新尝试数据库操作 break; } catch (SQLException ex) { // 等待一段时间后重试 Thread.sleep(1000); } } }