BlogJava-太阳雨-随笔分类-hibernate相关http://www.blogjava.net/sy1214520/category/35374.html痛并快乐着zh-cnSun, 08 Nov 2009 21:43:16 GMTSun, 08 Nov 2009 21:43:16 GMT60ORACLE中文排序http://www.blogjava.net/sy1214520/archive/2009/08/06/290062.html小虫旺福小虫旺福Thu, 06 Aug 2009 03:01:00 GMThttp://www.blogjava.net/sy1214520/archive/2009/08/06/290062.htmlhttp://www.blogjava.net/sy1214520/comments/290062.htmlhttp://www.blogjava.net/sy1214520/archive/2009/08/06/290062.html#Feedback0http://www.blogjava.net/sy1214520/comments/commentRss/290062.htmlhttp://www.blogjava.net/sy1214520/services/trackbacks/290062.html阅读全文

小虫旺福 2009-08-06 11:01 发表评论
]]>JPA和hibernate对删除操作的不同http://www.blogjava.net/sy1214520/archive/2008/11/10/239756.html小虫旺福小虫旺福Mon, 10 Nov 2008 15:24:00 GMThttp://www.blogjava.net/sy1214520/archive/2008/11/10/239756.htmlhttp://www.blogjava.net/sy1214520/comments/239756.htmlhttp://www.blogjava.net/sy1214520/archive/2008/11/10/239756.html#Feedback0http://www.blogjava.net/sy1214520/comments/commentRss/239756.htmlhttp://www.blogjava.net/sy1214520/services/trackbacks/239756.html在hibernate里面调用session的delete方法以后，无论这个被删除的对象有没有被人外键引用到，都可以被删除，并且此时的外键设为null，也就是说他会自动帮我们去查看他被谁引用到了。然后把引用全部去掉后，再把自己删掉。而在JPA里面，如果调用EntityManager.remove方法时，传进去的对象，有被外键引用到，则会失败。因为JPA里面的实现就是直接执行delete语句，也不管他有没有被外键引用，此时，当然会出错了。

测试时候使用的两个类分别如下：

举的例子是部门和员工的关系。一个部门可以有多个员工。然后把部门删掉的时候，员工的部门属性就为null了，不过，按照严谨来说，还是JPA的严谨一些。这样可以防止误操作，呵呵。


部门的实体对象
/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package com.hadeslee.jpaentity;

import java.io.Serializable;
import java.util.HashSet;
import java.util.Set;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.OneToMany;
import javax.persistence.Table;

/**
 *
 * @author hadeslee
 */
@Entity
@Table(name = "JPADepartment")
public class Department implements Serializable {

    private static final long serialVersionUID = 1L;
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Long id;
    @OneToMany(mappedBy = "department")
    private Set<Person> persons = new HashSet<Person>();
    private String deptName;
    private String description;

    public String getDeptName() {
        return deptName;
    }

    public void setDeptName(String deptName) {
        this.deptName = deptName;
    }

    public String getDescription() {
        return description;
    }

    public void setDescription(String description) {
        this.description = description;
    }
    
    public Set<Person> getPersons() {
        return persons;
    }

    public void setPersons(Set<Person> persons) {
        this.persons = persons;
    }

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    @Override
    public int hashCode() {
        int hash = 0;
        hash += (id != null ? id.hashCode() : 0);
        return hash;
    }

    @Override
    public boolean equals(Object object) {
        // TODO: Warning - this method won't work in the case the id fields are not set
        if (!(object instanceof Department)) {
            return false;
        }
        Department other = (Department) object;
        if ((this.id == null && other.id != null) || (this.id != null && !this.id.equals(other.id))) {
            return false;
        }
        return true;
    }

    @Override
    public String toString() {
        return "com.hadeslee.jpaentity.Department[id=" + id + "]";
    }
}

人员的实体对象

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package com.hadeslee.jpaentity;

import java.io.Serializable;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.ManyToOne;
import javax.persistence.Table;

/**
 *
 * @author hadeslee
 */
@Entity
@Table(name = "JPAPerson")
public class Person implements Serializable {

    private static final long serialVersionUID = 1L;
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Integer id;
    private String name;
    private int age;
    @ManyToOne
    private Department department;

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public Department getDepartment() {
        return department;
    }

