摘要: <!------------------///事件处理----------------------->     <!--1-事件源对象所对应的HTML标签的事件属性     <script language="javascript">    &...  阅读全文 function MyAlert()
{
var msg="";
msg+="发生事件的类型：\n";
msg+="type="+event.type+"\n\n";
msg+="发生事件的原始对象：\n";
msg+="target="+event.srcElement+"\n\n";
msg+="光标相对于事件所在文档的水平和垂直位置：\n";
msg+="x="+event.x+"y="+event.y+"\n\n";
msg+="光标相对于事件所在容器的水平和垂直位置：\n";
msg+="x="+event.offsetX+"y="+event.offsetY+"\n\n";
msg+="光标相对于事件所在屏幕的水平和垂直位置：\n";
msg+="x="+event.screenX+"y="+event.screenY+"\n\n";
msg+="光标相对于事件所在Web页面的水平和垂直位置：\n";
msg+="x="+event.clientX+"y="+event.clientY+"\n\n";
alert(msg);
}

文件下载代码(2008-02-26 21:33:36)标签：情感   
 
 String fileName = request.getParameter("fileName");
  fileName = fileName.substring(fileName.indexOf("=")+1);
 
  String filePath = servlet.getServletContext().getRealPath("")
  + "\\upload\\" ;
  String file = filePath + fileName;
  System.out.println(file);
  FileInputStream fis = null;
  OutputStream os = null; 

  byte[] bos = new byte[1024];
  int length = 0;
  try {

   response.setContentType("application/x-msdownload");
   response.setHeader("Content-disposition", "attachment;filename="
     + new String(fileName.getBytes("gb2312"),"iso8859-1"));
  
   fis = new FileInputStream(file);
   os = response.getOutputStream();
   while((length=fis.read(bos))!=-1){
    os.write(bos, 0, length);
//    os.flush();
   }
  } catch (Exception e) {
   e.printStackTrace();
  }finally{
   try {
    if(os!=null)
     os.close();
    if(fis!=null)
     fis.close();
   } catch (Exception e) {
    e.printStackTrace();
   }
  }

 

 

 

 

 

注意:

1.response.setContentType("application/x-msdownload");

2.response.setHeader("Content-disposition", "attachment;filename="
     + new String(fileName.getBytes("gb2312"),"iso8859-1"));

 PS:解决下载中文乱码 fileName.getBytes("gb2312"),"iso8859-1")

3.待解决问题：选择图片下载时候点取消抛异常

 

----------------------------------------------------------------------------------------------
用commons.fileupload实现文件的上传和下载2008年04月11日 星期五 15:27commons.fileupload实现文件的上传，需要用到的组件如下：

1）Commons-fileupload-1.1.zip,下载地址为http://archive.apache.org/dist/jakarta/commons/fileupload/

2)commons-io-1.1.zip,下载地址为:http://archive.apache.org/dist/jakarta/commons/io/

代码如下：
<%!
//服务器端保存上传文件的路径
    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);
             }
         }
     }

1、拷贝pager-taglib.jar包
2、在JSP页面中使用taglib指令引入pager-taglib标签库
3、使用pager-taglib标签库进行分页处理

pg:pager【这个标签用来设置分页的总体参数】重要参数说明：
 url:分页的链接根地址，pager标签会在这个链接的基础上附加分页参数
 items:总记录数，pager标签正是根据这个值来计算分页参数的
 maxPageItems:每页显示的行数，默认为10
 maxIndexPages:在循环输出页码的时候，最大输出多少个页码，默认是10
 
pg:first【第一页的标签】重要参数说明：
 export变量的意义：
 pageUrl - 分页链接URL地址（最重要的export参数）
 pageNumber - 页码
 firstItem - 首页第一行的索引值
 lastItem - 首页最后一行的索引值
 
pg:pre【上一页标签】重要参数说明：
 export变量的意义：
 pageUrl - 分页链接URL地址（最重要的export参数）
 pageNumber - 页码
 firstItem - 前页第一行的索引值
 lastItem - 前页最后一行的索引值

pg:next【下一页标签】重要参数说明：
 export变量的意义：
 pageUrl - 分页链接URL地址（最重要的export参数）
 pageNumber - 页码
 firstItem - 下页第一行的索引值
 lastItem - 下页最后一行的索引值
 
