配置模組

概述

什麼是配置？chatGPT是這麼回答的：

配置項（Configuration Item）是一個廣泛使用的術語，尤其在軟體開發、系統管理和IT服務管理中。它通常指的是系統或應用程式中的一個可配置的元素，可以用來調整系統或應用的行為、效能或其他特性。配置項可以是軟體、硬體、文件、資料庫、引數設定等。

配置項的用途

• 定製化：透過調整配置項，可以讓同一軟體或系統在不同環境中執行時表現出不同的行為和特性。
• 最佳化效能：透過修改配置引數，可以最佳化系統或應用程式的效能。
• 提高安全性：配置安全引數和策略，增強系統或應用程式的安全性。
• 簡化管理：透過集中管理和控制配置項，可以簡化系統或應用程式的管理和維護。

Sylar使用YAML作為配置檔案。最簡單的配置檔案方式還是 .ini 那種，選擇YAML是因為易讀易寫，同時能支援複雜的資料結構。這裡支援 STL 容器（vector, list, set, map 等等），支援自定義型別（但需要實現序列化和反序列化方法，也就是兩個仿函式）。YAML 語法快速簡單入門：https://www.runoob.com/w3cnote/yaml-intro.html

在配置模組中主要有以下幾個類：

• class ConfigVarBase：配置變數的基類
• class ConfigVar：配置引數模板子類，儲存對應型別的引數值，透過仿函式實現string和T型別之間的相互轉化
• class Config：ConfigVar的管理類

最後將日誌模組與配置模組整合起來，當配置檔案相應引數做出改變時，能夠透過回撥函式改變相應的引數。

配置模組實現了以下功能：

• 支援yaml格式的配置檔案解析
• 使用模板完成基礎型別，複雜型別（vector、map、set等），自定義型別的序列化與反序列化
• 利用回撥機制，在載入配置時，完成配置的更新
• 使用yaml-cpp庫，實現配置檔案讀取
• 約定大於配置

詳解

配置變數的基類 class ConfigVarBase

虛基類。包含配置名稱和配置描述兩個屬性。提供 toString() 和 fromString() 兩個純虛擬函式將引數值轉換成 YAML String 和從 YAML String 轉成引數的值。

// 名字
std::string m_name;
// 描述
std::string m_description;

virtual std::string toString() = 0; //轉化為string
virtual bool fromString(const std::string& val) = 0;    //從string轉化為相應型別
virtual std::string getTypeName() const = 0;    //獲得該型別的名稱

ConfigVarBase（建構函式 ）

std::transform被用於將字串m_name中的字母字元轉換為小寫形式並覆蓋原來的字串。所以不區分大小寫

ConfigVarBase(const std::string& name, const std::string &description = "")
        : m_name(name)
        , m_description(description)  {
        std::transform(m_name.begin(), m_name.end(), m_name.begin(), ::tolower);
    }

配置引數 class ConfigVar

/* 
 *  T 引數的具體型別
 *  FromStr 從std::string轉換成T型別的仿函式
 *  ToStr 從T轉換成std::string的仿函式
 *  std::string 為YAML格式的字串
 */
template <class T, class FromStr = LexicalCast<std::string, T>
                , class ToStr = LexicalCast<T, std::string> >
class ConfigVar : public ConfigVarBase {};

• 對於每種型別的配置，在對應的 ConfigVar 模板類例項化時都要提供其 FromStr 和 ToStr 兩個仿函式，用於實現該型別和 YAML 字串的相互轉換。
• 配置引數模板子類。繼承自 ConfigVarBase。
• 儲存對應型別 T 的引數值。
• 根據不同的非內建基本型別 T，FromStr 和 ToStr 具有不同的模板偏特化實現。
• 內含一個 std::map，存放配置變更的回撥函式。
  提供 setValue() 和 getValue() 函式，其中在 setValue() 函式中，會呼叫 std::map 中存放的所有回撥函式進行通知配置變更。
• 關於回撥函式，提供 addListener()、delListener()、getListener()、clearListener() 四個函式給外界使用。
  其中，FromStr和ToStr使用仿函式片特化的方式，實現不同型別T與string之間的相互轉化，例如vector與string之間的轉化，在轉化的過程中，字串格式都是以YAML為標準。

