Servlet 总结

小灰灰 2022-05-09 09:03 200阅读 0赞

**目录**

1.  **基础**
2.  Servlet容器
3.  Servlet简介
4.  Servlet运行环境
5.  Servlet生命周期
6.  手动创建第一个Servlet程序
7.  使用Eclipse编写Servlet
8.  Servlet API 中主要接口和类
9.  **进阶**
10. Servlet实例（继承HttpServlet抽象类或者实现Servlet接口）
11. Servlet表单数据（继承HttpServlet抽象类，重写doGet（）、doPost（）等方法）
12. Servlet客户端HTTP请求（实现HttpServetRequest 接口）
13. Servlet服务器HTTP响应（实现HttpServletResponse 接口）
14. HTTP协议：浏览器与服务器之间的通信协议。  
    Servlet HTTP状态代码：200,404等等。
15. Servlet网页重定向（redirect）和跳转（forward）：客户端跳转、服务端跳转
16. Servlet编写过滤器（实现接口Filter）：拦截每个页面的请求，看看你是否登录过（Filter就像一个一个哨卡，用户的请求需要经过Filter，并且可以有多个过滤器），可以解决用户是否登录、中文问题等问题
17. Servlet编写监听器：监听web应用是否启动，sesseion是否有创建,request的生命周期（可配置多个监听器）  
    Listener 的作用是用于监听 web应用的创建和销毁，以及在其上attribute发生的变化。   
    web应用即ServletContext对象(jsp的[隐式对象application][application])   
    除了对[web应用][web]的监听外，还能监听[session][]和[request][]的生命周期，以及他们的attribute发生的变化
18. Servlet异常处理
19. Servlet Cookies处理
20. Servlet Session跟踪
    
        cookies处理与session跟踪 都是对数据(request.getParameter("name");)进行处理（临时保存request.getParamerter("name");）
        
        创建（为从表单中转递过来的数据创建cookies）
        设置（为cookies失效时间）
        添加（在response头中添加）
21. ServletContext对象（ServletContext接口）
22. Servlet数据库访问
23. Servlet文件上传
24. Servlet处理日期
25. Servlet 国际化
26. servlet和jsp的区别
27. **练习：**
28. 点击计数器
29. 自动刷新页面
30. 发送电子邮件

