面向对象的开发方法是当今的主流，但是同时我们不得不使用关系型数据库，所以在企业级应用开发的环境中，对象、关系的映射（ORM）是一种耗时的工作。围绕对象关系的映射和持久数据的访问，在Java领域中发展起来了一些API和框架，下面分别简单介绍。

　　JDBC可以说是访问持久数据层最原始、最直接的方法。在企业级应用开发中，我们可能使用DAO（Data Access Object）模式来把数据访问封装起来，然后在其它的层中同一调用。这种方式的优点是运行效率最高，缺点是把DAO对象和SQL语言紧密耦合在一起使得在大项目中难以维护。但是不管怎么说，使用JDBC来直接访问持久数据层是当今企业级应用开发中使用最广泛的。

　　实体Bean是J2EE平台中用来表示和访问持久数据的方式。虽然实体Bean是一种方便快捷的方法，但是在运行时我们需要额外购买EJB容器（当然，如今也有免费的EJB容器，如JBOSS），并且使用不同的应用服务器，需要重新书写不同的部署描述，使得在不同应用服务器下移植企业级应用会带来一些困难。

　　另外，在Java领域中，还有一些表示持久数据的框架，比如JDO和OJB，在这里就不详细介绍了。

　　Hibernate是一种新的ORM映射工具，它不仅提供了从Java类到数据表之间的映射，也提供了数据查询和恢复机制。相对于使用JDBC和SQL来手工操作数据库，使用Hibernate，可以大大减少操作数据库的工作量。

　　Hibernate可以和多种Web服务器或者应用服务器良好集成，如今已经支持几乎所有的流行的数据库服务器（达16种）。

　　下面我们来介绍怎么结合Hibernate2.0和Apache Tomcat5.0在Web应用中使用Hibernate。

　　配置

　　1、下载安装Tomcat，并且下载Hibernate的运行环境（主要包含一些JAR包）。
　　2、把要使用的数据库的JDBC驱动程序拷贝到%TOMCAT_HOME%\common\lib目录下。笔者使用的是MYSQL，对应的驱动程序的JAR包为mm.mysql-2.0.4-bin.jar。
　　3、在Tomcat的Webapps目录下新建一个Web应用，名字为hibernate。
　　4、把Hibernate提供的hibernate2.jar和一些第三方的运行库拷贝到hibernate\WEB\INF\lib目录下。（这些第三方的运行库包含在下载的Hibernate lib目录下）
　　5、在%TOMCAT_HOME%\conf\server.xml中Web应用和数据源。在server.xml中加入以下的配置描述。

　　例程1 配置web应用

　<Context path="/hibernate" docBase="hibernate" debug="0"   reloadable="true" crossContext="true">
　　<Resource name="jdbc/hibernate" auth="Container" type="javax.sql.DataSource"/>  
     <ResourceParams name="jdbc/hibernate"> 
      <parameter>  
          <name>factory</name>  
       <value>org.apache.commons.dbcp.BasicDataSourceFactory</value>  
      </parameter>
      <parameter>  
         <name>driverClassName</name>  
            <value>org.gjt.mm.mysql.Driver</value>  
       </parameter> 
        <parameter> 
              <name>url</name>  
              <value>jdbc:mysql:///test</value>  
         </parameter>  
       <parameter> 
            <name>username</name> 
           <value>root</value> 
       </parameter>  
      <parameter> 
         <name>password</name>  
         <value></value> 
          </parameter>  
      <parameter> 
      <name>maxActive</name> 
      <value>20</value> 
    </parameter>
         <parameter>  
        <name>maxIdle</name>  
           <value>10</value>
    </parameter> 
    <parameter> 
          <name>maxWait</name> 
      <value>-1</value> 
    </parameter>  
　　</ResourceParams>  
　</Context>

　　在这里，配置了一个名为hibernate的Web应用，并且配置了一个数据源，数据源的JNDI名称为jdbc/hibernate。您需要根据情况修改数据源的链接属性。

　　6、下一步就是书写Hibernate的配置描述符。可以使用XML的配置描述，也可以使用基于属性的配置描述。在这里使用基于XML的配置描述。在hibernate\WEB-INF\classes目录下新建一个hibernate.cfg.xml文件。然后加入例程2所示的内容。

<!DOCTYPE hibernate-configuration
    PUBLIC "-//Hibernate/Hibernate Configuration DTD//EN"
    "http://hibernate.sourceforge.net/hibernate-configuration-2.0.dtd">

<hibernate-configuration>
    <session-factory>
        <property name="connection.datasource">java:comp/env/jdbc/hibernate</property>
        <property name="show_sql">false</property>
        <property name="dialect">net.sf.hibernate.dialect.MySQLDialect</property>
        <!-- Mapping files -->
    </session-factory>
</hibernate-configuration>

　　注意connection.datasource属性必须和server.xml中配置的数据源的属性一样。如果不是使用MYSQL，那么需要更改dialect属性。

　　到现在，配置基本完成，下面我们来开发一个最简单的应用。

　　开发持久对象、编写映射描述

　　我们使用hibernate来封装一个简单的数据表。这个表的名字为Courses，它有两个字段，一个是ID，它是Courses表的主键；另一个是name，表示Courses的名字。在数据库中使用以下的脚本来创建这个表：

　　create table Courses(CourseId varchar(32) not null, name varchar(32), constraint pk_Courses primary key (CourseId) );

　　接下来的任务就是为Courses表书写持久对象，如例程3所示。

　　例程3 Courses的持久对象（Courses.java）

package com.hellking.study.hibernate;

import java.util.Set;

/**
 *在hibernate中代表了Course表的类。
 */
public class Course
{
   /**每个属性和表的一个字段对应**/
   private String id;
   private String name;
  
