Terry Su

中国一线二线三线城市名单

2014-03-04T07:19:00.003+11:00

中国一线二线三线城市名单：
　　一线城市：北京上海广州深圳
　　准一线：天津
　　二线城市：
　　二线强： 1南京 2武汉 3沈阳 4西安 5成都 6重庆 7杭州8青岛 9大连 10宁波
　　二线中： 11济南 12哈尔滨 13长春14厦门15郑州 16长沙 17福州18乌鲁木齐 19昆明20兰州21苏州 22无锡
　　二线弱： 23南昌 24贵阳 25南宁 26合肥 27太原 28石家庄 29呼和浩特 30佛山31东莞32唐山 33烟台34泉州35包头
　　三线城市：
　　三线强： 1温州2珠海3大庆 4西宁 5海口 6徐州7淄博8潍坊9洛阳 10南通 11常州12绍兴13台州14鞍山 15中山 16汕头 17吉林 18柳州
　　三线中：19拉萨 20保 21邯 22银川23秦皇 24沧州 25鄂尔 26东营 27威海 28济宁 29临沂 30德州 31滨州 32泰安 33湖州 34嘉兴 35金华 36泰州 37镇江 38盐城 39扬州 40桂林 41惠州 42湛江 43江门 44茂名 45株洲 46岳阳 47衡阳 48宝鸡 49宜昌 50襄樊 51开封 52许昌 53平顶山 54赣州 55九江 56芜湖 57绵阳 58齐齐哈尔 59牡丹江 60抚顺
　　三线弱：61本溪 62丹东 63辽阳 64锦州 65营口 66承德 67廊坊 68邢台 69大同 70榆林 71延安 72天水 73克拉玛 74喀什 75石河子 76南阳 77濮阳 78安阳 79焦作 80新乡 81日照82聊城 83枣庄 84蚌埠 85淮南 86马鞍山 87连云港 88淮安 89丽水 90衢州 91荆州 92安庆 93景德镇 94新余 95湘潭 96常德 97郴州 98漳州 99清远 100揭阳 101梅州 102肇庆 103玉林 104北海105德阳 106宜宾 107遵义 108大理
　　四线城市：剩余的所有城市
拓展业务布局的经营者们收藏吧。

Error: API mismatch: the NVIDIA kernel module

2013-12-19T11:42:00.001+11:00

I was trying to get STEAM working on Ubuntu 12.04. I downloaded and installed the STEAM App and when I started it, it told me I had to upgrade my Nvidia Driver from version 295.40 to version 304.43 or 310.11. It gave me nice instructions, which I followed and it looked like it worked. Ubuntu said it need to reboot to complete the driver update, which I did.

On reboot I was greeted with a Black TERMINAL SCREEN asking for my USER NAME and PASSWORD. Even after giving my user/password I was still stuck at the TERMINAL Screen. Well I remembered the command STARTX, which I tried. That's when I got the following ERROR MESSAGE;

"Error: API mismatch: the NVIDIA kernel module has version 295.49, but this NVIDIA driver component has version 310.11. Please make sure that the kernel and all NVIDIA driver components has the same version."

No matter what I did I could not get Ubuntu to boot into a GUI. I knew this was a Video Drive Issue so I began my Google Searches. Many of the things I found involved editing your /etc/X11/xorg.conf file, which I was afraid to do. After reading several articles I pieced together how to remove and reinstall your Nvidia Video Driver from a Terminal Screen. Here's how;

1. At the Terminal Screen type the following and hit ENTER;

sudo apt-get purge nvidia*

2. That removes your Nvidia Drivers, once it runs (it takes about 10 minutes and runs several lines in the Terminal) we reinstall the current Nvidia Driver with the following command;

sudo apt-get install nvidia-current-updates-dev

3. Once this command runs, just reboot your system and you should be good to go.

As a bonus, this Driver Removal and Reinstall lets the STEAM APP start working. I'll do a post on STEAM and it's Linux Game Selection once I get a chance to play with it a little.

你必须知道的十大网络分销渠道

2013-12-16T23:24:00.003+11:00

徐静蕾的开啦饰品做电子商务，销售额100%来源于分销渠道，他们只做线上渠道，自己不直接销售，没有自己的官网B2C商城，自己也不在淘宝开店，每天几百个线上订单100%是外部线上渠道带来的。
从2009年11月，开啦正式上线凡客，接着入驻卓越、当当，并成功获得卓越网免费首页及频道内推广资源，成为手表饰品频道的重要品牌商。后又进入了时尚类的垂直B2C走秀网、逛街网、三十到五十商城等。开啦凭借徐静蕾的人脉与影响力，半年之内几乎进入了中国绝大多数排名靠前的B2C网站渠道销售，是线上分销的成功案例。
成功的电子商务企业，网上分销渠道销量一般不会少于自己的官网平台，线上互联网世界与线下实体世界一样，未来仍是渠道为王。有远见的B2C企业如红孩子、走秀网等都成立专门的线上渠道部来负责线上渠道建设。
传统企业进入网上零售最好采用这样的运营节奏：第一步，建立商品供应链与运营体系；第二步，全方位地建立线上渠道；第三步，进行渠道推广。而现在90%以上的企业还未建立线上渠道，就开始大规模推广，这就是为什么很多网络推广投入产出比不理想的原因。
其实电子商务与传统商业生意并无二致，不重视线上渠道、分销体系建立的电子商务推广效果会大打折扣。线下做销售，有了产品，知道要进入沃尔玛、家乐福，要找地区经销商，知道要做渠道，但进入线上互联网世界，就不知道要做网络分销渠道了，仅仅漫无目的地利用网络媒体推广自己的官网，而不结合渠道来促销商品，推广效果怎不大打折扣？
所以，推广一定要结合线上渠道来推广。有线上渠道的网络推广，会事半功倍；而无线上渠道的网络推广，就会事倍功半。
我在中国最大的时尚B2C平台走秀网做营销副总裁期间，最主要的工作之一是带领10多人的团队，花了两年多时间在互联网上全面建立线上渠道，一共建立了十大渠道体系，开设了上百个线上销售渠道点。最后的收益是：通过这些线上渠道不花一分钱推广费用，一年365天，每天带来几百单的销售。
十大网络渠道
1.C2C渠道：
淘宝（C2C及淘宝商城）、拍拍（C2C及B2C渠道）、有啊商城。
这个渠道大家都已经熟悉，就不详细介绍了。目前对很多传统企业来说，做电子商务就是在淘宝开店，销量也绝大部分来源于淘宝。但对于传统大型企业来说，从长远看，淘宝只能作为一个销售渠道，不能作为唯一的渠道，必须发展全方位渠道，争取未来的主动权。
2.B2C商城渠道：
如当当网、卓越网等。
渠道情况：他们在线上渠道的地位相当于线下的沃尔玛、家乐福。2009年，中国前十名的B2C商城大多开始转入百货商城，大多数商品品类都卖，正在建立其他品类商品供应链，这就给传统企业进入B2C渠道提供了机会。
如何进入：如果你的商品是市场上热卖的商品，又有电子商务的客服体系等基本条件，保证这些平台一定的毛利空间，就有可能成为这些B2C平台的供应商。注意，以传统企业名义去谈比你用网站名义去谈更能被接受。
效果预估：根据我的实操经验，如果能成为这些大的B2C平台的主推供应商，一个大的平台每天可以带来几十个订单。更何况其他小有价值的B2C平台还有成百上千，累计起来每天订单也不少。
3.CPS渠道：
包括第三方CPS平台及自营CPS平台。如yiqifa、linktech、唯一、成果网。
渠道情况：目前电子商务比较主流且固定的渠道推广就是CPS模式，通过推广产生有效的订单后进行比例分成。这是一种零风险的实效营销方式，如果网站主不能为给你的网站带来销售额，广告主不用支付任何广告费用。
如何进入：制定超越竞争对手的联盟分成政策，增强竞争力，还需要有专人结算与维护。
效果预估：一般B2C平台，CPS销售会占到20%，不做这个渠道意味着你损失20%的销量。当然，有实力的企业也可以建立自己的CPS联盟，一旦发展起来，和第三方CPS平台形成补充，带来的销量比例更大。
4.银行商城渠道：
招行、工行、交行、建行等网上商城。
渠道情况：中国大部分银行商城及信用卡商城都建设有B2C平台，据我的经验，银行网上商城这个渠道价值非常大，银行拥有大量网银支付的用户。
如何进入：和银行谈判他们最在乎的是自己网上支付的流水，知道人家的需求就容易进入了。
合作效果：我们进入了中国16家网上银行商城（每个银行的很多地区分行也开设有自己的网上商城），并进行了深度推广合作。除了订单的实际效果，银行对B2C平台的背书作用也不容忽视。如果能与这些银行深层次合作，一次合作带来上百万销售额也是可能的。
5.网上支付渠道：
腾讯财付通商城渠道、支付宝商城渠道、第三方支付渠道如快钱、环迅等。
这些第三方支付平台拥有庞大的用户量，这些已经开通网上支付手段的用户，基本都有网购经验，是精准的网购人群。这些平台也希望企业使用其支付手段做大资金流。抓住他们的需求，展示你的实力与未来注册用户的庞大，他们也愿意利用自己的资源推广你的网站平台。
6.门户商城渠道：
腾讯QQ会员商城、腾讯返利商城、新浪商城、搜狐商城、网易购物返现商城等。
渠道情况：中国的主流门户都有自己的B2C商城，虽然它们都没有发力。门户商城的交易量也还暂时不大，但门户的影响力及庞大用户量是不可小觑的；
如何进入：门户也欢迎直接与厂商合作，如果和这些门户有广告投放合作，结合推广进入商城，会更容易一些。
合作效果：如果你在这些门户商城占据较好的渠道位置，并争取门户的推广资源支持，并策划一些在门户的促销活动，有专门的人维护商品与专人的客服，也可取得每天几十单的销售。
至于其他大流量的网站如天涯、迅雷等，都已经进军电子商务，也可作为补充渠道。
7.积分商城渠道：
平安万里通商城/网易邮箱积分商城/携程特约商户等。
渠道情况：现在很多有庞大用户量的机构，建有自己的积分体系，并将这个积分和电子商务结合。在积分体系商城中，平安万里通是做得最极致的，将自己的4000万用户的积分变成一个商城，用平安万里通的入口可以直接购买其他B2C平台的商品如1号店及红孩子等商品。
如何进入：由于这个渠道是给他们积分用户带来优惠，所以对商品价格的优惠力度要求较高，而且要求合作伙伴能和他们对接网上同步订单操作，对技术接口要求也高。
合作效果：1号店的总销售额中60%来源于平安万里通这个渠道，超过其他渠道及官网销售额的总和，其效果可见一斑。网易邮箱及携程用户也是海量级别的，将他们的部分用户转为你的购买用户，将对商务拓展及公关工作带来极大挑战，但一旦变成你的销售渠道，其战略意义是很大的。
8.运营商渠道：
中国移动商城、中国联通积分商城、中国电信商城。
渠道价值：随着移动互联网兴起及移动支付的普及，这个渠道的战略意义会越来越大，属于提前占位的策略。我们的实际经验是：和中国移动商城的合作每天带来上10单，就是用户用手机支付来买我们的商品，等于多开了一个销售渠道与支付手段。
9.购物搜索渠道：
聪明点、返利网、易购网、特价王、askyaya。
渠道价值：由于这些购物搜索用户都是购买用户，其价值大于一般娱乐性信息网站，成为成熟网购人群的入口之一。如能让这些购物搜索全部收录一些你的网站商品，而且在首页推荐，每天都能带来一些订单。
10.网站导航渠道：
hao123/265/114la购物频道。
效果介绍：如果能进入这些导航站的首页的购物频道，每天可以带来上百订单左右，但审核较严，需要你的品牌商城关键词在百度每天有5000左右搜索量才行。如果达不到这个标准，需要以做广告付费的形式进入。

由于传统企业缺乏互联网经验，更不用说建立线上渠道的经验，相信不久就会出现专业的全渠道方案解决服务商，不仅协助这些企业省人力物力、最快时间地进入这些有价值的线上渠道。服务商还需要策划一些渠道促销，购物卡渠道促销方案、团购与节庆、渠道促销方案、永不落幕的网上特卖会（银行）渠道促销方案等，正如线下世界进入沃尔玛卖场，要进行堆头促销，要派促销小姐现场导购。

此外，企业还有将网络推广与以上渠道结合的需求，如进入了新浪商城，在新浪做广告促销，进入了迅雷商城，利用迅雷的推广资源进行渠道促销，形成整合的推广效果，这种进入渠道再进行渠道推广方式，比现在单纯打网络广告的方式，ROI可以提高好几倍，从而达到替传统企业树线上品牌、建线上渠道、促渠道销售全面整合的效果。

扫盲GFW的工作原理和封锁技术

2013-12-10T12:36:00.001+11:00

GFW是Great Fire Wall的缩写，即“长城防火墙”。这个工程由若干个部分组成，实现不同功能。长城防火墙主要指TG监控和过滤互联网内容的软硬件系统，由服务器和路由器等设备，加上相关的应用程序所构成。

首先，需要强调的是，由于中国网络审查广泛，中国国内含有“不合适”内容的的网站，会受到政府直接的行政干预，被要求自我审查、自我监管，乃至关闭，所以GFW的主要作用在于分析和过滤中国境内外网络的资讯互相访问。

GFW对网络内容的过滤和分析是双向的，GFW不仅针对国内读者访问中国境外的网站进行干扰，也干扰国外读者访问主机在中国大陆的网站。
一关键字过滤阻断
关键字过滤系统。此系统能够从出口网关收集分析信息，过滤、嗅探指定的关键字。主要针对HTTP的默认端口：80端口，因为HTTP传播的内容是明文的内容，没有经过加密，而GFW是一个IDS(Intrusion detection system)。普通的关键词如果出现在HTTP请求报文的头部(如“Host: www.youtube.com”)时，则会马上伪装成对方向连接两端的计算机发送RST包(reset)干扰两者正常的TCP连接，进而使请求的内容无法继续查看。如果GFW在数据流中发现了特殊的内文关键词(如轮子，达赖等)时，其也会试图打断当前的连接，从而有时会出现网页开启一部分后突然停止的情况。在任何阻断发生后，一般在随后的90秒内同一IP地址均无法浏览对应IP地址相同端口上的内容。

二 IP地址封锁
IP 地址封锁是GFW通过路由器来控制的，在通往国外的最后一个网关上加上一条伪造的路由规则，导致通往某些被屏蔽的网站的所有IP数据包无法到达。路由器的正常工作方式是学习别的路由器广播的路由规则，遇到符合已知的IP转发规则的数据包，则按已经规则发送，遇到未知规则IP的数据，则转发到上一级网关。

而 GFW对于境外(中国大陆以外)的XX网站会采取独立IP封锁技术。然而部分XX网站使用的是由虚拟主机服务提供商提供的多域名、单(同)IP的主机托管服务，这就会造成了封禁某个IP地址，就会造成所有使用该服务提供商服务的其它使用相同IP地址服务器的网站用户一同遭殃，就算是正常的网站，也不能幸免。其中的内容可能并无不当之处，但也不能在中国大陆正常访问。现在GFW通常会将包含XX信息的网站或网页的URL加入关键字过滤系统，并可以防止民众透过普通海外HTTP代理服务器进行访问。
三特定端口封锁
GFW会丢弃特定IP地址上特定端口的所有数据包，使该IP地址上服务器的部分功能(如SSH的22、VPN的1723或SSL的443端口等)无法在中国大陆境内正常使用。

在中国移动、中国联通等部分ISP(手机IP段)，所有的PPTP类型的VPN都被封锁。

2011 年3月起，GFW开始对Google部分服务器的IP地址实施自动封锁(按时间段)某些端口，按时段对www.google.com(用户登录所有 Google服务时需此域名加密验证)和mail.google.com的几十个IP地址的443端口实施自动封锁，具体是每10或15分钟可以连通，接着断开，10或15分钟后再连通，再断开，如此循环，令中国大陆用户和Google主机之间的连接出现间歇性中断，使其各项服务出现问题。GFW这样的封锁手法很高明，因为Gmail并非被完全阻断，这令问题看上去好像出自Google本身。这就是你们认为Google抽风的原因。
四 SSL连接阻断
GFW 会阻断特定网站的SSL加密连接，方法是通过伪装成对方向连接两端的计算机发送RST包(RESET)干扰两者间正常的TCP连接，进而打断与特定IP地址之间的SSL(HTTPS，443端口)握手(如Gmail、Google文件、Google网上论坛等的SSL加密连接)，从而导致SSL连接失败。

当然由于SSL本身的特点，这并不意味着与网站传输的内容可被破译。
五 DNS劫持和污染
GFW主要采用DNS劫持和污染技术，使用Cisco提供的IDS系统来进行域名劫持，防止访问被过滤的网站，2002年Google被封锁期间其域名就被劫持到百度。中国部分ISP也会通过此技术插入广告。

对于含有多个IP地址或经常变更IP地址逃避封锁的域名，GFW通常会使用此方法进行封锁。具体方法是当用户向DNS服务器提交域名请求时，DNS返回虚假(或不解析)的IP地址。

全球一共有13组根域名服务器(Root Server)，目前中国大陆有F、I这2个根域DNS镜像，但现在均已因为多次DNS污染外国网络，而被断开与国际互联网的连接。

DNS劫持和污染是针对某些网站的最严重的干扰。
干扰的方式有两种：

一种是通过网络服务提供商(Internet Service Provider)提供的DNS服务器进行DNS欺骗，当人们访问某个网站时，需要要把域名转换为一个IP地址，DNS服务器负责将域名转换为IP地址，中国大陆的ISP接受通信管理局的屏蔽网站的指令后在DNS服务器里加入某些特定域名的虚假记录，当使用此DNS服务器的网络用户访问此特定网站时，DNS服务便给出虚假的IP地址，导致访问网站失败，甚至返回ISP运营商提供的出错页面和广告页面。

另一种是GFW在DNS查询使用的UDP的53端口上根据blacklist进行过滤，遇到通往国外的使用UDP53端口进行查询的DNS请求，就返回一个虚假的IP地址。

jsonp详解

2013-09-03T17:09:00.001+10:00

http://www.cnblogs.com/lemontea/archive/2012/12/11/2812268.html

面向站长和网站管理员的Web缓存加速指南

2013-08-14T12:26:00.003+10:00

这是一篇知识性的文档，主要目的是为了让Web缓存相关概念更容易被开发者理解并应用于实际的应用环境中。为了简要起见，某些实现方面的细节被简化或省略了。如果你更关心细节实现则完全不必耐心看完本文，后面参考文档和更多深入阅读部分可能是你更需要的内容。

什么是Web缓存，为什么要使用它？
缓存的类型：

浏览器缓存；
代理服务器缓存；

Web缓存无害吗？为什么要鼓励缓存？
Web缓存如何工作：
如何控制（控制不）缓存：

HTML Meta标签 vs. HTTP头信息；
Pragma HTTP头信息（为什么不起作用）；
使用Expires（过期时间）HTTP头信息控制保鲜期；
Cache-Control（缓存控制） HTTP头信息；
校验参数和校验；

创建利于缓存网站的窍门；
编写利于缓存的脚本；
常见问题解答；
缓存机制的实现：Web服务器端配置；
缓存机制的实现：服务器端脚本；
参考文档和深入阅读；
关于本文档；

什么是Web缓存，为什么要使用它？

Web缓存位于Web服务器之间（1个或多个，内容源服务器）和客户端之间（1个或多个）：缓存会根据进来的请求保存输出内容的副本，例如html页面，图片，文件（统称为副本），然后，当下一个请求来到的时候：如果是相同的URL，缓存直接使用副本响应访问请求，而不是向源服务器再次发送请求。

使用缓存主要有2大理由：

减少相应延迟：因为请求从缓存服务器（离客户端更近）而不是源服务器被相应，这个过程耗时更少，让web服务器看上去相应更快；
减少网络带宽消耗：当副本被重用时会减低客户端的带宽消耗；客户可以节省带宽费用，控制带宽的需求的增长并更易于管理。

缓存的类型

浏览器缓存

对于新一代的Web浏览器来说（例如：IE，Firefox）：一般都能在设置对话框中发现关于缓存的设置，通过在你的电脑上僻处一块硬盘空间用于存储你已经看过的网站的副本。浏览器缓存根据非常简单的规则进行工作：在同一个会话过程中（在当前浏览器没有被关闭之前）会检查一次并确定缓存的副本足够新。这个缓存对于用户点击“后退”或者点击刚访问过的链接特别有用，如果你浏览过程中访问到同一个图片，这些图片可以从浏览器缓存中调出而即时显现。

代理服务器缓存

Web代理服务器使用同样的缓存原理，只是规模更大。代理服务器群为成百上千用户服务使用同样的机制；大公司和ISP经常在他们的防火墙上架设代理缓存或者单独的缓存设备；

由于带路服务器缓存并非客户端或者源服务器的一部分，而是位于原网络之外，请求必须路由到他们才能起作用。一个方法是手工设置你的浏览器：告诉浏览器使用那个代理，另外一个是通过中间服务器：这个中间服务器处理所有的web请求，并将请求转发到后台网络，而用户不必配置代理，甚至不必知道代理的存在；

代理服务器缓存：是一个共享缓存，不只为一个用户服务，经常为大量用户使用，因此在减少相应时间和带宽使用方面很有效：因为同一个副本会被重用多次。

网关缓存

也被称为反向代理缓存或间接代理缓存，网关缓存也是一个中间服务器，和内网管理员部署缓存用于节省带宽不同：网关缓存一般是网站管理员自己部署：让他们的网站更容易扩展并获得更好的性能；
请求有几种方法被路由到网关缓存服务器上：其中典型的是让用一台或多台负载均衡服务器从客户端看上去是源服务器；

网络内容发布商 (Content delivery networks CDNs)分布网关缓存到整个（或部分）互联网上，并出售缓存服务给需要的网站，Speedera和Akamai就是典型的网络内容发布商(下文简称CDN)。

本问主要关注于浏览器和代理缓存，当然，有些信息对于网关缓存也同样有效；

Web缓存无害吗？为什么要鼓励缓存？

