C++博客-fenglin-文章分类-Hibernate

SSH&MySQL数据存取乱码

风林 — Thu, 18 Nov 2010 14:39:00 GMT

使用Hibernate向MySQL数据库里写了数据，全是乱码：

mysql> select * from tbl_Category;
+----+--------------------+--------------------+----------+
| id | descr              | name               | parentId |
+----+--------------------+--------------------+----------+
|  1 | ��?????�????       | ��?????�????       |     NULL |
|  2 | ????��??????       | ????��??????       |     NULL |
|  3 | ??�?�???????       | ??�?�???????       |     NULL |
|  4 | ???????�????       | ???????�????       |     NULL |
|  5 | ?��?�??�??       | ?��?�??�??       |     NULL |
|  6 | ?�???????�?�?????? | ?�???????�?�?????? |     NULL |
+----+--------------------+--------------------+----------+
6 rows in set (0.10 sec)

为了能处理Unicode编码，最好将数据库库的编码设置为UTF8(这样就可以不管是哪国文字都能正常显示)，连接时也用UTF8来处理。我们先查看当前数据的编码设置情况：

以上是未设置前的编码情况，通过以下命令来设置编码：

mysql> set character_set_client=utf8;
Query OK, 0 rows affected (0.00 sec)

使用set命令将相应的参数设置相应的值，请自己一个一个设置，下面是设置好了的。

到此为止，MySQL数据库编码被我们设置好了。
在连接MySQL数据库时，使用如下连接串：

jdbc.url=jdbc:mysql://192.168.1.114:3306/szblcz?useUnicode=true&characterEncoding=UTF-8

我这里是配置在一个Properties文件里。useUnicode=true&characterEncoding=UTF-8 这两个参数起到了至关重要的作用。
到这里一切再测试一下，应该没问题了。

风林 2010-11-18 22:39 发表评论

SSH_could not initialize proxy - no Session

风林 — Fri, 22 Oct 2010 15:02:00 GMT

