Java Servlet彻底教程

时间  2019-11-25
标签 java servlet 彻底 教程 栏目 Java 繁體版
原文   原文链接

Servlet 是一些听从Java Servlet API的Java类，这些Java类能够响应请求。尽管Servlet能够响应任意类型的请求，可是它们使用最普遍的是响应web方面的请求。 Servlet必须部署在Java servlet容器才能使用。虽然不少开发者都使用Java Server Pages（JSP）和Java Server Faces（JSF）等Servlet框架，可是这些技术都要在幕后经过Servlet容器把页面编译为Java Servlet。也就是说，了解Java Servlet技术的基础知识对任何Java web开发者来讲是颇有用的。html

在这个教程里，咱们将会经过下面的专题来全面了解Java Servlet技术。java

目录web

  • 编写你的第一个Servlet
  • Servlet生命周期方法
  • 使用@WebServlet注解开发Servlet
  • 打包和部署Servlet到Tomcat服务器
  • 编写动态的Servlet响应内容
  • 处理Servlet请求和响应
  • 监听Servlet容器事件
  • 传递Servlet初始化参数
  • 为特定的URL请求添加Servlet过滤器
  • 使用Servlet下载二进制文件
  • 使用RequestDispatcher.forward()转发请求到另外一个Servlet
  • 使用HttpServletResponse.sendRedirect()重定向请求到另外一个Servlet
  • 使用Servlets读写Cookie

让咱们一块儿来一步步地学习Servlet。api

编写你的第一个Servlet浏览器

咱们的第一个Servlet是一个只拥有少许代码的简单Servlet，目的是让你只需关注它的行为。缓存

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
package com.howtodoinjava.servlets;
 
import java.io.IOException;
import java.io.PrintWriter;
 
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
 
public class MyFirstServlet extends HttpServlet {
 
     private static final long serialVersionUID = -1915463532411657451L;
 
     @Override
     protected void doGet(HttpServletRequest request,
             HttpServletResponse response) throws ServletException, IOException
     {
         response.setContentType( "text/html;charset=UTF-8" );
         PrintWriter out = response.getWriter();
         try {
             // Write some content
             out.println( "<html>" );
             out.println( "<head>" );
             out.println( "<title>MyFirstServlet</title>" );
             out.println( "</head>" );
             out.println( "<body>" );
             out.println( "<h2>Servlet MyFirstServlet at " + request.getContextPath() + "</h2>" );
             out.println( "</body>" );
             out.println( "</html>" );
         } finally {
             out.close();
         }
     }
 
     @Override
     protected void doPost(HttpServletRequest request,
             HttpServletResponse response) throws ServletException, IOException {
         //Do some other work
     }
 
     @Override
     public String getServletInfo() {
         return "MyFirstServlet" ;
     }
}

为了在web容器里注册上面的Servlet，你要为你的应用建一个web.xml入口文件。tomcat

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
<?xml version= "1.0" ?>
<web-app     xmlns= "http://xmlns.jcp.org/xml/ns/javaee"
             xmlns:xsi= "http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http: //xmlns.jcp.org/xml/ns/javaee
 
http: //xmlns.jcp.org/xml/ns/javaee/web-app_3_0.xsd"
 
             version= "3.0" >
 
     <welcome-file-list>
         <welcome-file>/MyFirstServlet</welcome-file>
     </welcome-file-list>
 
     <servlet>
         <servlet-name>MyFirstServlet</servlet-name>
         <servlet- class >com.howtodoinjava.servlets.MyFirstServlet</servlet- class >
     </servlet>
     <servlet-mapping>
         <servlet-name>MyFirstServlet</servlet-name>
         <url-pattern>/MyFirstServlet</url-pattern>
     </servlet-mapping>
 
</web-app>

上面的Servlet作了一些重要的事情，你可能想了解的。安全

  1. MyFirstServlet类继承了HttpServlet。这个继承是必须的，由于全部的Servlet必须是要么继承了 javax.servlet.GenericServlet 的普通Servlet，要么是继承了 javax.servlet.http.HttpServlet 的HTTP Servlet。
  2. 从新 doGet() 和 doPost() 方法。这两个方法都已在 HttpServlet 类里定义了。当一个GET或POST请求到来时，它就会被映射到相应的方法里。例如，若是你向这个servlet发送一个HTTP GET请求，doGet()方法就会被调用。
  3. 这里也有一些其余有用的方法。你能够重写它们来在运行时控制应用。例如getServletInfo()。
  4. HttpServletRequest 和 HttpServletResponse 是全部doXXX()方法的默认参数。咱们会在后面的章节里详细学习这些对象。

