Servlet-JSP相关

EL表达式
EL 全名为Expression Language ， EL表达式语言
目的:
使用EL 和 JSTL 取代jsp中的脚本 --> jsp页面中没有java代码（底层还需要执行相应的java代码）
作用:
获得域中的数据
执行运算
获得web开发常用对象
调用java对象方法
格式：${el表达式}
注意：如果数据不存在，将返回空字符串""
EL内置对象(11个)
作用域：pageScope 、requestScope、sessionScope、applicationScope
示例:${requestScope.属性名}
注意:如果没有显示说明从哪个作用域取,则底层调用pageContext.findAttribute(name)方法.从小到大取
JSP上下文对象：pageContext
示例:<%((HttpServletRequest)pageContext.getRequest()).getContextPath()%>
el:${pageContext.request.contextPath}
请求参数：
param.name      --> request.getParameter(name)
paramValues.name    -->request.getParameterValues(name)
请求头信息：
header.name     --> request.getHeader(name)
headerValues.name   --> request.getHeaders(name)
获得cookie ： cookie
获得指定cookie名称的值：${cookie.cookie名称.value}
web项目的初始化参数：
initParam.name --> servletContext.getInitParameter(name)
4000
访问集合
访问List中的元素: list[0]
访问Map中的元素: map.key 或 map['key']
运算符
算术运算符 + - / % (5/2=2.5)
关系运算符 == != < <= > >=  (可以用对应英文缩写表示 eq ne lt le gt ge)
逻辑运算符 && || !  (非也可以用not)
其他
empty 表示是否为空 (null , "" , size()==0)  ${empty 变量名}
${表达式 ? true : false}    三目运算符
注意
访问属性eWaiJiFen时,要写 对象.EWaiJiFen

自定义标签库(了解)
概述
在jsp中书写自定义标签,在生成java代码时要被指定java代码替换,底层还是java代码
要关联自定义标签和替换的java代码,需要有配置文件(tld文件)
步骤
编写实现类
传统标签：必须实现Tag接口  --> 继承实现类 TagSupport ，如果需要标签体 继承BodyTagSupport (了解)
简单标签：必须实现SimpleTag接口 --> 继承实现类 SimpleTagSupport(源码tomcat中有)
编写配置文件 tld
使用
引入标签库 taglib
使用：<前缀:标签名称>
tld文件
标签库描述符(taglib description)
tld文件基于xml文件 ，扩展名为tld，但内容是xml
存放位置
1 WEB-INF目录下，但classes和lib目录除外
2 WEB-INF/lib目录下的jar文件中的META-INF目录下
tomcat将自动加载tld文件
示例(自定义foreach标签,用来遍历集合)
编写实现类
package tagImpl;
import java.io.IOException;
import java.util.ArrayList;
import javax.servlet.jsp.JspException;
import javax.servlet.jsp.PageContext;
import javax.servlet.jsp.tagext.SimpleTagSupport;
public class MyTagImpl extends SimpleTagSupport{
//页面的属性必须对应一个set方法
ArrayList<String> list;
String item;
public void setList(ArrayList<String> list){
this.list=list;
}
public void setItem(String item){
this.item=item;
}
public void doTag() throws JspException,IOException{
PageContext page=(PageContext)this.getJspContext();
for(String str : list){
page.setAttribute(item, str);//存入page作用域,方便页面取出
this.getJspBody().invoke(page.getOut());//把标签体中的内容输出到浏览器
}
}
}
编写tld文件(位置:WEB-INF目录,名称任意)
<?xml version="1.0" encoding="UTF-8" ?>
<taglib 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-jsptaglibrary_2_1.xsd" version="2.1">
<!-- 版本 -->
<tlib-version>1.0</tlib-version>
<!-- 建议前缀 -->
<short-name>s</short-name>
<!-- 引用此文件的标识 -->
<uri>http://localhost:8080/demo/tagImpl/MyTagImpl</uri>

<!-- 定义标签 -->
<tag>
<!-- 标签名称 -->
<name>foreach</name>
<!-- 标签的实现类 -->
<tag-class>tagImpl.MyTagImpl</tag-class>
<!-- 标签体
取值:
JSP:不会用
empty:空,没有标签体
scriptless:支持EL表达式,不支持jsp脚本
tagdependent:不会用
-->
<body-content>scriptless</body-content>
<!-- 标签的属性 -->
<attribute>
<!-- 属性名称 -->
<name>list</name>
<!-- 是否是必须的 -->
<required>true</required>
<!-- 是否支持运行时表达式(EL) -->
<rtexprvalue>true</rtexprvalue>
</attribute>
<attribute>
<!-- 属性名称 -->
<name>item</name>
<!-- 是否是必须的 -->
<required>true</required>
<!-- 是否支持运行时表达式(EL) -->
<rtexprvalue>true</rtexprvalue>
</attribute>
</tag>
</taglib>
使用
在页面引用标签库
<%@ taglib uri="http://localhost:8080/demo/tagImpl/MyTagImpl" prefix="s"%>
在页面使用标签
<s:foreach list="${list}" item="i">
${i}<br>
</s:foreach>
自定义标签细节（其实是自定义标签的生命周期）
1 父类SimpleTagSupport会缓存PageContext对象。可以PageContext page=(PageContext)this.getJspContext();获取jsp上下文对象
2 通过标签的属性attribute进行数据的传递，实现类需要提供相应的属性property的setter方法接受传递的数据
3 缓存了标签体，类型是JspFragment(代码片段)，可以通过this.getJspBody()获得标签体.
可以执行invoke将标签体的内容输出到指定流中this.getJspBody().invoke(page.getOut());如果invoke参数为null,则默认输出到浏览器
4 doTag()方法,定义自定义标签功能的方法
如果在doTag标签体中，throw new SkipPageException(),表示当前标签执行之后，页面之后的内容将不输出。

