中文字幕精品一区二区精品绿巨人,美女久久久久久,亚洲第一福利视频

abin — Fri, 19 Apr 2013 13:28:00 GMT

我是一个初学�?
我徏了一个classes表和一个students�?表示班��和学�?其中学生里面有一个外键关联到班��?
然后学生�c�里面徏了一个classes的属�?
用session取出学生�?如果关闭session的话,��无法读取到学生�c�里的classes�?没有关闭��p��d��?
请问�q�个session会不会媄响到其他用户的访问呢?
��是说如果有两个用户�q�行操作数据库的�?一个用��L��session不关闭媄不媄响另一个用户呢?

J2EE中最大的一个观念就是分�?.

session是持久层的东�?不可�H�到别的�?.

你的�q�个问题其实��是延迟加蝲的问�?

从理论的角度�?最好是用一个就关一�?防止资源消�?
但由于hibernate中的延迟加蝲,所以出��C��你的关闭session的话,��无法读取到学生�c�里的classes值问�?
�q�个问题可以用Hibernate.initialize()来解�?也可��׃��用opensessionview的方�?spring中提供了�q�样的filter
不知道这在��用中有没有��用spring.用了��比较方�?也不会出��C��所说的

引用

一个用��L��session不关闭媄不媄响另一个用�?/div>
因�ؓsession由spring来管�?很安�?不会出现�q�个�U��ƈ发问�?

如果只是使用了Hibernate的话,那得注意�?你在servlet中直接创建session��可能出现�ƈ发问�?因�ؓsession不是�U�程安全�?而servlet是多�U�程�?
�q�时可以使用ThreadLocal来解册��个问�?

希望对你有所帮助!

abin 2013-04-19 21:28 发表评论

Hibernate4之getCurrentSession和openSession

abin — Fri, 19 Apr 2013 13:22:00 GMT

在一个应用程序中�Q?/span>如果DAO层��用Spring的hibernate模板�Q�通过Spring来控制session的生命周期，则首选getCurrentSession

使用Hibernate的大多数应用�E�序需要某�U��Ş式的“上下文相关的”session�Q�特定的session在整个特定的上下文范围内始终有效。然而，对不同类型的应用�E�序而言�Q�要�l��ؓ什么是�l�成�q�种“上下�?#8221;下一个定义通常是困隄��Q�不同的上下文对“当前”�q�个概念定义了不同的范围。在3.0版本之前�Q��用Hibernate的程序要么采用自行编写的��Z��ThreadLocal的上下文session�Q�如下面代码�Q�，要么采用HibernateUtil�q�样的辅助类�Q�要么采用第三方框架�Q�比如Spring或Pico)�Q�它们提供了��Z��代理(proxy)或者基于拦截器(interception)的上下文相关session

�?.0.1版本开始，Hibernate增加了SessionFactory.getCurrentSession()�Ҏ(gu��)��。一开始，它假定了采用JTA事务�Q�JTA事务定义了当前session的范围和上下�?scope and context)。Hibernate开发团队坚信，因�ؓ有好几个独立的JTA TransactionManager实现�E�_��可用�Q�不论是否被部��v��C��个J2EE容器中，大多�?假若不是所有的�Q�应用程序都应该采用JTA事务��理�?��Z��q�一点，采用JTA的上下文相关session可以满��你一切需要�?nbsp;

更好的是�Q�从3.1开始，SessionFactory.getCurrentSession()的后台实现是可拔插的。因此，我们引入了新的扩展接�?(org.hibernate.context.CurrentSessionContext)和新的配�|�参�?(hibernate.current_session_context_class)�Q�以便对什么是“当前session”的范围和上下�?scope and context)的定义进行拔插�?nbsp;

org.hibernate.context.JTASessionContext - 当前session�Ҏ(gu��)��JTA来跟�t�和界定。这和以前的仅支持JTA的方法是完全一��L��?nbsp;

org.hibernate.context.ThreadLocalSessionContext - 当前session通过当前执行的线�E�来跟踪和界定�?nbsp;

�q�两�U�实现都提供�?#8220;每数据库事务对应一个session”的编�E�模型，也称作一��h��一事务。即Hibernate的session的生命周期由数据库事务的生存来控制。假若你采用自行�~�写代码来管理事务（比如�Q�在�U��a的J2SE,或�?JTA/UserTransaction/BMT�Q�，��你��用Hibernate Transaction API来把底层事务实现从你的代码中隐藏掉。如果你在支持CMT的EJB容器中执行，事务边界是声明式定义的，你不需要在代码中进行�Q何事务或session��理操作�?nbsp;

1、getCurrentSession()与openSession()的区�?/span>
* 采用getCurrentSession()创徏的session会绑定到当前�U�程中，而采用openSession()
创徏的session则不�?nbsp;
* 采用getCurrentSession()创徏的session在commit或rollback时会自动关闭�Q�而采用openSession()创徏的session必须手动关闭

2、��用getCurrentSession()需要在hibernate.cfg.xml文�g中加入如下配�|�：
* 如果使用的是本地事务�Q�jdbc事务�Q?nbsp;
thread
* 如果使用的是全局事务�Q�jta事务�Q?nbsp;
jta

在SessionFactory启动的时候，Hibernate会根据配�|�创建相应的CurrentSessionContext�Q�在 getCurrentSession()被调用的时候，实际被执行的�Ҏ(gu��)��是CurrentSessionContext.currentSession()。在currentSession()执行�Ӟ��如果当前Session 为空�Q�currentSession 会调用SessionFactory 的openSession�?/span>所以getCurrentSession() 对于Java EE 来说是更好的获取Session 的方法�?/span>

sessionFactory.getCurrentSession()可以完成一�p�d��的工作，当调用时�Q�hibernate��session�l�定到当前线�E�，事务�l�束后，hibernate��session从当前线�E�中释放�Q��ƈ且关闭session�Q�当再次调用getCurrentSession()�Ӟ��得��C��个新的session�Q��ƈ重新开始这一�p�d��工作�?nbsp;
�q�样调用�Ҏ(gu��)��如下�Q?nbsp;

Session session = HibernateUtil.getSessionFactory().getCurrentSession();
session.beginTransaction();
Event theEvent = new Event();
theEvent.setTitle(title);
theEvent.setDate(theDate);
session.save(theEvent);
session.getTransaction().commit();

不需要close session�?nbsp;

利于ThreadLocal模式��理Session
早在Java1.2推出之时�Q�Java�q�_��中就引入了一个新的支持：java.lang.ThreadLocal�Q�给我们在编写多�U�程�E�序时提供了一�U�新的选择。ThreadLocal是什么呢�Q�其实ThreadLocal�q��是一个线�E�的本地实现版本�Q�它�q�不是一个Thread�Q�而是thread local variable(�U�程局部变�?。也许把它命名�ؓThreadLocalVar更加合适。线�E�局部变�?ThreadLocal)其实的功用非常简单，��是为每一个��用某变量的线�E�都提供一个该变量值的副本�Q�是每一个线�E�都可以独立地改变自��q��副本�Q�而不会和其它�U�程的副本冲�H�。从�U�程的角度看�Q�就好像每一个线�E�都完全拥有一个该变量。ThreadLocal是如何做��Cؓ每一个线�E�维护变量的副本的呢�Q�其实实现的思�\很简单，在ThreadLocal�c�M��有一个Map�Q�用于存储每一个线�E�的变量的副本�?nbsp;

public class HibernateUtil {

    private static String CONFIG_FILE_LOCATION = "/hibernate.cfg.xml";

    //创徏一个局部线�E�变�?/span>
    private static final ThreadLocal THREAD_LOCAL = new ThreadLocal();

    private static final Configuration cfg = new Configuration();

    private static SessionFactory sessionFactory;