以上全部关于简单Servlet的内容就是你须要知道的内容。服务器

Servlet生命周期方法cookie

在你的应用加载并使用一个Servlet时，从初始化到销毁这个Servlet期间会发生一系列的事件。这些事件叫作Servlet的生命周期事件（或方法）。让咱们一块儿来进一步了解它们。

Servlet生命周期的三个核心方法分别是 init() , service() 和 destroy()。每一个Servlet都会实现这些方法，而且在特定的运行时间调用它们。

1) 在Servlet生命周期的初始化阶段，web容器经过调用init()方法来初始化Servlet实例，而且能够传递一个实现 javax.servlet.ServletConfig 接口的对象给它。这个配置对象（configuration object）使Servlet可以读取在web应用的web.xml文件里定义的名值（name-value）初始参数。这个方法在Servlet实例的生命周期里只调用一次。

init方法定义与这相似：

1
2
3
public void  init() throws ServletException {
     //custom initialization code
}

2) 初始化后，Servlet实例就能够处理客户端请求了。web容器调用Servlet的service()方法来处理每个请求。service() 方法定义了可以处理的请求类型而且调用适当方法来处理这些请求。编写Servlet的开发者必须为这些方法提供实现。若是发出一个Servlet没实现的请求，那么父类的方法就会被调用而且一般会给请求方（requester）返回一个错误信息。

一般，咱们不须要重写（override）这个方法。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
protected void service(HttpServletRequest req, HttpServletResponse resp)
     throws ServletException, IOException
{
String method = req.getMethod();
 
if (method.equals(METHOD_GET)) {
     long lastModified = getLastModified(req);
     if (lastModified == - 1 ) {
     // servlet doesn't support if-modified-since, no reason
     // to go through further expensive logic
     doGet(req, resp);
     } else {
     long ifModifiedSince = req.getDateHeader(HEADER_IFMODSINCE);
     if (ifModifiedSince < (lastModified / 1000 * 1000 )) {
         // If the servlet mod time is later, call doGet()
                 // Round down to the nearest second for a proper compare
                 // A ifModifiedSince of -1 will always be less
         maybeSetLastModified(resp, lastModified);
         doGet(req, resp);
     } else {
         resp.setStatus(HttpServletResponse.SC_NOT_MODIFIED);
     }
     }
 
} else if (method.equals(METHOD_HEAD)) {
     long lastModified = getLastModified(req);
     maybeSetLastModified(resp, lastModified);
     doHead(req, resp);
 
} else if (method.equals(METHOD_POST)) {
     doPost(req, resp);
 
} else if (method.equals(METHOD_PUT)) {
     doPut(req, resp);  
 
} else if (method.equals(METHOD_DELETE)) {
     doDelete(req, resp);
 
} else if (method.equals(METHOD_OPTIONS)) {
     doOptions(req,resp);
 
} else if (method.equals(METHOD_TRACE)) {
     doTrace(req,resp);
 
} else {
     //
     // Note that this means NO servlet supports whatever
     // method was requested, anywhere on this server.
     //
 
     String errMsg = lStrings.getString( "http.method_not_implemented" );
     Object[] errArgs = new Object[ 1 ];
     errArgs[ 0 ] = method;
     errMsg = MessageFormat.format(errMsg, errArgs);
 
     resp.sendError(HttpServletResponse.SC_NOT_IMPLEMENTED, errMsg);
}
}

3) 最后，web容器调用destroy()方法来终结Servlet。若是你想在Servlet的生命周期内关闭或者销毁一些文件系统或者网络资源，你能够调用这个方法来实现。destroy() 方法和init()方法同样，在Servlet的生命周期里只能调用一次。

1
2
3
public void destroy() {
//
}

在大多数状况下，你一般不须要在你的Servlet里重写这些方法。

扩展阅读：web服务器是如何运做的？

使用@WebServlet注解来开发Servlet

若是你不喜欢使用xml配置而喜欢注解的话，不要紧，Servlets API一样提供了一些注解接口给你。你能够像下面的例子同样使用 @WebServlet 注解而且不须要在web.xml里为Servlet注册任何信息。容器会自动注册你的Servlet到运行环境，而且像往常同样处理它。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
package com.howtodoinjava.servlets;
 
import java.io.IOException;
import java.io.PrintWriter;
 
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
 
@WebServlet (name = "MyFirstServlet" , urlPatterns = { "/MyFirstServlet" })
public class MyFirstServlet extends HttpServlet {
 
     private static final long serialVersionUID = -1915463532411657451L;
 
