澳门新萄京官方网站-www.8455.com-澳门新萄京赌场网址

澳门新萄京官方网站:hibernate延迟加载org,Hibe

2019-05-02 作者:www.8455.com   |   浏览(63)

public static void main(String[] args) {
 
  DeptEntity dept = getDept("402882e762ae888d0162ae888e420000");

转载:

延期加载在Hibernate中是暗中同意延迟加载;

始建筑工程程得以是java也能够是web

Hibernnate延迟加载计策(这么详细你还看不懂),hibernnate延迟

恒久未有认真写过博客了,前些天就十全十美的写一篇吧!!!!!!!!!

当Hibernate 从数据库中加载某些对象(比方:Dept对象)时,要是还要活动加载全体的关联的有些对象(比方:Emp对象),而先后实际上只有须求拜访Dept对象,那么那些涉及的Emp对象就白白浪费了众多内部存款和储蓄器空间。发生这种情况的原因是:正是即时加载的标题。

1.怎么是当下加载呢?

Hibernate 查询 Dept 对象时,立刻加载并加载与之提到的Emp对象,那种查询战略称为 立刻加载。

马上加载存在两大不足:

一.select 语句的数额太多,要求反复地走访数据库,会潜移默化查询品质。

二.在应用程序只要求拜访Dept对象时,而无需访问Emp对象的场面,加载Emp对象完全是多余的操作,这个多余的Emp对象就白白的浪费了繁多内部存款和储蓄器空间。

 

那么大家不能够不要解决这些难题,所以将在聊到了“延迟加载”的知识了,延迟加载战略能防止加载应用程序无需拜访的关联对象,以优化查询品质。

只是大家要掌握有种种查询战术,接下去大家就协同来分析每1种查询计谋的加载难题。

第1种:类等级的查询计谋

澳门新萄京官方网站 1

类等级可选的加载计策包罗立时加载和延期加载,暗许是延迟加载,要是,<class>元素的lazy的性质为true,表示选用延迟加载;要是lazy 属性 为 false,表示选用当下加载。

大家未来以代码来解释是最佳的主意。

一.应声加载计策

我们在Dept.hbm.xml文件中 加 lazy=“false”  属性,即可。

澳门新萄京官方网站 2

表结构:

 澳门新萄京官方网站 3

测试代码:

    Session session = HibernateUtil.currentSession();

        session.beginTransaction();

        Dept dept = (Dept)session.load(Dept.class, 1);

        System.out.println("部门名称" dept.getdName());

        System.out.println("===================");

        Dept dept2 = (Dept)session.load(Dept.class, 1);

        System.out.println("部门名称" dept2.getdName());

        session.getTransaction().commit();

        HibernateUtil.closeSessio();

测试结果:

 澳门新萄京官方网站 4

咱们领略使用Load方法加载的是代理对象,只会在性质里保存一个OID,可是如若在Dept映射文件中布局了类级其他lazy为false就表示加载该对象时登时加载,也正是当下搜索三次数据库,发出了一条sql语句。

二.延迟加载

类级其余默许加载攻略正是延迟加载。在在Dept.hbm.xml文件中 ,以下三种方法都意味延迟加载计谋。

 澳门新萄京官方网站 5

或是

 澳门新萄京官方网站 6

只要程序加载二个持久化对象的目标是为着访问它的性质,那是大家能够选取当下加载,不过假设程序加载1个持久化对象的目标是为着获得它的引用,这是大家得以行使延迟加载,无须访问Dept对象的品质。

看例子:

   

   Dept dept = (Dept)session.load(Dept.class, 1);

        System.out.println("部门名称" dept.getdName());

        Employee emp=new Employee();

        emp.setEname("李四");

        emp.setDept(dept);

        session.save(emp);

 

那段代码向数据库保存了 四个Employee 对象,它与已经存在的多少个Dept持久化对象关系。如若在Dept 类等第选择延迟加载,则 session.load()方法不会实践访问DEPT 表的select 语句,只回去叁个Dept的代办对象,它的deptNo的属性值为一,别的属性都为NULL。session.save()方法实施的sql语句:

 澳门新萄京官方网站 7

故而当,<class>成分的lazy属性为true时,会影响session.load()方法的各样运营时表现。比如表明:

1.倘诺加载的Dept对象在数据库中不设有时,不会抛出分外,唯有运营dept.getxxx()时,才会抛出卓殊。

测试代码:

    Session session = HibernateUtil.currentSession();

        session.beginTransaction();

        Dept dept = (Dept)session.load(Dept.class, 3);

        System.out.println("部门名称" dept.getdName());

        Employee emp=new Employee();

        emp.setEname("李四");

        emp.setDept(dept);

        session.save(emp);

 

当 deptNo为三不设有时,会抛出以下格外:

 澳门新萄京官方网站 8

二.万1在在整个Session范围内,应用程序未有访问过的Dept对象,那么Dept代理类的实例一向不会被伊始化,Hibernater 不会奉行其余的select语句。以下代码试图在关闭Session后走访的Dept游离对象:

测试代码:

Session session = HibernateUtil.currentSession();

        session.beginTransaction();

        Dept dept = (Dept)session.load(Dept.class, 3);

        HibernateUtil.closeSessio();

        System.out.println("部门名称" dept.getdName());

        session.getTransaction().commit();

        HibernateUtil.closeSessio();

 

从代码中我们得以看到,session被提前关闭,所以dept引用的Dept代理类的实例在Session范围内始终未有被发轫化,所以当施行到  System.out.println("部门名称" dept.getdName())时,会抛出以下非常:

澳门新萄京官方网站 9

 

 

综上可得,Dept代理类的实例只有在现阶段的Session范围内手艺被伊始化。

三.import org.hibernate.Initialized()静态方法,用于在Session范围内显式开始化代理类实例,isInitialized()方法用于决断代理类实例是或不是已经被初步化。

代码:

Dept dept = (Dept)session.load(Dept.class, 1);

if(!Hibernate.isInitialized(dept)){

Hibernate.initialize(dept);

HibernateUtil.closeSessio();

System.out.println("部门名称" dept.getdName());

}

 

以上代码在Session范围内经过Hibernate 类的Initialized()方法显式开头化了Dept代理类实例,因而关闭Session关闭后,可以符合规律访问Dept的游离对象。

四.超过后访问代理类实例的getDeptNo()方法时,不会触发Hibernate 初步化 代理类实例的作为。举个例子:

代码:

Dept dept = (Dept)session.load(Dept.class, 1);

      System.out.println("编号:"  dept.getDeptNo());

HibernateUtil.closeSessio();

System.out.println("部门名称" dept.getdName());

 

当程序访问dept.getDeptNo()方法时,该方法直接回到Dept代理类的实例OID值,无须查询数据库。由于变量dept始终引用的是向来不初步化的Dept代理类的实例,因而当Session关闭后再实施dept.getdName()方法,会抛出以下极度。

 澳门新萄京官方网站 10

唯独值得大家注意的是:不管Dept.hbm.xml文件的<class>成分的质量是true依然false,Session 的get方法及Query对象的list方法在Dept类品级总是接纳即时加载攻略。比方表明:

一.Session的get方法总是立刻到数据库中查询Dept查询对象,假诺在数据库中不设有对应的数量,就能够回来NULL,举个例子:

代码:

 

Session session = HibernateUtil.currentSession();
        session.beginTransaction();
        Dept dept = (Dept)session.get(Dept.class, 3);
        System.out.println(dept);

 

结果:

澳门新萄京官方网站 11

 

由此可见,get方法恒久不会试行Dept的代理类实例。

二.Query的list方法总是立时到数据库中查询Dept对象

 

代码:

List<Dept> query = session.createQuery("from Dept").list();
        for (Dept dept : query) {
            System.out.println(dept.getdName());
        }

结果:

澳门新萄京官方网站 12

 

到了这里,算是把第一连串等级的询问计谋写的大约了。

第二种:一对多和多对壹涉及的询问攻略

澳门新萄京官方网站 13

加上七个小知识点:

01.一对多要么多对多寻觅计谋由lazy和fetch共同明确

 

02.fetch取值

    Join:紧急    Lazy:决定涉及对象早先化时机

左外连接

    Select:多条简单SQL(私下认可值)

    Subselect:子查询

03.fetch和lazy组合

  解析:fetch=”join” lazy会被忽视,急迫左外连接的即时寻觅

        Fetch=”s    Fetch:决定SQL语句塑造形式

elect” lazy=”false”  多条轻巧SQL马上搜索

        Fetch=”select” lazy=”true”  多条语句延迟检索

        Fetch=”select” lazy=”extra”  多条语句及其懒惰检索

        Fetch=”subselect” lazy=”false”  子查询即刻搜索

        Fetch=”subselect” lazy=”true”  子查询延迟检索

        Fetch=”subselect” lazy=”extra”  子查询及其懒惰检索

Extra:及其懒惰,只有访问集结对象的性质时才会加载,访问集合自身的性质时(比如,集结大小,生成count),不会登时加载。

注意:query的list()会忽视映射文件配置的左外连接查询,fetch,此时lazy属性重新生效。

 

 

在炫人眼目文件中,用<SET>成分来配置1对多涉及及多对壹关乎关系的加载攻略。Dept.hbm.xml文件中的一下代码用于配置Dept和Employee类的一对多涉及关系:

  <!-- 双向     cascade:级联     inverse:反转 -->
           <!--set表明Dept类的emps属性为set集合类型  -->
           <!--order-by 对集合排序  order-by="dName asc   order-by="dName desc-->
           <set name="emps" inverse="true" lazy="true">
           <!--employee表的外键 deptNo  -->
           <key column="deptNo"></key>
           <!--一对多    class 属性设定与所关联的持久化类 为employee -->
           <one-to-many class="Employee"/>
           </set>

 

此间的<set>成分有lazy属性,首要取决于emps群集被开始化的火候,到底是在加载Dept对象时就被初阶化,依旧在先后访问emps会集时被初叶化。

壹.眼看加载

Dept.hbm.xml的布署文件:

澳门新萄京官方网站 14

测试代码:

        Dept dept = (Dept)session.get(Dept.class, 1);
        System.out.println(dept.getdName());

结果:实施Session的get方法时,对于Dept对象选用类级其他立即加载战术,对于Dept对象的emps集结(Dept关联全体的employee对象),选择一对多关系的立即加载战略。

澳门新萄京官方网站 15

 

 从那几个结果我们能够观察,Hibernate加载了贰个Dept对象和Employee对象,可是大家理解多数景色下,无需访问Employee对象,所以我们就得用了 延迟加载战略。

二.延迟加载

对此<set>成分,应该先行怀恋使用的私下认可延迟加载计策。

澳门新萄京官方网站 16

 

测试代码:

    Dept dept = (Dept)session.get(Dept.class, 1);
        System.out.println(dept.getdName());

结果:

澳门新萄京官方网站 17

很引人侧目,只实行了一条sql语句,即唯有加载了Dept对象。

Session的get方法,重返的是Dept对象的emps属性引用四个并未有被开端化的集纳代理类实例。换句话说,此时的emps集结中绝非存废弃何Emp对象,唯有emps集合代理类实例被开首化时,才回来数据库查询全体与Dept关联的Emp对象。

测试代码:

    Dept dept = (Dept)session.get(Dept.class, 1);
        System.out.println(dept.getdName());

        for (Employee emp : dept.getEmps()) {
            System.out.println(emp.getEname());
        }

结果:

澳门新萄京官方网站 18

 

这正是说,Dept对象的emps属性引用的联谊代理类实例什么日期被早先化呢?主要总结以下三种情状:

0壹.当应用程序第3次访问它时,如调用 iterator(),size(),isEmpty(),或是 contains()方法时:

代码:

    Dept dept = (Dept)session.get(Dept.class, 1);
        Set<Employee> emp=dept.getEmps();
        System.out.println(dept.getdName());

        Iterator<Employee> itee=emp.iterator();//emps被初始化

0二.通过hibernate的静态方法initialize()来初叶化它。

    Dept dept = (Dept)session.get(Dept.class, 1);
        Set<Employee> emp=dept.getEmps();
        System.out.println(dept.getdName());
        Hibernate.initialize(emp);//emps被初始化

3.巩固延迟加载

lazy="extra"

配备如下:

 澳门新萄京官方网站 19

做实延迟加载计谋能越来越延迟Dept对象的emps集结代理类实例开端化时机。当应用程序第二回访问emps属性的iterator()时,会促成emps集结代理类的实例早先化。可是当当应用程序第3回size(),isEmpty(),或是 contains()方法时,emps不会发轫化emps集结代理实例。仅仅经过询问select语句要求消息。

测试代码:

Dept dept = (Dept)session.get(Dept.class, 1);
//不会初阶化emps集结代理类实例
int size = dept.getEmps().size();
System.out.println(size);

//会初阶化emps集结代理类实例
Iterator<Employee> iterator = dept.getEmps().iterator();
System.out.println(iterator);

结果:

澳门新萄京官方网站 20

最近是第三种:多对一关乎的询问计谋

lazy=proxy

 Employee.hbm.xml中但自己安顿:

澳门新萄京官方网站 21

一.推迟加载计谋。

测试代码:

Employee em=(Employee) session.get(Employee.class, 21);//仅仅执行em对象的sql语句
        Dept dept = em.getDept();
        System.out.println(dept.getdName());//执行Dept对象

当Sesson施行get()方法时,仅仅登时实践查询Employee对象的select语句。当Employee 对象引用Dept代理类实例,这几个代理类实例的IOD由Employee 表的DeptNo外键值决定。 当施行dept.getdName()时,hibernate 伊始化Dept代理类实例,实践以下select语句到数据库中加载Dept对象。

结果:

澳门新萄京官方网站 22

 

无代理延迟加载:

lazy="no-proxy" 

澳门新萄京官方网站 23

测试代码:

        Employee em=(Employee) session.get(Employee.class, 21);//仅仅执行em对象的sql语句
        Dept dept = em.getDept();
        System.out.println(dept.getdName());//执行Dept对象

假如Employee对象的dept属性使用无代理延迟加载,即<many-to-many>成分的lazy属性为no-proxy,当实行get方法时,加载的Employee的dept属性为NULL,当实施到  em.getDept()时,将触发hibernate实施查询Dept 表的select 语句,从而加载Dept对象。

结果:

澳门新萄京官方网站 24

总之,当lazy为proxy 时,能够延长延迟加载 Dept对象的时光,而当lazy属性为no-proxy时,则能够制止选取由hibernate 提供的Dept代理类实例,使用hibernate 对先后 提供越来越透亮的持久化服务。

当即加载:

lazy=“false”

澳门新萄京官方网站 25

测试:

    Employee em=(Employee) session.get(Employee.class, 21);

结果:

澳门新萄京官方网站 26

能够观看,实施了两条sql语句。 

Open Session In View 模式9

Open Session In View 情势的职能:

 Hibernate 允许对关乎对象、属性实行延期加载,不过必须保险延迟加载的操作限于同1个Hibernate Session 范围之内实行。倘使 Service层重返一个启用了推迟加载功效的天地对象给 Web 层,当 Web 层访问到那二个急需延期加载的多寡时,由于加载领域对象的 Hibernate Session 已经破产,那个产生延迟加载数据的造访十分。

在Java Web 应用中,常常供给调用ibernate API 获取到呈现的有些要显得的某部对象并传给相应但的视图JSP, 并在JSP中从那么些目的导航到与之提到的目的或集合数据。那么些关系对象或会集数据要是是被延缓加载的,hibernate 就能够抛出以下相当:

澳门新萄京官方网站 27

这是因为在调用完hibernate完之后,Session 对象已经关门了。针对那几个主题素材,hibernate 社区提供了Open Session In View 方式 的化解方案!!

代码示例:

  //dept.getEmp()获得子表的记录会集
  System.out.println(dept.getEmp());

hibernate使用版本是:hibernate-release-肆.三.四.Final

测试代码壹:

1、引入jar文件

HibernateUtil代码

 private static final ThreadLocal<Session> sessionTL=new ThreadLocal<Session>();
//私有的静态的配置对象
 private static Configuration configuration;
//私有的静态的工厂对象
 private final static SessionFactory sessionFactory;
 //静态代码块,负责给成员变量赋值
 static{
     configuration=new Configuration().configure();
     sessionFactory=configuration.buildSessionFactory();
 }
 //从SessionFactory  连接池            获取一个和当前thread bind session
 public static Session currentSession(){
    //2.返回当前的线程其对应的线程内部变量

      //sessionTL的get()方法依据当下线程重临其对应的线程内部变量,

     //也正是大家需求的Session,10二线程情状下共享数据库连接是不安全的。

       //ThreadLocal保险了各样线程都有投机的Session.

     Session session=sessionTL.get();
     //如果当前线程是session 为空=null ,则打开一个新的Session
     if(session==null){
         //创建一个session对象
         session=sessionFactory.openSession();
         //保存该Sessioon对象到ThreadLocal中
         sessionTL.set(session);     
     } 
     return session;
 }
 //关闭Session
 public  static void closeSessio(){
     Session session=sessionTL.get();
     sessionTL.set(null);
     session.close();

 }

}

