1.如果你在坚持做某件事，其实你很脆弱，你在强迫自己做一件事，因为你心里有一个度，此时这个度大于这件需要坚持的事，如果有某件事物干扰，超越了这个度呢？就出现所谓的坚持不下去了。
2.如果你习惯于做某件事，这时候潜意识里无理由就要做这件事，自动，条件反射，基本上不会不爽，可是，如果有意识觉得某样东西超越这个习惯，这个习惯就被打破了，所以还是度的问题。
3.如果你已经形成某种信仰，真正的坚信不移，你就可怕了，你的度是无穷大，给定一个任意大的理由，却总存在一个更大的理由，去执行自己的信仰，毫不动摇。

所以，信仰>习惯>坚持。
……

传说，看客们有70%会相信以上论调，5%会因此改变自己，只有若干人会建立自己的信仰。

   A DO：
   1.好好工作
   2.以结婚为目的找一个女朋友，解决个人问题。
   3.多运动，成为一个“肌肉男”。
   涛哥：
   1.租一个大大的房子，大家来广州好好落脚。
   2.好好挣钱，为成家做准备。
   3.还债。
   涛嫂：
   1.挣钱。
   2.挣钱。
   3.还是挣钱。
   韩老大：
   1.吃遍公司附近的餐馆。
   2.还Banner的￥735.00元。
   3.半年内保持单身。
   老毛：
   1.找一女朋友解决单身问题，首当其冲。
   2.继续彩票事业，多买多赚，以500W和LAMBORGHINI为目标。
   3.任劳任怨，踏实工作。

澳门仔自归大陆后，身形愈发消瘦，思循古法于入冬时加以补养。【注意身形愈发消瘦不是去了澳门才造成的，没看到我天天坚持跑步啊，锻炼结果Keep Fit，知不知啊】小三川之味，已去数次，渐厌之，众人遂奔大巴适。为犒此仔拔毛之举，夜敲此篇“老毛”，为RICA人物列传开刀之作【很荣幸啊，看来钱没有白花啊，虽然钱也是从万恶的 Casino 拿来的，但谁知下次会不会再还回去呢】。
    吾与此猥物同床异枕二载有余，甚悉之。【这话说的，我是和你对脚，不是同床。反正我是没有gay倾向，至于你有没有我就不知啦】老毛悄然行至身后，吾不待转首即感猥琐之气铺天盖地，料定必是此物，老毛讶之。【对我如此之关切，更加证明你的取向有问题，以后注意和我保持距离】
    此君好戴一宠物圈于项，名曰健身，实未见效，【带钛白项圈好处有二：1.防止腰肌劳损，知不知腰对男人的重要性啊。2.美观，引领时尚之风，君不见刘德华也开始学样了嘛。】反有阻大脑供养之嫌，何以为证？近日老毛言语迥异于常。涛哥、阿杜皆不堪其扰，存灭其肉体而后快之意。老毛以寡敌众，慷慨应对，屡除其自生大规模杀伤化学武器保险，置于寝室上风处，随即颓势立转。【我有这么残忍嘛，要怪就怪安踏不透气，无心之作。】余窃以为此乃老毛渐归本性之兆。
    老毛长于言辩，眼光敏锐，领风气之先（数度拉吾下水），思维极为跳跃，擅伤女仔之心（略去数万言。。。），而讨大妈欢心。【反了反了，从来都是我被别人挫伤。】猛男CALL之“猥琐毛”，颇为传神。【保留申辩的权利】此仔将混迹于珠海某著名CM公司，余甚忧之。澳门场暗备此仔诸多劣迹，若这厮任职CM毛总，无间道恐将由其主演【虽然我玩了5次，大部分是有挣，谁知别人是不是小饵钓大鱼】。。。

PS:觅兔肉于巴适，半饷而不可得，痛憾之~

【感谢韩老大为我研究生三年做了个简要的总结，虽然大部分不是好话，弄得我都不好到处贴。总是为我整理了下思路，开始写自序了！】

二十岁之前相信的很多东西，后来一件一件变成不相信。

曾经相信过爱国，后来知道“国”的定义有问题，通常那循循善诱要你爱国的人所定义的“国”，不一定可爱，不一定值得爱，而且更可能值得推翻。

曾经相信过历史，后来知道，原来历史的一半是编造。前朝史永远是后朝人在写，后朝人永远在否定前朝，他的后朝又来否定他，但是负负不一定得正，只是累积渐进的扭曲变形移位，使真相永远掩盖，无法复原。说“不容青史尽成灰”，表达的正是，不错，青史往往是要成灰的。指鹿为马，也往往是可以得逞和胜利的。

