Servlet学习笔记（三）：Servlet基础

一、Servlet基础

1.一个Servlet程序就是一个实现了特殊接口的java类，它由支持servlet(具有servlet引擎)的web服务器调用和启动运行。一个Servlet程序负责处理它所对应的一个或一组url地址的访问请求，并接收客户端发出的访问请求信息和产生响应内容。它的请求-响应的典型过程如下图：

2.所有的servlet(自定义的)都必须实现servlet接口(javax.servlet.Servlet)。Servlet接口中有很多方法不需要实现，所以可以去继承已经实现了servlet接口的类。

1）GenericServlet类。GenericServlet实现了servlet接口的基本特征和功能。

2）HttpServlet类继承了GenericServlet类，并在其基础上进行了一些对HTTP协议的扩充。所以一般，我们编写servlet直接继承HttpServlet类，并覆盖需要的方法即可。

3.客户端每次访问一个支持HTTP的Servlet程序时，Servlet引擎都将调用Servlet的service方法来进行处理。

HTTPServletRequest用于封装HTTP请求，HTTPServletResponse用于封装HTTP响应。

扫描二维码关注公众号，回复： 196352 查看本文章

二、Servlet的生命周期

1、Servlet的生命周期是由Web服务器来维护的，其相关的方法，在Servlet接口中都有定义。Servlet接口源码如下：

[java]  view plain  copy

1. package javax.servlet;  
2.   
3. import java.io.IOException;  
4.   
5. public abstract interface Servlet  
6. {  
7.   public abstract void init(ServletConfig paramServletConfig)  
8.     throws ServletException;  
9.   
10.   public abstract ServletConfig getServletConfig();  
11.   
12.   public abstract void service(ServletRequest paramServletRequest, ServletResponse paramServletResponse)  
13.     throws ServletException, IOException;  
14.   
15.   public abstract String getServletInfo();  
16.   
17.   public abstract void destroy();  
18. }  

2、Servlet会在服务器启动(load-on-startup 为 1)或第一次请求(load-on-startup 为 0)该Servlet的时候，初始化并开始生命周期，在服务器关闭的时候，销毁这个对象，结束生命周期。只有一个Servlet对象。多客户端并发请求该Servlet时，服务器启动多个线程分别执行该Servlet的service()方法。

3、Servlet的生命周期是由Servlet的容器来控制的，它可以分为3个阶段;初始化，运行，销毁。

第一、初始化阶段：

1）Servlet容器加载servlet类，把servlet类的.class文件中的数据读到内存中。

2）然后Servlet容器创建一个ServletConfig对象。ServletConfig对象包含了Servlet的初始化配置信息。

3）Servlet容器创建一个servlet对象。

4）Servlet容器调用servlet对象的init方法进行初始化。

第二、运行阶段：、

1）当servlet容器接收到一个请求时，servlet容器会针对这个请求创建servletRequest和servletResponse对象。
2）然后调用service方法。并把这两个参数传递给service方法。Service方法通过servletRequest对象获得请求的
信息。并处理该请求。

3）通过servletResponse对象生成这个请求的响应结果。然后销毁servletRequest和servletResponse对象。我们不管这个请求是post提交的还是get提交的，最终这个请求都会由service方法来处理。

第三、销毁阶段：
1）当Web应用被终止时，servlet容器会先调用servlet对象的destrory方法，然后再销毁servlet对象，同时也会销毁与servlet对象相关联的servletConfig对象。

2）我们可以在destroy方法的实现中，释放servlet所占用的资源，如关闭数据库连接，关闭文件输入输出流等。

4、在整个生命周期中：

1）构造方法、init()方法、destroy()方法只会被调用一次

2）每次访问会从新发一次请求调用service方法。

2）getLastModified()只有当访问方式是Get的时候才会调用，返回-1表示永远是新的，不使用缓存

5、java中与两个注解和Servlet的生命周期有关，这两个注解被用来修饰非静态方法，且不能抛出异常。

1）@PostConstruct：在构造方法之后，init()之前被调用，只调用一次。

2）@PreDestroy：在destroy()之后，Servlet被彻底卸载之前调用，只调用一次。

6、总结：Servlet的生命周期，完整应该是这样的：见下图。

7、生命周期的代码如下：