   /**students表示course中的学生，在后面才会用到，暂时不管**/
   private Set students;
    
    /**属性的访问方法**/
 public void setId(String string) {
  id = string;
 }
 
 public String getId() {
  return id;
 }
 
 public void setName(String name)
 {
  this.name=name;
 }
 public String getName()
 {
  return this.name;
 }
 public void setStudents(Set stud)
 {
  this.students=stud;
 }
 public Set getStudents()
 {
  return this.students;
 }
}

　　可以看出，在Course类中也包含了两个属性，id和name，它的属性和表Courses的字段是一一对应的，并且类型一致。

　　书写好了持久对象，接下来的任务就是书写对象、关系映射描述。在hibernate\WEB-INF\classes目录下新建一个Course.hbm.xml描述文件，内容如例程4所示。

　　例程4 Course.hbm.xml

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
    "-//Hibernate/Hibernate Mapping DTD 2.0//EN"
    "http://hibernate.sourceforge.net/hibernate-mapping-2.0.dtd">

<hibernate-mapping>
    <class
        name="com.hellking.study.hibernate.Course"
        table="Courses"
        dynamic-update="false"
    >

        <id
            name="id"
            column="CourseId"
            type="string"
            unsaved-value="any"
        >
            <generator class="assigned"/>
        </id>

        <property
            name="name"
            type="string"
            update="true"
            insert="true"
            column="Name"
        />     
    </class>
</hibernate-mapping>

　　在Course.hbm.xml映射文件中，指定了要映射的类和映射的表，并且指定了表的各个字段和Java对象中各个字段的映射关系，比如Course对象中的id属性对应了Courses表的courseId字段。

　　接下来的任务就是在hibernate.cfg.xml中指定这个映射关系。如下所示：

<session-factory>
…
<!-- Mapping files --> 
 <mapping resource="Course.hbm.xml"/>
</session-factory>

　　编写业务逻辑

　　到此，我们已经封装了一个名为Courses的表，并且配置完成。接下来的任务就是在Web应用开发中使用它们，为了演示在Hibernate中对数据库的不同类型的操作，我们开发的Web应用有以下的功能：
　　增加一个Course；
　　删除一个Course；
　　按照Course的名字进行模糊搜索；
　　查看系统中所有的Course。

　　虽然我们可以直接在JSP中使用hibernate，但是往往我们不这样，而是把这些业务逻辑封装在JavaBean中，然后在JSP中通过调用JavaBean以访问Hibernate封装的对象。

　　由于访问通过使用hibernate有一些共性的操作，在这里我们把这些共性的操作封装在一个专门的类中，这样其它的类可以继承它，如例程5所示。

　　例程5 HibernateBase.java

package com.hellking.study.hibernate;

import net.sf.hibernate.*;
import net.sf.hibernate.cfg.*;
import java.util.*;
import java.io.IOException;
import java.io.PrintWriter;

public abstract class HibernateBase
{
 protected SessionFactory sessionFactory;//会话工厂，用于创建会话
    protected Session session;//hibernate会话
    protected Transaction transaction; //hiberante事务
   
    public HibernateBase()throws HibernateException
    {
     this.initHibernate();
    }
    // 帮助方法
    protected void initHibernate()
        throws HibernateException {

        // 装载配置，构造SessionFactory对象
        sessionFactory = new Configuration().configure().buildSessionFactory();
    }
   
    /**
     *开始一个hibernate事务
     */
    protected void beginTransaction()
        throws HibernateException {

        session = sessionFactory.openSession();
        transaction = session.beginTransaction();
    }
   
    /**
     *结束一个hibernate事务。
     */
    protected void endTransaction(boolean commit)
        throws HibernateException {

        if (commit) {
            transaction.commit();
        } else {
           //如果是只读的操作，不需要commit这个事务。
            transaction.rollback();
        }
         session.close();
    }
}

　　下面编写业务逻辑类，新建一个名为CourseBean的JavaBean，并且CourseBean继承HibernateBase类，代码如例程6所示。

　　例程6 CourseBean.java

package com.hellking.study.hibernate;

import net.sf.hibernate.*;
import net.sf.hibernate.cfg.*;
import java.util.*;

/**
 *和course相关的业务逻辑
 */
public class CourseBean extends HibernateBase
{
 public CourseBean()throws HibernateException
 {
  super();
 }
 /**
  *增加一个Course
  */
 public void addCourse(Course st)throws HibernateException
 {
  beginTransaction();
         session.save(st);        
         endTransaction(true);
    }
   
    /**
     *查询系统中所有的Course，返回的是包含有Course持久对象的Iterator。
     */
    public Iterator getAllCourses()throws HibernateException
    {
      String queryString = "select courses from Course as courses";
        beginTransaction();
        Query query = session.createQuery(queryString);
        Iterator it= query.iterate();
        return it;
    }
   
    /**
     *删除给定ID的course
     */
    public void deleteCourse(String id)throws HibernateException
    {
      beginTransaction();     
      Course course=(Course)session.load(Course.class,id);     
      session.delete(course);
      endTransaction(true);
     }
   
    /**
     *按course的名字进行模糊查找，返回的是包含有Course持久对象的Iterator。
     */
    public Iterator getSomeCourse(String name)throws HibernateException
    {
       String queryString = "select c from Course as c where c.name like :name" ;
         beginTransaction();
         Query query = session.createQuery(queryString);
         query.setString("name", "%"+name+"%");
        Iterator it= query.iterate();
        return it;
    }     
}

　　在CourseBean封装了4个业务方法，你可以根据情况增加其它的业务方法。在CourseBean中，通过Hibernate来操作潜在的数据库资源。

　　要保存Course数据到数据库，可以通过：

　　session.save(Course);

　　方法来保存，它相当于使用在JDBC中执行以下语句：

