3.表单数据验证
      表单验证是ActionForm的主要功能之一，要实现这个功能，我们需要采取4个步骤：
      ·重写validate()方法。
      ·在资源文件ApplicationResources.properties中设置可能的验证错误的标识。
      ·要在配置文件struts-config.xml中，把<action>元素的validate属性设置为true，并添加<message-resources>元素以指明资源文件的存放路径。
      ·在相应输入页面的相应位置加如错误标记<html:errors>，以输出可能的验证错误。
      (1)重写validate()方法
      对该form bean的validatet()方法进行重写。ActionErrors类封装了一组验证错误，它的用法类似Map类。而ActionMessage类封装了单个验证错误，它的构造函数内的参数就指向资源文件内的一个错误文本。例如语句“ActionMessage("login.password.error");”中的参数"login.password.error"其实就是资源文件ApplicationResources.properties中的一条错误文本的键(key)。通过ActionErrors对象的add()方法，可以把ActionMessage对象加入到ActionErrors对象中。
      (2)设置资源文件
      在Struts的资源文件ApplicationResources.properties中设置可能的验证错误的标识：
#用户名错误
error.username.required=<li>Please input your username again!</li>
#密码错误
error.password.required=<li>Please input your password again!</li>
      (3)修改配置文件struts-config.xml
      将配置文件struts-config.xml中<action>元素的validate属性设定为true。此外，还需要增加<message-resource>元素，以指明资源文件的路径。
      (4)在输入页面中加入错误标记
      表单数据验证的目的是，一旦用户在输入页面表单中输入的数据不符合要求或出现错误，Struts验证机制将把验证错误在该输入页面相应的位置显示出来。
      <html:errors>是Struts的一个自定义标记。它能根据它的property属性从资源文件ApplicationResources.properties中取出相应的验证错误，并在输入页面中指定的位置显示验证错误。

                        HttpServletRequest request, HttpServletResponse response )
   {
          loginActionForm loginForm=(loginActionForm) actionForm;
            //从form bean中取出表单数据
          String username=loginForm.getUsername();
          String password=loginForm.getPassword();
            //生成一个Session对象
          HttpSession session=request.getSession(true);
          session.removeAttribute("username");
          session.setAttribute("username",username);
            //生成一个ArrayList对象，并把用户名和密码的值寸入该对象中
          ArrayList arr=new ArrayList();
          arr.add(username);
          arr.add(password);
          String prompt;
            //调用模型组件loginHandler，检查该用户是否已经注册
          loginHandler login=new loginHandler();
          boolean mark=login.checkLogin(arr);

          if(mark)  prompt="Success";
              else prompt="Fail";
            return actionMapping.findForward(prompt);
   }
}

1.<form-beans>元素(用于描述ActionForm对象)
      <form-beans>元素允许配置多个ActionForm类。它可包含零个或多个<form-bean>子元素。
      <form-bean>元素的主要属性如下：
      ·className：可选，指定和<form-bean>元素对应的配置类，默认值为org.apache.struts.config.FormBeanConfig，自定义的配置类必须扩展该类。
      ·name：指定该ActionForm的唯一标识，Struts框架用该标识来引用这个form bean，该属性必须指定。
      ·type：指定ActionForm的完整类路径和类名，该属性必须指定。
      如果配置了动态ActionForm(DynaActionForm)，则还必须配置<form-bean>元素的<form-property>子元素，用来指定表单字段。

