LDAP（輕量級目錄服務器）越來越被廣泛的使用，特別是在管理海量用戶信息和管理身份認證信息的時候，LDAP被國內大多數企業所使用，從中國電信，中國移動，新浪，和許多省市政府部門都使用LDAP來管理用戶身份的信息。下面重點介紹在LDAP中管理用戶的一些概念和技巧。

LDAP服務器使用樹狀結構來存儲和查找用戶的信息。這種樹狀結構比較適合用戶身份信息的存儲，因為無論在社會還是在企業中，對人的管理是分層的。從地域上的國家、省市到區域，從企業的大部門到小部門，從總經理到小職員，所有的管理都是分層的。“人類的層次劃分是社會活動的自然產物”，忘了這句話是誰說的了，但是我們觀察自己的周圍環境，樹狀結構的分層無處不在，這也是LDAP為什么在人員管理上這么流行的原因，也是LDAP最初設計的需求。當然，在這里我們不討論人類社會活動現象，只討論LDAP技術問題。

LDAP在存儲樹狀結構的數據比關系型數據庫有很大的優勢。請試圖想想在關系數據庫中要實現這種樹狀的數據，需要費一番功夫，并且要定位層次比較深的節點的數據需要經過復雜的查詢和轉換。但是LDAP這種樹狀的結構也有一個重要的缺點，就是很難反映出除了結構層次之外的其他關系（例如在同一個組織之下的管理和被管理的關系），而且當組織結構經常發生變化的情況下，樹狀結構很難滿足這種靈活性的要求。有樹狀結構特點決定，當一個組織變化的時候，這個組織下的所有節點都需要一一變化。

因此，在LDAP中出現了Group（組）和Role（角色）來動態的管理節點之間的關系。例如，建立一個“管理員”的組或角色，然后可以將不同組織結構下的人員放到“管理員”這個邏輯結構下。那么通過“管理員”這個虛擬的組織結構可以將不同物理組織下的人員動態的組合在一起。例如給“管理員”賦予特殊的權力，使他們能夠修改本機構中的人員信息。過了一段時間，如果需要將“管理員”這個邏輯組織取消或者改動，只需要在LDAP的單個節點上操作，而實際“管理員”邏輯結構的成員們，不需要作任何的變化，原來是在哪個物理組織，現在也不用變化。這種Group（組）和Role（角色）的出現是增加了節點之間的關聯程度。

Group（組）和Role（角色）的功能基本相同，操作起來也很類似。那么Group（組）和Role（角色）到底有什么區別呢？事實上，由于實現方法不同，Group（組）和Role（角色）在某些操作上體現出不同的性能。

Group（組）的實現機制很簡單，每個Group本身就是LDAP的一個實體。這個實體有個member的屬性。每次將一個成員添加到這個Group中就會在Member屬性中添加一條記錄（成員的DN）。如果這個Group有200個成員，那么它的member屬性中會有200條記錄。這種實現方式非常適合下面的操作：1. 列舉當前Group下的所有成員。2.將一些成員從當前的Group中刪除或添加。因為所有的成員都記錄在Group實體的屬性里；這種實現方式非常不適合下面的操作：查找某個用戶所屬的所有Group。這個操作可能要去每個Group中查找信息。

Role（角色）的實現機制就比較復雜了。其實每個LDAP實體本身都有一個“nsrole”的屬性。如果某個角色賦予這個用戶的話，就會在這個用戶的“nsrole”（其實是nsroleDN,這個會在以后解釋）的屬性中添加一個角色的記錄。如果當前用戶有10個角色（例如，他又是領導，又是員工，又是管理員，又是教授....），那么在這個用戶的"nsrole"屬性中會有10條記錄（Role的DN）。這種實現方式非常適合下面的操作： 列舉當前用戶擁有的所有的角色，因為在用戶的“nsrole”屬性中記錄了所有的角色。因此給一個用戶授權通常使用角色，這是因為從用戶信息中就能很快獲得當前用戶所有的角色，以及相關的權限。

另外還有一些準則來幫助判斷在設計時到底使用Group還是Role。

1 使用Group會很容易將用戶從一系列“邏輯組織”中刪除或添加。只要是Group的創建者，就有權限修改Group中的member屬性。而角色（Role）的信息存在每個用戶的“nsroleDN”中，需要特定的權限才能修改這個屬性。