需要的jar包:hibernate-release-4.3.4Finallibrequired下所有jar包

HibernateTest.java

二、设计表同时开辟和表的字段名一样的javabean(持久化类)

biz层代码:

HibernateDao dao=new HibernateDao();
    public Object get(Class clazz,Serializable id){
           Object obj= dao.get(clazz, id);return obj;
    }

private static DeptEntity getDept(String did){
  Session session = sessionFactory.openSession();
  DeptEntity dept = (DeptEntity)session.get(DeptEntity.class, did);
  session.close();
  return dept;
}

ehcache  jar包:hibernate-release-4.3.4.Finalliboptionalehcache下所有包

代码:

三、创设对象-关系映射文件:映射文件的扩充名称为 .hbm.xml 这里Login.hbm.xml文件

dao层代码:

public Object get(Class clazz,Serializable id){
           Object result= HibernateUtils.currentSession().load(clazz, id);
           return result;
    }

filter层代码:

public void doFilter(ServletRequest request, ServletResponse response,
            FilterChain chain) throws IOException, ServletException {            
        Session session = null;
        Transaction tx = null;
        try {

            session = HibernateUtils.currentSession();
            System.out.println("filtert" session.hashCode());        
            tx = session.beginTransaction();                        
            // 执行请求处理链    双向过滤
            chain.doFilter(request, response);
            // 返回响应时,提交事务
            tx.commit();
        } catch (HibernateException e) {
            e.printStackTrace();
            tx.rollback();
        } finally {
            // 关闭session
            HibernateUtils.closeSession();
        }
    }

 