2.<action-mappings>元素(用于描述Action对象)
      <action-mappings>元素帮助进行框架内部的流程控制，可将请求URI映射到Action类，将Action对象与ActionForm对象相关联。
      <action-mappings>元素内可以定义多个<action>子元素。<action>元素所描述的是特定的请求路径和一个相应Action类之间的映射关系。Struts控制器会将请求中的URI路径与诸多<action>元素中的path属性相匹配，以选出一个特定的映射。
      <action-mappings>元素的主要属性如下：
      ·attribute：设置和Action关联的forn bean在request/session内的属性key，通过request/session的getAttribute(attribute)方法返回该form bean的实例。
      ·name：指定同该Action关联的form bean的引用标识。
      ·type：指定该Action类的完整类路径和类名。
      ·validate：指定是否调用form bean的validate()方法验证表单的数据，默认为true。
      ·input：指定表单输出页面的URL路径，当表单验证失败时将请求转发到该URL。
      ·scope：指定同该Action类关联的forn bean的存在范围，可选request和session，默认为session。
      ·path：指定Action的访问路径，即该Action在引用中的标识名，以“/”开头。
      <action>元素中可包含零个或多个<forward>子元素，<forward>子元素定义了转发动作，它的主要属性如下所示：
      ·name：指定转向标识名。
      ·path：指定转向标识名所对应的转向页面。
      ·redirect：指定是转发还是重定向。

3.<global-forwardvs>元素
      <global-forwards>元素用来定义在整个应用程序内的全局转发，在该元素内可以定义多个<forward>子元素。例如：
      <global-forwards>
            <forward name="Success" path="/main.jsp"/>
            <forward name="Fail" path="/register.jsp"/>
      </global-forwards>

4.<message-resources>元素
      <message-resources>元素用于配置消息资源文件(Resource Bundle),以在应用的客户端界面中输出本地化消息文本。例如：
      <mesasge-resources key="application" parameter="ApplicationResources"/>
      该语句指定了一个叫ApplicationResources.properties的消息资源文件或属性文件。
      <message-resources>元素的属性如下：
      ·className：指定和<form-bean>元素对应的配置类,默认值为org.apache.struts.config.MessageResourcesConfig
      ·factory：指定消息资源的工厂类，默认为org.apache.struts.uitl.PropertyMessageResourcesFactory
      ·key：指定资源文件存放在ServletContext对象中时使用的属性key,默认值为Globals.MESSAGE_KEY定义的字符串常量。
      ·null：指定MessageResources对未知消息的处理方式，若为true将返回空字符串，若为false则返回类似“???global.label.missing???”的字符串，默认值为true。
      ·parameter：指定消息资源文件存放的路径。     

      Bean的属性相关联。
       ·<bean:message>：用于输出本地化的文本内容，它的key属性指定消息key，与消息key匹配的文本内容来自于专门的Resource Bundle。
       ·<bean:write>：用于输出JavaBean的属性值。例如，<bean:write name="personbean" property="userName"/>，它用于输出personbean对象的userName属性值。
       ·<logic:present>：用来判断JavaBean在特定的范围内是否存在，只有当JavaBean存在时，才会执行标签主体中的内容,例如：
       <logic"present name="personbean" scope="request">
       <h2>
          Hello <bean:write name="personbean" property="userName"/>!<p>
       </h2>
       </logic:present>
       <logic:present>标签用来判断在request范围内是否存在personBean对象，如果存在，就输出personBean的userName属性值。与<logic:present>标签相对的是<logic:notPresent>标签，它表示只有当JavaBean在特定的范围内部存在时，才会执行标签能主体中的内容。

2. 运用Struts框架 
     ·模型包括一个JavaBean组件PersonBean，它有一个userName属性，代表用户输入的名字。它提供了get/set方法，分别用于读取和设置userName属性，它还提供一个save()方法，负责把userName属性保存到持久化存储系统中，如数据库或文件系统。对于更为复杂的Web应用，JavaBean组件可以作为EJB或Web服务的前端组件。
    ·视图包括一个JSP文件hello.jsp，它提供用户界面，接受用户输入的姓名。视图还包括一个ActionForm Bean，它用来存放表单数据，并进行表单验证，如果用户没有输入姓名就提交表单，将返回出错信息。 
    ·控制器包括一个Action类HelloAction，它完成三项任务：1．进行业务逻辑验证，如果用户输入的姓名为"Monster", 将返回错误消息；2．调用模型组件PersonBean的save()方法，保存用户输入的名字；3．决定将合适的视图组件返回给用户。
     ·除了创建模型、视图和控制器组件，还需要创建Struts的配置文件struts-config.xml，它可以把这些组件组装起来，使它们协调工作。此外，还需要创建整个Web应用的配置文件web.xml。