<table> 
 <tbody> 
  <tr> 
   <td>Servlet</td> 
   <td>Struts2</td> 
   <td>Spring MVC</td> 
  </tr> 
  <tr> 
   <td> <p>1.简介</p> </td> 
   <td>1.简介</td> 
   <td>1.简介</td> 
  </tr> 
  <tr> 
   <td>2.架构</td> 
   <td>2.架构</td> 
   <td>2.架构</td> 
  </tr> 
  <tr> 
   <td>3.环境设置</td> 
   <td>3.环境设置</td> 
   <td>3.环境设置</td> 
  </tr> 
  <tr> 
   <td>4.运行流程</td> 
   <td>4.运行流程</td> 
   <td>4.运行流程</td> 
  </tr> 
  <tr> 
   <td> <p>5.入门：表单实例</p> <p>配置文件：<br> web.xml文件</p> </td> 
   <td> <p>5.入门：表单实例</p> <p>配置文件：</p> <p>web.xml文件</p> <p>struts.xml映射文件</p> </td> 
   <td> <p>5.入门：表单实例</p> <p>配置文件</p> <p>web.xml文件&nbsp;</p> <p>springmvc.xml映射文件</p> </td> 
  </tr> 
  <tr> 
   <td>关于请求数据保存方法</td> 
   <td>值栈</td> 
   <td>ModelAndMap</td> 
  </tr> 
  <tr> 
   <td>6.servlet对象</td> 
   <td> <p>6.Actions动作</p> <p>接受表单数据</p> </td> 
   <td> <p>6.Controller控制器</p> <p>接受表单数据</p> </td> 
  </tr> 
  <tr> 
   <td>7.Servlet客户端HTTP请求</td> 
   <td>&nbsp;</td> 
   <td>&nbsp;</td> 
  </tr> 
  <tr> 
   <td>8.Servlet服务器HTTP响应</td> 
   <td>&nbsp;</td> 
   <td>&nbsp;</td> 
  </tr> 
  <tr> 
   <td>9.HTTP协议</td> 
   <td>&nbsp;</td> 
   <td>&nbsp;</td> 
  </tr> 
  <tr> 
   <td>10.Servlet网页重定向（redirect）和跳转（forward）</td> 
   <td>&nbsp;</td> 
   <td>&nbsp;</td> 
  </tr> 
  <tr> 
   <td>11.Servlet编写过滤器（实现接口Filter）</td> 
   <td>支持拦截器</td> 
   <td> <p>&nbsp;</p> <p>过滤器Filter：中文问题<br> 支持拦截器</p> </td> 
  </tr> 
  <tr> 
   <td>12.Servlet编写监听器</td> 
   <td>&nbsp;</td> 
   <td>&nbsp;</td> 
  </tr> 
  <tr> 
   <td>13.Servlet异常处理</td> 
   <td>异常处理</td> 
   <td>异常处理</td> 
  </tr> 
  <tr> 
   <td>14.Servlet Cookies处理</td> 
   <td>&nbsp;</td> 
   <td>&nbsp;</td> 
  </tr> 
  <tr> 
   <td>15.Servlet Session跟踪</td> 
   <td>&nbsp;</td> 
   <td>&nbsp;</td> 
  </tr> 
  <tr> 
   <td>16.Servlet数据库访问</td> 
   <td>&nbsp;</td> 
   <td>&nbsp;</td> 
  </tr> 
  <tr> 
   <td>17.Servlet 国际化</td> 
   <td>本地化/国际化（i18n）</td> 
   <td>本地化/国际化（i18n）</td> 
  </tr> 
  <tr> 
   <td>18.Servlet文件上传</td> 
   <td>文件上传</td> 
   <td> <p>上传文件</p> </td> 
  </tr> 
  <tr> 
   <td>&nbsp;</td> 
   <td>类型转换</td> 
   <td> <p>SpringMVC中使用REST风格的url</p> </td> 
  </tr> 
  <tr> 
   <td>&nbsp;</td> 
   <td>主题和模板</td> 
   <td>SpringMVC与前台json数据交互，并应用ajax</td> 
  </tr> 
  <tr> 
   <td>&nbsp;</td> 
   <td>注解</td> 
   <td> <p>注解</p> </td> 
  </tr> 
 </tbody> 
</table>

### 一.Servlet容器 ###

Servlet容器：运行Servlet、jsp、filter等的软件环境，Tomcat服务器就是一个Servlet容器。  
Servlet容器负责Servlet和客户的通信以及调用servlet的方法，Servlet和客户的通信采用“请求/响应”的模式。  
Servlet、Servlet容器和Web服务器三者之间的关系：

![70][]

###    二.Servlet简介 ###

**1.介绍**

Java Servlet是和平台无关的服务器端组件，它运行在Servlet容器中。

Servlet 是服务 HTTP 请求并实现 **javax.servlet.Servlet** 接口的 Java 类。

**2.Servlet 架构**

下图显示了 Servlet 在 Web 应用程序中的位置。

![Servlet 架构][Servlet]

**3.Servlet 任务**

Servlet 执行以下主要任务：

*  读取客户端（浏览器）发送的显式的数据。这包括网页上的 HTML 表单，或者也可以是来自 applet 或自定义的 HTTP 客户端程序的表单。
 *  读取客户端（浏览器）发送的隐式的 HTTP 请求数据。这包括 cookies、媒体类型和浏览器能理解的压缩格式等等。
 *  处理数据并生成结果。这个过程可能需要访问数据库，执行 RMI 或 CORBA 调用，调用 Web 服务，或者直接计算得出对应的响应。
 *  发送显式的数据（即文档）到客户端（浏览器）。该文档的格式可以是多种多样的，包括文本文件（HTML 或 XML）、二进制文件（GIF 图像）、Excel 等。
 *  发送隐式的 HTTP 响应到客户端（浏览器）。这包括告诉浏览器或其他客户端被返回的文档类型（例如 HTML），设置 cookies 和缓存参数，以及其他类似的任务。
 *  与其他服务器资源（如数据库或基于Java应用程序）进行通信。

**4.工作模式：**

1.  客户端发送请求至服务器
2.  服务器启动并调用 Servlet，Servlet 根据客户端请求生成响应内容并将其传给服务器
3.  服务器将响应返回客户端

**5.Servlet 包**

Java Servlet 是运行在带有支持 Java Servlet 规范的解释器的 web 服务器上的 Java 类。