//F from_type, T to_type
template<class F, class T>
class LexicalCast {
public:
    T operator() (const F &v) {
        return boost::lexical_cast<T>(v);
    }
};
​
// string To vector
// "[1, 2, 3]" ——> [1, 2, 3]
template<class T>
class LexicalCast<std::string, std::vector<T>> {
public:
    std::vector<T> operator() (const std::string& v) {
        YAML::Node node = YAML::Load(v);
        typename std::vector<T> vec;
        std::stringstream ss;
        for (size_t i = 0; i < node.size(); ++i) {
            ss.str("");
            ss << node[i];
            vec.push_back(LexicalCast<std::string, T>()(ss.str()));
        }
        return vec;
    }
};
​
// vector To string
// [1, 2, 3] ——> - 1
//               - 2
//               - 3             
template<class T>
class LexicalCast<std::vector<T>, std::string> {
public:
    std::string operator() (const std::vector<T>& v) {
        YAML::Node node;
        for (auto& i : v) {
            node.push_back(YAML::Load(LexicalCast<T, std::string>()(i)));
        }
        std::stringstream ss;
        ss << node;
        return ss.str();
    }
};

mumber（成員變數）

    // 引數值
    T m_val;
    // 變更回撥函式組， uint64_t key(要求唯一，一般可以用hash)
    // typedef std::function<void(const T &old_value, const T &new_value)> on_change_cb;
    std::map<uint64_t, on_change_cb> m_cbs;
    // 讀寫鎖
    mutable RWMutexType m_mutex;

函式

// 建構函式
// 給配置名、描述、引數值賦值
ConfigVar(const std::string& name
        , const T& defult_val
        , const std::string& description = "")
    : ConfigVarBase(name, description)
    , m_val(defult_val) {
​
    }

// toString（從引數轉為string）
// 若成功，返回轉化後的string，失敗打出日誌，異常以及值的型別
std::string toString() override {
    try{
        RWMutexType::ReadLock lock(m_mutex);
        return ToStr()(m_val);
    }
    catch (std::exception &e)
    {
        SYLAR_LOG_ERROR(SYLAR_LOG_ROOT()) << "ConfigVar::toString exception"
            << e.what() << "convert: " << typeid(m_val).name() << "to String";
    }
    return "";
}

// fromString（從string轉為值）
// 從YAML String轉為引數值，失敗打出日誌，異常以及值的型別
bool fromString(const std::string& val) override {
    try {
        setValue(FromStr()(val));
    }
    catch (std::exception &e)
    {
        SYLAR_LOG_ERROR(SYLAR_LOG_ROOT()) << "ConfigVar::fromString exception "
            << e.what() << " convert: String to " << typeid(m_val).name()
            << " - " << val;
    }
    return false;
}

// getValue（獲取）和setValue（設定引數）
// 獲取引數直接返回m_val，設定引數時，判斷v與m_val是否相同，若相同，直接返回，若不相同，則回撥變更函式
// 獲取引數
const T getValue() const {
    RWMutexType::ReadLock lock(m_mutex);
    return m_val;
}
​
// 設定引數
void setValue(const T& v) {
    {
        RWMutexType::ReadLock lock(m_mutex);
        if (v == m_val) {
            return;
        }
        for (auto& i : m_cbs) {
            i.second(m_val, v);
        }
    }
    RWMutexType::WriteLock lock(m_mutex);
    m_val = v;
}

// addListener（新增變化回撥函式）
// 返回該回撥函式對應的唯一id，用於刪除回撥函式
uint64_t addListener(on_change_cb cb) {
    static uint64_t s_fun_id = 0;
    RWMutexType::WriteLock lock(m_mutex);
    ++s_fun_id;
    m_cbs[s_fun_id] = cb;
​
    return s_fun_id;
}

// delListener（刪除回撥函式）
void delListener(uint64_t key) {
    RWMutexType::WriteLock lock(m_mutex);
    m_cbs.erase(key);
}

