于是，我的代码如下：

       parentComposite.setLayout(new FillLayout());
        ScrolledComposite scrolledComposite = new ScrolledComposite(parentComposite,  SWT.H_SCROLL|SWT.V_SCROLL);
       
        Composite mainComposite = new Composite(scrolledComposite,SWT.NONE);
        scrolledComposite.setContent(mainComposite);
        mainComposite.setBackground(Display.getCurrent().getSystemColor (SWT.COLOR_WHITE));// White color
        mainComposite.setLayout(new GridLayout(1,true));
        GridData data = new GridData(GridData.FILL_BOTH);
        mainComposite.setLayoutData(data);
      

        Composite topComposite = new Composite(mainComposite, SWT.BORDER);
        topComposite.setLayout(new GridLayout(2, false));
        topComposite.setBackground(Display.getCurrent().getSystemColor(SWT.COLOR_WHITE));// White color

        reloadBtn = new Button(topComposite, SWT.PUSH);
        reloadBtn.setText("&Reload from preferences");
        reloadBtn.setToolTipText("Reload values from preference page(Shift+R)");

        saveBtn = new Button(topComposite, SWT.PUSH);
        saveBtn.setText("&Save to preferences");
        saveBtn.setToolTipText("save values to preference page(Shift+S)");
       
        scrolledComposite.setExpandHorizontal(true);
        scrolledComposite.setExpandVertical(true);
        scrolledComposite.setMinWidth(800);
        scrolledComposite.setMinHeight(400);

 总结：
 1）在为Composite添加滚动条时，最上面的Composite的布局需设为FillLayout();
 2) 不要直接往scrolledComposite上面添加控件;
 3) 在创建完ScrolledComposite后不要忘记使用setContent()方法去设置滚动条所控制的Composite;
 4) 最重要的是,Scrolledcomposite的以下四个参数必须设置才能出现滚动条：
    scrolledComposite.setExpandHorizontal(true);
    scrolledComposite.setExpandVertical(true);
    scrolledComposite.setMinWidth(800);
    scrolledComposite.setMinHeight(400);
    只有前两项设为true之后，后面的两项才起作用。
5） 对于setMinWidth()和setMinHeight()方法，API的注释中是说用来设置滚动条出现的最小宽度和高度，但是我试了一下，有时出现滚动条了，
    但是拖动滚动条还是不能显示Composite里面的全部内容，于是把setMinWidth()和setMinHeight()设大一些就可以了，个人感觉滚动条出现的
    宽度和高度检测Scrolledcomposite自己已经实现了，这里的宽度和高度是指拖动滚动条里可以看到的Composite的最大宽度和最大高度。

 <viewerContribution
            id="test.viewerContribution1"
            targetID="test.testView" >
         <action
               class="test.AddTestDelegate"
               id="add.a"
               label="A"
               menubarPath="test"/>
         <action
               class="test.AddTestDelegate"
               id="add.b"
               label="B"
               menubarPath="test"/>
         <action
               class="test.AddTestDelegate"
               id="add.c"
               label="C"
               menubarPath="test"/>
         <action
               class="test.AddTestDelegate"
               id="add.d"
               label="D"
               menubarPath="test"/>
      </viewerContribution>

    上面的主要区别是在id，在所有的代理ActionDelegate中的run(IAction action)方法中都带有一个参数action，这个参数有个用途就是可以在运行时区别是对应的那个action。下面我们看一下AddTestDelegate类的定义：

 1package test;
 2
 3import org.eclipse.jface.action.IAction;
 4import org.eclipse.jface.viewers.ISelection;
 5import org.eclipse.ui.IViewActionDelegate;
 6import org.eclipse.ui.IViewPart;
 7
 8public class AddTestDelegate implements IViewActionDelegate {
 9
10    private IViewPart view;
11    public AddTestDelegate() {
12        // TODO 自动生成构造函数存根
13    }
14
15    public void init(IViewPart view) {
16        this.view = view;
17
18    }
19
20    public void run(IAction action) {
21        String id = action.getId();
22        
23        if(id.equals("add.a")){
24            //TODO
25        }else if(id.equals("add.b")){
26            //TODO
27        }else if(id.equals("add.c")){
28            //TODO
29        }else if(id.equals("add.d")){
30            //TODO
31        }
32
33    }
34
35    public void selectionChanged(IAction action, ISelection selection) {
36        // TODO 自动生成方法存根
37
38    }
39
40}

    我们可以在运行时通过action.getId()在识别是对应的那个Action。
   总结：这个途径可以为插件开发中避免写过多的ActionDelegate，把一些功能较为接近实现代码又比较少的操作合并在一起。当然，对于操作步骤比较多的，为了代码维护的方便，还是建议单独为它定义一个代理。
      