junit:junit-4.10.jar和mysql-connector-java-5.1.15-bin.jar

/**
 *
 */
package com.b510.examples;

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

过滤器在网站xml中的配置:

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5" 
    xmlns="http://java.sun.com/xml/ns/javaee" 
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
    xsi:schemaLocation="http://java.sun.com/xml/ns/javaee 
    http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">
  <display-name></display-name>    
 <!-- 过滤器 -->
 <filter>
   <filter-name>openSessionInView</filter-name>
   <filter-class>cn.happy.filter.OpenSessionInViewFilter</filter-class>
 </filter>
 <filter-mapping>
    <filter-name>openSessionInView</filter-name>
    <url-pattern>/*</url-pattern>
 </filter-mapping>
  <welcome-file-list>
    <welcome-file>index.jsp</welcome-file>
  </welcome-file-list>
</web-app>

index.jsp页面包车型地铁代码:

<body>
    <%
          HibernateBiz biz=new HibernateBiz();
        Emp emp=(Emp)biz.get(Emp.class,1);
      %>
     <%=emp.getEmpName() %>
  </body>

本条代码只是二个例证而已,你能够写别样的代码。那样就算实现了Open Session In View 模式。

再下结论二次:

至于No Session的那个难题,有了四种的化解方案:

方案一
在biz层 把load 改成get
方案二
/* if (!Hibernate.isInitialized(obj)) {
Hibernate.initialize(obj);
}*/
方案 三 :在 映射文件中 ,类品级 <set> 中加多 lazy =“false”
方案4: 在biz 层 先用1道 要求的UI使用 到的属性 ,然后在biz关闭
方案伍:把实体类 改成 用 final 修饰,我们了解,延迟加载的案由是 内部存款和储蓄器中 有代理对象 (其实是emp 类的子类),所以当大家设为 该类 无法 有子类
方案六:Open Session In View 模式。

