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方法就显得特别有用了，在不同的测试案例中用这些方法来指定相应的配置文件，这样就可以做到自动化测试，保证了持续性。