pg:last重要参数说明：
 export变量的意义：
 pageUrl - 分页链接URL地址（最重要的export参数）
 pageNumber - 页码
 firstItem - 尾页第一行的索引值
 lastItem - 尾页最后一行的索引值
 
pg:pages【这个标签用来循环输出页码信息】重要参数说明：
 export变量的意义：
 pageUrl - 分页链接URL地址（最重要的export参数）
 pageNumber - 页码
 firstItem - pageNumber这个页码指定的那一页的第一行的索引值
 lastItem - pageNumber这个页码指定的那一页的最后一行的索引值

文件上传组件
1 Apache的Commons FileUpload
2 JavaZoom的UploadBean
3 jspSmartUpload
FileUpload下载网址：
http://commons.apache.org/fileupload/
步骤：
1 导入Apache的Commons FileUpload组件的两个jar包
2 建上传页面
<form action="servlet/upload" method="post" enctype="multipart/form-data" name="form1">
  上传人：<input type="text" name="username"/><br/>
  上传文件：<input type="file" name="loadname"/><br/>
  <input type="submit"/>
</form>
注意，form中enctype="multipart/form-data"属性为上传属性，必写
---------------------------------------------------------------------
3 建立servlet处理类
public class UploadServlet extends HttpServlet {
 private ServletContext sc;//ServletContext定义了一系列方法用于与相应的servlet容器通信
 private String savePath;

 public void init(ServletConfig config) throws ServletException {
  savePath = config.getInitParameter("savePath");//得到初始化信息
  sc = config.getServletContext();//得到ServletContext接口的实例
 }

 private static final long serialVersionUID = 7093971456528100363L;

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

 public void doPost(HttpServletRequest request, HttpServletResponse response)
   throws ServletException, IOException {
  request.setCharacterEncoding("UTF-8");
  DiskFileItemFactory factory = new DiskFileItemFactory();
  ServletFileUpload upload = new ServletFileUpload(factory);
  try {
   List items = upload.parseRequest(request);
   for (int i = 0; i < items.size(); i++) {
    FileItem item = (FileItem) items.get(i);
    if (item.isFormField()) {
     System.out.println("表单的参数名称：" + item.getFieldName()
       + ",对应的参数值：" + item.getString("UTF-8"));
    } else {
     if (item.getName() != null && !item.getName().equals("")) {
      System.out.println("上传文件的大小:" + item.getSize());
      System.out.println("上传文件的类型:" + item.getContentType());
      System.out.println("上传文件的名称:" + item.getName());

      File temFile = new File(item.getName());
      File file = new File(sc.getRealPath("/") + savePath,
        temFile.getName());
      item.write(file);

      request.setAttribute("upload.message", "上传文件成功！");
     } else {
      request.setAttribute("upload.message", "没有上传文件成功！");
     }
    }
   }
  } catch (Exception e) {
   e.printStackTrace();
   request.setAttribute("upload.message", "没有上传文件成功！");
  }
  request.getRequestDispatcher("/uploadresult.jsp").forward(request, response);
 }
}
-----------------------------------------------------------------------------------
4 配置web.xml
<servlet>
    <servlet-name>UploadServlet</servlet-name>
    <servlet-class>com.webs.UploadServlet</servlet-class>
    <init-param>
    <param-name>savePath</param-name>
    <param-value>uploads</param-value>
    </init-param>
  </servlet>

  <servlet-mapping>
    <servlet-name>UploadServlet</servlet-name>
    <url-pattern>/servlet/upload</url-pattern>
  </servlet-mapping>

-----------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
Apache的commons-fileupload.jar可方便的实现文件的上传功能，本文通过实例来介绍如何使用commons-fileupload.jar。
@author:ZJ 07-2-22
Blog: http://zhangjunhd.blog.51cto.com/
    将Apache的commons-fileupload.jar放在应用程序的WEB-INF\lib下，即可使用。下面举例介绍如何使用它的文件上传功能。