曾经相信过文明的力量，后来知道，原来人的愚昧和野蛮不因文明的进展而消失，只是愚昧野蛮有很多不同的面貌：纯朴的农民工人、深沉的知识分子、自信的政治领袖、替天行道的王师，都可能有不同形式的巨大愚昧和巨大野蛮，而且野蛮和文明之间，竟然只有极其细微、随时可以被抹掉的一线之隔。

曾经相信过正义，后来知道，原来同时完全可以存在两种正义，而且彼此抵触，冰火不容。选择其中之一，正义同时就意味着不正义。而且，你绝对看不出，某些人在某一个特定的时机热烈主张某一个特定的正义，其中隐藏着深不可测的不正义。

曾经相信过理想主义者，后来知道，理想主义者往往经不起权力的测试：一掌有权力，他或者变成当初自己誓死反对的“邪恶”，或者，他在现实的场域里不堪一击，一下就被弄权者拉下马来，完全没有机会去实现他的理想。理想主义者要有品格，才能不被权力腐化；理想主义者要有能力，才能将理想转化为实践。可是理想主义者兼具品格及能力者，几希。

曾经相信过爱情，后来知道，原来爱情必须转化为亲情才可能持久，但是转化为亲情的爱情，犹如化入杯水中的冰块---它还是冰块吗？

曾经相信过海枯石烂作为永恒不灭的表征，后来知道，原来海其实很容易枯，石，原来很容易烂。雨水，很可能不再来，沧海，不会再成桑田。原来，自己脚下所踩的地球，很容易被毁灭。海枯石烂的永恒，原来不存在。

二十岁之前相信的很多东西，有些其实到今天也还相信。

譬如国也许不可爱，但是土地和人可以爱。譬如史也许不能信，但是对于真相的追求可以无止尽。譬如文明也许脆弱不堪，但是除文明外我们其实别无依靠。譬如正义也许极为可疑，但是在乎正义比不在乎要安全。譬如理想主义者也许成就不了大事大业，但是没有他们社会一定不一样。譬如爱情总是幻灭的多，但是萤火虫在夜里发光从来就不是为了保持光。譬如海枯石烂的永恒也许不存在，但是如果一粒沙里有一个无穷的宇宙，一刹那里想必也有一个不变不移的时间。

那么，有没有什么，是我二十岁前不相信的，现在却信了呢？

有的，不过都是些最平凡的老生常谈。曾经不相信“性格决定命运”，现在相信了。曾经不相信“色即是空”，现在相信了。曾经不相信“船到桥头自然直”，现在有点信了。曾经不相信无法实证的事情，现在也还没准备相信，但是，有些无关实证的感觉，我明白了，譬如李叔同圆寂前最后的手书：“君子之交，其淡如水，执象而求，咫尺千里。问余何适，廓尔忘言，华枝春满，天心月圆。”

相信与不相信之间，彷佛还有令人沉吟的深度。

8.异常，如果对try{}catch(exception o){}的所有catch情况都考虑到了的话，调用者就不需要添加catch或throw exception啦

9.文件流： 分为字节流（ 带Input）和字符流（带reader）
              例如FileInputStream    例如FileReader
           字符流不依赖於编码，全部采用unicode编码
           如果需要支持国际化的话就需要采用直接流啦 。
           示例：  FileInputStream is=new FileInputStream(f);
                   InputStreamReader r=new InputSteamReader(is,"utf-8");

  另外可以使用System.getProperty("file.endcoding")来获得系统的默认编码
10，数组和矢量Vector比较  遍历Vector比较慢，因为Vector是线程安全的，获取值时采用了同步化，解决方法在遍历是toArray（）
    例外ArrayList具有vector的动态增加长度的特点，但ArrayList是非同步的矢量。
11.在循环体内链接字符串，使用StringBuffer效率更高；其他情况下使用+。

　　为什么会业务逻辑层使用if else，其实使用者的目的也是为了重用，但是这是面向过程编程的重用，程序员只看到代码重用，因为他看到if else几种情况下大部分代码都是重复的，只有个别不同，因此使用if else可以避免重复代码，并且认为这是模板Template模式。

　　他范的错误是：程序员只从代码运行顺序这个方向来看待它的代码，这种思维类似水管或串行电路，水沿着水管流动（代码运行次序），当遇到几个分管（子管），就分到这几个分管子在流动，这里就相当于碰到代码的if else处了。