[java]  view plain  copy

1. package servlet.base;  
2.   
3. import java.io.IOException;  
4.   
5. import javax.annotation.PostConstruct;  
6. import javax.annotation.PreDestroy;  
7. import javax.servlet.ServletException;  
8. import javax.servlet.ServletRequest;  
9. import javax.servlet.ServletResponse;  
10. import javax.servlet.http.HttpServlet;  
11. import javax.servlet.http.HttpServletRequest;  
12. import javax.servlet.http.HttpServletResponse;  
13. /** 
14.  *  
15.  * LifeCycleServlet.java 
16.  * 
17.  * @title Servlet的生命周期 
18.  * @description 
19.  * @author SAM-SHO  
20.  * @Date 2014-9-25 
21.  */  
22. public class LifeCycleServlet extends HttpServlet {  
23.   
24.   
25.     private static final long serialVersionUID = 1L;  
26.   
27.     public LifeCycleServlet() {  
28.         System.out.println("调用 构造方法 ");  
29.   
30.     }  
31.   
32.     public void destroy() {  
33.         System.out.println("调用 destroy()方法 ");  
34.         super.destroy();  
35.   
36.       
37.     }  
38.   
39.     public void doGet(HttpServletRequest request, HttpServletResponse response)  
40.             throws ServletException, IOException {  
41.   
42.         System.out.println("调用 doGet()方法 ");  
43.     }  
44.   
45.     public void doPost(HttpServletRequest request, HttpServletResponse response)  
46.             throws ServletException, IOException {  
47.   
48.         System.out.println("调用 doPost()方法 ");  
49.     }  
50.       
51.     public void init() throws ServletException {  
52.         System.out.println("调用 init()方法 ");  
53.     }  
54.   
55.     @Override  
56.     protected void service(HttpServletRequest req, HttpServletResponse resp)  
57.             throws ServletException, IOException {  
58.         System.out.println("调用 Http  service()方法 ");  
59.         super.service(req, resp);  
60.       
61.     }  
62.       
63.       
64.     // 只有以get方式调用该servlet的时候才会调用getLastModified  
65.     // 返回-1 表示永远是最近的，不使用缓存  
66.     @Override  
67.     protected long getLastModified(HttpServletRequest req) {  
68.         System.out.println("调用 getLastModified()方法 ");  
69.         return super.getLastModified(req);  
70.     }  
71.   
72.     @Override  
73.     public void service(ServletRequest req, ServletResponse res)  
74.             throws ServletException, IOException {  
75.         System.out.println("调用 service()方法 ");  
76.         super.service(req, res);  
77.   
78.     }  
79.       
80.       
81.     @PreDestroy  
82.     public void preDestroy(){  
83.         System.out.println("调用 preDestroy()方法 ");  
84.     }  
85.       
86.     @PostConstruct  
87.     public void postConstruct (){  
88.         System.out.println("调用 postConstruct()方法");  
89.     }  
90.       
91.   
92. }  
93.   
94. /* 
95. 【输出】 
96. 调用 构造方法  
97. 调用 postConstruct()方法 
98. 调用 init()方法  
99.  
100. 调用 service()方法  
101. 调用 Http  service()方法  
102. 调用 getLastModified()方法  
103. 调用 doGet()方法  
104.  
105. 调用 service()方法  
106. 调用 Http  service()方法  
107. 调用 doPost()方法  
108.  
109. 调用 destroy()方法  
110. 调用 preDestroy()方法  
111. */  

三、Servlet的配置及参数：Web.xml

要运行Servlet，除了要有代码即XxxServlet这个类以后，还需要在Web.xml中配置该Servlet的信息以及一些参数，告诉Servlet容器，应该这么访问这个Servlet。

1、基本标签：

1）<servlet> ：是一个Servlet的开始和结束标签，中间的部分就是一个Servlet的配置信息。

A、<servlet-name>：配置Servlet的名称，如LifeCycleServlet，可以取任一字符串，保证在web.xml中唯一。该名称组要是供其他标签使用，如<servlet-mapping>、<filter>等使用。

B、<servet-class> ：配置该Servlet的类名，servlet.base.LifeCycleServlet，需要完整的包。

2）<servlet-mapping> ：配置该Servlet的访问方式。