　　Connection con=…
　　Statement stmt=con.createStatement();
　　stmt.executeUpdate("insert into courses values('"+course.getId(),+"','"+course.getName()+"')");
　　con.close();

　　可以看出，通过使用Hibernate，可以大大减少数据访问的复杂度。

　　在JSP中调用业务逻辑

　　添加数据

　　CourseBean这个业务对象封装了和Hibernate的交互关系，从而使JSP和Hibernate关系的解藕。我们来看测试主页面的部分代码，如例程7所示。

　　例程7 测试Hibernate开发的应用（course.jsp）

<%@ page import="java.sql.*,java.util.*" errorPage="error.jsp"%>
<jsp:useBean id="course" class="com.hellking.study.hibernate.Course" scope="page">
<jsp:setProperty name="course" property="*"/>
</jsp:useBean>
<jsp:useBean id="courseBusiness" class="com.hellking.study.hibernate.CourseBean" scope="page"/>
<html><body><center>
<% 
  try
  {
  if(course.getId().equals(null)||course.getId().equals(""));
  else courseBusiness.addCourse(course);
 
  %>
成功添加了Course：<br>
name：<%=course.getName()%>
Id:<%=course.getId()%>
<%
}
  catch(Exception e)
  {
  } 
%>

<hr>
<br>::增加一个course::<br>
<form action="course.jsp" method="get" name="add">
id:<input type=text name="id"><br>
name:<input type=text name="name"><br>
<input type=submit value="submit"><br>
</form>
<hr>
::按名字模糊查找::<br>
<form action="queryCourse.jsp" method="get" name="queryByName">
name:<input type=text name="name"><br>
<input type=submit value="query"><br>
</form>
<hr>
::删除一个Course::<br>
<form action="deleteCourse.jsp" method="get" name="queryByName">
id:<input type=text name="id"><br>
<input type=submit value="delete"><br>
</form>
<hr>
<a href=viewAll.jsp>::查看所有Course::<a>
</body>
</html>

　　首先通过一个值对象Course（这个类正好是Hibernate使用的持久对象，这里作为值对象来传递数据）接收获得的参数，然后CourseBean的addCourse(Course)方法把数据保存到数据库。可以看出，通过使用Hibernate，把数据从表单中添加到数据库非常简单。

　　查询

　　下面来看模糊查找的JSP代码，如例程8所示。

　　例程8 按名字模糊查找Course

<%@ page import="java.sql.*,java.util.*,com.hellking.study.hibernate.Course" errorPage="error.jsp"%>
<jsp:useBean id="courseBusiness" class="com.hellking.study.hibernate.CourseBean" scope="page"/>
…
<% try
{
   Iterator it=courseBusiness.getSomeCourse((String)request.getParameter("name"));
   while(it.hasNext())
   {
     Course temp=(Course)it.next();
     out.println("<tr><td>"+temp.getId()+"</td>");
     out.println("<td>"+temp.getName()+"</td></tr>");
   }
  }
  catch(Exception e)
  {
    out.println(e.getMessage());
   }
%>
….

　　它实际上调用的是CourseBean的Iterator getSomeCourse(String name)方法。我们来回顾一下这个方法中的代码：

　　/**
     *按course的名字进行模糊查找
     */
    public Iterator getSomeCourse(String name)throws HibernateException
    {
       String queryString = "select c from Course as c where c.name like :name" ;
        beginTransaction();
        Query query = session.createQuery(queryString);
         query.setString("name", "%"+name+"%");
        Iterator it= query.iterate();
        return it;
    }

　　在查询前，首先调用beginTransaction方法启动新的Hibernate事务，然后创建一个Query对象，在创建这个对象时，同时指定查询的语句。

　　注意，在查询语句：

　　select c from Course as c where c.name like :name"

　　中，它虽然和普通的SQL语句相似，但是不同，在数据库中，使用的表的名字是Courses，而在这个查询语句中使用的是Course，它和持久对象的名字一致，也就是说，这个查询的概念是查询持久对象，而不是数据库的记录。

　　创建了查询对象Query后，需要设置查询的参数，它和在JDBC中PreparedStatement对象中设置参数的方法相似。通过"Iterator it= query.iterate()"语句来执行查询，并且返回一个Iterator对象。在这里使用了Hibernate提供的查询机制，一般的JDBC查询返回的是ResultSet对象，而这里返回的是包含了CourseBean对象的Iterator。

　　要查询系统中所有的Course，也同样非常简单，可以通过例程9所示的代码实现。

　　例程9 查询数据库中所有的Course

…
<jsp:useBean id="courseBusiness" class="com.hellking.study.hibernate.CourseBean" scope="page"/>
…
<% try
{
   Iterator it=courseBusiness.getAllCourses();
   while(it.hasNext())
   {
     Course temp=(Course)it.next();
     out.println("<tr><td>"+temp.getId()+"</td>");
     out.println("<td>"+temp.getName()+"</td></tr>");
   }
  }
  catch(Exception e)
  {
    out.println(e.getMessage());
   }
%>
…

　　实际上调用的是CourseBean的getAllCourses方法，它和getSomeCourse方法机制一样，就不再介绍了。

　　删除数据

　　在JSP中，使用以下的代码来执行删除操作。

　　例程10 删除数据库中Courses表的记录

<jsp:useBean id="courseBusiness" class="com.hellking.study.hibernate.CourseBean" scope="page"/>
…
删除id为：<%=request.getParameter("id")%>的course：:::<br>

<% try
{
 courseBusiness.deleteCourse(request.getParameter("id"));
 out.println("删除成功");
}
  catch(Exception e)
  {
    out.println("不存在这个记录");
   }
%>

　　我们来看CourseBean中执行删除操作的具体代码：

