javaweb应用程序概述

阅读量：5344 次

发布时间：2019-06-15

本文共 22980 字，大约阅读时间需要 76 分钟。

1、HTTP(超文本传输协议)，它是一种主流的B/S架构中应用的通信协议。具有以下特点:

1.1、无状态：服务不会记录客户端每次提交的请求，服务器一旦响应客户端之后，就会结束本次的通信过程，客户端下一次的请求是一个新的连接，和上一次通信没有任何关系

1.2、简单灵活：HTTP是基于请求和响应的模型

支持客户端与服务端：

1.3、支持主流的B/S以及C/S架构的通信。C/S架构可选的协议有多种，列如：TCP/IP、UDP、HTTP、等，而B/S架构通常只支持HTTP协议。

2、服务器

2.1、概念

服务器同常由硬件和软件部分构成，对用户提供相应的服务

硬件：包括相应的CPU、内存、磁盘、等等

软件：包括操作系统、运行环境、服务端软件、数据库等等

2.2、Web服务器

web服务器是提供服务端程序运行的一个环境，它本身也是一个软件

列如：将我们编写的html文件放到web容器服务器中，那么外界就可以通过浏览器来访问我们的HTML页面，

常见的web服务器有Apache、Tomcat、Jetty、Nginx等等，而Tomcat、Jetty、这些web服务器更准确地来说是一个Servlet容器

3. Web项⽬结构

录，例如： myweb、 ch01	通常存放静态资源⽂件（如： html等等）
WEB-INF	这个⽬录是当前项⽬私有的⼀个⽂件夹，只能提供给项⽬内部访问，对于客户端来说是访问不到了，通常这个⽬录下存放的是Java源代码、编译后的字节码⽂件以及Servlet的核⼼配置⽂件web.xml
src	存放Java源代码的⽬录
classes	存放编译后的字节码⽂件
llib	lib⽬录存放当前项⽬所需要的jar⽂件
jsp ⻚⾯	⽤于存放JSP动态
web.xml	项⽬的配置⽂件，⽤于配置Servlet的请求映射、过滤器、监听器等等信息。每⼀个web项⽬都对应⼀个web.xml配置⽂件

4. Servlet基础

4.1 什么是Servlet6

Servlet是JavaEE中的标准组件之⼀，专⻔⽤于处理客

户端的HTTP请求。并且它必须依赖于Servlet容器

（Tomcat就是⼀个标准的Servlet容器）才可以运⾏，

⽽不能脱离这个环境⽽单独执⾏。因为Servlet实例的

创建和销毁都是由容器负责管理的，我们不能⾃⾏通过

new关键去创建和使⽤它。

4.2 编写⼀个简单的Servlet

1.在任意地⽅创建⼀个myweb⽂件夹，这个⽂件夹相

当于⼀个项⽬根⽬录

2.在根⽬录下创建WEB-INF⼦⽬录

3.在WEB-INF⽬录下创建src和classes⼦⽬录

4.在src⽬录下编写⼀个类，继承HttpServlet这个⽗类

public class HelloServlet extendsHttpServlet	{}

2.重写⽗类的service⽅法，这个就是专⻔处理客户端请

求的⽅法， web容器会为这个⽅法传⼊两个参数

HttpServletRequest和HttpServletResponse,并且这个

⽅法还需要抛出ServletException和IOException给容

器捕获

public class HelloServlet extendsHttpServlet	{public void service(HttpServletRequestrequest,	 HttpServletResponseresponse)throws ServletException,	IOException{//设置响应类型及编码response.setContentType("text/html;charset=utf-8");//获取字符输出流输出html信息response.getWriter().println("Hello	Servlet
")}}

5.编译Servlet，需要依赖servlet-api.jar⽂件,将它添加

到classpath中

javac    -cp    d:\servlet-api.jar;HelloServlet.java

6.将编译后的HelloServlet.class⽂件剪切到classes⽬

录中

7.在WEB-INF⽬录下创建并编辑web.xml⽂件，为

servlet配置请求映射


     
     
     
      
      
       
       
        hello
       
       
       
        HelloServlet
       
      
      
      
       
       
        hello
       
       
       
