您可以捐助,支持我们的公益事业。

1元 10元 50元





认证码:  验证码,看不清楚?请点击刷新验证码 必填



  求知 文章 文库 Lib 视频 Code iProcess 课程 认证 咨询 工具 火云堂 讲座吧   成长之路  
会员   
 
   
 
  
每天15篇文章
不仅获得谋生技能
更可以追随信仰
 
 
     
   
 订阅
  捐助
wcf分布式构架集群案例解决方案
 
作者:指尖流淌 来源:博客园 发布于:2016-1-29
2092 次浏览     评价:      
 

在wcf集群中,高性能的构架中一种常用的手法就是在内存中维护一个叫做“索引”的内存数据库,在实战中利用“索引”这个概念做出“海量数据的”秒杀。

首先,先上架构图:

大体讲解下该系统流程;所谓的Search集群就是图中WCF模块,它分布于不同的服务器上,为了提供高效率的数据检索,我们分步骤进行:

1、我们将数据库中的数据通过程序加载到内存数据库中

2、通过各个服务器中的WCFSearch服务为IIS提供内存数据中的数据检索

3、为了管理不同服务器中的WCFSearch服务,我们利用了“心跳检测”,实现WCFSearch和IIS的搭桥工作

4、在IIS中获取数据索引,然后向本地数据库中提取数据,实现客户端数据提取。

下面重点分析这里面的“心跳检测”的实战手法:

第一步:项目准备,为了显示出该系统构架的优越性我们先新建立个数据库,上图:

类似电子商务中的用户和店铺的关系,一个用户可以开多个店:

我们向这两张表中插入数据,插入百万级别的数据,晒下SQL数据:

------------------------------------------------
declare @a int --定义变量
declare @m int

declare @ShopName char(50)
declare @ShopUrl nchar(50)


declare @UserName nchar(50)
declare @Password nchar(50)

set @a=0 --初始值

set @m=0

set @ShopName='淘宝店'
set @ShopUrl='www.baidu.com'

set @UserName='小吴'
set @Password='110'

while @a<=1800000 ---循环插入User表180W数据
begin
insert into [User] (UserName,Passwrod) values (@UserName,@Password)

declare @UserID int
set @UserID=(select @@identity)

while @m<=10
begin
insert into dbo.Shop (UserID,ShopName,ShopUrl,User_UserID) values (@UserID,@ShopName,@ShopUrl,null)
set @m=@m+1
continue
end
set @m=0 --内循环重置为0
set @a=@a+1
continue
end

---------------------------------------------------------

select * from Shop

select * from [User]

delete from Shop
delete from [User]

truncate table Shop --重置Shop标识列
dbcc checkident('[User]',reseed,1) ---重置标识列
----------------------------------------------------------

至此,数据库已经准备完毕,我们开始建立项目。

第二步:先晒项目结构:

第三步:先解析LoadDBService项目,该项目实现的是数据库内容的加载,不废话,晒代码:

/**
*心跳检测机制
*模拟数据库加载到内存中,形成内存中的数据库
*/
namespace xinTiaoTest
{
class Program
{
static void Main(string[] args)
{
//这里的Dicionary用来表示“一个注册用户用过了多少个店铺”,即UserID和ShopID的一对多关系
SerializableDictionary<int, List<int>> dic = new SerializableDictionary<int, List<int>>();
List<int> shopIDList = new List<int>();
for (int shopID = 3000; shopID < 3050; shopID++)
{
shopIDList.Add(shopID);

}
int UserID = 15;
//假设这里已经维护了UserID与shopID的关系
dic.Add(UserID, shopIDList);

XmlSerializer xml = new XmlSerializer(dic.GetType());

var memoryStrean = new MemoryStream();

xml.Serialize(memoryStrean, dic);//将dic对象写入ID流
memoryStrean.Seek(0, SeekOrigin.Begin); //从0开始读取

//将Dicrionary持久化,相当于模拟保存在Mencache里面
File.AppendAllText("E://1.txt", Encoding.UTF8.GetString(memoryStrean.ToArray()));

Console.WriteLine("将数据加载成功");
Console.Read();

}
}
}