　　/**
     *删除给定ID的course
     */
    public void deleteCourse(String id)throws HibernateException
    {
     beginTransaction();     
     Course course=(Course)session.load(Course.class,id);     
     session.delete(course);
     endTransaction(true);
     }

　　在这个方法中，首先开始一个事务，然后通过session.load(Course.class,id)方法来装载指定ID的持久对象，接下来通过"session.delete(course)"来删除已经装载的course，并且结束Hibernate事务。

　　总结

　　下面总结一下使用Hibernate的开发过程：

　　1、配置Hibernate（一次即可）；
　　2、确定数据表；
　　3、创建持久对象；
　　4、编写对象和数据表的映射描述；
　　5、编写和业务逻辑。

　　实际上，上面的过程和使用EJB没有什么区别：在使用EJB时，首先当然也是配置环境，初始化数据表；然后创建实体Bean（对象于Hibernate的持久对象）；接下来编写部署描述符（ejb-jar.xml，厂商专有的部署描述），在这些部署描述符里，指定了EJB和数据表的映射关系，如果多个实体Bean存在关联关系，需要描述它们之间的关系，这些描述对应于Hibernate中持久对象的描述，如Course.hbm.xml；往往我们并不在应用程序中直接操作实体Bean，而是通过业务对象（如会话Bean）来操作，这里的会话Bean可以简单的和Hibernate中执行业务逻辑的JavaBean对应。这里只是简单的类比，不是绝对的，比如我们同样可以在会话Bean中访问Hibernate持久对象，也就是说使用Hibernate，同样可以把业务逻辑放在会话Bean中。

　　通过本文的学习，相信读者对Hibernate已经有了初步的认识，并且能够使用Hibernate开发简单的应用。在下一篇中，我们将学习怎么使用Hibernate来为复杂的数据表进行映射，并且维护它们之间的关系。

在配置jsp开发环境的过程中会碰到不少问题，感谢网上的许多前辈的经验总结，作者cl41的JSP连接Mysql数据库攻略和作者Saulzy的MySQL学习笔记等文章对我来说简直是雪中送碳，为了帮助象我一样的初学者在此总结了不少作者的经验，非常感谢他们的无私奉献精神，也希望更多的人把这种精神发扬光大，呵呵，再次对所参考文章的作者表示最崇高的敬意！
以下软件下载连接地址无法显示的话，请直接到官方网站下载即可！
 
软件下载
Mysql
下载版本：mysql-4.1.13-win32.zip(Windows downloads)
http://dev.mysql.com/downloads/mysql/4.1.html

JDBC驱动
下载版本：mysql-connector-java-3.1.10.zip
http://dev.mysql.com/downloads/connector/j/3.1.html

下载j2sdk
下载版本：jdk-1_5_0_04-windows-i586-p.exe
http://java.sun.com/j2se/1.5.0/download.jsp

下载tomcat
下载版本: jakarta-tomcat-5.5.9.exe
http://jakarta.apache.org/site/downloads/downloads_tomcat-5.cgi

安装,配置j2sdk：

执行j2sdk安装程序，按默认设置进行安装，也可自定义路径，但需修改下面的配置

配置j2sdk:

配置环境变量:

我的电脑->属性->高级->环境变量->系统变量中添加以下环境变量：
JAVA_HOME=C:\Program Files\Java\jdk1.5.0_04
CLASSPATH=%JAVA_HOME%\lib\dt.jar;%JAVA_HOME%\lib\tools.jar;
path=%JAVA_HOME%\bin;%SystemRoot%\system32;%SystemRoot%;%SystemRoot%\System32\Wbem

写一个简单的java程序来测试J2SDK是否已安装成功：
public class hello
{
 public static void main(String args[])
 {
 System.out.println("Hello");
 }
}

将程序保存为文件名为hello.java的文件。

打开命令提示符窗口，进入到hello.java所在目录，键入下面的命令
javac hello.java
java hello
此时若打印出来hello则安装成功，若没有打印出这句话，仔细检查以上配置是否正确。
注意系统文件夹选项中应确定“隐藏已知文件类型的扩展名”不勾选（我的电脑—工具—查看）

安装,配置tomcat
执行tomcat安装程序，按默认设置进行安装，也可自定义路径，但需修改下面的配置

我的电脑->属性->高级->环境变量->系统变量中添加以下环境变量
CATALINA_HOME=C:\Program Files\Apache Software Foundation\Tomcat 5.5
CATALINA_BASE=C:\Program Files\Apache Software Foundation\Tomcat 5.5

修改环境变量中的classpath，把tomat安装目录下的common\lib下的servlet-api.jar添加到classpath中去，
修改后的classpath如下：
classpath=%JAVA_HOME%\lib\dt.jar;%JAVA_HOME%\lib\tools.jar;C:\Program Files\Apache Software Foundation\Tomcat 5.5\common\lib\servlet-api.jar;

启动tomcat，在IE中访问http://localhost:8080，若看到tomcat的欢迎页面的话说明安装成功。

