[c++] 工厂模式 + cyberrt 组件加载器分析

使用对象的时候，可以直接 new 一个，为什么还需要工厂模式？

工厂模式属于创建型设计模式，将对象的创建和使用进行解耦，对用户隐藏了创建逻辑。

个人感觉上边的表述并没有说清楚为什么需要使用工厂模式。因为使用 new 创建一个对象的时候，比如 new Object(x, x, x, x)，对象创建逻辑在构造函数中实现，逻辑也对用户隐藏了，在一定程度上也实现了解耦。

为什么使用工厂模式 ?

生活中的工厂是生产商品的，一个工厂生产的商品往往有多个种类，比如手机代工厂，可能会代工多个品牌的手机。c++ 的工厂模式来源于生活，工厂模式常常应用于多态的场景，有一个基类，派生出多个类，创建这些类的时候，使用工厂模式就比较合适。

比如一个工厂代工了 3 个品牌的手机，apple, mi, oppo。如下图所示，我们往往会定义一个基类 Phone，在基类的基础上派生出 3 个子类：ApplePhone，MiPhone，OppoPhone。如果开发者在创建这些类的时候，需要分别 new ApplePhone()，new MiPhnoe()，new OppoPhone()，这样使用 new 的方式就不如使用工厂模式简单了。

1 简单工厂

手机工厂的例子，代码如下。

（1）一个抽象类，class Phone

（2）3 个派生类，ApplePhone，MiPhone， OppoPhone

（3）一个工厂类 PhoneFactory

可以看到，相对于直接使用 new 来创建对象，工厂类就是把产品的类型和类的对应关系这个逻辑给隐藏起来了，用户使用的时候只需要传一个手机类型就可以了。

#include <iostream>
#include <string>class Phone {
public:virtual ~Phone() {}virtual void CallUp() = 0;
};class ApplePhone : public Phone {
public:void CallUp() {std::cout << "ApplePhone call up" << std::endl;}
};class MiPhone : public Phone {
public:void CallUp() {std::cout << "MiPhone call up" << std::endl;}
};class OppoPhone : public Phone {
public:void CallUp() {std::cout << "OppoPhone call up" << std::endl;}
};enum PHONE_TYPE {APPLE,MI,OPPO
};class PhoneFactory {
public:Phone *CreatePhone(PHONE_TYPE type) {switch (type) {case APPLE:return new ApplePhone();case MI:return new MiPhone();case OPPO:return new OppoPhone();default:return nullptr;}}
};int main() {PhoneFactory phone_factory;Phone *apple = phone_factory.CreatePhone(APPLE);if (apple != nullptr) {apple->CallUp();delete apple;apple = nullptr;}Phone *mi = phone_factory.CreatePhone(MI);if (mi != nullptr) {mi->CallUp();delete mi;mi = nullptr;}Phone *oppo = phone_factory.CreatePhone(OPPO);if (oppo != nullptr) {oppo->CallUp();delete oppo;oppo = nullptr;}return 0;
}

2 工厂方法

简单工厂模式，如果生产的产品类型发生变化的时候需要改变工厂类，增减一个 if 分支，或者增减一个 case 分支。有一个编码原则是 "对修改关闭，对扩展开发"，简单工厂就违反了这条编码原则。因此，从简单工厂模式又延伸出了工厂方法模式。

工厂方法模式，需要增加一个工厂类。一个抽象工厂类 Factory，这个类派生出 3 个子类， AppleFactory，MiFactory，OppoFactory。

一个全局的表 map，这个 map 的 key 是商品的类型，value 是工厂类。这样的话，如果需要增加一种商品，只需要增加一个工厂类，然后在 map 中增加一项就可以了。

工厂类创建对象的时候，根据类型去 map 中查找对应的工厂，找到工厂之后就行生产。这样当增加商品的时候就彻底不需要修改工厂类了。把修改的范围缩小了，并且做了解耦。

多种设计模式中都使用了 map 来对代码进行解耦，并且做到对修改关闭，对扩展开方。比如策略模式，职责链模式。

代码如下，代码中有一个全区的数据结构 factory_map，key 是手机类型，value 是工厂类。每定义一个工厂类，都可以通过宏 REGISTER_FACTORY 将工厂类注册到 factory_map 中。这样在使用的时候，只需要根据类型去 factory_map 中查找对应的工厂类，找到之后就可以生产。

