Hibernate学习扩展知识

// 同样是先创建链接

Session session = HibernateSessionFactory.getSession();
  // List list=
  // session.createQuery("select employeeId,firstName,salary from Employees")
  // .list();

  // 如何进入持久层呢个呢？
  // List list=
  // session.createQuery("select new com.hsbc.hr.pojo.LittleEmp(e.employeeId,e.firstName,e.salary) from com.hsbc.hr.pojo.Employees e")
  // .list();
  // System.out.println(list);
  // findall from Employeee虽然可以得到所有的
  // 外表及其数据。但是这是立即检索的查询策略。他会将自己和关联到自己的所有从表和所有相关联的表和数据都立即加载到hibernate内存
  // 此时多态查询，只得到用户想要的对象，就能屏蔽其他对象加载内存
  // 内联接也是解决这个问题的。朱从表两方会进入内存。但是与之相关联其他从表。当用户不去使用其从表的列时，不加载。当用户时候的时候触发加载。

  // List list=
  // session.createQuery("select sum(e.salary),max(e.salary) from com.hsbc.hr.pojo.Employees e")
  // .list();
  // 让聚合函数进入持久层方法同上
  // 联结查询。然后问题。链接查询虽然解决了对象立即检索的问题。但是没有解决持久层的问题
  // 所以解决方案是迫切查询策略。他可以让查询结果进入持久层。并使用刚才的策略
  // 不用写
  // List list=
  // session.createQuery(" from com.hsbc.hr.pojo.Employees e inner  join e.jobs")
  // .list();
  // 左外
  // List list=
  // session.createQuery(" from com.hsbc.hr.pojo.Employees e left  join e.jobs")
  // .list();
  // 右外
  // List list=
  // session.createQuery(" from com.hsbc.hr.pojo.Employees e right  join e.jobs")
  // .list();
  // 全外.不支持
  // List list=
  // session.createQuery(" from com.hsbc.hr.pojo.Employees e full  join e.jobs")
  // .list();
  // 如何将链接查询进入持久层。使用迫切 。切记。hibernate老版本只支持迫切右
  // List list=
  // session.createQuery(" from com.hsbc.hr.pojo.Employees e inner  join fetch e.jobs")
  // .list();
  // 迫切左外
  // List list=
  // session.createQuery(" from com.hsbc.hr.pojo.Employees e left  join fetch e.jobs")
  // .list();
  // 迫切右外
  // List list=
  // session.createQuery(" from com.hsbc.hr.pojo.Employees e right  join fetch e.jobs")
  // .list();
  // 全外.不支持
  // List list=
  // session.createQuery(" from com.hsbc.hr.pojo.Employees e full  join  fetch e.jobs")
  // .list();
  // 分组查询
  // List list = session
  // .createQuery(
  // "select e.jobs.jobId,count(e.employeeId) from com.hsbc.hr.pojo.Employees e  group  by e.jobs.jobId")
  // .setCacheable(true)
  // .list();
  // System.out.println(((Object[])list.get(1))[1]);
  // 如何进入持久层？方法同上
  // naturalId 是1==1永远为真
  // List list = session.createCriteria(Employees.class)
  // .add(Restrictions.naturalId())
  // .list();
  // != 或者<>
  // List list = session.createCriteria(Employees.class)
  // .add(Restrictions.ne("firstName", "Steven"))
  // .list();
  // 判断两个列不是值
  // List list = session.createCriteria(Employees.class)
  // .add(Restrictions.neProperty("firstName", "lastName"))
  // .list();
  // QBE
  Employees e = new Employees();
  e.setEmployeeId(101);// 不管id
  e.setFirstName("Neena");

  List list = session
    .createCriteria(Employees.class)
    .add(
      Example.create(e)
      .excludeNone()
      .excludeZeroes()
      .excludeProperty("firstName")).list();

  System.out.println(list);
 }

 public void qbc() {
  Session session = HibernateSessionFactory.getSession();
  // 内联接，仅供玩赏
  Criteria cri = session.createCriteria(Employees.class)
    .add(Restrictions.gt("employeeId", 100)).createCriteria("jobs")
    .add(Restrictions.idEq("IT_PROG"))
        .setCacheable(true);

  // 复杂的条件查询--and
  Junction con = Restrictions.conjunction()
    .add(Restrictions.gt("employeeId", 100))
    .add(Restrictions.gt("salary", 1.0));
  Criteria cri2 = session.createCriteria(Employees.class)
                       .add(con);

  Criteria cri3 = session.createCriteria(Employees.class).add(
    Restrictions.or(con, Restrictions.lt("employeeId", 1000)));

  // 复杂的条件查询--or
  Junction con2 = Restrictions.disjunction()
    .add(Restrictions.gt("employeeId", 100))
    .add(Restrictions.gt("salary", 1.0));
  Criteria cri4 = session.createCriteria(Employees.class).add(con2);

  // 统计分析
  ProjectionList pl = Projections.projectionList()
    .add(Projections.rowCount()).add(Projections.avg("salary"))
    .add(Projections.sum("salary")).add(Projections.max("salary"))
    .add(Projections.min("salary"));

  Criteria cri5 = session.createCriteria(Employees.class);
  cri5.setProjection(pl);
  // System.out.println(((Object[])cri5.list().get(0))[1]);
  // System.out.println(((Object[])cri5.uniqueResult())[2]);

  ProjectionList pl2 = Projections.projectionList()
    .add(Projections.rowCount())
    .add(Property.forName("jobs").group());
  Criteria cri6 = session.createCriteria(Employees.class);
  cri6.setProjection(pl2);

  // 离线查询查询.相当于预处理
  DetachedCriteria dc = DetachedCriteria.forClass(Employees.class)
    .add(Restrictions.idEq(101))
    .add(Restrictions.eq("firstName", "Neena")).setComment("测试");
  // 执行查询
  Criteria cri7 = dc.getExecutableCriteria(session);

  // 离线条件预处理1
  // Subqueries 和Property都可以
  DetachedCriteria dc2 = DetachedCriteria.forClass(Employees.class)
    .setProjection(Projections.avg("salary"));

  // 执行查询.结合离线查询
  Criteria cri8 = session.createCriteria(Employees.class).add(
    Property.forName("salary").lt(dc2));

  // 离线条件预处理2
  DetachedCriteria dc3 = DetachedCriteria.forClass(Employees.class)
    .setProjection(Projections.avg("salary"));

  // 执行查询.结合离线查询
  Criteria cri9 = session.createCriteria(Employees.class).add(
    Subqueries.lt(100.23, dc3));

  System.out.println(cri9.list());

  

 }

 public void testproc() {
  Session session = HibernateSessionFactory.getSession();
  Connection conn = session.connection();
  CallableStatement cs;
  try {
   cs = conn.prepareCall("{call proc1()}");
   System.out.println(cs);
  } catch (SQLException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  }

 }

 public void testxml() {
  Session session = HibernateSessionFactory.getSession();
  Query query = session.getNamedQuery("byname").setString("name",
    "Steven");
  System.out.println(query.list());
 }

 /**
  * 原生sql
  */
 public void nativesql() {
  Session session = HibernateSessionFactory.getSession();
  // 新版本的写法
  Query q = session.createSQLQuery("select * from employees");
  // 老版本的写法：
  Query q2 = session.createSQLQuery("select {a.*} from employees {a}");

  // q没有进入持久层。如何将一个纯粹的sql查询结果进入持久层
  Query q3 = session.createSQLQuery("select * from employees").addEntity(
    Employees.class);
  // 精度处理
  Integer ii = (Integer) session
    .createSQLQuery("select count(*) as cnt from employees")
    .addScalar("cnt", Hibernate.INTEGER).setCacheable(true)
    .uniqueResult();
  System.out.println(ii);
 }

 /**
 集合过滤
  * 第一步： <filter-def name="f1"> <filter-param name="filterparams"
  * type="string"/> </filter-def> 第二部：在<class>里面加入：<filter name="f1"
  * condition=":filterparams=first_name"></filter> 集合过滤 在xml定义filter
  */
 public void filter() {
  // 得到查询结果是Steven的数据
  Session session = HibernateSessionFactory.getSession();
  Filter f = session.enableFilter("f1").setParameter("filterparams",
    "Steven");
  List list = session.createCriteria(Employees.class).list();
  System.out.println(list);

 }
 
 /**
  * 优化
  */
 public void queruyouhua(){
  Session session = HibernateSessionFactory.getSession();
  // 内联接法2：左外链接而且迫切
  /*
   * 使用HQL的左联接抓取left join fetch 调用setFetchMode(FetchMode.JOIN)
   */
  Users1 u = (Users1) session.createCriteria(Users1.class)
      .setFetchMode("permissions", FetchMode.JOIN)
      .add(Restrictions.idEq(2)).uniqueResult();
  System.out.println("改变抓取策略" + u);
  
  //iter
   //session.createQuery("").iterate();
  session.close();
  session = HibernateSessionFactory.getSession();
   //管理缓存
  //调用query的list() iterator() save() saveOrUpdate() update()
  //         load() get()获得对象。对象就在内部缓存
  //当flush()调用，对象和数据库同步。如果不希望同步发生。正在处理大数据对象。可以调用evict()
  //从一级缓存去掉这些对象的集合。
  
   ScrollableResults sr= session.createCriteria(Users1.class)
                                .scroll();   
   while(sr.next()){
    System.out.println(sr.get(0));//0就是存放的对象
    session.evict(sr.get(0));
   }
  
  
  session.close();
  session = HibernateSessionFactory.getSession();
   //管理二级缓存
  //CacheMode.NORMAL 读写
  //CacheMode.GET    读，尽在update的时候写
  //CacheMode.PUT    写缓存。不从二级缓存读
  //CacheMode.REFRESH 写不读
  
  SessionFactory sf= HibernateSessionFactory.getSessionFactory();
  Map cacheObject= sf.getStatistics()
                 .getSecondLevelCacheStatistics(CacheMode.NORMAL.toString())
                 .getEntries()
                 ;
  //此时会爆出java.lang.NullPointerException
  //说明没有配置支持二级缓存的配置。
  //<property name="hibernate.generate_statistics">true</property>
  //<property name="hibernate.cache.use_structured_entries">true</property>
  
   System.out.println(cacheObject);                 
  
 }

 public static void main(String[] args) {
  new SeniroDAO().queruyouhua();
 }