    /*
     * 取得当前session对象
     */
    @SuppressWarnings("deprecation")
    public static Session currentSession() throws HibernateException {
        Session session = (Session)THREAD_LOCAL.get();
        if (session == null) {
            if (sessionFactory == null) {
                try {
                    cfg.configure(CONFIG_FILE_LOCATION);
                    sessionFactory = cfg.buildSessionFactory();
                } catch (Exception e) {
                    System.out.println("【ERROR】创建SessionFactory对象出错�Q�原因是�Q?);
                    e.printStackTrace();
                }
            }

            session = sessionFactory.openSession();
            THREAD_LOCAL.set(session);
        }
        return session;
    }

    public static void closeSession() throws HibernateException {
        Session session = (Session) THREAD_LOCAL.get();
        THREAD_LOCAL.set(null);
        if(session != null){
            session.close();
        }
    }
}

abin 2013-04-19 21:22 发表评论

Hibernate hql 查询指定字段�q�获取结果集

abin — Thu, 25 Oct 2012 06:32:00 GMT

在hibernate中，用hql语句查询实体�c�，采用list�Ҏ(gu��)��的返回结果�ؓ一个List�Q�该List中封装的对象分�ؓ以下三种情况�Q?br />1.查询全部字段的情况下�Q�如"from 实体�c?�Q�list中封装的对象为实体类本��n�Q�各属性都��得到填充�?br />2.只查询一个字�D�，默认情况下，list中封装的是Object对象�?/span>
3.查询两个或两个以上的字段�Q�默认情况下�Q�list中封装的�?span style="color: rgb(255,0,0)">Object[],长度与所查询的字�D�|��一致�?br />

对于后两�U�情况，用标�{�N��历时不太方便�Q�因为无法直接�{换成实体�cȝ��对象。比较简单的解决�Ҏ(gu��)��是：

の：在hql中��?span style="color: rgb(255,0,0)">select new 包名.�c�d��(属�?�Q�属�?……) from 实体�c�，同时在实体类中添加带参的构造方法，参数的个数和��序与（属�?�Q�属�?……) 保持一�?/span>�Q�这��h��们得到的list中存攄��依然是实体类的对象，所查询到的属性得��C��填充�Q��用�v来更为方�ѝ�?br />

　　の：hql查询多表部分字段�Q?span style="color: rgb(255,0,0)">select new 包名.�?实体�c�d��(�?.属�?�Q�表2.属�?……) from �?实体�c?�?实体�c?where �?.ID=�?.ID�Q�即相关联的字段�Q?/span>�Q�同时在要返回的�?实体�c�M��d��?的属性和带参的构造方法，参数的个数和��序与（�?.属�?�Q�表2.属�?2……) 保持一�?/span>

例如要查询Problem 中的pid�Q�score�Q�title�Q�totalAccept,totalSubmission,unSee

public class Problem {

private int pid;

private int score;

private int timeLimit;

private int memoryLimit;

private int totalAccept;

private int totalSubmission;

private int unSee;

private String title;

private String description;

private String input;

private String output;

public Problem(int pid, int score,String title, int totalAccept, int totalSubmission,

int unSee) {

super();

this.pid = pid;

this.score = score;

this.totalAccept = totalAccept;

this.totalSubmission = totalSubmission;

this.unSee = unSee;

this.title = title;

}

//省略getter �?setter

}

查询语句如下

Query query=session.createQuery("select new Problem(pid,score,title,totalAccept,totalSubmission,unSee) from Problem order by pid");

//query.setFirstResult(firstResult); //分页函数

//query.setMaxResults(maxResutl);

List problems=query.list();//�q�回的还是Problem对象

关于hibernate的问题：
我现在有�?nbsp;
hql="select s.id,s.name,t.id,t.name from User s,Useraddress t where t.id=s.id"

�q�条sql里面的User和Useraddress是两个实体类�Q�现在组合查询分别取出来两个实体�c�里面的两个字段�Q�然后我惛_��建立一个实体类Result�Q�里面定义这四个�l�果集里面的字段�Q�能不能执行完这条hql�Q�正好把�q�个�l�果集对应到实体�c�Result里面呢，Result�q�个实体�c�，没写映射文�gResult.hbm.xml.
希望能帮下忙

2�U�做�?nbsp;
创徏一个class temp
有属性sid,name,tid,sname,tname
创徏一个构造函�?nbsp;
public temp(sid,name,tid,sname,tname)
{

}
1.hql�?nbsp;
List

select new temp(s.id,s.name,t.id,t.name) from User s,Useraddress t where t.id=s.id

2.List
记录的每一行是object[] 遍历
object[0] ==s.id
object[1] ==s.name
object[2] ==t.id
object[3] ==t.name

感谢glamey兄弟的文章，正好解决了当前遇到的问题。原文链接如下：http://glamey.iteye.com/blog/721019
假设我们现在有一个DTO�Q�其属性包括两张表的属性，我们现在需要将sql语句查询得到的内容�{��Z��个DTO对象�Q�其解决�Ҏ(gu��)��如下�Q?nbsp;

String sql = "select u.userName as userName �Q�p.title as title ,p.addTime as addTime from user as u,post as p where u.id=p.userId"

Query q = factory.getCurrentSession().createSQLQuery(sql).setResultTransformer(Transformers.aliasToBean(PostVO.class));

上面select中as后面的内容必��d��PostVO中属性名一��_��q�样��可以返回一个针对PostVO的一个集合�?nbsp;
其实大家可以看下hibernate�q�一部分的源码就会发玎ͼ�主要是��用了AliasToBeanResultTransformer�q�个�c�，通过sql的查询，会返回数�l�，然后hibernate�Ҏ(gu��)��数据表的映射�Q�自动帮我们来set对应的字�D�属性，所以标�U�的部分务必要跟VO中的属性��g��_��要不然会报错的�?nbsp;
如果需要的话，大家也可以重写这个类。例如VOResultTransformer。然后在dao中更�Ҏ(gu��)��Q?nbsp;

setResultTransformer(new VOResultTransformer(PostVO.class));

另外�Q�除了以上glamey的方法外�Q�还有一�U�方法：

Query q = session.createQuery("select new com.hibernate.MsgInfo(m.id, m.cont, m.topic.title, m.topic.category.name) from Msg m");

List list=q.list();

其中�Q�MsgInfo是DTO�?/span>值得注意的是�Q�第二种�Ҏ(gu��)��中DTO必须提供带参数的构造方法，�q�且HQL语句中属性的位置要与构造方法中的位�|�一一对应�?/span>

abin 2012-10-25 14:32 发表评论

Hibernate 命名查询NamedQuery

abin — Mon, 10 Sep 2012 05:28:00 GMT

/**
* UserBean entity. @author MyEclipse Persistence Tools
*/

public class UserBean implements java.io.Serializable {

// Fields

private String id1;
private String name1;
private java.util.Date createtime1;
private String address;

// Constructors

/** default constructor */
public UserBean() {
}

/** minimal constructor */
public UserBean(String id1) {
this.id1 = id1;
}

/** full constructor */
public UserBean(String id1, String name1, java.util.Date createtime1, String address) {
  this.id1 = id1;
  this.name1 = name1;
  this.createtime1 = createtime1;
  this.address = address;
}

// Property accessors

public String getId1() {
return this.id1;
}

public void setId1(String id1) {
this.id1 = id1;
}

public String getName1() {
return this.name1;
}

public void setName1(String name1) {
this.name1 = name1;
}

public java.util.Date getCreatetime1() {
return this.createtime1;
}

public void setCreatetime1(java.util.Date createtime1) {
this.createtime1 = createtime1;
}

public String getAddress() {
return this.address;
}

public void setAddress(String address) {
this.address = address;
}

}

"

package com.abin.lee.hibernate;

import java.util.List;

import junit.framework.TestCase;

import org.hibernate.Criteria;
import org.hibernate.HibernateException;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.hibernate.criterion.Order;

import com.lcdbtsf.air.po.UserBean;

public class UserDao extends TestCase {

public List getAll(){
  Configuration cfg = new Configuration().configure(); // 获取hibernate的配�|�信�?br />  SessionFactory sf = cfg.buildSessionFactory(); // �Ҏ(gu��)��config建立sessionFactory
  Session session = sf.openSession(); // factory用于建立session�Q�开启Session�Q�相当于开启JDBC的Connection
  Transaction ts = session.beginTransaction(); // 创徏事务的对象ts
  List list=null;
  try {
   Criteria criteria=session.createCriteria(UserBean.class);
   criteria.addOrder(Order.desc("createtime1"));
   list=criteria.list();
   ts.commit();
  } catch (HibernateException he) {
   he.printStackTrace();
   ts.rollback();
  }
  return list;
}

public List getAllByAddress(String address){
  Configuration cfg = new Configuration().configure(); // 获取hibernate的配�|�信�?br />  SessionFactory sf = cfg.buildSessionFactory(); // �Ҏ(gu��)��config建立sessionFactory
  Session session = sf.openSession(); // factory用于建立session�Q�开启Session�Q�相当于开启JDBC的Connection
  Transaction ts = session.beginTransaction(); // 创徏事务的对象ts
  List list=null;
  try {
   Query query=session.getNamedQuery("getUserBeanByAddress");
   query.setParameter("address", address);
   list=query.list();
   ts.commit();
  } catch (HibernateException he) {
   he.printStackTrace();
   ts.rollback();
  }
  return list;
}

}

package com.abin.lee.hibernate;

import java.util.List;

import junit.framework.TestCase;

import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;

import com.lcdbtsf.air.po.UserBean;

public class UserDaoTest extends TestCase {

public void test() {
   List list=new UserDao().getAllByAddress("shanghai");
  try {
   if(list.size()>0){
    UserBean user =list.get(0);
    System.out.println(list.get(0).getId1());
   }
  } catch (HibernateException he) {
   he.printStackTrace();  }
}

}

abin 2012-09-10 13:28 发表评论

abin — Thu, 06 Sep 2012 16:04:00 GMT

摘要: 要对资料库管理系�l�进行操作，最基本的就是��用SQL�Q�Standard Query Language�Q�语句，大部份的资料库都支援标准的SQL语句�Q�然而也有一些特定于资料库的SQL语句�Q�应用程式配合SQL语句�q�行资料库查询时�Q�若使用到特定于资料库的SQL语句�Q�程式本�w�会有相依于特定资料库的问题。��用Hibernate�Ӟ��即��(zh��n)�不了解SQL的��用与撰写�Q�也可以使用它所提供的API来进行SQL语句查询�Q�o... 阅读全文

abin 2012-09-07 00:04 发表评论

Hibernate Criteria

abin — Thu, 06 Sep 2012 15:59:00 GMT

hibernate �?span class="Apple-converted-space"> Criteria 的��用介�l?/a>

http://blog.csdn.net/alex197963/article/details/2628196

abin 2012-09-06 23:59 发表评论

Hibernate 调用oracle存储�q�程

abin — Thu, 06 Sep 2012 15:21:00 GMT

package com.abin.lee.bean;

/**
* Userbean entity. @author MyEclipse Persistence Tools
*/

public class UserBean implements java.io.Serializable {

// Fields

private String id;
private String username;
private String password;

// Constructors

/** default constructor */
public UserBean() {
}

/** minimal constructor */
public UserBean(String id) {
this.id = id;
}

/** full constructor */
public UserBean(String id, String username, String password) {
  this.id = id;
  this.username = username;
  this.password = password;
}

// Property accessors

public String getId() {
return this.id;
}

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

public String getUsername() {
return this.username;
}

public void setUsername(String username) {
this.username = username;
}

public String getPassword() {
return this.password;
}

public void setPassword(String password) {
this.password = password;
}

}

package com.abin.lee.dao;

import java.sql.SQLException;

import org.hibernate.SQLQuery;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;

public class UserDao {
private static final ThreadLocal threadLocal = new ThreadLocal();
private static SessionFactory sessionFactory;
static {
  sessionFactory=new Configuration().configure().buildSessionFactory();
}
public static Session GetSession(){
  Session session=(Session)threadLocal.get();
  if(null == session|| !session.isOpen()){
   if(null==sessionFactory){
    sessionFactory=new Configuration().configure().buildSessionFactory();
   }
   session=(sessionFactory!=null)?sessionFactory.openSession():null;
   threadLocal.set(session);
  }
  return session;
}

public static int insert(String id,String usr,String pwd) throws SQLException{
  UserDao UserDao=new UserDao();
  Session session=UserDao.GetSession();
  Transaction tx=session.beginTransaction();
  SQLQuery sqlQuery = session.createSQLQuery("{call insertObj(?,?,?)}");
  sqlQuery.setParameter(0, id);
  sqlQuery.setParameter(1, usr);
  sqlQuery.setParameter(2, pwd);
  int result=sqlQuery.executeUpdate();
  System.out.println("result="+result);
  return result;
}

}

package com.abin.lee.test;

import java.sql.SQLException;

import junit.framework.TestCase;

import com.abin.lee.dao.UserDao;

public class UserTest extends TestCase{
public void test() throws SQLException{
  UserDao user=new UserDao();
  int success=user.insert("abin","abing","bing");
  System.out.println("success="+success);
}
}

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

   org.hibernate.dialect.OracleDialect


   jdbc:oracle:thin:@localhost:1521:xe

  abing
  abing

   oracle.jdbc.driver.OracleDriver


   OracleConnection

abin 2012-09-06 23:21 发表评论

hibernate 分页�Ҏ(gu��)��

abin — Thu, 17 May 2012 08:54:00 GMT

**
* 使用hql 语句�q�行操作

   * @param hql
* @param offset
* @param length
* @return List
*/
public List getListForPage(final String hql, final int offset,
    final int length) {
   List list = getHibernateTemplate().executeFind(new HibernateCallback() {
    public Object doInHibernate(Session session)
      throws HibernateException, SQLException {
     Query query = session.createQuery(hql);
     query.setFirstResult(offset);
     query.setMaxResults(length);
     List list = query.list();
     return list;
    }
   });
   return list;
}/**
* 使用criterion�q�行操作
* @param arg
* @param criterions
* @param offset
* @param length
* @return List
*/
protected List getListForPage(final Class arg, final Criterion[] criterions,final int offset, final int length) {
   List list = getHibernateTemplate().executeFind(new HibernateCallback() {
    public Object doInHibernate(Session session)
      throws HibernateException, SQLException {
     Criteria criteria = session.createCriteria(arg);
     //循环遍历��d��U�束条�g
     for (int i = 0; i < criterions.length; i++) {
      criteria.add(criterions[i]);
     }
     criteria.setFirstResult(offset);
     criteria.setMaxResults(length);
     return criteria.list();
    }
   });
   return list;
}

你不是说你用HibernateTemplate了，如果你用的是spring的HibernateTemplate�Q�那么就直接用就行了�Q�如果你是自己写的template�Q?br />那你也应该会准备一个HibernateCallback�c�d��Q�这才是典型的模板加回调�?

��了�Q�把HibernateCallback也给你脓(chu��ng)出来

import org.hibernate.HibernateException;
import org.hibernate.Session;

/*************************************
* �?Hibernate 所提供的一�?回调接口�Q?br />* 此接口定义了 �l�一 Hibernate的业务操作；
* @author kenshin
*
*/
public interface HibernateCallback {

/**************************************
* 回调接口的回调方法，此方法��用者无需调用,
* 它由模板�c�L��q�行回调�Q��ƈ传入一�?session参数�Q?br /> * 以便让��用者完成相关业�?br /> * @param ses
* @return 执行�l�果
* @throws HibernateException
*/
Object doInHibernate(Session ses)
       throws HibernateException;

}

abin 2012-05-17 16:54 发表评论

Spring+Hibernate下配�|�Hibernate二��~�存EhCache

abin — Sat, 12 May 2012 18:07:00 GMT

假设�c�A为持久化对象�Q�对应表为tableA�Q�这里没有考虑A和其他表兌��的情��c�?/p>

在spring下配�|��用二�U�缓存：

........
${hibernate.cache.provider_class}
${hibernate.cache.use_query_cache}

其中${hibernate.cache.provider_class}为net.sf.ehcache.hibernate.EhCacheProvider�Q?{hibernate.cache.use_query_cache}属性��gؓtrue�Q�对�l�常使用的List查询方式�Q�只有在使用查询�~�存�Ӟ��才会从缓存中通过id去get�~�存的��|��查询�~�存一般缓存查询语句和查询�l�果的id�Q?/p>

A的持久化映射文�g中加上cache元素�Q�usage属性的取值根据自��q��情况自己指定相应的�?/p>

配置spring的HibernateTemplate�Ҏ(gu��)��询语句和�l�果�~�存�Q�cacheQueries��gؓtrue)�Q?/p>

开发的spring dao�Q�集成HibernateDaoSupport�Q�应该配�|�实用这个hibernateTemplate�Q?/p>

在src下新建ehcache.xml文�g�Q�文件内容如下：