报这个错误信息：
could not initialize proxy - no Session
原因：由于在加载数据时使用了load方法，返回的是一个代理对象，而在真正要使用数据时，Session已经被关闭，因此就会报此错误信息。
解决办法：
将Session的生命周期延长到JSP展现层，通过配置web.xml来完成。

    <filter>
        <filter-name>OpenSessionInViewfilter-name>
        <filter-class>org.springframework.orm.hibernate3.support.OpenSessionInViewFilterfilter-class>
    filter>
    <filter-mapping>
        <filter-name>OpenSessionInViewfilter-name>
        <url-pattern>/*url-pattern>
    filter-mapping>

将以上Filter加到web.xml文件里合适位置，注意Filter配置存在先后顺序。

风林 2010-10-22 23:02 发表评论

Spring3_Spring&Hibernate_HibernateDaoSupport(方法二)

风林 — Wed, 20 Oct 2010 16:38:00 GMT

SuperDAO.java

package com.bebig.dao.impl;

import javax.annotation.Resource;

import org.hibernate.SessionFactory;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;
import org.springframework.stereotype.Repository;

@Repository
public class SuperDAO extends HibernateDaoSupport {

    @Resource(name = "sessionFactory")//注入sessionFactory
    public void setSuperSessionFactory(SessionFactory sessionFactory) {
        super.setSessionFactory(sessionFactory);
    }

}

LogDAOImpl.java

package com.bebig.dao.impl;

import org.springframework.stereotype.Repository;

import com.bebig.dao.LogDAO;
import com.bebig.model.Log;

@Repository
public class LogDAOImpl extends SuperDAO implements LogDAO {

    @Override
    public void save(Log log) {
        this.getHibernateTemplate().save(log);
    }

}

UserDAOImpl.java

package com.bebig.dao.impl;

import org.springframework.stereotype.Repository;
import com.bebig.dao.UserDAO;
import com.bebig.model.User;

@Repository
public class UserDAOImpl extends SuperDAO implements UserDAO {

    @Override
    public void save(User u) {
        this.getHibernateTemplate().save(u);
    }

}

风林 2010-10-21 00:38 发表评论

Spring3_Spring&Hibernate_HibernateDaoSupport(方法一)

风林 — Wed, 20 Oct 2010 16:35:00 GMT

SuperDAO.java

package com.bebig.dao.impl;

import javax.annotation.Resource;

import org.springframework.orm.hibernate3.HibernateTemplate;
import org.springframework.stereotype.Repository;

@Repository
public class SuperDAO {
    private HibernateTemplate hibernateTemplate;

    @Resource
    public void setHibernateTemplate(HibernateTemplate hibernateTemplate) {
        this.hibernateTemplate = hibernateTemplate;
    }

    public HibernateTemplate getHibernateTemplate() {
        return hibernateTemplate;
    }

}

以上的hibernateTemplate属性由Spring注入，其它DAO则可以直接继承自它，而不用再次注入即可完成操作。
LogDAOImpl.java

UserDAOImpl.java

风林 2010-10-21 00:35 发表评论

Spring3_Spring&Hibernate_HibernateTemplate

风林 — Wed, 20 Oct 2010 16:25:00 GMT

beans.xml

xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
    xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
    xsi:schemaLocation="
http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/context
    http://www.springframework.org/schema/context/spring-context-3.0.xsd
    http://www.springframework.org/schema/aop
    http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
         http://www.springframework.org/schema/tx
       http://www.springframework.org/schema/tx/spring-tx-3.0.xsd">


    <context:annotation-config />
    <context:component-scan base-package="com.bebig" />

    <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"
        destroy-method="close">
        <property name="driverClassName" value="${jdbc.driverClassName}" />
        <property name="url" value="${jdbc.url}" />
        <property name="username" value="${jdbc.username}" />
        <property name="password" value="${jdbc.password}" />
    bean>
    <context:property-placeholder location="classpath:jdbc.properties" />

    <bean id="sessionFactory"
        class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">
        <property name="dataSource" ref="dataSource" />






        <property name="packagesToScan">
            <list>
                <value>com.bebig.modelvalue>
            list>
        property>
        <property name="hibernateProperties">
            <props>
                <prop key="hibernate.dialect">org.hibernate.dialect.SQLServerDialectprop>
                <prop key="hibernate.show_sql">trueprop>
                <prop key="hibernate.format_sql">trueprop>
                <prop key="hibernate.hbm2ddl.auto">updateprop>
            props>
        property>
    bean>

    <bean id="transactionManager"
        class="org.springframework.orm.hibernate3.HibernateTransactionManager">
        <property name="sessionFactory" ref="sessionFactory" />
    bean>

    <aop:config>
        <aop:pointcut expression="execution(public * com.bebig.service..*.*(..))"
            id="servicePointcut" />
        <aop:advisor advice-ref="txAdvisor" pointcut-ref="servicePointcut" />
    aop:config>
    <tx:advice id="txAdvisor" transaction-manager="transactionManager">
        <tx:attributes>
            <tx:method name="getUser" read-only="true" />
            <tx:method name="add*" propagation="REQUIRED" />
        tx:attributes>
    tx:advice>


    <bean id="hibernateTemplate" class="org.springframework.orm.hibernate3.HibernateTemplate">
        <property name="sessionFactory" ref="sessionFactory" />
    bean>

beans>

LogDAOImpl.java

package com.bebig.dao.impl;

import javax.annotation.Resource;

import org.springframework.orm.hibernate3.HibernateTemplate;
import org.springframework.stereotype.Repository;

import com.bebig.dao.LogDAO;
import com.bebig.model.Log;

@Repository
public class LogDAOImpl implements LogDAO {
    //由容器注入hibernateTemplate
    private HibernateTemplate hibernateTemplate;

    public HibernateTemplate getHibernateTemplate() {
        return hibernateTemplate;
    }

    @Override
    public void save(Log log) {
        hibernateTemplate.save(log);
        // throw new RuntimeException("error!");
    }

    @Resource
    public void setHibernateTemplate(HibernateTemplate hibernateTemplate) {
        this.hibernateTemplate = hibernateTemplate;
    }

}

UserDAOImpl.java

package com.bebig.dao.impl;

import javax.annotation.Resource;

import org.springframework.orm.hibernate3.HibernateTemplate;
import org.springframework.stereotype.Repository;
import com.bebig.dao.UserDAO;
import com.bebig.model.User;

@Repository
public class UserDAOImpl implements UserDAO {
    //由容器注入hibernateTemplate
    private HibernateTemplate hibernateTemplate;

    @Override
    public void save(User u) {
        hibernateTemplate.save(u);
    }

    @Resource
    public void setHibernateTemplate(HibernateTemplate hibernateTemplate) {
        this.hibernateTemplate = hibernateTemplate;
    }

    public HibernateTemplate getHibernateTemplate() {
        return hibernateTemplate;
    }

}

风林 2010-10-21 00:25 发表评论

Spring3_Hibernate&Spring声明式事务的XML配置方法

风林 — Wed, 20 Oct 2010 06:23:00 GMT

beans.xml

xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
    xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
    xsi:schemaLocation="
http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/context
    http://www.springframework.org/schema/context/spring-context-3.0.xsd
    http://www.springframework.org/schema/aop
    http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
         http://www.springframework.org/schema/tx
       http://www.springframework.org/schema/tx/spring-tx-3.0.xsd">


    <context:annotation-config />
    <context:component-scan base-package="com.bebig" />

    <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"
        destroy-method="close">
        <property name="driverClassName" value="${jdbc.driverClassName}" />
        <property name="url" value="${jdbc.url}" />
        <property name="username" value="${jdbc.username}" />
        <property name="password" value="${jdbc.password}" />
    bean>
    <context:property-placeholder location="classpath:jdbc.properties" />

    <bean id="sessionFactory"
        class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">
        <property name="dataSource" ref="dataSource" />

        <property name="packagesToScan">
            <list>
                <value>com.bebig.modelvalue>
            list>
        property>
        <property name="hibernateProperties">
            <props>
                <prop key="hibernate.dialect">org.hibernate.dialect.SQLServerDialectprop>
                <prop key="hibernate.show_sql">trueprop>
                <prop key="hibernate.format_sql">trueprop>
                <prop key="hibernate.hbm2ddl.auto">updateprop>
            props>
        property>
    bean>

    <bean id="transactionManager"
        class="org.springframework.orm.hibernate3.HibernateTransactionManager">
        <property name="sessionFactory" ref="sessionFactory" />
    bean>

    <aop:config>
        <aop:pointcut expression="execution(public * com.bebig.service..*.*(..))"
            id="servicePointcut" />
        <aop:advisor advice-ref="txAdvisor" pointcut-ref="servicePointcut" />
    aop:config>
    <tx:advice id="txAdvisor" transaction-manager="transactionManager">
        <tx:attributes>
            <tx:method name="getUser" read-only="true" />
            <tx:method name="add*" propagation="REQUIRED"/>
        tx:attributes>
    tx:advice>

beans>

风林 2010-10-20 14:23 发表评论

Spring3_Hibernate&Spring声明式事务的Annotation配置方法

风林 — Wed, 20 Oct 2010 06:19:00 GMT

beans.xml

xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
    xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
    xsi:schemaLocation="
http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/context
    http://www.springframework.org/schema/context/spring-context-3.0.xsd
    http://www.springframework.org/schema/aop
    http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
         http://www.springframework.org/schema/tx
       http://www.springframework.org/schema/tx/spring-tx-3.0.xsd">


    <context:annotation-config />
    <context:component-scan base-package="com.bebig" />

    <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"
        destroy-method="close">
        <property name="driverClassName" value="${jdbc.driverClassName}" />
        <property name="url" value="${jdbc.url}" />
        <property name="username" value="${jdbc.username}" />
        <property name="password" value="${jdbc.password}" />
    bean>
    <context:property-placeholder location="classpath:jdbc.properties" />

    <bean id="sessionFactory"
        class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">
        <property name="dataSource" ref="dataSource" />
        <property name="annotatedClasses">
            <list>
                <value>com.bebig.model.Uservalue>
                <value>com.bebig.model.Logvalue>
            list>
        property>
        <property name="hibernateProperties">
            <props>
                <prop key="hibernate.dialect">org.hibernate.dialect.SQLServerDialectprop>
                <prop key="hibernate.show_sql">trueprop>
                <prop key="hibernate.format_sql">trueprop>

                <prop key="hibernate.hbm2ddl.auto">updateprop>
            props>
        property>
    bean>

    <bean id="transactionManager"
            class="org.springframework.orm.hibernate3.HibernateTransactionManager">
    <property name="sessionFactory" ref="sessionFactory"/>
  bean>
  <tx:annotation-driven transaction-manager="transactionManager"/>

beans>

UserService.java

package com.bebig.service;

import javax.annotation.Resource;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import com.bebig.dao.LogDAO;
import com.bebig.dao.UserDAO;
import com.bebig.model.Log;
import com.bebig.model.User;

@Service("userService")
public class UserService {
    private UserDAO userDAO;
    private LogDAO logDAO;

    public LogDAO getLogDAO() {
        return logDAO;
    }

    @Resource
    public void setLogDAO(LogDAO logDAO) {
        this.logDAO = logDAO;
    }

    @Transactional//事务注解
    public void add(User u) {
        userDAO.save(u);
        Log l = new Log();
        l.setMsg("a user saved!");
        logDAO.save(l);
    }

    @Resource
    public void setUserDAO(UserDAO userDAO) {
        this.userDAO = userDAO;
    }

    public UserDAO getUserDAO() {
        return userDAO;
    }

    public void init() {
        System.out.println("init.");
    }

    public void destory() {
        System.out.println("destory.");
    }
}

风林 2010-10-20 14:19 发表评论

Spring3_Hibernate与Spring的整合

风林 — Wed, 20 Oct 2010 06:09:00 GMT

摘要: UserDAO.java package com.bebig.dao;import com.bebig.model.User;public interface UserDAO { public void save(User u);} UserDAOImpl.java ... 阅读全文

风林 2010-10-20 14:09 发表评论

事务并发级别选择（悲观锁、乐观锁）

风林 — Fri, 08 Oct 2010 12:26:00 GMT

在hibernate.cfg.xml配置程序里的默认事务并发处理级别：
2

为了考虑并发的效率，推荐使用级别2（TRANSACTION_READ_UNCOMMITTED），但是存在重复读问题（non-reapeatable reads）和幻读（phantom reads）问题。
在Hibernate中为了解决重复读问题（non-reapeatable reads）问题，可以使用悲观锁、乐观锁两种方法来解决。
用悲观锁解决 repeatable read 的问题（依赖于数据库的锁）
LOCKMODE.UPGRADE

悲观锁
使用数据库的锁，如：
select * from test for update（Oracle）
/////////////////////////////////////
select
        account0_.id as id0_0_,
        account0_.balance as balance0_0_
    from
        Account account0_ with (updlock,
        rowlock)
    where
        account0_.id=?
（SQL SERVER）

乐观锁
程序员自己加字段，来记录版本信息，当事务1查询数据后，事务2对数据产生变化时，版本号自动加1，当事务1提交事务时会检测版本号是否一致，如果不一致则报错。效率要比悲观锁高。

风林 2010-10-08 20:26 发表评论

事务隔离机制

风林 — Fri, 08 Oct 2010 01:07:00 GMT

Field Summary
`static int`	`TRANSACTION_NONE` A constant indicating that transactions are not supported.
`static int`	`TRANSACTION_READ_COMMITTED` A constant indicating that dirty reads are prevented; non-repeatable reads and phantom reads can occur.
`static int`	`TRANSACTION_READ_UNCOMMITTED` A constant indicating that dirty reads, non-repeatable reads and phantom reads can occur.
`static int`	`TRANSACTION_REPEATABLE_READ` A constant indicating that dirty reads and non-repeatable reads are prevented; phantom reads can occur.
`static int`	`TRANSACTION_SERIALIZABLE` A constant indicating that dirty reads, non-repeatable reads and phantom reads are prevented.

事务级别越高，效率越低。

一般使用read-commited事务隔离级别，如果在程序中没有指定事务隔离级别，则使用数据库系统默认的级别。

Hibernate事务隔离级别：

隔离级别	脏读 (Dirty Read)	不可重复读(NonRepeatable Read)	幻读（Phantom Read）
读操作未提交 (Read uncommitted)	可能	可能	可能
读操作已提交 (Read commited)	不可能	可能	可能
可重复读 (Repeatable read)	不可能	不可能	可能
可串行化（Serializable）	不可能	不可能	不可能

设置隔离级别：
4 //可填1,2,4（不可重复读）,8

在以下的情况下，Hibernate会调用flush():
(1)    事务提交时，如果flush模式不为FlushMode.NEVER, commit()将调用flush().
(2)    在某些查询语句之前(此查询语句已经改变了数据库状态，所以需要调用flush()以同步数据，使查出来的数据是经过更改的)
(3)    当程序强制调用session.flush时。
在一个事务中调用一个select 查询,如果此查询之前已经有某个update语句做了数据修改(注意此update语句并没有真正执行)，则首先会调用flush(),使update对数据库操作成功，接着才返回查询数据。
FlushMode有以下几种：
（1）       FlushMode.AUTO: 数据有更改，则在查询前更新此改动，以保证数据同步.
（2）       FlushMode.COMMIT: 在事务结束之前刷新session
（3）       FlushMode.NEVER: 仅在明确调用flush()时才对数据库进行同步.

在Hibernate中使用JDBC事务：
Hibernate.transaction.factory_class=net.sf.hibernate.transaction.JDBCTransactionFactory

使用JTA 事务：
       在一个具有多个数据库的系统中，可能一个程序将会调用几个数据库中的数据，需要一种分布式事务，或者准备用JTA来管理跨Session的长事务，那么就需要使用JTATransaction.

Hibernate中对数据的锁定：
如果要在事务中使用悲观锁，则可以像下面这样写：
Transaction tx=session.beginTransaction();
//取得持久化User对象，并使用LockMode.UPGRADE模式锁定对象
User user=(User)session.get(User.class,LockMode.UPGRADE);
user.setName(“newName”); //更改对象属性，注意并不需要使用session.save(user)
tx.commit();
这样的话，Hibernate会使用select …… for update 语句载入User类，并且锁住了这个对象在数据库中的列，直到事务完成(commit()以后)。

Hibernate 可以利用Query或者Criteria的setLockMode()方法来设定要锁定的表或列(Row)及其锁定模式。可设定的模式有两个：
（1）       LockMod.UPGRADE
（2）       LockMode.UPDGRADE_NOWAIT:

风林 2010-10-08 09:07 发表评论

事务并发问题处理

风林 — Fri, 08 Oct 2010 01:00:00 GMT

事务的特性：ACID
数据库事务的四个基本性质（ACID）
1. 原子性（Atomicity）

事务的原子性是指事务中包含的所有操作要么全做，要么全不做（all or none）。

2. 一致性（Consistency）
在事务开始以前，数据库处于一致性的状态，事务结束后，数据库也必须处于一致性状态。

拿银行转账来说，一致性要求事务的执行不应改变A、B 两个账户的金额总和。如果没有这种一致性要求，转账过程中就会发生钱无中生有，或者不翼而飞的现象。事务应该把数据库从一个一致性状态转换到另外一个一致性状态。

3. 隔离性（Isolation）
事务隔离性要求系统必须保证事务不受其他并发执行的事务的影响，也即要达到这样一种效果：对于任何一对事务T1 和 T2，在事务 T1 看来，T2 要么在 T1 开始之前已经结束，要么在 T1 完成之后才开始执行。这样，每个事务都感觉不到系统中有其他事务在并发地执行。

4. 持久性（Durability）
一个事务一旦成功完成，它对数据库的改变必须是永久的，即便是在系统遇到故障的情况下也不会丢失。数据的重要性决定了事务持久性的重要性。

事务并发可能存在如下几个问题：
A）第一类丢失更新（Lost Update）：这种问题只存在于不支持事务的数据库系统中。
B）脏读（Dirty Read）：读了其它事务没有提交的事务数据。
C）不可重复读（non-repeatable read)：在同一个事务前后读到的事务数据不一致。
D）第二类丢失更新（second update problem）【不可重复读的特殊情况】
E）幻读（phantom read）：重点说的是插入、删除操作，在读的过程中，另一个事务可能在插入或者删除操作。
其中B、C、E三种最为重要。

风林 2010-10-08 09:00 发表评论

缓存

风林 — Wed, 29 Sep 2010 15:28:00 GMT

缓存分为三种：一级缓存、二级缓存、查询缓存（三级缓存）
1、一级缓存
Session级缓存，只能在Session内部使用。

2、二级缓存
sessionFactory级别，所有Session可以共用。以配置EHCache为例：
a)新建/src/ehcache.xml文件，内容如下：

<ehcache>


    <diskStore path="java.io.tmpdir"/>


    <defaultCache
        maxElementsInMemory="10000"
        eternal="false"
        timeToIdleSeconds="120"
        timeToLiveSeconds="1200"
        overflowToDisk="true"
        />




    <cache name="sampleCache1"
        maxElementsInMemory="10000"
        eternal="false"
        timeToIdleSeconds="300"
        timeToLiveSeconds="600"
        overflowToDisk="true"
        />


    <cache name="sampleCache2"
        maxElementsInMemory="1000"
        eternal="true"
        timeToIdleSeconds="0"
        timeToLiveSeconds="0"
        overflowToDisk="false"
        /> -->



ehcache>

b)hibernate.cfg.xml

<property name="cache.use_second_level_cache">trueproperty>
<property name="cache.provider_class">org.hibernate.cache.EhCacheProviderproperty>

c)在需要使用缓存的实体类上加标注
@Cache(usage=CacheConcurrencyStrategy.READ_WRITE)
d)测试用例：

    @Test
    public void testCache1() {
        Session session = sf.openSession();
        session.beginTransaction();
        Category c = (Category) session.load(Category.class, 1);
        System.out.println(c.getName());
        session.getTransaction().commit();
        session.close();

        Session session2 = sf.openSession();
        session2.beginTransaction();
        Category c2 = (Category) session2.load(Category.class, 1);
        System.out.println(c2.getName());
        session2.getTransaction().commit();
        session2.close();

    }

3、查询缓存（三级缓存）
Query缓存，查询语句相同时会使用。
a)hibernate.cfg.xml

<property name="cache.provider_class">org.hibernate.cache.EhCacheProviderproperty>
<property name="cache.use_query_cache">trueproperty>

b)测试用例：

    @Test
    public void testQueryCache() {
        Session session = sf.openSession();
        session.beginTransaction();
        List<Category> q = session.createQuery("from Category c where c.id>?")
                .setCacheable(true)
                .setInteger(0, 3)
                .list();
        session.getTransaction().commit();
        session.close();

        Session session2 = sf.openSession();
        session2.beginTransaction();

        List<Category> q2 = session2
                .createQuery("from Category c where c.id>?")
                .setCacheable(true)
                .setInteger(0, 3)
                .list();
        session2.getTransaction().commit();
        session2.close();

    }

二级缓存适合放什么对象？
1、经常被访问
2、改动不大（不会被经常改动）
3、数量有限

load默认使用二级缓存，iterator默认使用二级缓存
list默认往二级缓存加数据，但是查询的时候不使用

缓存算法：
LRU(Least Recently Used）最近很少使用的对象会被删除
LFU(Least Frequently Used）命中率低的对象会被删除
FIFO(First In First Out）先进先出

风林 2010-09-29 23:28 发表评论

List与Iterator的区别

风林 — Wed, 29 Sep 2010 07:33:00 GMT

1、List
a)一次将所有对象属性取出来
b)不会从Session缓存读取数据，会重新查再刷新缓存

2、Iterator
a)一次将所有对象主键取出来，用时再取其它属性
b)会先读取Session里的缓存，如果存在则不查数据库直接读数据，否则会从数据库取数据

第一次用List取数据，再次使用数据时可以用Iterator直接从缓存里读取。
大多数情况下用List就可以了。

风林 2010-09-29 15:33 发表评论

1+N问题_N+1问题

风林 — Wed, 29 Sep 2010 06:55:00 GMT

1+N问题也可以叫N+1问题，什么是1+N问题呢？
如果在一个对象里关联另一个对象，并且fetch = FetchType.EAGER。
比如说ManyToOne（OneToMany也存在这种问题）关联，本来只需要取Many里的对象属性，可是Many里关联的对象都会单独再发一条语句取关联对象的属性。
本来只用发一条就可以查出Many里的对象属性，可是它发了一条语句后，再发N条语句取关联对象的数据。

解决办法：
1、fetch = FetchType.LAZY：在合适的时候才发出语句（按需要发语句）。
2、BatchSize：在One对象设置Size后，取出Many里的数据后，再发N/Size条语句取关联对象的数据，从而达到少发语句的目的。
3、Join Fetch：将Many与One做外连接，因此只要发一条语句就可以查出Many与其相关联的One对象数据，Criteria默认就是这种做法。

如何选择解决办法：
如果只要用Many里的对象，不用关联对象的属性，那就用方法1解决；
如果要Many里的对象属性，也想要关联的对象属性就用方法3解决。

风林 2010-09-29 14:55 发表评论

在实体类里设置导航的意义

风林 — Wed, 29 Sep 2010 03:13:00 GMT

在实体类里并不一定要设置OneToOne、OneToMany、ManyToOne、ManyToMany导航，之所以设置导航是为了方便程序的编写。

风林 2010-09-29 11:13 发表评论

Java有内存泄漏吗？

风林 — Wed, 29 Sep 2010 03:09:00 GMT

Java在语法级别上是没有内存泄漏的，因为Java有垃圾自动回收器。但是在使用资源上会存在内存泄漏现象，比如：Session用完后没有关闭，或者缓存数据在用完后没有Clear等就会造成另一种形式、意义上的内存泄漏。

风林 2010-09-29 11:09 发表评论

Hibernate查询_HQL_EJBQL_QBC_QBE

风林 — Wed, 29 Sep 2010 02:54:00 GMT

查询按功能强弱可以分为以下几种：
Native SQL > HQL > EJBQL > QBC > QBE

1、Native SQL
Native SQL为数据库系统本身的SQL，里面包含了一些特有的函数等，功能也最为强大。
如：

1    @Test
2    public void testHQL_34() {
3        Session session = sf.openSession();
4        session.beginTransaction();
5        //下面查询使用的函数是Session的createSQLQuery
6        SQLQuery q = session.createSQLQuery("select * from category limit 2,4").addEntity(Category.class);
7        List<Category> categories = (List<Category>)q.list();
8        for(Category c : categories) {
9            System.out.println(c.getName());
10        }
11        session.getTransaction().commit();
12        session.close();
13
14    }

2、HQL
Hibernate提供的面向对象查询语言。
如：

1    @Test
2    public void testHQL_02() {
3        Session session = sf.openSession();
4        session.beginTransaction();
5        //Category是对象名而不是数据表名
6        Query q = session.createQuery("from Category c where c.name > 'c5'");
7        List<Category> categories = (List<Category>)q.list();
8        for(Category c : categories) {
9            System.out.println(c.getName());
10        }
11        session.getTransaction().commit();
12        session.close();
13
14    }

3、EJBQL
与HQL类似，是HQL的一个子集

4、QBC
Query By Criteria，即带约束/条件的查询
如：

1    @Test
2    public void testQBC() {
3        Session session = sf.openSession();
4        session.beginTransaction();
5        //criterion 标准/准则/约束
6        Criteria c = session.createCriteria(Topic.class) //from Topic
7
8                     .add(Restrictions.gt("id", 2)) //greater than = id > 2
9                     .add(Restrictions.lt("id", 8)) //little than = id < 8
10                     .add(Restrictions.like("title", "t_"))
11                     .createCriteria("category")
12                     .add(Restrictions.between("id", 3, 5)) //category.id >= 3 and category.id <=5
13                     ;
14
15        //DetachedCriterea
16        for(Object o : c.list()) {
17            Topic t = (Topic)o;
18            System.out.println(t.getId() + "-" + t.getTitle());
19        }
20        session.getTransaction().commit();
21        session.close();
22
23    }

5、QBE
Query By Example
如：

1    @Test
2    public void testQBE() {
3        Session session = sf.openSession();
4        session.beginTransaction();
5        Topic tExample = new Topic();
6        tExample.setTitle("T_");
7
8        //创建一个例子对象，然后设置其相应的属性
9        //QBE仅适合于给特定值的查询
10        Example e = Example.create(tExample)
11                    .ignoreCase().enableLike();
12        //QBC除了添加自己的条件，最后将例子对象e也当成条件添加进来
13        //QBC可以添加给特定值的条件，也可添加给了一定范围的条件
14        Criteria c = session.createCriteria(Topic.class)
15                     .add(Restrictions.gt("id", 2))
16                     .add(Restrictions.lt("id", 8))
17                     .add(e)
18                     ;
19        //from Topic t where t.id>2 and t.id<8 and t.title like 'T_'
20
21
22        for(Object o : c.list()) {
23            Topic t = (Topic)o;
24            System.out.println(t.getId() + "-" + t.getTitle());
25        }
26        session.getTransaction().commit();
27        session.close();
28
29    }

以上几种方法，其中QBC、QBE更加符合面向对象编程（仅此而已）。

风林 2010-09-29 10:54 发表评论

树型结构

风林 — Wed, 29 Sep 2010 00:45:00 GMT

摘要: 类文件：TreeNode.java 1package com.bebig.hibernate.model; 2 3import java.util.HashSet; 4import java.util.Set; 5 6import javax.persistence.CascadeType;&n... 阅读全文

风林 2010-09-29 08:45 发表评论

继承映射(Inheritance Mapping)

风林 — Tue, 28 Sep 2010 03:44:00 GMT

摘要: EJB3 supports the three types of inheritance: EJB3支持三种类型的继承: 1.Table per Class Strategy: the element in Hibernate 每个类分别一张表 2.Single Table per Class ... 阅读全文

风林 2010-09-28 11:44 发表评论

关联关系的CRUD_Cascade_Fetch

风林 — Tue, 28 Sep 2010 01:04:00 GMT

a、cascade影响CUD（增、改、删）操作，级联只是方便操作。
b、fetch影响R（检索）操作。
c、两边关系不能同时将fetch设置成FetchType.EAGER，否则将导致多次发出相同SQL，影响效率。
d、关系为多的那边，fetch默认为EAGER，关系为一的那边，fetch默认为LAZY。

风林 2010-09-28 09:04 发表评论

导出或者生成数据表结构SchemaExport

风林 — Tue, 28 Sep 2010 00:55:00 GMT

1    @Test
2    public void testSchemaExport() {
3        new SchemaExport(new AnnotationConfiguration().configure()).create(
4                false, true);
5
6    }

SchemaExport方法导出数据表DDL语句，或者执行生成的DDL语句。
第一个参数为true时，输出脚本到Console，否则不输出。
第二个参数为true时，执行脚本，否则不执行。

风林 2010-09-28 08:55 发表评论

多对多双向关联

风林 — Mon, 27 Sep 2010 02:23:00 GMT

摘要: 1、AnnotationTeacher.java 1package com.bebig.hibernate.model; 2 3import java.util.HashSet; 4import java.util.Set; 5 6import javax.persistence.Entity;... 阅读全文

风林 2010-09-27 10:23 发表评论

多对多单向关联

风林 — Mon, 27 Sep 2010 01:55:00 GMT

摘要: 1、AnnotationTeacher.java 1package com.bebig.hibernate.model; 2 3import java.util.HashSet; 4import java.util.Set; 5 6import javax.persistence.Entity;... 阅读全文

风林 2010-09-27 09:55 发表评论

一对多&多对一双向关联

风林 — Mon, 27 Sep 2010 01:03:00 GMT

摘要: 1、AnnotationGroup.java 1package com.bebig.hibernate.model; 2 3import java.util.HashSet; 4import java.util.Set; 5 6import javax.persistence.Entity;&n... 阅读全文

风林 2010-09-27 09:03 发表评论

一对多单向关联

风林 — Mon, 27 Sep 2010 00:40:00 GMT

摘要: 1、AnnotationUser.java 1package com.bebig.hibernate.model; 2 3import javax.persistence.Entity; 4import javax.persistence.GeneratedValue; 5import javax.per... 阅读全文

风林 2010-09-27 08:40 发表评论

多对一单向关联

风林 — Sun, 26 Sep 2010 10:16:00 GMT

1、Annotation
Group.java

1package com.bebig.hibernate.model;
2
3import javax.persistence.Entity;
4import javax.persistence.GeneratedValue;
5import javax.persistence.Id;
6import javax.persistence.Table;
7
8@Entity
9@Table(name="t_group")
10public class Group {
11    private int id;
12
13    private String name;
14
15    @Id
16    @GeneratedValue
17    public int getId() {
18        return id;
19    }
20
21    public String getName() {
22        return name;
23    }
24
25    public void setId(int id) {
26        this.id = id;
27    }
28
29    public void setName(String name) {
30        this.name = name;
31    }
32}
33

User.java

1package com.bebig.hibernate.model;
2
3import javax.persistence.Entity;
4import javax.persistence.GeneratedValue;
5import javax.persistence.Id;
6import javax.persistence.ManyToOne;
7import javax.persistence.Table;
8
9@Entity
10@Table(name="t_user")
11public class User {
12    private int id;
13
14    private String name;
15
16    private Group group;
17
18    @ManyToOne
19    public Group getGroup() {
20        return group;
21    }
22
23    @Id
24    @GeneratedValue
25    public int getId() {
26        return id;
27    }
28
29    public String getName() {
30        return name;
31    }
32
33    public void setGroup(Group group) {
34        this.group = group;
35    }
36
37    public void setId(int id) {
38        this.id = id;
39    }
40
41    public void setName(String name) {
42        this.name = name;
43    }
44}
45

hibernate.cfg.xml

1 <mapping class="com.bebig.hibernate.model.Group"/>
2 <mapping class="com.bebig.hibernate.model.User"/>

2、XML
两个类文件不变，修改hibernate.cfg.xml，并增加两个类映射XML文件。
Group.hbm.xml

1xml version="1.0"?>
2DOCTYPE hibernate-mapping PUBLIC
3        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
4        "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
5
6<hibernate-mapping package="com.bebig.hibernate.model">
7    <class name="Group" table="t_group">
8        <id name="id">
9            <generator class="native">generator>
10        id>
11        <property name="name">property>
12    class>
13hibernate-mapping>

User.hbm.xml

1xml version="1.0"?>
2DOCTYPE hibernate-mapping PUBLIC
3        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
4        "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
5
6<hibernate-mapping package="com.bebig.hibernate.model">
7    <class name="User" table="t_user">
8        <id name="id">
9            <generator class="native">generator>
10        id>
11        <property name="name">property>
12        <many-to-one name="group" column="groupId">many-to-one>
13    class>
14hibernate-mapping>

hibernate.cfg.xml

1<mapping resource="com/bebig/hibernate/model/Group.hbm.xml" />
2 <mapping resource="com/bebig/hibernate/model/User.hbm.xml" />

风林 2010-09-26 18:16 发表评论

组件映射

风林 — Sun, 26 Sep 2010 09:25:00 GMT

1、Annotation
Husband.java

1package com.bebig.hibernate.model;
2
3import javax.persistence.Embedded;
4import javax.persistence.Entity;
5import javax.persistence.GeneratedValue;
6import javax.persistence.Id;
7
8@Entity
9public class Husband {
10    private int id;
11
12    private String name;
13
14    private Wife wife;
15
16    @Id
17    @GeneratedValue
18    public int getId() {
19        return id;
20    }
21
22    public String getName() {
23        return name;
24    }
25
26    @Embedded
27    public Wife getWife() {
28        return wife;
29    }
30
31    public void setId(int id) {
32        this.id = id;
33    }
34
35    public void setName(String name) {
36        this.name = name;
37    }
38
39    public void setWife(Wife wife) {
40        this.wife = wife;
41    }
42}
43

Wife.java

1package com.bebig.hibernate.model;
2
3public class Wife {
4    private String wifename;
5
6    private int age;
7
8    public int getAge() {
9        return age;
10    }
11
12    public String getWifeName() {
13        return wifename;
14    }
15
16    public void setAge(int age) {
17        this.age = age;
18    }
19
20    public void setWifeName(String name) {
21        this.wifename = name;
22    }
23}
24

hibernate.cfg.xml

1 <mapping class="com.bebig.hibernate.model.Husband"/>

2、XML
除了hibernate.cfg.xml与以上不同外，另添加一个Husband.hbm.xml文件。
Husband.hbm.xml

1xml version="1.0"?>
2DOCTYPE hibernate-mapping PUBLIC
3        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
4        "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
5
6<hibernate-mapping package="com.bebig.hibernate.model">
7    <class name="Husband">
8        <id name="id">
9            <generator class="native">generator>
10        id>
11        <property name="name">property>
12        <component name="wife">
13            <property name="wifeName">property>
14            <property name="age">property>
15        component>
16    class>
17hibernate-mapping>

hibernate.cfg.xml

1<mapping resource="com/bebig/hibernate/model/Husband.hbm.xml" />

风林 2010-09-26 17:25 发表评论

联合主键关联

风林 — Sun, 26 Sep 2010 08:58:00 GMT

摘要: Husband.java 1package com.bebig.hibernate.model; 2 3import javax.persistence.Entity; 4import javax.persistence.GeneratedValue; 5import javax.persistence.... 阅读全文

风林 2010-09-26 16:58 发表评论

一对一外键关联

风林 — Sun, 26 Sep 2010 06:57:00 GMT

1、一对一单向外键关联
A、Annotation：@One2One @JoinColumn指定列名，默认为字段_id
B、XML：

2、一对一双向外键关联
A、Annotation：@One2One(mappedBy="")，规律：凡是双向关联，必须设置mappedBy
B、XML：

风林 2010-09-26 14:57 发表评论

saveOrUpdate/clear/flush/SchemaExport

风林 — Sat, 25 Sep 2010 15:18:00 GMT

1、saveOrUpdate
如果session要保存的对象的ID存在，而对象的相应属性与数据库里的相应字段值不相同，则为Update，否则session执行save操作。

2、clear
无论调用的是load还是get，都会先查找缓存（一级缓存），如果不存在，再到数据库里查找，调用clear方法可以强制清除session缓存。

3、flush
强制进行从内存到数据库的同步，commit会自动进行一次flush操作。可以通过setFlushMode来设置flush模式。

4、SchemaExport
输出DDL脚本到Console或者数据库（即生成数据表）

风林 2010-09-25 23:18 发表评论