在上面都曾经用代码做例子了,够清楚了的。

好久未有当真写过博客了,明日就美好的写1篇吧!!!!!!!!! 当 H...

运维结果:

注:hibernate 4.二.5版本ehcache缓存不重视commons-logging-一.一.一.jar,需求的是slf四j-api-一.陆.一.jar

import java.util.Set;

<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" ";

Exception in thread "main" org.hibernate.LazyInitializationException: failed to lazily initialize a collection of role: com.javakc.hibernate.onetomany.entity.DeptEntity.emp, could not initialize proxy - no Session
at org.hibernate.collection.internal.AbstractPersistentCollection.throwLazyInitializationException(AbstractPersistentCollection.java:566)
at org.hibernate.collection.internal.AbstractPersistentCollection.withTemporarySessionIfNeeded(AbstractPersistentCollection.java:186)
at org.hibernate.collection.internal.AbstractPersistentCollection.initialize(AbstractPersistentCollection.java:545)
at org.hibernate.collection.internal.AbstractPersistentCollection.read(AbstractPersistentCollection.java:124)
at org.hibernate.collection.internal.PersistentSet.toString(PersistentSet.java:326)
at java.lang.String.valueOf(String.java:2827)
at java.io.PrintStream.println(PrintStream.java:771)
at com.javakc.hibernate.onetomany.action.TestAction.main(TestAction.java:74)

项目结构如下
 
澳门新萄京官方网站 28  

import org.hibernate.Session;

<hibernate-mapping>

 

hibernate.cfg.xml

/**
 *
 * @author XHW
 *
 * @date 2011-7-18
 *
 */
public class HibernateTest {
 public static void main(String[] args) {
  new HibernateTest().update();
 }
 public void update(){
  Session session=HibernateSessionFactoryUtil.getSessionFactory().getCurrentSession();
  session.beginTransaction();
  Category category=(Category)session.get(Category.class, 1);
  System.out.println("id:" category.getId() "  ,name:" category.getName() ", description:" category.getDescription());
  
  Set<Product> products=category.getProducts();
  
  session.getTransaction().commit();  
 }
 
 
}

<class name="com.hw.entity.Student" table="tab_student">

集结延迟加载起始化败北,无法起头化三个代理。正是集聚在非1对壹对象关系中,为了节省资源是暗中同意延迟加载,而get方法又是非延迟加载,所以在推行完3遍数据库查询后就施行session.close();关闭了session,而会集是延迟加载,在动用集结时再加载,此时session已经关门,所以得不到代办。化解格局:能够在主表的hbm配置文件中,在<set>标签里设置lazy="false",集结就不推迟加载了,由此在实行get方法时,集结也获得到了,就不会冒出延迟加载难题了。

  1. <?xml version='1.0' encoding='utf-8'?>  
  2. <!DOCTYPE hibernate-configuration PUBLIC  
  3.         "-//Hibernate/Hibernate Configuration DTD 3.0//EN"  
  4.         ";  
  5. <hibernate-configuration>  
  6.     <session-factory>  
  7.         <!-- Database connection settings -->  
  8.         <property name="connection.driver_class">com.mysql.jdbc.Driver</property>  
  9.         <property name="connection.url">jdbc:mysql://127.0.0.1:3306/hibernate4</property>  
  10.         <property name="connection.username">root</property>  
  11.         <property name="connection.password">root</property>  
  12.         <!-- JDBC connection pool (use the built-in) -->  
  13.         <property name="connection.pool_size">1</property>  
  14.         <!-- SQL dialect -->  
  15.         <property name="dialect">org.hibernate.dialect.MySQL5Dialect</property>  
  16.         <!-- Enable Hibernate's automatic session context management -->  
  17.         <property name="current_session_context_class">thread</property>  
  18.         <!-- Disable the second-level cache -->  
  19.         <!--<property name="cache.provider_class">org.hibernate.cache.internal.NoCacheProvider</property> 
  20.         -->  
  21.         <!-- 配置二级缓存 -->  
  22.         <property name="hibernate.cache.use_second_level_cache">true</property>  
  23.         <property name="hibernate.cache.region.factory_class">org.hibernate.cache.ehcache.EhCacheRegionFactory</property>  
  24.         <!-- hibernate三的二级缓存配置 -->  
  25.         <!-- <property name="hibernate.cache.provider_class">org.hibernate.cache.EhCacheProvider</property> -->  
  26.         <!-- 开启查询缓存 -->  
  27.         <property name="hibernate.cache.use_query_cache">true</property>  
  28.           
  29.         <!-- Echo all executed SQL to stdout -->  
  30.         <property name="show_sql">true</property>  
  31.         <!-- Drop and re-create the database schema on startup -->  
  32.         <property name="hbm2ddl.auto">update</property>  
  33.         <mapping class="com.test.pojo.User" />  
  34.     </session-factory>  
  35. </hibernate-configuration>  

运作结果:

<id name="id" type="integer" column="id"><!-- 如若列名和name名一致方可省去 -->

 

log4j:WARN No appenders could be found for logger (org.hibernate.cfg.Environment).
log4j:WARN Please initialize the log4j system properly.
Hibernate:
    select
        category0_.id as id1_0_,
        category0_.name as name1_0_,
        category0_.description as descript3_1_0_
    from
        users.category category0_
    where
        category0_.id=?