            eternal="false"            timeToIdleSeconds="120"            timeToLiveSeconds="120"
            overflowToDisk="true"            diskPersistent="false"           diskExpiryThreadIntervalSeconds="120"
            memoryStoreEvictionPolicy="LRU"/>

               maxElementsInMemory="500"               eternal="false"
               timeToIdleSeconds="2400"      timeToLiveSeconds="3600"
               overflowToDisk="false"/>

        maxElementsInMemory="50" eternal="false" timeToIdleSeconds="600"
        timeToLiveSeconds="1200" overflowToDisk="false"/>

        maxElementsInMemory="500" eternal="true" overflowToDisk="false"/>

然后你可以��用HQL查询对象了，比如"from A where name=�Q?�Q?/p>

跟踪查询的sql日志��可以看出第一�ơ是查询数据库，�W�二�ơ是从缓存中get(见Hibernate ReadWriteCache�cȝ��get�Ҏ(gu��)��Q?/p>

问题�Q�什么样的数据适合存放到第二��~�存中？

1 很少被修改的数据
2 不是很重要的数据�Q�允许出现偶��ƈ发的数据
3 不会被�ƈ发访问的数据
4 参考数�?指的是供应用参考的帔R��数据�Q�它的实例数目有限，它的实例会被许多其他�cȝ��实例引用�Q�实例极��或者从来不会被修改�?/p>

本文来自CSDN博客�Q��{载请标明出处�Q?a rel="nofollow">http://blog.csdn.net/selley/archive/2008/03/13/2177479.aspx

abin 2012-05-13 02:07 发表评论

abin — Tue, 27 Mar 2012 14:30:00 GMT

在applicationContext.xml中有如下配置�Q?/span>

也可以：

两种实现方式其实没有区别�Q�尤其是�W�二�U�不要自己去关闭session�Q�session在事务结束后都会自动关闭�?但是一定要注意延迟加蝲的问题，当对象在session关闭前没有从数据库中取得�Q�而jsp中需要展�C�对象时�Q�会提示LazyInitializationException�Q�你可以通过OpenSessionInViewFilter来保证�g�q�加载不会出现错误，卻I��

     opensession
     org.springframework.orm.hibernate3.support.OpenSessionInViewFilter

     opensession
     *.do

abin 2012-03-27 22:30 发表评论

abin — Tue, 20 Mar 2012 14:20:00 GMT

详细介绍 Hibernate 泛型 DAO 及其使用�Ҏ(gu��)��
�~�写Spring+Hibernate框架下的应用�Q��L��M��了编写一个通用的泛型GenericHibernateDao。查阅了�|�上不少的GenericHibernateDao实现�Q�归�U�x��理�ؓ如下实现�Q�供后箋�~�码参考�?br />
首先定义接口泛型DAO接口 GenericDao

package com.th.huz;

import java.io.Serializable;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import org.hibernate.Criteria;
import org.hibernate.LockMode;
import org.hibernate.criterion.DetachedCriteria;

public interface GenericDao {
// -------------------- 基本��索、增加、修攏V��删除操�?--------------------

// �Ҏ(gu��)��主键获取实体。如果没有相应的实体�Q�返�?null�?br />public T get(PK id);

// �Ҏ(gu��)��主键获取实体�q�加锁。如果没有相应的实体�Q�返�?null�?br />public T getWithLock(PK id, LockMode lock);

// �Ҏ(gu��)��主键获取实体。如果没有相应的实体�Q�抛出异常�?br />public T load(PK id);

// �Ҏ(gu��)��主键获取实体�q�加锁。如果没有相应的实体�Q�抛出异常�?br />public T loadWithLock(PK id, LockMode lock);

// 获取全部实体�?br />public List loadAll();

// loadAllWithLock() ?

// 更新实体
public void update(T entity);

// 更新实体�q�加�?br />public void updateWithLock(T entity, LockMode lock);

// 存储实体到数据库
public void save(T entity);

// saveWithLock()

// 增加或更新实�?br />public void saveOrUpdate(T entity);

// 增加或更新集合中的全部实�?br />public void saveOrUpdateAll(Collection entities);

// 删除指定的实�?br />public void delete(T entity);

// 加锁�q�删除指定的实体
public void deleteWithLock(T entity, LockMode lock);

// �Ҏ(gu��)��主键删除指定实体
public void deleteByKey(PK id);

// �Ҏ(gu��)��主键加锁�q�删除指定的实体
public void deleteByKeyWithLock(PK id, LockMode lock);

// 删除集合中的全部实体
public void deleteAll(Collection entities);

// -------------------- HSQL ----------------------------------------------

// 使用HSQL语句直接增加、更新、删除实�?br />public int bulkUpdate(String queryString);

// 使用带参数的HSQL语句增加、更新、删除实�?br />public int bulkUpdate(String queryString, Object[] values);

// 使用HSQL语句��索数�?br />public List find(String queryString);

// 使用带参数的HSQL语句��索数�?br />public List find(String queryString, Object[] values);

// 使用带命名的参数的HSQL语句��索数�?br />public List findByNamedParam(String queryString, String[] paramNames,
Object[] values);

// 使用命名的HSQL语句��索数�?br />public List findByNamedQuery(String queryName);

// 使用带参数的命名HSQL语句��索数�?br />public List findByNamedQuery(String queryName, Object[] values);

// 使用带命名参数的命名HSQL语句��索数�?br />public List findByNamedQueryAndNamedParam(String queryName,
String[] paramNames, Object[] values);

// 使用HSQL语句��索数据，�q�回 Iterator
public Iterator iterate(String queryString);

// 使用带参数HSQL语句��索数据，�q�回 Iterator
public Iterator iterate(String queryString, Object[] values);

// 关闭��索返回的 Iterator
public void closeIterator(Iterator it);

// -------------------------------- Criteria ------------------------------

// 创徏与会话无关的��索标准对�?br />public DetachedCriteria createDetachedCriteria();

// 创徏与会话绑定的��索标准对�?br />public Criteria createCriteria();

// 使用指定的检索标准检索数�?br />public List findByCriteria(DetachedCriteria criteria);

// 使用指定的检索标准检索数据，�q�回部分记录
public List findByCriteria(DetachedCriteria criteria, int firstResult,
int maxResults);

// 使用指定的实体及属性检索（满��除主键外属性＝实体��|��数据
public List findEqualByEntity(T entity, String[] propertyNames);

// 使用指定的实体及属�?非主�?��索（满��属�?like 串实体��|��数据
public List findLikeByEntity(T entity, String[] propertyNames);

// 使用指定的检索标准检索数据，�q�回指定范围的记�?br />public Integer getRowCount(DetachedCriteria criteria);

// 使用指定的检索标准检索数据，�q�回指定�l�计�?br />public Object getStatValue(DetachedCriteria criteria, String propertyName,
String StatName);

// -------------------------------- Others --------------------------------

// 加锁指定的实�?br />public void lock(T entity, LockMode lockMode);

// 强制初始化指定的实体
public void initialize(Object proxy);

// 强制立即更新�~�冲数据到数据库�Q�否则仅在事务提交时才更斎ͼ�
public void flush();

}

