实现动机
最近项目中需要用到工厂模式,但是普通的工厂模式面临一个问题,每新增一个派生类,都需要在工厂中加一个case分支,这样就会频繁地修改工厂的代码,而且随着派生类越来越多,case分支也逐渐增多,代码越来越臃肿,对于后期的维护也不友好。下面是一个工厂方法的伪代码:
Message* create(int type)
{
switch (type)
{
case MSG_PGSTATS:
m = new MPGStats;
break;
case MSG_PGSTATSACK:
m = new MPGStatsAck;
break;
case CEPH_MSG_STATFS:
m = new MStatfs;
break;
case CEPH_MSG_STATFS_REPLY:
m = new MStatfsReply;
break;
case MSG_GETPOOLSTATS:
m = new MGetPoolStats;
break;
default:
break;
}
}
最近在博客上看到了一个比较优雅的解决方案:自动注册的工厂方法模式。自己也动手实现了一把,解决了项目中遇到的问题。
实现方法
自动注册的对象工厂的实现思路如下:
- 提供一个单例工厂对象。
- 工厂注册对象(保存创建对象的key和构造器)。
- 利用辅助类,在辅助类对象的构造过程中实现目标对象地注册。
- 利用一个宏来生成辅助对象。
- 在派生类文件中调用这个宏实现自动注册。
其中,需要注意的是,对象工厂并不直接保存对象,而是对象的构造器,因为对象工厂不是对象池,是对象的生产者,允许不断地创建实例,另外,这样做还实现了延迟创建。另外一个要注意的地方是借助宏来实现自动注册,本质上是通过宏来定义了很多全局的静态变量,而这些静态变量仅仅是为了实现自动注册,并没有实际的意义。
下面来看看如何用C++11来实现这个自动注册的对象工厂。
一个单例的对象工厂代码
struct factory
{
static factory& get()
{
static factory instance;
return instance;
}
private:
factory() {};
factory(const factory&) = delete;
factory(factory&&) = delete;
static std::map<std::string, std::function<Message*()>> map_;
};
在C++11中单例的实现非常简单,返回一个一个静态局部变量的引用即可,而且这个方法还是线程安全的,因为C++11中静态局部变量的初始化是线程安全的。工厂内部有一个map,map的值类型为一个function,是对象的构造器。
对象工厂的辅助类的代码
struct factory
{
template<typename T>
struct register_t
{
register_t(const std::string& key)
{
factory::get().map_.emplace(key, []{ return new T; });
}
};
private:
inline static factory& get()
{
static factory instance;
return instance;
}
static std::map<std::string, FunPtr> map_;
};
对象工厂的辅助类register_t是工厂类的一个内部模版类,非常简单,只有一个构造函数,这个构造函数中调用了factory的私有变量map_,并往map_中插入了key和泛型对象的构造器。这里用到了C++11的一个新特性:内部类可以通过外部类的实例访问外部类的私有成员,所以register_t可以直接访问factory的私有变量map_。
自动注册的代码
#define REGISTER_MESSAGE_VNAME(T) reg_msg_##T##_
#define REGISTER_MESSAGE(T, key, ...) static factory::register_t<T> REGISTER_MESSAGE_VNAME(T)(key, __VA_ARGS__);
在派生类中调用宏注册自己:
class Message1 : public Message
{
//……
};
REGISTER_MESSAGE(Message1, "message1");
自动注册的关键是通过一个宏来生成静态全局的register_t的实例,因为register_t的实例是用来向工厂注册目标对象的构造器。所以仅仅需要在派生类中调用这个宏就可以实现自动至注册了,而无需修改原有代码。
我们还可以添加智能指针接口,无需让用户管理原始指针,甚至让工厂能创建带任意参数的对象。
Factory最终的实现
//factory.h
#pragma once
#include<map>
#include<iostream>
#include<functional>
#include"Message.h"
struct factory {
template<typename T>
struct register_t
{
register_t(const std::string& key)
{
factory::get().map_.emplace(key, [] { return new T(); });
}
template<typename... Args>
register_t(const std::string& key, Args... args)
{
factory::get().map_.emplace(key, [&] { return new T(args...); });
}
};
static Message* produce(const std::string& key)
{
if (map_.find(key) == map_.end())
throw std::invalid_argument("the message key is not exist!");
return map_[key]();
}
private:
factory() {};
factory(const factory&) = delete;
factory(factory&&) = delete;
static factory& get()
{
static factory instance;
return instance;
}
static std::map<std::string, std::function<Message*()>> map_;
};
std::map<std::string, std::function<Message*()>> factory::map_;
#define REGISTER_MESSAGE_VNAME(T) reg_msg_##T##_
#define REGISTER_MESSAGE(T, key, ...) static factory::register_t<T> REGISTER_MESSAGE_VNAME(T)(key, ##__VA_ARGS__);
用法示例:
//Message.h
#pragma once
#include"factory.h"
class Message
{
public:
virtual ~Message() {}
virtual void foo()
{
}
};
class Message1 : public Message
{
public:
Message1()
{
std::cout << "message1 Construct" << std::endl;
}
Message1(int a)
{
std::cout << "message1" << std::endl;
}
~Message1()
{
}
void foo()
{
std::cout << "message1 foo" << std::endl;
}
};
class Message2 : public Message
{
public:
Message2()
{
std::cout << "message2" << std::endl;
}
Message2(int a)
{
std::cout << "message2" << std::endl;
}
~Message2()
{
}
void foo()
{
std::cout << "message2" << std::endl;
}
};
//main.cpp
#include"factory.h"
using namespace std;
REGISTER_MESSAGE(Message1, "message1",5);
int main() {
Message* p = factory::produce("message1");
p->foo();
return 0;
}