     @Override
     protected void doGet(HttpServletRequest request,
             HttpServletResponse response) throws ServletException, IOException
     {
         //Do some work
     }
 
     @Override
     protected void doPost(HttpServletRequest request,
             HttpServletResponse response) throws ServletException, IOException {
         //Do some other work
     }
}

打包和部署Servlet到Tomcat服务器

若是你在使用IDE（例如Eclipse），那么打包和部署你的应用只须要一个简单的步骤。右击项目> Run As > Run As Server。若是还没配置服务器先配置好服务器，而后就能够准备开干了。

若是你没在使用IDE，那么你须要作一些额外的工做。好比，使用命令提示符编译应用，使用ANT去生成war文件等等。但我相信，如今的开发者都在使用IDE来开发。因此我就不在这方面浪费时间了。

当你把咱们的第一个Servlet部署到tomcat上并在浏览器输入“http://localhost:8080/servletexamples/MyFirstServlet”，你会获得下面的响应。

 

编写动态的Servlet响应内容

Java Servlets如此有用的缘由之一是Servlet能动态显示网页内容。这些内容能够从服务器自己、另一个网站、或者许多其余网络能够访问的资源里获取。Servlet不是静态网页，它们是动态的。能够说这是它们最大的优点。

让咱们来举个Servlet例子，这个Servlet会显示当前日期和时间给用户而且会显示用户名和一些自定义的信息。让咱们来为这个功能编写代码吧。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
package com.howtodoinjava.servlets;
 
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
 
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
 
@WebServlet (name = "CalendarServlet" , urlPatterns = { "/CalendarServlet" })
public class CalendarServlet extends HttpServlet {
 
     private static final long serialVersionUID = -1915463532411657451L;
 
     @Override
     protected void doGet(HttpServletRequest request,
             HttpServletResponse response) throws ServletException, IOException
     {
 
         Map<String,String> data = getData();
 
         response.setContentType( "text/html;charset=UTF-8" );
         PrintWriter out = response.getWriter();
         try {
             // Write some content
             out.println( "<html>" );
             out.println( "<head>" );
             out.println( "<title>CalendarServlet</title>" );
             out.println( "</head>" );
             out.println( "<body>" );
             out.println( "<h2>Hello " + data.get( "username" ) + ", " + data.get( "message" ) + "</h2>" );
             out.println( "<h2>The time right now is : " + new Date() + "</h2>" );
             out.println( "</body>" );
             out.println( "</html>" );
         } finally {
             out.close();
         }
     }
 
     //This method will access some external system as database to get user name, and his personalized message
     private Map<String, String> getData()
     {
         Map<String, String> data = new HashMap<String, String>();
         data.put( "username" , "Guest" );
         data.put( "message" ,  "Welcome to my world !!" );
         return data;
     }
}

当你在tomcat里运行上面的Servlet并在浏览器里输入“http://localhost:8080/servletexamples/CalendarServlet”，你会得得下面的响应。

处理Servlet请求和响应

Servlet能够轻松建立一个基于请求和响应生命周期的web应用。它们可以提供HTTP响应而且可使用同一段代码来处理业务逻辑。处理业务逻辑的能力使Servlet比标准的HTML代码更强大。

现实世界里的应用，一个HTML网页表单包含了要发送给Servlet的参数。Servlet会以某种方式来处理这些参数而且 返回一个客户端可以识别的响应。在对象是HttpServlet的状况下，客户端是web浏览器，响应是web页面。<form>的 action属性指定了使用哪一个Servlet来处理表单里的参数值。

为了获取请求参数，须要调用 HttpServletRequest 对象的 getParameter() 方法，而且传递你要获取的输入参数的id给该方法。

1
2
String value1 = req.getParameter( "param1" );
String value1 = req.getParameter( "param2" );

一旦获取了参数值，它们就会在须要时被处理。对客户端的响应和咱们上面部分讨论的同样。咱们使用 HttpServletResponse 对象给客户端发送响应。

request和response处理的基本使用能够是这样的：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
@Override
protected void doGet(HttpServletRequest request,
         HttpServletResponse response) throws ServletException, IOException
{
 
     response.setContentType( "text/html;charset=UTF-8" );
     PrintWriter out = response.getWriter();
 
     String username = request.getParameter( "username" );
     String password = request.getParameter( "password" );
 
     boolean success = validateUser(username, password);
 
     try {
         // Write some content
         out.println( "<html>" );
         out.println( "<head>" );
         out.println( "<title>LoginServlet</title>" );
         out.println( "</head>" );
         out.println( "<body>" );
 
         if (success) {
             out.println( "<h2>Welcome Friend</h2>" );
         } else {
             out.println( "<h2>Validate your self again.</h2>" );
         }
 
         out.println( "</body>" );
         out.println( "</html>" );
     } finally {
         out.close();
     }
}

