哪个用于封装servlet的配置信息

Ⅰ Java中的Servlet的定义，Servlet的具体用途

Servlet是一个实现了Servlet接口的类，一个与访问协议和平台无关的、运行在Servlet容器中的Java程序。

针对Servlet实现技术，SUN公司提供了一套标准的Java Servlet API以便于更快速、规范地开发Servlet程序。这套Servlet API中，最重要的两个软件包是：javax.servlet、javax.servlet.http。

javax.servlet是一个与通信协议无关的通用软件包;javax.servlet.http是一个支持HTTP访问协议的软件包，这两个软件包的同时存在，使得Servlet API能支持任何协议的请求/响应。

在javax.servle中，包含着一套常用接口，负责承担指定的任务。下表中列出了常用的类和接口：

javax.servlet软件包：

javax.servlet包中定义了与通信协议无关的接口和类。

常用接口：

RequestDispatcher、Servlet、ServletConfig、ServletContext、ServletRequest、ServletResponse。

常用类：

GenericServlet、ServletInputStream、ServletOutputStream。

1、RequestDispatcher接口

public interface RequestDispatcher;

资源调度器接口，用于定义一个在服务器内部直接实现资源转发的对象。

RequestDispatcher对象由Servlet容器创建，用于封装并调度由一个特定的URL定义的服务器资源。

(1)请求传递方法

public void forward(ServletRequest request,

ServletReponse response) throws ServletException,IOException

从一个Servlet向服务器上的另一个资源传递请求。

将请求转发给其他资源时，将由被调用的资源负责对请求作出响应，而原先Servlet的执行则终止。

public void include(ServletRequest request,

ServletResponse response) throws ServletException,IOException

从一个Servlet向服务器上的另一个资源传递请求。

将请求转发给其他资源时，被调用的Servlet对该请求作出的响应将并入原先的响应对象中，原先的Servlet还可以继续输出响应消息。

2、Servlet接口

public interface Servlet;

开发一个Servlet需要实现的基础接口。

接口中定义了5个方法：

init()：Servlet初始化方法，通过init()方法可以获得容器创建的ServletConfig对象

service()：请求处理方法

destroy()：Servlet实例销毁方法

getServletConfig()：获取ServletConfig配置对象方法

getServletInfo()：获取Servlet相关信息方法

(1)初始化方法

public void init(ServletConfig config) throws ServletException

Servlet容器会在Servlet实例化之后，调用init方法对Servlet对象进行初始化，该方法由Servlet容器顺序调用，无需Servlet自身考虑何时执行。

(2)服务方法

public void service(ServletRequest request,

ServletResponse response) throws ServletException,IOException

当Servlet容器接收到客户请求时，调用service方法响应客户请求，service方法在Servlet实例化、初始化之后被调用，并且可以被多次调用。

(3)销毁方法

public void destroy()

当Servlet实例从服务器中移除或服务停止时，Servlet容器调用destroy方法销毁Servlet实例。

(4)获取Servlet配置对象方法

public ServletConfig getServletConfig()

获取一个由Servlet容器创建的ServletConfig配置对象，这个对象常常用在Servlet初始化方法中，将初始化参数封装在ServletConfig对象中，然后传递给Servlet。

(5)获取Servlet相关信息方法

public String getServletInfo()

获取关于Servlet的一些相关信息，返回的字符串是纯文本格式而不带有任何标记(例如：HTML、XML等)。

3、ServletConfig接口

public interface ServletConfig;

Servlet配置信息接口，在Servlet初始化时，Servlet容器将Servlet初始化参数封装在ServletConfig对象中，并传递给Servlet，一个Servlet实例只有一个ServletConfig对象。

接口中，只定义了4个方法：

getInitParameter()：获取Servlet指定初始化参数的值

getInitParameterNames()：获取Servlet所有初始化参数名称

getServletContext()：获取Servlet容器为WEB应用创建的Servlet上下文环境对象ServletContext

getServletName()：获取Servlet名称

(1)获取初始化参数方法

public String getInitParameter(String name)

根据初始化参数名称，获取Servlet指定初始化参数的值，如果指定的参数不存在，返回空值null。

public Enumeration getInitParameterNames()

获取Servlet所有初始化参数名称，如果Servlet没有初始化参数，返回一个空列表。

(2)获取Servlet上下文环境方法

public ServletContext getServletContext()