3.创建视图组件
       本例中，视图包括两个组件：
                      ·一个JSP文件：hello.jsp
                      ·一个ActionForm Bean： HelloForm Bean (HelloForm.java)。
       其中，jsp中有代码<html:bean action="/HelloWorld" focus="userName">
      当用户提交了HTML表单后，Struts框架将自动把表单数据组装到ActionForm Bean中。ActionForm Bean中的属性和HTML表单中的字段一一对应。ActionForm Bean还提供了数据验证方法，以及把属性重新设置为默认值的方法。Struts框架中定义的ActionForm类是抽象的，必须在应用中创建它的子类，来存放具体的HTML表单数据。
       HelloForm.java中有两个特殊的方法：
    ·validate()：用于表单验证。
    ·reset()：把属性重新设置为默认值。
        本例中的资源文件是application.properties，用来存放数据信息。

4.创建控制器组件：HelloAction.java 
      控制器组件包括ActionServlet类和Action类。ActionServlet类是Struts框架自带的，它是整个Struts框架的控制枢纽，通常不需要扩展。Struts框架提供了可供扩展的Action类，它用来处理特定的HTTP请求。
 所有的Action类都是org.apache.struts.action.Action的子类，Action子类应该覆盖父类的execute()方法。
HelloAction.java的代码如下：

package hello;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.apache.struts.action.Action;
import org.apache.struts.action.ActionForm;
import org.apache.struts.action.ActionForward;
import org.apache.struts.action.ActionMapping;
import org.apache.struts.action.ActionMessage;
import org.apache.struts.action.ActionMessages;
import org.apache.struts.util.MessageResources;

import com.yourcompany.struts.PersonBean;
import com.yourcompany.struts.form.HelloForm;
/** 
 * @struts.action path="/hello" name="helloForm" input="/form/hello.jsp" scope="request" validate="true"
 */
public final class HelloAction extends Action {