安装mysql
解压缩mysql-4.1.13-win32.zip，运行setup.exe
首先出现的是安装向导欢迎界面,直接点击“Next”
继续，选择安装类型,选择“自定义”custom安装，然后点“Next”下一步，出现自定义安装界面
选择安装路径：C:\MySQL Server 4.1(可自定义)
点“OK”返回到自定义安装界面，路径已改为设置的路径
点“Next”，准备开始安装
点“Install”开始安装
完成后出现创建MySQL.com帐号的界面
如果是首次使用MySQL，选“Create anew free MySQL.com accout”
点“Next”，输入你的Email地址和自己设定的用于登录MySQL.com的密码
填完后点“Next”进入第二步
填写姓名等相关信息，填完点“Next”，进入第三步
填完电话号码、公司名称等信息后，点“Next”，
然后出现预览你刚才填的信息的界面，点“Next”出现安装完成界面
注意，这里有个配置向导的选项（Configure the MySQL Server now），
建议勾选立即配置你的MySQL。许多说安装完MySQL后无法启动，原因就在于没有配置MySQL。
点击“Finish”完成安装，并开始配置MySQL
点“Next”，进入配置类型选择页面。选“Detailed configuration”(详细配置)
点“Next”，进入服务类型选择页面。选“Developer Machine”（开发者机器），这样占用系统的资源不会很多
点“Next”后，进入数据库用法选择页面。选择“Multifunctional Database”
点“Next”，进入选择InnoDB数据存放位置页面
不用更改设置，直接放在Installation Path安装目录里即可，然后点“Next”，选择MySQL的同时联接数
选择“Manual Setting”，设置为100(根据自己需要，酌情设置)
点“Next”，配置MySQL在TCP/IP通讯环境中的端口选择默认的3306端口即可。
点“Next”，选择MySQL中的字符设置
注意，这里的选择将会影响你是否能在MySQL中使用中文。选择gb2312字符集以便支持简体中文
点“Next”，设置Windows服务选项
注意，这里的选择很关键。
“Install As Windows Service”一定要勾选，这是将MySQL作为Windows的服务运行。
“Service Name”就用默认的“MySQL”
下面的“Launch the MySQL Server automatically”一定要勾选，这样Windows启动时，MySQL就会自动启动服务，要不然就要手工启动MySQL。
许多人说安装MySQL后无法启动、无法连接、出现10061错误，原因就在这里。
点“Next”，设置根帐号root的登录密码
“Modify Security Settings”是设置根帐号的密码，输入你设定的密码即可。
“Create An Anonymous Account”是创建一个匿名帐号，这样会导致未经授权的用户非法访问你的数据库，有安全隐患，建议不要勾选。
点“Next”，MySQL配置向导将依据你上面的所有设定配置MySQL，以便MySQL的运行符合你的需要
点“Execute”开始配置，当出现“Service started successfully”时，说明你的配置完成，MySQL服务启动成功
点“Finish”完成，整个MySQL的配置完成，剩下的就是用MySQL客户端连接MySQL服务器，然后使用了。

安装JDBC驱动：
解压缩mysql-connector-java-3.1.10.zip
将要使用的是mysql-connector-java-3.1.10-bin-g.jar和mysql-connector-java-3.1.10-bin.jar

配置
在C:\Program Files\Java目录下建立mysqlforjdbc子目录，进入该目录将mysql-connector-java-3.1.10-bin.jar到该目录下
进入C:\Program Files\Java\jdk1.5.0_04\lib目录将mysql-connector-java-3.1.10-bin-g.jar拷贝到该目录下
然后配置classpath，追加%JAVA_HOME%\lib\mysql-connector-java-3.1.10-bin-g.jar;C:\Program Files\Java\mysqlforjdbc\mysql-connector-java-3.1.10-bin.jar;到该环境变量中去
追加以后环境变量如下：
CLASSPATH=%JAVA_HOME%\lib\dt.jar;%JAVA_HOME%\lib\tools.jar;C:\Program Files\Apache Software Foundation\Tomcat5.5\common\lib\servlet-api.jar;%JAVA_HOME%\lib\mysql-connector-java-3.1.10-bin-g.jar;C:\Program Files\Java\mysqlforjdbc\mysql-connector-java-3.1.10-bin.jar;
配置这个的目的是让java应用程序找到连接mysql的驱动．

查看并启动MySQL服务
在Windows XP下安装完MySQL后，它就已经自动启动服务了，并且在开始菜单中有其客户端的快捷方式连接
可以通过Windows的服务管理器查看。“开始”－“运行”，输入“services.msc”，回车。
弹出Windows的服务管理器，然后就可以看见服务名为“mysql”的服务项了，其右边标明“已启动”
在开始菜单-所有程序-MySQL-MySQL Server 4.1-MySQL Command Line Client用客户端的快捷方式连接
输入安装是设置的密码即可

数据库的使用

Mysql安装完毕以后，在开始菜单-所有程序-MySQL-MySQL Server 4.1-MySQL Command Line Client用客户端的快捷方式连接
输入安装时设置的密码

使用mysql的基本命令(在mysql命令行编辑每输入完命令后最后一定要有分号)
显示数据库：show databases;
使用数据库：use 数据库名；

建库
在mysql里建一个数据库first，以及在数据库里建一个表about
命令：create database first;

为数据库设置权限（用户和密码）
命令：grant all privileges on first.* to test@localhost identified by  “123456”;
当你执行完这个命令以后，只要你再以用户名：test,密码：123456登录时你就只可以对first这个数据库操作，这样避开使用root
输入命令：use first;
使用first数据库；

在first库中建表
命令：create table about(id int(8) primary key,name varchar(10));

在表中假如数据：
命令：insert into  about values('xyw1026','laojiang');

退出
命令：exit

JSP连接mysql
在C:\Program Files\Apache Software Foundation\Tomcat5.5\webapps目录下建立子目录myapp
进入C:\Program Files\Apache Software Foundation\Tomcat5.5\webapps\myapp目录下
用记事本编写一个文件保存为first.jsp
代码如下：
<%@ page contentType="text/html;charset=gb2312"%>
<%@ page import="java.sql.*"%>
<html>
<body>
<%Class.forName("org.gjt.mm.mysql.Driver").newInstance();
String url ="jdbc:mysql://localhost/softforum?user=soft&password=soft1234&useUnicode=true&characterEncoding=8859_1"
//first为你的数据库名
Connection conn= DriverManager.getConnection(url);
Statement stmt=conn.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,ResultSet.CONCUR_UPDATABLE);
String sql="select * from first";
ResultSet rs=stmt.executeQuery(sql);
while(rs.next()) {%>
您的第一个字段内容为：<%=rs.getString(1)%>
您的第二个字段内容为：<%=rs.getString(2)%>
<%}%>
<%out.print("数据库操作成功，恭喜你");%>
<%rs.close();
stmt.close();
conn.close();
%>
</body>
</html>

