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的包都去掉，竟然就成功了。其实现在也不明白为什么会这样。。。