    public void setDepartment(Department department) {
        this.department = department;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    @Override
    public int hashCode() {
        int hash = 0;
        hash += (id != null ? id.hashCode() : 0);
        return hash;
    }

    @Override
    public boolean equals(Object object) {
        // TODO: Warning - this method won't work in the case the id fields are not set
        if (!(object instanceof Person)) {
            return false;
        }
        Person other = (Person) object;
        if ((this.id == null && other.id != null) || (this.id != null && !this.id.equals(other.id))) {
            return false;
        }
        return true;
    }

    @Override
    public String toString() {
        return "com.hadeslee.jpaentity.Person[id=" + id + "]";
    }
}


由于JPA是不需要配置的，代码里面已经包括了注释，所以下面附上Hibernate的映射文件，为了使数据库里面更清楚一些，所以两者使用的表不是同一张表，JPA的表是带JPA前缀的，用@Table这个注释声明了这一点。

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE hibernate-mapping PUBLIC
  "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
  "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="com.hadeslee.jpaentity">
    <class name="Department" table="Department">
        <id name="id" column="departId" type="long">
            <generator class="native"/>
        </id>
        <property name="deptName"/>
        <property name="description"/>
        <set name="persons">
            <key column="deptId"/>
            <one-to-many class="Person"/>
        </set>
    </class>
    <class name="Person" table="Person">
        <id name="id" column="personId" type="long">
            <generator class="native"/>
        </id>
        <property name="name"/>
        <property name="age"/>
        <many-to-one name="department" column="deptId" class="Department"/>
     </class>
</hibernate-mapping>

调用JPA的代码如下：

 EntityManagerFactory emf = Persistence.createEntityManagerFactory("TestSSH1PU2");
        EntityManager em = emf.createEntityManager();
        em.getTransaction().begin();
        com.hadeslee.jpaentity.Person p = new com.hadeslee.jpaentity.Person();
        p.setAge(26);
        p.setName("千里冰封");

        com.hadeslee.jpaentity.Department dept = em.find(com.hadeslee.jpaentity.Department.class, Long.valueOf("3"));
        System.out.println("找到的dept=" + dept);
        em.remove(dept);
        em.getTransaction().commit();

调用hibernate的代码如下：

Session session = HibernateUtil.getSessionFactory().getCurrentSession();
        session.getTransaction().begin();
        Department dept = (Department) session.load(Department.class, 2);
        session.delete(dept);
        session.getTransaction().commit();

最后发现是JPA是不能删除的，而hibernate这边的调用可以删除，一开始我还以为是toplink的实现问题，后来特意把实现改成hibernate的实现，也同样。所以有可能是JPA的要求必须得这样做，不能替我们自动完成一些东西，是利于安全。这可能就是标准和流行的差别吧。呵呵。

小虫旺福 2008-11-10 23:24 发表评论
]]>Hibernate常见异常总结（不断补充） http://www.blogjava.net/sy1214520/archive/2008/10/21/235667.html小虫旺福小虫旺福Tue, 21 Oct 2008 06:29:00 GMThttp://www.blogjava.net/sy1214520/archive/2008/10/21/235667.htmlhttp://www.blogjava.net/sy1214520/comments/235667.htmlhttp://www.blogjava.net/sy1214520/archive/2008/10/21/235667.html#Feedback0http://www.blogjava.net/sy1214520/comments/commentRss/235667.htmlhttp://www.blogjava.net/sy1214520/services/trackbacks/235667.html本文总结Hibernate中常见的异常。

1. net.sf.hibernate.MappingException

       当出现net.sf.hibernate.MappingException: Error reading resource:…异常时一般是因为映射文件出现错误。

       当出现net.sf.hibernate.MappingException: Resource: … not found是因为XML配置文件没找到所致，有可能是放置目录不正确，或者没将其加入hibernate.cfg.xml中。

2. net.sf.hibernate.PropertyNotFoundException

       当出现net.sf.hibernate.PropertyNotFoundException: Could not find a setter for property name in class …时，原因一般是因为XML映射文件中的属性与对应的Java类中的属性的getter或setter方法不一致。

3. org.hibernate.id.IdentifierGenerationException

       当出现org.hibernate.id.IdentifierGenerationException: ids for this class must be manually assigned before calling save():异常时，一般是因为<id>元素配置不正确，<id>元素缺少其子元素<generator></generator>的配置引起。

       解决方案：<id>元素映射了相应数据库表的主键字段，对其子元素<generator class="">,其中class的取值可以为increment、identity、sequence、hilo、native……等，更多的可参考hibernate参考文档，一般取其值为native 。具体可参考2.2.2.1小节。

4. a different object with the same identifier value was already associated with the session

       当出现a different object with the same identifier value was already associated with the session时，一般是因为在hibernate中同一个session里面有了两个相同标识但是是不同实体。

       有如下几种解决方案：

（1）使用session.clean()，如果在clean操作后面又进行了saveOrUpdate(object)等改变数据状态的操作，有可能会报出"Found two representations of same collection"异常。

（2）使用session.refresh(object)，当object不是数据库中已有数据的对象的时候，不能使用session.refresh(object)因为该方法是从hibernate的session中去重新取object，如果session中没有这个对象，则会报错所以当你使用saveOrUpdate(object)之前还需要判断一下。

（3）session.merge(object)，Hibernate里面自带的方法，推荐使用。

5. SQL Grammer Exception,Could not execute JDBC batch update

       当出现SQL Grammer Exception,Could not execute JDBC batch update异常时，一般是由如下问题引起：