为了序列化List列表,我们引入了该类的序列化:

///<summary>
///13 /// 标题:支持 XML 序列化的 Dictionary
///</summary>
///<typeparam name="TKey"></typeparam>
///16 ///<typeparam name="TValue"></typeparam>
[XmlRoot("SerializableDictionary")]
public class SerializableDictionary<TKey, TValue> : Dictionary<TKey, TValue>, IXmlSerializable
{
public SerializableDictionary()
: base()
{

}
public SerializableDictionary(IDictionary<TKey, TValue> dictionary)
: base(dictionary)
{

}
public SerializableDictionary(IEqualityComparer<TKey> comparer)
: base(comparer)
{

}
public SerializableDictionary(int capacity)
: base(capacity)
{
}
public SerializableDictionary(int capacity, IEqualityComparer<TKey> comparer)
: base(capacity, comparer)
{
}
protected SerializableDictionary(SerializationInfo info, StreamingContext context)
: base(info, context)
{
}
public System.Xml.Schema.XmlSchema GetSchema()
{
return null;
}
///<summary> 54 /// 从对象的 XML 表示形式生成该对象 55 ///</summary>
///56 ///<param name="reader"></param>
public void ReadXml(System.Xml.XmlReader reader)
{
XmlSerializer keySerializer = new XmlSerializer(typeof(TKey));
XmlSerializer valueSerializer = new XmlSerializer(typeof(TValue));
bool wasEmpty = reader.IsEmptyElement; reader.Read();
if (wasEmpty)
return;
while (reader.NodeType != System.Xml.XmlNodeType.EndElement)
{
reader.ReadStartElement("item");
reader.ReadStartElement("key");
TKey key = (TKey)keySerializer.Deserialize(reader);
reader.ReadEndElement();
reader.ReadStartElement("value");
TValue value = (TValue)valueSerializer.Deserialize(reader);
reader.ReadEndElement();
this.Add(key, value);
reader.ReadEndElement();
reader.MoveToContent();
}
reader.ReadEndElement();
}
/**/
///<summary> 83 /// 将对象转换为其 XML 表示形式
///84 ///</summary> 85 ///<param name="writer"></param> 86
public void WriteXml(System.Xml.XmlWriter writer)
{
XmlSerializer keySerializer = new XmlSerializer(typeof(TKey));
XmlSerializer valueSerializer = new XmlSerializer(typeof(TValue));
foreach (TKey key in this.Keys)
{
writer.WriteStartElement("item");
writer.WriteStartElement("key");
keySerializer.Serialize(writer, key);
writer.WriteEndElement();
writer.WriteStartElement("value");
TValue value = this[key];
valueSerializer.Serialize(writer, value);
writer.WriteEndElement();
writer.WriteEndElement();
}
}
}
}

这样我们就实现了数据库中索引保存为内存数据库中的,当然为了演示我们将其持久化,另存为txt文件。

第四步:新建WCFSearch,用于从内存数据中读取索引,为IIS提供服务,不废话,晒代码:

namespace SearhService
{
// 注意: 使用“重构”菜单上的“重命名”命令,可以同时更改代码和配置文件中的接口名“IIProduct”。
[ServiceContract]
public interface IProduct
{
[OperationContract]
List<int> GetShopListByUserID(int userID);
[OperationContract]
void TestSrarch();

}
}

实现方法:

namespace SearhService
{
// 注意: 使用“重构”菜单上的“重命名”命令,可以同时更改代码和配置文件中的类名“IProduct”。
public class Product : IProduct
{

public List<int> GetShopListByUserID(int userID)
{
//模拟从Memcache中读取索引
SerializableDictionary<int, List<int>> dic = new SerializableDictionary<int, List<int>>();
byte[] bytes = Encoding.UTF8.GetBytes(File.ReadAllText("E://1.txt", Encoding.UTF8));
var memoryStream = new MemoryStream(); //新建缓存区域
memoryStream.Write(bytes, 0, bytes.Count()); //使用从缓冲区读取的数据将字节块写入当前流。
memoryStream.Seek(0, SeekOrigin.Begin);

XmlSerializer xml = new XmlSerializer(dic.GetType());
var obj = xml.Deserialize(memoryStream) as Dictionary<int, List<int>>; //反序列化生成对象

return obj[userID];

}

public void TestSrarch()
{
throw new NotImplementedException();
}
}
}