2 如果要使用分布式部署（例如使用Chaining的方式），要考慮到角色（Role）是無法跨越服務器的界限

3 如果成員數量巨大（超過20000）個，可以使用動態組的概念（FilterGroup），這個以后再將。

     摘要: Lucene in Action 中文版  第一部分 Lucene核心 1.      接觸Lucene  2.      索引 3.      為程序添加搜索 4.    ...  閱讀全文

---

以下的幾個服務器可以免費下載或者進行開發：

Blazix (1.5 Megabytes, JSP, Servlets and EJBs)
來自www.blazix.com/blazix.html

ServletExec (3.8 Megabytes, JSP and Servlets)
來自www.unifyeware.com/servletExec/

所周知，發布一個由JSP/SERVLET開發的網站，除了需要相應的WEB服務器來響應普通網頁的請求外還需要專門的應用服務器來響應動態網頁JSP/SERVLET的請求。對于商業用戶來說，目前最流行的應用服務器軟件要數BEA公司開發的WebLogic，下面介紹的是WebLogic5.1的版本。
先將WebLogic解壓到/usr目錄下，需要修改WebLogic安裝目錄下的StartWebLogic.sh腳本文件來來設置你的CLASSPATH和JAVA_HOME，最后也是通過這個腳本文件來啟動服務。現在啟動的服務還不支持JSP/EJB/Servlet等技術，所以還需要修改WebLogic安裝目錄下的weblogic.properties文件。下面就詳細介紹如何來配置這個文件。
------------------------------------------------------------------------------------------
第98行：
weblogic.system.listenPort=80
設置HTTP端口，默認是7001
第114行：
weblogic.password.system=11111111
設置啟動Console的密碼，默認密碼長度為8位
第139行：
weblogic.system.SSLListenPort=7002
設置SSL端口，默認是7002
第236行：
weblogic.system.minPasswordLen=8
設置最小密碼長度，默認為8位
第495行-第508行：
設置你自己的RMI，命令格式如下：
weblogic.system.startupClass.[virtualName]=[fullPackageName]
例如：
weblogic.system.startupClass.hello=examples.rmi.hello.HelloImpl
第524行：
#weblogic.ejb.deploy=
# /usr/WebLogic/myserver/Your_Ejb.jar,
默認情況是不允許使用EJB，如果要使用可以把前面的注釋去掉，再設置你的EJB的路徑
第539行-第543行：
增加用戶列表，命令格式如下：
weblogic.password.[username]=XXX
例如：
weblogic.password.xxx=11111111
第604行：
weblogic.httpd.session.enable=true
允許在服務器端使用session；session在開發電子商務程序時非常有用
第663行-第674行：
663行：#weblogic.jdbc.connectionPool.db2Pool=
664行：# url=jdbc:db2//localhost/database,
665行：# driver=COM.ibm.db2.jdbc.net.DB2Driver,
666行：# loginDelaySecs=1,
667行：# initialCapacity=4,
668行：# maxCapacity=10,
669行：# capacityIncrement=2,
670行：# allowShrinking=true,
671行：# shrinkPeriodMins=15,
672行：# refreshMinutes=10,
673行：# testTable=table,
674行：# props=user=db2admin;password=db2admin
設置你要使用到的JDBC POOL，默認情況是不允許使用，如果要使用JDBC POOL可以將前面的注釋去掉，不過首先你的JDBC驅動程序必須是在StartWebLogic.sh的CLASSPATH中已經存在的。其中663行是設置JDBC POOL的名字(如db2Pool)；664和665行是注冊JDBC驅動程序以及連接的數據庫；667行為缺省的連接數；668行為連接池中最大連接數；674行為連接數據庫的用戶名和密碼
第767行：
weblogic.httpd.register.*.shtml=weblogic.servlet.ServerSideIncludeServlet
允許使用SSI，即允許使用.shtml為后綴的擴展名
第790行：
weblogic.httpd.register.servlets=weblogic.servlet.ServletServlet
允許使用Servlet，例如URL：
http://localhost/servlets/foo/hello
則實際路徑為：
/home/servlet/foo/hello.class
第814行：
weblogic.httpd.documentRoot=/home/www/
此行為設定WEB頁面的發布目錄
第831行：
weblogic.httpd.servlet.classpath=/home/servlet
此行用來設置放置Servlet等class文件的目錄，當然這個目錄還必須在StartWebLogic.sh的CLASSPATH中已經存在的
第861行-第868行：
861行：#weblogic.httpd.register.*.jhtml=
862行：# weblogic.servlet.jhtmlc.PageCompileServlet
863行：#weblogic.httpd.initArgs.*.jhtml=
864行：# pageCheckSeconds=1,
865行：# packagePrefix=examples.jhtml,
866行：# compileCommand=/usr/java/bin/javac,
867行：# workingDir=/home,
868行：# verbose=true
這幾行是用來支持JHTML技術的，默認是不能使用JHTML擴展名，如果想使用JHTML，將前面的注釋去掉即可。861行后面的*.jhtml用來注冊使用擴展名為jhtml的任意文件；866行設置javac的目錄
第878行-第884行：
878行：#weblogic.httpd.register.*.jsp=
879行：# weblogic.servlet.JSPServlet
880行：#weblogic.httpd.initArgs.*.jsp=
881行：# pageCheckSeconds=1,
882行：# compileCommand=/usr/java/bin/javac,
883行：# workingDir=/home,
884行：# verbose=true
這幾行是用來支持JSP的，默認是不能使用JSP擴展名，如果想使用JSP，將前面的注釋去掉即可。878行后面的*.jsp用來注冊使用擴展名為jsp的任意文件；882行設置javac的目錄；在WebLogic中如果要運行test.jsp文件，是先將這個文件編譯成_test.class后在運行的，所以第883行設置的目錄就是用來放編譯后的.class文件用的

