上传日志

jhc

2024-11-07 f647dd12ca604593774b7022c49f47ac98baf617

上传日志

 Client/¼½ºÆêÆ/log/ÈÕÖ¾_¼½ºÆêÆ_1107.doc

Binary files differ

 Client/ËÎ껕i/log/ÈÕÖ¾_ËÎ껕i_1106.doc

Binary files differ

 Client/Ö캽/log/Ö캽1105.doc

Binary files differ

 Client/ÀîÏüÔö/log/ÀúÊ·²éѯ_ÀîÏüÔö_1104.doc

Binary files differ

 Client/ÀîÏüÔö/log/ÀúÊ·²éѯ_ÀîÏüÔö_1105.doc

Binary files differ

 Client/ÍõöÎöÎ/log/ÈÕÖ¾_ÍõöÎöÎ_1106.doc

Binary files differ

 Client/ÉêŸ@/log/ÈÕÖ¾_ÉêŸ@_1106.doc

Binary files differ

 Client/Ö£¿­ÎÄ/log/Ö£¿­ÎÄ1106.doc

Binary files differ

 Client/ÀèºëÁØ/log/É豸¹ÜÀí_ÀèºëÁØ_1106.doc

Binary files differ

 Client/¹¨ÆôÏé/log/ÈÕ־ģ°å_¹¨ÆôÏé_1106.doc

Binary files differ

 Server/ÍõçûÔª/code/ConnectionPool.cpp

@@ -1,125 +1,101 @@
#include "stdafx.h"
#include "ConnectionPool.h"

#include <fstream>
#include <iostream>
#include <thread>

ConnectionPool* ConnectionPool::getInstance() {
    static ConnectionPool connPool;
    return &connPool;
}

ConnectionPool::ConnectionPool() {
    // åŠ è½½é…ç½®æ–‡ä»¶
    if (!parseJsonFile()) {
        std::cout << "parseJsonFile is failed!" << std::endl;
        return;
    }
    for ( int i = 0 ; i < m_min_conn ; i++ ) {
        addConnection( );
    }
    // åˆ›å»ºä¸€ä¸ªçº¿ç¨‹ï¼Œå¯¹è¿žæŽ¥æ•°è¿›è¡Œç›‘控 ï¼Œè¿žæŽ¥æ•°ä¸è¶³å°±å†ç»§ç»­åˆ›å»º
    std::thread producer(&ConnectionPool::produce, this);
    // å¯¹è¿žæŽ¥æ•°è¿›è¡Œç›‘控 ï¼Œå¦‚果有太多空闲得线程 ï¼Œé‚£ä¹ˆå°±å¯¹å…¶è¿›è¡Œé”€æ¯
    std::thread recycler( &ConnectionPool::recycle,  this);

    // çº¿ç¨‹åˆ†ç¦»
    producer.detach();
    recycler.detach();

    m_min_conn = 5; // å‡è®¾æœ€å°è¿žæŽ¥æ•°ä¸º 5
    m_max_conn = 10; // å‡è®¾æœ€å¤§è¿žæŽ¥æ•°ä¸º 10
    m_timeout = 1000; // å‡è®¾è¿žæŽ¥è¶…时时间为 1000 æ¯«ç§’
    max_del_time = 60000; // å‡è®¾æœ€å¤§ç©ºé—²æ—¶é—´ä¸º 60000 æ¯«ç§’

    for (int i = 0; i < m_min_conn; i++) {
        addConnection();
    }
    // åˆ›å»ºä¸€ä¸ªçº¿ç¨‹ï¼Œå¯¹è¿žæŽ¥æ•°è¿›è¡Œç›‘控 ï¼Œè¿žæŽ¥æ•°ä¸è¶³å°±å†ç»§ç»­åˆ›å»º
    thread producer(&ConnectionPool::produce, this);
    // å¯¹è¿žæŽ¥æ•°è¿›è¡Œç›‘控 ï¼Œå¦‚果有太多空闲得线程 ï¼Œé‚£ä¹ˆå°±å¯¹å…¶è¿›è¡Œé”€æ¯
    thread recycler(&ConnectionPool::recycle, this);

    // çº¿ç¨‹åˆ†ç¦»
    producer.detach();
    recycler.detach();
}