获取Servlet容器为WEB应用创建的Servlet上下文环境对象ServletContext，WEB服务器启动的时候，在加载WEB应用时，为每个加载的WEB应用创建一个代表WEB应用Servlet上下文环境对象。

(3)获取Servlet名称方法

public String getServletName()

获取正在访问的这个Servlet的名称。

以上就是Servlet相关问题的解答，更多关于Java Web方面的问题可以看下这个详细的视频教程网页链接，希望我的回答能帮到你。

Ⅱ servlet在哪个文件中进行配置如何配置servlet

从映射名查找servlet名，因为你的跳转肯定是servlet的映射名，而不是servlet类名，所以先根据你的跳转获取你的servlet跳转路径url，找到web.xml中servlet-mapping的url-pattern，然后找到servlet-name,通过servlet-name找到servlet的servlet同名的servlet-class，然后调用该servlet的类。

Ⅲ 怎么配置servlet

一、servlet的配置

servlet有两种配置的方法
1.在web.xml文件中配置

<servlet>
<servlet-name>loginServlet</servlet-name>
<servlet-class>com.hwua.servlet.LoginServlet</servlet-class></servlet><servlet-mapping>
<servlet-name>loginServlet</servlet-name>
<url-pattern>/login</url-pattern></servlet-mapping>

2.在servlet中用Java注解的方式配置
使用注解配置Servlet的步骤:

1. 在Servlet类上贴@WebServlet注解2. 在web.xml文件中进行如下的配置
metadata-complete="true":表示是否忽略Servlet上面的注解
metadata-complete="false"表示是否不忽略Servlet上面的注解,缺省值

二、servlet生命周期

• public void init(ServletConfig config):初始化方法,在第一次请求时调用,只在最初的时候调用一次.

• public void service(ServletRequest req, ServletResponse res):服务方法

• public void destroy():销毁方法

三、在web.xml文件中设置/获取初始化参数

1.作用域当前的servlet 写在servlet标签中

• <init-param>


• <param-name>name</param-name>


• <param-value>admin</param-value></init-param>



过去参数 在init方法中

• String name = config.getInitParameter("name");



2.上下文参数 写在web-app标签中

• <context-param>


• <param-name>driver</param-name>


• <param-value>oracle.jdbc.OracleDriver</param-value></context-param>



获取参数 在init方法中

• ServletContext servletContext = config.getServletContext();


• String initParameter = servletContext.getInitParameter("driver");



四、设置servlet启动的时间

默认情况下servlet是在第一次被请求时启动的
通过在web.xml文件中设置

• <load-on-startup>1</load-on-startup>



注意：

• load-on-startup 的参数是大于等于0的 负数没有效果load-on-startup 必须在参数init-param标签的下面 否则init-param会失效



五、常用方法:

• String getContextPath():获取上下文路径,<Context path="上下文" ../>


• String getHeader(String headName):根据指定的请求头获取对应的请求头的值. String getRequestURI():返回当期请求的资源名称. 上下文路径/资源名


• StringBuffer getRequestURL():返回浏览器地址栏的内容 String getRemoteAddr():返回请求服务器的客户端的IP



六、获取请求参数的方法:

• String getParameter(String name):根据参数名称,获取对应参数的值.String[] getParameterValues(String name):根据参数名称,获取该参数的多个值.


• Enumeration<String> getParameterNames():获取所有请求参数的名字Map<String,String[]> getParameterMap():返回请求参数组成的Map集合.


• key:参数名称


• value:参数值,封装在String数组中.

Ⅳ 如何利用servletcontext和servletconfig对象获得初始化参数

七、ServletConfig对象
在Servlet的配置文件中可以使用一个或多个<init-param>标签为Servlet配置初始化参数，web服务器会在创建Servlet对象时，将这些参数封装在ServletConfig对象中，因此我们可以通过ServletConfig对象来获取一个Servlet的初始化参数。通常将Servlet运行时要读取的配置文件写在这里。
八、ServletContext对象
ServletContext对象代表了一个应用，他是一个Context域对象，它里面的方法主要是一些全局性的方法，可以用来存储各个Servlet之间的共享数据。
ServletContext对象的应用场景，主要用于Servlet之间数据共享(可以用来做聊天室)，获取web应用的初始化参数，实现Servlet转发，读取资源文件。
配置web应用的初始化参数，在web.xml文件中使用标签<context-param>，通常在这里配置数据库连接，
Servlet的转发和重定向，转发（你来请求我，我将请求转给他），通常转发给jsp用来美化输出，重定向（你来请求我，我让你重新请求他）
RequestDispatcher rd = this.getServletContext().getRequestDispatcher("/1.jsp");
rd.forward(request,response);


九、利用ServletContext读取资源文件
1.
1 InputStream stream = this.getServletContext().getResourceAsStream("/WEB-INF/classes/db.properties");
2 Propertied prop = new Properties();
3 prop.load(stream);
4 prop.getProperty("user");

2.
//这种方式，可以很方便的获取文件名称
String path = this.getServletContext().getRealPath("/WEB-INF/classes/db.properties");
FileInputStream inStream = new FileInputStream(path);
Propertied prop = new Properties();
prop.load(stream);
prop.getProperty("user");

十、Java web应用中非Servlet程序读取资源文件
1.

//使用类装载器，文件不能太大
public class UserDao
{
private static Properties prop = new Properties();
static
{
//InputStream inStream = UserDao.class.getClassLoader().getResourceAsStream("db.properties"); 这种方式无法获取到更新后的数据

String path = UserDao.class.getClassLoader().getResource("db.properties");
FileInputStream inStream = new FileInputStream(path); //这种方式可以获取到更新后的数据

prop.load(inStream);
}

public void update()
{
//引用inStream
}

public void find()
{
//引用inStream
}
}

Ⅳ servlet如何使用

Servlet是响应客户端请求的技术。就是一个运行在Web服务器上的，由服务器实例化，并根据客户端发送过来的请求，调用其中相应方法的一个类。
q理解HTTP Servlet 基础知识
q使用 Servlet API
q理解Servlet 的生命周期
q使用JBuilder2005演示Servlet
本章很重要，首先要理解servlet的作用，就是用来响应客户端的请求的；然后理解servlet的运行机制，就是什么时候响应客户端请求，由服务器调用什么方法来处理客户端请求；再具体的看每个方法，这时看到方法中出现的一些类，再来理解这些类使用来实现什么功能的。（理解思路）
知识点：
1、生命周期（本节了解servlet何时被调用何方法来处理客户端请求，注意理解每个方法的作用和调用时间。）
生命周期: (重点)
实例化—————————〉初始化——〉服务——〉破坏——〉不可用
| | | |
| | | |
容器创建servlet实例 init() service() destroy()
2、在HttpServlet类中，doGet()和doPost()分别被用来对客户端get请求和post请求来做处理。
3、servlet 应用程序体系结构
在理解了servlet的各个方法是何时被调用之后，再来看每个方法中使用到的这些类是做什么用的，这样再来决定什么时候来使用这些类。
整个servlet的应用程序中，所有的类构成了servlet-API
ServletInputStream类
该类创建的对象用于从客户端请求中读取二进制数据。（用途决定了什么时候使用该类。如果现在要我们从客户端的请求中读取数据，则要考虑到使用该类）
ServletOutputStream类
该类用于将二进制数据传送给客户端。其类中有print(),println()方法可以用来往客户端输出。
ServletRequest接口
该接口对象用于接受客户端请求信息。它的子接口HttpServletRequest用作于doGet()方法的参数，用来接受Servlet容器传递过来的客户端请求。也就是说，Servlet容器，将客户端请求封装成一个HttpServletRequest类型对象，并传递给doGet()方法。由 该方法中HttpServletRequest刑参接受。
ServletResponse接口，
该接口用于接受向客户端发送的响应。它的子接口HttpServletResponse用于doGet()方法的参数，用于接受Servelt容器传递过来的对客户端的响应。也就是说，Servlet容器，创建了HttpServletReponse类型的对象，用于表示对客户端的响应，并传递给doGet()方法。那么我们在doGet()方法中可以通过设置该对象来设置对客户端的响应。
HttpServletRequest接口(重点)
HttpServletResponse接口(重点)
ServletConfig接口
该接口对象是用于传递Servlet的配置信息的。我们在web.xml中配置了关于Servlet的配置信息，而该Servlet被实例化的时候，Servlet容器从web.xml中提取出有关Servlet的初始化信息并且封装成为一个ServletConfig类型的对象，传递给init()方法。（那我们就可以在init()方法中，通过该对象获取Servlet的初始化信息了。）
ServletContext接口(重点)
该接口用于创建一个生存周期为整个应用程序的对象，并用它来存储一些整个应用程序中要使用的变量。
对于每个应用程序Servlet容器将会创建出一个ServletContext类型的对象，并一直存在知道应用程序不再发布在服务器上。那么我们就可以使用该对象来保存一些变量，这些变量在整个应用程序生命周期内都存在。
注意，当有变量要存储于某个范围内时，注意区别、联系、比较该对象与针对于每个客户端创建的HttpSession对象（session）；针对于每请求创建的HttpRequestServlet对象；针对于每个页面创建的PageContext对象(page)

Ⅵ spring4框架中如何实现servlet功能

Spring管理filter和servlet
在使用spring容器的web应用中，业务对象间的依赖关系都可以用context.xml文件来配置，并且由spring容器来负责依赖对象 的创建。如果要在filter或者servlet中使用spring容器管理业务对象，通常需要使用

WebApplicationContextUtils.(getServletContext())来获得WebApplicationContext，然后调用WebApplicationContext.getBean("beanName")来获得对象的引用，这实际上是使用了依赖查找来获得对象，并且在filter或者servlet代码中硬编码了应用对象的bean名字。为了能在filter或者servlet中感知spring中bean，可采用如下步骤来实现：

1- 将filter或者servlet作为bean定义在context.xml文件中，和要应用的bean定义放在一起；

2- 实现一个filter代理或者servlet代理，该代理用WebApplicationContext来获得在context.xml中定义的filter或者servlet的对象，并将任务委托给context.xml中定义的filter或者servlet

3- 在web.xml中用ContextLoaderListener来初始化spring 的context，同时在filter代理或者servlet代理的定义中用初始化参数来定义context.xml中filter或者servlet的bean名字（或者直接受用代理的名称获得相应的filter或者servlet的名称）。

4- 在web.xml中定义filter代理或者servlet代理的mapping.

利用这种方式就将filter或者servlet和业务对象的依赖关系用spring 来进行管理，并且不用在servlet中硬编码要引用的对象名字。

具体实例如下：
Filter
1. 在applicationContext.xml中定义filter

<bean id="springFilter" class="com.netqin.filter.SpringFilter">

<property name="name">

<value>SpringFilter</value>

</property>

</bean>

说明：com.netqin.filter.SpringFilter为实现了javax.servlet.Filter接口的filter

2. 实现filter代理

实际上，filter代理不需要我们自己来实现，Spring提供了两种现成的filter代理

org.springframework.security.util.FilterToBeanProxy，

org.springframework.web.filter.DelegatingFilterProxy，两者只是在web.xml中的配置上略有不同，下面就让我们一起看看如何在web.xml中进行配置。

3. 配置web.xml

Ø 初始化spring的context

因为是使用spring来管理，所以在使用filter前先要初始化spring的context，一般来说配置如下：

<context-param>

<param-name>contextConfigLocation</param-name>

<param-value>

/WEB-INF/applicationContext.xml

</param-value>

</context-param>

<listener>

<listener-class>

org.springframework.web.context.ContextLoaderListener

</listener-class>

</listener>

Ø Filter配置：

² FilterToBeanProxy

<filter>

<filter-name> springFilter </filter-name>

<filter-class>

org.springframework.security.util.FilterToBeanProxy

</filter-class>

<init-param>

<param-name>targetBean</param-name>

<param-value>springFilter</param-value>

</init-param>

</filter>

说明：需要为FilterToBeanProxy提供上下文参数，这里我们配置的是targetBean属性，它告诉spring在context中查找的bean名称，所以当请求被过滤器拦截后FilterToBeanProxy会在applicationContext.xml中会查找id为springFilter的bean.

我们也可以配置targetClass属性，意思就是查找该类型的bean.

² DelegatingFilterProxy

<filter>

<filter-name>springFilter</filter-name>

<filter-class>

org.springframework.web.filter.DelegatingFilterProxy

</filter-class>

</filter>

说明：使用DelegatingFilterProxy时不需要配置任何参数，spring会根据filter-name的名字来查找bean，所以这里spring会查找id为springFilter的bean.

4. 配置filter的mapping

<filter-mapping>

<filter-name>springFilter</filter-name>