　　而使用OO，则首先打破这个代码由上向下顺序等同于运行时的先后循序这个规律，代码结构不由执行循序决定，由什么决定呢？由OO设计；设计模式会取代这些if else，但是最后总是由一个Service等总类按照运行顺序组装这些OO模块，只有一处，这处可包含事务，一般就是Service，EJB中是Session bean。

　　一旦需求变化，我们更多的可能是Service中各个OO模块，甚至是只改动Service中的OO模块执行顺序就能符合需求。

　　这里我们也看到OO分离的思路，将以前过程语言的一个Main函数彻底分解，将运行顺序与代码其他逻辑分离开来，而不是象面向过程那样混乱在一起。所以有人感慨，OO也是要顺序的，这是肯定的，关键是运行顺序要单独分离出来。

　　是否有if else可以看出你有没有将运行顺序分离到家。

设计模式的切入口

　　经常有人反映，设计模式是不错，但是我很难用到，其实如果你使用if else来写代码时（除显示控制以外），就是在写业务逻辑，只不过使用简单的判断语句来作为现实情况的替代者。

　　 还是以大家熟悉的论坛帖子为例子，如ForumMessage是一个模型，但是实际中帖子分两种性质：主题贴（第一个根贴）和回帖（回以前帖子的帖子），这里有一个朴素的解决方案：
建立一个ForumMessage，然后在ForumMessage加入isTopic这样判断语句，注意，你这里一个简单属性的判断引入，可能导致你的程序其他地方到处存在if else 的判断。

　　如果我们改用另外一种分析实现思路，以对象化概念看待，实际中有主题贴和回帖，就是两种对象，但是这两种对象大部分是一致的，因此，我将ForumMessage设为表达主题贴；然后创建一个继承ForumMessage的子类ForumMessageReply作为回帖，这样，我在程序地方，如Service中，我已经确定这个Model是回帖了，我就直接下溯为ForumMessageReply即可，这个有点类似向Collection放入对象和取出时的强制类型转换。通过这个手段我消灭了以后程序中if else的判断语句出现可能。

　　从这里体现了，如果分析方向错误，也会导致误用模式。

　　讨论设计模式举例，不能没有业务上下文场景的案例，否则无法决定是否该用模式，下面举两个对比的例子：

　　第一. 这个帖子中举例的第一个代码案例是没有上下文的，文中只说明有一段代码：

　　这段代码只是纯粹的代码，没有业务功能，所以，在这种情况下，我们就很难确定使用什么模式，就是一定用策略模式等，也逃不过还是使用if else的命运，设计模式不是魔法，不能将一段毫无意义的代码变得简单了，只能将其体现的业务功能更加容易可拓展了。

　　第二.在这个帖子中，作者举了一个PacketParser业务案例，这段代码是体现业务功能的，是一个数据包的分析，作者也比较了各种模式使用的不同，所以我们还是使用动态代理模式或Command模式来消灭那些可能存在的if else

　　由以上两个案例表明：业务逻辑是我们使用设计模式的切入点，而在分解业务逻辑时，我们习惯则可能使用if else来实现，当你有这种企图或者已经实现代码了，那么就应该考虑是否需要重构Refactoring了。

if else替代者

　　那么实战中，哪些设计模式可以替代if else呢？其实GoF设计模式都可以用来替代if else，我们分别描述如下：

AOP或Decorator模式
　　
　　其实使用filter过滤器也可以替代我们业务中的if else，过滤器起到一种过滤和筛选作用，将符合本过滤器条件的对象拦截下来做某件事情，这就是一个过滤器的功能，多个过滤器组合在一起实际就是if else的组合。
　　所以，如果你实在想不出什么办法，可以使用过滤器，将过滤器看成防火墙就比较好理解，当客户端有一个请求时，经过不同性质的防火墙，这个防火墙是拦截端口的；那个防火墙是安全检查拦截等等。过滤器也如同红蓝白各种光滤镜；红色滤镜只能将通过光线中的红色拦截了；蓝色滤镜将光线中的蓝色拦截下来，这实际上是对光线使用if else进行分解。


　　如图，通过一个个条件过滤器我们立体地实现了对信号的分离，如果你使用if else，说明你是将图中的条件1/2/3/4合并在一起，在同一个地方实现条件判断。
　　需要深入了解过滤器的实现细节和微小区别，请参考文章：AOP vs Decorator

OO设计的总结　　

　　还有一种伪模式，虽然使用了状态等模式，但是在模式内部实质还是使用if else或switch进行状态切换或重要条件判断，那么无疑说明还需要进一步努力。更重要的是，不能以模式自居，而且出书示人。

