开发笔记 第813页

介绍Lucene知识比较全面的一个站
推荐：http://blog.tianya.cn/blogger/view_blog.asp?BlogID=114714&CategoryID=110243&idWriter=0&Key=0
具体教程：
[转]Lucene 中文分词的 highlight 显示
Lucene–基于Java的全文搜索引擎简介[转]
[lucene]关于对xml的lucene索引
[Lucene]用Lucene建立索引及查询示例

为自己的系统搞个全文搜索
 
在本文我又提到lucene了，在java业界，提到全文检索，几乎没有什么人不知道它。
用google搜索一下，满世界都是有关资料。具有代表性的就是车东的“基于Java的全
文索引引擎Lucene简介”，我要写的也就只有最简单的三板斧，再加上支持中文的
ChineseAnalyzer以及按照时间排序的搜索结果排序方法。这些都可以在其他地方找
到相关资料，我只是把他们提出来，作为lucence应用中经常遇到的麻烦解决办法。
去年MSN上面有个朋友跟我提到希望用lucene构建个网站的全文检索，我当时就觉得
很简单，直说没问题没问题，不过他提到一个要求就是搜索结果要安装时间排序，
我查阅了些资料，发现lucene并不提供用户自定义排序方式，而只能按照自己相关
性算法排序。后来我在车东的weblucene项目找到了IndexOrderSearcher。解决了结
果排序常规需求。IndexOrderSearcher跟一般IndexSearch使用差不多，仅仅在构建
对象的时候多加一个参数IndexOrderSearcher.ORDER_BY_DOCID_DESC
IndexOrderSearcher indexsearcher =
new IndexOrderSearcher("/home/lucenetest/index",IndexOrderSearcher.ORDER_BY_DOCID_DESC);
新版本的lucene还提供了一个MultiFieldQueryParser，可以同时检索多个字段，以前
QueryParser比较麻烦。

private  static  ChineseAnalyzer  chineseAnalyzer  =  new  ChineseAnalyzer();
public  Hits  search(String  queryText)
{
 if  (queryText  ==  null)
        {
         return  null;
 }
 Query  query;
   try
   {
         query  =  MultiFieldQueryParser.parse(queryText,  new  String[]{"title"},chineseAnalyzer);
        return  indexsearcher.search(query);
   }
   catch(Exception  e)
   {
        return  null;
   }
}
下面是构建索引，定时从数据库取出数据索引，做完记录完成时间，我是把时间写入一个txt文件。
package  com.test.search;
import  org.apache.lucene.analysis.Analyzer;
import  org.apache.lucene.analysis.cn.*;
import  org.apache.lucene.analysis.standard.StandardAnalyzer;
import  org.apache.lucene.document.*;
import  org.apache.lucene.index.*;

import  java.io.*;
import  java.SQL.*;
import  java.util.Date;

import  com.test.db.*;
import  com.test.utility.*;

/**
  *  Title:  SearchIndexer
  *  Description:  全文索引
  *  Copyright:      Copyright  (c)  2001
  *  Company:  test
  *  @author  Sean
  *  @version  1.0
  */
public  class  SearchIndexer 
{
    private  String  indexPath  =  null;
    protected  Analyzer  analyzer  =  new  ChineseAnalyzer();