JRun (11 Megabytes, JSP, Servlets and EJBs)
來自www.jrun.com/

WebLogic(44 Megabytes, JSP, Servlets and EJBs)
來自www.beasys.com/

WebSphere (105 Megabytes, JSP, Servlets and EJBs)
來自www-4.ibm.com/sofeware/webservers/

以下的幾個服務器可以免費下載或者進行開發：

Blazix (1.5 Megabytes, JSP, Servlets and EJBs)
來自www.blazix.com/blazix.html

ServletExec (3.8 Megabytes, JSP and Servlets)
來自www.unifyeware.com/servletExec/

JRun (11 Megabytes, JSP, Servlets and EJBs)
來自www.jrun.com/

WebLogic(44 Megabytes, JSP, Servlets and EJBs)
來自www.beasys.com/

WebSphere (105 Megabytes, JSP, Servlets and EJBs)
來自www-4.ibm.com/sofeware/webservers/

以下的幾個服務器可以免費下載或者進行開發：

Blazix (1.5 Megabytes, JSP, Servlets and EJBs)
來自www.blazix.com/blazix.html

ServletExec (3.8 Megabytes, JSP and Servlets)
來自www.unifyeware.com/servletExec/

JRun (11 Megabytes, JSP, Servlets and EJBs)
來自www.jrun.com/

WebLogic(44 Megabytes, JSP, Servlets and EJBs)
來自www.beasys.com/

WebSphere (105 Megabytes, JSP, Servlets and EJBs)
來自www-4.ibm.com/sofeware/webservers/

使用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來為復雜的數據表進行映射，并且維護它們之間的關系。 參考資料 http://www.apache.org 下載Tomcat。 Hibernate的官方網站，http://hibernate.bluemars.net/ ，包含了Hibernate最新資料。 Hibernate中文論壇，hibernate.fankai.com包含了Hibernate較多的參考資料。 包含了Hibernate技術討論網站，www.jdon.com， 于Hibernate、JDO、CMP等技術的熱烈討論1： http://www.jdon.com/jive/thread.jsp?forum=16&thread=6062&start=0&msRange=15 于Hibernate、JDO、CMP等技術的熱烈討論2： http://www.theserverside.com/discussion/thread.jsp?thread_id=19732 Hibernate2 Reference document．tion，可以從Hibernate官方網站獲得，非常好的參考資料。 Hibernate In Action，一本非常專業的Hibernate參考書，由Hibernate項目主要開發人員Gavin King 等著，Manning出版社出版。您可以從 http://www.theserverside.com 獲得本書的部分章節。

