servlet

servlet学习大纲：

　　1.servlet概念及相关接口简介

　　2.servlet执行过程

　　3.servlet路径映射

　　4.缺省servlet　　应用

　　5.servlet生命周期（重点）

　　6.servlet自动加载

　　7.servlet线程安全

　　8.servletConfig对象

　　9.servlet相关接口详解

　　10.servletContext对象　　知识点

　　1.如何开发一个servlet

　　　1.1步骤：

　　　　1.编写一个java类，继承httpservlet

　　　　2.重写doget/dopost方法

　　　　3.servlet程序交给tomcat服务器运行

　　　　　　1.servlet程序的class码拷贝到WEB-INF/classes目录

　　　　　　2.在web.xml文件中进行配置

 1 <servlet>
 2     <!--配置一个servlet-->
 3     <description></description>
 4     <!--servlet内部名称，自定义，尽量有意义-->
 5     <display-name>response_location</display-name>
 6     <servlet-name>response_location</servlet-name>
 7     <!-- servlet的类全名，包名加简单类名 -->
 8     <servlet-class>com.http.response.response_location</servlet-class>
 9   </servlet>
10     <!-- servlet映射配置 -->
11   <servlet-mapping>
12     <!--servlet内部名称，要和上边保持一致-->
13     <servlet-name>response_location</servlet-name>
14     <!--servlet的映射路径（访问servlet的名称）-->
15     <url-pattern>/response_location</url-pattern>
16   </servlet-mapping>

问题：访问 url：http://localhost:8080/项目名/uri

tomcat启动时，首先加载webapp的每个web应用中的web.xml配置文件

　　http：// ：http协议

　　localhost：到本地的hosts文件中查找是否存在该域名对应的IP地址

　　8080：　　找到tomcat服务器

　　/项目名：　　在tomcat的webapp目录下找项目名称的目录

　　/uri:　　资源名称

　　　　1.在项目的web.xml中查找是否有匹配的url-pattern的内容（uri）

　　　　2.如果找到了url-pattern，则使用当前servlet-name的名称到web.xml文件中查询是否有名称一样的servlet配置

　　　　3.如果找到，则取出对应的servlet配置信息中的servlet-class内容

　　　　　　通过反射：

　　　　　　　　构造类的对象

　　　　　　　　然后调用类里面的方法

2.servlet的映射路径

　　精确匹配

　　　　url-pattern：/first

　　　　浏览器输入：　http://localhost:8080/项目名/first

　　　　url-pattern：/java/first

　　　　浏览器输入：http://localhost:8080/项目名/java/first

　　模糊匹配

　　　　　　url-pattern　　　　　　　　浏览器输入

　　　　　　*.后缀名　　　　　　　http：//localhost：8080/项目名/任意路径