 /**
  * Method execute
  * @param mapping:ActionMapping包含了这个Action的配置信息和Struts-config.xml文件中的<action>元素对应。
  * @param form:ActionForm包含了用户的表单数据，当Struts框架调用execute()方法时，ActionForm中的数据
  *已经通过了表单验证。
  * @param request:HttpServletRequest当前的HTTP请求对象
  * @param response:HttpServletResponse当前的HTTP响应对象
  * @return ActionForward
  */
 public ActionForward execute(
  ActionMapping mapping,
  ActionForm form,
  HttpServletRequest request,
  HttpServletResponse response) throws Exception{
    
  /* These "massage come from the ApplicationResources.properties file"
   * getResources(HttpServletRequest request)方法返回当前默认的MessageResource对象，它封装了Resource
   *Bundle 中的文本内容。  
   * 接下来Action类就可以通过MessageResource对象来访问文本内容。例如：如果要读取消息key   
   *为"hello.jsp.title"对应的文本内容,可以调用MessageResources类的getMessage(String key)方法:
   *String title=messages.getMessage("hello.jsp.title");
   * MessageResources messages=getResources(request);
   */
  /*
   * Validate the request parameters specified by the user
   * Note: Basic field validation done in  HelloForm.java
   * Business logic validation done in HelloAction.java
   * 如果用户输入的姓名为"Monster"，将创建包含错误信息的AcrionMessage对象，ActionMessage对象被保存
   *到ActionMessages对象中。接下来调用在Action基类中定义的saveErrors()方法，它负责把ActionMessages
   *对象保存到request范围内。最后返回ActionForward对象，Struts框架会根据ActionForward对象包含的转发
   *信息把请求转发到恰当的视图组件，视图组件通过<html:errors>标签把request范围内的ActionMessages对象
   *中包含的错误消息显示出来，提示用户修改错误。  
   * */
      ActionMessages errors=new ActionMessages();
      String userName=(String)((HelloForm) form).getUserName();
  
      String badUserName="Monster";
  
      if(userName.equalsIgnoreCase(badUserName))
      {      
    //equalsIgnoreCase方法同vequals，只不过equalsIgnoreCase 是忽略大小写。
       errors.add("username",new ActionMessage("hello.dont.talk.to.monster",badUserName));
       saveErrors(request,errors);
       return (new ActionForward(mapping.getInput()));
      }
  /*
   * HelloAction类创建了一个模型组件PersonBean对象，并调用它的saveToPersistentStore()方法来保存userName
   *属性。
   * from the View,we now update the model
   *
   * */
     PersonBean pb=new PersonBean();
     pb.setUserName(userName);
     pb.saveToPersistentStore();
  /*
   * 把PersonBean对象保存在request范围内内
   * 从request范围内删除ActionForm Bean。由于后续的请求转发目标组件不再需要HelloForm Bean，所以
   *可将它删除。当HelloAction类调用HttpServletRequest的setAttribute()方法，向hello.jsp传递PersonBean对象时，
   *需要提供一个名为“persinbean”的属性key:request..setAttribute("personbean",pb);
   * hello.jsp通过这个名为"personbean"的属性来读取PersonBean对象：
   * <login:present name="personbean" scope="request">
   * <h2>Hello <bean:write name="personbean" property="userName"/>!</h2>
   * </logic:persent>
   * 对于Struts应用，提倡将这些属性key常量定义在一个Java文件Constant.java中，例如本例。
   * */
     request.setAttribute(com.yourcompany.struts.Constants.PERSON_KEY,pb);
  
     request.removeAttribute(mapping.getAttribute());
  
     return (mapping.findForward("SayHello"));
    }
}

5.创建模型组件
      本例的模型组件是PersonBean.java，PersonBean是一个非常简单的JavaBean，它包括一个userName属性，以及相关的get/set方法。此外，它还有一个业务方法saveToPersistentStore()。

6. 创建存放常量的Java文件：Constant.java

7.创建配置文件web.xml和struts-config.xml

本例的运行流程为：

1.Servlet容器在web.xml文件中寻找<url-pattern>属性为"*.do"的<servlet-mapping>元素：
   <servlet-mapping>
   <servlet-name>action</servlet-name>
   <url-pattern>*.do</url-pattern>
   </servlet-mapping>

2.Servlet容器依据以上<servlet-mapping>元素的<servlet-name>属性"action"，在web.xml文件中寻找匹配的<servlet>元素：
   <servlet>
   <servlet-name>action</servlet-name>
   <servlet-class>org.apache.struts.action.ActionServlet</servlet-class>
   </servlet>

3.Servlet容器把请求转发给以上<servlet>元素指定的ActionServlet，ActionServlet依据用户请求路径"/HelloWorld"，在Struts配置文件中检索path属性为"/HelloWorld"的Action元素：
   <action
       path="/HelloWorld"      
       type="hello.HelloAction"
       name="HelloForm"
       attribute="inputForm"
       scope="request"
       validate="true"
       input="/hello.jsp"
      >
      <forward name="SayHello" path="/hello.jsp" />
   </action>

4.ActionServlet根据<action>元素的name属性，创建一个HelloForm对象，把客户提交的表单数据传给HelloForm对象，再把HelloForm对象保存在<action>元素的scope属性指定的request范围内。