所使用的fileUpload版本为1.2，环境为Eclipse3.3+MyEclipse6.0。FileUpload 是基于 Commons IO的，所以在进入项目前先确定Commons IO的jar包（本文使用commons-io-1.3.2.jar）在WEB-INF\lib下。
此文作示例工程可在文章最后的附件中下载。
示例1
最简单的例子，通过ServletFileUpload静态类来解析Request，工厂类FileItemFactory会对mulipart类的表单中的所有字段进行处理，不只是file字段。getName（）得到文件名，getString（）得到表单数据内容，isFormField（）可判断是否为普通的表单项。
demo1.html
<html>
<head>
    <meta http-equiv="Content-Type" content="text/html; charset=GB18030">
    <title>File upload</title>
</head>
<body>
       //必须是multipart的表单数据。
    <form name="myform" action="demo1.jsp" method="post"
       enctype="multipart/form-data">
       Your name: <br>
       <input type="text" name="name" size="15"><br>
       File:<br>
       <input type="file" name="myfile"><br>
       <br>
       <input type="submit" name="submit" value="Commit">
    </form>
</body>
</html>

demo1.jsp
<%@ page language="java" contentType="text/html; charset=GB18030"
    pageEncoding="GB18030"%>
<%@ page import="org.apache.commons.fileupload.*"%>
<%@ page import="org.apache.commons.fileupload.servlet.*"%>
<%@ page import="org.apache.commons.fileupload.disk.*"%>
<%@ page import="java.util.*"%>

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<%
    boolean isMultipart = ServletFileUpload.isMultipartContent(request);//检查输入请求是否为multipart表单数据。
    if (isMultipart == true) {
       FileItemFactory factory = new DiskFileItemFactory();//为该请求创建一个DiskFileItemFactory对象，通过它来解析请求。执行解析后，所有的表单项目都保存在一个List中。
       ServletFileUpload upload = new ServletFileUpload(factory);
       List<FileItem> items = upload.parseRequest(request);
       Iterator<FileItem> itr = items.iterator();
       while (itr.hasNext()) {
           FileItem item = (FileItem) itr.next();
           //检查当前项目是普通表单项目还是上传文件。
           if (item.isFormField()) {//如果是普通表单项目，显示表单内容。
       String fieldName = item.getFieldName();
       if (fieldName.equals("name")) //对应demo1.html中type="text" name="name"
           out.print("the field name is" + item.getString());//显示表单内容。
       out.print("<br>");
           } else {//如果是上传文件，显示文件名。
       out.print("the upload file name is" + item.getName());
       out.print("<br>");
           }
       }
    } else {
       out.print("the enctype must be multipart/form-data");
    }
%>
<html>
<head>
    <meta http-equiv="Content-Type" content="text/html; charset=GB18030">
    <title>File upload</title>
</head>
<body>
</body>
</html>

结果：
the field name isjeff
the upload file name isD:\C语言考试样题\作业题.rar

示例2
上传两个文件到指定的目录。
demo2.html
<html>
<head>
    <meta http-equiv="Content-Type" content="text/html; charset=GB18030">
    <title>File upload</title>
</head>
<body>
    <form name="myform" action="demo2.jsp" method="post"
       enctype="multipart/form-data">
       File1:<br>
       <input type="file" name="myfile"><br>
       File2:<br>
       <input type="file" name="myfile"><br>
       <br>
       <input type="submit" name="submit" value="Commit">
    </form>
</body>
</html>

demo2.jsp
<%@ page language="java" contentType="text/html; charset=GB18030"
    pageEncoding="GB18030"%>
<%@ page import="org.apache.commons.fileupload.*"%>
<%@ page import="org.apache.commons.fileupload.servlet.*"%>
<%@ page import="org.apache.commons.fileupload.disk.*"%>
<%@ page import="java.util.*"%>
<%@ page import="java.io.*"%>

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<%String uploadPath="D:\\temp";
  boolean isMultipart = ServletFileUpload.isMultipartContent(request);
  if(isMultipart==true){
      try{
        FileItemFactory factory = new DiskFileItemFactory();
        ServletFileUpload upload = new ServletFileUpload(factory);
        List<FileItem> items = upload.parseRequest(request);//得到所有的文件
       Iterator<FileItem> itr = items.iterator();
        while(itr.hasNext()){//依次处理每个文件
         FileItem item=(FileItem)itr.next();
         String fileName=item.getName();//获得文件名，包括路径
         if(fileName!=null){
             File fullFile=new File(item.getName());
             File savedFile=new File(uploadPath,fullFile.getName());
             item.write(savedFile);
         }
        }
        out.print("upload succeed");
      }
      catch(Exception e){
         e.printStackTrace();
      }
  }
  else{
      out.println("the enctype must be multipart/form-data");
  }
