设计模式里面有一个很重要的思想，原话可能是“不要依赖于具体，而是要依赖于抽象”。在软件的设计中，这种思想可谓算是指导思想了。比如系统要设计一个rpc服务。一种比较好的设计思路是，首先提供一个抽象的类，把需要的方法都放进去。
class RPC
{
public:
virtual void send(const std::string& text) = 0;
};
然后呢，比如要接入grpc，那么定义一个grpc的类，继承RPC类。把里面的接口用grpc的实现封装一套。
class GRPC final : public RPC
{
public:
void send(const std::string& text) override
{
std::cout << text << std::endl;
// todo
// use grpc to send data
}
};
如果，以后要再接入其他rpc服务，或者更换rpc服务，那么只需要再新定义一个rpc类。
class TRPC final : public RPC
{
public:
void send(const std::string& text) override
{
std::cout << text << std::endl;
// todo
// use trpc to send data
}
};
如果需要业务层需要接入的时候，只需要让自己依赖于抽象的RPC类，而不是某个具体的RPC类。比如这样：
class MY_SERVICE
{
public:
MY_SERVICE()
{
// 读配置或者是什么样，选择不同的rpc类型
rpc = new TRPC();
}
int send(const std::string text)
{
rpc->send(text);
return 0;
}
private:
RPC * rpc;
};
这是一个简单的例子，实现了依赖的解耦。开始进入依赖注入的环节。依赖注入的分为“注册”和“构造”两个阶段，在注册的时候，指定好service和接口的关系；在构建的时候，根据绑定的关系，初始化serive对象。
这里有几点需要开发，第一是：管理各种基类派生出来的子类，或者是根据不同的配置文件创建不同的子类。第二是：需要反射的机制，根据子类的名称完成对象创建。
比较硬的写法是，可以这样：
COMM_DEP* create_obj(string name)
{
if (name == "GRPC")
{
return new GRPC();
}
else if (name == "TRPC")
{
return new TRPC();
}
else
{
xxx;
}
}
这样写法有很多弊端，更好的方式是让这个过程更简洁。这里使用了一个宏，会生成一个字符串和对象的映射map。然后把它封装到一个类中，可以main函数之外，创建这个类，就可以将对象的字符串和对象映射到map中。
// helper.h
#pragma once
#include <map>
#include <string>
class COMM_DEPENDENCY;
class DEPENDENCY_HELPER
{
private:
std::map<std::string, COMM_DEPENDENCY *> _map_str2obj;
static DEPENDENCY_HELPER* helper;
DEPENDENCY_HELPER() {}
public:
static DEPENDENCY_HELPER* inst()
{
if (!helper)
{
helper = new DEPENDENCY_HELPER();
}
return helper;
}
COMM_DEPENDENCY* get_by_name(std::string name)
{
if (_map_str2obj.find(name) != _map_str2obj.end())
{
return _map_str2obj[name];
}
return nullptr;
}
void push(std::string name, COMM_DEPENDENCY * obj)
{
_map_str2obj[name] = obj;
}
};
DEPENDENCY_HELPER* DEPENDENCY_HELPER::helper = nullptr;
#define REGISTER(CLASS_TYPE) \
class CLASS_TYPE##Generator {\
public:\
CLASS_TYPE##Generator() {\
DEPENDENCY_HELPER::inst()->push(#CLASS_TYPE, new CLASS_TYPE());\
}\
};\
CLASS_TYPE##Generator* CLASS_TYPE##Inst = new CLASS_TYPE##Generator();
对于各种子类，可以调用REGISTER(GRPC)来注册。
// dep.h
#pragma once
#include "helper.h"
class COMM_DEPENDENCY{};
class RPC: public COMM_DEPENDENCY
{
public:
virtual void send(const std::string& text) = 0;
};
class GRPC final : public RPC
{
public:
void send(const std::string& text) override
{
std::cout << "[GRPC] " << text << std::endl;
// todo
// use grpc to send data
}
};
class TRPC final : public RPC
{
public:
void send(const std::string& text) override
{
std::cout << "[TRPC] " << text << std::endl;
// todo
// use trpc to send data
}
};
class LOG: public COMM_DEPENDENCY
{
public:
virtual void print_log(const std::string& text) = 0;
};
class GLOG final : public LOG
{
public:
void print_log(const std::string& text) override
{
std::cout << "[GLOG] " << text << std::endl;
}
};
class XXLOG final: public LOG
{
public:
void print_log(const std::string& text) override
{
std::cout << "[XXLOG] " << text << std::endl;
}
};
// 注册反射类型
REGISTER(GRPC);
REGISTER(TRPC);
REGISTER(GLOG);
REGISTER(XXLOG);
那么，最后的main函数就很简单了。
#include <iostream>
#include <string>
#include <vector>
#include "helper.h"
#include "dep.h"
class MY_SERVICE
{
public:
int deps_init()
{
// 改为配置加载
std::vector<std::string> name =
{
"GRPC",
"GLOG",
};
for (int i = 0; i < name.size(); i++)
{
COMM_DEPENDENCY* obj = DEPENDENCY_HELPER::inst()->get_by_name(name[i]);
if (obj)
{
// init xxx
}
}
return 0;
}
RPC* get_rpc()
{
RPC* obj = static_cast<RPC*>(DEPENDENCY_HELPER::inst()->get_by_name("GRPC"));
return obj;
}
LOG* get_log()
{
LOG* obj = static_cast<LOG*>(DEPENDENCY_HELPER::inst()->get_by_name("GLOG"));
return obj;
}
};
int main()
{
MY_SERVICE s;
s.get_rpc()->send("HELLO RPC");
s.get_log()->print_log("HELLO LOG");
return 0;
}
g++ main.cc
$ ./a.out
[GRPC] HELLO RPC
[GLOG] HELLO LOG
源码路径：
https://github.com/zhaozhengcoder/CoderNoteBook/tree/master/example_code/reflect
小结：
本文整理了cpp开发中的一个技巧，依赖注入的核心思想。这里通过实现一个RPC的例子，来具体的介绍。另外，为了实现根据字符串去创建对象，这里利用宏实现了一个简单的反射机制。