（1）SQL语句中存在语法错误或是传入的数据有误;

（2）数据库的配置不合法，或者说是配置有误。较容易出现的有数据表的映射文件(,hbm.xml文件)配置有误；Hibernate.cfg.xml文件配置有误;

（3） 当前的数据库用户权限不足，不能操作数据库。以是以Oracle 数据库为例，这种情况下在错误提示中会显示java.sql.BatchUpdateException: ORA-01031: insufficient privileges这样的信息。

       针对上面的各种原因，开发人员可以找出对应的解决方案。



小虫旺福 2008-10-21 14:29 发表评论
]]>Hibernate使用举例http://www.blogjava.net/sy1214520/archive/2008/10/21/235666.html小虫旺福小虫旺福Tue, 21 Oct 2008 06:29:00 GMThttp://www.blogjava.net/sy1214520/archive/2008/10/21/235666.htmlhttp://www.blogjava.net/sy1214520/comments/235666.htmlhttp://www.blogjava.net/sy1214520/archive/2008/10/21/235666.html#Feedback0http://www.blogjava.net/sy1214520/comments/commentRss/235666.htmlhttp://www.blogjava.net/sy1214520/services/trackbacks/235666.html本节讲述如何使用Hibernate实现记录的增、删、改和查功能。

1 查询

       在Hibernate中使用查询时，一般使用Hql查询语句。

HQL（Hibernate Query Language），即Hibernate的查询语言跟SQL非常相像。不过HQL与SQL的最根本的区别，就是它是面向对象的。

使用HQL时需要注意以下几点：

l         大小写敏感

因为HQL是面向对象的，而对象类的名称和属性都是大小写敏感的，所以HQL是大小写敏感的。

Eg.

HQL语句：from Cat as cat where cat.id > 1;与from Cat as cat where cat.ID > 1;是不一样的，这点与SQL不同。

l         from子句

Eg. from Cat，该句返回Cat对象实例，开发人员也可以给其加上别名，eg. from Cat as cat，对于多表查询的情况，可参考如下：

from Cat as cat, Dog as dog

其它方面都与SQL类似，在此不再赘述。

接下来讲一个在Hibernate中查询的例子。

1.1简单查询

List list = session.createQuery("from User as user order by user.loginName").list();

1.2带单个参数的查询

List list = session.find("from User as user where user.loginName=?",

                                                          loginName,

                                                          Hibernate.STRING);

1.3多个参数的查询

Eg1. 此例采用“?”占位符的方式

String hql = "from User as user where user.loginName=? and user.orgId=? ";

Query query = session.createQuery(hql);

query.setParameter(1, 'amigo');

query.setParameter(2, new Long(1)) ;

List list = query .list();

Eg2. 此例采用“:paramName”的方式

String hql = "from User as user where user.loginName=:loginName and user.orgId=:orgId ";

Query query = session.createQuery(hql);

query.setParameter('loginName', 'amigo');

query.setParameter('orgId', new Long(1)) ;

List list = query .list();

1.4查询数量

int count  = (Integer) session.createQuery("select count(*) from User").uniqueResult().intValue();

1.5限制查询起始值和数量的查询

这种一般是在记录需要分页的时候需要用到，例如，在如下的代码中，限制查询的开始记录的位置为50，最大查询条数为50。

String hql = "from User as user order by user.loginName";

int firstResult= 50;

int maxResults = 50;

Query query = session.createQuery(hql);

query = query.setFirstResult(firstResult);

query.setMaxResults(maxResults);

1.6子查询

在某些情况下，也需要用到子查询，例如在下面的例子中，User为用户对象，UserRole为用户与角色关联对象。如下HQL语句将没有分配角色的用户对象查找出来。

String hql = "from User user where user.loginName"

+ " not in(select ur.user.loginName from UserRole ur) ";

List list = (session.createQuery(hql)).list();

1.7原生SQL查询

对于某些复杂的查询语句，需要调用某种特定的数据库的特定函数才能解决，Hibernate虽然不推荐使用原生SQL语句来查询，因为这将破坏数据库的易移植性，但是Hibernate中也提供了使用原生SQL进行查询的方法，只需要获得连接即可。

Eg. 在下面的例子中，用到了Sql Server数据库中的原生sql语句，如下所示：

String timeUnit = "13";

String sql = "select count(*) count, CONVERT(VARCHAR(" + timeUnit +"),  log.gen_datetime,121) timeUnit " + "from Log log";

SQLQuery query = session.createSQLQuery(sql)

.addScalar("count", Hibernate.INTEGER)

.addScalar("timeUnit", Hibernate.STRING);

List list = query.list();

2 新增

       在数据库中新增记录在Hibernate中不需要使用insert命令，只需要构造新增的对象后，调用Session对象的save(…)方法即可。

2.1新增单个对象

       新增单个对象的实例如下，该实例将在用户表中新增一条记录。