　　真正掌握面向对象这些思想是一件困难的事情，目前有各种属于揪着自己头发向上拔的解说，都是误人子弟的，所以我觉得初学者读Thinking in Java（Java编程思想）是没有用，它试图从语言层次来讲OO编程思想，非常失败，作为语言参考书可以，但是作为Java体现的OO思想的学习资料，就错了。

　　OO编程思想是一种方法论，方法论如果没有应用比较，是无法体会这个方法论的特点的，禅是古代一个方法论，悟禅是靠挑水砍柴这些应用才能体会。

　　那么OO思想靠什么应用能够体会到了？是GoF设计模式，GoF设计模式是等于软件人员的挑水砍柴等基本活，所以，如果一个程序员连基本活都不会，他何以自居OO程序员？从事OO专业设计编程这个工作，如果不掌握设计模式基本功，就象一个做和尚的人不愿意挑水砍柴，他何以立足这个行业？早就被师傅赶下山。

　　最后总结：将if else用在小地方还可以，如简单的数值判断；但是如果按照你的传统习惯思维，在实现业务功能时也使用if else，那么说明你的思维可能需要重塑，你的编程经验越丰富，传统过程思维模式就容易根深蒂固，想靠自己改变很困难；建议接受专业头脑风暴培训。

　　用一句话总结：如果你做了不少系统，很久没有使用if else了，那么说明你可能真正进入OO设计的境地了。（这是本人自己发明的实战性的衡量考核标准）。

1. import  java.math.BigDecimal;   
2.   
3. /** */ /**  
5. * 由于Java的简单类型不能够精确的对浮点数进行运算，这个工具类提供精  
7. * 确的浮点数运算，包括加减乘除和四舍五入。  
9. */   
10.   
11. public   class  Arith{   
12.   
13. //默认除法运算精度   
14.   
15. private   static   final   int  DEF_DIV_SCALE =  10 ;   
16.   
17. //这个类不能实例化   
18.   
19. private  Arith(){   
20.   
21. }   
22.   
23. /** */ /**  
25. * 提供精确的加法运算。  
27. * @param v1 被加数  
29. * @param v2 加数  
31. * @return 两个参数的和  
33. */   
34.   
35. public   static   double  add( double  v1, double  v2){   
36.   
37. BigDecimal b1 =  new  BigDecimal(Double.toString(v1));   
38.   
39. BigDecimal b2 =  new  BigDecimal(Double.toString(v2));   
40.   
41. return  b1.add(b2).doubleValue();   
42.   
43. }   
44.   
45. /** */ /**  
47. * 提供精确的减法运算。  
49. * @param v1 被减数  
51. * @param v2 减数  
53. * @return 两个参数的差  
55. */   
56.   
57. public   static   double  sub( double  v1, double  v2){   
58.   
59. BigDecimal b1 =  new  BigDecimal(Double.toString(v1));   
60.   
61. BigDecimal b2 =  new  BigDecimal(Double.toString(v2));   
62.   
63. return  b1.subtract(b2).doubleValue();   
64.   
65. }   
66.   
67. /** */ /**  
69. * 提供精确的乘法运算。  
71. * @param v1 被乘数  
73. * @param v2 乘数  
75. * @return 两个参数的积  
77. */   
78.   
79. public   static   double  mul( double  v1, double  v2){   
80.   
81. BigDecimal b1 =  new  BigDecimal(Double.toString(v1));   
82.   
83. BigDecimal b2 =  new  BigDecimal(Double.toString(v2));   
84.   
85. return  b1.multiply(b2).doubleValue();   
86.   
87. }   
88.   
89. /** */ /**  
91. * 提供（相对）精确的除法运算，当发生除不尽的情况时，精确到  
93. * 小数点以后10位，以后的数字四舍五入。  
95. * @param v1 被除数  
97. * @param v2 除数  
99. * @return 两个参数的商  
101. */   
102.   
103. public   static   double  div( double  v1, double  v2){   
104.   
105. return  div(v1,v2,DEF_DIV_SCALE);   
106.   
107. }   
108.   
109. /** */ /**  
111. * 提供（相对）精确的除法运算。当发生除不尽的情况时，由scale参数指  
113. * 定精度，以后的数字四舍五入。  
115. * @param v1 被除数  
117. * @param v2 除数  
119. * @param scale 表示表示需要精确到小数点以后几位。  
121. * @return 两个参数的商  
123. */   
124.   
125. public   static   double  div( double  v1, double  v2, int  scale){   
126.   
127. if (scale< 0 ){   
128.   
129. throw   new  IllegalArgumentException(   
130.   
131. "The scale must be a positive integer or zero" );   
132.   
133. }   
134.   
135. BigDecimal b1 =  new  BigDecimal(Double.toString(v1));   
136.   
137. BigDecimal b2 =  new  BigDecimal(Double.toString(v2));   
138.   
139. return  b1.divide(b2,scale,BigDecimal.ROUND_HALF_UP).doubleValue();   
140.   
141. }   
142.   
143. /** */ /**  
145. * 提供精确的小数位四舍五入处理。  
147. * @param v 需要四舍五入的数字  
149. * @param scale 小数点后保留几位  
151. * @return 四舍五入后的结果  
153. */   
154.   
155. public   static   double  round( double  v, int  scale){   
156.   
157. if (scale< 0 ){   
158.   
159. throw   new  IllegalArgumentException(   
160.   
161. "The scale must be a positive integer or zero" );   
162.   
163. }   
164.   
165. BigDecimal b =  new  BigDecimal(Double.toString(v));   
166.   
167. BigDecimal one =  new  BigDecimal( "1" );   
168.   
169. return  b.divide(one,scale,BigDecimal.ROUND_HALF_UP).doubleValue();   
170.   
171. }   
172.   
173. }   