Servlet 可以使用 **javax.servlet** 和 **javax.servlet.http** 包创建，它是 Java 企业版的标准组成部分，Java 企业版是支持大型开发项目的 Java 类库的扩展版本。

这些类实现 Java Servlet 和 JSP 规范。

Java Servlet 就像任何其他的 Java 类一样已经被创建和编译。在安装 Servlet 包并把它们添加到您的计算机上的 Classpath 类路径中之后，就可以通过 JDK 的 Java 编译器或任何其他编译器来编译 Servlet。

### 三.运行环境 ###

运行在Servlet容器中。

1.  安装jdk
2.  安装tomcat服务器

### 四.生命周期 ###

![生命周期][format_png]

**以下方法都是由Servlet容器负责调用。**

1.  构造器：只被调用一次，只有第一次请求Servlet时，创建Servlet的实例，调用构造器。这说明Servlet是单实例的！  
      
    当用户通过浏览器输入一个路径，这个路径对应的servlet被调用的时候，该Servlet就会被实例化
    
        public LoginServlet(){
                System.out.println("LoginServlet 构造方法 被调用");
        }
    
     
2.  init方法：只被调用一次，在创建好实例后立即被调用，用于初始化当前Servlet。  
      
    （自启动问题：在web.xml中，配置Hello Servlet的地方，增加一句<load-on-startup>10</load-on-startup>）
3.  service：被多次调用，每次请求都会调用service方法，实际用于响应请求的。  
      
    service() 方法由容器调用，service 方法在适当的时候调用 doGet、doPost、doPut、doDelete 等方法。doGet() 和 doPost() 方法是每次服务请求中最常用的方法。  
    实际上，在执行doGet()或者doPost()之前，都会先执行service()，由service()方法进行判断，到底该调用doGet()还是doPost()）
4.  destroy：只被调用一次，在当前Servlet所在的web应用被卸载前调用，用于释放当前Servlet所占用的资源。
5.   最后，Servlet 是由 JVM 的垃圾回收器进行垃圾回收的。

## ##

### 五.手动创建第一个Servlet程序 ###

**Servlet 实例**

Servlet 是服务 HTTP 请求并实现 **javax.servlet.Servlet** 接口的 Java 类。Web 应用程序开发人员通常编写 Servlet 来扩展 javax.servlet.http.HttpServlet，并实现 Servlet 接口的抽象类专门用来处理 HTTP 请求。

**项目结构如图：**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lpZ3VhbmdfODIw_size_16_color_FFFFFF_t_70][]

**详细步骤：**

1.  第一步：使用eclipse创建一个 helloServlet2 项目
2.  第二步：在Java项目下创建web开发的目录结构  
    ![20190710120518708.png][]
3.  第三步：将servlet-api.jar包放在lib目录下，并导入项目。（servlet-api.jar在 apache-tomcat-8.5.39\\lib 目录下）  
    ![20190710124205270.png][]
4.  第四步：在src的test包下新建一个Hello World类
    
        //导入必需的 java 库
        import java.io.*;
        import javax.servlet.*;
        import javax.servlet.http.*;
        
        //扩展 HttpServlet 类
        public class HelloWorld extends HttpServlet{
        	private String message;
        	public void init() {
        		//执行必须的初始化
        		message="hello world";
        	}
        	public void doGet(HttpServletRequest request,HttpServletResponse response)
                    throws ServletException, IOException{
        	      // 设置响应内容类型
        	      response.setContentType("text/html");
        
        	      // 实际的逻辑是在这里
        	      PrintWriter out = response.getWriter();
        	      out.println("<h1>" + message + "</h1>");
        	}
        	public void destroy(){
        	      // 什么也不做
        	}
        
        }
5.  第五步：手动的将HelloWorld类对应的class文件（含包）复制到classes的目录下
6.  第六步：修改web.xml  
    将一下代码添加到web.xml中
    
        <servlet>
                <servlet-name>HelloWorld</servlet-name>
                <servlet-class>test.HelloWorld</servlet-class>
            </servlet>
        
            <servlet-mapping>
                <servlet-name>HelloWorld</servlet-name>
                <url-pattern>/HelloWorld</url-pattern>
            </servlet-mapping>
    
    上面的条目要被创建在 web.xml 文件中的 <web-app>...</web-app> 标签内。在该文件中可能已经有各种可用的条目，但不要在意。
