pageContext对象

    pageContext对象是JSP技术中最重要的一个对象，它代表JSP页面的运行环境，这个对象不仅封装了对其它8大隐式对象的引用，它自身还是一个域对象，可以用来保存数据。并且，这个对象还封装了web开发中经常涉及到的一些常用操作，例如引入和跳转其它资源、检索其它域对象中的属性等。

通过pageContext获得其他对象

    getException方法返回exception隐式对象

    getPage方法返回page隐式对象

    getRequest方法返回request隐式对象

    getResponse方法返回response隐式对象

    getServletConfig方法返回config隐式对象

    getServletContext方法返回application隐式对象

    getSession方法返回session隐式对象

    getOut方法返回out隐式对象

    pageContext封装其它8大内置对象的意义，思考：如果在编程过程中，把pageContext对象传递给一个普通java对象，那么这个java对象将具有什么功能？ 

pageContext作为域对象

pageContext对象的方法

    public void setAttribute(java.lang.String name,java.lang.Object value)

    public java.lang.Object getAttribute(java.lang.String name)

    public void removeAttribute(java.lang.String name)

pageContext对象中还封装了访问其它域的方法

    public java.lang.Object getAttribute(java.lang.String name,int scope)

    public void setAttribute(java.lang.String name, java.lang.Object value,int scope)

    public void removeAttribute(java.lang.String name,int scope)

代表各个域的常量

    PageContext.APPLICATION_SCOPE

    PageContext.SESSION_SCOPE

    PageContext.REQUEST_SCOPE

    PageContext.PAGE_SCOPE

findAttribute方法    （*重点，查找各个域中的属性）

引入和跳转到其他资源

    PageContext类中定义了一个forward方法和两个include方法来分别简化和替代RequestDispatcher.forward方法和include方法。

方法接收的资源如果以“/”开头， “/”代表当前web应用。

JSP标签

    JSP标签也称之为Jsp Action(JSP动作)元素，它用于在Jsp页面中提供业务逻辑功能，避免在JSP页面中直接编写java代码，造成jsp页面难以维护。

JSP常用标签

1、<jsp:include>标签 

    <jsp:include>标签用于把另外一个资源的输出内容插入进当前JSP页面的输出内容之中，这种在JSP页面执行时的引入方式称之为动态引入。

语法：

       <jsp:include page="relativeURL | <%=expression%>" flush="true|false" />

page属性用于指定被引入资源的相对路径，它也可以通过执行一个表达式来获得。

flush属性指定在插入其他资源的输出内容时，是否先将当前JSP页面的已输出的内容刷新到客户端。 

<jsp:include>与include指令的比较

    <jsp:include>标签是动态引入， <jsp:include>标签涉及到的2个JSP页面会被翻译成2个servlet，这2个servlet的内容在执行时进行合并。

而include指令是静态引入，涉及到的2个JSP页面会被翻译成一个servlet，其内容是在源文件级别进行合并。

不管是<jsp:include>标签，还是include指令，它们都会把两个JSP页面内容合并输出，所以这两个页面不要出现重复的HTML全局架构标签，否则输出给客户端的内容将会是一个格式混乱的HTML文档。

2、<jsp:forward>标签 

    <jsp:forward>标签用于把请求转发给另外一个资源。

语法：

       <jsp:forward page="relativeURL | <%=expression%>" />

page属性用于指定请求转发到的资源的相对路径，它也可以通过执行一个表达式来获得。

3、<jsp:param>标签 

    当使用<jsp:include>和<jsp:forward>标签引入或将请求转发给其它资源时，可以使用<jsp:param>标签向这个资源传递参数。

语法1：

       <jsp:include page="relativeURL | <%=expression%>">

              <jsp:param name="parameterName" value="parameterValue|<%= expression %>" />

       </jsp:include>

语法2：

       <jsp:forward page="relativeURL | <%=expression%>">

              <jsp:param name="parameterName" value="parameterValue|<%= expression %>" />

       </jsp:include>

<jsp:param>标签的name属性用于指定参数名，value属性用于指定参数值。在<jsp:include>和<jsp:forward>标签中可以使用多个<jsp:param>标签来传递多个参数。

映射JSP

<servlet>

       <servlet-name>SimpleJspServlet</servlet-name>

       <jsp-file>/jsp/simple.jsp</jsp-file>

       <load-on-startup>1</load-on-startup >

</servlet>

       ……

<servlet-mapping>

       <servlet-name>SimpleJspServlet</servlet-name>

       <url-pattern>/xxx/yyy.html</url-pattern>

</servlet-mapping>