A、<servlet-name> ：同<servlet>标签中配置的Servlet名称。

B、<url-pattern> ：配置该Servlet的访问方式。<url-pattern>配置的值前面加上Web应用程序的路径，在加上服务器域名端口号信息，就是访问该Servlet的网址。

<url-pattern>中允许使用通配符 “*” 和 “?” ，"*"代表任意长度的字符串，“?”表示任意字符。如果<url-pattern>的配置路径为 /servlet/LifeCycleServlet.* ，就可以使用http://localhost:8080/servlet/LifeCycleServlet.xxx 访问LifeCycleServlet 这个Servlet，xxx 代表任意文件类型后缀。

C、Java EE 5以后，<servlet-mapping>可以配置多个 <url-pattern>。例如可以同时将LifeCycleServlet 配置一下多个映射方式：。这时，不论用jsp后缀、php后缀访问，都会正常显示。

[java]  view plain  copy

1. <servlet-mapping>  
2.     <servlet-name>LifeCycleServlet</servlet-name>     
3.     <url-pattern>/servlet/LifeCycleServlet</url-pattern>    
4.     <url-pattern>/servlet/LifeCycleServlet.jsp</url-pattern>    
5.     <url-pattern>/servlet/LifeCycleServlet.asp</url-pattern>    
6.     <url-pattern>/servlet/LifeCycleServlet.php</url-pattern>    
7. </servlet-mapping>   

D、缺省的Servlet配置。所有的web访问都是去找Servlet，服务器会有默认的缺省Servlet，如访问静态资源，就会去访问缺省Servlet，然后该Servlet会帮忙访问静态资源，显示给浏览器。Tomcat中这个缺省的Servlet为其Web.xml中定义的org.apache.catalina.servlets.DefaultServlet。

[java]  view plain  copy

1. <servlet>  
2.     <servlet-name>default</servlet-name>  
3.     <servlet-class>org.apache.catalina.servlets.DefaultServlet</servlet-class>  
4.     <init-param>  
5.         <param-name>debug</param-name>  
6.         <param-value>0</param-value>  
7.     </init-param>  
8.     <init-param>  
9.         <param-name>listings</param-name>  
10.         <param-value>false</param-value>  
11.     </init-param>  
12.     <load-on-startup>1</load-on-startup>  
13. </servlet>  
14. ;servlet-mapping>  
15.     <servlet-name>default</servlet-name>  
16.     <url-pattern>/</url-pattern>  
17. </servlet-mapping>  

自己定义缺省的Servlet的方法为，<url-pattern>/</url-pattern>，只配置“/”即可。

3）<load-on-startup> ：配置该Servlet的加载方式，可选值为0和1或正整数。

1-Servlet会在服务器启动的死后就加载该Servlet。当是正整数时，1的优先级最高。（1>2）

0-第一次请求该Servlet的服务器才去加载该Servlet。Struts、Spring等框架都会使用该参数来预先加载核心的Servlet。

2、参数标签：

1）<init-param> ：初始化参数，供某一个Servlet使用。

A、配置某个Servlet的初始化参数，配置在<servlet>便签里面，只能由这个Servlet来读取，其他Servlet读取不到。它包括一个参数名<param-name>和一个参数值<param-value>。一个Servlet可以配置多个初始化参数。

B、获取：通过方法getInitParameter() 和 getServletConfig().getInitParameter()获取，getInitParameter()方法内部其实调用的也是后者。

2）<context-param> ：上下文参数，供所有Servlet使用。

A、配置所有Servlet的参数，被所有Servlet共享。也是由一个参数名<param-name>和一个参数值<param-value>组成。同样可以配置多个上下文参数。

B、获取：获取<context-param>，可以通过通过ServletContext对象。封装的方法为 getServletContext().getInitParameter()和getServletConfig().getServletContext().getInitParameter()获得。

3）总结：

A、Context和ContextPath ： 一个Web工程，如名为JavaWeb，访问的路径为http://localhost:8080/JavaWeb，这整个web应用就成为一个Context，路径/JavaWeb被称为上下文路径(ContextPath )。

B、<init-param> 和<context-param>只能配置简单的字符串类型的参数，更灵活的参数配置，推荐写到xml文件或properties文件，写程序读取。

