置顶随笔
#
写在大学结束前：
可以说，我准备毕业设计的时间不短于一年，我选题的时候也是满怀“志向”，选题后我更是志气高昂。无赖于技术不够，实习不顺利，时间不够等原因，我自己也不能让我自己满意。不管我的答辩后的结果是什么，那只是别人一个评论，就像对考试成绩从不计算一样。四年来我很努力的读书，可以说是10来年的都很努力，毕业设计也是很想把他做好，而且我在大学里得到了很多人很大的帮助，比如毕业指导老师陈老师，任课老师章老师，公司的同事苏敏，还有我的同学陈纪律等人的帮助。他们的帮助可以说都是奇遇，可以说运气好的地上没有，天上才有的人。看到如此结束我的大学四年......(我也不知道自己在想什么)
今天怎么了，我本来心情很好的，上上网，找找资料，做做毕业设计，搞些新的技术，聊聊天，跟漂亮的同事说说话，，看看别人的空间
----------------------------------------------------------------------
妈妈:
好几次，想写点什么，却又不知从何说起。外婆的去世，给了妈妈一个沉重的打击。看着妈妈每天都那么辛苦的熬夜，忙碌。连哭泣都得忍着，因为外婆曾经跟妈妈说，孩子，你要乖，我死了以后别哭，我以后会在天上保佑着你的。妈妈确实做到了这点。外婆咽下了最后一口气以后，妈妈并没有大声哭，只是默默的流眼泪，她不想让外婆知道她在哭，所以她不能发出声音。我知道，要忍着哭很难，妈妈的心里肯定已经在号啕大哭，可她没表现出来，因为外婆躺在大嫂家的楼下。看着老妈在那里含着泪水的样子，我感觉好心疼，看着外婆躺在那边的样子，我的眼泪也不能控制的流了出来，不过我没出声。因为妈妈说，要让外婆走的安心一点。他们说在24小时之内，我外婆还是可以听见我们的声音的。对于这些我很迷惑，我不知道这些是真是假，不过我相信宁可信其有，不可信其无。何况我也好想念我的外婆，曾经我是那么的喜欢跟她一起睡。
原来人死后要经过那么多的仪式，尤其是我们这些信佛教的家族。经过了10来天的忙碌，念经，跪拜，守灵，火葬，上山，跪拜，念经，酒席，念经。我的体力都有点吃不消了，不是发烧就是感冒。妈妈也把嗓子给哭哑了。老爸总是那么的不懂事，让老妈也添了几分愁。我知道她的心里很难受，却总是装着自己很坚强。记得有一次，那时候外婆正好住院，而爸爸也因意外受了伤，而且还是在外地。妈妈很焦急，一方面是因为不能丢下外婆不管，一方面又很担心爸爸。都哭出来了。这是我第二次看见我妈在我面前哭，她跟我讲了好多好多，让我感觉到了她身上的沉重和无奈，让我知道了原来家里的重担给她心理造成了很大的压力。那时候我真的好希望自己能赚好多好多的钱，可以让妈妈轻松一点。我也终于体会到了为人女，为人妻，为人母的辛苦。老妈还跟我开玩笑说，如果找不到好的男人，就别嫁了，一个女人是可以养得起自己的。不然的话，苦的还是自己。我不知道妈妈说这些话的时候是什么样的心情，也许这是她自己的心理写照吧。
---------------------------------------------------------------来自网上qq空间
15年多了啊，15年多了，很小就想写一些，但从没在作文，或者什么地方写过什么，看到这篇文章后，今天实在忍不住了，我哭了，我不记得什么哭过了，我一直以为我是个坚强的人。
现在想想，15前，我是多么的幸福啊，只是......
当时我才8岁不到，1米来高，老爷爷门下四兄弟,没有姐妹,我最大,我每天起来第一件事就是去我老爷爷房里拿哪个半边橘子,我老爷爷当时86了，水分不好，牙也不好,所以吃点橘子,他一天开一个橘子,吃半边,剩半边放在藤椅上,用扇子盖着,等着我第二天早上去拿,我的记忆中，这样的日子过了不长,我老爷爷突然不行了,再也没起来，一个礼拜后,92年的正月初2早上5点半走了，我在睡梦中被我爸妈吵醒,我就知道我老爷爷已经走了，只是我不明白他为什么不让我爸妈叫醒我，"别叫醒孩子们,大过年的，让他们好好睡.",这是他留给我四兄弟的唯一遗言.
时间过了很多年,我越来越想念我老爷爷，老缠着我爷爷奶奶,爸爸妈妈讲我老爷爷的事.我也知道了些,比如老爷爷一个人无田无地的养活10几个人,累的吐血,昏倒在田里，文化大革命,买房子救自己的被国民党抓去的弟弟,等等，还讲我小时候贪玩,满地爬,在地上检鸡屎吃,而老爷爷80高龄抱不了,气的直哆嗦,而我却大笑.讲我喜欢偷老爷爷的脉奶精吃,没吃却浪费了,老爷爷却舍不的说我们.现在想想我是多么的幸福啊.
已经过了15年了，我虽不能每年去扫墓,但我每年清明节晚上都去外面走走，希望,老爷爷在 天上可以看到,他曾疼爱的我,现在过的很幸福。当我有了家,带我的家人一起去扫墓.和他谈谈心。说说我的这些年。
这两天在搞一个repeater中放一个checkbox, 非常想实现在服务器端自动的搜索他，并验证，用foreach +FindControl 实现，解决了一个问题，又出现了新问题，一但递交给服务器，repeater的数据重新绑定了，checkbox复原了，还要给他一个变量组，记录他的状态，用一个隐藏asp:label记录id，但他的值也是要复空的，用text=""，强行附值，才可以得到，不大愿意用js获获得数据，再用window.location.href("asp.aspx?id="+id+"&page"=page)传递数据，再跳转回来，绑定到page页，找了很多checkbox方面的资料，最后还是没成功，当然用datagrid是很好实现的。实验后才有了自己的想法，真的需要跳转吗？真的需要服务器控件，要服务器响应，不停的刷新吗？用ajax不是把所有的问题都解决了吗？更新后刷新一下就什么也解决了啊，当时怎么就没想到啊，我做的程序不多，没什么经验，知道的东西也是少之又少，但我以为还好的方法。如果有人知道更好的方法，请指教啊，我当是抛砖引玉了。
小弟刚开始学习，大学时间全浪费了（当然不能怨任何人，是我太不用功了，），转眼就毕业了，呵呵，都毕业的人了，计算机还没入门，希望各位高手，走过，路过，如果有什么建议，意见，或者我的blog上的错误，留下点余香，对我来说是一生受用，下世也不忘怀。如果有人能留下联系方式，比如QQ,Msn，E_Mail。有问题能直接找到你，教导我，小弟感激不尽，小弟在此谢过了,在此说明，本人blog几乎全部来自网络，极少数是自己写的，我习惯不好，没有表明出处，在此表示歉意。小弟QQ:407521952
2010年4月26日
#
-----------------热键注册类
using System;
using System.Collections.Generic;
using System.Text;
using System.Windows.Forms;
using System.Runtime.InteropServices;
namespace Workflow.Frame
{
/// <summary>
/// 热键注册类
/// </summary>
public class HotKey
{
//如果函数执行成功，返回值不为0。
//如果函数执行失败，返回值为0。要得到扩展错误信息，调用GetLastError。
[DllImport("user32.dll", SetLastError = true)]
public static extern bool RegisterHotKey(
IntPtr hWnd, //要定义热键的窗口的句柄
int id, //定义热键ID（不能与其它ID重复）
KeyModifiers fsModifiers, //标识热键是否在按Alt、Ctrl、Shift、Windows等键时才会生效
Keys vk //定义热键的内容
);
[DllImport("user32.dll", SetLastError = true)]
public static extern bool RegisterHotKey(
IntPtr hWnd, //要定义热键的窗口的句柄
int id, //定义热键ID（不能与其它ID重复）
KeyModifiers fsModifiers, //标识热键是否在按Alt、Ctrl、Shift、Windows等键时才会生效
KeyModifiers vk, //定义热键的内容
Keys vkk
);
[DllImport("user32.dll", SetLastError = true)]
public static extern bool UnregisterHotKey(
IntPtr hWnd, //要取消热键的窗口的句柄
int id //要取消热键的ID
);
//定义了辅助键的名称（将数字转变为字符以便于记忆，也可去除此枚举而直接使用数值）
[Flags()]
public enum KeyModifiers
{
None = 0,
Alt = 1,
Ctrl = 2,
Shift = 4,
WindowsKey = 8
}
}
}
-----------------------from中注册，及消息处理方式-------
private void MainForm_Activated(object sender, EventArgs e)
{
//注册热键Shift+S，Id号为100。HotKey.KeyModifiers.Shift也可以直接使用数字4来表示。
HotKey.RegisterHotKey(Handle, 100, HotKey.KeyModifiers.Shift, Keys.S);
//注册热键Ctrl+B，Id号为101。HotKey.KeyModifiers.Ctrl也可以直接使用数字2来表示。
HotKey.RegisterHotKey(Handle, 101, HotKey.KeyModifiers.Ctrl, Keys.B);
//注册热键Alt+D，Id号为102。HotKey.KeyModifiers.Alt也可以直接使用数字1来表示。
HotKey.RegisterHotKey(Handle, 102, HotKey.KeyModifiers.Alt, Keys.D);
//注册热键Alt+D，Id号为102。HotKey.KeyModifiers.Alt也可以直接使用数字1来表示。
HotKey.RegisterHotKey(Handle, 103, HotKey.KeyModifiers.Ctrl|HotKey.KeyModifiers.Alt, Keys.X);
}
private void MainForm_Leave(object sender, EventArgs e)
{
//注销Id号为100的热键设定
HotKey.UnregisterHotKey(Handle, 100);
//注销Id号为101的热键设定
HotKey.UnregisterHotKey(Handle, 101);
//注销Id号为102的热键设定
HotKey.UnregisterHotKey(Handle, 102);
}
///
/// 监视Windows消息
/// 重载WndProc方法，用于实现热键响应
///
///
protected override void WndProc(ref Message m)
{
const int WM_HOTKEY = 0x0312;
//按快捷键
switch (m.Msg)
{
case WM_HOTKEY:
switch (m.WParam.ToInt32())
{
case 100: //按下的是Shift+S
//此处填写快捷键响应代码
break;
case 101: //按下的是Ctrl+B
//此处填写快捷键响应代码
break;
case 102: //按下的是Alt+D
//此处填写快捷键响应代码
break;
case 103: //按下的是Alt+D
//此处填写快捷键响应代码
break;
}
break;
}
base.WndProc(ref m);
}
2009年8月12日
#
1.1. 概要
分析如何使用微软提供的ASP.NET来对动态产生的URL地址进行网址重写。网址重写是实现一种截取网址请求并将其进行处理后重新指向到一个指定的网址的过程。作者本人在对各种实现网址重写的技术进行研究和探讨后得出的经验和方法，希望能对您有所帮助。
1.2. 内容简介
稍微花点时间看一看你做的网站里头的URL地址，你看到类似这样的地址吗http://yoursite.com/info/dispEmployeeInfo.aspx?EmpID=459-099&type=summary ？也许你会出于某种目的把大量的页面文件从一个目录甚至一个网站转移到其他地方，而许多访问者出于个人兴趣或者研究目的之前就已经将原有网址收藏了起来， 如果这时他从收藏夹打开该页面的时候发现这已经是坏链了。本文旨在介绍如何使用网址重写将那些“难看”的网址转换成比较有实际意义的网址，使其便于记忆。例如将http://yoursite.com/info/dispEmployeeInfo.aspx?EmpID=459-099&type=summary转换成如下地址：http://yoursite.com/ dispEmployeeInfo/459-099/summary.html 。我们甚至发现网址重写技术可以解决令人头疼的404错误，或者说它可以创建一个智能化的404错误解决方案。
如上所述，网址重写是实现一种截取网址请求并将其进行处理后重新指向到一个指定的网址的过程。在网址重写执行的期间，相应处理程序处理被请求的网址，从中提取出相关的值，然后重新指向一个新的指定地址。例如：由于一次网站目录调整，原有的 /people/ 子目录下的所有网页全部移动到/info/employees/目录，原访问者从收藏夹或者其他什么地方点击链接发出访问/people/目录下的文件的请求时，你肯定希望他还是能通过原有地址看到和原来相同的页面，但实际上看到的却是网址重写指向的新目录下的相应文件。
在老版本ASP中，使用网址重写技术的途径很少，要么写一个ISAPI过滤器，要么购买第三方厂商提供的网址重写组件，然而在微软提供的ASP.NET下你可以通过多种方法很简单地开发出自己的网址重写软件，以满足自己各种不同的需要。本文将和你一起讨论这门针对ASP.NET开发人员的实现网址重写的技术，然后举一些网址重写实际应用的例子。在我们深入探讨网址重写技术的细节之前，我们先看一下日常使用网址重写技术实现的场景。
1.3. 网址重写的一般用途
创建一个数据操作的ASP.NET程序最常见的就是一个aspx页面后面带上一些查询参数集合。例如在设计一个电子商务网站的时候，假定你设计了一项功能允许用户浏览待售的商品，为了更加方便操作，你设计了一个页面displayCategory.aspx将商品按照给定的分类显示，那么该分类下的商品显示页面上应该在页面文件对应网址后面加上了一个商品分类的查询参数，例如用户要查询待售的“装饰品”，在数据库中所有的装饰品数据对应的分类编号CategoryID的值为5，那么用户会访问如下网址：http://yoursite.com/displayCategory.aspx?CategoryID=5。
创建一个包含类似这样网址的网站最终有两种结果，首先从最终用户的角度来观察，http://yoursite.com/displayCategory.aspx?CategoryID=5 这个网址有些杂乱，可行性分析专家Jakob Neilson（主页：http://useit.com/） 建议选择网址显示方式时候考虑如下要求（参考网址：http://www.useit.com/alertbox/990321.html）：
● 是否简短
● 是否易于输入
● 是否将站点结构形象化
● 是否具有隐蔽性，也就是让用户通过一个虚拟的看似有意义的导航地址访问指向该地址
我想还应该在上述列表中再增加一条：是否便于记忆。http://yoursite.com/displayCategory.aspx?CategoryID=5 这个地址没有一个地方符合Neilson标准的任何一条，也不便于记忆。当然，对于有经验的网络开发专家来说，他们很熟悉这种键值对构成的查询参数结构体系，然而对于普通用户来说输入这些带有参数的网址实在是太麻烦了。
一种较好的方法就是使用一种比较直观且容易记忆的方式来将网址表示为：http://yoursite.com/products/Widgets 乍一看很容易就会推断这个网址所对应的内容极有可能会是显示装饰品（Widgets）信息，这个网址就变得更加容易记忆和传播！然后我告诉我的同事：“请查看这个网址：http://yoursite.com/products/widgets ”不用我说第二遍，她可能一次就把地址敲到浏览器上了（你也可以在亚马逊（Amazon.com）的网站上这样尝试一下）。很快就浏览器上就列出了装饰品（Widgets）的内容。这里“隐蔽性”表示：用户可以自行变更网址的结尾，例如输入：http://yoursite.com/products 就能看到全部分类相关的商品列表或者列出所有相关商品分类目录列表。
注：用上述简单的变更网址内容的方法来构思一下如今的比较流行的Blog网站生成的网址。例如：要查询2004年1月28日所发的帖子，只需输入 http://someblog.com/2004/01/28 即可，如果将网址裁减为 http://someblog.com/2004/01 则显示 2004年1月份的帖子 ，同样将月份裁减掉得到 http://someblog.com/2004 则显示出2004年全年所发的帖子。
网址重写技术除了用于将复杂的网址简单化之外，它还能用于处理因网站目录调整或者其他原因导致产生大量的无效链接和过期书签。
1.4. 当一个Web请求传送到IIS会发生什么？
在探讨如何实现网址重写这项技术之前，很有必要了解一下IIS是处理所接收的Web请求的机制。当一个Web请求到达IIS Web服务器时，IIS会根据所请求的文件后缀名来决定如何处理该请求，IIS可以处理诸如HTML页面、图片、静态内容，或者将请求转发给ISAPI应用程序，由该ISAPI应用程序处理后生成HTML静态内容返回给IIS，最后由IIS将请求结果发送回给客户端。（一个ISAPI应用程序就是一套编译好能随时在后台运行的类库，它的任务就是根据请求生成相关的内容。）
例如：如果IIS接收到一个对Info.asp的请求，它会将该请求转交给asp.dll来处理，该ISAPI应用程序调出并执行所请求的ASP页面，然后把生成的HTML代码返回给IIS，IIS最后把内容发送回请求客户端。对于ASP.NET页面，IIS则将请求转交给名为aspnet_isapi.dll的ISAPI应用程序来处理，该ISAPI应用程序调用托管的ASP.NET工作进程来处理该请求，并将生成的HTML代码返回给请求客户端。
你可以自定义IIS，将某一类扩展名映射到指定的ISAPI应用程序，图一显示了IIS管理工具中的应用程序配置对话框。
图一．已配置的文件扩展名映射
关于对IIS如何管理所接收的请求的详细探讨有些超出本文内容，想了解的更详细的话可以参考Michele Leroux Bustamante的著作Inside IIS and ASP.NET（深入研究IIS与ASP.NET），重要的是要了解ASP.NET引擎只负责处理对扩展名已经被正确配置映射到aspnet_isapi.dll的网络请求。
1.5. 用ISAPI过滤器来分析请求
除了将请求的文件扩展名映射到相应的ISAPI应用程序外，IIS还执行一些其他工作。例如IIS还主动对发出请求的客户端用户进行授权，并判断已授权用户是否对其请求的文件拥有访问权限，在一个请求过程的全部生命期内，IIS的处理经历了几个阶段，在每一个阶段IIS都生成一个事件，而该事件可以被ISAPI过滤器实时操控的。
如同ISAPI应用程序一样，ISAPI过滤器也是一块块安装在Web服务器上的非托管代码。ISAPI应用程序用于对所接收的特定文件类型做出响应，而ISAPI过滤器含有对IIS生成的事件做出响应的代码（contain Code），甚至可以编辑进出的数据。ISAPI也含有众多应用程序，包括：
· 权限控制与授权（Authentication and Authorization）
· 日志记录与监视（Logging and Monitoring）
· HTTP内容压缩（HTTP Compression）
· 网址重写（URL Rewriting）
本文所探讨的用ASP.NET实现的网址重写技术就是基于ISAPI过滤器用于网址重写的技术内容，然而我们仍然要讨论一下究竟是使用ISAPI过滤器还是使用ASP.NET应用程序提供的技术来实现网址重写技术。
1.6. 当一个请求传入ASP.NET引擎的时候会发生什么？
ASP.NET问世之前，在IIS Web服务器上的网址重写功能需要通过ISAPI过滤器来实现，自从这个家伙问世后我们就能通过ASP.NET来实现URL重写了，因为ASP.NET的解释引擎与IIS有极大的相似之处，产生这些相似性主要是因为ASP.NET：
· 在处理接收的请求的生命期内也会产生事件；
· 允许任意数量的HttpModule操控产生的事件，这与IIS中的ISAPI过滤器类似；
· 将请求的资源委托给HttpHandler处理，这与IIS中的ISAPI应用程序类似。
和IIS一样，在一个请求的整个生命期内，ASP.NET对该请求的处理状态发出的状态改变信号引发相应的事件。例如：BeginRequest事件在ASP.NET开始响应客户端请求之始引发；AuthenticateRequest事件在ASP.NET确立用户身份后引发，当然还有诸如AuthorizeRequest，ResolveRequestCache和EndRequest等其它很多事件，这些都是System.Web.HttpApplication类下的事件，更多信息请参考技术文档中的类HttpApplication概要（HttpApplication Class Overview）。
如上所述，可以创建ISAPI过滤器并用于相应IIS引发的事件，同理，ASP.NET也提供了HttpModule用于响应ASP.NET引擎引发的事件，一个ASP.NET应用程序通过配置可以拥有多个HttpModule。ASP.NET引擎每处理一个请求，便初始化一个相应配置好的HttpModule，并允许它针对请求处理期间引发的事件生成相应的事件委托。事实上ASP.NET引擎处理每一个请求调用大量的事件委托。FormsAuthenticationModule就是众多内嵌HttpModule中的一个，它首先检查是否使用表单授权，如果是的话，它将检查用户是否已授权，如果没有授权则自动把用户重定向到指定的登录页面。
回忆在IIS中，一项请求最后被转交给一个ISAPI应用程序处理，该应用程序针对每一项请求进行处理并返回相应的数据。例如，客户端发出一个访问经典ASP页面的请求，IIS将该请求转交给asp.dll程序处理，asp.dll针对该请求执行asp页面内容，并返回HTML编码。ASP.NET也使用了类似的手法，ASP.NET引擎在将这些HttpModule初始化后，判断并决定调用相应的HttpModule来处理该请求。
所有通过ASP.NET引擎解析的请求最终被送交一个HttpHandler或者HttpHandlerFactory（一个HttpHandler只是简单地返回一个用于处理该请求的HttpHandler的实例。）最终的委托呈现并响应所请求的HTML编码，并发送回IIS，IIS则将HTML返回给请求客户端。
ASP.NET包含许多HttpHandler，例如，PageHandlerFactory是用于呈现ASP.NET页面内容，WebServiceHandlerFactory用于呈现ASP.NET Web服务的SOAP数据包，TraceHandler用于将ASP.NET请求资源的HTML标记写入trace.axd。
图二描绘了一个针对ASP.NET资源的请求所经过的处理流程。首先，IIS接收到该请求并将其转交给aspnet_isapi.dll。其次，ASP.NET引擎将一些HttpModule初始化。最后，最终的HttpHandler被调用，生成相应的标记语言，并将其返回给IIS，最终返回到请求客户端。
图二．IIS和ASP.NET对请求的处理过程
1.7. 创建并注册自定义HttpModule和HttpHandler
创建自定义HttpModule的工作相对较简单，它包括一个实现当前接口的托管类，HttpModule必须实现System.Web.IHttpModule接口，同样HttpHandler和HttpHandlerFactory必须分别实现System.Web.IHttpHandler接口和System.Web.IhttpHandlerFactory接口。有关创建HttpHandler和HttpModule的细节已经超出本书范围，要了解更多详情请参阅Mansoor Ahmed Siddiqui的文章《HttpHandlers and HTTP modules in ASP.NET》（ASP.NET中的HttpHandler和HttpModule）。
一旦HttpModule和HttpHandler被创建后，必须向Web应用程序注册。如果要向整个Web服务器HttpModule和HttpHandler只需简单的写入machine.config文件；如果是由指定的Web应用程序调用则需在该程序的web.config配置文件中添加几行XML标记。
例如，要向指定的Web应用程序注册HttpModule和HttpHandler，只需向该Web应程序的web.config配置文件中configuration\System.Web节中添加下列几行：
<HttpModules>
<add type="type" name="name" />
</HttpModules>
其中type属性为HttpModule的标识号和类库名称，name属性则为该模块取一个较为友好的名称方便在Global.asax调用。
HttpHandler和HttpHandlerFactory则是在web.config文件中configuration\System.Web节中添加<httpHandler>标记，例如：
<httpHandlers>
<add verb="verb" path="path" type="type" />
</HttpModules>
回忆上文，ASP.NET对每一个接收到的请求指派相应的HttpHandler来处理并呈现相应内容，该指派决定于所接收请求的verb和path的内容，verb为HTTP请求的类型：GET或者POST，path则为请求的文件的路径和文件名。如果我们打算用一个HttpHandler来处理所有GET类型和POST类型的并且文件扩展名为.scott的内容，可以在web.config相应配置节中加入下列标记：
<httpHandlers>
<add varb="*" path=".scott" type="type" />
</httpHandlers>
其中type是我们定义的HttpHandler的类型。
注意：在注册HttpHandler的时候必须注意HttpHandler所使用的文件扩展名必须已经在IIS中做指向ASP.NET引擎的映射，在上面.scott扩展名的例子中，如果我们所使用的.scott扩展名如果没有在IIS中做指向ASP.NET引擎的映射的话，假定对foo.scott文件发出请求，该请求将导致IIS将foo.scott文件内容直接呈现给客户端，为了能够让HttpHandler处理该请求，必须将.scott扩展名在IIS中做指向ASP.NET引擎的映射，之后IIS才能正确地将.scott的请求转交给相应的HttpHandler。
有关HttpModule和HttpHandler更详细的内容请参阅MSDN中<HttpModules>节和<httpHandlers>节的文档信息。
<HttpModules>文档参考；
<httpHandlers>文档参考。
1.8. 实现网址重写
网址重写技术不但可以在IIS Web服务器一级通过ISAPI过滤器实现，而且还可以在ASP.NET一级通过HttpModule或者HttpHandler实现。本文主要关注在ASP.NET一级实现网址重写技术，所以此时不必关注在ISAPI应用程序中实现网址重写的技术细节，而且有很多第三方厂商提供的ISAPI过滤器，比如
Helicon的ISAPI Rewrite；
QwerkSoft的IIS Rewrite；Port80的PageXChanger；
等等。
1.9. 构建网址重写引擎
在ASP.NET中实现网址重写很简单，只需调用System.Web.HttpContext类的RewritePath()方法即可。HttpContext类中包含有关于特定HTTP请求的HTTP规范信息。ASP.NET引擎每接收到一个特定请求后便针对该请求创建一个特定的实例，这个类包含一些属性诸如：Request和Response属性，分别提供对请求和响应的访问；Application和Session属性提供对Application变量和Session变量的访问；User属性提供对已授权用户信息的访问。
在微软.NET Framework 1.0版本中，RewritePath()方法接收一个新路径的简单字符串，在其内部HttpContext类的RewritePath(string)方法内在地更新Request对象的路径和查询参数。除了RewritePath(string)方法之外，.NET Framework 1.1版还提供了另外一些重载版本，其中一个重载版本接收三个输入字符串参数，这种交替的重载形式不仅仅只是设置Request对象的路径和查询参数这些属性，而是设置更深层的成员变量，这些成员变量用于为PhysicalPath、PathInfo、FilePath属性计算Request对象值。
为了实现ASP.NET中的网址重写，我们需要创建一个HttpHandler和HttpModule用于：
? 根据请求的路径决定所需要重写的路径；
? 重写路径，如果需要的话可以调用RewritePath方法；
以前文所构建的那个站点为例，可以通过/info/employee.aspx?empID=EmployeeID来访问每一个雇员的信息。为了使这个网址更加地具有“隐蔽性”，我们可能会使用更加容易理解的访问方式如：/people/雇员名.aspx。这里就有了一个网址重写的案例：当接收到对/people/ScottMitchell.aspx的请求的时候，我们就得使用网址重写使得对该页面的请求被重写指向到先前使用的/info/employee?EmpID=1001地址。
1.10. 使用HttpModule来调用网址重写
在ASP.NET一级来执行网址重写，既可以使用HttpHandler，也可以使用HttpModule。当使用HttpModule的时候，必须决定如果该网址需要被重写的话，究竟应该在整个请求的生命周期期间的那一个点来使用。乍一看着有些武断，但是这个决定以重大而且微妙的方式影响到你的应用程序。之所以作出对网址重写点的选择是因为内嵌的ASP.NET HttpModule使用Request对象的属性值来完成自己的工作（回忆一下重写路径对Request对象的属性值的改变），这些内嵌HttpModule和相应事件的密切关系列举如下：
HttpModule 事件 简介
FormsAuthenticationModule AuthenticateRequest 判断用户是否已通过表单授权方式获取授权，如果没有的话则将用户重定向到指定的登录页面
FileAuthorizationModule AuthorizeRequest 当使用Windows授权方式的时候，该HttpModule判断并确定该Microsoft Windows帐户是否对其请求的资源拥有足够的权限
UrlAuthorizationModule AuthorizeRequest 检查并确认请求者是否对所访问的网址拥有权限。该Url授权可以在web.config文件的<authorization>和<location>元素中配置
回想一下BeginRequest事件在AuthenticateRequest事件之前引发，而AuthenticateRequest事件又在AuthorizeRequest事件之前引发。
实现网址重写的一个较为安全的场合就是把它放在在BeginRequest事件中执行，这意味着如果要执行网址重写的话，在众多内嵌HttpModule运行的时候他已经完成了。这种途径的最终用途淋漓尽致地体现在表单验证上。当用户访问受限资源的时候，如果之前使用了表单验证，他会自动被重定向到指定的登录页面，在成功登录之后，用户被重定向回先前试图访问的受限制页面。
如果把网址重写放在BeginRequest事件或者AuthenticateRequest事件中，在登录页面上执行提交后，该页面会将用户重定向到网址重写指定的页面。假定当用户在浏览器上敲入/people/ScottMitchell.aspx地址，该地址是要被重定向到/info/employee.aspx?EmpID=1001的，如果该Web应用程序设定使用表单验证，当用户开始访问/people/ScottMitchell.aspx的时候，该网址将重写指向/info/employee.aspx?EmpID=1001，接着ForumAuthenticationModule启动，如果需要的话将用户重定向到登录页面，用户登录后重定向到的页面将是/info/employee.aspx?EmpID=1001，这也是自从FormAuthenticationModule启动运行时所发出请求的页面。
同上类似，当把网址重写放在BeginRequest事件或者AuthenticateRequest事件中运行的时候，UrlAuthenticationModule也发现了网址重写指向的网址，这意味着如果在该应用程序的web.config文件中<location>节为特定的网址配置特定的授权地址的话，你得引用重写所指向的网址。
为了解决这个微妙的问题，一个可能就是把网址重写放在AuthorizeRequest事件中运行，但是在使用这种方法解决URL授权和表单授权的异常时又引入了一个新的缺陷：文件授权会失效。当使用Windows验证的时候，FileAuthorizationModule检查并验证已通过验证的用户是否拥有足够的权限访问特定的ASP.NET页面。
假定有一群用户并没有Windows级别的访问权限访问C:\inetpub\wwwroot\info\employee.aspx，当这些用户试图访问/info/employee.aspx?EmpID=1001的时候，他们会得到未授权的错误，如果我们把网址重写放到AuthenticateRequest事件中运行，当FileAuthorizationModule验证该安全性设置的时候，他仍任人为被请求的文件是/people/ScottMitchell.aspx，而这时该网址已经被重写了，因此FileAuthorizationModule会直接放行，让用户看到了网址重写指向的内容：/info/employee.aspx?Empid=1001。
那么什么时候在HttpModule调用网址重写合适呢？他决定于所使用的验证方式，当然如果不使用验证方式的话，那么无论是在BeginRequest事件、AuthenticateRequest事件还是AuthorizeRequest事件中调用网址重写没有多大区别，如果使用表单验证方式并且不使用Windows验证方式的话，把网址重写放入AuthorizeRequest事件委托中调用既可，如果使用Windows验证方式的话，把这项功能放入BeginRequest事件或者AuthenticateRequest事件调用就行了。
1.11. 使用HttpHandler来调用网址重写
除了上面所述方法外，网址重写也可以放入HttpHandler或者HttpHandlerFactory中调用。HttpHandler是一个负责针对特定请求生成相应内容的类，而HttpHandlerFactory返回一个HTTP的实例，该实例针对特定请求生成相应内容。
本节将着眼于为这些ASP.NET页面创建一个网址重写的HttpHandlerFactory。创建HttpHandlerFactory必须实现IHTTPHandlerFactory接口，它包括一个GetHandler()方法。ASP.NET引擎在初始化这些HttpModule后做出决定针对该请求调用相应的HttpHandler或者HttpHandlerFactory，在调用HttpHandlerFactory的时候，针对该Web请求以及随同的其他信息的HttpContext中经过的的HttpHandlerFactory的GetHandler()方法将被ASP.NET引擎调用，HttpHandlerFactory必须返回一个能委托该请求的对象，并且该对象要能实现IHttpHandler接口。
要通过一个HttpHandler来调用网址重写，可以先创建一个HttpHandlerFactory，它的GetHandler()方法检查所请求的网址并决定是否需要调用网址重写。如果要调用网址重写的话则调用前文所述的已通过检查的HttpContext对象的RewritePath()方法。最后该HttpHandlerFactory返回一个由类System.Web.UI.PageParser的GetCompiledInstance()方法返回的HttpHandler。（这与内嵌于ASP.NET页面的HttpHandlerFactory（PageHandlerFactory）的工作原理相同。）
在所有HttpModule被初始化后，HttpHandlerFactory就开始被实例化。把网址重写放在这些事件场所的最后一个里头调用的时候，也会碰到相同的问题：文件授权将会失效。如果非要依赖于Windows验证和文件验证的时候，你可能得使用HttpModule来调用网址重写了。
下一章我们着眼于如何构建一个可重用的网址重写引擎，使用下文所提的这些示例均以真实案例作为参照，在作者主页上提供下载。先用用一个简单的网址重写的例子来探讨如何实现网址重写，紧接着将利用网址重写引擎中正则表达式的强大处理能力来展示真正“隐蔽”的网址重写技术！
1.12. 使用网址重写引擎实现简单的网址重写
为了便于在Web应用程序中实现网址重写，我构建了一个网址重写引擎，该引擎提供下列功能：
? 可以在web.config文件中为页面开发者定义其所使用的网址重写引擎的规则；
? 通过使用正则表达式来使所制定的网址重写规则具有更加强大的重写能力；
? 能够通过简单配置即可在HttpModule和HttpHandler中使用网址重写。
本节只探讨通过HttpModule来实现网址重写，要了解如何通过HttpHandler来实现网址重写请下载本文提供的代码。
1.12.1. 设置网址重写引擎的配置信息
我们来探讨一下在web.config中网址重写规则的配置节。首先必须在web.config文件中指出是否需要在HttpHandler或者HttpModule中调用网址重写，在web.config中，下文已经包含了两个已经被注释掉的配置节：
<!--
<HttpModules>
<add type="URLRewriter.ModuleRewriter,URLRewriter" name="ModuleRewriter"/>
</HttpModules>
-->
<!--
<httpHandlers>
<add verb="*" path="*.aspx" type="URLRewriter.RewriterFactoryHandler,URLRewriter" />
</httpHandlers>
-->
被注释掉的<HttpModules>为配置使用HttpModule调用网址重写；注释掉的<httpHandler>为配置使用HttpHandler调用网址重写。
不论配置使用<HttpModules>还是<httpHandlers>调用网址重写，除此之外还须配置网址重写规则，一条重写规则包括两项字符串：请求URL中的查找模式和针对该模式的匹配成功后的替换字符串。该信息在web.config文件中用下列标签描述：
<RewriterConfig>
<Rules>
<RewriterRule>
<LookFor>pattern to look for</LookFor>
<SendTo>String to replace pattern with </SendTo>
</RewriterRule>
<RewriterRule>
<LookFor>pattern to look for</LookFor>
<SendTo>String to replace pattern with </SendTo>
</RewriterRule>
</Rules>
</RewriterConfig>
每一条规则都用一个<RewriterRule>元素表示，以<LookFor>节表示查询模式，当查询模式发现匹配字符串时便用<SendTo>节表示的字符串进行替换。这些规则从上到下进行查询匹配，如果找到一个匹配则按此规则执行网址重写，并且停止查找。
配置<LookFor>节要使用正则表达式来进行字符串匹配和替换。（在此我们举一个例子来说明如何使用正则表达式来对字符串进行匹配和替换。）既然该查找模式是一个正则表达式，那么要注意避开对正则表达式保留字符串的直接使用。（正则表达式的保留字符串包括有：.，?，^，$，等等，可以通过在前面加上一个反斜线来引用这些保留字符，例如\.表示引用一个句点）
1.12.2. 使用HttpModule来执行网址重写
创建一个HttpModule很简单，只要创建一个实现IHttpModule接口的类，该IHttpModule接口定义了两个方法：
? Init(HttpApplication)，该方法在HttpModule初始化时引发，通过该方法为HttpApplication事件调用相应的事件委托；
? Dispose()，当相应请求处理结束并发送回IIS调用此方法，通过此方法执行最终所有的清理和回收程序。
为了更加方便地为网址重写创建HttpModule，从一开始我就创建一个抽象的基类（BaseModuleRewriter），该类实现了IHttpModule接口。在Init(HttpApplication)事件中，它通过BaseModuleRewriter_AuthorizeRequest方法引发了HttpApplication的AuthorizeRequest事件，该BaseModuleRewriter_AuthorizeRequest方法通过该类的Rewrite()方法重写传入参数HttpApplication对象的内部请求虚拟路径（Path）。在BaseModuleRewriter对象中，该Rewrite()方法是抽象的，并且没有实际内容，但在继承自该类的对象中必须重载Rewrite()方法并为该方法提供实际内容。
通过对该基类的继承，所有需要做的工作就是创建一个继承自BaseModuleRewriter的类，重载Rewrite()方法并在该方法中添加网址重写逻辑代码。下文列出BaseModuleRewriter代码：
public abstract class BaseModuleRewriter : IHttpModule
{
public virtual void Init(HttpApplication app){
// WARNING! This does not work with Windows authentication!
// If you are using Windows authentication,
// change to app.BeginRequest
app.AuthorizeRequest += new EventHandler(this.BaseModuleRewriter_AuthorizeRequest);
}
public virtual void Dispose() {}
protected virtual void BaseModuleRewriter_AuthorizeRequest(object sender, EventArgs e){
HttpApplication app = (HttpApplication) sender;
Rewrite(app.Request.Path, app);
}
protected abstract void Rewrite(string requestedPath, HttpApplication app);
}
注意：该BaseModuleRewriter类将网址重写放在AuthorizeRequest事件中调用，如果要使用Windows验证并使用文件验证模式时请修改代码将网址授权放在BeginRequest或者AuthenticateRequest事件中。
ModuleRewriter继承自BaseModuleRewriter，并真正意义地实现了网址重写的操作，该类仅包含一个重载了的方法Rewrite()，其内容如下文所示：
protected override void Rewrite(string requestedPath, System.Web.HttpApplication app)
{
// get the configuration rules
RewriterRuleCollection rules = RewriterConfiguration.GetConfig().Rules;
// iterate through each rule
for(int i = 0; i < rules.Count; i++)
{
// get the pattern to look for, and
// Resolve the Url (convert ~ into the appropriate directory)
string lookFor = "^" +
RewriterUtils.ResolveUrl(app.Context.Request.ApplicationPath, rules[i].LookFor) + "$";
// Create a regex (note that IgnoreCase is set)
Regex re = new Regex(lookFor, RegexOptions.IgnoreCase);
// See if a match is found
if (re.IsMatch(requestedPath))
{
// match found - do any replacement needed
string sendToUrl = RewriterUtils.ResolveUrl(app.Context.Request.ApplicationPath, re.Replace(requestedPath, rules[i].SendTo));
// Rewrite the URL
RewriterUtils.RewriteUrl(app.Context, sendToUrl);
break; // exit the for loop
}
}
}
该Rewriter()方法以获取web.config文件中的网址重写规则的设置为起始，它通过循环访问各条网址重写规则，每次均获取当前规则中的LookFor属性，用正则表达式验证并判断是否查找是否对当前请求的网址是否有匹配。
如果发现一条匹配，将用当前规则的SendTo值对请求的路径执行一个正则表达式替换，替换后的地址通过参数的形式传给RewriterUtils.RewriteUrl()方法，RewriterUtils是一个帮助类，它提供一对HttpModule和HttpHandler都可以使用的静态方法，RewriterUrl()方法只是简单地调用了HttpContext对象的RewritePath()方法。
注意：你已经注意到了当执行正则表达式匹配和替换的时候调用了一个RewriterUtils.ResolveUrl()方法。该帮助方法简单地替换了应用程序路径中“~”的所有实例。
本文附录中提供所有涉及该网址重写引擎的代码下载，我们已经探讨了主要的部分，但是还有其它一些组件诸如将web.config文件中XML格式化了的网址重写规则反序列化至一个对象的类定义、通过HttpHandlerFactory实现网址重写的类定义等。本文最后三节将通过一些真实案例来探讨网址重写的技术。
1.12.3. 用网址重写引擎实现简单的网址重写
为了更好地示范网址重写引擎的运行，我们来建立一个ASP.NET Web应用程序来实现简单的网址重写引擎。假定我们为一家在线销售各类商品的公司服务，这些产品划分为以下类别：
分类编号(CategoryID) 分类名称(CategoryName)
1 饮料（Beverages）
2 调味品（Condiments）
3 工艺品（Confections）
4 日记本（Diary Products）
... ...
假定已经建立好一个名为ListProductsByCategoryID.aspx的ASP.NET页面文件，它通过查询参数获取一个分类编号，并根据此编号获取所有该分类下的所有商品。如果用户想浏览所销售的饮料类商品可以通过ListProductsByCategoryID.aspx?CategoryID=1来访问，如果用户想浏览所销售的日记本类商品可以通过ListProductsByCategoryID.aspx?CategoryID=4来访问。假定还有一个页面ListCategories.aspx，它列出所有代售商品的分类编号。
显然这里发现了一个网址重写的案例。对于用户来说他们所输入的地址不具有任何实际意义并且不具备任何“隐蔽性”，倒不如使用网址重写引擎让用户去访问/Products/Baverage.aspx地址，系统将该地址重写到ListProductsByCategoryID.aspx?CategoryID=1。我们可以在web.config文件中来完成网址重写任务：
<RewriterConfig>
<Rules>
<!—- Rules for products lister -->
<RewriterRule>
<LookFor>~/Products/Baverage.aspx</LookFor>
<SendTo>~/ListProductsByCategoryID.aspx?CategoryID=1</SendTo>
</RewriterRule>
</Rules>
</RewriterConfig>
很明显地看到，搜索用户访问的路径是否匹配/Products/Baverage.aspx，如果匹配的话，则将网址重写到/ListProductsByCategoryID.aspx?CategoryID=1。
注意：你会发现<LookFor>节点中避免直接在“Baverage.aspx”中使用句点“.”是因为<LookFor>节点的值是正则表达式的匹配模式，在正则表达式中句点符号是一个特殊字符，它表示匹配任何一个字符，也就是说如果访问BaverageQaspx时也会发生匹配，为了避免发生这个句点引起的匹配我们得在该句点符号前面加上一个“\”，表示引用句点符号
通过该规则定义，当用户访问/Products/Baverage.aspx文件的时候，他们将看到代售的饮料类商品列表信息。图3为访问/Products/Baverage.aspx地址时的浏览器截图，注意在浏览器中地址栏上显示的是用户输入的/Products/Baverage.aspx地址，但是实际访问的地址却是网址重写后的/ListProductsByCategoryID.aspx?CategoryID=1。（事实上，在服务器上根本就不存在/Products/Baverage.aspx文件！）
图三．网址重写后的对商品分类的请求
和/Products/Baverage.aspx类似，下一步我们添加其它分类的重写规则，只需简单地在web.config文件中<Rules>中在添加其他<RewriteRule>节即可。该演示完整的重写规则集合请参考下载文档的web.config文件中的定义。
为了让该网址更具有“隐蔽性”，如果让用户把/Products/Baverage.aspx后面Baverage.aspx一段截去，在浏览器中输入/Products/来浏览产品分类列表会更好一些。乍一看，这项任务微不足道，只需添加一条网址重写规则将/Products/映射到/ListCategories.aspx即可。然而这里有一个微妙之处，你必须先创建一个/Products/目录，并在里面放一个空文件Default.aspx。
要认识为什么这些额外的步骤是必须的，先回顾一下前文。网址重写引擎是处于ASP.NET一级的，也就是说，如果ASP.NET没有获得处理请求的机会的话，网址重写引擎就不能对输入的网址请求作出判断。此外，IIS仅在请求文件包含相应扩展名时才将请求转交给ASP.NET引擎。如果用户访问/Products/，IIS并不知道其扩展名是什么，于是它检查该目录下的文件看是否包含有默认首页文件名（Default.aspx,Default.htm,Default.asp,等等，这些文件名在IIS管理工具对话框中Web服务器属性对话框中的文档标签中定义。）当然，如果/Products/目录不存在的话，IIS将返回一个HTTP 404错误。
所以我们需要创建一个/Products/目录并在该目录下额外创建一个空文件Default.aspx，IIS会检查该目录下的文件，发现有一个默认文件名Default.aspx，于是将请求转交给ASP.NET，这样，网址重写引擎才能生效。
<RewriterRule>
<LookFor>~/Products/Default.aspx</LookFor>
<SendTo>~ListCategories.aspx</SendTo>
</RewriterRule>
通过该规则，用户访问/Products/Default.aspx或者访问/Products/都可以看到如图四所示的产品分类列表。
图四.在网址上添加“隐蔽性”
1.12.4.处理回送数据
如果要重写的网址上包含有服务器端Web Form并执行数据回送，当该Web Form回送数据时会暴露出真实的网址，也就是说，当用户访问/Products/Baverage.aspx时，浏览器上地址栏显示的也是/Products/Baverage.aspx，但是实际上是访问/ListProdutsByCategoryID.aspx?CategoryID=1的内容，如果ListProductsByCategoryID.aspx页面执行了数据回送的话，用户被数据回送定向给原始的/ListProductByCategoryID.aspx?CategoryID=1页面上，而不是/Products/Baverage.aspx页面。这虽然不是什么大问题，但是用户会觉察到点击一个按钮时网址发生了的变化，这也许会令人不安，因为如果出于网址安全的角度来说，直接把真实的网址暴露出来了。
之所以发生这种现象的原因是当Web Form在呈现之时就明确地设置其action属性为当前Request对象中文件路径的值。当然，在Web Form呈现之时，从/Produts/Baverage.aspx到/ListProductsByCategoryID.aspx?CategoryID=1的网址重写就已经执行完毕了，这意味着Request对象所汇报的是当前用户所访问的地址是/ListProductsByCategoryID.aspx?CategoryID=1。这么看来，只需让该服务器端表单在呈现之时不呈现action属性即可解决问题了。（对浏览器来说，如果不设置action属性的话，那么在提交的时候将使用其默认值。）
然而不幸的是该Web Form不会允许你指定action属性，也不会允许你通过设置一些属性来达到禁用呈现action属性的目的。得自行继承System.Web.HtmlControls.HtmlForm这个类，并重载该类的RenderAttribute()方法，明确指出该类不呈现acton属性。
感谢继承这个强大的功能，使得我们很简单就获取了HtmlForm这个类下所有的功能定义，只需少量几行代码就达到所需目的，完整代码如下所示：
namespace ActionlessForm
{
public class Form:System.Web.UI.WebControls.
{
protected override void RenderAttributes(System.Web.UI.HtmlTextWriter writer)
{
writer.WriteAttribute("name",this.Name);
base.Attributes.Remove("name");
writer.WriteAttribute("method",this.Method);
base.Attributes.Remove("method");
this.Attributes.Render(writer);
base.Attributes.Remove("action");
if (base.ID!=null)
{
writer.WriteAttribute("id",this.ClientID);
}
}
}
}
对RenderAttributes()方法重载的代码包含了原类HtmlForm的RenderAttributes()方法全部的代码内容，只是简单地去掉了设置action属性这一节。（我参考了Lutz Roeder的Reflecter一文中类HtmlForm的源代码）
当创建并编译了这个类后，将其添加到引用目录即可在该ASP.NET Web应用程序中使用。为了将原有HtmlForm类替换，只需简单地在页面顶部添加下列代码：
<%@ Register TagPrifix="skm" Namespace="ActionlessForm" Assembly="ActionlessForm"%>
然后将<Form runat=”server”>标签替换为
<skm:Form id="Form1" method="post" runat="Server">
并将结束标记</Form>替换为
<skm:Form>
你可以查看该文档相关下载中的ListProductsByCategoryID.aspx文件中的自定义Web Form，该下载已经提供了完整的Visual Studio.NET项目文件包。
注意：如果你打算进行网址重写的地址不执行数据回送，则没有必要使用该自定义Web Form的类。
1.13. 创建真正“隐蔽”的网址
上一节简单网址重写的示例展示了如何通过新的网址重写规则来轻松地配置网址重写引擎，本节将通过出众的正则表达式来展示网址重写的强大威力。
时下正在流行Blog，很多人都拥有一个自己的Blog。不论你是否对Blog感到陌生，他们正在不断地更新自己的Blog页面，这些页面就像一个个人日记本一样。大多数Bloger只是简单地记录每天发生的事情，也有一些聚焦于某一主题，比如影评、球迷组织、电脑技术等。
Blog可以在任何地点由作者进行更新，更新次数可以是一天多次，也可以是一周一两次。在Blog页面上只显示最近10条更新，但事实上所有的Blog软件都提供了存档记录，访客可以阅读其历史记录。有了“隐蔽”的网址，Blog应用程序将变得更加强大。假定你通过/2004/02/14.aspx来查询自己的Blog上的文章，你会为阅读到2004年2月14日的Blog感到惊讶吗？此外你可能为了访问2004年2月所有的Blog而将该地址裁减为/2004/02/，要访问2004年所有的Blog，你可能会试着去访问/2004/。
在维护一个Blog的时候，如果将这种具有“隐蔽性”的网址提供给用户将会更好。实际上很多Blog引擎都提供了这种网址重写的功能，现在来看看这些是如何通过网址重写实现的。
首先，我们需要一个页面能够分别按照年、月、日分别显示Blog的内容。假定现在已经做好了一个页面文件ShowBlogContent.aspx，它能分别获取年、月、日的查询参数，要查看2004年2月14日所发的帖子，我们可以访问/ShowBlogContent.aspx?year=2004&month=2&day=14，要浏览2004年2月的数据可以访问/ShowBlogContent.aspx?year=2004&month=2，要查询2004年所有数据可以访问/ShowBlogContent.aspx?year=2004。（在下载文件中提供ShowBlogContent.aspx源代码。）
然后，当用户访问/2004/02/14.aspx时，我们需要将他访问的网址重写到/ShowBlogContent.aspx?year=2004&month=2&day=14上。这里需要制定三条网址重写规则：当指定访问年月日时、当指定访问年月时和当指定访问年时。
<RewriterConfig>
<Rules>
<!-- Rules for Blog Content Displayer -->
<RewriterRule>
<LookFor>~/(d{4})/(d{2})/(d{2}).aspx</LookFor>
<SendTo>~/ShowBlogContent.aspx?year=$1&month=$2&day=$3</SendTo>
</RewriterRule>
<RewriterRule>
<LookFor>~/(d{4})/(d{2})/Default.aspx</LookFor>
<SendTo><![CDATA[~/ShowBlogContent.aspx?year=$1&month=$2]]></SendTo>
</RewriterRule>
<RewriterRule>
<LookFor>~/(d{4})/Default.aspx</LookFor>
<SendTo>~/ShowBlogContent.aspx?year=$1</SendTo>
</RewriterRule>
</Rules>
</RewriterConfig>
这些网址重写规则展示了正则表达式的强大威力。第一条规则按照(\d{4})/(\d{2})/(\d{2})\.aspx模式进行查找，通俗的说，它查找是否包含匹配xxxx/xx/xx.aspx格式的字符串，其中x表示数字，每一组数字必须用圆括号括起来，这样可以在相应<SendTo>节内引用圆括号内的匹配字符串。我们可以使用$1、$2、$3来分别引用前面匹配的圆括号组，其中$1，$2，$3分别表示所匹配的第一、第二、第三个圆括号组。
注意：由于web.config是XML格式的文档，所以在文本域内必须回避直接使用一些特殊字符，如：&，<和>符号等。在第一条网址重写规则的<SendTo>节中用&来表示引用&符号，在第二条网址重写规则的<SendTo>节中用<![CDATA[...]]>元素来表示其中所有的内容都是文本域，不再需要用转义字符来表示引用。这两种方法都可以实现同样的目的。
下面图五、图六、图七都显示出网址重写的运行状况。这些数据都真实地摘自作者的Blog（http://ScottOnWritting.net），图五显示2003年11月7日的帖子，图六显示所有2003年11月的帖子，图七显示2003年所有帖子。
图五.显示2003年11月7日的帖子
图六. 显示2003年11月所有的帖子
图七. 显示2003年所有的帖子
注意：要使用网址重写引擎，强烈推荐在<LookFor>节中使用正则表达式。如果你对正则表达式不是很熟悉，可以先阅读作者本人写的一篇文章An Introduction to Regular Expressions，此外还可以在RegexLib.com 上查询常用的正则表达式，或把你自己设计的正则表达式提交到该站点共享使用。
1.14. 创建必须的目录结构
当IIS接收到对/2004/03/19.aspx的请求时，他发现文件扩展名.aspx，便将该请求转交给ASP.NET引擎处理，在ASP.NET 引擎中传递时，该地址被重写到/ShowBlogContent.aspx?year=2004&month=3&day=19，最后用户将看到该Blog上2004年3月19日所有的帖子，但是在用户访问/2004/03/时会发生什么呢？除非已经存在一个/2004/01/的目录，否则IIS将返回一个404错误，而且该目录下还必须要有一个默认页面Default.aspx，IIS才能将请求转交给ASP.NET引擎处理。
通过这种方法你得手动为每一年的Blog创建一个年份的目录并在该年份下放置一个默认文件Default.aspx，而且还得在该年份目录下创建每一月的目录，从01、02、...、12，每一个目录下也要防止一个默认文件Default.aspx。（回想前面的例子，为了将/Products/重写到/ListCategories.aspx也是要建立一个/Products/目录并放置一个默认Default.aspx文件。
很明显，这样创建目录结构的过程是很痛苦的。解决这种问题的一个办法就是设置IIS将所有接收的请求都转交给ASP.NET引擎来处理，这种方法，甚至连访问这种地址/2004/04/，IIS都如实地将其转交给ASP.NET引擎处理，这种方法造成ASP.NET引擎得处理所有传入的请求，包括css文件，图片文件、Javascript文件以及Flash文件等等。
关于对所有类型文件的处理的详细讨论已经超出了本书范围。有关在ASP.NET Web应用程序中使用这些技术的例子请访问 .Text 这个开源的Blog。.Text 可以通过配置将所有请求都转交给ASP.NET处理。它使用了一个自定义的HttpHandler来处理所有类型的文件类型，这个自定义的HttpHandler可以识别并判断如何处理所有的文件类型。（图像文件、CSS文件等等。）
1.15. 结束语
本文探讨了通过类HttpContext类的RewriteUrl()方法来实现ASP.NET一级的网址重写，正如我们所看到那样，RewriteUrl()方法在修改这个特有的HttpContext的Request的属性时也修改了所请求的文件和路径。实际得到的效果就是在用户访问其特有的网址的时候，他实际却是在服务器端请求另一个与此不同的网址。
网址重写不但可以在HttpModule中执行，也可以在HttpHandler中运行。本文我们探讨了在一个HttpModule中执行网址重写，也研究了一下网址重写在ASP.NET中的各个不同场所的情况。
当然，在ASP.NET一级的网址重写中，只有在IIS成功地将请求转交给ASP.NET引擎后才能成功地执行，当用户请求一个扩展名为.aspx的文件时这很自然地发生。然而，如果要让用户输入一个实际并不存在的网址，通过网址重写到另一个存在的aspx页面，你必须为该请求创建相应的目录和默认的Default.aspx页面，除非配置IIS让它把所有的请求都转交给IIS处理，但是这种方式盲目地将所有请求都转交给了ASP.NET引擎。
1.16. 参考
本文源代码下载地址：http://download.microsoft.com/download/0/4/6/0463611e-a3f9-490d-a08c-877a83b797cf/MSDNURLRewriting.msi
《深入研究IIS与ASP.NET》(Inside IIS and ASP.NET) 作者：Michele Leroux Bustamante
工作参考：网址重写是一个颇受欢迎的主题，不论是ASP.NET还是其他竞争对手都对其表示出巨大的关注。例如：Apache Web Server提供了一个叫做mod_rewriting的模块，mod_rewriting是个功能完善的网址重写引擎，它提供基于HTTP 头信息和服务器参数环境的网址重写功能，甚至还提供用正则表达式来创建网址重写规则。有关mod_rewriting更多信息请参考A User's Guide to URL Rewriting with the Apache Web Server《Apache Web Server网址重写用户向导》。
这里有相当数量的关于ASP.NET级别下网址重写的文章：
Rewrite.NET - A URL Rewriting Engine for .NET探讨模拟mod_rewriting的正则表达式描述的网址重写规则来实现ASP.NET下网址重写；
URL Rewriting With ASP.NET提供对ASP.NET下网址重写能力的总的概述；
Ian Griffiths有一个Blog，上面有许多有关在ASP.NET中实现网址重写的建议，比如本文所提到的考虑到数据回送时的做法；
Fabrice Marguerie和Jason Salas都各有一个Blog，在上面可以找到有关将ASP.NET网址重写来推动搜索引擎的查找替换的文章。
（Fabrice Marguerie: http://weblogs.asp.net/fmarguerie/archive/2003/12/24/45712.aspx）
（Jason Salas: http://weblogs.asp.net/jasonsalas/archive/2003/12/14/43404.aspx）
本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/kanshangren/articles/67505.aspx
2009年7月20日
#
1，最基本的乱码问题。
这个乱码问题是最简单的乱码问题。一般新会出现。就是页面编码不一致导致的乱码。
<%@ page language="java" pageEncoding="UTF-8"%>
<%@ page contentType="text/html;charset=iso8859-1"%>
<html>
<head>
<title>中文问题</title>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
</head>
</head>
<body>
我是个好人
</body>
</html>
三个地方的编码。
第一个地方的编码格式为jsp文件的存储格式。Ecljpse会根据这个编码格式保存文件。并编译jsp文件，包括里面的汉字。
第 二处编码为解码格式。因为存为UTF-8的文件被解码为iso8859-1，这样 如有中文肯定出乱码。也就是必须一致。而第二处所在的这一行，可以没有。缺省也是使用iso8859-1的编码格式。所以如果没有这一行的话，“我是个好 人”也会出现乱码。必须一致才可以。
第三处编码为控制浏览器的解码方式。如果前面的解码都一致并且无误的话，这个编码格式没有关系。有的网页出现乱码，就是因为浏览器不能确定使用哪种编码格式。因为页面有时候会嵌入页面，导致浏览器混淆了编码格式。出现了乱码。
2， 表单使用Post方式提交后接收到的乱码问题
这 个问题也是一个常见的问题。这个乱码也是tomcat的内部编码格式iso8859-1在捣乱，也就是说post提交时，如果没有设置提交的编码格式，则 会以iso8859-1方式进行提交，接受的jsp却以utf-8的方式接受。导致乱码。既然这样的原因，下面有几种解决方式，并比较。
A， 接受参数时进行编码转换
String str = new String(request.getParameter("something").getBytes("ISO-8859-1"),"utf-8") ； 这样的话，每一个参数都必须这样进行转码。很麻烦。但确实可以拿到汉字。
B， 在请求页面上开始处，执行请求的编码代码， request.setCharacterEncoding("UTF-8")，把提交内容的字符集设为UTF－8。这样的话，接受此参数的页面就不必在转码了。直接使用
String str = request.getParameter("something")；即可得到汉字参数。但每页都需要执行这句话。这个方法也就对post提交的有效 果，对于get提交和上传文件时的enctype="multipart/form-data"是无效的。稍后下面单独对这个两个的乱码情况再进行说明。
C， 为了避免每页都要写request.setCharacterEncoding("UTF-8")，建议使用过滤器对所有jsp
进行编码处理。这个网上有很多例子。请大家自己查阅。
/***********************************************************过滤器的使用*******************************************************/
现在将常见的乱码问题分为JSP页面显示中文乱码、表单提交乱码两类。
1）JSP页面中显示中文乱码
在JSP文件中使用page命令指定响应结果的MIME类型，如<%@ page language="java" contentType="text/html;charset=gb2312" %>
2）表单提交乱码
表单提交时（post和Get方法），使用request.getParameter方法得到乱码，这是因为tomcat处理提交的参数时默认的是iso-8859-1，表单提交get和post处理乱码问题不同，下面分别说明。
(1)POST处理
对post提交的表单通过编写一个过滤器的方法来解决，过滤器在用户提交的数据被处理之前被调用，可以在这里改变参数的编码方式，过滤器的代码如下：
Java代码
CharacterEncodingFilter.java:
public class CharacterEncodingFilter implements Filter
{
protected String encoding = null;
public void init(FilterConfig filterConfig) throws ServletException
{
this.encoding = filterConfig.getInitParameter("encoding");
}
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException
{
request.setCharacterEncoding(encoding);
response.setContentType("text/html;charset="+encoding);
chain.doFilter(request, response);
}
}
web.xml:
<filter>
<filter-name>CharacterEncodingFilter</filter-name>
<filter-class>net.vschool.web.CharacterEncodingFilter</filter-class>
<init-param>
<param-name>encoding</param-name>
<param-value>GBK</param-value>
</init-param>
</filter>
<filter-mapping>
<filter-name>CharacterEncodingFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
(2) Get方法的处理
tomcat对post和get的处理方法不一样，所以过滤器不能解决get的乱码问题，它需要在其他地方设置。
打开<tomcat_home>\conf目录下server.xml文件，找到对8080端口进行服务的Connector组件的设置部分，给这个组件添加一个属性：URIEncoding="GBK"。修改后的Connector设置为：
Java代码
<Connector port="8080" maxHttpHeaderSize="8192"
maxThreads="150" minSpareThreads="25" maxSpareThreads="75"
enableLookups="false" redirectPort="8443" acceptCount="100"
connectionTimeout="20000" disableUploadTimeout="true" <SPAN style="COLOR: #ff0000">URIEncoding="GBK"</SPAN> />
<Connector port="8080" maxHttpHeaderSize="8192"
maxThreads="150" minSpareThreads="25" maxSpareThreads="75"
enableLookups="false" redirectPort="8443" acceptCount="100"
connectionTimeout="20000" disableUploadTimeout="true" URIEncoding="GBK" />
* 注意修改后重新启动tomcat才能起作用。
/***********************************************************过滤器的使用*******************************************************/
3，表单get提交方式的乱码处理方式。
如果使用get方式提交中文，接受参数的页面也会出现乱码，这个乱码的原因也是tomcat的内部编码格式iso8859-1导致。Tomcat会以get的缺省编码方式iso8859-1对汉字进行编码，编码后追加到url，导致接受页面得到的参数为乱码/、。
解决办法：
A， 使用上例中的第一种方式，对接受到的字符进行解码，再转码。
B， Get走的是url提交，而在进入url之前已经进行了iso8859-1的编码处理。要想影响这个编码则需要在server.xml的Connector节点增加useBodyEncodingForURI="true"
属 性配置，即可控制tomcat对get方式的汉字编码方式，上面这个属性控制get提交也是用 request.setCharacterEncoding("UTF-8")所设置的编码格式进行编码。所以自动编码为utf-8，接受页面正常接受就 可以了。
但我认为真正的编码过程是，tomcat又要根据
<Connector port="8080"
maxThreads="150" minSpareThreads="25" maxSpareThreads="75"
enableLookups="false" redirectPort="8443" acceptCount="100"
debug="0" connectionTimeout="20000" useBodyEncodingForURI="true"
disableUploadTimeout="true" URIEncoding=”UTF-8”/>
里面所设置的URIEncoding=”UTF-8”再进行一次编码，但是由于已经编码为utf-8，再编码也不会有变化了。如果是从url获取编码，接受页面则是根据URIEncoding=”UTF-8”来进行解码的。
4， 上传文件时的乱码解决
上传文件时，form表单设置的都是enctype="multipart/form-data"。这种方式以流方式提交文件。如果使用apach的上传 组件，会发现有很多乱码想象。这是因为apach的先期commons-fileupload.jar有bug，取出汉字后进行解码，因为这种方式提交， 编码又自动使用的是tomcat缺省编码格式iso-8859-1。但出现的乱码问题是： 句号，逗号，等特殊符号变成了乱码，汉字如果数量为奇数，则会出现乱码，偶数则解析正常。
解决方式： 下载commons-fileupload-1.1.1.jar 这个版本的jar已经解决了这些bug。
但是取出内容时仍然需要对取出的字符进行从iso8859-1到utf-8转码。已经能得到正常所有汉字以及字符。
5，Java代码关于url请求，接受参数的乱码
url的编码格式，取决于上面所说的URIEncoding=”UTF-8”。 如果设定了这个编码格式，则意味着所有到url的汉字参数，都必须进行编码才可以。否则得到的汉字参数值都是乱码，例如
一个链接 Response.sendDerect（“/a.jsp?name=张大维”）；而在a.jsp里面直接使用
String name = request.getParameter（"name"）；得到的就是乱码。因为规定了必须是utf-8才可以，所以，这个转向应该这样写：
Response.sendDerect（“/a.jsp?name=URLEncode.encode(“张大维”,”utf-8”)；才可以。
如 果不设置这个参数URIEncoding=”UTF-8”， 会怎么样呢? 不设置则就使用了缺省的编码格式iso8859-1。问题又出来了，第一就是参数值的个数如果是奇数个数，则就可以正常解析，如果使偶数个数，得到最后字 符就是乱码。还有就是如果最后一个字符如果是英文，则就能正常解析，但中文的标点符号仍出现乱码。权宜之计，如果您的参数中没有中文标点符号，则可以在参 数值最后加一个英文符号来解决乱码问题，得到参数后再去掉这个最后面的符号。也可以凑或使用。
6， 脚本代码关于url请求，接受到的参数乱码
脚 本中也会进行页面转向的控制，也会涉及到附带参数，并在接受页面解析这个参数的情况。如果这个汉字参数不进行URIEncoding=”UTF-8”所指 定的编码处理，则接受页面接受到的汉字也是乱码。脚本处理编码比较麻烦，必须有相应的编码脚本对应文件，然后调用脚本中的方法对汉字进行编码即可。
7， 关于jsp在MyEclipse中打开的乱码问题
对 于一个已经存在的项目，Jsp文件的存储格式可能是utf-8。如果新安装的eclipse，则缺省打开使用的编码格式都是iso8859-1。所以导致 jsp里面的汉字出现乱码。这个乱码比较容易解决，直接到eclipse3.1的偏好设置里面找到general-〉edidor，设置为您的文件打开编 码为utf-8即可。Eclipse会自动重新以新的编码格式打开。汉字即可正常显示。
8， 关于html页面在eclipse中打开出现乱码情况
由于大部分页面都是由dreamweaver制作，其存储格式跟eclipse的识别有差别导致。
一般这种情况，在eclipse中新建一个jsp，直接从dreamweaver复制页面内容粘贴到jsp即可
但我认为真正的编码过程是，tomcat又要根据
<Connector port="8080"
maxThreads="150" minSpareThreads="25" maxSpareThreads="75"
enableLookups="false" redirectPort="8443" acceptCount="100"
debug="0" connectionTimeout="20000" useBodyEncodingForURI="true"
disableUploadTimeout="true" URIEncoding=”UTF-8”/>
里面所设置的URIEncoding=”UTF-8”再进行一次编码，但是由于已经编码为utf-8，再编码也不会有变化了。如果是从url获取编码，接受页面则是根据URIEncoding=”UTF-8”来进行解码的。
4， 上传文件时的乱码解决
上传文件时，form表单设置的都是enctype="multipart/form-data"。这种方式以流方式提交文件。如果使用apach的上传 组件，会发现有很多乱码想象。这是因为apach的先期commons-fileupload.jar有bug，取出汉字后进行解码，因为这种方式提交， 编码又自动使用的是tomcat缺省编码格式iso-8859-1。但出现的乱码问题是： 句号，逗号，等特殊符号变成了乱码，汉字如果数量为奇数，则会出现乱码，偶数则解析正常。
解决方式： 下载commons-fileupload-1.1.1.jar 这个版本的jar已经解决了这些bug。
但是取出内容时仍然需要对取出的字符进行从iso8859-1到utf-8转码。已经能得到正常所有汉字以及字符。
5，Java代码关于url请求，接受参数的乱码
url的编码格式，取决于上面所说的URIEncoding=”UTF-8”。 如果设定了这个编码格式，则意味着所有到url的汉字参数，都必须进行编码才可以。否则得到的汉字参数值都是乱码，例如
一个链接 Response.sendDerect（“/a.jsp?name=张大维”）；而在a.jsp里面直接使用
String name = request.getParameter（"name"）；得到的就是乱码。因为规定了必须是utf-8才可以，所以，这个转向应该这样写：
Response.sendDerect（“/a.jsp?name=URLEncode.encode(“张大维”,”utf-8”)；才可以。
如 果不设置这个参数URIEncoding=”UTF-8”， 会怎么样呢? 不设置则就使用了缺省的编码格式iso8859-1。问题又出来了，第一就是参数值的个数如果是奇数个数，则就可以正常解析，如果使偶数个数，得到最后字 符就是乱码。还有就是如果最后一个字符如果是英文，则就能正常解析，但中文的标点符号仍出现乱码。权宜之计，如果您的参数中没有中文标点符号，则可以在参 数值最后加一个英文符号来解决乱码问题，得到参数后再去掉这个最后面的符号。也可以凑或使用。
6， 脚本代码关于url请求，接受到的参数乱码
脚 本中也会进行页面转向的控制，也会涉及到附带参数，并在接受页面解析这个参数的情况。如果这个汉字参数不进行URIEncoding=”UTF-8”所指 定的编码处理，则接受页面接受到的汉字也是乱码。脚本处理编码比较麻烦，必须有相应的编码脚本对应文件，然后调用脚本中的方法对汉字进行编码即可。
7， 关于jsp在MyEclipse中打开的乱码问题
对 于一个已经存在的项目，Jsp文件的存储格式可能是utf-8。如果新安装的eclipse，则缺省打开使用的编码格式都是iso8859-1。所以导致 jsp里面的汉字出现乱码。这个乱码比较容易解决，直接到eclipse3.1的偏好设置里面找到general-〉edidor，设置为您的文件打开编 码为utf-8即可。Eclipse会自动重新以新的编码格式打开。汉字即可正常显示。
8， 关于html页面在eclipse中打开出现乱码情况
由于大部分页面都是由dreamweaver制作，其存储格式跟eclipse的识别有差别导致。
一般这种情况，在eclipse中新建一个jsp，直接从dreamweaver复制页面内容粘贴到jsp即可
2008-02-11 11:54
在使用JSP的过程中，最使人头疼的一个问题就是中文乱码问题，以下是我在软件开发中遇到的乱码问题以及解决方法。
1、JSP页面乱码
这种乱码的原因是应为没有在页面里指定使用的字符集编码，解决方法：只要在页面开始地方用下面代码指定字符集编码即可，<%@ page contentType="text/html; charset=utf-8" %>
2、数据库乱码
这种乱码会使你插入数据库的中文变成乱码，或者读出显示时也是乱码，解决方法如下：
在数据库连接字符串中加入编码字符集
String Url="jdbc:mysql://localhost/digitgulf?user=root&password=root&useUnicode=true&characterEncoding=utf-8";
并在页面中使用如下代码：
response.setContentType("text/html;charset=utf-8");
request.setCharacterEncoding("utf-8");
3、中文作为参数传递乱码
当我们把一段中文字符作为参数传递个另一页面时，也会出现乱码情况，解决方法如下：
在参数传递时对参数编码，比如
RearshRes.jsp?keywords=" + java.net.URLEncoder.encode(keywords)
然后在接收参数页面使用如下语句接收
keywords=new String(request.getParameter("keywords").getBytes("8859_1"));
以上为现阶段遇到的乱码问题，乱码的核心问题还是字符集编码问题，只要掌握了这一点，一般的乱码问题都可以解决。
=============================
首选 ActionConext 其次 ServletActionContext 最后是实现接口
http://scorpio-jh.blog.sohu.com/83673437.html
-- 1 --
### ActionContext ### --- 不能获得response对象
static ActionContext getContext() 获得当前线程的向下文
相当于
Object get(Object key) ---- getAttribute()
void put( Object key, Object value ) ---- setAttribute()
Map getParameter() 相当于Servlet中的getParameterMap()
Map getApplication() 对应于ServletContext
如:
action中
ActionContext.getContext().put("zhangsan","hello");
jsp中
张三：${ requestScope.zhangsan }
-- 2 --
通过接口使用 --- 典型的依赖注入
### ServletContextAware ### 接口
void setServletContext( ServletContext )
### ServletRequestAware ### 接口
void setServletRequest( HttpServletRequest )
### ServletResponseAware ### 接口
void setServletResponse( HttpServletResponse )
例：
public class LoginAction extends ActionSupport
implements ServletRequestAware,
ServletResponseAware {
private String username;
private String password;
//setter...getter...
private HttpServletRequest request;
private HttpServletResponse response;
public String execute() throws Exception {
//使用request对象
request.setAttribute("zhangshan","hello");
//使用response对象
Cookie cookie = new Cookie("username",
this.getUsername());
cookie.setMaxAge(1000);
response.addCookie(cookie);
return "success";
}
//这个方法由Strust2框架来自动调用
//调用后，便可以使用容器的request对象了
public void setServletRequest(HttpServletRequest request) {
this.request = request;
}
public void setServletResponse(HttpServletResponse responset) {
this.response = response;
}
}
---------------------
jsp页面中显示cookie
cookie: ${ cookie.username.value }
--------------------
-- 3 --
使用 org.apache.struts2.ServletActionContext类
---继承于 com.opensymphony.xwork2.ActionContext
内部全部为static的方法
static ActionContext getActionContext(HttpServletRequest req)
static PageContext getPageContext()
static HttpServletRequest getRequest()
static HttpServletResponse getResponse()
static ServletContext getServletContext()
static ValueStack getValueStack(HttpServletRequest req)
-----
static void setRequest(HttpServletRequest request)
static void setResponse(HttpServletResponse response)
static void setServletContext(ServletContext servletContext)
例：
public class LoginAction extends ActionSupport {
private String username;
private String password;
//setter...getter...
public String execute() throws Exception {
HttpServletResponse response = ServletActionContext.getResponse();
HttpServletRequest request = ServletActionContext.getRequest();
HttpSession session = request.getSession();
return "success";
}
}
|
在Web应用程序开发中，除了将请求参数自动设置到Action的字段中，我们往往也需要在Action里直接获取请求(Request)或会话（Session）的一些信息, 甚至需要直接对JavaServlet Http的请求（HttpServletRequest）、响应(HttpServletResponse)操作。
我们需要在Action中取得request请求参数“username”的值：
ActionContext context = ActionContext.getContext();
Map params = context.getParameters();
String username = (String) params.get(“username”);
ActionContext（com.opensymphony.xwork.ActionContext）是Action执行时的上下文，上下文可以看作是一个容器（其实我们这里的容器就是一个Map而已），它存放放的是Action在执行时需要用到的对象
一般情况，我们的ActionContext都是通过：ActionContext context = (ActionContext) actionContext.get();来获取的。我们再来看看这里的actionContext对象的创建：static ThreadLocal actionContext = new ActionContextThreadLocal();，ActionContextThreadLocal是实现ThreadLocal的一个内部类。ThreadLocal可以命名为“线程局部变量”，它为每一个使用该变量的线程都提供一个变量值的副本，使每一个线程都可以独立地改变自己的副本，而不会和其它线程的副本冲突。这样，我们ActionContext里的属性只会在对应的当前请求线程中可见，从而保证它是线程安全的。
下面我们看看怎么通过ActionContext取得我们的HttpSession：
Map session = ActionContext.getContext().getSession()；
ServletActionContext（com.opensymphony.webwork. ServletActionContext），这个类直接继承了我们上面介绍的ActionContext，它提供了直接与JavaServlet相关对象访问的功能，它可以取得的对象有：
1、 javax.servlet.http.HttpServletRequest：HTTPservlet请求对象
2、 javax.servlet.http.HttpServletResponse;：HTTPservlet相应对象
3、 javax.servlet.ServletContext：Servlet 上下文信息
4、 javax.servlet.ServletConfig：Servlet配置对象
5、 javax.servlet.jsp.PageContext：Http页面上下文
下面我们看看几个简单的例子，让我们了解如何从ServletActionContext里取得JavaServlet的相关对象：
1、 取得HttpServletRequest对象：
HttpServletRequest request = ServletActionContext. getRequest();
2、 取得HttpSession对象：
HttpSession session = ServletActionContext. getRequest().getSession();
ServletActionContext和ActionContext有着一些重复的功能，在我们的Action中，该如何去抉择呢？我们遵循的原则是：如果ActionContext能够实现我们的功能，那最好就不要使用ServletActionContext，让我们的Action尽量不要直接去访问JavaServlet的相关对象。在使用ActionContext时有一点要注意：不要在Action的构造函数里使用ActionContext.getContext()，因为这个时候ActionContext里的一些值也许没有设置，这时通过ActionContext取得的值也许是null。
|
|
2008年7月17日
#
//输出类
package em.util;
import java.io.*;
import jxl.LabelCell;
import jxl.Workbook;
import jxl.write.Label;
import jxl.write.WritableCellFormat;
import jxl.write.WritableSheet;
import jxl.write.WritableWorkbook;
import jxl.write.WriteException;
import jxl.write.biff.RowsExceededException;
import jxl.write.Number;
import jxl.write.Boolean;
import jxl.write.DateTime;
import jxl.write.DateFormats;
import java.util.Date;
import java.util.List;
import java.io.IOException;
import java.util.List;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import jxl.Workbook;
import jxl.format.Alignment;
import jxl.format.Border;
import jxl.format.BorderLineStyle;
import jxl.format.Colour;
import jxl.format.VerticalAlignment;
import jxl.write.Label;
import jxl.write.WritableCellFormat;
import jxl.write.WritableFont;
import jxl.write.WritableSheet;
import jxl.write.WritableWorkbook;
import jxl.write.NumberFormats;
import java.util.Calendar;
import java.text.SimpleDateFormat;
import java.io.*;
import java.util.*;
public class ComplexDataExcelWrite {
private WritableFont NormalFont, BoldFont, tableFont, baodanFont;
private WritableCellFormat wcf_title, wcf_tabletitle, wcf_baodan, wcf_left, wcf_center;
private WritableCellFormat wcf_merge, wcf_right, wcf_table, dtCellFormat;
private static ComplexDataExcelWrite instance = null;
private ComplexDataExcelWrite() {
}
public static synchronized ComplexDataExcelWrite getInstance() throws WriteException, IOException {
try {
if (instance == null) {
instance = new ComplexDataExcelWrite();
instance.formatFont();
instance.formatTableCell();
}
return instance;
} catch (Exception e) {
return null;
}
}
private void formatFont() {
/** ************设置单元格字体************** */
// 字体
NormalFont = new WritableFont(WritableFont.ARIAL, 10);
BoldFont = new WritableFont(WritableFont.ARIAL, 14, WritableFont.BOLD);
tableFont = new WritableFont(WritableFont.ARIAL, 12, WritableFont.NO_BOLD);
baodanFont = new WritableFont(WritableFont.ARIAL, 10, WritableFont.BOLD);
}
private void formatTableCell() throws WriteException, IOException {
/** ************以下设置几种格式的单元格************ */
try {
// 用于标题
wcf_title = new WritableCellFormat(BoldFont);
wcf_title.setBorder(Border.NONE, BorderLineStyle.THIN); // 线条
wcf_title.setVerticalAlignment(VerticalAlignment.CENTRE); // 垂直对齐
wcf_title.setAlignment(Alignment.CENTRE); // 水平对齐
wcf_title.setWrap(true); // 是否换行
// 用于标题
wcf_tabletitle = new WritableCellFormat(tableFont);
wcf_tabletitle.setBorder(Border.NONE, BorderLineStyle.THIN); // 线条
wcf_tabletitle.setVerticalAlignment(VerticalAlignment.CENTRE); // 垂直对齐
wcf_tabletitle.setAlignment(Alignment.CENTRE); // 水平对齐
wcf_tabletitle.setWrap(true); // 是否换行
// 用于保单标题
wcf_baodan = new WritableCellFormat(baodanFont);
wcf_baodan.setBorder(Border.ALL, BorderLineStyle.THIN); // 线条
wcf_baodan.setVerticalAlignment(VerticalAlignment.CENTRE); // 垂直对齐
wcf_baodan.setAlignment(Alignment.CENTRE);
wcf_baodan.setWrap(true); // 是否换行
// 用于正文左
wcf_left = new WritableCellFormat(NormalFont);
wcf_left.setBorder(Border.ALL, BorderLineStyle.THIN); // 线条
wcf_left.setVerticalAlignment(VerticalAlignment.CENTRE); // 垂直对齐
wcf_left.setAlignment(Alignment.LEFT);
wcf_left.setWrap(true); // 是否换行
// 用于正文左
wcf_center = new WritableCellFormat(NormalFont);
wcf_center.setBorder(Border.ALL, BorderLineStyle.THIN); // 线条
wcf_center.setVerticalAlignment(VerticalAlignment.CENTRE); // 垂直对齐
wcf_center.setAlignment(Alignment.CENTRE);
wcf_center.setWrap(true); // 是否换行
// 用于正文右
wcf_right = new WritableCellFormat(NormalFont);
wcf_right.setBorder(Border.ALL, BorderLineStyle.THIN); // 线条
wcf_right.setVerticalAlignment(VerticalAlignment.CENTRE); // 垂直对齐
wcf_right.setAlignment(Alignment.RIGHT);
wcf_right.setWrap(false); // 是否换行
// 用于跨行
wcf_merge = new WritableCellFormat(NormalFont);
wcf_merge.setBorder(Border.ALL, BorderLineStyle.THIN); // 线条
wcf_merge.setVerticalAlignment(VerticalAlignment.TOP); // 垂直对齐
wcf_merge.setAlignment(Alignment.LEFT);
wcf_merge.setWrap(true); // 是否换行
wcf_table = new WritableCellFormat(NormalFont);
wcf_table.setBorder(Border.ALL, BorderLineStyle.THIN); // 线条
wcf_table.setVerticalAlignment(VerticalAlignment.CENTRE); // 垂直对齐
wcf_table.setAlignment(Alignment.CENTRE);
wcf_table.setBackground(Colour.GRAY_25);
wcf_table.setWrap(true); // 是否换行
// 时间格式
dtCellFormat = new WritableCellFormat(DateFormats.FORMAT1);
dtCellFormat.setBorder(Border.ALL, BorderLineStyle.THIN); // 线条
dtCellFormat.setVerticalAlignment(VerticalAlignment.CENTRE); // 垂直对齐
dtCellFormat.setAlignment(Alignment.CENTRE);
dtCellFormat.setBackground(Colour.GRAY_25);
dtCellFormat.setWrap(true); // 是否换行
} catch (Exception e) {
}
}
private void formatSheetColView(WritableSheet sheet) throws WriteException, IOException {
try {
/** *********设置列宽**************** */
sheet.setColumnView(0, 15); // 第1列
sheet.setColumnView(1, 15); // 第2列
sheet.setColumnView(2, 15);
sheet.setColumnView(3, 15);
sheet.setColumnView(4, 15);
sheet.setColumnView(5, 15);
// 设置页边距
sheet.getSettings().setRightMargin(0.5);
} catch (Exception e) {
// TODO: handle exception
}
}
public void creatExcel(List list, OutputStream os) throws WriteException, IOException {
try {
WritableWorkbook workbook = Workbook.createWorkbook(os);
WritableSheet sheet = workbook.createSheet("first sheet", 0);
formatSheetColView(sheet);
// 添加主体
int rowNum = 0;
for (Iterator it = list.iterator(); it.hasNext();) {
rowNum += 1;
// 设置行高
sheet.setRowView(rowNum, 400, false);
String[] str = (String[]) it.next();
for (int i = 0; i < str.length; i++) {
Label example = new Label(i, rowNum, str[i], wcf_table);
sheet.addCell(example);
}
}
workbook.write();
workbook.close();
os.close();
} catch (Exception e) {
}
}
public void creatExcel(String sheetName, String[] title, List list, OutputStream os) throws WriteException, IOException {
try {
WritableWorkbook workbook = Workbook.createWorkbook(os);
WritableSheet sheet = workbook.createSheet(sheetName, 0);
formatSheetColView(sheet);
formatFont();
formatTableCell();
/** ****** 填充数据 ******** */
// 添加标题，第一行
sheet.mergeCells(0, 0, title.length - 1, 0);
Label titleLabel;
if (sheetName == null) {
titleLabel = new Label(0, 0, "sheetName", wcf_baodan);
} else {
titleLabel = new Label(0, 0, sheetName, wcf_baodan);
}
// 设置行高
sheet.setRowView(0, 400, false);
sheet.addCell(titleLabel);
// 添加表头
for (int i = 0; i < title.length; i++) {
Label formate = new Label(i, 1, title[i], wcf_tabletitle);
sheet.addCell(formate);
}
// 添加主体
int rowNum = 1;
for (Iterator it = list.iterator(); it.hasNext();) {
rowNum += 1;
// 设置行高
sheet.setRowView(rowNum, 400, false);
String[] str = (String[]) it.next();
for (int i = 0; i < str.length; i++) {
Label example = new Label(i, rowNum, str[i], wcf_table);
sheet.addCell(example);
}
}
workbook.write();
workbook.close();
workbook = null;
sheet = null;
} catch (RuntimeException e) {
e.printStackTrace();
}
}
}
//调用类
try {
List resultItems = new ArrayList();
resultItems.clear();
String[] title = { "第一列", "第二列", "第三列", "第四列" };
String[] s1 = { "11", "12", "13", "14" };
String[] s2 = { "21", "22", "23", "24" };
resultItems.add(s1);
resultItems.add(s2);
OutputStream os = response.getOutputStream();
response.reset();
String fname = "学校专业竞争力情况";
response.setCharacterEncoding("UTF-8");
fname = URLEncoder.encode(fname, "UTF-8");
response.setHeader("Content-Disposition", "attachment;filename=" + new String(fname.getBytes("UTF-8"), "GBK") + ".XLS");
response.setContentType("application/msexcel");
ComplexDataExcelWrite.getInstance().creatExcel("标题", title, resultItems, os);
//ComplexDataExcelWrite sw=new ComplexDataExcelWrite();
// sw.creatExcel("标题", title, resultItems, os);
} catch (Exception e) {
// TODO: handle exception
}
return null;
//如果用jsp直接调用，注意out的处理方法，用他屏蔽一个getOutputStream() has already been called for this response
//异常
<%@ page language="java" import="java.util.*" pageEncoding="gbk"%>
<%@ page import="java.io.*"%>
<%@page import="java.net.URLEncoder"%>
<%@page import="em.util.ComplexDataExcelWrite"%>
<%
List resultItems = new ArrayList();
resultItems.clear();
String[] title = { "第一列", "第二列", "第三列", "第四列" };
String[] s1 = { "11", "12", "13", "14" };
String[] s2 = { "21", "22", "23", "24" };
resultItems.add(s1);
resultItems.add(s2);
OutputStream os = response.getOutputStream();
response.reset();
String fname = "学校专业竞争力情况";
response.setCharacterEncoding("UTF-8");
fname = URLEncoder.encode(fname, "UTF-8");
response.setHeader("Content-Disposition", "attachment;filename=" + new String(fname.getBytes("UTF-8"), "GBK") + ".XLS");
response.setContentType("application/msexcel");
ComplexDataExcelWrite.getInstance().creatExcel("标题", title, resultItems, os);
out.clear();
out = pageContext.pushBody();
//ComplexDataExcelWrite sw=new ComplexDataExcelWrite();
// sw.creatExcel("标题", title, resultItems, os);
%>
<html>
<head>
<META HTTP-EQUIV="Pragma" CONTENT="no-cache">
<META HTTP-EQUIV="Cache-Control" CONTENT="no-cache">
<META HTTP-EQUIV="Expires" CONTENT="0">
</head>
</html>
2008年5月5日
#
1、创建一个Criteria实例
net.sf.hibernate.Criteria这个接口代表对一个特定的持久化类的查询。Session是用来制造Criteria实例的工厂。
Criteria crit = sess.createCriteria(Cat.class);//创建实力类可以为OBJECT.CLASS
crit.setMaxResults(50);
List cats = crit.list();
返回最多50条记录的结果集。
2、缩小结果集范围
一个查询条件(Criterion)是net.sf.hibernate.expression.Criterion接口的一个实例。类net.sf.hibernate.expression.Expression定义了获得一些内置的Criterion类型。
import org.hibernate.criterion.Projections;//两个查询条件类
import org.hibernate.criterion.Expression;
List cats = sess.createCriteria(Cat.class)
.add( Expression.like("name", "Fritz%") )
.add( Expression.between("weight", minWeight, maxWeight) )
.list();
表达式（Expressions）可以按照逻辑分组.
List cats = sess.createCriteria(Cat.class)
.add( Expression.like("name", "Fritz%") )
.add( Expression.or(
Expression.eq( "age", new Integer(0) ),
Expression.isNull("age")
) )
.list();
返回（name like "Fritz%" and age 等于0 或者 age 为空）的结果集
List cats = sess.createCriteria(Cat.class)
.add( Expression.in( "name", new String[] { "Fritz", "Izi", "Pk" } ) )
.add( Expression.disjunction()
.add( Expression.isNull("age") )
.add( Expression.eq("age", new Integer(0) ) )
.add( Expression.eq("age", new Integer(1) ) )
.add( Expression.eq("age", new Integer(2) ) )
) )
.list();
Expression.disjunction()----意思是可以按照逻辑分组
有很多预制的条件类型（Expression的子类）。有一个特别有用，可以让你直接嵌入SQL。
List cats = sess.createCriteria(Cat.class)
.add( Expression.sql("lower($alias.name) like lower(?)", "Fritz%", Hibernate.STRING) )
.list();
其中的{alias}是一个占位符，它将会被所查询实体的行别名所替代。(原文:The {alias} placeholder with be replaced by the row alias of the queried entity.)
3、对结果排序
可以使用net.sf.hibernate.expression.Order对结果集排序.
List cats = sess.createCriteria(Cat.class)
.add( Expression.like("name", "F%")
.addOrder( Order.asc("name") )
.addOrder( Order.desc("age") )
.setMaxResults(50)
.list();
4、关联（Associations）
你可以在关联之间使用createCriteria()，很容易地在存在关系的实体之间指定约束。
List cats = sess.createCriteria(Cat.class)
.add( Expression.like("name", "F%")
.createCriteria("kittens")
.add( Expression.like("name", "F%")
.list();
注意，第二个createCriteria()返回一个Criteria的新实例，指向kittens集合类的元素。
下面的替代形式在特定情况下有用。
List cats = sess.createCriteria(Cat.class)
.createAlias("kittens", "kt")
.createAlias("mate", "mt")
.add( Expression.eqProperty("kt.name", "mt.name") )
.list();
（createAlias()）并不会创建一个Criteria的新实例。）
请注意，前面两个查询中Cat实例所持有的kittens集合类并没有通过criteria预先过滤！如果你希望只返回满足条件的kittens,你必须使用returnMaps()。
List cats = sess.createCriteria(Cat.class)
.createCriteria("kittens", "kt")
.add( Expression.eq("name", "F%") )
.returnMaps()
.list();
Iterator iter = cats.iterator();
while ( iter.hasNext() ) {
Map map = (Map) iter.next();
Cat cat = (Cat) map.get(Criteria.ROOT_ALIAS);
Cat kitten = (Cat) map.get("kt");
}
5、动态关联对象获取（Dynamic association fetching）
可以在运行时通过setFetchMode()来改变关联对象自动获取的策略。
List cats = sess.createCriteria(Cat.class)
.add( Expression.like("name", "Fritz%") )
.setFetchMode("mate", FetchMode.EAGER)
.list();
这个查询会通过外连接(outer join)同时获得 mate和kittens。
6、根据示例查询（Example queries）
net.sf.hibernate.expression.Example类允许你从指定的实例创造查询条件。
Cat cat = new Cat();
cat.setSex('F');
cat.setColor(Color.BLACK);
List results = session.createCriteria(Cat.class)
.add( Example.create(cat) )
.list();
版本属性，表示符属性和关联都会被忽略。默认情况下，null值的属性也被排除在外。
You can adjust how the Example is applied. 你可以调整示例(Example)如何应用。
Example example = Example.create(cat)
.excludeZeroes() //exclude zero valued properties
.excludeProperty("color") //exclude the property named "color"
.ignoreCase() //perform case insensitive string comparisons
.enableLike(); //use like for string comparisons
List results = session.createCriteria(Cat.class)
.add(example)
.list();
你甚至可以用示例对关联对象建立criteria。
List results = session.createCriteria(Cat.class)
.add( Example.create(cat) )
.createCriteria("mate")
.add( Example.create( cat.getMate() ) )
.list();
2008年3月19日
#
Update base_ct set ct=null where id=1;
Select address||’kong’|| ‘ ’||id from address;
Select last_name aa from address;//大写显示标题
Select las_name AS “aa” from address;//栏位保持不变 aa
Like 区分大小写；
Select * from t1 where id
Between 10 and 20 and name is (not) null and id not in(10,20,5,6);
Select lower(al_name ),upper(fname) from auther;
Select concat(‘hello’,name) from auther;//连接诶
Select substr(lname,1,5) from auther//从第个截取5个；
Instr(lname,’w’)判断存在位置； lpad（au_name,15,’&’）左填充&到15位长度；
Round（45.926，2）求余，trunc（45.923，2）截取
Nvl(name,’tom’)//是否位空空，如实是就用后面的填充，否则返回原值。
Nvl2（name，‘have name’,’have not name’）
Nullif(name1,name2)如果相等返回空，否贼返回第一个；
Cocalesce（，，，，）直到找到第一个不为空的值。
Natural join aa;依据aa同名的栏位连接；
Using（aa，bb）依据多个栏位同名连接；
Left outer join
Create view testview
As
Select stor_id,qty;
Select * from testview;
Select * from sales union select * from sales,集合操作；排序，删除重复
Select * from sales1 union all select * from sales2 不删除重复，不排序
Select * from sales1 intersect all select * from sales2求交集
Select * from sales1 minus all select * from sales2第一句减去交集；
Insert all
When name like ‘b%’ then into t1,
When name like ‘c%’ then into t2,
Select * from sales;
2007年11月1日
#
摘要: 先给一个简单实用的方式（可以打印多页，控制分页，隐藏非打印项目）
<!--语言无关 保存成 .HTML 看看--> <html> <head> <meta name=vs_targetSchema content="http://schemas.microsoft.com...
阅读全文
2007年10月27日
#
System.IO.FileStream file = new FileStream("c:/a.txt",System.IO.FileMode.OpenOrCreate);
byte [] msg= new byte[file.Length];
file.Read(msg, 0, msg.Length );
System.Net.Sockets.Socket send = new System.Net.Sockets.Socket(System.Net.Sockets.AddressFamily.InterNetwork,System.Net.Sockets.SocketType.Stream, System.Net.Sockets.ProtocolType.Tcp);
System.Net.IPEndPoint ipendp = new System.Net.IPEndPoint(System.Net.IPAddress.Parse("127.0.0.1"), 9999);
send.Connect(ipendp);
send.Send(msg);
send.Shutdown(System.Net.Sockets.SocketShutdown.Both);
send.Close();
//发送端
System.IO.FileStream file = new FileStream("c:/b.txt", System.IO.FileMode.OpenOrCreate);
System.Net.Sockets.Socket soclip = new System.Net.Sockets.Socket(System.Net.Sockets.AddressFamily.InterNetwork,
System.Net.Sockets.SocketType.Stream, System.Net.Sockets.ProtocolType.Tcp);
System.Net.IPEndPoint ipendp = new System.Net.IPEndPoint(System.Net.IPAddress.Parse("127.0.0.1"), 9999);
soclip.Bind(ipendp);
soclip.Listen(100);
System.Net.Sockets.Socket soclipapp = soclip.Accept();
byte[] by = new byte[200];
string str = "";
soclipapp.Receive(by);
file.Write(by, 0, by.Length);//'将数据写到kk.txt中
file.Close();//'流关
str = System.Text.Encoding.UTF8.GetString(by);
soclipapp.Shutdown(System.Net.Sockets.SocketShutdown.Both);
soclipapp.Close();
Response.Write(str);
//接受，
//网上搜索，自己整理而来，名字我网了。在此表示谢谢
//运行此代码，建立两个工程。同时运行。这两个项目
2007年10月3日
#
<ItemTemplate>
<asp:Button ID="asda" runat="server" Text="删除" CommandName="edit" />
delete edit,update,canlce
</ItemTemplate>