自定义函数库(了解)
概述
在jsp中使用 ${fn:函数名(参数...)} 执行固定的java方法完成操作
要关联固定的java代码,需要有配置文件(tld文件)
示例
编写自定义类,类中编写要调用的方法,必须是静态的,例:
package function;
public class MyFunction {
public static String join(String i,String j){
return i + "/" + j;
}
}
编写tld文件(位置:WEB-INF目录,名称任意)
<?xml version="1.0" encoding="UTF-8" ?>
<taglib xmlns="http://java.sun.com/xml/ns/j2ee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-jsptaglibrary_2_0.xsd" version="2.0">

<tlib-version>1.0</tlib-version>
<short-name>myfn</short-name>
<uri>http://localhost:8080/myFunctionTag/myFunction</uri>
<function>
<!-- 使用时的名称 -->
<name>join</name>
<!-- 对应的类 -->
<function-class>function.MyFunction</function-class>
<!-- 函数签名 -->
<function-signature>java.lang.String join(java.lang.String ,java.lang.String)</function-signature>
</function>
</taglib>
使用
引入标签库
<%@ taglib uri="http://localhost:8080/myFunctionTag/myFunction" prefix="myfn" %>
调用
${myfn:join("q","w")}

JSTL
JavaServer Pages Standard Tag Library， JSP标准标签库。
第三方实现apache
导入jar包(/jstl/)
jstl.jar            --> myeclipse自动添加的jar名称javax.servlet.jsp.jstl.jar
standard.jar        --> myeclipse自动添加的jar名称jstl-impl.jar
注意：myeclipse已经提供了相应的jar，并在将web项目发布到tomcat时，自动的将两个jar添加到web/WEB-INF/lib目录中
JSTL提供5种 标签库
核心库 ： http://java.sun.com/jsp/jstl/core ，默认前缀：c
函数库 ： http://java.sun.com/jsp/jstl/functions ，默认前缀：fn
国际化标签库,数据库标签库,XML标签库
核心库
先引入标签库
<%@taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
域操作
<c:set> 给指定作用域设置属性
var         属性的名称
value       属性的值
scope       作用域(page/request/session/application)
例:<c:set var="名称" value="值" scope="page"></c:set>
<c:remove/> 移除属性
var         要移除的属性的名称
scope       作用域,默认移除所有域中的指定名称的数据(page/request/session/application)
例:<c:remove var="username" />
<c:out> 向页面输出内容(可以进行html或js转义)
value       要输出的内容,支持EL表达式
escapeXml   是否进行标签内容转义(如:html代码在页面中原样输出,还是解析为html代码)默认为true
例:<c:out value="${username}"></c:out>
逻辑操作
<c:if> 相当于java中的if
test        判断条件
例:<c:if test="${empty username}">如果是真则输出</c:if>
注意:没有<c:else>
<c:choose> 相当于java中的switch
test        条件
子标签<c:when> 相当于java中的case
子标签<c:otherwise> 相当于java中的default
例:
<c:choose>
<c:when test="${param.num<10}">
num小于10
</c:when>
<c:when test="${param.num<20}">
num大于等于10且小于20
</c:when>
<c:otherwise>
num大于等于20
</c:otherwise>
</c:choose>
循环操作
<c:forEach> 循环
items       需要遍历的数据,支持EL表达式
var         循环时每一项数据存放的变量名称,可以从域中获取当前项.只能在标签体内使用
begin       循环初始值
end         循环结束值
例:
遍历集合或数组
<c:forEach items="${list}" var="obj">
${obj} <br/>
</c:forEach>
遍历Map
<c:forEach items="${map}" var="entry">
${entry.key} --> ${entry.value} <br/>
</c:forEach>
指定范围的循环
<c:forEach begin="1" end="9" var="i">
${i} <br/>
</c:forEach>
注:访问对象的属性,就是调用对象的get方法
其它常用操作
<c:url> 将url添加项目名称后添加到域中
var         添加域中的属性的名称
value       要添加到域中的url
子标签<c:param> 给url后添加参数,此标签在<c:url>标签体中使用
name        参数名称
value       参数值,可以自动进行中文编码(base64)
例:
<c:url var="oneURL" value="/oneServlet">
<c:param name="username" value="sss"></c:param>
</c:url>
<c:redirect> 重定向
url     要重定向的url,特别注意:当以/开头时不需要加项目名称
例:<c:redirect url="/index.jsp"></c:redirect>
函数库
先引入标签库
<%@ taglib uri="http://java.sun.com/jsp/jstl/functions" prefix="fn" %>
用法:
${fn:函数名(参数...)}
包含了一下处理字符串的常用方法

JSP模式
模式1 ： JSP + JavaBean
小型项目，开发速度快。不好处扩展差，不易维护
模式2 ： JSP + Servlet + JavaBean (推荐)
模式2 基于MVC思想

MVC设计模式
MVC 软件设计模式，思想：一种分离业务逻辑与显示界面的设计方法 （业务逻辑 与 显示页面 相分离）
模块
Model模型 ， 负责管理程序的业务数据
View视图 ，负责显示界面
Controller控制器 ，负责与用户进行交互（接收请求和选择响应视图）

