把byte转化成string，必须经过编码。

例如下面一个例子:

import java.io.UnsupportedEncodingException;

public class test{
 public static void main(String g[]) {
  String s = "12345abcd";
  byte b[] = s.getBytes();
  String t = b.toString();

  System.out.println(t);

 }
}
输出字符串的结果和字符串s不一样了.

经过以下方式转码就可以正确转换了:

public class test{
 public static void main(String g[]) {
  String s = "12345abcd";
  byte b[] = s.getBytes();
  try {
   String t = new String(b);
   System.out.print(t);
  } catch (Exception e) {
   e.printStackTrace();
  }
 }
}

引用：
String   str   =   "String"; 
          byte[]   byte1   =   str.getBytes(); 
          String   str1   =   new   String(byte1); 
          byte[]   byte2   =   str1.getBytes(); 
          String   str2   =   new   String(byte2); 
          System.out.println("str<<<"   +   str); 
          System.out.println("byte1<<<"   +   byte1); 
          System.out.println("str1<<<"   +   str1); 
          System.out.println("byte2<<<"   +   byte2); 
          System.out.println("str2<<<"   +   str2); 
  ------------------------------------- 
  输出结果 
  str<<<String 
  byte1<<<[B@192d342 
  str1<<<String 
  byte2<<<[B@6b97fd 
  str2<<<String 
  
  想请教为什么两个byte输出的不一样呢? 
 

String   str   =   "String"; 
          byte[]   byte1   =   str.getBytes(); 
          String   str1   =   new   String(byte1); 
          byte[]   byte2   =   str1.getBytes(); 
  ---------- 
  注意byte1是str得到的byte数组，而byte2是另一个字符串str1得到的数组 
  他们本身也是两个对象  
   
  直接打印实际上调用的是toString()方法，而toString()的默认实现是打印对象类型+hashCode()  
  [B表示byte数组  @表示之后的是地址  后面跟着的是hashCode，其实就是其虚拟机地址  
  

永久区内存（ Permanent space）和堆内存（heap space）。

栈内存（stack space）一般都不归在JVM内存模型中，因为栈内存属于线程级别。

每个线程都有个独立的栈内存空间。

Permanent space里存放加载的Class类级对象如class本身，method，field等等。

heap space主要存放对象实例和数组。

heap space由Old Generation和NewGeneration组成，OldGeneration存放生命周期长久的实例对象，而新的对象实例一般放在NewGeneration。

New Generation还可以再分为Eden区(圣经中的伊甸园)、和Survivor区，新的对象实例总是首先放在Eden区，Survivor区作为Eden区和Old区的缓冲，可以向Old区转移活动的对象实例。

一般，我们常见的OOM（out of memory）内存溢出异常，就是堆内存空间不足以存放新对象实例时导致。

永久区内存溢出相对少见，一般是由于需要加载海量的Class数据，超过了非堆内存的容量导致。通常出现在Web应用刚刚启动时，因此Web应用推荐使用预加载机制，方便在部署时就发现并解决该问题。

栈内存也会溢出，但是更加少见。

堆内存优化：

调整JVM启动参数-Xms  -Xmx   -XX:newSize -XX:MaxNewSize，如调整初始堆内存和最大对内存 -Xms256M -Xmx512M。 或者调整初始New Generation的初始内存和最大内存-XX:newSize=128M -XX:MaxNewSize=128M。

永久区内存优化：

调整PermSize参数   如  -XX:PermSize=256M-XX:MaxPermSize=512M。

栈内存优化：

调整每个线程的栈内存容量  如  -Xss2048K

最终，一个运行中的JVM所占的内存= 堆内存  +  永久区内存  +  所有线程所占的栈内存总和 。

Java代码

1. 1 function findShape(flags, point, attribute, list) {   
2.   
3. 2    if(!findShapePoints(flags, point, attribute)) {   
4.   
5. 3        if(!doFindShapePoints(flags, point, attribute)) {   
6.   
7. 4            if(!findInShape(flags, point, attribute)) {   
8.   
9. 5                if(!findFromGuide(flags,point) {   
10.   
11. 6                    if(list.count() > 0 && flags == 1) {   
12.   
13. 7                          doSomething();   
14.   
15. 8                    }   
16.   
17. 9                }   
18.   
19. 10            }   
20.   
21. 11       }   
22.   
23. 12    }      
24.   
25. 13  }  

1 function findShape(flags, point, attribute, list) {
2    if(!findShapePoints(flags, point, attribute)) {
3        if(!doFindShapePoints(flags, point, attribute)) {
4            if(!findInShape(flags, point, attribute)) {
5                if(!findFromGuide(flags,point) {
6                    if(list.count() > 0 && flags == 1) {
7                          doSomething();
8                    }
9                }
10            }
11       }
12    }
13  }

Java代码

1. 1 function findShape(flags, point, attribute, list) {   
2.   
3. 2    if(findShapePoints(flags, point, attribute)) {   
4.   
5. 3        return;   
6.   
7. 4    }   
8.   
9. 5    
10.   
11. 6    if(doFindShapePoints(flags, point, attribute)) {   
12.   
13. 7        return;   
14.   
15. 8    }   
16.   
17. 9    
18.   
19. 10    if(findInShape(flags, point, attribute)) {    
20.   
21. 11        return;   
22.   
23. 12    }   
24.   
25. 13    
26.   
27. 14    if(findFromGuide(flags,point) {   
28.   
29. 15        return;   
30.   
31. 16    }   
32.   
33. 17    
34.   
35. 18    if (!(list.count() > 0 && flags == 1)) {   
36.   
37. 19        return;   
38.   
39. 20    }   
40.   
41. 21    
42.   
43. 22    doSomething();   
44.   
45. 23    
46.   
47. 24 }  

1 function findShape(flags, point, attribute, list) {
2    if(findShapePoints(flags, point, attribute)) {
3        return;
4    }
5
6    if(doFindShapePoints(flags, point, attribute)) {
7        return;
8    }
9
10    if(findInShape(flags, point, attribute)) {
11        return;
12    }
13
14    if(findFromGuide(flags,point) {
15        return;
16    }
17
18    if (!(list.count() > 0 && flags == 1)) {
19        return;
20    }
21
22    doSomething();
23
24 }

Java代码

1. 1 function isStringEmpty(str){   
2.   
3. 2    if(str === "") {    
4.   
5. 3        return true;   
6.   
7. 4    }   
8.   
9. 5    else {   
10.   
11. 6        return false;   
12.   
13. 7    }   
14.   
15. 8 }  

1 function isStringEmpty(str){
2    if(str === "") {
3        return true;
4    }
5    else {
6        return false;
7    }
8 }

Java代码

1. 1 function isStringEmpty(str){   
2.   
3. 2    return (str === "");   
4.   
5. 3 }  

1 function isStringEmpty(str){
2    return (str === "");
3 }

Java代码

1.  function getSomeAngle() {   
2.   
3. 2    // Some code here then   
4.   
5. 3    radAngle1 = Math.atan(slope(center, point1));   
6.   
7. 4    radAngle2 = Math.atan(slope(center, point2));   
8.   
9. 5    firstAngle = getStartAngle(radAngle1, point1, center);   
10.   
11. 6    secondAngle = getStartAngle(radAngle2, point2, center);   
12.   
13. 7    radAngle1 = degreesToRadians(firstAngle);   
14.   
15. 8    radAngle2 = degreesToRadians(secondAngle);   
16.   
17. 9    baseRadius = distance(point, center);   
18.   
19. 10    radius = baseRadius + (lines * y);   
20.   
21. 11    p1["x"] = roundValue(radius * Math.cos(radAngle1) + center["x"]);   
22.   
23. 12    p1["y"] = roundValue(radius * Math.sin(radAngle1) + center["y"]);   
24.   
25. 13    pt2["x"] = roundValue(radius * Math.cos(radAngle2) + center["y"]);   
26.   
27. 14    pt2["y"] = roundValue(radius * Math.sin(radAngle2) + center["y");   
28.   
29. 15    // Now some more code   
30.   
31. 16 }  

 function getSomeAngle() {
2    // Some code here then
3    radAngle1 = Math.atan(slope(center, point1));
4    radAngle2 = Math.atan(slope(center, point2));
5    firstAngle = getStartAngle(radAngle1, point1, center);
6    secondAngle = getStartAngle(radAngle2, point2, center);
7    radAngle1 = degreesToRadians(firstAngle);
8    radAngle2 = degreesToRadians(secondAngle);
9    baseRadius = distance(point, center);
10    radius = baseRadius + (lines * y);
11    p1["x"] = roundValue(radius * Math.cos(radAngle1) + center["x"]);
12    p1["y"] = roundValue(radius * Math.sin(radAngle1) + center["y"]);
13    pt2["x"] = roundValue(radius * Math.cos(radAngle2) + center["y"]);
14    pt2["y"] = roundValue(radius * Math.sin(radAngle2) + center["y");
15    // Now some more code
16 }

Java代码

1. 1 function getSomeAngle() {   
2.   
3. 2    // Some code here then   
4.   
5. 3    radAngle1 = Math.atan(slope(center, point1));   
6.   
7. 4    radAngle2 = Math.atan(slope(center, point2));   
8.   
9. 5    
10.   
11. 6    firstAngle = getStartAngle(radAngle1, point1, center);   
12.   
13. 7    secondAngle = getStartAngle(radAngle2, point2, center);   
14.   
15. 8    
16.   
17. 9    radAngle1 = degreesToRadians(firstAngle);   
18.   
19. 10    radAngle2 = degreesToRadians(secondAngle);   
20.   
21. 11    
22.   
23. 12    baseRadius = distance(point, center);   
24.   
25. 13    radius = baseRadius + (lines * y);   
26.   
27. 14    
28.   
29. 15    p1["x"] = roundValue(radius * Math.cos(radAngle1) + center["x"]);   
30.   
31. 16    p1["y"] = roundValue(radius * Math.sin(radAngle1) + center["y"]);   
32.   
33. 17    
34.   
35. 18    pt2["x"] = roundValue(radius * Math.cos(radAngle2) + center["y"]);   
36.   
37. 19    pt2["y"] = roundValue(radius * Math.sin(radAngle2) + center["y");   
38.   
39. 20    // Now some more code   
40.   
41. 21 }   
42.   
43.   
44.   
45. 4， 不要使用无谓的注释   
46.   
47. 无谓的注释让人费神，这实在很讨厌。不要标出很明显的注释。在以下的例子中，每个人都知道代码表达的是“students id”，因而没必要标出。   
48.   
49. 1 function existsStudent(id, list) {   
50.   
51. 2    for(i = 0; i < list.length; i++) {   
52.   
53. 3       student = list[i];   
54.   
55. 4    
56.   
57. 5       // Get the student's id   
58.   
59. 6       thisId = student.getId();   
60.   
61. 7    
62.   
63. 8       if(thisId === id) {   
64.   
65. 9           return true;   
66.   
67. 10       }   
68.   
69. 11    }   
70.   
71. 12    return false;      
72.   
73. 13 }  

1 function getSomeAngle() {
2    // Some code here then
3    radAngle1 = Math.atan(slope(center, point1));
4    radAngle2 = Math.atan(slope(center, point2));
5
6    firstAngle = getStartAngle(radAngle1, point1, center);
7    secondAngle = getStartAngle(radAngle2, point2, center);
8
9    radAngle1 = degreesToRadians(firstAngle);
10    radAngle2 = degreesToRadians(secondAngle);
11
12    baseRadius = distance(point, center);
13    radius = baseRadius + (lines * y);
14
15    p1["x"] = roundValue(radius * Math.cos(radAngle1) + center["x"]);
16    p1["y"] = roundValue(radius * Math.sin(radAngle1) + center["y"]);
17
18    pt2["x"] = roundValue(radius * Math.cos(radAngle2) + center["y"]);
19    pt2["y"] = roundValue(radius * Math.sin(radAngle2) + center["y");
20    // Now some more code
21 }
4， 不要使用无谓的注释
无谓的注释让人费神，这实在很讨厌。不要标出很明显的注释。在以下的例子中，每个人都知道代码表达的是“students id”，因而没必要标出。
1 function existsStudent(id, list) {
2    for(i = 0; i < list.length; i++) {
3       student = list[i];
4
5       // Get the student's id
6       thisId = student.getId();
7
8       if(thisId === id) {
9           return true;
10       }
11    }
12    return false;
13 }

Java代码

1. //function thisReallyHandyFunction() {   
2.   
3. //      someMagic();   
4.   
5. //      someMoreMagic();   
6.   
7. //      magicNumber = evenMoreMagic();   
8.   
9. //      return magicNumber;   
10.   
11. //}  

//function thisReallyHandyFunction() {
//      someMagic();
//      someMoreMagic();
//      magicNumber = evenMoreMagic();
//      return magicNumber;
//}

Java代码

1. 1 public static EnumMap<Category, IntPair> getGroupCategoryDistribution(EnumMap<Category, Integer> sizes, int groups) {   
2.   
3. 2        EnumMap<Category, IntPair> categoryGroupCounts = new EnumMap<Category,IntPair>(Category.class);   
4.   
5. 3    
6.   
7. 4        for(Category cat : Category.values()) {   
8.   
9. 5            categoryGroupCounts.put(cat, getCategoryDistribution(sizes.get(cat), groups));   
10.   
11. 6        }  

1 public static EnumMap<Category, IntPair> getGroupCategoryDistribution(EnumMap<Category, Integer> sizes, int groups) {
2        EnumMap<Category, IntPair> categoryGroupCounts = new EnumMap<Category,IntPair>(Category.class);
3
4        for(Category cat : Category.values()) {
5            categoryGroupCounts.put(cat, getCategoryDistribution(sizes.get(cat), groups));
6        }

1. Class cls = Class.forName("chb.test.reflect.Student");   
2. Method m = cls.getDeclaredMethod("方法名",new Class[]{int.class,String.class});   
3. m.invoke(cls.newInstance(),20,"chb");

package com.inspur.reflect;

import java.lang.reflect.Method;

public class Methodtest1 {
 
 
 private int abc(Object p,int x) throws NullPointerException{
  if(p==null)throw new NullPointerException();
  return x;
 }

 public static void main(String[] args) {
  
  try{
   Class cls = Class.forName("com.inspur.reflect.Methodtest1");
   Method methodlist[]= cls.getDeclaredMethods();
   for(int i = 0;i<methodlist.length;i++){
    Method m = methodlist[i];
    System.out.println("name=="+m.getName());//得到方法的名称
    System.out.println("decl class=="+m.getDeclaringClass());//得到定义的类名
    Class prev[] = m.getParameterTypes();   //取m方法中的所有参数
    //遍历所有的参数
    for(int j = 0; j<prev.length;j++){
     System.out.println("param["+j+"]=="+prev[j]);
    }
    Class exec[] = m.getExceptionTypes(); //得到所有的异常
    //遍历所有的异常
    for(int k=0;k<exec.length;k++){
     System.out.println("execption["+k+"]=="+exec[k]);
    }
   
    Class ret = m.getReturnType(); //得到每个方法的返回值
    System.out.println("return leixing=="+ret.toString()); 
   }
  }catch(Throwable e){
   System.err.println(e.getMessage());
  }
 }

}

 Commons FileUpload，可以在http://jakarta.apache.org/commons/fileupload/下载，这个包需要Commons IO的支持，可以在http://jakarta.apache.org/commons/io/下载

 com.oreilly.servlet，可以在http://www.servlets.com/cos/下载
Commons FileUpload提供三种文件上传处理方式，DiskFileUpload、ServletFileUpload和PortletFileUpload三种方式，其中DiskFileUpload已经在javadoc下已经被标记为过期的方法，建议用ServletFileUpload代替，而PortletFileUpload需要配合portlet-api来使用，所以这里我们只介绍ServletFileUpload，并且这个也是最常用的。

com.oreilly.servlet也提供了三种文件上传的处理方式，MultipartWrapper、MultipartRequest和MultipartParser三种方式，其中MultipartWrapper和MultipartRequest的用法基本相同，并且没有MultipartRequest提供的操作多，所以这里介绍MultipartRequest，MultipartParser和前两者有些不同，可以用来处理某些特殊情况，例如表单中有两个同名的文件上传选择框。

我们暂时称三面三种文件上传方式分别为：ServletFileUpload方式（MultipartTestServlet）、MultipartRequest方式（MultipartTestServlet2）、MultipartParser方式（MultipartTestServlet3）

代码如下：
test.html

<%@ page language="java" import="java.util.*" contentType="text/html;charset=gbk" pageEncoding="gbk"%>
<html>
  <body>
    <form action="MultipartTestServlet" enctype="multipart/form-data" method="post">
     <input type="text" name="username" /><br />
     <input type="file" name="myfile" /><br/>
     <input type="file" name="myfile" /><br/>
     <input type="submit" />
    </form>
    <br/><br/><br/><br/>
    <form action="MultipartTestServlet2" enctype="multipart/form-data" method="post">
     <input type="text" name="username" /><br />
     <input type="file" name="myfile" /><br/>
     <input type="file" name="myfile" /><br/>
     <input type="submit" />
    </form>
    <br/><br/><br/><br/>
    <form action="MultipartTestServlet3" enctype="multipart/form-data" method="post">
     <input type="text" name="username" /><br />
     <input type="file" name="myfile" /><br/>
     <input type="file" name="myfile" /><br/>
     <input type="submit" />
    </form>
  </body>
</html>
MultipartTestServlet.java

package com.bug.servlet;

import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.apache.commons.fileupload.FileItem;
import org.apache.commons.fileupload.FileUpload;
import org.apache.commons.fileupload.FileUploadException;
import org.apache.commons.fileupload.RequestContext;
import org.apache.commons.fileupload.disk.DiskFileItemFactory;
import org.apache.commons.fileupload.servlet.ServletFileUpload;
import org.apache.commons.fileupload.servlet.ServletRequestContext;

public class MultipartTestServlet extends HttpServlet {

 public MultipartTestServlet() {
  super();
 }

 public void doPost(HttpServletRequest request, HttpServletResponse response)
   throws ServletException, IOException {

  request.setCharacterEncoding("gbk");
  RequestContext requestContext = new ServletRequestContext(request);
 
  if(FileUpload.isMultipartContent(requestContext)){
  
   DiskFileItemFactory factory = new DiskFileItemFactory();
   factory.setRepository(new File("c:/tmp/"));
   ServletFileUpload upload = new ServletFileUpload(factory);
   //upload.setHeaderEncoding("gbk");
   upload.setSizeMax(2000000);
   List items = new ArrayList();
    try {
     items = upload.parseRequest(request);
    } catch (FileUploadException e1) {
     System.out.println("文件上传发生错误" + e1.getMessage());
    }

   Iterator it = items.iterator();
   while(it.hasNext()){
    FileItem fileItem = (FileItem) it.next();
    if(fileItem.isFormField()){     
     System.out.println(fileItem.getFieldName() + "   " + fileItem.getName() + "   " + new String(fileItem.getString().getBytes("iso8859-1"), "gbk"));
    }else{
     System.out.println(fileItem.getFieldName() + "   " +
        fileItem.getName() + "   " +
        fileItem.isInMemory() + "    " +
        fileItem.getContentType() + "   " +
        fileItem.getSize());
    
     if(fileItem.getName()!=null && fileItem.getSize()!=0){
      File fullFile = new File(fileItem.getName());
      File newFile = new File("c:/temp/" + fullFile.getName());
      try {
       fileItem.write(newFile);
      } catch (Exception e) {
       e.printStackTrace();
      }
     }else{
      System.out.println("文件没有选择 或 文件内容为空");
     }
    }
    
   }
  }
 }

}

MultipartTestServlet2.java

package com.bug.servlet;

import java.io.IOException;
import java.util.Enumeration;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import com.oreilly.servlet.MultipartRequest;
import com.oreilly.servlet.multipart.DefaultFileRenamePolicy;

public class MultipartTestServlet2 extends HttpServlet {

 public MultipartTestServlet2() {
  super();
 }

 public void doPost(HttpServletRequest request, HttpServletResponse response)
   throws ServletException, IOException {

  //request.setCharacterEncoding("gbk");  不起作用
  System.out.println("start ");
  MultipartRequest multi = new MultipartRequest(request, "c:/tmp/", 2*1024*1024, "gbk", new DefaultFileRenamePolicy());
  System.out.println("start ");
  Enumeration filesName = multi.getFileNames();
  Enumeration paramsName = multi.getParameterNames();
  while(paramsName.hasMoreElements()){
   String paramName = (String) paramsName.nextElement();
   System.out.println(multi.getParameter(paramName));
  }
  while(filesName.hasMoreElements()){
   String fileName = (String) filesName.nextElement();
   System.out.println(multi.getFilesystemName(fileName) + "  " +
          multi.getOriginalFileName(fileName) + "  " +
          multi.getContentType(fileName) + "  ");
   if(multi.getFilesystemName(fileName)!=null && !multi.getFilesystemName(fileName).equals(""))
    System.out.println(multi.getFile(fileName).toURI());
  }
 }
 
}

MultipartTestServlet3.java

package com.bug.servlet;

import java.io.File;
import java.io.IOException;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import com.oreilly.servlet.multipart.FilePart;
import com.oreilly.servlet.multipart.MultipartParser;
import com.oreilly.servlet.multipart.ParamPart;
import com.oreilly.servlet.multipart.Part;

public class MultipartTestServlet3 extends HttpServlet {

 public MultipartTestServlet3() {
  super();
 }

 public void doPost(HttpServletRequest request, HttpServletResponse response)
   throws ServletException, IOException {

      MultipartParser mp = new MultipartParser(request, 2*1024*1024, false, false, "gbk");
      Part part;
      while ((part = mp.readNextPart()) != null) {
        String name = part.getName();
        if (part.isParam()) {
          ParamPart paramPart = (ParamPart) part;
          String value = paramPart.getStringValue();
          System.out.println("param: name=" + name + "; value=" + value);
        }
        else if (part.isFile()) {
          // it's a file part
          FilePart filePart = (FilePart) part;
          String fileName = filePart.getFileName();
          if (fileName != null) {
            long size = filePart.writeTo(new File("c:/tmp/"));
            System.out.println("file: name=" + name + "; fileName=" + fileName +
              ", filePath=" + filePart.getFilePath() +
              ", contentType=" + filePart.getContentType() +
              ", size=" + size);
          }
          else {
           System.out.println("file: name=" + name + "; EMPTY");
          }
          System.out.flush();
        }
      }
    }

}

web.xml中加入

 <servlet>
    <servlet-name>MultipartTestServlet</servlet-name>
    <servlet-class>com.bug.servlet.MultipartTestServlet</servlet-class>
  </servlet>
  <servlet>
    <servlet-name>MultipartTestServlet2</servlet-name>
    <servlet-class>com.bug.servlet.MultipartTestServlet2</servlet-class>
  </servlet>
  <servlet>
    <servlet-name>MultipartTestServlet3</servlet-name>
    <servlet-class>com.bug.servlet.MultipartTestServlet3</servlet-class>
  </servlet>
  <servlet-mapping>
    <servlet-name>MultipartTestServlet</servlet-name>
    <url-pattern>/MultipartTestServlet</url-pattern>
  </servlet-mapping>
  <servlet-mapping>
    <servlet-name>MultipartTestServlet2</servlet-name>
    <url-pattern>/MultipartTestServlet2</url-pattern>
  </servlet-mapping>
  <servlet-mapping>
    <servlet-name>MultipartTestServlet3</servlet-name>
    <url-pattern>/MultipartTestServlet3</url-pattern>
  </servlet-mapping>

问题1、中文问题：
 三种凡是都可以通过自己的方法来设置encoding为gbk开处理和解决中文问题，包括初始化的时候传入gbk作为参数，或是是初始化后通过setEncoding的方式来实现。
 另外ServletFileUpload方式也可以通过request.setCharacterEncoding("gbk");的方式来实现，而其它两种方式不支持这种方式。

问题2、文件大小限制
 ServletFileUpload方式可以设置文件大小限制，也可以不用设置，例子中的upload.setSizeMax(2000000)就可以注释掉。如果设置upload.setSizeMax(-1)，表明不限制上传的大小。文档中没有指明默认的限制的多少，我在不设置的情况下上传了一个9M的东西，可以上传，估计默认是不限制大小的。
 而MultipartRequest方式和MultipartParser方式是必须设置文件的上传文件的大小限制的，如果不设置，默认是1M的大小限制。

问题3、文件上传发生错误
 如果文件上传过程中发生任何错误，或者是文件的大小超出了范围，系统都将抛出错误。
 ServletFileUpload方式在upload.parseRequest(request)时抛出错误
 MultipartRequest方式在new MultipartRequest(。。。)时抛出错误
 MultipartParser方式在new MultipartParser(。。。)时抛出错误

问题4、上传同名文件时，他们保存到临时目录是的冲突问题
 ServletFileUpload方式，不会有冲突，系统会把上传得文件按照一定的规则重新命名，保证不会冲突
 MultipartParser方式，会产生冲突，系统会把文件按照上传时的文件名，保存到临时目录下，如果两个用会同时上传文件名相同的文件，那么就可能会产生冲突，一方把另一方的临时文件给替换了。
 MultipartRequest方式，在初始化时如果提供了一个名称转换策略，就不会有冲突，如果不提桶，就会有冲突。在上面的例子中我们提供了一个new DefaultFileRenamePolicy()保证了文件名不会有冲突发生。

问题5：表单中有两个同名的文件上传选择框，就像我们例子中的myfile一样，每个表单中有两个name=“myfile”的上传框
 ServletFileUpload方式，可以处理，可以分别得到他们各自的文件，
 MultipartRequest方式，不可以处理，会发生冲突，会有一个上传框的文件覆盖了另外一个。
 MultipartParser方式，可以处理，可以分别得到他们各自的文件，

备注：
 代码比较乱，主要是为了说明他们间的区别。他们的详细地使用说明还是要参考他的javadoc和domo。

参考：
 1、http://www.servlets.com/cos/#classes
 2、http://jakarta.apache.org/commons/fileupload/apidocs/index.html
 3、http://jakarta.apache.org/commons/fileupload/using.html
 4、http://www.onjava.com/pub/a/onjava/2003/06/25/commons.html?page=3

    好了，上面都是比较烦人的理论问题，还是赶快切入XML的配置文件的读取吧。

    在我们的程序中，通常要有一些根据主机环境确定的变量。比如数据库访问用户名和密码，不同的主机可能设置不一样。只要更改XML配置文件，就可以正常运行。


localhost
sqlname
username
password

    上面这个myenv.xml配置文件一般是放在tomcat的WEB-INF/classes目录下.

    我们编制一个Java程序直接读取,将dbhost dbuser dbpassword提取出来供其他程序访问数据库用.

    目前使用SAX比较的多,与DOM主要区别是 SAX是一行一行读取XML文件进行分析,适合比较大文件,DOM是一次性读入内存,显然不能对付大文件.这里我们使用SAX解析,由于SAX解析器不断在发展,网上有不少文章是针对老版本的.如果你使用JDK1.4 ,可以参考 使用SAX处理XML文档 一文.这里的程序是根据其改进并且经过实践调试得来的.

对上面myenv.xml读取的Java程序:


import org.xml.sax.Attributes;
import org.xml.sax.helpers.DefaultHandler;
import org.xml.sax.SAXException;
import java.util.Properties;

//使用DefaultHandler的好处 是 不必陈列出所有方法,
public class ConfigParser extends DefaultHandler {

////定义一个Properties 用来存放 dbhost dbuser dbpassword的值
private Properties props;

private String currentSet;
private String currentName;
private StringBuffer currentValue = new StringBuffer();

//构建器初始化props
public ConfigParser() {

this.props = new Properties();
}

public Properties getProps() {
return this.props;
}

//定义开始解析元素的方法. 这里是将 中的名称xxx提取出来.
public void startElement(String uri, String localName, String qName, Attributes attributes)
throws SAXException {
currentValue.delete(0, currentValue.length());
this.currentName =qName;

}

//这里是将 之间的值加入到currentValue

public void characters(char[] ch, int start, int length) throws SAXException {

currentValue.append(ch, start, length);

}

//在遇到 结束后,将之前的名称和值一一对应保存在props中

public void endElement(String uri, String localName, String qName) throws SAXException {

props.put(qName.toLowerCase(), currentValue.toString().trim());
}

}

    上面的这个解析程序比较简单吧? 其实解析XML就是这么简单.

    现在我们已经将dbhost dbuser dbpassword的值localhost sqlname username password提取了出来.但是这只是在在解析器内部,我们的程序还不能访问.需要再编制一个程序.


import java.util.Properties;
import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;
import java.net.URL;

public class ParseXML{

//定义一个Properties 用来存放 dbhost dbuser dbpassword的值
private Properties props;

//这里的props
public Properties getProps() {
return this.props;
}

public void parse(String filename) throws Exception {

//将我们的解析器对象化
ConfigParser handler = new ConfigParser();

//获取SAX工厂对象
SAXParserFactory factory = SAXParserFactory.newInstance();
factory.setNamespaceAware(false);
factory.setValidating(false);

//获取SAX解析
SAXParser parser = factory.newSAXParser();

//得到配置文件myenv.xml所在目录. tomcat中是在WEB-INF/classes
//下例中BeansConstants是用来存放xml文件中配置信息的类,可以自己代替或定义
URL confURL = BeansConstants.class.getClassLoader().getResource(filename);

try
{
//将解析器和解析对象myenv.xml联系起来,开始解析
parser.parse(confURL.toString(), handler);
//获取解析成功后的属性 以后 我们其他应用程序只要调用本程序的props就可以提取出属性名称和值了
props = handler.getProps();
}finally{
factory=null;
parser=null;
handler=null;
}

}

}

    由于我们的XML文件是使用最简单的形式 ,因此解析器相对简单,但是这已经足够对付我们的配置文件了.

    判断一个程序系统的先进性,我们先看看他的配置文件,如果还在使用老套的xxx=123 这样类似.ini的文件,

         现在在Java开发中，使用的开发工具大部分都是Eclipse，并且和Eclipse关系紧密的要数MyEclipse了，但是MyEclipse是一个EXE可执行程序，对于没有安装Eclipse与MyEclilpse的电脑来说，首先得先解压Eclipse，然后再安装MyEclipse，这不光很麻烦，而且还很费时，对于已经安装好的电脑来说，如果哪天电脑出了问题或是Eclipse崩溃了，导致工具不能用，这时又不得不重新安装时，那可真够郁闷滴～～～，因此，大象本着我为人人，人人为我的奉献精神，在此，将Eclipse+MyEclipse的完全绿色版制作方法写出来，和大家一起分享，让大家都能享受到这种方便。
        在这里，大象采用Eclipse3.3.1与MyEclipse_6.0.1GA_E3.3.1_Installer版来举例说明，其它的版本做法与此相同。
        第1步：下载Eclipse3.3.1和MyEclipse_6.0.1GA
           这里我要提醒大家注意一下：下载Eclipse时不要选择3.2的版本，因为MyEclipse6.0需要3.3版本以上的支持，另外就是下载MyEclipse时不要下完全版，而应该只下插件版，我的这个MyEclipse6.0.1的插件版是176M。

        第2步：解压Eclipse3.3.1 
          将Eclipse3.3.1的压缩包解压到D盘根目录下。


          做这个绿色版，把它放在根目录下是因为这样做很方便，在这里，大象以D盘为例，来说明制作方法。
    第3步：安装MyEclipse6.0.1GA
           双击"MyEclipse_6.0.1GA_E3.3.1_Installer.exe"开始安装MyEclipse，在第3步:"Choose Eclipse Folder"时，注意 "Please Choose Existing Eclipse Installation Folder"，点击"Choose...",请选择你解压的Eclipse文件夹，选择好之后如下图：

          点击"Next"，出现"Where Would You Like to Install MyEclipse 6.0.1?",点击"Choose...",选择上面的eclipse文件夹，这时记得在eclipse后面加一个目录名，否则，MyEclipse的安装文件就会全部放在eclipse的根目录下，这可不是我们希望看到滴，设置好之后如下图:

           下面的安装没什么好说的，就是一路Next了。安装结束后，可以在eclipse目录下看到有一个"MyEclipse 6.0.1GA"这个文件夹,进去看看，是不是有两个文件夹，两个文件？

           OK,到此MyEclipse插件已经安装完成了，下面来进行我们的绿色插件制作。
    第4步：插件制作
           在eclipse目录下，新建一个文件夹，命名为"ThirdPlugins"（你要取别的名字也可以，不过一定要和links目录里面的配置文件中的路径一致，后面会有说明),将"MyEclipse 6.0.1GA"这个文件夹复制到"ThirdPlugins"目录下，别用剪切喔，这可是刚才安装MyEclipse的目录，等会还要缷载MyEclipse，如果这个目录没有了，到时缷载不了，出了什么问题可不要怪大象喔！
           MyEclipse安装好之后，会在eclipse目录下生成一个links文件夹，里面有一个"com.genuitec.eclipse.MyEclipse.link"文件，我们删除它，另外新建一个"MyEclipse 6.0.1GA.ini"文件，内容为：path=ThirdPlugins/MyEclipse 6.0.1GA
           保存完之后，我们的插件制作也结束了，然后就是缷载MyEclipse，千万不要直接把那个文件夹删掉，而应该缷载它。


           其实所有的插件都可以按这个方式来做，这样做的好处就是，想用就放进去，不想用就删掉，如果放到eclipse的features和plugins里面，会很不好管理。
    第5步：配置参数
           虽然插件已经安装好了，但是，此时我们还不能启动它，应该对eclipse的启动参数设置一下，提高它的启动速度和运行时的稳定性。在eclipse.exe上点右键，选择"创建快捷方式"，在快捷方式上点右键，选择"属性"，在"D:\eclipse\eclipse.exe后面加上空格，将这些参数加在后面：
           -vmargs -Xverify:none -XX:+UseParallelGC -XX:PermSize=20M -XX:MaxPermSize=128M -Xms256M -Xmx512M
           -Xms256M -Xmx512M：这是堆，根据内存大小来设置，比如大象的内存是1G,我就设成256和512，这样一般都够用了。
           当然了，你也可以什么都不设置，不过大象还是建议设置这些参数，可以很大程度上提升eclipse的启动速度。在安装完MyEclipse时，还会生成一个eclipse.ini的备份文件，这个不需要，删掉。我们可以修改下eclipse.ini文件，原始的如下：

           最下面一行是启动时，显示MyEclipse的图片，如果没有这句话运行"MyEclipse 6.0.1"快捷方式，则会显示eclipse的启动画面，其实"MyEclipse 6.0.1"快捷方式还是连接着eclipse.exe这个执行程序，在"MyEclipse 6.0.1"上点右键，选择属性，在目标里就可以看到。
    第6步：注册MyEclipse
           MyEclipse6.0的注册一定要断开网络，否则肯定不成功！
           6.0.1GA注册码
           Subscriber: administrator
           Subscription Code: nLR7ZL-655342-54657656405281154
           这里有一点大象要提醒大家注意，如果你电脑上现在正有使用的MyEclipse，就是说已经注册了，那么在C:\Documents and Settings\"自己的用户名" 目录下，会有一个".myeclipse.properties"文件，这时请先备份此文件，然后删除它，断开网络，再来注册MyEclipse6.0.1，成功后如下：