如何查找JSP页面中的错误

    JSP页面中的JSP语法格式有问题，导致其不能被翻译成Servlet源文件，JSP引擎将提示这类错误发生在JSP页面中的位置（行和列）以及相关信息。

    JSP页面中的JSP语法格式没有问题，但被翻译成的Servlet源文件中出现了Java语法问题，导致JSP页面翻译成的Servlet源文件不能通过编译，JSP引擎也将提示这类错误发生在JSP页面中的位置（行和列）以及相关信息。

    JSP页面翻译成的Servlet程序在运行时出现异常，这与普通Java程序的运行时错误完全一样，Java虚拟机将提示错误发生在Servlet源文件中的位置（行和列）以及相关信息。

1.page指当前页面。只在一个jsp页面里有效 。
2.request 指从http请求到服务器处理结束，返回响应的整个过程。在这个过程中使用forward方式跳转多个jsp。在这些页面里你都可以使用这个变量。 
3.Session 有效范围当前会话，从浏览器打开到浏览器关闭这个过程。 
4.application它的有效范围是整个应用。 
作用域里的变量，它们的存活时间是最长的，如果不进行手工删除，它们就一直可以使用 
page里的变量没法从index.jsp传递到test.jsp。只要页面跳转了，它们就不见了。 
request里的变量可以跨越forward前后的两页。但是只要刷新页面，它们就重新计算了。 
session和application里的变量一直在累加，开始还看不出区别，只要关闭浏览器，再次重启浏览器访问这页，session里的变量就重新计算了。 
application里的变量一直在累加，除非你重启tomcat，否则它会一直变大。 
而作用域规定的是变量的有效期限。 
如果把变量放到pageContext里，就说明它的作用域是page，它的有效范围只在当前jsp页面里。 
从把变量放到pageContext开始，到jsp页面结束，你都可以使用这个变量。 
如果把变量放到request里，就说明它的作用域是request，它的有效范围是当前请求周期。 
所谓请求周期，就是指从http请求发起，到服务器处理结束，返回响应的整个过程。在这个过程中可能使用forward的方式跳转了多个jsp页面，在这些页面里你都可以使用这个变量。
如果把变量放到session里，就说明它的作用域是session，它的有效范围是当前会话。 
所谓当前会话，就是指从用户打开浏览器开始，到用户关闭浏览器这中间的过程。这个过程可能包含多个请求响应。也就是说，只要用户不关浏览器，服务器就有办法知道这些请求是一个人发起的，整个过程被称为一个会话（session），而放到会话中的变量，就可以在当前会话的所有请求里使用。
如果把变量放到application里，就说明它的作用域是application，它的有效范围是整个应用。 
整个应用是指从应用启动，到应用结束。我们没有说“从服务器启动，到服务器关闭”，是因为一个服务器可能部署多个应用，当然你关闭了服务器，就会把上面所有的应用都关闭了。
application作用域里的变量，它们的存活时间是最长的，如果不进行手工删除，它们就一直可以使用。 
与上述三个不同的是，application里的变量可以被所有用户共用。如果用户甲的操作修改了application中的变量，用户乙访问时得到的是修改后的值。这在其他scope中都是不会发生的，page, request, session都是完全隔离的，无论如何修改都不会影响其他人的数据。

pageContext对象的范围只适用于当前页面范围，即超过这个页面就不能够使用了。所以使用pageContext对象向其它页面传递参数是不可能的。 
request对象的范围是指在一JSP网页发出请求到另一个JSP网页之间，随后这个属性就失效。 
session的作用范围为一段用户持续和服务器所连接的时间，但与服务器断线后，这个属性就无效。比如断网或者关闭浏览器。 
application的范围在服务器一开始执行服务，到服务器关闭为止。它的范围最大，生存周期最长。

JSP运行原理和九大隐式对象

        每个JSP 页面在第一次被访问时，WEB容器都会把请求交给JSP引擎（即一个Java程序）去处理。JSP引擎先将JSP翻译成一个_jspServlet(实质上也是一个servlet) ，然后按照servlet的调用方式进行调用。

由于JSP第一次访问时会翻译成servlet，所以第一次访问通常会比较慢，但第二次访问，JSP引擎如果发现JSP没有变化，就不再翻译，而是直接调用，所以程序的执行效率不会受到影响。

         JSP引擎在调用JSP对应的_jspServlet时，会传递或创建9个与web开发相关的对象供_jspServlet使用。JSP技术的设计者为便于开发人员在编写JSP页面时获得这些web对象的引用，特意定义了9个相应的变量，开发人员在JSP页面中通过这些变量就可以快速获得这9大对象的引用。

JSP九大隐式对象

request、response、config、application、exception、Session、page、out、pageContext

out隐式对象

out隐式对象用于向客户端发送文本数据。 

out对象是通过调用pageContext对象的getOut方法返回的，其作用和用法与ServletResponse.getWriter方法返回的PrintWriter对象非常相似。 

