修改

wangky

2024-10-29 4e09764be3e77fc866399230982086cb606b7e11

修改

 Server/ÍõçûÔª/document/µ¥Àýģʽ·â×°.txt

@@ -1,62 +1,51 @@
#include <iostream>
#include <memory>
#include <mutex>
#include <fstream>
#include <string>
#include <ctime>
using namespace std;
class A {
#include <mysql_driver.h>
#include <mysql_connection.h>
#include <cppconn/statement.h>
#include <cppconn/resultset.h>

class DatabaseOperator {
private:
    ofstream logFile;
    A() {
        logFile.open("123.txt", ios::app);
    // ç§æœ‰æž„造函数
    DatabaseOperator() {
        try {
            driver = sql::mysql::get_mysql_driver_instance();
            connection = driver->connect("tcp://127.0.0.1:3306", "username", "password");
            connection->setSchema("your_database");
        } catch (sql::SQLException &e) {
            std::cerr << "数据库连接错误: " << e.what() << std::endl;
    }
    ~A() {
        logFile.close();
    }
    A(const A &t){}
    A& operator=(const A &t){}
    static A* volatile s_obj;
    static mutex g_mutex;

    static DatabaseOperator* instance;
    static std::mutex mutex;
    sql::Driver* driver;
    std::unique_ptr<sql::Connection> connection;

public:
    static A* getInstance() {
        if (s_obj == nullptr) {
            lock_guard<mutex> guard(g_mutex);
            if (s_obj == nullptr) {
                s_obj = new A;
    // èŽ·å–单例实例
    static DatabaseOperator* getInstance() {
        std::lock_guard<std::mutex> lock(mutex);
        if (instance == nullptr) {
            instance = new DatabaseOperator();
            }
        return instance;
        }
        return s_obj;

    // æ‰§è¡ŒæŸ¥è¯¢æ“ä½œï¼ˆç¤ºä¾‹ï¼‰
    sql::ResultSet* query(const std::string& sql) {
        try {
            std::unique_ptr<sql::Statement> stmt(connection->createStatement());
            return stmt->executeQuery(sql);
        } catch (sql::SQLException &e) {
            std::cerr << "查询错误: " << e.what() << std::endl;
    }
    void write(const string& level, const string& description, const string& time) {
        logFile << "[" << level << "] " << "[" << time << "] " << description << endl;
    }
    void release() {
        if (s_obj) {
            delete s_obj;
            s_obj = nullptr;
        }
        return nullptr;
    }
};

A* volatile A::s_obj = nullptr;
mutex A::g_mutex;

int main() {
    A* a1 = A::getInstance();
    A* a2 = A::getInstance();
    if (a1 == a2) {
        cout << "单例成功" << endl;
    }
    else {
        cout << "单例失败" << endl;
    }
    time_t now = time(nullptr);
    char buffer[80];
    struct tm timeinfo;
    localtime_s(&timeinfo, &now);
    strftime(buffer, 80, "%Y - %m - %d %H:%M:%S", &timeinfo);
    string timeStr(buffer);
    a1->write("1", "日志", timeStr);
    a1->release();
    return 0;
}
std::mutex DatabaseOperator::mutex;
DatabaseOperator* DatabaseOperator::instance = nullptr;

 Server/ÍõçûÔª/document/±¸·Ýµ¼³ö.txt

New file
@@ -0,0 +1,29 @@
#!/bin/bash

# æ•°æ®åº“连接参数
DB_USER="your_username"
DB_PASS="your_password"
DB_NAME="your_database_name"
BACKUP_DIR="/path/to/backup/directory"

# èŽ·å–当前日期，用于文件名
DATE=$(date +%Y%m%d%H%M%S)

# å¤‡ä»½æ–‡ä»¶å
BACKUP_FILE="${BACKUP_DIR}/backup_${DATE}.sql"

# åˆ›å»ºå¤‡ä»½ç›®å½•ï¼ˆå¦‚果不存在）
mkdir -p $BACKUP_DIR

# ä½¿ç”¨mysqldump进行数据库备份
mysqldump -u $DB_USER -p$DB_PASS $DB_NAME > $BACKUP_FILE

if [ $? -eq 0 ]; then
    echo "数据库备份成功：$BACKUP_FILE"
else
    echo "数据库备份失败"
fi

# æ·»åŠ å®šæ—¶ä»»åŠ¡ï¼ˆä½¿ç”¨crontab -e来编辑定时任务）
# ä¾‹å¦‚，每天凌晨2点执行备份
# 0 2 * * * /path/to/this/script.sh

 Server/ÍõçûÔª/document/Êý¾Ý¿âÄ£¿éÐèÇó·ÖÎö.docx

Binary files differ

 Server/ÍõçûÔª/document/Êý¾Ý¿âÁ¬½Ó³ØÀà.txt

New file
@@ -0,0 +1,91 @@
#include <iostream>
#include <list>
#include <mutex>
#include <condition_variable>
#include <mysql_driver.h>
#include <mysql_connection.h>
#include <cppconn/statement.h>
#include <cppconn/resultset.h>

class SQLConnectionPool {
private:
    SQLConnectionPool(int minConns, int maxConns) :
        minConnections(minConns), maxConnections(maxConns), currentConnections(0) {}

    static SQLConnectionPool* instance;
    static std::mutex mutex;
    std::condition_variable cv;
    int minConnections;
    int maxConnections;
    int currentConnections;
    std::list<std::unique_ptr<sql::Connection>> connections;

    // åˆ›å»ºä¸€ä¸ªæ–°çš„数据库连接
    std::unique_ptr<sql::Connection> createConnection() {
        try {
            sql::Driver* driver = sql::mysql::get_mysql_driver_instance();
            std::unique_ptr<sql::Connection> conn(driver->connect("tcp://127.0.0.1:3306", "username", "password"));
            conn->setSchema("your_database");
            return conn;
        } catch (sql::SQLException &e) {
            std::cerr << "创建连接错误: " << e.what() << std::endl;
            return nullptr;
        }
    }

public:
    // èŽ·å–单例实例
    static SQLConnectionPool* getInstance(int minConns, int maxConns) {
        std::lock_guard<std::mutex> lock(mutex);
        if (instance == nullptr) {
            instance = new SQLConnectionPool(minConns, maxConns);
            instance->initializePool();
        }
        return instance;
    }

    // åˆå§‹åŒ–连接池
    void initializePool() {
        for (int i = 0; i < minConnections; ++i) {
            std::unique_ptr<sql::Connection> conn = createConnection();
            if (conn) {
                connections.push_back(std::move(conn));
                currentConnections++;
            }
        }
    }

    // èŽ·å–数据库连接
    std::unique_ptr<sql::Connection> getConnection() {
        std::unique_lock<std::mutex> lock(mutex);
        while (connections.empty() && currentConnections >= maxConnections) {
            cv.wait(lock);
        }

        std::unique_ptr<sql::Connection> conn;
        if (!connections.empty()) {
            conn = std::move(connections.front());
            connections.pop_front();
        } else if (currentConnections < maxConnections) {
            conn = createConnection();
            if (conn) {
                currentConnections++;
            }
        }
        return conn;
    }

    // å½’还数据库连接
    void releaseConnection(std::unique_ptr<sql::Connection>& conn) {
        std::lock_guard<std::mutex> lock(mutex);
        if (currentConnections > minConnections) {
            currentConnections--;
        } else {
            connections.push_back(std::move(conn));
        }
        cv.notify_one();
    }
};

std::mutex SQLConnectionPool::mutex;
SQLConnectionPool* SQLConnectionPool::instance = nullptr;

 Server/ÍõçûÔª/document/·À×¢Èë.txt

@@ -1,29 +1,67 @@
https://blog.csdn.net/qq_28245087/article/details/131453274
1 .使用参数化查询
使用参数化查询可以防止SQL注入攻击，并提高代码的可读性和可维护性。在Java中，可以使用PreparedStatement来实现参数化查询。
2. è¾“入验证和过滤
输入验证和过滤是一种用于确保用户输入数据的安全性和有效性的技术。它可以防止恶意输入和错误数据导致的安全漏洞和应用程序错误。
3. ä½¿ç”¨å­˜å‚¨è¿‡ç¨‹
存储过程是一组预定义的SQL语句集合，可以在数据库中进行重复性和复杂性的操作。它们可以接受参数，并且可以在数据库中进行重复使用。
4.最小权限原则
最小权限原则是一种安全性原则，指的是为了保护敏感数据和系统资源，用户应该被授予最小必需的权限。这意味着用户只能访问和执行他们工作所需的数据库对象和操作，而不是拥有对整个数据库的完全访问权限。
使用最小权限原则可以减少潜在的安全风险和数据泄露的可能性。通过限制用户的权限，可以防止他们对数据库中的敏感数据进行未经授权的访问、修改或删除。
5. ä½¿ç”¨ORM框架
ORM（对象关系映射）框架是一种将对象模型和关系数据库之间进行映射的技术。它允许开发人员使用面向对象的方式操作数据库，而不需要编写繁琐的SQL语句。ORM框架将数据库表映射为对象，将表的行映射为对象的属性，将表之间的关系映射为对象之间的关联。
ORM框架的优点包括提高开发效率、减少代码量、简化数据库操作、提供对象级别的查询和持久化等。
6. ä½¿ç”¨å‡†å¤‡è¯­å¥
准备语句（Prepared Statement）是一种预编译的SQL语句，它允许开发人员将参数化查询发送到数据库，并在执行时提供参数值。准备语句可以提高数据库操作的性能和安全性，同时还能防止SQL注入攻击。
7.使用安全的数据库连接
使用安全的数据库连接是非常重要的，可以保护数据库免受恶意攻击和数据泄露。
使用SSL/TLS加密：通过使用SSL/TLS加密，可以确保数据库连接在传输过程中的数据安全。
8.避免动态拼接SQL语句
避免动态拼接SQL语句是为了防止SQL注入攻击和提高代码的可读性和可维护性。
9.使用防火墙和入侵检测系统
使用防火墙和入侵检测系统是为了保护计算机网络免受未经授权的访问和恶意攻击。
10.定期更新和维护数据库软件
定期更新和维护数据库软件是非常重要的，以确保数据库的安全性、性能和功能的稳定性。以下是一些说明和解释，以及使用Java代码示例来实现数据库软件的定期更新和维护：
#include <iostream>
#include <mysql_driver.h>
#include <mysql_connection.h>
#include <cppconn/statement.h>
#include <cppconn/prepared_statement.h>
#include <cppconn/resultset.h>
#include <string>
#include <regex>

定期更新：
定期更新数据库软件是为了获取最新的安全补丁、功能改进和性能优化。数据库供应商通常会发布更新版本，以修复已知的漏洞和问题。更新数据库软件可以提高数据库的安全性，并确保数据库与最新的技术和标准保持一致。
维护任务：
数据库软件的维护任务包括备份和恢复、索引优化、统计信息更新、空间管理、日志管理等。这些任务有助于提高数据库的性能、可用性和可靠性。
class DatabaseUtils {
public:
    // è¿žæŽ¥æ•°æ®åº“
    static sql::Connection* connect() {
        try {
            sql::mysql::MySQL_Driver* driver = sql::mysql::get_mysql_driver_instance();
            sql::Connection* con = driver->connect("tcp://127.0.0.1:3306", "mayi", "123456");
            con->setSchema("your_database");
            return con;
        } catch (sql::SQLException& e) {
            std::cerr << "数据库连接错误: " << e.what() << std::endl;
            return nullptr;
        }
    }

    // æ£€æŸ¥SQL语句是否存在潜在注入风险（简单正则校验）
    static bool isSafeSQL(const std::string& sql) {
        // ç®€å•çš„正则表达式，防止常见的注入关键词
        std::regex injectionRegex("(drop|delete|update|insert|select\\s+\\*\\s+from)", std::regex_constants::icase);
        return!std::regex_search(sql, injectionRegex);
    }

    // ä½¿ç”¨å‚数化查询执行SQL语句
    static sql::ResultSet* executeSafeQuery(sql::Connection* con, const std::string& sql, const std::vector<std::string>& params) {
        try {
            sql::PreparedStatement* pstmt = con->prepareStatement(sql);
            for (size_t i = 0; i < params.size(); ++i) {
                pstmt->setString(i + 1, params[i]);
            }
            return pstmt->executeQuery();
        } catch (sql::SQLException& e) {
            std::cerr << "查询执行错误: " << e.what() << std::endl;
            return nullptr;
        }
    }
};

int main() {
    sql::Connection* con = DatabaseUtils::connect();
    if (con) {
        std::string sql = "SELECT * FROM your_table WHERE column_name =?";
        std::vector<std::string> params = {"test_value"};
        if (DatabaseUtils::isSafeSQL(sql)) {
            sql::ResultSet* res = DatabaseUtils::executeSafeQuery(con, sql, params);
            if (res) {
                while (res->next()) {
                    // å¤„理结果
                    std::cout << res->getString(1) << std::endl;
                }
                delete res;
            }
        } else {
            std::cerr << "潜在的SQL注入风险" << std::endl;
        }
        delete con;
    }
    return 0;
}