JSP 七讲

第 7 章 java servlet<b> </b>

<b>教学目的与要求：</b>通过本章的学习让学生了解如何用 servlet 读写文件，用 servlet 访问数据库；理解servlet 工作原理，servlet共享变量的使用；掌握编译和安装 servlet，通过 jsp 页面调用 servlet，httpservlet 类，掌握会话管理。

7.1 servlet 工作原理

7.2 编译和安装 servlet

7.3 通过 jsp 页面调用 servlet

7.4 servlet共享变量

7.5 httpservlet 类

7.6 用 servlet 读写文件

7.7 用 servlet 访问数据库

7.8 会话管理<b> </b>

<b>教学基本要求：</b>

了解：用 servlet 读写文件，用 servlet 访问数据库

理解：servlet 工作原理，servlet共享变量

掌握：编译和安装 servlet，通过 jsp 页面调用 servlet，httpservlet 类，会话管理<b> </b>

<b>教学重点教学难点：</b>

servlet 工作原理，编译和安装 servlet，通过 jsp 页面调用 servlet，httpservlet 类，会话管理

<b>教学手段：</b>多媒体教学和计算机程序演示<b> </b>

<b>教学小结：</b><b> </b><b>（见教学进程）</b>

<b>作业与思考：</b>见课后习题<b> </b>

<b></b>

<b>第7章 java servlet</b>

我们已经知道，sun公司以java servlet为基础，推出了java server page。jsp提供了java servlet的几乎所有好处，当一个客户请求一个jsp页面时，jsp引擎根据jsp页面生成一个java文件，即一个servlet。这一章，将对servlet做一个较详细的介绍，这不仅对于深刻理解jsp有一定的帮助，而且通过学习servlet，还能使我们选择使用jsp+javabeans+servlet的模式来开发我们的web应用程序。

我们已经知道，用jsp支持javabeans这一特点，可以有效的管理页面的静态部分和页面的动态部分。另外，我们也可以在一个jsp页面中调用一个servlet完成动态数据的处理，而让jsp页面本身处理静态的信息。因此，开发一个web应用有两种模式可以选择：

(1) jsp+javabeans

(2) jsp+javabeans+servlet

<b>7.1 servlet</b><b>工作原理</b>

servlet由支持servlet的服务器：servlet引擎，负责管理运行。当多个客户请求一个servlet时，引擎为每个客户启动一个线程而不是启动一个进程，这些线程由servlet引擎服务器来管理，与传统的cgi为每个客户启动一个进程相比较，效率要高的多。

<b>7.1.1</b><b> servlet </b><b>的生命周期</b>

学习过java 语言的人对java applet(java小应用程序)都很熟悉，一个java applet是java.applet.applet类的子类，该子类的对象由客户端的浏览器负责初始化和运行。servlet的运行机制和applet类似，只不过它运行在服务器端。一个servlet是javax.servlet包中httpservlet类的子类，由支持servlet的服务器完成该子类的对象，即servlet的初始化。

servlet的生命周期主要有下列三个过程组成：

(1)初始化servlet。servlet第一次被请求加载时，服务器初始化这个servlet，即创建一个servlet对象，这对象调用init方法完成必要的初始化工作。

(2)诞生的servlet对象再调用service方法响应客户的请求。

(3)当服务器关闭时，调用destroy方法，消灭servlet对象。

init方法只被调用一次，即在servlet第一次被请求加载时调用该方法。当后续的客户请求servlet服务时，web服务将启动一个新的线程，在该线程中，servlet调用service方法响应客户的请求，也就是说，每个客户的每次请求都导致service方法被调用执行。

该方法是httpservlet类中的方法，我们可以在servlet中重写这个方法。

方法描述：

public void init(servletconfig config) throws servletexception

servlet第一次被请求加载时，服务器初始化一个servlet，即创建一个servlet对象，这个对象调用init方法完成必要的初始化工作。该方法在执行时，servlet引擎会把一个sevletconfig类型的对象传递给init()方法，这个对象就被保存在servlet对象中，直到servlet对象被消灭，这个servletconfig对象负责向servlet传递服务设置信息，如果传递失败就会发生serveletexception，servlet就不能正常工作。

我们已经知道，当多个客户请求一个servlet时，引擎为每个客户启动一个线程，那么servlet类的成员变量被所有的线程共享。

<b>7.1.3</b><b> service</b><b>方法</b><b> </b>

该方法是httpservlet类中的方法，我们可以在servlet中直接继承该方法或重写这个方法。

public void service(httpservletrequest request httpservletresponse response) throw

servletexception,ioexception

当servlet成功创建和初始化之后，servlet就调用service方法来处理用户的请求并返回响应。servlet引擎将两个参数传递给该方法，一个httpservletrequest类型的对象，该对象封装了用户的请求信息，此对象调用相应的方法可以获取封装的信息，即使用这个对象可以获取用户提交的信息。另外一个参数对象是httpservletresponse类型的对象，该对象用来响应用户的请求。和init方法不同的是，init方法只被调用一次，而service方法可能被多次的调用，我们已经知道，当后续的客户请求servlet服务时，servlet引擎将启动一个新的线程，在该线程中，servlet调用service方法响应客户的请求，也就是说，每个客户的每次请求都导致service方法被调用执行，调用过程运行在不同的线程中，互不干扰。