// getListener（獲取回撥函式）
on_change_cb getListener(uint64_t key) {
    RWMutexType::ReadLock lock(m_mutex);
    auto it = m_cbs.find(key);
    return it == m_cbs.end() ? nullptr : it->second;
}

// clearListener（清除回撥函式）
void clearListener() {
    RWMutexType::WriteLock lock(m_mutex);
    m_cbs.clear();
} 

ConfigVar管理類 Config

Config是ConfigVar的管理類，用來管理全部的ConfigVar全特化後的物件。他透過單例模式進行管理，整個服務程序只有一個物件。

沒有任何靜態成員變數，透過GetDatas函式內的靜態的map進行管理，以及用GetMutex函式內的靜態的鎖加解鎖。

Lookup函式用於建立或獲取對應引數名的配置引數。傳入三個引數，字串形式的配置引數名稱，T型別的引數預設值，字串形式的引數描述。首先判斷是否存在引數名稱的配置，若存在，則從map中取出這個配置項（ConfigVarBase型別的指標，指向了ConfigVar的某個全特化的類的物件）。並且透過dynamic_pointer_cast，轉換成ConfigVar型別的智慧指標。若tmp為nullptr的話，說明map中存在著相同名字的配置項，但是map中配置項的引數型別和傳入的預設值的引數預設值不一樣，返回nullptr，否則就返回正確的配置引數。接著判斷引數名是否包含非法字元，存在就丟擲一個異常。然後建立一個ConfigVar型別的指標指向的ConfigVar型別的物件，新增到map中。

還有一個過載的Lookup函式用於查詢配置引數，傳入配置引數名稱，返回對應配置引數名稱的配置引數。若不存在或者型別錯誤的話，都會返回nullptr。

LoadFromYaml函式用於使用yaml初始化配置模組，引數傳入一個yaml物件。函式內有名為ListAllMember的函式，採用類似遍歷二叉樹的方式遍歷。

LoadFromConfDir用於載入path資料夾裡面的配置檔案。

LookupBase用於返回配置引數的基類（他跟上面的Lookup的區別是一個返回ConfigVar型別的指標，一個返回基類指標）。

Visit函式用於遍歷配置模組裡面所有配置項，並且將配置項作為傳入函式的引數進行執行。

用法如下：

sylar::ConfigVar<int>::ptr g_int_value_config = sylar::Config::Lookup("system.port", (int)8080, "system port");
  				|
				|
			   \|/
SYLAR_LOG_INFO(SYLAR_LOG_ROOT()) << "before: " << g_int_value_config->getValue();
  				|
				|
			   \|/
YAML::Node root = YAML::LoadFile("/home/sylar/workspace/sylar/bin/conf/test.yml");
sylar::Config::LoadFromYaml(root);
				|
				|
			   \|/
SYLAR_LOG_INFO(SYLAR_LOG_ROOT()) << "after: " << g_int_value_config->getValue();

成員變數：

// typedef std::unordered_map<std::string, ConfigVarBase::ptr> ConfigVarMap;
// 返回所有的配置項
static ConfigVarMap& GetDatas() {
    static ConfigVarMap s_datas;
    return s_datas;
}
​
// 配置項的RWMutex
static RWMutexType& GetMutex() {
    static RWMutexType s_mutex;
    return s_mutex;
}

Lookup（獲取/建立對應引數名的配置引數）