%>
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=GB18030">
<title>File upload</title>
</head>
<body>
</body>
</html>

结果：
upload succeed

此时，在"D:\temp"下可以看到你上传的两个文件。
示例3
上传一个文件到指定的目录，并限定文件大小。
demo3.html
<html>
<head>
    <meta http-equiv="Content-Type" content="text/html; charset=GB18030">
    <title>File upload</title>
</head>
<body>
    <form name="myform" action="demo3.jsp" method="post"
       enctype="multipart/form-data">
       File:<br>
       <input type="file" name="myfile"><br>
       <br>
       <input type="submit" name="submit" value="Commit">
    </form>
</body>
</html>

demo3.jsp
<%@ page language="java" contentType="text/html; charset=GB18030"
    pageEncoding="GB18030"%>
<%@ page import="org.apache.commons.fileupload.*"%>
<%@ page import="org.apache.commons.fileupload.servlet.*"%>
<%@ page import="org.apache.commons.fileupload.disk.*"%>
<%@ page import="java.util.*"%>
<%@ page import="java.io.*"%>

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<%
    File uploadPath = new File("D:\\temp");//上传文件目录
    if (!uploadPath.exists()) {
       uploadPath.mkdirs();
    }
    // 临时文件目录
    File tempPathFile = new File("d:\\temp\\buffer\\");
    if (!tempPathFile.exists()) {
       tempPathFile.mkdirs();
    }
    try {
       // Create a factory for disk-based file items
       DiskFileItemFactory factory = new DiskFileItemFactory();

       // Set factory constraints
       factory.setSizeThreshold(4096); // 设置缓冲区大小，这里是4kb
       factory.setRepository(tempPathFile);//设置缓冲区目录

       // Create a new file upload handler
       ServletFileUpload upload = new ServletFileUpload(factory);

       // Set overall request size constraint
       upload.setSizeMax(4194304); // 设置最大文件尺寸，这里是4MB

       List<FileItem> items = upload.parseRequest(request);//得到所有的文件
       Iterator<FileItem> i = items.iterator();
       while (i.hasNext()) {
           FileItem fi = (FileItem) i.next();
           String fileName = fi.getName();
           if (fileName != null) {
       File fullFile = new File(fi.getName());
       File savedFile = new File(uploadPath, fullFile
              .getName());
       fi.write(savedFile);
           }
       }
       out.print("upload succeed");
    } catch (Exception e) {
       e.printStackTrace();
    }
%>
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=GB18030">
<title>File upload</title>
</head>
<body>
</body>
</html>

示例4
利用Servlet来实现文件上传。
Upload.java
package com.zj.sample;

import java.io.File;
import java.io.IOException;
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.disk.DiskFileItemFactory;
import org.apache.commons.fileupload.servlet.ServletFileUpload;

@SuppressWarnings("serial")
public class Upload extends HttpServlet {
    private String uploadPath = "D:\\temp"; // 上传文件的目录
    private String tempPath = "d:\\temp\\buffer\\"; // 临时文件目录
    File tempPathFile;

    @SuppressWarnings("unchecked")
    public void doPost(HttpServletRequest request, HttpServletResponse response)
           throws IOException, ServletException {
       try {
           // Create a factory for disk-based file items
           DiskFileItemFactory factory = new DiskFileItemFactory();

           // Set factory constraints
           factory.setSizeThreshold(4096); // 设置缓冲区大小，这里是4kb
           factory.setRepository(tempPathFile);// 设置缓冲区目录

           // Create a new file upload handler
           ServletFileUpload upload = new ServletFileUpload(factory);

           // Set overall request size constraint
           upload.setSizeMax(4194304); // 设置最大文件尺寸，这里是4MB

           List<FileItem> items = upload.parseRequest(request);// 得到所有的文件
           Iterator<FileItem> i = items.iterator();
           while (i.hasNext()) {
              FileItem fi = (FileItem) i.next();
              String fileName = fi.getName();
              if (fileName != null) {
                  File fullFile = new File(fi.getName());
                  File savedFile = new File(uploadPath, fullFile.getName());
                  fi.write(savedFile);
              }
           }
           System.out.print("upload succeed");
       } catch (Exception e) {
           // 可以跳转出错页面
           e.printStackTrace();
       }
    }

