hibernate入门---Hibernate查询方式（for循环、构造器、对象数组等）【第三天，相当于总结整合】

Hibernate查询方式【内连接和外连接不在此篇】

本文讲述的是HQL以及各种情况输出对象的for循环以及构造器的例子，当然这是Hibernate结合一起完成的任务。技术上，离开一些方法，不掌握一些基本的方法，灵活使用，是会带来诸多不便的。

查询方式都在例子里的方法里，我把全部都写在了一个类里，基本思路：

类:Customer->CustomerManager->Demo

配置文件:hibernate.cfg.xml->Customer.hbm.xml

关系:

(我们不去考虑什么session啊之类的内部机制，单纯的从自己写的类和配置文件来进行初步理解，深入机制前面已有/也可查阅资料了解更多)

下面直接贴例子，自行体会（因为之前的文章基本总结过了，当然这个例子还是能够看出一些思想的）：

一、配置文件:(你没有看错，还是那个hibernate.cfg.xml的配置文件)

<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
    "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
<!-- 配置文件标签顺序property*,mapping*,(class-cache|collection-cache),event,listener* -->
    <session-factory>
      <!-- 设置访问mysql数据库的驱动描述 -->
      <property name="connection.driver_class">com.mysql.jdbc.Driver</property>
      <!-- 设置数据库的url -->
      <property name="connection.url">jdbc:mysql://127.0.0.1:3306/test</property>
      <!-- 指定登录数据库用户账户 -->
      <property name="connection.username">root</property>
      <!-- 指定登录数据库用户密码 -->
      <property name="connection.password">123456</property>

      <!-- 设置访问数据库的方言，提高数据库访问性能 -->
      <property name="dialect">org.hibernate.dialect.MySQLDialect</property>
      <!-- 设置ddl -->
      <!-- <property name="hbm2ddl.auto">auto</property> -->
       <!-- 配置控制台视图，显示查询内容 -->
       <property name="show_sql">true</property>
       <!-- 下面是多表映射 -->
      <!-- 指出映射文件 -->
      <mapping resource="resource/Customer.hbm.xml"/>
    </session-factory>
</hibernate-configuration>

二、还是配置文件【Customer.hbm.xml，数据库和实体类映射】：

<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE hibernate-mapping PUBLIC
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

<hibernate-mapping package="bean" auto-import="false">
   <!-- POJO类映射表及某表的关系-->
   <class name="bean.Customer" table="customers" catalog="test">
       <id name="customerID" type="java.lang.String">
           <column name="customerID" length="8"/>
           <generator class="assigned"></generator>
       </id>
       <!-- 映射表中name字段 -->
       <property name="name" type="java.lang.String">
          <column name="name" length="40"/>
       </property>
       <!-- 映射表中phone字段 -->
       <property name="phone" type="java.lang.String">
          <column name="phone" length="16"/>
       </property>
   </class>
</hibernate-mapping>

三、映射数据库的类：

package bean;

public class Customer {
    private String customerID,name,phone;

    public String getCustomerID() {
        return customerID;
    }