为了发送内容给客户端，你须要使用从 HttpServletResponse 里获取的 PrintWriter 对象。任何写到这个对象的内容都会被写进outputstream里，并会把内容发送回给客户端。

监听Servlet容器事件

有时候，知道应用服务器容器（the application server container）里某些事件发生的时间是颇有用的。这个概念适用于不少状况，但它一般用在开启应用时初始化应用或者关闭应用时清理应用。能够在应用里 注册一个监听器（listener）来显示应用何时开启或者关闭。所以，经过监听这些事件，Servlet能够在一些事件发生时执行相应的动做。

为了建立一个基于容器事件执行动做的监听器，你必须建立一个实现 ServletContextListener 接口的类。这个类必须实现的方法有 contextInitialized() 和 contextDestroyed()。这两个方法都须要 ServletContextEvent 做为参数，而且在每次初始化或者关闭Servlet容器时都会被自动调用。

为了在容器注册监听器，你可使用下面其中一个方法：

1) 利用 @WebListener 注解。
2) 在web.xml应用部署文件里注册监听器。
3) 使用 ServletContext 里定义的 addListener() 方法

请注意，ServletContextListener 不是Servlet API里惟一的监听器。这里还有一些其余的监听器，好比

1
2
3
4
5
6
javax.servlet.ServletRequestListener
javax.servlet.ServletRequestAttrbiteListener
javax.servlet.ServletContextListener
javax.servlet.ServletContextAttributeListener
javax.servlet.HttpSessionListener
javax.servlet.HttpSessionAttributeListener

根据你要监听的事件选择他们来实现你的监听器类。好比，每当建立或销毁一个用户session时，HttpSessionListener 就会发出通知。

传递Servlet初始化参数

如今的大多数应用都须要设置一些在应用/控制器（controller）启动时能够传递的配置参数（configuration parameters）。Servlet一样能够接受初始化参数，并在处理第一个请求前来使用它们来构建配置参数。

显然，你也能够在Servlet里硬编码配置值。可是这样作的话，在Servlet发生改动时你须要再次从新编译整个应用。没有人喜欢这样作。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
<web-app>
     <servlet>
         <servlet-name>SimpleServlet</servlet-name>
         <servlet- class >com.howtodoinjava.servlets.SimpleServlet</servlet- class >
 
         <!-- Servlet init param -->
         <init-param>
             <param-name>name</param-name>
             <param-value>value</param-value>
         </init-param>
 
     </servlet>
 
</web-app>

设置后，你就能够在代码里调用 getServletConfig.getInitializationParameter() 并传递参数名给该方法来使用参数。就像下面展现的代码同样：

1
String value = getServletConfig().getInitParameter( "name" );

为特定的URL请求添加Servlet过滤器

Web过滤器在给定的URL被访问时对请求进行预处理并调用相应的功能是颇有用的。相 比于直接调用给定URL请求的Servlet，包含相同URL模式的过滤器（filter）会在Servlet调用前被调用。这在不少状况下是颇有用的。 或许最大的用处就是执行日志，验证或者其余不须要与用户交互的后台服务。

过滤器必需要实现 javax.servlet.Filter 接口。这个接口包含了init()，descriptor()和doFilter()这些方法。init()和destroy()方法会被容器调用。 doFilter()方法用来在过滤器类里实现逻辑任务。若是你想把过滤器组成过滤链（chain filter）或者存在多匹配给定URL模式的个过滤器，它们就会根据web.xml里的配置顺序被调用。

为了在web.xml里配置过滤器，须要使用<filter>和<filter-mapping> XML元素以及相关的子元素标签。

1
2
3
4
5
6
7
8
<filter>
     <filter-name>LoggingFilter</filter-name>
     <filter- class >LoggingFilter</filter- class >
