第4章 数据库技术
4.1 连接SQL Server数据库
大多数的Web程序和网站都需要有后台数据库的支持，这是由于数据库可以记录或存储在Web程序和网站中发生的任何数据，因此数据库的连接就成了数据库操作的第一步。
实例074 通过JDBC-ODBC桥连接SQL Server数据库
本实例是一个数据库连接的程序
实例位置：光盘\mingrisoft\04\074
实例说明
不同的数据库系统都可以通过ODBC来达到统一处理的方式，也就是通过ODBC的驱动程序，用户可以使用相同的语法来存取或是维护数据库中的数据。
本例使用JDBC-ODBC桥连接SQL Server数据库。运行本例，首先附加SQL Server数据库，然后配置ODBC。配置成功后，即可连接数据库，并显示相应的数据，如图4.1所示。
图4.1 通过JDBC-ODBC桥连接SQL Server数据库
技术要点
建立数据库连接，需要指定数据库的驱动和路径。
指定驱动：
String driverClass="sun.jdbc.odbc.JdbcOdbcDriver";
说明：采用JDBC-ODBC方式连接数据库，该参数指定的是连接方式，并不需要引入驱动包。
指定路径：
String url="jdbc:odbc:db_database04";
说明：字符串中的db_database04为建立的数据源名称。
实现过程
（1）配置ODBC数据源。在“控制面板”窗口中，双击“管理工具”图标打开图4.2所示的“管理工具”窗口。
（2）在“管理工具”窗口中双击“数据源（ODBC）”图标，打开图4.3所示的“ODBC数据源管理器”对话框。
（3）在“ODBC数据源管理器”对话框中打开“系统DSN”选项卡，然后单击“添加”按钮，打开图4.4所示的“创建新数据源”对话框。
图4.2 “管理工具”窗口
图4.3 “ODBC数据源管理器”对话框
图4.4 “创建新数据源”对话框
（4）在“创建新数据源”对话框中双击“SQL Server”列表项，打开图4.5所示的对话框。
（5）在“名称”文本框中输入数据源名称，本实例为DSN_bookmanage；在“服务器”下拉列表框中选择合适的服务器（local为本机服务器），然后单击“下一步”按钮，打开图4.6所示的对话框。
图4.5 配置DSN的名称及连接的SQL Server服务器
图4.6 设置与数据库系统连接的用户账号
（6）在图4.6所示对话框中，将“使用用户输入登录ID和密码的SQL Server验证”单选按钮选中，此时，“登录ID”和“密码”文本框有效。在“登录ID”文本框中输入“sa”（本机服务器的默认ID为sa，密码为空）。单击“下一步”按钮，打开图4.7所示的对话框。
图4.7 指定数据库
（7）在图4.7所示的对话框中选中“更改默认的数据库为”复选框，并在可用的数据库下拉列表框中选择要使用的数据库，本实例为db_database04。单击“下一步”按钮，打开图4.8所示的对话框，该对话框用于设置有关ODBC的一些杂项，包括更改SQL Server系统信息的语言，执行字符数据转换等。
（8）单击“完成”按钮，打开“ODBC Microsoft SQL Server安装”对话框，如图4.9所示。在该对话框中会显示用户设置的信息，并提供“测试数据源”按钮。
图4.8 设置ODBC杂项
图4.9 “ODBC Microsoft SQL Server安装”对话框
（9）单击“测试数据源”按钮，测试数据源的正确性，系统会弹出显示测试结果的对话框。如果确认连接无误，连续确认操作，完成创建系统DSN的任务。
（10）定义ODBC数据库连接，代码如下：
<%!
Connection Con;
public boolean Con() throws SQLException {
try {
Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
Con = DriverManager
.getConnection("jdbc:odbc:DSN_bookmanage","sa","");
return true;
} catch (ClassNotFoundException e) {
return false;
}
举一反三
根据本实例，读者可以：
通过ODBC连接Oracle数据库；
通过ODBC连接My SQL数据库；
通过ODBC连接其他数据库。
实例075 通过JDBC连接SQL Server数据库
本实例是一个数据库连接的程序
实例位置：光盘\mingrisoft\04\075
实例说明
JDBC是Java连接数据库的一种非常快速和有效的方法。但是JDBC不能直接使用，必须配合数据库提供商所提供的数据库连接驱动才能实现数据库的连接。程序运行结果如图4.10所示。
图4.10 通过JDBC连接SQL Server数据库
技术要点
使用JDBC连接数据库主要分为3个步骤：定义数据库连接字符串，加载数据库驱动和创建数据库连接。
（1）定义数据库连接字符串，关键代码如下：
String URL="jdbc:microsoft:sqlserver://localhost:1433;DatabaseName=db_database04"; //指定URL地址
String user="sa"; //指定用户名
String password=""; //指定密码
private Connection con=null; //定义操作接口变量
private Statement stmt=null; //定义操作接口变量
private ResultSet rs=null; //定义操作接口变量
（2）加载数据库连接的驱动。在Java中使用Class.forName来加载数据库驱动。通过Class.forName()方法注册SQL Server数据库驱动类的关键代码如下：
Class.forName("com.microsoft.jdbc.sqlserver.SQLServerDriver"); //注册SQL Server数据库驱动
注意：在加载数据库驱动时，必须将SQL Server数据库驱动包（mssqlserver.jar、msutil.jar、msbase.jar）放置于项目根目录下的WEB-INF\lib文件夹下。
（3）创建数据库的连接。在Java中使用位于java.sql包中的DriverManager类管理JDBC驱动程序的基本服务；通过java.sql包中的Connection接口与特定的数据库进行连接。其语法如下：
Connection con=DriverManager.getConnection(url,name,pwd); //建立数据库连接
实现过程
（1）创建数据库操作类。包括数据库的连接方法、数据的查询方法和数据库的关闭方法。关键代码如下：
package com.pkh.dao;
import java.sql.*;
public class UserDao{
String url="jdbc:microsoft:sqlserver://localhost:1433;DatabaseName=db_database04";
String username="sa";
String password="";
private Connection con=null;
private Statement stmt=null;
private ResultSet rs=null;
public UserDao(){ //通过构造方法加载数据库驱动
try {
Class.forName("com.microsoft.jdbc.sqlserver.SQLServerDriver");
} catch (Exception ex) {
System.out.println("数据库加载失败");
}
}
public boolean Connection(){ //创建数据库连接
try {
con = DriverManager.getConnection(url, username, password);
} catch (SQLException e) {
System.out.println(e.getMessage());
System.out.println("creatConnectionError!");
}
return true;
}
public ResultSet selectStatic(String sql)throws SQLException{ //对数据库的查询操作
ResultSet rs=null;
if (con == null) {
Connection();
}
try {
stmt = con.createStatement();
rs = stmt.executeQuery(sql);
} catch (SQLException e) {
e.printStackTrace();
}
return rs;
}
public void closeConnection(){ //关闭数据库的操作
if (con != null && stmt != null && rs != null) {
try {
rs.close();
stmt.close();
con.close();
} catch (SQLException e) {
e.printStackTrace();
System.out.println("Failed to close connection!");
} finally {
con = null;
}
}
}
}
（2）创建index.jsp页面，通过JavaBean标签调用数据库操作类。然后判断数据库是否连接成功，如果成功则输出数据库中的数据。关键代码如下：
<%@ page language="java" import="java.sql.*" import="java.util.*"
pageEncoding="GBK"%>
<jsp:useBean id="con" class="com.pkh.dao.UserDao" scope="page"></jsp:useBean>
<%
if (con.Connection()) {
out.println("数据库连接成功！");
} else {
out.println("数据库连接失败！");
}
%>
<%
String SQL = "Select * From tb_ClassList";
ResultSet Rs;
Rs = con.selectStatic(SQL);
%>
<%
for (int i = 0; i < 2; i++) {
Rs.next();
%>
<tr class="style1">
<td><div align="left"><%=Rs.getString("CID")%> </div></td>
<td><div align="left"><%=Rs.getString("CName")%> </div></td>
<td><div align="left"><%=Rs.getString("CStartDate")%> </div></td>
<td><div align="left"><%=Rs.getString("CPeriod")%> </div></td>
<td><div align="left"><%=Rs.getString("CType")%> </div></td>
</tr>
<%
}
%>
举一反三
根据本实例，读者可以：
动态指定数据库连接；
编写简单的数据库程序。
实例076 通过Tomcat连接池连接SQL Server数据库
本实例是一个高效数据库连接的程序
实例位置：光盘\mingrisoft\04\076
实例说明
数据库连接池是当今Java程序控制开发中常用的技术，其主要用于解决高负载数据库访问造成的性能问题，提高数据库的使用效率。本实例将介绍如何通过Tomcat连接池访问数据库。运行本实例，如图4.11所示。
图4.11 通过Tomcat连接池连接SQL Server数据库
技术要点
连接池技术原理如图4.12所示。连接的建立、断开都由连接池自身来管理，当程序需要建立数据库连接时，只需从内存中取一个来用而不用新建。同样，使用完毕后，将其放回内存即可。另外，连接池还可以通过其自身的管理机制来监视数据库连接的数量、使用情况等。
图4.12 数据库连接池原理
本实例中配置Tomcat连接池主要使用的是<Resource>标签，下面对本实例中用到<Resource>标签中的属性进行详细讲解。
（1）name：数据库连接池名称。
（2）type：数据库连接池类型。
（3）driverClassName：使用的JDBC驱动的完整有效的java类名。
（4）url：传递给JDBC驱动的用于建立连接的URL。
（5）username：传递给JDBC驱动的用于建立连接的用户名。
（6）password：传递给JDBC驱动的用于建立连接的密码。
（7）initialSize：初始化连接数，连接池启动时创建的初始化连接数量，默认值为0。
（8）maxActive：最大活动连接数，连接池在同一时间能够分配的最大活动连接的数量，如果设置为非正数则表示不限制，默认值为8。
（9）maxIdle：最大空闲连接数，连接池中允许保持空闲状态的最大连接数量，超过的空闲连接将被释放，如果设置为负数表示不限制，默认值为8。
（10）minIdle：最小空闲连接数，连接池中允许保持空闲状态的最小连接数量，低于这个数量将创建新的连接，如果设置为0则不创建，默认值为0。
（11）maxWait：无限最大等待时间。当没有可用连接时，连接池等待连接被归还的最大时间（以毫秒计数），超过时间则抛出异常，如果设置为-1表示无限等待，默认值为0。
实现过程
（1）下载SQL Server驱动包并复制到tomcat安装目录的lib文件夹下。
（2）在当前项目的META-INF文件夹内新建context.xml文件，在此xml文件的<Context>标签中加入<Resource>标签，关键代码如下：
<Context antiJARLocking="true" path="/076">
<Resource name="jdbc/076"
type="javax.sql.DataSource"
username="sa"
password=""
driverClassName="com.microsoft.jdbc.sqlserver.SQLServerDriver"
url="jdbc:microsoft:sqlserver://localhost:1433;DatabaseName=db_database04"/>
initialSize="10"
maxActive="5"
maxIdle="20"
minIdle="5"
maxWait="-1"
/>
</Context>
（3）创建UserBean类封装数据记录，并且编写getConnection()方法从数据库连接池中获取数据库连接，编写findAll()方法查询数据表中的数据，并将查询结果集添加到List集合中。关键代码如下：
public Connection getConnection() {
Connection con=null; //声明Connection对象
try {
Context initctx=new InitialContext(); //创建Context对象
Context envContext = (Context) initctx.lookup("java:comp/env");
DataSource ds=(DataSource)envContext.lookup("jdbc/076"); //按照JNDI名称查找
con=ds.getConnection(); //创建Connection对象
} catch (Exception ex) {
ex.printStackTrace();
}
return con;
}
public List findAll(){
List list=new ArrayList(); //声明list对象
try {
Connection con=getConnection(); //创建数据库连接
Statement st=con.createStatement(); //创建Statmenet对象
ResultSet rs=st.executeQuery("select top 2*from tb_ClassList order by CID desc"); //执行SQL语句
while (rs.next()) {
UserBean bean=new UserBean(); //声明UserBean，并为UserBean的属性赋值
bean.setCid(Integer.valueOf(rs.getInt("CID")));
bean.setCname(rs.getString("CName"));
bean.setCstartDate(rs.getString("CStartDate"));
bean.setCtype(rs.getString("CType"));
list.add(bean); //添加到list列表
}
rs.close(); //关闭rs对象
st.close(); //关闭st对象
con.close(); //关闭con对象
} catch (SQLException ex) {
ex.printStackTrace();
}
return list; //返回list列表
}
（4）创建index.jsp页面，输出从数据库中查询出的结果集，代码如下：
<%@page import="java.util.*"%>
<%@page import="com.pkh.UserBean"%>
<%@page contentType="text/html" pageEncoding="GBK"%>
<jsp:useBean id="user" class="com.pkh.UserBean"/>
<%
List list = user.findAll();
for (int i = 0; i < list.size(); i++) {
UserBean ub=(UserBean)list.get(i);
%>
<tr align="center" valign="middle">
<td class="tr2"><%= ub.getCid() %></td>
<td class="tr2"><%= ub.getCname() %></td>
<td class="tr2"><%= ub.getCstartDate() %></td>
<td class="tr2"><%= ub.getCtype() %></td>
</tr>
<%
}
%>
举一反三
根据本实例，读者可以：
配置Oracle数据库的连接池；
配置Access数据库的连接池；
配置MySQL数据库的连接池。
实例077 通过WebLogic连接池连接SQL Server数据库
本实例是一个实用的程序
实例位置：光盘\mingrisoft\04\077
实例说明
利用WebLogic连接池访问数据库不但可以提高网站的访问速度，而且可以保证数据库的安全。下面将介绍如何通过WebLogic连接池连接SQL Server 2000数据库。运行本实例，将从数据表中查询出全部公告信息，并显示在页面中，如图4.13所示。
图4.13 通过WebLogic连接池连接数据库
技术要点
通过WebLogic连接池连接数据库时，首先需要获得一个引用本地服务器上JNDI服务的Context对象，然后再通过Context对象的lookup()方法，得到JNDI名字服务中的DataSource对象的引用，最后通过DataSource对象的getConnection()方法获得一个Connection对象的实例。关键代码如下：
Context ctx = new InitialContext();
DataSource ds = (DataSource) ctx.lookup("database05JNDI");
conn = ds.getConnection();
其中，DataSource对象代表了数据源，一般由数据库驱动程序厂商实现，其主要方法如下。
● getConnection()：获取一个Connection对象。
● getConnection(String username,String password)：获取一个Connection对象。
● getLogWriter()：从DataSource获得LogWriter对象，该对象是PrinterWriter对象的实例。
● setLogWriter(PrintWriter out)：设置DataSource的LogWriter对象。
● getLoginTimeout()：获得DataSource尝试连接数据库的最大时间。
● setLoginTimeout()：设置DataSource尝试连接数据库的最大时间。
实现过程
在使用WebLogic服务器之前，首先需要安装与配置WebLogic服务器。下面详细介绍WebLogic服务器的安装和配置。
（1）运行WebLogic服务器的安装文件platform811_win32.exe，开启安装向导，在弹出的Welcome对话框中单击“Next”按钮，将弹出WebLogic服务器的许可协议对话框，选中“Yes”单选按钮，接受许可协议，如图4.14所示。
图4.14 许可协议
（2）单击“Next”按钮，将弹出选择安装路径的Choose BEA Home Directory对话框，单击“Browse…”按钮选择WebLogic服务器的安装路径为D:\bea，如图4.15所示。
图4.15 选择WebLogic服务器的安装路径
（3）单击“Next”按钮，将弹出选择安装类型的“Choose Install Type”对话框，此处采用默认值。单击“Next”按钮，将弹出“Choose Product Directory”对话框，用于指定WebLogic的安装目录，这里采用默认值，如图4.16所示。
图4.16 选择安装目录
（4）单击“Next”按钮，开始自动安装WebLogic服务器。在安装结束时，将弹出“Installation Complete”对话框，取消选择“Install XML Spy”和“Run Quickstart”选项，如图4.17所示，单击“Done”按钮，完成安装。
图4.17 安装完毕
（5）在WebLogic服务器安装成功后，还需要配置WebLogic服务。选择“开始”→“程序”→“BEA WebLogic platform 8.1”→“Configuration Wizard”命令，将弹出“Create or Extend a Configuration”对话框，选中“Create a new WebLogic configuration”单选按钮，创建一个新的配置，如图4.18所示。
（6）单击“Next”按钮，将弹出“Select a Configuration Template”对话框，这里采用默认值。单击“Next”按钮，将弹出“Choose Express or Custom Configuration”对话框，这里采用默认值。单击“Next”按钮，将弹出创建登录WebLogic服务器的用户名和密码的对话框，在User Name文本框中输入用户名Admin，在User Password文本框中输入密码12345678，注意密码必须输入8位以上，如图4.19所示。
图4.18 创建或扩展WebLogic配置
图4.19 创建登录WebLogic的用户名和密码
（7）连续单击“Next”按钮，直到弹出“Create WebLogic Configuration”对话框，这里采用默认值，单击“Create”按钮创建配置，再单击“Done”按钮，关闭配置向导。
（8）启动WebLogic服务器。选择“开始”→“程序”→“BEA WebLogic Platform 8.1”→“User Projects”→“mydomain”→“Start Server”命令，启动WebLogic服务器。WebLogic服务器启动后，在IE地址栏中输入http://localhost:7001/console，如果出现登录界面，则说明启动成功。
下面以WebLogic Server 8.0和MS SQL Server 2000为例，讲解如何在WebLogic服务器中配置连接池。
（1）在SQL Server企业管理器中，创建一个名称为mr的登录用户，该用户的登录密码为mrsoft，并指定该用户可以访问本实例所用的数据库db_database04。
（2）编辑WebLogic的启动脚本文件startWebLogic.cmd（该文件保存在bea\user_projects\domains\mydomain文件夹中），在set CLASSPATH=一行中的结尾处指定JDBC的3个驱动包的位置，各包之间用分号隔开。由于是在结尾处添加驱动包，所以必须用分号与前面的变量值分开。关键代码如下：
;C:\JDBC\msbase.jar;c:\jdbc\mssqlserver.jar;c:\jdbc\msutil.jar
（3）启动WebLogic服务器。在地址栏输入http://localhost:7001/console，在打开的登录页面中输入用户名和密码（如Admin和12345678），进入图4.20所示的页面。
（4）在打开的页面中，选择“Services”→“JDBC”→“Connection Pools”节点配置连接池，在右侧打开的页面中单击“Configure a new JDBC Connection Pool...”超级链接，将打开Choose database页面，选择Database Type下拉列表中的MS SQL Server列表项，在Database Driver列表框中，选择微软的SQL Server驱动Microsoft Ms SQL Server Driver（Type 4）Versions 2000，如图4.21所示。
图4.20 WebLogic服务控制台
图4.21 选择数据库类型与驱动
（5）单击“Continue”按钮，将进入Define connection properties页面，定义有关数据库连接的参数。在Name文本框中输入连接池的名称database04Pool，在Database Name文本框中输入要连接的数据库名db_database04，在Host Name文本框中输入本机计算机名或IP地址，由于本实例使用的数据库服务器在本地计算机上，所以这里输入127.0.0.1，在Port文本框中输入数据库服务器的端口号1433，在Database User Name文本框中输入登录用户名mr，在Password和Confirm Password文本框中输入登录密码mrsoft（WebLogic服务器不允许登录密码为空），如图4.22所示。
图4.22 定义连接参数
（6）单击“Continue”按钮，进入Test database connection页面，此时WebLogic服务器已经根据图4.22所示页面中的参数自动生成了驱动类名、URL、服务器、数据库等信息，如图4.23所示。
图4.23 测试连接
（7）单击“Test Driver Configuration”按钮，测试驱动配置与数据库连接是否正确。如果连接成功将进入Connection Successful页面，单击“Create and Deploy”按钮，建立并发布JDBC连接池。
（8）JDBC连接池配置成功后，还需要配置数据源（Data Sources）。在图4.20所示的页面中选择“Services”→“JDBC”→“Data Sources”节点，在右侧打开的页面中单击Configure a new JDBC Data Source超级链接，进入“Configure the data source”页面。在Name文本框输入数据源名称database04DS，在JNDI Name文本框中输入JNDI（Java naming and Directory interface即Java命名接口）的名字“database04JNDI”，如图4.24所示。
图4.24 配置数据源
（9）单击“Continue”按钮，进入Connect to connection pool页面。在Pool Name下拉列表中，选择刚刚建立的连接池database04Pool，如图4.25所示。
图4.25 连接数据源与连接池
（10）单击“Continue”按钮，在进入的页面中单击“Create”按钮，创建数据源。至此，WebLogic的数据连接池配置完毕。
接下来讲解实例开发的操作步骤。
（1）编写连接SQL Server数据库的ConnDB类，将其保存到com.core包中。首先定义相应的全局变量，然后定义查询数据库的方法executeQuery()，在该方法中通过WebLogic服务的JNDI名字访问指定数据源，获取数据库配置信息，并连接数据库。关键代码如下：
package com.core;
import java.sql.*;
import javax.sql.*;
import javax.naming.Context;
public class ConnDB{
public Connection conn = null;
public Statement stmt = null;
public ResultSet rs = null;
public Context context = null;
}
public ResultSet executeQuery(String sql){
try {
Context ctx = new InitialContext();
DataSource ds = (DataSource) ctx.lookup("database04JNDI");
conn = ds.getConnection();
stmt = conn.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_READ_ONLY);
rs = stmt.executeQuery(sql);
} catch (Exception ex) {
System.err.println(ex.getMessage());
} finally {}
return rs;
}
（2）创建index.jsp页面，通过JavaBean标签调用数据库操作类CooDB，执行executeQuery()方法查询出公告信息，最后通过while循环语句，输出查询结果集。关键代码如下：
<jsp:useBean id="conn" scope="page" class="com.core.ConnDB"/>
<%ResultSet rs= conn.executeQuery("select * from tb_BBS");%>
<%
int ID_bbs=0;
String title="";
try{
while(rs.next()){
ID_bbs=rs.getInt(1);
title=rs.getString(2);
%>
<tr>
<td height="24" class="tableBorder_T_dashed"><a href="#"><%=title%></a></td>
</tr>
<% }
}catch(Exception e){
System.out.println(e.getMessage());
}
%>
举一反三
根据本实例，读者可以：
通过WebLogic连接池连接MySQL数据库；
通过WebLogic连接池连接Oracle数据库。
实例078 通过Hibernate连接SQL Server数据库
本实例是一个典型的、连接数据库的程序
实例位置：光盘\mingrisoft\04\078
实例说明
在开发软件的过程中，对数据的持久化是必须的，Hibernate对数据持久化进行了简单的封装，只需要简单的配置，就可以通过Hibernate进行数据持久化操作了，并且可以通过修改Hibernate配置文件将软件从一种数据库移到另一种数据库。运行本实例，将查询“性别”为“男”的员工信息，如图4.26所示。
图4.26 应用Hibernate连接SQL Server数据库
技术要点
Hibernate与数据库建立连接，主要通过默认文件路径下的配置文件hibernate.cfg.xml获取配置信息，本例配置文件的完整代码如下：
<?xml version='1.0' encoding='UTF-8'?>
<!DOCTYPE hibernate-configuration
PUBLIC "-//Hibernate/Hibernate Configuration DTD//EN"
"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
<session-factory>
<property name="connection.driver_class">com.microsoft.jdbc.sqlserver.SQLServerDriver </property>
<property name="connection.url">jdbc:microsoft:sqlserver://127.0.0.1:1433;databaseName=db_database04 </property>
<property name="connection.username">sa</property>
<property name="connection.password"> </property>
<property name="show_sql">true</property>
<mapping resource="mrgf/HibernateJoin.hbm.xml"/>
</session-factory>
</hibernate-configuration>
其中，元素connection.driver_class用来指定连接数据库所用的驱动包，具体为msbase.jar、mssqlserver.jar和msutil.jar三个包，需要将它们复制到Web工程的lib文件夹下。
元素connection.url用来指定要连接的数据库的路径，IP“127.0.0.1”代表本机，“1433”为端口号，“db_database04”为要连接的数据库的名称。
元素connection.username用来指定连接数据库的用户名，本实例的用户名是sa。
元素connection.password用来指定连接数据库的用户密码，本实例用户密码为空。
元素show_sql为true时表示程序运行时将生成的SQL语句输出到控制台，为false时则不输出，建议在编码时将其设为true，以便跟踪程序的运行情况，方便调试，在发布之前将其改为false，因为向控制台输出SQL语句会影响软件的运行速度。
元素<mapping>用来指定持久化类的映射文件，可以有多个。
实现过程
（1）Hibernate包的获得与放置。Hibernate包可以到它的官方网站（http://www.hibernate.org）下载。如果不采用开发工具，可以直接将lib文件夹内的所有Jar包和与lib同目录的Jar包复制到Web-INF/lib文件夹内；否则，引入方法因开发工具而定。
（2）配置Hibernate配置文件hibernate.cfg.xml。该文件存储于src文件夹下。代码及解析见本例的技术要点。
（3）创建数据表。表结构如图4.27所示。
图4.27 数据库表结构
（4）编写持久化类HibernateJoin.java及其对应的映射文件HibernateJoin.hbm.xml。持久化类符合JavaBean规范，没有引入任何Hibernate API，它包含一些属性及与其对应的setXXX()和getXXX()方法，作用是存放对应数据表字段的值。部分代码如下：
public class HibernateJoin{
private int id;
private String name;
private Date birthday; //birthday的类型为java.sql.Date
public int getId() {
return id;
}
public String getName() {
return name;
}
public Date getBirthday() {
return birthday;
}
public void setId(int id) {
this.id = id;
}
public void setName(String name) {
this.name = name;
}
public void setBirthday(Date birthday) {
this.birthday = birthday;
}
// 此处省略了部分属性和方法
}
映射文件负责建立持久化类中属性与数据表中字段之间的映射关系。关键代码如下：
<hibernate-mapping>
<class name="mrgf.HibernateJoin" table="tb_hibernateJoin">
<id name="id" column="id" type="int">
<generator class="increment"/>
</id>
<property name="name" column="name" type="string"/>
<property name="birthday" column="birthday" type="java.sql.Date"/>
</class>
</hibernate-mapping>
注意：持久化类和对应的映射文件应放在同一目录下。
（5）编写基于持久化的业务逻辑类。为了提高软件的运行效率，应该在静态代码块中加载Hibernate配置信息，因为它仅须在该类第一次被初始化时执行一次，负责创建一个Configuration类的实例，Configuration类的构造方法负责把默认文件路径下的Hibernate配置文件hibernate.cfg.xml中的配置信息读入内存，主要包括底层数据库信息，如数据库驱动和URL等，数据表与对应持久化类之间的映射信息，即*.hbm.xml文件内的信息也同时被加载，然后通过Configuration类的实例创建一个SessionFactory类实例，并将所有配置信息复制到SessionFactory类实例的缓存中，关键代码如下：
public class Hibernate {
private static SessionFactory sessionFactory;
static {
try {
Configuration config = new Configuration().configure();
sessionFactory = config.buildSessionFactory();
} catch (Exception e) {
System.out.println("------在初始化Hibernate时抛出异常，内容如下：");
e.printStackTrace();
}
}
private Session session = null;
private Transaction tx = null;
public List query(String hql) {
session=sessionFactory.openSession(); //打开Session
tx=session.beginTransaction(); //开启事务
List result=null; //开始检索数据
try {
Query query = session.createQuery(hql);
result = query.list();
} catch (Exception e) {
e.printStackTrace();
} //检索数据结束
tx.commit(); //提交事务
session.close(); //关闭Session
return result;
}
}
注意：SessionFactory类是一个重量级对象，对于每个数据库只需创建一个SessionFactory类的实例，这也是将该段代码放在static静态块中的主要原因。
（6）编写index.jsp页面，调用query()方法检索数据，并遍历检索结果。关键代码如下：
<%
Hibernate hibernate = new Hibernate();
List result=hibernate.query("from HibernateJoin"+where);
for(int i=0;i<result.size();i++){
HibernateJoin join=(HibernateJoin)result.get(i);
%>
<tr align="center">
<td><%=join.getId() %></td>
<td><%=join.getName() %></td>
<td><%=join.getBirthday() %></td>
</tr>
<%
}
%>
举一反三
根据本实例，读者可以：
应用Hibernate连接带登录密码的数据库；
应用Hibernate连接SQL Server 2005。