    public void setCustomerID(String customerID) {
        this.customerID = customerID;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getPhone() {
        return phone;
    }

    public void setPhone(String phone) {
        this.phone = phone;
    }
}

四、会话工厂类：

package hibernate.factory;

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

public class HibernateSessionFactory {
    private static String configfile = "resource/hibernate.cfg.xml";
    /**ThreadLocal是一个本地线程**/
    private static final ThreadLocal<Session> threadLocal = new ThreadLocal<Session>();
    private static Configuration config;
    private static SessionFactory sessionFactory;
    /**读取配置文件，创建一个工厂会话，这段代码为静态块，编译后已经运行**/
    static{
        try {
            config = new Configuration().configure(configfile);
            sessionFactory = config.buildSessionFactory();
        } catch (Exception e) {
            // TODO: handle exception
            e.printStackTrace();
        }
    }
    /**通过会话工厂打开会话，就可以访问数据库了**/
    public static Session getSession(){
        Session session = (Session)threadLocal.get();
        if (session==null||!session.isOpen()) {
            if (sessionFactory==null) {
                rebuildSessionFactory();
            }
            session = (sessionFactory!=null)?sessionFactory.openSession():null;
        }
        return session;
    }
    /**重新创建一个会话工厂**/
    public static void rebuildSessionFactory() {
        try {
            config.configure(configfile);
            sessionFactory = config.buildSessionFactory();
        } catch (Exception e) {
            // TODO: handle exception
            e.printStackTrace();
        }
    }
    /**关闭与数据库的会话**/
    public static void closeSession() {
        Session session = (Session)threadLocal.get();
        threadLocal.set(null);
        if (session!=null) {
            session.close();
        }
    }
}

五、查询Customer的类：

package bean.dao;

import java.util.List;

import hibernate.factory.HibernateSessionFactory;

import org.hibernate.Session;
import org.hibernate.query.Query;

import bean.Customer;

//针对各类查询的单表查询
public class CustomerManager {
    //各类查询方式
    /**
     * @see 限制查询结果记录数与起始记录
     * @return list
     */
    @SuppressWarnings("rawtypes")
    public List selLimitCustomerScore(){
        Session session = HibernateSessionFactory.getSession();
        Query query = session.createQuery("from bean.Customer");
        //即从第三条记录开始查询，并且只查询两条记录
        query.setFirstResult(2);
        query.setMaxResults(2);
        List list = query.list();
        return list;
    }
    /**
     * @see 通过条件查询，起别名
     * @return list
     */
    @SuppressWarnings("rawtypes")
    public List selConditionCustomer(){
        Session session = HibernateSessionFactory.getSession();
        Query query = session.createQuery("from bean.Customer cus where cus.name=‘we‘");
        List list = query.list();
        return list;
    }
    /**
     * @see 取表中部分列，单一属性查询，还是返回一个集合，不过集合中存储的不是表的实例，而是实例的对象<br/>在使用时:<br/>
     for(int i=0;i&lt;list.size;i++){
     String name = (String)list.get(i);
     System.out.println(name);
     }
     * @return list
     *
     */
    public List selOneCustomer(){
        Session session = HibernateSessionFactory.getSession();
        return session.createQuery("from bean.Customer cus where cus.name=‘we‘").list();
    }
    /**
     * @see 多个属性的查询，使用对象数组
     */
    @SuppressWarnings("null")
    public List selMoreCustomer() {
        Session session = HibernateSessionFactory.getSession();
        List customers = session.createQuery("select name,phone from bean.Customer").list();
        return customers;
    }
    /**
     * @see 多个属性查询，使用集合装“部分”列。
     * @return list
     */
    public List selListCustomer() {
        Session session = HibernateSessionFactory.getSession();
        List list = session.createQuery("select new list(cus.name,cus.phone) from bean.Customer cus").list();
        return list;
    }
    /**
     * @see 使用map集合装部分列
     * @return map
     *
     */
    public List selMapCustomer() {
        Session session = HibernateSessionFactory.getSession();
        List list = session.createQuery("select new map(cus.name,cus.phone) from bean.Customer cus").list();
        return list;
    }
}

六、测试类：

package demo;

import java.util.Iterator;
import java.util.List;
import java.util.Map;

import bean.Customer;
import bean.dao.CustomerManager;

//根据以下查询，基本上变化的是查询的for里面转化上有区别，而与之关联的管理查询类，变化上就是Query的对象设置以及HQL语句的变化，然后查询的时候根据需要使用for。
public class Demo {
    @SuppressWarnings("unchecked")
    public static void main(String[] args) {
        CustomerManager manager = new CustomerManager();
        //测试条件查询的方法，同时理解foreach的用法
        List<Customer> lists = manager.selConditionCustomer();
        System.out.println("---------分界线，selConditionCustomer()以下是条件查询--------");
        for (Customer customer : lists) {
            System.out.println(customer.getName()+customer.getPhone());
        }
        System.out.println("---------分界线，selLimitCustomerScore()以下是测试限制查询结果与起始记录数--------");
        //测试限制查询结果记录数与起始记录
        List<Customer> customers = manager.selLimitCustomerScore();
        for (Customer customer : customers) {
            System.err.println(customer.getName()+customer.getPhone());
        }
        System.out.println("--------------分界线，selListCustomer()集合装部分列--------------------");
        List lists2 = manager.selListCustomer();//集合部装，没有使用到Customer
        for (int i = 0; i < lists2.size(); i++) {
            List temp = (List)lists2.get(i);
            System.out.println(temp.get(0)+"  "+temp.get(1));//0是索引，集合部装，根据索引，打印该索引对应的那一列全部记录
        }
        System.out.println("--------------分界线，selMapCustomer()集合部装列--------------------");
        List list =manager.selMapCustomer();
        for (int i = 0; i < list.size(); i++) {
            Map tmp = (Map)list.get(i);
            System.out.println(tmp.get("0")+" "+tmp.get("1"));//0是key，1是key，2也是key，以此类推，其实与java对象查询相关，HQL里：new map(cus.name,cus.phone)，表示只查询key为0和1两个值
        }
        System.out.println("--------------分界线，selOneCustomer()，查询单个属性--------------------");
        List cnames = manager.selOneCustomer();
        for(int i=0;i<cnames.size();i++){
            Customer customer = (Customer)cnames.get(i);
            System.out.println(customer.getName());
        }
        System.out.println("--------------分界线，selMoreCustomer()多个属性的查询，使用对象数组--------------------");
        List list2 = manager.selMoreCustomer();
        for (int i = 0; i < list2.size(); i++) {
            Object[] obj = (Object[])list2.get(i);//多个属性的查询，使用对象数组，指这里开始
            System.out.println(obj[0]+","+obj[1]);
        }
    }
}

记录这些例子，更好的是为后续纠错等能够快速定位，也同时使自己记忆深刻。理解。

既然闲着，那就“闲着”。

原文地址：https://www.cnblogs.com/ciscolee/p/10954535.html

时间： 2024-10-15 03:31:01

hibernate入门---Hibernate查询方式（for循环、构造器、对象数组等）【第三天，相当于总结整合】的相关文章

Hibernate系列（四）：Hibernate两种查询方式：HQL和Criteria

Hibernate主要是提供与数据库之间交互的一个框架,想要用面向对象的语言操作关系型数据库,有如下两种操作方式: HQL语句:面向对象的查询语言,对象名区分大小写.而且不同于SQL的是这里查询的是对象,而不是表,并且支持多态.hql主要通过Query操作 Criteria类:是一种面向对象的查询,主要查询条件. 一.HQL语句: 比如我们要根据name属性查询一条记录(对象): static void query(String name){ Session s = null; try{ s =

Hibernate 提供的查询方式

OID查询方式(o指的是object) 通过get()和load()方法加载指定OID的对象 save()添加 update()更新 delete()删除 HQL查询方式(面向对象的查询语言) 实体更新和实体删除都是调用的executeUpdate()方法. 通过QUERy接口使用HQL语言进行查询 QBC查询方式 通过Criteria等接口和类进行查询: 本地SQl查询方式 使用原生SQL语言进行查询 对象导航查询方式 通过已经加载的对象,导航到其关联对象

Hibernate 查询方式(HQL/QBC/QBE)汇总

作为老牌的 ORM 框架,Hibernate 在推动数据库持久化层所做出的贡献有目共睹. 它所提供的数据查询方式也越来越丰富,从 SQL 到自创的 HQL,再到面向对象的标准化查询. 虽然查询方式有点眼花缭乱,配置使用起来也稍微有点复杂. 但是丝毫掩盖不了它迷人的地方,本篇博客试着汇总 Hibernate 所有的查询方式. 萝卜青菜各有所爱,工作中可以根据自己的喜好选择其中的几种进行编程. 1. HQL 方式,参数使用问号占位(4.1 版本中已被废弃) public List<UserPO>

Hibernate查询方式 一

Hibernate查询方式 说到hibernate的查询方式,我们自然而然就想到了它--hql,hibernate query language.hql是使用hibernate框架的变成配朋友们使用最多的一种方式,它以自身的独特的优势:屏蔽数据库,书写灵活的优点,备受大家的青睐.但是Hibernate不仅给我们提供了这一种查询方式,这时候悠然要说来,是不只一种,还有sql,对,确实还有sql,但是还有一种,就是Criteria 查询.那么今天,我们就来聊一聊hibernate的几种查询方式. H

hibernate查询方式和查询策略

1.Hibernate框架的查询方式    1) 唯一标识OID的检索方式        * session.get(对象.class,OID)    2) 对象的导航的方式        3) HQL的检索方式        * Hibernate Query Language    -- Hibernate的查询语言        4) QBC的检索方式        * Query By Criteria    -- 条件查询        5) SQL检索方式(了解)        *

