如何实现自动注册对象Factory

转载自 如何实现自动注册对象Factory

目标

了解C++里的Factory模式应用场景、实现方法，采用模板实现带来的便利。

来源

• A C++ Object Factory
• Automatic object factory in C++
• Register an object creator in object factory
• C++11实现一个自动注册的工厂

用途

一系列类继承自基类，均可以执行某个动作，可以根据类的Key获取类实例进行动作。

原始版本及存在的问题

class IObject
{
public:
    virtual void run() = 0;
    virtual ~IObject() {};
};

class Object1:public IObject
{
public:
    ~Object1()
    {
        ;
    }
    virtual void run() override
    {
        std::cout<<"Object1\n";
    }
};

class Object2 :public IObject
{
public:
    ~Object2()
    {
        ;
    }

    virtual void run() override
    {
        std::cout << "Object2\n";
    }
};

class ObjectFactory
{
public:
    static std::shared_ptr<IObject> create(const std::string& key)
    {
        if(key == "Object1")
            return std::make_shared<Object1>();
        if(key == "Object2")
            return std::make_shared<Object2>();
        return nullptr;
    }
};

void original_test()
{
    auto pVal1 = ObjectFactory::create("Object1");
    auto pVal2 = ObjectFactory::create("Object2");

    if(pVal1)
        pVal1->run();
    if(pVal2)
        pVal2->run();
}

这是最常规的实现方法，一旦新增类，则需要调整factory的创建方法，一旦这些代码被封装成库就没有扩展的可能；
我们希望没有非必要的依赖，避免调整类定义，尽可能简单就能够注册新类。

实现思路

1. 准备基类
2. Factory单例
3. 注册类构造方法
4. 获取类实例

调整版本

基类

class IObject
{
public:
    virtual void run() = 0;
    virtual ~IObject() {};
};

Factory单例

class ObjectFactory
{
public:
    static ObjectFactory* Instance()
    {
        static ObjectFactory factory;
        return &factory;
    }
};

注册类构造方法

    void registerObjectFunc(const std::string& name, std::function<IObject*()> func)
    {
        funcs_[name] =func;
    }
private:
    std::map<std::string,std::function<IObject*()>> funcs_;

构造类实例

std::shared_ptr<IObject> create(const std::string& key)
{
    auto it = funcs_.find(key);
    if (it != funcs_.end())
        return std::shared_ptr<IObject>(it->second());
    return nullptr;
}

使用方法

//类1
class Object1 :public IObject
{
public:
    ~Object1()
    {
        ;
    }
    virtual void run() override
    {
        std::cout << "Object1\n";
    }
};
//类2
class Object2 :public IObject
{
public:
    ~Object2()
    {
        ;
    }

    virtual void run() override
    {
        std::cout << "Object2\n";
    }
};

//使用
auto pVal1= ObjectFactory::Instance()->create("Object1");
auto pVal2 = ObjectFactory::Instance()->create("Object2");

if (pVal1)
    pVal1->run();
if (pVal2)
    pVal2->run();

新类注册

static ObjectRegisterHelper Object1_ObjectRegisterHelper("Object1", []()->IObject* { return new Object1();  });
static ObjectRegisterHelper Object2_ObjectRegisterHelper("Object2", []()->IObject* { return new Object2();  });

使用宏进行新类注册

辅助注册：

class ObjectRegisterHelper
{
public:
    ObjectRegisterHelper(const char* key, std::function<IObject*()> func)
    {
        ObjectFactory::Instance()->registerObjectFunc(key,func);
    }
};

#define REGISTER_OBJECT(className,key) \
static ObjectRegisterHelper className##ObjectRegisterHelper(key,[]()->className*{ return new className();})

使用方式:

REGISTER_OBJECT(Object1,"Object1");
REGISTER_OBJECT(Object2, "Object2");

使用模板进行新类注册

辅助注册：

template<typename T>
class ObjectRegister
{
public:
    ObjectRegister(const char* key)
    {
        ObjectFactory::Instance()->registerObjectFunc(key,[](){
            return new T();
        });
    }
};

使用方式:

static ObjectRegister<Object1> register1("Object1");
static ObjectRegister<Object2> register2("Object2");

自动注册的实现

以上的方案都需要在外部定义静态变量用来进行构造方法注册，还有方法无需外部定义：

将静态变量包裹在类中

约束Key获取接口

每个类定义均有静态接口Key()来获取Key供注册使用

template<typename T>
void registerT()
{
    //std::cout << "RegisterT " << T::Key() << "\n";
    funcs_[T::Key()] = []()->IEntry* { return new T(); };
}

定义辅助类

template<typename T>
struct RegisterClass
{
    RegisterClass()
    {
        Factory::Instance().registerT<T>();
    }
};

自动注册类

I为基类，新类继承自AutoRegister自动附带注册类

template<typename T, typename I>
struct AutoRegister :public I
{
    AutoRegister()
    {
        //®ister_;
    }
public:
    static RegisterClass<T> register_;
};

//模板类静态变量声明->(C++14的变量模板)
template<typename T, typename I>
RegisterClass<T> AutoRegister<T, I>::register_;

使用

class Object :public AutoRegister<Object, IEntry>
{
public:
    void run()
    {
        std::cout << "Object\n";
    }
    //Key配置接口
    static const char* Key()
    {
        //由于VisualStudio2015不支持变量模板,这个可以用来声明静态变量
        Object::register_;
        //在支持变量模板的C++编译器中这个是不需要的
        return "Object";
    }
};

调整注册辅助类

C++11新特性：内部类可以通过外部类的实例访问外部类的私有成员;

struct Factory
{
public:
    template<typename T>
    struct register_helper
    {
        register_helper(const char* key)
        {
            //获取外部类实例的私有成员变量
            Instance().funcs_[key] = []()->IEntry* { return new T(); };
        }
    };

模板注册免命名

之前使用宏进行新类注册会自动合并出静态辅助类实例名称，而使用模板进行新类注册则需要保证名称不重复，否则编译报错，可以采用以下方式避免该问题：

template<typename T>
struct register_agent
{
    static Factory::register_helper<T> helper;
};

//TObject的注册辅助类静态实例
decltype(register_agent<TObject>::helper) register_agent<TObject>::helper("TObject");
//Object的
decltype(register_agent<Object>::helper) register_agent<Object>::helper("Object");

其它调整

参见C++11实现一个自动注册的工厂。

通过实现factory模板能够实现统一的factory。

学到的内容

• Factory模式的实现
• 静态变量在自动注册等处理方面的应用
• 在一些场景下如何使用模板替代宏