经典三层体系架构
在程序业务更加复杂的时候,会将Controller控制层继续划分为三层.
表示层(web层)
业务逻辑层(service层)
数据访问层(dao层)

监听器Listener
servlet 三种技术 : servlet,listener(监听器),filter(过滤器)
web提供8接口，分别对ServletContext、HttpSession、ServletRequest 对象自身、属性(域)进行监听
域对象自身(3个)
ServletContextListener ，对ServletContext对象进行监听 (对象创建，与对象销毁)
HttpSessionListener ，对HttpSession对象进行监听 (对象创建，与对象销毁)
ServletRequestListener ，对ServletRequest对象进行监听 (对象创建，与对象销毁)
以上三个监听器，都提供了事件对象 xxxEvent,获得被监听对象。
需要在web.xml文件中进行注册。tomcat自动触发响应的方法。
域内容(对象属性)(3个)
ServletContextAttributeListener  对ServletContext属性进行监听 (属性添加，移除，替换)
HttpSessionAttributeListener 对HttpSession属性进行监听  (属性添加，移除，替换)
ServletRequestAttributeListener 对ServletRequest属性进行监听 (属性添加，移除，替换)
需要在web.xml文件中进行注册。tomcat自动触发响应的方法。
session中javabean(2个)
HttpSessionBindingListener ： 对实现此接口的javabean在session域中的状态进行监听(绑定状态)
valueBound(HttpSessionBindingEvent event) ，当javabean对象添加到session属性触发此方法 (绑定)
void valueUnbound(HttpSessionBindingEvent event) ，当javabean对象从session属性移除时，触发此方法 (取消绑定)
应该以被监听的javaBean继承此接口,并且不需要再web.xml中注册
HttpSessionActivationListener ： 对实现此接口的javabean在session域中的状态进行监听(持久化状态)
void sessionDidActivate(HttpSessionEvent se) ，在服务器启动时，如果已经钝化了javabean，则将javabean重新加载进内存。(活化 ：硬盘 --> 内存 )
void sessionWillPassivate(HttpSessionEvent se) ，如果javabean在session中，当服务器正常关闭时，进行持久化此对象。(钝化 ： 内存 --> 硬盘)
钝化时数据保持位置：%tomcat%\work\Catalina\localhost\day14_listener\SESSIONS.ser
应该以被监听的javaBean继承此接口,并且不需要在web.xml中注册
javabean必须实现java.io.Serial
13c7b
izable接口
注册监听器(web.xml)
<listener>
<listener-class>类的完全限定名</listener-class>
</listener>
HttpSessionAttributeListener 和 HttpSessionBindingListener 区别：
HttpSessionAttributeListener ，对所有javabean生效
HttpSessionBindingListener ，对实现了此接口javabean生效
对同一件事的监听角度不同,一个从session角度进行监听,一个从javaBean角度进行监听

国际化(i18n)
程序的界面可以支持多国语言。 internationalization ，i18n
国际化资源文件
文件名称：baseName_语言_国家|地区.properties
baseName,基名,自定义
后面的语言和国家不能乱写,可参见IE浏览器的internet选项-->常规-->语言 中的选项
例如：
message_zh_CN.properties ,简体中文
message_zh_TW.properties ,繁体中文
message_en.properties ,英语
message.properties ,默认配置文件
默认位置:src，ResourcBundle.getBundle("baseName");
Locale 对象表示了特定的地理、政治和文化地区
Locale(String language, String country) 指定 语言，国家|地区
例如 new Locale("zh", "CN")
使用时
文本
ResourceBundle.getBundle("message" ,request.getLocale()); 对资源文件进行解析，可以指定 Locale对象设置不同的语言
getString("usernameMsg") 获得指定名称的对象
数字
数字 NumberFormat.getNumberInstance(request.getLocale()).format(double)
百分比 NumberFormat.getPercentInstance(request.getLocale()).format(double)
货币 NumberFormat.getCurrencyInstance(request.getLocale()).format(double)
日期时间
DateFormat.getDateTimeInstance ,处理日期时间
DateFormat.getDateInstance  处理日期
DateFormat.getTimeInstance  处理时间
样式：FULL 、LONG 、MEDIUM (默认) 、 SHORT
消息格式化
MessageFormat.format ，将字符串中{n}进行内容自动的填充。
示例
在src下添加message_zh_CN.properties
usernameMsg=用户名
passwordMsg=密码
在src下添加message_en.properties
usernameMsg=username
passwordMsg=password
jsp页面
<%
ResourceBundle bundle = ResourcBundle.getBundle("message",request.getLocale());
%>
<%=bundle.getString("usernameMsg") %> : <input name="username"/> <br/>
<%=bundle.getString("passwordMsg") %> : <input type="password" name="password"/>
在IE浏览器的internet选项-->常规-->语言 中选择不同的语言,则网页显示效果不同

