hibernate--一级和二级缓存（使用Ehcache）以及查询缓存

其他 2018-07-03 17:59:01 阅读次数: 0

https://blog.csdn.net/u012411414/article/details/50483185

有一下几点需要理清才行：

一级缓存是session缓存 session关闭就小时

二级缓存是sessionFactory级别的缓存 一个应用程序只有一个 多个线程共享  不要把经常修改的对象放到二级缓存中 二级缓存中放一些查询的对象

1 首先是在hibernate,cfg.xml文件中进行配置：

添加下列配置项

  1.  
    <property name="hibernate.cache.use_second_level_cache">true</property>
  2.  
    <!-- 使用哪种缓存提供的类 哪种缓存 -->
  3.  
    <property name="hibernate.cache.provider_class">org.hibernate.cache.EhCacheProvider</property>
  4.  
    <!-- 使用查询缓存-->
  5.  
    <property name="hibernate.cache.use_query_cache">true</property>
  6.  
    <!-- ehcache.xml的配置文件路径 -->
  7.  
    <property name="hibernate.cache.provider_configuration_file_resource_path">ehcache.xml</property>

在需要使用二级缓存的对象配置文件上：

  1.  
    <class name="Student" table="t_stu">
  2.  
    <!-- <cache usage="read-only" /> -->
  3.  
    <id name="id">
  4.  
    <generator class="native"></generator>
  5.  
    </id>
  6.  
    <!-- 注意：version 一定要加在ID后面 property前面 -->
  7.  
    <version name="version" />
  8.  
    <property name="name" />
  9.  
    <property name="sex" />
  10.  
    <many-to-one name="classroom" column="cid" fetch="join" />
  11.  
    </class>

ehcache.xml中的配置：

  1.  
    <defaultCache
  2.  
    maxElementsInMemory= "10000"
  3.  
    eternal= "false"
  4.  
    timeToIdleSeconds= "120"
  5.  
    timeToLiveSeconds= "120"
  6.  
    overflowToDisk= "true"
  7.  
    />
  1.  
    <!-- 每一个独立的cache可以单独为不同的对象进行设置 如果找不到就用默认的cache-->
  2.  
    <cache name= "com.itany.model.Student"
  3.  
    maxElementsInMemory= "10000"
  4.  
    eternal= "false"
  5.  
    timeToIdleSeconds= "300"
  6.  
    timeToLiveSeconds= "600"
  7.  
    overflowToDisk= "true"
  8.  
    />




2 N+1问题

 如果使用iterator返回列表 对于hibernate而言 
         它仅仅是查询了id列表的SQL 在进行iterator迭代的时候 
         再会根据id一个个去数据库查询具体对象 因此发出多条SQL 这就是典型的N+1问题 避免它
         就是不使用iterator iterator存在的原因 
         使用的地方：
         因为有可能需要查询2次 第一次list全部查询出来 存在二级缓存中 第二次 用Iterator数据库查id，再根据ID从二级缓存的对象中查询更快

  1.  
    session = HibernateUtil.openSession();
  2.  
    Iterator<Student> it = session.createQuery( "from Student").setFirstResult(0).setMaxResults(12).iterate();
  3.  
    while (it.hasNext())
  4.  
    {
  5.  
    Student stu = it.next();
  6.  
    System.out.println(stu.getName());
  7.  
    }

3  重要：二级缓存缓存的是对象　　查询缓存缓存的是ＩＤ　这是两种不同的缓存  谁也不依赖谁　　 查询缓存也是sessionFactory级别的缓存

     查询缓存是针对HQL语句的缓存  查询缓只缓存ID 而不会缓存对象
     1 但是使用查询缓存最好打开二级缓存　因为在查询缓存中查到ＩＤ后可以直接去
     二级缓存中查找　不然的话又是Ｎ＋１问题　多次根据查询缓存中的ＩＤ去数据库查询
     2 若打开了二级缓存 但是没有打开查询缓存（HQL不一致、参数不一致、查询缓存没开、
     setCacheable(true)没写等原因）那么还是会直接从数据库中查询一次、
     因为需要借助查询缓存查ID再到二级缓存中查对象
     3 注意：load方式可以直接从二级缓存中查对象 不必借助查询缓存
     4如果取得只是某些属性（而不是完整对象） 那么不会进行二级缓存见test04
     5 查询缓存 工作顺序：如果正常开启了查询缓存（HQL完全一致 且set(True)），先去查询缓存中查ID
          再根据查询到的ID去二级缓存中查对象 若此时二级缓存打开了 那么不会发SQL
         若二级缓存没打开  那么此时会再次根据查到的ID去数据库中查询