Hibernate查詢語言：HQL

    HQL：Hibernate Qusery Language，如果你已經熟悉它，就會發現它跟SQL非常相像。不過 你不要被表面的假象迷惑，HQL是面向對象的（OO，用生命的眼光看待每一個對象，他們是如此 鮮活）。如果你對JAVA和SQL語句有一定了解的話，那么HQL對你簡直易如反掌，你完全可以利用在公車上的時間掌握它。
   
         以下從幾個方面進行慢慢深入：
        
         1。大小些敏感
         大家知道Query是對大小寫不敏感的，但是在HQL（前面提到它是OO的）中那么對象類的名稱和屬性確實大小寫敏感的（符合java編程語法）。
       如：sElect cat.name from Cat as cat和select cat.name from Cat as cat是一樣的
       但是：
           sElect cat.name from CAT as cat和select cat.name from Cat as cat確實不一樣的。
          
       2。from語句
       最簡單的：
        from eg.Cat
        它只是簡單的返回所有eg.Cat的實例
        通常我們此時會為eg.Cat其個別名，因為在query的其余部分可能會用到(參看上邊關于大小寫
        敏感時的例子情形)，如：
        from eg.Cat as cat 這里as可以省略。
        上邊只是單表查詢，多表的情況如下寫法：
        from eg.Cat,eg.Dog
        from eg.Cat as cat,eg.Dog as dog
       
        3。join相關
        (inner) join
        left (outer) join
        right (outer) join
        full join
        HQL同樣對SQL中的這些特性支持
         下面插播一個小話題，關于上邊的那些特性，我一直都沒怎么用，今天既然說到這里，就想
        把上邊的幾個特性的用法說一下，也算對自己的一個補充：
         假設有兩個表：部門、員工，下面列舉一些數據：
         員工(Employee)：
         ID      Name    DepNo
         001     Jplateau  01
         002     Jony      01
         003     Camel    02
         部門(Department)：
         ID      Name
         01     研發部
         02     營銷部
         
         在Hibernate中我們操縱的都是對象，所以我們操縱的是部門類和員工類
         1).(inner) join
         select employee.ID as id1,employee.Name as name1,department.ID as id2,department.Name
          as name2 from Employee as employee join Department as department on employee.DepNo=
          department.ID  (注意到條件語句我用on 沒有用where)
         那么執行結果是什么呢？
         id1 name1 id2 name2
         ++++++++++++++++++++++++++++++++++++++
         001 Jplateau 01 研發部
         002 Jony     01 研發部
         
         2).left (outer) join
         select employee.ID as id1,employee.Name as name1,department.ID as id2,department.Name
          as name2 from Employee as employee left join Department as department on employee.DepNo=
          department.ID
         那么執行結果又該是什么呢？
         id1 name1 id2 name2
         ++++++++++++++++++++++++++++++++++++++
         001 Jplateau 01 研發部
         002 Jony     01 研發部
         003 Camel    null null  
         {就是說此時我要已第一個表的記錄多少為準，第二個表中沒有相應紀錄的時候填充null}  
         3).  right (outer) join
         select employee.ID as id1,employee.Name as name1,department.ID as id2,department.Name
          as name2 from Employee as employee right join Department as department on employee.DepNo=
          department.ID
         那么執行結果又該是什么呢？
         id1 name1 id2 name2
         ++++++++++++++++++++++++++++++++++++++
         001 Jplateau 01 研發部
         002 Jony     01 研發部
         null null     02 營銷部  
         {就是說此時我要已第二個表的記錄多少為準，第一個表中沒有相應紀錄的時候填充null} 
         
        4。select語句
           就是要確定你要從查詢中返回哪些對象或者哪些對象的屬性。寫幾個例子吧：
           select employee form Employee as employee
           select employee form Employee as employee where employee.Name like 'J%'
           select employee.Name form Employee as employee where employee.Name like 'J%'
           select employee.ID as id1,employee.Name as name1,department.ID as id2,department.Name
          as name2 from Employee as employee right join Department as department on employee.DepNo=
          department.ID
         
           select elements(employee.Name) from Employee as employee
           （不明白elements到底是做什么用的？望給于說明）          
           等等
        5。數學函數
           JDO目前好像還不支持此類特性。
           avg(...), sum(...), min(...), max(...)

            count(*)

     count(...), count(distinct ...), count(all...)
    
     其用法和SQL基本相同
    
     select distinct employee.name from Employee as employee
     select count(distinct employee.name),count(employee) from Employee as employee
    
   6。polymorphism (暫時不知道如何解釋？)
     from com.test.Animal as animal
     不光得到所有Animal得實例，而且可以得到所有Animal的子類（如果我們定義了一個子類Cat）
     一個比較極端的例子
     from java.lang.Object as o
     可以得到所有持久類的實例
    
   7。where語句
     定義查詢語句的條件，舉幾個例子吧：
     from Employee as employee where employee.Name='Jplateau'
     from Employee as employee where employee.Name like 'J%'
     from Employee as employee where employee.Name like '%u'
     在where語句中“=”不光可以比較對象的屬性，也可以比較對象，如：
     select animal from com.test.Animal as animal  where animal.name=dog
    
    8。表達式
   
    在SQL語句中大部分的表達式在HQL中都可以使用：
    mathematical operators +, -, *, /

           binary comparison operators =, >=, <=, <>, !=, like

           logical operations and, or, not

           string concatenation ||

           SQL scalar functions like upper() and lower()
          
           Parentheses ( ) indicate grouping

           in, between, is null

           JDBC IN parameters ?

           named parameters :name, :start_date, :x1 （這種應該是另一種"?"的變通解決方法）

           SQL literals 'foo', 69, '1970-01-01 10:00:01.0'

           Java public static final constants eg.Color.TABBY
          
           其他不必解釋了，在這里我只想對查詢中的參數問題說明一下：
           大家知道在SQL中進行傳遞參數進行查詢的時候，我們通常用PreparedStatement，在語句中寫一大堆的“？”，
           在hql中也可以用這種方法，如：
           List mates = sess.find(
                    "select employee.name from Employee as employee " +
                    "where employee.Name=? ",
                    name,
                    Hibernate.STRING
                   );
           (說明：上面利用Session里的find方法，在hibernate的api Session中重載了很多find方法，它可以滿足你多種形式的查詢)
           上邊是一個參數的情形，這種情況下緊接著引入參數和定義參數的類型，當為多個參數，調用另一個find方法，它的后兩個
           參數都是數組的形式。
          
           還有另外一種方法來解決上邊的問題，JDO也有這樣的方法，不過和hibernate的表現形式上有差別，但他們兩個骨子里卻是
           一樣的，如：
           Query q = sess.createQuery("select employee.name from Employee as employee where employee.Name=:name");
           q.setString("name", "Jplateau");
           //當有多個參數的時候在此逐一定義
           Iterator employees = q.iterate();  
          
           9。order 語句
           和sql語句沒什么差別，如：
           select employee.name from Employee as employee where employee.Name like 'J%'  order by employee.ID desc (或者asc)
          
           10。group by 語句
           同樣和sql語句沒什么差別，如：
          
           select employee.name,employee.DepNo from Employee as employee group by employee.DepNo
          
           select foo.id, avg( elements(foo.names) ), max( indices(foo.names) ) from eg.Foo foo group by foo.id
           {Note: You may use the elements and indices constructs inside a select clause, even on databases with no subselects.}
           誰幫我解釋一下上邊兩句，謝過！
          
           11。子查詢
           hibernate同樣支持子查詢，寫幾個例子：
          
           from eg.Cat as fatcat where fatcat.weight > ( select avg(cat.weight) from eg.DomesticCat cat )