　　　　　　/java/*　　　　　　　 http://localhost:8080/项目名/任意路径

　　　　　　*.do　　　　　　　　　http://localhost:8080/项目名/任意路径.do

　　　　　　/*　　　　　　　　　　http：//localhost：8080/项目名/任意路径

　　　　　　*.action

　　　　　　*.html(伪静态)

　　　　　　　1.　精确匹配与模糊匹配同时存在时，优先精确匹配　　（长得最像）

　　　　　　　2.以后缀名结尾的模糊url-pattern优先级最低

　　　　/* servlet的缺省路径

　　　　　　servlet的缺省路径是在tomcat服务器内置的一个路径。改路径对应的是一个defaultServlet（缺省的servlet）这个缺省的servlet的作用是解析web应用的静态资源文件

　　　　问题：URL输入 http://localhost:8080/项目名/uri　　如何读取文件

　　　　1.到当前项目应用下的web.xml文件，查找是否有匹配的url-pattern

　　　　2.如果没有匹配的url-pattern，则交给tomcat的内置servlet处理

　　　　3.defaultServlet程序到项目应用的根目录下查找是否存在一个名为index.html静态文件

　　　　4.如果找到该文件，则读取该文件的内容，然后返回给浏览器

　　　　5.如果找不到文件，则返回404错误页面

　　　　　　结论：先找动态资源，再找静态资源

servlet的生命周期（重点）

　　4.1引入

　　　　servlet的生命周期：servlet类的对象什么时候创建，调用什么方法，什么时候销毁。

　　　　以前的对象，new Student() 调用方法销毁，置其为空

　　　　servlet程序的生命周期由tomcat服务器控制

　　4.2servlet重要的生命周期：

　　　　GenericServlet　　没有任何协议（但是是HttpServlet的父类）及没有http协议，没有doget/dopost

 1 package com.java.servlet;
 2 
 3 import java.io.IOException;
 4 
 5 import javax.servlet.ServletConfig;
 6 import javax.servlet.ServletException;
 7 import javax.servlet.http.HttpServlet;
 8 import javax.servlet.http.HttpServletRequest;
 9 import javax.servlet.http.HttpServletResponse;
10 
11 public class ServletLife extends HttpServlet{
12     /**
13      * 1.构造方法
14      */
15     public ServletLife(){
16         System.out.println("1.servlet对象被创建了");
17         
18     }
19     /**
20      * 2.init方法
21      */
22     @Override
23     public void init() throws ServletException {
24         // TODO Auto-generated method stub
25         super.init();
26     }
27     
28     @Override
29     public void init(ServletConfig config) throws ServletException {
30         System.out.println("2.init 方法被调用");
31         super.init(config);
32     }
33     
34     @Override
35     protected void service(HttpServletRequest arg0, HttpServletResponse arg1) throws ServletException, IOException {
36         System.out.println("3.service 方法被调用");
37     }
38     
39     @Override
40     public void destroy() {
41         System.out.println("4.destory销毁方法被调用，servlet对象已经被销毁");
42     }
43     
44 }

运行结果：

　　第一次

1 1.servlet对象被创建了
2 2.init 方法被调用
3 3.service 方法被调用

　　第二次

1 1.servlet对象被创建了
2 2.init 方法被调用
3 3.service 方法被调用
4 3.service 方法被调用

　　对比显示：servlet对象被创建一次，init方法被调用一次

　　　　　　　　访问一次servlet，service方法被调用一次

　停掉服务器或者重新部署

1 4.destory销毁方法被调用，servlet对象已经被销毁

构造方法：创建servlet对象的时候调用。默认情况下，第一次访问servlet的时候创建对象，只调　　　　用一次，证明servlet对象在tomcat中是单实例的

init方法：创建完servlet对象的时候调用，只调用一次

service方法：每次发出请求时调用，调用多次

destory方法：销毁servlet对象的时候调用。停止服务器或者重新部署web应用时销毁servlet对象，调用多次

　　4.3伪代码演示servlet的生命周期

　　　　1.通过映射找到servlet-class的内容字符串：com.java.servlet.ServletLife

　　　　2.通过反射构造ServletLife对象

　　　　　　2.1得到字节码对象

　　　　　　Class clazz = clazz.forName("com.java.servlet.ServletLife");

　　　　　　2.2调用无参数的构造方法来构造对象

　　　　　　Object obj = clazz.newInstance();　　　　　　　　　　------1.servlet的构造方法被调用

　　　　3.创建servletConfig对象，通过反射调用init方法

　　　　　　3.1得到方法对象

　　　　　　Method m = clazz.getDeclareMethod("init",ServletConfig.class);

　　　　　　3.2调用方法

　　　　　　m.invoke(obj,config);　　　　　　------2.servlet的init方法被调用

　　　　4.创建request，response对象，通过反射去调用service方法

　　　　　　4.1得到方法对象

　　　　　　　　Method m = clazz.getDeclareMethod("service",HttpServletRequest.class,HttpServletResponse.class);

　　　　　　4.2调用方法

　　　　　　m.invoke(obj,request,response);　　　　　　--------3.servlet的service方法被调用

　　　　　　5.当tomcat服务器停止或者web应用重新部署，通过反射调用destory方法

　　　　　　　　5.1得到方法到的对象

　　　　　　　　　　Method m = clazz.getDeclaredMethod("destory",nulll);

　　　　　　　　5.2调用方法

　　　　　　　　　　　m.invoke(obj,null);　　　　　　---------------4.servlet的destory的方法被调用

　　　4.4用时序图来演示servlet的生命周期

　　默认情况下，在第一次访问servlet的时候创建servlet对象。如果servlet的构造方法或init方法中执行了较多的逻辑代码，那么导致用户第一次访问servlet的时候比较慢‘　　　　

　　改变servlet创建的时机，提前到加载web应用的时候！！！

　　在servlet的配置信息中，加上一个<load-on-startup>即可

开启服务器时，加载应用，创建对象，提高用户体验

 1  <servlet>
 2     <description></description>
 3     <display-name>test</display-name>
 4     <servlet-name>test</servlet-name>
 5     <servlet-class>com.java.servlet.ServletLife</servlet-class>
 6     <!-- servlet对象的创建提前到加载web应用的时候  数字越大，优先级越低-->
 7     <load-on-startup>1</load-on-startup>
 8   </servlet>
 9   <servlet-mapping>
10     <servlet-name>test</servlet-name>
11     <url-pattern>/test</url-pattern>
12   </servlet-mapping>

servlet的init方法：

　　servlet有参数的init方法，该方法是servlet的生命周期方法，一定会被tomcat服务器调用，在有参数的init方法中，调用了无参数的init方法；如果有参数的init方法被覆盖，则无参数的init方法不会被调用，除非覆盖方法里面写了调用无参数的构造方法；如果要编写初始化代码。不覆盖有参数的init方法

　　servlet无参数的init方法，该方法是servlet的编写初始化代码的方法。是sun公司设计出来进行覆盖，然后在里面编写servlet的初始逻辑代码的方法

8.servlet对象在tomcat中是单实例的，但是可以调用多次service方法，而且互不干扰，所以肯定用了多线程；所以servlet是单实例多线程的第三方

　　　servlet在tomcat中的运行机制：

上面的first对象为servlet对象，为同一个对象，但是上面的request和response对象是一次请求一个对象，是互不相同的

　　关于线程安全：servlet是单实例多线程，因为两个first是同一个实例，所以，有公共的数据域存在，如果两个线程同时访问同一个数据域，可能会引发多线程问题

 1 package com.java.thread;
 2 
 3 import java.io.IOException;
 4 import javax.servlet.ServletException;
 5 import javax.servlet.http.HttpServlet;
 6 import javax.servlet.http.HttpServletRequest;
 7 import javax.servlet.http.HttpServletResponse;
 8 
 9 /**
10  * Servlet implementation class Safe_thread
11  */
12 public class Safe_thread extends HttpServlet {
13     private static final long serialVersionUID = 1L;
14        
15     /**
16      * @see HttpServlet#HttpServlet()
17      */
18     public Safe_thread() {
19         super();
20         // TODO Auto-generated constructor stub
21     }
22     int count=1;
23 
24     /**
25      * @see HttpServlet#doGet(HttpServletRequest request, HttpServletResponse response)
26      */
27     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
28         response.setContentType("text/html;charset=utf-8");;
29 //        int count=1;
30         response.getWriter().write("你是本网站的第"+count+"个访客");//线程1执行到这里，下面代码还没有执行，线程2来了，此时，线程1和线程2 的count值是一样的
31         try {
32             Thread.sleep(5000);
33         } catch (InterruptedException e) {
34             // TODO Auto-generated catch block
35             e.printStackTrace();
36         }
37         
38         
39         count++;
40         
41         response.getWriter().append("Served at: ").append(request.getContextPath());
42     }
43 
44 
45 }

用不同的浏览器进行访问

解决方案：加锁（所用当前类对象的字节码）

　　建议：在servlet类中尽量不要使servlet类的成员变量，如果确实要使用成员变量，必须要同步，而且要尽量缩小同步代码块的范围（若出现同步代码块，则当一个线程访问同步代码块的时候，其他线程是不能访问同步代码块，影响并发效率）哪里使用到了成员变量，就同步哪里，以避免因为同步而导致并发的效率降低

 1 package com.java.thread;
 2 
 3 import java.io.IOException;
 4 import javax.servlet.ServletException;
 5 import javax.servlet.http.HttpServlet;
 6 import javax.servlet.http.HttpServletRequest;
 7 import javax.servlet.http.HttpServletResponse;
 8 
 9 /**
10  * Servlet implementation class Safe_thread
11  */
12 public class Safe_thread extends HttpServlet {
13     private static final long serialVersionUID = 1L;
14        
15     /**
16      * @see HttpServlet#HttpServlet()
17      */
18     public Safe_thread() {
19         super();
20         // TODO Auto-generated constructor stub
21     }
22     int count=1;
23 
24     /**
25      * @see HttpServlet#doGet(HttpServletRequest request, HttpServletResponse response)
26      */
27     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
28         
29         synchronized (Safe_thread.class) {
30             response.setContentType("text/html;charset=utf-8");;
31 //            int count=1;
32             response.getWriter().write("你是本网站的第"+count+"个访客");//线程1执行到这里，下面代码还没有执行，线程2来了，此时，线程1和线程2 的count值是一样的
33             try {
34                 Thread.sleep(5000);
35             } catch (InterruptedException e) {
36                 // TODO Auto-generated catch block
37                 e.printStackTrace();
38             }
39             
40             
41             count++;
42             
43             response.getWriter().append("Served at: ").append(request.getContextPath());
44         }
45         
46         
47     }
48 
49 
50 }

servlet学习：

　　HttpServletRequest　　请求对象：获取请求信息

　　HttpServletResponse　　响应对象：设置响应对象

　　ServletConfig 对象　　Servlet配置对象

　　ServletContext　对象　　Servlet的上下文对象

　　　　所有web应用动态资源都是在web.xml文件进行配置，servlet信息封装到servletConfig对象中

9.ServletConfig对象

　　9.1作用：该对象主要是用于加载servlet的初始化参数　　一个web应用中可以存在多个servletConfig对象（一个servlet对应一个servletConfig）

　　9.2对象创建和得到：

　　　　创建的时机：在创建完servlet对象之后，调用init方法之前

　　　　得到对象：直接从有参数的init方法中可以得到。。。

　　9.3 servlet的初始化参数配置

　　　　　　servletConfig　　API:

　　　　　　　　getinitParameter(String name)　　根据参数名获取参数值 web文件中的参数，与web应用不同

　　　　　　　　getInitParameterNames()　　获取所有的参数

　　　　　　　　getServletContext()　　得到servlet的上下文

　　　　　　　　getServletNames()　　得到Servlet的名称

servletConfig

　　class文件

 1 package com.java.config;
 2 
 3 import java.io.BufferedReader;
 4 import java.io.File;
 5 import java.io.FileReader;
 6 import java.io.IOException;
 7 import java.util.Enumeration;
 8 
 9 import javax.servlet.ServletConfig;
10 import javax.servlet.ServletContext;
11 import javax.servlet.ServletException;
12 import javax.servlet.http.HttpServlet;
13 import javax.servlet.http.HttpServletRequest;
14 import javax.servlet.http.HttpServletResponse;
15 
16 
17 /**
18  * Servlet implementation class ConfigDemo
19  */
20 public class ConfigDemo extends HttpServlet {
21 //    /**
22 //     * 1.tomcat服务器把这些参数会加载在web应用中，封装到ServletConfig对象中
23 //     * 2.tomcat服务器调用init方法传入servletConfig对象
24 //     */
25 //    public ServletConfig config;
26 //    @Override
27 //    public void init(ServletConfig config) throws ServletException {
28 //        this.config= config;
29 //        
30 //    }
31 //    
32 //    
33     
34     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
35         
36         
37         /**
38          * 读取servlet的初始化参数
39          */
40         String path = this.getServletConfig().getInitParameter("path");
41         
42         File file = new File(path);
43         //读取内容
44         BufferedReader br = new BufferedReader(new FileReader(file));
45         String str = null;
46         while((str=br.readLine())!=null){
47             System.out.println(str);
48         }
49         
50         
51         /**
52          * 查找当前所有的servlet初始化参数
53          * 
54          */
55         
56         Enumeration<String > names = this.getServletConfig().getInitParameterNames();
57         
58         while (names.hasMoreElements()) {
59             String string = (String) names.nextElement();
60             System.out.println("参数名："+string +"参数值："+this.getServletConfig().getInitParameter(string));
61         }
62         //拿到servlet的名称
63         String servletName = this.getServletConfig().getServletName();
64         System.out.println(servletName);
65         
66         //servletContext
67         ServletContext context = this.getServletConfig().getServletContext();
68         
69         
70         
71         response.getWriter().append("Served at: ").append(request.getContextPath());
72     }
73 
74 
75 }

　　web文件

 1  <servlet>
 2     <description></description>
 3     <display-name>ConfigDemo</display-name>
 4     <servlet-name>ConfigDemo</servlet-name>
 5     <servlet-class>com.java.config.ConfigDemo</servlet-class>
 6       <!-- 初始化参数 。这些参数在加载web应用的时候封装到ServletConfig对象中-->
 7       <init-param>
 8           <param-name>path</param-name>
 9           <param-value>e:\Contact.xml</param-value>
10       </init-param>
11       <init-param>
12           <param-name>path1</param-name>
13           <param-value>测试1</param-value>
14       </init-param>
15       <init-param>
16           <param-name>path2</param-name>
17           <param-value>测试2</param-value>
18       </init-param>
19       <init-param>
20           <param-name>path3</param-name>
21           <param-value>测试3</param-value>
22       </init-param>
23   </servlet>
24   <servlet-mapping>
25     <servlet-name>ConfigDemo</servlet-name>
26     <url-pattern>/ConfigDemo</url-pattern>
27   </servlet-mapping>

测试结果：

 1 <?xml version="1.0" encoding="utf-8"?>
 2 
 3 <contactList> 
 4   <contact id="58"> 
 5     <name>閽為洩</name>  
 6     <gender>濂?/gender>  
 7     <age>34</age>  
 8     <phone>123456</phone>  
 9     <email>12542.qq.com</email>  
10     <QQ>124569</QQ> 
11   </contact> 
12 </contactList>
13 参数名：path2参数值：测试2
14 参数名：path1参数值：测试1
15 参数名：path3参数值：测试3
16 参数名：path参数值：e:\Contact.xml
17 ConfigDemo

sun公司的设计：

　　1.创建servletContext对象　　ServletContext servletCotext = new ServletContext()　　

　　2.创建servletConfig对象 servletConfig config = new ServletConfig()

　　　　　　　　　　　　　　config.setServletContext(context);

1 class ServlerConfig{
2         servletContext context;
3         public ServletContext getServletContext(){
4              return this.context;
5         }
6 }

10 servletContext

　　10.1 servletContext对象，叫做servlet的上下文对象，表示一个当前的web应用环境

　　　　一个web应用中只有一个servletConfig对象

　　10.2　　对象创建时间和得到

　　　　　　创建时间：加载web应用时去创建servletContext对象

　　　　　　得到对象：从servletConfig的getServletContext方法得到

　　10.3　　servletContext 核心api

　　　　getContextPath()　　　　　　-------得到当前web应用的路径用在请求重定向的路径资源中

　　　　getInitParameter(String name)　　----------得到web应用的初始化参数

　　　　getInitParameterNames()

域对象有关的方法

　　　　setAttribute(String name,Object object)　　　　---------------保存数据

　　　　getAttribute(String name)　　　　　　------------------------获取数据

　　　　removeAttribute(String name)　　　　--------------------从域对象中删除数据，如果不删除，则数据一直存在

　　　　域对象：作用是用于保存数据，获取数据。可以在不同的动态资源之间共享数据

　　　　案例：

　　　　　　servlet1　　　　　　　　　　　　　　　　　　　　　　servlet2

　　　　　　name=nanami

　　response.sendRedirect("/servlet2?name=nanami")　　　　String name = nanami

　　方案1：可以通过传递参数的形式，共享数据。局限：只能传递字符串类型。

　　方案2：可以使用域对象来共享数据。好处：可以共享任何类型的数据！！！！

　　servletContext就是一个域对象

扩展：

　　所有域对象（范围不一样）：

　　　　 HttpServletRequest　　域对象

　　　　ServletContext·　　　　域对象

　　　　HttpSession　　域对象

　　　　pageContext　　域对象

　　　　getRequestDispatcher(String path)　　　　--------------转发（类似于重定向）

1 RequestDispatcher rd = context.getRequestDispatcher("/test.html");
2         rd.forward(request, response);

区别：

　　转发：地址不变　　不能转发到web应用以外的资源　　可以在转发过程中，可以把数据保存到request域对象中

　　重定向：地址栏会改变，变成重定向的地址可以去到web应用以外的资源　　不能再重定向的过程，把数据保存到request中

结论：如果要使用request域对象进行数据的共享，只能用转发技术

　　　　getRealPath(String path)　　-------得到web应用的资源文件

　　　　getResourceAsAtream(String path)　　　

　　　　注：web应用参数可以让当前所有的servlet进行访问，servlet参数只能由当前的servlet来进行读取

web.xml

  1 <?xml version="1.0" encoding="UTF-8"?>
  2 <web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" id="WebApp_ID" version="2.5">
  3   <context-param>
  4     <param-name>test</param-name>
  5     <param-value>test_context</param-value>
  6   </context-param>
  7   <servlet>
  8     <description></description>
  9     <display-name>ServletDemo1</display-name>
 10     <servlet-name>ServletDemo1</servlet-name>
 11     <servlet-class>com.http.servlet.ServletDemo1</servlet-class>
 12   </servlet>
 13   <servlet-mapping>
 14     <servlet-name>ServletDemo1</servlet-name>
 15     <url-pattern>/ServletDemo1</url-pattern>
 16   </servlet-mapping>
 17   <servlet>
 18     <description></description>
 19     <display-name>getParam</display-name>
 20     <servlet-name>getParam</servlet-name>
 21     <servlet-class>com.http.servlet.getParam</servlet-class>
 22   </servlet>
 23   <servlet-mapping>
 24     <servlet-name>getParam</servlet-name>
 25     <url-pattern>/getParam</url-pattern>
 26   </servlet-mapping>
 27   <servlet>
 28     <description></description>
 29     <display-name>Response</display-name>
 30     <servlet-name>Response</servlet-name>
 31     <servlet-class>com.http.servlet.Response</servlet-class>
 32   </servlet>
 33   <servlet-mapping>
 34     <servlet-name>Response</servlet-name>
 35     <url-pattern>/Response</url-pattern>
 36   </servlet-mapping>
 37   <servlet>
 38     <description></description>
 39     <display-name>response_location</display-name>
 40     <servlet-name>response_location</servlet-name>
 41     <servlet-class>com.http.response.response_location</servlet-class>
 42   </servlet>
 43   <servlet-mapping>
 44     <servlet-name>response_location</servlet-name>
 45     <url-pattern>/response_location</url-pattern>
 46   </servlet-mapping>
 47   <servlet>
 48     <description></description>
 49     <display-name>response_refresh</display-name>
 50     <servlet-name>response_refresh</servlet-name>
 51     <servlet-class>com.http.response.response_refresh</servlet-class>
 52   </servlet>
 53   <servlet-mapping>
 54     <servlet-name>response_refresh</servlet-name>
 55     <url-pattern>/response_refresh</url-pattern>
 56   </servlet-mapping>
 57   <servlet>
 58     <description></description>
 59     <display-name>response_contentType</display-name>
 60     <servlet-name>response_contentType</servlet-name>
 61     <servlet-class>com.http.response.response_contentType</servlet-class>
 62   </servlet>
 63   <servlet-mapping>
 64     <servlet-name>response_contentType</servlet-name>
 65     <url-pattern>/response_contentType</url-pattern>
 66   </servlet-mapping>
 67   <servlet>
 68     <description></description>
 69     <display-name>test</display-name>
 70     <servlet-name>test</servlet-name>
 71     <servlet-class>com.java.servlet.ServletLife</servlet-class>
 72     <load-on-startup>1</load-on-startup>
 73   </servlet>
 74   <servlet-mapping>
 75     <servlet-name>test</servlet-name>
 76     <url-pattern>/test</url-pattern>
 77   </servlet-mapping>
 78   <servlet>
 79     <description></description>
 80     <display-name>Safe_thread</display-name>
 81     <servlet-name>Safe_thread</servlet-name>
 82     <servlet-class>com.java.thread.Safe_thread</servlet-class>
 83   </servlet>
 84   <servlet-mapping>
 85     <servlet-name>Safe_thread</servlet-name>
 86     <url-pattern>/Safe_thread</url-pattern>
 87   </servlet-mapping>
 88   <servlet>
 89     <description></description>
 90     <display-name>ConfigDemo</display-name>
 91     <servlet-name>ConfigDemo</servlet-name>
 92     <servlet-class>com.java.config.ConfigDemo</servlet-class>
 93     <init-param>
 94       <param-name>path</param-name>
 95       <param-value>e:\Contact.xml</param-value>
 96     </init-param>
 97     <init-param>
 98       <param-name>path1</param-name>
 99       <param-value>测试1</param-value>