#include <iostream>
#include <string>
#include <map>enum PHONE_TYPE {APPLE,MI,OPPO
};class Factory;
std::map<PHONE_TYPE, Factory *> factory_map;#define REGISTER_FACTORY(factory_type, class_name) \
struct ClassRegister##class_name { \ClassRegister##class_name() { \factory_map[factory_type] = new class_name(); \}; \
}; \
static struct ClassRegister##class_name factory_register##class_name;// 手机类
class Phone {
public:virtual ~Phone() {}virtual void CallUp() = 0;
};class ApplePhone : public Phone {
public:void CallUp() {std::cout << "ApplePhone call up" << std::endl;}
};class MiPhone : public Phone {
public:void CallUp() {std::cout << "MiPhone call up" << std::endl;}
};class OppoPhone : public Phone {
public:void CallUp() {std::cout << "OppoPhone call up" << std::endl;}
};// 工厂类
class Factory {
public:virtual ~Factory() {};virtual Phone *CreatePhone() = 0;
};class AppleFactory : public Factory {
public:Phone *CreatePhone() {return new ApplePhone();};
};
REGISTER_FACTORY(APPLE, AppleFactory);class MiFactory : public Factory {
public:Phone *CreatePhone() {return new MiPhone();};
};
REGISTER_FACTORY(MI, MiFactory);class OppoFactory : public Factory {
public:Phone *CreatePhone() {return new OppoPhone();};
};
REGISTER_FACTORY(OPPO, OppoFactory);class PhoneFactory {
public:Phone *CreatePhone(PHONE_TYPE type) {if (factory_map.count(type) > 0) {return factory_map[type]->CreatePhone();}return nullptr;}
};int main() {PhoneFactory phone_factory;Phone *apple = phone_factory.CreatePhone(APPLE);if (apple != nullptr) {apple->CallUp();delete apple;apple = nullptr;} else {std::cout << "apple is nulptr" << std::endl;}Phone *mi = phone_factory.CreatePhone(MI);if (mi != nullptr) {mi->CallUp();delete mi;mi = nullptr;}Phone *oppo = phone_factory.CreatePhone(OPPO);if (oppo != nullptr) {oppo->CallUp();delete oppo;oppo = nullptr;}return 0;
}

3 cyberrt 中组件加载器

cyberrt 中提供了两个基类 TimerComponent 和 Component。用户可以根据自己的业务需求，是定时触发还是事件触发来决定基于 TimerComponent 开发还是基于 Component 开发。比如自动驾驶系统中的传感器组件(camera，lidar，radar) 一般是定时组件，定时将传感器数据向外发布；感知，预测，决策，控制模块一般是事件触发，一般基于 Component 开发。如下图所示，TimerComponent 和 Component 由 ComponentBase 派生出来，这 3 个类都是属于架构层的类；上层的 camera，lidar，radar，perception，prediction 等组件属于业务层。

用户开发的软件最后会编译成一个动态库，动态库的加载和运行通过 cyberrt 中的组件加载器来进行。组件加载器的实现使用了工厂模式，并且使用的是工厂方法模式。

3.1 类加载

cyberrt 加载运行组件的时候，首先要加载用户的动态库。动态库的加载通过类 ClassLoader 来完成。

（1）动态库加载函数 dlopen()

底层动态库的加载是通过函数 dlopen() 完成。dlopen() 可以直接传动态库的名字，比如 libcamera.so，也可以传动态库的路径，比如 /ads/lib/libcamera.so。传动态库名字的时候，dlopen() 查找动态库的时候会根据系统的配置来查找，查找的路径有以下 5 个，按优先级先后顺序是 rpath > LD_LIBRARY_PATH > /etc/ls.so.cache > /lib > /usr/lib。

① rpath

在编译的时候可以加编译选项，比如 -Wl,-rpath,/ads/lib，这样 /ads/lib 的路径就会保存到动态库中。

② LD_LIBRARY_PATH

环境变量，可以配置动态库的路径。

③ /etc/ls.so.cache

这个缓存中的路径，可以通过 ldconfig -p 查看缓存中的动态库。

如果想要向这个缓冲区中配置路径，可以增加一个 conf 文件放到目录 /etc/ld.so.conf.d/ 中，然后再执行 ldconfig，就能通过 ldconfig -p 查看到自己的路径。

（2）保存动态库的全局数据结构

动态库加载之后要保存到一个数据结构中，数据结构是一个 vector，vector 中的元素是 std::pair 数据，pair 的 key 是动态库的路径，value 是表示加载动态库的类 SharedLibrary。

// using LibPathSharedLibVector =
//    std::vector<std::pair<std::string, SharedLibraryPtr>>;
LibPathSharedLibVector& GetLibPathSharedLibVector() {static LibPathSharedLibVector instance;return instance;
}

3.2 创建对象

（1）工厂类

用户开发的组件都要使用下边这个宏进行注册， name 是用户类的类名。在这个宏中最后会通过 RegisterClass() 创建一个工厂类，工厂类放到一个全局单例的 map 里，key 是 classname, value 是工厂类。

#define CYBER_REGISTER_COMPONENT(name) \CLASS_LOADER_REGISTER_CLASS(name, apollo::cyber::ComponentBase)

创建对象的时候是在函数 CreateObj() 中完成，对于没有形参的构造函数，使用 new 创建对象的时候，类名后边也可以不加括号。

template <typename ClassObject, typename Base>
class ClassFactory : public AbstractClassFactory<Base> {public:ClassFactory(const std::string& class_name,const std::string& base_class_name): AbstractClassFactory<Base>(class_name, base_class_name) {}Base* CreateObj() const { return new ClassObject; }
};

（2）工厂类创建

工厂类创建的在宏 CLASS_LOADER_REGISTER_CLASS_INTERNAL 中实现的。第 2 节工厂方法模式中，自己写的代码就是参考这个宏实现的。这里边有一个技巧，就是定义一个结构体，然后声明一个静态的结构体对象，这样就会调用结构体的构造函数，在构造函数中完成工厂类的注册。

#define CLASS_LOADER_REGISTER_CLASS_INTERNAL(Derived, Base, UniqueID)    \namespace {                                                            \struct ProxyType##UniqueID {                                           \ProxyType##UniqueID() {                                              \vcl::class_loader::utility::RegisterClass<Derived, Base>(#Derived, \#Base);   \}                                                                    \};                                                                     \static ProxyType##UniqueID g_register_class_##UniqueID;                \}