Configuration的其他用法

　　Configuration的configure ()方法還支持帶參數的訪問方式，你可以指定hbm.xml文件的位置，而不是使用默認的classpath下面的hibernate.cfg.xml這種方式，例如：

Configuration cfg = new Configuration().configure("myexample.xml");

　　同時Configuration還提供了一系列方法用來定制hibernate的加載配置文件的過程，讓你的應用更加靈活，常用的是以下幾種：

addProperties(Element) addProperties(Properties) setProperties(Properties) setProperty(String, String)

　　通過以上幾個方法，除了使用默認的hibernate.properties文件，你還可以提供多個.properties配置文件，使用Hibernate的時候根據不同的情況使用不同的配置文件，例如：

Properties properties = Properties.load("my.properties"); Configuration config = new Configuration().setProperties(properties).configure();

　　除了指定.properties文件之外，還可以指定.hbm.xml文件，下面列出幾個常用的方法：

addClass(Class) addFile(File) addFile(String) addURL(URL)

　　前面我們已經講了，configure()方法默認是通過訪問hibernate.cfg.xml的＜mapping＞元素來加載我們提供的.hbm.xml文件，上面列出的方法可以直接指定hbm.xml文件，例如addClass()方法可以直接通過指定class來加載對應的映射文件，hibernate會將提供的class的全名（包括package）自動轉化為文件路徑，如net.sf.hibernate.examples.quickstart.Cat.class對應了net/sf/hibernate/examples/quickstart/Cat.hbm.xml，還可以用addFile方法直接指定映射文件。