以上内容为转载~下面内容为原创！

今天在做客户端程序的自动更新，简单描述一下，就是从服务器上将更新包下载下来，然后在本地解压缩，最后删掉~功能很简单~

但是问题出在使用JAVA的ZIP模块做文件的解压缩不是想象的那么简单，资源需要释放，一个不小心就没有办法删除掉原有ZIP文件了~资源的占用确实是个大问题，但是好在，客户端程序更新完是要重启的，一切都烟消云散了~对于删除不掉ZIP文件的问题，我也流氓一下~用DEL硬删除~此处一定要注意！

Process process = Runtime.getRuntime().exec("cmd /c del f:\\aaa.doc");
这样的调用是没有问题~

Process process = Runtime.getRuntime().exec("del f:\\aaa.doc");
这样写是不可能对的~

记录一下，警告一下后人！


Ref from：http://www.blogjava.net/leeguannan/archive/2007/11/29/164044.html

SetCharacterEncodingFilter:

package com.util.filters;

import java.io.IOException;
import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.UnavailableException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class SetCharacterEncodingFilter
    implements Filter {

  protected String encoding = null;

  protected FilterConfig filterConfig = null;

  protected boolean ignore = true;

  public void destroy() {

    this.encoding = null;
    this.filterConfig = null;

  }

  public void doFilter(ServletRequest request, ServletResponse response,
                       FilterChain chain) throws IOException, ServletException {

    // Conditionally select and set the character encoding to be used
   request.setCharacterEncoding("GBK");
    // Pass control on to the next filter
    chain.doFilter(request, response);

  }

  public void init(FilterConfig filterConfig) throws ServletException {

    this.filterConfig = filterConfig;
    this.encoding = filterConfig.getInitParameter("encoding");
    String value = filterConfig.getInitParameter("ignore");
    if (value == null) {
      this.ignore = true;
    }
    else if (value.equalsIgnoreCase("true")) {
      this.ignore = true;
    }
    else if (value.equalsIgnoreCase("yes")) {
      this.ignore = true;
    }
    else {
      this.ignore = false;
    }

  }

  protected String selectEncoding(ServletRequest request) {

    return (this.encoding);

  }

}

2．解决GET方式出现乱码的方案

tomcat的server.xml中
<Connector connectionTimeout="20000" maxSpareThreads="75" maxThreads="150" minSpareThreads="25" port="8080" redirectPort="8443" uRIEncoding="UTF-8" useBodyEncodingForURI="true">
</Connector>
注意其中的useBodyEncodingForURI="true"这句是是解决问题的关键，但缺省情况下没有，自己加进去。
然后再用Filter方案解决 解决GET的问题

3.乱码字符转换　
　　byte[] bytes = str.getBytes("ISO8859-1");
    String dept=new String(bytes);

AJAX
在用XMLHttpRequest发送请求时如用post方式传送数据,容易出现中文乱码问题!
在Ajax中,默认的编码方式是UTF-8,所以在服务器端用request.setCharacterEncoding("UTF-8");(对于java言,其它语言可能类似方法)设置编码即可解决大部份的编码问题!

 对于服务器端返回的XML文件在用responseXML读取时也要注意编码问题!

以下是正确的处理方法：

response.setCharacterEncoding("UTF-8");-----(1)
PrintWriter out=response.getWriter();------(2)
out.println("返回内容");

如上所示,如果1、2的先后顺序发生变化就会产生乱码！