</filter>
<filter-mapping>
     <filter-name>LogingFilter</filter-name>
     <url-pattern>/*</url-pattern>
</filter-mapping>

若是你要使用注解来为特定的servlet配置过滤器，你可使用@WebFilter注解。

使用Servlet下载二进制文件

几乎全部的web应用都必须有下载文件的功能。为了下载一个文件，Servlet必须提供一个和下载文件类型匹配的响应类型。一样，必须在响应头里指出该响应包含附件。就像下面的代码。

1
2
3
String mimeType = context.getMimeType( fileToDownload );
response.setContentType( mimeType != null ? mimeType : "text/plain" );
response.setHeader( "Content-Disposition" , "attachment; filename=" " + fileToDownload + " "" );

经过调用 ServletContext.getResourceAsStream() 方法并传递文件路径给该方法，你能够获取要下载的文件（文件保存在文件系统）的引用。这个方法会返回一个输入流（InputStream）对 象，咱们能够用这个对象来读取文件内容。当读取文件时，咱们建立一个字节缓存区（byte buffer）从文件里获取数据块。最后的工做就是读取文件内容而且把它们复制到输出流。咱们使用while循环来完成文件的读取，这个循环直到读取了文 件的全部内容才会跳出循环。咱们使用循环来读进数据块并把它写进输出流。把全部数据写进输出流后，ServletOutputStream 对象的flush方法就会被调用而且清空内容和释放资源。

看这段简单的代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
private void downloadFile(HttpServletRequest request, HttpServletResponse response, String fileToDownload) throws IOException
     {
         final int BYTES = 1024 ;
         int length = 0 ;
 
         ServletOutputStream outStream = response.getOutputStream();
         ServletContext context = getServletConfig().getServletContext();
 
         String mimeType = context.getMimeType( fileToDownload );
         response.setContentType( mimeType != null ? mimeType : "text/plain" );
         response.setHeader( "Content-Disposition" , "attachment; filename=" " + fileToDownload + " "" );
 
         InputStream in = context.getResourceAsStream( "/" + fileToDownload);
 
         byte [] bbuf = new byte [BYTES];
 
         while ((in != null ) && ((length = in.read(bbuf)) != - 1 )) {
             outStream.write(bbuf, 0 , length);
         }
 
         outStream.flush();
         outStream.close();
     }

使用RequestDispatcher.forward()转发请求到另外一个Servlet

有时候，你的应用须要把一个Servlet要处理的请求转让给另外的Servlet来处理并完成任务。并且，转让请求时不能重定向客户端的URL。即浏览器地址栏上的URL不会改变。

在 ServletContext 里已经内置了实现上面需求的方法。因此，当你获取了 ServletContext 的引用，你就能够简单地调用getRequestDispatcher() 方法去获取用来转发请求的 RequestDispatcher 对象。当调用 getRequestDispatcher() 方法时，须要传递包含servlet名的字符串，这个Servlet就是你用来处理转让请求的Servlet。获取 RequestDispatcher 对象后，经过传递 HttpServletRequest 和HttpServletResponse 对象给它来调用转发方法。转发方法负责对请求进行转发。

1
2
RequestDispatcher rd = servletContext.getRequestDispatcher( "/NextServlet" );
rd.forward(request, response);

使用HttpServletResponse.sendRedirect()重定向请求到另外一个Servlet

尽管有时候，你不想在Servlet发送重定向时通知用户，就像咱们在上面那段看到的同样。可是在某些状况下，咱们确实想要通知用户。当应用内的特定URL被访问时，你想把浏览器的URL重定向到另一个。

要实现这种功能，你须要调用 HttpServletResponse 对象的sendRedirect()方法。

1
httpServletResponse.sendRedirect( "/anotherURL" );

这个简单的重定向，与servlet链（servlet chaining）相反，不须要传递目标地址的HttpRequest对象。

使用Servlet读写Cookie

不少应用都想在客户端机器里保存用户当前的浏览历史。目的是当用户再次使用应用时，他可以从上次离开的地方开始浏览。为了实现这个需求，一般使用cookies。你能够把它看做是保存在客户端机器里的键值对基本数据。当使用浏览器打开应用时，应用能够对这些数据进行读写。

为了建立cookie，须要实例化一个新的 javax.servlet.http.Cookie 对象而且为它分配名称和值。实例化cookie后，能够设置属性来配置cookie。在这个例子里，咱们使用 setMaxAge() 和 setHttpOnly() 方法来设置cookie的生命周期和防范客户端脚本。

从Servlet3.0 API开始，已经能够把cookie标记为HTTP only了。这使cookie能够防范客户端脚本的攻击，使cookie更加安全。

1
2
3
4
Cookie cookie = new Cookie( "sessionId" , "123456789" );
cookie.setHttpOnly( true );
cookie.setMaxAge(- 30 );
response.addCookie(cookie);

这里的response是传递给doXXX()方法的 HttpServletResponse 实例。

要读取服务端的cookie信息，使用下面代码：

1
2
3
4
5
6
Cookie[] cookies = request.getCookies();
for (Cookie cookie : cookies)
{
     //cookie.getName();
     //cookie.getValue()
}
相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程