org.hibernate.NonUniqueResultException

org.hibernate.NonUniqueResultException: query did not return a unique result: 68
 at org.hibernate.impl.AbstractQueryImpl.uniqueElement(AbstractQueryImpl.java:789)
 at org.hibernate.impl.AbstractQueryImpl.uniqueResult(AbstractQueryImpl.java:780)
 at com.bjsxt.oa.manager.impl.InitSystemDatasImpl.importRoleAndAcl(InitSystemDatasImpl.java:89)
 at com.bjsxt.oa.manager.impl.InitSystemDatasImpl.addOrUpdateInitDatas(InitSystemDatasImpl.java:47)
 at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
 at sun.reflect.NativeMethodAccessorImpl.invoke(Unknown Source)
 at sun.reflect.DelegatingMethodAccessorImpl.invoke(Unknown Source)
 at java.lang.reflect.Method.invoke(Unknown Source)
 at org.springframework.aop.support.AopUtils.invokeJoinpointUsingReflection(AopUtils.java:318)
 at org.springframework.aop.framework.ReflectiveMethodInvocation.invokeJoinpoint(ReflectiveMethodInvocation.java:203)
 at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:162)
 at org.springframework.transaction.interceptor.TransactionInterceptor.invoke(TransactionInterceptor.java:107)
 at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:185)
 at org.springframework.aop.framework.JdkDynamicAopProxy.invoke(JdkDynamicAopProxy.java:209)
 at $Proxy7.addOrUpdateInitDatas(Unknown Source)
 at com.bjsxt.oa.manager.InitSystemDatasTest.testAddOrUpdateInitDatas(InitSystemDatasTest.java:7)
 at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
 at sun.reflect.NativeMethodAccessorImpl.invoke(Unknown Source)
 at sun.reflect.DelegatingMethodAccessorImpl.invoke(Unknown Source)
 at java.lang.reflect.Method.invoke(Unknown Source)
 at junit.framework.TestCase.runTest(TestCase.java:154)
 at junit.framework.TestCase.runBare(TestCase.java:127)
 at org.springframework.test.ConditionalTestCase.runBare(ConditionalTestCase.java:69)
 at junit.framework.TestResult$1.protect(TestResult.java:106)
 at junit.framework.TestResult.runProtected(TestResult.java:124)
 at junit.framework.TestResult.run(TestResult.java:109)
 at junit.framework.TestCase.run(TestCase.java:118)
 at junit.framework.TestSuite.runTest(TestSuite.java:208)
 at junit.framework.TestSuite.run(TestSuite.java:203)
 at org.eclipse.jdt.internal.junit.runner.junit3.JUnit3TestReference.run(JUnit3TestReference.java:128)
 at org.eclipse.jdt.internal.junit.runner.TestExecution.run(TestExecution.java:38)
 at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:460)
 at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:673)
 at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.run(RemoteTestRunner.java:386)
 at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.main(RemoteTestRunner.java:196)

 

 

☆

 

有谁知道query did not return a unique result:2的含义？

发表于: 2007-2-14 下午7:01

 

   

有谁知道
org.hibernate.NonUniqueResultExce：query did not return a unique result:2
是个什么意思？

HQL：
"select count(*) from XXX 1 d where d.action = true" 就出现上面的错误

"select count(*) from XXX2 d where d.action = true" 就正确

晕死 XXX1和XXX2是相同的表结构啊！

呵呵，找到原因了，一时偷懒，把两个表的对象设成继承关系了，hibernate搜索似乎会把子类定义的表也搜索上。

☆

操纵持久化对象

                                                        ++YONG原创，转载请注明

1.    理解Session的缓存：

在Java里面，缓存通常是指Java对象的属性占用的内存空间，通常是一些集合类型的属性。在session接口的实现类SessionImpl中定义了一系列的Java集合，这些Java集合就构成了Session的缓存。

当Session的save()方法持久化一个对象时，这个对象被加入到Session的缓存中，以后即使应用程序中的引用变量不再引用这个对象，只要Session的缓存还没有被清空，这个对象仍然处于生命周期中。当Session的load()方法加载一个对象时，Session会先判断缓存中是否已经存在这个对象了，如果存在，就不需要再到数据库中重新加载了。

Session的缓存有两大作用：

1.1.        减少访问数据库的频率。