4 代码中使用查询缓存

  

  1.  
    List<Object[]> ls = session.createQuery( "select stu from Student stu where name like ?")
  2.  
    .setCacheable( true).setParameter(0, "%张%").list();//开启查询缓存 查询缓存也是sessionFactory级别的缓存

5 此时关闭了二级缓存（存对象）
    打开了查询缓存（存ID） 第二个人查询缓存只查到ID 会根据ID 去二级缓存查对象  但是没有  所以去数据库查  发出大量SQL

6 查询缓存很少使用 因为很少ＨＱＬ完全一样
          因为只要HQL语句不一样 就不会开启查询缓存 
          只有两个完全一样的 并且参数都一样的 才能使用查询缓存

    1.  
      public class TestSecondCache
    2.  
      {
    3.  
      /*
    4.  
      * 重要：二级缓存缓存的是对象　　查询缓存缓存的是ＩＤ　这是两种不同的缓存
    5.  
      * 谁也不依赖谁　　
    6.  
      * 1 但是使用查询缓存最好打开二级缓存　因为在查询缓存中查到ＩＤ后可以直接去
    7.  
      * 二级缓存中查找　不然的话又是Ｎ＋１问题　多次根据查询缓存中的ＩＤ去数据库查询
    8.  
      * 2 若打开了二级缓存 但是没有打开查询缓存（HQL不一致、参数不一致、查询缓存没开、
    9.  
      * setCacheable(true)没写等原因）那么还是会直接从数据库中查询一次、
    10.  
      * 因为需要借助查询缓存查ID再到二级缓存中查对象
    11.  
      * 3 注意：load方式可以直接从二级缓存中查对象 不必借助查询缓存
    12.  
      *
    13.  
      * 如果取得只是某些属性（而不是完整对象） 那么不会进行二级缓存见test04
    14.  
      */
    15.  
       
    16.  
      @Test
    17.  
      public void test01()
    18.  
      {
    19.  
      /*
    20.  
      * 不可以缓存 Ehcache是看SQL是否一样
    21.  
      */
    22.  
      Session session = null;
    23.  
      try
    24.  
      {
    25.  
      session = HibernateUtil.openSession();
    26.  
      Student s=(Student)session.load(Student.class, 1);
    27.  
      System.out.println(s.getName());
    28.  
      }
    29.  
      catch (HibernateException e)
    30.  
      {
    31.  
      e.printStackTrace();
    32.  
      }
    33.  
      finally
    34.  
      {
    35.  
      if (null != session)
    36.  
      HibernateUtil.closeSession(session);
    37.  
      }
    38.  
      Session session2 = null;
    39.  
      /*
    40.  
      * 此时session已经关闭 但再次查询 仍然可以不发SQL 二级缓存起作用了
    41.  
      */
    42.  
      try
    43.  
      {
    44.  
      session2 = HibernateUtil.openSession();
    45.  
      Student s2=(Student)session2.load(Student.class, 1);//这种写法 根据ID去二级缓存中查询
    46.  
      System.out.println(s2.getName());
    47.  
      }
    48.  
      catch (HibernateException e)
    49.  
      {
    50.  
      e.printStackTrace();
    51.  
      }
    52.  
      finally
    53.  
      {
    54.  
      if (null != session2)
    55.  
      HibernateUtil.closeSession(session2);
    56.  
      }
    57.  
      }
    58.  
      @Test
    59.  
      public void test02()
    60.  
      {
    61.  
      /*
    62.  
      *
    63.  
      */
    64.  
      Session session = null;
    65.  
      try
    66.  
      {
    67.  
      session = HibernateUtil.openSession();
    68.  
      Student s=(Student)session.load(Student.class, 1);
    69.  
      System.out.println(s.getName());
    70.  
      }
    71.  
      catch (HibernateException e)
    72.  
      {
    73.  
      e.printStackTrace();
    74.  
      }
    75.  
      finally
    76.  
      {
    77.  
      if (null != session)
    78.  
      HibernateUtil.closeSession(session);
    79.  
      }
    80.  
      Session session2 = null;
    81.  
      Transaction trans= null;
    82.  
      /*
    83.  
      * 会报错 因为二级缓存 在Student上设置的是 read-only 因此不能写入
    84.  
      * 最好不要设置 read write因为hibernate要频繁的加锁 解锁 影响效率 还不如不用二级缓存
    85.  
      */
    86.  
      try
    87.  
      {
    88.  
      session2 = HibernateUtil.openSession();
    89.  
      trans=session2.beginTransaction();
    90.  
      Student s2=(Student)session2.load(Student.class, 1);
    91.  
      s2.setName( "zhangasnsss");
    92.  
      System.out.println(s2.getName());
    93.  
      trans.commit();
    94.  
      }
    95.  
      catch (HibernateException e)
    96.  
      {
    97.  
      e.printStackTrace();
    98.  
      }
    99.  
      finally
    100.  
      {
    101.  
      if (null != session2)
    102.  
      HibernateUtil.closeSession(session2);
    103.  
      }
    104.  
      }
    105.  
      @Test
    106.  
      public void test03()
    107.  
      {
    108.  
      /*
    109.  
      *
    110.  
      */
    111.  
      Session session = null;
    112.  
      Transaction trans = null;
    113.  
      try
    114.  
      {
    115.  
      session = HibernateUtil.openSession();
    116.  
      List<Student> ls = session.createQuery( "from Student").list();
    117.  
      Iterator<Student> it = ls.iterator();
    118.  
      while (it.hasNext())
    119.  
      {
    120.  
      Student stu = it.next();
    121.  
      System.out.println(stu.getName());
    122.  
      }
    123.  
      }
    124.  
      catch (HibernateException e)
    125.  
      {
    126.  
      e.printStackTrace();
    127.  
      }
    128.  
      finally
    129.  
      {
    130.  
      if (null != session)
    131.  
      HibernateUtil.closeSession(session);
    132.  
      }
    133.  
       
    134.  
      try
    135.  
      {
    136.  
      session = HibernateUtil.openSession();
    137.  
      Student s=(Student)session.load(Student.class, 1);
    138.  
      System.out.println(s.getName());
    139.  
      }
    140.  
      catch (HibernateException e)
    141.  
      {
    142.  
      e.printStackTrace();
    143.  
      }
    144.  
      finally
    145.  
      {
    146.  
      if (null != session)
    147.  
      HibernateUtil.closeSession(session);
    148.  
      }
    149.  
      }
    150.  
      @Test
    151.  
      public void test04()
    152.  
      {
    153.  
      /*
    154.  
      *
    155.  
      */
    156.  
      Session session = null;
    157.  
      Transaction trans = null;
    158.  
      try
    159.  
      {
    160.  
      session = HibernateUtil.openSession();
    161.  
      List<Object[]> ls = session.createQuery( "select stu.id,stu.name from Student stu").list();
    162.  
      }
    163.  
      catch (HibernateException e)
    164.  
      {
    165.  
      e.printStackTrace();
    166.  
      }
    167.  
      finally
    168.  
      {
    169.  
      if (null != session)
    170.  
      HibernateUtil.closeSession(session);
    171.  
      }
    172.  
      /*
    173.  
      * 以上代码仅仅去了id和name 而二级缓存是缓存对象的 所以上一段代码不会使用二级缓存
    174.  
      * 此时就会发出相应的SQL
    175.  
      */
    176.  
      try
    177.  
      {
    178.  
      session = HibernateUtil.openSession();
    179.  
      Student s=(Student)session.load(Student.class, 1);
    180.  
      System.out.println(s.getName());
    181.  
      }
    182.  
      catch (HibernateException e)
    183.  
      {
    184.  
      e.printStackTrace();
    185.  
      }
    186.  
      finally
    187.  
      {
    188.  
      if (null != session)
    189.  
      HibernateUtil.closeSession(session);
    190.  
      }
    191.  
      }
    192.  
      @Test
    193.  
      public void test05()
    194.  
      {
    195.  
      /*
    196.  
      * iterator 作用就是配合二级缓存使用 最好
    197.  
      */
    198.  
      Session session = null;
    199.  
      Transaction trans = null;
    200.  
      try
    201.  
      { //一条SQL
    202.  
      session = HibernateUtil.openSession();
    203.  
      List<Object[]> ls = session.createQuery( "select stu from Student stu").list();
    204.  
      }
    205.  
      catch (HibernateException e)
    206.  
      {
    207.  
      e.printStackTrace();
    208.  
      }
    209.  
      finally
    210.  
      {
    211.  
      if (null != session)
    212.  
      HibernateUtil.closeSession(session);
    213.  
      }
    214.  
      /* 1条SQL
    215.  
      * 由于学生的对象经过上面查询对象之后 已经存在于二级缓存之中
    216.  
      * 此时正好直接使用iterator 首先会查询通过1条取ID的语句 然后再获取对象时候去二级缓存中查询
    217.  
      * 有的话 直接用 不会产生N+1问题
    218.  
      *
    219.  
      * 若没二级缓存 我们直接使用iterator会首先产生一条查ID的语句
    220.  
      * 再在获取对象的时候再去数据库中取 那么这是就会产生N+1问题
    221.  
      */
    222.  
      try
    223.  
      {
    224.  
      session = HibernateUtil.openSession();
    225.  
      Iterator<Student> it = session.createQuery( "from Student").iterate();
    226.  
      while (it.hasNext())
    227.  
      {
    228.  
      Student stu = it.next();
    229.  
      System.out.println(stu.getName());
    230.  
      }
    231.  
      }
    232.  
      catch (HibernateException e)
    233.  
      {
    234.  
      e.printStackTrace();
    235.  
      }
    236.  
      finally
    237.  
      {
    238.  
      if (null != session)
    239.  
      HibernateUtil.closeSession(session);
    240.  
      }
    241.  
      }
    242.  
      @Test
    243.  
      public void test06()
    244.  
      {
    245.  
      /*
    246.  
      * 与上面一个几乎一样 区别在于iterator换成list()
    247.  
      * 虽然第一次已经二级缓存了 但是不能决定我再去不去数据库中查询
    248.  
      *
    249.  
      * 重要 ：如果希望第二次不发SQL 那就要使用查询缓存
    250.  
      * 查询缓存是针对HQL语句的缓存 查询缓只缓存ID 而不会缓存对象
    251.  
      */
    252.  
      Session session = null;
    253.  
       
    254.  
      Transaction trans = null;
    255.  
      try
    256.  
      { //一条SQL
    257.  
      session = HibernateUtil.openSession();
    258.  
      List<Object[]> ls = session.createQuery( "select stu from Student stu").list();
    259.  
      }
    260.  
      catch (HibernateException e)
    261.  
      {
    262.  
      e.printStackTrace();
    263.  
      }
    264.  
      finally
    265.  
      {
    266.  
      if (null != session)
    267.  
      HibernateUtil.closeSession(session);
    268.  
      }
    269.  
      /* 1条SQL 和上一条一模一样
    270.  
      *
    271.  
      */
    272.  
      try
    273.  
      {
    274.  
      session = HibernateUtil.openSession();
    275.  
      List<Student> ls = session.createQuery( "select stu from Student stu").list();
    276.  
      Iterator<Student> it=ls.iterator();
    277.  
      while (it.hasNext())
    278.  
      {
    279.  
      Student stu = it.next();
    280.  
      System.out.println(stu.getName());
    281.  
      }
    282.  
      }
    283.  
      catch (HibernateException e)
    284.  
      {
    285.  
      e.printStackTrace();
    286.  
      }
    287.  
      finally
    288.  
      {
    289.  
      if (null != session)
    290.  
      HibernateUtil.closeSession(session);
    291.  
      }
    292.  
      }
    293.  
      @Test
    294.  
      public void test07()
    295.  
      {
    296.  
      /*
    297.  
      * 设置了查询缓存为true
    298.  
      */
    299.  
      Session session = null;
    300.  
      Transaction trans = null;
    301.  
      try
    302.  
      { //一条SQL
    303.  
      session = HibernateUtil.openSession();
    304.  
      List<Object[]> ls = session.createQuery( "select stu from Student stu")
    305.  
      .setCacheable( true).list();//开启查询缓存 查询缓存也是sessionFactory级别的缓存
    306.  
      }
    307.  
      catch (HibernateException e)
    308.  
      {
    309.  
      e.printStackTrace();
    310.  
      }
    311.  
      finally
    312.  
      {
    313.  
      if (null != session)
    314.  
      HibernateUtil.closeSession(session);
    315.  
      }
    316.  
      /*0条SQL
    317.  
      *
    318.  
      */
    319.  
      try
    320.  
      {
    321.  
      session = HibernateUtil.openSession();
    322.  
      List<Student> ls = session.createQuery( "select stu from Student stu")
    323.  
      .setCacheable( true).list();
    324.  
      Iterator<Student> it=ls.iterator();
    325.  
      while (it.hasNext())
    326.  
      {
    327.  
      Student stu = it.next();
    328.  
      System.out.println(stu.getName());
    329.  
      }
    330.  
      }
    331.  
      catch (HibernateException e)
    332.  
      {
    333.  
      e.printStackTrace();
    334.  
      }
    335.  
      finally
    336.  
      {
    337.  
      if (null != session)
    338.  
      HibernateUtil.closeSession(session);
    339.  
      }
    340.  
      }
    341.  
      @Test
    342.  
      public void test08()
    343.  
      {
    344.  
      /*
    345.  
      * 此时无法使用查询缓存 查询缓存很少使用 因为很少ＨＱＬ完全一样
    346.  
      * 因为只要HQL语句不一样 就不会开启查询缓存
    347.  
      * 只有两个完全一样的 并且参数都一样的 才能使用查询缓存
    348.  
      */
    349.  
      Session session = null;
    350.  
      Transaction trans = null;
    351.  
      try
    352.  
      { //一条SQL
    353.  
      session = HibernateUtil.openSession();
    354.  
      List<Object[]> ls = session.createQuery( "select stu from Student stu where name like ?")
    355.  
      .setCacheable( true).setParameter(0, "%张%").list();//开启查询缓存 查询缓存也是sessionFactory级别的缓存
    356.  
      }
    357.  
      catch (HibernateException e)
    358.  
      {
    359.  
      e.printStackTrace();
    360.  
      }
    361.  
      finally
    362.  
      {
    363.  
      if (null != session)
    364.  
      HibernateUtil.closeSession(session);
    365.  
      }
    366.  
      /*
    367.  
      *
    368.  
      */
    369.  
      try
    370.  
      {
    371.  
      //一条SQL
    372.  
      session = HibernateUtil.openSession();
    373.  
      List<Student> ls = session.createQuery( "select stu from Student stu where name like ?")
    374.  
      .setCacheable( true).setParameter(0, "%王%").list();
    375.  
      Iterator<Student> it=ls.iterator();
    376.  
      while (it.hasNext())
    377.  
      {
    378.  
      Student stu = it.next();
    379.  
      System.out.println(stu.getName());
    380.  
      }
    381.  
      }
    382.  
      catch (HibernateException e)
    383.  
      {
    384.  
      e.printStackTrace();
    385.  
      }
    386.  
      finally
    387.  
      {
    388.  
      if (null != session)
    389.  
      HibernateUtil.closeSession(session);
    390.  
      }
    391.  
      }
    392.  
      @Test
    393.  
      public void test09()
    394.  
      {
    395.  
      /*
    396.  
      * 此时关闭了二级缓存（存对象）
    397.  
      * 打开了查询缓存（存ID）
    398.  
      * ！！！工作顺序：如果正常开启了查询缓存（HQL完全一致 且set(True)），先去查询缓存中查ID
    399.  
      * 再根据查询到的ID去二级缓存中查对象 若此时二级缓存打开了 那么不会发SQL
    400.  
      * 若二级缓存没打开 那么此时会再次根据查到的ID去数据库中查询
    401.  
      */
    402.  
      Session session = null;
    403.  
      Transaction trans = null;
    404.  
      try
    405.  
      { //一条SQL
    406.  
      session = HibernateUtil.openSession();
    407.  
      List<Object[]> ls = session.createQuery( "select stu from Student stu where name like ?")
    408.  
      .setCacheable( true).setParameter(0, "%张%").list();//开启查询缓存 查询缓存也是sessionFactory级别的缓存
    409.  
      }
    410.  
      catch (HibernateException e)
    411.  
      {
    412.  
      e.printStackTrace();
    413.  
      }
    414.  
      finally
    415.  
      {
    416.  
      if (null != session)
    417.  
      HibernateUtil.closeSession(session);
    418.  
      }
    419.  
      /*
    420.  
      *
    421.  
      */
    422.  
      try
    423.  
      {
    424.  
      //此时关闭了student的二级缓存 打开了查询缓存 发出大量SQL
    425.  
      session = HibernateUtil.openSession();
    426.  
      List<Student> ls = session.createQuery( "select stu from Student stu where name like ?")
    427.  
      .setCacheable( true).setParameter(0, "%张%").list();
    428.  
      Iterator<Student> it=ls.iterator();
    429.  
      while (it.hasNext())
    430.  
      {
    431.  
      Student stu = it.next();
    432.  
      System.out.println(stu.getName());
    433.  
      }
    434.  
      }
    435.  
      catch (HibernateException e)
    436.  
      {
    437.  
      e.printStackTrace();
    438.  
      }
    439.  
      finally
    440.  
      {
    441.  
      if (null != session)
    442.  
      HibernateUtil.closeSession(session);
    443.  
      }
    444.  
      }
    445.  
      @Test
    446.  
      public void test10()
    447.  
      {
    448.  
      /*
    449.  
      * 此时打开了二级缓存（存对象）
    450.  
      * 打开了查询缓存（存ID）
    451.  
      * ！！！！工作顺序：如果正常开启了查询缓存，先去查询缓存中查ID
    452.  
      * 再根据查询到的ID去二级缓存中查对象 若此时二级缓存打开了 那么不会发SQL
    453.  
      * 若二级缓存没打开 那么此时会再次根据查到的ID去数据库中查询
    454.  
      */
    455.  
      Session session = null;
    456.  
      Transaction trans = null;
    457.  
      try
    458.  
      { //一条SQL
    459.  
      session = HibernateUtil.openSession();
    460.  
      List<Object[]> ls = session.createQuery( "select stu from Student stu where name like ?")
    461.  
      .setCacheable( true).setParameter(0, "%张%").list();//开启查询缓存 查询缓存也是sessionFactory级别的缓存
    462.  
      }
    463.  
      catch (HibernateException e)
    464.  
      {
    465.  
      e.printStackTrace();
    466.  
      }
    467.  
      finally
    468.  
      {
    469.  
      if (null != session)
    470.  
      HibernateUtil.closeSession(session);
    471.  
      }
    472.  
      /*
    473.  
      *
    474.  
      */
    475.  
      try
    476.  
      {
    477.  
      //此时打开了student的二级缓存 打开了查询缓存 不发SQL
    478.  
      session = HibernateUtil.openSession();
    479.  
      List<Student> ls = session.createQuery( "select stu from Student stu where name like ?")
    480.  
      .setCacheable( true).setParameter(0, "%张%").list();
    481.  
      Iterator<Student> it=ls.iterator();
    482.  
      while (it.hasNext())
    483.  
      {
    484.  
      Student stu = it.next();
    485.  
      System.out.println(stu.getName());
    486.  
      }
    487.  
      }
    488.  
      catch (HibernateException e)
    489.  
      {
    490.  
      e.printStackTrace();
    491.  
      }
    492.  
      finally
    493.  
      {
    494.  
      if (null != session)
    495.  
      HibernateUtil.closeSession(session);
    496.  
      }
    497.  
      }
    498.  
      @Test
    499.  
      public void test11()
    500.  
      {
    501.  
      /*
    502.  
      * 此时打开了二级缓存（存对象）
    503.  
      * 打开了查询缓存（存ID）
    504.  
      * ！！！！工作顺序：如果正常开启了查询缓存，先去查询缓存中查ID
    505.  
      * 再根据查询到的ID去二级缓存中查对象 若此时二级缓存打开了 那么不会发SQL
    506.  
      * 若二级缓存没打开 那么此时会再次根据查到的ID去数据库中查询
    507.  
      */
    508.  
      Session session = null;
    509.  
      Transaction trans = null;
    510.  
      try
    511.  
      { //一条SQL
    512.  
      session = HibernateUtil.openSession();
    513.  
      List<Object[]> ls = session.createQuery( "select stu from Student stu where name like ?")
    514.  
      .setCacheable( true).setParameter(0, "%张%").list();//开启查询缓存 查询缓存也是sessionFactory级别的缓存
    515.  
      }
    516.  
      catch (HibernateException e)
    517.  
      {
    518.  
      e.printStackTrace();
    519.  
      }
    520.  
      finally
    521.  
      {
    522.  
      if (null != session)
    523.  
      HibernateUtil.closeSession(session);
    524.  
      }
    525.  
      /*
    526.  
      *
    527.  
      */
    528.  
      try
    529.  
      {
    530.  
      //此时虽然打开了student的二级缓存 但是不能使用查询缓存（HQL不一致）导致没法通过查询缓存查ID去
    531.  
      //二级缓存中查对象
    532.  
      //所以仍然发出一条SQL 从数据库中查询
    533.  
      session = HibernateUtil.openSession();
    534.  
      List<Student> ls = session.createQuery( "select stu from Student stu where name like ?")
    535.  
      .setCacheable( true).setParameter(0, "%张三%").list();
    536.  
      Iterator<Student> it=ls.iterator();
    537.  
      while (it.hasNext())
    538.  
      {
    539.  
      Student stu = it.next();
    540.  
      System.out.println(stu.getName());
    541.  
      }
    542.  
      }
    543.  
      catch (HibernateException e)
    544.  
      {
    545.  
      e.printStackTrace();
    546.  
      }
    547.  
      finally
    548.  
      {
    549.  
      if (null != session)
    550.  
      HibernateUtil.closeSession(session);
    551.  
      }
    552.  
      }
    553.  
      }