发布服务:

namespace SearhService
{
public class SearchHost : ServiceHeartBeat.IAddressCallback
{

static DateTime startTime;
public static void Main()
{
ServiceHost host = new ServiceHost(typeof(Product));
host.Open();
AddSearch();
Console.Read();
}
private static void AddSearch()
{
startTime = DateTime.Now;
Console.WriteLine("Search服务发送中.....\n\n*************************************************\n");
try
{
var heartClient = new ServiceHeartBeat.AddressClient(new InstanceContext(new SearchHost()));
string search = ConfigurationManager.AppSettings["search"]; //获取配置的本机service地址

heartClient.AddSearch(search); //添加到连接。
}
catch (Exception err)
{
Console.WriteLine("Search服务发送失败:" + err.Message);
}
}

//服务端回调函数
public void LiveAddress(string address)
{
Console.WriteLine("恭喜你,"+address+"已经被心跳成功接受");
Console.WriteLine("发送时间:"+startTime+"\n接收时间:"+DateTime.Now.ToString());
}
}
}

这里有几个点需要注意,在我们首先要引用“心跳服务”,然后将自己的发布的服务地址发送给"心跳服务“,在程序中也就是实现 ServiceHeartBeat.IAddressCallback接口,这是一个”心跳检测“中设置的一个回调接口,目的是实现告诉Search,我已经接受了你的服务,实现数据的推送....

下面是该服务的配置文件:

<?xml version="1.0"?>
<configuration> <!--设置本service的地址-->
<appSettings>
<add key="search" value="net.tcp://localhost:8732/Design_Time_Addresses/SearhService/IProduct/"/>
</appSettings>
<system.serviceModel> <!--添加服务引用生成的客户端的配置资料 -->
<bindings>
<netTcpBinding>
<binding name="NetTcpBinding_IAddress"
closeTimeout="00:01:00"
openTimeout="00:01:00"
receiveTimeout="00:10:00"
sendTimeout="00:01:00"
transactionFlow="false"
transferMode="Buffered"
transactionProtocol="OleTransactions"
hostNameComparisonMode="StrongWildcard"
listenBacklog="10"
maxBufferPoolSize="524288"
maxBufferSize="65536"
maxConnections="10"
maxReceivedMessageSize="65536"> <readerQuotas maxDepth="32"
maxStringContentLength="8192"
maxArrayLength="16384"
maxBytesPerRead="4096"
maxNameTableCharCount="16384"/>
<reliableSession ordered="true"
inactivityTimeout="00:10:00" enabled="false"/>
<security mode="Transport">
<transport clientCredentialType="Windows" protectionLevel="EncryptAndSign"/>
<message clientCredentialType="Windows"/>
</security>
</binding>
</netTcpBinding>
</bindings>
<client>
<endpoint address="net.tcp://localhost:8888/Heart" binding="netTcpBinding" bindingConfiguration="NetTcpBinding_IAddress" contract="ServiceHeartBeat.IAddress" name="NetTcpBinding_IAddress">
<identity>
<dns value="localhost"/>
</identity>
</endpoint>
</client> <!--End 添加服务引用生成的客户端的配置资料 -->
<!--添加本机服务配置 -->
<behaviors>
<serviceBehaviors>
<behavior name="IProductBehavior">
<serviceMetadata httpGetEnabled="false"/>
<serviceDebug includeExceptionDetailInFaults="false"/>
</behavior>
</serviceBehaviors>
</behaviors><services>
<service behaviorConfiguration="IProductBehavior" name="SearhService.Product">
<endpoint address=""
binding="netTcpBinding"
contract="SearhService.IProduct">
<identity>
<dns value="localhost"/>
</identity>
</endpoint>
<endpoint
address="mex"
binding="mexTcpBinding"
contract="IMetadataExchange"/>
<host>
<baseAddresses>
<add baseAddress="net.tcp://localhost:8732/Design_Time_Addresses/SearhService/IProduct/"/>
</baseAddresses>
</host>
</service>
</services>
</system.serviceModel>
<startup>
<supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.0"/>
</startup>
</configuration>