过滤器Filter
对tomcat的请求会优先由过滤器进行处理
编写流程
1 编写实现类 ，实现Filter接口 (javax.servlet.Fitler)
2 在web.xml配置
格式
<filter>
<filter-name>随便起个名,注意不要重复,一般为类名</filter-name>
<filter-class>实现类的全限定名称</filter-class>
</filter>
<filter-mapping>
<filter-name>上面的filter-name</filter-name>
<url-pattern>/*</url-pattern>
<!-- <dispatcher>request</dispatcher> -->
</filter-mapping>
注意
<url-pattern>和servlet的<url-pattern>用法相同,可参加<Servlet访问路径配置>
url-pattern和dispatcher标签可以有多个

Filter接口(javax.servlet)
所有过滤器需要实现的父接口
方法
void init(FilterConfig filterConfig) 初始化
void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) 过滤到请求时执行的方法
void destroy() 销毁
注意 chain.doFilter(request,response);为放行

过滤器的生命周期
init ，初始化
时间：tomcat启动时。只要注册了过滤器，则tomcat就进行实例化
参数：
FilterConfig，当前过滤器配置对象
getFilterName() ，获得过滤器配置的名称<filter-name>的值
getInitParameter(java.lang.String name) 获得指定名称，过滤器初始化参数的值
getInitParameterNames() 获得所有的初始化参数的名称
getServletContext() 获得servlet的上下文对象
doFilter ，过滤执行
时间：接收到请求时。
参数：
FilterChain对象 过滤器链对象
服务器tomcat将所有符合要求的过滤器生成了一个链。
过滤器使用 FilterChain 调用链中的下一个过滤器，如果调用的过滤器是链中的最后一个过滤器，则调用链末尾的资源。
方法
void doFilter(ServletRequest request, ServletResponse response) 放行
注意：
过滤器链中的所有过滤器的顺序，取决于web.xml配置文件<filter-mapping>配置顺序
tomcat6.0 web.xml文件中<filter> 必须在<filter-mapping>之前
destroy，销毁
时间：服务器正常关闭时

配置Filter的初始化参数
在web.xml中<filter>中的<filter-class>后添加<init-param>
例:
<filter>
<filter-name>
<filter-class>
<init-param>
<param-name>参数名</param-name>
<param-value>参数值</param-value>
</init-param>
</filter>

dispatcher标签(过滤器的过滤类型)
位置：<filter-mapping>中的末尾
作用：设置当前过滤器的过滤类型
取值：
REQUEST，request ： 对请求进行过滤(默认)
FORWARD，forward ： 在进行请求转发时进行过滤
INCLUDE，include ： 在进行包含操作时进行过滤
ERROR，error ： 当页面出现错误，执行友好页面(web.xml <error-page>)时进行过滤
ASYNC，async ：异步，Servlet3.0提供，用servlet3.0新技术异步时进行过滤。
注意
取值为FORWARD,INCLUDE,ERROR时,url-pattern应该写要转发到的页面或要包含的页面的url
当取值为ERROR时,可以不能看到自定义的错误页面,而是浏览器的错误页面.可在过滤器放行前将状态码设置为200(先强转).例:response.setStatus(200);

过滤器案例
处理中文乱码(post)
添加过滤器,<url-pattern>为/*
在过滤器的doFilter方法放行前设置
request.setCharacterEncoding("utf-8");
response.setContentType("text/html;charset=UTF-8");
设置图片缓存时间
http响应提供三个头，进行页面缓存设置
pragma ： no-cache
cache-control ： no-cache
expires ： 0
添加过滤器,<url-pattern>为*.jpg
在过滤器的doFilter方法放行前设置
response.setDateHeader("expires",System.currentTimeMillis() + 60 * 60 * 1000 * 24 * 30L); //一个月,加L是为了防止溢出

处理中文乱码工具类
思想:
对request的getParameter和getParameterMap方法进行增强,在其中处理get中文乱码.然后将增强后的自定义request对象传递给servlet
tomcat提供了HttpServletRequestWrapper作为HttpServletRequest接口的装饰类,无任何增强的方法,供编程人员使用
代码:
package filter;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.util.HashMap;
import java.util.Map;
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.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;
import javax.servlet.http.HttpServletResponse;
public class EncodingFilter implements Filter {
public void init(FilterConfig filterConfig) throws ServletException {

}
public void doFilter(ServletRequest req, ServletResponse res,
FilterChain chain) throws IOException, ServletException {
//强转
HttpServletRequest request = (HttpServletRequest) req;
HttpServletResponse response = (HttpServletResponse) res;
//处理post请求乱码
request.setCharacterEncoding("utf-8");
//实例化自己的类(装饰者模式,增强了request的getParameter和getParameterMap方法,处理get请求乱码)
MyRequest myRequest = new MyRequest(request);
//放行
chain.doFilter(myRequest, response);//传递自己的类对象
}
public void destroy() {

}
}
/**
* 自定义的用于增强tomcat的request对象的类
* @author Administrator
* HttpServletRequestWrapper为HttpServletRequest接口的装饰类,不过无任何增强的方法,供编程人员使用
*/
class MyRequest extends HttpServletRequestWrapper{
public MyRequest(HttpServletRequest request) {
super(request);//父类缓存起来了
}
//增强方法
public String getParameter(String name){
//获取原来的值
String value = super.getParameter(name);
if(value == null){
return null;
}
//对get请求乱码问题处理
if(super.getMethod().equalsIgnoreCase("get")){
//get请求
try {
value = new String(value.getBytes("ISO8859-1"),super.getRequest().getCharacterEncoding());
} catch (UnsupportedEncodingException e) {
throw new RuntimeException(e);
}
}
return value;
}
public Map<String, String[]> getParameterMap(){
Map<String,String[]> map = super.getParameterMap();
try {
if(super.getMethod().equalsIgnoreCase("get")){
Map<String,String[]> map2 = new HashMap<String,String[]>();
for(String key : map.keySet()){
String[] value = map.get(key);
for(int i=0;i<value.length;i++){
value[i] = new String(value[i].getBytes("ISO8859-1"),super.getCharacterEncoding());
}
map2.put(key, value);
}
map = map2;
}
} catch (Exception e) {
e.printStackTrace();
}
return map;
}
}
web.xml配置
<filter>
<filter-name>EncodingFilter</filter-name>
<filter-class>filter.EncodingFilter</filter-class>
</filter>
<filter-mapping>
<filter-name>EncodingFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>