bool ConnectionPool::parseJsonFile() {

    /*std::ifstream ifs("dbconf.json");
    Reader rd;
    Value root;
    rd.parse(ifs, root);
    if ( root.isObject( ) ) {
        m_ip = root["ip"].asString();
        m_port = root["port"].asInt();
        m_userName = root["userName"].asString();
        m_passwd = root["password"].asString();
        m_db = root["dbName"].asString();
        m_min_conn = root["minSize"].asInt();
        m_max_conn = root["maxSize"].asInt();
        max_del_time = root["maxDleTime"].asInt();
        m_timeout = root["timeout"].asInt();
        return true;
    }*/
    return false;
}

void ConnectionPool::description() {
    std::cout << m_ip << ". " << m_userName << ". " << m_passwd << ". " << m_db << ". "
               << m_port << ". " << m_max_conn << ". " << m_min_conn << ". " << m_timeout << ". " 
               << max_del_time << std::endl;
}

ConnectionPool::~ConnectionPool() {
    while (!m_connkQueue.empty()) {
        MysqlConn* conn = m_connkQueue.front();
        m_connkQueue.pop();
        delete  conn;
    }

    while (!m_connkQueue.empty()) {
        MysqlConn* conn = m_connkQueue.front();
        m_connkQueue.pop();
        delete conn;
    }
}

void ConnectionPool::addConnection() {
    MysqlConn* conn = new MysqlConn();
    if ( !conn->connect( m_ip, m_userName, m_passwd, m_db, m_port  ) ) {
        std::cout << "ConnectionPool connect to mysql is failed!" << std::endl;
        delete conn;
        return;
    }
    conn->refreshActiveTime( );
    m_connkQueue.push(conn);
    m_cond.notify_one();   // å”¤é†’一个线程
    MysqlConn* conn = new MysqlConn();
    if (!conn->isConnected()) {
        cout << "ConnectionPool connect to mysql is failed!" << endl;
        delete conn;
        return;
    }
    conn->refreshActiveTime();
    m_connkQueue.push(conn);
    m_cond.notify_one();   // å”¤é†’一个线程
}