在浏览器中输入：
http://127.0.0.1:8080/myapp/first.jsp
若出现：
id|num
0 |laojiang

数据库操作成功，恭喜你

表示配置成功

进入C:\Program Files\Apache Software Foundation\Tomcat5.5\webapps\myapp目录
在myapp目录下新建一个目录WEB-INF，注意，目录名称是区分大小写的；
在WEB-INF下用记事本新建一个文件，命名为web.xml，内容如下：

<?xml version="1.0" encoding="ISO-8859-1"?>

<!DOCTYPE web-app
PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
"http://java.sun.com/dtd/web-app_2_3.dtd">

<web-app>
<display-name>My Web Application</display-name>
<description>
A application for test.
</description>
</web-app>

在myapp下用记事本新建一个测试的jsp页面，文件名为index.jsp，文件内容如下：

<html><body><center>
Now time is: <%=new java.util.Date()%>
</center></body></html>

重启Tomcat
打开浏览器，输入http://localhost:8080/myapp/index.jsp
看到当前时间的话说明成功安装。

建立自己的Servlet：
用记事本新建一个servlet程序，文件名为HelloWorld.java，文件内容如下：

import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
public class HelloWorld extends HttpServlet
{
public void doGet(HttpServletRequest request,HttpServletResponse response)throws ServletException,IOException
{

response.setContentType("text/html");
PrintWriter out = response.getWriter();
out.println("<html><head><title>");
out.println("This is my first Servlet");
out.println("</title></head><body>");
out.println("<h1>Hello,World!</h1>");
out.println("</body></html>");

}
}

编译
将HelloWorld.java剪切到C:\Program Files\Apache Software Foundation\Tomcat5.5\common\classes目录下
命令行方式下输入：
cd C:\Program Files\Apache Software Foundation\Tomcat5.5\common\classes
javac HelloWorld.java
用javac HelloWorld.java来编译这个文件，如果出现无法import javax.servlet.*
则将C:\Program Files\Apache Software Foundation\Tomcat5.5\common\lib目录下的servlet-api.jar文件拷贝并添加到
C:\Program Files\Java\jre1.5.0_04\lib\ext目录中去就可以了

然后在C:\Program Files\Apache Software Foundation\Tomcat5.5\common\classes下会产生一个编译后的servlet文件：HelloWorld.class
用记事本打开C:\Program Files\Apache Software Foundation\Tomcat5.5\webapps\ROOT\WEB-INF目录下的web.xml如下所示，添加后的内容如下:
.
.
.
<!-- JSPC servlet mappings start -->

    <servlet>
        <servlet-name>org.apache.jsp.index_jsp</servlet-name>
        <servlet-class>org.apache.jsp.index_jsp</servlet-class>
    </servlet>

    <servlet-mapping>
        <servlet-name>org.apache.jsp.index_jsp</servlet-name>
        <url-pattern>/index.jsp</url-pattern>
    </servlet-mapping>

   
    <servlet>
        <servlet-name>HelloWorld</servlet-name>
        <servlet-class>HelloWorld</servlet-class>
    </servlet>

    <servlet-mapping>
        <servlet-name>HelloWorld</servlet-name>
        <url-pattern>/servlet/HelloWorld</url-pattern>
    </servlet-mapping>

<!-- JSPC servlet mappings end -->

</web-app>

这段话中的servlet这一段声明了你要调用的Servlet，而servlet-mapping则是将声明的servlet“映射”到/servlet/HelloWorld地址上

启动Tomcat，启动浏览器，输入http://localhost:8080//servlet/HelloWorld 如果看到输出HelloWorld！就说明编写的servlet成功了。
注意：修改了web.xml以及新加了class，都要重启Tomcat

也可以在自己创建的目录下测试如：
将HelloWorld.class拷贝到C:\Program Files\Apache Software Foundation\Tomcat5.5\webapps\myapp\WEB-INF\classes目录下
其中classes目录若没有就创建一个
用记事本打开C:\Program Files\Apache Software Foundation\Tomcat5.5\webapps\myapp\WEB-INF目录下的web.xml如下所示，修改后的内容如下:
.
.
.
<!-- JSPC servlet mappings start -->
   
    <servlet>
        <servlet-name>HelloWorld</servlet-name>
        <servlet-class>HelloWorld</servlet-class>
    </servlet>

    <servlet-mapping>
        <servlet-name>HelloWorld</servlet-name>
        <url-pattern>/servlet/HelloWorld</url-pattern>
    </servlet-mapping>

<!-- JSPC servlet mappings end -->

</web-app>

启动Tomcat，启动浏览器，输入http://localhost:8080/myapp/servlet/HelloWorld 如果看到输出HelloWorld！就说明编写的servlet成功了。
注意：修改了web.xml以及新加了class，都要重启Tomcat

建立自己的javaBean：

用记事本新建一个java程序，文件名为TestBean.java，文件内容如下：
package test;
public class TestBean{
private String name = null;
public TestBean(String strName_p){
this.name=strName_p;
}
public void setName(String strName_p){
this.name=strName_p;
}
public String getName(){
return this.name;
}
}

编译
将TestBean.java放在c:\test下，使用如下命令编译：
C:\test>javac TestBean.java
然后在c:\Test下会产生一个编译后的bean文件：TestBean.class
将TestBean.class文件剪切到C:\Program Files\Apache Software Foundation\Tomcat5.5\webapps\myapp\WEB-INF\classes\test目录下，
若无某些子目录则创建一个