Web缓存在互联网上最容易被误解的技术之一：网站管理员经常怕对网站失去控制，由于代理缓存会“隐藏”他们的用户，让他们感觉难以监控谁在使用他们的网站。
不幸的是：就算不考虑Web缓存，互联网上也有很多网站使用非常多的参数以便管理员精确地跟踪用户如何使用他们的网站；如果这类问题也是你关心的，本文将告诉你如何获得精确的统计而不必将网站设计的非常缓存不友好。
另外一个抱怨是缓存会给用户过期或失效的数据；无论如何：本文可以告诉你怎样配置你的服务器来控制你的内容将被如何缓存。

CDN是另外一个有趣的方向，和其他代理缓存不同：CDN的网关缓存为希望被缓存的网站服务，没有以上顾虑。即使你使用了CDN，你也要考虑后续的代理服务器缓存和浏览器缓存问题。

另外一方面：如果良好地规划了你的网站，缓存会有助于网站服务更快，并节省服务器负载和互联网的链接请求。这个改善是显著的：一个难以缓存的网站可能需要几秒去载入页面，而对比有缓存的网站页面几乎是即时显现：用户更喜欢速度快的网站并更经常的访问；

这样想：很多大型互联网公司为全世界服务器群投入上百万资金，为的就是让用户访问尽可能快，客户端缓存也是这个目的，只不过更靠近用户一端，而且最好的一点是你甚至根本不用为此付费。

事实上，无论你是否喜欢，代理服务器和浏览器都回启用缓存。如果你没有配置网站正确的缓存，他们会按照缺省或者缓存管理员的策略进行缓存。

缓存如何工作

所有的缓存都用一套规则来帮助他们决定什么时候使用缓存中的副本提供服务（假设有副本可用的情况下）；一些规则在协议中有定义（HTTP协议1.0和1.1），一些规则由缓存的管理员设置（浏览器的用户或者代理服务器的管理员）；
一般说来：遵循以下基本的规则（不必担心，你不必知道所有的细节，细节将随后说明）

如果响应头信息：告诉缓存器不要保留缓存，缓存器就不会缓存相应内容；
如果请求信息是需要认证或者安全加密的，相应内容也不会被缓存；
如果在回应中不存在校验器（ETag或者Last-Modified头信息），缓存服务器会认为缺乏直接的更新度信息，内容将会被认为不可缓存。
一个缓存的副本如果含有以下信息：内容将会被认为是足够新的

含有完整的过期时间和寿命控制头信息，并且内容仍在保鲜期内；
浏览器已经使用过缓存副本，并且在一个会话中已经检查过内容的新鲜度；
缓存代理服务器近期内已经使用过缓存副本，并且内容的最后更新时间在上次使用期之前；
够新的副本将直接从缓存中送出，而不会向源服务器发送请求；

如果缓存的副本已经太旧了，缓存服务器将向源服务器发出请求校验请求，用于确定是否可以继续使用当前拷贝继续服务；

总之：新鲜度和校验是确定内容是否可用的最重要途径：

如果副本足够新，从缓存中提取就立刻能用了；
而经缓存器校验后发现副本的原件没有变化，系统也会避免将副本内容从源服务器整个重新传输一遍。

如何控制（控制不）缓存

有很多工具可以帮助设计师和网站管理员调整缓存服务器对待网站的方式，这也许需要你亲自下手对服务器的配置进行一些调整，但绝对值得；了解如何使用这些工具请参考后面的实现章节；

HTML meta标签和HTTP 头信息

HTML的编写者会在文档的区域中加入描述文档的各种属性，这些META标签常常被用于标记文档不可以被缓存或者标记多长时间后过期；
META标签使用很简单：但是效率并不高，因为只有几种浏览器会遵循这个标记（那些真正会“读懂”HTML的浏览器），没有一种缓存代理服务器能遵循这个规则（因为它们几乎完全不解析文档中HTML内容）；有事会在Web页面中增加：Pragma: no-cache这个META标记，如果要让页面保持刷新，这个标签其实完全没有必要。
如果你的网站托管在ISP机房中，并且机房可能不给你权限去控制HTTP的头信息（如：Expires和Cache-Control），大声控诉：这些机制对于你的工作来说是必须的；
另外一方面： HTTP头信息可以让你对浏览器和代理服务器如何处理你的副本进行更多的控制。他们在HTML代码中是看不见的，一般由Web服务器自动生成。但是，根据你使用的服务，你可以在某种程度上进行控制。在下文中：你将看到一些有趣的HTTP头信息，和如何在你的站点上应用部署这些特性。

HTTP头信息发送在HTML代码之前，只有被浏览器和一些中间缓存能看到，一个典型的HTTP 1.1协议返回的头信息看上去像这样：

HTTP/1.1 200 OK
Date: Fri, 30 Oct 1998 13:19:41 GMT
Server: Apache/1.3.3 (Unix)
Cache-Control: max-age=3600, must-revalidate
Expires: Fri, 30 Oct 1998 14:19:41 GMT
Last-Modified: Mon, 29 Jun 1998 02:28:12 GMT
ETag: "3e86-410-3596fbbc"
Content-Length: 1040
Content-Type: text/html

在头信息空一行后是HTML代码的输出，关于如何设置HTTP头信息请参考实现章节；

Pragma HTTP头信息 (为什么它不起作用)

很多人认为在HTTP头信息中设置了Pragma: no-cache后会让内容无法被缓存。但事实并非如此：HTTP的规范中，响应型头信息没有任何关于Pragma属性的说明，而讨论了的是请求型头信息 Pragma属性（头信息也由浏览器发送给服务器），虽然少数集中缓存服务器会遵循这个头信息，但大部分不会。用了Pragma也不起什么作用，要用就使用下列头信息：

使用Expires（过期时间）HTTP头信息来控制保鲜期

Expires（过期时间）属性是HTTP控制缓存的基本手段，这个属性告诉缓存器：相关副本在多长时间内是新鲜的。过了这个时间，缓存器就会向源服务器发送请求，检查文档是否被修改。几乎所有的缓存服务器都支持Expires（过期时间）属性；

大部分Web服务器支持你用几种方式设置Expires属性；一般的：可以设计一个绝对时间间隔：基于客户最后查看副本的时间（最后访问时间）或者根据服务器上文档最后被修改的时间；

Expires头信息：对于设置静态图片文件（例如导航栏和图片按钮）可缓存特别有用；因为这些图片修改很少，你可以给它们设置一个特别长的过期时间，这会使你的网站对用户变得相应非常快；他们对于控制有规律改变的网页也很有用，例如：你每天早上6点更新新闻页，你可以设置副本的过期时间也是这个时间，这样缓存服务器就知道什么时候去取一个更新版本，而不必让用户去按浏览器的“刷新”按钮。

过期时间头信息属性值只能是HTTP格式的日期时间，其他的都会被解析成当前时间“之前”，副本会过期，记住：HTTP的日期时间必须是格林威治时间（GMT），而不是本地时间。举例：

Expires: Fri, 30 Oct 1998 14:19:41 GMT

所以使用过期时间属性一定要确认你的Web服务器时间设置正确，一个途径是通过网络时间同步协议（Network Time Protocol NTP），和你的系统管理员那里你可以了解更多细节。
虽然过期时间属性非常有用，但是它还是有些局限，首先：是牵扯到了日期，这样Web服务器的时间和缓存服务器的时间必须是同步的，如果有些不同步，要么是应该缓存的内容提前过期了，要么是过期结果没及时更新。
还有一个过期时间设置的问题也不容忽视：如果你设置的过期时间是一个固定的时间，如果你返回内容的时候又没有连带更新下次过期的时间，那么之后所有访问请求都会被发送给源Web服务器，反而增加了负载和响应时间；

Cache-Control（缓存控制） HTTP头信息

HTTP 1.1介绍了另外一组头信息属性：Cache-Control响应头信息，让网站的发布者可以更全面的控制他们的内容，并定位过期时间的限制。
有用的 Cache-Control响应头信息包括：

max-age=[秒] — 执行缓存被认为是最新的最长时间。类似于过期时间，这个参数是基于请求时间的相对时间间隔，而不是绝对过期时间，[秒]是一个数字，单位是秒：从请求时间开始到过期时间之间的秒数。
s-maxage=[秒] — 类似于max-age属性，除了他应用于共享（如：代理服务器）缓存
public — 标记认证内容也可以被缓存，一般来说：经过HTTP认证才能访问的内容，输出是自动不可以缓存的；
no-cache — 强制每次请求直接发送给源服务器，而不经过本地缓存版本的校验。这对于需要确认认证应用很有用（可以和public结合使用），或者严格要求使用最新数据的应用（不惜牺牲使用缓存的所有好处）；
no-store — 强制缓存在任何情况下都不要保留任何副本
must-revalidate — 告诉缓存必须遵循所有你给予副本的新鲜度的，HTTP允许缓存在某些特定情况下返回过期数据，指定了这个属性，你高速缓存，你希望严格的遵循你的规则。
proxy-revalidate — 和 must-revalidate类似，除了他只对缓存代理服务器起作用

举例:

Cache-Control: max-age=3600, must-revalidate

如果你计划试用Cache-Control属性，你应该看一下这篇HTTP文档，详见参考和深入阅读；

校验参数和校验

在Web缓存如何工作：我们说过：校验是当副本已经修改后，服务器和缓存之间的通讯机制；使用这个机制：缓存服务器可以避免副本实际上仍然足够新的情况下重复下载整个原件。
校验参数非常重要，如果1个不存在，并且没有任何信息说明保鲜期（Expires或Cache-Control）的情况下，缓存将不会存储任何副本；
最常见的校验参数是文档的最后修改时间，通过最后Last-Modified头信息可以，当一份缓存包含Last-Modified信息，他基于此信息，通过添加一个If-Modified-Since请求参数，向服务器查询：这个副本从上次查看后是否被修改了。
HTTP 1.1介绍了另外一个校验参数： ETag，服务器是服务器生成的唯一标识符ETag，每次副本的标签都会变化。由于服务器控制了ETag如何生成，缓存服务器可以通过If-None-Match请求的返回没变则当前副本和原件完全一致。
所有的缓存服务器都使用Last-Modified时间来确定副本是否够新，而ETag校验正变得越来越流行；
所有新一代的Web服务器都对静态内容（如：文件）自动生成ETag和Last-Modified头信息，而你不必做任何设置。但是，服务器对于动态内容（例如：CGI,ASP或数据库生成的网站）并不知道如何生成这些信息，参考一下编写利于缓存的脚本章节；

创建利于缓存网站的窍门

除了使用新鲜度信息和校验，你还有很多方法使你的网站缓存友好。

保持URL稳定：这是缓存的金科玉律，如果你给在不同的页面上，给不同用户或者从不同的站点上提供相同的内容，应该使用相同的URL，这是使你的网站缓存友好最简单，也是最高效的方法。例如：如果你在页面上使用 "/index.html" 做为引用，那么就一直用这个地址；
使用一个共用的库存放每页都引用的图片和其他页面元素；
对于不经常改变的图片/页面启用缓存，并使用Cache-Control: max-age属性设置一个较长的过期时间；
对于定期更新的内容设置一个缓存服务器可识别的max-age属性或过期时间；
如果数据源（特别是下载文件）变更，修改名称，这样：你可以让其很长时间不过期，并且保证服务的是正确的版本；而链接到下载文件的页面是一个需要设置较短过期时间的页面。
万不得已不要改变文件，否则你会提供一个非常新的Last-Modified日期；例如：当你更新了网站，不要复制整个网站的所有文件，只上传你修改的文件。
只在必要的时候使用Cookie，cookie是非常难被缓存的，而且在大多数情况下是不必要的，如果使用cookie，控制在动态网页上；
减少试用SSL，加密的页面不会被任何共享缓存服务器缓存，只在必要的时候使用，并且在SSL页面上减少图片的使用；
使用可缓存性评估引擎，这对于你实践本文的很多概念都很有帮助；

编写利于缓存的脚本

脚本缺省不会返回校验参数（返回Last-Modified或ETag头信息）或其他新鲜度信息（Expires或Cache-Control），有些动态脚本的确是动态内容（每次相应内容都不一样），但是更多（搜索引擎，数据库引擎网站）网站还是能从缓存友好中获益的。
一般说来，如果脚本生成的输出在未来一段时间（几分钟或者几天）都是可重复复制的，那么就是可缓存的。如果脚本输出内容只随URL变化而变化，也是可缓存的；但如果输出会根据cookie，认证信息或者其他外部条件变化，则还是不可缓存的。

最利于缓存的脚本就是将内容改变时导出成静态文件，Web服务器可以将其当作另外一个网页并生成和试用校验参数，让一些都变得更简单，只需要写入文件即可，这样最后修改时间也有了；
另外一个让脚本可缓存的方法是对一段时间内能保持较新的内容设置一个相对寿命的头信息，虽然通过Expires头信息也可以实现，但更容易的是用Cache-Control: max-age属性，它会让首次请求后一段时间内缓存保持新鲜；
如果以上做法你都做不到，你可以让脚本生成一个校验属性，并对 If-Modified-Since 和/或If-None-Match请求作出反应，这些属性可以从解析HTTP头信息得到，并对符合条件的内容返回304 Not Modified（内容未改变），可惜的是，这种做法比不上前2种高效；

其他窍门：

尽量避免使用POST，除非万不得已，POST模式的返回内容不会被大部分缓存服务器保存，如果你发送内容通过URL和查询（通过GET模式）的内容可以缓存下来供以后使用；
不要在URL中加入针对每个用户的识别信息：除非内容是针对每个用户不同的；
不要统计一个用户来自一个地址的所有请求，因为缓存常常是一起工作的；
生成并返回Content-Length头信息，如果方便的话，这个属性让你的脚本在可持续链接模式时：客户端可以通过一个TCP/IP链接同时请求多个副本，而不是为每次请求单独建立链接，这样你的网站相应会快很多；

具体定义请参考实现章节。

常见问题解答

让网站变得可缓存的要点是什么？

好的策略是确定那些内容最热门，大量的复制（特别是图片）并针对这些内容先部署缓存。

如何让页面通过缓存达到最快相应？

缓存最好的副本是那些可以长时间保持新鲜的内容；基于校验虽然有助于加快相应，但是它不得不和源服务器联系一次去检查内容是否够新，如果缓存服务器上就知道内容是新的，内容就可以直接相应返回了。

我理解缓存是好的，但是我不得不统计多少人访问了我的网站！

如果你必须知道每次页面访问的，选择【一】个页面上的小元素，或者页面本身，通过适当的头信息让其不可缓存，例如：可以在每个页面上部署一个1x1像素的透明图片。Referer头信息会有包含这个图片的每个页面信息；
明确一点：这个并不会给你一个关于你用户精确度很高的统计，而且这对互联网和你的用户这都不太好，消耗了额外的带宽，强迫用户去访问无法缓存的内容。了解更多信息，参考访问统计资料。

我如何能看到HTTP头信息的内容？

很多浏览器在页面属性或类似界面中可以让你看到Expires 和Last-Modified信息；如果有的话：你会找到页面信息的菜单和页面相关的文件（如图片），并且包含他们的详细信息；
看到完整的头信息，你可以用telnet手工连接到Web服务器；
为此：你可能需要用一个字段指定端口（缺省是80），或者链接到www.example.com:80 或者 www.example.com 80(注意是空格)，更多设置请参考一下telnet客户端的文档；
打开网站链接：请求一个查看链接，如果你想看到http://www.example.com/foo.html 连接到www.example.com的80端口后，键入：

GET /foo.html HTTP/1.1 [回车]
GET /foo.html HTTP/1.1 [return]
Host: www.example.com [回车][回车]
Host: www.example.com [return][return]

在[回车]处按键盘的回车键；在最后，要按2次回车，然后，就会输出头信息及完整页面，如果只想看头信息，将GET换成HEAD。

我的页面是密码保护的，代理缓存服务器如何处理他们？

缺省的，网页被HTTP认证保护的都是私密内容，它们不会被任何共享缓存保留。但是，你可以通过设置Cache-Control: public让认证页面可缓存，HTTP 1.1标准兼容的缓存服务器会认出它们可缓存。
如果你认为这些可缓存的页面，但是需要每个用户认证后才能看，可以组合使用Cache-Control: public和no-cache头信息，高速缓存必须在提供副本之前，将将新客户的认证信息提交给源服务器。设置就是这样：

Cache-Control: public, no-cache

无论如何：这是减少认证请求的最好方法，例如：你的图片是不机密的，将它们部署在另外一个目录，并对此配置服务器不强制认证。这样，那些图片会缺省都缓存。

我们是否要担心用户通过cache访问我的站点？

代理服务器上SSL页面不会被缓存（不推荐被缓存），所以你不必为此担心。但是，由于缓存保存了非SSL请求和从他们抓取的URL，你要意识到没有安全保护的网站，可能被不道德的管理员可能搜集用户隐私，特别是通过URL。
实际上，位于服务器和客户端之间的管理员可以搜集这类信息。特别是通过CGI脚本在通过URL传递用户名和密码的时候会有很大问题；这对泄露用户名和密码是一个很大的漏洞；
如果你初步懂得互联网的安全机制，你不会对缓存服务器有任何。

我在寻找一个包含在Web发布系统解决方案，那些是比较有缓存意识的系统？

这很难说，一般说来系统越复杂越难缓存。最差就是全动态发布并不提供校验参数；你无发缓存任何内容。可以向系统提供商的技术人员了解一下，并参考后面的实现说明。

我的图片设置了1个月后过期，但是我现在需要现在更新。

过期时间是绕不过去的，除非缓存（浏览器或者代理服务器）空间不足才会删除副本，缓存副本在过期之间会被一直使用。
最好的办法是改变它们的链接，这样，新的副本将会从源服务器上重新下载。记住：引用它们的页面本身也会被缓存。因此，使用静态图片和类似内容是很容易缓存的，而引用他们的HTML页面则要保持非常更新；
如果你希望对指定的缓存服务器重新载入一个副本，你可以强制使用“刷新”（在FireFox中在reload的时候按住shift键：就会有前面提到恶Pragma: no-cache头信息发出）。或者你可以让缓存的管理员从他们的界面中删除相应内容；

我运行一个Web托管服务，如何让我的用户发布缓存友好的网页？

如果你使用apahe，可以考虑允许他们使用.htaccess文件并提供相应的文档；
另外一方面：你也可以考虑在各种虚拟主机上建立各种缓存策略。例如：你可以设置一个目录 /cache-1m 专门用于存放访问1个月的访问，另外一个 /no-cache目录则被用提供不可存储副本的服务。
无论如何：对于大量用户访问还是应该用缓存。对于大网站，这方面的节约很明显（带宽和服务器负载）；

我标记了一些网页是可缓存的，但是浏览器仍然每次发送请求给服务。如何强制他们保存副本？

缓存服务器并不会总保存副本并重用副本；他们只是在特定情况下会不保存并使用副本。所有的缓存服务器都回基于文件的大小，类型（例如：图片页面），或者服务器空间的剩余来确定如何缓存。你的页面相比更热门或者更大的文件相比，并不值得缓存。
所以有些缓存服务器允许管理员根据文件类型确定缓存副本的优先级，允许某些副本被永久缓存并长期有效；

缓存机制的实现 - Web服务器端配置

一般说来，应该选择最新版本的Web服务器程序来部署。不仅因为它们包含更多利于缓存的功能，新版本往往在性能和安全性方面都有很多的改善。

Apache HTTP服务器

Apache有些可选的模块来包含这些头信息：包括Expires和Cache-Control。这些模块在1.2版本以上都支持；
这些模块需要和apache一起编译；虽然他们已经包含在发布版本中，但缺省并没有启用。为了确定相应模块已经被启用：找到httpd程序并运行httpd -l 它会列出可用的模块，我们需要用的模块是mod_expires和mod_headers

如果这些模块不可用，你需要联系管理员，重新编译并包含这些模块。这些模块有时候通过配置文件中把注释掉的配置启用，或者在编译的时候增加-enable -module=expires和-enable-module=headers选项（在apache 1.3和以上版本）。参考Apache发布版中的INSTALL文件；

Apache一旦启用了相应的模块，你就可以在.htaccess文件或者在服务器的access.conf文件中通过mod_expires设置副本什么时候过期。你可设置过期从访问时间或文件修改时间开始计算，并且应用到某种文件类型上或缺省设置，参考模块的文档获得更多信息，或者遇到问题的时候向你身边的apache专家讨教。
应用Cache-Control头信息，你需要使用mod_headers,它将允许你设置任意的HTTP头信息，参考mod_headers的文档可以获得更多资料；
这里有个例子说明如何使用头信息：

.htaccess文件允许web发布者使用命令只在配置文件中用到的命令。他影响到所在目录及其子目录；问一下你的服务器管理员确认这个功能是否启用了。

### 启用 mod_expires
ExpiresActive On
### 设置 .gif 在被访问过后1个月过期。
ExpiresByType image/gif A2592000
### 其他文件设置为最后修改时间1天后过期
### (用了另外的语法)
ExpiresDefault "modification plus 1 day"
### 在index.html文件应用 Cache-Control头属性

Header append Cache-Control "public, must-revalidate"

注意：在适当情况下mod_expires会自动计算并插入Cache-Control:max-age 头信息

Apache 2.0的配置和1.3类似，更多信息可以参考2.0的mod_expires和mod_headers文档；

Microsoft IIS服务器

Microsoft的IIS可以非常容易的设置头信息，注意：这只针对IIS 4.0服务器，并且只能在NT服务器上运行。
为网站的一个区域设置头信息，先要到管理员工具界面中，然后设置属性。选择HTTP Header选单，你会看到2个有趣的区域：启用内容过期和定制HTTP头信息。头一个设置会自动配置，第二个可以用于设置Cache-Control头信息；
设置asp页面的头信息可以参考后面的ASP章节，也可以通过ISAPI模块设置头信息，细节请参考MSDN。

Netscape/iPlanet企业服务器

3.6版本以后，Netscape/iPlanet已经不能设置Expires头信息了，他从3.0版本开始支持HTTP 1.1的功能。这意味着HTTP 1.1的缓存（代理服务器/浏览器）优势都可以通过你对Cache-Control设置来获得。
使用Cache-Control头信息，在管理服务器上选择内容管理|缓存设置目录。然后：使用资源选择器，选择你希望设置头信息的目录。设置完头信息后，点击“OK”。更多信息请参考Netscape/iPlanet企业服务器的手册。