id:1  ,name:java, description:java好啊

时刻档案的次序 把 java.util.Date 改成 java.sql.Date

瞩目:hibernate四和hibernate3配置不平等,hibernate4是

此地我们来看大家关心的是id,name和description属性,

<generator class="native"></generator><!-- 主键自增 --></id>

  1. <property name="hibernate.cache.region.factory_class">org.hibernate.cache.ehcache.EhCacheRegionFactory</property>  

纵然有:  Set<Product> products=category.getProducts(); 代码,即:不管理集结对象。可是我们倘若的是:

<property name="name" type="string"></property>

 

  System.out.println("id:" category.getId() "  ,name:" category.getName() ", description:" category.getDescription());
输出的是id,name和description属性值,其余的大家不管,所以Hibernate用了lazy loading(延迟加载),带来的受益正是大家不关心的

<property name="score" type="float"></property>

而hibernate叁的铺排是

数据,不用未来加载,当大家要用的时候,才去加载

</class></hibernate-mapping>

  1. <property name="hibernate.cache.provider_class">org.hibernate.cache.EhCacheProvider</property>  

测试代码二:

4、创立 Hibernate 配置文件(hibernate.cfg.xml)

 此处有三个疑团是:hibernate4的合法文档中,已经把class改了,可是属性名称未有改,照旧hibernate.cache.provider_class,不是地点的 hibernate.cache.region.factory_class,不过写成hibernate.cache.provider_class会 报下边错误

HibernateTest.java

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

 

代码:

<!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration DTD 3.0//EN" ";

Java代码 

/**
 *
 */
package com.b510.examples;

<!-- Generated by MyEclipse Hibernate Tools.                -->

  1. org.hibernate.service.spi.ServiceException: Unable to create requested service [org.hibernate.engine.spi.CacheImplementor]  
  2.     at org.hibernate.service.internal.AbstractServiceRegistryImpl.createService(AbstractServiceRegistryImpl.java:186)  
  3.     at org.hibernate.service.internal.AbstractServiceRegistryImpl.initializeService(AbstractServiceRegistryImpl.java:150)  
  4.     at org.hibernate.service.internal.AbstractServiceRegistryImpl.getService(AbstractServiceRegistryImpl.java:131)  
  5.     at org.hibernate.internal.SessionFactoryImpl.<init>(SessionFactoryImpl.java:264)  
  6.     at org.hibernate.cfg.Configuration.buildSessionFactory(Configuration.java:1790)  
  7.     at com.test.pojo.UserTest.beforeClass(UserTest.java:28)  
  8.     at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)  
  9.     at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:39)  
  10.     at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:25)  
  11.     at java.lang.reflect.Method.invoke(Method.java:597)  
  12.     at org.junit.runners.model.FrameworkMethod$1.runReflectiveCall(FrameworkMethod.java:45)  
  13.     at org.junit.internal.runners.model.ReflectiveCallable.run(ReflectiveCallable.java:15)  
  14.     at org.junit.runners.model.FrameworkMethod.invokeExplosively(FrameworkMethod.java:42)  
  15.     at org.junit.internal.runners.statements.RunBefores.evaluate(RunBefores.java:27)  
  16.     at org.junit.runners.ParentRunner.run(ParentRunner.java:300)  
  17.     at org.eclipse.jdt.internal.junit4.runner.JUnit4TestReference.run(JUnit4TestReference.java:46)  
  18.     at org.eclipse.jdt.internal.junit.runner.TestExecution.run(TestExecution.java:38)  
  19.     at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:467)  
  20.     at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:683)  
  21.     at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.run(RemoteTestRunner.java:390)  
  22.     at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.main(RemoteTestRunner.java:197)  
  23. Caused by: org.hibernate.cache.NoCacheRegionFactoryAvailableException: Second-level cache is used in the application, but property hibernate.cache.region.factory_class is not given, please either disable second level cache or set correct region factory class name to property hibernate.cache.region.factory_class (and make sure the second level cache provider, hibernate-infinispan, for example, is available in the classpath).  
  24.     at org.hibernate.cache.internal.NoCachingRegionFactory.buildTimestampsRegion(NoCachingRegionFactory.java:87)  
  25.     at org.hibernate.cache.spi.UpdateTimestampsCache.<init>(UpdateTimestampsCache.java:62)  
  26.     at org.hibernate.internal.CacheImpl.<init>(CacheImpl.java:72)  
  27.     at org.hibernate.engine.spi.CacheInitiator.initiateService(CacheInitiator.java:40)  
  28.     at org.hibernate.engine.spi.CacheInitiator.initiateService(CacheInitiator.java:35)  
  29.     at org.hibernate.service.internal.SessionFactoryServiceRegistryImpl.initiateService(SessionFactoryServiceRegistryImpl.java:91)  
  30.     at org.hibernate.service.internal.AbstractServiceRegistryImpl.createService(AbstractServiceRegistryImpl.java:176)  
  31.     ... 20 more  

import java.util.Set;

<hibernate-configuration>

 说是hibernate.cache.region.factory_class属性未有配置,估算官方文书档案里从未把质量改过来。。。

import org.hibernate.Session;

<session-factory>

 

/**
 *
 * @author XHW
 *
 * @date 2011-7-18
 *
 */
public class HibernateTest {
 public static void main(String[] args) {
  new HibernateTest().update();
 }
 public void update(){
  Session session=HibernateSessionFactoryUtil.getSessionFactory().getCurrentSession();
  session.beginTransaction();
  Category category=(Category)session.get(Category.class, 1);
  System.out.println("id:" category.getId() "  ,name:" category.getName() ", description:" category.getDescription());
  
  Set<Product> products=category.getProducts();
  for(Product product:products){
   System.out.println("ID:  " product.getId() "  name:" product.getName() " price: " product.getPrice());
  }  
  session.getTransaction().commit();  
 }
 
 
}

<!-- hibernate 的mysql方言 -->

ehcache.xml

运转效果:

<property name="dialect">org.hibernate.dialect.MySQLDialect</property>

  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <ehcache xmlns:xsi=""  
  3.     xsi:noNamespaceSchemaLocation=""  
  4.     updateCheck="false">  
  5.     <!--  
  6.         name:cache唯1标记   
  7.         eternal:缓存是或不是永世有效   
  8.         maxElementsInMemory:内部存款和储蓄器中最大缓存对象数  
  9.         overflowToDisk(true,false):缓存对象抵达最大数后,将缓存写到硬盘中  
  10.         diskPersistent:硬盘持久化  
  11.         timeToIdleSeconds:缓存清除时间   
  12.         timeToLiveSeconds:缓存存活时间  
  13.         memoryStoreEvictionPolicy:缓存清空战略  
  14.         1.FIFO:first in first out 先讲先出  
  15.         2.LFU: Less Frequently Used 平昔以来最少被采纳的  
  16.         三.LRU:Least Recently Used  近来起码使用的  
  17.     -->  
  18.     <defaultCache maxElementsInMemory="1000" eternal="false"  
  19.         timeToIdleSeconds="120" timeToLiveSeconds="120" overflowToDisk="true" />  
  20.     <cache name="userCache" eternal="false" maxElementsInMemory="1000"  
  21.         overflowToDisk="false" diskPersistent="false" timeToIdleSeconds="3600"  
  22.         timeToLiveSeconds="3600" memoryStoreEvictionPolicy="LFU" />  
  23. </ehcache>  

log4j:WARN No appenders could be found for logger (org.hibernate.cfg.Environment).
log4j:WARN Please initialize the log4j system properly.
Hibernate:
    select
        category0_.id as id1_0_,
        category0_.name as name1_0_,
        category0_.description as descript3_1_0_
    from
        users.category category0_
    where
        category0_.id=?
id:1  ,name:java, description:java好啊
Hibernate: 
澳门新萄京官方网站:hibernate延迟加载org,Hibernate延迟加载。    select
        products0_.category_id as category2_1_,
        products0_.id as id1_,
        products0_.id as id0_0_,
        products0_.category_id as category2_0_0_,
        products0_.name as name0_0_,
        products0_.price as price0_0_,
        products0_.descripton as descripton0_0_
    from
        users.product products0_

<property name="connection.url">jdbc:mysql://localhost:3306/stu?useUnicode=true&characterEncoding=utf8</property>

 

    where
        products0_.category_id=?
ID:  一  name:java SE应用程序设计 price: 78.00
那边能够鲜明的报告我们,当大家要加载Set集结的时候,那时候才去加载,而地点的例子,表达的是大家不加载的时候

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

User实体类

Hibernate就延期加载

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

  1. package com.test.pojo;  
  2.   
  3. import javax.persistence.Entity;  
  4. import javax.persistence.GeneratedValue;  
  5. import javax.persistence.GenerationType;  
  6. import javax.persistence.Id;  
  7.   
  8. import org.hibernate.annotations.Cache;  
  9. import org.hibernate.annotations.CacheConcurrencyStrategy;  
  10.   
  11. @Entity  
  12. @Cache(usage=CacheConcurrencyStrategy.READ_WRITE)  
  13. public class User {  
  14.     @Id  
  15.     @GeneratedValue(strategy=GenerationType.IDENTITY)  
  16.     private int id;  
  17.     private String name;  
  18.     private int age;  
  19.     public int getId() {  
  20. 澳门新萄京官方网站:hibernate延迟加载org,Hibernate延迟加载。        return id;  
  21.     }  
  22.     public void setId(int id) {  
  23.         this.id = id;  
  24.     }  
  25.     public String getName() {  
  26.         return name;  
  27.     }  
  28.     public void setName(String name) {  
  29.         this.name = name;  
  30.     }  
  31.     public int getAge() {  
  32.         return age;  
  33.     }  
  34.     public void setAge(int age) {  
  35.         this.age = age;  
  36.     }  
  37.       
  38. }  

撤销延迟加载:

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

 

Category.hbm.xml

<!-- hibernate自动生成表 -->

UserTest测试类:

代码:

<property name="hibernate.hbm2ddl.auto">update</property>

  1. package com.test.pojo;  
  2. import org.hibernate.HibernateException;  
  3. import org.hibernate.Session;  
  4. import org.hibernate.SessionFactory;  
  5. import org.hibernate.cfg.Configuration;  
  6. import org.hibernate.service.ServiceRegistry;  
  7. import org.hibernate.service.ServiceRegistryBuilder;  
  8. import org.junit.BeforeClass;  
  9. import org.junit.Test;  
  10.   
  11. public class UserTest {  
  12.       
  13.     private static SessionFactory sessionFactory = null;  
  14.     @BeforeClass  
  15.     public static void beforeClass() {  
  16.         Configuration configuration = new Configuration();  
  17.           
  18.   
  19.         try {  
  20.             configuration.configure();  
  21.         } catch (HibernateException e) {  
  22.             // TODO Auto-generated catch block  
  23.             e.printStackTrace();  
  24.         }  
  25.               
  26.           
  27.         ServiceRegistry serviceRegistry = new ServiceRegistryBuilder().applySettings(configuration.getProperties()).buildServiceRegistry();  
  28.         sessionFactory = configuration.buildSessionFactory(serviceRegistry);  
  29.     }   
  30.     @Test  
  31.     public void testEhcache() {  
  32.         Session session = sessionFactory.openSession();  
  33.         session.beginTransaction();  
  34.         User u1 = (User) session.load(User.class, 3);  
  35.         System.out.println(u1.getName());  
  36.         session.getTransaction().commit();  
  37.         session.close();  
  38.         Session session2 = sessionFactory.openSession();  
  39.           
  40.         session2.beginTransaction();  
  41.         User u2 = (User) session2.load(User.class, 3);  
  42.         System.out.println(u2.getName());  
  43.         session2.getTransaction().commit();  
  44.         session2.close();  
  45.     }  
  46. }  

<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"">
<!--
    Mapping file autogenerated by MyEclipse Persistence Tools
-->
<hibernate-mapping>
    <class name="com.b510.examples.Category" table="category" catalog="users">
        <id name="id" type="java.lang.Integer">
            <column name="id" />
            <generator class="increment" />
        </id>
        <property name="name" type="java.lang.String">
            <column name="name" length="500" />
        </property>
        <property name="description" type="java.lang.String">
            <column name="description" length="500" />
        </property>
        <set name="products" inverse="true" lazy="false">
            <key>
                <column name="category_id" />
            </key>
            <one-to-many class="com.b510.examples.Product" />
        </set>
    </class>
</hibernate-mapping>

<!-- hibernate显示sql -->(运维底下会显得语句,可以删)

 结果:

测试代码:

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

 

HIbernateTest.java