        /hello

8.将项⽬部署都tomcat的webapps⽬录中,并执⾏bin⽬

录下的startup.bat启动容器

9.打开浏览器，在地址栏输⼊http://localhost:8080/m

yweb/hello访问Servlet

4.3 Servlet的请求处理流程

浏览器发起http的请求，这个请求⾸先会被servlet容器

（Tomcat）截获，然后容器会根据web.xml⽂件中配

置servlet的来找到相应的这个别名，然后再根据这个

别名找到具体Servlet的类，然后容器会创建这个

Servlet类的实例并调⽤service⽅法来处理这个请求。

4.4 Servlet的⽣命周期

所谓的⽣命周期，就是从Servlet的创建⼀直到它销毁

的整个过程。并且它的这个⽣命周期都是由Servlet容

器（Tomcat）负责管理和维护的。（补充：在Tomcat

中， Servlet是以单实例多线程的⽅式处理客户端请

求）

4.4.1 Servlet对象创建的过程

当第⼀次请求某个Servlet的时候，容器会先查找之前

有没有创建过这个Servlet的实例，如果没有则创建⼀

个并缓存起来。后续相同的请求都由这个缓存的对象来

处理。（注意：这⾥说的是第⼀次请求时创建。另外⼀

种情况则是在容器启动的时候就创建Servlet的实例，

4.4.2 ⽣命周期⽅法

⽅法名	描述
init	在Servlet对象创建之后⽴即执⾏的初始化⽅法，且只执⾏⼀次
service	核⼼的请求处理⽅法，这个⽅法可以执⾏多次
destroy	容器准备销毁Servlet实例之前执⾏这个⽅法，也是执⾏⼀次

在web.xml中为Servlet指定配置，这个配置的值是⼀个整型，数值越⼩，则初始化的优先级别越⾼）

4.5 HTTP报⽂组成

4.5.1 请求报⽂

请求⾏：请求报⽂的第⼀⾏就是请求⾏。包括请求⽅

法、请求URL地址、 HTTP协议版本。

请求头：请求⾏之后的信息就是请求头，它是以“名称:

内容”的格式体现。主要包括服务器主机地址及端⼝、

连接状态、系统信息、编码、语⾔等等。

请求体：请求头结束之后会有⼀个空⾏，空⾏之后就是

请求体的内容。通常使⽤POST提交的数据信息会存放

在请求体当中，然后传递给服务器。

4.5.2 响应报⽂

状态⾏：主要包括HTTP协议、响应状态码（例如：

200表示OK，成功响应）。

响应头：主要包括服务器信息、响应的类型及编码、内容的⻓度、响应的时间等。

响应体：服务端可以将信息数据携带到响应体中，带回客户端。

4.6 HTTP请求⽅法

在HTTP/1.1协议中，请求⽅法主要包括8个，下⾯列举

常⽤的请求⽅法进⾏说明。

⽅法	说明
GET	向服务器请求指定的资源，并返回响应主体。⼀般来说GET⽅法应该只⽤于数据的读取（类似于查询）
POST	向指定的服务器提交数据（例如：表单数据的提交、⽂件上传等） ,并且提交的数据会放⼊请求体中（类似于新增）
PUT	向服务器提交数据，但是和POST有所区别。如果服务器不存在此资源的时候，则执⾏新增，如果存在则执⾏修改（类似于修改）
DELETE	根据uri的标识删除服务器上的某个资源（类似于删除）
其他	...

备注： GET与POST区别：

1.GET主要⽤于获取数据， POST⽤于提交数据。

2.GET请求所带的参数是放在请求⾏的url地址后⾯，⽽POST这是放在请求体中。

3.通常浏览器会对GET请求的url⻓度有所限制，⽽POST提交的数据在请求体中，可以提交更多的内容。

⽅法	说明
service	可以处理任何的请求类型
doGet	处理对应的GET请求
doPost	处理对应的POST请求
doPut	处理对应的PUT请求
doDelete	处理对应的DELETE请求
其他	...

4.浏览器会对GET请求进⾏缓存

说明：通过HttpServlet的源代码得知，默认的所有请求都会先经过service⽅法，然后service⽅法根据请求

的⽅法类型判断来决定交给doGet或者是doPost⽅法来处理请求。如果⼦类重写了⽗类的service⽅法同时

还重写了其他的doXxx的⽅法，那么只有service⽅法会处理请求，其他⽅法将失效。

4.8 Request与Response对象

当web容器调⽤某个Servlet的Service⽅法时，会创建⼀个HttpServletRequest和HttpServletRespinse对象

作为参数传⼊到这个⽅法中，那么我们可以通过HttpServletRequest来获取相关的请求内容等，⽽响应客户端

可以利⽤HttpServletResponse对象来完成。

4.9 Servlet之间的通信

4.9.1转发

所谓转发就是在多个Servlet之间共享请求和响应对象，所有参与转发的过程的Servlet都可以获取同一个请求对象的信息。

在servlet的API中，转发的操作有HttpServletRequest

示例代码：

package edu.nf.ch06.servlet;import java.io.IOException;import javax.servlet.RequestDispatcher;import javax.servlet.ServletException;import javax.servlet.http.HttpServlet;import javax.servlet.http.HttpServletRequest;import javax.servlet.http.HttpServletResponse;public class ServletA extends HttpServlet{		public void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException{		System.out.println("请求经过ServletA，准备转发给ServletB...");		//获取页面提交的参数		String name = request.getParameter("userName");		System.out.println("ServletA获取请求参数："+name);				//可以使用请求作用域（requestScope）而外携带一些数据到ServletB		request.setAttribute("age", 35);		System.out.println("设置请求作用域：age = " + 35);		//转发由HttpServletRequest完成		//第一步先获取一个请求转发器RequestDispatcher		//获取请求转发器的同时要告诉转发器转发到哪里，转发给谁		//如果要转发给ServletB，那么就是对应ServletB的url-pattern		RequestDispatcher rd = request.getRequestDispatcher("servletB");		//调用转发器的forward方法执行转发,同时将request和response对象一并转发ServletB		rd.forward(request, response);			}}

package edu.nf.ch06.servlet;import java.io.IOException;import javax.servlet.ServletException;import javax.servlet.http.HttpServlet;import javax.servlet.http.HttpServletRequest;import javax.servlet.http.HttpServletResponse;public class ServletB extends HttpServlet{	@Override	protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {		System.out.println("请求到达ServletB,并接收了同一个请求和响应对象");		//这里在同一个请求中再次获取页面的参数		String name = request.getParameter("userName");		//从请求作用域中取出相应的值		Integer age = (Integer)request.getAttribute("age");		System.out.println("ServletB获取请求参数："+name);		System.out.println("ServletB获取请求作用域的值："+age);	}}


       	
      
       servletA
        	
      
       edu.nf.ch06.servlet.ServletA
        
       
       	
      
       servletA
        	
      
       /servletA
        
       
       	
      
       servletB
        	
      
       edu.nf.ch06.servlet.ServletB
        
       
       	
      
       servletB
        	
      
       /servletB


     Insert title here 测试转发

转发的特点：

1、url的地址栏是不会发生改变的

2、转发的过程是在服务端自动完成的

4.9.2 重定向

重定向的机制和转发不同，一次重定向的过程中会有两次请求和两次响应，服务器在接受第一次请求后悔先做一次302响应（302表示重定向状态码）

告诉客户端浏览器必须发起一个新的请求地址，服务端再次接受这个请求处理，最后再次响应到客户端。由于会产生不同的响应对象，因此并不同共享同一个请求的参数

重定向是服务器通知浏览器去访问另一个地址，即再发出另一个请求。

下面用一张图来简单描述下：

重定向的特点：

1、URL地址栏会发生改变

2、重定向的操作是在客户端浏览器完成的

示例代码：

package edu.nf.ch06.servlet;import java.io.IOException;import javax.servlet.ServletException;import javax.servlet.http.HttpServlet;import javax.servlet.http.HttpServletRequest;import javax.servlet.http.HttpServletResponse;public class ServletC extends HttpServlet {	@Override	protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {		System.out.println("请求到达ServletC");		System.out.println("ServletC获取请求参数："+request.getParameter("userName"));		//执行重定向		//方式一：设置302响应状态码，并在响应头中添加location属性指定重定向的地址		//response.setStatus(302);		//response.addHeader("location", "http://localhost:8080/ch06/servletD");				//方式二：		response.sendRedirect("servletD");	}}

package edu.nf.ch06.servlet;import java.io.IOException;import javax.servlet.ServletException;import javax.servlet.http.HttpServlet;import javax.servlet.http.HttpServletRequest;import javax.servlet.http.HttpServletResponse;public class ServletD extends HttpServlet{	@Override	protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {		System.out.println("重定向到ServletD");		System.out.println("ServletD获取请求参数："+request.getParameter("userName"));	}}


     Insert title here 测试重定向

4.10会话跟踪

由于HTTP协议是无状态的，服务器并不会记录每一个客服端的状态，因此，如果想要实现服务器能记录客服端的状态的话，那么就需要会话跟踪技术

4.1.1cookie

cookie是客服端浏览器内部的一个文本文件，专门用于记录服务器发送过来的一些文本信息，那么再次请求的时候，都把这个cookie信息由提交回给

相应的服务器，那么服务器就可以获取客服端保存的信息，达到会话跟踪的目的，使用cookie的机制是基于客户端浏览器来维护与服务端的状态跟踪

cookie的生命周期：

示例代码：

默认cookie只会保存在浏览器进程的内存中，并不会写入cookie文件，如果关闭了浏览器，那么浏览器的进程也就会消失，那么对应的内存就会释放空间，

因此cookie也就销毁。如果想要cookie写入文件，那么就必须设置cookie的生命时长，一旦设置了生命时长，那么就表示这个cookie会在文件中保留多长

时间，到了这个时间之后，浏览器就会自动销毁这个cookie

设置cookie：

public class SetCookieServlet extendsHttpServlet{protected voidservice(HttpServletRequest request,HttpServletResponse response)	throwsServletException,	IOException	{//创建⼀个Cookie的实例Cookie cookie = newCookie("userId","10001");//将cookie对象设置到响应对象中response.addCookie(cookie);System.out.println("成功设置cookie");}}

获取cookie

public class GetCookieServlet extendsHttpServlet{@Overrideprotected voidservice(HttpServletRequest request,HttpServletResponse repsonse)	throwsServletException,	IOException	{//cookie是通过request对象来得到的//从请求中可以获取多个cookie对象Cookie[]	cookies =request.getCookies();for	(Cookie cookie	:	cookies)	{//判断cookie，只获取name为userId的cookie对象if("userId".equals(cookie.getName()))	{System.out.println(cookie.getValue());}}}}

cookie保存中文：

在保存cookie的时候如果需要保存中⽂，那么中⽂信息

需要经过编码后才可以写⼊cookie

示例代码：

编码使⽤URLEncoder

String str = URLEncoder.encode("张三","utf-8");Cookie cookie = new Cookie("userName",str);

解码使⽤URLDecoder ：

String str =URLDecoder.decode(cookie.getValue(),"utf-8");System.out.println(str);

设置cookie的存活时间：

示例代码：

//设置为0表示⽴即删除cookiecookie.setMaxAge(0);//设置为正数表示cookie在cookie⽂件的存活时间，单位：秒cookie.setMaxAge(5);//设置为-1表示cookie只保留在浏览器器的进程中，关闭浏览器之后会销毁cookiecookie.setMaxAge(-1);

4.4.2 Session

Session是基于服务端来保存用户的信息，这个是和cookie最大的区别。不同的客服端在请求的服务器的时候，服务器会为每一个客服端创建一个

Session对象并保存在服务器端，Session对象是每一个客服端所独有的，相互之间不能访问。服务器为了区别不同的Session属于哪一个客户端，因此Session

对象也有一个唯一标识，叫做SessionID.而这个SessionID是以cookie的机制保存在客户端浏览器。每次请求的时候，浏览器都会把这个SessionID带回服务端，服务端

根据这个SessionID就可以找到对应的Session对象

示例代码：

public class SessionServlet extendsHttpServlet{@Overrideprotected voidservice(HttpServletRequest request,HttpServletResponse response)    throwsServletException,    IOException    {//HttpSession对象是在第⼀次调⽤request的getSession()⽅法时才会创建//注意： getSession()的⽅法会先判断之前是否为客户端创建了session实例，//如果创建了，则使⽤之前创建好的Session对象，没有则创建⼀个新的SessionHttpSession session =request.getSession();//创建HttpSession的同时，会创建⼀个唯⼀的标识SessionID//这个sessionId会保存在浏览器的cookie中，每次请求会带回这个id找到相应的session对象String sessionId = session.getId();System.out.println(sessionId);}}

Session的生命周期：Session是保存在浏览器的cookie中，但是不会写入cookie文件中，这也就是表示当关闭浏览器之后，Sessionid就会销毁，Sessionid销毁之后，服务端

的Session就没有如何作用了，但是，服务器并不会立刻销毁这个Session对象，至于什么时候销毁是由服务器自己决定的，除非我们手动调用了Session.invalidate()

方法，服务器就会立刻销毁这个session实例

例如：

HttpSession session = request.getSession(); //⽴即销毁session session.invalidate();

2、Session默认也有存活时间，服务器创建session的时候，session设置默认的存活时间为30分钟，如果在30分钟之内，

客户端没有发起任何请求到服务器来到服务器，那么服务器就会销毁这个Session对象，我们也可以设置Session的存活时间，

可以为当前的Session设置，也可以为全局(服务端所有的Session)的Session设置

设置当前的Session的超时(存活)时间：

HttpSession session = request.getSession();//设置当前Session的存活时间，单位：秒session.setMaxInactiveInterval(3600);

设置全局的Session存活时间：

在web.xml中进⾏设置：

Session的作用域：

当我们需要一些数据信息出入Session的时候，就需要操作Session作用域(SessionScope)，它和请求作用域类似，也有相应的setAttribute和getAttribute

的方法，只不过Session作用域的范围要比请求作用域更宽，请求的作用域在一次请求响应之后，就会消失，（因为响应之后请求对象就会销毁）。而Session

对象只要浏览器不关闭或者Session对象会一直驻留在服务器端，因此不管重新请求多少次还是转发和重定向，都可以重Session中获取之前保存的数据信息

代码示例：

User user = new User();user.setUid("1001");user.setUserName("wangl");HttpSession session = request.getSession();//将数据保存在会话作⽤域中session.setAttribute("user",    user);

重回复作用域中取值：

HttpSession session = request.getSession();//取值User user =(Object)session.getAttribute("user");

URL的重写：

浏览器是可以禁⽤cookie的，⼀旦禁⽤了cookie，那么SessionId将⽆法写⼊cookie的缓存中，这样就导致⽆

法实现会话跟踪了，因此解决办法就是使⽤URL重写。URL重写的⽬的就是把SessionId在放在请求URL地址

的后⾯提交回服务器（类似GET请求后⾯带上参数，⽽这个参数就是⼀个SessionId），服务器会解析这个

URL的地址并得到SessionId。

代码示例：

//重写请求的URL地址，这个地址后⾯会⾃动带上SessionIdString url =response.encodeRedirectURL("getSession");//重定向URLresponse.sendRedirect(url);

浏览器地址演示:

http://localhost:8080/ch07/getSession;jsessionid=6F1BA8C92D7E5D7CC479ED8DD30D3ED0

4.11 Servlet上下文

web容器在启动时会为每一个web应用创建唯一的上下文对象，这个对象就是Servlet上下文对象（ServletContext），这个上下文对象可以理解为是当前项目的一个共享内存空间，为项目中的所有Servlet提供一个共享的区域。

常用API：

getContextPath()	获取项目的相对路径
getRealPath(String path)	获取项目的绝对路径
getInitParameter(String name)	获取上下文的初始化参数（web.xml中配置的）
setAttribute(String name, String value)	将数据放入上下文作用域
getAttribute(String name)	从上下文作用域中去获取数据

上下文作用域：

上下文作用域是为当前项目所有Servlet提供的一个共享内存区域，可以将需要的数据信息保存在作用域中。这个作用域的的范围是最大的，只要容器没有停止，它就会一直存在。

三种作用域：

结合前面所学的作用域，那么一共有三个，分别是：请求作用域，会话作用域，上下文作用域。

范围从小到大来划分:

请求作用域>会话作用域>上下文作用域

4.12 过滤器

过滤器可以在请求到达servlet之前和servlet响应客户端之前进行拦截，相当于一个拦截器

主要用于进行一些请求和响应的预处理操作，通常用的场景有限制权限的控制、统一字符编码

4.12.1编写过滤器

要实现一个过滤器必须要实现一个Filter接口，只有实现了这个接口的类才称之为过滤器

示例代码:

public class DemoFilter implements Filter {    ...}

web.xml配置过滤器：


            
       
        demoFilter
             
       
        edu.nf.ch09.filter.DemoFilter
             
             
                 
        
         param
                  
        
         hello
              
         
        
            
       
        demoFilter
             
             
       
        /*

4.12.2过滤器的生命周期

与servlet类似，Filter同样也是容器负责创建和销毁，与servlet的区别在于，容器会在启动的时候最先创建所有

的顾虑器，并执行init方法进行初始化

生命周期的方法：

方法	说明
init	初始化方法，容器启动时执行一次
doFilter	请求过滤方法，决定请求是否放行
destroy	容器销毁过滤器之前执行的方法

实例代码：

public class DemoFilter implements Filter{    @Override    public void destroy() {                System.out.println("准备销毁DemoFilter");    } 　@Override    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)            throws IOException, ServletException {        //FilterChain表示一个过滤链对象，因为过滤器可能会存在多个        //同时这个对象将决定是否放行当前请求，        //放行的话则请求会继续到达下一个过滤器或者servlet中        System.out.println("请求经过DemoFileer..放行");        chain.doFilter(request, response);        System.out.println("响应前经过DemoFilter...");    }@Override    public void init(FilterConfig config) throws ServletException {        String name = config.getInitParameter("param");        System.out.println("初始化DemoFilter，获取初始化参数："+name);    }}

4.12.3 过滤链

在一个web项目中可能存在多个过滤器，当有多个过滤器存在的时候就会形成一个过滤链。请求会按照过滤器链的顺序一直传递下去，最终到达某个Servlet来处理请求。（注意：过滤链的顺序是按照web.xml中的先后配置顺序决定的）

配置示例：


      
      
          
       
        firstFilter
           
       
        edu.nf.ch09.filter.FirstFilter
       
      
          
       
        firstFilter
           
       
        /*
       
      
      
          
       
        secondFilter
           
       
        edu.nf.ch09.filter.SecondFilter
       
      
          
       
        secondFilter
           
       
        /*

4.13 监听器

监听器用于监听对象的上的事件发生，在Servlet中监听器主要监听请求对象、会话对象、上下文对象以及监听这些对象的作用域操作。JavaEE为我们提供了一系列的监听器接口，开发时按需实现相应的接口即可。

4.13.1 监听作作用域对象的创建与销毁

监听器	说明
ServletRequestListener	监听请求对象的创建和销毁
HttpSesisonListener	监听会话对象的创建和销毁
ServletContextListener	监听Servlet上下文对象的创建和销毁

代码示例：

1.请求对象监听器

public class DemoRequestListener implements ServletRequestListener{    /**     * 当请求对象销毁后容器执行此方法     * 销毁方法中同样也有一个ServletRequestEvent事件对象     */    @Override    public void requestDestroyed(ServletRequestEvent event) {        //通过这个事件对象就可以获取当前的请求对象        HttpServletRequest request = (HttpServletRequest)event.getServletRequest();        System.out.println("销毁请求对象..."+request);    }/**     * 当请求对象创建之后容器调用此方法     * ServletRequestEvent这个参数就是一个事件对象     */    @Override    public void requestInitialized(ServletRequestEvent event) {        //通过这个事件对象就可以获取当前的请求对象        HttpServletRequest request = (HttpServletRequest)event.getServletRequest();        System.out.println("初始化了请求对象..."+request);    }}

web.xml配置


        
          
         
       
        edu.nf.ch10.listener.DemoRequestListener

2、会话监听器

public class DemoSessionListener implements HttpSessionListener{    /**     * 监听HttpSession对象的创建     * HttpSessionEvent参数是一个事件对象     * 通过它可以获得当前的HttpSession     */    @Override    public void sessionCreated(HttpSessionEvent event) {        HttpSession session = event.getSession();System.out.println("创建了Session对象"+session);    }    /**     * 监听HttpSession对象的销毁     */    @Override    public void sessionDestroyed(HttpSessionEvent event) {        HttpSession session = event.getSession();        System.out.println("销毁了Session对象"+session);    }}

注意：当第一次调用了request.getSesison()方法创建Session时，监听器才会起作用。

web.xml配置


          
             
       
        edu.nf.ch10.listener.DemoSessionListener

3.Servlet上下文监听器

public class DemoContextListener implements ServletContextListener{    /**     * 监听ServletContext的销毁     */    @Override    public void contextDestroyed(ServletContextEvent event) {        //通过事件对象获取ServletContext        ServletContext sc = event.getServletContext();        System.out.println("销毁了ServletContext对象..."+sc);}    /**     * 监听SerlvetContext的创建     */    @Override    public void contextInitialized(ServletContextEvent event) {        //通过事件对象获取ServletContext        ServletContext sc = event.getServletContext();        System.out.println("创建了ServletContext对象..."+sc);    }}

配置web.xml


          
             
       
        edu.nf.ch10.listener.DemoContextListener

4.13.2 监听作用域的操作

监听器	说明
ServletRequestAttributeListener	监听请求作用域的操作
HttpSessionAttributeListener	监听会话作用域的操作
ServletContextAttributeListener	监听Servlet上下文作用域的操作

示例代码：

这里以HttpSessionAttributeListener说明，其他作用于监听器用法相似。

public class DemoSessionAttributeListener implements HttpSessionAttributeListener{    /**     * 当有数据添加到会话作用域时，执行此方法     */    @Override    public void attributeAdded(HttpSessionBindingEvent event) {        //获取存入作用域的键和值        System.out.println("存入会话作用域..."+event.getName() + " : " + event.getValue());            }    /**     * 当从会话作用域移除数据时，执行此方法     */    @Override    public void attributeRemoved(HttpSessionBindingEvent event) {        System.out.println("移除会话作用域..."+event.getName() + " : " + event.getValue());            }    /**     * 当替换了会话作用域中的某个数据时，执行此方法     */    @Override    public void attributeReplaced(HttpSessionBindingEvent event) {        HttpSession session = event.getSession();        //从session中获取的是替换之后的值        System.out.println("替换的值： "+session.getAttribute("userName").toString());        //注意：这里event.getValue()获取到的是替换之前的值        System.out.println("替换会话作用域..."+event.getName() + " : " + event.getValue());    }}

web.xml 配置


          
             
       
        edu.nf.ch10.listener.DemoSessionAttributeListener

4.14 注解配置

Servlet3.0开始提供了一系列的注解来配置Servlet、Fiilter、Listener等等。这种方式可以极大的简化在开发中大量的xml的配置。

从这个版本开始，web.xml可以不再需要，使用相关的注解同样可以完成相应的配置。完全配置，

注解	说明
@WebServlet	这个注解标识在类上，用于配置Servlet。例如：@WebServlet(name="hello", urlPatterns="/hello") 也可简化配置@WebServlet("/hello")
@WebFilter	这个注解标识在类上，用于配置Filter。例如：@WebFilter(filterName="encode",urlPatterns="/") 也可简化配置@WebFilter("/"),
@WebListener	这个注解标识在类上，用于配置监听器

5. JSP基础

5.1 简介

JSP全名为java Server Pages,中文名叫java服务器页面，是一种动态页面技术，而HTML是属于静态页面。JSP

可以在HTML中嵌入java脚本代码，因为JSP本质上还是一个Servlet，因此JSP也必须依赖于web容器才能运行

JSP的出现并不是为了去掉Servlet，而是简化了Servlet的工作，将Servlet中繁琐的视图呈现代码脱离出来，交给

JSP来完成，让Servlet专注于请求的处理，所有在开发中通常将jsp和Servlet结合一起使用

5.2JSP引擎

由于JSP本质上就是一个Servlet，那么JSP文件转义成一个Servlet的java源文件，然后通过javac将这个源文件编译成class

字节码文件并装载到JVM中执行，JSP引擎的核心类是JSPServlet，位于Jasper.jar文件张总，并且在Tomcat的web

.xml中也默认就配置好了这个类(JSPServlet也是一个servlet，因此凡是以“.jsp”结尾的请求都会先经过JSPServlet

，那么这个引擎就可以开始工作了。通常引擎转义和编译后的文件放在容器的work工作目录中)

注意：如果第一次访问jsp文件的时候，由于work目录中并不存在源文件和字节码文件，jsp引擎就必须完成这两个工作，

因此，有可能在第一次访问jsp时会比较缓慢，当字节码编译出来加载后，第二次访问时的速度就会很快了

5.3JSP的三大元素

语法：<%@ %>

指令	说明
page指令	用于设置JSP页面的相关信息以及编码
include指令	用于静态包含其他的JSP页面代码,所谓静态包含，就是在编译期，将另外的JSP页面的代码合并到当前的JSP中，最终只会产生一个Java源文件
taglib指令	这个指令用于引入标签库

5.3.2 动作元素

语法：jsp:xxx

动作	说明
include	动态包含其他JSP页面的内容，所谓的动态包含是指在编译期将不同的JSP文件转义成不同的Java源文件，然后在运行时才将目标内容包含到当前的JSP页面中
forward	相当于Servlet中的转发，转发到其他的JSP页面或者Servlet
param	用于传递参数，通常结合其他的动作一起使用，例如转发时需要提交一些而外的参数
useBean	用于在JSP页面中使用JavaBean对象,通常结合setProperty和getProperty来使用，完成bean对象的赋值和取值操作

5.3.3 脚本元素

脚本元素主要就是在JSP中嵌入Java脚本代码，包括声明、表达式、Java脚本

声明语法：<%! %>

表达式: <%= %>

Java脚本: <% %>

代码实例：

<%@ page language="java" contentType="text/html; charset=UTF-8"    pageEncoding="UTF-8"%>
      Insert title here   <%-- 声明变量和方法，这里声明的变量a是实例变量 --%>   <%!          int a = 10;           public void say(){               System.out.println("hello");        }       %>              <%-- 表达式,注意：表达式后面是不允许有;号结束的 --%>       3 + 1 = <%=3+1%>
              <%-- Java脚本,脚本代码最终会生成在servlet中的service方法中作为代码片段 --%>       
      
           <% for(int i=0;i<5;i++){%>             
           <%}%>       
                                                Name                        Age                    
                                  user<%=i%>                           <%=10+i%>

Name	Age
user<%=i%>	<%=10+i%>

5.4 JSP内置对象

内置对象，是在容器运行时将创建好的9个对象内嵌在JSP中，在JSP里可以直接拿来使用的对象。

对象	说明
out	字符流输出对象
config	等同于Servlet中的ServletConfig
page	表示当前JSP页面
request	等同于Servlet中的HttpServletRequest
response	等同于Servlet中的HttpServletResponse
session	等同于Servlet中的HttpSession
application	等同于Servlet中的ServletContext
pageContext	表示当前JSP页面的上下文对象
exception	表示当前JSP中的异常对象

<%@ page language="java" contentType="text/html; charset=UTF-8"    pageEncoding="UTF-8"%>
      Insert title here  <%-- 常用内置对象 --%>  <%       //使用request,API使用同HttpServletRequest一样     request.getParameter("userName");     request.setAttribute("user", "user1");     request.getAttribute("user");          //使用session,API使用等同于HttpSession  session.setAttribute("user", "user2");     session.getAttribute("user");     session.getId();          //使用response     //response.sendRedirect("demo.jsp");          //out对象，等同于字符输出流对象，在JSP页面输出相关内容     out.println("hello world");     //这个是输出在控制中     System.out.println("hello");  //使用application,等同于ServletContext     application.setAttribute("userName", "user3");          //pageContext使用     //从pageContext中获取相关的其他对象     HttpServletRequest req = (HttpServletRequest)pageContext.getRequest();     HttpServletResponse res = (HttpServletResponse)pageContext.getResponse();     HttpSession ses = pageContext.getSession();     ServletConfig conf = pageContext.getServletConfig();     ServletContext sc = pageContext.getServletContext();     //也可以通过pageContext来统一设置不同的作用域    //第三个参数表示要放入到哪个作用域，是一个int类型的参数     //1代表page作用域（当前页面有效）     //2代表请求作用域     //3代表会话作用域     //4代表上下文作用域     pageContext.setAttribute("userName", "zhangsan", 2);     //也可以指定中哪个作用域取出相应的值     String name = (String)pageContext.getAttribute("userName", 2);     out.println(name);  %>

5.5 EL表达式

EL（Expression Language），全称叫做表达式语言，是JSP2.0推出的一种技术。主要简化了在JSP中使用Java脚本表达式。EL表达式的特点在于使用简单，支持四则运算、逻辑运算等，并且还可以对Servlet API中的对象进行数据访问。EL的语法: ${expression}

运算：

示例	结果
${1+1}	2
${2*2}	4
${1==1}	true
${2>5}	false
其他	...

数据访问：

1.使用“.”来访问

示例	说明
${param.参数名}	获取请求参数的值,相当于使用request.getParameter()方法
${requestScope.xxx}	从请求作用域中访问数据
${sessionScope.xxx}	从会话作用域中访问数据
${applicationScope.xxx}	从上下文作用域中访问数据
${xxx}	不指定作用域范围时,默认按照作用域范围从小到大的顺序自动查找
其他	...