BeginnersBook Servlet 教程（一）
原文：BeginnersBook
协议：CC BY-NC-SA 4.0
项目的web.xml文件中的welcome-file-list标签
原文： https://beginnersbook.com/2014/04/welcome-file-list-in-web-xml/
你有没见过web.xml文件中的<welcome-file-list>标签并想知道它是什么？在本文中，我将解释这个标签是什么以及我们使用它的原因。
标签<welcome-file-list>如果在浏览器上加载项目时未指定文件名，则用于指定默认情况下需要由服务器调用的文件。
对于例如您已经创建了一个名为MyServletProject的项目，并且您在项目中定义了很少的 html 页面和 servlet 类。但是在浏览器中你给出了这样的 url：
http://localhost:8080/MyServletProject
通常我们给出完整的路径：http://localhost:8080/MyServletProject/index.html。但是，如果您已经给出了上述路径，那么网络服务器将查找<welcome-file-list>标签在项目的web.xml文件中。假设您的web.xml文件中包含以下内容：
<web-app>
....
<welcome-file-list><welcome-file>myhome.htm</welcome-file><welcome-file>myindex.htm</welcome-file><welcome-file>mydefaultpage.htm</welcome-file>
</welcome-file-list>
....
</web-app>
根据欢迎文件列表，服务器将查找myhome.htm页面，如果这不存在，则查找第二个欢迎文件myindex.html，依此类推，直到找到有效的欢迎文件。
注意：如果<welcome-file-list>标签未在web.xml中定义，或者在<welcome-file-list>中定义的欢迎文件中定义标签不存在然后服务器将按给定的顺序查找以下文件：
1）index.html
2）index.htm
3）index.jsp
我希望我涵盖了与此标签相关的所有内容。如果您有任何疑问，请随时在下面发表评论。
如何在web.xml文件中使用load-on-startup标签
原文： https://beginnersbook.com/2017/07/load-on-startup-tag-in-web-xml-file-with-example/
默认情况下，在 servlet 容器收到特定 servlet 的请求之前，不会加载 Servlet。这可能会导致第一次访问 servlet 的延迟。为避免访问时间延迟，您可以使用web.xml文件中的标签<load-on-startup>，允许您在服务器启动时强制 servlet 容器加载（实例化并使其init()调用）servlet。
如何使用<load-on-startup>？
这是一个示例web.xml文件：
<web-app>
…<servlet>
<servlet-name>MyServlet</servlet-name>
<servlet-class>com.beginnersbook.DemoServlet</servlet-class>
<load-on-startup>1</load-on-startup>
</servlet>…
</web-app>
如果我没有指定<load-on-startup>，那么在收到对DemoServlet servlet 类的请求之前，Web 容器就不会加载 servlet。由于我已经指定了值>= 0，因此将在启动时加载此 servlet（DemoServlet类）。
>= 0的值表示在部署 web-app 时或服务器启动时加载 servlet。
如何使用<load-on-startup>标签指定 servlet 加载的顺序？
<web-app>
…<servlet>
<servlet-name>MyServlet1</servlet-name>
<servlet-class>com.beginnersbook.DemoServlet1</servlet-class>
<load-on-startup>5</load-on-startup>
</servlet><servlet>
<servlet-name>MyServlet2</servlet-name>
<servlet-class>com.beginnersbook.DemoServlet2</servlet-class>
<load-on-startup>0</load-on-startup>
</servlet>
<servlet><servlet-name>MyServlet3</servlet-name>
<servlet-class>com.beginnersbook.DemoServlet3</servlet-class>
<load-on-startup>-2</load-on-startup>
</servlet>…
</web-app>
在这个例子中，我们在web.xml文件中指定了三个 Servlet，因为 servlet 类DemoServlet1和DemoServlet2具有>= 0的加载启动值，它们都将在服务器启动时立即加载。但是，在DemoServlet1类之前加载 servlet 类DemoServlet2，因为它具有较低的启动加载值。
Servlet 类DemoServlet3在启动时不会加载，因为它具有负加载启动值。
ServletRequest接口
原文： https://beginnersbook.com/2013/05/servlet-request-interface/
当客户端向 Web 服务器发送请求时，servlet 容器会创建ServletRequest和ServletResponse对象并将它们作为参数传递给 servlet 的service()方法。请求对象提供对请求信息的访问，例如请求数据的头和主体信息。
首先，我们将看到一个示例，然后我们将看到ServletRequest接口中可用的方法列表：
示例 1：ServletRequest getParameter()方法显示用户输入
在这个例子中，我演示了使用getParameter()方法返回给定参数的值。
在这个 html 表单中，我们将用户输入（名称和年龄）分别存储在参数uname和uage中。
index.html
<form action="details" method="get">User Name: <input type="text" name="uname"><br>User Age: <input type="text" name="uage"><br><input type="submit" value="submit">
</form>
MyServletDemo.java
在这个 servlet 类中，我们通过使用getParameter()方法获取参数的值，此方法属于ServletRequest接口。在这个例子中，我们将HttpServletRequest作为doGet()方法的参数，HttpServletRequest扩展了ServletRequest接口，这就是为什么getParameter()方法可用于req对象。
获取值后，我们将在网页上编写它们。
import javax.servlet.http.*;
import javax.servlet.*;
import java.io.*;
public class MyServletDemo extends HttpServlet{ public void doGet(HttpServletRequest req,HttpServletResponse res) throws ServletException,IOException { res.setContentType("text/html"); PrintWriter pwriter=res.getWriter(); String name = req.getParameter("uname");String age = req.getParameter("uage");pwriter.println("Name: "+name); pwriter.println("Age: "+age); pwriter.close(); }
}
Web.xml
这是将 servlet 映射到 url 的部署描述符文件。由于我们的表单将详细信息页面作为操作，因此我们将 servlet 类映射到详细信息页面。
<web-app>
<display-name>BeginnersBookDemo</display-name><welcome-file-list><welcome-file>index.html</welcome-file><welcome-file>index.htm</welcome-file><welcome-file>index.jsp</welcome-file><welcome-file>default.html</welcome-file><welcome-file>default.htm</welcome-file><welcome-file>default.jsp</welcome-file></welcome-file-list>
<servlet><servlet-name>BeginnersBook</servlet-name><servlet-class>MyServletDemo</servlet-class>
</servlet>
<servlet-mapping><servlet-name>BeginnersBook</servlet-name><url-pattern>/details</url-pattern>
</servlet-mapping>
</web-app>
输出：
屏幕 1：
点击提交时出现的屏幕 2：
示例 2：获取参数名称和值
在此示例中，我们将使用getParameterNames()和getParameter()方法来获取参数名称和值。
getParameterNames()：返回一个String对象的枚举，其中包含此请求中包含的参数的名称。如果请求没有参数，则该方法返回一个空的枚举。
getParameter()：如上所述，这将返回给定参数的值。
index.html
<form action="details" method="get">User Name: <input type="text" name="uname"><br>User Age: <input type="text" name="uage"><br><input type="submit" value="submit">
</form>MyServletDemo.class
import java.io.IOException;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Enumeration;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
public class MyServletDemo extends HttpServlet{ public void doGet(HttpServletRequest req,HttpServletResponse res) throws ServletException,IOException { PrintWriter pwriter=res.getWriter(); res.setContentType("text/html");Enumeration en=req.getParameterNames();while(en.hasMoreElements()) { Object obj=en.nextElement(); String param=(String)obj; String pvalue=req.getParameter(param); pwriter.print("Parameter Name: "+param+ " Parameter Value: "+pvalue); } pwriter.close(); }
}web.xml
<web-app>
<servlet><servlet-name>BeginnersBook</servlet-name><servlet-class>MyServletDemo</servlet-class>
</servlet>
<servlet-mapping><servlet-name>BeginnersBook</servlet-name><url-pattern>/details</url-pattern>
</servlet-mapping>
</web-app>输出：
示例 3：显示标题信息
index.html
<h1>Servlet Request Demo</h1>
<body>
<a href="headinfo">Click Here</a>
</body>HeaderDetails.java
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Enumeration;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;public class HeaderDetails extends HttpServlet {public void doGet(HttpServletRequest request,HttpServletResponse response)throws IOException, ServletException {response.setContentType("text/html");PrintWriter pwriter = response.getWriter();pwriter.println("HTTP header Information:<br>");Enumeration en = request.getHeaderNames();while (en.hasMoreElements()) {String hName = (String) en.nextElement();String hValue = request.getHeader(hName);pwriter.println("<b>"+hName+": </b>"+hValue + "<br>");}}
}
web.xml
<web-app>
<welcome-file-list><welcome-file>index.html</welcome-file><welcome-file>index.htm</welcome-file><welcome-file>index.jsp</welcome-file><welcome-file>default.html</welcome-file><welcome-file>default.htm</welcome-file><welcome-file>default.jsp</welcome-file></welcome-file-list><servlet><servlet-name>BeginnersBook</servlet-name><servlet-class>HeaderDetails</servlet-class>
</servlet>
<servlet-mapping><servlet-name>BeginnersBook</servlet-name><url-pattern>/headinfo</url-pattern>
</servlet-mapping>
</web-app>
输出：
ServletRequest接口的方法
String getParameter(String name)：它将给定参数的值作为String返回，如果给定的参数不存在，则返回null。
Enumeration getParameterNames()：它返回一个包含请求中参数名称的字符串Enumeration对象。
String [] getParameterValues(String name)：它返回一个包含参数具有的所有值的字符串数组，如果参数没有任何值，则返回null。
String getCharacterEncoding()：返回此请求正文中使用的字符编码的名称。如果请求未指定字符编码，则此方法返回null。
void setCharacterEncoding(String env)：覆盖请求正文中的字符编码。
int getContentLength()：以字节为单位返回请求内容的长度。
String getContentType()：返回请求正文的 MIME 类型，如果类型未知，则返回null。
注意：我刚刚提到了一些方法。如果您需要完整的方法列表，请参阅官方文档。
Servlet 中的RequestDispatcher方法
原文： https://beginnersbook.com/2017/07/requestdispatcher-methods-with-examples-in-servlet/
RequestDispatcher接口定义一个对象，该对象从客户端接收请求并将其分派给资源（例如 servlet，JSP，HTML 文件）。该接口有以下两种方法：
public void forward(ServletRequest request, ServletResponse response)：它将请求从一个 servlet 转发到另一个资源（例如 servlet，JSP，HTML 文件）。
public void include(ServletRequest request, ServletResponse response)：它包含响应中的资源内容（如 servlet，JSP，HTML 文件）。
forward()与include()方法的区别
为了理解这两种方法之间的区别，让我们举一个例子：假设你有两个页面X和Y。在页面X 中你有一个include标签，这意味着控制流将在页面X中，直到它遇到包含标签，之后控制流将被转移到页面Y。在页面Y的处理结束时，控制流将返回到包含标签之后的页面X并保持在X直到结束。
在这种情况下，客户的最终回复将由X页面发送。
现在，我们正在采用相同的例子。我们有相同的页面X和Y。在页面X中，我们有转发标签。在这种情况下，控制流将在页面X中，直到它遇到转发，此后控制流将被转移到页面Y。这里的主要区别是控制流不会返回到X，它将在页面Y中直到结束它的。
在这种情况下，对客户的最终回复将由Y页面发送。
例：
在这个例子中，我将使用include和forward两种方法。使用include方法，我将更改当前页面的内容，当我准备将控制流转移到下一页时，我将使用forward方法。
index.html
<form action="loginPage" method="post"> User Name:<input type="text" name="uname"/><br/> Password:<input type="password" name="upass"/><br/> <input type="submit" value="SUBMIT"/>
</form> Validation.java
import java.io.*;
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
public class Validation extends HttpServlet
{ public void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { response.setContentType("text/html"); PrintWriter pwriter = response.getWriter(); String name=request.getParameter("uname"); String pass=request.getParameter("upass"); if(name.equals("Chaitanya") && pass.equals("beginnersbook")){ RequestDispatcher dis=request.getRequestDispatcher("welcome"); dis.forward(request, response); } else{ pwriter.print("User name or password is incorrect!"); RequestDispatcher dis=request.getRequestDispatcher("index.html"); dis.include(request, response); } }
} WelcomeUser.java
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*; public class WelcomeUser extends HttpServlet { public void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { response.setContentType("text/html"); PrintWriter pwriter = response.getWriter(); String name=request.getParameter("uname"); pwriter.print("Hello "+name+"!");pwriter.print(" Welcome to Beginnersbook.com"); } } web.xml
<web-app><display-name>BeginnersBookDemo</display-name><welcome-file-list><welcome-file>index.html</welcome-file></welcome-file-list><servlet><servlet-name>Login</servlet-name><servlet-class>Validation</servlet-class></servlet><servlet><servlet-name>Welcome</servlet-name><servlet-class>WelcomeUser</servlet-class></servlet><servlet-mapping><servlet-name>Login</servlet-name><url-pattern>/loginPage</url-pattern></servlet-mapping><servlet-mapping><servlet-name>Welcome</servlet-name><url-pattern>/welcome</url-pattern></servlet-mapping><welcome-file-list><welcome-file>index.html</welcome-file></welcome-file-list>
</web-app>输出：
输入错误的凭据：
错误屏幕：
输入正确的用户名和密码时欢迎屏幕：
ServletConfig接口
原文： https://beginnersbook.com/2017/07/servletconfig-interface-with-example/
Servlet 容器在初始化期间为每个 Servlet 创建ServletConfig对象，以将信息传递给 Servlet。此对象可用于从部署描述符文件（web.xml）获取配置信息，例如参数名称和值。
ServletConfig接口的方法
public String getInitParameter(String name)：以String形式返回给定参数的值，如果web.xml中不存在给定参数，则返回null。
public Enumeration getInitParameterNames()：返回所有参数名称的枚举。
public String getServletName()：返回 servlet 实例的名称。
public ServletContext getServletContext()：返回ServletContext的一个对象。
例：
在这个例子中，我们将使用两个方法getInitParameter()和getInitParameterNames()来获取web.xml中的所有参数及其值。
getInitParameterNames()方法返回所有参数名称的枚举，并通过在调用getInitParameter()方法期间传递这些名称，我们可以从web.xml获取相应的参数值。
DemoServlet.java
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
import java.util.Enumeration;public class DemoServlet extends HttpServlet {protected void doGet(HttpServletRequest request, HttpServletResponse response)throws ServletException, IOException {response.setContentType("text/html;charset=UTF-8");PrintWriter pwriter = response.getWriter();ServletConfig sc=getServletConfig();Enumeration<String> e=sc.getInitParameterNames();String str;while(e.hasMoreElements()) {str=e.nextElement();pwriter.println("<br>Param Name: "+str);pwriter.println(" value: "+sc.getInitParameter(str));}}
}
web.xml
<web-app><display-name>BeginnersBookDemo</display-name><welcome-file-list><welcome-file>index.html</welcome-file></welcome-file-list><servlet><servlet-name>MyServlet</servlet-name><servlet-class>DemoServlet</servlet-class><init-param><param-name>MyName</param-name><param-value>Chaitanya</param-value></init-param><init-param><param-name>MyWebsite</param-name><param-value>Beginnersbook.com</param-value></init-param></servlet><servlet-mapping><servlet-name>MyServlet</servlet-name><url-pattern>/scdemo</url-pattern></servlet-mapping>
</web-app>输出：
ServletContext接口
原文： https://beginnersbook.com/2013/05/servlet-context/
在上一篇教程中，我们讨论了ServletConfig，Servlet 容器在初始化期间为每个 Servlet 创建ServletConfig对象。ServletConfig和ServletContext之间的主要区别在于，与ServletConfig不同，ServletContext每个 Web 应用创建一次，即ServletContext对象对 Web 应用中的所有 servlet 都是通用的。
这就是我们如何创建ServletContext对象。在这段代码中，我们在init()方法中创建对象，但是您可以在任何地方创建对象。
ServletContext sc;
public void init(ServletConfig scfg)
{sc=scfg.getServletContext();
}
一旦我们有ServletContext对象，我们就可以使用setAttribute()方法设置ServletContext对象的属性。由于ServletContext对象可用于 Web 应用的所有 servlet，因此其他 servlet 可以使用getAttribute()方法从ServletContext对象中检索该属性。
上下文初始化参数
上下文初始化参数是您可以在部署描述符文件（web.xml文件）中指定的参数名称和值对。您可以在此处指定 Web 应用中所有 servlet 都可访问的参数。
当我们部署 Web 应用时，Servlet 容器从web.xml文件中读取初始化参数，并使用它初始化ServletContext对象。我们可以使用ServletContext接口的getInitParameter()和getInitParameterNames()方法分别获取参数名称的参数值和枚举。
例如，这里我已经使用值指定了参数email_id，因为这对所有 servlet 都是通用的，您可以在任何 servlet 中获取参数名称和值。
<context-param>
<param-name>email_id</param-name>
<param-value>[email protected]</param-value>
</context-param>
ServletContext完整示例：获取初始化参数
在此示例中，我们在web.xml文件中有两个上下文初始化参数（用户名和用户电子邮件），我们使用getInitParameter()方法获取 Servlet 中的值，该方法返回给定参数的值。
DemoServlet.java
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
public class DemoServlet extends HttpServlet{public void doGet(HttpServletRequest request,HttpServletResponse response)throws ServletException,IOException{response.setContentType("text/html");PrintWriter pwriter=response.getWriter();//ServletContext object creationServletContext scontext=getServletContext();//fetching values of initialization parameters and printing itString userName=scontext.getInitParameter("uname");pwriter.println("User name is="+userName);String userEmail=scontext.getInitParameter("email");pwriter.println("Email Id is="+userEmail);pwriter.close();}
}
web.xml
<web-app>
<servlet><servlet-name>BeginnersBook</servlet-name><servlet-class>DemoServlet</servlet-class>
</servlet>
<context-param><param-name>uname</param-name><param-value>ChaitanyaSingh</param-value>
</context-param>
<context-param><param-name>email</param-name><param-value>[email protected]</param-value>
</context-param>
<servlet-mapping><servlet-name>BeginnersBook</servlet-name><url-pattern>/context</url-pattern></servlet-mapping>
</web-app>
输出：
ServletContext接口的方法
以下是ServletContext接口常用方法的列表。
public String getInitParameter(String param)：返回给定参数的值，如果参数不存在，则返回null。
public Enumeration getInitParameterNames()：返回上下文参数名称的枚举。
public void setAttribute(String name，Object object)：设置给定属性名称的属性值。
public Object getAttribute(String name)：返回给定名称的属性值，如果该属性不存在，则返回null。
public String getServerInfo()：返回运行 servlet 的 servlet 容器的名称和版本。
public String getContextPath()：返回 Web 应用的上下文路径。
要获得完整的方法列表，请参阅官方文档。
ServletResponse接口
原文： https://beginnersbook.com/2013/05/servlet-response/
servlet 容器连接到 Web 服务器，该服务器从某个端口上的客户端接收 Http 请求。当客户端向 Web 服务器发送请求时，servlet 容器会创建HttpServletRequest和HttpServletResponse对象，并将它们作为参数传递给 servlet service()方法。
响应对象允许您格式化并将响应发送回客户端。首先，我们将看到ServletReponse接口中常用的方法，然后我们将看到一个示例。
ServletResponse接口的方法
1）String getCharacterEncoding()：返回发送给客户端的响应正文中使用的 MIME 字符集的名称。
2）String getContentType()：返回响应内容类型。例如text，html等
3）ServletOutputStream getOutputStream()：返回一个适合在响应中写入二进制数据的ServletOutputStream。
4）java.io.PrintWriter getWriter()：返回PrintWriter对象。
5）void setCharacterEncoding(java.lang.String charset)：设置响应的 MIME 字符集（字符编码）。
6）void setContentLength(int len)：设置响应体的长度。
7）void setContentType(java.lang.String type)：设置响应数据的类型。
8）void setBufferSize(int size)：设置缓冲区大小。
9）int getBufferSize()：返回缓冲区大小。
10）void flushBuffer()：强制将缓冲区中的任何内容写入客户端。
11）boolean isCommitted()：返回一个布尔值，指示响应是否已提交。
12）void reset()：清除缓冲区的数据以及标题和状态代码。
获取完整的方法列表。请参阅官方文档。
例：
在下面的示例中，我们使用了ServletResponse接口的setContentType()和getWriter()方法。
index.html
<form action="mydetails" method="get">
User name: <input type="text" name="uname">
<input type="submit" value="login">
</form>
MyServletDemo.java
import javax.servlet.http.*;
import javax.servlet.*;
import java.io.*;
public class MyServletDemo extends HttpServlet{public void doGet(HttpServletRequest req,HttpServletResponse res)throws ServletException,IOException{res.setContentType("text/html");PrintWriter pwriter=res.getWriter();String name=req.getParameter("uname");pwriter.println("User Details Page:");pwriter.println("Hello "+name);pwriter.close();}
}
web.xml
<web-app>
<servlet><servlet-name>DemoServlet</servlet-name><servlet-class>MyServletDemo</servlet-class>
</servlet>
<servlet-mapping> <servlet-name>DemoServlet</servlet-name><url-pattern>/mydetails</url-pattern>
</servlet-mapping>
</web-app>
输出：
屏幕 2：
Servlet 中的HttpSession
原文： https://beginnersbook.com/2013/05/http-session/
HttpSession对象用于会话管理。会话包含特定于整个应用中的特定用户的信息。当用户第一次通过request.getSession()获得HttpSession时进入网站（或在线应用）时，将为用户提供唯一 ID 以标识其会话。此唯一 ID 可以存储在 cookie 或请求参数中。
HttpSession保持活动状态，直到它的使用时间超过部署描述符文件（web.xml）中标签中指定的超时值。默认超时值为 30 分钟，如果未在标记中指定值，则使用此值。这意味着当用户未访问指定的 Web 应用时间时，会话将被 servlet 容器销毁。后续请求将不再从此会话提供，servlet 容器将创建新会话。
这是您创建HttpSession对象的方法。
protected void doPost(HttpServletRequest req,HttpServletResponse res)throws ServletException, IOException {HttpSession session = req.getSession();
}
您可以使用setAttribute()方法将用户信息存储到会话对象中，稍后在需要时可以从会话中获取此信息。这是您在会话中存储信息的方式。这里我们分别在属性名称为uName，uemailId和uAge的会话中存储用户名，emailid和userage。
session.setAttribute("uName", "ChaitanyaSingh");
session.setAttribute("uemailId", "[email protected]");
session.setAttribute("uAge", "30");
第一个参数是属性名称，第二个是属性值。对于例如uName是属性名称，ChaitanyaSingh是上面代码中的属性值。
要从会话中获取值，我们使用HttpSession接口的getAttribute()方法。这里我们使用属性名称获取属性值。
String userName = (String) session.getAttribute("uName");
String userEmailId = (String) session.getAttribute("uemailId");
String userAge = (String) session.getAttribute("uAge");
HttpSession的方法
public void setAttribute(String name，Object value)：使用名称绑定对象，并将名称/值对存储为 HttpSession 对象的属性。如果属性已存在，则此方法将替换现有属性。
public Object getAttribute(String name)：从会话对象返回参数中指定的String对象。如果未找到指定属性的对象，则getAttribute()方法返回null。
public Enumeration getAttributeNames()：返回一个Enumeration，其中包含作为会话对象的属性绑定的所有对象的名称。
public void removeAttribute(String name)：从会话中删除给定的属性。
setMaxInactiveInterval(int interval)：以秒为单位设置会话不活动时间。这是以秒为单位的时间，指定自客户端上次收到请求后会话保持活动状态的时间。
有关方法的完整列表，请参阅官方文档。
会话示例
index.html
<form action="login">User Name:<input type="text" name="userName"/><br/>Password:<input type="password" name="userPassword"/><br/><input type="submit" value="submit"/>
</form>
MyServlet1.java
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
public class MyServlet1 extends HttpServlet {public void doGet(HttpServletRequest request, HttpServletResponse response){try{response.setContentType("text/html");PrintWriter pwriter = response.getWriter();String name = request.getParameter("userName");String password = request.getParameter("userPassword");pwriter.print("Hello "+name);pwriter.print("Your Password is: "+password);HttpSession session=request.getSession();session.setAttribute("uname",name);session.setAttribute("upass",password);pwriter.print("<a href='welcome'>view details</a>");pwriter.close();}catch(Exception exp){System.out.println(exp);}}
}
MyServlet2.java
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
public class MyServlet2 extends HttpServlet {public void doGet(HttpServletRequest request, HttpServletResponse response){try{response.setContentType("text/html");PrintWriter pwriter = response.getWriter();HttpSession session=request.getSession(false);String myName=(String)session.getAttribute("uname");String myPass=(String)session.getAttribute("upass");pwriter.print("Name: "+myName+" Pass: "+myPass);pwriter.close();}catch(Exception exp){System.out.println(exp);}}
}
web.xml
<web-app>
<servlet><servlet-name>Servlet1</servlet-name><servlet-class>MyServlet1</servlet-class>
</servlet>
<servlet-mapping><servlet-name>Servlet1</servlet-name><url-pattern>/login</url-pattern>
</servlet-mapping>
<servlet><servlet-name>Servlet2</servlet-name><servlet-class>MyServlet2</servlet-class>
</servlet>
<servlet-mapping><servlet-name>Servlet2</servlet-name><url-pattern>/welcome</url-pattern>
</servlet-mapping>
</web-app>
输出：
第一个界面：
点击提交后：
点击查看详细信息后：
Servlet 中的Cookie
原文： https://beginnersbook.com/2013/05/servlet-cookies/
在上一篇指南中，我介绍了 Servlet 中的会话。在这里，我们将讨论用于会话管理的Cookie。让我们回顾一下上一篇教程中的一些内容，以便我们可以关联会话和cookie。当用户第一次访问 Web 应用时，servlet 容器通过调用request.getSession()来创建新的HttpSession对象。为会话分配唯一的 ID。Servlet 容器还在 HTTP 响应的标头中设置Cookie，其中包含cookie名称和唯一会话 ID 作为其值。
cookie存储在用户浏览器中，客户端（用户的浏览器）将此cookie发送回服务器以获取所有后续请求，直到cookie有效。Servlet 容器检查cookie的请求标头，并从cookie获取会话信息，并使用服务器内存中的关联会话。
会话在web.xml中的标签中指定的时间内保持活动状态。如果未在web.xml中设置标记，则会话将保持活动状态 30 分钟。 只要用户的浏览器正在运行，Cookie就会保持活动状态，一旦浏览器关闭，cookie和相关的会话信息就会被破坏。因此，当用户再次打开浏览器并向 Web 服务器发送请求时，将创建新会话。
Cookie的类型
我们可以根据Cookie的到期时间对Cookie进行分类：
- 会话
- 持久
1）会话Cookie：
会话Cookie没有到期时间。它存在于浏览器内存中。一旦 Web 浏览器关闭，该cookie就会被破坏。
2）持久性Cookie：
与会话Cookie不同，它们具有到期时间，它们存储在用户硬盘中，并根据到期时间被销毁。
如何将Cookie发送给客户
以下是向客户端发送cookie的步骤：
- 创建一个
Cookie对象。 - 设置最大年龄。
- 将
Cookie放在 HTTP 响应标头中。
1）创建一个Cookie对象：
Cookie c = new Cookie("userName","Chaitanya");2）设置最大年龄：
通过使用setMaxAge()方法，我们可以设置特定cookie的最大年龄（以秒为单位）。
c.setMaxAge(1800);3）将Cookie放在 HTTP 响应头中：
我们可以通过response.addCookie()方法将cookie发送到客户端浏览器。
response.addCookie(c);如何阅读cookie
Cookie c[]=request.getCookies();
//c.length gives the cookie count
for(int i=0;i<c.length;i++){ out.print("Name: "+c[i].getName()+" & Value: "+c[i].getValue());
}
java servlet 中的Cookie示例
index.html
<form action="login">User Name:<input type="text" name="userName"/><br/>Password:<input type="password" name="userPassword"/><br/><input type="submit" value="submit"/>
</form>MyServlet1.java
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
public class MyServlet1 extends HttpServlet
{public void doGet(HttpServletRequest request, HttpServletResponse response) {try{response.setContentType("text/html");PrintWriter pwriter = response.getWriter();String name = request.getParameter("userName");String password = request.getParameter("userPassword");pwriter.print("Hello "+name);pwriter.print("Your Password is: "+password);//Creating two cookiesCookie c1=new Cookie("userName",name);Cookie c2=new Cookie("userPassword",password);//Adding the cookies to response headerresponse.addCookie(c1);response.addCookie(c2);pwriter.print("<br><a href='welcome'>View Details</a>");pwriter.close();}catch(Exception exp){System.out.println(exp);}}
}
MyServlet2.java
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
public class MyServlet2 extends HttpServlet {public void doGet(HttpServletRequest request, HttpServletResponse response){try{response.setContentType("text/html");PrintWriter pwriter = response.getWriter();//Reading cookiesCookie c[]=request.getCookies(); //Displaying User name value from cookiepwriter.print("Name: "+c[1].getValue()); //Displaying user password value from cookiepwriter.print("Password: "+c[2].getValue());pwriter.close();}catch(Exception exp){System.out.println(exp);}}
}
web.xml
<web-app>
<display-name>BeginnersBookDemo</display-name><welcome-file-list><welcome-file>index.html</welcome-file></welcome-file-list>
<servlet><servlet-name>Servlet1</servlet-name><servlet-class>MyServlet1</servlet-class>
</servlet>
<servlet-mapping><servlet-name>Servlet1</servlet-name><url-pattern>/login</url-pattern>
</servlet-mapping>
<servlet><servlet-name>Servlet2</servlet-name><servlet-class>MyServlet2</servlet-class>
</servlet>
<servlet-mapping><servlet-name>Servlet2</servlet-name><url-pattern>/welcome</url-pattern>
</servlet-mapping>
</web-app>输出：
欢迎画面：
点击提交后：
点击查看详情后：
Cookie类的方法
public void setComment(String purpose)：此方法用于在cookie中设置注释。这主要用于描述cookie的用途。
public String getComment()：返回描述此cookie用途的注释，如果cookie没有注释，则返回null。
public void setMaxAge(int expiry)：以秒为单位设置cookie的最大年龄。
public int getMaxAge()：获取此Cookie的最大年龄（以秒为单位）。默认情况下，返回 -1，表示cookie将持续到浏览器关闭。
public String getName()：返回cookie的名称。创建后无法更改名称。
public void setValue(String newValue)：为此Cookie指定一个新值。
public String getValue()：获取此Cookie的当前值。
上面的列表只有常用的方法。要获得Cookie类的完整方法列表，请参阅官方文档。
Servlet 面试问答
原文： https://beginnersbook.com/2013/05/servlet-interview-questions/
以下是有关 Servlet 的常见问题。我已经提供了每个问题的简要和答案，这将有助于您在技术面试轮次中被选中。
Q1. 什么是 servlet？
Servlet 是一种服务器端编程语言，用于生成动态网页。它生成网页作为从客户端（浏览器）收到的请求的响应。
Q2. 静态网页与动态网页？
对所有用户都相同的网页是静态网页，根据用户的请求动态生成的网页（根据请求可能因用户而异）被称为动态网页。 Servlet 主要用于动态网页。
Q3. servlet 的生命周期？
遵循 servlet 生命周期的各个阶段：
1）加载 Servlet 类：servlet 容器找到web.xml文件中提到的 servlet 类并加载它。
2）Servlet 实例化：在此阶段创建 servlet 类的对象。
3）初始化：通过调用init()方法初始化 Servlet。
4）处理请求：在此阶段，servlet 通过调用service()方法为客户端请求提供服务。
5）销毁：servlet 生命周期的最后阶段。destroy()方法释放 servlet 实例，以便可以对其进行垃圾回收。
Q4.为什么我们使用 Servlets？
1）处理用户从屏幕提交的输入数据。
2）根据请求生成并返回对用户的动态响应。
3）理想的编程语言，用于根据用户的请求与数据库进行交互。
4）servlet 可以同时处理多个请求，这使它们成为高性能应用的完美选择。
Q5. 为什么 Servlet 优于 CGI？
1）Servlet 响应比 CGI 更快，因为它使用多线程概念来为每个请求提供服务。 CGI 性能不是很好，因为它为每个请求创建一个新对象，而 servlet 为每个请求分配一个新线程。
2）与 CGI 相比，学习和实现 servlet 非常容易。
3）与 CGI 相比，servlet 中的内存消耗较低。
Q6. 加载 Servlet 的时候？
1）当 servlet 容器收到来自客户端（浏览器）的第一个请求时。
2）应用的管理员手动加载 servlet。
3）当 webserver（部署了 servlet）开始时。
Q7. 什么是Servlet接口以及它的用途是什么？
Servlet接口是 servlet 的 API。每个 Servlet 都应该实现Servlet接口或扩展已经实现接口的类。 javax.servlet.GenericServlet和javax.servlet.http.HttpServlet是实现Servlet接口的Servlet类，因此每个 servlet 应该直接实现Servlet接口，或者通过扩展任何这些类。
Q8. 什么是ServletConfig？
ServletConfig接口属于包javax.servlet.ServletConfig。它用于将配置参数传递给 servlet。Servlet 容器隐式实例化它。
Q9. 什么是ServletContext？
每个 Web 应用都有一个共同的ServletContext。 Web 应用中的所有 servlet 都可以访问ServletContext。它有网络应用信息和 Web 应用中存在的所有 servlet 都可以访问的资源。
Q10. ServletConfig与ServletContext？
以下是ServletConfig和ServletContext之间的两个主要区别：
1）ServletConfig用于将配置信息传递给 Servlet，而ServletContext提供 Servlet 类可以使用的一组方法与 Servlet 容器通信。
2）每个 Servlet 都有一个单独的ServletConfig对象，而ServletContext对于 Web 应用中的所有 servlet 都是通用的。
3）ServletConfig的参数在web.xml文件中的标签<init-param>下定义。ServletContext的参数在web.xml中的标签<context-param>下定义。
Q11. GenericServlet和HTTPServlet之间的区别？
1）GenericServlet是一个实现 Servlet 接口的抽象类，而HTTPServlet抽象类扩展了GenericServlet类。简而言之：GenericServlet类是HTTPServlet的父类。
2）GenericServlet不支持任何协议。HTTPSeervlet支持 HTTP 和 HTTPS 协议。
3）GenericServlet无法处理cookie和会话，而HTTPServlet可以处理它们。
Q12. forward()和sendRedirect()之间的区别？
1）在forward()中，相同的请求被转发到另一个资源。在sendRedirect()中，新请求被发送到重定向资源。
2）forward()由 Servlet 容器处理，而sendRedirect()由浏览器处理。
3）在forward()中，URL（统一资源定位符）在 Web 浏览器上保持不变。在sendRedirect()中，URL 在 Web 浏览器地址栏中更改。
4）与sendRedirect()相比，forward()更快。
Q13. 什么是部署描述符？ Web 应用的
web.xml文件称为部署描述符。它通常放在应用的WEB-INF文件夹中。它具有 Servlet 名称，Servlet 映射等信息。该文件告诉 Servlet 容器需要为给定的 URL 模式调用哪个 Servlet 类。
Q14. doGet()对于doPost()方法？
1）在doGet()中，参数在地址栏中可见，它们会附加到 URL。在doPost()中，参数在地址栏中不可见。
2）您可以通过GET请求最多传输 1024 个字符。doPost()没有任何限制。
3）doGet()不适合敏感数据，因为参数不会被加密。在doPost()中，参数是加密的，因此与doGet()相比更安全。
4）方法doGet()允许您为资源添加书签。doPost()不允许书签。
5）与doPost()方法相比，doGet()更快。
Q15. <load-on-startup>有什么用？
<load-on-startup>用于指定在服务器启动期间需要加载的 Servlet 文件。一旦服务器启动，就会加载此元素中指定的 servlet 文件，它不会等待第一个加载它们的请求。这是在web.xml文件中指定的方式。
<servlet>
<servlet-name>MyServletNameHere</servlet-name>
<servlet-class>ServletClassHere-FullyQualified</servlet-class>
<load-on-startup>1</load-on-startup>
</servlet>
如果指定了多个文件，则文件将按照在其中指定的顺序加载。
Q20. Servlets 支持哪些不同类型的会话跟踪机制？
1）URL 重写
2）隐藏表单字段
3）Cookies
4）安全套接字层（SSL）会话
Q21. URL 重写如何维持会话？
在 URL 重写方法中，会话跟踪数据已附加在 URL 的末尾以跟踪会话。
Q22. 解释 Servlet 链接？
Servlet 链接是一个在一系列 servlet 中处理请求的概念。第一个 Servlet 部分处理请求并传递给第二个请求，然后第二个 servlet 处理它并传递给第三个请求，依此类推。最后一个 servlet 将响应返回给客户端（浏览器）。
Q23. 如何使 servlet 中的会话无效？
通过调用session.invalidate()方法。
Q24. Servlet 容器的主要功能是什么？
1）Servlet 生命周期管理
2）维护 Servlet 和 Web 服务器之间的交互。
3）提供多线程支持，同时处理多个请求。
4）管理部署描述符web.xml文件。
Q25. 什么是<session-timeout>？
元素<session-timeout>用于指定会话的超时。这是在web.xml文件中定义的方式。
<session-config>
<session-timeout>35</session-timeout>
</session-config>
它会将会话超时设置为 25 分钟。
Q26. 什么是 Servlet 延迟加载以及如何避免它？
默认情况下，Servlet 容器在服务器启动时不初始化 Servlet。它仅在收到来自客户端的请求时初始化 servlet。这称为 Servlet 的延迟加载。
通过指定<load-on-startup>元素为 Servlet 我们可以避免延迟加载。<load-on-startup>中指定的 servlet 文件 Web 服务器启动后立即加载。
Q27. 为什么我们在 servlet 中需要构造函数，即使我们有一个init()方法？
init()方法用于初始化 servlet，但是为了实例化 Servlet 类，需要构造函数。 Servlet 容器实例化Servlet类。
Q28. 什么时候卸载 Servlet？
1）管理员手动卸载 servlet。
2）Web 服务器关闭。
Q29. Servlet 如何使用cookie维护会话？
Cookie是一小段信息，由 servlet 发送到 Web 浏览器。Cookie会存储在浏览器中，并在需要时返回给服务器。Cookie具有名称，单个值和少数其他属性。
Q30. 为什么使用cookie进行会话跟踪是一种不好的做法？
使用cookie进行会话跟踪有几个缺点。其中很少是：
1）由于cookie存储在客户端（在客户端的浏览器中），如果客户端浏览器清除或禁用cookie，它将不可用。
2）与其他会话管理机制相比，实现会话跟踪的cookie要困难得多。
3）Cookie仅适用于 HTTP 协议。
Q31. 如何在 Servlets 中获取服务器信息？
使用此：
getServletContext().getServerInfo()
Q32. 如何在 Servlet 中获取客户端的 IP 地址？
使用此：
request.getRemoteAddr()
Q33. 为什么我们在 Servlet 中使用过滤器？
我们使用过滤器：
1）安全检查
2）修改请求或响应
3）数据压缩
4）记录和审核
5）响应压缩
Q34. HTTPServlet支持哪些协议？
HTTP 和 HTTPS 协议。
Q35. GenericServlet支持哪些协议？
GenericServlet抽象类并不特定于任何协议。
Q36. Servlet 3 增加了哪些新功能？
1）Servlet 注释
2）Web 片段
3）Web 组件动态添加
4）异步处理
Q37. 我们是否覆盖service()方法？
不，我们不会覆盖service()方法。我们通常根据需求覆盖doPost()，doGet()方法。
适用于初学者的 Servlet 教程
原文： https://beginnersbook.com/2013/05/servlet-tutorial/
Servlet 是一个在 Web 服务器上的 JVM 内运行的 java 程序。它用于开发动态 Web 应用。
在我们继续之前，让我们了解什么是动态 Web 应用？ Web 应用可以被描述为网页集合（例如网站），当我们称之为动态时，它只是意味着所有用户的网页都不相同，网页将在服务器端生成根据客户端（用户的浏览器）的请求。
静态和动态网页之间的主要区别在于，名称建议的静态页面对于所有用户保持相同，但是动态网页基于来自客户端（用户的浏览器）的请求而改变。例如，考虑一个 Web 应用，它向您显示两个输入字段和添加按钮，当您输入两个数字并单击添加时，它会显示另一个网页，其中包含两个数字的结果，此 Web 应用本质上是动态的，作为第二个网页，显示结果更改基于用户输入，对所有用户都不是静态的。
但是你可以很好地说，一个 servlet 可以通过 CGI（通用网关接口）完成什么，这是真的，但这就是事情 - CGI 有一些限制，如性能，可伸缩性，可重用性等等。我不打算详细讨论 CGI，但我要告诉你，servlet 如何比 CGI 更好。
CGI 的局限性
服务器必须为每个客户端请求创建一个新的 CGI 进程。例如，如果 100 个用户正在访问 Web 应用，则服务器必须创建 100 个 CGI 进程来处理它们发出的请求。由于服务器资源有限，每次为新请求创建新进程都不是一个可行的选择，这会对服务器造成限制，因为服务器无法同时处理超过指定数量的用户。
Servlet 如何比 CGI 更好
每次发出新请求时，CGI 程序都由新进程处理。与 CGI 不同，servlet 程序由可以更高效地并发运行的单独线程处理。
CGI 程序可以用任何编程语言编写，使其主要依赖于平台，因为并非所有编程语言都是独立于平台的。Servlet 仅使用 Java 作为编程语言，使其与平台无关且可移植。使用 java 的另一个好处是 servlet 可以利用 java 的面向对象编程功能。
Servlet 如何工作
正如我上面提到的，对服务器的并发请求由线程处理，这里是相同的图形表示：
Servlet 的特点
现在我们已经了解了什么是 servlet 以及它正在被使用的目的。让我们进一步讨论它的主要特征。
1.便携式：
正如我上面提到的，Servlet 使用 Java 作为编程语言，因为 java 是独立于平台的，所以对于 servlet 也是如此。例如，您可以在 Windows 操作系统上创建一个 servlet，用户将 GlassFish 作为 Web 服务器，然后在任何其他操作系统（如 Unix，Linux 和 Apache tomcat Web 服务器）上运行它，此功能使 servlet 可移植，这是 servlet 优于 CGI 的主要优点。
2.高效且可扩展：
一旦 servlet 被部署并加载到 Web 服务器上，它就可以立即开始满足客户端的请求。 Web 服务器使用轻量级线程调用 servlet，因此可以使用 Java 的多线程功能同时通过 servlet 填充多个客户端请求。与服务器必须为每个客户端请求启动新进程的 CGI 相比，servlet 真正高效且可扩展。
3.强大：
通过继承 Java 的主要功能（例如垃圾收集，异常处理，Java 安全管理器等），servlet 不易出现内存管理问题和内存泄漏。这使得 servlet 中的 Web 应用开发安全且不易出错。
Servlet API
原文： https://beginnersbook.com/2013/05/servlet-api/
您需要使用 Servlet API 来创建 servlet。使用 API 时必须记住两个包，包含支持通用 servlet（独立于协议的 servlet）的类的javax.servlet包和包含支持httpServlet的类的javax.servlet.http包。你可能想知道什么是泛型和 http Servlet，我在本文后面已经解释过了。
让我们看看包的层次结构：
java.lang.Object|_extended byjavax.servlet.GenericServlet|_extended byjavax.servlet.http.HttpServlet每个 Servlet 必须实现java.servlet.Servlet接口，您可以通过扩展以下两个类之一来实现：javax.servlet.GenericServlet或javax.servlet.http.HttpServlet。第一个用于协议无关的 Servlet，第二个用于httpServlet。
servlet 如何工作？
通用 Servlet
如上所述，如果要创建GenericServlet，则必须扩展javax.servlet.GenericServlet类。GenericServlet类有一个抽象的service()方法。这意味着GenericServlet的子类应始终覆盖service()方法。
service()方法的签名：
public abstract void service(ServletRequest request, ServletResponse response)throws ServletException, java.io.IOException
service()方法接受两个参数ServletRequest对象和ServletResponse对象。请求对象告诉 servlet 客户端发出的请求，而响应对象用于将响应返回给客户端。
HTTPServlet
如果您创建HttpServlet，则必须扩展javax.servlet.http.HttpServlet类，这是一个抽象类。与GenericServlet不同，HTTPServlet不会覆盖service()方法。相反，它会覆盖以下一种或多种方法。它必须覆盖以下列表中的至少一个方法：
doGet()- 这个方法由 servlet 服务方法调用，用于处理来自客户端的 HTTPGET请求。Get方法用于从服务器获取信息doPost()- 用于向服务器发布信息doPut()- 这个方法类似于doPost方法，但与我们向服务器发送信息的doPost方法不同，此方法将文件发送到服务器，这类似于从客户端到服务器的 FTP 操作doDelete()- 允许客户端从服务器删除文档，网页或信息init()和 destroy()- 用于管理 servlet 生命周期内持有的资源getServletInfo()- 返回有关 servlet 的信息，例如作者，版本和版权。
在HttpServlet中，不需要覆盖service()方法，因为此方法将 Http 请求分派给正确的方法处理程序，例如，如果它接收到 HTTP GET请求，它会将请求分派给doGet()方法。
javax.servlet包中的接口
ServletServletRequestServletResponseServletConfigServletContextSingleThreadModelRequestDispatcherServletRequestListenerServletRequestAttributeListenerServletContextListenerServletContextAttributeListenerFilterFilterConfigFilterChain
javax.servlet包中的类
GenericServletServletInputStreamServletOutputStreamServletExceptionServletRequestWrapperServletRequestEventServletResponseWrapperServletContextEventServletRequestAttributeEventServletContextAttributeEventUnavailableException
javax.servlet.http包中的接口
HttpSessionHttpServletRequestHttpServletResponseHttpSessionAttributeListenerHttpSessionListenerHttpSessionBindingListenerHttpSessionActivationListenerHttpSessionContext
javax.servlet.http包中的类
HttpServletCookieHttpSessionEventHttpSessionBindingEventHttpServletRequestWrapperHttpServletResponseWrapperHttpUtils
参考：
- 官方 Servlet API 文档：
javax.servlet - API 文档：
java.servlet.http
Servlet接口解释
原文： https://beginnersbook.com/2014/04/servlet-interface/
在我关于 Servlet API 的上一篇指南中，我已经解释过要创建任何 Servlet，你必须直接或间接地实现Servlet接口（间接实现意味着扩展那些实现Servlet接口的类，这些类是GenericServlet和HttpServlet） 。
如果您正在创建协议相关的 servlet，例如httpServlet，那么您应该扩展HttpServlet类，以便扩展GenericServlet 类的协议无关的Servlet。
在本指南中，我不打算详细解释GenericServlet和HttpServlet，因为我已经在单独的指南中介绍了它们。
编辑：以下是这些指南的链接： GenericServlet，HttpServlet 。
总之，你有 3 种方法来创建一个 servlet：
1）通过扩展
HttpServlet类2）通过扩展
GenericServlet类3）通过实现
Servlet接口注意：但是你应该总是喜欢第一个创建 servlet 的方法，即通过扩展
HttpServlet类。
Servlet接口方法
以下是Servlet接口中可用的方法列表。
1） void destroy()：这个方法在 servlet 生命周期结束时由 Servlet 容器调用。与在生命周期中多次调用的service()方法不同，此方法在整个生命周期中仅由 Servlet 容器调用一次。一旦调用了destroy()方法，servlet 容器就不会为该 servlet 调用service()方法。
2） void init(ServletConfig config)：当 Servlet 容器启动时（在 Web 服务器启动时发生），它加载所有 servlet 并实例化它们。在为每个实例化的 servlet 调用此init()方法之后，此方法初始化 servlet。
3） void service(ServletRequest req, ServletResponse res)：这是在 servlet 生命周期中多次调用的唯一方法。此方法为客户端请求提供服务，每次服务器收到请求时都会调用它。
4） ServletConfig getServletConfig()：返回一个ServletConfig对象，该对象包含该 servlet 的初始化和启动参数。
5） String getServletInfo()：返回有关 servlet 的信息，例如作者，版本和版权。
例：
在这个例子中，我们通过扩展Servlet接口创建了一个 servlet 类。
index.html
<a href="welcome">Click here to call the servlet</a>
DemoServlet.java
import java.io.*;
import javax.servlet.*;
public class DemoServlet implements Servlet{ServletConfig config=null;public void init(ServletConfig config){this.config=config;System.out.println("Initialization complete");}public void service(ServletRequest req,ServletResponse res)throws IOException,ServletException{res.setContentType("text/html");PrintWriter pwriter=res.getWriter();pwriter.print("<html>");pwriter.print("<body>");pwriter.print("<h1>Servlet Example Program</h1>");pwriter.print("</body>");pwriter.print("</html>");}public void destroy(){System.out.println("servlet life cycle finished");}public ServletConfig getServletConfig(){return config;}public String getServletInfo(){return "A Demo program written by Chaitanya";}
}
web.xml
<web-app>
<servlet><servlet-name>Beginnersbook</servlet-name><servlet-class>DemoServlet</servlet-class>
</servlet><servlet-mapping><servlet-name>Beginnersbook</servlet-name><url-pattern>/welcome</url-pattern>
</servlet-mapping>
</web-app>
参考：
Servlet 接口
GenericServlet类
原文： https://beginnersbook.com/2014/04/genericservlet-class/
在讨论 Servlet API 时，我已经讨论了一些关于GenericServlet的内容。在本文中，我将详细讨论GenericServlet。
GenericServlet是一个独立于协议的 Servlet，它应该始终覆盖service()方法来处理客户端请求。service()方法接受两个参数ServletRequest对象和ServletResponse对象。请求对象告诉 servlet 客户端发出的请求，而响应对象用于将响应返回给客户端。
GenericServlet如何工作？
GenericServlet的层次结构
java.lang.Object|_extended byjavax.servlet.GenericServlet
GenericServlet是一个抽象类，它只有一个抽象方法，即service()。这就是为什么当我们通过扩展GenericServlet类来创建GenericServlet时，我们必须覆盖service()方法。
使用GenericServlet的优点：
GenericServlet更容易编写- 具有简单的生命周期方法
- 要编写
GenericServlet，您只需要扩展javax.servlet.GenericServlet并覆盖service()方法（请查看下面的示例）。
使用GenericServlet的缺点：
使用GenericServlet并不是那么容易，因为我们在GenericServlet中没有像doGet()，doPost()，doHead()等方便的方法可以在HttpServlet中使用。
在HttpServlet中，我们需要为特定请求覆盖特定的便捷方法，例如，如果您需要获取信息，则覆盖doGet()，如果要向服务器发送信息覆盖doPost()。但是在GenericServlet中，我们只为每种类型的请求覆盖service()方法，这很麻烦。
我总是建议你使用HttpServlet而不是GenericServlet。HttpServlet更易于使用，并且具有比GenericServlet更多的方法。
GenericServlet的示例
我在这个例子中使用 Eclipse IDE。从 Eclipse 文件菜单中创建新的Dynamic Web Project。
我已经解释了在 Eclipse IDE 中创建 Servlet 的每一步，但是如果您刚接触 Eclipse 并且没有在系统上安装它，那么请参考本指南：如何安装 Eclipse，设置 Tomcat 并使用 Eclipse IDE运行第一个 servlet 程序。
完成后，在 IDE 中创建以下所有文件后，项目结构（或层次结构）将如下所示。
index.htm
我们正在创建一个 html 文件，一旦我们点击网页上的链接就会调用 servlet。在WebContent文件夹中创建此文件。该文件的路径应如下所示：WebContent/index.html
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Generic Servlet Demo</title>
</head>
<body>
<a href="welcome">Click to call Servlet</a>
</body>
</html>
ExampleGeneric.java
现在，我们通过扩展GenericServlet类来创建GenericServlet。创建GenericServlet时，应始终覆盖service()方法。右键单击src文件夹并创建一个新的类文件，将该文件命名为ExampleGeneric。文件路径应如下所示：Java Resouces/src/default package/ExampleGeneric.java
import java.io.*;
import javax.servlet.*;public class ExampleGeneric extends GenericServlet{public void service(ServletRequest req,ServletResponse res)
throws IOException,ServletException{res.setContentType("text/html");PrintWriter pwriter=res.getWriter();pwriter.print("<html>");pwriter.print("<body>");pwriter.print("<h2>Generic Servlet Example</h2>");pwriter.print("<p>Hello BeginnersBook Readers!</p>");pwriter.print("</body>");pwriter.print("</html>");}
}web.xml
此文件可在此路径WebContent/WEB-INF/web.xml中找到。在此文件中，我们将使用特定 URL 映射 Servlet。由于我们在单击index.html页面上的链接时调用欢迎页面，因此我们将欢迎页面映射到我们上面创建的 Servlet 类。
<web-app>
<display-name>BeginnersBookServlet</display-name>
<welcome-file-list>
<welcome-file>index.html</welcome-file>
<welcome-file>index.htm</welcome-file>
<welcome-file>index.jsp</welcome-file>
<welcome-file>default.html</welcome-file>
<welcome-file>default.htm</welcome-file>
<welcome-file>default.jsp</welcome-file>
</welcome-file-list><servlet>
<servlet-name>MyGenericServlet</servlet-name>
<servlet-class>ExampleGeneric</servlet-class>
</servlet><servlet-mapping>
<servlet-name>MyGenericServlet</servlet-name>
<url-pattern>/welcome</url-pattern>
</servlet-mapping></web-app>
输出：
点击第一个屏幕中的链接后的屏幕：
GenericServlet类的方法：
以下是GenericServlet类的所有方法的列表。
-
public void init()：这是一种方便的方法。可以重写此方法，因此无需调用super.init(config)。 -
public void init(ServletConfig config)：由 servlet 容器调用以指示 servlet 正在投入使用，此方法用于初始化 servlet。 -
public String getInitParameter(String name)：返回包含给定初始化参数值的String，如果参数不存在，则返回null。 -
public Enumeration getInitParameterNames()：返回web.xml文件中定义的所有参数的名称，如果web.xml没有任何参数，则返回null。 -
public abstract void service(ServletRequest request, ServletResponse response)：由 Servlet 容器调用，允许 servlet 响应客户端发出的请求。 -
public void destroy()：servlet 容器在 servlet 生命周期结束时调用一次，表明 servlet 正在被销毁。 -
public ServletConfig getServletConfig()：返回初始化此 servlet 的ServletConfig对象 -
public String getServletInfo()：返回有关 servlet 的信息。 -
public ServletContext getServletContext()：返回ServletContext对象，由init方法传递给这个 servlet -
public String getServletName()：返回 servlet 实例的名称。 -
public void log(String msg)：在 servlet 日志文件中写入给定的消息。 -
public void log(String msg, Throwable t)：在 servlet 日志文件中写入解释性消息，包括描述错误或异常的String。
参考：
GenericServlet官方文档
HttpServlet类
原文： https://beginnersbook.com/2013/05/http-servlet/
在 Servlet API 中，我对HttpServlet进行了一些讨论。在本文中，我将详细讨论HttpServlet。
与GenericServlet不同，HTTPServlet不会覆盖service()方法。相反，它会覆盖doGet()方法或doPost()方法或两者。doGet()方法用于从服务器获取信息，而doPost()方法用于向服务器发送信息。
在HttpServlet中，不需要覆盖service()方法，因为此方法将 Http 请求分派给正确的方法处理程序，例如，如果它接收到 HTTP GET请求，则会将请求分派给doGet()方法。
`HttpServlet 如何工作？
正如您在下图中看到的那样，客户端（用户的浏览器）发出请求。这些请求可以是任何类型，例如 - GET请求，POST请求，HEAD请求等。服务器将这些请求分派给 servlet 的service()方法，此方法将这些请求分派给正确的处理程序，例如，如果它接收到Get请求它将其分派给doGet()方法。
HttpServlet的层次结构
java.lang.Object|_extended byjavax.servlet.GenericServlet|_extended byjavax.servlet.http.HttpServlet
我已经在GenericServlet文章中讨论过你应该总是使用HttpServlet而不是GenericServlet。HttpServlet更易于使用，并且具有比GenericServlet更多的方法。
HttpServlet的例子
我在这个例子中使用 Eclipse IDE。从 Eclipse 文件菜单中创建新的Dynamic Web Project。
我已经解释了在 Eclipse IDE 中创建 Servlet 的所有步骤，但是如果您不熟悉 Eclipse 并且没有在系统上安装它，请参考本指南：如何安装 Eclipse，配置 tomcat 并使用 Eclipse 运行第一个 Servlet 应用。
完成后，在 IDE 中创建以下所有文件后，项目结构（或层次结构）将如下所示。
index.html
我们正在创建一个 html 文件，一旦我们点击网页上的链接就会调用 servlet。在WebContent文件夹中创建此文件。该文件的路径应如下所示：WebContent/index.html
index<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Http Servlet Demo</title>
</head>
<body>
<a href="welcome">Click to call Servlet</a>
</body>
</html>ExampleHttpServlet.java
现在，我们通过扩展HttpServlet类来创建一个HttpServlet。右键单击src文件夹并创建一个新的类文件，将该文件命名为ExampleHttpServlet。文件路径应如下所示：Java Resources/src/default package/ExampleHttpServlet.java
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
// Creating Http Servlet by Extending HttpServlet class
public class ExampleHttpServlet extends HttpServlet
{ private String mymsg;public void init() throws ServletException { mymsg = "Http Servlet Demo"; }public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { // Setting up the content type of web page response.setContentType("text/html");// Writing the message on the web page PrintWriter out = response.getWriter(); out.println("<h1>" + mymsg + "</h1>"); out.println("<p>" + "Hello Friends!" + "</p>"); }public void destroy() { // Leaving empty. Use this if you want to perform //something at the end of Servlet life cycle. }
}
web.xml
此文件可在此路径WebContent/WEB-INF/web.xml中找到。在此文件中，我们将使用特定 URL 映射 Servlet。由于我们在单击index.html页面上的链接时调用欢迎页面，因此我们将欢迎页面映射到我们上面创建的 Servlet 类。
<web-app>
<display-name>BeginnersBookServlet</display-name>
<welcome-file-list>
<welcome-file>index.html</welcome-file>
<welcome-file>index.htm</welcome-file>
<welcome-file>index.jsp</welcome-file>
<welcome-file>default.html</welcome-file>
<welcome-file>default.htm</welcome-file>
<welcome-file>default.jsp</welcome-file>
</welcome-file-list><servlet>
<servlet-name>MyHttpServlet</servlet-name>
<servlet-class>ExampleHttpServlet</servlet-class>
</servlet><servlet-mapping>
<servlet-name>MyHttpServlet</servlet-name>
<url-pattern>/welcome</url-pattern>
</servlet-mapping></web-app>运行项目：
右键单击index.html，在服务器上运行。
输出：
单击链接后，您将看到此屏幕：
HttpServlet类的方法
-
protected void doGet(HttpServletRequest req, HttpServletResponse resp)：这个方法由 servletservice方法调用，以处理来自客户端的 HTTPGET请求。覆盖此方法时，请读取请求数据，编写响应头，获取响应的编写器或输出流对象，最后编写响应数据。 -
protected long getLastModified(HttpServletRequest req)：返回一个长整数，指定上次修改HttpServletRequest对象的时间，格林威治标准时间 1970 年 1 月 1 日午夜（以秒为单位），如果时间不知道，则返回 -1 -
protected void doHead(HttpServletRequest req, HttpServletResponse resp)：这个方法由 servletservice方法调用，以处理来自客户端的 HTTPHEAD请求。当客户端想要仅查看响应的标头（例如Content-Type或Content-Length）时，它会发送HEAD请求 -
protected void doPost(HttpServletRequest req, HttpServletResponse resp)：servletservice方法调用此方法来处理来自客户端的POST请求。 HTTPPOST方法允许客户端一次性向 Web 服务器发送无限长度的数据，并且在向服务器发布信息时非常有用。与doGet不同，我们从服务器获取信息时，在从客户端向服务器传输信息时使用此方法。 -
protected void doPut(HttpServletRequest req, HttpServletResponse resp)：这个方法由 servletservice方法调用，以处理来自客户端的PUT请求。此方法类似于doPost方法，但与我们向服务器发送信息的doPost方法不同，此方法将文件发送到服务器，这类似于从客户端到服务器的 FTP 操作。 -
protected void doDelete(HttpServletRequest req, HttpServletResponse resp)：由 servletservice()方法调用，以处理来自客户端的DELETE请求，允许客户端从服务器删除文档，网页或信息。 -
protected void doOptions(HttpServletRequest req, HttpServletResponse resp)：由service方法调用，以允许 servlet 处理OPTIONS请求。OPTIONS请求确定服务器支持哪些 HTTP 方法并返回适当的标头。 -
protected void doTrace(HttpServletRequest req, HttpServletResponse resp)：此方法由service()方法调用，用于处理TRACE请求。用于调试目的。 -
protected void service(HttpServletRequest req, HttpServletResponse resp)：没有必要覆盖此方法，此方法从客户端接收 HTTP 请求并将它们转发到相应的 doXXX 方法，如doGet()，doPost()，doHEAD()等 -
public void service(ServletRequest req, ServletResponse res)：将客户端请求转发给受保护的service方法。也没有必要重写此方法。
参考：HttpServlet官方文档
如何在 Eclipse IDE 中创建和运行 Servlet
原文： https://beginnersbook.com/2017/07/how-to-create-and-run-servlet-in-eclipse-ide/
这是安装 Eclipse，设置 apache tomcat 服务器和运行第一个 hello world servlet 应用的完整指南。
下载 Eclipse IDE
在 Windows 上安装 Eclipse
转到此链接 https://www.eclipse.org/downloads 。在“获取 Eclipse Oxygen”下单击“下载软件包”下载“Eclipse IDE for Java Developers”。您会在右侧看到两个选项（32 位和 64 位），如果系统是 32 位，则单击 32 位，否则单击 64 位。这将在您的系统上下载压缩文件。
要安装 Eclipse，请解压缩下载的文件并将解压缩的文件夹复制到所需的位置。
在 Mac OS X 上安装 Eclipse
转到此链接 https://www.eclipse.org/downloads 。在“获取 Eclipse Oxygen”下单击“下载软件包”❯下载“Eclipse IDE for Java Developers”。要下载点击 64 位，它将下载一个 TAR 文件。
下载完成后，双击 TAR 文件，它会将文件的内容提取到一个文件夹中。将文件夹拖到“Applications”文件夹。
要启动 Eclipse ，请单击 Eclipse 文件夹中的 Eclipse 图标。 Mac 用户可以将其拖到停靠区域以从桌面快速启动 Eclipse，类似 Windows 可以在桌面上创建 Eclipse 的快捷方式。
在 Eclipse 中安装和配置 Apache tomcat 服务器
要在 Eclipse IDE 中运行 Servlet，您需要在 Eclipse IDE 中配置 Apache tomcat Server。
如果您没有它，请参阅本教程：如何在 Eclipse IDE 中下载和配置 Apache Tomcat 服务器。
注意：我上面提供的链接属于 JSP 教程，但 Servlet 的步骤也是如此。
在 Eclipse IDE 中创建 Servlet
第 1 步：创建项目：
让我们在 Eclipse 中创建一个 Servlet 应用。打开 Eclipse，然后单击“文件❯新建❯动态 Web 项目”。
如果您在 Eclipse 中没有看到动态 Web 项目选项，请参阅本教程：如何修复 Eclipse 问题中缺少的“动态 Web 项目”
提供项目名称，然后单击下一步
勾选显示生成web.xml部署描述符的复选框
初始项目结构：
项目创建后，层次结构（项目结构）如下所示：
第 2 步：创建 Servlet 类：
我们通过扩展HttpServlet类来创建一个HttpServlet。右键单击src文件夹并创建一个新的类文件，将该文件命名为MyServletDemo。文件路径应如下所示：Java Resources/src/default package/MyServletDemo.java
MyServletDemo.java
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;// Extend HttpServlet class to create Http Servlet
public class MyServletDemo extends HttpServlet {private String mymsg;public void init() throws ServletException {mymsg = "Hello World!";}public void doGet(HttpServletRequest request, HttpServletResponse response)throws ServletException, IOException {// Setting up the content type of webpageresponse.setContentType("text/html");// Writing message to the web pagePrintWriter out = response.getWriter();out.println("<h1>" + mymsg + "</h1>");}public void destroy() {/* leaving empty for now this can be* used when we want to do something at the end* of Servlet life cycle*/}
}
第 3 步：创建一个 html 页面来调用网页上的 servlet 类
我们正在创建一个 html 文件，一旦我们点击网页上的链接就会调用 servlet。在WebContent文件夹中创建此文件。文件的路径应如下所示：WebContent/index.html
index.html
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>BeginnersBook Servlet Demo</title>
</head>
<body>
<a href="welcome">Click to call Servlet</a>
</body>
</html>编辑web.xml文件
此文件可在此路径WebContent/WEB-INF/web.xml中找到。在此文件中，我们将使用特定 URL 映射 Servlet。由于我们在单击index.html页面上的链接时调用欢迎页面，因此我们将欢迎页面映射到我们上面创建的 Servlet 类。
<web-app>
<display-name>BeginnersBookDemo</display-name>
<welcome-file-list>
<welcome-file>index.html</welcome-file>
<welcome-file>index.htm</welcome-file>
<welcome-file>index.jsp</welcome-file>
<welcome-file>default.html</welcome-file>
<welcome-file>default.htm</welcome-file>
<welcome-file>default.jsp</welcome-file>
</welcome-file-list><servlet>
<servlet-name>MyHttpServletDemo</servlet-name>
<servlet-class>MyServletDemo</servlet-class>
</servlet><servlet-mapping>
<servlet-name>MyHttpServletDemo</servlet-name>
<url-pattern>/welcome</url-pattern>
</servlet-mapping></web-app>最终项目结构
运行项目：
右键单击index.html，在服务器上运行。
单击“全部添加”以在服务器上部署项目。单击完成
输出：
单击链接后，您将看到此屏幕：
Servlet 生命周期
原文： https://beginnersbook.com/2013/05/servlet-life-cycle/
Servlet 生命周期可以描述为 servlet 在其生命周期中从一系列步骤开始，从加载开始直到它被破坏。
在我开始解释 Servlet 的生命周期之前，我们先讨论一下您在阅读本指南时会遇到的几个术语。了解每个术语的含义非常重要，这将有助于您更快地理解事物。
Web 服务器：它也称为 HTTP 服务器，它可以处理客户端发送的 HTTP 请求，并使用 HTTP 响应来响应请求。
Web 容器：也称为 Servlet 容器和 Servlet 引擎。它是 Web Server 的一部分，与 Servlet 交互。这是管理 Servlet 生命周期的 Web Server 的主要组件。
注意：您在本网站中找到的 servlet 教程使用 apache tomcat web 服务器。虽然我将其称为 Web 服务器，但它实际上是一个 Web 服务器和 Web 容器。 （如上所述，Web 容器是 Web 服务器的一部分）。
Servlet 的生命周期
Servlet 生命周期包含五个步骤：1）加载 Servlet，2）创建 Servlet 实例，3）调用init()一次，4）为每个客户端请求重复调用service()，5）调用destroy()
对于那些想知道什么是实例和调用的人来说：实例和对象是一回事。调用方法意味着调用一个方法，它只是一个奇特的词，我们在编程世界中使用而不是调用:)
让我们回到主题。以下是 servlet 生命周期的五个步骤。
步骤 1：加载 Servlet
当 Web 服务器（例如 Apache Tomcat）启动时，servlet 容器部署并加载所有 servlet。
步骤 2：创建 Servlet 实例
一旦加载了所有 Servlet 类，servlet 容器就会创建每个 servlet 类的实例。 Servlet 容器每个 servlet 类只创建一个实例，并且对 servlet 的所有请求都在同一个 servlet 实例上执行。
步骤 3：调用init()方法
一旦实例化了所有 servlet 类，就会为每个实例化的 servlet 调用init()方法。此方法初始化 servlet。您可以在部署描述符（web.xml）文件中指定某些init参数。例如，如果 servlet 的值>= 0，则在 Web 容器启动期间立即调用其init()方法。
您可以在web.xml文件中指定元素，如下所示：
<servlet><servlet-name>MyServlet</servlet-name><servlet-class>com.beginnersbook.MyServletDemo</servlet-class><load-on-startup>1</load-on-startup>
</servlet>现在，在 Web 容器启动期间将调用相应 servlet 类com.beginnersbook.MyServletDemo的 init()方法。
注意：init（）方法在 servlet 的生命周期中只调用一次。
步骤 4：调用service()方法
每次 Web 服务器收到 servlet 请求时，它都会产生一个调用service()方法的新线程。如果 servlet 是GenericServlet，那么请求由service()方法本身提供，如果 servlet 是HttpServlet，则service()方法接收请求并根据请求的类型将其分派给正确的处理程序方法。
例如，如果它是Get请求，则service()方法会通过使用请求参数调用doGet()方法将请求分派给doGet()方法。类似地，诸如Post，Head，Put等的请求被 servlet 的service()方法分派给相应的处理程序doPost()，doHead()，doPut()等。
注意：与只调用一次的init()和destroy()不同，在 servlet 生命周期中可以多次调用service()方法。只要不销毁 servlet，就会为每个客户端请求调用service()方法。
在生命周期的所有 5 个步骤中，这是多次执行的唯一步骤。
步骤 5：调用destroy()方法
当 servlet 容器关闭时（这通常在我们停止 Web 服务器时发生），它卸载所有 servlet 并为每个初始化的 servlet 调用destroy()方法。
Servlet 的工作原理
原文： https://beginnersbook.com/2013/05/working-of-servlets/
在我开始解释 servlet 如何工作之前，让我们熟悉这三个术语。
Web 服务器：它可以处理客户端发送的 HTTP 请求，并通过 HTTP 响应响应请求。
Web 应用（webapp）：我在本指南中将其称为 webapp。基本上该项目是您的 Web 应用，它是 servlet 的集合。
Web 容器：也称为 Servlet 容器和 Servlet 引擎。它是 Web Server 的一部分，与 Servlet 交互。这是管理 Servlet 生命周期的 Web Server 的主要组件。
您会发现本指南的某些部分已在 servlet 生命周期指南中介绍，但本指南主要介绍 servlet 应用（webapp）的工作，而不是生命周期的步骤。我强烈建议您阅读本文，深入了解 servlet 的实际工作原理。
Servlet 如何工作？
1）当 Web 服务器（例如 Apache Tomcat）启动时，servlet 容器部署并加载所有 servlet。在此步骤中，Servlet 容器创建ServletContext对象。ServletContex是一个接口，它定义了可以用来与 servlet 容器**通信的方法集。
注：每个 webapp 只有一个ServletContext，这对所有 servlet 都是通用的。ServletContext有几个有用的方法，如addListener()，addFilter()等。现在我不解释它们，因为我将在一个关于ServletContext的单独文本中介绍它们。
2）一旦加载了 servlet，servlet 容器就会创建 servlet 类的实例。对于每个实例化的 servlet，调用其init()方法。
3）客户端（用户浏览器）向某个端口上的 Web 服务器发送 Http 请求。每次 Web 服务器收到请求时，servlet 容器都会创建HttpServletRequest和HttpServletResponse对象。HttpServletRequest对象提供对请求信息的访问，HttpServletResponse对象允许我们在将 http 响应发送到客户端之前对其进行格式化和更改。
servlet 容器生成一个新线程，该线程为每个客户端请求调用service()方法。service()方法根据请求类型将请求调度到正确的处理程序方法。
例如，如果服务器收到Get请求，则service()方法会通过使用请求参数调用doGet()方法将请求分派给doGet()方法。类似地，诸如Post，Head，Put等的请求被 servlet 的service()方法分派给相应的处理程序doPost()，doHead()，doPut()等。
4）当 servlet 容器关闭时，它会卸载所有 servlet 并为每个初始化的 servlet 调用destroy()方法。
![[日志分析篇]-利用ELK分析jumpserver日志-日志拆分篇](https://img2024.cnblogs.com/blog/1919503/202410/1919503-20241024173407706-1317493237.png)