缓存机制的实现：服务器端脚本

需要注意的一点是：也许服务器设置HTTP头信息比脚本语言更容易，但是两者你都应该使用。
因为服务器端的脚本主要是为了动态内容，他本身不产生可缓存的文件页面，即使内容实际是可以缓存的。如果你的内容经常改变，但是不是每次页面请求都改变，考虑设置一个Cache-Control: max-age头信息；大部分用户会在短时间内多次访问同一页面。例如：用户点击“后退”按钮，即使没有新内容，他们仍然要再次从服务器下载内容查看。

CGI程序

CGI脚本是生成内容最流行的方式之一，你可以很容易在发送内容之前的扩展HTTP头信息；大部分CGI实现都需要你写 Content-Type头信息，例如这个Perl脚本：

#!/usr/bin/perl
print "Content-type: text/html\n";
print "Expires: Thu, 29 Oct 1998 17:04:19 GMT\n";
print "\n";
### 后面是内容体...

由于都是文本，你可以很容易通过内置函数生成Expires和其他日期相关的头信息。如果你使用Cache-Control: max-age;会更简单；

print "Cache-Control: max-age=600\n";

这样脚本可以在被请求后缓存10分钟；这样用户如果按“后退”按钮，他们不会重新提交请求；
CGI的规范同时也允许客户端发送头信息，每个头信息都有一个‘HTTP_’的前缀；这样如果一个客户端发送一个If-Modified-Since请求，就是这样的：

HTTP_IF_MODIFIED_SINCE = Fri, 30 Oct 1998 14:19:41 GMT

参考一下cgi_buffer库，一个自动处理ETag的生成和校验的库，生成Content-Length属性和对内容进行gzip压缩。在Python脚本中也只需加入一行；

服务器端包含 Server Side Includes

SSI（经常使用.shtml扩展名）是网站发布者最早可以生成动态内容的方案。通过在页面中设置特别的标记，也成为一种嵌入HTML的脚本；
大部分SSI的实现无法设置校验器，于是无法缓存。但是Apache可以通过对特定文件的组执行权限设置实现允许用户设置那种SSI可以被缓存；结合XbitHack调整整个目录。更多文档请参考mod_include文档。

PHP

PHP是一个内建在web服务器中的服务器端脚本语言，当做为HTML嵌入式脚本，很像SSI，但是有更多的选项，PHP可以在各种Web服务器上设置为CGI模式运行，或者做为Apache的模块；
缺省PHP生成副本没有设置校验器，于是也无法缓存，但是开发者可以通过Header()函数来生成HTTP的头信息；
例如：以下代码会生成一个Cache-Control头信息，并设置为3天以后过期的Expires头信息；

Header("Cache-Control: must-revalidate");

$offset = 60 * 60 * 24 * 3;
$ExpStr = "Expires: " . gmdate("D, d M Y H:i:s", time() + $offset) . " GMT";
Header($ExpStr);
?>

记住： Header()的输出必须先于所有其他HTML的输出；
正如你看到的：你可以手工创建HTTP日期；PHP没有为你提供专门的函数（新版本已经让这个越来越容易了，请参考PHP的日期相关函数文档），当然，最简单的还是设置Cache-Control: max-age头信息，而且对于大部分情况都比较适用；
更多信息，请参考header相关的文档；
也请参考一下cgi_buffer库，自动处理ETag的生成和校验，Content-Length生成和内容的gzip压缩，PHP脚本只需包含1行代码；

Cold Fusion

Cold Fusion是Macromedia的商业服务器端脚本引擎，并且支持多种Windows平台，Linux平台和多种Unix平台。Cold Fusion通过CFHEADER标记设置HTTP头信息相对容易。可惜的是：以下的Expires头信息的设置有些容易误导；

它并不像你想像的那样工作，因为时间（本例中为请求发起的时间）并不会被转换成一个符合HTTP时间，而且打印出副本的Cold fusion的日期/时间对象，大部分客户端会忽略或者将其转换成1970年1月1日。
但是：Cold Fusion另外提供了一套日期格式化函数， GetHttpTimeSTring. 结合DateAdd函数，就很容易设置过期时间了，这里我们设置一个Header声明副本在1个月以后过期；

你也可以使用CFHEADER标签来设置Cache-Control: max-age等其他头信息；
记住：Web服务器也会将头信息设置转给Cold Fusion(做为CGI运行的时候)，检查你的服务器设置并确定你是否可以利用服务器设置代替Cold Fusion。

ASP和ASP.NET

在asp中设置HTTP头信息是：确认Response方法先于HTML内容输出前被调用，或者使用 Response.Buffer暂存输出；同样的：注意某些版本的IIS缺省设置会输出Cache-Control: private 头信息，必须声明成public才能被共享缓存服务器缓存。
IIS的ASP和其他web服务器都允许你设置HTTP头信息，例如：设置过期时间，你可以设置Response对象的属性；

<% Response.Expires=1440 %>

设置请求的副本在输出的指定分钟后过期，类似的：也可以设置绝对的过期时间（确认你的HTTP日期格式正确）

<% Response.ExpiresAbsolute=#May 31,1996 13:30:15 GMT# %>

Cache-Control头信息可以这样设置：

<% Response.CacheControl="public" %>

在ASP.NET中，Response.Expires 已经不推荐使用了，正确的方法是通过Response.Cache设置Cache相关的头信息；

Response.Cache.SetExpires ( DateTime.Now.AddMinutes ( 60 ) ) ;
Response.Cache.SetCacheability ( HttpCacheability.Public ) ;

参考MSDN文档可以找到更多相关新年系；

参考文档和深入阅读

HTTP 1.1 规范定义

HTTP 1.1的规范有大量的扩展用于页面缓存，以及权威的接口实现指南，参考章节：13, 14.9, 14.21, 以及 14.25.

Web-Caching.com

非常精彩的介绍缓存相关概念，并介绍其他在线资源。

关于非连续性访问统计

Jeff Goldberg内容丰富的演说告诉你为什么不应该过度依赖访问统计和计数器；

可缓存性检测引擎

可缓存的引擎设计，检测网页并确定其如何与Web缓存服务器交互，这个引擎配合这篇指南是一个很好的调试工具，

cgi_buffer库

包含库：用于CGI模式运行的Perl/Python/PHP脚本，自动处理ETag生成/校验，Content-Length生成和内容压缩。正确地。 Python版本也被用作其他大量的CGI脚本。

成功创业家的法则：学好再做还是边做边学？

2013-07-04T13:18:00.000+10:00

今日忙碌，再以以前作品《别学北极熊》其中一篇章摘录一段给各位分享：
成功创业家都不约而同的告诉我，他们创业的时候，根本不知道自己在做什么。假如他们当初真的想得很清楚，再三的确认无误才宣布创业，可能就永远不会创业了，不可能以成功创业家悠闲姿态坐在我面前。
成功创业家一点也不讳言，他们在创业初期，是从跌跌撞撞中闯出一番头绪。第一次创业，一群二十几岁的人，能懂得什么东西？年纪三十出头就把公司卖掉的杨孟佑回忆当时年纪小：都是靠自己的感觉，随后再调整。
你可以看到，成功创业家虽然是这世代最年轻就累积财富的一群，他们的学、经历却不一定是同年纪中最好的。为什么？这是因为，那些总是从最好的学校出来、录取最好的公司的高层人士，从小到大都在做正确的事，养成了做什么事都要求正确的习惯，在创业方面反而就缚手缚脚。他们都是先学好再做好，成功创业家则是一边做一边学。科技创业，本来就是需要一些傻劲；那些习惯做正确的事的守本份的人，傻劲就缺了一些。
大部份的人都缺乏傻劲，也因此无法认同创业家的傻劲。他们看到别人创业，第一句话就是：你，真的可以创业吗？听了对方的点子，还没听完就说：真的有这么简单吗？等到他也开始羡慕成功创业家，打算自己出来创业时，他会先做了非常详尽的市场调查，各项细节都考虑了非常详尽，还很害怕别人将他的点子偷走，这样的人，速度太慢，要考虑的事情太多，便无法支持到最后一刻，创业也无法成功。
成功创业家想都不想就跳下去，如此莽撞的行为为什么反而容易创业成功？大概是因为科技创业成功的人，一定是靠创新，在产业里应该是第一位。这就好像田径赛。跑第二名的，可以跟着第一名跑，第三名则可以跟着第一和第二名跑，但，身为第一名的，若还东张西望、研究自己跑的跑道是否正确，就会愈跑愈慢，跑得摇摇晃晃，跑得不够坚决，很快就会被第二名赶上去，要不也自己先精疲力竭了。
林百里当初创立广达电脑，就是一口气就砸了三千万资金、聘了二十余人的团队，不到半年就做出了产品。也就是林百里迅速的动作，公司马上取得先机，获欧美大厂订单，也因而进步迅速，让广达先一步的成为全球最大的笔记型电脑工厂。
看着各方创业家成长长达二十年的成功创业家沙正治，也对于这件事有很深刻的感觉。他说，成功创业家当然也不是随便创业，但他们作初期的创业分析时，都是盲目的自信。到最后，产品完成的期限一定是一延再延，比计画中的还长几倍。等到把东西好不容易都做出来了，人家就是不买；有时候，别人又突然买了，你也摸不透他为什么买了！
既然再厉害的创业家都很难计划得周全，所以周全就不是这么重要了。创业，要有一种永不妥协的个性和宗教式的狂热。沙正治说：太注重理性、完美的人，并不适合创业。
科技本身本来就是充满风险，已经成功五次的人，下次不见得会成功；已经失败五次的人，下次也不见得会失败。就是因为这样，成功创业家这样的做下去精神，让他们至少比别人更有机会。创业家一定要有勇气大声说：没关系，做下去，这次或许失败了，但一定会有成功的一天！
而做中学，就是最好的学习方法。若创业家没有先起个头，他也没机会调整方向，也就没机会将他个人和公司透过学习而提升到下一步的程度，成为成功创业家。
在印度被称作教父级的创业元老雷奇（Kanwal Rekhi），虽然很聪明，从来学不会做人处事的圆融技巧，七零年代，在美国各大公司工作了林林总总十一年，却从来没担任过比系统工程师更高的职位。老板告诉他，因为他太聪明，是个不可多得的技术天才，所以不忍埋没他的才能，不能让他当经理。雷奇愤而和他的印度朋友一起创立Excelan公司，虽然技术很强，但在当时白人气氛下，雷奇又不擅做人，资金找得非常辛苦，最后好不容易从一个白人创投拿到钱。
拿到钱后，没人放心让雷自己做，一开始执行长给别人做。后来他做不下去，雷奇才重新接掌，但随后又因为公司要上市被换下来，之后又因为执行长管不住才被换回来。没想到，雷奇做了以后，管理公司的能力大增，因为他喜欢当老板的感觉做得好。后来，原本看起来和人无法相处的雷奇，做到Novell公司的技术长，并在故乡印度做了一连串有远见的东西，他被印度人称为爸爸，登上了富比士（ Forbes）的封面。成为一个最受尊敬的人。但，有谁去想过，为何他能从一个怪异孤僻的人，变成人人爱戴的人，这些都是从他创业的过程中做中学出来的。
注意，并不是所有事都可以随便做下去试试。成功创业家做下去之前，还是对财务要有一定的规画。张敦凯在这方面就很有经验了。当时他靠着从前工作所积得的一些现金和股票，算一算，没收入仍可撑二到三年，在创业之前，在财务上已经有了最坏的准备。除了个人以外，在公司的财务也要注意，方向错了没关系，但公司财务的观念一定要有。不知道这产品能不能用无所谓，但一定要知道这钱能烧多久。
把财务都算清楚以后，张敦凯就和其他的创业家一样，捏起鼻孔噗通跳进水里。当时他才三十三岁，并未真的懂得从市场的角度来看东西，只大概看了一下市场，觉得市场大概蛮大的。然后就钻了进去，中间方向有点错，但都还可以改，一边改，一边就看得到市场中有大大小小的缝隙，就能找到自己的特殊点（niche）。张敦凯最后终于突破了一重又一重的难关，他的公司也在台湾上市了。回想当年当他还是青涩的创业家一路学来的过程，他不禁一笑：假如当时想得太清楚，就不会出来创业啦！
而成功创业家勇于做下去，也是在为自己增加成功的机会。多尝试者，铁定让成功机率增加。一次又一次的试，从每次尝试中去作微调，就会愈来愈容易成功。
把公司卖掉赚进亿万财富的陈劲初，回想当年创业的时候，一心只想设计一个全世界唯一做这东西的积体电路，就找了一个朋友，两人很高兴的做起来了。等到做完积体电路才发现没有电路板可装这个积体电路，只好自己再继续做电路板。等到做完电路板，又发现市场上没软体可用这样的电路板，于是就连软体也自己做。等到所有东西都做完了，发现没人帮他们卖产品，只好跑来自己卖。这些都不见得是当初刚创业的人所想得到的，但，若没有做出积体电路，怎么知道电路板需要呢？若没做到下一步，要怎么知道其它东西有需要呢？
这些成功创业家一致认为，尤其是东方人，更需要训练不怕失败的饪性。科技大老史钦泰认为，东方的教育系统在培养学龄儿童不怕输精神方面，做得相当少，因此东方人创业家相对就比较少。史钦泰忧心国内成者为王，败者为寇的竞争环境，虽然刺激很多人进步再进步，但同时也让很多人由于怕失败了被嘲笑、被以异样眼光对待，于是对于冒险一途望之却步，许多创意十足的构想也从来没人敢拿出来发表。
成功创业家根本不知道要向谁学。所以他们只能一边做一边学。
也就是说，创业成功的技巧无它，只要你肯踏出第一步，一边做一边学！

Eclipse Java EE jQuery Validation Error Workaround

2013-06-29T15:38:00.002+10:00

During my recent Java EE project I came across an annoying bug which always showed an Error Symbol on my root project folder. At first I thought it was a Java error but then I saw it was caused by the minified version of jQuery (jquery-1.7.2.min.js) in my case. This is an Eclipse bug already reported in summer 2011. I guess this can also happen with other minified JavaScript files.

Workaround – How to fix

To get rid of the annoying Error symbol do the following:

Right click your Project root folder in your Eclipse Project Explorer View
Go to Properties -> JavaScript -> Include Path -> Source Tab
Select Excluded and Edit… and then Add..
Now you can either browse for JavaScript file which has errors or just enter a wildcard patternwhich will exclude anything matched by your pattern. In my case in entered **/jquery*.js to exclude all jQuery library files.
Then you can hit OK, Finish and OK again
Your Eclipse Progress View should now show a Building Workspace message
Tada! The Error Symbol is gone!

What do “branch”, “tag” and “trunk” mean in Subversion repositories?

2013-06-22T14:16:00.000+10:00

Trunk would be the main body of development, originating from the start of the project until the present.
Branch will be a copy of code derived from a certain point in the trunk that is used for applying major changes to the code while preserving the integrity of the code in the trunk. If the major changes work according to plan, they are usually merged back into the trunk.
Tag will be a point in time on the trunk or a branch that you wish to preserve. The two main reasons for preservation would be that either this is a major release of the software, whether alpha, beta, RC or RTM, or this is the most stable point of the software before major revisions on the trunk were applied.
For example, let's say you start a new project. You start working in "trunk", on what will eventually be released as version 1.0.
- trunk/ - development version, soon to be 1.0
- branches/ - empty
Once 1.0.0 is finished, you branch trunk into a new "1.0" branch, and create a "1.0.0" tag. Now work on what will eventually be 1.1 continues in trunk.
- trunk/ - development version, soon to be 1.1
- branches/1.0 - 1.0.0 release version
- tags/1.0.0 - 1.0.0 release version
You come across some bugs in the code, and fix them in trunk, and then merge the fixes over to the 1.0 branch. You can also do the opposite, and fix the bugs in the 1.0 branch and then merge them back to trunk, but commonly projects stick with merging one-way only to lessen the chance of missing something. Sometimes a bug can only be fixed in 1.0 because it is obsolete in 1.1. It doesn't really matter: you only want to make sure that you don't release 1.1 with the same bugs that have been fixed in 1.0.
- trunk/ - development version, soon to be 1.1
- branches/1.0 - upcoming 1.0.1 release
- tags/1.0.0 - 1.0.0 release version
Once you find enough bugs (or maybe one critical bug), you decide to do a 1.0.1 release. So you make a tag "1.0.1" from the 1.0 branch, and release the code. At this point, trunk will contain what will be 1.1, and the "1.0" branch contains 1.0.1 code. The next time you release an update to 1.0, it would be 1.0.2.
- trunk/ - development version, soon to be 1.1
- branches/1.0 - upcoming 1.0.2 release
- tags/1.0.0 - 1.0.0 release version
- tags/1.0.1 - 1.0.1 release version
Eventually you are almost ready to release 1.1, but you want to do a beta first. In this case, you likely do a "1.1" branch, and a "1.1beta1" tag. Now, work on what will be 1.2 (or 2.0 maybe) continues in trunk, but work on 1.1 continues in the "1.1" branch.
- trunk/ - development version, soon to be 1.2
- branches/1.0 - upcoming 1.0.2 release
- branches/1.1 - upcoming 1.1.0 release
- tags/1.0.0 - 1.0.0 release version
- tags/1.0.1 - 1.0.1 release version
- tags/1.1beta1 - 1.1 beta 1 release version
Once you release 1.1 final, you do a "1.1" tag from the "1.1" branch.
You can also continue to maintain 1.0 if you'd like, porting bug fixes between all three branches (1.0, 1.1, and trunk). The important takeaway is that for every main version of the software you are maintaining, you have a branch that contains the latest version of code for that version.

浏览器缓存机制

2013-06-05T19:37:00.002+10:00

Cache-Control

Cache-Control 是最重要的规则。这个字段用于指定所有缓存机制在整个请求/响应链中必须服从的指令。这些指令指定用于阻止缓存对请求或响应造成不利干扰的行为。这些指令通常覆盖默认缓存算法。缓存指令是单向的，即请求中存在一个指令并不意味着响应中将存在同一个指令。

cache-control 定义是：Cache-Control = “Cache-Control” “:” cache-directive。表 1 展示了适用的值。

表 1. 常用 cache-directive 值
Cache-directive	说明
public	所有内容都将被缓存
private	内容只缓存到私有缓存中
no-cache	所有内容都不会被缓存
no-store	所有内容都不会被缓存到缓存或 Internet 临时文件中
must-revalidation/proxy-revalidation	如果缓存的内容失效，请求必须发送到服务器/代理以进行重新验证
max-age=xxx (xxx is numeric)	缓存的内容将在 xxx 秒后失效, 这个选项只在HTTP 1.1可用, 并如果和Last-Modified一起使用时, 优先级较高

表 2 表明在不同的情形下，浏览器是将请求重新发送到服务器还是使用缓存的内容。

表 2. 对 cache-directive 值的浏览器响应
Cache-directive	打开一个新的浏览器窗口	在原窗口中单击 Enter 按钮	刷新	单击 Back 按钮
public	浏览器呈现来自缓存的页面	浏览器呈现来自缓存的页面	浏览器重新发送请求到服务器	浏览器呈现来自缓存的页面
private	浏览器重新发送请求到服务器	第一次，浏览器重新发送请求到服务器；此后，浏览器呈现来自缓存的页面	浏览器重新发送请求到服务器	浏览器呈现来自缓存的页面
no-cache/no-store	浏览器重新发送请求到服务器	浏览器重新发送请求到服务器	浏览器重新发送请求到服务器	浏览器重新发送请求到服务器
must-revalidation/proxy-revalidation	浏览器重新发送请求到服务器	第一次，浏览器重新发送请求到服务器；此后，浏览器呈现来自缓存的页面	浏览器重新发送请求到服务器	浏览器呈现来自缓存的页面
max-age=xxx (xxx is numeric)	在 xxx 秒后，浏览器重新发送请求到服务器	在 xxx 秒后，浏览器重新发送请求到服务器	浏览器重新发送请求到服务器	在 xxx 秒后，浏览器重新发送请求到服务器

Cache-Control是关于浏览器缓存的最重要的设置，因为它覆盖其他设置，比如 Expires 和 Last-Modified。另外，由于浏览器的行为基本相同，这个属性是处理跨浏览器缓存问题的最有效的方法。

失效

Expires 头部字段提供一个日期和时间，响应在该日期和时间后被认为失效。失效的缓存条目通常不会被缓存（无论是代理缓存还是用户代理缓存）返回，除非首先通过原始服务器（或者拥有该实体的最新副本的中介缓存）验证。（注意：cache-control max-age 和 s-maxage 将覆盖 Expires 头部。）

Expires 字段接收以下格式的值：“Expires: Sun, 08 Nov 2009 03:37:26 GMT”。如果查看内容时的日期在给定的日期之前，则认为该内容没有失效并从缓存中提取出来。反之，则认为该内容失效，缓存将采取一些措施。表 3-6 表明针对不同用户操作的不同浏览器的行为。

表 3. 当用户打开一个新的浏览器窗口时的失效操作
	Firefox 3.5	IE 8	Chrome 3	Safari 4
内容没有失效	浏览器呈现来自缓存的页面	浏览器重新发送请求到服务器。返回代码是 200	浏览器呈现来自缓存的页面	浏览器呈现来自缓存的页面
内容失效	浏览器重新发送请求到服务器。返回代码是 200	浏览器重新发送请求到服务器。返回代码是 200	浏览器重新发送请求到服务器。返回代码是 200	浏览器重新发送请求到服务器。返回代码是 200

表 4. 当用户在原始浏览器窗口中单击 Enter 按钮时的失效操作
	Firefox 3.5	IE 8	Chrome 3	Safari 4
内容没有失效	浏览器呈现来自缓存的页面	浏览器呈现来自缓存的页面	浏览器重新发送请求到服务器。返回代码是 304	浏览器重新发送请求到服务器。返回代码是 304
内容失效	浏览器重新发送请求到服务器。返回代码是 200	浏览器呈现来自缓存的页面	浏览器重新发送请求到服务器。返回代码是 200	浏览器重新发送请求到服务器。返回代码是 200