　　例一：

Configuration config = new Configuration().addClass(Cat.class);

　　例二：

Configuration config = new Configuration().addURL(Configuration.class.getResource ("Cat.hbm.xml"));

　　例三：

Configuration config = new Configuration().addFile("Cat.hbm.xml");

　　5、總結

　　Configuration提供的這些方法的好處如下：

　　1) 一個應用中往往有很多.hbm.xml映射文件，開發的過程中如果只是為了測試某個或幾個Java PO(Persistence Object)，我們沒有必要把所有的.hbm.xml都加載到內存，這樣可以通過addClass或者addFile直接，顯得非常靈活。

　　2) 學習Hibernate的過程中，往往需要通過練習來體會Hibernate提供的各種特征，而很多特征是需要修改配置文件的，如果要觀察相同的代碼在不同的特征下的表現，就需要手工改配置文件，這樣太麻煩了，而且容易出錯，我們可以提供多個配置文件，每個配置文件針對需要的特征而配置，這樣我們在調用程序的時候，把不同的配置文件作為參數傳遞進去，而程序代碼里面使用setProperties和addFile指定傳入的配置文件參數就可以了。

　　3) 在單元測試中，特別是在集成測試里面，整個過程是自動化的，我們不能手工干預測試過程，往往需要準備多個配置文件針對不同的測試案例，這個時候setProperties和addFile方法就顯得特別有用了，在不同的測試案例中用這些方法來指定相應的配置文件，這樣就可以做到自動化測試，保證了持續性。

Oracle開發人員 JAVA存儲過程
利用Java存儲過程簡化數據庫操作
作者：Kuassi Mensah
利用Java存儲過程溝通SQL、XML、Java、J2EE和Web服務。
存儲過程（stored procedure）允許將運行于數據庫層中的持久性邏輯與運行于中間層中的商務邏輯有效地分離開來。這種分離可以降低整個應用程序的復雜性，并提供其重用性、安全性、性能和可伸縮性。

但是，妨礙存儲過程廣泛采用的一個主要障礙是不同數據庫廠商使用各種專有的、且依賴于數據庫的實現語言。使用基于Java的存儲過程可以解決這一問題。Oracle已經實現了ANSI標準，這些標準規定了從SQL中將靜態Java方法作為過程或函數進行調用的能力。這種實現被簡單地稱作"Java存儲過程"。

在本文中，你將了解基于Java的存儲過程如何幫助簡化商務邏輯、提高其性能，并擴展數據庫的功能。本文將介紹Oracle如何在數據庫內啟用基于Java的存儲過程。還會介紹Java存儲過程如何訪問數據，以及如何創建基本Java存儲過程。

選擇PL/SQL還是Java

在考慮Oracle存儲過程時，你可能會想到PL/SQL。不過，從Oracle8i開始，Oracle已經在數據庫中支持Java，從而為存儲過程提供了不同于PL/SQL的開放式和可移植的方法。我可以聽到"$64 000問題"："我如何在PL/SQL和Java之間做出選擇？我是否應當忘記已經學習的所有PL/SQL相關知識，而變為一個Java天地的新手？"

兩種語言都適用于數據庫編程，都有自己的優點和弱點。在決定選擇哪一種語言時，可以參考下面根據經驗得出的通用規則：

對于要求與SQL進行無縫集成的數據庫中心來說則邏輯使用PL/SQL，從而完成對數據庫對象、類型和特性的訪問。
出于與數據庫的無關性考慮時，可以選擇Java作為開放式的語言來取代PL/SQL，同時也為了集成和溝通SQL、XML、J2EE和Web服務等各個領域。
OralceJVM使得Java可以運行在數據庫中