7.  第六步：在eclipse-workspace目录将项目复制到Tomcat的webapps目录下  
      
    ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lpZ3VhbmdfODIw_size_16_color_FFFFFF_t_70 1][]
8.  第七步：在浏览器的地址栏中输入：http://localhost:8080/helloServlet2/HelloWorld  
      
    ![20190710171739371.png][]

### 六.使用Eclipse编写Servlet ###

**项目结构如图：**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lpZ3VhbmdfODIw_size_16_color_FFFFFF_t_70 2][]

**详细步骤：**

1.  **第一步：**在src的test包下新建一个Hello World类
    
        //导入必需的 java 库
        import java.io.*;
        import javax.servlet.*;
        import javax.servlet.http.*;
        
        //扩展 HttpServlet 类
        public class HelloWorld extends HttpServlet{
        	private String message;
        	public void init() {
        		//执行必须的初始化
        		message="hello world";
        	}
        	public void doGet(HttpServletRequest request,HttpServletResponse response)
                    throws ServletException, IOException{
        	      // 设置响应内容类型
        	      response.setContentType("text/html");
        
        	      // 实际的逻辑是在这里
        	      PrintWriter out = response.getWriter();
        	      out.println("<h1>" + message + "</h1>");
        	}
        	public void destroy(){
        	      // 什么也不做
        	}
        
        }
2.  第二步：修改web.xml  
    将一下代码添加到web.xml中
    
        <servlet>
            	
                <servlet-name>HelloWorld</servlet-name>
                
                <servlet-class>test.HelloWorld</servlet-class>
            </servlet>
        
            <servlet-mapping>
            	
                <servlet-name>HelloWorld</servlet-name>
                
                <url-pattern>/HelloWorld</url-pattern>
            </servlet-mapping>
3.  第三步：使用Eclipse访问 http://localhost:8080/helloServlet/HelloWorld  
    ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lpZ3VhbmdfODIw_size_16_color_FFFFFF_t_70 3][]

**说明：**

**1.servlet容器响应客户请求的过程**

1.  Servlet引擎检查是否已经装在并创建了该Servlet的实例对象。如果是，则直接执行第4步，否则，执行第2步。
2.  装载并创建该Servlet的一个实例对象：调用该Servlet的构造器。
3.  调用Servlet实例对象的init（）方法。
4.  创建一个用于封装请求的ServletRequest对象和一个代表service（）方法并将请求和响应作为参数转递进去。
5.  web应用程序被停止或重新启动之前，Servlet引擎将卸载Servlet，并在卸载之前调用Servlet的destroy（）方法。

**2.load-on-startup参数：配置在servlet节点中**  
load-on-startup：可以指定Servlet被创建的时机。若为负数，则在第一次请求时被创建，若为0或正数，则在当前web应用被Servlet容器加载时创建实例，且数字越小越早被创建。

<servlet>
        
        <servlet-name>helloServlet</servlet-name>
        <--Servlet的全类名-->
        <servlet-class>com.atguigu.HelloServlet</servlet-class>    
        
        <load-on-startup>2</load-on-startup>
    </servlet>>

**3.Servlet的注册与运行**

*  Servlet程序必须通过servlet容器来启动运行，并且储存目录特殊要求，通需要存储在<WEB应用程序目录>\\WEB-INF\\classes\\目录中。
 *  Servlet程序必须在web应用程序的web.xml文件中进行注册和映射其访问路径，才可以被Servlet引擎加载和被外界访问。
 *  一个<servlet>元素用于注册一个Servlet，它包含有两个主要的子元素：<servlet-name>和<servlet-class>,分别用于设置Servlet的注册名称和Servlet的完整类名。
 *  一个<servlet-mapping>元素用于映射一个已注册的Servlet的一个对外访问路径，它包含两个子元素：<servlet-name>和<url-pattern>,分别用于指定Servlet的注册名称和Servlet的对外访问路径。

**4.servlet映射的细节**