Session session = HibernateSessionFactory.getSession();

         Transaction ts = null;

try {

ts = session.beginTransaction();

                  User user = new User();

                  user.setLoginName("amigo");

                  user.setFullName("阿蜜果");

                  ……

                  session.save(user) ;

                   ts.commit();

} catch (Exception e) {

                  if (ts != null) {

ts.rollback();

}

} finally {

                   HibernateSessionFactory.closeSession();

}

2.2批量新增对象

对于批量新增对象的情况，需要在新增一部分对象后flush和clear一次，例如，没批量新增20个对象时手动的flush一次，假设在list为一个用户列表，里面包含很多User对象，那么要将实现这些对象的批量新增，可采用如下方法：

Session session = HibernateSessionFactory.getSession();

Transaction ts = null;

try {

ts = session.beginTransaction();

for (int i = 0; i < list.size(); i++) {

                            User user = (User) list.get(i);

                            session.save(user) ;

                            if (i % 20 == 0) {

         session.flush();

         session.clear();

}

                   }

                   ts.commit();

} catch (Exception e) {

                   if (ts != null) {

ts.rollback();

}

} finally {

                   HibernateSessionFactory.closeSession();

}

3 更新

       在hibernate中，更新对象前不需要使用查询语句：update…，一般需要在取得需要更新的持久化对象后，执行Session对象的update(…)方法。例如：

Session session = HibernateSessionFactory.getSession();

Transaction ts = null;

try {

ts = session.beginTransaction();

//取得持久化对象

                   User user = session.get(User.class, "amigo");

                   //对需要修改的属性进行修改

                   user.setFullName("阿蜜果");

                   ……

                   session.update(user) ;

                   ts.commit();

} catch (Exception e) {

                   if (ts != null) {

ts.rollback();

}

} finally {

                  HibernateSessionFactory.closeSession();

}

4 删除

4.1删除单个对象

       一般在取得某对象后，开发人员可以调用Session对象的delete(…)方法删除该对象。

Eg. 下面的实例中取得loginName（主键）为“amigo”的User对象后，将它删除。

Session session = HibernateSessionFactory.getSession();

Transaction ts = null;

try {

ts = session.beginTransaction();

//取得持久化对象

                   User user = session.get(User.class, "amigo");

                   session.delete(user) ;

                   ts.commit();

} catch (Exception e) {

                   if (ts != null) {

ts.rollback();

}

} finally {

                   HibernateSessionFactory.closeSession();

}

4.2批量删除对象

对于批量删除对象的情况，开发人员可以在取得待删除的对象列表后，一个一个的将对象删除，对于每个对象的删除方法，见3.4.1小节。开发人员还可以hql语句来做批量删除。

Eg. 该实例通过delete语句来删除记录，除了loginName为“amigo”的对象为，其余都删除，代码如下所示：

Session session = HibernateSessionFactory.getSession();

Transaction ts = null;

try {

ts = session.beginTransaction();

String hql = "delete User as user where user.loginName != 'amigo'";

Query query = session.createQuery(hql);

int count  = query.executeUpdate();

 ts.commit();

System.out.println("delete count : " + count); //删除条数

} catch (Exception e) {

                   if (ts != null) {

ts.rollback();

}

} finally {

                   HibernateSessionFactory.closeSession();

}



小虫旺福 2008-10-21 14:29 发表评论
]]>hibernate.cfg.xml配置http://www.blogjava.net/sy1214520/archive/2008/10/21/235664.html小虫旺福小虫旺福Tue, 21 Oct 2008 06:27:00 GMThttp://www.blogjava.net/sy1214520/archive/2008/10/21/235664.htmlhttp://www.blogjava.net/sy1214520/comments/235664.htmlhttp://www.blogjava.net/sy1214520/archive/2008/10/21/235664.html#Feedback0http://www.blogjava.net/sy1214520/comments/commentRss/235664.htmlhttp://www.blogjava.net/sy1214520/services/trackbacks/235664.html的描述文件可以是一个properties属性文件，也可以是一个xml文件。下面讲一下Hibernate.cfg.xml的配置。配置格式如下：
1. 配置数据源

       在Hibernate.cfg.xml中既可以配置JDBC，也可以配置JNDI。在本小节中讲述数据源如何配置。

hibernate.cfg.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">

<hibernate-configuration>

<session-factory>

<!-- 各属性的配置-->

<!—为true表示将Hibernate发送给数据库的sql显示出来 -->

<property name="show_sql">true</property>

<!-- SQL方言，这边设定的是MySQL -->

<property name="dialect">net.sf.hibernate.dialect.MySQLDialect</property>

<!-- 一次读的数据库记录数 -->

<property name="jdbc.fetch_size">50</property>

<!-- 设定对数据库进行批量删除 -->
        <property name="jdbc.batch_size">30</property>

<!—下面为JNDI的配置 -->

<!-- 数据源的名称 -->

<property name="connection.datasource">java:comp/env/jdbc/datasourcename</property>