<url-pattern>/*</url-pattern>

</filter-mapping>

OK!filter配置完成。推荐使用DelegatingFilterProxy，应为配置上更简单。

Servlet
Servlet的配置与Filter的配置十分相似

1. 在applicationContext.xml中定义servlet

<bean id="springServlet" class="com.netqin.servlet.SpringServlet">

<property name="name">

<value>SpringServlet</value>

</property>

</bean>

说明：com.netqin.servlet.SpringServlet继承自

javax.servlet.http.HttpServlet

2. 实现servlet代理

与filter不同，spring没有为servlet提供代理实现，需要我们自己来创建，不过放心，创建一个servlet代理十分简单，一个具体的实现如下：

import java.io.IOException;

import javax.servlet.GenericServlet;

import javax.servlet.Servlet;

import javax.servlet.ServletException;

import javax.servlet.ServletRequest;

import javax.servlet.ServletResponse;

import org.springframework.web.context.WebApplicationContext;

import org.springframework.web.context.support.WebApplicationContextUtils;

public class ServletToBeanProxy extends GenericServlet {

private String targetBean;

private Servlet proxy;

public void init() throws ServletException {

this.targetBean = getInitParameter("targetBean");

getServletBean();

proxy.init(getServletConfig());

}

public void service(ServletRequest req, ServletResponse res)

throws ServletException, IOException {

proxy.service(req, res);

}

private void getServletBean() {

WebApplicationContext wac = WebApplicationContextUtils

.(getServletContext());

this.proxy = (Servlet) wac.getBean(targetBean);

}

}

Ⅶ 当tomcat初始化一个servlet时，会将该servlet的配置信息封装到什么对象中

说白了就是想当容器启动时拉起一些服务呗，可以这么搞：（1）新建一个Servlet实现ServletContextListener接口，重写contextInitialized用来执行启动时要做的事情，例子中我拉起了一个线程，或者重写contextDestroyed方法来执行容器销毁时要做什么。importjavax.servlet.ServletContextEvent;importjavax.servlet.ServletContextListener;{//初始化驱动线程DriveThreaddThread=null;privatestaticfinalLoggerlog=Logger.getLogger(MyServlet.class);@(ServletContextEventarg0){dThread=newDriveThread();dThread.start();log.debug("DriveThreadstart");}@(ServletContextEventarg0){log.debug("DriveThreadDestroyed");}}（2）在web.xml中配一个监听com.lear.MyServlet（3）现在启动吧~容器会拉起你的servlet

Ⅷ 一个控制器servlet组件需要完成那些工作

一、ActionServlet的初始化

ActionServlet 作为Struts组件的前端控制器，由于web.xml的相应配置：

<load-on-startup>0</load-on-startup>

在 应用一加载时即会被实例化并调用其init方法，init方法所做的主要工作有二：

1. 加载struts配置文件，并创建用于封装配置信息的MoleConfig对象
2. 加载资源文件，并创建用于封装资源文件的MessageResources对象
需要注意两点：如果web.xml有多模块配置，将创建多个 MoleConfig对象和MessageResources对象分别用于封装各个模块的struts配置文件和资源文件。
针对各个模块所 创建的MoleConfig对象和MessageResources对象将

Ⅸ servlet 的作用是什么

在 JavaWeb 项目中，处理请求和发送响应的过程是由一种叫做 Servlet 的程序来完成的，并且 Servlet 是为了解决实现动态页面而衍生的东西。

简单来讲：Servlet其实就是一个遵循Servlet开发的java类，Serlvet是由服务器调用的，运行在服务器端。

一张图描述 Servler 在 B/S 中的作用点：

2. Tomcat 和 Servlet 的关系

Tomcat 是Web应用服务器，是一个Servlet/JSP容器。 Tomcat 作为 Servlet 容器，负责处理客户请求,把请求传送给 Servlet，并将 Servlet 的响应传送回给客户，而 Servlet 是一种运行在支持 Java 语言的服务器上的组件。

Servlet 最常见的用途是扩展 Java Web 服务器功能，提供非常安全的、可移植的、易于使用的 CGI 替代品。

从 Http 协议中的请求和响应可以得知，浏览器发出的请求是一个请求文本，而浏览器接收到的也应该是一个响应文本。但是在上面这个图中，并不知道是如何转变的，只知道浏览器发送过来的请求也就是 request，我们响应回去的就用 response。忽略了其中的细节，现在就来探究一下。

①：Tomcat 将 Http 请求文本接收并解析，然后封装成 HttpServletRequest 类型的 request 对象，所有的 Http 头数据读可以通过request 对象调用对应的方法查询到。

②：Tomcat 同时会要响应的信息封装为 HttpServletResponse 类型的response 对象，通过设置 response 属性就可以控制要输出到浏览器的内容，然后将 response 交给 Tomcat，Tomcat 就会将其变成响应文本的格式发送给浏览器。

Java Servlet API 是Servlet容器(tomcat)和servlet之间的接口，它定义了Serlvet 的各种方法，还定义了 Servlet 容器传送给 Servlet 的对象类，其中最重要的就是 ServletRequest 和 ServletResponse 。所以说我们在编写Servlet时，需要实现 Servlet 接口，按照其规范进行操作。

3. Servlet 接口主要方法

Servlet 接口主要的 3 个方法：

• init()方法：只会调用一次，只是在创建servlet实例的时候才会创建。

• service()方法：是进行数据处理的，只要接受了一次请求，就会被调用一次

• destroy()方法：销毁 Servlet 对象的时候调用。停止服务器或者重新部署 Web 应用时销毁 Servlet 对象，同样也是调用一次

4. 编写 Servlet

首先说明一点疑惑，有时候我们在一些资料上看到别人这样写：

• {



• init()...



• service()...



• getServletConfig()...



• ...


• }



而在这我们要继承 HttpServlet类 那么问题来了，继承HttpServlet 和实现Servlet 有什么区别？

首先，直观的不同，Servlet 是一个接口，如果实现这个接口，那么就必须实现接口里面定义的所有方法。

而 HttpServlet 实现了 Servlet 接口，并把 Servlet 接口中的方法实现了。
继承 Httpservelt，实际上也就实现了 Servlet 接口。

但是我们没必要再去实现 Servlet 中定义的生命周期方法，因为在 Httpservlet 中已经有了默认实现，并且这些默认实现也挺规范和实用， doget 和 dopost 是执行用户请求的终点，get 请求会调用 doget 方法，post 请求会执行 dopost 方法，我们可以在这2个方法中定义我们自己的业务逻辑。

最后，HttpServlet 在实现 Servlet 接口的时候，已经实现了 Servlet 中所有的方法，因此继承自 HttpSrvlet 的类，不需要再去覆写相应的生命周期等方法。

4.1 编写Java类，继承HttpServlet

创建一个 MyServlet java 类，继承 HttpServlet 实现 service 方法：

• {



• @Override


• protectedvoidservice(HttpServletRequestrequest,HttpServletResponseresponse)throwsServletException,IOException{


• //设置字符编码


• request.setCharacterEncoding("utf8");


• //从request对象中获取username,password


• Stringusername=request.getParameter("username");


• Stringpassword=request.getParameter("password");


• request.setAttribute("username",username);


• request.setAttribute("password",password);


• request.getRequestDispatcher("/index2.jsp").forward(request,response);;


• }


• }



4.2 配置web.xml文件

web.xml 配置 Servlet 访问路径，能让别人通过链接访问到你的 Servlet：

• <web-app>


• <display-name></display-name>



• <servlet>


• <servlet-name>MyServlet</servlet-name>


• <servlet-class>club.sscai.demo.MyServlet</servlet-class>


• </servlet>



• <servlet-mapping>


• <servlet-name>MyServlet</servlet-name>


• <url-pattern>/MyServlet</url-pattern>


• </servlet-mapping>



• </web-app>



4.3 jsp 界面显示

index2.jsp:

• <html>


• <body>


• <h2>2222222</h2>


• username:<%=request.getParameter("username")%>


• <br>


• password:<%=request.getParameter("password")%>


• </body>


• </html>

Ⅹ Servlet Config 与Servlet context 的作用

servlet config对象可以使用一个或多个<init-param>标签为servlet配置一些初始化参数，servlet配置了初始化参数后，web容器在创建servlet实例对象时，会自动将这些初始化参数封装到ServletConfig对象中，并在调用servlet的init方法时，将ServletConfig对象传递给servlet。进而，程序员通过ServletConfig对象就可以得到当前servlet的初始化参数信息。
WEB容器在启动时，它会为每个WEB应用程序都创建一个对应的ServletContext对象，它代表当前web应用。

ServletConfig对象中维护了ServletContext对象的引用，开发人员在编写servlet时，可以通过ServletConfig.getServletContext方法获得ServletContext对象。