    public  SearchIndexer(String  s) 
    {
        this.indexPath  =  s;
    }
    /**
      *  索引某日期以前的所有文档
      *  @param  fromdate
      *  @return
      */
    public  final  void  updateIndex(String  fromdate) 
    {
        Connection  conn  =  DbUtil.getCon();
        IndexWriter  indexWriter  =  null;
        try 
        {
             indexWriter  =  getWriter(false);
             //索引发布系统内部文件
                PreparedStatement  pstm  =  conn.prepareStatement(
                        "select  title,body,creationtime  from  document 
                        where  creationtime  >  '"  +  fromdate  +
                        "'  order  by  creationtime");
                ResultSet  rs  =  pstm.executeQuery();
                while  (rs.next()) 
                {
                    String  creationtime  =  rs.getString("creationtime");
                    String  title  =  rs.getString("title");
                    String  body  =  rs.getString("body");

                   
                    if  (title  ==  null  ||  body  ==  null) 
                    {
                        continue;
                    }
                    try 
                    {
                        addDocsToIndex(title,body,  creationtime,indexWriter);
                    }
                    catch  (Exception  ex) 
                    {
                        ex.printStackTrace();
                    }
              }
            indexWriter.optimize();
        }
        catch  (Exception  ex) 
        {
            ex.printStackTrace();
        }
        finally 
        {
            try 
            {
                indexWriter.close();
                conn.close();
            }
            catch  (Exception  e) 
            {
                e.printStackTrace();
            }
        }
    }
    /**
      *  检查索引文件是否存在
      *  @param  s
      *  @return  索引是否存在
      */
    private  boolean  indexExists(String  s) 
    {
        File  file  =  new  File(s  +  File.separator  +  "segments");
        return  file.exists();
    }
    /**
      *  增加一组索引
      *  @param  title
      *  @param  body
      *  @param  creationtime
      *  @param  indexwriter
      *  @return
      */
    private  final  void  addNewsToIndex(String  docid,  String  url,String  title,  String  body,
                                String  ptime,  IndexWriter  indexwriter)  throws IOException 
    {
        if  (indexwriter  ==  null) 
        {
            return;
        }
        else 
        {
            try 
            {
                Document  document  =  new  Document();
                document.add(Field.Text("title",  title));
                document.add(Field.Text("body",  body));
                document.add(new  Field("creationtime",  creationtime,  true,  true,  false));
                indexwriter.addDocument(document);
            }
            catch  (Exception  ex) 
            {
         ex.printStackTrace();
            }
            return;
        }
    }
    /**
      *  取得IndexWriter
      *  @param  flag  是否新建索引
      *  @return  IndexWriter
      */
    private  IndexWriter  getWriter(boolean  flag)  throws  IOException 
    {
        String  s  =  indexPath;
        if  (s  ==  null) 
        {
            throw  new  IOException("索引文件路径设置错误.");
        }
        indexPath  =  s  +  File.separator  +  "search";
        IndexWriter  indexwriter  =  null;
        if  (flag) 
        {
            try 
            {
                indexwriter  =  new  IndexWriter(indexPath,  analyzer,  true);
            }
            catch  (Exception  exception) 
            {
                System.err.println("ERROR:  Failed  to  create  a  new  index  writer.");
                exception.printStackTrace();
            }
        }
        else 
        {
            if  (indexExists(indexPath)) 
            {
                try 
                {
                    indexwriter  =  new  IndexWriter(indexPath,  analyzer,  false);
                }
                catch  (Exception  exception1) 
                {
                    System.err.println("ERROR:  Failed  to  open  an  index  writer.");
                    exception1.printStackTrace();
                }
            }
            else 
            {
                try  {
                    indexwriter  =  new  IndexWriter(indexPath,  analyzer,  true);
                }
                catch  (Exception  exception2) 
                {
                    System.err.println("ERROR:  Failed  to  create  a  new  index  writer.");
                    exception2.printStackTrace();
                }
            }
        }
        return  indexwriter;
    }

    public  static  void  main(String[]  args) 
    {
        String  lastUpdate  =  "/home/lucenetest/lastUpdate.txt";
        SearchIndexer  searchIndexer  =  new  SearchIndexer("/home/lucenetest/index");
        //取出上次更新时间
        String  str  =  Util.readTxtFile(lastUpdate);
        if(str==null  ||  str.length()==0)
        {
            str  =  new  java.util.Date().toString();
        }
        searchIndexer.updateIndex(str);
        //写入当前时间
        Util.writeTxtFile(lastUpdate,new  java.util.Date(),false);
    }
}

写个cmd或者sh在相应操作系统下面定时执行SearchIndexer就可以了

Microsoft SQL Server 2005 引入了新的 Transact-SQL 数据定义语言 (DDL) 语句，用来创建、实现和管理全文目录和索引。以下是新的全文搜索 DDL 语句的列表。
Create FULLTEXT CATALOG (Transact-SQL)
使用此语句可以为数据库创建全文目录。
Create FULLTEXT INDEX (Transact-SQL)
使用此语句可以针对数据库某个表的一列或多列创建全文索引。
Alter FULLTEXT CATALOG (Transact-SQL)
使用此语句可以更改全文目录的属性。
Alter FULLTEXT INDEX (Transact-SQL)
使用此语句可以更改全文索引的属性。
Drop FULLTEXT CATALOG (Transact-SQL)
使用此语句可以删除全文目录。
Drop FULLTEXT INDEX (Transact-SQL)
使用此语句可以从指定的表中删除全文索引。