页面静态化
原因
每次请求会查询数据库,动态生成静态网页,速度很慢.对于一些固定的或访问量很大,很少更新的页面,可以使用静态页面
思想
首次访问Servlet将数据保存为静态html页面(而不是发送到浏览器),然后将html页面发送到浏览器.以后的访问不用查询数据库,直接返回第一次访问生成的html页面
Servlet(JSP)的响应内容默认通过request.getWriter方法输出到浏览器,增强response的getWriter方法修改目标输出位置
tomcat提供了HttpServletResponseWrapper作为Response接口的装饰类,无任何增强的方法,供编程人员使用
代码
package web.filter;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
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.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpServletResponseWrapper;
public class PageStaticFilter implements Filter {
public void init(FilterConfig filterConfig) throws ServletException {

}
public void doFilter(ServletRequest req, ServletResponse res,
FilterChain chain) throws IOException, ServletException {
//强转
HttpServletRequest request = (HttpServletRequest) req;
HttpServletResponse response = (HttpServletResponse) res;
//获取文件名(这里根据自己的需求写)
String id = request.getParameter("id");
String fileName = "/html/" + id + ".html";
//获取全路径
String filePath = request.getSession().getServletContext().getRealPath(fileName);
//判断文件是否存在
File htmlFile = new File(filePath);
if(!htmlFile.exists()){
//不存在
MyResponse myResponse = new MyResponse(response,htmlFile);
//放行
chain.doFilter(request, myResponse);//通过增强方法,会将数据保存为静态页面
}
//将文件发送给浏览器
request.getRequestDispatcher(fileName).forward(request, response);
}
public void destroy() {

}
}
/**
* 自定义的response类,修改getWriter方法的功能
* @author Administrator
* HttpServletResponseWrapper为tomcat的Response对象的装饰类,没有修改任何方法,供开发人员使用
*/
class MyResponse extends HttpServletResponseWrapper{
private File htmlFile;//缓存的文件
PrintWriter writer;//缓存的打印流
public MyResponse(HttpServletResponse response,File htmlFile) {
super(response);
this.htmlFile = htmlFile;
}
//增强方法(将目的地改为指定文件)
public PrintWriter getWriter() throws IOException {
//此方法会调用两次,第一次tomcat获得流用来输出,第二次tomcat获得流是为了关闭流
if(writer == null){
//第一次调用,实例化打印流
String encoding = super.getResponse().getCharacterEncoding();//编码
OutputStreamWriter out = new OutputStreamWriter(new FileOutputStream(htmlFile),encoding);//转换流
writer = new PrintWriter(out);//此类编码为操作系统默认编码,要使用转换流指定编码,否则将出现乱码
}
return writer;
}
}
web.xml配置
<filter>
<filter-name>PageStaticFilter</filter-name>
<filter-class>web.filter.PageStaticFilter</filter-class>
</filter>
<filter-mapping>
<filter-name>PageStaticFilter</filter-name>
<url-pattern>路径自己写,某个servlet</url-pattern>
</filter-mapping>