[java]  view plain  copy

1. <!-- 上下文参数 -->  
2. <context-param>  
3.     <param-name>A</param-name>  
4.     <param-value>1</param-value>  
5. </context-param>  
6.   
7. <context-param>  
8.     <param-name>B</param-name>  
9.     <param-value>2</param-value>  
10. </context-param>  

3、session标签：

1）<session-config> ：session标签，内置的<session-timeout> 标签可以配置session的有效期，单位是分钟。Tomcat中默认超时时间为20分钟。

2）session的超时时间为MaxInactiveInterval属性，可以利用session的方法 setMaxInactiveInterval(int s) 和 getMaxInactiveInterval() 分别设置于获取session的有效期，单位是秒。

[java]  view plain  copy

1. <!-- session -->  
2. <session-config>  
3.     <session-timeout>20</session-timeout>  
4. </session-config>  

4、过滤器标签 ：

每个过滤器需要配置在web.xml中才能生效，一个Filter需要配置<filter> 和 <filter-mapping>便签。

1）<filter>  ：配置 Filter 名称，实现类以及初始化参数。可以同时配置多个初始化参数

2）<filter-mapping> ：配置什么规则下使用这个Filter 。

A、<url-pattern> ：配置url的规则，可以配置多个，也可以使用通配符（*）。例如 /jsp/* 适用于本ContextPath下以“/jsp/ ”开头的所有servlet路径， *.do 适用于所有以“ .do”结尾的servlet路径。

B、<dispatcher> ：配置到达servlet的方式，可以同时配置多个。有四种取值：REQUEST、FORWARD、ERROR、INCLUDE。如果没有配置，则默认为REQUEST。它们的区别是：

# REQUEST ：表示仅当直接请求servlet时才生效。

# FORWARD ：表示仅当某servlet通过forward转发到该servlet时才生效。

# INCLUDE ：Jsp中可以通过<jsp:include/>请求某servlet， 只有这种情况才有效。

# ERROR ：Jsp中可以通过<%@page errorPage="error.jsp" %>指定错误处理页面，仅在这种情况下才生效。

C、<url-pattern>和<dispatcher> 是且的关系，只有满足<url-pattern>的条件，且满足<dispatcher>的条件，该Filter 才能生效。

3）总结：一个Web程序可以配置多个Filter ，访问有先后顺序，<filter-mapping> 配置在前面的Filter 执行要早于配置在后面的Filter 。

[java]  view plain  copy

1. <!-- 过滤器 -->  
2. <filter>  
3.     <filter-name>MyFilter</filter-name>  
4.     <filter-class>servlet.filter.MyFilter</filter-class>  
5.     <init-param>  
6.         <param-name>name</param-name>  
7.         <param-value>Sam-Sho</param-value>  
8.     </init-param>  
9. </filter>  
10. <filter-mapping>  
11.     <filter-name>MyFilter</filter-name>  
12.     <url-pattern>/jsp/*</url-pattern>  
13.     <url-pattern>*.do</url-pattern>  
14.   
15.     <dispatcher>REQUEST</dispatcher>  
16.     <dispatcher>FORWARD</dispatcher>  
17. </filter-mapping>  

5、监听器便签：一般配置在servlet便签前面。主要有<listener> 、<listener-class> 。

[java]  view plain  copy

1. <!--监听器 -->  
2. <listener>  
3.     <listener-class>servlet.listener.MyListener</listener-class>  
4. </listener>  

6、其他

1）<mime-mapping>：如果Web应用具有用到特殊的文件，希望能保证给他们分配特定的MIME类型。一般可以配置一些允许下载的文件类型。

[java]  view plain  copy

1. <!-- 下载文件类型 -->  
2. <mime-mapping>  
3.     <extension>doc</extension>  
4.     <mime-type>application/msword</mime-type>  
5. </mime-mapping>  
6.   
7. <mime-mapping>  
8.     <extension>xls</extension>  
9.     <mime-type>application/msexcel</mime-type>  
10. </mime-mapping>  
11.   
12. <mime-mapping>  
13.     <extension>pdf</extension>  
14.     <mime-type>application/pdf</mime-type>  
15. </mime-mapping>  

2）<env-entry>：

A、资源注射标签。初始化参数与上下文参数都需要我们主动去获取，而资源注射的内容不需要主动获取，Web启动的时候会主动把资源内容注射到servlet中。这种功能是需要通过注解完成的，@Resource负责这个功能

B、一般包括三组便签：<env-entry-name>、<env-entry-type>、<env-entry-value>，局限是只能配置java.lang包下的标准变量。

C、在代码中，用@Resource（name="）注解标注定义好的属性变量，一定要指定名字，且需要与签定义的一致，这样，在web启动的时候，资源就会注入其中，不需要自己主动去获取。

D、例如：

[java]  view plain  copy

1. <env-entry>  
2.     <env-entry-name>uerName</env-entry-name>  
3.     <env-entry-type>java.lang.String</env-entry-type><!-- 只能配置java.lang包下的标准变量-->  
4.     <env-entry-value>Shao-xiao-bao</env-entry-value>  
5. </env-entry>  

[java]  view plain  copy

1. @Resource(name="uerName")//指定名字，与配置的一致  
2. private String name;//资源注入的名字  

E、资源注射的原理是JNDI，其本质为在web.xml中定义了名为userName的JNDI资源，然后使用 @Resource标签把定义好的资源注射到servlet中。如果不使用@Resource便签，通过查找JNDI资源同样获取。

[java]  view plain  copy

1. Context context = new InitialContext();  
2. String name = (String) context.lookup("userName");  
3. System.out.println("利用JNDI获取的资源注入的参数" + name);  

F、注解多少会影响到web服务器启动的速度，因为服务器在启动的时候会遍历Web应用的WEB-INF/classes 下的所有class文件，以及lib下的所有jar包，以检查哪些类使用了注解。如果应用程序中没有使用注解，我们可以把这种注解检查功能关掉：通过把web.xml中<web-app>标签的 metadata-complete 属性设为"true"。

[java]  view plain  copy

1. <web-app version="2.5" metadata-complete="true"  
2.     xmlns="http://java.sun.com/xml/ns/javaee"  
3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
4.     xsi:schemaLocation="http://java.sun.com/xml/ns/javaee   
5.     http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">  

7、完整代码如下：

[java]  view plain  copy

1. <?xml version="1.0" encoding="UTF-8"?>  
2. <web-app version="2.5" metadata-complete="true"  
3.     xmlns="http://java.sun.com/xml/ns/javaee"  
4.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
5.     xsi:schemaLocation="http://java.sun.com/xml/ns/javaee   
6.     http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">  
7.       
8.     <!--metadata-complete="true" 关掉服务器启动时的注解扫描检查 -->  
9.   
10.     <!-- 参数 -->  
11.     <context-param>  
12.         <param-name>A</param-name>  
13.         <param-value>1</param-value>  
14.     </context-param>  
15.   
16.     <context-param>  
17.         <param-name>B</param-name>  
18.         <param-value>2</param-value>  
19.     </context-param>  
20.   
21.     <!-- 过滤器 -->  
22.     <filter>  
23.         <filter-name>MyFilter</filter-name>  
24.         <filter-class>servlet.filter.MyFilter</filter-class>  
25.         <init-param>  
26.             <param-name>name</param-name>  
27.             <param-value>Sam-Sho</param-value>  
28.         </init-param>  
29.     </filter>  
30.     <filter-mapping>  
31.         <filter-name>MyFilter</filter-name>  
32.         <url-pattern>/jsp/*</url-pattern>  
33.         <url-pattern>*.do</url-pattern>  
34.   
35.         <dispatcher>REQUEST</dispatcher>  
36.         <dispatcher>FORWARD</dispatcher>  
37.     </filter-mapping>  
38.   
39.   
40.     <!--监听器 -->  
41.     <listener>  
42.         <listener-class>servlet.listener.MyListener</listener-class>  
43.     </listener>  
44.   
45.     <!-- Servlet -->  
46.     <servlet>  
47.         <servlet-name>LifeCycleServlet</servlet-name>  
48.         <servlet-class>servlet.base.LifeCycleServlet</servlet-class>  
49.         <init-param>  
50.             <param-name>a</param-name>  
51.             <param-value>1</param-value>  
52.         </init-param>  
53.   
54.         <init-param>  
55.             <param-name>b</param-name>  
56.             <param-value>2</param-value>  
57.         </init-param>  
58.         <!--  
59.             初始化时机： 1-Servlet会在服务器启动的时候初始化 2-第一次真正访问这个Servlet的时候初始化  
60.         -->  
61.         <load-on-startup>0</load-on-startup>  
62.   
63.     </servlet>  
64.     <servlet-mapping>  
65.         <servlet-name>LifeCycleServlet</servlet-name>  
66.         <url-pattern>/servlet/LifeCycleServlet</url-pattern>  
67.         <url-pattern>/servlet/LifeCycleServlet.jsp</url-pattern>  
68.         <url-pattern>/servlet/LifeCycleServlet.asp</url-pattern>  
69.         <url-pattern>/servlet/LifeCycleServlet.php</url-pattern>  
70.     </servlet-mapping>  
71.       
72.     <!-- 资源注入 -->  
73.     <env-entry>  
74.         <env-entry-name>userName</env-entry-name>       
75.         <env-entry-type>java.lang.String</env-entry-type><!-- 只能配置java.lang包下的标准变量-->  
76.         <env-entry-value>Shao-xiao-bao</env-entry-value>  
77.     </env-entry>  
78.   
79.     <!-- 下载文件类型 -->  
80.     <mime-mapping>  
81.         <extension>doc</extension>  
82.         <mime-type>application/msword</mime-type>  
83.     </mime-mapping>  
84.   
85.     <mime-mapping>  
86.         <extension>xls</extension>  
87.         <mime-type>application/msexcel</mime-type>  
88.     </mime-mapping>  
89.   
90.     <mime-mapping>  
91.         <extension>pdf</extension>  
92.         <mime-type>application/pdf</mime-type>  
93.     </mime-mapping>  
94.       
95.     <!-- session -->  
96.     <session-config>  
97.         <session-timeout>20</session-timeout>  
98.     </session-config>  
99.   
100.   
101.     <welcome-file-list>  
102.         <welcome-file>index.jsp</welcome-file>  
103.     </welcome-file-list>  
104.   
105.     <error-page>  
106.         <error-code>404</error-code>  
107.         <location>/ErrorPage.jsp</location>  
108.     </error-page>  
109.   
110. </web-app>   

四、线程安全

1、Servlet只有只有一个实例，多个用户请求同一个Servlet时，会派生出多条线程执行Servlet的代码，因此Servlet是线程不安全的。

2、Servlet不是线程安全的，多线程并发的读写绘导致数据的不同步，下例中，尽量不要定义name属性，而是把name变量分别定义在doGet() 和doPost()方法内。

3、如果是并发的读取servlet的属性的话，并不会导致数据的不同步，所以Servlet里面的只读属性做好定义为final类型的。

[java]  view plain  copy

1. package servlet.base;  
2.   
3. import java.io.IOException;  
4.   
5. import javax.servlet.ServletException;  
6. import javax.servlet.http.HttpServlet;  
7. import javax.servlet.http.HttpServletRequest;  
8. import javax.servlet.http.HttpServletResponse;  
9.   
10. /** 
11.  *  
12.  * ThreadSafetyServlet.java 
13.  * 
14.  * @title servlet线程安全 
15.  * @description 
16.  * @author SAM-SHO  
17.  * @Date 2014-9-25 
18.  */  
19. public class ThreadSafetyServlet extends HttpServlet {  
20.   
21.     private static final long serialVersionUID = 2957055449370562943L;  
22.   
23.     private String name;  
24.   
25.     public void doGet(HttpServletRequest request, HttpServletResponse response)  
26.             throws ServletException, IOException {  
27.   
28.         name = request.getParameter("name");  
29.   
30.         try {  
31.             Thread.sleep(5000);//为了测试，让线程睡一会  
32.         } catch (InterruptedException e) {  
33.         }  
34.   
35.         response.getWriter().println("您好, " + name + ". 您使用了 GET 方式提交数据");  
36.     }  
37.   
38.     public void doPost(HttpServletRequest request, HttpServletResponse response)  
39.             throws ServletException, IOException {  
40.   
41.         name = request.getParameter("name");  
42.   
43.         response.getWriter().println("您好, " + name + ". 您使用了 POST 方式提交数据");  
44.     }  
45. }