请确认jdk版本>=1.5

本插件已经在
eclipse3.2.1
wtp1.5.2
myeclipse5.1
jdk6
jdk5
环境下测试通过

　　安装Eclipse和安装MyEclipse组件的过程在这里不进行介绍。可以参考其它资料完成Eclipse环境的安装与资源的配置。

　　接下来的篇幅将给出一个在MyEclipse开发环境下的一个Web工程实例。说明在MyEclipse的集成开发环境下，如何利用Struts进行Web工程开发。

例子工程的环境：

Windows 2000 Professional或者更高的版本。
J2SDK 5.0
Apache Tomcat 5.0
MySQL 4.0.14b
Eclipse-SDK-3.1
MyEclipse 4.0
SQLyog407(可选)

2. 例子工程说明

　　本例子是利用struts架构，实现用户logon的Web工程。在这个工程中，用户可以访问三个页面，index.jsp、logon.jsp、menu.jsp。他们的关系如下图所示：

　　其中，左上角的方框代表struts结构中/WEB-INF/struts-config.xml中定义的，<global-forwards>，也就是在整个Web工程中，只要有logon的动作发生，都会使画面转移到logon.jsp。那么处理logon.jsp画面的formbeen是上图上放右侧的模块表示的formbean来完成——logonForm。

　　LogonFrom处理后会有两个结果，“success”的时候，画面会转移到menu.jsp，失败的话，回到logon画面。

　　在logon画面，用户需要输入用户名和密码，点击submit，进行登录认证。输入内容的检测是在logonForm的bean中检查。判断操作在logonAction的bean中完成，在logonAction的bean中，需要访问MySql数据库的Account表格，进行用户和密码的查询。查询成功的话，证明用户认证通过。

3. 建立工程

3.1 v创建新的Web Project

　　启动MyEclipse，通过Wizard，建立一个Web工程。如下图：

　　点击project后，MyEclipse弹出工程的对话框，我们在所罗列的工程中选中MyEclipse下面的J2EE Projects的Web Project。如下图所示：

　　在Wizard的下一页，必要的输入信息是Project Name、Context root URL。最后点击finish，一个空的WebProject就已经建立起来了

3.2 加载Struts

　　在新创建的Web Project中加载struts。

　　在MyEclipse集成开发环境下，已经集成了struts开发的环境，用户可以根据自己的实际需要，加载struts的环境。加载过程如下图：

　　右键点击刚刚创建好的工程，点击MyEclipse属性，在扩展的右键菜单里面，选择Add Struts Capabilities。

　　MyEclipse集成环境就会自动将Struts所需要的目录结构进行创建，并将需要的环境资源自动引用到相应的目录中去。

　　我们还要对自动生成的Struts进行修正，首先，修改WEB-INF/web.xml 将<web-app>标签中的属性删除。<web-app XXXXXXXXXXXXXXX> -> <web-app>

　　其次要添加本工程的标签定义库，添加<taglib></taglib>
<taglib>
    <taglib-uri>/WEB-INF/app.tld</taglib-uri>
    <taglib-location>/WEB-INF/app.tld</taglib-location>
  </taglib>
  <taglib>
    <taglib-uri>/WEB-INF/struts-bean.tld</taglib-uri>
    <taglib-location>/WEB-INF/struts-bean.tld
</taglib-location>
  </taglib>
  <taglib>
    <taglib-uri>/WEB-INF/struts-html.tld</taglib-uri>
    <taglib-location>/WEB-INF/struts-html.tld
</taglib-location>
  </taglib>
  <taglib>
    <taglib-uri>/WEB-INF/struts-logic.tld</taglib-uri>
    <taglib-location>/WEB-INF/struts-logic.tld
</taglib-location>
  </taglib>

4. 完善工程

4.1 添加index画面

　　在加载完Struts结构之后，就可以在这个工程中添加内容了。我们可以添加一个画面JSP。添加JSP很简单，点击工程的右键，添加JSP。Wizard会弹出一个添加的对话框。如下图：

　　在File Name栏中改变文件名称，改成index.jsp把这个jsp作为Web工程的第一个画面。