在jsp向页面输出图片的时候,使用response.getOutputStream()会有这样的提示：java.lang.IllegalStateException:getOutputStream() has already been called for this response,会抛出Exception

//检查是否是一个文件上传请求
boolean isMultipart = FileUpload.isMultipartContent(request);

现在我们就可以准备解析这个请求到一个备选的选项了。解析的结果是一个文件选项的List,每个这样的选项都实现了FileItem接口，处理这些选项将在下面得到讨论。

最简单的情况

最简单的使用场景可以参照下面：

• 被上传得选项必须以适度的大小驻留在内存中；
• 比较大的文件上传选项必须写入到磁盘的临时文件中去；
• 大文件上传请求必须不被允许；
• 默认的驻留内存的选项的最大大小，最大允许的上传文件请求，和临时文件的存储地方是可以接受的；

在这种情景下处理这样一个请求并不是很简单的：

//创建一个新的文件上传句柄
DiskFileUpload upload = new DiskFileUpload();
//解析请求
List /* FileItem */ items = upload.parseRequest(request);

这就是所有我们需要做的，真的！
解析的结果是一个文件项目的List,每一个都实现了FileItem接口。处理这些项目将在下面讨论。

练习更多的控制

如果你的使用情景非常接近最简单的使用方式，在上文中可以看到，但是你需要更多的控制临界的大小和临时文件的驻留地址，你可以使用DiskFileUpload类的方法来自定义这些动作，就像这样：

//创建一个新的文件上传句柄
DiskFileUpload upload = new DiskFileUpload();
//设置上传参数
upload.setSizeThrehold(最大内存大小);
upload.setSizeMax(最大请求大小);
upload.setRepositoryPath(临时目录);
//解析请求
List /* FileItem */ items = upload.parseRequest(request);

当然，每个配置方法都是独立于其它的，但是如果你想一次就配置它们，你可以使用可选的parseRequest()方法，像这样：

// 建立一个新的文件上传句柄
DiskFileUpload upload = new DiskFileUpload();
// 解析请求
List /* FileItem */ items = upload.parseRequest(request,
        内存大小, 允许上传的最大文件, 临时目录);

如果你想更多地控制请求的解析，比如把上传选项存储到其它地方，例如，存到数据库中-你可以参照自定义FileUpload。

处理上传选项

一旦解析过程完毕，你就可以获得一个文件选项的List，以便进一步处理。在大多数情况下，你将会根据规则的表单域来不同地处理文件的上传。所以你可能以这样的方式来处理：

// 处理上传的选项
Iterator iter = items.iterator();
while (iter.hasNext()) {
    FileItem item = (FileItem) iter.next();

    if (item.isFormField()) {
        processFormField(item);
    } else {
        processUploadedFile(item);
    }
}

对于一个规则的表单域来说，你对它感兴趣的可能就只有它的名字以及它的字符串值。你也会想到，处理它们是简单的:

//处理一个规则表单域
if (item.isFormField()) {
    String name = item.getFieldName();
    String value = item.getString();
    ...
}

而对于一个文件的上传，在你处理它的内容之前，可以有好多令你想知道的不同的东西，这里有一个采用了一些你可能感兴趣的方法的例子

// 处理一个文件上传
if (!item.isFormField()) {
    String fieldName = item.getFieldName();
    String fileName = item.getName();
    String contentType = item.getContentType();
    boolean isInMemory = item.isInMemory();
    long sizeInBytes = item.getSize();
    ...
}

对于这些上传的文件，你一般不想通过内存来存取它们，除非它们很小，或者你没有其它好的方法，更进一步，你想将内容当作文件流来处理，或者将整个文件写到最终的地址。FileUpload提供了简单的方法来完成这些 操作。

// 处理一个文件上传的情况
if (writeToFile) {
    File uploadedFile = new File(...);
    item.write(uploadedFile);
} else {
    InputStream uploadedStream = item.getInputStream();
    ...
    uploadedStream.close();
}

注意到，在默认的FileUpload的实现中，write()方法将尝试把文件改名以将它保存到特定的地点，如果数据已经在临时文件中了，如果重命名失败，实际的复制文件就完成了（？），在其它原因看来，或者数据已经在内存中了。如果你的确需要在内存中取上传的数据，你只需简单的调用get()方法来把它当作一个字符数组来获得。

// 在内存中处理一个上传的文件
byte[] data = item.get();
...

和杀毒软件的相互作用