5.由于<action>元素的validate属性为true，ActionServlet调用HelloForm对象的validate()方法执行表单验证。

      ·当文本框中不输入姓名的时候,vallidate()方法返回一个ActionErrors对象。
          ActionServlet把HelloForm的validate()方法返回的ActionErrors对象保存在request范围内,然后根据<action>元素的input属性,把客户请求转发给hello.jsp。

      ·当文本框中输入姓名"Monster"的时候,vallidate()方法返回ActionErrors对象中不包含任何ActionMessage对象,表示表单验证成功。
         ActionServlet查找HelloAction实例是否存在，如果不存在就创建一个实例，然后调用HelloAction的execute()方法。
          HelloAction的execute()方法先进行逻辑验证，由于没有通过逻辑验证，就创建一个ActionMessage对象，这个ActionMessage对象封装了错误消息，execute()方法把ActionMessage对象保存在ActionMessages对象中，再把ActionMessages对象存放在request范围内。最后返回一个ActionForward对象，该对象包含的请求转发路径为<action>元素的input属性指定的hello.jsp。

      ·当文本框中输入其他姓名的时候,vallidate()方法返回ActionErrors对象中不包含任何ActionMessage对象,表示表单验证成功。
          HelloAction的execute()方法进行逻辑验证，这次通过了验证，然后执行相关的业务逻辑，最后调用ActionMapping.findForward()方法，参数为“SayHello”:return (mapping.findForward("SayHello"));
          ActionMapping.findForward()方法从<action>元素中寻找name属性为“SayHello”的<forward>子元素，然后返回与之对应的ActionForward对象，它代表的请求转发路径为“/hello.jsp”。
          HelloAction的execute()方法把ActionForward对象返回给ActionServlet，ActionServlet再把客户请求转发给hello.jsp。
 hello.jsp的<bean:message>标签从Resource Bundle中读取文本，把它们输出到网页上，最后生成动态网页。
                     

        用JSP、Servlet及JavaBeans构建一个简单的登陆系统。该系统的要求是，当用户在登陆录页面上填写用户名和密码并提交之后，系统将检查该用户是否已经注册；如果该用户已经注册，系统将进入主页面，否则就进入注册页面。我们将按照以下步骤构建这个系统：

1.数据库设计：使用MS Access作为数据库，构建数据表T_UserInfo;

2.构建视图组件：登录页面login.jsp，主页面main.jsp，以及注册页面register.jsp；

3.构建控制层组件：一个Servlet,取名为loginServlet.java;

4.构建业务逻辑层组件（Model组件）：一个JavaBean，取名为loginHandler.java；

5.构建数据访问层组件：一个数据访问类，取名为dbPool,java;

6.编译、打包程序；

7.部署该程序到Web服务器Tomcat中，然后运行。

该系统的工作流程如图：

1.数据库设计

        用户登录是一个涉及数据库操作的用例。登录涉及的数据表名为test，结构如下：

      字段名：username              字段类型：nvarchar(50)        字段描述：用户名，主键

      字段名：password              字段类型：nvarchar(50)        字段描述：密码

2.构建视图组件

        本例有3个视图组件，分别是登录页面login.jsp，主页面main.jsp及注册页面register.jsp。它们之间的关系是，当用户在登录页面login.jsp填上用户名和密码后并提交后，系统将检查用户是否已经注册，如果该用户已经注册，系统将进入主页面main.jsp，否则就进入注册页面register.jsp。

        当用户按下login.jsp页面上的“登录”按钮后，系统就把请求传给一个叫做loginServlet的Servlet。以做进一步处理。

login.jsp:

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>  
  <body>
  <FORM name="form" action="loginservlet" method="get">
   <P>&nbsp;&nbsp; 用户名:
    <INPUT type="text" name="username" size="15">
   </P><P>  &nbsp;&nbsp; 密&nbsp; 码: <INPUT type="password" name="password" size="15">
   </P><P>
    &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<INPUT type="submit" name="submit" value="登录"></P><P>
   </P>
  </FORM>
 </body>