实现GenericDao接口的Hibernate的实现类 GenericHibernateDao

package com.th.huz;

import java.io.Serializable;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import org.apache.commons.beanutils.PropertyUtils;
import org.hibernate.Criteria;
import org.hibernate.LockMode;
import org.hibernate.criterion.DetachedCriteria;
import org.hibernate.criterion.Example;
import org.hibernate.criterion.MatchMode;
import org.hibernate.criterion.Order;
import org.hibernate.criterion.Projections;
import org.hibernate.criterion.Restrictions;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;

@SuppressWarnings("unchecked")
public class GenericHibernateDao
extends HibernateDaoSupport implements GenericDao {
// 实体�cȝ��?由构造方法自动赋�?
private Class entityClass;

// 构造方法，�Ҏ(gu��)��实例�c�自动获取实体类�c�d��
public GenericHibernateDao() {
this.entityClass = null;
Class c = getClass();
Type t = c.getGenericSuperclass();
if (t instanceof ParameterizedType) {
Type[] p = ((ParameterizedType) t).getActualTypeArguments();
this.entityClass = (Class) p[0];
}
}

// -------------------- 基本��索、增加、修攏V��删除操�?--------------------

// �Ҏ(gu��)��主键获取实体。如果没有相应的实体�Q�返�?null�?br />public T get(PK id) {
return (T) getHibernateTemplate().get(entityClass, id);
}

// �Ҏ(gu��)��主键获取实体�q�加锁。如果没有相应的实体�Q�返�?null�?br />public T getWithLock(PK id, LockMode lock) {
T t = (T) getHibernateTemplate().get(entityClass, id, lock);
if (t != null) {
this.flush(); // 立即��h��Q�否则锁不会生效�?br />}
return t;
}

// �Ҏ(gu��)��主键获取实体。如果没有相应的实体�Q�抛出异常�?br />public T load(PK id) {
return (T) getHibernateTemplate().load(entityClass, id);
}

// �Ҏ(gu��)��主键获取实体�q�加锁。如果没有相应的实体�Q�抛出异常�?br />public T loadWithLock(PK id, LockMode lock) {
T t = (T) getHibernateTemplate().load(entityClass, id, lock);
if (t != null) {
this.flush(); // 立即��h��Q�否则锁不会生效�?br />}
return t;
}

// 获取全部实体�?br />public List loadAll() {
return (List) getHibernateTemplate().loadAll(entityClass);
}

// loadAllWithLock() ?

// 更新实体
public void update(T entity) {
getHibernateTemplate().update(entity);
}

// 更新实体�q�加�?br />public void updateWithLock(T entity, LockMode lock) {
getHibernateTemplate().update(entity, lock);
this.flush(); // 立即��h��Q�否则锁不会生效�?br />}

// 存储实体到数据库
public void save(T entity) {
getHibernateTemplate().save(entity);
}

// saveWithLock()�Q?br />
// 增加或更新实�?br />public void saveOrUpdate(T entity) {
getHibernateTemplate().saveOrUpdate(entity);
}

// 增加或更新集合中的全部实�?br />public void saveOrUpdateAll(Collection entities) {
getHibernateTemplate().saveOrUpdateAll(entities);
}

// 删除指定的实�?br />public void delete(T entity) {
getHibernateTemplate().delete(entity);
}

// 加锁�q�删除指定的实体
public void deleteWithLock(T entity, LockMode lock) {
getHibernateTemplate().delete(entity, lock);
this.flush(); // 立即��h��Q�否则锁不会生效�?br />}

// �Ҏ(gu��)��主键删除指定实体
public void deleteByKey(PK id) {
this.delete(this.load(id));
}

// �Ҏ(gu��)��主键加锁�q�删除指定的实体
public void deleteByKeyWithLock(PK id, LockMode lock) {
this.deleteWithLock(this.load(id), lock);
}

// 删除集合中的全部实体
public void deleteAll(Collection entities) {
getHibernateTemplate().deleteAll(entities);
}

// -------------------- HSQL ----------------------------------------------

// 使用HSQL语句直接增加、更新、删除实�?br />public int bulkUpdate(String queryString) {
return getHibernateTemplate().bulkUpdate(queryString);
}