    public void init() throws ServletException {
       File uploadFile = new File(uploadPath);
       if (!uploadFile.exists()) {
           uploadFile.mkdirs();
       }
       File tempPathFile = new File(tempPath);
        if (!tempPathFile.exists()) {
           tempPathFile.mkdirs();
       }
    }
}

demo4.html
<html>
<head>
    <meta http-equiv="Content-Type" content="text/html; charset=GB18030">
    <title>File upload</title>
</head>
<body>
// action="fileupload"对应web.xml中<servlet-mapping>中<url-pattern>的设置.
    <form name="myform" action="fileupload" method="post"
       enctype="multipart/form-data">
       File:<br>
       <input type="file" name="myfile"><br>
       <br>
       <input type="submit" name="submit" value="Commit">
    </form>
</body>
</html>

web.xml
<servlet>
    <servlet-name>Upload</servlet-name>
    <servlet-class>com.zj.sample.Upload</servlet-class>
</servlet>

<servlet-mapping>
    <servlet-name>Upload</servlet-name>
    <url-pattern>/fileupload</url-pattern>
</servlet-mapping>

JavaMail下载与安装
http://java.sun.com/products/javamail/index.html
核心类与接口
javax.mail.Session
javax.mail.Message
javax.mail.Address
javax.mail.Authenticator
javax.mail.Transport
javax.mail.Store
javax.mail.Folder
-----------------------------------------------------
1 加载javamail的jar包
2 编写处理类
public class SendMail {
 public static void mian(String[] args){
  Properties props=new Properties();
  Session session=Session.getInstance(props,null);
  props.put("mail.host", "127.0.0.1");//接收邮件的地址
  props.put("mail.transport.protocol", "smtp");//传输邮件的协议
  
  Message message=new MimeMessage(session);
  try {
   message.setFrom(new InternetAddress("ywj_sh110@163.com"));//设定发件人
   message.setRecipient(Message.RecipientType.TO, new InternetAddress("ywj_316@163.com"));//设定收件人
   message.setSubject("你好吗？");//设标题
   message.setText("javamail发送邮件测试");//设内容
   Transport.send(message);//发送信息
  } catch (AddressException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  } catch (MessagingException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  }
 }
}
---------------------------------------------------
Apache Commons Email组件
1 加载javamail的jar包和Apache Commons Email的jar包
2 编写servlet的处理类
public class SendCommMail extends HttpServlet {
 public void doGet(HttpServletRequest request, HttpServletResponse response)
   throws ServletException, IOException {
  doPost(request,response);
 }
public void doPost(HttpServletRequest request, HttpServletResponse response)
   throws ServletException, IOException {
  request.setCharacterEncoding("UTF-8");
  SimpleEmail email=new SimpleEmail();//生成SimpleEmail对象
  email.setHostName("smtp.sina.com");//生成邮件
  email.setAuthentication("web08", "web2008");//建立用户
  email.setCharset("UTF-8");//邮件内容编码
  try {
   email.setFrom(request.getParameter("from"));//发件人
   email.addTo(request.getParameter("to"));//收件人
   email.setMsg(request.getParameter("context"));//内容
   email.send();//发送邮件
   request.setAttribute("sendmail.message", "邮件发送成功！");
  } catch (Exception e) {
   e.printStackTrace();
   request.setAttribute("sendmail.message", "邮件发送不成功！");
  }
  request.getRequestDispatcher("/sendResult.jsp").forward(request, response);
 }
}
3 配置web.xml文件
4 页面
----------------------------------------------------------------------
带附件的邮件
1 1 加载javamail的jar包，Apache Commons Email的jar包和fileUpLoad
2 2 编写servlet的处理类
public class SendCommMail extends HttpServlet {
 private ServletContext sc;//ServletContext定义了一系列方法用于与相应的servlet容器通信
 private String savePath;
 File file;
 private Map<String,String> parameters=new HashMap<String,String>();//存页面信息

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