javamail
应用场景
注册账号时，进行账号激活
邮件订阅
生日祝福
名词
邮件服务器：安装有接收邮件、发送邮件功能的软件的计算机。
电子邮箱email：邮件服务器上申请的账号。
协议
SMTP(Simple Mail Transfer Protocol)即简单邮件传输协议，发送邮件服务器称为SMTP服务器,默认端口号:25
POP3(Post Office Protocol 3)即邮局协议，接收邮件服务器称为POP3服务器。默认端口：110
IMAP(Internet Mail Access Protocol)交互邮件访问协议，接收邮件服务器。默认端口：143
与POP3协议的主要区别是用户可以不用把所有的邮件全部下载，可以通过客户端直接对服务器上的邮件进行操作
发送邮件过程
xxx@163.com 发送到 xxx@126.com
首先发送到163邮件服务器的SMTP发送端,然后发送到126邮件服务器的SMTP发送端,并保存.
当用户读取时,通过126邮件服务器的POP3接收端读取邮件,返回给用户
手动发送邮件示例
命令行
telnet smtp.163.com 25      --连接163邮件服务器的smtp发送端(一般都为smtp.服务器.com)
ehlo itcast                 --随便说点啥
auth login                  --需要登陆
aXRjYXN0X2x0                --用户名(base64编码)
MXFhejJ3c3g=                --密码(base64编码)
mail from:<itcast_lt@163.com>   --发件人
rcpt to:<itcast_lt@126.com>     --收件人
data                            --需要书写邮件内容
from:<lkplovelyf@163.com>   --显示的发件人
to:<itcast_lt@126.com>      --显示的收件人
subject:good luck!!!        --主题
[空行]                      --与正文的分割
baidu welcome you!!!        --正文
.                           --结束邮件主体
quit                        --断开连接
base64编码与解码
解码:
sun.misc.BASE64Decoder类
sun.misc.BASE64Decoder decoder = new sun.misc.BASE64Decoder();
byte[] bytes = decoder.decodeBuffer("要解码的字符串");
System.out.println(bytes);
编码:
sun.misc.BASE64Encoder类
sun.misc.BASE64Encoder encoder = new sun.misc.BASE64Encoder();
String str = encoder.encode("要编码的字符串".getBytes());
System.out.println(str);
注意:
myeclipse默认没有上面两个类,换个jre库就好了(没搞明白为什么)
项目右键-->Properties-->Java Build Path-->Libraries-->删除原来的-->Add Library-->JRE System Library
javamail
使用java程序发送电子邮件。
sun公司提供
核心jar：mail.jar           --> javamail1_4_5.zip
依赖jar：activation.jar     --> jaf-1_1_1.zip (编写复杂邮件时使用，现阶段不用)
javamail 编写流程
1 获得会话 Session  -->相当于连接
2 编写消息 Message  -->相当于邮件
3 发送邮件 Transport
工具类
import java.util.Properties;
import javax.mail.Authenticator;
import javax.mail.Message;
import javax.mail.Message.RecipientType;
import javax.mail.PasswordAuthentication;
import javax.mail.Session;
import javax.mail.Transport;
import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimeMessage;
/**
* 邮件工具包
* @author Administrator
*
*/
public class MailUtils {
private static String serverHost = "localhost";//邮箱服务器地址(例:smtp.163.com)
private static String mail_username = "123";//用户
private static String mail_password = "123";//密码
private static String sendHost = "123@ss.cn";//发送人地址
/**
* 向用户发送邮件
* @param sendToUrl 目标邮箱
* @param subject 主题
* @param content 正文
*/
public static void sendMail(String sendToHost,String subject,String content){
try {
//获得会话
// * 准备参数
// ** 1 准备配置信息
Properties props = new Properties();
props.setProperty("mail.host", serverHost);//邮箱服务器地址
props.setProperty("mail.smtp.auth", "true");//进行登录验证
// ** 2 准备用户和密码
Authenticator authenticator = new Authenticator() {
protected PasswordAuthentication getPasswordAuthentication() {
return new PasswordAuthentication(mail_username, mail_password);
}
};
Session session = Session.getDefaultInstance(props, authenticator);
//session.setDebug(true);// 设置debug模式 在控制台看到交互信息
//编写消息
Message message = new MimeMessage(session);
// * 1 设置发件人
message.setFrom(new InternetAddress(sendHost));
// * 2 设置收件人
message.setRecipient(RecipientType.TO, new InternetAddress(sendToHost));
//TO:接收者;CC:抄送;BCC:暗送;(接收者知道所有被抄送的人,但不知道被暗送的人)
// * 3 设置主题
message.setSubject(subject);
// * 4 设置正文
message.setContent(content, "text/html;charset=utf-8");
//发送
Transport.send(message);
} catch (Exception e) {
e.printStackTrace();
throw new RuntimeException(e);
}
}
public static void main(String[] args) {
sendMail("456@ss.cn","主题1","正文");
}
}

MIME类型
概述
多用途互联网邮件扩展（MIME，Multipurpose Internet Mail Extensions）
规定了各种各样数据类型的符号化方法,使邮件能够支持非ASCII字符,二进制格式附件等多种格式的消息
HTTP协议中也使用了MIME的框架,标准被扩展为互联网媒体类型
格式：content-type ： type/subtype;parameter
例如：text/html;charset=UTF-8
type的所有取值
Text：用于标准化地表示的文本信息，文本消息可以是多种字符集和或者多种格式的；
Multipart：用于连接消息体的多个部分构成一个消息，这些部分可以是不同类型的数据；
Application：用于传输应用程序数据或者二进制数据；
Message：用于包装一个E-mail消息；
Image：用于传输静态图片数据；
Audio：用于传输音频或者音声数据；
Video：用于传输动态影像数据，可以是与音频编辑在一起的视频数据格式。
subtype常见取值
text/plain（纯文本）
text/html（HTML文档）
image/gif（gif图像）
image/jpeg（jpeg图像）
image/png（png图像）
application/msword（Microsoft Word文件）
application/x-www-from-urlencoded（HTTP的POST方式提交表单）
multipart/form-data （用于文件上传）
%tomcat%/conf/web.xml 提供常见的MIME类与扩展名的映射关系。

案例:使用本地服务器发送邮件
软件介绍
易邮邮件服务器:邮件服务器软件,可以注册账号发送和接收邮件
Foxmail:使用客户端管理邮箱
安装易邮邮件服务器
设置易邮邮件服务器
工具-->服务器设置-->作为局域网的邮件服务器,单域名:ss.cn
新建账号
账号123     账号123     联系邮件地址123@ss.cn
账号456     账号456     联系邮件地址456@ss.cn
安装Foxmail
设置Foxmail
第一次启动时创建用户:手动设置
邮件账号    123@ss.cn
密码        123
POP服务器   localhost
SMTP服务器  localhost
启动后创建用户:在已有用户上右击-->设置-->新建-->手动设置
邮件账号    456@ss.cn
密码        456
POP服务器   localhost
SMTP服务器  localhost
可以试试用Foxmail用两个账号互相发送邮件
使用java代码发送邮件
设置工具类MailUtils中的成员变量的值
private static String serverHost = "localhost";//邮箱服务器地址(例:smtp.163.com)
private static String mail_username = "123";//用户
private static String mail_password = "123";//密码
private static String sendHost = "123@ss.cn";//发送人地址
发送邮件
MailUtils.sendMail("456@ss.cn","主题","正文");