<!-- Hibernate的连接加载类 -->

<property name="connection.provider_class">net.sf.hibernate.connection.DatasourceConnectionProvider</property>

<property name="dialect">net.sf.hibernate.dialect.SQLServerDialect</property>

<!—映射文件 -->

<mapping resource="com/amigo/pojo/User.hbm.xml"/>

<mapping resource="com/amigo/pojo/Org.hbm.xml"/>
    </session-factory>
</hibernate-configuration>

2. c3p0连接池

       c3p0连接池是Hibernate推荐使用的连接池，若需要使用该连接池时，需要将c3p0的jar包加入到classpath中。c3p0连接池的配置示例如下：

hibernate.cfg.xml

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE hibernate-configuration PUBLIC

"-//Hibernate/Hibernate Configuration DTD 3.0//EN"

"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">

<hibernate-configuration>

<session-factory>

        <!-- 显示实际操作数据库时的SQL -->

        <property name="show_sql">true</property>

        <!-- SQL方言，这边设定的是MySQL -->

        <property name="dialect">net.sf.hibernate.dialect.MySQLDialect</property>

        <!--驱动程序，在后续的章节中将讲述mysql、sqlserver和Oracle数据库的配置 -->

        <property name="connection.driver_class">……</property>

        <!-- JDBC URL -->

        <property name="connection.url">……</property>

        <!-- 数据库用户名 -->

        <property name="connection.username">user</property>

        <!-- 数据库密码 -->

        <property name="connection.password">pass</property>

        <property name="c3p0.min_size">5</property>

        <property name="c3p0.max_size">20</property>

        <property name="c3p0.timeout">1800</property>

        <property name="c3p0.max_statements">50</property>

        <!-- 对象与数据库表格映像文件 -->

       <mapping resource="com/amigo/pojo/User.hbm.xml"/>

<mapping resource="com/amigo/pojo/Org.hbm.xml"/>

    </session-factory>

</hibernate-configuration>

在上述配置中，Hibernate根据配置文件生成连接，再交给c3p0管理。

3. proxool连接池

       proxool跟c3p0以及dbcp不一样，它是自己生成连接的，因此连接信息放在proxool配置文件中。使用它时，需要将proxool-0.8.3.jar加入到classespath中。配置举例如下：

hibernate.cfg.xml

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE hibernate-configuration PUBLIC

"-//Hibernate/Hibernate Configuration DTD 3.0//EN"

"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">

<hibernate-configuration>

<session-factory>

        <!-- 显示实际操作数据库时的SQL -->

        <property name="show_sql">true</property>

        <!-- SQL方言，这边设定的是MySQL -->

        <property name="dialect">net.sf.hibernate.dialect.MySQLDialect</property>

<!—proxool的配置 -->

       <property name="proxool.pool_alias">pool1</property>

<property name="proxool.xml">ProxoolConf.xml</property>

<property name="connection.provider_class">net.sf.hibernate.connection.ProxoolConnectionProvider</property>

       <!-- 对象与数据库表格映像文件 -->

       <mapping resource="com/amigo/pojo/User.hbm.xml"/>

<mapping resource="com/amigo/pojo/Org.hbm.xml"/>

  </session-factory>

</hibernate-configuration>

在hibernate.cfg.xml的同目录下编写proxool的配置文件：ProxoolConf.xml，该文件的配置实例如下：

ProxoolConf.xml

<?xml version="1.0" encoding="utf-8"?>
<!-- the proxool configuration can be embedded within your own application's.
Anything outside the "proxool" tag is ignored. -->
<something-else-entirely>
<proxool>
<alias>pool1</alias>
<!--proxool只能管理由自己产生的连接-->

<!-- 驱动的url-->

<!-- jdbc:mysql://localhost:3306/dbname?useUnicode=true&characterEncoding=GBK-->

<driver-url>… </driver-url>

<!-- 驱动类，eg. com.mysql.jdbc.Driver-->

<driver-class>… </driver-class>
<driver-properties>

<!-- 数据库用户名，eg. value为root-->

<property name="user" value="…"/>

<!-- 数据库密码，eg. value为root-->

<property name="password" value="…."/>
</driver-properties>
<!-- proxool自动侦察各个连接状态的时间间隔(毫秒),侦察到空闲的连接就马上回收,超时的销毁-->
<house-keeping-sleep-time>90000</house-keeping-sleep-time>
<!-- 指因未有空闲连接可以分配而在队列中等候的最大请求数,超过这个请求数的用户连接就不会被接受-->
<maximum-new-connections>20</maximum-new-connections>
<!-- 最少保持的空闲连接数-->
<prototype-count>5</prototype-count>
<!-- 允许最大连接数,超过了这个连接，再有请求时，就排在队列中等候，最大的等待请求数由maximum-new-connections决定-->
<maximum-connection-count>100</maximum-connection-count>
<!-- 最小连接数-->
<minimum-connection-count>10</minimum-connection-count>
</proxool>
</something-else-entirely>