 public void doPost(HttpServletRequest request, HttpServletResponse response)
   throws ServletException, IOException {
  request.setCharacterEncoding("UTF-8");
  file=this.doAtta(request);
  MultiPartEmail email=new MultiPartEmail();//生成SimpleEmail对象
  email.setHostName("smtp.163.com");//生成邮件
  email.setAuthentication("ywj_316", "1234567890");//建立用户
  email.setCharset("UTF-8");//邮件内容编码
  try {
   email.setFrom(parameters.get("from"));//发件人
   email.addTo(parameters.get("to"));//收件人
   email.setMsg(parameters.get("context"));//内容 
   email.setSubject(parameters.get("title"));//主题
   if(file!=null){
    EmailAttachment attachment=new EmailAttachment();//附什对象
    attachment.setPath(file.getParent());//附件路径
    attachment.setDescription(EmailAttachment.ATTACHMENT);//附件类型
    attachment.setName(file.getName());//附件名称
    email.attach(attachment);
   }
   System.out.println("ssssssssssssssssssssssssssssssssssss");
   email.send();//发送邮件
   request.setAttribute("sendmail.message", "邮件发送成功！");
  } catch (Exception e) {
   e.printStackTrace();
   request.setAttribute("sendmail.message", "邮件发送不成功！");
  }
  request.getRequestDispatcher("/sendResult.jsp").forward(request, response);
 }
 
 public File doAtta(HttpServletRequest request)throws ServletException,IOException{
  DiskFileItemFactory factory = new DiskFileItemFactory();
  ServletFileUpload upload = new ServletFileUpload(factory);
  try {
   List items = upload.parseRequest(request);
   for (int i = 0; i < items.size(); i++) {
    FileItem item = (FileItem) items.get(i);
    if (item.isFormField()) {
     parameters.put(item.getFieldName(), item.getString("UTF-8"));
     System.out.println(item.getFieldName());
     System.out.println(item.getString("UTF-8"));
    } else {
     if (item.getName() != null && !item.getName().equals("")) {
      File temFile = new File(item.getName());
      file = new File(sc.getRealPath("/") + savePath,
        temFile.getName());
      item.write(file);

      request.setAttribute("upload.message", "上传文件成功！");
     } else {
      request.setAttribute("upload.message", "没有上传文件成功！");
     }
    }
   }
  } catch (Exception e) {
   e.printStackTrace();
   request.setAttribute("upload.message", "没有上传文件成功！");
  }
  return file;
 }
 
 public void init(ServletConfig config) throws ServletException {
  savePath = config.getInitParameter("savePath");//得到初始化信息
  sc = config.getServletContext();//得到ServletContext接口的实例
 }
}
3 配置web.xml文件
 <servlet>
    <servlet-name>SendCommMail</servlet-name>
    <servlet-class>com.webs.SendCommMail</servlet-class>
      <init-param>
    <param-name>savePath</param-name>
    <param-value>uploads</param-value>
    </init-param>
  </servlet>
  <servlet-mapping>
    <servlet-name>SendCommMail</servlet-name>
    <url-pattern>/servlet/sendMail</url-pattern>
  </servlet-mapping>
4 页面
 <body>
    发送邮件的程序<br>
    <form action="servlet/sendMail" name="form1"  enctype="multipart/form-data" method="post">
     收件人：<input type="text" name="to"/><br>
    发件人：<input type="text" name="from"/><br>
    主题：<input type="text" name="title"/><br>
    附件：<input type="file" name="file"/><br>
    内容：<input type="text" name="context"/><br>
    <input type="submit"/>
    </form>
  </body>