这里面有个技巧是在我们在vs2010中新建服务时,添加的服务地址里面包含Design_Time_Addresses路径,这个是vs在安装的时候自己注册的一个安全配置,也就是说在这里面普通的的用户就能够发布服务..为了能发布任何服务,我们在运行vs2010的时候要选择“管理员权限”运行。

第五步:新建ClientService项目,该项目代表的是IIS端,实现的是从内存数据库中获取索引值,也就是连接Srerch,废话不多说,上代码:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.ServiceModel; namespace ClientService
{
[ServiceContract]
public interface IServiceList
{
[OperationContract]
void AddSearchList(List<string> search);
}
}


提供一个AddSearchList方法,目的是让“心跳检测”向IIS端发送Search的地址。

实现代码为:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading; namespace ClientService
{
public class ServiceList : IServiceList
{
public static List<string> serarchilist = new List<string>();
static object obj = new object();
public static string Search
{
get
{
//如果心跳没及时返回地址,客户端就在等候,如果有的话,就随机获取其地址
while (serarchilist.Count == 0)
{
Thread.Sleep(1000);
}
return serarchilist[new Random().Next(0, serarchilist.Count)]; }
set
{
}
}
public void AddSearchList(List<string> search)
{
lock (obj)
{
serarchilist = search;
Console.WriteLine("心跳发来searche信息************************************");
Console.WriteLine("当前存活的search为:");
foreach (var single in serarchilist)
{
Console.WriteLine(single);
}
}
}
}
}

配置服务,发布服务

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.ServiceModel;
using System.Configuration;
using SearhService;
using Common;
namespace ClientService
{
class Program:ServiceHeartBeat.IAddressCallback
{
static void Main(string[] args)
{
ServiceHost host = new ServiceHost(typeof(ServiceList));
host.Opened += delegate
{
Console.WriteLine("IIS服务已经启动");
};
host.Open(); //向心跳添加链接,获取service。。
var client = new ServiceHeartBeat.AddressClient(new InstanceContext(new Program()));
//获取配置文件中的获取IIS的地址
var iis = ConfigurationManager.AppSettings["iis"];
//发送IIS地址给心跳
client.GetService(iis); //从集群中获取search地址来对search服务进行调用
var factory = new ChannelFactory<SearhService.IProduct> (new NetTcpBinding(SecurityMode.None), new EndpointAddress(ServiceList.Search));
//根据userID获取了shopId的集合
//比如说这里的ShopIDList是通过索引交并集获取分页的一些shopID
var shopIDList = factory.CreateChannel().GetShopListByUserID(15); var strSql = string.Join(",", shopIDList);
System.Diagnostics.Stopwatch watch = new System.Diagnostics.Stopwatch(); //定义时间检测量 watch.Start();
SqlHelper.Query("select s.ShopID,u.UserName,s.ShopName from [User] as u , Shop as s where s.ShopID in(" + strSql + ")");
watch.Stop();//停止检测
Console.WriteLine("通过wcf索引获取的ID>>>>>花费时间:" + watch.ElapsedMilliseconds); //普通的sql查询花费的时间
StringBuilder builder = new StringBuilder();
builder.Append("select * from ");
builder.Append("(select ROW_NUMBER() over(order by s.ShopID) as NumberID, ");
builder.Append(" s.ShopID, u.UserName, s.ShopName ");
builder.Append("from Shop s left join [User] as u on u.UserID=s.UserID ");
builder.Append("where s.UserID=15) as array ");
builder.Append("where NumberID>300000 and NumberID<300050");
watch.Start();
SqlHelper.Query(builder.ToString());
watch.Stop();
Console.WriteLine("普通的sql分页 >>>花费时间:" + watch.ElapsedMilliseconds);
Console.Read();
}
public void LiveAddress(string address)
{
Console.WriteLine("心跳检测到了你的IIS地址为:" + address );
Console.WriteLine("\n接收时间:" + DateTime.Now.ToString());
}
}
}