当web容器在运行时，而杀毒软件又同时运行在同样的系统上，这种情况下在应用中使用FileUpload容易导致一些很难预料的事情.这部分将描述一些你可能要遇到的情况，我们会提供一些方法来处理它们。默认的FileUpload实现将会使超过它在内存中大小的上传的选项写入到磁盘。而当这样的文件关闭后，任何系统中的杀毒软件都会被唤醒,然后去检查它，然后会潜在地隔离这个文件--就是说，将它移动到一个不产生问题的特定地方。这样一来，对开发者来说当然是一个意外，因为刚刚上传的文件将不能被处理了。从另一方面来说，小于设定的内存大小的那些上传的文件将被保持在内存中，这样一来，将不会被杀毒软件所检测到，这样就有可能使病毒以某种方式驻留在了系统中了（虽然如果一旦它被写入到磁盘，杀毒软件就会定位并检测到它）。一个通用的解决方法是在系统中专门设置一个目录来存放这些上传的文件，然后配置杀毒软件忽略这个目录。这样将确保上传的文件在系统中不被隔离，但是这样就把扫描病毒的责任交给了应用程序的开发者了。扫描这些上传的文件的任务可以在外部的处理中实现。这样可以将干净的文件移动到一个“改进”过的地方，或者也可以把杀毒集成到应用中去。至于怎么将外部处理或集成病毒扫描到一个
应用，这个已经超出了本文档的讨论范围。

下一步是什么

希望这个页面能提供给你一个好的意见，让你在你自己的应用中能使用FileUpload。更多关于这里介绍的方法，以及其它可用的方法，你可以参照api文档。这里介绍的用法已经可以满足大多数的文件上传的需要了，当然，如果你还有更多的复杂的需求，使用它的灵活的自定义配置的能力，FileUpload一定可以能够帮助你。

另一个实例：

commons.fileupload实现文件的上传，代码如下：
<%!
 //服务器端保存上传文件的路径
    String saveDirectory = "g:\\upload\\";
    // 临时路径 一旦文件大小超过getSizeThreshold()的值时数据存放在硬盘的目录
    String tmpDirectory = "g:\\upload\\tmp\\";
    // 最多只允许在内存中存储的数据大小,单位:字节
    int maxPostSize = 1024 * 1024;
%>
<%
    // 文件内容 
    String FileDescription = null;
    // 文件名（包括路径）
    String FileName = null;
    // 文件大小
    long FileSize = 0;
    // 文件类型
    String ContentType = null;

%>

<%
   DiskFileUpload fu = new DiskFileUpload();
    // 设置允许用户上传文件大小,单位:字节
   fu.setSizeMax(200*1024*1024);
    // 设置最多只允许在内存中存储的数据,单位:字节
   fu.setSizeThreshold(maxPostSize);
    // 设置一旦文件大小超过getSizeThreshold()的值时数据存放在硬盘的目录
   fu.setRepositoryPath("g:\\upload\\tmp\\");
    //开始读取上传信息 得到所有文件
   try{
      List fileItems = fu.parseRequest(request);
     }catch(FileUploadException e){
         //这里异常产生的原因可能是用户上传文件超过限制、不明类型的文件等
         //自己处理的代码
     }
%>
<%
   // 依次处理每个上传的文件
   Iterator iter = fileItems.iterator();
   while (iter.hasNext()) {
     FileItem item = (FileItem) iter.next();
       //忽略其他不是文件域的所有表单信息
     if (!item.isFormField()) {
       String name = item.getName();
       long size = item.getSize();
       String  contentType = item.getContentType();
     if((name==null||name.equals("")) && size==0)
       continue;
%>
<%
   //保存上传的文件到指定的目录
  String[] names=StringUtils.split(name,"\\");  //对原来带路径的文件名进行分割
   name = names[names.length-1];
   item.write(new File(saveDirectory+ name));
  }
}
%>
 下面是其简单的使用场景：
 A、上传项目只要足够小，就应该保留在内存里。
 B、较大的项目应该被写在硬盘的临时文件上。
 C、非常大的上传请求应该避免。
 D、限制项目在内存中所占的空间，限制最大的上传请求，并且设定临时文件的位置。
 
 可以根据具体使用用servlet来重写，具体参数配置可以统一放置到一配置文件
 

 文件的下载用servlet实现
      public void doGet(HttpServletRequest request,
                       HttpServletResponse response)
     {
         String aFilePath = null;    //要下载的文件路径
         String aFileName = null;    //要下载的文件名
         FileInputStream in = null;  //输入流
         ServletOutputStream out = null;  //输出流

         try
   {
          
             aFilePath = getFilePath(request);
             aFileName = getFileName(request);

             response.setContentType(getContentType(aFileName) + "; charset=UTF-8");
             response.setHeader("Content-disposition", "attachment; filename=" + aFileName);

             in = new  FileInputStream(aFilePath + aFileName); //读入文件
            out = response.getOutputStream();
            out.flush();
            int aRead = 0;
           while((aRead = in.read()) != -1 & in != null)
        {
             out.write(aRead);
         }
           out.flush();
      }
       catch(Throwable e)
     {
     log.error("FileDownload doGet() IO error!",e);
      }
         finally
         {
             try
             {
                 in.close();
                 out.close();
             }
             catch(Throwable e)
             {
              log.error("FileDownload doGet() IO close error!",e);
             }
         }
     }

