TestServlet.java
// 文件路径 D:\ApacheServer\web_java\HelloWorld\src\com\test\TestServlet.java
package com.test;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;
import java.sql.SQLException;
import java.sql.PreparedStatement;
import java.text.SimpleDateFormat;
import javax.activation.DataHandler;
import javax.activation.DataSource;
import javax.activation.FileDataSource;
import javax.mail.BodyPart;
import javax.mail.Message;
import javax.mail.Multipart;
import javax.mail.Session;
import javax.mail.Transport;
import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimeBodyPart;
import javax.mail.internet.MimeMessage;
import javax.mail.internet.MimeMultipart;
import javax.servlet.ServletContext;
import javax.servlet.ServletException;
import javax.servlet.ServletOutputStream;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.Cookie;
import javax.servlet.http.HttpSession;
import org.apache.commons.fileupload.FileItem;
import org.apache.commons.fileupload.disk.DiskFileItemFactory;
import org.apache.commons.fileupload.servlet.ServletFileUpload;
import org.apache.commons.io.filefilter.SuffixFileFilter;
import org.apache.commons.fileupload.FileUploadException;
import java.util.Date;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Properties;
// 由于 web.xml 里配置的 url-pattern = /TomcatTest/TestServlet ，所以该 Servlet 浏览地址可以是 http://localhost:8080/TomcatTest/TestServlet
// 下面的注解 @WebServlet 功能和 web.xml 配置 url-pattern 类似，所以该 Servlet 浏览地址也可以是 http://localhost:8080/TestServlet
// 注解浏览地址和 web.xml 里配置的 url-pattern 地址不能一样，要么只配置其中一项(删除注解，或者删除web.xml中对应Servlet的<servlet-mapping>...</servlet-mapping>项)，要么两者配置地址不能相同
@WebServlet("/TestServlet")
public class TestServlet extends HttpServlet {
// 实际作用不明，暂时注释，无影响
//private static final long serialVersionUID = 1L;
public TestServlet() {
super();
}
public void init() throws ServletException {
// 创建 Servlet 时只执行一次的 init
}
public void destroy() {
// 销毁 Servlet 时只执行一次的 destroy
// destroy 方法被调用后，servlet 被销毁，但是并没有立即被回收，再次请求时，并没有重新初始化。
}
// post 请求会被 doPost 处理
protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
// 转移到 doGet 函数处理信息
doGet(request, response);
}
// get 请求会被 doGet 处理
protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
//response.getWriter().append("Served at1: ").append(request.getContextPath());
/*
// 配合测试异常处理 Servlet （这里是 TestErrorServlet ）捕获处理 web 容器抛出的异常
if(true) {
response.setContentType("text/html;charset=UTF-8");
throw new ServletException("这是测试异常信息");
}
*/
// ============================= response 响应 ============================================
// 设置返回响应内容类型及编码，否则返回输出中文会乱码
response.setContentType("text/html;charset=UTF-8");
// 添加一个自定义名称和值的响应报头。
response.setHeader("test_foo", "test_val");
// 响应返回任意错误响应状态码及信息（通常为404 或407等状态码），该设置会使页面直接显示错误页面
//response.sendError(404,"test response status");
// 返回任意响应状态码
//response.setStatus(200);
// 生成一个 302 响应，暂时性重定向到后面的网址
//response.sendRedirect("http://www.baidu.com");
// ============================= 请求的 HTTP 头信息 ============================================
// 获取打印客户端请求的 HTTP 头信息
Enumeration headerNames = request.getHeaderNames();
while(headerNames.hasMoreElements()) {
String paramName = (String)headerNames.nextElement();
String paramValue = request.getHeader(paramName);
response.getWriter().append("<br/>客户端请求的 HTTP 头信息 : " + paramName + " 值为 : " + paramValue);
}
// ============================= Servlet Cookie ============================================
// Servlet Cookie 处理需要对中文进行编码与解码，方法如下
String enStr = java.net.URLEncoder.encode("测试中文", "UTF-8"); // 编码
String deStr = java.net.URLDecoder.decode(enStr, "UTF-8"); // 解码
// 创建新 cookie 对象 并赋键值对，键值即该 cookie 名称，这里值赋中文值，需要先编码
Cookie cookie = new Cookie("testKey",enStr);
// 设置 cookie 适用的域名，例如 runoob.com
cookie.setDomain("runoob.com");
// 获取 cookie 适用的域，例如 runoob.com
cookie.getDomain();
// 设置 cookie 过期的时间（以传给客户端为起始，以秒为单位）。如果不设置，cookie 只会在当前 session 会话中持续有效。或者cookie.setMaxAge(0) 即表示删除这个cookie
cookie.setMaxAge(3600 * 24);
// 返回 cookie 的最大生存周期（以秒为单位），默认情况下，-1 表示 cookie 将持续下去，直到浏览器关闭。
cookie.getMaxAge();
// 返回 cookie 的名称。名称在创建后不能改变。
cookie.getName();
// 设置 cookie 的值，除了创建 cookie 对象时赋值，setValue() 方法也可赋值。赋的值非中文就不用转码了
cookie.setValue("newTestVal");
// 获取 cookie 的值
cookie.getValue();
// 设置 cookie 适用的路径uri。浏览器在发该 cookie 消息给服务器之前，请求的 url 中必须存在一个指定 uri 路径。这个比较是通过将 path 属性值与请求的 url 从头开始逐字符串比较完成的。如果字符匹配，则发送该 cookie 消息。如果不指定路径，与当前页面相同目录（uri）下的（包括子目录下的）所有 url 浏览器都会返回 cookie。
cookie.setPath("/testuri");
// 获取 cookie 适用的路径uri。
cookie.getPath();
// 设置布尔值，表示 cookie 是否应该只在加密的（即 SSL）连接上发送。
cookie.setSecure(false);
// 设置该 cookie 在浏览器中不能通过 Javascript 的 document.cookie 属性访问
cookie.setHttpOnly(true);
// 设置cookie的注释。该注释在浏览器向用户呈现 cookie 时非常有用。
cookie.setComment("testNotes");
// 获取 cookie 的注释，如果 cookie 没有注释则返回 null。
cookie.getComment();
// 输出 cookie值，中文的话需要解码
response.getWriter().append("<br/>cookie testKey 值为 : " + java.net.URLDecoder.decode(cookie.getValue(), "UTF-8"));
// 发送 Cookie 到 HTTP 响应头，即将 cookie 传到浏览器
response.addCookie(cookie);
// 获取览器发送的与当前页面 url 相关的 Cookie 的数组
Cookie request_cookie[] = request.getCookies();
if( request_cookie != null ){
// 遍历获取每一个浏览器发送的 cookie
for (int i = 0; i < request_cookie.length; i++){
cookie = request_cookie[i];
// 对比找到指定名称的 cookie
if((cookie.getName( )).compareTo("delCookieName") == 0 ){
// 然后删除
cookie.setMaxAge(0);
response.addCookie(cookie);
}else {
response.getWriter().append("<br/>浏览器上传 cookie 名称 : " + cookie.getName() + " 值为 : " + cookie.getValue());
}
}
}else{
response.getWriter().append("<br/>No Cookie founds");
}
// ============================= Servlet Session ============================================
// 获取当前请求的 session 会话，需要在向客户端发送任何文档内容之前调用 request.getSession()。
// getSession() 等同于 getSession(true) 若存在会话，则返回该会话，否则新建一个会话。getSession(false) 则是如存在会话，则返回该会话，否则返回NULL
HttpSession session = request.getSession();
//下面总结了 HttpSession 对象中可用的几个重要的方法：
// 指定键名绑定一个对象到该 session 会话，绑定的对象可以是任意类型的对象包括字符串
Object anyObject = new Object();
session.setAttribute("testKey", anyObject);
// 获取 session 中指定键名的数据值，如果没有指定该键名对则返回 null，之前赋的键值无论何类型，getAttribute 方法返回的都是 Object 类型，使用时需要强制类型
Object val = session.getAttribute("testKey");
// 从该 session 会话移除指键名称及对应对象。
session.removeAttribute("testKey");
// 以枚举方式获取 session 中所有设置绑定的键名
Enumeration sessionEnumeration = session.getAttributeNames();
// 获取 session id
String sessionId = session.getId();
// 返回该 session 创建的时间戳，单位毫秒，创建完不一定已经回传给客户端。
long sessionBegin = session.getCreationTime();
// 判断该对话是否是第一次建立，即客户端还未保存 session id，或者客户选择不参入该 session 会话，则该方法返回 true
boolean isNew = session.isNew();
// 返回该 session 客户端最后一次请求到服务器的时间戳，单位毫秒
long sessionEnd = session.getLastAccessedTime();
// 设定 session 在用户请求间隔多少秒内不失效
session.setMaxInactiveInterval(360);
// 返回 Servlet 容器 session 在用户请求间隔多少秒内不失效
int interval = session.getMaxInactiveInterval();
// 使该 session 会话无效，并解除绑定到它上面的任何对象。
//session.invalidate();
// 输出相关信息
// session 创建时间
Date createTime = new Date(sessionBegin);
// 该网页的最后一次访问时间
Date lastAccessTime = new Date(sessionEnd);
//设置日期输出的格式
SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
// 设置键值
String testStr = "";
int testInt = 0;
if(session.getAttribute("key_str") == null) {
testStr = "this is test str";
session.setAttribute("key_str", testStr);
}else {
testStr = (String)session.getAttribute("key_str");
}
if(session.getAttribute("key_int") == null) {
testInt = 0;
session.setAttribute("key_int", testInt);
}else {
testInt = (int)session.getAttribute("key_int") + 1;
session.setAttribute("key_int", testInt);
}
response.getWriter().append("<br/>用户最后一次请求时间为 : " + dateFormat.format(lastAccessTime));
response.getWriter().append("<br/>session key_str 键对应值为 : " + testStr);
response.getWriter().append("<br/>session testInt 键对应值为 : " + testInt);
/*
// ============================= 下载文件 ============================================
// 最好放在 response 所有输出之前调用
this.download(response);
// 为禁止再向浏览器发送其他输出流
if(true) return;
*/
// ============================= 连接 MySql ============================================
this.conn_mysql(response);
// ============================= 日期处理 ============================================
doDate(response);
// ============================= 网页重定向 ============================================
// 浏览器重新请求的新地址，URL会变
String location = "https://www.baidu.com" ;
// 方法一
//response.sendRedirect(location);
// 方法二
//response.setStatus(response.SC_MOVED_TEMPORARILY);
//response.setHeader("Location", location);
// ============================= 自动刷新页面 ============================================
// 设置自动刷新间隔为 5 秒
//response.setIntHeader("Refresh", 5);
// ============================= 发送邮件 ============================================
sendMail(request, response);
// 获取 form-data 类型 post 数据依赖于 FileUpload，下载地址 http://commons.apache.org/proper/commons-fileupload/ 这里用到的是 FileUpload 1.4 选择 Binaries->commons-fileupload-1.4-bin.zip
// FileUpload 依赖于 Commons IO，下载地址 http://commons.apache.org/proper/commons-io/ 这里用到的是 Commons IO 2.6 选择 Binaries->commons-io-2.6-bin.zip
// 将下载的压缩包内的 commons-io-2.6.jar 和 commons-fileupload-1.4.jar 解压缩到 D:\ApacheServer\web_java\HelloWorld\WebContent\WEB-INF\lib 中。环境变量 CLASSPATH 补充 ";D:\ApacheServer\web_java\HelloWorld\WebContent\WEB-INF\lib\commons-io-2.6.jar;D:\ApacheServer\web_java\HelloWorld\WebContent\WEB-INF\lib\commons-fileupload-1.4.jar;" 。eclipse->Java Build Path 中分别引入 commons-io-2.6.jar 与 commons-fileupload-1.4.jar
// 检测是 GET 和 x-www-form-urlencode POST 还是 multipart/form-data POST 方式
if (!ServletFileUpload.isMultipartContent(request)) {
// 提交的表单类型为GET 或者 x-www-form-urlencoded 方式的 POST
getOrFormUrlencoded(request, response);
}else {
// 提交的表单类型为 multipart/form-data 的 POST
formData(request, response);
}
}
// 自建方法，文件下载
public void download(HttpServletResponse response){
try{
// 要下载的文件名，必须是服务器上存在的文件，eclipse 实际运行项目路径需要找找
// 这里实际目录为 D:/ApacheServer/web_java/.metadata/.plugins/org.eclipse.wst.server.core/tmp0/wtpwebapps/HelloWorld/upload/00125943U-0.jpg
String fileName = "00125943U-0.jpg";
// 文件下载到客户端时文件名
String downName = "download.jpg";
// 设置文件 MIME 类型，getServletContext()为父类方法
response.setContentType(this.getServletContext().getMimeType(fileName));
// 设置 Content-Disposition 响应报头，命名下载文件名称
response.setHeader("Content-Disposition"," attachment;filename=" + downName);
ServletContext context = this.getServletContext();
// 根据文件在项目中的路径获取文件的完整绝对路径，这里 upload 文件夹为项目根目录下，与 WEB-INF 文件夹同级父目录下
String fullFileName = context.getRealPath("/upload/" + fileName);
// 把文件读入到内存输入流中
InputStream inputStream = new FileInputStream(fullFileName);
// 创建输出流对象
ServletOutputStream outputStream = response.getOutputStream();
// 每次从输入流实际读取到的字节数
int len = 0;
// 定义一个字节数组,相当于缓存，数组长度为1024，即缓存大小为1024个字节
byte[] cache = new byte[1024];
// inputStream.read(cache)) 方法，从输入流中读取最多 cache 数组大小的字节，并将其存储在 cache 中。以整数形式返回实际读取的字节数，当文件读完时返回-1
while((len = inputStream.read(cache)) != -1){
// 每次把数组 cache 从 0 到 len 长度的内容输出到浏览器
outputStream.write(cache, 0, len);
}
// 关闭流
inputStream.close();
outputStream.close();
}catch(Exception exception) {
// 处理 Class.forName 错误
exception.printStackTrace();
}
}
// 自建方法，连接 MySQL 数据库
public void conn_mysql(HttpServletResponse response) {
// 需要下载 MySQL 驱动 jar 包，下载地址 https://mvnrepository.com/artifact/mysql/mysql-connector-java，这里用到的是 mysql-connector-java-8.0.17.jar，下载的 jar 包 要放在 Tomcat 安装目录下的 lib 文件夹内，这里路径是 D:\ApacheServer\apache-tomcat\lib\mysql-connector-java-8.0.17.jar
// 连接 MySQL 需要 MySQL 的时区和 java 一致（MySQL 默认 UTC 时区），这里本地是北京时区。修改 MySQL 配置文件 my.ini 在 [mysqld] 项下添加一行 default-time-zone = '+8:00' 重启 MySQL 即可。如果不能修改MySQL配置文件，则将如下 jdbc:mysql://localhost:3306/testdb 改为 jdbc:mysql://localhost:3306/testdb?serverTimezone=UTC 亦可
try{
// 注册 JDBC 驱动器
// 如果下载的 MySQL jar 包是 5 系列版本，则需要用 com.mysql.jdbc.Driver 注册驱动，而且必须写
//Class.forName("com.mysql.jdbc.Driver");
// MySQL jar包 6 以上版本用 com.mysql.cj.jdbc.Driver 注册，或者不写也可，这里没有写，已注释掉
//Class.forName("com.mysql.cj.jdbc.Driver");
// 打开一个连接
Connection conn = null;
// localhost 为数据库连接地址，3306 端口号,testDB 为数据库名称
String db_host = "jdbc:mysql://localhost:3306/testdb";
// 用户名
String user = "root";
// 密码
String password = "123456";
conn = DriverManager.getConnection(db_host,user,password);
// ==================================================== Statement 类处理
// Statement 对象执行查询 SQL 语句
Statement statement = conn.createStatement();
String sql_sel = "SELECT id, name, age FROM test_table";
ResultSet result = statement.executeQuery(sql_sel);
//遍历结果集
int i = 1;
while(result.next()){
int id = result.getInt("id");
String name = result.getString("name");
int age = result.getInt("age");
response.getWriter().append("<br/>第 " + i + "行 id : " + id + " name : " + name + " age : " + age);
i++;
}
// ==================================================== PreparedStatement 类处理
// PreparedStatement 执行插入语句效果更好，原因：1可以写动态参数化的查询，2PreparedStatement比 Statement 更快，3PreparedStatement可以防止SQL注入式攻击
// preparedStatement对象的 executeUpdate() 方法可执行 insert，update，delete 语句以及 SQL DDL（如建表，改表，删除表等）， executeQuery() 方法执行select语句，execute()执行所有语句，效率也最慢
// ============================ executeUpdate 方法
//编写预处理 SQL 语句
String sql_ins= "INSERT INTO `test_table`(id, name, age) VALUES(?, ?, ?)";
PreparedStatement preparedStatement = conn.prepareStatement(sql_ins);
preparedStatement.setInt(1, 3); //插入表数据的 id
preparedStatement.setString(2, "testName"); // 名称
preparedStatement.setInt(3, 40); // 年龄
// 返回值是一个整数，指示受影响的行数（即更新计数）建表，删表等不操作行的语句总返回 0。
int updateCount = preparedStatement.executeUpdate();
response.getWriter().append("<br/> 插入结果 " + updateCount);
// ============================ executeQuery 方法
// 执行 select 语句
preparedStatement = conn.prepareStatement(sql_sel);
// 获取查询结果，result 遍历查询结果与之前 Statement 类方式一致
result = preparedStatement.executeQuery();
// ============================ execute 方法
preparedStatement = conn.prepareStatement(sql_sel);
// execute 可用于执行任何SQL语，返回一个 boolean 值，如果执行后第一个结果（有可能返回的是多个结果集合）是 ResultSet（即查询语句结果），则返回 true，否则返回 false。
boolean isResult = preparedStatement.execute();
// 如果 execute() 执行的 sql 语句能返回多个结果集合时，PreparedStatement 对象获取下个 getResultSet() 或者 getUpdateCount() 前要先执行 getMoreResults() 使指针下移，然后再执行 getResultSet() 或 getUpdateCount() 获取当前指针指向结果
//preparedStatement.getMoreResults(); // 一至多个结果集时，获取第一个结果时不需要执行此语句，获取下一个结果时才执行，如在 while 循环语句里用
if(isResult) {
// 如果结果集当前指针指向的返回结果是个 select 查询结果，用 getResultSet 获取，如果执行的是更新语句，则返回的是更新计数，这时就要用 getUpdateCount来获取
result = preparedStatement.getResultSet();
// ...
}else {
//当某个过程返回两个更新计数，则首先调用方法getUpdateCount()
updateCount = preparedStatement.getUpdateCount();
response.getWriter().append("<br/> 插入结果 " + updateCount);
}
// 完成后关闭
preparedStatement.close();
result.close();
statement.close();
conn.close();
}catch(SQLException sqlException) {
// 处理 JDBC 错误
sqlException.printStackTrace();
}catch(Exception exception) {
// 处理 Class.forName 错误
exception.printStackTrace();
}
}
// 自建方法，处理日期
public void doDate(HttpServletResponse response) throws ServletException, IOException {
Date date = null;
// 构造函数初始化当前日期和时间的对象
date = new Date();
// 或者构造指定日期时间的对象。参数为毫秒时间戳，示例时间为 2019/8/18 16:12:56
date = new Date(1566115976000L);
// date 对应的时间戳大于 after() 的参数所对应时间戳则返回 true，否则返回 false。这里返回 false
if(date.after(new Date())) {
response.getWriter().append("<br/> date对应时间大于 after 参数对应时间");
}else {
response.getWriter().append("<br/> date对应时间小于 after 参数对应时间");
}
// 判断方式与 date.after() 相反
boolean isBefore = date.before(new Date());
// 克隆一个时间对象，但返回值类型为 Object
Object objDate = date.clone();
// 如果两个 date 对象时间戳相等，返回0，如果 date 大于 compareTo() 里参数的时间，则返回正数，否则返回负数，这里结果为 -1
int compare = date.compareTo(new Date());
response.getWriter().append("<br/> 对比时间结果为 : " + compare);
// 两日期对象对应时间戳相等返回 true，否则返回 false，这里返回 true
boolean equals = date.equals(new Date(1566115976000L));
// 获取当前 date 对应时间戳
long stampLong = date.getTime();
response.getWriter().append("<br/> 当前 date 时间戳为 : " + stampLong);
// 返回该日期对象的哈希码值
int hashCode = date.hashCode();
// 设置 date 对象对应的时间戳
date.setTime(1566119343000L);
// 将 date 对象转换为字符串，这里返回为 Sun Aug 18 17:09:03 CST 2019
String strDate = date.toString();
response.getWriter().append("<br/> 当前 date 字符串为 : " + strDate);
// 创建日期格式化对象，y 年，M 月，d 月中第几日，H 小时（24制），h 小时（12制）， m 分，s 秒，S 毫秒，E 星期几，D 年中第几日，F 月中第几周，w 年中第几周，W 月中的第几周，a 上午下午，k 天中第几小时,K 带有 A.M./P.M. 的小时（0~11），z 时区
SimpleDateFormat dateFormat = new SimpleDateFormat ("yyyy-MM-dd HH:mm:ss");
String strFormat = dateFormat.format(date);
// 这里输出日期为 2019-08-18 17:09:03
response.getWriter().append("<br/> 格式化后时间为 : " + strFormat);
}
// 自建方法，发送邮件
public void sendMail(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
// 需要先下载 javax.mail.jar 和 activation.jar。只发文字邮件 javax.mail.jar 就够了，发附件则还需要 activation.jar
// mail.jar 下载地址 https://www.oracle.com/technetwork/java/javamail/index.html 点击 Downloads 下载 JavaMail API 1.4.7，或者 https://javaee.github.io/javamail/ 下载 JavaMail 1.6.2 这里版本是 JavaMail 1.6.2
// jaf 下载页面 https://www.oracle.com/technetwork/java/javasebusiness/downloads/java-archive-downloads-java-plat-419418.html 这里用到版本 JavaBeans Activation Framework 1.1.1
// 提取下载的压缩包里的 javax.mail.jar 和 activation.jar 放到项目中
// 收件人的电子邮件 ID
String to = "32705317@qq.com";
// 发件人的电子邮件 ID
String from = "zdy_521@126.com";
// SMTP服务器地址
String host = "smtp.126.com";
// 授权密码
String passWord = "87477zhang";
// 设置邮件发送相关属性
Properties properties = System.getProperties();
// 设置邮件传输采用的协议smtp（这里使用网易的smtp服务器）
properties.setProperty("mail.transport.protocol", "smtp");
//设置发送邮件的邮件服务器的属性
properties.setProperty("mail.smtp.host", host);
//需要经过授权，也就是有户名和密码的校验，这样才能通过验证（一定要有这一条）
properties.setProperty("mail.smtp.auth", "true");
// SMTP 服务器的端口 (非 SSL 连接的端口一般默认为 25, 可以不添加, 如果开启了 SSL 连接,
// 需要改为对应邮箱的 SMTP 服务器的端口, 具体可查看对应邮箱服务的帮助,
// QQ邮箱的SMTP(SLL)端口为465或587, 其他邮箱自行去查看)
/*
final String smtpPort = "465";
properties.setProperty("mail.smtp.port", smtpPort);
properties.setProperty("mail.smtp.socketFactory.class", "javax.net.ssl.SSLSocketFactory");
properties.setProperty("mail.smtp.socketFactory.fallback", "false");
properties.setProperty("mail.smtp.socketFactory.port", smtpPort);
*/
// 获取默认的 Session 对象
Session session = Session.getDefaultInstance(properties);
// 会话采用debug模式
session.setDebug(true);
try {
// 创建邮件对象
MimeMessage message = new MimeMessage(session);
// 设置发送邮件地址,param1 代表发送地址 param2 代表发送的名称(任意的) param3 代表名称编码方式
message.setFrom(new InternetAddress(from, "发件人名称", "utf-8"));
// 代表收件人
message.setRecipient(Message.RecipientType.TO, new InternetAddress(to, "收件人名称", "utf-8"));
// To: 增加更多收件人（可选）
//message.addRecipient(MimeMessage.RecipientType.TO, new InternetAddress("chimuhuadao@126.com", "收件人名称", "UTF-8"));
//message.addRecipient(MimeMessage.RecipientType.TO, new InternetAddress("chimuhuadao@163.com", "收件人名称", "UTF-8"));
// Cc: 抄送（可选）
//message.setRecipient(MimeMessage.RecipientType.CC, new InternetAddress("chimuhuadao@126.com", "抄送人名称", "UTF-8"));
// Bcc: 密送（可选）
//message.setRecipient(MimeMessage.RecipientType.BCC, new InternetAddress("chimuhuadao@126.com", "密送人名称", "UTF-8"));
// 设置邮件主题
message.setSubject("测试转发邮件");
//====================附件测试开始=================
//以下部分为测试邮件附件，如不需要可以把整段附件这部分代码注释
// 创建 Multipart 对象，来包含邮件的多部分（正文，附件等）消息
Multipart multipart = new MimeMultipart();
// 第一部分正文消息部分
BodyPart bodyPart = new MimeBodyPart();
// 设置邮件正文内容
bodyPart.setContent("<h1>早安,世界</h1>", "text/html;charset=utf-8");
// 将正文消息部分添加到 Multipart 对象中
multipart.addBodyPart(bodyPart);
// 第二部分是附件
bodyPart = new MimeBodyPart();
// 读取项目根目录下 upload 文件夹内 00125943U-0.jpg 文件作为附件，这里路径为 D:\ApacheServer\web_java\HelloWorld\WebContent\\upload\00125943U-0.jpg。这里WebContent为实际项目运行根目录
String fileName = "00125943U-0.jpg";
String filePath = request.getServletContext().getRealPath("./") + "upload" + File.separator + fileName;
DataSource dataSource = new FileDataSource(filePath);
bodyPart.setDataHandler(new DataHandler(dataSource));
// 设置邮件中附件名称
bodyPart.setFileName("testAttachment.jpg");
// 将附件部分添加到 Multipart 对象中
multipart.addBodyPart(bodyPart);
//response.getWriter().append(filePath);if(true)return;
// 另一份附件，可发送多个附件
bodyPart = new MimeBodyPart();
// 读取项目根目录下 upload 文件夹内 00125943U-0.jpg 文件作为附件
fileName = "abc.ppt";
filePath = request.getServletContext().getRealPath("./") + "upload" + File.separator + fileName;
dataSource = new FileDataSource(filePath);
bodyPart.setDataHandler(new DataHandler(dataSource));
// 设置邮件中附件名称
bodyPart.setFileName("testAttachment.ppt");
// 将附件部分添加到 Multipart 对象中
multipart.addBodyPart(bodyPart);
//和下面发送文本的 message.setContent("<h1>早安,世界</h1>", "text/html;charset=utf-8"); 二选一执行
message.setContent(multipart);
//====================附件测试结束=================
// 设置邮件内容，可以带HTML标签，也可以不带，内容大小不限
//message.setContent("<h1>早安,世界</h1>", "text/html;charset=utf-8");
// 设置发送时间
message.setSentDate(new Date());
// 保存上面的编辑内容
message.saveChanges();
Transport transport = session.getTransport();
// 链接邮件服务器
transport.connect(from, passWord);
// 发送信息
transport.sendMessage(message, message.getAllRecipients());
// 关闭链接
transport.close();
}catch(Exception exception) {
// 处理错误
exception.printStackTrace();
}
}
// 自建方法，用来处理 GET URL 或 application/x-www-form-urlencoded 方式的 POST
protected void getOrFormUrlencoded(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException{
// getParameter，getParameterNames 只能获取 get 参数（POST 请求里也能用 getParameter 获取 GET 参数）或者编码格式为 application/x-www-form-urlencoded 的 post 数据，无法获取 multipart/form-data 的 post 数据
// application/x-www-form-urlencoded 传的 post 数据实际和 get 方式一样，都是格式化成 参数1=值1&参数2=值2&参数3=值3&... ，区别是 get 参数在 url 中，post 参数在请求体里。
String name_val = request.getParameter("name");
response.getWriter().append("<br/>表单名 : name 单一值为 : " + name_val);
// getParameterNames() 方法获取所有提交的表单参数名。该方法返回一个枚举对象，包含未指定顺序的参数名
Enumeration paramNames = request.getParameterNames();
// hasMoreElements() 循环遍历判断该枚举是否有更多元素，指针每次往后移一位
while(paramNames.hasMoreElements()) {
// nextElement() 每次获取该枚举一个元素，指针每次往后移一位
String paramName = (String)paramNames.nextElement();
// 根据参数名获取对应参数值，但不知道该参数名对应单个值还是多个值（复选框即是多个表单同名，不同值，与PHP不同JAVA相同复选框名后面不用加中括号 [] ），所以用数组接收
String paramValues[] = request.getParameterValues(paramName);
// 读取参数值的数据
if (paramValues.length == 1) { // 该参数名对应单一参数值
// 参数值为 paramValues[0]
String paramValue = paramValues[0];
if (paramValue.length() > 0) { // 判断该参数值有实际字符串内容
response.getWriter().append("<br/>表单名 : " + paramName + "单一值为 : " + paramValue);
}
} else {
// 读取多个值的数据
for(int i=0; i < paramValues.length; i++) {
// 值为 paramValues[i]
response.getWriter().append("<br/>多重参数名 : " + paramName + "多重id值 : "+i+"为 : " + paramValues[i]);
}
}
}
}
// 自建方法，用来处理 multipart/form-data 方式的 POST，若不想方法名后面跟 throws 抛出异常，则需在方法内执行有可能抛出异常的语句时有 try catch 捕获异常
protected void formData(HttpServletRequest request, HttpServletResponse response){
try {
// 创建磁盘文件项目工厂（form-data方式POST获取参数必须用的不管有无上传文件），可设置限制上传文件的临时存储目录等
DiskFileItemFactory factory = new DiskFileItemFactory();
// 可有可无，setSizeThreshold方法判断post数据（包括上传文件及表单数据）的大小（以字节为单位的int值，大于该值则post数据以临时文件形式存在磁盘，小于等于此值则存在内存中），如果从没有调用该方法设置此临界值，将会采用系统默认值10KB。对应的getSizeThreshold() 方法用来获取此临界值。
//factory.setSizeThreshold(1024 * 1024 * 3); // 3MB
// 可有可无，设置当上传数据大于 setSizeThreshold 设置的值时，临时文件在磁盘上的存放目录。当从没有此方法设置临时文件存储目录时，采用系统默认的临时文件路径 Tomcat 系统默认临时目录为 tomcat安装目录/temp/，默认的临时文件路径可通过 System.getProperty("java.io.tmpdir");查看
//factory.setRepository(new File(System.getProperty("java.io.tmpdir")));
// 通过文件工厂对象创建上传对象，可设置 post 文件最大上传大小，请求数据最大值（包含文件和表单数据）等
ServletFileUpload upload = new ServletFileUpload(factory);
// 可有可无，设置上传的单个文件的最大字节数为100M
//upload.setFileSizeMax(1024 * 1024 * 100);
// 可有可无，设置整个表单的最大字节数为1G (包含文件和表单数据)
//upload.setSizeMax(1024 * 1024 * 1024);
// 可有可无，中文处理，解决上传数据的中文乱码
//upload.setHeaderEncoding("UTF-8");
// 构造路径存储上传的文件，request.getServletContext().getRealPath("./") 获取的路径 为 WEB-INF 文件夹父级目录，即项目根目录路径，这里路径为 D:\ApacheServer\web_java\HelloWorld\WebContent\\upload\00125943U-0.jpg。这里WebContent为实际项目运行根目录
String uploadPath = request.getServletContext().getRealPath("./") + "upload";
// 如果目录不存在则创建，目录同样只能一级一级创建，不能一次创建多级
File uploadDir = new File( uploadPath );
if (!uploadDir.exists()) {
uploadDir.mkdir();
}
// List类传泛型 FileItem 则其创建对象内元素都变为 FileItem 类型
// 将用户请求传给设置好参数的上传对象，返回一个数组
List<FileItem> item_list = upload.parseRequest(request);
// 创建 param_map 保存提交表单的键值对
Map param_map = new HashMap();
// 假设有未知个数同表单名的复选框表单提交信息，用 testCheckBox 存该复选框选中的值
Map testCheckBox = new HashMap();
if (item_list != null && item_list.size() > 0) {
// 遍历上传的表单元素
for(FileItem fileItem : item_list){
// fileItem.getFieldName() 表单参数名
String fieldName = fileItem.getFieldName();
// fileItem.getString("UTF-8") 获取表单参数的值，或者上传文件的文本内容
String fieldVal = fileItem.getString("UTF-8"); // 如果页面编码是 UTF-8 的
// 处理在表单中的字段
if (fileItem.isFormField()) {
response.getWriter().append("<br/>表单参数名 : " + fieldName + " 参数值为 : " + fieldVal);
// 当表单名为 testCheckBox 时，将其不确定个数的多个值存到 Map 对象中
if(fieldName.equals("testCheckBox")) {
testCheckBox.put(testCheckBox.size(), fieldVal);
}
// 把post参数以键值对形式重新存到 param_map 列表中。复选框的话最后一个选中的同名值会覆盖之前的值
param_map.put(fieldName, fieldVal);
}
// 处理表单中上传文件，这里上传文件的表单名任意都可上传
if (!fileItem.isFormField()) {
// ===============上传文件
// 获取上传的文件名（含扩展名），fileItem.getName()只能获取上传文件的完整名，不能获取其他post表单参数值
String fileName = fileItem.getName();
// 拼接将文件保存本地完整路径及文件+扩展名。File.separator 表示目录分割斜杠
String filePath = uploadPath + File.separator + fileName;
// 将合成的完整路径文件名 filePath 放入 File 对象中，File 对象代表磁盘中实际存在的文件和目录
File saveFile = new File(filePath);
// 限制上传文件扩展名
String suffix_limit[] = {".html", ".jpg", ".jsp"};
SuffixFileFilter filter = new SuffixFileFilter(suffix_limit);
boolean flag = filter.accept(saveFile);
if(!flag) {
response.getWriter().append("<br/>上传文件类型不符，文件名为 : " + fileName);
return;
}
// 将该上传文件按指定路径保存文件到硬盘
fileItem.write(saveFile);
request.setAttribute("message", "文件上传成功!");
}
}
}
// 可以使用 param_map.get 获取表单参数值了
String name_val = (String) param_map.get("name");
response.getWriter().append("<br/>表单name的值 : " + name_val);
// 遍历获取复选框的 Map 对象里每个值
for(int i = 0;i<testCheckBox.size();i++) {
response.getWriter().append("<br/>复选框i : " + i + "对应值 : " + (String) testCheckBox.get(i));
}
} catch (FileUploadException fex) {
fex.printStackTrace();
} catch (Exception ex) {
request.setAttribute("message", "错误信息: " + ex.getMessage());
}
}
}
TestFilter.java
// 文件路径 D:\ApacheServer\web_java\HelloWorld\src\com\test\TestFilter.java
package com.test;
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.annotation.WebFilter;
// 浏览器暂不能通过 http://localhost:8080/HelloWorld/TestFilter 访问页面
@WebFilter("/TestFilter")
//实现 Filter 类
public class TestFilter implements Filter {
public TestFilter() {
}
// Servlet容器在销毁 Filter 实例前调用该方法，在该方法中释放 Filter 实例占用的资源。
public void destroy() {
// TODO Auto-generated method stub
}
// 该方法完成实际的过滤操作，当客户端请求过滤器设置的 URL 时，Servlet 容器将先调用过滤器的 doFilter 方法。FilterChain 用户访问后续过滤器。
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
// 这里的 request 和 response 对象与 Servlet 类中一样可获取用户请求信息及直接返回响应信息
// pass the request along the filter chain
// 把请求传回过滤链
chain.doFilter(request, response);
}
// web 容器启动时，web 服务器将创建 Filter 的实例对象，并调用其 init 方法，读取 web.xml 配置，完成对象的初始化功能，从而为后续的用户请求作好拦截的准备工作（ filter 对象只会创建一次，init 方法也只会执行一次）。开发人员通过 init 方法的参数，可获得代表当前 filter 配置信息的 FilterConfig 对象。
public void init(FilterConfig fConfig) throws ServletException {
// 获取初始化参数
String testParam = fConfig.getInitParameter("testParam");
// 输出初始化参数
System.out.println("web.xml 配置 测试参数 testParam 值为 : " + testParam);
}
}
// Console 信息界面会出现 web.xml 配置 测试参数 testParam 值为 : 测试配置参数值 信息
TestErrorServlet.java
// 文件路径 D:\ApacheServer\web_java\HelloWorld\src\com\test\TestErrorServlet.java
package com.test;
import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
@WebServlet("/TestErrorServlet")
public class TestErrorServlet extends HttpServlet {
private static final long serialVersionUID = 1L;
public TestErrorServlet() {
super();
}
protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
//response.getWriter().append("Served at: ").append(request.getContextPath());
// javax.servlet.error.status_code 该属性给出状态码，状态码可被存储，并在存储为 java.lang.Integer 数据类型后可被分析
Integer statusCode = (Integer) request.getAttribute("javax.servlet.error.status_code");
// javax.servlet.error.request_uri 该属性给出报错页面的请求地址，可被存储，并在存储为 java.lang.String 数据类型后可被分析
String requestUri = (String) request.getAttribute("javax.servlet.error.request_uri");
// javax.servlet.error.message 该属性给出确切错误消息信息，信息可被存储，并在存储为 java.lang.String 数据类型后可被分析
String message = (String) request.getAttribute("javax.servlet.error.message");
// javax.servlet.error.servlet_name 该属性给出报错的 Servlet 类名，可被存储，并在存储为 java.lang.String 数据类型后可被分析
String servletName = (String) request.getAttribute("javax.servlet.error.servlet_name");
// javax.servlet.error.exception_type 该属性给出异常的类型，异常类型可被存储，并在存储为 java.lang.Class 数据类型后可被分析
Object exceptionType = request.getAttribute("javax.servlet.error.exception_type");
// javax.servlet.error.exception 该属性给出异常的相关信息，信息可被存储，并在存储为 java.lang.Throwable 数据类型后可被分析
Throwable exception = (Throwable) request.getAttribute("javax.servlet.error.exception");
// 设置返回响应内容类型及编码
response.setContentType("text/html;charset=UTF-8");
// 以下项是抛出异常或报 404 等错误码时均有返回信息
response.getWriter().append("<br/> 访问报错 Servlet 页面返回的错误码 : " + statusCode + " 这里显示内容为 404 或 500 ");
response.getWriter().append("<br/> 访问报错 Servlet 页面的请求地址 : " + requestUri + " 这里显示内容为 /HelloWorld/TomcatTest/TestServlet ");
response.getWriter().append("<br/> 访问报错 Servlet 页面返回的错误信息 : " + message + " 404 错误时这里显示内容为 test response status 异常错误时显示内容为 这是测试异常信息");
response.getWriter().append("<br/> 访问报错 Servlet 页面返回的报错的 Servlet 类名 : " + servletName + " 这里显示内容为 TestServlet ");
// 以下项是只有抛出异常才有值，报 404 等错误码时无返回值
response.getWriter().append("<br/> 访问报错 Servlet 页面返回的异常类型 : " + exceptionType.toString() + " 这里显示内容为 class javax.servlet.ServletException ");
response.getWriter().append("<br/> 访问报错 Servlet 页面返回的异常类型 : " + exception.getClass().getName() + " 这里显示内容为 class javax.servlet.ServletException ");
response.getWriter().append("<br/> 访问报错 Servlet 页面返回的异常信息 : " + exception.getMessage() + " 这里显示内容为 这是测试异常信息 ");
}
protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
doGet(request, response);
}
}
web.xml
<?xml version="1.0" encoding="UTF-8"?>
<!-- 文件路径 D:\ApacheServer\web_java\HelloWorld\WebContent\WEB-INF\web.xml -->
<web-app version="2.5" xmlns="http://java.sun.com/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">
<!-- 注册一个过滤器 -->
<filter>
<!-- 注册一个过滤器名称 -->
<filter-name>TestFilter</filter-name>
<!-- 该注册名对应的实际 Filter 类的完整的包及类名 -->
<filter-class>com.test.TestFilter</filter-class>
<!-- 为过滤器指定初始化参数，它的子元素 <param-name> 指定参数的名字，<param-value> 指定参数的值 -->
<init-param>
<param-name>testParam</param-name>
<param-value>测试配置参数值</param-value>
</init-param>
</filter>
<!-- 方便测试，再注册一个 filter -->
<filter>
<filter-name>TestFilter2</filter-name>
<filter-class>com.test.TestFilter</filter-class>
<init-param>
<param-name>testParam2</param-name>
<param-value>测试配置参数值2</param-value>
</init-param>
</filter>
<!-- web.xml 中的 filter-mapping 元素的顺序决定了某个请求时 Web 容器调用 filter 的顺序 -->
<!-- <filter-mapping> 元素用于设置一个 Filter 所负责拦截的资源。一个 Filter 拦截的资源可通过两种方式来指定：资源访问的请求路径和 Servlet 名称 -->
<filter-mapping>
<!-- 设置负责此次过滤功能的 Filter 的注册名称即该值必须是在<filter>元素中声明过的过滤器的名字 -->
<filter-name>TestFilter</filter-name>
<!-- 设置该 Filter 所拦截的请求路径。此处的 /* 表示该过滤器适用于所有的 Servlet和请求路径 -->
<url-pattern>/*</url-pattern>
<!-- 也可以指定特定的 Servlet 注册名，在访问指定 Servlet 上应用该过滤器 -->
<servlet-name>TestServlet</servlet-name>
<!-- dispatcher 访问指定资源时，调用该过滤器的条件，可以是 REQUEST，,INCLUDE，,FORWARD 和 ERROR 之一，默认 REQUEST。用户可以设置一个或多个 <dispatcher> 子元素用来指定 Filter 对资源的多种调用方式进行拦截。该参数可不写 -->
<dispatcher>REQUEST</dispatcher> <!-- 当用户直接访问时，Web 容器将会调用过滤器。如果目标资源是通过 RequestDispatcher 的 include() 或 forward() 方法访问时，那么该过滤器就不会被调用 -->
<dispatcher>INCLUDE</dispatcher> <!-- 如果目标资源是通过 RequestDispatcher 的 include() 方法访问时，那么该过滤器将被调用。除此之外，该过滤器不会被调用 -->
<dispatcher>FORWARD</dispatcher> <!-- 如果目标资源是通过 RequestDispatcher 的 forward() 方法访问时，那么该过滤器将被调用，除此之外，该过滤器不会被调用 -->
<dispatcher>ERROR</dispatcher> <!-- 如果目标资源是通过声明式异常处理机制调用时，那么该过滤器将被调用。除此之外，过滤器不会被调用 -->
</filter-mapping>
<!-- 如果拦截的请求相同，则先执行上一个 filter-mapping 中指定的 Filter -->
<filter-mapping>
<filter-name>TestFilter2</filter-name>
<url-pattern>/TomcatTest/TestServlet</url-pattern>
</filter-mapping>
<servlet>
<!-- Servlet 在此 xml 里的注册名 -->
<servlet-name>TestServlet</servlet-name>
<!-- 该注册名对应的实际 Servlet 类的完整包名类名 -->
<servlet-class>com.test.TestServlet</servlet-class>
</servlet>
<servlet-mapping>
<!-- 指定一个 Servlet 注册名 -->
<servlet-name>TestServlet</servlet-name>
<!-- 外部访问的网址 -->
<url-pattern>/TomcatTest/TestServlet</url-pattern>
</servlet-mapping>
<servlet>
<servlet-name>TestErrorServlet</servlet-name>
<servlet-class>com.test.TestErrorServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>TestErrorServlet</servlet-name>
<url-pattern>/TomcatTest/TestErrorServlet</url-pattern>
</servlet-mapping>
<!-- 当请求的路径报错时指定一个 Servlet 来处理及返回相应信息，但用户请求的 url 未重定向跳转 -->
<error-page>
<!-- 当客户端请求 web 容器返回指定错误状态代码时（示例是404，也可是403等）调用指定的 Servlet 页面 -->
<error-code>404</error-code>
<location>/TomcatTest/TestErrorServlet</location>
</error-page>
<error-page>
<!-- 当客户端请求 web 容器抛出异常时调用指定的 Servlet 页面，示例的 java.lang.Throwable 对应所有web容器抛出的异常，也可换成 javax.servlet.ServletException 或 java.io.IOException 等抛出指定异常时才调用设置的 Servlet 页面 -->
<exception-type>java.lang.Throwable</exception-type >
<location>/TomcatTest/TestErrorServlet</location>
</error-page>
<!-- 设置 session 超时时间，单位分钟，该设置将覆盖 Tomcat 默认的 30 分钟超时时间 -->
<session-config>
<session-timeout>15</session-timeout>
</session-config>
</web-app>