序列化是把一个对象的状态写入一个字节流的过程，它执行RMI，RMI允许一台机器上的JAVA对象调用不同机器上的JAVA对象方法，对象可以作为参数提供给那个远程方法，发送机序列化该对象并传送它，接收机执行反序列化。
序列化和反序列化的关系图表可形成包含循环引用的顺序图表。这是整个序列化的总体思想。
而Serializable接口属于支持序列化的一个接口，只有一个实现它的对象可以被序列化工具存储和回复，Serializable接口没有定义任何成员，只用来表示一个累可以被序列化，若该类可以序列化，那么它的所有子类都可以。
下面是关于序列化的一个实例：
程序名称：SerializationDemo.java
程序主题：实现对象的序列化和反序列化
程序说明：该程序由实例化一个MyClass类的对象开始，该对象有三个实例变量，类型分别为String、int、double，是希望存储和恢复的信息。

 

import java.io.*;

public class SerializationDemo{
        public static void main(String args[]){

//Object serialization
try{
 MyClass object1=new MyClass("Hello",-7,2.7e10);
 System.out.println("object1:"+object1);
 FileOutputStream fos=new FileOutputStream("serial");
 ObjectOutputStream oos=new ObjectOutputStream(fos);
 oos.writeObject(object1);
 oos.flush();
 oos.close();
 }
catch(Exception e){
 System.out.println("Exception during serialization:"+e);
 System.exit(0);
 }

//Object deserialization
try{
 MyClass object2;
 FileInputStream fis=new FileInputStream("serial");
 ObjectInputStream ois=new ObjectInputStream(fis);
 object2=(MyClass)ois.readObject();
 ois.close();
 System.out.println("object2:"+object2);
 }
catch(Exception e){
 System.out.println("Exception during deserialization:"+e);
 System.exit(0);
 }
}
}

class MyClass implements Serializable{
 String s;
 int i;
 double d;
 public MyClass(String s,int i,double d){
  this.s=s;
  this.i=i;
  this.d=d;
 }
 public String toString(){
  return "s="+s+";i="+i+";d="+d;
 }
}

 

程序运行结果：object1和object2的实例变量是一样的，输出如下：
object1:s=Hello;i=-7;d=2.7E10
object2:s=Hello;i=-7;d=2.7E10

我补充一下：

Object serialization的定义：
Object serialization 允许你将实现了Serializable接口的对象转换为字节序列，这些字节序列可以被完全存储以备以后重新生成原来的对象。 

serialization不但可以在本机做，而且可以经由网络操作（就是猫小说的RMI）。这个好处是很大的----因为它自动屏蔽了操作系统的差异，字节顺序（用Unix下的c开发过网络编程的人应该知道这个概念，我就容易在这上面犯错）等。比如，在Window平台生成一个对象并序列化之，然后通过网络传到一台Unix机器上，然后可以在这台Unix机器上正确地重构这个对象。

Object serialization主要用来支持2种主要的特性：
1。Java的RMI(remote method invocation).RMI允许象在本机上一样操作远程机器上的对象。当发送消息给远程对象时，就需要用到serializaiton机制来发送参数和接收返回直。

2。Java的JavaBeans.   Bean的状态信息通常是在设计时配置的。Bean的状态信息必须被存起来，以便当程序运行时能恢复这些状态信息。这也需要serializaiton机制。

 

二。sakulagi和rollingpig说的持久化我也说一下。
我觉得你们说的应该是英文里的persistence.但是Java语言里现在只支持lightweight persistence,就是轻量级持久化，这是通过serialization机制来实现的。

persistence是指一个对象的生命周期不由程序是否执行来决定，即使是在程序终止时这个对象也存在。它把一个serializable的对象写到磁盘（本机或其他机器上的非RAM存储器），并在程序重新调用时再读取对象到通常的RAM存储器。

为什么说Java的serialization机制实现的是lightweight persistence?因为你必须显式的序列化和反序列化程序里的对象；而不是直接由一个关键词来定义一个对象是序列化的然后由系统做相应的处理。  如果以后的Java版本出现一个新的关键字来实现这种机制，比如就是persistence,如果我用

persistence  (String s="chinaunix")

然后系统自动做猫小程序里的那些处理，那么Java就实现了persistence.

public void synchronized getall(){}

java.lang.Thread

【创建新线程的方法有两种】

1 定义线程类实现Runnable接口
public class MyThred implements Runnable{
     @overwrite
     public void run(){}
}

起用线程：
MyThred myThred=new MyThred();
Thread t=new Thread(myThred);
t.start();