// 使用带参数的HSQL语句增加、更新、删除实�?br />public int bulkUpdate(String queryString, Object[] values) {
return getHibernateTemplate().bulkUpdate(queryString, values);
}

// 使用HSQL语句��索数�?br />public List find(String queryString) {
return getHibernateTemplate().find(queryString);
}

// 使用带参数的HSQL语句��索数�?br />public List find(String queryString, Object[] values) {
return getHibernateTemplate().find(queryString, values);
}

// 使用带命名的参数的HSQL语句��索数�?br />public List findByNamedParam(String queryString, String[] paramNames,
Object[] values) {
return getHibernateTemplate().findByNamedParam(queryString, paramNames,
values);
}

// 使用命名的HSQL语句��索数�?br />public List findByNamedQuery(String queryName) {
return getHibernateTemplate().findByNamedQuery(queryName);
}

// 使用带参数的命名HSQL语句��索数�?br />public List findByNamedQuery(String queryName, Object[] values) {
return getHibernateTemplate().findByNamedQuery(queryName, values);
}

// 使用带命名参数的命名HSQL语句��索数�?br />public List findByNamedQueryAndNamedParam(String queryName,
String[] paramNames, Object[] values) {
return getHibernateTemplate().findByNamedQueryAndNamedParam(queryName,
paramNames, values);
}

// 使用HSQL语句��索数据，�q�回 Iterator
public Iterator iterate(String queryString) {
return getHibernateTemplate().iterate(queryString);
}

// 使用带参数HSQL语句��索数据，�q�回 Iterator
public Iterator iterate(String queryString, Object[] values) {
return getHibernateTemplate().iterate(queryString, values);
}

// 关闭��索返回的 Iterator
public void closeIterator(Iterator it) {
getHibernateTemplate().closeIterator(it);
}

// -------------------------------- Criteria ------------------------------

// 创徏与会话无关的��索标�?br />public DetachedCriteria createDetachedCriteria() {
return DetachedCriteria.forClass(this.entityClass);
}

// 创徏与会话绑定的��索标�?br />public Criteria createCriteria() {
return this.createDetachedCriteria().getExecutableCriteria(
this.getSession());
}

// ��索满��x��准的数据
public List findByCriteria(DetachedCriteria criteria) {
return getHibernateTemplate().findByCriteria(criteria);
}

// ��索满��x��准的数据�Q�返回指定范围的记录
public List findByCriteria(DetachedCriteria criteria, int firstResult,
int maxResults) {
return getHibernateTemplate().findByCriteria(criteria, firstResult,
maxResults);
}

// 使用指定的实体及属性检索（满��除主键外属性＝实体��|��数据
public List findEqualByEntity(T entity, String[] propertyNames) {
Criteria criteria = this.createCriteria();
Example exam = Example.create(entity);
exam.excludeZeroes();
String[] defPropertys = getSessionFactory().getClassMetadata(
entityClass).getPropertyNames();
for (String defProperty : defPropertys) {
int ii = 0;
for (ii = 0; ii < propertyNames.length; ++ii) {
if (defProperty.equals(propertyNames[ii])) {
criteria.addOrder(Order.asc(defProperty));
break;
}
}
if (ii == propertyNames.length) {
exam.excludeProperty(defProperty);
}
}
criteria.add(exam);
return (List) criteria.list();
}

// 使用指定的实体及属性检索（满��属�?like 串实体��|��数据
public List findLikeByEntity(T entity, String[] propertyNames) {
Criteria criteria = this.createCriteria();
for (String property : propertyNames) {
try {
Object value = PropertyUtils.getProperty(entity, property);
if (value instanceof String) {
criteria.add(Restrictions.like(property, (String) value,
MatchMode.ANYWHERE));
criteria.addOrder(Order.asc(property));
} else {
criteria.add(Restrictions.eq(property, value));
criteria.addOrder(Order.asc(property));
}
} catch (Exception ex) {
// 忽略无效的检索参考数据�?br />}
}
return (List) criteria.list();
}

// 使用指定的检索标准获取满��x��准的记录�?br />public Integer getRowCount(DetachedCriteria criteria) {
criteria.setProjection(Projections.rowCount());
List list = this.findByCriteria(criteria, 0, 1);
return (Integer) list.get(0);
}

// 使用指定的检索标准检索数据，�q�回指定�l�计�?max,min,avg,sum)
public Object getStatValue(DetachedCriteria criteria, String propertyName,
String StatName) {
if (StatName.toLowerCase().equals("max"))
criteria.setProjection(Projections.max(propertyName));
else if (StatName.toLowerCase().equals("min"))
criteria.setProjection(Projections.min(propertyName));
else if (StatName.toLowerCase().equals("avg"))
criteria.setProjection(Projections.avg(propertyName));
else if (StatName.toLowerCase().equals("sum"))
criteria.setProjection(Projections.sum(propertyName));
else
return null;
List list = this.findByCriteria(criteria, 0, 1);
return list.get(0);
}

// -------------------------------- Others --------------------------------

// 加锁指定的实�?br />public void lock(T entity, LockMode lock) {
getHibernateTemplate().lock(entity, lock);
}

// 强制初始化指定的实体
public void initialize(Object proxy) {
getHibernateTemplate().initialize(proxy);
}

// 强制立即更新�~�冲数据到数据库�Q�否则仅在事务提交时才更斎ͼ�
public void flush() {
getHibernateTemplate().flush();
}
}
//以上代码来自�|�上攉��

以上��实��C��泛型�?Hibernate Dao 了，下面的例子就是业务对象对 GenericHibernateDao的��?br />
业务对象 Article 对应文章表的 aticle �?br />
package com.th.huz.model;

import java.io.Serializable;
import java.util.Date;

public class Article implements Serializable {

private static final long serialVersionUID = 1072812006693587010L;

private long id;
private String title;
private String author;
private Date pubDate;
private String content;

public long getId() {
return id;
}

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

public String getTitle() {
return title;
}

public void setTitle(String title) {
this.title = title;
}

public String getAuthor() {
return author;
}

public void setAuthor(String author) {
this.author = author;
}

public Date getPubDate() {
return pubDate;
}

public void setPubDate(Date pubDate) {
this.pubDate = pubDate;
}

public String getContent() {
return content;
}

public void setContent(String content) {
this.content = content;
}
}

定义 Article 业务对象的Dao 接口 IArticleDao �Q�它�l�承�?GenericDao 接口�Q�以获得其中的方�?br />
你可以在 IArticleDao 中添�?Article 业务对象�Ҏ(gu��)��的方法，也可以直接��?GenericDao 中提供的所有方法IArticleDao接口指定业务对象的类型和主键的类�?

package com.th.huz.model;

import com.th.huz.dao.GenericDao;
import com.th.huz.model.Article;
public interface IArticleDAO extends GenericDao {
// public void findById(Long id);
}
然后��可以定�?ArticleHibernateDao �c�M��Q�它只要实现 IArticleDao 接口�q��?GenericHibernateDao �c?��可以��用所有的 Generic 接口�?IArticleDao 接口中的定义的方法。如果你�?IArticleDao 接口里指定了Article业务对象�Ҏ(gu��)��的方法，��在ArticleHibernateDao实现�q�些�Ҏ(gu��)��。而Generic 接口中的�Ҏ(gu��)��Q�在ArticleHibernateDao 的父�c?GenericHibernateDao 中已�l�全部实��C��Q�直接调用就可以方便的访问数据库�?br />
package com.th.huz.model;

import com.th.huz.dao.GenericHibernateDao;

public class ArticleHibernateDao extends GenericHibernateDao implements
IArticleDAO {

}
其他的业务对象也可以参照 Article �?ArticleHibernateDao �c�L��定义 �Q?GenericDao 接口中有的通用�Ҏ(gu��)��q��接调用，不��的以后补充，其他业务对象�Ҏ(gu��)��的方法就在其他业务对象的 Dao接口(�l�承GenericDao接口) 中定义�ƈ通过 GenericHibernateDao 子类来实现�?节省很多重复代码�Q�简单几步就可以使用GenericDao接口的实现类 GenericHibernateDao 方便地访问数据库�?br />
最后提供一�?Article 业务对象�?Hibernate 映射文�g �?��SQL脚本 �?一�?ArticleHibernateDao �cȝ��试�c?br />
Article的映��文�?br />

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

Article对应的article表的��脚本

if exists (select * from dbo.sysobjects where id = object_id(N'[dbo].[article]') and OBJECTPROPERTY(id, N'IsUserTable') = 1)
drop table [dbo].[article]
GO