猜你喜欢

转载自www.cnblogs.com/yuluoxingkong/p/9259807.html
今日推荐
国产云输入法——仅华为无云端数据上传安全问题
开源日报 | 工业开源项目OGG 1.0；姐姐，你要和我一起配置火狐吗；苹果AI遥遥落后？Fedora 40
开放签电子签章：停止新增，优化体验，前进更进（五一假期前工作）
开源日报 | 中学生开源前端动画引擎；全球首个Llama3 8B中文版开源模型；联想电脑恐出局；Linus讽刺AI炒作
“百模大战”必有一战 | 2024中国“百模大战”竞争格局分析
最强开源大模型 Llama 3 上架 Gitee AI
周排行
自媒体文章如何提高原创度以及如何检测原创度
开启qq邮箱的smtp服务
Qt程序单次启动（QSingleApplication类）
国外的外包网站
更新IDEA主题——放飞代码风格
cocos2dx 实现搓牌效果（翻牌效果），包括铺平动画
dict和json之间的互相转换
angular的一些思考
. Fibonacci数列是这样定义的： F[0] = 0 F[1] = 1 for each i ≥ 2: F[i] = F[i-1] + F[i-2] 因此，Fibonacci数列就形如：0, 1
洛谷P1064 金明的预算方案
每日归档
更多
2024-04-25(22)
2024-04-24(36)
2024-04-23(26)
2024-04-22(39)
2024-04-21(0)
2024-04-20(6)
2024-04-19(5)
2024-04-18(0)
2024-04-17(5)
2024-04-16(70)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022