<!-- hibernate 格式化sql-->(运营底下会显得语句,能够删)

  1. Hibernate: select user0_.id as id1_0_0_, user0_.age as age2_0_0_, user0_.name as name3_0_0_ from User user0_ where user0_.id=?  
  2. zhangsan  
  3. zhangsan  

代码:

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

 

/**
 *
 */
package com.b510.examples;

<!-- hibernate映射文件 -->(点source的另一个 add加进去)

list二级缓存测试

import java.util.Set;

<mapping resource="com/hw/entity/Student.hbm.xml" />

  1. package com.test.pojo;  
  2. import java.util.List;  
  3.   
  4. import org.hibernate.HibernateException;  
  5. import org.hibernate.Session;  
  6. import org.hibernate.SessionFactory;  
  7. import org.hibernate.cfg.Configuration;  
  8. import org.hibernate.service.ServiceRegistry;  
  9. import org.hibernate.service.ServiceRegistryBuilder;  
  10. import org.junit.BeforeClass;  
  11. import org.junit.Test;  
  12.   
  13. public class UserTest {  
  14.       
  15.     private static SessionFactory sessionFactory = null;  
  16.     @BeforeClass  
  17.     public static void beforeClass() {  
  18.         Configuration configuration = new Configuration();  
  19.           
  20.   
  21.         try {  
  22.             configuration.configure();  
  23.         } catch (HibernateException e) {  
  24.             // TODO Auto-generated catch block  
  25.             e.printStackTrace();  
  26.         }  
  27.               
  28.           
  29.         ServiceRegistry serviceRegistry = new ServiceRegistryBuilder().applySettings(configuration.getProperties()).buildServiceRegistry();  
  30.         sessionFactory = configuration.buildSessionFactory(serviceRegistry);  
  31.     }   
  32.     @SuppressWarnings("unchecked")  
  33.     @Test  
  34.     public void testListEhcache() {  
  35.         Session session = sessionFactory.openSession();  
  36.         session.beginTransaction();  
  37.         List<User> users1 = (List<User>)session.createQuery("from User").setCacheable(true).list();  
  38.         for(User user : users1) {  
  39.             System.out.println(user.getName());  
  40.         }  
  41.         session.getTransaction().commit();  
  42.         session.close();  
  43.           
  44.         Session session2 = sessionFactory.openSession();  
  45.         session2.beginTransaction();  
  46.         List<User> users2 = (List<User>)session2.createQuery("from User").setCacheable(true).list();  
  47.         for(User user : users2) {  
  48.             System.out.println(user.getName());  
  49.         }  
  50.         session2.getTransaction().commit();  
  51.         session2.close();  
  52.     }  
  53. }  

import org.hibernate.Session;

</session-factory>

 输出结果:

/**
 *
 * @author XHW
 *
 * @date 2011-7-18
 *
 */
public class HibernateTest {
 public static void main(String[] args) {
  new HibernateTest().update();
 }
 public void update(){
  Session session=HibernateSessionFactoryUtil.getSessionFactory().getCurrentSession();
  session.beginTransaction();
  Category category=(Category)session.get(Category.class, 1);
  System.out.println("id:" category.getId() "  ,name:" category.getName() ", description:" category.getDescription());
  
  Set<Product> products=category.getProducts();
   
  session.getTransaction().commit();  
 }
 
 
}

</hibernate-configuration>

  1. Hibernate: select user0_.id as id1_0_, user0_.age as age2_0_, user0_.name as name3_0_ from User user0_  
  2. zhangsan  
  3. zhangsan  
  4. lisi  
  5. wangwu  
  6. zhangsan  
  7. zhangsan  
  8. lisi  
  9. wangwu  

运维作效果果:

5、加载xml文件,创建sessionFactory

log4j:WARN No appenders could be found for logger (org.hibernate.cfg.Environment).
log4j:WARN Please initialize the log4j system properly.
Hibernate:
    select
        category0_.id as id1_0_,
        category0_.name as name1_0_,
        category0_.description as descript3_1_0_
    from
        users.category category0_
    where
        category0_.id=?
Hibernate:
    select
        products0_.category_id as category2_1_,
        products0_.id as id1_,
        products0_.id as id0_0_,
        products0_.category_id as category2_0_0_,
        products0_.name as name0_0_,
        products0_.price as price0_0_,
        products0_.descripton as descripton0_0_
    from
        users.product products0_
    where
        products0_.category_id=?
id:1  ,name:java, description:java好啊
和测试代码一的运行结果互相比较,大家会意识,这一次运转结果用了两条select语句。不过大家会发觉

public class HibernateUtil {

其次条select语句,对于大家的须要是不曾须要的,他唯有二个用场正是占领大家的程序试行时间。当然,

public static Session getSession() {//获取当前session

那是大家不希望看到的结果。

return new Configuration().configure().buildSessionFactory().openSession()

相似意况下,Hibernate会暗中同意给我们设置延迟加载。lazy="true" ,那样会进步大家的体系质量,所以一般景观下,大家不会去

}

设置lazy="false",当然在至极的情形下,我们必需要撤回延迟加载的时候,我们就把lazy="false",就足以了

}

6、开发crud

private Session session=null;

public void add(Person per){//添加

session=HibernateUtil.getSession();

Transaction beginTransaction = session.beginTransaction();//开启事务

session.save(per);//添加

beginTransaction.commit();//事务提交

session.close();

}

public void update(Person per){//修改

session=HibernateUtil.getSession();

Transaction beginTransaction = session.beginTransaction();//开启事务

session.update(per);//修改

beginTransaction.commit();//事务提交

session.close();

}

//saveOrUpdate 加多或涂改,有id且存在为修改或则为抬高

public void del(Person per){//删除

session=HibernateUtil.getSession();

Transaction beginTransaction = session.beginTransaction();//开启事务

session.delete(session.get(Dept.class,id));//删除对象

beginTransaction.commit();//事务提交

session.close();

}

查询

一get和load可查询单个对象,两者区就是为查询不到时回来结果不一样,get是null

load是not found

get方法

session=HibernateUtil.getSession();

// Transaction beginTransaction = session.beginTransaction();//开启事务

Person per = (Person) session.get(Person.class, id);//get获取单个对象

System.out.println(per.getId() " " per.getName() " " per.getMoney());

// beginTransaction.commit();//事务提交

session.close();  //注:查询能够不加事务

一、get方法查询单个对象,有就输出结果,未有则报空指针

案例:

public Person findByid(int id){//查询单个对象,能够不用职业

session=HibernateUtil.getSession();

Person per = (Person) session.get(Person.class, id);//get获取单个对象

session.close();

return per;

}