*  同一个Servlet可以被映射到多个URL上，即多个<servlet-mapping>元素的<servler-name>子元素的设置值可以是同一个Servlet的注册名。
 *  在servlet映射到URL中也可以使用\*通配符，但是只能有两种固定的格式：一种格式是“\*.扩展名（如html）”，另一种格式是以正斜杠（/）开头并以“/\*”结尾。  
    具体映射：/aaa/bbb/ccc，提醒：尽量使用具体映射  
    通配符1：\*.html、/aaa/\*.html，注意：\*.html/ 这样的不合法  
    通配符2：/aaa/、/aaa/bbb/、/aaa/\*、/aaa/bbb/\*，提醒：尽量不要使用 / 或者 /\*   
      
    说明：  
    /，在没有找到具体映射的时候，它就会拦截来进行处理，会拦截\*.html，图片呀，\*.css，\*.js等静态文件，一句话，啥都拦截。但是不会拦截\*.jsp，即遇到\*.jsp，servlet容器会放行，而不会让Servlet类 处理。（例如：使用springmvc在web.xml中配置拦截的时候就是使用的/，静态文件也会别springmvc的默认中央处理器DispatcherServlet所处理，图片什么的都不会显示，需要在web.xml配置放行才可以）。为什么不拦截 \*.jsp?因为servlet容器有内置的“\*.jsp”匹配器，而扩展名匹配的优先级高于缺省匹配（/），所以才会有上述现象。  
    /\*，会拦截所有，但是不会拦截\*.html，会拦截\*.jsp，即遇到\*.html，servlet容器会放行，而不会让Servlet类 处理。
 *  匹配顺序
    
    1.  精确匹配，servlet-mapping1：<url-pattern>/user/users.html</url-pattern>，servlet-mapping2：<url-pattern>/\*</url-pattern>。当一个请求http://localhost:8080/appDemo/user/users.html来的时候，servlet-mapping1匹配到，不再用servlet-mapping2匹配
    2.  路径匹配，先最长路径匹配，再最短路径匹配servlet-mapping1：<url-pattern>/user/\*</url-pattern>，servlet-mapping2：<url-pattern>/\*</url-pattern>。当一个请求http://localhost:8080/appDemo/user/users.html来的时候，servlet-mapping1匹配到，不再用servlet-mapping2匹配
    3.  扩展名匹配，servlet-mapping1：<url-pattern>/user/\*</url-pattern>，servlet-mapping2：<url-pattern>\*.action</url-pattern>。当一个请求http://localhost:8080/appDemo/user/addUser.action来的时候，servlet-mapping1匹配到，不再用servlet-mapping2匹配
    4.  缺省匹配，以上都找不到servlet，就用默认的servlet，配置为<url-pattern>/</url-pattern>
 *  例子：
    
     *  1.URL输入`http://localhost:8080/servlet_test/index.html，如果设置为<url-pattern>/</url-pattern>,则不会跳转到index.hmtl,很蛋痛`  
        springmvc的DispatcherServlet就是如此，如果不配置放行的话，无法跳转到html页面  
        ![20200516141226693.png][]

### 七.Servlet API 中几个主要接口和抽象类 ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lpZ3VhbmdfODIw_size_16_color_FFFFFF_t_70 4][]

### 1.Servlet接口 ###

public interface Servlet {
        public void init(ServletConfig config) throws ServletException;
        public ServletConfig getServletConfig();
        public String getServletInfo();
        public void service(ServletRequest req, ServletResponse res)throws ServletException, IOException;
        public void destroy();
    }

### 2.ServletConfig接口 ###

**封装了Servlet的配置信息，并且可以获取ServletContext对象**

**1.getInitParameter(String name)：获取当前servlet指定参数名的初始化信息**

1.  配置Servlet的初始化参数，代码：
    
        <servlet>
                <servlet-name>HelloWorld</servlet-name>
                <servlet-class>test.HelloWorld</servlet-class>
                
                <init-param>
                	
        	    	<param-name>name</param-name>
        	    	
        	    	<param-value>aaa</param-value>
           	 	</init-param>
            </servlet>
            
            <servlet-mapping>
                <servlet-name>HelloWorld</servlet-name>
                <url-pattern>/HelloWorld</url-pattern>
            </servlet-mapping>