CREATE TABLE [dbo].[article] (
[id] [int] IDENTITY (1, 1) NOT NULL ,
[title] [varchar] (100) COLLATE Chinese_PRC_CI_AS NOT NULL ,
[author] [varchar] (32) COLLATE Chinese_PRC_CI_AS NULL ,
[pubDate] [datetime] NULL ,
[content] [text] COLLATE Chinese_PRC_CI_AS NULL
) ON [PRIMARY] TEXTIMAGE_ON [PRIMARY]
GO
ArticleHibernateDao的测试类�Q�只提供了seve(article) �Ҏ(gu��)��的测试代�?br />
package com.th.huz.test;

import junit.framework.TestCase;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.th.huz.model.Article;
import com.th.huz.model.ArticleHibernateDao;

public class ArticleHibernateDaoTest extends TestCase {

ApplicationContext ctx = new ClassPathXmlApplicationContext(
"applicationContext.xml");
ArticleHibernateDao adh = (ArticleHibernateDao) ctx
.getBean("articleHibernateDao");

public void testSave() {
Article art = (Article) ctx.getBean("article");
art.setId(1);
art.setTitle("标题1");
art.setAuthor("作�?");
adh.save(art);
}
}

abin 2012-03-20 22:20 发表评论

abin — Sun, 11 Mar 2012 14:25:00 GMT

�~�存是介于应用程序和物理数据源之��_��其作用是��Z��降低应用�E�序对物理数据源讉K��的频�ơ，从而提高了应用的运行性能。缓存内的数据是对物理数据源中的数据的复�Ӟ��应用�E�序在运行时从缓存读写数据，在特定的时刻或事件会同步�~�存和物理数据源的数据�?/p>

　　�~�存的介质一般是内存�Q�所以读写速度很快。但如果�~�存中存攄��数据量非常大�Ӟ��也会用硬盘作为缓存介质。缓存的实现不仅仅要考虑存储的介质，�q�要考虑到管理缓存的�q�发讉K��和缓存数据的生命周期�?/p>

　　Hibernate的缓存包括Session的缓存和SessionFactory的缓存，其中SessionFactory的缓存又可以分�ؓ两类�Q�内�|�缓存和外置�~�存。Session的缓存是内置的，不能被卸载，也被�U�CؓHibernate的第一�U�缓存。SessionFactory的内�|�缓存和Session的缓存在实现方式上比较相��|��前者是SessionFactory对象的一些集合属性包含的数据�Q�后者是指Session的一些集合属性包含的数据。SessionFactory的内�|�缓存中存放了映��元数据和预定义SQL语句�Q�映��元数据是映��文件中数据的拷贝，而预定义SQL语句是在Hibernate初始化阶�D�|��据映��元数据推导出来�Q�SessionFactory的内�|�缓存是只读的，应用�E�序不能修改�~�存中的映射元数据和预定义SQL语句�Q�因此SessionFactory不需要进行内�|�缓存与映射文�g的同步。SessionFactory的外�|�缓存是一个可配置的插件。在默认情况下，SessionFactory不会启用�q�个插�g。外�|�缓存的数据是数据库数据的拷贝，外置�~�存的介质可以是内存或者硬盘。SessionFactory的外�|�缓存也被称为Hibernate的第二��~�存�?/p>

　　Hibernate的这两��~�存都位于持久化层，存放的都是数据库数据的拷贝，那么它们之间的区别是什么呢�Q��ؓ了理解二者的区别�Q�需要深入理解持久化层的�~�存的两个特性：�~�存的范围和�~�存的�ƈ发访问策略�?/p>

　　持久化层的缓存的范围

　　�~�存的范围决定了�~�存的生命周期以及可以被谁访问。缓存的范围分�ؓ三类�?/p>

　　1 事务范围�Q�缓存只能被当前事务讉K��。缓存的生命周期依赖于事务的生命周期�Q�当事务�l�束�Ӟ��~�存也就�l�束生命周期。在此范围下�Q�缓存的介质是内存。事务可以是数据库事务或者应用事务，每个事务都有独自的缓存，�~�存内的数据通常采用�怺�兌��的的对象形式�?/p>

　　2 �q�程范围�Q�缓存被�q�程内的所有事务共享。这些事务有可能是�ƈ发访问缓存，因此必须对缓存采取必要的事务隔离机制。缓存的生命周期依赖于进�E�的生命周期�Q�进�E�结束时�Q�缓存也��q��束了生命周期。进�E�范围的�~�存可能会存攑֤�量的数据�Q�所以存攄��介质可以是内存或��盘。缓存内的数据既可以是相互关联的对象形式也可以是对象的松散数据�Ş式。松散的对象数据形式有点�c�M��于对象的序列化数据，但是对象分解为松散的��法比对象序列化的算法要求更快�?/p>

　　3 集群范围�Q�在集群环境中，�~�存被一个机器或者多个机器的�q�程�׃�n。缓存中的数据被复制到集��环境中的每个进�E�节点，�q�程间通过�q�程通信来保证缓存中的数据的一致性，�~�存中的数据通常采用对象的松散数据�Ş式�?/p>

　　对大多数应用来说�Q�应该慎重地考虑是否需要��用集��范围的�~�存�Q�因��问的速度不一定会比直接访问数据库数据的速度快多��?/p>

　　持久化层可以提供多种范围的缓存。如果在事务范围的缓存中没有查到相应的数据，�q�可以到�q�程范围或集��范围的�~�存内查询，如果�q�是没有查到�Q�那么只有到数据库中查询。事务范围的�~�存是持久化层的�W�一�U�缓存，通常它是必需的；�q�程范围或集��范围的�~�存是持久化层的�W�二�U�缓存，通常是可选的�?/p>

　　持久化层的缓存的�q�发讉K��{�略

　　当多个�ƈ发的事务同时讉K��持久化层的缓存的相同数据�Ӟ��会引起�ƈ发问题，必须采用必要的事务隔��L��施�?/p>

　　在进�E�范围或集群范围的缓存，即第二��~�存�Q�会出现�q�发问题。因此可以设定以下四�U�类型的�q�发讉K��{�略�Q�每一�U�策略对应一�U�事务隔��ȝ�别�?/p>

　　事务型：仅仅在受��理环境中适用。它提供了Repeatable Read事务隔离�U�别。对于经常被��M��很少修改的数据，可以采用�q�种隔离�c�d��Q�因为它可以防止脏读和不可重复读�q�类的�ƈ发问题�?/p>

　　��d��型：提供了Read Committed事务隔离�U�别。仅仅在非集��的环境中适用。对于经常被��M��很少修改的数据，可以采用�q�种隔离�c�d��Q�因为它可以防止脏读�q�类的�ƈ发问题�?/p>

　　非严��D��写型�Q�不保证�~�存与数据库中数据的一致性。如果存在两个事务同时访问缓存中相同数据的可能，必须��数据配置一个很短的数据�q�期旉��Q�从而尽量避免脏诅R��对于极��被修改�Q��ƈ且允许偶��脏�ȝ��数据�Q�可以采用这�U��ƈ发访问策略�?　　只读型：对于从来不会修改的数据，如参考数据，可以使用�q�种�q�发讉K��{�略�?/p>

　　事务型�ƈ发访问策略是事务隔离�U�别最高，只读型的隔离�U�别最低。事务隔��ȝ�别越高，�q�发性能��p��低�?/p>

　　什么样的数据适合存放到第二��~�存中？

　　1、很��被修改的数�?/p>

　　2、不是很重要的数据，允许出现偶尔�q�发的数�?/p>

　　3、不会被�q�发讉K��的数�?/p>

　　4、参考数�?/p>

　　不适合存放到第二��~�存的数据？

　　1、经常被修改的数�?/p>

　　2、胦务数据，�l�对不允许出现�ƈ�?/p>

　　3、与其他应用�׃�n的数据�?/p>

　　Hibernate的二�U�缓�?/p>

　　如前所�q�ͼ�Hibernate提供了两�U�缓存，�W�一�U�是Session的缓存。由于Session对象的生命周期通常对应一个数据库事务或者一个应用事务，因此它的�~�存是事务范围的�~�存。第一�U�缓存是必需的，不允许而且事实上也无法比卸除。在�W�一�U�缓存中�Q�持久化�cȝ��每个实例都具有唯一的OID�?/p>

　　�W�二�U�缓存是一个可插拔的的�~�存插�g�Q�它是由SessionFactory负责��理。由于SessionFactory对象的生命周期和应用�E�序的整个过�E�对应，因此�W�二�U�缓存是�q�程范围或者集��范围的�~�存。这个缓存中存放的对象的松散数据。第二��对象有可能出现�ƈ发问题，因此需要采用适当的�ƈ发访问策略，该策略�ؓ被缓存的数据提供了事务隔��ȝ�别。缓存适配器用于把具体的缓存实现��Y件与Hibernate集成。第二��~�存是可选的�Q�可以在每个�c�L��每个集合的粒度上配置�W�二�U�缓存�?/p>

　　Hibernate的二�U�缓存策略的一般过�E�如下：

　　1) 条�g查询的时候，��L��发出一条select * from table_name where …. �Q�选择所有字�D�）�q�样的SQL语句查询数据库，一�ơ获得所有的数据对象�?/p>

　　2) 把获得的所有数据对象根据ID攑օ�到第二��~�存中�?/p>

　　3) 当Hibernate�Ҏ(gu��)��ID讉K��数据对象的时候，首先从Session一�U�缓存中查；查不刎ͼ�如果配置了二�U�缓存，那么从二�U�缓存中查；查不刎ͼ�再查询数据库�Q�把�l�果按照ID攑օ�到缓存�?/p>