新建一个TestBean.jsp文件，文件内容为：
<%@ page import="test.TestBean" %>
<html><body><center>
<%
TestBean testBean=new TestBean("This is a test java bean.");
%>
Java bean name is: <%=testBean.getName()%>
</center></body></html>

重启Tomcat，启动浏览器，输入http://localhost:8080/myapp/TestBean.jsp 如果看到输出Java bean name is: This is a test java bean
就说明编写的javaBean成功了。

（特别注明：本文内容均来自互联网）

webwork是个优秀的开源框架，特别是其拦截器机制，我认为是整个系统最大的亮点，可在其上面做大量文章
我的开发环境为Eclipse3.0.1+lomoz，数据库我用的是MySQL4.0.12,当然，也用到了mysqlcc,服务器我用的是tomcat4.0.3和tomcat4.1
请先下载webwork.,spring.,hibernate，并把JAR文件放到web-inf的lib目录里面。同时，请下载http://unc.dl.sourceforge.net/sourceforge/aopalliance/aopalliance.zip ，将aopalliance.jar放到lib目录里面。
还有webwork2-spring.jar，以及mysql的驱动都要下载并放到lib里面，缺一不可
然后是配置log4j，如果没有正确配置log，TOMCAT将不能正常发布你的项目。配置log4j很简单，
在web-inf/classes下建立一个log4j.properties的文件，内容如下
    log4j.rootLogger=INFO, A1 , R
    log4j.appender.A1=org.apache.log4j.ConsoleAppender
    log4j.appender.A1.layout=org.apache.log4j.PatternLayout
    log4j.appender.A1.layout.ConversionPattern=%-d{yyyy-MM-dd HH:mm:ss} [%c]-[%p] %m%n
    log4j.appender.R=org.apache.log4j.RollingFileAppender
    log4j.appender.R.File=d:/Tomcat 4.1/webapps/demo/logs/log4j.log
    log4j.appender.R.MaxFileSize=100KB
    log4j.appender.R.MaxBackupIndex=1
    log4j.appender.R.layout=org.apache.log4j.PatternLayout
    log4j.appender.R.layout.ConversionPattern=%p %t %c - %m%n
其中log4j.appender.R.File这一项请按照你TOMCAT的安装位置进行修改，关于log4j的详细内容，推荐大家看Hilton的学习笔记以及IBM网站上的相关文章.
 好了，开始我们的webwork之旅了。首先是配置web.xml文件
<?xml version="1.0" ?>
<!DOCTYPE web-app PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN" "http://java.sun.com/dtd/web-app_2_3.dtd">

<!-- Copyright (c) 2002 by ObjectLearn. All Rights Reserved. -->
<web-app>
       <listener>
              <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
       </listener>
       <listener>
              <listener-class>com.atlassian.xwork.ext.ResolverSetupServletContextListener</listener-class>
       </listener>
    <servlet>
        <servlet-name>webwork</servlet-name>
        <servlet-class>com.opensymphony.webwork.dispatcher.ServletDispatcher</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>webwork</servlet-name>
        <url-pattern>*.action</url-pattern>
    </servlet-mapping>

     <taglib>
        <taglib-uri>webwork</taglib-uri>
        <taglib-location>/WEB-INF/webwork.tld</taglib-location>
    </taglib>

</web-app>

我们配置了两个监听器，还有一个servlet，这个servlet负责action的转发工作，关于action的详细工作原理，大家可以参看xwork的源代码
在接下来配置之前，我想大概说一下我想实现的功能，就是简单的往mysql的一个表中插入一些数据
首先我用Middlegen-Hibernate和hibernate-extensions（我没用eclipse的hibernate插件，我喜欢用这两样工具来生成）生成了表对应的hbm.xml文件和两个JAVA类，表的字段是"tablename,fieldname,chinesename", 表名是
"systable",其中tablename,fieldname做双主键，这样，生成出来的类应该是两个，一个PK主键类和主类本身，我把他们加入到了我的项目中.
然后我做了一个接口类
 package com.cz.struct;

 /**
  * @author tijichen
  *
  * TODO To change the template for this generated type comment go to
  * Window - Preferences - Java - Code Style - Code Templates
  */
 public interface SystableDAO {
  public abstract void insert(Systable data);
 }
然后是实现类
 package com.cz.struct;
 import net.sf.*;
 import org.springframework.orm.hibernate.support.HibernateDaoSupport;
 /**
  * @author tijichen
  *
  * TODO To change the template for this generated type comment go to
  * Window - Preferences - Java - Code Style - Code Templates
  */
 public class SysTableDAOImp extends HibernateDaoSupport implements
 SystableDAO{
  public void insert(Systable data)
  {
   this.getHibernateTemplate().save(data);
  }
 }
为什么要用接口类？因为spring会用到JAVA的动态代理，关于这部分，大家可以看xiaxin的spring指南
在insert 方法中，我直接调用了spring提供的hibernate模板方法，真是方便呀