2.  获取初始化参数：
    
        //扩展 HttpServlet 类
        public class HelloWorld extends HttpServlet{
        	ServletConfig sc;
        	private String message;
        	public void init(ServletConfig servletConfig) {
        		//执行必须的初始化
        		sc=servletConfig;
        		message="hello world";
        	}
        
        	public void doGet(HttpServletRequest request,HttpServletResponse response)
        			throws ServletException, IOException{
        	      // 设置响应内容类型
        	      response.setContentType("text/html");
        	      
        	      //1.获取参数信息
        	      String name=sc.getInitParameter("name");
        	      System.out.print(name);
        
        	      // 实际的逻辑是在这里
        	      PrintWriter out = response.getWriter();
        	      out.println("<h1>" + message + "</h1>");
        	}
        	public void destroy(){
        	      // 什么也不做
        	}
        
        }

**2.getInitParameterNames():获取参数名组成的Enumeration对象**

//扩展 HttpServlet 类
    public class HelloWorld extends HttpServlet{
    	ServletConfig sc;
    	private String message;
    	public void init(ServletConfig servletConfig) {
    		//执行必须的初始化
    		sc=servletConfig;
    		message="hello world";
    	}
    
    	public void doGet(HttpServletRequest request,HttpServletResponse response)
    			throws ServletException, IOException{
    	      // 设置响应内容类型
    	      response.setContentType("text/html");
    	      
    	      //1.获取指定参数名的初始化信息
    	      String name1=sc.getInitParameter("name");
    	      System.out.println(name1);
    	      
    	      //2.获取参数名组成的Enumeration对象
    	      Enumeration<String> names=sc.getInitParameterNames();
    	      while(names.hasMoreElements()) {
    	    	  String name2=names.nextElement();
    	    	  String value=sc.getInitParameter(name2);
    	    	  System.out.println("name:"+name2);
    	    	  System.out.println("value:"+value);
    	      }
    
    	      // 实际的逻辑是在这里
    	      PrintWriter out = response.getWriter();
    	      out.println("<h1>" + message + "</h1>");
    	}
    	public void destroy(){
    	      // 什么也不做
    	}
    
    }

**3.serlvetName():获取当前运行的servlet名称 ，代码**

//3.获取当前运行的Servlet名称
    	      String servletName=sc.getServletName();
    	      System.out.println(servletName);

## ##

### 3.ServletContext接口 ###

**1.可以由ServletConfig获取，代码**

ServletContext servletContext=servletConfig.getServletContext();

**2.该对象代表当前WEB应用**

*  Servlet引擎为每个web应用程序都创建一个对应的ServletContext对象，ServletContext对象被包含在ServletConfig对象中，调用ServletConfig.getServlertcontext方法可以返回ServletContext对象的引用
 *  可以认为ServletContext是当前web应用的一个大管家，可以从中获取到当前web应用的各个方面的信息
    
     *  一个ServletContext对象可以有多个Servlet、Listener和Filter
     *  还可以得到Session和Cookie的配置信息
 *  由于一个web应用程序中所有Servlet都共享同一个ServletContext对象，所以，ServletContext对象被称之为application对象（web应用程序对象）

**3.功能：**

1.  获取web应用程序的初始化参数
2.  获取当前WEB应用程序的名称  
    ![2019071214103820.png][]
3.  获取当前web应用的某个文件在服务器上的绝对目录，而不是部署前的物理路径
4.  获取当前WEB应用的某一个文件对应的输入流
5.  记录日志
6.  application域范围的属性（作用域）
7.  访问资源文件
8.  web应用程序之间的访问
9.  ServletContext的其他方法

**（1）获取当前WEB应用的初始化参数**

**配置WEB应用的初始化参数**

<servlet>
            <servlet-name>HelloWorld</servlet-name>
            <servlet-class>test.HelloWorld</servlet-class>
            
            <init-param>
            	
    	    	<param-name>name</param-name>
    	    	
    	    	<param-value>aaa</param-value>
       	 	</init-param>
        </servlet>
    
        
        <context-param>
        	<param-name>driver</param-name>
        	<param-value>com.mysql.Driver.mysql</param-value>
        </context-param>
        
        <servlet-mapping>
            <servlet-name>HelloWorld</servlet-name>
            <url-pattern>/HelloWorld</url-pattern>
        </servlet-mapping>

方法：和ServletConfig方法一样
    getInitParameter
    getInitParameterNames
    
    
     代码：
    //1.获取ServletContent
    ServletContext servletContext=sc.getServletContext();
    
    //2.获取WEB初始化参数
    String driver=context1.getInitParameter("driver");
    System.out.println("driver:"+driver);
            
    
    Enumeration<String> name2=arg0.getInitParameterNames();
        while(name2.hasMoreElements()) {
            String name=name2.nextElement();
            System.out.println("-->"+ name);
    }

