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来完成这个功能。