———————————————————————————-

而以下是老旧的sql2000的方法:

———————————————————————————-
一个完整的SQL SERVER数据库全文索引的示例。（以pubs数据库为例）

首先，介绍利用系统存储过程创建全文索引的具体步骤：

1) 启动数据库的全文处理功能 (sp_fulltext_database)
2) 建立全文目录 (sp_fulltext_catalog)
3) 在全文目录中注册需要全文索引的表 (sp_fulltext_table)
4) 指出表中需要全文索引的列名 (sp_fulltext_column)
5) 为表创建全文索引 (sp_fulltext_table)
6) 填充全文目录 (sp_fulltext_catalog)

———********示例********————-
以对pubs数据库的title和notes列建立全文索引，之后使用索引查询title列或notes列中包含有datebase 或computer字符串的图书名称：

在这之前，需要安装Microsoft Search服务，启动SQL server全文搜索服务

user pubs –打开数据库
go
–检查数据库pubs是否支持全文索引，如果不支持
–则使用sp_fulltext_database 打开该功能
if(select databaseproperty('pubs','isfulltextenabled'))=0
execute sp_fulltext_database 'enable'

–建立全文目录FT_PUBS
execute sp_fulltext_catalog 'FT_pubs','create'

–为title表建立全文索引数据元
execute sp_fulltext_table 'title','create','FT_pubs','UPKCL_titleidind'

–设置全文索引列名
execute sp_fulltext_column 'title','title','add'
execute sp_fulltext_column 'title','notes','add'

–建立全文索引
–activate，是激活表的全文检索能力，也就是在全文目录中注册该表
execute sp_fulltext_table 'title','activate'

–填充全文索引目录
execute sp_fulltext_catalog 'FT_pubs','start_full'
go

–检查全文目录填充情况
While fulltextcatalogproperty('FT_pubs','populateStatus') <>0
begin

–如果全文目录正处于填充状态，则等待30秒后再检测一次
waitfor delay '0:0:30'
end

–全文目录填充完成后，即可使用全文目录检索

select title
form
where CONTAINS(title,'database')
or CONTAINS(title,'computer')
or CONTAINS(notes,'database')
or CONTAINS(notes,'database')

'————–以下介绍一下全文操作类的系统存储过程
过程名称：sp_fulltext_service
执行权限：serveradmin或系统管理员
作 用：设置全文搜索属性

过程名称：sp_fulltext_catalog
执行权限：db_owner及更高角色成员
作 用：创建和删除一个全文目录，启动或停止一个全文目录的索引操作

过程名称：sp_fulltext_database
执行权限：db_owner角色成员
作 用：初始化全文索引或删除数据库中所有全文目录

过程名称：sp_fulltext_table
执行权限：db_ddladnmin或db_owner角色成员
作 用：将一个表标识为全文索引表或非全文索引表

过程名称：sp_fulltext_column
执行权限：db_ddladnmin角色成员
作 用：指出一个全文索引表中的那些列假如或退出全文索引