<%@ page contentType="image/jpeg" import="java.awt.*,
java.awt.image.*,java.util.*,javax.imageio.*" %>
<%!
Color getRandColor(int fc,int bc){//给定范围获得随机颜色
        Random random = new Random();
        if(fc>255) fc=255;
        if(bc>255) bc=255;
        int r=fc+random.nextInt(bc-fc);
        int g=fc+random.nextInt(bc-fc);
        int b=fc+random.nextInt(bc-fc);
        return new Color(r,g,b);
        }
%>
<%
//设置页面不缓存
response.setHeader("Pragma","No-cache");
response.setHeader("Cache-Control","no-cache");
response.setDateHeader("Expires", 0);

// 在内存中创建图象
int width=60, height=20;
BufferedImage image = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);

// 获取图形上下文
Graphics g = image.getGraphics();

//生成随机类
Random random = new Random();

// 设定背景色
g.setColor(getRandColor(200,250));
g.fillRect(0, 0, width, height);

//设定字体
g.setFont(new Font("Times New Roman",Font.PLAIN,18));

//画边框
//g.setColor(new Color());
//g.drawRect(0,0,width-1,height-1);

// 随机产生155条干扰线，使图象中的认证码不易被其它程序探测到
g.setColor(getRandColor(160,200));
for (int i=0;i<155;i++)
{
 int x = random.nextInt(width);
 int y = random.nextInt(height);
        int xl = random.nextInt(12);
        int yl = random.nextInt(12);
 g.drawLine(x,y,x+xl,y+yl);
}

// 取随机产生的认证码(4位数字)
String sRand="";
for (int i=0;i<4;i++){
    String rand=String.valueOf(random.nextInt(10));
    sRand+=rand;
    // 将认证码显示到图象中
    g.setColor(new Color(20+random.nextInt(110),20+random.nextInt(110),20+random.nextInt(110)));
//调用函数出来的颜色相同，可能是因为种子太接近，所以只能直接生成
    g.drawString(rand,13*i+6,16);
}

// 将认证码存入SESSION
session.setAttribute("rand",sRand);

// 图象生效
g.dispose();

// 输出图象到页面
ImageIO.write(image, "JPEG", response.getOutputStream());
%>

使用验证码图片的文件a.jsp

<%@ page contentType="text/html;charset=gb2312" %>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>认证码输入页面</title>
<meta http-equiv="Content-Type" content="text/html; charset=gb2312">
<META HTTP-EQUIV="Pragma" CONTENT="no-cache">
<META HTTP-EQUIV="Cache-Control" CONTENT="no-cache">
<META HTTP-EQUIV="Expires" CONTENT="0">
</head>
<body>
<form method=post action="check.jsp">
<table>
<tr>
<td align=left>系统产生的认证码：</td>
<td><img border=0 src="image.jsp"></td>
</tr>
<tr>
<td align=left>输入上面的认证码：</td>
<td><input type=text name=rand maxlength=4 value=""></td>
</tr>
<tr>
<td colspan=2 align=center><input type=submit value="提交检测"></td>
</tr>
</form>
</body>
</html>

验证的页面check.jsp

<%@ page contentType="text/html; charset=gb2312" language="java" import="java.sql.*" errorPage="" %>
<html>
<head>
<title>认证码验证页面</title>
<meta http-equiv="Content-Type" content="text/html; charset=gb2312">
<META HTTP-EQUIV="Pragma" CONTENT="no-cache">
<META HTTP-EQUIV="Cache-Control" CONTENT="no-cache">
<META HTTP-EQUIV="Expires" CONTENT="0">
</head>

<body>
<%
 String rand = (String)session.getAttribute("rand");
 String input = request.getParameter("rand");
%>
系统产生的认证码为： <%= rand %><br>
您输入的认证码为： <%= input %><br>
<br>
<%
  if (rand.equals(input)) {
%>
<font color=green>输入相同，认证成功！</font>
<%
  } else {
%>
<font color=red>输入不同，认证失败！</font>
<%
  }
%>
</body>
</html>