從Oracle8i版本1（Oralce8.1.5）開始，Oracle便提供緊密集成的Java虛擬機（JVM），JVM支持Oralce的數據庫會話期結構。任何數據庫對話期都可以在第一Java代碼調用時啟動一個虛擬上專用的JVM，后續的用戶可以使用這一已經存在的支持Java的會話期。事實上，所有會話共享同一JVM代碼并保持"僅靜態"的私有狀態，而垃圾則收集在單個對話期空間內，從而為各個Java對話期提供了和SQL操作相同的對話期隔離和數據完整性能力。這里，不需要為了數據完整性而進行單獨的Java支持的過程。這一基于對話期的結構提供了較小的內存占用率，并使OracleJVM具有與Oracle數據庫一樣的線性SMP可伸縮性。

創建Java存儲過程

要將Java方法轉換為Java存儲過程需要幾個步驟，包括：用loadjava實用程序將Java類加載到數據庫中，利用調用規范（Call Spec）發布Java方法，將Java方法、參數類型和返回類型映射到其SQL的對應部分。下面部分說明如何完成這些步驟。

我將使用一個簡單的Hello類，它有一個方法Hello.world()，返回字符串"Hello world"：
public class Hello { public static String world () { return "Hello world"; } }
Loadjava 實用程序

Loadjava是加載Java源文件、Java類文件和Java資源文件的實用程序，它可以用來驗證字節碼，并將Java類和JAR文件布置到數據庫中。它既可以通過命令行調用，也可以通過包含于DBMS_JAVA類中的loadjava()方法調用。為了加載我們的Hello.class示例，輸入：
loadjava -user scott/tiger Hello.class

從Oracle9i版本2開始，loadjava允許通過為包含在被處理的類中的方法創建相應的Call Specs來自動將Java類發布為存儲過程。Oracle為開發、測試、調試和布置Java存儲過程提供了Oracle9i JDeveloper。

The Resolver Spec

基于JDK的JVM在列于CLASSPATH中的目錄中查找類引用，并對其進行解析。因為Oracle數據庫類存在于數據庫模式中，所以OracleJVM利用數據庫解析器（resolver）通過列于Resolver Spec中的模式查找并解析類引用。與CLASSPATH不同（CLASSPATH可以應用于所有的類），Resover Spec根據每類的情況進行應用。缺省解析器首先在加載類的模式中搜尋類，然后在公共同義詞（public synonyms）中搜索。 
 loadjava -resolve <myclass>
你可能需要指定不同的解析器，也可以在使用loadjava時強制進行解析，從而在布置時確定可能在以后運行時發生的任何問題。
loadjava -resolve -resolver "((* SCOTT) (foo/bar/* OTHERS) (* PUBLIC))"
Call Spec和存儲過程調用

為了從SQL中調用Java方法（以及從PL/SQl和JDBC中調用），必須首先通過Call Spec發布公共靜態方法，它為SQL定義方法采用的參數以及返回的SQL類型。

在我們的例子中，我們將利用SQL＊Plus連接到數據庫，并為Hello.world()定義一個頂級Call Spec：
SQL> connect scott/tiger SQL> create or replace function helloworld return VARCHAR2 as language java name 'Hello.world () return java.lang.String'; / Function created.
可以像下面這樣調用Java存儲過程：
SQL> variable myString varchar2[20]; SQL> call helloworld() into :myString; Call completed. SQL> print myString; MYSTRING --------------------- Hello world
Java存儲過程可以通過其Call Spec從以下各項中進行調用：SQL DML語句（INSERT, UPDATE、DELETE、SELECT、CALL、EXPLAIN PLAN、LOCK TABLE和MERGE）、PL/SQL塊、子程序、程序包以及數據庫觸發器。Call Spec的美妙之處在于存儲過程實現可以從PL/SQL轉換為Java，反之亦可，這一點對于請求者是透明的。

Call Spec從實現語言中（PL/SQL或Java）中抽象出調用界面，因而使之能夠在原有應用程序和新的基于Java／J2EE的應用程序之間共享商務邏輯。但是，在從Java客戶程序調用在數據庫駐留的Java類時，你可能不希望通過PL/SQL包裝器(wrapper)。在以后的版本中，Oracle計劃提供一種機制，它可以使開發人員略過Call Spec。