然后是 spring的配置了，请在web-lib/下建立applicationContext.xml文件，内容如下
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
  <bean id="dataSource"
    class="org.springframework.jdbc.datasource.DriverManagerDataSource"
   destroy-method="close">
   <property name="driverClassName">
    <value>org.gjt.mm.mysql.Driver</value>
   </property>
   <property name="url">
    <value>jdbc:mysql://localhost/mystructs</value>
   </property>
   <property name="username">
    <value>chenzhi</value>
   </property>
   <property name="password">
    <value>1</value>
   </property>
  </bean>
  <bean id="sessionFactory"
   class="org.springframework.orm.hibernate.LocalSessionFactoryBean">
   <property name="dataSource">
    <ref local="dataSource" />
   </property>
   <property name="mappingResources">
    <list>
     <value>com\cz\struct\SysTable.hbm.xml</value>
    </list>
   </property>
   <property name="hibernateProperties">
    <props>
     <prop key="hibernate.dialect">
      net.sf.hibernate.dialect.MySQLDialect
     </prop>
     <prop key="hibernate.show_sql">
      true
     </prop>
    </props>
   </property>
  </bean>
  <bean id="transactionManager"
   class="org.springframework.orm.hibernate.HibernateTransactionManager">
   <property name="sessionFactory">
    <ref local="sessionFactory" />
   </property>
  </bean>
  <bean id="systableDAO" class="com.cz.struct.SysTableDAOImp">
   <property name="sessionFactory">
    <ref local="sessionFactory" />
   </property>
  </bean>
  <bean id="systableDAOProxy"
   class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
   <property name="transactionManager">
    <ref bean="transactionManager" />
   </property>
   <property name="target">
    <ref local="systableDAO" />
   </property>
   <property name="transactionAttributes">
    <props>
      <prop key="insert*">PROPAGATION_REQUIRED</prop>
      <prop key="get*">PROPAGATION_REQUIRED,readOnly</prop>
      <prop key="is*">PROPAGATION_REQUIRED,readOnly</prop>
    </props>
   </property>
  </bean>
</beans>
在这个配置文件里面，我们设置了datasource\sessionfactory以及spring的动态代理，还有hibernate所需要的XML映射文件路径
然后是配置xwork.xml
<!DOCTYPE xwork PUBLIC "-//OpenSymphony Group//XWork 1.0//EN" "http://www.opensymphony.com/xwork/xwork-1.0.dtd">
<xwork>
 <include file="webwork-default.xml" />
  <package name="default" extends="webwork-default"
   externalReferenceResolver="com.atlassian.xwork.ext.SpringServletContextReferenceResolver">
  <interceptors>
  <interceptor name="reference-resolver"
  class="com.opensymphony.xwork.interceptor.ExternalReferencesInterceptor" />
  <interceptor-stack name="vxStack">
  <interceptor-ref name="params" />
  <interceptor-ref name="model-driven" />
  <interceptor-ref name="reference-resolver" />
  </interceptor-stack>
  </interceptors>
<action name="Test" class="com.cz.struct.TestAction">
 <external-ref name="systableDAO">systableDAOProxy</external-ref>
 <result name="success" type="dispatcher">
 <param name="location">/index.jsp</param>
 </result>

 <interceptor-ref name="vxStack" />
</action>
</package>
</xwork>
在配置action的external-ref的时候我遇到了一个不大不小的玩笑，一般编辑XML的时候我都是在editplus里面编辑的
，最开始我写成
<external-ref name="systableDAO">
 systableDAOProxy
</external-ref>
结果系统提示找不到叫systableDAOProxy这个名字的bean，结果一查，发现旁边不能加上空格和tab，哎。。肯定是返回串的时候没加trim
的后果
好了，最后是我们的TestAction.java
package com.cz.struct;
import com.opensymphony.xwork.*;
import com.opensymphony.webwork.*;
import java.util.*;
/**
 * @author tijichen
 *
 * TODO To change the template for this generated type comment go to
 * Window - Preferences - Java - Code Style - Code Templates
 */
public class TestAction extends ActionSupport
{
 private SystableDAO systabledao;
 
 String testname=null;
 public void setSystableDAO(SystableDAO dao)
 {
  this.systabledao=dao;
 }
 public SystableDAO getSystableDAO()
 {return this.systabledao;}
    public String execute() throws Exception {
     testname="executeing";
     SystablePK pk=new SystablePK();
     Systable newdata=new Systable();
     pk.setFieldName("test");
     pk.setTableName("test3");
     newdata.setComp_id(pk);
     newdata.setChineseName("tets");

     systabledao.insert(newdata);
        return Action.SUCCESS;
    }
 
}
ok,编译打包，然后在浏览器地址栏中输入http://localhost:8080/你的发布目录/Test.action
看看，是不是数据库里面多出了一条数据了？
至于其他，比如从页面提交的值插入数据库等等，这里都不多说了，webwork自带的sample就是最好的参考资料

package zmsjdbc;
import java.sql.*;
public class mysql1
{

  private   String url="jdbc:mysql://localhost:3306/beyond";
            //先下载MYSQL 驱动  mm.mysql-2.0.4-bin.jar 放在D:\JBuilder9\jdk1.4\jre\lib\ext 下

 private   String user="root";
 private   String pwd="";
 public   Connection  getcon()
 {
   Connection con;
    try
    { //加载驱动程序
      Class.forName("org.gjt.mm.mysql.Driver").newInstance();
      //创建连接
      con=DriverManager.getConnection(url,user,pwd);
      return con;
     }

     catch(ClassNotFoundException e)
     {
         System.out.println("加载驱动程序出错");
     }

     catch(Exception e)
     {
       System.out.println("出现了好大的错误");
     }

     return null;
 }
 public  ResultSet  executeSql(String sqlstr)
   {
     Connection conn;
     Statement stmt;

      try
      {
        conn=getcon();
        stmt=conn.createStatement();
        ResultSet  rs=stmt.executeQuery(sqlstr);

        return rs;
      }
      catch(SQLException e)
      {
        System.out.print("获取数据集时出现错误");
      }
      return null;
   }

  public static void main(String[] args)
  {
    mysql1 mysql11 = new mysql1();
    Connection conn;
    ResultSet  rs;
   rs= mysql11.executeSql("select * from zms1");
    try
    {
      while(rs.next())
      {
        System.out.println(rs.getString("name"));
      }
    }
    catch(Exception e)
    {
       System.out.println(e.getMessage());
    }

  }

}