**（2）获取当前WEB应用的名称**

方法：
    getContextPath()
    
    代码：
    //1.获取ServletContent
    ServletContext servletContext=sc.getServletContext();
    	      
    //2.ServletContext接口方法
    System.out.println(servletContext.getInitParameter("driver"));
    System.out.println(servletContext.getContextPath());
    
    //打印结果
    /helloServlet

**（3）获取当前web应用的某个文件在服务器上的绝对目录，而不是部署前的物理路径**

方法：
    getRealPath(String Path)
    
    
    代码：
    //1.获取ServletContent
    ServletContext servletContext=sc.getServletContext();
    	      
    //2.ServletContext接口方法
    System.out.println(servletContext.getRealPath("hello.jsp"));
    
    //打印结果
    F:\tools\eclipse\eclipse-workspace\.metadata\.plugins\org.eclipse.wst.server.core\tmp0\wtpwebapps\helloServlet\hello.jsp

**（4）获取当前WEB应用的某一个文件对应的出入流**

getResourceAsStream(String path):path的/为当前WEB的根目录
    代码：
    ServletContext context4=arg0.getServletContext();
    InputStream is2=context4.getResourceAsStream("/WEB-INF/classes/jdbc.propertise");
    System.out.println("2."+ is2);

**（5）和attribute相关的几个方法**

### 4.HttpServlet ###

1.  HttpServlet是一个抽象类，继承自GenericServlet,针对HTTP协议所定制。
2.  在service(ServletRequest req, ServletResponse res)方法中直接把ServletRequest和ServletResponse转化为HttpServletRequest和HttpServletResponse,并调用了重载的service（HttpServletRequest,HttpServletResponse）
    
        1.实现Servlet接口，重写Service（）方法
        public class Test extends HttpServlet{
            @Override
        	public void service(ServletRequest req, ServletResponse res) throws ServletException, IOException {
        		HttpServletRequest request;
        		HttpServletResponse response;
        		try {
        			request=(HttpServletRequest) req;
        			response=(HttpServletResponse) res;
        		}catch(ClassCastException e) {
        			throw new ServletException("non-HTTP request or response");
        		}
        		
        	}
        }
3.  在service(HttpServiceRequest ,HttpServletResponse)获取了请求方式：request.getMethod（）。根据请求方式又创建了doXxx（）方法（Xxx为具体的请求方式，比如doGet,doPost,doPut,doDelete）
    
        2.继承HttpServlet抽象类，重写service（）方法和对应的doXxx（）方法
        public class Test extends HttpServlet{
        	public void service(HttpServletRequest request,HttpServletResponse response) throws ServletException, IOException {
        		//1.获取请求方式
        		String method=request.getMethod();
        		
        		//2.根据请求方式调用对应的方法
        		if("GET".equalsIgnoreCase(method)) {
        			doGet(request,response);
        		}else if("POST".equalsIgnoreCase(method)){
        			doPost(request,response);
        		}
        	}
        	protected void doPost(HttpServletRequest req, HttpServletResponse resp)
        	        throws ServletException, IOException {
        			//
        	}
        	
        	protected void doGet(HttpServletRequest req, HttpServletResponse resp)
        	        throws ServletException, IOException {
        			//
        	}
        }
4.  实际开发中，直接继承HttpServlet,并根据请求方式重写doXxx（）方法接口。
5.  好处：直接由针对性的覆盖doXxx（）方法；直接使用HttpServletRequest和HttpServletResponse,不再需要强转。

###           5.**HttpServletRequest：获取请求信息** ###

**1.如何在Servlet中获取请求信息**

Servlet的service（）方法用于应答请求：因为每次请求都会调用service（）方法

public void service(ServletRequest request, ServletResponse response) throws ServletException, IOException
    
    ServletRequest:封装了请求信息，可以从中获取到任何的请求信息。
    ServletResponse:封装了响应信息，如果想给用户什么响应，具体可以使用该接口的方法实现
    这两个接口的实现类都是服务器给予实现的，并在服务器调用service方法是传入。

ServletRequest：封装了请求信息，可以从中获取到任何的请求信息。

**1.获取请求参数：**