1.2.        保证缓存中的对象与数据库中的相关记录保持同步。

Session有两个方法：一个commit()事务提交方法，还有flush()刷新缓存方法，都有着清理缓存的作用。flush()进行缓存的清理，执行一系列的SQL语句，但不会提交事务。而commit()方法会先调用flush()方法，然后在提交事务。

2.    定义持久化类的建议：

在应用程序中，用来实现业务问题实体的（如，在电子商务应用程序中的Customer和Order） 类就是持久化类。如果这些持久化类遵循一些简单的规则，Hibernate能够工作得更好，这些规则也被称作简单传统Java对象(POJO:Plain Old Java Object)编程模型。但是这些规则并不是必需的。最好要遵循以下几条主要的规则：

1)      实现一个默认的（即无参数的）构造方法（constructor）：

我们强烈建议，在Hibernate中，为了运行期代理的生成，构造方法至少是 包(package)内可见的。

2)      提供一个标识属性（identifier property）：

我们建议你对持久化类声明命名一致的标识属性。我们还建议你使用一个可以为空（也就是说，不是原始类型）的类型。

3)      使用非final的类：

代理（proxies）是Hibernate的一个重要的功能，它依赖的条件是，持久 化类或者是非final的，或者是实现了一个所有方法都声明为public的接口。你也应该避免在非final类中声明 public final的方法。

4)      为持久化字段声明访问器(accessors)：

5)      如果你有如下需求，你必须重载 equals() 和 hashCode()方法：

l 想把持久类的实例放入Set中（当表示多值关联时，推荐这么做）

l 想重用脱管实例

Hibernate保证，仅在特定会话范围内，持久化标识（数据库的行）和Java标识是等价的。因此，一旦 我们混合了从不同会话中获取的实例，如果希望Set有明确的语义，就必须实现equals() 和hashCode()。

3.    持久化对象的三种状态：

一个持久化类的实例可能处于三种不同状态中的某一种。

3.1.    瞬时（transient）状态：

该实例是刚用new语句创建的，还没有被持久化，不处于任何Session的缓存中。它没有持久化标识（相当于主键值）。处于瞬时状态的实例被称为瞬时对象。它的特点是：

不和任何一个Session实例关联。在数据库中没有对应的记录。

3.2.    持久化 (persistent) 状态：

已经被持久化，加入到Session缓存中。处于持久化状态的实例被称为持久化对象。

实例目前与某个Session有关联。 它拥有持久化标识（相当于主键值），并且可能在数据库中有一个对应的行。 Hibernate保证在同一个Sesion实例的缓存中，数据库中的每条记录只对应唯一的持久化对象。 它的特点是：

       持久化对象总是被一个Session实例关联。持久化对象和数据库中的相关记录对应。Session在清理缓存时，会根据持久化对象的属性变化，来同步更新数据库。

3.3.    脱管(detached) 状态：

已经被持久化过，但不再处于Session的缓存中。处于脱管状态的实例被称为脱管对象。实例曾经与某个持久化上下文发生过关联，不过那个上下文被关闭了， 或者这个实例是被序列化(serialize)到另外的进程。 它拥有持久化标识，并且在数据库中可能存在一个对应的行。 对于脱管状态的实例，Hibernate不保证任何持久化标识和Java标识的关系。它的特点是：

不再位于session的缓存中，即它不再和session关联。它拥有持久化标识。

4.    Session的保存、删除、更新和查询方法：

4.1.    Session的save()方法：使用一个临时对象转变为持久对象。

方法签名：public Serializable save(Object object) throws HibernateException; 它完成以下操作：

1)      把持久化类的实例加入到缓存中，使它变为持久化对象。

2)      选用映射文件指定的标识符生成器为持久化对象分配唯一的OID。

3)      计划执行一个insert语句，把持久化对象当前的属性值组装到insert 语句(SQL DML)中。值得注意的是，save()方法并不是立即执行SQL insert语句。只有当Session清理缓存时，才会执行SQL insert语句。

另外，需要注意的是：Hibernate通过持久化对象的OID来维持它和数据库相关记录的对应关系。所以当持久化的实例处于持久化状态时，不允许程序随意修改它的OID。其实，无论java对象处于瞬时状态、持久化状态还是脱管状态，程序都不应该修改它的OID。

4.2.    Session的update()方法：使一个脱管对象转变为持久化对象。