　　Template To Use 栏可以选择第五项（选择选择其他项也可以）。

　　对于新生成的jsp文件进行必要的修改。

Index.jsp文件：
<taglib>
<%@ page language="java" pageEncoding="UTF-8"%>

<%@ taglib uri="/WEB-INF/struts-bean.tld" prefix="bean" %>
<%@ taglib uri="/WEB-INF/struts-html.tld" prefix="html" %>
<%@ taglib uri="/WEB-INF/struts-logic.tld" prefix="logic" %>

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
  <head>
    <title>My JSP 'index.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">
   
    <!--
    <link rel="stylesheet" type="text/css" href="styles.css">
    -->
  </head>
 
  <body>
  <h3><bean:message key="index.heading"/></h3>
<html:link page="/logon.jsp"><bean:message key="index.logon"/></html:link>
</body>
</html>

　其中蓝色和橙色部分是修改的内容，蓝色部分是今后自动添加jsp文件必须修改的地方，让这个页面用到的tag都能在这个工程中定义的tag集合中找到。

　　橙色部分是画面的主要显示内容。<h3></h3>的内容是一段文本，内容被struts结构的静态文本集合中的index.heading给替换掉了。这个文本的内容可以在工程的src\com\yourcompany\struts\ApplicationResources.properties文件中找到。Struts结构推荐用户将页面上的静态文本用ApplicationResources的形式替换。这样可以在大量的维护页面文字时候，感到便捷很多，同时，也大大减轻了多国语言版本网页的维护。

　　<html:link page="/logon.jsp">相当于html语言中的<a herf=xxxxx>。这个tag是在/WEB-INF/struts-html.tld中可以找到并在显示页面的时候，被转义成<a herf=xxxxx>

4.2 添加logon画面

　　添加方法跟添加index画面相同。修改内容稍微有些差别。

Logon.jsp的内容：

<taglib>
<%@ page language="java" pageEncoding="UTF-8"%>

<%@ taglib uri="/WEB-INF/struts-bean.tld" prefix="bean" %>
<%@ taglib uri="/WEB-INF/struts-html.tld" prefix="html" %>
<%@ taglib uri="/WEB-INF/struts-logic.tld" prefix="logic" %>

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html:html locale="true">
  <head>
    <html:base />
   
    <title>logon.jsp</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>
    <html:form action="/logon.do" method="post"  focus="userName">
      <table border="0">
        <tr>
          <td><bean:message key="prompt.username"/></td>
          <td><html:text property="userName" /></td>
        </tr>
        <tr>
          <td>Password:</td>
          <td><html:password property="password" /></td>
        </tr>
        <tr>
          <td colspan="2" align="center"><html:submit /></td>
        </tr>
      </table>
    </html:form>
  </body>
</html:html>

　　其中，蓝色部分是引用本工程的tag标示库，红色的部分是表单属性名称的修改，和指定action动作的名称。

4.3 修改WEB-INF/struts-config.xml

　　画面上出现了form，那么根据struts的结构要求，就必须在WEB-INF/struts-config.xml中明确这个form的formbean（表单内容校验的java class）是什么。执行这个form的action（表单执行的内部逻辑）是什么，以及action的结果会产生怎样的画面迁移。这些都是在WEB-INF/struts-config.xml中定义的。也就是标准的MVC架构所要求的。
<taglib>
<struts-config>
  <form-beans >
    <form-bean name="logonForm" type="com.yourcompany.forms.
LogonForm" />
  </form-beans>

  <global-forwards >
    <forward name="logon" path="/logon.jsp" />
  </global-forwards>

  <action-mappings >
    <action
      path="/logon"
      type="com.yourcompany.actions.LogonAction"
      name="logonForm"
      scope="request"
      input="/logon.jsp">
      <forward name="success" path="/menu.jsp" />
      <forward name="fails" path="/logon.jsp" />
    </action>
  </action-mappings>

  <message-resources parameter="com.yourcompany.struts.
ApplicationResources" />
</struts-config>

　　其中<action>部分是说明action的属性。

　　Path 指定Action处理的URL

　　Type 指定Action的类名

　　Name 指定Action主力的ActionForm名，与<form-beans >元素的name属性匹配。

　　Scope 指定ActionForm存在的范围

　　Input 指定包含客户提交表单的网页，如果ActionForm的Validate方法返回错误，则因该把用户请求转发到这个网页。

　　Validate 如果取值为true，则表示ActionServlet应该调用ActionForm的validate方法