*  String getParameter(String name):根据请求参数的名字，返回参数值.若请求参数有多个值时（例如CheckBox），该方法只能获取到第一个提交的值
 *  String\[\] getParametValues(String name)：根据请求参数的名字，返回请求参数对应的字符串数组。
 *  Enumeration getParameterNames():返回参数名对应的Enumeration对象，类似于ServletConfig（或ServletContext）的getInitParameterNames()方法.
 *  Map getParameterMap():返回请求参数的键值对： key :参数名，value：参数值，String 数组类型.

例：

//http://localhost:8080/Login/HelloForm?first_name=ZARA&last_name=ALI 
    
    request.getParameter("first_name");//ZARA
    request.getParameter("last_name");//ALI

**2.获取请求的方式：**

//http://localhost:8080/Login/HelloForm?first_name=ZARA&last_name=ALI 
    
    String method=request.getMethod();
    System.out.println(method);
    
    打印结果为：get

**3.若是一个get请求，获取请求参数对应的那个字符串，即？后的那个字符串。（网址输入框中的字符串）**

//http://localhost:8080/Login/HelloForm?first_name=ZARA&last_name=ALI 
    
    代码：
    HttpServletRequest httpServletRequest=(HttpServletRequest) request;
    String queryString=httpServletRequest.getQueryString();
    System.out.println(queryString);
    
    打印结果 first_name=ZARA&last_name=ALI

**4.获取请求的Servlet的URL、ServerName（主机名）、ServerPart（端口）、URI（映射路径）、**

![20190930180424390.png][]  
![20190930180442465.png][]

**5.和attribute相关的几个方法**

在Listener监听器会使用到request.attribute()方法。

**request中getParameter和getAttribute的区别**

1.  获取的对象不同
    
    1.  getParameter()表示接收页面提交的 参数，主要有表单提交的参数、URL重写传递的参数（http://item.jsp?id=1中的id值）等，所以不需要通过setParameter来设置参数，而且参数的返回类型是String类型。
    2.  getAttribute()表示从request范围取得设置的属性，必须要通过setAttribute设置属性，才能通过getAttribute取得。设置和取得的值都是Object类型。
2.  两者的返回值类型不一样，前者永远返回字符串，后者返回任意对象；request.getAttribute()方法返回request范围内存在的对象，而request.getParameter()方法是获取http提交过来的字符串。

[application]: http://how2j.cn/k/jsp/jsp-object/580.html
[web]: http://how2j.cn/k/listener/listener-context/605.html
[session]: http://how2j.cn/k/listener/listener-session/606.html
[request]: http://how2j.cn/k/listener/listener-request/607.html
[70]: /images/20220509/bd292e33381d4de8a34a85904bf267c4.png
[Servlet]: /images/20220509/7dfd0305cfe94008845e09b736d6eef7.png
[format_png]: /images/20220509/7c4ec43296fa43938dc22d1fa42cdb62.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lpZ3VhbmdfODIw_size_16_color_FFFFFF_t_70]: /images/20220509/07f1fc057c914464b02a796718ac2460.png
[20190710120518708.png]: /images/20220509/e3886c5148db4cc7a924f0674bbab9f5.png
[20190710124205270.png]: /images/20220509/99f47137350a4bcbae38940a63758537.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lpZ3VhbmdfODIw_size_16_color_FFFFFF_t_70 1]: /images/20220509/059e03b997ee403395f37aa484e8202b.png
[20190710171739371.png]: /images/20220509/25ff32449128439085a4841467c09520.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lpZ3VhbmdfODIw_size_16_color_FFFFFF_t_70 2]: /images/20220509/5880b2bcb5c043289dc88d0cb0b6a313.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lpZ3VhbmdfODIw_size_16_color_FFFFFF_t_70 3]: /images/20220509/c057bb09712a4075ab1d12b6bcca5206.png
[20200516141226693.png]: /images/20220509/b9c34a47b04a46d184c4e1a463b3d3d0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lpZ3VhbmdfODIw_size_16_color_FFFFFF_t_70 4]: /images/20220509/fd59734fee4b4de1af863fe58ee33816.png
[2019071214103820.png]: /images/20220509/dcc2312c12fc4043a5ccf712d1f95ab4.png
[20190930180424390.png]: /images/20220509/e72be31248de4610b31b8eb535313ed7.png
[20190930180442465.png]: /images/20220509/6f58594400ea47a2b435702361cd672d.png