<b>7.1.4</b><b> destroy</b><b>方法</b>

该方法是httpservlet类中的方法。servlet可直接继承这个方法，一般不需要重写。

public destroy()

当servlet引擎终止服务时，比如关闭服务器等，destroy()方法会被执行，消灭servlet对象。

<b>7.2 </b><b>编译和安装servlet</b>

<b>7.2.1</b><b> </b><b>简单的servlet例子</b>

在下面的例子1中，hello扩展了httpservlet。

servlet源文件

hello.java：

import java.io.*;

import javax.servlet.*;

import javax.servlet.http.*;

public class hello extends httpservlet

{ public void init(servletconfig config) throws servletexception

{super.init(config);

}

public void service(httpservletrequest reqest,httpservletresponse response) throws ioexception

{ //获得一个向客户发送数据的输出流：

printwriter out=response.getwriter();

response.setcontenttype("text/html;charset=gb2312");//设置响应的mime类型。

out.println("<html> <body>");

out.println("simple servlet");

out.println("</body> </html>");

}

<b>7.2.2</b><b> </b><b>编译servlet</b>

为了编译servlet源文件，需要httpservlet、httpservletrequest等类，jdk内置包中并不包含这些类文件。为了能编译servlet源文件得到创建servlet用的字节码文件，需要在环境变量中包含<b>servlet.jar</b>，这个jar文件在tomcat安装目录的common\lib文件下，如图7.1所示（也可以到sun公司网站下载编译servlet所需要的类）。

对于window2000，用鼠标右键点击“我的电脑”，弹出菜单，然后选择属性，弹出“系统特性”对话筐，再单击该对话框中的高级选项，然后点击按钮“环境变量”，编辑classpath，添加新的环境变量的值：

d:\tomcat\jakarta-tomcat-4.0\common\lib\servlet.jar;

我们将上述servlet的源文件hello.java保存到f:\2000，然后编译生成字节码文件hello.class

<b>7.2.3 </b><b>存放servlet的目录</b>

（1）所有web服务目录可使用的servlet的存放位置

如果让所有web服务目录都可以使用该servlet，那么创建这个servlet的字节码文件需存放在tomcat安装目录的classes目录中，例如，本书所用机器的目录就是：d:tomcat\jakarta-tomcat-4.0\classes，如图7.1所示。

我们已经知道，servlet第一次被请求加载时，服务器初始化一个servlet，即创建一个servlet对象，这对象调用init方法完成必要的初始化工作。如果你对servlet的源文件进行了修改，并将新的字节码文件存放到classes中，如果服务器没有关闭的话，新的servlet不会被创建，因为，当后续客户请求servlet服务时，已初始化的servlet将调用service方法响应客户。

(2）只对examples服务目录可用的seclet的存放目录

examples是tomcat引擎的默认web服务目录之一。

如果想让某个servlet只对examples目录可用，那么创建该servlet的字节码文件只需存放在webapps/example/web-inf/classes目录中。

存放在该目录中的servlet和存放在上面（1）中所述目录中的servlet有所不同，服务器引擎首先检查webapps/example/web-inf/classes目录中的创建该servlet的字节码文件是否被修改过，如果重新修改过，就会用消灭servlet，用新的字节码重新初始化servlet。

如果经常调试servlet，可以把servlet放在webapps/example/web-inf/classes。需要注意的是，当用户请求servlet服务时，由于服务器引擎每次都要检查字节码文件是否被修改过，导致服务器的运行效率降低。

<b>7.2.4 </b><b>运行servlet</b>

如果一个servlet对所有的web服务目录可用，那么只要在服务器引擎启动后，在浏览器地址栏键入：

http://localhost:8080/web服务目录/servlet/创建servlet类的名字

即可，例如，对于用上述hello创建的servlet，

(1) root 服务目录

http://localhost:8080/servlet/hello

(2) friend目录（我们自定义的一个web服务目录）

http://localhost:8080/friend/servlet/hello

如果是只对examples服务目录可用的servelt，那么只要在服务器引擎启动后，在浏览器地址栏键入：

http://localhost:8080/examples/servlet/创建servlet类的名字

我们将hello.class文件保存到tomcat引擎的classes文件夹中。图7.2和7.3是在不同的web目录下运行servlet的效果。

<b>7.2.5 </b><b>带包名的servle</b><b>t</b>

在写一个servlet的java文件时，可以使用package语句给servlet一个包名。包名可以是一个合法的标识符，也可以是若干个标识符加“.”分割而成，如：

package gping;

package tom.jiafei;

程序如果使用了包语句，例如

那么在classes目录下需有如下的子目录，例如，在d:\tomcat\jakarta-tomcat-4.0\classes下再建立如下的目录结构。

\tom\jiafei

并将servlet的字节码文件存在该目录中，如图7.4所示。

如果servlet有包名，比如，hello的包名是tom.jiafei，那么调用该servlet的url是：

http://localhost:8080/web服务目录/servlet/tom.jiafei.hello

因为起了包名，hello的全名是tom.jiafei.hello（就好比大连的全名是：中国.辽宁.大连）。

<b>7.3 </b><b>通过jsp页面调用servlet</b>

<b>7.3.1</b><b> </b><b>通过表单向servlet提交数据</b>

任何一个web服务目录下的jsp页面都可以通过表单或超链接访问某个servlet。通过jsp页面访问servlet的好处是，jsp页面可以负责页面的静态信息处理，动态信息处理交给servlet去完成。

在下面的例子中，jsp页面通过表单向servlet提交一个正实数，servlet负责计算这个数的平方根返回给客户。

为了方便地调试servlet，本书中，servlet的字节码文件存放在d:\tomcat\jakarta-tomcat-4.0\webapps\example\web-inf\classes中，那么在jsp页面中调用servlet时，servlet的url是：

/examples/servlet/servletname

在下面的例子2中，jsp页面通过表单提交一个正数，servlet负责计算这个数的平方根。

调用servlet的页面(该页面存放在web服务的根目录root中)

givenumber.jsp(效果如图7.5所示)

<%@ page contenttype="text/html;charset=gb2312" %>

<html>

<p>输入一个数，servlet求这个数的平方根：

</form>

</body>

</html>

servlet源文件(效果如图7.6所示)

sqrt.java

public class sqrt extends httpservlet

{ public void init(servletconfig config) throws servletexception

public void service(httpservletrequest request,httpservletresponse response) throws ioexception

string number=request.getparameter("number"); //获取客户提交的信息。

double n=0;

try{ n=double.parsedouble(number);

out.print("<br>"+math.sqrt(n));

}

catch(numberformatexception e)

{ out.print("<h1>input number letter please! </h1>");

}

<b>7.3.2 </b><b>通过超链接访问servlet</b>

我们可以在jsp页面中，点击一个超链接，访问servlet。

例子3

connection.jsp:

<a href="/servlet/hello" >加载servlet<a>

<b>7.4 servlet</b><b>的共享变量</b>

我们已经知道，在servlet被加载之后，当后续的客户请求servlet服务时，引擎将启动一个新的线程，在该线程中，servlet调用service方法响应客户的请求，而且servlet类中定义的成员变量，被所有的客户线程共享。在下面的例子4中，利用共享变量实现了一个计数器。

<b>例子4</b>(效果如图7.7所示)

count.java：

public class count extends httpservlet

{ int count;

public void init(servletconfig config) throws servletexception

count=0;

public synchronized void service(httpservletrequest request,httpservletresponse response)

throws ioexception

response.setcontenttype("text/html;charset=gb2312");//设置响应的mime类型。

count++; //增加计数。

out.println("you are "+count+"th"+" people");

注:在处理多线程问题时，我们必须注意这样一个问题：当两个或多个线程同时访问同一个变量，并且一个线程需要修改这个变量。我们应对这样的问题作出处理，否则可能发生混乱.所以上述例子中的service方法是一个synchronized方法。

数学上有一个计算π的公式：

π/4=1-1/3+1/5-1/7+1/9-1/11… …

下面的例子中利用成员变量被所有客户共享这一特性实现客户帮助计算的值，即每当客户请求访问servlet时都参与了一次的计算。

客户通过点击一个jsp页面的超链接访问一个计算的servlet

<b>例子5</b>(效果如图7.8所示)

jsp页面

example7_5.jsp：

<a href="examples/servlet/computerpi" >查看pi的值<a>

public class computerpi extends httpservlet

{ double sum=0,i=1,j=1;

int number=0;

public synchronized void service(httpservletrequest request,httpservletresponse response)

throws ioexception

response.setcontenttype("text/plain");//设置响应的mime类型为纯文本。

number++;

sum=sum+i/j;

j=j+2;

i=-i;

out.println("you are "+number+"th people coming to here");

out.println("now pi= "+4*sum);

<b>7.5 httpservlet </b><b>类</b>

<b>7.5.1</b><b> doget</b><b>方法和dopost方法</b>

httpservlet除了init、service、destroy方法外，该类还有两个很重要的方法：doget和dopost，用来处理客户的请求并作出响应。

当服务器引擎第一次接受到一个servlet请求时，会使用init方法初始化一个servlet，以后每当服务器再接受到一个servlet请求时，就会产生一个新线程，并在这个线程中调用service方法检查http请求类型（get 、post等），并在service方法中根据用户的请求方式，对应地再调用doget或dopost方法。因此，在servlet类中，我们不必重写service方法来响应客户，直接继承service方法即可。我们可以在servlet类中重写dopost或doget方法来响应用户的请求，这样可以增加响应的灵活性，并降低服务器的负担。

如果不论用户请求类型是post还是get，服务器的处理过程完全相同，那么我们可以只在dopost方法中编写处理过程，而在doget方法中再调用dopost方法即可，或只在doget方法中编写处理过程，而在dopost方法中再调用doget方法（见例子6）。

如果根据请求的类型进行不同的处理，就需在两个方法中编写不同的处理过程（见例子7）。

在下面的例子6中，用户可以通过两个表单向servlet提交一个正数，其中一个表单的提交方式是post，另一个表单的方式是get。无论用户用那种方式，服务器的servlet都计算这个数的全部因数，返回给用户。而在下面的例子7中，如果使用post方式提交正数，servlet计算这个数的全部因数，如果使用get方式，servlet求出小于这个数的全部素数。

例子6(效果如图7.9所示)

提交正数的jsp页面

example7_6.jsp：

<p>输入一个数，提交给servlet(post方式)：

<p>输入一个数，提交给servlet(get方式)：

sevlet源文件

computerfacor.java：

public class computerfactor extends httpservlet

{

public void dopost(httpservletrequest request,httpservletresponse response)

throws servletexception,ioexception

{ //获得一个向客户发送数据的输出流：

out.println("<html>");

out.println("<body>");

string number=request.getparameter("number"); //获取客户提交的信息。

out.println("<h1> factors of "+n+" :</h1>");

//求n的全部因数：

for(int i=1;i<=n;i++)

{ if(n%i==0)

out.println(i);

}

public void doget(httpservletrequest request,httpservletresponse response)

{

dopost(request,response);

<b>例子7</b>(效果如图7.10所示)

example7_7.jsp：

computerfacorandprimnumber.java：

public class computerfactorandprimnumber extends httpservlet

throws servletexception,ioexception

{ printwriter out=response.getwriter();

out.println("<h1> primnumbers less "+n+" :</h1>");

//求小于n的全部素数：

int j=1;

for(int i=1;i<n;i++)

{ for(j=2;j<i;j++)

{if(i%j==0)

break;

}

if(j>=i)

{ out.println(i);

<b>7.5.2 </b><b>处理http请求头及表单信息</b>

有关http请求头的和表单的介绍，可参见第3章。

在下面的例子8中，servlet显示请求的http头的值和表单提交的信息（可参考对比第3章例子4）。

提交信息的jsp页面

example7_8.jsp：

</form>

</font>

处理http请求头的sevlet源文件

getmessages.java：

import java.util.*;

public class getmessages extends httpservlet

// 客户使用的协议是:

out.println("<br>protocol:");

string protocol=request.getprotocol();

out.println(protocol);

//获取接受客户提交信息的servlet：

out.println("<br>accept servlet:");

string path=request.getservletpath();

out.println(path);

//客户提交的信息的长度:

out.println("<br>message length:");

int length=request.getcontentlength();

out.println(length);

// 客户提交信息的方式：

out.print("<br> method:");

string method=request.getmethod();

out.println(method);

//获取http头文件中user-agent的值：

out.println("<br> user-agent:");

string header1=request.getheader("user-agent");

out.println(header1);

//获取http头文件中accept的值：

out.println("<br> accept:");

string header2=request.getheader("accept");

out.println(header2);

// 获取http头文件中host的值：

out.println("<br> host:");

string header3=request.getheader("host");

out.println(header3);

//获取http头文件中accept-encoding的值:

out.println("<br> accept-encoding:");

string header4=request.getheader("accept-encoding");

out.println(header4);

//获取客户的ip地址：

out.println("<br> client ip:");

string ip=request.getremoteaddr();

out.println(ip);

// 获取客户机的名称：

out.println("<br> client name:");

string clientname=request.getremotehost();

out.println(clientname);

// 获取服务器的名称：

out.println("<br> server name:");

string servername=request.getservername();

out.println(servername);

// 获取服务器的端口号：

out.println("<br> serverport:");

int serverport=request.getserverport();

out.println(serverport);

//获取客户端提交的所有参数的名字：

out.println("<br>parameter names");

enumeration enum=request.getparameternames();

while(enum.hasmoreelements())

{string s=(string)enum.nextelement();

out.println(s);

}

// 文本框text提交的信息:

out.println("<br> text:");

string str=request.getparameter("boy");

out.println(str);

out.println("</body>");

out.println("</html>");

dopost(request,response);

下面的例子9用servlet实现用户注册。用户通过一个jsp页面提交姓名和email地址实现注册。当servlet获取这些信息后，首先检查散列表对象中是否已经存在这个名字，该散列表存储了已经注册的用户的名字。如果目前准备注册的用户提交的名字在散列表中已经存在，就提示客户更换名字，否则将检查客户是否提供了书写正确的email地址，如果提供了书写正确email地址将允许注册（仅仅要求email地址中不允许出现空格）。

<b>例子9</b>(效果如图7.11所示)

提交注册名字的jsp页面

example7_9.jsp：

<p>输入你的姓名:

<br>

<p>输入你的e-mail地址:

<p>点击送出按钮：

<br>

</form>

</font>

loginbyservlet.java：

public class loginbyservlet extends httpservlet

{ hashtable hashtable=new hashtable();

public synchronized void dopost(httpservletrequest request,httpservletresponse response)

response.setcontenttype("text/html;charset=gb2312");outputstream();

response.setcontenttype("text/html");//设置响应的mime类型。

//获取用户提交的名字：

string person_name=request.getparameter("name"),

name_found=null;

if(person_name==null)

{person_name="";

}

//在散列表查找是否已存在该名字：

name_found=(string)hashtable.get(person_name);

if(name_found==null)

{ string person_email=request.getparameter("address");

if(person_email==null)

{person_email="";

}

stringtokenizer fenxi=new stringtokenizer(person_email," @");

int n=fenxi.counttokens();

if(n>=3)

{out.print("<br>"+"there are exists illegal letters in your email");

else

{ hashtable.put(person_name,person_name);

out.print("<br>"+"login success!");

out.print("<br>"+"your name is "+person_name);

}

else

{out.print("<br>"+"this name has exist ");

public synchronized void doget(httpservletrequest request,httpservletresponse response)

<b>7.5.3 </b><b>设置响应的http头</b>

有关响应的http头介绍，可参见第3章。

在下面的例子10中，servlet设置响应头：refresh的头值是2，那么该servlet在2秒钟后自动刷新，即servlet在2秒钟后重新调用service方法响应用户。

<b>例子10</b>(效果如图7.12所示)

调用servlet的jsp页面

example7_10：

dateservlet.java：

public class dateservlet extends httpservlet

public void dopost(httpservletrequest request,httpservletresponse response)

response.setheader("refresh","2"); //设置refresh的值。

out.println("now time:");

out.println("<br>"+new date());

下面例子11实现servlet的重定向，客户访问servlet：day；如果访问的时间是在22点之后，就被重定向到servlet：night，提醒用户休息。day和night被存放在examples/web-inf/classes中。

<b>例子11</b>(效果如图7.13所示)

day.java：

public class day extends httpservlet

calendar calendar=calendar.getinstance(); //创建一个日历对象。

calendar.settime(new date());//用当前时间初始化日历时间。

int hour=calendar.get(calendar.hour_of_day),

minute=calendar.get(calendar.minute),

second=calendar.get(calendar.second);

if(hour>=22)

{response.sendredirect("night"); //重定向。

{ out.print("now time :");

out.print(hour+":"+minute+":"+second);

out.println("</body>");

out.println("</html>");

public void doget(httpservletrequest request,httpservletresponse response)

night.java：

public class night extends httpservlet

out.println("<h1> it is time to sleep");

<b>7.6 </b><b>用servlet读写文件</b>

这节内容涉及到的文件操作及输入、输出流的内容可参见第4章。

<b>7.6.1 </b><b>读取文件的内容</b>

在下面的例子12中，通过一个jsp页面显示给用户一些jsp文件的名字，该jsp文件存放在root服务目录下。用户可以通过post或get方式将文件的名字提交给一个servlet，该servelt存放在服务目录examples下的web-inf/classes中。这个servlet将根据提交方式的不同，分别读取jsp文件的源代码给客户，或显示该jsp文件的运行效果给客户。

<b>例子12</b>(效果如图7.14、7.15、7.16所示)

提交文件名字的jsp页面

read.jsp:

<%@ page import ="java.io.*" %>

<%! class filejsp implements filenamefilter

{ string str=null;

filejsp(string s)

{str="."+s;

}

public boolean accept(file dir,string name)

{ return name.endswith(str);

}

<p>下面列出了服务器上的一些jsp文件

<% file dir=new file("d:/tomcat/jakarta-tomcat-4.0/webapps/root/");

filejsp file_jsp=new filejsp("jsp");

string file_name[]=dir.list(file_jsp);

for(int i=0;i<5;i++)

{out.print("<br>"+file_name[i]);

<br>输入文件的名字读取jsp文件的源代码内容：

<br>输入文件的名字显示该jsp文件的运行效果：

读取文件的servlet源文件

readfileservlet:

public class readfileservlet extends httpservlet

//dopost方法使用了回压流来读取jsp文件的源代码：

{ //获取提交的文件的名字：

string name=request.getparameter("name");

//获得一个向客户发送数据的输出流：

file f=new file("d:/tomcat/jakarta-tomcat-4.0/webapps/root",name);

try{ filereader in=new filereader(f) ;

pushbackreader push=new pushbackreader(in);

int c;

char b[]=new char[1];

while ( (c=push.read(b,0,1))!=-1)//读取1个字符放入字符数组b。

{ string s=new string(b);

if(s.equals("<")) //回压的条件

{ push.unread('&');

push.read(b,0,1); //push读出被回压的字符字节,放入数组b.

out.print(new string(b));

push.unread('l');

push.unread('t');

else if(s.equals(">")) //回压的条件

{ push.unread('&');

push.unread('g');

out.print(new string(b));

}

else if(s.equals("\n"))

{ out.print("<br>");

}

else

{out.print(new string(b));

push.close();

}

catch(ioexception e){}

//doget方法将显示jsp源文件运行的效果

{ string name=request.getparameter("name");

bufferedreader bufferin=new bufferedreader(in);

string str=null;

while((str=bufferin.readline())!=null)

{out.print("<br>"+str);

bufferin.close();

in.close();

在这节，我们通过一个servlet实现小说内容的续写来说明servlet在写文件中的技巧。

在下面的例子13中，通过一个jsp页面显示给用户一个小说文件的已有内容，小说文件存放在服务器的f:/2000下，文件名字是story.txt。jsp文件存放在root服务目录下。用户可以通过post方式将小说的新内容提交给一个servlet，该servelt存放在服务目录examples下的web-inf/classes中。这个servlet将用户提交的内容写入小说文件的尾部。

<b>例子13</b>(效果如图7.17所示)

提交小说内容的jsp页面

story.jsp:

<body>

<h4>小说已有内容：</h4>

<% file f=new file("f:/2000","story.txt");

//列出小说的内容：

try{ randomaccessfile file=

new randomaccessfile(f,"r");

string temp=null;

while((temp=file.readutf())!=null)

{ byte d[]=temp.getbytes("iso-8859-1");

temp=new string(d);

out.print("<br>"+temp);

file.close();

catch(ioexception e){}

<p>请输入续写的新内容：

</textarea>

<br>

</form>

续写文件的servlet源文件：

write.java:

public class write extends httpservlet

{ //声明一个共享的文件和共享字符串：

file f=null;

string use="yes" ;

{ //获取提交的文件内容：

string content=request.getparameter("content");

f=new file("f:/2000","story.txt");

//把对文件的操作放入一个同步块中，并通知

//其它用户该文件正在被操作中：

if(use.startswith("yes"))

{ synchronized(f)

{ use="using";

try{

randomaccessfile file=new randomaccessfile(f,"rw");

file.seek(file.length()); //定位到文件的末尾。

file.writeutf(content);

file.close();

use="yes";

out.print("<br>"+"contents have been write to file");

catch(ioexception e){}

}

//如果该小说正在被续写，就通知客户等待：

else

{out.print("file is writing,wait please");

}

{

<b>7.7 </b><b>用servlet访问数据库</b>

有关数据库连接的一些知识可参见第5章。本节通过例子说明servlet在数据库方面的应用。我们仍然使用第5章的数据源sun ，该数据源为server服务器上的pubs数据库，该库有一个表：students。

<b>7.7.1 </b><b>数据库记录查询</b>

在下面的例子14中，客户通过condition.jsp页面输入查询条件，例如，查询某个姓名的成绩、查询成绩在某个分数段范围内的学生成绩等等。用户通过post方式提交姓名给servlet；分数区间通过get方式提交给servlet。该servlet根据不同的提交方式采取相应的查询方法。

<b>例子14</b>(效果如图7.18所示)

提交查询条件的jsp页面

condition.jsp:

<p>成绩查询

<p>输入姓名:

<p>根据分数查询名单:<br>

英语分数在

和

之间

<br> 数学分数在

之间 <br>

负责查询的servlet源文件：

inquire.java:

import java.sql.*;

public class inquire extends httpservlet

//通过post方法按名字查询记录：

{ printwriter out=response.getwriter();

response.setcontenttype("text/html;charset=gb2312");//设置响应的mime类型。

out.println("<html>");

out.println("<body>");

//获取提交的姓名：

string name=request.getparameter("name");

string number,xingming;

connection con=null;

statement sql=null;

resultset rs=null;

int math,english,physics;

try{class.forname("sun.jdbc.odbc.jdbcodbcdriver");

catch(classnotfoundexception e){}

try

{ con=drivermanager.getconnection("jdbc:odbc:sun","sa","");

sql=con.createstatement();

string condition="select * from students where 姓名 = "+"'"+name+"'";

rs=sql.executequery(condition);

out.print("<table border>");

out.print("<tr>");

out.print("<th width=100>"+"number");

out.print("<th width=100>"+"name");

out.print("<th width=50>"+"math");

out.print("<th width=50>"+"english");

out.print("<th width=50>"+"phsics");

out.print("</tr>");

while(rs.next())

{ out.print("<tr>");

number=rs.getstring(1);

out.print("<td >"+number+"</td>");

xingming=rs.getstring(2);

out.print("<td >"+xingming+"</td>");

math=rs.getint("数学成绩");

out.print("<td >"+math+"</td>");

english=rs.getint("英语成绩");

out.print("<td >"+english+"</td>");

physics=rs.getint("物理成绩");

out.print("<td >"+physics+"</td>");

out.print("</tr>") ;

}

out.print("</table>");

con.close();

catch(sqlexception e)

{

}

//通过get方法按成绩查询记录：

//获取提交的分数的最大值和最小值：

string englishmax=request.getparameter("englishmax");

string englishmin=request.getparameter("englishmin");

string mathmax=request.getparameter("mathmax");

string mathmin=request.getparameter("mathmin");

string econdition="英语成绩 <= "+englishmax+" and "+"英语成绩 >= "+englishmin;

string mcondition="数学成绩 <= "+mathmax+" and "+"数学成绩 >= "+mathmin;

string condition="select * from students where "+mcondition+" and "+econdition;

out.print("<table border>");

{ out.print("<tr>");

out.print("<td >"+math+"</td>");

out.print("</tr>") ;

{

out.println("</body>");

out.println("</html>");

<b>7.7.2 </b><b>使用共享连接</b>

数据库操作中，建立连接是耗时最大的操作之一。如果客户访问的是同一数据库，那么，为每个客户都建立一个连接是不合理的。我们已经知道，servlet的成员变量是被所有用户共享的。这样，我们可以把connection对象作为一个成员变量被所有的客户共享，也就是说第一个访问数据库的客户负责建立连接，以后所有的客户共享这个连接，每个客户都不要关闭这个共享的连接。下面的servlet使用共享连接查询数据库的所有记录。

使用共享连接的servlet源文件

shareinquire.java:

public class shareinquire extends httpservlet

{ connection con=null; //共享连接。

//加载jdbc-odbc桥接器：

if(con==null)

{ try

{ //第一个用户负责建立连接con。

con=drivermanager.getconnection("jdbc:odbc:sun","sa","");

string condition="select * from students";

rs=sql.executequery(condition);

out.print("</tr>");

{ out.print("<tr>");

out.print("<td >"+rs.getstring(1)+"</td>");

out.print("<td >"+rs.getstring(2)+"</td>");

out.print("<td >"+rs.getint("数学成绩")+"</td>");

out.print("<td >"+rs.getint("英语成绩")+"</td>");

out.print("<td >"+rs.getint("物理成绩")+"</td>");

out.print("</tr>") ;

out.print("</table>");

}

catch(sqlexception e)

{

//其它客户通过同步块使用这个连接：

else

{ synchronized(con)

{try{ sql=con.createstatement();

string condition="select * from students";

rs=sql.executequery(condition);

out.print("<table border>");

out.print("<tr>");

out.print("<th width=100>"+"number");

out.print("<th width=100>"+"name");

out.print("<th width=50>"+"math");

out.print("<th width=50>"+"english");

out.print("<th width=50>"+"phsics");

out.print("</tr>");

while(rs.next())

{ out.print("<tr>");

out.print("<td >"+rs.getstring(1)+"</td>");

out.print("<td >"+rs.getstring(2)+"</td>");

out.print("<td >"+rs.getint("数学成绩")+"</td>");

out.print("<td >"+rs.getint("英语成绩")+"</td>");

out.print("<td >"+rs.getint("物理成绩")+"</td>");

out.print("</tr>") ;

out.print("</table>");

catch(sqlexception e)

out.println("</body>");

out.println("</html>");

}

throws servletexception,ioexception

{ dopost(request,response);

<b>7.8.1</b><b> </b><b>获取用户的会话</b>

我们已经知道，http协议是一种无状态协议。一个客户向服务器发出请求（request）然后服务器返回响应（respons），连接就被关闭了。在服务器端不保留连接的有关信息，因此当下一次连接时，服务器已没有以前的连接信息了，无法判断这一次连接和以前的连接是否属于同一客户。因此，必须使用客户的会话，记录有关连接的信息。

一个servlet使用httpservletrequest 对象request调用getsession方法获取用户的会话对象：

httpsession session=request.getsession(true);

一个用户在不同的servlet中获取的session对象是完全相同的，不同的用户的session对象互不相同。有关会话对象常用方法可参见第4章。

在下面的例子16中，有两个servlet，boy和girl。客户访问boy时，将一个字符串对象，存入自己的会话中，然后访问girl，在girl中再输出自己的session对象中的字符串对象。

例子16(效果如图7.19所示)

boy.java：

public class boy extends httpservlet

httpsession session=request.getsession(true); //获取客户的会话对象

session.setattribute("name","zhoumin");

out.println(session.getid()); //获取会话的id.

out.println("</body>");

{ dopost(request,response);

girl.java：

public class girl extends httpservlet

httpsession session=request.getsession(true); //获取客户的会话对象

string s=(string)session.getattribute("name"); //获取会话中存储的数据。

out.print("<br>"+s);

throws servletexception,ioexception

用户通过一个jsp页面：choice.jsp选择商品，提交给servlet：addcar，该servlet负责将商品添加到用户的session对象中（相当于用户的一个购物车），并将session对象中的商品显示给用户。用户可以不断地从choice.jsp页面提交商品给addcar。用户通过remove.jsp页面选择要从购物车中删除的商品提交给servlet：removegoods，该servlet负责从用户的购物车（用户的session对象）删除商品。

<b>例子17</b>(效果如图7.20、7.21所示)

负责选择商品的jsp页面

choice.jsp:

<%@ page import="java.util.*" %>

<%@ page import="car1" %>

<p>这里是第一百货商场，选择您要购买的商品添加到购物车：

<option value="tv">电视机

<option value="apple">苹果

<option value="coke">可口可乐

<option value="milk">牛奶

<option value="tea">茶叶

</select>

<p>输入购买的数量:

<p>选择计量单位：

<input type="radio" name="unit" value="个">个

<input type="radio" name="unit" value="公斤">公斤

<input type="radio" name="unit" value="台">台

<input type="radio" name="unit" value="瓶">瓶

负责添加商品的servlet

addcar.java:

public class addcar extends httpservlet

public void init(servletconfig config) throws servletexception

string item =request.getparameter("item"), //获取客户选择的商品名称。

mount=request.getparameter("mount"), //获取客户购买的数量。

unit =request.getparameter("unit"); //获取商品的计量单位。

//将客户的购买信息存入客户的session对象中。

string str="name: "+item+" mount:"+mount+" unit:"+unit;

session.setattribute(item,str);

//将购物车中的商品显示给客户：

out.println(" goods in your car: ");

enumeration enum=session.getattributenames();

{ string name=(string)enum.nextelement();

out.print("<br>"+(string)session.getattribute(name));

选择删除商品的jsp页面

remove.jsp：

<p>选择要从购物车中删除的商品：

负责删除商品的servlet

removegoods.java

public class removegoods extends httpservlet

{public void init(servletconfig config) throws servletexception

public void dopost(httpservletrequest request,httpservletresponse response)

string item =request.getparameter("item"); //获取要删除的商品名称。

session.removeattribute(item); //删除商品。

//将购物车中的商品显示给客户：

out.println("<h3>now goods in your car:</h3> ");

public void doget(httpservletrequest request,httpservletresponse response)

在第3章、第6章讲述jsp内置对象以及javabeans时，曾分别举过猜数字的例子。在这里，我们再使用servlet来实现猜数字这个小游戏，这样，我们就用3种方式实现了这个小游戏：直接由jsp页面来实现、通过javabeans来实现、通过servlet来实现。

当客户访问servlet：getnumber时，随机分配给客户一个1到100之间的数，然后将这个数字存在客户的session对象中。客户在表单里输入一个数，来猜测分配给自己的那个数字。客户输入一个数字后，提交给servlet：result，该servlet负责判断这个数是否和客户的session对象中存放的那个数字相同，如果相同就连接到servlet：success；如果不相同就连接到servlet： large或small。然后，客户在这些servlet中重新提交数字到result。

getnumber.java：

public class getnumber extends httpservlet

{ response.setcontenttype("text/html");

servletoutputstream out=response.getoutputstream();

out.print("a number between 1 and 100 to you,guess it out please! ");

httpsession session=request.getsession(true);

session.setattribute("count",new integer(0));

int number=(int)(math.random()*100)+1; //获取一个随机数。

session.setattribute("save",new integer(number));

out.print("<form action=result method=post name=form>");

out.print("<input type=text name=boy >");

out.print("<input type=submit value=enter>");

out.print("</form>");

result.java：

public class result extends httpservlet

{ public void init(servletconfig config) throws servletexception

string str=request.getparameter("boy");

if(str==null)

{str="0";

int guessnumber=integer.parseint(str);

integer integer=(integer)session.getattribute("save");

int realnumber=integer.intvalue();

if(guessnumber==realnumber)

{ int n=((integer)session.getattribute("count")).intvalue();

n=n+1;

session.setattribute("count",new integer(n));

response.sendredirect("success");

else if(guessnumber>realnumber)

response.sendredirect("larger");

else if(guessnumber<realnumber)

response.sendredirect("smaller");

larger.java：

public class larger extends httpservlet

out.print("larger ,try again!"); //所猜的数比实际的数大，请再猜。

out.print("<br><form action=result method=post name=form>");

smaller.java

public class smaller extends httpservlet

out.print("smaller ,try again!"); //所猜的数比实际的数小，请再猜。

success.java

public class success extends httpservlet

int count=((integer)session.getattribute("count")).intvalue();

int num=((integer)session.getattribute("save")).intvalue();

long starttime=session.getcreationtime();

long endtime=session.getlastaccessedtime();

long spendtime=(endtime-starttime)/1000;

out.println("congratulatuon! you are right");

out.println("afer just"+count+"tries") ;

out.println("you spend"+spendtime+"seconds");

out.println("that number is"+num);

JSP 七讲

继续阅读

Java String.format方法的简单使用

neo4j之cypher使用文档

GitHub连夜封杀！这份阿里 10W 字内部 Java 字面试手册到底有多强？

spark/scala关于【资源文件】加载方法概述外部文件加载方案测试资源文件打包入jar包中小结

NOSQL安全攻击

mybatis_入门程序Mybatis入门

AOP编程_Android优雅权限框架(1)概念基础，2021金三银四前言正文大纲正文

登录plsql 报错 the account is locked --用户被锁

sqlServer根据经纬查距离

Effective Java 8:通用程序设计

SequoiaDB巨杉数据库C++驱动概述

OOM三种类型

工厂模式-三种类型

【递归】高效率求2的n次幂

win10本地scala和spark安装安装scala安装spark

scala (3) Function 和 Method