　　4) 删除、更新、增加数据的时候，同时更新�~�存�?/p>

　　Hibernate的二�U�缓存策略，是针对于ID查询的缓存策略，对于条�g查询则毫无作用。�ؓ此，Hibernate提供了针�Ҏ(gu��)��件查询的Query�~�存�?/p>

　　Hibernate的Query�~�存�{�略的过�E�如下：

　　1) Hibernate首先�Ҏ(gu��)��q�些信息�l�成一个Query Key�Q�Query Key包括条�g查询的请求一般信息：SQL, SQL需要的参数�Q�记录范��_��起始位置rowStart�Q�最大记录个数maxRows)�Q�等�?/p>

　　2) Hibernate�Ҏ(gu��)��q�个Query Key到Query�~�存中查扑֯�应的�l�果列表。如果存在，那么�q�回�q�个�l�果列表�Q�如果不存在�Q�查询数据库�Q�获取结果列表，把整个结果列表根据Query Key攑օ�到Query�~�存中�?/p>

　　3) Query Key中的SQL涉及��C��些表名，如果�q�些表的��M��数据发生修改、删除、增加等操作�Q�这些相关的Query Key都要从缓存中清空�?/p>

abin 2012-03-11 22:25 发表评论

abin — Sun, 11 Mar 2012 08:36:00 GMT

来源�Q�http://www.tianxiaboke.com/u/lyeerwy

�U�联保存和更�?/font>
当Hibernate持久化一个��时对象时�Q�在默认情下�Q�他不会自动持久化所兌��的其他��时对象，如果希望当持久化对象时把他所兌��的所有��时对象进行持久化的话�Q�可以把的cascade属性设�|��ؓ"save-update" ,cascade的默认属性��gؓnone�?br />cascade:讄��操作对象时的�U�联操作�Q�即层��之间的连锁操�?br />�?nbsp;save-update �Q�表�C�当保存和更新当前对�?即insert和update语句�?�Q�会�U�联保存和更��C��他关联的对象
�?nbsp;all �Q�表�C�Z�Q何情况下都会�q�行�U�联操作�Q�即对一个对象进行操作，也会对和他关联的其他对象�q�行同样的操�?br />�?nbsp;delete �Q�表�C�在执行delete�Ӟ��q�行�U�联操作�Q�删除和他关联的对象
�?nbsp;none �Q�表�C�Z�Q何情况下�Q�都不会�q�行�U�联操作
元素的inverse属�?/font>

在运行上面的�E�序�Ӟ��如果hibernate�?show-sql"讄��为true�Ӟ��׃��看到Hibernate会生成很多sql语句�Q�其实很多sql语句都是重复�?br />eg�Q?nbsp;
insert into  test.order(o_name,c_id)values(?,?)
insert into  test.order(o_name,c_id)values(?,?)
insert into  test order   set c_id=? where id=?
insert into  test order   set c_id=? where id=?

��Z��解决�q�个问题�Q�我们可以利用在标签中加上inverse属性。术语：inverse是指反�{的意思，�?Hibernate中，表示兌��关系中的方向兌��关系中，inverse="false"的主控方�Q�由��d��方负责维护对象关�p�L��?nbsp;在customer对象的对象配�|�文件中加上

声明在Customer和Order的双向关联关�p�M��Q�Customer端的兌��只是Order端关联的镜象�Q�即Order端是�ȝ��端，负责�l�护 Customer和order对象之间的关联关�p�）�Q�当hibernate探测到持久化对象Customer或Order的状态发生变化时(主要是关联关�pȝ��改变),仅按照Order对象的状态的变化来同步更新数据库�?br />按次配置�Q�如果在�E�序中，我们仅仅使用Customer.getOrder().add(order)�Q�涉及了和Order的关联关�pȝ��改变�Q�，是不能让数据库跟对象的变化来�q�行数据库同步更新的�Q�只有利用Order对象的方法改变的Order对象状�?(eg�Q�order.setCustomer(customer)----涉及��C��和Customer的关联关�pȝ��改变)�Ӟ��数据库才会根据变化来同步更新数据库，卛_��有主控方的状态（涉及��C��和另一斚w��的关联关�pȝ��改变�Q�发生了变化后，才会触发对象和数据库的同步更新�?/p>

映射一对多双向兌��关系
当类与类之间建立了关联，��可以方便的从一个对象导航到另一个对象或一�l�与他关联的对象当中�Q�根据上面的�E�序�Q�对于一个给定的Order对象�Q�如果想获取与他兌��的Customer对象�Q�我们只需要调用入下方法：
Customer c=order.geCustomer(); 那么当我们得��C��个Customer对象后，��x��出和�q�个Customer对象兌��的所有Order对象�Ӟ��应该怎么办呢�Q�由于在Customer中没有徏立对Order对象的关联，所以，不能通过加蝲Customer对象来自动加载和他关联的所有Order对象�Q�唯一的方法只能通过JDBC或SQL语言人工写出代码来查询数据库Order表来�q�回所需要的信息
上面的问题虽然解冻I��但不能算是最好，因�ؓ�q�样性能会有所下降�Q�对象位于内存中�Q�在内存中从一个对象导航到另一个对象显然比到数据库中查询数据要快得�?br />

具体实现

1�Q�由于Customer和Order是一对多�Q�即一个Customer要对应多个Order�Q�所以在Customer中应该徏立一个Set对象�Q�用于存攑֒�本Customer对象兌��的所有Order对象�?br />2�Q�在customer.hbm.xml通过建立对Order表的兌��关系
注意�Q?lt;one-to-many>应该攄��?lt;set>标签�?nbsp;
我们先来看看Customer�cȝ��设计和customer.hbm.xml文�g的内�?br />

------------------------------------------------------
Customer Order 双向一对多
1�Q�Customer�c�M��建立一个容器对象，包含兌��的所有Order对象
2�Q�Order�c�M��建立一个Customer对象�Q�关联Customer
inverse="true"表示��维护关联的权利交给引�vHibernate语句的生�?/p>

customer.getOrders().add(order);
customer.setName("dddddd");

inverse="true"�Q�设�|�此属性的一�?---是被控方�Q?br />当主控方修改对象之间的关联关�p�L��Q�让Hibernate生成sql语句

abin 2012-03-11 16:36 发表评论

5个最帔R��的几个Hibernate面试问题

abin — Sun, 11 Mar 2012 07:34:00 GMT

5个最帔R��的几个Hibernate面试问题�Q�不一定你都能回答�Q?

1.实体对象在Hibernate中如何进行状态迁�U�？
2.何谓Hibernate的N+1问题�Q�如何解冻I��
3.Hibernate延迟加蝲的机制是什么，如何工作�Q?
4.Hibernate�U�联保存要如何做�Q?
5.Hibernate的二�U�缓存和一�U�缓存有什么区别？

abin 2012-03-11 15:34 发表评论

Hibernate延迟加蝲机制

abin — Sun, 11 Mar 2012 07:32:00 GMT

延迟加蝲�Q?/p>

延迟加蝲机制是�ؓ了避免一些无谓的性能开销而提出来的，所谓�g�q�加载就是当在真正需要数据的时候，才真正执行数据加载操作。在Hibernate中提供了对实体对象的延迟加蝲以及寚w��合的延迟加蝲�Q�另外在Hibernate3中还提供了对属性的延迟加蝲。下面我们就分别介绍�q�些�U�类的�g�q�加载的�l�节�?/p>

A、实体对象的延迟加蝲�Q?/p>

如果惛_��实体对象使用延迟加蝲�Q�必��要在实体的映射配置文�g中进行相应的配置�Q�如下所�C�：

……

通过��class的lazy属性设�|��ؓtrue�Q�来开启实体的延迟加蝲�Ҏ(gu��)��。如果我们运行下面的代码�Q?/p>

User user=(User)session.load(User.class,”1”);�Q?�Q?/p>

System.out.println(user.getName());�Q?�Q?/p>

当运行到(1)处时�Q�Hibernate�q�没有发起对数据的查询，如果我们此时通过一些调试工�?比如JBuilder2005的Debug工具)�Q�观察此时user对象的内存快照，我们会惊奇的发现�Q�此时返回的可能是User$EnhancerByCGLIB$$bede8986�c�d��的对象，而且其属性�ؓ null,�q�是怎么回事�Q�还记得前面我曾讲过session.load()�Ҏ(gu��)��Q�会�q�回实体对象的代理类对象�Q�这里所�q�回的对象类型就是User对象的代理类对象。在Hibernate中通过使用CGLIB,来实现动态构造一个目标对象的代理�c�d��象，�q�且在代理类对象中包含目标对象的所有属性和�Ҏ(gu��)��Q�而且所有属性均被赋��gؓnull。通过调试器显�C�的内存快照�Q�我们可以看出此时真正的User对象�Q�是包含在代理对象的 CGLIB$CALBACK_0.target属性中�Q�当代码�q�行刎ͼ�2�Q�处�Ӟ��此时调用user.getName()�Ҏ(gu��)��Q�这旉��过CGLIB赋予的回调机�Ӟ��实际上调用CGLIB$CALBACK_0.getName()�Ҏ(gu��)��Q�当调用该方法时�Q�Hibernate会首先检�?CGLIB$CALBACK_0.target属性是否�ؓnull�Q�如果不为空�Q�则调用目标对象的getName�Ҏ(gu��)��Q�如果�ؓ�I�，则会发�v数据库查询，生成�c�M��q�样的SQL语句�Q�select * from user where id=’1’;来查询数据，�q�构造目标对象，�q�且��它赋值到CGLIB$CALBACK_0.target属性中�?/p>