load方法

session=HibernateUtil.getSession();

// Transaction beginTransaction = session.beginTransaction();//开启事务

Person per = (Person) session.load(Person.class, id);//get获取单个对象

System.out.println(per.getId() " " per.getName() " " per.getMoney());

// beginTransaction.commit();//事务提交

session.close();  //注:查询能够不加事务

1、load方法查询单个对象,有就输出结果,没有则报找不到目的

(hibernate中get方法和load方法的有史以来差异

借使您使用load方法,hibernate以为该id对应的目标(数据库记录)在数据库中是自然存在的,所以它能够放心的运用,它能够放心的行使代理来推迟加载该目的。在用到目的中的其余属性数据时才查询数据库,不过如若数据库中不存在该记录,那不能够,只可以抛卓殊ObjectNotFoundException,所说的load方法抛极度是指在利用该对象的数目时,数据库中不设有该数据时抛非常,而不是在开创这一个目的时。由于session中的缓存对于hibernate来讲是个至极廉价的能源,所以在load时会先查一下session缓存看看该id对应的靶子是否留存,不设有则创制代理。所以只要你驾驭该id在数据库中必然有对应记录存在就足以应用load方法来兑现延迟加载。

对于get方法,hibernate会确认一下该id对应的数码是不是留存,首先在session缓存中寻觅,然后在二级缓存中寻觅,还从未就查数据库,数据库中尚无就回来null。

就算如此好些个书中都那样说:“get()永世只回去实体类”,但实质上那是不得法的,get方法要是在session缓存中找到了该id对应的靶子,假诺恰巧该指标前面是被代理过的,如被load方法应用过,大概被其余关联对象延迟加载过,那么重返的依然原本的代办对象,而不是实体类对象,假使该代理对象还从未加载实体数据(便是id以外的其他属性数据),那么它会询问二级缓存恐怕数据库来加载数据,但是回到的或然代理对象,只但是已经加载了实体数据。

前边已经讲了,get方法首先查询session缓存,未有的话查询二级缓存,最后查询数据库;反而load方法成立时首先查询session缓存,没有就创立代理,实际应用数据时才查询二级缓存和数据库。

同理可得对于get和load的有史以来差异,一句话,hibernate对于load方法以为该数据在数据库中毫无疑问存在,能够放心的使用代理来拖延加载,要是在使用进度中窥见了难题,就抛分外;而对于get方法,hibernate一定要取获得实在的数码,否则重返null。)一

1.get()选拔当下加载格局,而load()采纳延迟加载;

get()方法施行的时候,会马上向数据库发出查询语句,

而load()方法再次来到的是3个代理(此代理中唯有叁个id属性),唯有等的确使用该目的属性的时候,才会发生sql语句

贰.例如数据库中一向不相应的笔录,get()方法再次来到的是null.而load()方法出现万分ObjectNotFoundException

hibernate的get/load的有史以来不一样分为四点:第一点是:load会抛出拾1分,get会重返空,一般采取的load方法。第一点是:get只回去实体对象实例。而load再次回到的是代理类实体对象实例。第三点是:get方法只可以选拔一流缓存。而load能够运用一级和二级缓存。第四点是:都是经过id获得单个对象的措施。

贰list方法能够再次来到多个(hql)

public List<Dept>list() {//查询和原先jdbc有分别

Query createQuery = session.createQuery("from Dept");//from 后接类名

List<Dept>list = createQuery.list();

return list;

}

public List<Dept>listPage(int currentPage, int pageSize) {

//selecct* from dept limit ?,?

//hql中不援救limit分页,只可以利用如下设置

Query createQuery = session.createQuery("from Dept");//from 后接类名

/*hibernate分页错误写法

* createQuery.setInteger(0,(currentPage-1)*pageSize);

createQuery.setInteger(1,pageSize);*/

//相当于limit的第1个问号

createQuery.setFirstResult((currentPage-1)*pageSize);

//相当于limit的第2个问号

createQuery.setMaxResults(pageSize);

List<Dept>list = createQuery.list();

return list;

}

public List<Dept>listLike(String name) {

//from Dept  相当于sql语句的 select * from Dept

Query createQuery = session.createQuery("from Dept where dname like ?");

//from 后接类名

createQuery.setString(0, '%' name '%');

//hibernate是从0开始,jdbc是从1开始

List<Dept>list = createQuery.list();

return list;

}

public int getCount() {//总结数据

Query createQuery = session.createQuery("from Dept");//from 后接类名

List<Dept>list = createQuery.list();

return list.size();

}

Query query = session.createQuery("select count(*) from "

clazz.getSimpleName());

count = (Long) query.uniqueResult();

session.close();

hql的update(不用)

public void updateStudent2(Student stu) {

Session session = HibernateUtils.getSession();

// 4开立数据库事务(要么同时功要么同时退步):开垦中除了查询外都要用事务

Transaction beginTransaction = session.beginTransaction();

String hql="update Student set name=?,score=? where id=?";

// String hql="insert into Student values(null,?,?)"; //hib不支持insert

Query createQuery = session.createQuery(hql);

createQuery.setString(0, stu.getName());

createQuery.setFloat(1, stu.getScore());

createQuery.setInteger(2, stu.getId());

createQuery.executeUpdate();//执行修改或删除

beginTransaction.commit();

// 7关闭Session

session.close();

}

hql的delete(不用)

public void delStudent2(int id) {

Session session = HibernateUtils.getSession();

// 四成立数据库事务(要么同时功要么同时失败):开辟中除去查询外都要用事务

Transaction beginTransaction = session.beginTransaction();

String hql="delete from Student  where id=?";

Query createQuery = session.createQuery(hql);

createQuery.setInteger(0,id);

createQuery.executeUpdate();//执行修改或删除

beginTransaction.commit();

// 7关闭Session

session.close();

}

createSQLQuery:用于复杂sql语句询问

public ListlistLikeStudentPage2(String name, int currentPage,int pageSize) {Session session = HibernateUtils.getSession();String sql="select * from tab_student where name like ? limit ?,?";//createSQLQuery:用于复杂sql语句询问SQLQuery query = session.createSQLQuery(sql);query.setString(0, '%' name '%');query.setInteger(一, (currentPage-一)*pageSize);query.setInteger(二, pageSize);query.addEntity(Student.class);//一定要增添实体类Listlist = query.list();

return list;

}

本文由澳门新萄京官方网站发布于www.8455.com,转载请注明出处:澳门新萄京官方网站:hibernate延迟加载org,Hibe

关键词: