开发笔记 第814页

原文：A Million-user Comet Application with Mochiweb, Part 1

参考资料：Comet–基于 HTTP 长连接、无须在浏览器端安装插件的“服务器推”技术为“Comet”

               MochiWeb–建立轻量级HTTP服务器的Erlang库

      在这个系列中，我将详述我所发现的mochiweb是怎样支持那么巨大的网络连接的，为大家展示怎样用mochiweb构建一个comet应用，这个应用 中每个mochiweb连接都被注册到负责为不同用户派送消息的路由器上。最后我们建立一个能够承受百万并发连接的可工作的应用，更重要的我们将知道这样 的应用需要多少内存才能使它跑起来。

本部分内容如下：

• 建立一个基本的comet应用， 它每10秒钟给客户端发送一条消息
• 调整linux内核参数，使它能够处理大量的TCP连接
• 写一个能够建立大量网络连接的压力测试工具 (也就是 C10k测试)
• 检查每个连接到底需要多少内存.

本系列续作将包括怎样建立一个真正的信息路由系统，降低内存使用的技巧，100K和1m并发连接的测试。

基础是你需要知道一些linux命令行操作和一点Erlang知识，否则看不懂别怪我呀，呵呵

写一个Mochiweb测试程序

概括如下:

1. 安装编译Mochiweb
2. 运行: /your-mochiweb-path/scripts/new_mochiweb.erl mochiconntest
3. cd mochiconntest 之后编辑 src/mochiconntest_web.erl

这部分代码(mochiconntest_web.erl)只是接收连接并且每十秒用块传输方式给客户端发送一个初始的欢迎信息。

mochiconntest_web.erl

启动Mochiweb应用

make && ./start-dev.sh
缺省的Mochiweb在所有网卡接口的8000端口上进行监听，假如是在桌面系统上做这些事，你可以使用任何浏览器访问http://localhost:8000/test/foo 进行测试。
这里只是命令行测试：

$ lynx --source "http://localhost:8000/test/foo"
Mochiconntest welcomes you! Your Id: foo<br/>
Chunk 1 for id foo<br/>
Chunk 2 for id foo<br/>
Chunk 3 for id foo<br/>
^C

是的,它可以工作。 现在，让我们使劲整它，呵呵。

调整linux内核参数，使它能够处理大量的TCP连接

为节省时间我们需要在进行大量并发连接测试之前调整内核的tcp设置参数，否则你的测试将会失败，你将看到大量的Out of socket memory 信息(假如在伪造将得到, nf_conntrack: table full, dropping packet. )

下面的是我用到的sysctl设置 – 你的配置可能不一样，但是大致就是这些：

# General gigabit tuning:
net.core.rmem_max = 16777216
net.core.wmem_max = 16777216
net.ipv4.tcp_rmem = 4096 87380 16777216
net.ipv4.tcp_wmem = 4096 65536 16777216
net.ipv4.tcp_syncookies = 1
# this gives the kernel more memory for tcp
# which you need with many (100k+) open socket connections
net.ipv4.tcp_mem = 50576   64768   98152
net.core.netdev_max_backlog = 2500
# I was also masquerading the port comet was on, you might not need this
net.ipv4.netfilter.ip_conntrack_max = 1048576

把这些写到 /etc/sysctl.conf中然后运行 sysctl -p 使其生效。不需要重启，现在你的内核能够处理大量的连接了，yay。

建立大量连接

有很多方法可以用. Tsung 就十分好, 也有很多其他比较好的工具如ab, httperf, httpload等等可以生成大量的无用请求。 但是它们中任何一款都不适合测试comet应用, 正好我也想找个借口测试一下Erlang的http客户端, 因此我写了一个基本的测试程序用以发起大量的连接。
只是因为你可以但并不意味着你就这样做.. 一个连接就用一个进程确实有点浪费。我用一个进程从文件中调入一批url链接，另一个进程建立连接并接收数据 (当定时器的进程每10秒打印一份报告)。所有从服务器接收来的数据都被丢弃，但是它增加计数，这样我们能够跟踪到底有多少http数据块被传输了。

floodtest.erl

udo bash
# ulimit -n 999999
# erl

       虽然现在已经是宽带时代，小猫已经离我们渐渐远去，可作为WEB应用开发者来说，我们仍然有责任和义务不断地通过技术手段来优化WEB应用性能，让用户浏览时少一些等待，多一些爽快。
       所 幸的是，ASP.NET作为基于.Net Framework的WEB开发技术，它也享用着.Net Framework的优越性，.Net Framework为我们提供了良好的Cache技术，使我们能开发出速度更快、用户体验更好的WEB应用。命名空间 System.Web.Caching提供了Cache类，其Cache的有效性依赖分以下三种情况：
1． 时间点（指定时间点内有效）；
2． KEY值（KEY值作Cache项标识）；
3． 文件或目录（指定文件或目录变更，则原Cache项不可用）；

       下面我就结合实际开发的应用跟大家分享一下使用Cache来提高ASP.NET应用的性能。
       我们在开发中常常会遇到读取记录列表（例如最近更新的新闻列表Top N）、记录本身（例如一条新闻），用户访问的时候，这样的信息是否每次都要重复从数据库中读取呢？聪明的你可能知道，这完全是没必要的。

我们为了方便处理，不防设计一个SiteCache类（借鉴了CS中的CSCache.cs），并提供若干静态方法，来负责处理Cache项的添加和删除。下面给出类图：

代码：

SiteCache.cs
  1using System;
  2using System.Collections;
  3using System.Text.RegularExpressions;
  4using System.Web;
  5using System.Web.Caching;
  6
  7namespace Ycweb.Components
  8{
  9    public class SiteCache
 10    {
 11        private static readonly Cache _cache;
 12        public static readonly int DayFactor;
 13        private static int Factor;
 14        public static readonly int HourFactor;
 15        public static readonly int MinuteFactor;
 16
 17        static SiteCache()
 18        {
 19            DayFactor = 17280;
 20            HourFactor = 720;
 21            MinuteFactor = 12;
 22            Factor = 5;
 23            _cache = HttpRuntime.Cache;
 24        }
 25
 26        private SiteCache()
 27        {
 28        }
 29
 30        public static void Clear()
 31        {
 32            IDictionaryEnumerator enumerator = _cache.GetEnumerator();
 33            while (enumerator.MoveNext())
 34            {
 35                _cache.Remove(enumerator.Key.ToString());
 36            }
 37        }
 38
 39        public static object Get(string key)
 40        {
 41            return _cache[key];
 42        }
 43
 44        public static void Insert(string key, object obj)
 45        {
 46            Insert(key, obj, null, 1);
 47        }
 48
 49        public static void Insert(string key, object obj, int seconds)
 50        {
 51            Insert(key, obj, null, seconds);
 52        }
 53
 54        public static void Insert(string key, object obj, CacheDependency dep)
 55        {
 56            Insert(key, obj, dep, HourFactor*12);
 57        }
 58
 59        public static void Insert(string key, object obj, int seconds, CacheItemPriority priority)
 60        {
 61            Insert(key, obj, null, seconds, priority);
 62        }
 63
 64        public static void Insert(string key, object obj, CacheDependency dep, int seconds)
 65        {
 66            Insert(key, obj, dep, seconds, CacheItemPriority.Normal);
 67        }
 68
 69        public static void Insert(string key, object obj, CacheDependency dep, int seconds, CacheItemPriority priority)
 70        {
 71            if (obj != null)
 72            {
 73                _cache.Insert(key, obj, dep, DateTime.Now.AddSeconds((double) (Factor*seconds)), TimeSpan.Zero, priority, null);
 74            }
 75        }
 76
 77        public static void Max(string key, object obj)
 78        {
 79            Max(key, obj, null);
 80        }
 81
 82        public static void Max(string key, object obj, CacheDependency dep)
 83        {
 84            if (obj != null)
 85            {
 86                _cache.Insert(key, obj, dep, DateTime.MaxValue, TimeSpan.Zero, CacheItemPriority.AboveNormal, null);
 87            }
 88        }
 89
 90        public static void MicroInsert(string key, object obj, int secondFactor)
 91        {
 92            if (obj != null)
 93            {
 94                _cache.Insert(key, obj, null, DateTime.Now.AddSeconds((double) (Factor*secondFactor)), TimeSpan.Zero);
 95            }
 96        }
 97
 98        public static void Remove(string key)
 99        {
100            _cache.Remove(key);
101        }
102
103        public static void RemoveByPattern(string pattern)
104        {
105            IDictionaryEnumerator enumerator = _cache.GetEnumerator();
106            Regex regex1 = new Regex(pattern, RegexOptions.Singleline | RegexOptions.Compiled | RegexOptions.IgnoreCase);
107            while (enumerator.MoveNext())
108            {
109                if (regex1.IsMatch(enumerator.Key.ToString()))
110                {
111                    _cache.Remove(enumerator.Key.ToString());
112                }
113            }
114        }
115
116        public static void ReSetFactor(int cacheFactor)
117        {
118            Factor = cacheFactor;
119        }
120
121
122
123    }
124}

       其实该类主要就是利用前文所提及的关于Cache依赖项的第一点与第二点的特性来维护我们自己的Cache项。
有了SiteCache类，接下来看看如何使用它。还是以读取新闻TonN列表为例：

 1public static RecordSet GetNewsSetTopN(string classCode,int topN,SortPostsBy orderBy, SortOrder sortOrder, string language)
 2{
 3 string cacheKey = string.Format("NewsSetTopN-LG:{0}:CC:{1}:TN:{2}:OB:{3}:SO:{4}", language,classCode,topN.ToString(), orderBy.ToString(),sortOrder.ToString());
 4  
 5 //从上下文中读缓存项
 6 RecordSet newsSet = HttpContext.Current.Items[cacheKey] as RecordSet;
 7 if (newsSet == null)
 8 {
 9  //从HttpRuntime.Cache读缓存项
10  newsSet = SiteCache.Get(cacheKey) as RecordSet;
11  if (newsSet == null)
12  {
13   //直接从数据库从读取
14   CommonDataProvider dp=CommonDataProvider.Instance();
15   newsSet =dp.GetNewsSetTopN(language,classCode,topN,orderBy,sortOrder);
16   //并将结果缓存到HttpRuntime.Cache中
17   SiteCache.Insert(cacheKey, newsSet, 60, CacheItemPriority.Normal);
18  }
19        
20 }
21return newsSet;
22}

       这 样在5分钟内就不用重复访问数据库了来读该列表了，当然，也有人会问，如果在这5分钟内某条新闻删除了或修改了怎么办，没关系，我们在删除或修改时可以根 据Cache KEY来强制删除该Cache项，当然，如果你觉得你对列表的时效性不是特别在意，你可以不强制删除该Cache项，让Cache项定义的时间点自动失 效。当然，最好还是提供一个方法按匹配模式项来强行删除Cache项就可以了，例如：

1/**//// <summary>
2/// 删除匹配的NewsSetTopN列表的Cache项
3/// </summary>
4public static void ClearNewsSetTopNCache(string language,string classCode,int topN)
5{
6 string cacheKey = string.Format("NewsSetTopN-LG:{0}:CC:{1}:TN:{2}",language,classCode,topN.ToString());
7 SiteCache.RemoveByPattern(cacheKey);
8}
9

       发布新闻后调用静态方法ClearNewsSetTopNCache()强行清除原来的TopN缓存项，例如：

 1/**//// <summary>
 2/// 发布(新建)新闻
 3/// </summary>
 4/// <param name="post">新闻实例</param>
 5/// <returns>返回状态</returns>
 6public static int Create(News post)
 7{
 8 int status;
 9 CommonDataProvider dp=CommonDataProvider.Instance();
10 dp.CreateUpdateDeleteNews(post, DataAction.Create, out status);
11 //强制清除匹配的缓存项
12 ClearNewsSetTopNCache (post.Language, post.ClassCode,Globals.GetSiteSetting.NewsListTopN);
13 return status;
14}

That's all.若有不妥之处还望各位同行指正。

Flex之于Java，就像美丽之于大脑，或者还有别的说法？谁能告诉我？我所知道的是，Flex和Java真的是能配合得很好，能创建出难以置信 的富 Internet应用（RIA）。你会问Flex是什么？Flex是一个开源框架，你可以通过基于标签的MXML语言（以及ActionScript 3）来构建Flash应用。

请观看：Jack有关Flex与JSON及XML互操作的演讲 （QuickTime格式，33MB）。

你可以从Adobe的站点下载（http://adobe.com/flex）Flex IDE即所谓Flex Builder，并由此开始你的开发之旅。Flex Builder是个商业产品，但它有很长的免费试用阶段，能让你有足够时间想清楚是不是值得掏这个钱。在这篇文章中，我会演示如何一起使用Flex和 Java。Java会运行在服务器端，而Flex运行在客户端。这两端间的通信协议可以是任何你想要的协议。但在这里，我会先使用XML，然后再使用 JSON，因为这两种技术是我们在Web 2.0的世界里最常见的。

创建服务器代码

XML示例由列表1中显示的简单JSP文件开始：

 列表1. xml.jsp
<jsp:root xmlns:jsp="http://java.sun.com/JSP/Page" version="1.2">
<jsp:directive.page import="java.text.*"/>
<jsp:directive.page import="java.lang.*"/>
<jsp:directive.page contentType="text/xml"/>
<days><jsp:scriptlet>
<![CDATA[
double compa = 1000.0;
double compb = 900.0;
for (int i = 0; i<=30; i++) {
compa += ( Math.random() * 100 ) - 50;
compb += ( Math.random() * 100 ) - 50;
]]>
</jsp:scriptlet>
<day>
<num><jsp:expression>i</jsp:expression></num>
<compa><jsp:expression>compa</jsp:expression></compa>
<compb><jsp:expression>compb</jsp:expression></compb>
</day>
<jsp:scriptlet>
<![CDATA[ }
]]>
</jsp:scriptlet>
</days>
</jsp:root>

这个服务会每三十天为两家公司（compa和compb）导出一些随机的股票数据。第一家公司的数值从1000美元开始，第二家从900美元开始，而JSP代码会每天为这两个数值增加一个随机数。

当我从命令行使用curl客户端去访问这个服务时，我获得的是下面这样的结果：

 % curl "http://localhost:8080/jsp-examples/flexds/xml.jsp"
<days><day><num>0</num><compa>966.429108587301</compa>
<compb>920.7133933216961</compb>
</day>...</days>

根标签是<days>标签，它包含了一个<day>标签的集合。每个<day>标签都 有一个<num>标签来表示天数，一个<compa>值来表示公司A的股票价格，以及<compb>值来表示公司B 的股票价格。两只股票的数值随着每次请求而不同，因为它们是随机生成的。

构建界面

现在我们已经有了一个web服务来输出股票的价格，我们还需要一个客户端应用来展现它。我们要构建的第一个界面是表格风格的界面，用它来简单的显示 数字。为了创建Flex项目，我们在Flex Builder IDE的新建菜单中选择Flex Project。显示如图1：

图1. 新Flex项目对话框

在这我们要做的就是给项目起个名字。我把它叫做xmldg，意思是XML数据表格。这样就会创建出一个名叫xmldg.mxml的文件，其中只包含一个空白标签。下面我会使用列表2中的代码来代替这个空白标签。

列表2. xmldg.mxml
<?xml version="1.0" encoding="utf-8"?>

<mx:Application  xmlns:mx="http://www.adobe.com/2006/mxml" layout="vertical">
<mx:XML source="http://localhost:8080/jsp-examples/flexds/xml.jsp" id="stockData" />
<mx:Panel title="Stock Data" width="100%" height="100%">
<mx:DataGrid dataProvider="{stockData..day}" width="100%" height="100%">
<mx:columns>
<mx:DataGridColumn dataField="compa" />
<mx:DataGridColumn dataField="compb" />
</mx:columns>
</mx:DataGrid>
</mx:Panel>
</mx:Application>

xmldg应用程序代码有两个主要的组件。第一个是<mx:XML>标签，它告诉Flex这是个XML数据源，并提供了URL。这样就会创建一个叫做stockData（由id属性指定）的局部变量，而<mx:DataGrid>组件可以把它当作dataProvider来使用。

代码的剩余部分就是界面了。<mx:Panel>对象为表格提供了一个简洁的包装。而<mx:DataGrid>用来显示数据。在<mx:DataGrid>中，是一串<mx:DataGridColumn>对象，来告诉表格显示什么数据。

如果我们从Flex Builder运行这个界面，你就会看到像图2的这个样子：

图2. xmldg应用运行界面

我们可以拉动滚动条，改变窗口大小，并且看到数据表格也会改变大小。如果需要添加一点过滤的功能，我们就需要使用<mx:HSlider>控件来更新代码，为它添加一个水平的滑块，来指定表格从哪一天开始显示数据。

比如，如果我们设置滑块到6，它就会只显示从第六天开始的数据。代码如列表3所示：

列表3. xmldg2.mxml
<?xml version="1.0" encoding="utf-8"?>
<mx:Application xmlns:mx="http://www.adobe.com/2006/mxml" layout="vertical">
<mx:XML source="http://localhost:8080/jsp-examples/flexds/xml.jsp" id="stockData" />
<mx:Panel title="Stock Data" width="100%" height="100%" layout="vertical"
paddingBottom="10" paddingLeft="10" paddingRight="10" paddingTop="10">
<mx:HBox>
<mx:Label text="Start Day" />
<mx:HSlider minimum="0" maximum="30" id="dayslider" snapInterval="1" />
</mx:HBox>
<mx:DataGrid dataProvider="{stockData..day.(num >= daySlider.value )}" width="100%" height="100%">
<mx:columns>
<mx:DataGridColumn dataField="num" headerText="day" />
<mx:DataGridColumn dataField=="compa" headerText="Company A" />
<mx:DataGridColumn dataField=="compb" headerText="Company B" />
</mx:columns>
</mx:DataGrid>
</mx:Panel>
</mx:Application>

还有其他的一些标签，但规则基本上还是一样的。<mx:Panel>标签可以包含所有内容。其中可以是<mx:HBox> （水平 格）标签，并且box还包含着<mx:Label>和<mx:HSlider>控件。slider用 于<mx:DataGrid>的dataProvider字段。

让我们来更进一步看看dataProvider属性：

{stockData..day.(num >= daySlider.value )}

这里使用的是ActionScript的E4X语法来减少<mx:DataGrid>控件的数据集合，使其只包含那些<num>值大于或等于滑块值的标签。Flex非常智能，它能观察到滑块的变化事件，并自动更新数据表格。

当我们从Flex Builder运行这个界面时，它看起来就像是图3这样：

图3. 可过滤性网格

我们可以调整滑块的位置，并查看到表格中的数据如何变化。图4显示的是我把滑块设到12时的样子：

图4. 滑块设为12时的显示界面

这只是个使用ActionScript中E4X的简单例子。E4X语法使得处理XML变得非常容易，以至于你不会再愿意使用任何其他办法来处理XML了。

画图表

数据表格有点让人厌倦了，至少对我来说是这样。我喜欢有图像的。那么让我们来干点什么——在界面上放置一张图表。我们创建了一个新的名叫xmlgph（意思是XML图表）的项目，并用列表4中的代码来代替自动生成的xmlgph.xml文件。

列表4. xmlgph.mxml
<?xml version="1.0" encoding="utf-8"?>
<mx:Application xmlns:mx="http://www.adobe.com/2006/mxml" layout="vertical">
<mx:XML source="http://localhost:8080/jsp-examples/flexds/xml.jsp" id="stockData" />
<mx:Panel title="Stock Data" width="100%" height="100%" layout="vertical"
paddingBottom="10" paddingLeft="10" paddingRight="10" paddingTop="10">
<mx:HBox>
<mx:Label text="Start Day" />
<mx:HSlider? minimum="0" maximum="30" id="dayslider" snapInterval="1" />
</mx:HBox>
<mx:LineChart id="chart" dataProvider="{stockData..day.(num >= daySlider.value )}"
width="100%" height="100%">
<mx:series>
<mx:LineSeries xField="num" yField="compa" displayName="Company A" />
<mx:LineSeries xField="num" yField="compb" displayName="Company B" />
</mx:series>
</mx:LineChart>
<mx:Legend dataProvider="{chart}" />
 </mx:Panel>
</mx:Application>

代码就跟xmldb2一样，但<mx:LineChart>控件替代了<mx:DataGrid>控件，用来显示一张数值 图表， 而不是一个表格。另外还有个<mx:Legend>控件来显示不同颜色线条代表的公司名称。而两 个<mx:LineSeries>对象就类似于<mx:DataGridColumn>的功能。它们让线性图表知道在哪个轴上显 示什么数据。

当我们从Flex Builder运行这个界面是，看到的会是图5这个样子：

图5. 线形图例

还不错吧？因为<mx:HSlider>控件还在那里，所以我们可以移动滑块的位置来改变图表的起始日期。

事实上，只需要一点点小的改变，我们就可以为用户在滑块上提供两个滑动杆，这样它们就能独立移动来让这个图表只显示一段日期内的数据。代码显示如列表5所示：

列表5. xmlgph2.mxml
<?xml version="1.0" encoding="utf-8"?>
<mx:Application xmlns:mx="http://www.adobe.com/2006/mxml" layout="vertical">
<mx:XML source="http://localhost:8080/jsp-examples/flexds/xml.jsp" id="stockData " />
<mx:Panel title="Stock Data " width="100% " height="100% " layout="vertical "
paddingBottom="10 " paddingLeft="10 " paddingRight="10 " paddingTop="10 ">
<mx:HBox>
<mx:Label text="Date Range " />
<mx:HSlider minimum="0 " maximum="30 " id="daySlider " snapInterval="1 "
thumbCount="2 " values="[0,30] " />
</mx:HBox>
<mx:LineChart id="chart"
dataProvider="{stockData..day.(num>=daySlider.values[0] &&
num<=daySlider.values[1])}"
width="100%" height="100%">
<mx:series>
<mx:LineSeries xField="num" yField="compa" displayName="Company A" />
<mx:LineSeries xField="num" yField="compb" displayName="Company B" />
</mx:series>
</mx:LineChart>
<mx:Legend dataProvider="{chart}" />
 </mx:Panel>
</mx:Application>

我们需要做的就是为<mx:HSlider>标签添加thumbCount和values属性，并更 新<mx:DataGrid>标签中的dataProvider。因为这是段XML，我必须对dataProvider中的部分实体进行编 码。如果从Flex Builder运行这段代码，我们会看到图6显示的那样：

图6.窗口型线形图

以上这些就是范例演示的XML部分。下面开始我会演示如何构建一个能调用JSON服务的Flex应用程序。

构建JSON服务器

我们由创建一个JSON数据源作为开端，来创建JSON阅读应用程序。同样，我们还是使用可靠的JSP来给构建JSON编码的数据流。这段服务器上的JSP代码显示如列表6：

 列表6. json.jsp
<jsp:root xmlns:jsp="http://java.sun.com/JSP/Page" version="1.2">
<jsp:directive.page import="java.text.*"/>
<jsp:directive.page import="java.lang.*"/>
<jsp:directive.page contentType="text/json"/>
[<jsp:scriptlet>
<![CDATA[
double compa = 1000.0;
double compb = 900.0;
for (int i = 0; i<=30; i++) {
compa += ( Math.random() * 100 ) - 50;
compb += ( Math.random() * 100 ) - 50;
if ( i > 0 ) out.print( "," );
]]> </jsp:scriptlet>{"compa":<jsp:expression>compa</jsp:expression>,"compb":<jsp:expres
sion>compb</jsp:expression>}<jsp:scriptlet>
<![CDATA[ }
]]>
</jsp:scriptlet>]
</jsp:root>

这就跟XML服务一样，但我们创建的不是XML标签，而是JSON编码的数据。

当我从命令行运行curl时，得到的页面如下所示：

 % curl "http://localhost:8080/jsp-examples/flexds/json.jsp"
[{"compa":992.2139849199265,"compb":939.89135379532}, ...]

而这恰恰是JavaScript客户端能够理解的东西。

使用JSON服务

Flex是用Flash播放器的编程语言ActionScript 3编写的。它和JavaScript很类似，但它没有eval方法。那么我们如何将JSON文本转换成ActionScript数据呢？幸运的是，免费的ActionScript 3核心库(http://as3corelib.googlecode.com)包含了JSON解码器和JSON编码器。

列表7中的代码演示了JSONDecoder对象的用法：

列表7. jsondg.mxml
<?xml version="1.0" encoding="utf-8"?>
<mx:Application xmlns:mx="http://www.adobe.com/2006/mxml" layout="vertical"
creationComplete="jsonservice.send()">
<mx:Script>
<![CDATA[
import mx.rpc.events.ResultEvent;
import com.adobe.serialization.json.JSONDecoder;
private function onJSONResult( event:ResultEvent ) : void {
var data:String = event.result.toString();
data = data.replace( /\s/g, '' );
var jd:JSONDecoder = new JSONDecoder( data );
dg.dataProvider = jd.getValue();
}
]]>
</mx:Script>
<mx:HTTPService id="jsonservice"
url="http://localhost:8080/jsp-examples/flexds/json.jsp"
resultFormat="text" result="onJSONResult(event)" />
<mx:Panel title="Stock Data " width="100% " height="100% ">
<mx:DataGrid id="dg" width="100%" height="100%">
<mx:columns>
<mx:DataGridColumn dataField="compa " />
<mx:DataGridColumn dataField="compb " />
 </mx:columns>
</mx:DataGrid>
</mx:Panel>
</mx:Application>

因为服务器返回的是JSON文本，我们无法使用<mx:XML>标签来取得数据。因此我们用的 是<mx:HTTPService>标签。它的工作原理跟<mx:XML>很像。你需要给它一个服务的URL，并且告诉它结果的 格式（比如文本）以及HTTP服务发回响应数据时需要调用的ActionScript方法。

在这个例子中，我为结果处理方法指定的是在<mx:Script>标签中定义的onJSONResult方法。这个方法会去掉所有空 格，并把 JSON文本传递给JSONDecoder对象。接着它将<mx:DataGrid>控件的dataProvider设置成 JSONDecoder返回的处理结果。

所有这些都是安全的，因为ActionScript不支持eval方法。JSONDecoder类是个简单状态机解析器，来实时地从文本构建出对象。最糟糕的情况可能是这样的过程会需要一段比较长的时间，如果JSON文本太大的话。

下面干什么

Flex是基于Flash的，而Flash可以跟任何技术进行交互。它可以直接与基于SOAP的web服务交互。它甚至能跟AMF（Adobe Message Format）这样的协议进行二进制数据的通信。

如果这是你第一次使用Flex，你可能会想着如何用Flex来构建一个Flash小部件，放到自己的网站上以更吸引人的方式来显示数据。为了确保 Flash应用的尺寸足够小方便下载，记得一定要使用新版本Flash播放器中的运行时共享库（Runtime Shared Library，RSL）。这可以让你在客户端缓存大尺寸的库（比如Flex库），并在不同的Flash应用中重用这些库。

Flex和Java是一个强大的组合。Java提供了优秀的的服务器后端支持。而Flex和ActionScript 3提供的是一个易于编写和采用的通用跨平台的GUI层。

查看英文原文：Flex for XML and JSON。

code2plan是由Jesse Johnston和Denis Morozov创建的一个敏捷软件项目管理工具，作为一款Visual Studio插件，其beta版已经免费发布了。该工具还能以独立应用的方式运行，可用来跟踪项目、迭代、用户故事、测试、缺陷及构建。

敏捷的软件项目管理正变得越来越流行，因此你也不会对另一个敏捷工具的出现而大惊小怪。该工具吸引人的地方在于其与Visual Studio 2008的集成，但它还能以独立应用的方式运行。要想运行该工具则需要.NET Framework 3.5 SP1，如果没有的话，那么在安装该工具时会自动安装。

当前code2plan会跟踪如下内容：项目、迭代、用户故事、特性、测试、缺陷及构建。该工具还可以通过跟踪阶段（而不是迭代）及需求（而不是故事）管理传统项目。它能够为这两类项目创建燃尽图。

code2plan可以使用自己的数据库，也能连接到团队的数据库，它同时支持SQL 2005及2008。通过使用团队的数据库，团队成员能共享项目并对其进行编辑。团队中的每个成员都可以更新当前视图以及时查看其它成员的修改。我们可以 离线编辑项目，一旦连接到网络上，这些改变就会自动地与团队进行同步。它对于团队成员的数量没有限制。

code2plan是免费的，也不需要注册和license。这个二人组打算将来发布一个功能更多的应用——很可能不再免费了，但他们承诺其基础版会一直免费下去。该项目并不开源，也不打算开源。不久他们会发布一个SDK，其他开发者可以借助其API来增强该工具。

Read a free sample chapter from each of these upcoming ASP.NET MVC Books

Programming ASP.NET MVC
by Alex Horovitz

多线程可以提高应用程序的效率，这是肯定的，但是，效率是不是最优的呢，是不是觉得多线程很复杂呢？
    前面学习线程的知道，用多线程需要CreateThread创建线程，还要关闭线程。另外，多线程有时候还要对资源进行同步，也就是说，需要用到事件，信标，互斥对象。
    当然，线程与进程比较，无论速度，对资源的访问，安全性上面线程都有非常大的优势。但是，创建与销毁线程并不是免费的。
    要创建一个线程，需要分配和初始化一个内核对象，也需要分配和初始化线程的堆栈空间，而且 Windows® 为进程中的每个 DLL 发送一个 DLL_THREAD_ATTACH 通知，使磁盘中的页分配到内存中，从而执行代码。当线程终止时，给每个 DLL 都发送一个 DLL_THREAD_DETACH 通知，线程的堆栈空间被释放，内核对象亦被释放（如果其使用数达到 0）。因此，与创建和销毁线程相关的许多开销都和创建线程原本要执行的工作无关。
    为了更优化效率，Windows提供了线程池的概念。
    线程池使创建，管理与撤销线程变得更容易。
    我觉得，线程池可以：
    *初始化线程，动态得创建线程。
    *预分配线程池的内存空间
    *优先级的排队
    *管理线程，撤销线程。
    Jeffer Richter在"CLR线程池"文章中讲到CLR中线程的特性：
    当 CLR 初始化时，其线程池中不含有线程。当应用程序要创建线程来执行任务时，该应用程序应请求线程池线程来执行任务。线程池知道后将创建一个初始线程。该新线程 经历的初始化和其他线程一样；但是任务完成后，该线程不会自行销毁。相反，它会以挂起状态返回线程池。如果应用程序再次向线程池发出请求，那么这个挂起的 线程将激活并执行任务，而不会创建新线程。这节约了很多开销。只要线程池中应用程序任务的排队速度低于一个线程处理每项任务的速度，那么就可以反复重用同一线程，从而在应用程序生存期内节约大量开销。

    那么，如果线程池中应用程序任务排队的速度超过一个线程处理任务的速度，则线程池将创建额外的线程。当然，创建新线程确实会产生额外开销，但应用程序在其 生存期中很可能只请求几个线程来处理交给它的所有任务。因此，总体来说，通过使用线程池可以提高应用程序的性能。

    现在您可能想知道，如果线程池包含许多线程而应用程序的工作负荷又在减少，将会发生什么事情。这种情况下，线程池包含几个长期挂起的线程，浪费着操作系统 的资源。Microsoft 也考虑到了这个问题。当线程池线程自身挂起时，它等待 40 秒钟。如果 40 秒过去后线程无事可做，则该线程将激活并自行销毁，释放出它使用的全部操作系统资源（堆栈、内核对象，等等）。同时，激活并自行销毁线程可能并不影响应用 程序的性能，因为应用程序做的事情毕竟不是太多，否则就会恢复执行该线程。顺便说一句，尽管我说线程池中的线程是在 40 秒内自行激活的，但实际上这个时间并没有验证并可以改变。

    线程池的一个绝妙特性是：它是启发式的。如果您的应用程序需要执行很多任务，那么线程池将创建更多的线程。如果您的应用程序的工作负载逐渐减少，那么线程池线程将自行终止。线程池的算法确保它仅包含置于其上的工作负荷所需要的线程数！

    线程池可以提供的功能：
    1.异步调用功能：一般我们调用函数都是同步的，即函数返回后，才执行下一句代码。但是，用线程池可以异步的调用我们的函数，调用后，马上执行下一句，至于线程的什么时候返回，是主线程所不知道的。
    另外，请注意，永远不要调用任何可以自己创建线程的方法； 如果需要，CLR 的线程池将自动创建线程，如果可能还将重用现有的线程。另外，线程处理回调方法后不会立即销毁该线程；它将返回到线程池并准备处理队列中的其他工作项。使 用System.Theading.TheadPool中的QueueUserWorkItem 会使您的应用程序更有效，因为您将不需要为每个客户端请求创建和销毁线程。
        例：下面写了一个线程池来实现异步调用的方法：
       

using System;
using System.Collections;
using System.Threading;

public class MyClass
{
    public static void Main()
    {
        Console.WriteLine("Main Thread:Queuing an aynchronous operation");
        ThreadPool.QueueUserWorkItem(new System.Threading.WaitCallback(MyAsyncOperation));
        
        Console.WriteLine("Main Thread:Performing other operation");
        Console.WriteLine("Main thread: Pausing to simulate doing other operations.");
        Console.ReadLine();
    }
    
    static void MyAsyncOperation(object state)
    {
        Console.WriteLine("ThreadPool thread:Perform aynchronous operation");
        Thread.Sleep(5000);
    }
}

    知道它的结果是什么吗？如果是传统的调用MyAsyncOperation函数，可以肯定得出结论，是输出：
    Main Thread:Queuing an aynchronous operation
    ThreadPool thread:Perform aynchronous operat
    Main Thread:Performing other operation
    Main thread: Pausing to simulate doing other operations
    但是，用了线程池，创建一个线程来执行这个函数，结果却大不一样。以下是执行结果的截图：
   
2.以一定的时间间隔调用方法：
    如果应用程序需要在某个时间执行某项任务，或者定时执行某个任务。那么，就使用线程池吧。
    System.Threading.Timer类可以为你构造这样的功能。函数原型如下：
   

public Timer(TimerCallback callback, Object state,   Int32 dueTime, Int32 period);
   public Timer(TimerCallback callback, Object state,   UInt32 dueTime, UInt32 period);
   public Timer(TimerCallback callback, Object state,   Int64 dueTime, Int64 period);
   public Timer(TimerCallback callback, Object state,   Timespan dueTime, TimeSpan period); 

    用户定义的线程函数可以这样定义：

public delegate void TimerCallback(Object state);

    我们写一下让线程池线程立即调用一个方法，并且每隔 2000 毫秒（或两秒）再次调用的应用程序。
    以下是程序：
   

using System;
using System.Collections;
using System.Threading;

public class MyClass
{
    static int Times=0;
    public static void Main()
    {
        Console.WriteLine("Checking for status updates every 2 seconds.");
        Console.WriteLine("Hit Enter to terminate the sample");
        Timer timer    =    new Timer(new TimerCallback(CheckStatus),"Timeing",0,2000);
        
        Console.ReadLine();
    }
    
    static void CheckStatus(object state)
    {
        Console.WriteLine("Checking Status:"+Convert.ToString(state)+" "+(Times++).ToString()+"'s");
    }
}

    以下是输出的截图：
   
3.当单个内核对象得到信号通知时调用方法
    Jeffer Richter文章中说到：

    Microsoft 研究人员在做性能研究时发现，许多应用程序生成线程，只是为了等待某单个内核对象得到信号通知。一旦该对象得到信号通知，这个线程就将某种通知发送给另一 个线程，然后环回，等待该对象再次发出信号。有些开发人员编写的代码中甚至有几个线程，而每个线程都在等待一个对象。这是系统资源的巨大浪费。因此，如果 当前您的应用程序中有多个线程在等待单个内核对象得到信号通知，那么线程池仍将是您提高应用程序性能的最佳资源。
    
    至于它应该怎么使用呢？
    要让线程池线程在内核对象得到信号通知时调用您的回调方法，您可以再次利用 System.Threading.ThreadPool 类中定义的一些静态方法。要让线程池线程在内核对象得到信号通知时调用方法，您的代码必须调用一个重载的 RegisterWaitHandle 方法
      它的原型如下：

public static RegisterWaitHandle RegisterWaitForSingleObject(
   WaitHandle h, WaitOrTimerCallback callback, Object state, 
   UInt32 milliseconds, Boolean executeOnlyOnce);

public static RegisterWaitHandle RegisterWaitForSingleObject(
   WaitHandle h, WaitOrTimerCallback callback, Object state, 
   Int32 milliseconds, Boolean executeOnlyOnce);

public static RegisterWaitHandle RegisterWaitForSingleObject(
   WaitHandle h, WaitOrTimerCallback callback, Object state, 
   TimeSpan milliseconds, Boolean executeOnlyOnce);

public static RegisterWaitHandle RegisterWaitForSingleObject(
   WaitHandle h, WaitOrTimerCallback callback, Object state,
   Int64 milliseconds, Boolean executeOnlyOnce); 

    第一个参数h表示你要等待的内核对象，第二个参数callback表示调用的用户线程函数，第三参数state是传递给用户线程函数的参数，第四个参数 milliseconds表示线程池内核对象得到信号通知前应该等待的时间，通常传递-1（就跟前面提到的函数WaitForSingleObject第 二个参数作用相同），表示无限超时。第五个参数executeOnlyOnce 为真，那么线程池线程将仅执行回调方法一次。但是，如果 executeOnlyOnce 为假，那么线程池线程将在内核对象每次得到信号通知时执行回调方法。
    客户端定义的函数原型：

public delegate void WaitOrTimerCallback(Object state,Boolean timedOut);

    当调用回调方法时，会传递给它状态数据和 Boolean 值 timedOut。如果 timedOut 为假，则该方法知道它被调用的原因是内核对象得到信号通知。如果 timedOut 为真，则该方法知道它被调用的原因是内核对象在指定时间内没有得到信号通知。回调方法应该执行所有必需的操作。
    看具体的代码：

using System;
using System.Collections;
using System.Threading;

public class MyClass
{
    public static void Main()
    {
        AutoResetEvent are = new AutoResetEvent(false); //自动事件对象
        RegisteredWaitHandle rwh = ThreadPool.RegisterWaitForSingleObject(
             are, new WaitOrTimerCallback(EventSignalled), null, –1, false);
          for (Int32 x = 0 ; x < 5; x++) 
        {
         Thread.Sleep(5000);
         are.Set();
          }

          rwh.Unregister(null);
          Console.WriteLine("Hit Enter to terminate the sample");
          Console.ReadLine();

    }
    
    static void EventSignalled(object state,Boolean timedOut)
    {
        if (timedOut) 
             Console.WriteLine("Timed-out while waiting for the AutoResetEvent.");
           else 
             Console.WriteLine("The AutoResetEvent became signalled.");
    }
}

执行如图所示：
   
Jeff的原文：http://blog.chinaunix.net/article.php?articleId=43400&blogId=5958

Jurgen Appelo上个月发表了一篇博客“敏捷团队当如群鸟飞”，他写到，“在敏捷软件开发中不应该限定规则，只应当做基本的限制”。
他开篇提出：

在组织中，人们总是试图通过引入某些规则来解决问题，例如，“在X情况下，你必须要做Y”。

我认为这绝不是最好的方式。规则应该是留给团队自己决定，你只需要设定一些限制就行了。

紧接着，他举了一个在计算机上为鸟群行为建模的例子，模拟鸟群的行为非常简单，只需要三条基本限制：

1. 不许离群
2. 不许相撞
3. 往一个方向飞

Jurgen Appelo认为，鸟群的行为可以很容易映射到软件开发团队上来：

1. 不要把自己孤立
2. 不要跟其他人打架
3. 与团队的方向保持一致

自然，这样几条简简单单的限制是无法保证能把事情做好的，但是给团队制定规则就能管用么？敏捷宣言中提到过：

鼓舞起每个人的积极性，以个人为中心构建项目，提供所需的环境、支持与信任。

最好的架构、需求和设计出自于自组织的团队。

团队会定期就如何更有效的工作进行回顾，继而调整行为。

那么，你有没有因为担心组织或者团队出现混乱，而从外部强加过多约束呢？

Jurgen Appelo接着说道：

在管理软件项目的时候，敏捷软件开发是一种很自然而然的方式。它设置了一些限制，如“跟客户协作”、“允许频繁的变化”、“只交付可以工作的成品”，剩下的规则就由团队自己选择。

……

这也表明，敏捷软件开发并不是天生就代表了结对编程、TDD、迭代……（注意，敏捷宣言根本没提到这些！）当然，这些实践很不错，但你要是想把它们当做固定规则来实施，你就……

当然，也就失去了敏捷的能力。

各位读者朋友，你对团队建设、团队管理持有何种态度呢？你有没有想办法组建自组织的团队？当团队能力和工作态度没有满足你的预期时，你采用了什么方式来提高生产效率，转变大家的心态？欢迎留下评论，与大家分享经验。

如果你有切实行之有效的实践经验，也欢迎为InfoQ中文站投稿，请mail至lijian[at]cn.infoq.com。

web Form 网页是基于HTTP的，它们没有状态， 这意味着它们不知道所有的请求是否来自
同一台客户端计算机，网页是受到了破坏，以及是否得到了刷新，这样就可能造成信息的
丢失。 于是， 状态管理就成了开发网络应用程序的一个实实在在的问题。
    在ASP中能够通过Cookie 、查询字符串、 应用程序、会话(Session) 等轻易解决这些问题。
现在在ASP.NET环境中，我们依然可以使用这些功能，并且功能更加强大。
  状态管理分为服务端和客户端两种情况， 这里只是介绍 服务端状态管理：

   与Application对象不同的是， ASP.NET 的Session对象可以在IIS服务器或者工作进程重新启动时
恢复启动前的状态而不丢失其中的数据。这是因为存储在Session中的所以信息都缺省的存储在
一个作为Windows服务运行的状态服务器进程中。状态可以被序列化并以二进制形式保存在内存中。
程序员可以悬着使用Microsoft SQL server数据库来存储数据。

 状态服务器服务和状态信息可以和web应用程序一起存在于同一台服务器上，也可以保存到外部的
状态服务器上。 为了指定如何存储信息，程序员可以在web.config文件中编写适当的配置。

  ASP.NET会话状态模块在Web.config文件中<System.web>标记下的<Sessionstate>标记的mode属性来决定
该属性的四种可能的值： Off、 Inproc StateServer 和SQLServer。
  
 1  Inproc是缺省的设置
 
它允许“无Cookie”的会话，以及在服务器之外存储
会话数据。ASP.NET会话状态模块在Web.config文件中像下面这样配置：

<sessionState mode="InProc" cookieless="false" timeout="20" />

在这个例子中，mode属性设为InProc（默认值），表明会话状态要由ASP.NET存储到内存中，而且
不用Cookie来传递会话ID。相反，会话ID要直接插入一个网页URL的查询字符串中。例如，采用
InProc模式并建立一个会话之后，调用一个假想的ASP.NET网页时，需要采用下面这样的URL：

http://my.website.com/(12mfju55vgblubjlwsi4dgjq)/education.aspx

圆括号中长长的字母、数字字符串就是会话ID。ASP.NET引擎从查询字符中提取会话ID，并将用户
请求与特定会话联系起来。采取这种方式，不管Cookie还是隐藏表单字段都用不着了。
所以，即使网页中没有使用表单，也能加入会话。

  但是这种方法，应用程序的状态将依赖于 ASP.NET进程， 当IIS进程崩溃或者正常重启时，保存在
进程中的状态将丢失。

 2 mode属性设为Off
 
   和从前的ASP一样，ASP.NET的会话状态管理是要产生开销的。所以，假如某个网页不需要访问
Session对象，开发者应将那个页的Page预编译指令的EnableSessionState属性设为False。
要为整个网站禁用会话状态，可在Web.config文件中将sessionState元素的mode属性设为Off。

   为了克服inproc 模式的缺点， ASP.NET 提供了两种进程外保存会话状态的方法。

 3 StateServer会话管理

  将mode属性设为StateServer，也就是将会话数据存储到单独的内存缓冲区中，再由单独一台机器上运行

的Windows服务来控制这个缓冲区。状态服务全称是“ASP.NET State Service ”（aspnet_state.exe），

它由Web.config文件中的stateConnectionString属性来配置。该属性指定了服务所在的服务器，以及要监

视的端口：
<sessionState mode="StateServer"
    stateConnectionString="tcpip=myserver:42424"
    cookieless="false" timeout="20" />
  
 在这个例子中，状态服务在一台名为myserver的机器的42424端口（默认端口）运行。要在服务器上改变

端口，可编辑HKLM\SYSTEM\CurrentControlSet\Services\aspnet_state注册表项中的Port值。
 
显然，使用状态服务的优点在于进程隔离，并可在Web farm中共享。 使用这种模式，会话状态的存储将不

依赖于iis进程的失败或者重启，然而，一旦状态服务中止，所有会话数据都会丢失。换言之，状态服务不

像SQL Server那样能持久存储数据；它只是将数据存储在内存中。

 4  用SQL Server进行会话管理
 
   ASP.NET还允许将会话数据存储到一个数据库服务器中，方法是将mode属性变成SQLServer。
在这种情况下，ASP.NET尝试将会话数据存储到由sqlConnectionString属性（其中包含数据源以及登录服

务器所需的安全凭证）指定的SQL Server中。
为了用恰当的数据库对象来配置SQL erver，管理员还需要创建ASPState数据库，
方法是运行WinDir\Microsoft.Net\Framework\Version文件夹中的InstallState.sql脚本（WinDir是服务

器的Windows文件夹，而Version是你使用的.NET框架版本的安装文件夹）。
要配置SQL服务器，可以在命令行中运行SQL Server 提供的命令行工具osql.exe

osql -S [ server name] -U [user] -P [password] <InstallSqlState.sql
例如
osql -S (local)\NetSDK -U sa -P "" -i InstallSqlState.sql

  在这里用户名必须是SQL服务器上的sa帐号，或者具有同等权限的其他帐号。有兴趣的读者可以打开
这个脚本文件来了解ASP.NET是如何和SQL Server配合实现状态管理的。
 
   卸载这些表和存储过程，可以使用UninstallSqlState.sql脚本，使用方法与上面类似。

做好必要的数据库准备工作后，将web.config 文件中的sessionstate 元素的mode改为"SQLServer"
,并且指定SQL连接字符串。具体如下：

 mode="sqlserver"
 sqlConnectionString="data source=127.0.0.1; userid=sa; password="

配置好SQL Server后，应用程序代码运行时就和InProc模式没有什么区别。但要注意的是，由于数据不存

储在本地内存，所以存储会话状态的对象需要进行序列化和反序列化，以便通过网络传给数据库服务器，

以及从数据库服务器传回。这当然会影响性能。通过在数据库中存储会话状态，可分别针对扩展性及可靠

性来有效地平衡性能。另外，可以利用SQL Server的集群，使状态存储不依赖于单个的SQL Server，
这样就可以为应用程序提供极大限度的可靠性。

WinWebMail,是一个比较轻量级的邮件服务器系统,适用于中小型企业的邮件系统,功能也比较齐全,关于它的详细介绍可参见官网地址:http://www.winwebmail.com/. 从网上去下载一个安装到机器上,我们公司服务器上安装的是WinWebMail 3.7.6.1 企业版,安装的时候它回自动生成网站文件目录,全部都是ASP的页面,在IIS里面创建一个虚拟目录指向该Web文件夹,按照他的一些说明配置好权限等, 这样我们就在网页使用它的邮件服务了.

它的Web客户端比较简洁,不过该有的功能还是都有.第一次用admin进去添加一个域,再 添加到一个用户进去,我们就拥有该域名的邮箱.注意,如果你这台机器并没有独立网络IP地址或者域名没有解析到你这里你也能添加域,比如我添加一个 microsoft.com的域,再到里面添加一个用户jonllen,那我登陆jonllen@microsoft.com用户,我也能以它的用户名发 送出邮件,呵呵,不过对方看到的应该是在垃圾邮件里面,因为现在一般邮件服务器都会判断邮件域名和发送的来源是不是同一个地方,不是同一个地方就认为是伪 造的垃圾邮件,而且对方回复你也不能收到,因为microsoft.com不是解析到你那里,先来看一张WinWebMail登陆后的截图.

发送邮件就只能在Web页面里面操作是往往不够的.比如系统自动发送邮件、定时群发邮件等这 些操作是不可能再跑到它的页面手工去发送,而应该要能在程序里调用他的接口进行发送邮件,而且最近可能会要开发一套OA,里面就要企业邮件,OA里注册一 个帐户就需要开一个邮件帐户,并且建立企业员工通讯录,邮件信息为内部相互通讯,且也能直接发送到外部邮箱,不过WinWebMail好象就提供接口方式 好象就是Web网页访问的形式而已,不过打开它里面的asp页面,我们能看到里面一些这样的代码.

懂asp的朋友都知道,它里面使用server.createobject是创建一个对象, 比如对数据的连接操作都是要用到server.createobject,而asp里面的变量是弱变量类型,变量无须声明就可以使用的,那么上面代码里面 server.createobject("easymail.InfoList")创建的是什么对象呢?突然想起来,WinWebMail它还有个 C/S的客户端界面,但是要到服务器上进去才能看到操作的,功能比较的简单,可以增加用户和配置域,还可以修改一些系统的设置,打开任务管理查看所有进 程,可以看到它其实是就是一个程序,你也可以关闭,但是还有一个名为emsvr的进程,它便就是WebWinWeb邮件系统的后台服务,最核心的地方还是在这里!那么它们之间是怎么实现相互调用的呢?细心的程序员很快就会想到是用COM组件,因为COM组件通过接口能方便的实现相互调用通讯甚至为不同的语言,在VS里面添加引用,选择COM组件,果然有WinWebMail的组件,如下图.

那么,上面server.createobject的就可以解释为创建调用的COM组件对象 了.既然有COM组件接口可以调用,那么就好办了.因为COM组件接口能跨任何语言调用,如果为标准的DLL组件的话,我们还可以使用非托管动态链接库的 方法进行引用,不过那好象你必须都要知道它的一些方法名和参数等.难道我去它的那些asp页面里一个个找出来不成?而且你没有相关文档还先得要搞清它的整 个页面逻辑,就算你都找到了那也不一定就是你要的方法名,那改如何是好呢?上面不是用VS来引用COM吗?没错!我们在项目里面添加 WebEasyMail的COM组件,VS会帮我们自动生成一个Interop.EASYMAILLib.dll文件到Bin目录,我们使用对象浏览器打 开,它里面的接口属性类一览如余.

我们要操作调用COM接口,那我们调用它生成的类即是,就是这么的简单,非常的方便.写代码 的话我们先实例化它里面的类,我们能看到类里面有很多的方法和属性.刚开始你可能会对它里面的一些属性和方法是干什么的不太明白.但是你可以打开它的 asp页面里的代码,先看下它调用的整个步骤,也许你就有一些思绪了.我为了做得通用,把一些常见的操作都用C#写成了WebService方法.我这里 贴出一个返回用户邮件夹信息(包括名称、总数量大小和新邮件数)的方法.

其他添加域、用户、收发邮件也能以次类推写出来,只不过你可能要参考它asp页面的一些方 法,调用正确才能返回结果.注意:它接口里面没有一个实体对象模型,里面所有的结果都是使用ref来赋值的,取多条结果则是通过for循环,它asp页面 里调用好象也都是这样做的.我的做的时候调试也是比较的郁闷.因为是本地在公司的一个局域网,我用上面写的那些方法竟然都调用不了,也没有报错,就是没有 结果返回,但是进它的asp网站里面操作又都行!害得我郁闷了好久.后来把代码传到服务器上,直接用WebService访问,竟然又行.那证明我写的那 些方法是没有错,那到底是那里有问题了呢?我现在还是不太明白.

不过既然能在服务器上运行就OK了,因为邮件服务器最终都将是要部署在服务器上的,这样我们 就也能把添加用户、企业通讯录、收发邮件的这样方法以WebService的方式提供出来,如果公司还有OA、ERP、人力资源管理系统等都可以方便的调 用,而且能统一域下用户管理,实现企业用户员工的邮件通讯.有需要使用邮件系统的朋友可以考虑使用WinWebMail.我这里提供一个 WinWebMailv3.7.6.1 企业版的破解版下载,仅供非商业用途学习测试使用,感兴趣的朋友可以来下载,正式使用请到官网购买付费版本.

WinWebMailv3.7.6.1 企业破解版下载