文件上传
概述
将用户本地的资源,通过浏览器发送给服务器,服务器保存到服务器端
浏览器:选择文件,提交
服务器:获得数据,保存
步骤
1 通知浏览器，可以选择文件、可以将文件进行提交
提交: <form> <input type="submit"/>
选择：<input type="file" name=""/>
发送上传内容：给form表单添加属性enctype="multipart/form-data" ，设置method="post". 注意：默认情况只发送文件的名称
enctype 属性规定在发送到服务器之前应该如何对表单数据进行编码
取值：
application/x-www-form-urlencoded 在发送前编码所有字符（默认）
multipart/form-data 不对字符编码。在使用包含文件上传控件的表单时，必须使用该值。
注意:
上传文件时,request.getParameter方法不能获取方法体传递的参数
可以在表单的action后面使用?追加参数
可以在当前servlet上添加servlet3.0的注解@MultipartConfig
2 服务器接收数据，并保存文件。
第一种：使用servlet的api解析上传内容，需要手动对内容进行分析。比较繁琐
request提供的getInputStream() 用来获得请求体的所有内容。
第二种：使用第三方工具 -- apache commons组件--fileupload
jar
核心jar：commons-fileupload-1.2.2.jar   --> 来自commons-fileupload-1.2.2-bin.zip
依赖jar：commons-io-2.3.jar             --> 来自commons-io-2.3-bin.zip
核心类：ServletFileUpload
api见工具类
第三种：Servlet3.0支持文件上传,参见下面的<servlet3.0>
第四种: struts2的文件上传,参见<struts>中的<文件上传>
工具类FileUploadApacheUtils
package util;
import java.io.File;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.UUID;
import javax.servlet.http.HttpServletRequest;
import org.apache.commons.fileupload.FileItem;
import org.apache.commons.fileupload.disk.DiskFileItemFactory;
import org.apache.commons.fileupload.servlet.ServletFileUpload;
public class FileUploadApacheUtils {
/**
* 处理文件上传
* @param request 请求对象
* @return Map:普通表单字段的name-value,上传文件的name-保存名称
*/
@SuppressWarnings("unchecked")
public static Map<String,String> fileUpload(HttpServletRequest request){
//判断是否表单是否是文件上传 ，即判断enctype是否为"multipart/form-data"
boolean isMultipart = ServletFileUpload.isMultipartContent(request);
if(!isMultipart){
throw new RuntimeException("表单不是文件上传类型");
}
int sizeThreshold = 1024 * 1024;//设置临界点大小,当文件大小大于临界点大小时,将会产生临时文件
String tempPath = "/WEB-INF/tempFile";//临时文件存放位置
String savePath = "/WEB-INF/uploadFile";//保存路径
Map<String,String> map = new HashMap<String,String>();
try {
//准备工厂,进行配置(出于安全性考虑,当文件过大时每接收一点先缓存到临时文件中)
DiskFileItemFactory factory = new DiskFileItemFactory();
factory.setSizeThreshold(sizeThreshold);//设置临界点大小,当文件大小大于临界点大小时,将会产生临时文件
String tempPath2 = request.getSession().getServletContext().getRealPath(tempPath);
factory.setRepository(new File(tempPath2));//设置临时文件存放位置
//准备解析文件
ServletFileUpload upload = new ServletFileUpload(factory);//核心类
upload.setHeaderEncoding("utf-8");//设置文件名的编码,否则文件名含有中文时会出现乱码.如果不设置则使用request的编码
List<FileItem> allFileItem = upload.parseRequest(request);//解析request,获得文件项
for(FileItem fileItem : allFileItem){
if(fileItem.isFormField()){
//表单字段
String name = fileItem.getFieldName();
String value = fileItem.getString("utf-8");//参数为编码方式,不设置可能出现中文乱码
map.put(name, value);
}else{
//上传的文件
String fieldName = fileItem.getFieldName();//name属性
String fileName = fileItem.getName();//文件名称
fileName = getFileName(fileName);//处理文件名称
InputStream in = fileItem.getInputStream();//获得文件流
//将文件流保存到文件
String path = request.getSession().getServletContext().getRealPath(savePath);//保存路径
File file = new File(path,fileName);
OutputStream out = new FileOutputStream(file);
byte[] bytes = new byte[128 * 1024];
int len = 0;
while( (len = in.read(bytes)) > 0 ){
out.write(bytes,0,len);
}
in.close();
out.close();
fileItem.delete();//删除临时文件(如果有的话)
map.put(fieldName, fileName);
}
}
return map;
} catch (Exception e) {
e.printStackTrace();
throw new RuntimeException(e);
}
}
/**
* 返回经过处理的文件名称,保证不重复
* @param fileName 要处理的文件名称
* @return 经过处理的文件名称
*/
private static String getFileName(String fileName){
fileName = fileName.substring(fileName.lastIndexOf("/") + 1);//处理兼容,因为ie8在xp下返回的是全路径
fileName = UUID.randomUUID().toString().replace("-", "") + "_" + fileName;//避免重复
return fileName;
}
}
上传文件示例
导入jar包和工具类
核心jar：commons-fileupload-1.2.2.jar   --> 来自commons-fileupload-1.2.2-bin.zip
依赖jar：commons-io-2.3.jar             --> 来自commons-io-2.3-bin.zip
工具类：自定义工具类FileUploadApacheUtils
在WEB-INF下创建tempFile和uploadFile文件夹
index.jsp
<form action="${pageContext.request.contextPath }/userServlet" method="post" enctype="multipart/form-data">
<input name="username" value="jack"><br>
<input type="file" name="uploadFile"><br>
<input type="submit" value="提交">
</form>
userServlet
public void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
Map<String,String> map = FileUploadApacheUtils.fileUpload(request);
System.out.println(map);
}
上传文件请求
请求头
Content-Type: multipart/form-data; boundary=---------------------------7de32138c0540
请求体
-----------------------------7de32138c0540
Content-Disposition: form-data; name="username"
jack
-----------------------------7de32138c0540
Content-Disposition: form-data; name="password"
123
-----------------------------7de32138c0540
Content-Disposition: form-data; name="uploadFile1"; filename="123.txt"
Content-Type: text/plain
上传文件内容...
-----------------------------7de32138c0540
Content-Disposition: form-data; name="uploadFile2"; filename="456.txt"
Content-Type: text/plain
上传文件内容...
注意:上面上传了两个普通表单字段和两个文件.(请求体中的空行我去掉了)
请求头生成一串随机字符串,然后用此字符串将请求体的多个键-值分隔

