Servlet 总结_servlet报告总结-CSDN博客

本文链接：https://blog.csdn.net/yiguang_820/article/details/82943813

基础
Servlet容器
Servlet简介
Servlet运行环境
Servlet生命周期
手动创建第一个Servlet程序
使用Eclipse编写Servlet
Servlet API 中主要接口和类
进阶
Servlet实例（继承HttpServlet抽象类或者实现Servlet接口）
Servlet表单数据（继承HttpServlet抽象类，重写doGet（）、doPost（）等方法）
Servlet客户端HTTP请求（实现HttpServetRequest 接口）
Servlet服务器HTTP响应（实现HttpServletResponse 接口）
HTTP协议：浏览器与服务器之间的通信协议。
Servlet HTTP状态代码：200,404等等。
Servlet网页重定向（redirect）和跳转（forward）：客户端跳转、服务端跳转
Servlet编写过滤器（实现接口Filter）：拦截每个页面的请求，看看你是否登录过（Filter就像一个一个哨卡，用户的请求需要经过Filter，并且可以有多个过滤器），可以解决用户是否登录、中文问题等问题
Servlet编写监听器：监听web应用是否启动，sesseion是否有创建,request的生命周期（可配置多个监听器）
Listener 的作用是用于监听 web应用的创建和销毁，以及在其上attribute发生的变化。
web应用即ServletContext对象(jsp的隐式对象application)
除了对web应用的监听外，还能监听session和request的生命周期，以及他们的attribute发生的变化
Servlet异常处理
Servlet Cookies处理

Servlet Session跟踪

cookies处理与session跟踪 都是对数据(request.getParameter("name");)进行处理（临时保存request.getParamerter("name");）

创建（为从表单中转递过来的数据创建cookies）
设置（为cookies失效时间）
添加（在response头中添加）

ServletContext对象（ServletContext接口）
Servlet数据库访问
Servlet文件上传
Servlet处理日期
Servlet 国际化
servlet和jsp的区别
练习：
点击计数器
自动刷新页面
发送电子邮件

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

一.Servlet容器

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

二.Servlet简介

1.介绍

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

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

2.Servlet 架构

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

Servlet 架构

3.Servlet 任务

Servlet 执行以下主要任务：

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

4.工作模式：

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

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容器中。

安装jdk
安装tomcat服务器

四.生命周期

生命周期

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

构造器：只被调用一次，只有第一次请求Servlet时，创建Servlet的实例，调用构造器。这说明Servlet是单实例的！

当用户通过浏览器输入一个路径，这个路径对应的servlet被调用的时候，该Servlet就会被实例化
```
public LoginServlet(){
        System.out.println("LoginServlet 构造方法 被调用");
}
```
init方法：只被调用一次，在创建好实例后立即被调用，用于初始化当前Servlet。

（自启动问题：在web.xml中，配置Hello Servlet的地方，增加一句<load-on-startup>10</load-on-startup>）
service：被多次调用，每次请求都会调用service方法，实际用于响应请求的。

service() 方法由容器调用，service 方法在适当的时候调用 doGet、doPost、doPut、doDelete 等方法。doGet() 和 doPost() 方法是每次服务请求中最常用的方法。
实际上，在执行doGet()或者doPost()之前，都会先执行service()，由service()方法进行判断，到底该调用doGet()还是doPost()）
destroy：只被调用一次，在当前Servlet所在的web应用被卸载前调用，用于释放当前Servlet所占用的资源。
最后，Servlet 是由 JVM 的垃圾回收器进行垃圾回收的。

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

Servlet 实例

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

项目结构如图：

详细步骤：

第一步：使用eclipse创建一个 helloServlet2 项目
第二步：在Java项目下创建web开发的目录结构
第三步：将servlet-api.jar包放在lib目录下，并导入项目。（servlet-api.jar在 apache-tomcat-8.5.39\lib 目录下）

第四步：在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(){
	      // 什么也不做
	}

}

第五步：手动的将HelloWorld类对应的class文件（含包）复制到classes的目录下

第六步：修改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> 标签内。在该文件中可能已经有各种可用的条目，但不要在意。

第六步：在eclipse-workspace目录将项目复制到Tomcat的webapps目录下
第七步：在浏览器的地址栏中输入：http://localhost:8080/helloServlet2/HelloWorld

六.使用Eclipse编写Servlet

项目结构如图：

详细步骤：

第一步：在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(){
	      // 什么也不做
	}

}

第二步：修改web.xml
将一下代码添加到web.xml中

    <servlet>
    	<!--Servlet注册的名字-->
        <servlet-name>HelloWorld</servlet-name>
        <!--Servlet的全类名-->
        <servlet-class>test.HelloWorld</servlet-class>
    </servlet>

    <servlet-mapping>
    	<!--需要和上面的注册名一致-->
        <servlet-name>HelloWorld</servlet-name>
        <!--映射具体的访问路径：/ 代表当前web应用的根目录
        	（http://localhost:8080/helloServlet/HelloWorld）-->
        <url-pattern>/HelloWorld</url-pattern>
    </servlet-mapping>

第三步：使用Eclipse访问 http://localhost:8080/helloServlet/HelloWorld

说明：

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

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

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

<!--配置和映射Servlet--> 
<servlet>
    <!--Servlet注册的名字-->
    <servlet-name>helloServlet</servlet-name>
    <--Servlet的全类名-->
    <servlet-class>com.atguigu.HelloServlet</servlet-class>    
    <!--可以指定Servlet被创建的时机-->
    <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页面

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

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指定参数名的初始化信息

配置Servlet的初始化参数，代码：

    <servlet>
        <servlet-name>HelloWorld</servlet-name>
        <servlet-class>test.HelloWorld</servlet-class>
        <!-- Servlet的初始化参数 -->
        <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>

获取初始化参数：

//扩展 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.功能：

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

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

配置WEB应用的初始化参数

    <servlet>
        <servlet-name>HelloWorld</servlet-name>
        <servlet-class>test.HelloWorld</servlet-class>
        <!-- Servlet的初始化参数 -->
        <init-param>
        	<!-- 参数值 -->
	    	<param-name>name</param-name>
	    	<!-- 参数名 -->
	    	<param-value>aaa</param-value>
   	 	</init-param>
    </servlet>

    <!-- 当前WEB应用的初始化参数：可以为所有的Servlet所获取，而Servlet的初始化参数只能用那个Serlvet可以获取。 -->
    <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

HttpServlet是一个抽象类，继承自GenericServlet,针对HTTP协议所定制。

在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");
		}
		
	}
}

在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 {
			//
	}
}

实际开发中，直接继承HttpServlet,并根据请求方式重写doXxx（）方法接口。
好处：直接由针对性的覆盖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（映射路径）、

5.和attribute相关的几个方法

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

request中getParameter和getAttribute的区别

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