同样的实现ServiceHeartBeat.IAddressCallback,“心跳检测”随时的告诉IIS,已经连接的SearchService,当然在里面在获得了SearchService的时候我们对其进行了连接,然后进行了索引的查询...下面的内容是为了比较这种方法的速度如何,稍后晒测试结果。

下面是该服务的配置文件:

<?xml version="1.0"?>
<configuration>
<appSettings>
<add key="iis" value="net.tcp://localhost:2345/ServiceList"/>
</appSettings>
<system.serviceModel>
<client>
<endpoint address="net.tcp://localhost:8888/Heart" binding="netTcpBinding"
bindingConfiguration="NetTcpBinding_IAddress" contract="ServiceHeartBeat.IAddress"
name="NetTcpBinding_IAddress">
<identity>
<dns value="localhost" />
</identity>
</endpoint>
</client>
<bindings>
<netTcpBinding>

<!--客户端验证模式为空-->
<binding name="ClientBinding">
<security mode="None" />
</binding>

<binding name="NetTcpBinding_IAddress"
closeTimeout="00:01:00"
openTimeout="00:01:00"
receiveTimeout="00:10:00"
sendTimeout="00:01:00"
transactionFlow="false"
transferMode="Buffered"
transactionProtocol="OleTransactions"
hostNameComparisonMode="StrongWildcard"
listenBacklog="10"
maxBufferPoolSize="524288"
maxBufferSize="65536"
maxConnections="10"
maxReceivedMessageSize="65536">
<readerQuotas
maxDepth="32"
maxStringContentLength="8192"
maxArrayLength="16384"
maxBytesPerRead="4096"
maxNameTableCharCount="16384" />
<reliableSession ordered="true" inactivityTimeout="00:10:00"
enabled="false" />

<security mode="Transport">
<transport clientCredentialType="Windows" protectionLevel="EncryptAndSign" />
<message clientCredentialType="Windows" />
</security>
</binding>
</netTcpBinding>
</bindings>

<!--定义behaviors-->
<behaviors>
<serviceBehaviors>
<behavior name="IProductBehavior">
<serviceMetadata httpGetEnabled="false"/>
<serviceDebug includeExceptionDetailInFaults="true"/>
</behavior>
</serviceBehaviors>
</behaviors> <services>
<service name="ClientService.ServiceList">
<endpoint address="net.tcp://localhost:2345/ServiceList"
binding="netTcpBinding"
contract="ClientService.IServiceList"
bindingConfiguration="ClientBinding">
<identity>
<dns value="localhost" />
</identity>
</endpoint>
</service>
</services> </system.serviceModel>
<startup>
<supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.0"/>
</startup>
</configuration>

这里面的几个简单的配置需提醒,像客户端验证模式一定要匹配,当然在该项目中我们做了简单的配置,在实际应用中我们会对其作进一步详细配置,以确保服务的流畅性。

第六步:这时候该我们的重头戏出场了..心跳检测的的项目,实现两者的互联,上代码:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.ServiceModel; namespace HeartBeatService
{ //callbackContract:这个就是Client实现回调接口,方便服务器通知客户端
[ServiceContract(CallbackContract = typeof(ILiveAddressCallback))]
public interface IAddress
{
//此方法用于Search方法启动后,将Search地址插入此处
[OperationContract(IsOneWay=true)]
void AddSearch(string address);
//此方法用于IIS获取Search地址
[OperationContract(IsOneWay=true)]
void GetService(string address);
} }

两个方法,第一个实现Search地址的获取,第二个实现IIS的检测,上面加了一个回调接口:ILiveAddressCallback方法,实现的是客户端数据的应答。方法如下:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.ServiceModel; namespace HeartBeatService
{
///<summary>10 /// 等客户端实现后,让客户端约束一下
///,只能是这个LiveAddress方法11 ///</summary>
public interface ILiveAddressCallback
{
[OperationContract(IsOneWay = true)]
void LiveAddress(string address);
}
}