方法签名：public void update(Object object) throws HibernateException; 它完成以下操作：

1)      把脱管对象重新加入到Session缓存中，使它变为持久化对象。

2)      计划执行一个update语句。值得注意的是，Session只有在清理缓存的时候才会执行update语句，并且在执行时才会把持久化对象当前的属性值组装到update语句中。

4.3.    Session的saveOrUpdate()方法：

       方法签名：public void saveOrUpdate(Object object) throws HibernateException ; saveOrUpdate()方法同时包含了save()与update()方法的功能，如果传入的参数是瞬时对象，就调用save()方法；如果传入的参数是脱管对象，就调用update()方法；如果传入的参数是持久化对象，方法就直接返回。那么，saveOrUpdate()方法如果判断一个对象处于瞬时状态不是脱管状态呢？如果满足以下情况之一，Hibernate就把它作为临时对象：

1)      Java对象的OID取值为null。

2)      Java对象具有version属性，并且取值了null。

3)      在映射文件中为<id>元素设置了unsaved-value属性，并且OID取值与unsaved-value属性值匹配。

4)      在映射文件中为<version>元素设置了unsaved-value属性，并且version属性取值与unsaved-value属性值匹配。

5)      自定义了Hibernate的Interceptor实现类，并且Interceptor的isUnsaved()方法返回Boolean.TRUE。

4.4.    Session的delete()方法：

方法签名：public void delete(Object object) throws HibernateException; delete()方法用于从数据库中删除与Java对象对应的记录。如果传入的参数是持久化对象，Session就计划执行一个delete语句。如果传入的参数是游离对象，先使游离对象被Session关联，使它变为持久化对象，然后计划执行一个delete语句。值得注意的也是，Session只有在清理缓存的时候才会执行delete语句。

5.    通过主键ID取得数据对象：

5.1.    Session的get()方法：

       方法签名：public Object get(Class clazz, Serializable id) throws HibernateException; 根据给定的OID从数据库中加载一个持久化对象，若数据库中不存在与OID对应的记录，此方法返回null。

       get()方法的执行顺序如下：

1)      首先通过id在session缓存中查找对象，如果存在此id主键值的对象，直接将其返回。如果不存在，将进行第2步。

2)      在二级缓存中查找，找到后将其返回。

3)      如果在session缓存和二级缓存中都找不到此对象，刚从数据库加载拥有此id的对象。如果数据库也不存在这个拥有此id的对象，则返回null。

5.2.    Session的load()方法：

方法签名：public Object load(Class theClass, Serializable id) throws HibernateException; 根据给定的OID从数据库中加载一个持久化对象，若数据库中不存在与OID对应的记录，此方法将抛出org.hibernate.ObjectNotFoundException异常。

对于get和load的根本区别，一句话，hibernate对于load方法认为该数据在数据库中一定存在，可以放心的使用代理来延迟加载，如果在使用过程中发现了问题，只能抛异常；而对于get方法，hibernate一定要获取到真实的数据，否则返回null。

6.    Query接口：

Hibernate提供Query接口，它用来执行HQL语句。

6.1.    绑定参数

6.1.1.       使用 “?” 按参数位置绑定：

通过Query接口执行HQL语句时，可以先设定查询参数，然后通过setXXX()方法来绑定参数。如下

Query query = session.createQuery("from User as u where u.age > ? and u.name like ?");

query.setInteger(0, 25);

query.setString(1, "%a%");

List list = query.list();

Hibernate提供了绑定各种类型的参数的方法，如参数为字符串类型，可调用setString()，如果参数为整数类型，可调用setInteger()方法，以此类推。这些setXXX()方法的第1个参数HQL查询语句中参数的位置，第2个参数代表HQL查询语句中参数的值。

6.1.2.       使用 “:” 后跟变量名来按命名参数绑定：

可以使用命名参数来取代使用“?”设置参数的方法，这可以不用依照特定的顺序来设定参数值，如上例可改成：

Query query = session.createQuery("from User as u where u.age > :minAge and u.name like likeName");

query.setInteger("minAge", 25);

query.setString("likeName", "%a%");

List list = query.list();

使用命名参数方式的绑定方式有以下优势：

1)      代码可读性更好。

2)      命名参数不依赖它们在查询字符串中出现的位置。