2 定义线程类继承Thread类并重写其run方法
public class MyThred extends Thread{
     @overwrite
     public void run(){}
}

起用线程：
MyThred myThred=new MyThred();
myThred.start();

说明：一般使用接口来实现
-------------------------------------------------
【线程状态转换】

【线程控制基本方法】：
isAlive() 判断线程是否还“活”着
getPriority() 获得线程的优先级
setPriority() 设置线程的优先级
Thread.sleep() 将当前线程睡眠指定的毫秒数
join()  调用某线程的该方法，将当前线程与该线程“合并”，即等待
        该线程线束，再恢复当前线程的运行。
yield() 让出CPU，当前线程进入就绪队列等待调度
wait() 当胶线程进入对象的wait pool。
notify()/notifyAll() 唤醒对象的wait pool中的一个/所有等待线程。
Thread.currentThread() 得到当前线程
----------------------------------------------------------------
【sleep/join/yield 方法】

sleep示例:
public class TestInterrupt {
  public static void main(String[] args) {
    MyThread thread = new MyThread();
    thread.start();
    //主线程睡眠
    try {Thread.sleep(10000);}
    catch (InterruptedException e) {}
    //停下当前线程，这个方法一般不建议使用
    thread.interrupt();
    //使用这个结束线程
    shutDown();
  }
}

class MyThread extends Thread {
 boolean flag = true;
  public void run(){
    while(flag){
      System.out.println("==="+new Date()+"===");
      try {
 //当前子线程睡眠
        sleep(1000);
 //sleep时被打断会抛InterruptedException
      } catch (InterruptedException e) {
        return;
      }
    }
  }
  //结束线程的方法
  public void shutDown(){
      flag = false;
  }
}

jion示例:
public class TestJoin {
  public static void main(String[] args) {
    MyThread2 t1 = new MyThread2("abcde");
    t1.start();
    try {
        //当前线程合并到主线程，相当于方法调用
     t1.join();
    } catch (InterruptedException e) {}
     
    for(int i=1;i<=10;i++){
      System.out.println("i am main thread");
    }
  }
}
class MyThread2 extends Thread {
  //给当前线程起个别名
  MyThread2(String s){
   super(s);
  }
 
  public void run(){
    for(int i =1;i<=10;i++){
      System.out.println("i am "+getName());
      try {
       sleep(1000);
      } catch (InterruptedException e) {
       return;
      }
    }
  }
}

yield示例:
public class TestYield {
  public static void main(String[] args) {
    //可以用同一个线程类创建不同的线程对象，分别执行
    MyThread3 t1 = new MyThread3("t1");
    MyThread3 t2 = new MyThread3("t2");
    t1.start(); t2.start();
  }
}
class MyThread3 extends Thread {
  MyThread3(String s){super(s);}
  public void run(){
    for(int i =1;i<=100;i++){
      System.out.println(getName()+": "+i);
      if(i%10==0){
 //让出时间给其它线程执行
        yield();
      }
    }
  }
}

--------------------------------------------------------------
【线程的优先级别】getPriority()/setProority(int newPriority)

线程的优先级用数字表示，范围从1到10，默认为5.
Thread.MIN_PRIORITY=1
Thread.MAX_PRIORITY=10
Thread.NORM_PRIORITY=5

示例：
public class TestPriority {
 public static void main(String[] args) {
  Thread t1 = new Thread(new T1());
  Thread t2 = new Thread(new T2());
  //将t1的优先级提高3级
  t1.setPriority(Thread.NORM_PRIORITY + 3);
  t1.start();
  t2.start();
 }
}

class T1 implements Runnable {
 public void run() {
  for(int i=0; i<1000; i++) {
   System.out.println("T1: " + i);
  }
 }
}

class T2 implements Runnable {
 public void run() {
  for(int i=0; i<1000; i++) {
   System.out.println("------T2: " + i);
  }
 }
}

--------------------------------------------------------------------
【线程的同步】未看完

生成jar包
jar -cvf test.jar *.*

*.*是指当前目录下所有文件打包到目标目录下

是否是该类或该类的子类类型的对象
instanceof
car instanceof Car

增加的for循环
int[] arr={1,2,4,5,6};
for(int i:arr){}//只用于显示，不可以访问i