现在网络上已经到处可以看到使用模板开发出来的网站。使用模板开发网站有很多好处，最主要的就是模板与程序完全脱离，用户可以根据规定好的标签任意开发模 板，导入到模板引擎里就能正常运行。所以美工人员跟程序编写人员彻底的独立了。提高了开发网站的效率，程序的重用性发挥的淋漓尽致。
    智能建站系统、速成网站、自助建站系统、只会打字就能做网站，等等广告字眼我们已经不再陌生了，所有的这些无非都是围绕着模板做文章。也正是因为 这样的系统越来越普及，对于要求不高的企业或者个人用户，拥有一个完全属于自己的网站，用现成的模板要比找网络公司定制省钱的多。性价比要高的多，所以目 前中小型网络公司的生存问题堪忧。
    提供模板做论坛的discuz公司，各位站长应该都很熟悉，但是做企业网站、独立购物网系统，国内做的比较好的几家公司，想必大家可能不太熟悉：ShopEx 、 携购网店系统（ShopXG） 、HiShop 、 狼烟网络(mynet.cn) 等等，大家有机会可以去他们的官网看看各自的优势。
    下面我们来详细讲解下如何开发网站模板。
    涉及到模板的部分我们可以分成以下几块：自定义标签、模板文件、数据控制项、模板引擎
    1. 自定义标签 自定义标签是模板文件与模板引擎之间交互的基础，也可以说是协议。 目前网络上普遍的标签样式为：{$****} {#*****#}，这样的表示方法，主要是为了区分html等脚本标签。 标签的内容区可以设置多种属性。比如len=100 表示数据长度不超过100个字节。 标签变量根据不同的类型，我们可以把名称规定为如下方式：
    {$var_**} 变量标签，表示这个标签的数据来源是某一个字段的值
    {$const_**} 常量标签，表示这个标签是一个常量数据，比如，当前的日期等
    {$temp_small} 小模板数据。（什么叫小模板，我们在后面详细讲解）
    {$page_**} 分页数据。例如首页，上页，下页等翻页的代码部分。等等。
    举例：{$var_news_title len=30} 表示显示新闻的标题，如果新闻标题的字数超过 30个字，那么截取。
    2．模板文件
    模板文件就是由美工人员开发的脚本代码，里面不涉及到任何程序。由于数据经常会涉及到一个循环显示的问题，所以我们把模板文件又分成：大模板、小模板。
    模板文件一般都是普通的html文件，源代码里包含了事先约定好的自定义标签，
    图标说明每个模块的共性：

    图1：新闻列表        图2：产品列表
    大家看上面两个模块，一个是新闻列表，一个是产品列表。无论从数据类型还是展现方式上乍一看截然不同。
    但是大家仔细的看一下，很容易看出来他们其实有很多共同的特点–他们都是有大模板（模块的外框部分）、小模板（模块的数据循环部分）组成。另外，大家可以去找个网站分解下看看。是不是都可以把他们分解成不同的模块，然后每个模块又可以分成大模板、小模板组成。
    我们以上图中新闻列表来给大家讲解下：
    大模板文件就是整个外框部分。基本html如下面所示：

	<div  class=”newslist”>
<h>携购网店 – 不可多得的创业好项目</h>
<ul>代理商加盟携购之后能得到什么?!</ul>
<div>{$temp_small}</div>
</div>

    从上面可以看出，大模板文件里并没有涉及到数据部分，只有一个小模板标签{$temp_small} ，当模板引擎解析到这个标签的时候，将对应的小模板文件解析后，用最终生成的html数据将该标签替换掉。
    接下来，我们来看一下小模板的组成:
    这里特别需要注意下，当模板引擎在解析小模板的时候，是把小模板的数据当作一个循环体，说明白些：比如有10条新闻，那么模板引擎将循环10次小模板数据，将具体的新闻内容分别去替换小模板里的标签，然后组合成一个最终的html.
    小模板的脚本部分：

	<ul  clas=”small_item”>
<li>{$var_news_title  len=100}</li>
<li>{$var_news_add_time}</li>
</ul>

    当然，需要分页的时候，还需要做分页模板，解析引擎会解析分页模板后，将查询到的当前数据替换掉对应的分页变量标签，最后，替换掉大模板中的分页模板标签。
    分页的脚本部分举例：

		<a href="{$var_link_firstpage_link}" id="modulelist_linkup_first">首页</a>
<a href="{$var_link_prevpage_link}" id="modulelist_linkup_prev">上一页</a>
{$var_link_pageteam} <a href="{$var_link_nextpage_link}" id="modulelist_linkup_next">下一页</a>
<a href="{$var_link_lastpage_link}" id="modulelist_linkup_last">末页</a>总数:{$var_link_totalnum} 每页条数:{$var_link_perpagecnt}
总页数:{$var_link_totalpage}当前页码:{$var_link_curpagenum}/{$var_link_totalpage}

    最后从结构上我们再总结下模板的组成关系：

    3．数据控制部分
    该部分是要将哪些数据展示在模板数据项的核心。主要包括以下几部分：
    a. 查询条件 ，从数据库里要查出哪些数据。
    b. 排序类型， 将查询得到的数据，通过何种方式进行排序展示。
    c. 当前页码， 跟每页显示条数配合使用，
    d. 每页显示条数。
    e. 是否忽略URL地址里传过来的参数，这个项非常重要，因为像分页和查询，他们都需要从url将参数传过来，而有些定死的数据又不希望受到url参数的影响，所以该项在控制数据显示方面尤为重要。
    f. 接受url的参数列表。等等.
    有了数据控制部分，才能让相同类型的模块展示不同的数据。
    4. 模板引擎
    我们知道模板文件是静态的html脚本页面，它并不具有业务操作能力，单纯的模板没有任何存在的意义。需要模板引擎通过数据控制将获取到的数据按照模板文件规定的样式展示出来，
    模板引擎的好坏，直接影响到整个程序的性能，模板要跟数据库打交道，由于模板文件有非常多的数据冗余，而且，设计不合理的模板，同个页面可能需要多次相同的数据库查询操作，如果模板引擎不能很好的区分出来。那么对数据库的压力也是非常大的。
    如果大家对开发模板网站有兴趣，强烈推荐去用下携购公司开发的VTEditor可视化网站模板开发系统。官方网站：http://www.xiegoo.com/ .是目前唯一真正实现可视化模板编辑的系统。

http://goosh.org

搜索引擎 创意 shell

主要功能：shell版的搜索引擎

自由言论：在web上用用shell也是一件挺有意思的事情，蛮有一种复古的感觉。感谢google提供这种shell检索的方式（help查看可用命令）。

页面截图：

前两天写了一篇立主机无限二级域名解释的方式，不过由于服务器出了点问题，自己比较忙，这篇就拖了点时间才写出来！

现在实现无限二级域名解释的方式，如重写url的组件也相当多！实现方式也不少！实现方式也不难。

独立主机的实现方法最简单的一个可以参考：http://www.cnblogs.com/flyboy/archive/2009/01/06/1369932.html

不过不幸的是所有这些都要求主机支持域名泛解析，一旦拿到虚拟主机上，一切都枉然！

我也是在自己机器上做好后拿到虚拟主机上发现完全作废！不过也不是没办法！

下面就讲讲如何实现虚拟主机上实现二级别域名解析(泛解析) (ASP.NET)吧！

1、首先，在域名解析里，要把*.iloveyou.io 隐含转向指向你网站的某个转门用来判断的页面，注意，必须是隐含！我们假设为 http://www.iloveyou.io/wr.aspx

2、在http://www.iloveyou.io/wr.aspx 页面取的来路的路径！

        protected void Page_Init(object sender, EventArgs e)
        {

          string    path = Request.UrlReferrer.AbsoluteUri.ToLower();

             。。。

         }

       这里取得的不是当前路径，而是来路路径，也就是转向前url的路径了！

       取得后就进行你需要的处理！ 用上一节的例子来讲，把 http://liangsan.iloveyou.io 解析到 http://www.iloveyou.io/love/?toName=liangsan 这个页面。

3、    用 Response.Redirect(newurl);来实现跳转~！

        protected void Page_Init(object sender, EventArgs e)
        {

            string path = Request.UrlReferrer.AbsoluteUri.ToLower();//得到的如path =http://liangsan.iloveyou.io/

             。。。

          string newurl=…//如 http://www.iloveyou.io/love/?toName=liangsan

          Response.Redirect(newurl);

         }

具体的例子可以上一个爱情表白的网站看下: http://www.iloveyou.io

缺点，不过这个方法有个缺点就是，百度收录页面看不到二级域名页面的内容，不利搜索引擎！

不过因为我没有自己独立主机，又要实现，用户可以申请 “心上人名字.iloveyou.io"的域名做为表白使用，只能放弃搜索引擎了！

不知道朋友你有没什么更好的解决方法，有的话请告知小弟！谢谢！

以上就是本人所知道和已经实现的虚拟主机上实现二级别域名解析(泛解析) (ASP.NET)，如有不足请指正！谢谢！

在进行ASP.NET调试的时候，我们经常需要借助一些外部工具来辅助我们。俗话说，工欲善其事 必先利其器。可别小看了这些工具，它是你解决复杂问题的必备利器。比较常用的有这些：

HTTP抓包工具： Microsoft Network Monitor，Fiddler2，HttpWatcher 等，主要用来查看HTTP消息的header，以及body。

代码查看器： Reflector，利用反编译来查看assembly里的代码。通过这个工具，我们可以很轻易的看到.NET Framework的一些功能是怎么实现的。

文件监视器： Process Monitor，可以用来监视系统的哪些文件正在被修改，注册表中有什么改动等等，功能非常强大。

数据库工具：SQL Sever Profiler，可以用来查看SQL Server正在执行哪些脚本。对于和SQL Server通信的程序的调试，它是非常实用的。
 

其实还有很多好用的工具，但是如果能熟练使用这几个工具了，大部分的问题都能轻易解决了。下次将会介绍一下IIS 7中调试ASP.NET程序的一些实用的方法。

原文：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。