JSP页面中的out隐式对象的类型为JspWriter，JspWriter相当于一种带缓存功能的PrintWriter，设置JSP页面的page指令的buffer属性可以调整它的缓存大小，甚至关闭它的缓存。 

只有向out对象中写入了内容，且满足如下任何一个条件时，out对象才去调用ServletResponse.getWriter方法，并通过该方法返回的PrintWriter对象将out对象的缓冲区中的内容真正写入到Servlet引擎提供的缓冲区中：

设置page指令的buffer属性关闭了out对象的缓存功能

out对象的缓冲区已满

整个JSP页面结束

pageContext对象

pageContext对象是JSP技术中最重要的一个对象，它代表JSP页面的运行环境，这个对象不仅封装了对其它8大隐式对象的引用，它自身还是一个域对象，可以用来保存数据。并且，这个对象还封装了web开发中经常涉及到的一些常用操作，例如引入和跳转其它资源、检索其它域对象中的属性等。

通过jsp写文件下载代码

<%@page import="java.io.OutputStream"%><%@page import="java.io.FileInputStream"%><%@page import="java.io.InputStream"%><%@page import="java.io.File"%><%@page import="java.net.URLEncoder"%><%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%><%

   ServletContext context = this.getServletContext();

   String path = application.getRealPath("./images/da.jpg");

   //构造文件

   File file = new File(path);

   /*构造文件的输入流*/

   InputStream is = new FileInputStream(file);

   response.setHeader("content-disposition","attachment;filename="+URLEncoder.encode(file.getName(),"UTF-8"));

   OutputStream os   = response.getOutputStream();

   byte buffer[] = new byte[1024];

   int len=0;

    while((len=is.read(buffer))!=-1){

os.write(buffer,0,len);

}

os.flush();

os.close();

is.close();

%>

Session:服务器端技术。（Cookie：客户端技术）在WEB开发中，服务器可以为每个用户浏览器创建一个会话对象（session对象），注意：一个浏览器独占一个session对象(默认情况下)。因此，在需要保存用户数据时，服务器程序可以把用户数据写到用户浏览器独占的session中，当用户使用浏览器访问其它程序时，其它程序可以从用户的session中取出该用户的数据，为用户服务。

Session和Cookie的主要区别在于：

Cookie是把用户的数据写给用户的浏览器。

Session技术把用户的数据写到用户独占的session中。

Session对象由服务器创建，开发人员可以调用request对象的getSession方法得到session对象。

IE禁用Cookie后的session处理

实验演示禁用Cookie后servlet共享数据导致的问题。

解决方案：URL重写

response.encodeRedirectURL(java.lang.String url)

用于对sendRedirect方法后的url地址进行重写。

response.encodeURL(java.lang.String url)

用于对表单action和超链接的url地址进行重写。

Session可用来完成简单的购物功能，用户登录，防止表单重复提交，一次性验证码。

部分代码：

//怎么获取创建Session

     HttpSession session=request.getSession();

     //存入数据

        session.setAttribute("name", "wyd");

//从Session中获取name的值

     HttpSession session=request.getSession();

     String value=(String) session.getAttribute("name");

        System.out.println("name"+value);

Cookie：客户端技术。（Session:服务器端技术）程序把每个用户的数据以cookie的形式写给用户各自的浏览器。当用户使用浏览器再去访问服务器中得web资源时，就会带着各自的数据区。这样，web资源处理的就是用户各自的数据了.

  Javax.servlet.http.Cookie类用于创建一个Cookie，response接口中也定义了一个addCookie方法，它用于在其响应头中增加一个相应的Set-Cookie头字段。 同样，request接口中也定义了一个getCookies方法，它用于获取客户端提交的Cookie。Cookie类的方法：

public Cookie(String name,String value)

setValue与getValue方法

setMaxAge与getMaxAge方法

setPath与getPath方法   /day06

setDomain与getDomain方法

getName方法

 Cookie的应用：显示用户上次访问时间和浏览过的内容。

部分代码:

//创建Cookie

     Cookie ck=new Cookie("lastTime",System.currentTimeMillis()+"");

     //有效日期为0时 创建cookie到会话结束 删除cookie

     ck.setMaxAge(0);//1小时

     ck.setPath("/2011-10-24/servlet/CookieDemo");

     //发送给你的响应

   response.addCookie(ck);

//发送cookie信息

     String value=makeCookieValue(request,id);

     //产生一个cookie对象

     Cookie cookie=new Cookie("goodsHistory",value);

     cookie.setMaxAge(60*60);

     cookie.setPath("/2011-10-24");

     //响应

     response.addCookie(cookie);