　　Forward 就是Action的execute方法执行完毕后，把客户请求在转发给相应的页面。

4.4 添加formbean和actionbean

　　添加方法跟JSP相同，但是在选择superclass的时候，formbean要选择ActionForm作为类的父类。Actionbean的父类是Action

　　下面是各自的代码

LogonForm.java文件内容:

<taglib>
package com.yourcompany.forms;
import javax.servlet.http.HttpServletRequest;

import org.apache.struts.action.ActionForm;
import org.apache.struts.action.ActionMapping;

public class LogonForm extends ActionForm {

private static final long serialVersionUID
= 7322786881443789688L;
// ------------------------------
--------------------------- Instance Variables
    private String username = null;
    private String password = null;

// -------------------------
-------------------------------- Methods
    public String getUserName() {
return (this.username);
    }

    public void setUserName(String username) {
        this.username = username;
    }

    public String getPassword() {
return (this.password);
    }

    public void setPassword(String password) {
        this.password = password;
    }

public void reset(ActionMapping mapping,
HttpServletRequest request) {
this.password = null;
this.username = null;
}

}

LogonAction.java文件：
package com.yourcompany.actions;

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 com.yourcompany.forms.LogonForm;

public class LogonAction extends Action {

public ActionForward execute(ActionMapping
mapping, ActionForm form,
HttpServletRequest request,
HttpServletResponse response) {

String userName = null;
String password = null;

if (form != null) {
userName = ((LogonForm) form).getUserName();
password = ((LogonForm) form).getPassword();
}
if(userName.equals(“test1”) && password.
equals(“test1”)){
return (mapping.findForward("success"));
}
else{
return (mapping.findForward("fails"));
}
}

}

4.5 添加menu画面

　　与添加index画面的方法相同。下面是menu.jsp文件的内容

<taglib>
<%@ page language="java" pageEncoding="UTF-8"%>

<%@ taglib uri="/WEB-INF/struts-bean.tld" prefix="bean" %>
<%@ taglib uri="/WEB-INF/struts-html.tld" prefix="html" %>
<%@ taglib uri="/WEB-INF/struts-logic.tld" prefix="logic" %>

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html:html locale="true">
  <head>
    <html:base />
        <title>menu.jsp</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>
  <h3><bean:message key="menu.message"/></h3>
  </body>
</html:html>

5. 调试工程

如果本地机器已经安装了Tomcat5，那么可以在MyEclilpse的环境下调试工程了。

指定Tomcat5 的web application service 如下图：

将Enable选项打开，并且指定Tomcat的安装目录。

配置目前的工程到Tomcat中去。

点选工具栏上的被红线圈出的按钮

在弹出来的对话框中选择，我们创建的工程，和添加Tomcat5 的web application service

然后就可以按下工具栏上的启动服务按钮，调试这个Web工程了。

每一次改动工程中的文件后，要想看看改动后的效果，那么就在配置工程中，重新发布这个工程到tomecat5去。

6. Tomcat下如何配置mysql的数据库连接池

6.1 配置server.xml

配置Tomcat的server.xml文件，路径：【TOMCAT_HOME】\common\lib下的server.xml文件在</host>之前加入以下内容以添加JNDI数据源：

<taglib>
<Context path="/DBTest" docBase="DBTest"
        debug="5" reloadable="true" crossContext="true">
  <Logger className="org.apache.catalina.logger.FileLogger"
             prefix="localhost_DBTest_log." suffix=".txt"
             timestamp="true"/>
  <Resource name="jdbc/TestDB"
               auth="Container"
               type="javax.sql.DataSource"/>
  <ResourceParams name="jdbc/TestDB">
    <parameter>
      <name>factory</name>
    <value>org.apache.commons.dbcp.BasicDataSourceFactory</value>
    </parameter>
    <!-- Maximum number of dB connections in pool. Make sure you
         configure your mysqld max_connections large enough to handle
         all of your db connections. Set to 0 for no limit.
         -->
    <parameter>
      <name>maxActive</name>
      <value>100</value>
    </parameter>
    <!-- Maximum number of idle dB connections to retain in pool.
         Set to 0 for no limit.
         -->
    <parameter>
      <name>maxIdle</name>
      <value>30</value>
    </parameter>
    <!-- Maximum time to wait for a dB connection to become available
         in ms, in this example 10 seconds. An Exception is thrown if
         this timeout is exceeded.  Set to -1 to wait indefinitely.
         -->
    <parameter>
      <name>maxWait</name>
      <value>10000</value>
    </parameter>
    <!-- MySQL dB username and password for dB connections  -->
    <parameter>
     <name>username</name>
     <value>root</value>
    </parameter>
    <parameter>
     <name>password</name>
     <value> </value>
    </parameter>
    <!-- Class name for mm.mysql JDBC driver -->
    <parameter>
       <name>driverClassName</name>
       <value>org.gjt.mm.mysql.Driver</value>
    </parameter>
    <!-- The JDBC connection url for connecting to your MySQL dB.
         The autoReconnect=true argument to the url makes sure that the
         mm.mysql JDBC Driver will automatically reconnect if mysqld closed the
         connection.  mysqld by default closes idle connections after 8 hours.
         -->
    <parameter>
      <name>url</name> <value>jdbc:mysql://192.168.0.208:3306