4. dbcp连接池

       在hibernate3.0中，已经不再支持dbcp了，hibernate的作者在hibernate.org中，明确指出在实践中发现dbcp有 BUG,在某些种情会产生很多空连接不能释放，所以抛弃了对dbcp的支持。若需要使用dbcp，开发人员还需要将commons-pool-1.2.jar 和commons-dbcp-1.2.1.jar两个jar包加入到classpath中。dbcp与c3p0一样，都是由hibernate建立连接的。

在hibernate2.0中的配置建立如下：

hibernate.cfg.xml

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE hibernate-configuration PUBLIC

"-//Hibernate/Hibernate Configuration DTD 2.0//EN"

"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">

<hibernate-configuration>

<session-factory>

        <!-- 显示实际操作数据库时的SQL -->

        <property name="show_sql">true</property>

        <!-- SQL方言，这边设定的是MySQL -->

        <property name="dialect">net.sf.hibernate.dialect.MySQLDialect</property>

        <!--驱动程序，在后续的章节中将讲述mysql、sqlserver和Oracle数据库的配置 -->

        <property name="connection.driver_class">……</property>

        <!-- JDBC URL -->

        <property name="connection.url">……</property>

        <!-- 数据库用户名,eg. root -->

        <property name="connection.username">…</property>

        <!-- 数据库密码, eg. root-->

        <property name="connection.password">…</property>

       <property name="dbcp.maxActive">100</property>

<property name="dbcp.whenExhaustedAction">1</property>

<property name="dbcp.maxWait">60000</property>

<property name="dbcp.maxIdle">10</property>

<property name="dbcp.ps.maxActive">100</property>

<property name="dbcp.ps.whenExhaustedAction">1</property>

<property name="dbcp.ps.maxWait">60000</property>

<property name="dbcp.ps.maxIdle">10</property>

        <!-- 对象与数据库表格映像文件 -->

       <mapping resource="com/amigo/pojo/User.hbm.xml"/>

<mapping resource="com/amigo/pojo/Org.hbm.xml"/>

    </session-factory>

</hibernate-configuration>

5. MySql连接配置

在hibernate中，可以配置很多种数据库，例如MySql、Sql Server和Oracle，MySql的配置举例如下：

hibernate.cfg.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">

<hibernate-configuration>

<session-factory>

<!-- 各属性的配置-->

<!—为true表示将Hibernate发送给数据库的sql显示出来 -->

<property name="show_sql">true</property>

<!-- SQL方言，这边设定的是MySQL -->

<property name="dialect">net.sf.hibernate.dialect.MySQLDialect</property>

<!-- 一次读的数据库记录数 -->

<property name="jdbc.fetch_size">50</property>

<!-- 设定对数据库进行批量删除 -->
        <property name="jdbc.batch_size">30</property>

<!--驱动程序-->

<property name="connection.driver_class">com.mysql.jdbc.Driver</property>

<!-- JDBC URL -->

<property name="connection.url">jdbc:mysql://localhost/dbname?characterEncoding=gb2312</property>

<!-- 数据库用户名-->

<property name="connection.username">root</property>

<!-- 数据库密码-->

<property name="connection.password">root</property>

<!—映射文件 -->

<mapping resource="com/amigo/pojo/User.hbm.xml"/>

<mapping resource="com/amigo/pojo/Org.hbm.xml"/>
    </session-factory>
</hibernate-configuration>

上面使用的驱动类是com.mysql.jdbc.Driver。需要将MySql的连接器jar包(eg. mysql-connector-java-5.0.4-bin.jar)加入到classpath中。

6. Sql Server连接配置

       本小节讲述一下Sql Server数据库的hibernate连接设置，在此只给出连接部分的内容，其余部分与2.2.1.5一样，在此不再赘述。内容如下：

<!--驱动程序-->

<property name="connection.driver_class">net.sourceforge.jtds.jdbc.Driver</property>

<!-- JDBC URL -->

<property name="connection.url">jdbc:jtds:sqlserver://localhost:1433;DatabaseName=dbname</property>

<!-- 数据库用户名-->

<property name="connection.username">sa</property>

<!-- 数据库密码-->

<property name="connection.password"></property>

上例的驱动类使用的是jtds的驱动类，因此读者需要将jtds的jar包(eg. jtds-1.2.jar)加入到classpath中。

7. Oracle连接配置

本小节讲述一下Sql Server数据库的hibernate连接设置，在此只给出连接部分的内容，其余部分与2.2.1.5一样，在此不再赘述。内容如下：

<!--驱动程序-->

<property name="connection.driver_class">oracle.jdbc.driver.OracleDriver</property>

<!-- JDBC URL -->

<property name="connection.url">jdbc:oracle:thin:@localhost:1521:dbname</property>

<!-- 数据库用户名-->

<property name="connection.username">test</property>

