一、使用application 内置对象读web.xml 中的参数:
Web.xml 中如下：
<context-param>
<param-name>driver</param-name>
<param-value>com.jdbc.mysql.Driver</param-value>
</context-param>
<context-param>
<param-name>uri</param-name>
<param-value>jdbc:mysql://localhost:3306/shopping</param-value>
</context-param>
<context-param>
<param-name>user</param-name>
<param-value>root</param-value>
</context-param>
<context-param>
<param-name>pwd</param-name>
<param-value>root</param-value>
</context-param>
上面就是在 web.xml 中配置将要读取的的全局参数！ 下面使用 application 进行读取并显示到页面上：
Servlet中的代码：
String driver =getServletContext().getInitParameter("driver");
Stringuri=getServletContext().getInitParameter("uri");
Stringuser=getServletContext().getInitParameter("user");
Stringpwd=getServletContext().getInitParameter("pwd");
通过上面的连个步骤就可以读取全局变量！
二、使用 config 对象，读取servlet 的参数：
不管是Jsp页面还是servlet， config内置对象代表翻译之后的的 .java 本身！这种方法读取参数的使用场合：字符过滤器：
Serlet 中的配置如下：
<servlet>
<servlet-name>config</servlet-name>
<servlet-class>config</servlet-class>
<init-param>
<param-name>charset</param-name>
<param-value>utf-8</param-value>
</init-param>
</servlet>
在serlvet 中的代码如下：
Stringcharset=this.getServletConfig().getInitParameter("charset");
三、exception 对象：
exception 对象是 Throwable 类的实例，在Jsp中处理异常的模式,两个页面组成了一个try…….catch….
四、pageContext 对象：
pageContext.setAttribute("request","hello",pageContext.REQUEST_SCOPE);
五、request 对象：
使用 request.getParameterMap() 可以获取请求的Map 集合对象；使用request应注意以下情况：
并不是每个表单域都可以生成请求参数的，只有有name属性的表单域才可以生成请求参数的！如果多个表单域的name值相同，则生成一个请求参数；表单域的name属性为请求参数的名，value属性值为请求的值；如果某个表单的disabled=”true”则该表单不在生成请求参数！
Map<String,Object>res=request.getParameterMap();
Iterator<?>iter=res.keySet().iterator();
while(iter.hasNext()) {
Stringstr=iter.next().toString();
System.out.println(str);
}
使用如上代码获取请求信息的Map<String,String> 对象！为什么我们在jsp中设置的请求参数，不管是在 jsp中还是在 servlet中都可以获得到；原因就在于；系统将我们的请求参数放入了一个Map，不管是在jsp中还是在 servlet 总我们都是访问的这个map对象；
Stringqstr=request.getQueryString();
System.out.println(qstr);
StringstrE=java.net.URLDecoder.decode(qstr,"utf-8");
System.out.println(strE);
String[] arrayStr=strE.split("&");
for(String string : arrayStr) {
System.out.println("每个请求参数的值，对"+string);
String[] subStr=string.split("=");
System.out.println("名称："+subStr[0]);
System.out.println("值"+subStr[1]);
}
Request 对象的getQuaryString() 方法，可以获取请求字符串，java.net.Decoder.decode() 用于解码(原因是在请求参数中含有非西欧字符的参数，所以要使用java.net.Decoder.decode()进行解码);
使用getRequestDispatcher(“{0}”).forward()跳转时，要在 0 处的项目资源加 ‘/’;
六、response 对象：
比较request.getRequestDispatcher().forward(request,response)与response.sendRedirect():
Forward 执行完之后还是上一次的请求，而redirect 后生成第二次请求；forward 请求后，目标页面可以访问请求的请求参数，因为是同一个request请求，即所有的请求参数在同一个 request对象中都存在，而使用 redirect 后目标页面不能使用原来的请求参数，因为已经是第二次请求了，那也就是说，request对象的消失，请求的参数就会跟着消失；还有使用 forward 请求url 中的地址不会改变. 而使用 redirect 会改变为目标的 url;
七、cookie 的读写：
写入 cookie 对象：
//设置临时Cookie
Cookie tempCookie=newCookie("temp","222222");
tempCookie.setMaxAge(-1); //默认值，不会把 Cookie 保存到硬盘上
response.addCookie(tempCookie);
//设置 MaxAge 为 0 的 Cookie
Cookie cookie=newCookie("cookie","111111");
cookie.setMaxAge(0); //表示浏览器接受 Cookie 后会被立即删除
response.addCookie(cookie);
//设置永久的 Cookie
Cookie mcookie=newCookie("name","000000");
mcookie.setMaxAge(60*60*24);
response.addCookie(mcookie);
读取 cookie 对象：
protected Cookie getCookie(Cookie []cookies,String name){
if(cookies!=null){
for(Cookie c : cookies) {
if(c.getName().equals(name)){
returnc;
}
}
}
returnnull;
}
PrintWriter out = response.getWriter();
//获得临时的 Cookie
Cookie temp=getCookie(request.getCookies(),"temp");
if(temp!=null){
out.print("临时Cookie的值为："+temp.getValue());
}else{
out.print("没有值！");
}
//获取时间为 0 的Cookie，这个 Cookie永远都不可能获得到
Cookiecookie=getCookie(request.getCookies(), "cookie");
if(cookie!=null) {
out.print("MaxAge为零的Cookie:"+cookie.getValue());
}else {
out.print("没有值!");
}
//获取永久的Cookie
Cookiename=getCookie(request.getCookies(), "name");
if(name!=null) {
out.print("永久Cookie 值："+name.getValue());
}else {
out.print("没有值！");
}
在cookie中写的时候对汉字的处理：
添加之前将字符串使用java.net.URLEncoder.encode("高江涛","utf-8"); 取出来之后将结果java.net.URLDecoder.decode(temp.getValue(),"utf-8");
八、在servlet中访问servlet的配置参数：
ServletConfigconfig=this.getServletConfig();
config.getInitParameter("paramName");
九、自定义标签：
a) 传统的Jsp脚本有什么坏处：
i. Jsp 脚本非常丑陋，难以阅读！
ii. Jsp 脚本和 HTML 代码混杂，维护成本高!
iii. HTML 页面中嵌入 Jsp 脚本，导致美工难以参加开发！
b) 自定义标签的开发步骤:
i. 建立自定义标签的处理类；
ii. 建立一个 *.tld 文件，每一 tld文件都对应一个标签库，每个标签库对应多个个标签！
iii. 在Jsp 页面上使用自己的标签！
c) .tld 文件的描述(根元素为 tag-lib)：
i. tlib-version: 标签库的版本，这个对程序的作用不大！
ii. short-name: 标签库默认的短名,通常对程序的作用也不大！
iii. uri: 该标签库的uri，指定该标签库的唯一标示;
iv. tag: tag-lib 下可以有多个 tag,每个 tag 都代表一个标签；
d) tag 下的元素描述:
name: 这个非常重要，jsp页面就是根据这个来使用这个标签的；
tag-class: 这个是这个标签的后台处理类!
body-content: 这个属性可以是一下值: tagdependent: 指定标签的处理类，自己负责处理标签体! Empty: 空体标签； scriptless: 该标签里面可以含有静态的 HTML , 表达式语言，但不可以是 JSP 脚本！ JSP ：这个已被忽视；
e) 带属性自定义的标签开发：
对于有属性的标签，要为tag添加 attribute 子元素： 每个 attribute 子元素定义一个属性，attribute含有一下子元素：
Name: 属性的名称；
Required: 设置该属性为必须属性；
Fragment: 是否支持Jsp脚本等动态内容！
f) 在页面上使用自己定义的标签：
<%@ taglib uri="http://xabc.net"prefix="mytag" %>
g) 带体的标签：
Collection<?>itemList=
(Collection<?>)getJspContext().getAttribute(this.getCollection());
for (Object object : itemList) {
getJspContext().setAttribute(this.getItem(),object);
getJspBody().invoke(null);
}
十、过滤器：
a) 过滤器的使用场合：
i. 权限过滤;
ii. 日志过滤;
iii. 非法IP过滤;
iv. 字符集过滤；
b) 创建过滤器的后台处理类，实现Filter接口，实现如下方法：
i. init(FilterConfig config); 用于对过滤器的初始化；
ii. defiler(ServletRequestrequest,SerletResponse response,FilterChain chain);用于将请求继续传递；
iii. destroy(): 用于在 Filter 销毁之前将某些资源回收！
c) 在 web.xml 下如下配置：
<filter>
<filter-name>filter</filter-name>
<filter-class>util.DoFilter</filter-class>
<init-param>
<param-name>endoding</param-name>
<param-value>utf-8</param-value>
</init-param>
<init-param>
<param-name>fristPage</param-name>
<param-value>index.jsp</param-value>
</init-param>
<init-param>
<param-name>IP</param-name>
<param-value>127.0.0.2</param-value>
</init-param>
</filter>
<filter-mapping>
<filter-name>filter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
* 过滤器主要是对用户的请求进行预处理，也可以对 HttpServletResponse进行后处理!
过滤器的核心代码:
public void doFilter(ServletRequest request,ServletResponse response,
FilterChainchain) throws IOException, ServletException {
request.setCharacterEncoding(this.encoding);
HttpServletRequesthrequest=(HttpServletRequest)request;
HttpServletResponsehresponse=(HttpServletResponse)response;
Stringspath=hrequest.getServletPath();//获取请求的路径
Stringip=hrequest.getLocalAddr();//获取请求的IP
if(!ip.equals(this.IP)) {
if(!spath.endsWith(this.firstpage)) {
request.getRequestDispatcher(this.firstpage).forward(hrequest,hresponse);
}else{
chain.doFilter(hrequest,hresponse);
}
}else{
hrequest.setAttribute("msg","<scriptlanguage=‘javascript‘>window.alert(‘您被限制了！‘) </script>");
hrequest.getRequestDispatcher("error.jsp").forward(hrequest,hresponse);
}
}
十一、 监听器：
a) 使用 Listener 的步骤：
i. 创建 Listener 实现类，实现 ServeltContextListener 接口；包含一下方法:
1. contextInitialized (ServletContextEvent sce): 启动web应用时，系统调用的方法；
2. contextDestroyed(ServletContextEvent sce): 关闭 web 应用时，系统调用的方法；
ii. 在web.xml 中配置如下：
<listener>
<listener-class>util.Listener</listener-class>
</listener>
监听器如 servlet 的 load-on-startup一样，但是比servlet 的 load-on-startup 执行的还早，还有监听器不负责处理及相应用户的请求; 还有监听器在web.xml 下配置的时候无需配置参数，所访问的参数为全局共有参数。
十二、 配置 JSP属性：(在 JSP 2.1 之后的支持！)
<jsp-property-group>元素配置，主要包含以下子元素：
<el-ignored>：决定页面是否使用EL表达式，也就是是说是否解析EL表达式；默认为 false，可以使用 EL 表达式;
<sription-invalid>:默认为false，允许JSP页面可以使用 JSP脚本!
<page-encoding>:声明JSP页面的编码格式，指定次属性后，就不用在每个页面上使用pageEncoding: 来指定此页面的字符集；
<include-prelude> 和 <include-coda> ：来指定页面的头部和尾部！
<jsp-config>
<jsp-property-group>
<url-pattern>/admin/*</url-pattern>
<el-ignored>true</el-ignored>
<page-encoding>utf-8</page-encoding>
<scripting-invalid>true</scripting-invalid>
</jsp-property-group>
</jsp-config>
十三、 JSP中表达式语言(Expressionlanguage)：
a) ${1+2} : 前加 ‘ \’ 表示此EL 表达式不被解析；
b) 表达式语言的内置对象：
i. pageContext: 代表页面的 pageContext 对象,与JSP中的PageContext相同;
ii. pageScope: 获取page 范围内的属性；
iii. requestScope: 获取 request 范围内的属性；
iv. sessionScope : 获取 session 范围内的属性；
v. applicationScope : 获取 application 范围内的属性；
vi. param : 用于获取请求参数；
vii. paramValues: 用于获取请求的参数，与param不同的是该对象是用于获取返回值为数组的参数；
viii. header: 用于获取请求头信息;
ix. headerValues : 用于获取请求头信息; 与header不同的是该对象是用于获取返回值为数组的请求参数；
x. initParam: 用于获取有 web 应用初始化的参数；
xi. cookie: 用于获取指定 cookie 的值;
c) EL的自定义函数：
i. 自定义表达式语言与自定义标签类似；步骤分为：
1. 开发 EL函数处理类，这个类中的方法要求是静态的方法;
2. 建立tld 文件,tld 文件的描述:
name: 指定了函数的名称;
function-class: 函数对应的处理类；
function-signature:指定函数的实现方法；
3. 使用该函数;
<%@ tagliburi="http://xabc.com" prefix="fn" %>
ii.
publicstatic String reverse(String str){
returnnew StringBuffer(str).reverse().toString();
}
publicint countChar(String text){
returntext.length();
}
<function>
<name>reverse</name>
<function-class>demo.myfunction</function-class>
<function-signature>
java.lang.Stringreverse(java.lang.String)
</function-signature>
</function>
<function>
<name>countChar</name>
<function-class>demo.myfunction</function-class>
<function-signature>
intcountChar(java.lang.String)
</function-signature>
</function>