100     </init-param>
101     <init-param>
102       <param-name>path2</param-name>
103       <param-value>测试2</param-value>
104     </init-param>
105     <init-param>
106       <param-name>path3</param-name>
107       <param-value>测试3</param-value>
108     </init-param>
109   </servlet>
110   <servlet-mapping>
111     <servlet-name>ConfigDemo</servlet-name>
112     <url-pattern>/ConfigDemo</url-pattern>
113   </servlet-mapping>
114   <servlet>
115     <description></description>
116     <display-name>servletContext</display-name>
117     <servlet-name>servletContext</servlet-name>
118     <servlet-class>com.java.servletContext.servletContext</servlet-class>
119   </servlet>
120   <servlet-mapping>
121     <servlet-name>servletContext</servlet-name>
122     <url-pattern>/servletContext</url-pattern>
123   </servlet-mapping>
124   <servlet>
125     <description></description>
126     <display-name>ServletTest</display-name>
127     <servlet-name>ServletTest</servlet-name>
128     <servlet-class>com.java.servletContext.ServletTest</servlet-class>
129   </servlet>
130   <servlet-mapping>
131     <servlet-name>ServletTest</servlet-name>
132     <url-pattern>/ServletTest</url-pattern>
133   </servlet-mapping>
134 </web-app>

class

 1 package com.java.servletContext;
 2 
 3 import java.io.IOException;
 4 import java.util.Enumeration;
 5 
 6 import javax.servlet.ServletContext;
 7 import javax.servlet.ServletException;
 8 import javax.servlet.http.HttpServlet;
 9 import javax.servlet.http.HttpServletRequest;
10 import javax.servlet.http.HttpServletResponse;
11 
12 public class servletContext extends HttpServlet {
13 
14     protected void doGet(HttpServletRequest request, HttpServletResponse response)
15             throws ServletException, IOException {
16         // ServletContext servletContect
17         // =this.getServletConfig().getServletContext();
18         ServletContext servletContext = this.getServletContext();
19         // 得到web应用路径：部署到tomcat服务器上项目的名称
20         String projectName = servletContext.getContextPath();
21         System.out.println(projectName);
22 
23         // 案例：应用请求到重定向
24 //        response.sendRedirect(projectName + "/index.html");
25 
26         // 得到web应用的初始化参数
27         String value = servletContext.getInitParameter("test");
28         System.out.println(value);
29         Enumeration<String> names = servletContext.getInitParameterNames();
30 
31         while (names.hasMoreElements()) {
32             String string = (String) names.nextElement();
33             System.out.println(string+servletContext.getInitParameter(string));
34         }
35         
36         // response.getWriter().append("Served at:
37         // ").append(request.getContextPath());
38         
39         //域对象  共享数据
40         Student s = new Student();
41         s.setAge(12);
42         s.setName("test");
43         servletContext.setAttribute("student", s);
44         
45         response.sendRedirect(projectName+"/ServletTest");
46         
47         
48         
49         
50         
51         
52     }
53 
54 }

class

 1 package com.java.servletContext;
 2 
 3 import java.io.IOException;
 4 
 5 import javax.servlet.RequestDispatcher;
 6 import javax.servlet.ServletContext;
 7 import javax.servlet.ServletException;
 8 import javax.servlet.http.HttpServlet;
 9 import javax.servlet.http.HttpServletRequest;
10 import javax.servlet.http.HttpServletResponse;
11 
12 public class ServletTest extends HttpServlet {
13 
14     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
15         ServletContext context = this.getServletConfig().getServletContext();
16         Student s =(Student) context.getAttribute("student");
17         System.out.println(s.toString());
18     
19         
20         RequestDispatcher rd = context.getRequestDispatcher("/test.html");
21         rd.forward(request, response);
22     }
23 
24 }

总结

　　servlet编程：

　　　　servlet生命周期（重点）其他都是应用的东西

posted @ 2017-03-11 22:57 優syousetu 阅读(199) 评论(0) 编辑收藏举报

刷新页面返回顶部

優syousetu

servlet

公告