//声明返回值变量

     String goodsHistory=null;

     //第一步：获取cookie

       Cookie cookies[]=request.getCookies();

       for(int i=0;cookies!=null && i<cookies.length;i++){      if("goodsHistory".equals(cookies[i].getName())){

           goodsHistory=cookies[i].getValue();

         }

一、解决中文乱码问题，解决中文乱码问题有三种方法：

1）通过设置响应的头来处理的

response.setHeader("Content-Type","text/.html;charset=UTF-8");

2）通过字节设置响应的头来处理的

response.getOutputStream().write("中国".getBytes("UTF-8"));

3）使用html语言里面的<meta>标签来控制浏览器行为

response.getOutputStream().write("<meta http-equiv=\"content-type\" content=\"text/html; charset=UTF-8\">".getBytes());

二、文件下载

下面是文件下载的代码：

package cn.csdn.web.servlet;

import java.io.File;

import java.io.FileInputStream;

import java.io.IOException;

import java.io.InputStream;

import java.io.OutputStream;

import java.io.UnsupportedEncodingException;

import java.net.URLEncoder;

import javax.servlet.ServletContext;

import javax.servlet.ServletException;

import javax.servlet.http.HttpServlet;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

public class Demo01Servlet extends HttpServlet {

public void doGet(HttpServletRequest request, HttpServletResponse response)

throws ServletException, IOException {

   this.doPost(request, response);

}

public void doPost(HttpServletRequest request, HttpServletResponse response)

throws ServletException, IOException {

       /*文件下载

        * 首先知道下载的资源*/

ServletContext context = this.getServletContext();

String path =context.getRealPath("/WEB-INF/classes/res/aa.jpg");

/*构造文件*/

File file= new File(path);

/*构造文件的输入流*/

InputStream is = new FileInputStream(file);

/*写：输出流

 * 文件下载*/

response.setHeader("content-disposition", "attachment;filename=");

OutputStream os   = response.getOutputStream();

byte buffer[] = new byte[1024];

int len = 0;

while((len=is.read(buffer))!=-1){

os.write(buffer,0,len);

}

os.close();

is.close();

}

}

如果下载的是中文文件，就把上面代码中的

String path =context.getRealPath("/WEB-INF/classes/res/aa.jpg")

aa.jpg改为汉字

把response.setHeader("content-disposition", "attachment;filename=");

加上URLEncoder.encode(file.getName(), "UTF-8")

如：response.setHeader("content-disposition", "attachment;filename="+URLEncoder.encode(file.getName(), "UTF-8"));

ServletContext应用

 前提：  1----------Enumeration<E>e代表枚举值

（x|y|z）*代表

              无序的、里面互斥、可单独

              X-----0到多

              y-----0到多

              z-----0到多

应用一：实现Servlet的转发。  

注意：forward与include的区别   

1---forward方法调用后在响应中的没有提交的内容被自动消除。将请求转发给其他的Servlet后，由被调用的Servlet负责对请求做出响应，而原先Servlet的执行则终止。      

2---include方法使原先的Servlet和转发到的Servlet都可以输出响应信息，即原先的Servlet还可以继续输出响应信息。

在测试的Servlet中实现转发的步骤如下:   

要利用ServletContext对象实现转发获取对象 

ServletContext context = this.getServletContext();   

在request对象中存入name属性    

  request.setAttribute("name", wyd");   

          根据转发的地址获取 RequestDispatcher对象  

RequestDispatcher  rd  = context.getRequestDispatcher("/index.jsp");   

       调用转发方法 以下采用任意方法即可    

rd.forward(request, response);   

rd.include(request, response);   

应用二：多个ServletContext通过ServletContext对象实现数据共享。

       1--- 在InitServletde 通过ServletContext方法中利用ServletContext对象存入需要共享的数据。

           获取ServletContext对象

           ServletContext context=this.getServletContext();

           存入共享的数据

           Context.setAttribute(“name”,”wyd”);

       2--- 在其它的Servlet中利用ServletContext对象获取共享的数据   

           获取ServletContext对象

           ServletContext context=this.getServletContext();

           获取共享数据

           String name=context.getAttribute(“name”);

           System.out.println(“共享数据的值是：”+name);

应用三：实现Servlet的转发

注意：重定向与转发的区别

         1---地址栏的区别：转发地址栏不变

         2---处理请求资源的位置不同：sendRedirect()方法可以跨WEB应用程序和服务器重新定位资源来处理请求。forward()方法只能在应用程序内部转发。

         3---传值不同： forward()方法能在转发的地址中获取存入的作用域的值。但是，重定向不能。

应用四：利用ServletContext对象读取资源文件。

（这不会写只好用老师的代码了。。。）   

读取资源文件(properties文件（属性文件）)的三种方式   

配置的properties的内容如下:   

url=jdbc\:mysql\://localhost\:3306/3g   

user=root   

password=root   

获取实现的代码如下:   

 /*获取ServletContext对象*/  

ServletContext context = this.getServletContext();   

//第一种方式    

URL url = context.getResource("WEB-INF/classes/db.properties");   

 InputStream is =  url.openStream();   

//第二种方式   

/*读取db.properties文件*/  

String path =context.getRealPath("WEB-INF/classes/db.properties");   

/*根据文件的路径 构建文件对象*/  

File file = new File(path);   

/*根据file文件对象 创建输入流*/  

InputStream is = new FileInputStream(file);   

//第三种方式   

InputStream is = context.getResourceAsStream("WEB-INF/classes/db.properties ");   

//以三种方式任意一种可以    

/*解析properties的文件*/  

 Properties prop = new Properties();   

//从输入流中读取属性列表（键和元素对）。   

prop.load(is);   

Set<String> set = prop.stringPropertyNames();   

//遍历set集合   

Iterator<String> it = set.iterator();   

 while(it.hasNext()){   

String key = it.next();   

String value = prop.getProperty(key);   

System.out.println(key+"-----"+value);   

 }   

Servlet的细节、ServletConfig对象、ServletContext对象及ServletContext应用

细节一:1. 由于客户端是通过URL地址访问web服务器中的资源，所以Servlet程序若想被外界访问，必须把servlet程序映射到一个URL地址上。这个工作在web.xml文件中使用<servlet>元素和<servlet-mapping>元素完成。

2.<servlet>元素用于注册Servlet，它包含有两个主要的元素：<servlet-name>和<servlet-class>，分别用于设置Servlet的注册名称和Servlet的完整类名。

3．一个<servlet-mapping>元素用于映射一个已注册的Servlet的一个对外访问路径，它包含有两个子元素：<servlet-name>和<url-pattern>，分别用于指定Servlet的注册名称和Servlet的对外访问路径。

    例如:  <web-app>

       <servlet>

              <servlet-name>111 </servlet-name>

              <servlet-class>111t</servlet-class>

</servlet>

      <servlet-mapping>

              <servlet-name>222</servlet-name>

              <url-pattern>/1/1.html</url-pattern>

        </servlet-mapping>

</web-app>

细节二：1.同一个Servlet可以被映射到多个URL上，即多个<servlet-mapping>元素的<servlet-name>子元素的设置值可以是同一个Servlet的注册名。

2.在Servlet映射到的URL中也可以使用*通配符，但是只能有两种固定的格式：一种格式是“*.扩展名”，另一种格式是以正斜杠（/）开头并以“/*”结尾。

例如：1.<servlet-mapping>

            <servlet-name>www </servlet-name>

            <url-pattern>*.do</url-pattern>

</servlet-mapping>

      2. <servlet-mapping>

               <servlet-name>www</servlet-name>

               <url-pattern> /action/*</url-pattern>

</servlet-mapping>

细节三：对于如下的一些映射关系：

Servlet1 映射到 /abc/*

Servlet2 映射到 /*

Servlet3 映射到 /abc

Servlet4 映射到 *.do

问题：

当请求URL为“/abc/a.html”，“/abc/*”和“/*”都匹配，哪个servlet响应

       Servlet引擎将调用Servlet1。

当请求URL为“/abc”时，“/abc/*”和“/abc”都匹配，哪个servlet响应

Servlet引擎将调用Servlet3。

当请求URL为“/abc/a.do”时，“/abc/*”和“*.do”都匹配，哪个servlet响应

       Servlet引擎将调用Servlet1。

当请求URL为“/a.do”时，“/*”和“*.do”都匹配，哪个servlet响应

       Servlet引擎将调用Servlet2。

当请求URL为“/xxx/yyy/a.do”时，“/*”和“*.do”都匹配，哪个servlet响应

       Servlet引擎将调用Servlet2。

细节四：1.Servlet是一个供其他Java程序（Servlet引擎）调用的Java类，它不能独立运行，它的运行完全由Servlet引擎来控制和调度。

2.针对客户端的多次Servlet请求，通常情况下，服务器只会创建一个Servlet实例对象，也就是说Servlet实例对象一旦创建，它就会驻留在内存中，为后续的其它请求服务，直至web容器退出，servlet实例对象才会销毁。

3.在Servlet的整个生命周期内，Servlet的init方法只被调用一次。而对一个Servlet的每次访问请求都导致Servlet引擎调用一次servlet的service方法。对于每次访问请求，Servlet引擎都会创建一个新的HttpServletRequest请求对象和一个新的HttpServletResponse响应对象，然后将这两个对象作为参数传递给它调用的Servlet的service()方法，service方法再根据请求方式分别调用doXXX方法。

细节五：如果在<servlet>元素中配置了一个<load-on-startup>元素，那么WEB应用程序在启动时，就会装载并创建Servlet的实例对象、以及调用Servlet实例对象的init()方法。

       例如：

         <servlet>        

<servlet-name>invoker</servlet-name>

                <servlet-class>

                     org.apache.catalina.servlets.InvokerServlet

               </servlet-class>

              <load-on-startup>2</load-on-startup>

        </servlet>

用途：为web应用写一个InitServlet，这个servlet配置为启动时装载，为整个web应用创建必要的数据库表和数据

细节六：1.如果某个Servlet的映射路径仅仅为一个正斜杠（/），那么这个Servlet就成为当前Web应用程序的缺省Servlet。

2.凡是在web.xml文件中找不到匹配的<servlet-mapping>元素的URL，它们的访问请求都将交给缺省Servlet处理，也就是说，缺省Servlet用于处理所有其他Servlet都不处理的访问请求。

3.在<tomcat的安装目录>\conf\web.xml文件中，注册了一个名称为org.apache.catalina.servlets.DefaultServlet的Servlet，并将这个Servlet        设置为了缺省Servlet。

4.当访问Tomcat服务器中的某个静态HTML文件和图片时，实际上是在访问这个缺省Servlet。

细节七：线程安全

1. 当多个客户端并发访问同一个Servlet时，web服务器会为每一个客户端的访问请求创建一个线程，并在这个线程上调用Servlet的service方法，因此service方法内如果访问了同一个资源的话，就有可能引发线程安全问题。

2.如果某个Servlet实现了SingleThreadModel接口，那么Servlet引擎将以单线程模式来调用其service方法。

3. SingleThreadModel接口中没有定义任何方法，只要在Servlet类的定义中增加实现SingleThreadModel接口的声明即可。 

4.对于实现了SingleThreadModel接口的Servlet，Servlet引擎仍然支持对该Servlet的多线程并发访问，其采用的方式是产生多个Servlet实例对象，并发的每个线程分别调用一个独立的Servlet实例对象。

5.实现SingleThreadModel接口并不能真正解决Servlet的线程安全问题，因为Servlet引擎会创建多个Servlet实例对象，而真正意义上解决多线程安全问题是指一个Servlet实例对象被多个线程同时调用的问题。事实上，在Servlet API 2.4中，已经将SingleThreadModel标记为Deprecated（过时的）。  

ServletConfig对象

1. 在Servlet的配置文件中，可以使用一个或多个<init-param>标签为servlet配置一些初始化参数。

2. 当servlet配置了初始化参数后，web容器在创建servlet实例对象时，会自动将这些初始化参数封装到ServletConfig对象中，并在调用servlet的init方法时，将ServletConfig对象传递给servlet。进而，程序员通过ServletConfig对象就可以得到当前servlet的初始化参数信息。
3. 阅读ServletConfig API，并举例说明该对象的作用：

a)        获得字符集编码

b)        获得数据库连接信息

c)        获得配置文件，查看struts案例的web.xml文件

ServletContext对象

1. WEB容器在启动时，它会为每个WEB应用程序都创建一个对应的ServletContext对象，它代表当前web应用。

2. ServletConfig对象中维护了ServletContext对象的引用，开发人员在编写servlet时，可以通过ServletConfig.getServletContext方法获得ServletContext对象。

3. 由于一个WEB应用中的所有Servlet共享同一个ServletContext对象，因此Servlet对象之间可以通过ServletContext对象来实现通讯。ServletContext对象通常也被称之为context域对象。

4. 查看ServletContext API文档，了解ServletContext对象的功能。

ServletContext应用

1. 多个Servlet通过ServletContext对象实现数据共享。

2. 获取WEB应用的初始化参数。

3. 实现Servlet的转发。

4. 利用ServletContext对象读取资源文件。

a)        得到文件路径

b)        读取资源文件的三种方式

c)        .properties文件（属性文件）

一、 “java.sql.SQLException: Data truncated for column 'sex' at row 1”html信息输入界面获取问题，可能有两种，method方法拼写错误，或者sex不一致，另一种html错误没有写完整，例如缺少结束标签等！

*=0到多次

+=1到多次

？=0到多次

，代表有序

|代表互斥！

Enumeration<E>e代表枚举值

二、getServletContext() 和getServletConfig() 的不同

 getServletConfig() 

   在servlet初始化时，容器传递进来一个ServletConfig对象并保存在servlet实例中，该对象允许访问两项内容：初始化参数和

ServletContext对象，前者通常由容器在文件中指定，

允许在运行时向sevrlet传递有关调度信息，比如说getServletConfig().getInitParameter("debug")后者为servlet提供有关容器的信息。

此方法可以让servlet在任何时候获得该对象及配置信息。 

getServletContext() 

一个servlet可以使用getServletContext（）方法得到web应用的servletContext 。即而使用getServletContext的一些方法来获得一些值  。比如说getServletContext().getRealPath("/")来获得系统绝对路径。 getServletContext().getResource("WEB-INF/config.xml")来获得xml文件的内容。getServletContext()取得的是 <context-param>配置的参数  getServletConfig()取得的是 <servlet> <init-param>配置的参数

2： getServletContext()应用于整个web App,而getServletConfig()仅应用于当前Servlet。 但是ServletConfig对象拥有ServletContext的引用。所以可以通过getServletConfig()来获得web App的初始值。

http协议： 请求响应举例

一个HTTP响应代表服务器向客户端回送的数据，包括：一个状态行、若干消息头、以及实体内容 。

状态行

      格式： HTTP版本号　状态码　原因叙述<CRLF>（如：HTTP/1.1 200 OK）

状态码：用于表示服务器对请求的处理结果，它是一个三位的十进制数。

一些状态码的意义：

100～199表示成功接收请求，要求客户端继续提交下一次请求才能完成整个处理过程

200～299表示成功接收请求并已完成整个处理过程，常用200

300～399为完成请求，客户需进一步细化请求。例如，请求的资源已经移动一个新地址，常用302、307和304

400～499客户端的请求有错误，常用404

500～599服务器端出现错误，常用 500

响应头

Location：服务器通过这个头告诉浏览器去访问哪个页面，这个头通常配合302状态码使用

Content-Encoding: 服务器通过这个头告诉浏览器，回送的数据采用的压缩格式

Content-Length:  服务器通过这个头告诉浏览器，回送的数据的大小

Content-Type: 服务器通过这个头告诉浏览器，回送数据的类型

Last-Modified: 服务器通过这个头告诉浏览器，资源的最后修改时间

Refresh：服务器通过这个头告诉浏览器，定时刷新网页

Content-Disposition: attachment; filename=aaa.zip：服务器通过这个头告诉浏览器，以下载方式打开数据

ETag: W/"7777-1242234904000"：缓存相关的头，为每一个资源配一个唯一的编号

HTTP请求头字段

Range头指示服务器只传输一部分Web资源，可以用来实现断点续传功能。

Range设置要传输的字节范围：

Range： bytes=1000-2000（传输范围从1000到2000字节）

Range： bytes=1000-（传输Web资源中第1000个字节以后的所有内容）

Range bytes=1000（传输最后1000个字节）

HTTP响应消息头字段

Accept-Ranges：说明Web服务器是否支持Range。若支持，返回bytes；若不支持，则返回none.

Content-Range：指定返回的Web资源的字节范围。

格式为：Content-Range：Range字段（如：Content-Range：1000-3000/5000

动态web资源：页面中供人们浏览的数据是由程序产生，不同时间点访问web页面看到的内容各不相同。

jsp技术的特点:允许页面中嵌套java代码，为用户提供动态数据。

jsp与servlet的区别：

servlet做为web应用中得控制器组件来使用。

Jsp技术作为数据显示模板来使用。

Servlet负责响应请求产生数据，并把数据通过转发通过转发技术带给jsp.数据的显示交给jsp来做。

因为允许页面中嵌套java代码，为用户提供动态数据。并且web服务器在执行jsp时，web服务器会传递web开发相关的对象给jsp。Jsp通过这些对象，可以与浏览器进行交互，所以jsp当然也是一种动态的web资源的开发技术。

Jsp语法：

<%

  Java代码

%>

Jsp声明：

可用于定义jsp页面转换成的servlet程序的静态代码块、成员变量和方法。

对个静态代码块、变量和函数可以定义在一个jsp声明中，也可以分别单独定义在对个jsp声明中。

Jsp注释：

注释的格式：<%-- 注释信息 --%> jsp页面翻译成Servlet程序时，忽略jsp页面中被注释的内容。

乘法口诀，水仙花数，正三角形案例。

<body>
   <div>
      <div>
       <h1>乘法口诀</h1>
       <hr color="red"/>
      </div>
      <div>
     <%
     for(int i=1 ;i<10;i++){
      for(int j=1;j<=i;j++){
     %>
      <%=j%>*<%=i%>=<%=j*i%> 
     <%
     }
     %>
     <br/>
     <%
     }
     %>
      <br/>
     </div>
     <div>
     <h1>水仙花数</h1>
     <hr color="red"/>
     </div>
     <div>
       <%
          for(int m=0;m<1000;m++){
       %>
         <% int a=m/100; %>
         <% int b=(m-100*a)/10; %>
         <% int c=m-100*a-10*b; %>
        <% 
           if(a*a*a+b*b*b+c*c*c==m){
        %>
        <%=m %>是水仙花数<br/>
        <% } %>
        <% } %>
     </div>
     <div>
     <h1>正三角</h1>
     <hr color="red"/>
     </div>
     <div  align="center">
        <% for(int w=1;w<=9;w++){ 
           for(int y=1;y<9-w;y++){ %>
        <% } %>
        <% for(int z=1;z<=2*w-1;z++){ %>
         *
        <% } %>
        <br/>
        <% } %>
  </div>
  </div>
 
   </body>

 一、 http协议简介：

  客户端连上服务器后，向服务器请求某个web资源，称之为客户端向服务器发送了一个HTTP请求。

   HTTP请求的细节 ——消息头

   用于HTTP请求中的常用头

• Accept: text/html,image/*   

• Accept-Charset: ISO-8859-1

• Accept-Encoding: gzip,compress

• Accept-Language: en-us,zh-cn

• Host: www.it315.org:80

• If-Modified-Since: Tue, 11 Jul 2000 18:23:51 GMT

• Referer: http://www.it315.org/index.jsp

• User-Agent: Mozilla/4.0 (compatible; MSIE 5.5; Windows NT 5.0)

•Cookie

• Connection: close/Keep-Alive   

• Date: Tue, 11 Jul 2000 18:23:51 GMT

 

五、http协议请求的举例：

 

六、 http响应

一个HTTP响应代表服务器向客户端回送的数据，它包括：一个状态行、若干消息头、以及实体内容 。

 

七、 http响应的举例

Javabean

javabean：它是一个遵循特定写法的java类。

Javabean的特点： 这个java类必须具有一个无参的构造函数。

                  属性必须私有化。

                  私有化的属性必须通过public类型的方法暴露给其他程序，并且方法的命名也必须遵守一定的命名规范。

Javabean的属性：1--JavaBean的属性可以是任意类型，并且一个JavaBean可以有多个属性。每个属性通常都需要具有相应的setter、 getter方法，setter方法称为属性修改器，getter方法称为属性访问器。

             2--属性修改器必须以小写的set前缀开始，后跟属性名，且属性名的第一个字母要改为大写，例如，name属性的修改器名称为setName，password属性的修改器名称为setPassword。

           3--属性访问器通常以小写的get前缀开始，后跟属性名，且属性名的第一个字母也要改为大写，例如，name属性的访问器名称为getName，password属性的访问器名称为getPassword。

4--一个JavaBean的某个属性也可以只有set方法或get方法，这样的属性通常也称之为只写、只读属性。

Javabean在jsp中得使用标签：

                 1--<jsp:useBean>标签：用于在jsp页面中查找或实例化一个javabean组件。它用于在指定的域范围内查找指定名称的JavaBean对象：

                              a.如果存在则直接返回该JavaBean对象的引用。

                              b.如果不存在则实例化一个新的javabean对象并将它以指定的名称存储到指定的域范围中。

                   常用语法：1<jsp:useBean id="beanName" class"/> ="package.class"

                                                               scope="page|request|session|application

                                  2<jsp:useBean…>

                                        Body

                                   </jsp:useBean>

                 2--<jsp:setProperty>标签：用于在jsp页面中设置一个javabean组件的属性。

                   语 法：<jsp:setProperty name="beanName"

{

                                  property="propertyName" value="{string | <%= expression %>}" |

                                  property="propertyName" [ param="parameterName" ] |

                                  property= "*"

}/>

                 3--<jsp:getProperty>标签：用于在jsp页面中获取一个javabean组件的属性。

                   语法：<jsp:getProperty name="beanInstanceName" property="PropertyName" />

 //写汉字  
   String base = "\u7684\u4e00\u4e86\u662f\u6211\u4e0d\u5728\u4eba\u4eec\u6709\u6765\u4ed6\u8fd9\u4e0a\u7740";
        //写4个字
  Color c = Color.BLUE;
  g.setColor(c);
  Font font = new Font("宋体", Font.ITALIC, 20);
        g.setFont(font);
        
        StringBuffer sb = new StringBuffer();
        //产生汉字
        for(int i=0;i<4;i++){
         int location = new Random().nextInt(base.length()-1);
      char chr = base.charAt(location);
      sb.append(chr+"");
        }
        checkCode=sb.toString();
        Graphics2D gd = (Graphics2D) g;
        gd.rotate(0.05);
        //把汉字写到图片上
        g.drawString(checkCode, 10, 20);

 }

public static  void outImage(OutputStream os) throws IOException{
  //创建图片
  BufferedImage image = new BufferedImage(WIDTH, HEIGHT, IMAGETYPE);
  //得到图型
  Graphics g = image.getGraphics();
  // 设置图片背景色
  setBackground(g);
  //向图片上写边框
  setBorder(g);
  //向图片上写干扰线
  setRandomLine(g);
  // 7、向图片上写数据
  setFont(g);
  // 8、把图片写给浏览器
  ImageIO.write(image, "gif", os);
 }

//清楚浏览器缓存

      response.setIntHeader("expires", 0);

      response.setHeader("Cache-Control", "no-cache");

      response.setHeader("Pragma", "no-cache");

      //通知浏览器以图片的方式打开

      response.setHeader("Content-Type", "image/jpeg");