/db_test_account?autoReconnect=true</value>
    </parameter>
  </ResourceParams>
</Context>

注意:

*其中蓝色字体表示你这个应用的路径和别名,也就是你访问自己配置的这个web站点的名字,注意区分大小写,必须一致,否则系统无法正常运行(例:http://localhost:8080/DBTest)

*其中红色字体表示数据源的名字,注意将会被web.xml和你访问数据库的程序调用

6.2 配置web.xml

配置Web用程序的web.xml文件

<taglib>
<?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>
  <description>MySQL Test App</description>
  <resource-ref>
      <description>DB Connection</description>
      <res-ref-name>jdbc/TestDB</res-ref-name>
      <res-type>javax.sql.DataSource</res-type>
      <res-auth>Container</res-auth>
  </resource-ref>
</web-app>

6.3 访问数据库的程序片段

<taglib>
package swt.db.DBUtility;

import javax.naming.*;
import javax.sql.*;
import java.sql.*;

public class DBTest {

  String foo = "Not Connected";
  int bar = -1;
    
  public void init() {
    try{
      Context ctx = new InitialContext();
      if(ctx == null ) 
          throw new Exception("Boom - No Context");
      DataSource ds = 
            (DataSource)ctx.lookup(
               "java:comp/env/jdbc/TestDB");
      if (ds != null) {
        Connection conn = ds.getConnection();     
        if(conn != null)  {
            foo = "Got Connection "+conn.toString();
            Statement stmt = conn.createStatement();
            ResultSet rst = 
                stmt.executeQuery(
                  " select UserName from t_account ");
            if(rst.next()) {
               foo=rst.getString(1);
               bar=208;
            }
            conn.close();
        }
      }
    }catch(Exception e) {
      e.printStackTrace();
    }
}
public String getFoo() { return foo; }
public int getBar() { return bar;}
}

6.4 Jsp页面(index.jsp)

<taglib>
<%@ page language="java" pageEncoding="UTF-8"%>
<%@ page import ="swt.db.DBUtility.*" %>
<html>
  <head>
    <title>DB Test</title>
  </head>
  <body>
  <%
    DBTest tst = new DBTest();
    tst.init();
  %>
  <h2>Results</h2>
    Foo <%= tst.getFoo() %><br>
    Bar <%= tst.getBar() %>
  </body>
</html>

启动Tomcat在浏览器上输入http://localhost:8080/DBTest

备注：

连接池配置(Database Connection Pool (DBCP) Configurations)
DBCP使用的是Jakarta-Commons Database Connection Pool 要使用连接池需要如下的组件即jar文件

Jakarta-Commons DBCP 1.1 对应commons-dbcp-1.1.jar。
Jakarta-Commons Collections 2.0 对应commons-collections.jar。
Jakarta-Commons Pool 1.1 对应commons-pool-1.1.jar。
这三个jar文件要与你的JDBC驱动程序一起放到【TOMCAT_HOME】\common\lib目录下以便让tomcat和你的web应用都能够找到。
7. Tomcat5.0下配置Hibernate3.0应用

7.1 在Tomcat下建立数据库连接池，如6中所示

7.2 在Struts应用中添加Hibernate3.0支持

注意：hibernate.cfg.xml文件一定要存放到跟目录下，默认的也就是/web应用/src,这个部署这个应用的时候hibernate.cfg.xml才会出现在classes目录下，也就是hibernate存放配置文件的默认录入下.

由于我们采用Tomcat提供的数据库连接池，所以这里我们将是用自己创建的SessionFactory类。点击完成MyEclipse会自动把Hibernate所需的的类库加入到当前应用中。接下来就是配置Hibernate连接数据库的所需的参数，以及性能参数（可选）。

既然我们选用应用服务器所提供的数据库连接池，那么在这里我们只须要指定数据源的名字：java:comp/env/jdbc/TestDB，其中jdbc/TestDB就是我们在Tomcat中配置的数据源，也就是我们上面提到的jdbc/TestDB，资源名称一定要匹配。其他的参数由于已经在Tomcat中配置过了，所以在这里就不用配置了，Dialect一定要指定跟我们数据库匹配的语言。 既然我们选用应用服务器所提供的数据库连接池，那么在这里我们只须要指定数据源的名字：java:comp/env/jdbc/TestDB，其中jdbc/TestDB就是我们在Tomcat中配置的数据源，也就是我们上面提到的jdbc/TestDB，资源名称一定要匹配。其他的参数由于已经在Tomcat中配置过了，所以在这里就不用配置了，Dialect一定要指定跟我们数据库匹配的语言。

我们可以在这里配置Hibernate一些调整性能的参数（针对不同的数据库有些属性可能无效）。

在这里我们设置show_sql为true，这样在开发调试过程成控制台可以打印真正在数据库端执行的sql语句便于查找问题。其他一些属性可以参阅http://www.hibernate.org。
到这里Hibernate的配置已经基本完成，下面创建SessionFactory用来和数据库进行交互（Hibernate官方文档提供）。
package com.db;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

public class HibernateUtil {

    private static Log log =
LogFactory.getLog(HibernateUtil.class);

    private static final SessionFactory sessionFactory;

    static {
        try {
            sessionFactory = new Configuration().configure().
buildSessionFactory();
        } catch (Throwable ex) {
            log.error("Initial SessionFactory
creation failed.", ex);
            throw new ExceptionInInitializerError(ex);
        }
    }

    public static final ThreadLocal session = new ThreadLocal();

    public static Session currentSession()  {
        Session s = (Session) session.get();
        if (s == null) {
            s = sessionFactory.openSession();
            session.set(s);
        }
        return s;
    }

    public static void closeSession() {
        Session s = (Session) session.get();
        if (s != null)
            s.close();
        session.set(null);
    }
}

后面将会提到如何使用HibernateUtil,下面建立我们所需的数据库
（略）我们可以使用208上的db_test_account这个数据库中的表message来测试我们的Hibernate配置是否成功。数据库样例：

建表语句：

CREATE TABLE `message` (              
           `Id` varchar(50) NOT NULL default '0',   
           `text` varchar(50) default NULL,    
           `nextMessage` int(4) default NULL,  
           PRIMARY KEY  (`Id`)                 
          ) TYPE=MyISAM

创建O/R Mapping:

点击Edit

点击New添加MySQL的驱动，保存

激活Database Explorer，保存。

选择Database Explorer，创建数据库链接：

点击创建新的数据库,添加所需必要的参数

保存，然后右键点击该数据库选择open database，测试是否配置成功，如果不能连接查看该连接的配置参数。

点击完成后MyEclipse会自动生成POJO和Map文件，并更新Hibernate的配置文件（主要是加载Map文件）。ID Generator选项可以根据你的需要进行选择，具体含义请参阅hibernate官方文档。下面建立一个测试用的jsp页面来看看Hibernate是否好用。
//MyJsp.jsp

<%@ page language="java" import="com.db.*" pageEncoding="UTF-8"%>
<%
String path = request.getContextPath();
String basePath = request.getScheme()+":
//"+request.getServerName()+":"+request.getServerPort()+path+"/";
%>

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
  <head>
    <base href="<%=basePath%>">
   
    <title>My JSP 'MyJsp.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">
   
    <!--
    <link rel="stylesheet" type="text/css" href="styles.css">
    -->
  </head>
 
  <body>
    <%   
org.hibernate.Session s = HibernateUtil.currentSession();
String hql = " from Message where text='b'";
try {
org.hibernate.Query query = s.createQuery(hql);
java.util.List msgList = query.list();
hello.Message msg = (hello.Message) msgList.get(0);
out.println(msg.getId());
out.println(msg.getText());
out.println(msg.getNextmessage());
} catch (org.hibernate.HibernateException e) {
e.printStackTrace();
}
HibernateUtil.closeSession();
    %>
  </body>
</html>

正常的结果如下：