</html>
         当用户登录成功后，系统转入main.jsp，告诉用户已经登录成功，现已进入主页面。

main.jsp:

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
  <head>    
    <title>My JSP 'main.jsp' starting page</title>
    <meta http-equiv="pragma" content="no-cache">
    <meta http-equiv="cache-control" content="no-cache">
    <meta http-equiv="expires" content="0">
    <meta http-equiv="keywords" content="keyword1,keyword2,keyword3">
    <meta http-equiv="description" content="This is my page">
    </head> 
  <body>
    <h1>
    <%=session.getAttribute("username")%>，你成功登录，现已进入主页面！
    </h1>
  </body>
</html>

         当用户登录失败后，系统转入register.jsp，告诉用户登录失败，现已进入注册页面，请注册用户信息。

register.jsp:

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
  <head>
  <title>My JSP 'register.jsp' starting page</title>   
  </head> 
  <body>
  <H1>
    <%=session.getAttribute("username")%>，你未能成功登录，现进入注册页面，请注册你的信息！
  </H1>
  </body>
</html>

        本例的控制器组件是一个Servlet，叫做loginServlet，该组件先处理HTTP POST请求，然后调用模型组件或业务逻辑组件loginHandler检查该用户是否已注册，如果已注册，系统转入主页面main.jsp，否则进入注册页面register.jsp，要求用户注册自己的信息。另外，Servlet都要在web.xml中声明。

loginServlet.java:

package chap1;

import javax.servlet.*;
import javax.servlet.http.*;
import java.io.*;
import java.util.*;

public class LoginServlet extends HttpServlet{
 private static final long serialVersionUID = 2674925070582791853L;   
 //初始化Servlet
 public void init() throws ServletException{

 }
 //处理HTTP POST请求
 public void doPost(HttpServletRequest request,HttpServletResponse response)
  throws ServletException,IOException{
  //从请求中取出用户名和密码的值
  String username=request.getParameter("username");
  String password=request.getParameter("password");  
  //生成一个ArrayList对象，并把用户名和密码的值存入该对象中
  ArrayList arr=new ArrayList();
  arr.add(username);
  arr.add(password);
  //生成一个Session对象
  HttpSession session=request.getSession(true);
  session.removeAttribute("username");
  session.setAttribute("username",username);
  //调用模型组件loginHandler,检查该用户是否已注册
  LoginHandler login=new LoginHandler();
  boolean mark=login.checkLogin(arr); 
  //如果已经注册，进入主页面
  if(mark) response.sendRedirect("main.jsp");
  //如果未注册，进入注册页面
  else response.sendRedirect("register.jsp");
 }
 //处理HTTP GET请求
 public void doGet(HttpServletRequest request,HttpServletResponse response)
 throws ServletException,IOException{
  doPost(request,response);
 }
 //销毁Servlet
 public void destroy(){ 
 }
}

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>loginservlet</servlet-name>
<servlet-class>chap1.LoginServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>loginservlet</servlet-name>
<url-pattern>/loginservlet</url-pattern>
</servlet-mapping>
</web-app>

        本例的模型组件（或称为业务逻辑组件）是loginHandler，它先从数据访问组件dbPool取得数据库连接，然后检查数据库中是否已有该用户的记录，即检查还用户是否已经注册。如果已注册，返回true，否则返回false。

loginHandler.java:

package chap1;

import java.sql.*;
import java.util.*;

public class LoginHandler {
 
 public LoginHandler() { }
 