文件下载
概述
服务器提供下载资源,当浏览器发送请求时,通知浏览器保存到本地
服务器:读取资源,发送到浏览器,通知浏览器下载
浏览器:下载
浏览器下载文件时，如果浏览器可以解析将直接显示，如果不能解析则提供下载。
通知浏览器总是进行下载：response.setHeader("content-disposition", "attachment;filename=文件名称");
文件中文显示乱码处理：value = new String(value.getBytes("GBK") , "ISO-8859-1");
示例
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
String fileName = "图片.jpg";
//处理fileName中文乱码问题(响应头不支持中文)
//http协议进行iso8859-1编码,客户端进行gbk(操作系统默认编码)解码,所以要反着来一下
fileName = new String(fileName.getBytes("gbk"),"iso8859-1");
//通知浏览器内容类型为附件
response.setHeader("content-disposition", "attachment;filename=" + fileName);
//获得文件
InputStream in = request.getSession().getServletContext().getResourceAsStream("/图片.jpg");
//发送
OutputStream out = response.getOutputStream();
byte[] bytes = new byte[128 * 1024];
int len = 0;
while( (len = in.read(bytes))>0 ){
out.write(bytes,0,len);
}
in.close();
}
注意:处理文件名称中文乱码的代码通常放在过滤器中,处理图片名称含有中文的问题(向tomcat请求不到名称含有中文的图片)

servlet3.0
servlet3.0提供注解
@WebServlet, 用于取代servlet的配置web.xml <servlet>...配置内容
属性
name用来配置servlet名称,不写的话默认为当前类名
urlPatterns 和 value 作用一样,都用来配置servlet访问路径
例: @WebServlet("/one") 或 @WebServlet({"/one","/two"})
@WebFilter ,用于取代过滤器的配置 web.xml <filter>...配置内容,属性同上
@WebListener ,用于取代监听器的配置 <listener><listener-class>
@MultipartConfig，通知tomcat当前servlet将开启文件上传的处理,无属性
servlet3.0对文件上传进行支持
通过request.getPart(名称)获得上传内容，Part对象等价 commons FileItem
默认情况servlet不支持上传，需要在当前servlet上添加注解@MultipartConfig,无属性
注意:当使用@MultipartConfig注解时,request.getParameter()可以获得普通表单字段的值
工具类FileUploadServlet3Utils
public class FileUploadServlet3Utils {
/**
* 保存上传文件
* @param request 请求对象
* @param name input的name值
* @return 保存路径
*/
public static String saveUploadFile(HttpServletRequest request,String name){
String fileDir = "/WEB-INF/uploadFile";//保存文件夹
try {
// 获得上传文件内容对象
Part part = request.getPart(name);
if(part==null){
throw new RuntimeException("没有找到上传的文件");
}
// * 获得上传文件名称
String fileName = getFileName(part);
String savePath = fileDir+"/"+fileName;
// * 获得文件内容 --流
InputStream is = part.getInputStream();
// * 保存
String realSavePath = request.getServletContext().getRealPath(savePath);
FileOutputStream out = new FileOutputStream(new File(realSavePath));
byte[] buf = new byte[128*1024];
int len = -1;
while( (len = is.read(buf)) != -1 ){
out.write(buf, 0, len);
}
out.close();
is.close();
return savePath;
} catch (Exception e) {
e.printStackTrace();
throw new RuntimeException("保存上传文件失败");
}
}
/**
* 获得文件名称,保证不重复
* @param part
* @return
*/
private static String getFileName(Part part){
// * 获取文件名称
String headerValue = part.getHeader("Content-Disposition");
int beginIndex = headerValue.indexOf("filename=\"") + "filename=\"".length();
int endIndex = headerValue.length() -1;
String fileName = headerValue.substring(beginIndex, endIndex);
// * 处理文件名称 --浏览器兼容
fileName = fileName.substring(fileName.lastIndexOf("/") + 1);//处理兼容,因为ie8在xp下返回的是全路径
// * 处理文件名称 --不重复
fileName = UUID.randomUUID().toString().replace("-", "") + "_" + fileName;//避免重复
return fileName;
}
}
使用示例
在WEB-INF下创建uploadFile文件夹
index.jsp
<form action="${pageContext.request.contextPath }/userServlet" method="post" enctype="multipart/form-data">
<input name="username" value="jack"><br>
<input type="file" name="uploadFile"><br>
<input type="submit" value="提交">
</form>
userServlet
@MultipartConfig
public class UserServlet extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
String savePath = FileUploadServlet3Utils.saveUploadFile(request, "uploadFile");
System.out.println(savePath);
}
public void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
doGet(request, response);
}
}