下面是心跳检测的核心代码,上代码:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.ServiceModel;
using System.Timers;
using System.Configuration;
using SearhService;
using ClientService; namespace HeartBeatService
{
//InstanceContextMode:只要是管理上下文的实例,此处是single,也就是单体
//ConcurrencyMode:主要是用来控制实例中的线程数,此处是Multiple,也就是多线程 [ServiceBehavior(InstanceContextMode = InstanceContextMode.Single, ConcurrencyMode = ConcurrencyMode.Multiple)] public class Address : IAddress
{ tatic List<string> search = new List<string>();
static object obj = new object(); //构造函数用来检测Search的个数
static Address()
{
Timer timer = new Timer();
timer.Interval = 6000;
timer.Elapsed += (sender, e) =>
{ Console.WriteLine("\n》》》》》》》》》》》》》》》》》》》》》》");
Console.WriteLine("当前存活的search为:"); lock (obj)
{
//遍历当前存活的search
foreach (var single in search)
{
ChannelFactory<IProduct> factory = null;
try
{ //当search存活的话,心跳服务就要检测search是否死掉,也就是定时检测连接Search来检测
factory = new ChannelFactory<IProduct>(new NetTcpBinding(SecurityMode.None), new EndpointAddress(single));
factory.CreateChannel();
factory.Close(); Console.WriteLine(single);
}
catch (Exception err)
{
Console.WriteLine(err.Message); //如果抛出异常,则说明此search已经挂掉
search.Remove(single);
factory.Abort();
Console.WriteLine("\n当期时间:" + DateTime.Now + ",存活的search有:" + search.Count() + "个");
}
}
//最后统计下存活的search有多少个
Console.WriteLine("\n当前时间:" + DateTime.Now + " ,存活的Search有:" + search.Count() + "个");
}
};
imer.Start(); }
public void AddSearch(string address)
{
lock (obj)
{
//是否包含相同的Search地址
if (!search.Contains(address))
{
search.Add(address);
//search添加成功后就要告诉来源处,此search已经被成功载入。 var client = OperationContext.Current.GetCallbackChannel<ILiveAddressCallback>();
client.LiveAddress(address);
}
}
} public void GetService(string address)
{
Timer timer = new Timer();
timer.Interval = 1000;
timer.Elapsed += (obj, sender) =>
{
try
{ //这个是定时的检测IIS是否挂掉
var factory = new ChannelFactory<IServiceList>(new NetTcpBinding(SecurityMode.None), new EndpointAddress(address));
factory.Opened += delegate
{
Console.WriteLine("IIS("+address+")已经启动..正在发送searchSerive地址...");
};
factory.CreateChannel().AddSearchList(search);
factory.Close(); timer.Interval = 20000;
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
};
timer.Start();
}
}
}

为确保不丢掉任何的Search服务,我们采用多线程,InstanceContextMode:只要是管理上下文的实例,此处是single,也就是单体 ConcurrencyMode:主要是用来控制实例中的线程数,此处是Multiple,也就是多线程。

1、构造函数的静态方法实现当前服务的检测和显示,采用Timer定时检测...

2、AddSearch方法实现Search的添加,并回复客户端

3、GetService方法实现的是检测IIS是否等待连接,并且将Search集合发送给它,同样是定时发送。

下面晒配置文件:

<?xml version="1.0"?>
<configuration>
<system.web>
<compilation debug="true"/>
</system.web>
<!-- 部署服务库项目时,必须将配置文件的内容添加到
主机的 app.config 文件中。System.Configuration 不支持库的配置文件。-->
<system.serviceModel>
<services>
<service name="HeartBeatService.Address" behaviorConfiguration="myBehavior">
<endpoint address="net.tcp://localhost:8888/Heart"
binding="netTcpBinding"
contract="HeartBeatService.IAddress">
<identity>
<dns value="localhost"/>
</identity>
</endpoint>

<!--定义引用地址元数据的接受方式,此处基地址(baseAddress) 定义的协议Http所以binding同样为mexHttpBinding方式-->
<endpoint address="mex" binding="mexHttpBinding" contract="IMetadataExchange"/>
<host>
<baseAddresses>
<add baseAddress="http://localhost:9999/Heart"/>
</baseAddresses>
</host>
</service>
</services>
<behaviors>
<serviceBehaviors>
<behavior name="myBehavior">
<!-- 为避免泄漏元数据信息,请在部署前将以下值设置为 false 并删除上面的元数据终结点 -->
<serviceMetadata httpGetEnabled="True"/>
<!-- 要接收故障异常详细信息以进行调试,请将以下值设置为 true。 在部署前设置为 false 以避免泄漏异常信息-->
<serviceDebug includeExceptionDetailInFaults="False"/>
</behavior>
</serviceBehaviors>
</behaviors>
</system.serviceModel> <startup><supportedRuntime version="v4.0"
sku=".NETFramework,Version=v4.0"/></startup></configuration>

至此,我们已经成功顺利的搭建完心跳检测的流程,我们先运行下“心跳”项目,它将等待Search发送连接过来,并检查IIS时候等候状态...

然后我们再运行Search...向“心跳”抛出橄榄枝...

嘿嘿,两者已经顺利握手...下面咱把IIS启动,看看“心跳检测”是否能将这个SearchService发送给它:

同样成功,这说明我们的心跳服务还是能实时的为IIS提供连接地址的..

好,下面我们测试该框架性能如何,首先我们执行LoadDBService,将数据库加载到内存中...结果如下:

我们用该框架测试下速度和普通的查询方式进行比较:

先晒SQL语句,看两者差距性:

select * from         
(
select ROW_NUMBER() over(order by s.ShopID) as NumberID,
s.ShopID,
u.UserName,
s.ShopName
from Shop s left join [User] u
on u.UserID=s.UserID
where s.UserID=150
) as array
where NumberID>0 and NumberID<50
-------------------分页查询-------------------------
select s.ShopID,u.UserName,s.ShopName
from [User] as u ,
Shop as s
where s.ShopID in(100,200,3000,5000,4000,201)
select * from shop
select * from [user]

我们在IIS端进行加载检测:

晒运行结果:

提示了一个错误:

我们将此服务的连接时间该的长一点:

这个错误是因为和客户端验证模式不对,我们在这里面做了设置,将其设置为None,为了确保从内存数据库中读取完毕,我们将应答时间该的稍长点。我们下面晒结果:

这里看样子也快不了多少,那是因为我们在wcf里查询的条数设置和SQL里面的语法查询条数不同,我们将改一下,还有就是在此服务已有一个,并且内存数据库实现的方式是通过本地化文件操作,很显然是费时费力的工作,就性能均摊,可扩展性等方面,无疑该框架是利器...好了先解析到此..

   
2093 次浏览  评价: 差  订阅 捐助
 
相关文章

深度解析:清理烂代码
如何编写出拥抱变化的代码
重构-使代码更简洁优美
团队项目开发"编码规范"系列文章
 
相关文档

重构-改善既有代码的设计
软件重构v2
代码整洁之道
高质量编程规范
 
相关课程

基于HTML5客户端、Web端的应用开发
HTML 5+CSS 开发
嵌入式C高质量编程
C++高级编程
 

使用decj简化Web前端开发
Web开发框架形成之旅
更有效率的使用Visual Studio
MVP+WCF+三层结构搭建框架
ASP.NET运行机制浅析【图解】
编写更好的C#代码
10个Visual Studio开发调试技巧
更多...   

.NET框架与分布式应用架构设计
.NET & WPF & WCF应用开发
UML&.Net架构设计
COM组件开发
.Net应用开发
InstallShield

日照港 .NET Framework & WCF应用开发
神华信息 .NET单元测试
北京 .Net应用软件系统架构
台达电子 .NET程序设计与开发
赛门铁克 C#与.NET架构设计
广东核电 .Net应用系统架构
更多...   
 
 
 
 
 
每天2个文档/视频
扫描微信二维码订阅
订阅技术月刊
获得每月300个技术资源
 
 

关于我们 | 联系我们 | 京ICP备10020922号 京公海网安备110108001071号