<!-- 数据库密码-->

<property name="connection.password">test</property>

上例使用的驱动类为：oracle.jdbc.driver.OracleDriver，开发人员需要将相关的jar包（ojdbc14.jar）加入到classpath中。

小虫旺福 2008-10-21 14:27 发表评论
]]>Hibernate3.x调用存储过程http://www.blogjava.net/sy1214520/archive/2008/10/21/235663.html小虫旺福小虫旺福Tue, 21 Oct 2008 06:27:00 GMThttp://www.blogjava.net/sy1214520/archive/2008/10/21/235663.htmlhttp://www.blogjava.net/sy1214520/comments/235663.htmlhttp://www.blogjava.net/sy1214520/archive/2008/10/21/235663.html#Feedback0http://www.blogjava.net/sy1214520/comments/commentRss/235663.htmlhttp://www.blogjava.net/sy1214520/services/trackbacks/235663.html阅读全文

小虫旺福 2008-10-21 14:27 发表评论
]]>hibernat配置文件中set元素中各属性的定义http://www.blogjava.net/sy1214520/archive/2008/10/21/235662.html小虫旺福小虫旺福Tue, 21 Oct 2008 06:26:00 GMThttp://www.blogjava.net/sy1214520/archive/2008/10/21/235662.htmlhttp://www.blogjava.net/sy1214520/comments/235662.htmlhttp://www.blogjava.net/sy1214520/archive/2008/10/21/235662.html#Feedback0http://www.blogjava.net/sy1214520/comments/commentRss/235662.htmlhttp://www.blogjava.net/sy1214520/services/trackbacks/235662.html           name="propertyName"                                                                            (1)  
          table="table_name"                                                                                 (2)  
          schema="schema_name"                                                                         (3)  
          lazy="true|false"                                                                                       (4)  
          inverse="true|false"                                                                                  (5)  
          cascade="all|none|save-update|delete|all-delete-orphan"                        (6)  
          sort="unsorted|natural|comparatorClass"                                               (7)  
          order-by="column_name   asc|desc"                                                       (8)  
          where="arbitrary   sql   where   condition"                                             (9)  
          outer-join="true|false|auto"                                                                     (10)  
          batch-size="N"                                                                                         (11)  
          access="field|property|ClassName"                                                       (12)  
  >  
   
          <key   ....   />  
          <index   ....   />  
          <element   ....   />  
  </set>   
  (1)   name   集合属性的名称     
  (2)   table   （可选——默认为属性的名称）这个集合表的名称(不能在一对多的关联关系中使用)     
  (3)   schema   (可选)   表的schema的名称,   他将覆盖在根元素中定义的schema     
  (4)   lazy   (可选——默认为false)   lazy(可选--默认为false)   允许延迟加载（lazy   initialization   ）(不能在数组中使用)     
  (5)   inverse   (可选——默认为false)   标记这个集合作为双向关联关系中的方向一端。     
  (6)   cascade   (可选——默认为none)   让操作级联到子实体     
  (7)   sort(可选)指定集合的排序顺序,   其可以为自然的(natural)或者给定一个用来比较的类。     
  (8)   order-by   (可选,   仅用于jdk1.4)   指定表的字段(一个或几个)再加上asc或者desc(可选),   定义Map,Set和Bag的迭代顺序     
  (9)   where   (可选)   指定任意的SQL   where条件,   该条件将在重新载入或者删除这个集合时使用(当集合中的数据仅仅是所有可用数据的一个子集时这个条件非常有用)     
  (10)   outer-join(可选)指定这个集合,只要可能,应该通过外连接(outer   join)取得。在每一个SQL语句中,   只能有一个集合可以被通过外连接抓取(译者注:   这里提到的SQL语句是取得集合所属类的数据的Select语句)     
  (11)   batch-size   (可选,   默认为1)   指定通过延迟加载取得集合实例的批处理块大小（"batch   size"）。     
  (12)   access(可选-默认为属性property):Hibernate取得属性值时使用的策略