 Connection conn;
 PreparedStatement ps;
 ResultSet rs;
 //检查是否已注册
 public boolean checkLogin(ArrayList arr)
 {
  //从数据访问组件dbPool中取得连接
  try{ 
  conn=DbPool.getConnection(); 
  String name=(String)arr.get(0);
  String password=(String)arr.get(1);
  String sql="select * from test where username=? and password=?";
  ps=conn.prepareStatement(sql);
  ps.setString(1,name);
  ps.setString(2,password);   
  rs=ps.executeQuery();
  if(rs.next()){
   DbPool.dbClose(conn,ps,rs); //释放资源
   return true;   
   }
   else{
    DbPool.dbClose(conn,ps,rs);
    return false;    
   }
  }catch(SQLException e){
   System.out.print("SQLException"+e.getMessage());
   return false;
  }
 }
}
        本例的数据库访问组件是dbPool，dbPool从一个属性文件db.properties中获得数据库驱动程序，URL，用户名和密码，然后利用这些信息连接一数据库，取得连接。因为所用数据库是SQL Server，数据库驱动程序采用com.microsoft.jdbc.sqlserver.SQLServerDriver，数据库URL为jdbc:microsoft:sqlserver://localhost:1433;DatabaseName=test;本例需要把数据库驱动程序（3个jar包）放在lib目录下。

DbPool.java:

package chap1;
import java.io.*;
import java.util.*;
import java.sql.*;

public class DbPool {
 private static DbPool instance=null;
 //取得连接
 public static synchronized Connection getConnection(){  //多线程.
  if(instance == null){
   instance = new DbPool();
  }
  return instance._getConnection();
 }
 private DbPool()
 {
  super();
 }
 private Connection _getConnection(){
  try{
   String sDBDriver=null;
   String sConnection=null;
   String sUser=null;
   String sPassword=null;
   
   Properties p=new Properties();
   InputStream is=getClass().getResourceAsStream("/db.properties");
   p.load(is);
   sDBDriver=p.getProperty("DBDriver",sDBDriver);
   sConnection=p.getProperty("Connection",sConnection);
   sUser=p.getProperty("User",sUser);
   sPassword=p.getProperty("Password",sPassword);
   
   Properties pr=new Properties();
   pr.put("user",sUser);
   pr.put("password",sPassword);
   pr.put("characterEncoding","GB2312");
   pr.put("userUnicode","TRUE");
   Class.forName(sDBDriver).newInstance();
   return DriverManager.getConnection(sConnection, pr);
   }
    catch(Exception se){
     System.out.println(se.getMessage());
     return null;
  }
 }
 //释放资源
 public static void dbClose(Connection conn,PreparedStatement ps,ResultSet rs)
  throws SQLException
  {
   rs.close();
   ps.close();
   conn.close();
  }
}

db.properties:

DBDriver=com.microsoft.jdbc.sqlserver.SQLServerDriver
Connection=jdbc:microsoft:sqlserver://localhost:1433;DatabaseName=test;
User=sa
Password=sa

            编译loginServlet.java时，需要引用javax.servlet和javax.servlet.http两个软件包。Sun的JDK一般不包含这两个软件包。这两个软件包包含在servlet.jar中。因此在编译servlet时，需要引用servlet.jar。假如servlet.jar放在d:\library目录中，servlet程序放在d:\login目录中，要用javac编译servlet程序，则编译命令如下：
D:\javac  -classpath  "d:\library\servlet.jar"  login\*.java
 
         在实际的运行中，有一些细节是需要注意的，我将jsp文件放在了一个文件夹jsp中，所以遇到了一些问题：
1.jsp页面中action属性是与url-pattern对应的，程序首先与url-pattern对应，然后通过映射找到实际的servlet类。
2.jsp页面中action属性内容中如果含有“/”，例如：action="/login"，则系统将在webapps目录下开始查找对应的servlet类，如果不含有，则从本工程目录下查找servlet类。 

1. 为建立与数据库的连接，需要通过调用Class类的forName()方法来装入数据库特定的驱动器。例如，装载MySql的驱动器如下：
         Class.forName("com.mysql.jdbc.Driver");
