服务主机的路由器与负载均衡和实现思路-路由器负载均衡

路由器介绍及演示

WCF中间件的路由功能是在客户端与服务端之间加入中介服务，用来转发它们之间的消息。实现消息的转发可以修改WCF服务消息头的内容，重新指定服务地址即可，那给消息头指定的服务地址从哪来，需要给路由器配置服务端地址目录，路由器与服务端肯定不是一对一的，路由器可以指定多个服务端，而路由器把客户端连接指定给哪个服务端这里就有一个算法，算法的优劣就决定了中间件负载均衡的能力。

下面演示了中间件的路由功能，把Out目录中的程序复制6份，分别改名如下，3个客户端，1个路有中间件，2个服务中间件，还要修改每个程序的相关配置;这样先启动路由中间件Router和服务中间件WCFservser1、WCFServer2，然后分别启动2个客户端程序，路由中间件和服务中间件就会显示客户端的连接信息。3个客户端会有2个分配到一个服务中间件，一个客户端分配到另外一个服务中间件，不会说3个客户端都分配到1个服务中间件，这是由路由中间件的负载均衡算法决定的;

路由功能的实现

框架增加了一个路由服务对象Router，用它来拦截客户端发送的消息，拦截方法ProcessMessage(Message requestMessage);

首先根据路由目录结合负载均衡的算法取得服务地址endpointAddress，然后创建WCF通道并绑定新的服务地址，调用服务端的方法;

/// <summary> 
        /// 截获从Client端发送的消息转发到目标终结点并获得返回值给Client端 
        /// </summary> 
        /// <param name="requestMessage"></param> 
        /// <returns></returns> 
        public Message ProcessMessage(Message requestMessage) 
        { 
            //Binding binding = null; 
            EndpointAddress endpointAddress = null; 
            GetServiceEndpoint(requestMessage, out endpointAddress); 
            IDuplexRouterCallback callback = OperationContext.Current.GetCallbackChannel<IDuplexRouterCallback>(); 
            NetTcpBinding tbinding = new NetTcpBinding("netTcpExpenseService_ForSupplier"); 
            using (DuplexChannelFactory<IRouterService> factory = new DuplexChannelFactory<IRouterService>(new InstanceContext(null, new DuplexRouterCallback(callback)), tbinding, endpointAddress)) 
            { 
 
                factory.Endpoint.Behaviors.Add(new MustUnderstandBehavior(false)); 
                IRouterService proxy = factory.CreateChannel(); 
 
                using (proxy as IDisposable) 
                { 
                    // 请求消息记录 
                    IClientChannel clientChannel = proxy as IClientChannel; 
                    //Console.WriteLine(String.Format("Request received at {0}, to {1}\r\n\tAction: {2}", DateTime.Now, clientChannel.RemoteAddress.Uri.AbsoluteUri, requestMessage.Headers.Action)); 
                    if (Convert.ToInt32(HostSettingConfig.GetValue("debug")) == 1) 
                        hostwcfMsg(DateTime.Now, String.Format("路由请求消息发送：  {0}", clientChannel.RemoteAddress.Uri.AbsoluteUri)); 
                    // 调用绑定的终结点的服务方法 
                    Message responseMessage = proxy.ProcessMessage(requestMessage); 
 
                    // 应答消息记录 
                    //Console.WriteLine(String.Format("Reply received at {0}\r\n\tAction: {1}", DateTime.Now, responseMessage.Headers.Action)); 
                    //Console.WriteLine(); 
                    //hostwcfMsg(DateTime.Now, String.Format("应答消息： {0}", responseMessage.Headers.Action)); 
                    return responseMessage; 
                } 
            } 
        }

#p#负载均衡的实现

负载均衡实现代码在Router对象中的GetServiceEndpoint方法中，定义了RegistrationList对象用来存储客户端列表，在消息头中增加了两个标识routerID和CMD，routerID用来识别客户端，值是客户端创建发送到路由中间件，每个客户端只有一个routerID;CMD用来客户端发送给路由中间件的命令标识，这里只用到了一个就是”Quit”就是卸载路由中间件中的RegistrationList客户端列表;

解决了识别客户端的问题，那平均算法每个客户端分配到哪个服务中间件就很简单了，RoundRobinCount就记录每个服务中间件对应的客户端个数，哪个服务中间件数量少新的客户端就分配给它;

private void GetServiceEndpoint(Message requestMessage,out EndpointAddress endpointAddress) 
        { 
 
            string ns = "http://www.3yxx.com/"; 
            string routerID = GetHeaderValue("routerID", ns); 
            string cmd = GetHeaderValue("CMD", ns); 
            string contractNamespace = requestMessage.Headers.Action.Substring(0, requestMessage.Headers.Action.LastIndexOf("/")); 
 
            
 
            RegistrationInfo regInfo = null; 
 
            if (Router.RoundRobinCount.ContainsKey(routerID)) 
            { 
                int key = Router.RoundRobinCount[routerID]; 
                regInfo = Router.RegistrationList[key]; 
                if (cmd == "Quit") 
                { 
                    regInfo.ClientNum -= 1; 
                } 
            } 
            else 
            { 
                //根据指定的协议名称空间从注册表容器中得到注册项列表 
                var results = from item in Router.RegistrationList 
                              where item.Value.ContractNamespace.Contains(contractNamespace) 
                              orderby item.Value.ClientNum ascending 
                              select item; 
                if (results.Count<KeyValuePair<int, RegistrationInfo>>() > 0) 
                { 
                    var val = results.First<KeyValuePair<int, RegistrationInfo>>(); 
                    Router.RoundRobinCount.Add(routerID, val.Key); 
                    val.Value.ClientNum += 1; 
                    regInfo = val.Value; 
                } 
            } 
 
            Uri addressUri = new Uri(regInfo.Address); 
 
            //binding = CustomBindConfig.GetRouterBinding(addressUri.Scheme); 
            endpointAddress = new EndpointAddress(regInfo.Address); 
            //重设Message的目标终结点 
            requestMessage.Headers.To = new Uri(regInfo.Address); 
 
            hostwcfRouter(RegistrationList.Values.ToList()); 
        }