template<class T>
static typename ConfigVar<T>::ptr Lookup(const std::string& name
        , const T& default_value, const std::string& description = "") {
        RWMutexType::WriteLock lock(GetMutex());
        auto it = GetDatas().find(name);
        // 找到了
        if (it != GetDatas().end()) {
            // 將ConfigVarBase轉換為ConfigVar
            auto tmp = std::dynamic_pointer_cast<ConfigVar<T>>(it->second);
            // 若轉換成功，顯示顯示成功
            if (tmp) {
                SYLAR_LOG_INFO(SYLAR_LOG_ROOT()) << "Lookup name = " << name << " exists";
                return tmp;
            }   else {
                SYLAR_LOG_ERROR(SYLAR_LOG_ROOT()) << "Lookup name = " << name << " exitst but type not "
                                                  << typeid(T).name() << ", real_type = " << it->second->getTypeName()
                                                  << " " << it->second->toString();
                return nullptr;
            }
        }
    
        // 用於在當前字串中查詢第一個不屬於指定字符集合的字元，並返回該字元位置的索引。如果沒有找到任何字元，則返回 std::string::npos。
        // name不全在 "abcdefghigklmnopqrstuvwxyz._012345678" 中 
        // name中有非法字元，丟擲異常
        if (name.find_first_not_of("abcdefghigklmnopqrstuvwxyz._012345678")
                != std::string::npos) {
            SYLAR_LOG_ERROR(SYLAR_LOG_ROOT()) << "Lookup name invalid" << name;
            throw std::invalid_argument(name);
        }
        
        // 若沒有，則建立一個新的ConfigVar
        // typename：用於告訴編譯器 ConfigVar<T>::ptr 是一個型別而不是成員變數。
        typename ConfigVar<T>::ptr v(new ConfigVar<T>(name, default_value, description));
        GetDatas()[name] = v;
        return v;
}

Lookup（查詢配置引數）

template<class T>
static typename ConfigVar<T>::ptr Lookup(const std::string& name) {
        RWMutexType::ReadLock lock(GetMutex());
        auto it = GetDatas().find(name);
        if (it == GetDatas().end()) {
            return nullptr;
        }
        return std::dynamic_pointer_cast<ConfigVar<T>>(it->second);
}

LookupBase（查詢配置引數,返回配置引數的基類）

ConfigVarBase::ptr Config::LookupBase(const std::string& name) {
    RWMutexType::ReadLock lock(GetMutex());
    auto it = GetDatas().find(name);
    return it == GetDatas().end() ? nullptr : it->second;
}

LoadFromYaml（使用YAML::Node初始化配置模組）

// 遞迴方式，遍歷YAML格式的配置檔案中的所有成員，將每個節點的名稱和值存在list中
static void ListAllMember(const std::string& prefix,
                          const YAML::Node& node,
                          std::list<std::pair<std::string, const YAML::Node> >& output) {
    // prefix字元不合法
    if (prefix.find_first_not_of("abcdefghigklmnopqrstuvwxyz._012345678") 
            != std::string::npos) {
        SYLAR_LOG_INFO(SYLAR_LOG_ROOT()) << "Config invalid name: " << prefix << " ! " << node;
        return;
    }
    output.push_back(std::make_pair(prefix, node));
    // 若解析的是map
    if (node.IsMap()) {
        for (auto it = node.begin();
                 it != node.end(); ++it) {
            // 若字首為空,說明為頂層，prefix為key的值，否則為子層，prefix為父層加上當前層。it->second為當前node
            ListAllMember(prefix.empty() ? it->first.Scalar() : prefix + "." + it->first.Scalar(), it->second, output);
        }
    }
}
​
void Config::LoadFromYaml(const YAML::Node& root) {
    // 將root中的所有節點資訊儲存到all_nodes中
    std::list<std::pair<std::string, const YAML::Node> > all_nodes;
    ListAllMember("", root, all_nodes);
    
    // 遍歷list
    for(auto &i : all_nodes) {
        std::string &key = i.first;
        if (key.empty()) {
            continue;
        }
        
        // 無視大小寫
        std::transform(key.begin(), key.end(), key.begin(), ::tolower);
        // 查詢名為key的配置引數
        ConfigVarBase::ptr var = LookupBase(key);
        // 若找到
        if (var) {
            // 若為純量，則呼叫fromString(會呼叫setValue設值)
            if (i.second.IsScalar()) {
                var->fromString(i.second.Scalar());
            // 否則為陣列，將其轉換為字串
            } else {
                std::stringstream ss;
                ss << i.second;
                var->fromString(ss.str());
            }
        }
    }
}

Visit（遍歷配置模組裡面所有配置項）

void Config::Visit(std::function<void(ConfigVarBase::ptr)> cb) {
    RWMutexType::ReadLock lock(GetMutex());
    ConfigVarMap& m = GetDatas();
    for (auto it = m.begin();
         it != m.end(); ++it) {
        cb(it->second);
    }
}