表 5. 当用户按 F5 键刷新页面时的失效操作
	Firefox 3.5	IE 8	Chrome 3	Safari 4
内容没有失效	浏览器重新发送请求到服务器。返回代码是 304	浏览器重新发送请求到服务器。返回代码是 304	浏览器重新发送请求到服务器。返回代码是 304	浏览器重新发送请求到服务器。返回代码是 304
内容失效	浏览器重新发送请求到服务器。返回代码是 200	浏览器重新发送请求到服务器。返回代码是 200	浏览器重新发送请求到服务器。返回代码是 200	浏览器重新发送请求到服务器。返回代码是 200

表 6. 当用户单击 Back 或 Forward 按钮时的失效操作
	Firefox 3.5	IE 8	Chrome 3	Safari 4
内容没有失效	浏览器呈现来自缓存的页面	浏览器呈现来自缓存的页面	浏览器呈现来自缓存的页面	浏览器呈现来自缓存的页面
内容失效	浏览器呈现来自缓存的页面	浏览器呈现来自缓存的页面	浏览器呈现来自缓存的页面	浏览器重新发送请求到服务器。返回代码是 200

注意：所有浏览器都假定为使用默认设置运行。

Last-Modified/E-Tag

Last-Modified 实体头部字段值通常用作一个缓存验证器。简单来说，如果实体值在 Last-Modified 值之后没有被更改，则认为该缓存条目有效。ETag 响应头部字段值是一个实体标记，它提供一个 “不透明” 的缓存验证器。这可能在以下几种情况下提供更可靠的验证：不方便存储修改日期；HTTP 日期值的 one-second 解决方案不够用；或者原始服务器希望避免由于使用修改日期而导致的某些冲突。

不同的浏览器有不同的配置行为。表 7-10 表明针对不同用户操作的不同浏览器的行为。

表 7. 当用户打开一个新的浏览器窗口时的 Last-Modified E-Tag 操作
	Firefox 3.5	IE 8	Chrome 3	Safari 4
内容自上次访问以来没有被修改	浏览器重新发送请求到服务器。返回代码是 304	浏览器重新发送请求到服务器。返回代码是 200	浏览器重新发送请求到服务器。返回代码是 304	浏览器重新发送请求到服务器。返回代码是 304
内容自上次访问以来已经被修改	浏览器重新发送请求到服务器。返回代码是 200	浏览器重新发送请求到服务器。返回代码是 200	浏览器重新发送请求到服务器。返回代码是 200	浏览器重新发送请求到服务器。返回代码是 200

表 8. 当用户在原始浏览器窗口中单击 Enter 按钮时的 Last-Modified E-Tag 操作
	Firefox 3.5	IE 8	Chrome 3	Safari 4
内容自上次访问以来没有被修改	浏览器呈现来自缓存的页面	浏览器呈现来自缓存的页面	浏览器重新发送请求到服务器。返回代码是 304	浏览器重新发送请求到服务器。返回代码是 304
内容自上次访问以来已经被修改	浏览器重新发送请求到服务器。返回代码是 200	浏览器呈现来自缓存的页面	浏览器重新发送请求到服务器。返回代码是 200	浏览器重新发送请求到服务器。返回代码是 200

表 9. 当用户按 F5 键刷新页面时的 Last-Modified E-Tag 操作
	Firefox 3.5	IE 8	Chrome 3	Safari 4
内容自上次访问以来没有被修改	浏览器重新发送请求到服务器。返回代码是 304	浏览器重新发送请求到服务器。返回代码是 304	浏览器重新发送请求到服务器。返回代码是 304	浏览器重新发送请求到服务器。返回代码是 304
内容自上次访问以来已经被修改	浏览器重新发送请求到服务器。返回代码是 200	浏览器重新发送请求到服务器。返回代码是 200	浏览器重新发送请求到服务器。返回代码是 200	浏览器重新发送请求到服务器。返回代码是 200

表 10. 没有缓存设置且用户单击 Back 或 Forward 按钮
	Firefox 3.5	IE 8	Chrome 3	Safari 4
内容自上次访问以来没有被修改	浏览器呈现来自缓存的页面	浏览器呈现来自缓存的页面	浏览器呈现来自缓存的页面	浏览器呈现来自缓存的页面
内容自上次访问以来已经被修改	浏览器呈现来自缓存的页面	浏览器呈现来自缓存的页面	浏览器呈现来自缓存的页面	浏览器重新发送请求到服务器。返回代码是 200

注意：所有浏览器都假定使用默认设置运行。

不进行任何缓存相关设置

如果您不定义任何缓存相关设置，则不同的浏览器有不同的行为。有时，同一个浏览器在相同的情形下每次运行时的行为都是不同的。情况可能很复杂。另外，有些不该缓存的内容如果被缓存，将会导致安全问题。
不同的浏览器有不同的行为。表 11 展示了不同的浏览器行为。

表 11. 没有缓存设置且用户打开一个新的浏览器窗口
	Firefox 3.5	IE 8	Chrome 3	Safari 4
打开一个新页面	浏览器重新发送请求到服务器。返回代码是 200	浏览器重新发送请求到服务器。返回代码是 200	浏览器重新发送请求到服务器。返回代码是 200	浏览器重新发送请求到服务器。返回代码是 200
在原始窗口中单击 Enter 按钮	浏览器重新发送请求到服务器。返回代码是 200	浏览器呈现来自缓存的页面。	浏览器重新发送请求到服务器。返回代码是 200	浏览器重新发送请求到服务器。返回代码是 200
按 F5 键刷新	浏览器重新发送请求到服务器。返回代码是 200	浏览器重新发送请求到服务器。返回代码是 200	浏览器重新发送请求到服务器。返回代码是 200	浏览器重新发送请求到服务器。返回代码是 200
单击 Back 或 Forward 按钮	浏览器呈现来自缓存的页面。	浏览器呈现来自缓存的页面。	浏览器重新发送请求到服务器。返回代码是 200	浏览器重新发送请求到服务器。返回代码是 200

注意：所有浏览器都假定使用默认设置运行。

最后, 概括下关键的结论:

关键结论
打开新窗口	如果指定cache-control的值为private、no-cache、must-revalidate,那么打开新窗口访问时都会重新访问服务器。而如果指定了max-age值,那么在此值内的时间里就不会重新访问服务器,例如：Cache-control: max-age=5 表示当访问此网页后的5秒内再次访问不会去服务器.
在地址栏回车	如果值为private或must-revalidate,则只有第一次访问时会访问服务器,以后就不再访问。如果值为no-cache,那么每次都会访问。如果值为max-age,则在过期之前不会重复访问。
按后退按扭	如果值为private、must-revalidate、max-age,则不会重访问,而如果为no-cache,则每次都重复访问.
按刷新按扭	无论为何值,都会重复访问.

HTTP Performance

2013-06-04T14:30:00.001+10:00

HTTP Performance: An Overview

It's no secret—users love fast Web sites. Users are notoriously impatient, and unless your Web site has no competitive substitute, users are unlikely to stick around if your site's performance doesn't measure up. If your site has visitors from around the world, ensuring your site operates efficiently is even more critical, as international network connections generally suffer from the twin banes of snappy sites: high latency and low bandwidth.
There are many options for improving your site's performance: compression, caching, geographic load balancing, adding hardware, and so forth. Optimizing the use of compression and caching is often the best place to start, as configuration changes are generally free and can return dramatic benefits.
In this article, we'll use the Fiddler HTTP Debugger to explore HTTP performance, caching, and compression.

Tweaking "First Visit" Performance

On their crucial first visit to your site, visitors must download every piece of content used to generate the page, including JScript, CSS, images, and HTML. If your page is too slow to load, visitors may leave your page before it's even done downloading!
By exposing all HTTP traffic, Fiddler readily shows which files are used to generate a given page. Shift+click multiple entries in the HTTP Sessions list to calculate the "total page weight"—the number of requests and the bytes transferred.

Figure 1. Fiddler's Performance Statistics View

The best way to ensure a "Wow, this is fast" first impression is to deliver fewer and smaller files.
Tips for fast first-visits:

Use fewer graphics.
Extract styles into a single CSS file.
Extract script blocks into a single JS file.
Simplify your page layout.
Use HTTP Compression.

Once you've tuned your site for a fast first visit, you can make it even faster for return visitors by taking advantage of HTTP caching.

Introduction to HTTP Caching

Two key factors in improving the speed of your Web applications are:

Reducing the number of request/response roundtrips.
Reducing the number of bytes transferred between the server and the client.

HTTP caching is of the best ways to reduce roundtrips and bytes transferred. Caching provides a mechanism for a client or proxy to store HTTP responses for later use, so that requests need not cross the network.
Other than performance, another benefit of maximizing use of HTTP caching comes from the fact that bandwidth isn't free. By tuning caching for a major Microsoft site, we were able to reduce our outbound bandwidth costs by over $10,000 per month.

Cache-Related Request Headers

To enhance performance, Microsoft Internet Explorer and other Web clients maintain a local cache of resources downloaded from remote Web servers.
When a resource is needed by the client, there are three possible actions:

Send a plain HTTP request to the remote Web server asking for a resource
Send a conditional HTTP request to the origin server asking for the resource only if it differs from the locally cached version
Use a locally cached version of the resource, if a cached copy is available

When sending a request, the client may use one of the following headers:
Table 1. Client Cache Headers

`Pragma:` no-cache	The client is unwilling to accept any cached responses from caches along the route and the origin server must be contacted for a fresh copy of the resource.
`If-Modified-Since:` datetime	The server should return the requested resource only if the resource has been modified since the date-time provided by the client.
`If-None-Match:` etagvalue	The server should return the requested resource if the ETAG of the resource is different than the value provided by the client. An ETAG is a unique identifier representing a particular version of a file.

A client indicates that it has a cached response available for use by sending a "Conditional request" containing the headers If-Modified-Since or If-None-Match. If the server replies to a conditional request with HTTP/304 Not Modified, the client is directed to reuse its cached response. Otherwise, the server should return a new response and the client should discard its outdated cache item.
Observe two consecutive requests for an image file in the following code sessions. In the first session, no locally cached version of the file is present, so the server returns the file along with an ETAG value and the date-time of the last modification of the file. In the subsequent session, a locally cached version of the file is now available, so a conditional request is made, passing up the ETAG of the cached response as well as the Last-Modified time of the original request. Since the image has not changed since the cached version (either because the ETAG matches or the If-Modified-Since value matches the Last-Modified value) the server returns a 304 to the client to direct it to use the cached response.
Session #1

GET /images/banner.jpg HTTP/1.1
Host: www.bayden.com

HTTP/1.1 200 OK
Date: Tue, 08 Mar 2006 00:32:46 GMT
Content-Length: 6171
Content-Type: image/jpeg
ETag: "40c7f76e8d30c31:2fe20"
Last-Modified: Thu, 12 Jun 2003 02:50:50 GMT

Session #2

GET /images/banner.jpg HTTP/1.1
If-Modified-Since: Thu, 12 Jun 2003 02:50:50 GMT
If-None-Match: "40c7f76e8d30c31:2fe20"
Host: www.bayden.com

HTTP/1.1 304 Not Modified

Because an HTTP/304 response contains only headers and no body, it crosses the network much more quickly than if the full resource had been re-downloaded. However, even an HTTP/304 requires a full roundtrip to the remote Web server; by carefully setting response headers, a Web application developer can eliminate the need to issue even conditional requests.

Cache-Related Response Headers

Generally, the cacheability of an HTTP response is controlled by headers sent in the response. The HTTP specification describes the headers that control caching. The optional Cache-Control and Expires headers are the primary mechanisms for a Web server to indicate to a proxy or a client how content may be cached.
The Expires header contains an absolute date-time after which a cached copy of a response should no longer be considered fresh. If the Expires header contains something other than a date (0 or -1 are common values), the response should immediately be treated as stale. A fresh cache entry may be reused without contacting the server again; a stale cache entry should not be reused without first contacting the Web server to ensure that it is still up-to-date.
For example, let's look at the previous example, except we'll add an Expires header to the first response:
Session #1

GET /images/banner.jpg HTTP/1.1
Host: www.bayden.com

HTTP/1.1 200 OK
Date: Tue, 08 Mar 2006 00:32:46 GMT
Content-Length: 6171
Content-Type: image/jpeg
Expires: Tue, 12 Jun 2007 02:50:50 GMT
Last-Modified: Thu, 12 Jun 2003 02:50:50 GMT

Session #2

As you can see, we've improved performance by adding an Expires header, since no conditional HTTP request is made during Session #2.
Similarly, the Cache-Control header contains a list of tokens that control caching. Any Cache-Control directives supersede the Expires header.
Commonly used Cache-Control tokens include those found in table 2.
Table 2. Common Cache-Control Headers

Value	Meaning
public	The response may be stored in any cache, including caches shared among many users.
private	The response may only be stored in a private cache used by a single user.
no-cache	The response should not be reused to satisfy future requests.
no-store	The response should not be reused to satisfy future requests, and should not be written to disk. This is primarily used as a security measure for sensitive responses.
max-age=#seconds	The response may be reused to satisfy future requests within a certain number of seconds.
must-revalidate	The response may be reused to satisfy future requests, but the origin server should first be contacted to verify that the response is still fresh.

Notes

You can learn more about how to configure caching for IIS from the Microsoft Knowledge Base article How to Modify the Cache-Control HTTP Header When You Use IIS.
You can learn more about how to configure caching for ASP.NET pages the Microsoft Knowledge Base article How To Cache in ASP.NET by Using Visual C# .NET.
If you find that you often update files on your Web site without changing the filenames, take care to set appropriate cache lifetimes. For instance, if you want thisyear.gif to show the current year on your site, you need to make sure the caching directives don't call for an expiration longer than 1 day, or else a user visiting on December 31st won't see the right image when they go back on January 1st!
For legacy reasons, servers may send a Pragma: no-cache header. This is treated as Cache-Control: no-cache.
The Vary header signals to a cache that a response is valid for reuse only under certain circumstances. For example, use Vary: User-Agent to direct that the current response may only be reused for future requests sending the same User-Agent header. The directive Vary: * is equivalent to Cache-Control: no-cache.

Using the HTTP Sessions list, Fiddler users can see whether pages contain HTTP Caching headers.

Figure 2. Fiddler Sessions List
If a response does not contain Expires or Cache-Control headers, the client may be forced to issue a conditional request to ensure that the resource is still fresh.

Conditional Requests and the WinInet Cache

Internet Explorer takes advantage of the caching services provided by Microsoft Windows Internet Services (WinInet).
WinInet allows the user to configure the size and behavior of the cache. To access the cache settings:

Open Internet Explorer.
On the Tools menu, choose Internet Options.
On the General tab, in the Temporary Internet Files box, click Settings.

At the top of the Settings dialog box, there are four choices.

Figure 3. Internet Explorer Cache Options
The vast majority of users leave the setting at the default of Automatically.
The most important fact to keep in mind is that these four options mostly impact the behavior when there are no caching headers on the HTTP responses; when caching headers are present, Internet Explorer will always respect them. The following table describes the impact of these settings on request behavior.
Table 3. Cache behaviors

Setting	Cache copy is fresh	Cache stale	No cache-directives were present
Every visit to the page	No request	Conditional request	Conditional request
Every time you start Internet Explorer	No request	Conditional request	Conditional request
Automatically	No request	Conditional request	Heuristic (see below)
Never	No request	Conditional request	No request

Cached content is considered fresh if the request is made during the freshness lifetime specified by the Cache-Control or Expires headers on the original response. Cached content is considered stale if the request is made after the end of the freshness lifetime specified.
The Automatically setting bears some explanation—how can WinInet know if the cached resource is fresh when no caching directives were provided on the server's HTTP response?
The answer is that WinInet can't know for sure and a Heuristic process is followed to make a "best guess" effort. In the Automatically state, the Heuristic will issue a conditional request unless all of the following criteria are met:

The cached resource bears a Content-Type that begins with image/.
The cached resource has a Last-Modified time.
The URL to the cached resource does not contain a question mark (hinting that it's a CGI request).
The cached resource has been conditionally requested at least once within the most recent 25 percent of its overall age in the cache.

If all of the criteria above are met, no request is made.
As a Web developer, you should always ensure that you send appropriate caching headers to guarantee you get optimum cache behaviors.

Flagging Performance Problems

You can use Fiddler's Custom Rules to draw attention to potential performance problems. For instance, you can flag any response larger than 25KB.
To add this rule, click Rules and then Custom Rules, and add the following code inside the OnBeforeResponse event handler:

// Flag files over 25KB
   if (oSession.responseBodyBytes.length > 25000){
      oSession["ui-color"] = "red";
      oSession["ui-bold"] = "true";
      oSession["ui-customcolumn"] = "Large file";
   }

Similarly, you can flag responses that do not specify caching information:

   // Mark files which do not have caching information
if (!oSession.oResponse.headers.Exists("Expires") &&
!oSession.oResponse.headers.Exists("Cache-Control")){
      
oSession["ui-color"] = "purple";
      oSession["ui-bold"] = "true";
   }

Introduction to HTTP Compression

All popular Web servers and browsers offer support for HTTP Compression. HTTP Compression can dramatically decrease the number of bytes that are transmitted between the server and the client; savings of over 50 percent for HTML, XML, CSS, and JS are common.
A Web browser signals to the server that it is willing to accept HTTP compressed content by listing the supported compression types in the request headers. For instance, consider the following request to the new MSN Search homepage:

GET / HTTP/1.1
Accept: */*
Accept-Language: en-us
Accept-Encoding: gzip, deflate
User-Agent: Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1; .NET CLR 1.1.4322)
Host: search.msn.com

The Accept-Encoding header indicates Internet Explorer is willing to accept responses that have been compressed using either the GZIP or DEFLATE formats.
The MSN Search server obligingly returns the compressed contents; the Content-Encoding response header indicates the GZIP format was used:

HTTP/1.1 200 OK
Content-Type: text/html; charset=utf-8
Server: Microsoft-IIS/6.0 --Microsoft-HTTPAPI/1.0
X-Powered-By: ASP.NET
Vary: Accept-Encoding
Content-Encoding: gzip
Date: Tue, 15 Feb 2006 09:14:36 GMT
Content-Length: 1277
Connection: close
Cache-Control: private, max-age=3600

Using Fiddler, you can decompress the response using the Transformer tool on the Session Inspector tab.

Figure 4. Transformer Inspector before decompressing GZIP'd response
Click the No Compression radio button to decompress the response inside Fiddler. Compression reduced the number of bytes transferred by over 57 percent.

Figure 5. Transformer Inspector after decompressing response
The savings are more dramatic for the common.css file used by the MSN Search homepage; the CSS file was compressed 81 percent (from 25,288 bytes to 4,648 bytes). Note that image files like GIFs, JPEGs, and PNGs generally are already compressed and thus usually are not delivered with HTTP compression.
You can use Fiddler to simulate HTTP compression by checking "Simulate GZIP Compression" on the Fiddler Rules menu.

Enabling compression for static files in IIS has a minimal CPU impact on IIS Web servers, because the files are compressed only the first time and then cached on the server. Enabling compression for dynamic files like ASP.NET pages may impact your servers' CPU performance; you'll want to evaluate this performance impact before enabling dynamic compression on production Web servers.

xStream完美转换XML、JSON

2013-05-21T09:26:00.003+10:00

xStream框架
xStream可以轻易的将Java对象和xml文档相互转换，而且可以修改某个特定的属性和节点名称，而且也支持json的转换；
前面有介绍过json-lib这个框架，在线博文：http://www.cnblogs.com/hoojo/archive/2011/04/21/2023805.html
以及Jackson这个框架，在线博文：http://www.cnblogs.com/hoojo/archive/2011/04/22/2024628.html
它们都完美支持JSON，但是对xml的支持还不是很好。一定程度上限制了对Java对象的描述，不能让xml完全体现到对Java对象的描述。这里将会介绍xStream对JSON、XML的完美支持。xStream不仅对XML的转换非常友好，而且提供annotation注解，可以在JavaBean 中完成对xml节点、属性的描述。以及对JSON也支持，只需要提供相关的JSONDriver就可以完成转换。
一、准备工作
1、下载jar包、及官方资源
xStream的jar下载地址：
https://nexus.codehaus.org/content/repositories/releases/com/thoughtworks/xstream/xstream-distribution/1.3.1/xstream-distribution-1.3.1-bin.zip
官方的示例很全，官方参考示例：http://xstream.codehaus.org/tutorial.html
添加xstream-1.3.1.jar文件到工程中，就可以开始下面的工作；需要的jar如下：

2、测试用例代码

package com.hoo.test;

import java.io.IOException;

import java.io.ObjectInputStream;

import java.io.ObjectOutputStream;

import java.io.StringReader;

import java.io.Writer;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import java.util.Set;

import org.codehaus.jettison.json.JSONException;

import org.junit.After;

import org.junit.Before;

import org.junit.Test;

import com.hoo.entity.Birthday;

import com.hoo.entity.Classes;

import com.hoo.entity.ListBean;

import com.hoo.entity.Student;

import com.thoughtworks.xstream.XStream;

import com.thoughtworks.xstream.io.HierarchicalStreamWriter;

import com.thoughtworks.xstream.io.json.JettisonMappedXmlDriver;

import com.thoughtworks.xstream.io.json.JsonHierarchicalStreamDriver;

import com.thoughtworks.xstream.io.json.JsonWriter;

/**

 * function:Java对象和XML字符串的相互转换

 * jar-lib-version: xstream-1.3.1

 * @author hoojo

 * @createDate Nov 27, 2010 12:15:15 PM

 * @file XStreamTest.java

 * @package com.hoo.test

 * @project WebHttpUtils

 * @blog http://blog.csdn.net/IBM_hoojo

 * @email hoojo_@126.com

 * @version 1.0

*/

@SuppressWarnings("unchecked")

public class XStreamTest {

    private XStream xstream = null;

    private ObjectOutputStream  out = null;

    private ObjectInputStream in = null;

    private Student bean = null;

/**

     * function:初始化资源准备

     * @author hoojo

     * @createDate Nov 27, 2010 12:16:28 PM

*/

    @Before

    public void init() {

        try {

            xstream = new XStream();

            //xstream = new XStream(new DomDriver()); // 需要xpp3 jar

        } catch (Exception e) {

            e.printStackTrace();

        bean = new Student();

        bean.setAddress("china");

        bean.setEmail("jack@email.com");

        bean.setId(1);

        bean.setName("jack");

        Birthday day = new Birthday();

        day.setBirthday("2010-11-22");

        bean.setBirthday(day);

/**

     * function:释放对象资源

     * @author hoojo

     * @createDate Nov 27, 2010 12:16:38 PM

*/

    @After

    public void destory() {

        xstream = null;

        bean = null;

        try {

            if (out != null) {

                out.flush();

                out.close();

            if (in != null) {

                in.close();

        } catch (IOException e) {

            e.printStackTrace();

        System.gc();

    public final void fail(String string) {

        System.out.println(string);

    public final void failRed(String string) {

        System.err.println(string);

通过XStream对象的toXML方法就可以完成Java对象到XML的转换，toXML方法还有2个相同签名的方法，需要传递一个流。然后通过流来完成xml信息的输出。
3、需要的JavaBean

package com.hoo.entity;

public class Student {

    private int id;

    private String name;

    private String email;

    private String address;

    private Birthday birthday;

    //getter、setter

    public String toString() {

        return this.name + "#" + this.id + "#" + this.address + "#" + this.birthday + "#" + this.email;

二、Java转换成XML
1、 JavaBean转换XM

/**

 * function:Java对象转换成XML字符串

 * @author hoojo

 * @createDate Nov 27, 2010 12:19:01 PM

*/

@Test

public void writeBean2XML() {

    try {

        fail("------------Bean->XML------------");

        fail(xstream.toXML(bean));

        fail("重命名后的XML");

        //类重命名

        //xstream.alias("account", Student.class);

        //xstream.alias("生日", Birthday.class);

        //xstream.aliasField("生日", Student.class, "birthday");

        //xstream.aliasField("生日", Birthday.class, "birthday");

        //fail(xstream.toXML(bean));

        //属性重命名

        xstream.aliasField("邮件", Student.class, "email");

        //包重命名

        xstream.aliasPackage("hoo", "com.hoo.entity");

        fail(xstream.toXML(bean));

    } catch (Exception e) {

        e.printStackTrace();

看结果中的第一份xml内容，是没有经过然后修改或重命名的文档，按照原样输出。文档中的第二份文档的package经过重命名，email属性也经过重命名以及类名也可以进行重命名的。
运行后结果如下：

------------Bean->XML------------

<com.hoo.entity.Student>

  <id>1</id>

  <name>jack</name>

  <email>jack@email.com</email>

  <address>china</address>

  <birthday>

    <birthday>2010-11-22</birthday>

  </birthday>

</com.hoo.entity.Student>

重命名后的XML

<hoo.Student>

  <id>1</id>

  <name>jack</name>

  <邮件>jack@email.com</邮件>

  <address>china</address>

  <birthday>

    <birthday>2010-11-22</birthday>

  </birthday>

</hoo.Student>

2、将List集合转换成xml文档

/**

 * function:将Java的List集合转换成XML对象

 * @author hoojo

 * @createDate Nov 27, 2010 12:20:07 PM

*/

@Test

public void writeList2XML() {

    try {

        //修改元素名称

        xstream.alias("beans", ListBean.class);

        xstream.alias("student", Student.class);

        fail("----------List-->XML----------");

        ListBean listBean = new ListBean();

        listBean.setName("this is a List Collection");

        List list = new ArrayList();

        list.add(bean);

        list.add(bean);//引用bean

        //list.add(listBean);//引用listBean，父元素

        bean = new Student();

        bean.setAddress("china");

        bean.setEmail("tom@125.com");

        bean.setId(2);

        bean.setName("tom");

        Birthday day = new Birthday("2010-11-22");

        bean.setBirthday(day);

        list.add(bean);

        listBean.setList(list);

        //将ListBean中的集合设置空元素，即不显示集合元素标签

        //xstream.addImplicitCollection(ListBean.class, "list");

        //设置reference模型

        //xstream.setMode(XStream.NO_REFERENCES);//不引用

        xstream.setMode(XStream.ID_REFERENCES);//id引用

        //xstream.setMode(XStream.XPATH_ABSOLUTE_REFERENCES);//绝对路径引用

        //将name设置为父类（Student）的元素的属性

        xstream.useAttributeFor(Student.class, "name");

        xstream.useAttributeFor(Birthday.class, "birthday");

        //修改属性的name

        xstream.aliasAttribute("姓名", "name");

        xstream.aliasField("生日", Birthday.class, "birthday");

        fail(xstream.toXML(listBean));

    } catch (Exception e) {

        e.printStackTrace();

上面的代码运行后，结果如下：

----------List-->XML----------

<beans id="1">

  <name>this is a List Collection</name>

  <list id="2">

    <student id="3" 姓名="jack">

      <id>1</id>

      <email>jack@email.com</email>

      <address>china</address>

      <birthday id="4" 生日="2010-11-22"/>

    </student>

    <student reference="3"/>

    <student id="5" 姓名="tom">

      <id>2</id>

      <email>tom@125.com</email>

      <address>china</address>

      <birthday id="6" 生日="2010-11-22"/>

    </student>

  </list>

</beans>

如果不加xstream.addImplicitCollection(ListBean.class, "list");
这个设置的话，会出现一个List节点包裹着Student节点元素。添加addImplicitCollection可以忽略这个list节点元素。那么上面的list节点就不存在，只会在beans元素中出现name、student这2个xml元素标签；
setMode是设置相同的对象的引用方式，如果设置XStream.NO_REFERENCES就是不引用，会输出2分相同的 Student元素。如果是XStream.ID_REFERENCES会引用相同的那个对象的id属性，如果是 XStream.XPATH_ABSOLUTE_REFERENCES引用，那么它将显示xpath路径。上面采用的id引用，这个引用了id=3的那个student标签元素；
useAttributeFor是设置某个节点显示到父节点的属性中，也就是将指定class中的指定属性，在这个class元素节点的属性中显示。
如：hoojo
设置好后就是这样的结果：
aliasAttribute是修改属性名称。
3、在JavaBean中添加Annotation注解进行重命名设置
先看看JavaBean的代码

package com.hoo.entity;

import java.util.Arrays;

import java.util.Calendar;

import java.util.GregorianCalendar;

import java.util.List;

import com.thoughtworks.xstream.annotations.XStreamAlias;

import com.thoughtworks.xstream.annotations.XStreamAsAttribute;

import com.thoughtworks.xstream.annotations.XStreamConverter;

import com.thoughtworks.xstream.annotations.XStreamImplicit;

import com.thoughtworks.xstream.annotations.XStreamOmitField;

@XStreamAlias("class")

public class Classes {

/*

     * 设置属性显示

*/

    @XStreamAsAttribute

    @XStreamAlias("名称")

    private String name;

/*

     * 忽略

*/

    @XStreamOmitField

    private int number;

    @XStreamImplicit(itemFieldName = "Students")

    private List students;

    @SuppressWarnings("unused")

    @XStreamConverter(SingleValueCalendarConverter.class)

    private Calendar created = new GregorianCalendar();

    public Classes(){}

    public Classes(String name, Student... stu) {

        this.name = name;

        this.students = Arrays.asList(stu);

    //getter、setter

SingleValueCalendarConverter.java这个是一个类型转换器

package com.hoo.entity;

import java.util.Calendar;

import java.util.Date;

import java.util.GregorianCalendar;

import com.thoughtworks.xstream.converters.Converter;

import com.thoughtworks.xstream.converters.MarshallingContext;

import com.thoughtworks.xstream.converters.UnmarshallingContext;

import com.thoughtworks.xstream.io.HierarchicalStreamReader;

import com.thoughtworks.xstream.io.HierarchicalStreamWriter;

public class SingleValueCalendarConverter implements Converter {

     public void marshal(Object source, HierarchicalStreamWriter writer,

                MarshallingContext context) {

            Calendar calendar = (Calendar) source;

            writer.setValue(String.valueOf(calendar.getTime().getTime()));

        public Object unmarshal(HierarchicalStreamReader reader,

                UnmarshallingContext context) {

            GregorianCalendar calendar = new GregorianCalendar();

            calendar.setTime(new Date(Long.parseLong(reader.getValue())));

            return calendar;

        @SuppressWarnings("unchecked")

        public boolean canConvert(Class type) {

            return type.equals(GregorianCalendar.class);

再看看测试用例代码

@Test

public void writeList2XML4Annotation() {

    try {

        failRed("---------annotation Bean --> XML---------");

        Student stu = new Student();

        stu.setName("jack");

        Classes c = new Classes("一班", bean, stu);

        c.setNumber(2);

        //对指定的类使用Annotation

        //xstream.processAnnotations(Classes.class);

        //启用Annotation

        //xstream.autodetectAnnotations(true);

        xstream.alias("student", Student.class);

        fail(xstream.toXML(c));

    } catch (Exception e) {

        e.printStackTrace();

当启用annotation或是对某个特定的类启用annotation时，上面的classes这个类才有效果。如果不启用annotation，运行后结果如下：

---------annotation Bean --> XML---------

<com.hoo.entity.Classes>

  <name>一班</name>

  <number>2</number>

  <students class="java.util.Arrays$ArrayList">

    <a class="student-array">

      <student>

        <id>1</id>

        <name>jack</name>

        <email>jack@email.com</email>

        <address>china</address>

        <birthday>

          <birthday>2010-11-22</birthday>

        </birthday>

      </student>

      <student>

        <id>0</id>

        <name>jack</name>

      </student>

    </a>

  </students>

  <created>

    <time>1303292056718</time>

    <timezone>Asia/Shanghai</timezone>

  </created>

</com.hoo.entity.Classes>

当启用annotation后xstream.processAnnotations(Classes.class)，结果如下：

---------annotation Bean --> XML---------

<class 名称="一班">

  <Students>

    <id>1</id>

    <name>jack</name>

    <email>jack@email.com</email>

    <address>china</address>

    <birthday>

      <birthday>2010-11-22</birthday>

    </birthday>

  </Students>

  <Students>

    <id>0</id>

    <name>jack</name>

  </Students>

  <created>1303292242937</created>

</class>

4、 Map集合转换xml文档

/**

 * function:Java Map集合转XML

 * @author hoojo

 * @createDate Nov 27, 2010 1:13:26 PM

*/

@Test

public void writeMap2XML() {

    try {

        failRed("---------Map --> XML---------");

        Map map = new HashMap();

        map.put("No.1", bean);//put

        bean = new Student();

        bean.setAddress("china");

        bean.setEmail("tom@125.com");

        bean.setId(2);

        bean.setName("tom");

        Birthday day = new Birthday("2010-11-22");

        bean.setBirthday(day);

        map.put("No.2", bean);//put

        bean = new Student();

        bean.setName("jack");

        map.put("No.3", bean);//put

        xstream.alias("student", Student.class);

        xstream.alias("key", String.class);

        xstream.useAttributeFor(Student.class, "id");

        xstream.useAttributeFor("birthday", String.class);

        fail(xstream.toXML(map));

    } catch (Exception e) {

        e.printStackTrace();

运行后结果如下：

---------Map --> XML---------

<map>

  <entry>

    <key>No.3</key>

    <student id="0">

      <name>jack</name>

    </student>

  </entry>

  <entry>

    <key>No.1</key>

    <student id="1">

      <name>jack</name>

      <email>jack@email.com</email>

      <address>china</address>

      <birthday birthday="2010-11-22"/>

    </student>

  </entry>

  <entry>

    <key>No.2</key>

    <student id="2">

      <name>tom</name>

      <email>tom@125.com</email>

      <address>china</address>

      <birthday birthday="2010-11-22"/>

    </student>

  </entry>

</map>

5、用OutStream输出流写XML

/**

 * function:用OutStream输出流写XML

 * @author hoojo

 * @createDate Nov 27, 2010 1:13:48 PM

*/

@Test

public void writeXML4OutStream() {

    try {

        out = xstream.createObjectOutputStream(System.out);

        Student stu = new Student();

        stu.setName("jack");

        Classes c = new Classes("一班", bean, stu);

        c.setNumber(2);

        failRed("---------ObjectOutputStream # JavaObject--> XML---------");

        out.writeObject(stu);

        out.writeObject(new Birthday("2010-05-33"));

        out.write(22);//byte

        out.writeBoolean(true);

        out.writeFloat(22.f);

        out.writeUTF("hello");

    } catch (Exception e) {

        e.printStackTrace();

使用输出流后，可以通过流对象完成xml的构建，即使没有JavaBean对象，你可以用流来构建一个复杂的xml文档，运行后结果如下：

---------ObjectOutputStream # JavaObject--> XML---------

<object-stream>

  <com.hoo.entity.Student>

    <id>0</id>

    <name>jack</name>

  </com.hoo.entity.Student>

  <com.hoo.entity.Birthday>

    <birthday>2010-05-33</birthday>

  </com.hoo.entity.Birthday>

  <byte>22</byte>

  <boolean>true</boolean>

  <float>22.0</float>

  <string>hello</string>

</object-stream>

三、XML内容转换Java对象
1、用InputStream将XML文档转换成java对象

/**

 * function:用InputStream将XML文档转换成java对象

 * 需要额外的jar xpp3-main.jar

 * @author hoojo

 * @createDate Nov 27, 2010 1:14:52 PM

*/

@Test

public void readXML4InputStream() {

    try {

        String s = "0jack" +

2010-05-33" +

22true22.0" +

          "hello

        failRed("---------ObjectInputStream## XML --> javaObject---------");

        StringReader reader = new StringReader(s);

        in = xstream.createObjectInputStream(reader);

        Student stu = (Student) in.readObject();

        Birthday b = (Birthday) in.readObject();

        byte i = in.readByte();

        boolean bo = in.readBoolean();

        float f = in.readFloat();

        String str = in.readUTF();

        System.out.println(stu);

        System.out.println(b);

        System.out.println(i);

        System.out.println(bo);

        System.out.println(f);

        System.out.println(str);

    } catch (Exception e) {

        e.printStackTrace();

读取后，转换的Java对象，结果如下：

---------ObjectInputStream## XML --> javaObject---------

jack#0#null#null#null

2010-05-33

true

22.0

hello

2、将xml文档转换成Java对象

/**

 * function:将XML字符串转换成Java对象

 * @author hoojo

 * @createDate Nov 27, 2010 2:39:06 PM

*/

@Test

public void readXml2Object() {

    try {

        failRed("-----------Xml >>> Bean--------------");

        Student stu = (Student) xstream.fromXML(xstream.toXML(bean));

        fail(stu.toString());

        List list = new ArrayList();

        list.add(bean);//add

        Map map = new HashMap();

        map.put("No.1", bean);//put

        bean = new Student();

        bean.setAddress("china");

        bean.setEmail("tom@125.com");

        bean.setId(2);

        bean.setName("tom");

        Birthday day = new Birthday("2010-11-22");

        bean.setBirthday(day);

        list.add(bean);//add

        map.put("No.2", bean);//put

        bean = new Student();

        bean.setName("jack");

        list.add(bean);//add

        map.put("No.3", bean);//put

        failRed("==========XML >>> List===========");

        List studetns = (List) xstream.fromXML(xstream.toXML(list));

        fail("size:" + studetns.size());//3

        for (Student s : studetns) {

            fail(s.toString());

        failRed("==========XML >>> Map===========");

        Map maps = (Map) xstream.fromXML(xstream.toXML(map));

        fail("size:" + maps.size());//3

        Set key = maps.keySet();

        Iterator iter = key.iterator();

        while (iter.hasNext()) {

            String k = iter.next();

            fail(k + ":" + map.get(k));

    } catch (Exception e) {

        e.printStackTrace();

运行后结果如下：

-----------Xml >>> Bean--------------

jack#1#china#2010-11-22#jack@email.com

==========XML >>> List===========

size:3

jack#1#china#2010-11-22#jack@email.com

tom#2#china#2010-11-22#tom@125.com

jack#0#null#null#null

==========XML >>> Map===========

size:3

No.3:jack#0#null#null#null

No.1:jack#1#china#2010-11-22#jack@email.com

No.2:tom#2#china#2010-11-22#tom@125.com

怎么样，成功的完成XML到JavaBean、List、Map的转换，更多对象转换还需要大家一一尝试。用法类似~这里就不一样赘述。
四、XStream对JSON的支持
xStream对JSON也有非常好的支持，它提供了2个模型驱动。用这2个驱动可以完成Java对象到JSON的相互转换。使用JettisonMappedXmlDriver驱动，将Java对象转换成json，需要添加jettison.jar
1、用JettisonMappedXmlDriver完成Java对象到JSON的转换

/**

 * function:XStream结合JettisonMappedXmlDriver驱动，转换Java对象到JSON

 * 需要添加jettison jar

 * @author hoojo

 * @createDate Nov 27, 2010 1:23:18 PM

*/

@Test

public void writeEntity2JETTSON() {

    failRed("=======JettisonMappedXmlDriver===JavaObject >>>> JaonString=========");

    xstream = new XStream(new JettisonMappedXmlDriver());

    xstream.setMode(XStream.NO_REFERENCES);

    xstream.alias("student", Student.class);

    fail(xstream.toXML(bean));

运行后结果如下：

=======JettisonMappedXmlDriver===JavaObject >>>> JaonString=========

{"student":{"id":1,"name":"jack","email":"jack@email.com","address":"china","birthday":[{},"2010-11-22"]}}

JSON的转换和XML的转换用法一样，只是创建XStream需要传递一个参数，这个参数就是xml到JSON映射转换的驱动。这里会降到两个驱动，分别是JettisonMappedXmlDriver、JsonHierarchicalStreamDriver。
2、 JsonHierarchicalStreamDriver完成Java对象到JSON的转换

/**

 * function:用XStream结合JsonHierarchicalStreamDriver驱动

 * 转换java对象为JSON字符串

 * @author hoojo

 * @createDate Nov 27, 2010 1:16:46 PM

*/

@Test

public void writeEntiry2JSON() {

    failRed("======JsonHierarchicalStreamDriver====JavaObject >>>> JaonString=========");

    xstream = new XStream(new JsonHierarchicalStreamDriver());

    //xstream.setMode(XStream.NO_REFERENCES);

    xstream.alias("student", Student.class);

    failRed("-------Object >>>> JSON---------");

    fail(xstream.toXML(bean));

    //failRed("========JsonHierarchicalStreamDriver==删除根节点=========");

    //删除根节点

    xstream = new XStream(new JsonHierarchicalStreamDriver() {

        public HierarchicalStreamWriter createWriter(Writer out) {

            return new JsonWriter(out, JsonWriter.DROP_ROOT_MODE);

});

    //xstream.setMode(XStream.NO_REFERENCES);

    xstream.alias("student", Student.class);

    fail(xstream.toXML(bean));

运行后结果如下：

======JsonHierarchicalStreamDriver====JavaObject >>>> JaonString=========

-------Object >>>> JSON---------

{"student": {

  "id": 1,

  "name": "jack",

  "email": "jack@email.com",

  "address": "china",

  "birthday": {

    "birthday": "2010-11-22"

}}

  "id": 1,

  "name": "jack",

  "email": "jack@email.com",

  "address": "china",

  "birthday": {

    "birthday": "2010-11-22"

使用JsonHierarchicalStreamDriver转换默认会给转换后的对象添加一个根节点，但是在构建JsonHierarchicalStreamDriver驱动的时候，你可以重写createWriter方法，删掉根节点。
看上面的结果，一个是默认带根节点的JSON对象，它只是将类名作为一个属性，将对象作为该属性的一个值。而另一个没有带根属性的JSON就是通过重写createWriter方法完成的。
3、将List集合转换成JSON字符串

@Test

public void writeList2JSON() {

    failRed("======JsonHierarchicalStreamDriver====JavaObject >>>> JaonString=========");

    JsonHierarchicalStreamDriver driver = new JsonHierarchicalStreamDriver();

    xstream = new XStream(driver);

    //xstream = new XStream(new JettisonMappedXmlDriver());//转换错误

    //xstream.setMode(XStream.NO_REFERENCES);

    xstream.alias("student", Student.class);

    List list = new ArrayList();

    list.add(bean);//add

    bean = new Student();

    bean.setAddress("china");

    bean.setEmail("tom@125.com");

    bean.setId(2);

    bean.setName("tom");

    Birthday day = new Birthday("2010-11-22");

    bean.setBirthday(day);

    list.add(bean);//add

    bean = new Student();

    bean.setName("jack");

    list.add(bean);//add

    fail(xstream.toXML(list));

    //failRed("========JsonHierarchicalStreamDriver==删除根节点=========");

    //删除根节点

    xstream = new XStream(new JsonHierarchicalStreamDriver() {

        public HierarchicalStreamWriter createWriter(Writer out) {

            return new JsonWriter(out, JsonWriter.DROP_ROOT_MODE);

});

    xstream.alias("student", Student.class);

    fail(xstream.toXML(list));

运行后结果如下

======JsonHierarchicalStreamDriver====JavaObject >>>> JaonString=========

##{"list": [

    "id": 1,

    "name": "jack",

    "email": "jack@email.com",

    "address": "china",

    "birthday": {

      "birthday": "2010-11-22"

},

    "id": 2,

    "name": "tom",

    "email": "tom@125.com",

    "address": "china",

    "birthday": {

      "birthday": "2010-11-22"

},

    "id": 0,

    "name": "jack"

]}

#[

    "id": 1,

    "name": "jack",

    "email": "jack@email.com",

    "address": "china",

    "birthday": {

      "birthday": "2010-11-22"

},

    "id": 2,

    "name": "tom",

    "email": "tom@125.com",

    "address": "china",

    "birthday": {

      "birthday": "2010-11-22"

},

    "id": 0,

    "name": "jack"

上面的list1是使用JsonHierarchicalStreamDriver 转换的，当然你也可以使用JettisonMappedXmlDriver驱动进行转换；用JettisonMappedXmlDriver转换后，你会发现格式不同而且没有根属性。
4、 Map转换json

@Test

public void writeMap2JSON() {

    failRed("======JsonHierarchicalStreamDriver==== Map >>>> JaonString=========");

    xstream = new XStream(new JsonHierarchicalStreamDriver());

    //xstream = new XStream(new JettisonMappedXmlDriver());

    xstream.alias("student", Student.class);

    Map map = new HashMap();

    map.put("No.1", bean);//put

    bean = new Student();

    bean.setAddress("china");

    bean.setEmail("tom@125.com");

    bean.setId(2);

    bean.setName("tom");

    bean.setBirthday(new Birthday("2010-11-21"));

    map.put("No.2", bean);//put

    bean = new Student();

    bean.setName("jack");

    map.put("No.3", bean);//put

    fail(xstream.toXML(map));

    //failRed("========JsonHierarchicalStreamDriver==删除根节点=========");

    //删除根节点

    xstream = new XStream(new JsonHierarchicalStreamDriver() {

        public HierarchicalStreamWriter createWriter(Writer out) {

            return new JsonWriter(out, JsonWriter.DROP_ROOT_MODE);

});

    xstream.alias("student", Student.class);

    fail(xstream.toXML(map));

运行后结果如下：

======JsonHierarchicalStreamDriver==== Map >>>> JaonString=========

{"map": [

    "No.3",

      "id": 0,

      "name": "jack"

],

    "No.1",

      "id": 1,

      "name": "jack",

      "email": "jack@email.com",

      "address": "china",

      "birthday": {

        "birthday": "2010-11-22"

],

    "No.2",

      "id": 2,

      "name": "tom",

      "email": "tom@125.com",

      "address": "china",

      "birthday": {

        "birthday": "2010-11-21"

]}

    "No.3",

      "id": 0,

      "name": "jack"

],

    "No.1",

      "id": 1,

      "name": "jack",

      "email": "jack@email.com",

      "address": "china",

      "birthday": {

        "birthday": "2010-11-22"

],

    "No.2",

      "id": 2,

      "name": "tom",

      "email": "tom@125.com",

      "address": "china",

      "birthday": {

        "birthday": "2010-11-21"

5、将JSON转换java对象

/**

 * function:JsonHierarchicalStreamDriver可以将简单的json字符串转换成java对象，list、map转换不成功；

 * JsonHierarchicalStreamDriver读取JSON字符串到java对象出错

 * @author hoojo

 * @createDate Nov 27, 2010 1:22:26 PM

 * @throws JSONException

*/

@Test

public void readJSON2Object() throws JSONException {

    String json = "{\"student\": {" +

        "\"id\": 1," +

        "\"name\": \"haha\"," +

        "\"email\": \"email\"," +

        "\"address\": \"address\"," +

        "\"birthday\": {" +

            "\"birthday\": \"2010-11-22\"" +

        "}" +

    "}}";

    //JsonHierarchicalStreamDriver读取JSON字符串到java对象出错，但JettisonMappedXmlDriver可以

    xstream = new XStream(new JettisonMappedXmlDriver());

    xstream.alias("student", Student.class);

    fail(xstream.fromXML(json).toString());

    //JettisonMappedXmlDriver转换List集合出错，但JsonHierarchicalStreamDriver可以转换正确

    //JettisonMappedXmlDriver 转换的字符串 {"list":{"student":[{"id":1,"name":"haha","email":"email","address":"address","birthday":[{},"2010-11-22"]}]},"student":{"id":2,"name":"tom","email":"tom@125.com","address":"china","birthday":[{},"2010-11-22"]}}

    json = "{\"list\": [{" +

            "\"id\": 1," +

            "\"name\": \"haha\"," +

            "\"email\": \"email\"," +

            "\"address\": \"address\"," +

            "\"birthday\": {" +

              "\"birthday\": \"2010-11-22\"" +

            "}" +

           "},{" +

            "\"id\": 2," +

            "\"name\": \"tom\"," +

            "\"email\": \"tom@125.com\"," +

            "\"address\": \"china\"," +

            "\"birthday\": {" +

              "\"birthday\": \"2010-11-22\"" +

            "}" +

          "}]}";

    System.out.println(json);//用js转换成功

    List list = (List) xstream.fromXML(json);

    System.out.println(list.size());//0好像转换失败

运行后结果如下：

haha#1#address#2010-11-22#email

{"list": [{"id": 1,"name": "haha","email": "email","address": "address","birthday": {"birthday": "2010-11-22"}},

{"id": 2,"name": "tom","email": "tom@125.com","address": "china","birthday": {"birthday": "2010-11-22"}}]}

JSON到Java的转换是fromXML方法。

出处：http://www.cnblogs.com/hoojo/archive/2011/04/22/2025197.html

用Kibana和logstash快速搭建实时日志查询、收集与分析系统

2013-05-21T09:23:00.001+10:00

Logstash是一个完全开源的工具，他可以对你的日志进行收集、分析，并将其存储供以后使用（如，搜索），您可以使用它。说到搜索，logstash带有一个web界面，搜索和展示所有日志。
kibana 也是一个开源和免费的工具，他可以帮助您汇总、分析和搜索重要数据日志并提供友好的web界面。他可以为 Logstash 和 ElasticSearch 提供的日志分析的 Web 界面
说到这里，我们看看 kibana 和 logstash到底能为我们做些什么呢？下面是kibana的界面

简单来讲他具体的工作流程就是 logstash agent 监控并过滤日志，将过滤后的日志内容发给redis(这里的redis只处理队列不做存储)，logstash index将日志收集在一起交给
全文搜索服务ElasticSearch 可以用ElasticSearch进行自定义搜索通过Kibana 来结合自定义搜索进行页面展示，下图是 Kibana官网上的流程图

好了让我们一步步的把这套环境搭建起来吧，先看看都需要安装什么软件包
ruby 运行Kibana 必须，
rubygems 安装ruby扩展必须
bundler 功能类似于yum
JDK 运行java程序必须
redis 用来处理日志队列
logstash 收集、过滤日志
ElasticSearch 全文搜索服务(logstash集成了一个)
kibana 页面展示
这里有三台服务器
192.168.233.128 logstash index，ElasticSearch，kibana，JDK
192.168.233.129 logstash agent，JDK
192.168.233.130 redis

首先到 logstash index服务器上面，logstash分为 index和aget ，agent负责监控、过滤日志，index负责收集日志并将日志交给ElasticSearch 做搜索
此外 logstash 的收集方式分为 standalone 和 centralized。
standalone 是所有功能都在一个服务器上面，自发自收，centralized 就是集中收集，一台服务器接收所有shipper(个人理解就是logstash agent)的日志。
其实 logstash本身不分什么 shipper 和 collector ，只不过就是配置文件不同而已，我们这次按照集中的方式来测试

在 logstash index上安装基础的软件环境


[192.168.233.128 root@nodec:~] 

# cd /soft/ 

[192.168.233.128 root@nodec:/soft] 

# wget http://down1.chinaunix.net/distfiles/jdk-6u13-dlj-linux-i586.bin 

从oracle下载实在是太慢了，从CU下载会快一些，如果需要最新版本请访问这里 

http://www.oracle.com/technetwork/java/javase/downloads/jdk7-downloads-1880260.html 

[192.168.233.128 root@nodec:/soft] 

# sh jdk-6u13-dlj-linux-i586.bin 

输入yes 便开始安装了 

安装完成后设置一下 JAVA_HOME 

[192.168.233.128 root@nodec:/soft/Kibana-0.2.0] 

# vim /etc/profile 

export JAVA_HOME=/usr/java 

export PATH=$JAVA_HOME/bin:$PATH 

export CLASSPATH=.:$JAVA_HOME/lib/tools.jar:$JAVA_HOME/lib/dt.jar:$CLASSPATH 

 

安装ruby 就比较简单了(Kibana需要ruby 1.8.7以上版本) 

[192.168.233.128 root@nodec:/soft] 

# yum install ruby rubygems 

..... 安装内容省略 

安装完成后用 rubygems 来安装bundler 

[192.168.233.128 root@nodec:/soft] 

# /usr/bin/gem install bundler 

..... 

 

ok 这样基本的环境就已经有了，下面就是安装kibana 和 logstash 

其实logstash 就是一个java脚本，不需要安装... 下载即用 

[192.168.233.128 root@nodec:/soft] 

# wget http://logstash.objects.dreamhost.com/release/logstash-1.1.0-monolithic.jar 

现在看看 这个脚本应该怎么去执行 

[192.168.233.128 root@nodec:/soft] 

# java -jar /soft/logstash-1.1.0-monolithic.jar -h 

No such command "-h" 

Available commands: 

  -v 

  -V 

  --version 

  agent 

  web 

  test 

显然没有 -h 参数，不过列出了能用的参数，但是logstash的参数可不止这些， 

java -jar /soft/logstash-1.1.0-monolithic.jar agent --help 

这些是在agent模式下的命令参数 

-f, --config CONFIGFILE 

    Load the logstash config from a specific file, directory, or a wildcard. If given a directory or wildcard, config files will be read in order lexigraphically. 

-e CONFIGSTRING 

    Use the given string as the configuration data. Same syntax as the config file. If not input is specified, 'stdin { type => stdin }' is default. If no output is specified, 'stdout { debug => true }}' is default. 

-w, --filterworks COUNT 

    Run COUNT filter workers (default: 1) 

--watchdog-timeout TIMEOUT 

    Set watchdog timeout value. 

-l, --log FILE 

    Log to a given path. Default is to log to stdout 

-v 

    Increase verbosity. There are multiple levels of verbosity available with '-vv' currently being the highest 

--pluginpath PLUGIN_PATH 

    A colon-delimted path to find other logstash plugins in 

java -jar /soft/logstash-1.1.0-monolithic.jar web --help 

下面的是在web界面的参数 

--log FILE 

    Log to a given path. Default is stdout. 

--address ADDRESS 

    Address on which to start webserver. Default is 0.0.0.0. 

--port PORT 

    Port on which to start webserver. Default is 9292. 

-B, --elasticsearch-bind-host ADDRESS 

    Address on which to bind elastic search node. 

-b, --backend URL 

    The backend URL to use. Default is elasticsearch:/// (assumes multicast discovery). You can specify elasticsearch://[host][:port]/[clustername] 


如果上面的这些命令都能执行正常的话就表示 logstash可以使用了，但要让他启动还需要一个配置文件


[192.168.233.128 root@nodec:/soft] 

 

# vim redis.conf 

 

input {

redis { 

  host => '192.168.233.130' 

  data_type => 'list' 

  port => "6379" 

  key => 'logstash:redis' 

  type => 'redis-input' 

       } 

       }

 

output { 

    elasticsearch { 

    embedded => true 

                  } 

       }

解释一下 logstash的配置文件由 input filter output 等几个基本的部分组成，顾名思义 input 就是在那收集数据，output就是输出到哪，filter代表一个过滤规则意思是什么内容
会被收集。
上面这段是让 logstash 去192.168.233.130 这个redis服务器上去收集日志 redis端口为6379，key是 logstash:redis 类型为 redis-input ，（注意:这几个值必须跟logstash agent的
output 所对应），收集完成后输出到 elasticsearch ,embedded => true 的意思是使用logstash 内嵌的 elasticsearch。如果有独立的elasticsearch服务器，需要将 这条改为
host => 'elasticsearch的ip' port => 端口
好了，这个简单的配置文件可以让logstash开始启动了


[192.168.233.128 root@nodec:/soft] 

# java -jar /soft/logstash-1.1.0-monolithic.jar agent -f /soft/redis.conf -- web --backend elasticsearch:///?local & 

[1] 5205 

...这里要等待约5秒钟... 为什么？去问开发者吧 

[192.168.233.128 root@nodec:/soft] 

# I, [2013-03-19T03:23:10.749000 #5205]  INFO -- : Using beta plugin 'redis'. For more information about plugin statuses, see http://logstash.net/docs/1.1.0/plugin-status  {"timestamp":"2013-03-19T03:23:10.732000 -0700","message":"Using beta plugin 'redis'. For more information about plugin statuses, see http://logstash.net/docs/1.1.0/plugin-status ","level":"info"} 

file:/soft/logstash-1.1.0-monolithic.jar!/gems/rack-1.3.4/lib/rack/backports/uri/common_192.rb:53 warning: already initialized constant WFKV_ 

Mizuno 0.5.0 (Jetty 8.0.y.z-SNAPSHOT) listening on 0.0.0.0:9292 

解释一下 上面的命令 agent 代理模式 -f 指定配置文件 --web 其实是个分隔符等于又启动了一个命令，后面的参数就是开启一个web页面默认端口是9292,这个命令如果拆成两个就是这个样子 

java -jar /soft/logstash-1.1.0-monolithic.jar agent -f /soft/redis.conf & 

java -jar /soft/logstash-1.1.0-monolithic.jar web --backend elasticsearch:///?local & (其实如果用kibana来做web界面的话这一步完全可以省掉了)

好了，看到9292 端口启动就代表 启动成功了，检查一下


[192.168.233.128 root@nodec:/soft] 

# lsof -i:9292 

COMMAND  PID USER   FD   TYPE DEVICE SIZE NODE NAME 

java    5205 root  465u  IPv4 130805       TCP *:armtechdaemon (LISTEN) 

其实logstash还启动了一个端口9200，因为启动了内嵌的 elasticsearch，这个9200是 elasticsearch在监听 

[192.168.233.128 root@nodec:/soft] 

# lsof -i:9200 

COMMAND  PID USER   FD   TYPE DEVICE SIZE NODE NAME 

java    5205 root  160u  IPv4 130682       TCP *:wap-wsp (LISTEN)

现在可以通过浏览器访问一下 http://192.168.233.128:9292 看看logstash是的页面是个什么样子

现在还不能搜索因为现在还没有数据，其实这个时候 http://192.168.233.128:9200 也是可以访问的，
很多开发自己写代码来调用elasticsearch 来实现他们自己的需要，这里就不多说了
192.168.233.128 这台logstash index的操作暂时告一段落，下面开始配置logstash的agent
登录到服务器 192.168.233.129 安装基本软件包和logstash


[192.168.233.129 root@noded:~] 

# cd /soft/ 

[192.168.233.129 root@noded:/soft] 

# wget http://down1.chinaunix.net/distfiles/jdk-6u13-dlj-linux-i586.bin 

[192.168.233.129 root@noded:/soft] 

# sh jdk-6u13-dlj-linux-i586.bin 

设置 JAVA_HOME 

[192.168.233.129 root@noded:/soft] 

# vim /etc/profile 

export JAVA_HOME=/usr/java 

export PATH=$JAVA_HOME/bin:$PATH 

export CLASSPATH=.:$JAVA_HOME/lib/tools.jar:$JAVA_HOME/lib/dt.jar:$CLASSPATH 

[192.168.233.129 root@noded:/soft] 

# yum install ruby 

192.168.233.129 root@noded:/soft] 

# wget http://logstash.objects.dreamhost.com/release/logstash-1.1.0-monolithic.jar 

[192.168.233.129 root@noded:/soft] 

# vim redis.conf 

input { 

    file { 

    type => "producer" 

    path => "/soft/apache.log" 

    } 

    file { 

    type => "php-log" 

    path => "/soft/php.log" 

    } 

} 

filter { 

       grep { 

       match => [ "@message", "mysql|GET|error" ] 

            } 

       } 

 

output { 

      redis { 

      host => '192.168.233.130' 

      data_type => 'list' 

      key => 'logstash:redis' 

       } 

       }

大概说一下这个配置文件 input 里的file就是要监视的文件了这里我监视了两个文件，如果这两个文件有追加的内容就会通过下面的output设置发给 redis服务器
filter 里的grep 意思就是 grep... 后面这段就是日志内容里面只要有匹配 mysql或GET或error的内容就会被过滤出来，发送到 logstash index
以上就是一个比较简单的配置文件了，让我们启动他


[192.168.233.129 root@noded:/soft] 

# java -jar /soft/logstash-1.1.0-monolithic.jar agent -f /soft/redis.conf & 

I, [2013-03-19T19:45:35.762000 #2721]  INFO -- : Using beta plugin 'file'. For more information about plugin statuses, see http://logstash.net/docs/1.1.0/plugin-status  {"timestamp":"2013-03-19T19:45:35.752000 -0700","message":"Using beta plugin 'file'. For more information about plugin statuses, see http://logstash.net/docs/1.1.0/plugin-status ","level":"info"} 

I, [2013-03-19T19:45:35.778000 #2721]  INFO -- : Using beta plugin 'file'. For more information about plugin statuses, see http://logstash.net/docs/1.1.0/plugin-status  {"timestamp":"2013-03-19T19:45:35.778000 -0700","message":"Using beta plugin 'file'. For more information about plugin statuses, see http://logstash.net/docs/1.1.0/plugin-status ","level":"info"} 

I, [2013-03-19T19:45:35.804000 #2721]  INFO -- : Using beta plugin 'grep'. For more information about plugin statuses, see http://logstash.net/docs/1.1.0/plugin-status  {"timestamp":"2013-03-19T19:45:35.803000 -0700","message":"Using beta plugin 'grep'. For more information about plugin statuses, see http://logstash.net/docs/1.1.0/plugin-status ","level":"info"} 

I, [2013-03-19T19:45:35.854000 #2721]  INFO -- : Using beta plugin 'redis'. For more information about plugin statuses, see http://logstash.net/docs/1.1.0/plugin-status  {"timestamp":"2013-03-19T19:45:35.853000 -0700","message":"Using beta plugin 'redis'. For more information about plugin statuses, see http://logstash.net/docs/1.1.0/plugin-status ","level":"info"}

只要没有 warning 和 error就算是正常启动了
启动之前请确定 192.168.233.130的 redis服务器已经启动，不然会报错
下面登录到 192.168.233.130 上看看 redis服务的状态


[192.168.233.130 root@nodea:/data/redis/etc] 

# lsof -i:6379 

COMMAND    PID USER   FD   TYPE DEVICE SIZE NODE NAME 

redis-ser 2732 root    4u  IPv4   7946       TCP *:6379 (LISTEN) 

redis-ser 2732 root    5u  IPv4   7963       TCP localhost.localdomain:6379->localhost.localdomain:19214 (ESTABLISHED) 

java      2733 root    9u  IPv4   7959       TCP localhost.localdomain:19214->localhost.localdomain:6379 (ESTABLISHED) 

状态正常，端口处于监听状态，我用的是最简单的 配置， 

[192.168.233.130 root@nodea:/data/redis/etc] 

# vim redis.conf 

#this is the config file for redis 

pidfile /var/run/redis.pid 

port 6379 

timeout 0 

loglevel verbose 

logfile /data/redis/log/redis.log 

dbfilename dump.rdb 

dir /data/redis/db/ 

vm-swap-file /tmp/redis.swap 

activerehashing yes 

启动命令如下 

[192.168.233.130 root@nodea:/data/redis/etc] 

# redis-server /data/redis/etc/redis.conf &

下载安装就比较简单了


[192.168.233.130 root@nodea:/soft] 

# wget http://redis.googlecode.com/files/redis-2.4.14.tar.gz 

[192.168.233.130 root@nodea:/data/redis/etc] 

# make –j24 

[192.168.233.130 root@nodea:/data/redis/etc] 

# make install

配置文件里的那几个路径要提前建好

最后我们回到 logstash agent 上面测试一下


[192.168.233.129 root@noded:/soft] 

# echo GET12313 >> apache.log 

[192.168.233.129 root@noded:/soft] 

# echo errorabcd >> apache.log

ok 到 http://192.168.233.128:9292 去搜索一下刚才的两个内容

嗯，就是这样了，我现在找个php的错误日志给他追加到php.log文件里
[192.168.233.129 root@noded:/soft]
# cat php-error.log >> php.log
在看看 logstash的页面搜索一下 error

OK，最后就是 Kibana了，我把Kibana装在了 logstash index上面
下载地址为 http://kibana.org/intro.html


[192.168.233.128 root@nodec:/soft] 

# tar xf Kibana-0.2.0.tar.gz 

[192.168.233.128 root@nodec:/soft] 

# cd Kibana-0.2.0 

[192.168.233.128 root@nodec:/soft/Kibana-0.2.0] 

# bundle install 

直接安装就好了，非常简单，因为之前咱们已经安装好了 bundle 

编辑配置文件，指定 elasticsearch 的位置 

[192.168.233.128 root@nodec:/soft/Kibana-0.2.0] 

# vim KibanaConfig.rb 

..... 

  Elasticsearch = "localhost:9200" 

  KibanaPort = 5601 

  KibanaHost = '0.0.0.0' 

..... 

主要是这几个参数 

启动的话需要ruby 

[192.168.233.128 root@nodec:/soft/Kibana-0.2.0] 

# /usr/bin/ruby kibana.rb & 

[192.168.233.128 root@nodec:/soft/Kibana-0.2.0] 

# == Sinatra/1.3.5 has taken the stage on 5601 for development with backup from Thin 

>> Thin web server (v1.5.0 codename Knife) 

>> Maximum connections set to 1024 

>> Listening on 0.0.0.0:5601, CTRL+C to stop 

如果ruby的东西都不缺的话，启动会很顺利，ok 现在看看5601端口的状态 

[192.168.233.128 root@nodec:/soft/Kibana-0.2.0] 

# lsof -i:5601 

COMMAND  PID USER   FD   TYPE DEVICE SIZE NODE NAME 

ruby    3116 root    5u  IPv4  28947       TCP *:esmagent (LISTEN)

访问一下试试看 http://192.168.233.128:5601 尝试搜索一下php的错误日志，比如mysql

呵呵，要的就是这个效果，日志会实时的汇总到 logstash index 上供我们查询，当然这只是开始使用logstash的第一步而已，更多的高级功能可以看看官方文档
http://logstash.net/docs/1.1.9/

出处：http://storysky.blog.51cto.com/628458/1158707

Kibana installation

2013-05-20T15:22:00.003+10:00

kibana:

yum install rubygems ruby-devel make gcc gcc-c++
download kibana into /opt
edit KibanaConfig.rb:

Elasticsearch = "elasticsearch-lab:9200"
KibanaHost = '10.10.10.7'    # (kibana-host)

gem install bundler
bundle install
iptables allow inbound tcp:5601 (web interface)

Start with:

ruby kibana.rb

Browse to: http://kibana-host:5601/

How to install Sun Java JDK in CentOS 6

2013-05-20T12:26:00.001+10:00

But by default OpenJDK based java was installed in my system.

[root@server2 sandbox]# java -version
java version “1.6.0_17″
OpenJDK Runtime Environment (IcedTea6 1.7.9) (rhel-1.36.b17.el6_0-x86_64)
OpenJDK 64-Bit Server VM (build 14.0-b16, mixed mode)

Step 1: Donwload JDK from http://www.java.com. I got JDK version 7 in rpm format.

mohamed@SilentStorm $ ls *.rpm
jdk-7-linux-x64.rpm

Step 2: Install the RPM.

[root@server2 sandbox]# rpm -i jdk-7-linux-x64.rpm
Unpacking JAR files…
rt.jar…
jsse.jar…
charsets.jar…
tools.jar…
localedata.jar…

By default Java will be installed to /usr/java/jdk1.7.0/
Step 3: Add this new java to the alternatives configuration & Update the java alternatives

[root@server2 sandbox]# alternatives - -install /usr/bin/java java /usr/java/jdk1.7.0/bin/java 2
[root@server2 sandbox]# alternatives – -config java
There are 3 programs which provide ‘java’.
Selection Command
———————————————–
*+ 1 /usr/lib/jvm/jre-1.6.0-openjdk.x86_64/bin/java
2 /usr/lib/jvm/jre-1.5.0-gcj/bin/java
3 /usr/java/jdk1.7.0/bin/java
Enter to keep the current selection[+], or type selection number: 3

Step 4: Now verify the java version

[root@server2 sandbox]# java -version
java version “1.7.0″
Java(TM) SE Runtime Environment (build 1.7.0-b147)
Java HotSpot(TM) 64-Bit Server VM (build 21.0-b17, mixed mode)

ubuntu为什么没有/etc/inittab文件? 深究ubuntu的启动流程分析

2013-05-19T05:22:00.002+10:00

Linux 内核启动 init ，init进程ID是1，是所有进程的父进程，所有进程由它控制。

Ubuntu 的启动由upstart控制，自9.10后不再使用/etc/event.d目录的配置文件，改为/etc/init。

查看当前的运行级别，Ubuntu 桌面默认是2。

1	`runlevel`

Ubuntu 的系统运行级别：

1

2

3

4

5

0        系统停机状态
1        单用户或系统维护状态
2~5      多用户状态
6        重新启动
S

切换运行级别，执行命令：

1	`init [0123456Ss]`

即在 init 命令后跟一个参数，此参数是要切换到的运行级的运行级代号，如：用 init 0 命令关机；用 init 6 命令重新启动。

这就是我们的关机命令之一 $ sudo init 0  的由来:

1	`$ sudo init` `0`

查看系统当前运行等级：

1	`runlevel`

查看系统在什么地方设置这个初始值，打开文件：（后面详细介绍为什么）

1	`$ nano /etc/init/rc-sysinit.conf`

你会发现这么一句：

1

2

3

# Default runlevel, this may be overriden on the kernel command-line
# or by faking an old /etc/inittab entry
   env DEFAULT_RUNLEVEL=2

Ubuntu init启动流程分析:

现行的Linux distros主流的有两种init方式：一种是广为流传的System V initialization，它来源于Unix并且至今仍被各种Linux distros所采用；另一种是近几年提出的Upstart方式，基于事件机制，系统的所有服务，任务都是由事件驱动的。据我所知，采用后一种方式的目前有Ubuntu（6.10 and later），Fedora（9.10 and later），Debian（optional）。虽然采用Upstart的发行版并不多，但它旨在取代旧式的System V initialization。

作为知识梳理，我现在就先在这里总结一下这两种方式各自的初始化流程，这也是为了方便整理思路：

之前在查找Linux系统init流程的相关资料时总是能够看到inittab的身影，但是在我的Ubuntu上是没有这个文件的，到后来才知道采用 Upstart方式的Ubuntu上是没有inittab这个文件的。在旧式的System V initialization中，/etc/inittab可是个相当重要的文件。init进程启动后第一时间找的就是它！inittab负责初始化系统，设置系统runlevel及进 入各runlevel对应要执行的命令。假设当前inittab中设置的默认runlevle是5，则init会运行/etc/init.d/rc 5命令，该命令会依据系统服务的依赖关系遍历执行/etc/rc5.d中的脚本/程序。进入/etc/rc5.d目录可以发现里面的文件都是到/etc /init.d/下对应的脚本/程序的软链接。以S开头的为启动的意思，以K开头的为停止。并且S/K后面的两位数数字代表了服务的启动顺序（由服务依赖关系决定）。

【注】   网上查了一下， .d 文件的作用 ： .d代表目录即文件夹的意思。/etc是存放配置文件的目录，配置文件有的是单独的，有的是一类，通常单独的配置文件后缀是.conf，一类的配置文件放在一个目录中，目录名就叫XX.d，XX指的是哪方面的配置文件，比如init.d就存放有关linux启动的配置文件。

那么Upstart job是怎么样的呢？我们知道，System V initializaiton是以runlevel为核心，依据服务间依赖关系的init方式，但在Upstart job，runlevel虽说对于服务的启动也有影响但已不是关键所在。Upstart job是事件驱动的，系统服务的启动、停止等等均是由事件决定的，反过来，系统服务的启动、停止也可以作为事件源触发其他服务。并且事件并不一定得由系统内部产生，用户可以手工的键入start/stop [Service]产生事件来启动/终止服务。man upstart-evnets查看upstart job所定义的事件，可以发现，runlevel也被当作事件来对待（因runlevel的改变而产生的事件），诸如此类还有其他如 startup，started，filesystem等等。那么系统服务又是如何知道自己应该什么时候启动，什么时候终止的呢？答案就在于/etc /init中（有的distros可能是在/etc/event.d）。进入/etc/init目录下一看，均是系统服务的配置文件，或者说，是job definition files。（实际上Upstart init只需要/etc/init这么一个目录，不像System V init，“拐弯抹脚”转好多圈才到达目的地，在性能上不如前者）。随便打开一个文件，比如cron.conf：

# cron - regular background program processing daemon
#
# cron is a standard UNIX program that runs user-specified programs at
# periodic scheduled times
description "regular background program processing daemon"
start on runlevel [2345]
stop on runlevel [!2345]
expect fork
respawn
exec cron

相信敏锐的程序猿们都发现了：start on runlevel [2345]；stop on runlevel [！2345]

没错，配置文件就是通过这个来设置服务何时启动，何时终止的。

实际上并不仅仅在系统启动初期，在系统运转的任何时期都可以通过发送事件来启动或终止服务。这便是Upstart job的优点之一，除了用于系统初始化，还可以在系统运行阶段发挥作用。相比之下System V initialization方式下的配置文件一般只用于系统初始化阶段，当然系统运行阶段我们可以通过/etc/init.d/Service start/stop/otherCommand来操作服务，但很明显不如Upstart方式简洁明白。(如果你是linux 用户，你一定不陌生这些，一定很清楚。)

好，介绍完System V initialization和Upstart，那么现在就能介绍Ubuntu init系统初始化流程。前面提过Ubuntu使用的是Upstart方式的initialization，其实不全然，考虑到6.10之前的版本采用的System V init及某些服务的需要，Ubuntu采用的是兼容模式，即：系统中既有System V-style启动的服务，也有Upstart启动的服务。如果你使用的是Ubuntu11.04（我目前PC上的系统），那么你可以看到系统中有这么几个目录：

1

2

3

/etc/init
/etc/init.d
/etc/rc${runlevel}.d

作为两种init方式各自特征的/etc/init.d，/etc/rc${runlevel}.d目录和/etc/init目录在Ubuntu中都有了，那么Ubuntu是如何实现兼容的？实际上，Ubuntu中并没有直接采用System V-style启动服务，要知道，Ubuntu中的init已被替换为Upstart init，而System V-style的服务是存放于/etc/rc${runlevel}.d目录中的，（而/etc/rc${runlevle}.d/下的文件是到/etc/init.d的软链接）可Upstart init并不会直接跑到这里面去启动服务。它是通过间接调用来启动这类服务的。换句话说，Ubuntu中的init并不会直接奔着/etc/init.d或者/etc/rc${runlevel}.d/而去，它采用了折衷的办法，通过/etc/init下的某些配置文件调用/etc/rc${runlevel}.d/中的脚本以启动采用旧式System V-style的服务。（这是精髓）唉，说的我自己都觉得好绕，还是见实例吧，看下面。

进入/etc/init目录（Upstart init会到该目录下读取配置文件），会发现几个跟rc有关的配置文件：

1

2

3

rc.conf
rc-sysinit.conf
rcS.conf

rc-sysinit在startup事件发生时被启动，rc在系统runlevel变化时被启动，rcS在系统runlevel为S时启动。在配置文件的注释中说明了，这几个文件，正是Upstart init处理System V-style服务的关键。

rc-sysinit在startup事件发生时被启动，即，Upstart init会首先读取rc-sysinit.conf并执行相关配置和脚本。rc-sysinit.conf的主要工作是设置系统默认runlevel，检测是否存在/etc/inittab或内核命令行，若存在，则按内核命令行>/etc/inittab>默认runlevel的顺序设置系统 runlevel。最后，调用telinit进入设置的runlevel。

由于调用了telinit进入了设定的runlevel，runlevel改变的事件发生，此时rc服务启动（当然其他服务也会）。那么，我们就有必要来看看rc.conf中到底有什么东西。打开rc.conf，注意到最后一行：

1	`exec /etc/init.d/rc $RUNLEVEL`

是不是感觉/etc/init.d/rc很熟悉，没错，在System V initialization中，/etc/inittab中的各runlevel对应的命令行就是通过这种形式设置的。

很明显，/etc/init.d/rc被调用了，并且传入了早前设置好的系统runlevel作为参数。而/etc/init.d/rc会根据传入 的runlevel参数调用/etc/rc${runlevel}.d/下的脚本（以S开头）以启动服务，终止在前次runlevel启动而当前在 runlevel需要终止的服务。至此，Ubuntu处理System V-style服务的流程是不是渐渐明朗了。通过rc-sysinit和rc间接的调用/etc/init.d/rc从而启动System V-style服务，Ubuntu在采用新式Upstart init照顾了旧式的System V init。

采用Upstart方式启动的服务则在/etc/init/目录中有属于自己的一份配置文件，终端下键入：initctl list，看看列出的服务是否同/etc/init/下的服务完全一致！

Linux: /etc/inittab -> /etc/rc*.d -> /etc/init.d
Ubuntu: /etc/init/*.conf -> /etc/rc*.d -> /etc/init.d

Installing Apache Archiva as a Web Application

2013-05-14T21:24:00.002+10:00

http://archiva.apache.org/docs/1.3.6/adminguide/webapp.html
https://cwiki.apache.org/confluence/display/ARCHIVA/Archiva+on+Tomcat

Clearing a Solr search index

2013-05-04T20:54:00.001+10:00

When developing a search project using Apache Solr, you often need to clear out the search index and start again. A typical example of this is when you make a schema change. Luckily, there is an easy way to do this via the Solr REST API.

According to the official Solr FAQ, you can clear out a Solr index by issuing the following query:




 1 
<delete><query>*:*</query></delete>

To run this query, you can issue it via the REST API using curl:




 1 
 2 
curl http://localhost:8080/solr/update -H "Content-type: text/xml" \
--data-binary '*:*'

Note that you will also need to tell Solr to commit this change:




 1 
 2 
curl http://localhost:8080/solr/update -H "Content-type: text/xml" \
--data-binary ''

...and it is also a good idea to tell Solr to optimize it's index at this point:




 1 
 2 
curl http://localhost:8080/solr/update -H "Content-type: text/xml" \
--data-binary ''

To confirm that your index is now empty, load up the Solr admin web interface in your browser, and click on the statisticslink. You should now see that the number of documents listed in your index is now zero.

Note that the final optimize command is passed to Solr to tell it to physically remove the deleted documents, which will not only free up disc space, but will also increase search performance. Following the above procedure of delete/commit/optimize will ensure that you start off with a clean slate each time.

跑步新手如何开始你的跑步训练

2013-04-27T07:28:00.000+10:00

在任何运动中获得成功，你必须遵循一些基本规则。例如，高尔夫中要低头，网球中要保持从始到终的正确姿势，而跑步则是：正确训练，而不是过度训练。

步骤/方法

跑步永远不会太迟。如果你决定开始跑步了，那这对你来说是件好事。因为不管你年龄多大，跑步都是有益处的。有规律的锻炼能够使人更有活力、降低患心脏病和癌症的几率、减肥、睡眠更好等等。因此，什么时候开始跑步都不晚。
慢慢来。有些人不跑步是因为他们不知道怎么开始。新手的跑步计划应该将走和跑都包括在内。刚开始时，尤其是没有接受过任何训练时，不能跑太远，因为这样受伤的风险很大，对身体健康也不利。所以慢慢来，几周内你就能有很大进步。
使用计时器。假如你要进行3分钟跑加1分钟走的间歇跑，你就可以在间隔计时器上，将两个时间同时分别设定好，然后将计时器夹在裤子上，它会震动或响铃来提醒你时间到。这样你就不用老分散注意力看表了。
测心率。很多新手在开始跑步后会经常称体重，然而他们经常忘记测心率。跑步对心脑血管有好处。心脏向全身输送血液，经过适当锻炼，每一次心跳为身体注入的血液也会增加，此时你就会需要较少的心跳次数来为锻炼提供足够的血液。
记跑步日记。写日记是很好的记录进步的方式。你可以记录下跑步的基本信息，如距离、时间、跑步类型，还可以有规律地记录体重和心率变化。看到自己跑步距离不断增加、体重和心率不断减缓会使自己越发有动力将跑步进行下去。
听从身体的反应。跑完步会感觉疲劳和肌肉酸痛，这在一定程度上说，是很正常的。然而，如果在跑步中或跑步后感觉眩晕或胸部、背部、腿部不适，那就要小心了。这时要立即停止跑步，休息或走一会，直到恢复。如果不适感持续或感觉不放心，可以咨询医生。听从身体的召唤，做自己的教练。
起步阶段保持低强度锻炼。新手出现问题的一个主要原因是开始时强度太大。他们定好跑步路线以后，每跑一次都会计时，把注意力都放在速度上。如果你是新手，最好慢慢开始，因为快跑对身体压力很大，太早进行快跑会很容易受伤。
有规律的锻炼是进步的关键。如果是为强身健体而跑的话，最好是一周跑三或四次，一次30分钟，不要一周只跑一次，一次跑2个小时。跑步计划要有规律，并循序渐进。
如果体重下降不明显，不要灰心。如果你选择跑步减肥的话，恭喜你选择了最好的减肥方法之一。但要注意可能不会立马就有效果，因为肌肉比脂肪重，适当的锻炼会减少赘肉，增加肌肉，因此有时可能会增加体重。但看上去会更瘦，穿衣效果也更好些。
合理搭配饮食。体重超标往往是由锻炼不足和不良饮食习惯造成的。所以花点时间研究下怎样提高饮食质量。
热身与冷却。热身运动很重要，因为它能让身体做好锻炼的准备，心脏和腿及时做出调整。因此，不要一出门就快跑，先花几分钟时间走和慢跑，然后做伸展动作。
交叉训练。跑步是项很好的运动。然而，跑步过程中腿部承受巨大冲击力。每迈出一步，腿部承受的冲击力都是自身体重的两三倍。因此，最好加入其它锻炼方式，如骑自行车、游泳、散步、普拉提等等，缓解腿部所受冲击力同时增强腿部受力能力。
保持动力。跑步最难的就是坚持。可以找个跑友一起，这样为不让朋友失望你会坚持出来跑步，而且朋友还能帮你设定和实现目标。还可以报名参加比赛，来督促自己坚持训练计划。

INSTALLING APACHE SOLR ON TOMCAT

2012-12-28T16:35:00.002+11:00

http://contextllc.com/node/76

通过xinetd启动SSH服务

2012-12-16T00:02:00.002+11:00

作为例子，本节将带领读者配置SSH服务的xinetd实现。总的来说，在xinetd中添加服务无非是下面这几步：

（1）修改（增加）配置文件；

（2）停用该服务的守护进程；

（3）重启xinetd使配置生效；

（4）如果需要，从相应的rc目录中移除该服务的启动脚本。

下面就来逐一实现以上各个步骤。首先在/etc/xinetd.d目录下建立文件ssh，包含下面这些内容。


service ssh  

{  

        socket_type     = stream 

        protocol        = tcp 

        wait            = no 

        user            = root 

        server          = /usr/sbin/sshd  

        server_args     = -i  

        log_on_success  += DURATION  

        disable         = no 

}

注意log_on_success参数允许使用"+="这样的赋值方式，表示在原有默认值的基础上添加，而不是推倒重来。类似地，也可以使用"-="在默认值的基础上减去一些值。参数的默认值通常在/etc/xinetd.conf中设置。

下一步停用SSH守护进程，为xinetd接管22端口铺平道路。


$ sudo /etc/init.d/ssh stop  

 * Stopping OpenBSD Secure Shell server sshd  
[ OK ]

重新启动xinetd使配置生效。


$ sudo /etc/init.d/xinetd restart  

 * Stopping internet superserver xinetd          
[ OK ]   

 * Starting internet superserver xinetd       
[ OK ]

运行netstat -tulnp命令查看22端口的情况，发现xinetd已经顺利接管了SSH通信端口。


$ sudo netstat -tulnp | grep 22             
##查看22端口状态  

tcp        0      0 0.0.0.0:22             
0.0.0.0:*               LISTEN      8356/xinetd

现在尝试连接本地的SSH服务。对于客户端而言，看上去和standalone方式没有什么不同。


$ ssh localhost -l lewis  

lewis@localhost's password:

如果在安装SSH服务器的时候选择了随系统启动（通常这是默认配置），那么接下来还要从相应的rc目录中移除SSH服务的启动脚本，否则下次启动系统的时候xinetd将无法运行。假设系统默认启动到运行级5（可以参考22.1节获取有关运行级的详细信息）。


$ cd /etc/rc5.d/                             
##进入相应的rc目录  

$ ls | grep ssh                               
##查找SSH启动脚本  

S16ssh  

$ sudo mv S16ssh ../rc_bak.d/S16ssh_rc5_bak 
##移动到另一个地方备份起来

注意：不要随便删除启动脚本，而应该把它移动到另一个地方，并且取一个有意义的名字。这样在以后需要的时候可以方便地找回来。

Linux利用外部邮箱发送邮件的方法

2012-12-15T18:40:00.002+11:00

利用外部邮箱发送邮件的方法

bin/mail会默认使用本地sendmail发送邮件，这样要求本地的机器必须安装和启动Sendmail服务，配置非常麻烦，而且会带来不必要的
资源占用。而通过修改配置文件可以使用外部SMTP服务器，可以达到不使用sendmail而用外部的smtp服务器发送邮件的目的：
修改/etc/nail.rc (/etc/mail.rc)
set from=fromUser@domain.com smtp=smtp.domain.comset smtp-auth-user=username smtp-auth-password=passwordset smtp-auth=login
说明：
from是发送的邮件地址
smtp是发生的外部smtp服务器的地址
smtp-auth-user是外部smtp服务器认证的用户名
smtp-auth-password是外部smtp服务器认证的用户密码
smtp-auth是邮件认证的方式
配置成功后，就可以使用了
可以发送一封邮件测试一下：
mail -s "test" user@sohu.com

Grep学习笔记

2012-12-09T10:58:00.000+11:00

1. grep简介

grep （global search regular expression(RE) and print out the line,全面搜索正则表达式并把行打印出来）是一种强大的文本搜索工具，它能使用正则表达式搜索文本，并把匹配的行打印出来。Unix的grep家族包括grep、egrep和fgrep。egrep和fgrep的命令只跟grep有很小不同。egrep是grep的扩展，支持更多的re元字符， fgrep就是fixed grep或fast grep，它们把所有的字母都看作单词，也就是说，正则表达式中的元字符表示回其自身的字面意义，不再特殊。linux使用GNU版本的grep。它功能更强，可以通过-G、-E、-F命令行选项来使用egrep和fgrep的功能。
grep的工作方式是这样的，它在一个或多个文件中搜索字符串模板。如果模板包括空格，则必须被引用，模板后的所有字符串被看作文件名。搜索的结果被送到屏幕，不影响原文件内容。
grep可用于shell脚本，因为grep通过返回一个状态值来说明搜索的状态，如果模板搜索成功，则返回0，如果搜索不成功，则返回1，如果搜索的文件不存在，则返回2。我们利用这些返回值就可进行一些自动化的文本处理工作。

2. grep正则表达式元字符集（基本集）

^: 锚定行的开始如：'^grep'匹配所有以grep开头的行。
$: 锚定行的结束如：'grep$'匹配所有以grep结尾的行。
.: 匹配一个非换行符的字符如：'gr.p'匹配gr后接一个任意字符，然后是p。
*: 匹配零个或多个先前字符如：'*grep'匹配所有一个或多个空格后紧跟grep的行。 .*一起用代表任意字符。
[]: 匹配一个指定范围内的字符，如'[Gg]rep'匹配Grep和grep。
[^]: 匹配一个不在指定范围内的字符，如：'[^A-FH-Z]rep'匹配不包含A-R和T-Z的一个字母开头，紧跟rep的行。
$..$: 标记匹配字符，如'$love$'，love被标记为1。
\<: 锚定单词的开始，如:'\
\>: 锚定单词的结束，如'grep\>'匹配包含以grep结尾的单词的行。
x\{m\}: 重复字符x，m次，如：'0\{5\}'匹配包含5个o的行。
x\{m,\}: 重复字符x,至少m次，如：'o\{5,\}'匹配至少有5个o的行。
x\{m,n\}: 重复字符x，至少m次，不多于n次，如：'o\{5,10\}'匹配5--10个o的行。
\w: 匹配文字和数字字符，也就是[A-Za-z0-9]，如：'G\w*p'匹配以G后跟零个或多个文字或数字字符，然后是p。
\W: \w的反置形式，匹配一个或多个非单词字符，如点号句号等。
\b: 单词锁定符，如: '\bgrep\b'只匹配grep。

3. 用于egrep和 grep -E的元字符扩展集

+: 匹配一个或多个先前的字符。如：'[a-z]+able'，匹配一个或多个小写字母后跟able的串，如loveable,enable,disable等。
?: 匹配零个或多个先前的字符。如：'gr?p'匹配gr后跟一个或没有字符，然后是p的行。
a|b|c: 匹配a或b或c。如：grep|sed匹配grep或sed
(): 分组符号，如：love(able|rs)ov+匹配loveable或lovers，匹配一个或多个ov。
x{m},x{m,},x{m,n}: 作用同x\{m\},x\{m,\},x\{m,n\}

4. POSIX字符类

为了在不同国家的字符编码中保持一至，POSIX(The Portable Operating System Interface)增加了特殊的字符类，如[:alnum:]是A-Za-z0-9的另一个写法。要把它们放到[]号内才能成为正则表达式，如[A- Za-z0-9]或[[:alnum:]]。在linux下的grep除fgrep外，都支持POSIX的字符类。

[:alnum:]: 文字数字字符
[:alpha:]: 文字字符
[:digit:]: 数字字符
[:graph:]: 非空字符（非空格、控制字符）
[:lower:]: 小写字符
[:cntrl:]: 控制字符
[:print:]: 非空字符（包括空格）
[:punct:]: 标点符号
[:space:]: 所有空白字符（新行，空格，制表符）
[:upper:]: 大写字符
[:xdigit:]: 十六进制数字（0-9，a-f，A-F）

5. Grep命令选项

-?: 同时显示匹配行上下的？行，如：grep -2 pattern filename同时显示匹配行的上下2行。
-b，--byte-offset: 打印匹配行前面打印该行所在的块号码。
-c,--count: 只打印匹配的行数，不显示匹配的内容。
-f File，--file=File: 从文件中提取模板。空文件中包含0个模板，所以什么都不匹配。
-h，--no-filename: 当搜索多个文件时，不显示匹配文件名前缀。
-i，--ignore-case: 忽略大小写差别。
-q，--quiet: 取消显示，只返回退出状态。0则表示找到了匹配的行。
-l，--files-with-matches: 打印匹配模板的文件清单。
-L，--files-without-match: 打印不匹配模板的文件清单。
-n，--line-number: 在匹配的行前面打印行号。
-s，--silent: 不显示关于不存在或者无法读取文件的错误信息。
-v，--revert-match: 反检索，只显示不匹配的行。
-w，--word-regexp: 如果被\<和\>引用，就把表达式做为一个单词搜索。
-V，--version: 显示软件版本信息。

6. 实例

要用好grep这个工具，其实就是要写好正则表达式，所以这里不对grep的所有功能进行实例讲解，只列几个例子，讲解一个正则表达式的写法。

$ ls -l | grep '^a': 通过管道过滤ls -l输出的内容，只显示以a开头的行。
$ grep 'test' d*: 显示所有以d开头的文件中包含test的行。
$ grep 'test' aa bb cc: 显示在aa，bb，cc文件中匹配test的行。
$ grep '[a-z]\{5\}' aa: 显示所有包含每个字符串至少有5个连续小写字符的字符串的行。
$ grep 'w$es$t.*\1' aa: 如果west被匹配，则es就被存储到内存中，并标记为1，然后搜索任意个字符（.*），这些字符后面紧跟着另外一个es（\1），找到就显示该行。如果用egrep或grep -E，就不用"\"号进行转义，直接写成'w(es)t.*\1'就可以了。

linux下面用ssh上传，下载文件

2012-12-07T22:58:00.003+11:00

一，ssh上传文件
scp file username@hostIP:文件地址例:
[zhangy@BlackGhost ~]$ scp test.sql zhangying@192.168.1.5:/var/www/zhangying
zhangying@192.168.1.5's password:
test.sql 100% 7884 7.7KB/s 00:00
[zhangy@BlackGhost ~]$
二，ssh下载文件
scp username@hostIP:文件所在地址文件目录例:
[zhangy@BlackGhost ~]$ scp zhangying@192.168.1.5:/var/www/zhangying/test.sql /home/zhangy/database_bak/
zhangying@192.168.1.5's password:
test.sql 100% 7884 7.7KB/s 00:00
[zhangy@BlackGhost ~]$

Java获取各种常用时间方法

2012-12-04T11:12:00.002+11:00

package com.hefeng.test;

import java.text.DateFormat;
import java.text.ParsePosition;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;

public class TimeTest {
//用来全局控制上一周，本周，下一周的周数变化
private int weeks = 0;
private int MaxDate;//一月最大天数
private int MaxYear;//一年最大天数

/**
* @param args
*/
public static void main(String[] args) {
TimeTest tt = new TimeTest();
System.out.println("获取当天日期:"+tt.getNowTime("yyyy-MM-dd"));
System.out.println("获取本周一日期:"+tt.getMondayOFWeek());
System.out.println("获取本周日的日期~:"+tt.getCurrentWeekday());
System.out.println("获取上周一日期:"+tt.getPreviousWeekday());
System.out.println("获取上周日日期:"+tt.getPreviousWeekSunday());
System.out.println("获取下周一日期:"+tt.getNextMonday());
System.out.println("获取下周日日期:"+tt.getNextSunday());
System.out.println("获得相应周的周六的日期:"+tt.getNowTime("yyyy-MM-dd"));
System.out.println("获取本月第一天日期:"+tt.getFirstDayOfMonth());
System.out.println("获取本月最后一天日期:"+tt.getDefaultDay());
System.out.println("获取上月第一天日期:"+tt.getPreviousMonthFirst());
System.out.println("获取上月最后一天的日期:"+tt.getPreviousMonthEnd());
System.out.println("获取下月第一天日期:"+tt.getNextMonthFirst());
System.out.println("获取下月最后一天日期:"+tt.getNextMonthEnd());
System.out.println("获取本年的第一天日期:"+tt.getCurrentYearFirst());
System.out.println("获取本年最后一天日期:"+tt.getCurrentYearEnd());
System.out.println("获取去年的第一天日期:"+tt.getPreviousYearFirst());
System.out.println("获取去年的最后一天日期:"+tt.getPreviousYearEnd());
System.out.println("获取明年第一天日期:"+tt.getNextYearFirst());
System.out.println("获取明年最后一天日期:"+tt.getNextYearEnd());
System.out.println("获取本季度第一天到最后一天:"+tt.getThisSeasonTime(11));
System.out.println("获取两个日期之间间隔天数2008-12-1~2008-9.29:"+TimeTest.getTwoDay("2008-12-1","2008-9-29"));
}

/**
* 得到二个日期间的间隔天数
*/
public static String getTwoDay(String sj1, String sj2) {
SimpleDateFormat myFormatter = new SimpleDateFormat("yyyy-MM-dd");
long day = 0;
try {
java.util.Date date = myFormatter.parse(sj1);
java.util.Date mydate = myFormatter.parse(sj2);
day = (date.getTime() - mydate.getTime()) / (24 * 60 * 60 * 1000);
} catch (Exception e) {
return "";
}
return day + "";
}

/**
* 根据一个日期，返回是星期几的字符串
*
* @param sdate
* @return
*/
public static String getWeek(String sdate) {
// 再转换为时间
Date date = TimeTest.strToDate(sdate);
Calendar c = Calendar.getInstance();
c.setTime(date);
// int hour=c.get(Calendar.DAY_OF_WEEK);
// hour中存的就是星期几了，其范围 1~7
// 1=星期日 7=星期六，其他类推
return new SimpleDateFormat("EEEE").format(c.getTime());
}

/**
* 将短时间格式字符串转换为时间 yyyy-MM-dd
*
* @param strDate
* @return
*/
public static Date strToDate(String strDate) {
SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd");
ParsePosition pos = new ParsePosition(0);
Date strtodate = formatter.parse(strDate, pos);
return strtodate;
}

/**
* 两个时间之间的天数
*
* @param date1
* @param date2
* @return
*/
public static long getDays(String date1, String date2) {
if (date1 == null || date1.equals(""))
return 0;
if (date2 == null || date2.equals(""))
return 0;
// 转换为标准时间
SimpleDateFormat myFormatter = new SimpleDateFormat("yyyy-MM-dd");
java.util.Date date = null;
java.util.Date mydate = null;
try {
date = myFormatter.parse(date1);
mydate = myFormatter.parse(date2);
} catch (Exception e) {
}
long day = (date.getTime() - mydate.getTime()) / (24 * 60 * 60 * 1000);
return day;
}

// 计算当月最后一天,返回字符串
public String getDefaultDay(){
String str = "";
SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");

Calendar lastDate = Calendar.getInstance();
lastDate.set(Calendar.DATE,1);//设为当前月的1号
lastDate.add(Calendar.MONTH,1);//加一个月，变为下月的1号
lastDate.add(Calendar.DATE,-1);//减去一天，变为当月最后一天

str=sdf.format(lastDate.getTime());
return str;
}

// 上月第一天
public String getPreviousMonthFirst(){
String str = "";
SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");

Calendar lastDate = Calendar.getInstance();
lastDate.set(Calendar.DATE,1);//设为当前月的1号
lastDate.add(Calendar.MONTH,-1);//减一个月，变为下月的1号
//lastDate.add(Calendar.DATE,-1);//减去一天，变为当月最后一天

str=sdf.format(lastDate.getTime());
return str;
}

//获取当月第一天
public String getFirstDayOfMonth(){
String str = "";
SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");

Calendar lastDate = Calendar.getInstance();
lastDate.set(Calendar.DATE,1);//设为当前月的1号
str=sdf.format(lastDate.getTime());
return str;
}

// 获得本周星期日的日期
public String getCurrentWeekday() {
weeks = 0;
int mondayPlus = this.getMondayPlus();
GregorianCalendar currentDate = new GregorianCalendar();
currentDate.add(GregorianCalendar.DATE, mondayPlus+6);
Date monday = currentDate.getTime();

DateFormat df = DateFormat.getDateInstance();
String preMonday = df.format(monday);
return preMonday;
}

//获取当天时间
public String getNowTime(String dateformat){
Date now = new Date();
SimpleDateFormat dateFormat = new SimpleDateFormat(dateformat);//可以方便地修改日期格式
String hehe = dateFormat.format(now);
return hehe;
}

// 获得当前日期与本周日相差的天数
private int getMondayPlus() {
Calendar cd = Calendar.getInstance();
// 获得今天是一周的第几天，星期日是第一天，星期二是第二天......
int dayOfWeek = cd.get(Calendar.DAY_OF_WEEK)-1; //因为按中国礼拜一作为第一天所以这里减1
if (dayOfWeek == 1) {
return 0;
} else {
return 1 - dayOfWeek;
}
}

//获得本周一的日期
public String getMondayOFWeek(){
weeks = 0;
int mondayPlus = this.getMondayPlus();
GregorianCalendar currentDate = new GregorianCalendar();
currentDate.add(GregorianCalendar.DATE, mondayPlus);
Date monday = currentDate.getTime();

DateFormat df = DateFormat.getDateInstance();
String preMonday = df.format(monday);
return preMonday;
}

//获得相应周的周六的日期
public String getSaturday() {
int mondayPlus = this.getMondayPlus();
GregorianCalendar currentDate = new GregorianCalendar();
currentDate.add(GregorianCalendar.DATE, mondayPlus + 7 * weeks + 6);
Date monday = currentDate.getTime();
DateFormat df = DateFormat.getDateInstance();
String preMonday = df.format(monday);
return preMonday;
}

// 获得上周星期日的日期
public String getPreviousWeekSunday() {
weeks=0;
weeks--;
int mondayPlus = this.getMondayPlus();
GregorianCalendar currentDate = new GregorianCalendar();
currentDate.add(GregorianCalendar.DATE, mondayPlus+weeks);
Date monday = currentDate.getTime();
DateFormat df = DateFormat.getDateInstance();
String preMonday = df.format(monday);
return preMonday;
}

// 获得上周星期一的日期
public String getPreviousWeekday() {
weeks--;
int mondayPlus = this.getMondayPlus();
GregorianCalendar currentDate = new GregorianCalendar();
currentDate.add(GregorianCalendar.DATE, mondayPlus + 7 * weeks);
Date monday = currentDate.getTime();
DateFormat df = DateFormat.getDateInstance();
String preMonday = df.format(monday);
return preMonday;
}

// 获得下周星期一的日期
public String getNextMonday() {
weeks++;
int mondayPlus = this.getMondayPlus();
GregorianCalendar currentDate = new GregorianCalendar();
currentDate.add(GregorianCalendar.DATE, mondayPlus + 7);
Date monday = currentDate.getTime();
DateFormat df = DateFormat.getDateInstance();
String preMonday = df.format(monday);
return preMonday;
}

// 获得下周星期日的日期
public String getNextSunday() {

int mondayPlus = this.getMondayPlus();
GregorianCalendar currentDate = new GregorianCalendar();
currentDate.add(GregorianCalendar.DATE, mondayPlus + 7+6);
Date monday = currentDate.getTime();
DateFormat df = DateFormat.getDateInstance();
String preMonday = df.format(monday);
return preMonday;
}

private int getMonthPlus(){
Calendar cd = Calendar.getInstance();
int monthOfNumber = cd.get(Calendar.DAY_OF_MONTH);
cd.set(Calendar.DATE, 1);//把日期设置为当月第一天
cd.roll(Calendar.DATE, -1);//日期回滚一天，也就是最后一天
MaxDate=cd.get(Calendar.DATE);
if(monthOfNumber == 1){
return -MaxDate;
}else{
return 1-monthOfNumber;
}
}

//获得上月最后一天的日期
public String getPreviousMonthEnd(){
String str = "";
SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");

Calendar lastDate = Calendar.getInstance();
lastDate.add(Calendar.MONTH,-1);//减一个月
lastDate.set(Calendar.DATE, 1);//把日期设置为当月第一天
lastDate.roll(Calendar.DATE, -1);//日期回滚一天，也就是本月最后一天
str=sdf.format(lastDate.getTime());
return str;
}

//获得下个月第一天的日期
public String getNextMonthFirst(){
String str = "";
SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");

Calendar lastDate = Calendar.getInstance();
lastDate.add(Calendar.MONTH,1);//减一个月
lastDate.set(Calendar.DATE, 1);//把日期设置为当月第一天
str=sdf.format(lastDate.getTime());
return str;
}

//获得下个月最后一天的日期
public String getNextMonthEnd(){
String str = "";
SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");

Calendar lastDate = Calendar.getInstance();
lastDate.add(Calendar.MONTH,1);//加一个月
lastDate.set(Calendar.DATE, 1);//把日期设置为当月第一天
lastDate.roll(Calendar.DATE, -1);//日期回滚一天，也就是本月最后一天
str=sdf.format(lastDate.getTime());
return str;
}

//获得明年最后一天的日期
public String getNextYearEnd(){
String str = "";
SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");

Calendar lastDate = Calendar.getInstance();
lastDate.add(Calendar.YEAR,1);//加一个年
lastDate.set(Calendar.DAY_OF_YEAR, 1);
lastDate.roll(Calendar.DAY_OF_YEAR, -1);
str=sdf.format(lastDate.getTime());
return str;
}

//获得明年第一天的日期
public String getNextYearFirst(){
String str = "";
SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");

Calendar lastDate = Calendar.getInstance();
lastDate.add(Calendar.YEAR,1);//加一个年
lastDate.set(Calendar.DAY_OF_YEAR, 1);
str=sdf.format(lastDate.getTime());
return str;

}

//获得本年有多少天
private int getMaxYear(){
Calendar cd = Calendar.getInstance();
cd.set(Calendar.DAY_OF_YEAR,1);//把日期设为当年第一天
cd.roll(Calendar.DAY_OF_YEAR,-1);//把日期回滚一天。
int MaxYear = cd.get(Calendar.DAY_OF_YEAR);
return MaxYear;
}

private int getYearPlus(){
Calendar cd = Calendar.getInstance();
int yearOfNumber = cd.get(Calendar.DAY_OF_YEAR);//获得当天是一年中的第几天
cd.set(Calendar.DAY_OF_YEAR,1);//把日期设为当年第一天
cd.roll(Calendar.DAY_OF_YEAR,-1);//把日期回滚一天。
int MaxYear = cd.get(Calendar.DAY_OF_YEAR);
if(yearOfNumber == 1){
return -MaxYear;
}else{
return 1-yearOfNumber;
}
}
//获得本年第一天的日期
public String getCurrentYearFirst(){
int yearPlus = this.getYearPlus();
GregorianCalendar currentDate = new GregorianCalendar();
currentDate.add(GregorianCalendar.DATE,yearPlus);
Date yearDay = currentDate.getTime();
DateFormat df = DateFormat.getDateInstance();
String preYearDay = df.format(yearDay);
return preYearDay;
}

//获得本年最后一天的日期 *
public String getCurrentYearEnd(){
Date date = new Date();
SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy");//可以方便地修改日期格式
String years = dateFormat.format(date);
return years+"-12-31";
}

//获得上年第一天的日期 *
public String getPreviousYearFirst(){
Date date = new Date();
SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy");//可以方便地修改日期格式
String years = dateFormat.format(date); int years_value = Integer.parseInt(years);
years_value--;
return years_value+"-1-1";
}

//获得上年最后一天的日期
public String getPreviousYearEnd(){
weeks--;
int yearPlus = this.getYearPlus();
GregorianCalendar currentDate = new GregorianCalendar();
currentDate.add(GregorianCalendar.DATE,yearPlus+MaxYear*weeks+(MaxYear-1));
Date yearDay = currentDate.getTime();
DateFormat df = DateFormat.getDateInstance();
String preYearDay = df.format(yearDay);
getThisSeasonTime(11);
return preYearDay;
}

//获得本季度
public String getThisSeasonTime(int month){
int array[][] = {{1,2,3},{4,5,6},{7,8,9},{10,11,12}};
int season = 1;
if(month>=1&&month<=3){
season = 1;
}
if(month>=4&&month<=6){
season = 2;
}
if(month>=7&&month<=9){
season = 3;
}
if(month>=10&&month<=12){
season = 4;
}
int start_month = array[season-1][0];
int end_month = array[season-1][2];

Date date = new Date();
SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy");//可以方便地修改日期格式
String years = dateFormat.format(date);
int years_value = Integer.parseInt(years);

int start_days =1;//years+"-"+String.valueOf(start_month)+"-1";//getLastDayOfMonth(years_value,start_month);
int end_days = getLastDayOfMonth(years_value,end_month);
String seasonDate = years_value+"-"+start_month+"-"+start_days+";"+years_value+"-"+end_month+"-"+end_days;
return seasonDate;

}

/**
* 获取某年某月的最后一天
* @param year 年
* @param month 月
* @return 最后一天
*/
private int getLastDayOfMonth(int year, int month) {
if (month == 1 || month == 3 || month == 5 || month == 7 || month == 8
|| month == 10 || month == 12) {
return 31;
}
if (month == 4 || month == 6 || month == 9 || month == 11) {
return 30;
}
if (month == 2) {
if (isLeapYear(year)) {
return 29;
} else {
return 28;
}
}
return 0;
}
/**
* 是否闰年
* @param year 年
* @return
*/
public boolean isLeapYear(int year) {
return (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0);
}
}

Terry Su

中国一线二线三线城市名单

Error: API mismatch: the NVIDIA kernel module

你必须知道的十大网络分销渠道

扫盲GFW的工作原理和封锁技术

jsonp详解

面向站长和网站管理员的Web缓存加速指南

什么是Web缓存，为什么要使用它？

缓存的类型

浏览器缓存

代理服务器缓存

网关缓存

Web缓存无害吗？为什么要鼓励缓存？

缓存如何工作

如何控制（控制不）缓存

HTML meta标签和HTTP 头信息

Pragma HTTP头信息 (为什么它不起作用)

使用Expires（过期时间）HTTP头信息来控制保鲜期

Cache-Control（缓存控制） HTTP头信息

校验参数和校验

创建利于缓存网站的窍门

编写利于缓存的脚本

常见问题解答

让网站变得可缓存的要点是什么？

如何让页面通过缓存达到最快相应？

我理解缓存是好的，但是我不得不统计多少人访问了我的网站！

我如何能看到HTTP头信息的内容？

我的页面是密码保护的，代理缓存服务器如何处理他们？

我们是否要担心用户通过cache访问我的站点？

我在寻找一个包含在Web发布系统解决方案，那些是比较有缓存意识的系统？

我的图片设置了1个月后过期，但是我现在需要现在更新。

我运行一个Web托管服务，如何让我的用户发布缓存友好的网页？

我标记了一些网页是可缓存的，但是浏览器仍然每次发送请求给服务。如何强制他们保存副本？

缓存机制的实现 - Web服务器端配置

Apache HTTP服务器

Microsoft IIS服务器

Netscape/iPlanet企业服务器

缓存机制的实现：服务器端脚本

CGI程序

服务器端包含 Server Side Includes

PHP

Cold Fusion

ASP和ASP.NET

参考文档和深入阅读

HTTP 1.1 规范定义

Web-Caching.com

关于非连续性访问统计

可缓存性检测引擎

cgi_buffer库

成功创业家的法则：学好再做还是边做边学？

Eclipse Java EE jQuery Validation Error Workaround

Workaround – How to fix

What do “branch”, “tag” and “trunk” mean in Subversion repositories?

浏览器缓存机制

HTTP Performance

HTTP Performance: An Overview

Tweaking "First Visit" Performance

Introduction to HTTP Caching

Cache-Related Request Headers

Cache-Related Response Headers

Conditional Requests and the WinInet Cache

Flagging Performance Problems

Introduction to HTTP Compression

xStream完美转换XML、JSON

用Kibana和logstash快速搭建实时日志查询、收集与分析系统

Kibana installation

kibana:

How to install Sun Java JDK in CentOS 6

ubuntu为什么没有/etc/inittab文件? 深究ubuntu的启动流程分析

查看系统在什么地方设置这个初始值，打开文件： （后面详细介绍为什么）

你会发现这么一句：

Ubuntu init启动流程分析:

Installing Apache Archiva as a Web Application

Clearing a Solr search index

跑步新手如何开始你的跑步训练

步骤/方法

INSTALLING APACHE SOLR ON TOMCAT

通过xinetd启动SSH服务

Linux利用外部邮箱发送邮件的方法

Grep学习笔记

查看系统在什么地方设置这个初始值，打开文件：（后面详细介绍为什么）