在软件开发中，构建模块化、可扩展和易维护的应用程序是每位架构师的目标。本文将介绍如何设计和实现一个模块类来构建一个模块化编程框架，以便更好地管理和扩展应用程序功能。
在软件开发中，模块化编程是一种重要的架构方法。它将应用程序分解为多个相互独立的模块，每个模块负责不同的任务。这种方法使得代码更易维护、更易扩展，也更易重用。本文将介绍一个简单而强大的模块化编程框架，它包括两个主要组件：模块类（Module）和模块工厂类（ModuleFactory）。这两者的结合为开发者提供了一种灵活的方式，可以轻松地创建和管理模块。
模块类是模块化编程框架的核心。每个模块都是一个继承自 Module 的类。模块类有一个名字属性，用于唯一标识每个模块。
class Module {
public:
Module() = default;
virtual ~Module() = default;
const std::string &getModuleName() const {
return moduleName_;
}
protected:
void setModuleName(const std::string &name) {
moduleName_ = name;
}
private:
std::string moduleName_;
friend class ModuleFactory;
};
在上述代码中，Module 类包括了以下主要部分：
setModuleName 方法的私有访问权限确保只有 ModuleFactory 类能够修改模块的名字。
模块工厂类是一个用于创建和管理模块的中心枢纽。每个模块必须在工厂中进行注册，以便能够通过工厂创建和获取模块的实例。
class ModuleFactory {
private:
// 内部结构体，用于标识模块
struct moduleid {
moduleid() = default;
moduleid(std::string n, std::size_t h)
: name(std::move(n)), code(h) {}
explicit moduleid(const std::type_info &info)
: name(info.name()), code(info.hash_code()) {}
bool operator==(const moduleid &mid) const {
return name == mid.name && code == mid.code;
}
std::string name;
std::size_t code = 0;
};
public:
// 获取 ModuleFactory 的单例实例
static ModuleFactory &getFactory() {
static ModuleFactory factory;
return factory;
}
// 获取注册在工厂中的模块名称集合
const std::unordered_set<std::string> &getModuleNames() const {
return *moduleNames_;
}
// 用于注册模块的辅助结构体
template<typename T, typename C = T>
struct ModuleRegisterHelper {
// 构造函数，用于注册模块
template<typename... Args>
ModuleRegisterHelper(std::string n, Args &&...args) {
auto mptr = getFactory().moduleMapTable_;
if (mptr->find(n) != mptr->end()) {
throw std::invalid_argument("模块 " + n + " 已经注册。");
}
getFactory().moduleNames_->insert(n);
std::function<std::unique_ptr<Module>(Args...)> create_func = [](Args... args) {
return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
};
const std::any const_any = std::any(create_func);
(*mptr)[n] = std::make_pAIr(moduleid(typeid(C)), const_any);
}
};
// 获取指定名称和类型的模块
template<typename T = Module, typename... Args>
typename std::enable_if<std::is_base_of<Module, T>::value, std::unique_ptr<T>>::type
getModule(const std::string &n, Args &&...args) {
auto mptr = getFactory().moduleMapTable_;
auto miter = mptr->find(n);
if (miter == mptr->end()) {
throw std::runtime_error("找不到名称为 " + n + " 的模块。");
}
if (miter->second.first == moduleid(typeid(T))) {
auto moduleCreator = std::any_cast<std::function<std::unique_ptr<Module>(Args...)>>(miter->second.second);
std::unique_ptr<Module> module = moduleCreator(std::forward<Args>(args)...);
module->setModuleName(n);
return std::unique_ptr<T>(static_cast<T *>(module.release()));
}
auto moduleCreator = std::any_cast<std::function<std::unique_ptr<Module>(Args...)>>(miter->second.second);
std::unique_ptr<Module> module = moduleCreator(std::forward<Args>(args)...);
if (!dynamic_cast<T *>(module.get())) {
throw std::runtime_error("无法将模块 " + n + " 产生的类型转换为 " + typeid(T).name());
}
module->setModuleName(n);
return std::unique_ptr<T>(static_cast<T *>(module.release()));
}
private:
static std::unordered_map<std::string, std::pair<moduleid, std::any>> *moduleMapTable_;
static std::unordered_set<std::string> *moduleNames_;
ModuleFactory() {}
ModuleFactory(const ModuleFactory &) = delete;
ModuleFactory(ModuleFactory &&) = delete;
};
在 ModuleFactory 类中，可以创建、获取和管理已注册的模块。
要使用模块工厂创建模块，需要首先注册模块。这里是通过
ModuleFactory::ModuleRegisterHelper 模板类来实现的。在注册模块时，需要提供模块的类型和名字。
可以使用又爱又恨的宏，避免了手动编写大量的注册代码：
#define MODULE_VARIABLE_NAME(module_name, module_type) Module_##module_name##_##module_type##_
#define REGISTER_MODULE(module_name, module_type, ...)
static module::ModuleFactory::ModuleRegisterHelper<module_type> MODULE_VARIABLE_NAME(module_name, module_type)(#module_name, ##__VA_ARGS__)
#define DECLARE_MODULE(module_type, ...) REGISTER_MODULE(module_type, module_type, ##__VA_ARGS__)
解释如下：
REGISTER_MODULE( "MyModule",MyModule);
不喜欢使用宏则可以：
template<typename T, typename... Args>
void registerModule(const std::string &moduleName, Args &&...args) {
static ModuleFactory::ModuleRegisterHelper<T> helper(moduleName, std::forward<Args>(args)...);
}
注册模块：
registerModule<MyModuleType>("MyModule", arg1, arg2);
下面是一个示例，展示如何使用模块类和模块工厂类来创建和管理模块。
// 定义一个模块类
class MyModule : public Module {
public:
// 自定义模块的行为
};
// 注册模块
REGISTER_MODULE( "MyModule",MyModule);
int main() {
// 使用模块工厂创建模块
ModuleFactory &factory = ModuleFactory::getFactory();
MyModule *module = factory.getMultiModule<MyModule>("MyModule");
// 使用模块
if (module) {
std::cout << "Created module: " << module->getModuleName() << std::endl;
}
return 0;
}
下面以虚拟商城系统为例，演示如何使用模块类和模块工厂类来创建虚拟商城系统，包括购物车管理、用户注册和商品管理等多个模块。
首先，创建购物车管理模块：
#include "Module.h"
class ShoppingCartModule : public module::Module {
public:
ShoppingCartModule() {
setModuleName("ShoppingCartModule");
}
void execute() override {
std::cout << "Shopping Cart Management Module executed." << std::endl;
// 添加购物车操作
addToCart("Product1", 10.0);
addToCart("Product2", 15.0);
displayCartContents();
calculateTotal();
}
void addToCart(const std::string& item, double price) {
cart.push_back(std::make_pair(item, price));
std::cout << "Added " << item << " to the cart. Price: " << price << " USD" << std::endl;
}
void displayCartContents() {
std::cout << "Cart Contents:" << std::endl;
for (const auto& item : cart) {
std::cout << item.first << " - " << item.second << " USD" << std::endl;
}
}
void calculateTotal() {
double total = 0.0;
for (const auto& item : cart) {
total += item.second;
}
std::cout << "Total Cart Value: " << total << " USD" << std::endl;
}
private:
std::vector<std::pair<std::string, double>> cart;
};
DECLARE_MODULE(ShoppingCartModule);
然后，创建用户注册模块：
#include "Module.h"
class UserRegistrationModule : public module::Module {
public:
UserRegistrationModule() {
setModuleName("UserRegistrationModule");
}
void execute() override {
std::cout << "User Registration Module executed." << std::endl;
// 用户注册操作
registerUser("User1");
registerUser("User2");
displayRegisteredUsers();
loginUser("User1");
}
void registerUser(const std::string& username) {
users.push_back(username);
std::cout << "Registered new user: " << username << std::endl;
}
void displayRegisteredUsers() {
std::cout << "Registered Users:" << std::endl;
for (const std::string& user : users) {
std::cout << user << std::endl;
}
}
void loginUser(const std::string& username) {
std::cout << "User " << username << " logged in." << std::endl;
}
private:
std::vector<std::string> users;
};
DECLARE_MODULE(UserRegistrationModule);
最后，创建商品管理模块：
#include "Module.h"
class ProductManagementModule : public module::Module {
public:
ProductManagementModule() {
setModuleName("ProductManagementModule");
}
void execute() override {
std::cout << "Product Management Module executed." << std::endl;
// 商品管理操作
addProduct("Product1", 10.0, 20);
addProduct("Product2", 15.0, 15);
displayProducts();
showProductDetails("Product1");
}
void addProduct(const std::string& product, double price, int quantity) {
products.push_back(std::make_pair(product, std::make_pair(price, quantity));
std::cout << "Added new product: " << product << " Price: " << price << " USD Quantity: " << quantity << std::endl;
}
void displayProducts() {
std::cout << "Available Products:" << std::endl;
for (const auto& product : products) {
std::cout << product.first << " - Price: " << product.second.first << " USD Quantity: " << product.second.second << std::endl;
}
}
void showProductDetails(const std::string& product) {
for (const auto& p : products) {
if (p.first == product) {
std::cout << "Product Details - " << product << ":" << std::endl;
std::cout << "Price: " << p.second.first << " USD" << std::endl;
std::cout << "Available Quantity: " << p.second.second << std::endl;
return;
}
}
std::cout << "Product not found: " << product << std::endl;
}
private:
std::vector<std::pair<std::string, std::pair<double, int>> products;
};
DECLARE_MODULE(ProductManagementModule);
最终的main函数会非常简洁：
#include "Module.h"
int main() {
// 获取模块工厂实例
module::ModuleFactory& factory = module::ModuleFactory::getFactory();
// 获取购物车管理模块并执行
auto shoppingCartModule = factory.getMultiModule<ShoppingCartModule>("ShoppingCartModule");
shoppingCartModule->execute();
// 获取用户注册模块并执行
auto userRegistrationModule = factory.getMultiModule<UserRegistrationModule>("UserRegistrationModule");
userRegistrationModule->execute();
// 获取商品管理模块并执行
auto productManagementModule = factory.getMultiModule<ProductManagementModule>("ProductManagementModule");
productManagementModule->execute();
return 0;
}
模块化编程是一种强大的架构方法，它使得应用程序更容易维护、扩展和重用。通过使用模块类和模块工厂类，能够更好地管理和扩展应用程序的功能。模块化编程框架不仅可以帮助架构师构建可扩展的应用程序，还可以帮助开发者编写更具模块性的代码，提高代码质量和可维护性。
本文虽然简单，但一个大型框架同样也是由一招一式构成，大道至简，藏拙于巧。
参考文献： [1] Gamma, E., Helm, R., Johnson, R., & Vlissides, J. (1994). Design patterns: elements of reusable object-oriented software. Pearson Education.
[2] Martin, R. C. (2003). Agile software development, principles, patterns, and practices. Pearson Education.
[3] Fowler, M. (2018). Refactoring: improving the design of existing code. Addison-Wesley Professional.