Hibernate入门（四）—— 查询

一.Hibernate查询 1.Hibernate检索(查询)方式的分类 OID检索 :根据主键查询,get/load 对象导航检索 :通过一个对象获得其关联对象.[重点] Category category = session.get(Category.class, 1);Set<Product> products = category.getProducts(); HQL检索 :HQL,Hibernate Query Language(Hibernate查询语言,语法与SQL类似,但是又是

Hibernate六 HQL查询

HQL查询一 介绍1.HQL:Hibernate Query Language,是一种完全面向对象的查询语言.使用Hibernate有多重查询方式可供选择:hibernate的HQL查询,也可以使用条件查询,甚至使用原生的SQL查询语句.Hibernate还提供了一种数据过滤功能,这些都用于删选目标数据.2.查询步骤:(1)获取Hibernate Session对象(2)编写HQL语句(3)以HQL语句为参数,调用Session的createQuery()方法创建查询对象(4)如果HQL语句包含

Hibernate(九)HQL查询

一.Hibernate提供的查询方式 OID查询方式:主键查询.通过get()或者load()方法加载指定OID的对象查询结果为一个 HQL查询方式:通过Query接口使用HQL语言进行查询 QBC查询方式:通过Criteria等接口和类进行是查询 本地SQL查询方式:使用原生的SQL语言进行查询 对象导航查询方式:通过已经加载的对象,导航到其关联对象 其中HQL和QBC是Hibernater提供的专业的查询方式 HQL查询方式为官方推荐的标准查询方式 二.HQL查询简述 HQL:Hiberna

Hibernate入门4

HIbernate的导航查询: 适用场景:当一张A表关联到另一张B表的多条记录,存在一对多的关系(或者多对多),那么查询A表的记录时,就可以将A表某条记录关联的B表的所有记录查询出来,这种方式,就叫做Hibernate的导航查询(如:一张客户表,一张联系人表,客户表存在一条记录是百度公司的,而在联系人表中对应着多条联系人的记录,而在定义实体类的时候,客户实体类中就进行绑定联系人类用了一个Set进行绑定,因此在查询某个客户的时候,对应的此客户下的联系人Set集合中的数据也就一并查找出来了,这种查询