高級數據訪問控制

Java存儲過程可用于控制和限制對Oracle數據的訪問，其方法是只允許用戶通過存儲過程管理數據，而存儲過程在其調用者的權限內執行，而不能對表本身進行訪問。例如，你可以在特定時間內禁止更新數據，或者使管理者只具有查詢工資數據的權利，而不能進行更新，或者記錄所有的訪問并通知某一安全機構。

原有應用程序與J2EE應用程序之間的數據邏輯共享因為原有應用程序與J2EE應用程序都通過Call Spec調用存儲過程，所以J2EE和非J2EE應用程序可以共享相同的數據邏輯。由于有了Call Spec，所以不用考慮所用的是何種實現語言（無論是PL/SQL還是Java），該數據邏輯都可以共享。

為BMP實體Bean自動生成主關鍵字

在對EJB實體bean應用BMP時，一個bean實例可以由自動生成的與新插入的數據相關聯的主關鍵字惟一確定，它是ejbCreate()的返回值。可以利用一個插入相應數據的存儲過程在一個數據庫操作中檢索ejbCeater()中的該值，并檢索或計算主關鍵字。作為另一種方法，也可以利用JDBC3.0的RETURN_GENERATED_KEYS特性，以一個SQL語句插入該數據并檢索相應的關鍵字（或ROWID）。但是，存儲過程方法在各個JDBC驅動器版本和數據庫之間更具可移植性。

用XDoclet生成hbm.xml就是在.java文件里寫入一些元數據，XDoclet會從這些數據以及類本身得到足夠的信息來生成目標文件。當然，除了用于hibernate，XDoclet還可以用于web、ejb等等很多用途。

XDoclet要從sourceforge上下載，包含了很多jar包、文檔和例子，我覺得文檔做得還是不錯的，查起來比較方便。要使用XDoclet，一般要通過ant來完成，也就是在ant腳本里加入XDoclet的內容。

由于eclipse已經包含了ant支持，因此我沒有專門去下載一個ant回來，而是直接使用eclipse帶的，版本是1.5.3。

創建一個名為build.xml的腳本（其實應該換個名，比如gen-hbm.xml，看起來比較明白），內容如下：

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

<project name="XDoclet Examples" default="hibernate" basedir=".">
    <property name="xdoclet.root.dir" value="c:/xdoclet-1.2.1"/>
    <property name="xdoclet.lib.dir" value="${xdoclet.root.dir}/lib"/>
    <path id="myclasspath">
        <fileset dir="${xdoclet.lib.dir}">
            <include name="*.jar"/>
        </fileset>
    </path>
     <taskdef
        name="hibernatedoclet"
        classname="xdoclet.modules.hibernate.HibernateDocletTask"
        classpathref="myclasspath"
        />
    <target name="hibernate" description="Generate mapping documents">

        <echo>+---------------------------------------------------+</echo>
        <echo>|                                                   |</echo>
        <echo>| R U N N I N G   H I B E R N A T E D O C L E T     |</echo>
        <echo>|                                                   |</echo>
        <echo>+---------------------------------------------------+</echo>

        <hibernatedoclet
            destdir="./src"
            excludedtags="@version,@author,@todo,@see"
            addedtags="@xdoclet-generated at ${TODAY},@copyright The XDoclet Team,@author XDoclet,@version ${version}"
            force="false"
            verbose="true">

            <fileset dir="./src">
                <include name="org/haree/struts/form/UserForm.java"/>
            </fileset>

            <hibernate version="2.0"/>

        </hibernatedoclet>
    </target>
</project>

我曾經卡住的一個地方就是在taskdef里的classpathref屬性。一開始我在eclipse的ant運行參數里設置了XDoclet相關的包，總是提示：

Can't create a hibernate element under hibernatedoclet. Make sure the jar file containing the corresponding subtask class is on the classpath specified in the <taskdef> that defined {2}.

后來如上設置了classpathref，即包含了XDoclet使用到的包，并將eclipse的ant里關于XDoclet的包都去掉，竟然就成功了。其實現在也不明白為什么會這樣。。。