小虫旺福 2008-10-21 14:26 发表评论
]]>Hibernate的核心接口学习 http://www.blogjava.net/sy1214520/archive/2008/10/21/235661.html小虫旺福小虫旺福Tue, 21 Oct 2008 06:24:00 GMThttp://www.blogjava.net/sy1214520/archive/2008/10/21/235661.htmlhttp://www.blogjava.net/sy1214520/comments/235661.htmlhttp://www.blogjava.net/sy1214520/archive/2008/10/21/235661.html#Feedback0http://www.blogjava.net/sy1214520/comments/commentRss/235661.htmlhttp://www.blogjava.net/sy1214520/services/trackbacks/235661.html       Hibernate有如下5个核心接口：
  • Configuration接口：该对象用于配置并且根启动Hibernate。Hibernate应用通过Configuration实例来指定对象-关系映射文件的位置或动态配置Hibernate的属性，然后创建SessionFactory实例。
  • SessionFactory接口：一个SessionFactory实例对应一个数据存储源，应用从SessionFactory中获得Session实例。它具有如下特点：

              1）它是线程安全的，这意味着它的同一个实例可以被应用的各个线程共享。

              2）它是重量级的，这意味着不能随意创建或销毁它的实例。如果应用只访问一个数据库，只需创建一个SessionFactory实例，在应用初始化的时候创建该实例。如果应用同时访问多个数据库，则需要为每个数据库创建一个单独的SessionFactory实例。

              之所以说SessionFactory是重量级的，是因为它需要一个很大的缓存，用来存放预定义的SQL语句以及映射元数据等。用户还可以为SessionFactory配置一个缓存插件，这个缓存插件被称为Hibernate的第二级缓存，该缓存用来存放被工作单元读过的数据，将来其它工作单元可能会重用这些数据，因此这个缓存中的数据能够被所有工作单元共享，一个工作单元通常对应一个数据库事务。

  • Session接口：该接口是Hibernate应用使用最广泛的接口。Session也被称为持久化管理器，提供了和持久化相关的操作，如添加、更新、删除、加载和查询对象。Session具有一下特点：

             1）不是线程安全的，因此在设计软件架构时，应该避免多个线程共享同一个Session实例；

             2）Session实例是轻量级的，所谓轻量级，是指它的创建和销毁不需要消耗太多的资源。这意味着在程序中可以经常创建和销毁Session对象，例如为每个客户请求分配单独的Session实例，或者为每个工作单元分配单独的Session实例。

             Session有一个缓存，被称为Hibernate的第一级缓存，它存放被当前工作单元加载的对象。每个Session实例都有自己的缓存，这个Session实例的缓存，这个Session实例的缓存只能被当前工作单元访问。

  •  Transaction：该接口是Hibernate的数据库事务接口，它对底层的事务接口做了封装，底层事务接口包括：JDBC API、JTA（Java Transaction API）、CORBA（Common Object Requet Broker Architecture) API.

             Hibernate应用可通过一致的Transaction接口来声明事务边界，这有助于应用在不同环境或容器中移植。

  •  Query和Criteria接口：它们是Hibernate的查询接口，用于向数据库查询对象，以及控制执行查询的过程。Query实例封装了一个HQL（Hibernate Query Language）查询语句，HQL是面向对象的，它引用类名及类的属性名，而不是表名及表的字段名。Criteria接口完全封装了基于字符串形式的查询语句，比Query接口更加面向对象，Criteria接口更擅长于执行动态查询。


小虫旺福 2008-10-21 14:24 发表评论
]]>hibernate中对象的3种状态----瞬时态、持久态、脱管态 http://www.blogjava.net/sy1214520/archive/2008/10/21/235659.html小虫旺福小虫旺福Tue, 21 Oct 2008 06:23:00 GMThttp://www.blogjava.net/sy1214520/archive/2008/10/21/235659.htmlhttp://www.blogjava.net/sy1214520/comments/235659.htmlhttp://www.blogjava.net/sy1214520/archive/2008/10/21/235659.html#Feedback0http://www.blogjava.net/sy1214520/comments/commentRss/235659.htmlhttp://www.blogjava.net/sy1214520/services/trackbacks/235659.html
  •         瞬时态

    •         由new命令开辟内存空间的java对象，

           eg. Person person = new Person("amigo", "女");

            如果没有变量对该对象进行引用，它将被java虚拟机回收。

            瞬时对象在内存孤立存在，它是携带信息的载体，不和数据库的数据有任何关联关系，在Hibernate中，可通过session的save()或saveOrUpdate()方法将瞬时对象与数据库相关联，并将数据对应的插入数据库中，此时该瞬时对象转变成持久化对象。

    •        持久态

            处于该状态的对象在数据库中具有对应的记录，并拥有一个持久化标识。如果是用hibernate的delete()方法，对应的持久对象就变成瞬时对象，因数据库中的对应数据已被删除，该对象不再与数据库的记录关联。

           当一个session执行close()或clear()、evict()之后，持久对象变成脱管对象，此时持久对象会变成脱管对象，此时该对象虽然具有数据库识别值，但它已不在HIbernate持久层的管理之下。

           持久对象具有如下特点：

           1. 和session实例关联；

           2. 在数据库中有与之关联的记录。

    •  脱管态

            当与某持久对象关联的session被关闭后，该持久对象转变为脱管对象。当脱管对象被重新关联到session上时，并再次转变成持久对象。

           脱管对象拥有数据库的识别值，可通过update()、saveOrUpdate()等方法，转变成持久对象。

           脱管对象具有如下特点：

           1.  本质上与瞬时对象相同，在没有任何变量引用它时，JVM会在适当的时候将它回收；

           2.  比瞬时对象多了一个数据库记录标识值。



    小虫旺福 2008-10-21 14:23 发表评论
    ]]>