void ConnectionPool::produce(){
    while (true) {
        std::unique_lock<std::mutex> lock(m_mutex);
        while (m_connkQueue.size() >= m_min_conn) { // è¿žæŽ¥é˜Ÿåˆ—的数量大于最小的连接数
            m_cond.wait(lock);
        }
        addConnection();
    }
void ConnectionPool::produce() {
    while (true) {
        unique_lock<mutex> lock(m_mutex);
        while (m_connkQueue.size() >= m_min_conn) { // è¿žæŽ¥é˜Ÿåˆ—的数量大于最小的连接数
            m_cond.wait(lock);
        }
        addConnection();
    }
}

// åˆ é™¤ç©ºé—²è¿žæŽ¥
void ConnectionPool::recycle() {
    while ( true ) {
        std::this_thread::sleep_for( std::chrono::milliseconds(500));   // ä¼‘眠500 ms
        std::unique_lock<std::mutex>lock(m_mutex);
        while ( m_connkQueue.size() > m_min_conn ) {
            MysqlConn* conn = m_connkQueue.front( );
            if (conn->getActiveTime() >= max_del_time) {
                m_connkQueue.pop();
                delete conn;
            }
            else {
                break;
            }
        }
    }
    while (true) {
        this_thread::sleep_for(chrono::milliseconds(500));   // ä¼‘眠 500 ms
        unique_lock<mutex> lock(m_mutex);
        while (m_connkQueue.size() > m_min_conn) {
            MysqlConn* conn = m_connkQueue.front();
            if (conn->getActiveTime() >= max_del_time) {
                m_connkQueue.pop();
                delete conn;
            }
            else {
                break;
            }
        }
    }
}

std::shared_ptr<MysqlConn>  ConnectionPool::getMysqlConn() {
	
    std::unique_lock<std::mutex>lock(m_mutex);
    while ( m_connkQueue.empty()) {
        // å¦‚果等待一段时间后,队列还是为空,返回一个 null
        if ( std::cv_status::timeout == m_cond.wait_for(lock, std::chrono::milliseconds(m_timeout)) ) {
            if( m_connkQueue.empty( ) )    return nullptr;
        }
    }
    std::shared_ptr<MysqlConn> connPtr(std::move(m_connkQueue.front()), [this](MysqlConn* conn) {
        std::unique_lock <std::mutex>lock(m_mutex) ;
        conn->refreshActiveTime();
        m_connkQueue.push(conn);
        });
    m_connkQueue.pop();
    m_cond.notify_one();   // å”¤é†’阻塞的生产者线程,开始生产
    return connPtr;
shared_ptr<MysqlConn> ConnectionPool::getMysqlConn() {
    unique_lock<mutex> lock(m_mutex);
    while (m_connkQueue.empty()) {
        // å¦‚果等待一段时间后,队列还是为空,返回一个 null
        if (cv_status::timeout == m_cond.wait_for(lock, chrono::milliseconds(m_timeout))) {
            if (m_connkQueue.empty()) return nullptr;
        }
    }
    shared_ptr<MysqlConn> connPtr(move(m_connkQueue.front()), [this](MysqlConn* conn) {
        unique_lock<mutex> lock(m_mutex);
        conn->refreshActiveTime();
        m_connkQueue.push(conn);
        });
    m_connkQueue.pop();
    m_cond.notify_one();   // å”¤é†’阻塞的生产者线程,开始生产
    return connPtr;
}
void ConnectionPool::description() {
    cout << m_ip << ". " << m_userName << ". " << m_passwd << ". " << m_db << ". "
        << m_port << ". " << m_max_conn << ". " << m_min_conn << ". " << m_timeout << ". "
        << max_del_time << endl;
}

ConnectionPool* ConnectionPool::getInstance() {
    static ConnectionPool connPool;
    return &connPool;
}

 Server/ÍõçûÔª/code/ConnectionPool.h

@@ -1,50 +1,44 @@
#pragma once

#include <queue>
#include <mutex>
#include <condition_variable>
//#include <json/json.h>

#include "MysqlConn.h"

//using namespace Json;

class ConnectionPool
{
public:
    static ConnectionPool* getInstance( );
    static ConnectionPool* getInstance();

    std::shared_ptr<MysqlConn>  getMysqlConn();    // ä»Žæ•°æ®åº“连接池获取连接
    shared_ptr<MysqlConn> getMysqlConn();    // ä»Žæ•°æ®åº“连接池获取连接

    ConnectionPool(const ConnectionPool& other) = delete;
    ConnectionPool& operator = (const ConnectionPool & other ) = delete;
	
    ~ConnectionPool();
    ConnectionPool(const ConnectionPool& other) = delete;
    ConnectionPool& operator=(const ConnectionPool& other) = delete;

    void description();
    ~ConnectionPool();

    void description();

protected:
    ConnectionPool( );   // æž„造函数
    ConnectionPool();   // æž„造函数
private:
    bool parseJsonFile();   // è§£æžé…ç½®
    // ä¸å†éœ€è¦è§£æžé…ç½®æ–‡ä»¶çš„函数
    // bool parseJsonFile();   // è§£æžé…ç½®

    void produce();
    void recycle();
    void addConnection();  // å¢žåŠ è¿žæŽ¥æ•°
    void produce();
    void recycle();
    void addConnection();  // å¢žåŠ è¿žæŽ¥æ•°

    std::string  m_ip;
    std::string  m_userName;
    std::string  m_passwd;
    std::string  m_db;
    unsigned short m_port;
    // å†™æ­»çš„数据库连接参数
    string m_ip = "127.0.0.1";
    string m_userName = "root";
    string m_passwd = "123456";
    string m_db = "mayi_kunlun";
    unsigned short m_port = 3306;

    int m_max_conn;
    int m_min_conn;
    int m_max_conn;
    int m_min_conn;

    int m_timeout;      // è¿žæŽ¥è¶…时时间
    int max_del_time;   // æœ€å¤§åˆ é™¤æ—¶é—´( è¿žæŽ¥ç©ºé—²æ—¶é—´è¶…过这个,就给当前连接关闭 )
    std::queue<MysqlConn*>m_connkQueue ;   // è¿žæŽ¥é˜Ÿåˆ—
    std::mutex m_mutex;  // äº’斥锁
    std::condition_variable m_cond;   // æ¡ä»¶å˜é‡
    int m_timeout;      // è¿žæŽ¥è¶…时时间
    int max_del_time;   // æœ€å¤§åˆ é™¤æ—¶é—´( è¿žæŽ¥ç©ºé—²æ—¶é—´è¶…过这个,就给当前连接关闭 )
    queue<MysqlConn*> m_connkQueue;   // è¿žæŽ¥é˜Ÿåˆ—
    mutex m_mutex;  // äº’斥锁
    condition_variable m_cond;   // æ¡ä»¶å˜é‡
};


 Server/ÍõçûÔª/code/MysqlConn.cpp

@@ -1,37 +1,60 @@
#include "stdafx.h"
#include "MysqlConn.h"
#include <regex>



// åˆå§‹åŒ–连接
// åˆå§‹åŒ–连接
MysqlConn::MysqlConn() {
    mysql_ = mysql_init(mysql_);
    // è®¾ç½®å­—符集
    if (mysql_) mysql_set_character_set(mysql_, "gbk");
}

// è¿žæŽ¥æ•°æ®åº“
bool MysqlConn::connect(std::string ip, std::string userName, std::string passwd, std::string db, int port) {
    mysql_ = mysql_real_connect(mysql_, ip.c_str(), userName.c_str(), passwd.c_str(), db.c_str(), port, nullptr, 0);
    if (!mysql_) {
        return false;
    m_mysql = mysql_init(nullptr);
    if (!m_mysql) {
        cout << "Failed to initialize MySQL." << endl;
        return;
    }
    return true;
    // è®¾ç½®å­—符集
    if (m_mysql) mysql_set_character_set(m_mysql, "gbk");
    // ä½¿ç”¨å†™æ­»çš„参数连接数据库
    m_mysql = mysql_real_connect(m_mysql, "127.0.0.1", "root", "123456", "mayi_kunlun", 3306, nullptr, 0);
    if (!m_mysql) {
        cout << "MysqlConn connect to mysql is failed!" << endl;
        // ç¡®ä¿åœ¨è¿žæŽ¥å¤±è´¥æ—¶æ­£ç¡®æ¸…理资源
        mysql_close(m_mysql);
        m_mysql = nullptr;
    }
    // åˆå§‹åŒ– row_ å’Œ res_
    m_row = nullptr;
    m_res = nullptr;
}
bool MysqlConn::isConnected() {
    return m_mysql != nullptr;
}
// è¿žæŽ¥æ•°æ®åº“
//bool MysqlConn::connect() {
//    string ip = "127.0.0.1";
//    string userName = "root";
//    string passwd = "123456";
//    string db = "mayi_kunlun";
//    int port = 3306;
//    m_mysql = mysql_real_connect(mysql_, ip.c_str(), userName.c_str(), passwd.c_str(), db.c_str(), port, nullptr, 0);
//    if (!m_mysql) {
//        return false;
//    }
//    return true;
//}

// é‡Šæ”¾èµ„源
MysqlConn::~MysqlConn() {
    if (mysql_) {
        mysql_close(mysql_);
        mysql_ = nullptr;
    if (m_mysql) {
        mysql_close(m_mysql);
        m_mysql = nullptr;
    }
    freeRes();
}

// æ›´æ–°æ•°æ®
bool MysqlConn::update(std::string sql) {
bool MysqlConn::update(string sql) {
    // å‚数化查询优化后的安全检查
    MYSQL_STMT* stmt = mysql_stmt_init(mysql_);
    MYSQL_STMT* stmt = mysql_stmt_init(m_mysql);
    if (!stmt) {
        return false;
    }
@@ -53,11 +76,36 @@
    return true;
}

bool MysqlConn::query(string sql, vector<vector<string>>& result)
{
    freeRes();
    int ret = mysql_query(m_mysql, sql.c_str());
    if (ret != 0) {
        fprintf(stderr, "Query failed: %s\n", mysql_error(m_mysql));
        return false;
    }
    // èŽ·å–查询结果
    m_res = mysql_store_result(m_mysql);
    if (!m_res)   return false;
    //将结果集转到二维数组result里面
    //int col_cnt = m_mysql->field_count;
    int col_cnt = mysql_field_count(m_mysql);
    cout << col_cnt << endl;
    while (m_row = mysql_fetch_row(m_res)) {
        vector<string> tmp;
        for (int i = 0; i < col_cnt; i++) {
            tmp.push_back(m_row[i]);
        }
        result.push_back(tmp);
    }
    return true;
}

// æŸ¥è¯¢æ•°æ®åº“
bool MysqlConn::query(std::string sql) {
bool MysqlConn::query(string sql) {
    freeRes();
    // å‚数化查询优化后的安全检查
    MYSQL_STMT* stmt = mysql_stmt_init(mysql_);
    MYSQL_STMT* stmt = mysql_stmt_init(m_mysql);
    if (!stmt) {
        return false;
    }
@@ -75,8 +123,8 @@
        mysql_stmt_close(stmt);
        return false;
    }
    res_ = mysql_stmt_result_metadata(stmt);
    if (!res_) {
    m_res = mysql_stmt_result_metadata(stmt);
    if (!m_row) {
        mysql_stmt_close(stmt);
        return false;
    }
@@ -86,59 +134,60 @@

// å¾—到结果集
bool MysqlConn::getResult() {
    if (res_) {
        row_ = mysql_fetch_row(res_);
        if (row_) return true;
    if (m_row) {
        m_row = mysql_fetch_row(m_res);
        if (m_row) return true;
    }
    return false;
}

// èŽ·å–结果集的字段
std::string MysqlConn::getField(int index) {
    int cols = mysql_num_fields(res_);
    if (index >= cols || index < 0) return std::string("");
string MysqlConn::getField(int index) {
    int cols = mysql_num_fields(m_res);
    if (!m_res || index >= cols || index < 0) return string("");

    char* value = row_[index];
    unsigned long len = mysql_fetch_lengths(res_)[index];
    return std::string(value, len);
    char* value = m_row[index];
    // ä½¿ç”¨æ˜¾å¼ç±»åž‹è½¬æ¢
    unsigned long len = static_cast<unsigned long>(mysql_fetch_lengths(m_res)[index]);
    return string(value, len);
}

// äº‹åŠ¡æ“ä½œ
bool MysqlConn::transaction() {
    return mysql_autocommit(mysql_, false);
    return mysql_autocommit(m_mysql, false);
}

// æäº¤äº‹åŠ¡
bool MysqlConn::commit() {
    return mysql_commit(mysql_);
    return mysql_commit(m_mysql);
}

// äº‹åŠ¡å›žæ»š
bool MysqlConn::rollback() {
    return mysql_rollback(mysql_);
    return mysql_rollback(m_mysql);
}

void MysqlConn::refreshActiveTime() {
    activeTime_ = std::chrono::steady_clock::now();
    m_activeTime = chrono::steady_clock::now();
}

long long MysqlConn::getActiveTime() {
    // çº³ç±³
    std::chrono::nanoseconds nased = std::chrono::steady_clock::now() - activeTime_;
    chrono::nanoseconds nased = chrono::steady_clock::now() - m_activeTime;
    // è½¬æ¢æˆæ¯«ç±³
    std::chrono::microseconds millsed = std::chrono::duration_cast<std::chrono::microseconds>(nased);
    chrono::microseconds millsed = chrono::duration_cast<chrono::microseconds>(nased);
    return millsed.count();   // å¤šå°‘毫秒
}

// å®‰å…¨æ ¡éªŒå®žçŽ°ï¼Œè¿™é‡Œç®€å•ä½¿ç”¨æ­£åˆ™è¡¨è¾¾å¼åˆ¤æ–­æ˜¯å¦åŒ…含危险字符
bool MysqlConn::isSqlSafe(const std::string& sql) {
    std::regex dangerousPattern(".*(['\";\\-+=]).*");
    return!std::regex_search(sql, dangerousPattern);
bool MysqlConn::isSqlSafe(const string& sql) {
    regex dangerousPattern(".*(['\";\\-+=]).*");
    return!regex_search(sql, dangerousPattern);
}

void MysqlConn::freeRes() {
    if (res_) {
        mysql_free_result(res_);
        res_ = nullptr;
    if (m_res) {
        mysql_free_result(m_res);
        m_res = nullptr;
    }
}

 Server/ÍõçûÔª/code/MysqlConn.h

@@ -2,48 +2,53 @@

#include <string>
#include <WinSock2.h>
//#include <mysql.h>
#include "MySQL/include/mysql.h"
#include <string.h>
#include <chrono>

#include <iostream>
#include <memory>
#include <queue>
#include <mutex>
#include <condition_variable>
#include <regex>
#pragma comment(lib,"./MySQL/lib/libmysql.lib")

using namespace std;
class MysqlConn
{
public:
    // åˆå§‹åŒ–连接
    MysqlConn();
    // è¿žæŽ¥æ•°æ®åº“
    bool connect(std::string ip, std::string userName, std::string passwd, std::string db , int port = 3306);
    //bool connect();
    // é‡Šæ”¾èµ„源
    ~MysqlConn( );
    ~MysqlConn();
    // æ›´æ–°æ•°æ®åº“  ( insert  update delete )
    bool update(std::string sql);
    bool update(string sql);
    // æŸ¥è¯¢æ•°æ®åº“
    bool query(std::string sql);
    bool query(string sql, vector<vector<string>>& result);
    bool query(string sql);
    // å¾—到结果集
    bool getResult();
    // èŽ·å–结果集的字段
    std::string getField(int index);
    string getField(int index);
    // äº‹åŠ¡æ“ä½œ
    bool transaction();
    // æäº¤äº‹åŠ¡
    bool commit( );
    bool commit();
    // äº‹åŠ¡å›žæ»š
    bool rollback();

    void refreshActiveTime( );   // åˆ·æ–°æ´»è·ƒæ—¶é—´

    void refreshActiveTime();   // åˆ·æ–°æ´»è·ƒæ—¶é—´
    long long getActiveTime();   // èŽ·å–当前活跃的时间间隔 
    // å®‰å…¨æ ¡éªŒæŽ¥å£
    bool isSqlSafe(const std::string& sql);

private:

    bool isSqlSafe(const string& sql);
    bool isConnected();
protected:
    void freeRes();
    MYSQL* mysql_ = NULL ;
    MYSQL_RES* res_ = NULL;
    MYSQL_ROW row_ = nullptr;
    std::chrono::steady_clock::time_point  activeTime_;
    MYSQL* m_mysql;
    MYSQL_RES* m_res;
    MYSQL_ROW m_row;
    chrono::steady_clock::time_point  m_activeTime;
};


 Server/ÍõçûÔª/log/ÈÕ־ģ°å_ÍõçûÔª_1101.doc

Binary files differ

 Server/ÍõçûÔª/log/ÈÕ־ģ°å_ÍõçûÔª_1103 .doc

Binary files differ

 Server/ÍõçûÔª/log/ÈÕ־ģ°å_ÍõçûÔª_1104.doc

Binary files differ

 Server/ÍõçûÔª/log/ÈÕ־ģ°å_ÍõçûÔª_1105.doc

Binary files differ

 Server/ÂíÓ庼/log/20241106À¥ÂØÈÕ±¨.doc

Binary files differ

 Server/ÂíÓ庼/log/ÈÕÖ¾_ÂíÓ庼_20241106.doc

Binary files differ

 kunlun.sql

@@ -211,4 +211,8 @@
/*!40014 SET FOREIGN_KEY_CHECKS=IFNULL(@OLD_FOREIGN_KEY_CHECKS, 1) */;
/*!40101 SET CHARACTER_SET_CLIENT=@OLD_CHARACTER_SET_CLIENT */;
/*!40111 SET SQL_NOTES=IFNULL(@OLD_SQL_NOTES, 1) */;
z
<<<<<<< HEAD
z
=======
SELECT id,devices_name,longitude,latitude,devices_status FROM devices_management;
>>>>>>> 2e420a0a40cc3fcc62bcb42ee6a25f4ad4f22dd3