Adhesive框架中是分布式组件客户端首先实现的是基于Json序列化+二进制协议的Memcached客户端。在本文中会介绍其中的实现细节。
我们先来看一下项目结构：
从这个结构大致可以看出：
1）Memcached只是其中的一个具体实现，这个组件期望提供一个ClientSocket-ClientNode-ClientCluster的基础实现，以后可以有各种客户端基于这种结构来实现
2）对于Memcached的实现，其中把协议部分放在的Protocol文件夹中，并且根据协议为每一个请求和响应封装类型，也就是使用面向对象的方式而不是拼数据包的方式来封装协议
那么现在首先来介绍基础结构。从最底部的层次开始，最底部应该是对Socket进行一个封装，在这里我们实现了一个ClientSocket，主要完成下面功能：
1）封装Read、Write、Connect、Reset（因为我们实现的是Socket池，所以在Socket使用之后，归还池之前需要重置）操作
2）封装Socket基本状态，包括创建时间、忙碌时间、闲置时间、发生错误时的回调方法
在ClientSocket之上的一层是ClientNode，也就是一个节点的客户端，很明显，这里需要做的是Socket连接池，具体完成的工作有：
1）进行连接池的维护，包括移除空闲超时的Socket、强制结束忙碌时间过长的Socket、补充新的Socket到连接池的下限
2）初始化池、结束池、从池获取Socket、把使用后的Socket返回池、创建非池Socket
在正常使用的时候，所有Socket都从池中获取，如果整个Node不可用，那么我们定时创建非池Socket来测试Node是否恢复
在ClientNode之上的是ClientCluster，也就是集群，对于需要客户端进行一致性哈希分发节点的分布式组件来说，这层就很必要了，完成的功能主要有：
1）初始化集群、使用一致性哈希从集群获得节点、直接获得ClientSocket
2）在节点出错的时候进行重新节点分配、尝试恢复出错的节点
ClientCluster是使用ClientNodeLocator来分配节点的，其中的算法也就是一致性哈希算法。
之前说过节点有权重的概念，在这里也就是通过虚拟节点的数量来设置节点权重，权重越高分配到Key的数量也就会越多。
在ClientCluster之上还封装了一层AbstractClient，也就是直接面向用户的API入口。
public
abstract
class
AbstractClient<T>
where
T : AbstractClient<T>,
new
()
完成的功能有：
1）保存所有的Cluster，初始化Cluster
2）获取具体的XXXClient的实现，比如MemcachedClient
很明显，我们的第一个实现MemcachedClient是继承了AbstractClient：
public
partial
class
MemcachedClient : AbstractClient<MemcachedClient>
在这里使用了部分类，内部的实现都放在了MemcachedClient_Internal.cs中，而对外的API都放在了MemcachedClient.cs中。
对于Memcached的二进制协议，我们首先是实现一个头的格式包：
[StructLayout(LayoutKind.Sequential, Pack = 1)]
internal
struct
Header
{
internal
byte
Magic;
internal
byte
Opcode;
internal
ushort
KeyLength;
internal
byte
ExtraLength;
internal
byte
DataType;
internal
ushort
Reserved;
internal
uint
TotalBodyLength;
internal
uint
Opaque;
internal
ulong
Version;
}
由于我们会直接把结构打包为字节数组，所以这里声明了结构的内存布局。在Protocol.cs中，我们有一些实用的方法，比如结构和字节数组双向转换的实现：
internal
static
T BytesToStruct<T>(
this
byte
[] rawData)
{
T result =
default
(T);
RespectEndianness(
typeof
(T), rawData);
GCHandle handle = GCHandle.Alloc(rawData, GCHandleType.Pinned);
try
{
IntPtr rawDataPtr = handle.AddrOfPinnedObject();
result = (T)Marshal.PtrToStructure(rawDataPtr,
typeof
(T));
}
finally
{
handle.Free();
}
return
result;
}
internal
static
byte
[] StructToBytes<T>(
this
T data)
{
byte
[] rawData =
new
byte
[Marshal.SizeOf(data)];
GCHandle handle = GCHandle.Alloc(rawData, GCHandleType.Pinned);
try
{
IntPtr rawDataPtr = handle.AddrOfPinnedObject();
Marshal.StructureToPtr(data, rawDataPtr,
false
);
}
finally
{
handle.Free();
}
RespectEndianness(
typeof
(T), rawData);
return
rawData;
}
private
static
void
RespectEndianness(Type type,
byte
[] data)
{
var fields = type.GetFields(BindingFlags.NonPublic | BindingFlags.Instance).Select(field =>
new
{
Field = field,
Offset = Marshal.OffsetOf(type, field.Name).ToInt32()
}).ToList();
fields.ForEach(item => Array.Reverse(data, item.Offset, Marshal.SizeOf(item.Field.FieldType)));
}
在定义了头之后，我们就可以封装一个抽象的请求包了：
只要实现这个包，然后调用其GetBytes方法就可以直接获得需要发送的请求数据包，它会在内部处理Header和Body数据的打包。
比如，我们来看一个Set操作的包实现：
internal
class
SetRequestPackage : AbstractRequestPackage
{
private
TimeSpan expireSpan;
private
byte
[] valueBytes;
private
ulong
version;
public
override
Opcode Opcode
{
get {
return
Opcode.Set; }
}
internal
SetRequestPackage(
string
key,
byte
[] valueBytes, TimeSpan expireSpan,
ulong
version)
:
base
(key)
{
if
(expireSpan > TimeSpan.FromDays(30))
throw
new
ArgumentOutOfRangeException(
"过期时间不能超过30天!"
);
this
.expireSpan = expireSpan;
this
.valueBytes = valueBytes;
this
.version = version;
}
internal
SetRequestPackage(
string
key,
string
value
, TimeSpan expireSpan,
ulong
version)
:
this
(key, Encoding.UTF8.GetBytes(
value
), expireSpan, version)
{
}
internal
SetRequestPackage(
string
key,
string
value
,
ulong
version)
:
this
(key, Encoding.UTF8.GetBytes(
value
), TimeSpan.FromDays(30), version)
{
}
internal
SetRequestPackage(
string
key,
byte
[] valueBytes,
ulong
version)
:
this
(key, valueBytes, TimeSpan.FromDays(30), version)
{
}
protected
override
ulong
GetVersion()
{
return
version;
}
protected
override
byte
[] GetExtraBytes()
{
var extraBytes =
new
List<
byte
>();
uint
flag = 0xdeadbeef;
extraBytes.AddRange(flag.GetBigEndianBytes());
uint
expire = Convert.ToUInt32(expireSpan.TotalSeconds);
extraBytes.AddRange(expire.GetBigEndianBytes());
return
extraBytes.ToArray();
}
protected
override
byte
[] GetValueBytes()
{
return
valueBytes;
}
}
在这里，我们只是实现了抽象方法来为基类提供没有的数据，并不需要关心数据是如何打包的。那么，之后发送Set请求的操作就很简单了：
private
bool
InternalSet(
string
key,
string
value
, TimeSpan expire,
ulong
version)
{
using
(var socket = GetCluster().AcquireSocket(key))
{
if
(socket !=
null
)
{
AbstractRequestPackage requestPackage = expire == TimeSpan.MaxValue ?
new
SetRequestPackage(key,
value
, version)
:
new
SetRequestPackage(key,
value
, expire, version);
var requestData = requestPackage.GetBytes();
if
(requestData !=
null
)
{
socket.Write(requestData);
var responsePackage = ResponsePackageCreator.GetPackage(socket);
if
(responsePackage !=
null
)
{
if
(responsePackage.ResponseStatus == ResponseStatus.NoError)
{
return
true
;
}
else
if
(responsePackage.ResponseStatus != ResponseStatus.KeyExists
&& responsePackage.ResponseStatus != ResponseStatus.KeyNotFound)
{
LocalLoggingService.Warning(
"在 {0} 上执行操作 {1} 得到了不正确的回复 Key : {2} -> {3}"
,
socket.Endpoint.ToString(),
requestPackage.Opcode,
key,
responsePackage.ResponseStatus);
}
}
else
{
LocalLoggingService.Error(
"在 {0} 上执行操作 {1} 没有得到回复 Key : {2}"
,
socket.Endpoint.ToString(),
requestPackage.Opcode,
key);
}
}
}
}
return
false
;
}
1）首先是获取到Cluster，再获取到池中的Socket
2）然后初始化一个SetRequestPackage，再通过GetBytes获得数据
3）直接把数据写入Socket
4）通过ResponsePackageCreator来获得返回的数据包
很明显，ResponsePackageCreator和AbstractRequestPackage的意图差不多，用来把响应的数据包封装成我们需要的数据，其中有一个：
internal
static
GeneralResponsePackage GetPackage(ClientSocket socket)
获得的是一个通用的响应数据包：
internal
class
GeneralResponsePackage
{
internal
Opcode Opcode { get; set; }
internal
ResponseStatus ResponseStatus { get; set; }
internal
string
Key { get; set; }
internal
byte
[] ValueBytes { get; set; }
internal
ulong
Version { get; set; }
internal
string
Value
{
get
{
if
(ValueBytes !=
null
)
{
return
Encoding.UTF8.GetString(ValueBytes);
}
else
{
return
null
;
}
}
}
}
在这里基本的信息都有了，比如操作代码、响应状态、Key、Value、版本号。正因为Memcached的协议比较简单，所有的响应包都是这么一个格式，所以我们并没有实现特殊的响应包。如果要实现的话，只需要在类头部标记OpCode并且继承GeneralResponsePackage，ResponsePackageCreator会自动返回相应的子类：
[AttributeUsage(AttributeTargets.Class)]
internal
class
ResponsePackageAttribute : Attribute
{
internal
Opcode Opcode { get;
private
set; }
internal
ResponsePackageAttribute(Opcode opcode)
{
this
.Opcode = opcode;
}
}
在获得了响应之后，通过判断ResponseStatus来知道响应是否正确，并且记录相关日志即可。这么一来，数据一去一回以及协议如何实现的整个过程就介绍完了。下面，我们再介绍一下客户端中几个特色功能的实现。
1）获取一组Key功能。由于一个集群会有多个节点，所以要获取一组Key，我们首先需要把Key按照节点分类，然后对于不同的节点，采用并行的方式同时获取，这样速度会很快，代码片段如下：
var nodeCache =
new
Dictionary<ClientNode, List<
string
>>();
foreach
(var key
in
keys)
{
var node = GetCluster().AcquireNode(key);
if
(!nodeCache.ContainsKey(node))
nodeCache.Add(node,
new
List<
string
> { key });
else
if
(!nodeCache[node].Contains(key))
nodeCache[node].Add(key);
}
var data =
new
Dictionary<
string
,
string
>();
Parallel.ForEach(nodeCache, node =>
2）List功能。Memcached只提供了Key、Value的存储，有的时候我们的Value是一个列表，那么我们可以有两种方式完成这个功能。第一种就是直接把列表序列化作为一个Value保存，优点是简单，缺点是如果以后需要修改的话需要整个列表取出，修改后再把整个列表保存进去，并且由于Memcached Value大小的限制，这么做也不能保存大列表；第二种方式是一个Value保存列表中的一个项，再使用一个KeyValue来保存其中每一项的ID，这么优点是修改方便，获取的数据可以是列表中的一部分，缺点是实现麻烦，要考虑并发问题、要维护另外一个KeyValue来保存所有的ID。在这里，我们封装了后一种方式的实现。
3）Locker功能。使用Memcached完成锁的功能其实很简单，我们只需要在获取锁的时候判断Add一个空值是否成功，如果不成功则表示占有，等待一段时间尝试获取，一直到超时，在返回锁的时候删除这个项即可。在这里，我们封装了MemcachedLocker来完成这个功能。