2. java.sql包中包含DriverManager类和Connection接口，用来连接数据库。要连接数据库，必须先从DriverManager类生成Connection对象。要生成Connection对象，还需要数据库的URL，用户名及密码等信息。例如，有一个本地MySql数据库，名叫mydatabase，其用户名为Bill，密码为123，那么生成连接数据库的Connection对象的方法如下：
         String url="jdbc:mysql://localhost/mydatabase";
         Connection con=DriverManager.getConnection(url,"Bill","123"); 
3. 建立连接后，可使用两种对象查询数据库：Statement对象和PreparedStatement对象。
    Statement对象：把简单查询语句发送到数据库，允许执行简单的查询。它有两个查询方法：executeQuery()和executeUpdate()。executeQuery()方法执行简单的选择（SELECT）查询，并返回ResultSet对象；executeUpdate()方法执行SQL的INSERT，UPDATE或DELETE语句，返回int值，给出受查询影响的行数。例如：
         Statement st=con.createStatement();
         ResultSet rs=st.executeQuery("select * from students");
         PreparedStatement对象：允许执行参数化的查询。例如：
         String sql="select * from students where stuID=?";
         PrepareStatement ps=con.prepareStatement(sql);
         ps.setString(1,"56789");           //设定参数值
         ResulrSet rs=ps.executeQuery();  //获得查询结果
4. 查询结果
         查询结果一般封装在ResultSet对象中。ResultSet实际上是一张数据表。ResultSet对象有多种方法用来从查询结果中读取数据，如next()和getXXX(int cn)等。next()方法把光标移向下一行，getXXX(int cn)或getXXX(String colName)方法可用来检索ResultSet行中的数据，这里XXX代表列的数据类型，如String,Integer或Float,cn指结果集中的列号，colName代表列名。例如：
         ResultSet rs=st.executeQuery("select * from students");
         while(rs.next())
         String name=rs.getString("student_name");
5. 查询数据库示例例1-3

package chap1;

import java.sql.*;
public class JdbcTest {
      public static void main(String[] args) {
      try{
         Class.forName("com.mysql.jdbc.Driver");
         String url="jdbc:mysql://localhost/test";
         Connection con=DriverManager.getConnection(url,"root","root");
         String sql="select * from test where userid=?";
         PreparedStatement ps=con.prepareStatement(sql);
         ps.setString(1,"123");
         ResultSet rs=ps.executeQuery();
         while(rs.next()){
             String name=rs.getString("username");
             int age=rs.getInt(3);     //这里的“3”指数据表中的第3个字段的值
             System.out.println(name);
             System.out.println(age);
         }
         rs.close();
         con.close();
        }catch(SQLException e){
         System.out.println("Error"+e);
        } catch (ClassNotFoundException e) {
         e.printStackTrace();
        }
    }
}

MyFirstServlet.java:
package chap1;
import javax.servlet.http.*;
import javax.servlet.*;
import java.io.*;
import java.util.*;

public class MyFirstServlet extends HttpServlet{
      public void doPost(HttpServletRequest request,HttpServletResponse response){
      String name=request.getParameter("username");
      RequestDispatcher rd;
      try{
         try{
          if(name.equals("Tom")){
           HttpSession session=request.getSession(true);
           session.setAttribute("nm",name);
           response.sendRedirect("servlet/reply.jsp");
          }
          else{
           rd=request.getRequestDispatcher("servlet/error.jsp");
           rd.forward(request,response);     
           }
         }catch(ServletException e){System.out.println(e);}
        }catch(IOException e){System.out.println(e);}
    }
   public void doGet(HttpServletRequest request,HttpServletResponse response){
       doPost(request,response);
   }
}
在Java Web应用程序中，Servlet常用做控制器组件。当Servlet部署到Web服务器中时，需要Web配置文件Web.xml中进行声明。
<servlet>
<servlet-name>MyFirstServlet</servlet-name>
<servlet-class>chap1.MyFirstServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>MyFirstServlet</servlet-name>
<url-pattern>/MyFirstServlet</url-pattern>
</servlet-mapping>