�q�样�Q�通过一个中间代理对象，Hibernate实现了实体的延迟加蝲�Q�只有当用户真正发�v获得实体对象属性的动作�Ӟ��才真正会发�v数据库查询操作。所以实体的延迟加蝲是用通过中间代理�c�d��成的�Q�所以只有session.load()�Ҏ(gu��)��才会利用实体延迟加蝲�Q�因为只有session.load()�Ҏ(gu��)��才会�q�回实体�cȝ��代理�c�d��象�?/p>

B�?nbsp; 集合�c�d��的�g�q�加载：

在Hibernate的�g�q�加载机制中�Q�针寚w��合类型的应用�Q�意义是最为重大的�Q�因��有可能��性能得到大幅度的提高�Q��ؓ此Hibernate�q�行了大量的努力�Q�其中包括对JDK Collection的独立实玎ͼ�我们在一对多兌��中，定义的用来容�U�_��联对象的Set集合�Q��ƈ不是java.util.Set�c�d��或其子类型，而是 net.sf.hibernate.collection.Set�c�d��Q�通过使用自定义集合类的实玎ͼ�Hibernate实现了集合类型的延迟加蝲。�ؓ了对集合�c�d��使用延迟加蝲�Q�我们必��d��下配�|�我们的实体�cȝ��关于兌��的部分：

…..

通过��?lt;set>元素的lazy属性设�|��ؓtrue来开启集合类型的延迟加蝲�Ҏ(gu��)��。我们看下面的代码：

User user=(User)session.load(User.class,”1”);

Collection addset=user.getAddresses(); (1)

Iterator it=addset.iterator(); (2)

while(it.hasNext()){

Address address=(Address)it.next();

System.out.println(address.getAddress());

}

当程序执行到(1)处时�Q�这时�ƈ不会发�v对关联数据的查询来加载关联数据，只有�q�行�?2)处时�Q�真正的数据��d��操作才会开始，�q�时Hibernate会根据缓存中�W�合条�g的数据烦引，来查扄��合条件的实体对象�?/p>

�q�里我们引入了一个全新的概念——数据索引�Q�下面我们首先将接一下什么是数据索引。在Hibernate中对集合�c�d��q�行�~�存�Ӟ��是分两部分进行缓存的�Q�首先缓存集合中所有实体的id列表�Q�然后缓存实体对象，�q�些实体对象的id列表�Q�就是所谓的数据索引。当查找数据索引�Ӟ��如果没有扑ֈ�对应的数据烦引，�q�时��׃��一条select SQL的执行，获得�W�合条�g的数据，�q�构造实体对象集合和数据索引�Q�然后返回实体对象的集合�Q��ƈ且将实体对象和数据烦引纳入Hibernate的缓存之中。另一斚w��Q�如果找到对应的数据索引�Q�则从数据烦引中取出id列表�Q�然后根据id在缓存中查找对应的实体，如果扑ֈ��׃��~�存中返回，如果没有扑ֈ��Q�在发�vselect SQL查询。在�q�里我们看出了另外一个问题，�q�个问题可能会对性能产生影响�Q�这��是集合�c�d��的缓存策略。如果我们如下配�|�集合类型：

…..

�q�里我们应用�?lt;cache usage=”read-only”/>配置�Q�如果采用这�U�策略来配置集合�c�d��Q�Hibernate��只会对数据索引�q�行�~�存�Q�而不会对集合中的实体对象�q�行�~�存。如上配�|�我们运行下面的代码�Q?/p>

User user=(User)session.load(User.class,”1”);

Collection addset=user.getAddresses();

Iterator it=addset.iterator();

while(it.hasNext()){

Address address=(Address)it.next();

System.out.println(address.getAddress());

}

System.out.println(“Second query……”);

User user2=(User)session.load(User.class,”1”);

Collection it2=user2.getAddresses();

while(it2.hasNext()){

Address address2=(Address)it2.next();

System.out.println(address2.getAddress());

}

�q�行�q�段代码�Q�会得到�c�M��下面的输出：

Select * from user where id=’1’;

Select * from address where user_id=’1’;

Tianjin

Dalian

Second query……

Select * from address where id=’1’;

Select * from address where id=’2’;

Tianjin

Dalian

我们看到�Q�当�W�二�ơ执行查询时�Q�执行了两条对address表的查询操作�Q��ؓ什么会�q�样�Q�这是因为当�W�一�ơ加载实体后�Q�根据集合类型缓存策略的配置�Q�只寚w��合数据烦引进行了�~�存�Q�而�ƈ没有寚w��合中的实体对象进行缓存，所以在�W�二�ơ再�ơ加载实体时�Q�Hibernate扑ֈ�了对应实体的数据索引�Q�但是根据数据烦引，却无法在�~�存中找到对应的实体�Q�所以Hibernate�Ҏ(gu��)��扑ֈ�的数据烦引发起了两条select SQL的查询操作，�q�里造成了对性能的浪费，怎样才能避免�q�种情况呢？我们必须寚w��合类型中的实体也指定�~�存�{�略�Q�所以我们要如下寚w��合类型进行配�|�：

…..

此时Hibernate会对集合�c�d��中的实体也进行缓存，如果�Ҏ(gu��)��q�个配置再次�q�行上面的代码，��会得到�c�M��如下的输出：

Select * from user where id=’1’;

Select * from address where user_id=’1’;

Tianjin

Dalian

Second query……

Tianjin

Dalian

�q�时��不会再有根据数据烦引进行查询的SQL语句�Q�因为此时可以直接从�~�存中获得集合类型中存放的实体对象�?/p>

C�?nbsp; 属性�g�q�加载：

在Hibernate3中，引入了一�U�新的特�?#8212;—属性的延迟加蝲�Q�这个机制又��取高性能查询提供了有力的工具。在前面我们讲大数据对象��d��Ӟ��?User对象中有一个resume字段�Q�该字段是一个java.sql.Clob�c�d��Q�包含了用户的简历信息，当我们加载该对象�Ӟ��我们不得不每一�ơ都要加载这个字�D�，而不论我们是否真的需要它�Q�而且�q�种大数据对象的��d��本��n会带来很大的性能开销。在Hibernate2中，我们只有通过我们前面讲过的面性能的粒度细分，来分解User�c�，来解册��个问题（请参照那一节的��Q�，但是在Hibernate3中，我们可以通过属性�g�q�加载机�Ӟ��来��我们获得只有当我们真正需要操作这个字�D�|��Q�才去读取这个字�D�|��据的能力�Q��ؓ此我们必��d��下配�|�我们的实体�c�：

……

通过�?lt;property>元素的lazy属性设�|�true来开启属性的延迟加蝲�Q�在Hibernate3中�ؓ了实现属性的延迟加蝲�Q��用了�c�d��强器来对实体�cȝ��Class文�g�q�行强化处理�Q�通过增强器的增强�Q�将CGLIB的回调机刉��辑�Q�加入实体类�Q�这里我们可以看出属性的延迟加蝲�Q�还是通过 CGLIB来实现的。CGLIB是Apache的一个开源工�E�，�q�个�c�d��可以操纵java�cȝ��字节码，�Ҏ(gu��)��字节码来动态构造符合要求的�c�d��象。根据上面的配置我们�q�行下面的代码：

String sql=”from User user where user.name=’zx’ ”;

Query query=session.createQuery(sql); (1)

List list=query.list();

for(int i=0;i

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

System.out.println(user.getName());

System.out.println(user.getResume()); (2)

}

当执行到(1)处时�Q�会生成�c�M��如下的SQL语句�Q?/p>

Select id,age,name from user where name=’zx’;

�q�时Hibernate会检索User实体中所有非延迟加蝲属性对应的字段数据�Q�当执行�?2)处时�Q�会生成�c�M��如下的SQL语句�Q?/p>

Select resume from user where id=’1’;

�q�时会发起对resume字段数据真正的读取操作�?/p>

abin 2012-03-11 15:32 发表评论