3)      在同一个查询中可以多次使用。

所以，应该优先考虑使用命名参数方式。

6.2.    使用命名查询(nameQuery)：

可以将HQL语句编写在程序之外，以避免硬编码在程序之中，这样要修改HQL语句时就很方便。在xxx.hbm.xml中使用<qiuery/>标签，并在<![CDATA[ 与 ]]> 之间编写HQL，如下Student.hbm.xml：

......

<hibernate-mapping>

    <class name="org.qiujy.demo.User" table="user">

        <id name="id" column="id" type="java.lang.Integer">

            <generator class="native"/>

        </id>

        <property name="name" column="name" type="java.lang.String"/>

        <property name="age" column="age" type="java.lang.Integer"/>

    </class>

<query name="queryUserByAgeAndName">

    <![CDATA[

    from User as u where u.age >:minAge and u.name like :likeName

]]>

</query>

</hibernate-mapping>

在代码中这样来调用：

Query query = session.getNamedQuery("queryUserByAgeAndName");

query.setInteger("minAge", 25);

query.setString("likeName", "%a%");

List list = query.list();

6.3.    Query接口的list()方法：

Query接口的list()方法用于取得一个List类的实例，此实例中包括的可能是一个对象集合，也可能是一个对象数组集合。最常见的使用是用list()方法来取得一组符合实例对象。如上示例。

6.4.    Query接口的uniqueResult()方法：

当确信使用的HQL语句查询时返回的集合中只有一个对象时，就可以使用这个方法。但如果返回结果中有多个对象，使用这个方法会抛出org.hibernate.NonUniqueResultException 异常，说“query did not return a unique result”。

☆

October 10

Hibernate-QBC中的setFetchMode规则

使用QBC所需要注意的一些重点：HQL总是忽略配置文件中预先抓取策略，即在HQL中使用预先抓取时，必须显示指定fetch关键字（例如：from Team t left join fetch t.students s where t.teamName like '%2'）。

而QBC则不会忽略配置文件中的预先抓取策略。如果在配置文件中指定了预先抓取，则QBC会使用outer join fetch语句预先抓取对象的附属物，就好像是使用Session.get()或Session.load()方法一样。对于一个Criteria查询，可以调用criteria.setFetchMode("team",FetchMode.SELECT)，以使配置文件的预先抓取策略失效。

另外 createAlias时候也会覆盖 fetchmode 设置，修改关联对象的提取方式。

eg.  criteria.createAlias("tags", "tag",CriteriaSpecification.LEFT_JOIN); 

http://cid-65ac531dd8831879.spaces.live.com/Blog/cns!65AC531DD8831879!218.entry

Hibernate-column原则

属性                                 本身类的主键id                     关联类的主键id            <key column="" />的值      < column="" />的值

一对一                                    yes                                   yes                                                              

一对多                                    yes                                   yes                                yes                                

多对一                                    yes                                   yes                                                                     yes

多对多                                    yes                                  yes                                 yes                                 yes 

 

在我们查询Parent对象的时候，默认只有Parent的内容，并不包含childs的信息，如果在Parent.hbm.xml里设置lazy="false"的话才同时取出关联的所有childs内容. 问题是我既想要hibernate默认的性能又想要临时的灵活性该怎么办？  这就是fetch的功能。我们可以把fetch与lazy="true"的关系类比为事务当中的编程式事务与声明式事务,不太准确，但是大概是这个意思。
总值，fetch就是在代码这一层给你一个主动抓取得机会.
Parent parent = (Parent)hibernateTemplate.execute(new HibernateCallback() {
public Object doInHibernate(Session session) throws HibernateException, SQLException {
                Query q = session.createQuery(
"from Parent as parent "+
" left outer join fetch parent.childs " +
" where parent.id = :id"
                );
                q.setParameter("id",new Long(15));
return (Parent)q.uniqueResult();
            }
        });
        Assert.assertTrue(parent.getChilds().size() > 0);
你可以在lazy="true"的情况下把fetch去掉，就会报异常. 当然，如果lazy="false"就不需要fetch了

 

 

 

 

 

☆

 

最后把MYSQL5·0·18换成MYSQL5·0·22

改my.ini的default-character-set=gb2312有两个地方要改

重启mysql

打开运行

net stop mysql

net start mysql

最终OK。原来是数据库的问题。