web开发的背景知识(了解)
(1)主机/终端
特点：主机负责所有的业务运算和数据的管理，终端只提供操作界面。
优点：可靠
缺点：昂贵，维护困难
(1)二层的c/s：
特点：使用数据库当服务器(数据库不仅要保存数据，还需要编写大量的业务处理逻辑，客户端
负责界面及部分的业务处理逻辑)。
优点：开发方便
缺点：可移值性差(比如，要换数据库，就需要重新写一次业务处理逻辑，因为数据库的编程语
言是不一样的)。
另外，要求客户端跟数据库之间保持一个数据库连接，所以，不适合开发大型的应用(数
据库能够提供的数据库连接的个数是有限制的)。
(2)三层的c/s: 客户端/服务器端程序
特点：数据库只负责管理数据，所有的业务逻辑写在应用服务器里面，客户端负责界面。
优点：可移植性好,适合开发大型应用
缺点：客户端需要单独安装，开发相对比较复杂(需要开发通讯处理模块，需要自定义协议)。
(3) b/s：
特点： 数据库只负责管理数据，所有的业务逻辑写在web服务器里面,客户端使用标准的浏览器。
其实，b/s架构从本质上讲，是一种标准化的c/s：即使用标准化的通讯协议(http协议),标
准化的客户端程序(浏览器)，标准化的服务器(比如tomcat)。
优点：客户端不再需要安装，另外，开发相对简化(通讯模块不再需要开发了，也不再需要自定
义协议)。
2、什么是Servlet?
sun公司制订的一种用于扩展web服务器功能的组件规范。
（1）扩展web服务器功能:
1）早期的web服务器(比如，apache ws,iis)只能够处理静态资源(即需要事先将html文件写好)的
请求,不能够处理动态资源(需要依据用户的请求进行计算然后生成对应的html)的请求。
2）早期，可以使用cgi程序来扩展web服务器： cgi程序可以使用很多语言来开发，比如perl,c
等等都可以，但是，cgi程序有几个问题(比如，开发复杂，可移植差，性能不是特别好，因
为会启动过多的cgi进程)。
3）servlet也可以扩展web服务器(即动态生成页面)功能:
方案一：浏览器发请求给web服务器(比如,apache ws,iis,这些web服务器本身是不能够处理静
态资源的请求的),web服务器判断是否需要计算，如果需要，会调用servlet容器,servlet
容器再去调用servlet处理请求。
方案二 浏览器直接发请求给servlet容器(比如tomcat,jetty),因为servlet容器除了可以运行
servlet之外，同时，也可以充当简单的web服务器。
（2）组件规范
1）组件:
符合一定规范，实现部分功能的，并且可以部署在相应的容器里面运行的程序模块。
servlet就是一个组件，我们在写servlet时，不需要考虑网络编程相关的问题，这些问题都由servlet
容器（比如：tomcat）去解决。
2）容器:
符合一定规范，为组件提供运行环境和相应的基础服务(比如网络服务)的程序。并且管理组件
的生命周期程序。
servlet容器（比如，tomcat或者jboss）会提供servlet的运行环境。
3、如何开发一个servlet?
step1、写一个java类(servlet只能够使用java语言来开发),该类需要实现Servlet接口或者继承
HttpServlet抽象类。
step2、编译
step3、打包
appname(应用名)
WEB-INF
classes(.class文件)
lib(可选, .jar文件)
web.xml(部署描述文件)
step4、部署
将step3创建的整个文件夹拷贝到servlet容器特定的文件夹（webapps）下面。或者也可以
将整个文件夹先使用jar命令压缩成.war文件然后再拷贝。
step5、访问
启动servlet容器(web服务器),在浏览器地址栏输入http://ip:port/appname/servlet-url其中，
servlet-url参见web.xml。
4、tomcat的安装和简单的使用
windows环境：
step1、将tomcat解压到D:/ 路径：D:apache-tomcat-5.5.23
step2、配置环境变量
（1）JAVA_HOME（JDK的主目录） 必须配置
（2）tomcat的主目录 可以不配置
（3）tomcat的bin目录 可以不配置
1）“我的电脑”右击“属性”，打开“系统属性”的“高级”选项卡，找到“环境变量”
2）新建系统变量，或用户变量
变量名为：JAVA_HOME 变量值为：JDK目录
step3、启动 tomcat服务器
进入启动tomcat的bin目录下，双击“startup.bat”（windows系统）
关闭tomcat服务器
双击stutdown.sh
linux环境：
step1、找到tomcat的压缩文件(比如/opt/apache-tomcat5.5.23.tar.gz),然后解压到/home/soft01。
(也可以去www.apache.org去下载tomcat)
step2、配置环境变量(大家现在可以不用配置)
cd /home/soft01
vi .bash_profile
在该文件当中，添加
JAVA_HOME: JDK的安装路径，比如/opt/java6.0
CATALINA_HOME: tomat的安装路径,比如 /home/soft01/apache-tomcat5.5.23
PATH: /home/soft01/apache-tomcat5.5.23/bin
step3、启动tomcat
cd /home/soft01/apache-tomcat5.5.23/bin
sh startup.sh (或者 sh catalina.sh run)
接下来，打开浏览器，输入:http://localhost:8080
step4,关闭tomcat
cd /home/soft01/apache-tomcat5.5.23/bin
sh shutdown.sh
tomcat的几个主要文件夹的作用
1)bin: 是一些可执行文件(比如，启动和关闭tomcat)
2)common: 放置可以被部署到该服务器上面的所有的程序都可以访问的jar文件。
3)conf:服务器的配置文件。
4)webapps:tomcat的部署文件夹。
5、Servlet是如何运行的？
比如，从浏览器地址栏输入http://ip:port/firstweb/sayHello
（1） 浏览器依据ip，port建立与servlet容器之间的连接。
（2） 浏览器将请求资源路径("/firstweb/sayHello") 及相关的参数打包(按照http协议)发送给容器。
（3） 容器拆包，解析请求数据包，将解析之后的结果数据存放到一个request对象里面，同时还会
创建一个response对象。
（4） 容器依据请求资源路径找到Servlet的配置，然后创建对应的Servlet对象(这儿，会创建
HelloServlet对象)。
（5） 容器调用Servlet对象的service方法(会将step3创建好的request,response对象作为参数传递进
来),可以在该方法里面，通过访问request对象的相应方法来获取参数值，也可以将处理结果写
到response对象里。正因为有这样两个对象，Servlet不用考虑网络相关的问题(比如获取请求
参数，就不用拆包，同样，将结果输出给浏览器，也不需要打包)。
（6） servlet容器从response对象里面取出处理结果，然后打包，发送给浏览器。
（7） 浏览器拆包，解析响应数据包，取出数据，生成相应的界面。
6、使用eclipse开发Servlet程序
HelloServlet.java
public class HelloServlet extends HttpServlet{
/* 覆盖(override)HttpServlet的service方法。
* 服务器在创建好servlet对象之后，会调用该方法来处理请求。
*/
public void service(HttpServletRequest request,
HttpServletResponse response) throws ServletException,IOException{
System.out.println("service方法正在执行...");
//1 读取请求参数 String name = request.getParameter("name");
//2 处理请求 String rs = "<h1>" + "hello " + name + "</h1>";
//3 生成响应
1)生成一个消息头content-type,告诉 浏览器，返回的数据类型。
response.setContentType("text/html;charset=utf-8");
2)获得一个输出流
PrintWriter out = response.getWriter();
3)向流中输出数据，其实质是，将处理结果存放 到response对象上。
out.println(rs);
4)关闭流*
out.close(); }
web.xml
<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.4"
xmlns="http://java.sun.com/xml/ns/j2ee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">
<servlet>
<servlet-name>helloServlet</servlet-name>
<!--servlet-class:一定要将类的完整的名称写出来 -->
<servlet-class>web.HelloServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>helloServlet</servlet-name>
<url-pattern>/sayHello</url-pattern>
</servlet-mapping>
</web-app>
7、常见错误及及解决方式
(1)404
a,错误的原因:请求资源路径写错。
b,解决方式:检查请求资源路径。 http://ip:port/appname/servlet-url
(2)500
a,错误的原因：系统出错(程序出错或者是程序所运行的环境，比如数据库、网络等出现问题)。
b,解决方式: 检查代码(包括配置文件)，检查运行环境。
(3)405
a,错误的原因: 找不到service方法
b,解决方式：检查方法的签名
8、http协议（了解）
(1)什么是http协议(超文本传输控制协议)?
由w3c定义的一种应用层协议，用来定义浏览器与web服务器之间通讯的过程及数据的格式。
1)、浏览器与服务器之间通讯的过程:
step1、浏览器建立与服务器之间的连接
step2、浏览器打包(按照http协议的要求)，发送请求
step3、服务器处理完请求，将数据打包，发送响应
step4、服务器关闭连接
特点： 一次请求，一次连接。
优点：效率非常高，服务器可以尽可能的为更多的客户端（浏览器）服务。
2)、数据的格式
a、请求数据包
请求行
请求方式 请求资源路径协议的类型和版本
若干消息头
消息头是一些键值对，通信的双方都可以发送。比如，浏览器可以发送user-agent消息头告
诉服务器浏览器的类型和版本。
一般来说，一般由浏览器或者服务器自动生成，表示特定的含义。有些时候，需要编程生
成一些消息头。
实体内容
如果发送get请求，实体内容为空。
只有发送post请求时，实体内容才会有数据（即请求参数值，比如nam=tom），如果是get请
求，请求参数会添加到请求资源路径的后面。
b、响应数据包
状态行
协议的类型和版本 状态码 状态描述
状态码是一个3位数字，由w3c定义的，表示服务器处理请求的一种状态，比如:
404:依据请求资源路径，找不到对应的资源
500:系统出错
200:正常
若干消息头
比如，服务器可以向浏览器发送一个content-type的消息头，告诉浏览器返回的数据类型以
及编码格式。浏览器按照消息头的内容打开返回的数据。
response.setContentType(“text/html”); 返回的是一个html页面，编码格式是ISO-8859-1
response.setContentType(“text/html;charset=utf8”);返回的是一个html页面，编码格式是utf-8
实体内容
程序处理的结果
9、get请求与post请求
(1)哪一些情况下，浏览器发送get请求
a、直接在浏览器地址栏输入某个地址
b、点击链接
c、表单默认提交
(2)哪一些情况下，浏览器发送post请求
a、表单设置了method="post"。
(3)get请求的特点
a、会将请求参数添加到请求资源路径的后面，因为请求行最多只能存放大约2K左右的数据，所
以适合提交少量的数据给服务器。优点就是提交小数据时方便
b、请求参数会显示在浏览器地址栏,不安全(比如，路由器会记录这个地址)。
(4)post请求的特点
a、会将请求参数添加到实体内容里面，能够提供大量的数据给服务器。
b、请求参数不会显示在浏览器地址栏，相对安全。
要注意的是post方式并不会对请求参数加密（这里不安全）。
比如：姓名、密码需要加密的，需要使用HTTPS协议。 （需要服务器端进行配置）
HTTPS协议是由SSL+HTTP协议构建的可进行加密传输、身份认证的网络协议要比http协议安全。
10、web编程中的编码问题
1）常识：
a、java语言会将所有字符以unicode编码格式保存在内存里面。
b、编码：将以unicode编码格式对应的字节数组转换成某种本地编码格式(gbk,gb2312,utf-8)对应
的字节数组。
c、解码：将某种本地编码格式对应的字节数组转换成unicode编码格式对应的字节数组。
//encode方法先进行编码，然后将得到字节数组转换成一个字符串。
String str = URLEncoder.encode("过儿","utf-8"); 以utf-8格式编码
System.out.println(str);
String str2 = URLDecoder.decode(str,"utf-8"); 以utf-8格式解码
System.out.println(str2);
2）servlet如何输出中文?
（1）产生乱码问题的原因?
a、out.println(中文):（编码）
默认采用iso-8859-1编码格式进行编码,iso-8859-1，这个编码是不支持中文的。
b、服务器默认情况下，会发送一个content-type消息头，该消息头指定的编码是iso-8859-1，
浏览器会使用该编码格式打开页面。（解码）
（2）解决方式
response.setContentType("text/html;charset=支持中文的某种编码");
该方法有两个作用：
作用1：编码
out.println时，使用正确的编码格式进行编码(unicode -- >utf-8)。
作用2：解码
生成一个消息头content-type，该消息头会指定一个编码，让浏览器以该编码来打开页面。
11、表单处理
（1）如何获得表单的参数值?
a、String request.getParameter(String paraName);
注意：
1）如果paraName与实际传递的参数名称不一致，会返回null。
2）在文本输入框中，如果不输入，会获得空字符串""，需要注意对""的处理。
b、String[] request.getParameterValues(String paraName);
注意：如果有多个请求参数名称相同，使用个方法。
比如: city=bj&city=wh&city=hz，应该request.getParameterValues("city");
或者
<form action="/web01/first" method="post">
interst:cooking<input type="checkbox" value="cooking" name="interst"/>
finshing<input type="checkbox" value="fishing" name="interst"/>
<input type="submit" value="提交"/>
</form>
服务器端：采用 request.getParameterValues("interstate");获得用户的选择
（2）表单中如果有中文参数，如何处理？
a、乱码问题产生的原因
浏览器会对表单中的中文参数按照打开该表单时编码格式来编码
比如，浏览器按照utf-8打开页面，则使用utf-8对该表单的中文参数进行编码。服务器端，
默认使用iso-8859-1去解码。
b、解决方式:
step1 在html文件当中，
使用<meta http-equiv="content-type"content="text/html;charset=支持中文的编码">,让浏
览器以规定的编码打开页面
表单要采用post提交方式。
step2 服务器端使用指定的编码格式去解码。request.setCharacterEncoding(指定的编码);
注意：只对post请求有效
12、中文参数传递乱码问题？
自从Tomcat5.x开始，GET和POST方法提交的信息，Tomcat采用了不同的方式来处理编码
1）对于POST请求，Tomcat会仍然使用request.setCharacterEncoding方法所设置的编码来处理，如果
未设置，则使用默认的iso-8859-1编码。
2）而GET请求则不同，Tomcat对GET请求并不会考虑使用request.setCharacterEncoding方法设置的编
码，而会永远使用iso-8859-1编码，因此，tomcat将会使用iso-8859-1将提交的字节转换成字符串。
方法一：（只适合post请求）
1）<meta http-equiv="content-type"content="text/html;charset=支持中文的编码">
2）request.setCharacterEncoding(支持中文的编码)
方法二：（get/post都适用）
new String(str.getBytes(“iso-8859-1”),”支持中文的编码”);
方法三：（get/post都适用）
1）在传参数之前先把参数进行转码
java.net.URLEncoder.encode(param);
<a href="ds.jsp?url=
<%=java.net.URLEncoder.encode("编码的是这里","GB2312")%>"
点击这里
</a>
2）取值时再转回中文
java.net.URLDecoder.decode(param);
方法四：（只有get适用）
在你的Tomcat目录-->conf目录-->server.xml里找出这段:
<Connector port="8080" maxThreads="150"
minSpareThreads="25"
maxSpareThreads="75"
enableLookups="false" redirectPort="8443"
acceptCount="100"
debug="0" connectionTimeout="20000"
disableUploadTimeout="true"
<!--在里边加上这个参数-->
URIEncoding="utf-8"
/>
通知tomcat对于get请求中的参数不再使用iso-8859-1解码，而是使用utf-8进行
注意url地址后如果有参数并且参数是中文，就只能用二三四方法
13、重定向
1）什么是重定向?
服务器向浏览器发送一个状态码302及一个location消息头（值是一个地址，称之为重定向地址），
浏览器收到后，会立即向 location所指向的地址发送请求。
2）如何重定向
response.sendRedirect(String url); 其中,url是重定向的地址。
3）编程要注意的问题
a、重定向之前，不能够有out.close()或者out.flush()操作。（否则会报错）
有out.close或者out.flus时，请求经处理后要把处理结果打包响应给浏览器。
而response.sendRect也是对浏览器请求的响应，这样就造成了一次请求两次响应，不符合规范.
b、重定向之前，如果response对象缓存有数据，则这些数据会被清空。
重定向后，只发送一个重定向地址，不会发送实体内容。所以response对象会清空。
response对象里装的是返回给浏览器的实体内容。
4）重定向的特点
重定向的地址是任意的
重定向之后，浏览器地址栏的地址变成了location所指定的地址
14、将中文数据插入到数据库
将数据插入数据库的过程是编码：内存中的编码是unicode。
插入数据库的过程数据从unicode编码再变成数据库的编码进行入库。
从数据库中取出数据是解码。
step1 要保证数据库正确地设置了字符集，即字符集必须支持中文
step2 要保证jdbc驱动程序正确地进行了编码和解码。
jdbc:mysql://localhost:3306/jd1206db?useUnicode=true&characterEncoding=utf8
告诉jdbc驱动程序当前数据库的字符集。
因为某些版本的驱动程序不能够正确地获知数据库的字符集设置。
15、DAO
DAO，封装了数据访问逻辑，调用者不需要了解底层的数据访问细节就可以实现数据访问。
这样一来，当底层的数据访问细节发生改变，不会影响到调用者。
如何写一个DAO？
（1）实体类：为了方便处理数据库中的记录，可以定义与记录对应的实体类，即可以将数据库中的
某条记录转换成一个实体类的实例。
比如Employee类，提供id，name，salary，age属性及相关的get/set方法，我们可以将t_emp
表中的记录转化成一个Employee对象。
（2）DAO接口：
在DAO接口当中，声明对某个表的所有操作相关的方法。
基本原则： 接口中声明的方法不要涉及任何具体的实现。
比如：EmployeeDAO接口，
声明了： public void save(Employee e) throws SQLException;
这种方式不好,因为出现了jdbc的异常类，这就要求实现该方法只能使用jdbc。
换一种方式来声明，更好
public void save(Employee e) throws Exception;
public List<Employee> findAll() throws Exception;
（3）DAO实现类
采用具体的技术实现DAO接口
比如：使用jdbc实现EmployeeDAO接口，写一个类EmployeeDAOIdbcImpl。
（4）DAO工厂（工厂模式）
什么是设计模式：是为了解决一类相似的问题提出的解决方案。
工厂设计模式：工厂将对象的创建过程对外屏蔽，为调用者提供符合接口要求的对象(产品)。
比如：Connection conn = DriverManager.get...
16、处理请求资源路径
比如输入： http://ip:port/appname/abc.html
servlet处理请求资源路径的步骤：
step1、依据/appname查找该应用对应的文件夹（比如查找webapps下面的文件夹是否与其匹配）
step2、在找到的文件夹下面，找到web.xml文件，然后使用<url-pattern>与/abc.html匹配。
匹配规则：
精确匹配：即要求<url-pattern>与/abc.html完全一致
通配符匹配：使用“*”代表任意的字符串
比如在<url-pattern>中使用/*表示任意字符串，/abc/*表示有abc的字符串
后缀匹配：不能使用“/”开头，要求“*.任意的字符串”。
比如：*.do要求以.do为结尾 *.action要求以.action
step3、如果都不匹配，尝试查找/abc.html静态页面，如果找到，则返回该文件，找不到，则返回
404状态
17、Servlet处理多种请求
一个servlet如何处理多种请求？
step1、使用后缀匹配模式。<url-pattern>*.do</url-pattern>
step2、在service()方法里加入代码：
获得请求资源路径：String url=request.getRequestURI();
分析请求资源路径，来决定做何种处理
//几种地址的比较 request的方法
ServletPath:/image.jsp
RequestURI:/elec_qin/image.jsp
ContextPath:/elec_qin
RequestURL:http://localhost:8080/elec_qin/image.jsp
18、servlet生命周期相关核心接口与类
Servlet的框架是由两个Java包组成的：javax.servlet与javax.servlet.http。
在javax.servlet包中定义了所有的Servlet类都必须实现或者扩展的通用接口和类。
在javax.servlet.http包中定义了采用Http协议通信的HttpServlet类。
Servlet的框架的核心是javax.servlet.Servlet接口，所有的Servlet都必须实现这个接口。
（1）Servlet接口
在Servlet接口中定义了5个方法，
void init(ServletConfig config): 初始化
void service(ServletRequest req,ServletResponse res):
void destory():
ServletConfig getServletCnifg();
String getServletInfo();
Servlet接口依赖于ServletRequest，ServletResponse，ServletConfig接口
（2）ServletConfig接口
用来访问初始化参数。
当容器读取web.xml配置文件中<servlet>配置节信息，根据<servlet-class>配置节信息创建servlet
对象，同时根据<init-param>配置节信息创建ServletConfig对象。然后调用init方法，把创建好的
ServletConfig对象传给servlet对象。注意是servlet容器实现了ServletConfig接口。
ServletConfig对象封装了初始化参数。定义了如下的方法：
public abstract String getServletName();
public abstract ServletContext getServletContext();
public abstract String getInitParameter(String s);
public abstract Enumeration getInitParameterNames();
（2）GenericServlet抽象类
GenericServlet实现了Servlet和ServletConfig接口。拥有了两个接口的所有方法。
实现servlet接口中的部分方法，主要是实现了init,destroy方法。
GenericServlet类的主要结构
1）有一个属性：private ServletConfig config;
2）getServletCnifg()方法，获得容器创建好的Servletconfig对象
public ServletConfig getServletConfig(){
return this.config;
}
容器调用init方法时，将容器创建好的ServletConfig对象赋值给属性config。
再通过调用getServletConfig方法得到ServletConfig对象。
3）init方法()的实现
public void init(ServletConfig config)throw ServletException{
this.config=config;//把对象的引用通过属性保存下来
this.init();
}
//钩子方法，存在的意义就是被覆盖。当servlet要求有复杂的初始化步骤时，覆盖此方法
public void init()throws ServletException(){
//什么都没有做
}
4）service方法没有实现，由子类实现
public abstract void service(ServletRequest servletrequest, ServletResponse servletresponse)
5）实现类destroy方法
public void destroy(){ }
6）也实现了ServletConfig接口的getServletName，getServletContext，getInitParameter，
getInitParameterNames。
实现原理是在这些方法中调用了容器创建好的ServletConfig（属性config）中相应的方法
（3）HttpServlet抽象类
继承了GenericServlet，主要实现了service方法
定义doGet()，doPost()，doHead()，doPut()，doDelete()，doOptions()方法。
根据请求方式来调用相应的doXXX方法。
实现了GenericServlet的service方法。
service方法的主要逻辑是根据请求来调用相应的doXXX方法。
（4）ServletRequest与ServletResponse接口
（5）HttpServletRequest与HttpServletResponse接口
HttpServletRequest接口继承ServletRequest接口
HttpServletResponse接口继承ServletResponse接口
这些接口由servlet容器实现，在请求到达时创建request对象和response对象传入到service方法中。
（6）整个过程
1、Web客户向Servlet容器（Tomcat）发出Http请求
2、Servlet容器分析客户的请求信息
3、Servlet容器创建一个HttpRequest对象，将客户请求的信息封装到这个对象中
4、Servlet容器创建一个HttpResponse对象
5、Servlet容器调用HttpServlet对象的service方法，
把HttpRequest对象与HttpResponse对象作为参数传给 HttpServlet对象
6、HttpServlet调用HttpRequest对象的有关方法，获取Http请求信息
7、HttpServlet调用HttpResponse对象的有关方法，生成响应数据
8、Servlet容器把HttpServlet的响应结果传给Web客户
19、servlet的生命周期
所谓生命周期，指的是servlet容器如何创建servlet对象、如何初始化、如何调用servlet对象的方法来
处理请求以及如何销毁servlet对象的整个过程。
（1）实例化（就是创建servlet对象,调用构造器）
a、什么是实例化？
容器调用servlet的构造器，创建一个servlet对象。（new一个对象）
b、什么时候实例化？
1）当请求到达容器时，容器查找该servlet对象是否存在，如果不存在，才会创建实例。
2）容器在启动时，或者新部署了某个应用时，会检查web.xml当中，servlet是否有
load-on-starup配置。如果有，则会创建该servlet实例。
load-on-starup参数要求是一个>=0的整数，值越小，优先级越高（先被实例化）。
注意：servlet容器在默认情况下，对于每个servlet，只会创建一个实例。（单例模式）
（2）初始化
a、什么是初始化？
servlet容器在创建好servlet对象之后，会立即调用该对象的init方法。
b、GenericServlet已经提供了init方法,一般情况下，我们不再需要写init方法了。
GenericServlet提供的init方法是这样实现的：
将容器提供的ServletConfig对象保存下来，并且提供了getServletConfig方法用来获得ServletConfig对象。
c、servlet的初始化参数
1）使用<init-param>来配置初始化参数
<init-param>
<param-name>company</param-name>
<param-value>北京</param-value
</init-param>
2）调用ServletConfig对象的getInitParameter方法获得参数值
d、如何实现自己的初始化方法？
建议override init()方法
e、init方法只会执行一次
（3）就绪/调用
a、什么是就绪？
servlet容器在收到请求之后，会调用servlet对象的service方法来处理请求。
b、HttpServlet的service方法是如何实现的？
依据请求方式(get/post)分别调用doGet/doPost方法。
可以覆盖HttpServlet提供的doGet/doPost方法，也可以直接覆盖HttpServlet提供的service方法
（4）销毁
a、什么是销毁?
servlet容器依据自身的算法，在不再需要servlet对象时，会调用该对象的destroy方法，
然后，再删除该对象。
Servlet容器停止或者重新启动：Servlet容器调用Servlet对象的destroy方法来释放资源。
b、GenericServlet已经实现了destroy方法。释放资源
c,、该方法只会执行一次。
在servlet的整个生命周期当中，init,destroy只会执行一次，而service方法会执行多次。
20、案例
（1）产品计价
发送请求：http://localhost:8088/web04_2/pricing.html
pricing.html
<body style="font-size:30px;font-style:italic;">
<form action="pricing" method="post">
<fieldset>
<legend>产品计价</legend>
原始价格:<input name="basePrice"/><br/>
出售城市:<select name="city" style="150px;">
<option value="bj">北京</option>
<option value="sh">上海</option>
<option value="cs">长沙</option>
</select><br/>
<input type="submit" value="确定"/>
</fieldset>
</form>
</body>
点击按钮发送请求：http://localhost:8088/web04_2/pricing
配置文件web.xml
<servlet>
<servlet-name>pricingServlet</servlet-name>
<servlet-class>web.PricingServlet</servlet-class>
<init-param>
<param-name>taxRate</param-name>
<param-value>bj,0.08;sh,0.09;cs,0.03</param-value>
</init-param>
</servlet>
<servlet-mapping>
<servlet-name>pricingServlet</servlet-name>
<url-pattern>/pricing</url-pattern>
</servlet-mapping>
类PricingServlet.java
public class PricingServlet extends HttpServlet{
private HashMap<String,Double> taxRates =
new HashMap<String,Double>();
public void service(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
response.setContentType("text/html;charset=utf-8");
PrintWriter out = response.getWriter();
double basePrice = Double.parseDouble(request.getParameter("basePrice"));
String city = request.getParameter("city");
double taxRate = taxRates.get(city);
double price = basePrice * ( 1 + taxRate);
out.println("实际售价:" + price);
}
public void init() throws ServletException {
System.out.println("init...初始化，从配置文件中读取各个城市的利率");
ServletConfig config = getServletConfig();
//bj,0.08;sh,0.09;cs,0.03
String taxRate = config.getInitParameter("taxRate");
String[] strs = taxRate.split(";");
for(int i=0;i<strs.length;i++){
String str = strs[i]; //bj,0.08
String[] str1 = str.split(",");
taxRates.put(str1[0], Double.parseDouble(str1[1]));
}
}
（2）servlet生命周期
<servlet>
<servlet-name>some</servlet-name>
<servlet-class>web.SomeServlet</servlet-class>
<!-- 初始化参数 -->
<init-param>
<param-name>company</param-name>
<param-value>工商银行</param-value>
</init-param>
<init-param>
<param-name>address</param-name>
<param-value>北京上地</param-value>
</init-param>
<!-- 启动就加载 参数值越小，优先级越高 -->
<load-on-startup>1</load-on-startup>
</servlet>
public class SomeServlet extends HttpServlet{
public SomeServlet(){
System.out.println("SomeServlet's constructor...");
}
public void init() throws ServletException {
System.out.println("SomeServlet's init...");
}
public void service(HttpServletRequest request, HttpServletResponse response)
throws ServletException,IOException{
System.out.println("SomeServlet's doGet...");���ServletConfig����
ServletConfig config = getServletConfig();
String company = config.getInitParameter("company");
System.out.println("company:" + company);
}
public void destroy() {
System.out.println("SomeServlet's destroy...");
}