hibernate 学习 并且与spring 整合

 

hibernate  的helloWord

github地址

先添hibernate加依赖包，如果使用idea 先添加Hibernate support 插件

链接

 

hibernate的默认主配置文件生成

hibernate配置文件

<hibernate-configuration>
  <session-factory>
    <property name="connection.driver_class">com.mysql.jdbc.Driver</property>
    <property name="connection.url">jdbc:mysql://127.0.0.1:3306/hib</property>
    <property name="connection.username">root</property>
    <property name="connection.password">1234</property>
    <!-- 配置 hibernate 的基本信息 -->
    <!-- hibernate 所使用的数据库方言 -->
    <property name="dialect">org.hibernate.dialect.MySQLInnoDBDialect</property>
    <!-- 执行操作时是否在控制台打印 SQL -->
    <property name="show_sql">true</property>

    <!-- 是否对 SQL 进行格式化 -->
    <property name="format_sql">true</property>

    <!-- 指定自动生成数据表的策略 -->
    <property name="hbm2ddl.auto">update</property>
  </session-factory>
</hibernate-configuration>

 写一个实体类，然后用idea关联mysql的hib数据库

进一步：我们知道hibernate可以在映射文件中配置然后自动生成数据表的字段

但是idea 可以通过我们写的数据库表，生成对应的实体和映射文件：

view -tool windows -persistence点击如下配置

右键，

三个地方打钩

（1）配置文件和（2）实体类 和（3）映射文件都自己创建好了

（4）下面就可以测试了

//1. 创建一个 SessionFactory 对象
		SessionFactory sessionFactory = null;
		
		//1). 创建 Configuration 对象: 对应 hibernate 的基本配置信息和 对象关系映射信息
		Configuration configuration = new Configuration().configure();
		
		//2).4.0 之前这样创建
 		sessionFactory = configuration.buildSessionFactory();
		
		// 创建一个 ServiceRegistry 对象: hibernate 4.x 新添加的对象
		//hibernate 的任何配置和服务都需要在该对象中注册后才能有效.
		//ServiceRegistry serviceRegistry = 
			//new ServiceRegistryBuilder().applySettings(configuration.getProperties())
				                          //  .buildServiceRegistry();
		
		//3).
		sessionFactory = configuration.buildSessionFactory(serviceRegistry);
		
		//2. 创建一个 Session 对象
		Session session = sessionFactory.openSession();
		
		//3. 开启事务
		Transaction transaction = session.beginTransaction();
		
		//4. 执行保存操作
		News news = new News("Java12345", "ATGUIGU", new Date(new java.util.Date().getTime()));
		session.save(news);
		
		//5. 提交事务 
		transaction.commit();
		
		//6. 关闭 Session
		session.close();
		
		//7. 关闭 SessionFactory 对象
		sessionFactory.close();

完成了六六

------------------------------------------------------------------------------------------------------------------------------

源码解析：

SessionFactory

•针对单个数据库映射关系经过编译后的内存镜像，是线程安全的。

•SessionFactory 对象一旦构造完毕，即被赋予特定的配置信息

•SessionFactory是生成Session的工厂

•构造 SessionFactory 很消耗资源，一般情况下一个应用中只初始化一个 SessionFactory 对象。

Session

•Session 是应用程序与数据库之间交互操作的一个单线程对象，是 Hibernate 运作的中心，所有持久化对象必须在 session 的管理下才可以进行持久化操作。此对象的生命周期很短。Session 对象有一个一级缓存，显式执行 flush 之前，所有的持久层操作的数据都缓存在 session 对象处。相当于 JDBC 中的 Connection。

Transaction(事务)

代表一次原子操作，它具有数据库事务的概念。所有持久层都应该在事务管理下进行，即使是只读操作。

Transaction tx = session.beginTransaction();

Session 缓存

•在 Session 接口的实现中包含一系列的 Java 集合, 这些 Java 集合构成了 Session 缓存. 只要 Session 实例没有结束生命周期, 且没有清理缓存，则存放在它缓存中的对象也不会结束生命周期

   flush() 在 Transaction 的 commit() 方法中: 先调用 session 的 flush 方法, 再提交事务
   方法会可能会发送 SQL 语句, 但不会提交事务. 

 clear(): 清理缓存

refresh(): 会强制发送 SELECT 语句, 以使 Session 缓存中对象的状态和数据表中对应的记录保持一致!

hibernate 默认的隔离级别为1读未提交

clear()清除缓存

session 的方法

Session 的 save() 方法使一个临时对象转变为持久化对象。

把 News 对象加入到 Session 缓存中, 使它进入持久化状态

选用映射文件指定的标识符生成器, 为持久化对象分配唯一的 OID. 在 使用代理主键的情况下, setId() 方法为 News 对象设置 OID 使无效的.

临时对象：不再session 缓存中，oid为空（对象标识符）

游离对象：oid不为空，不在session缓存中

持久对象：oid 不为空，在session缓存中

•Session 的 update() 方法使一个游离对象转变为持久化对象, 并且计划执行一条 update 语句.

•Session 的 saveOrUpdate() 方法同时包含了 save() 与 update() 方法的功能

•Session 的 delete() 方法既可以删除一个游离对象, 也可以删除一个持久化对象.

通过 Hibernate session 的dowork()调用存储过程或者批量操作

 

 session.doWork(new Work() {//方法一利用JDBC Statement接口来处理批量增加的情况
            @Override
            public void execute(Connection connection) throws SQLException {
                connection.setAutoCommit(false);
                Statement statement = connection.createStatement();
                statement.addBatch("insert into GG_EMPLOYEE(ID,name) VALUES(55,'xiaomoa')");
                statement.addBatch("insert into GG_EMPLOYEE(ID,name) VALUES(66,'xioatian')");
                statement.executeBatch();
            }
        });

//方法二 PrepareStatement来处理批量增加
connection.setAutoCommit(false);
                PreparedStatement pst = connection.prepareStatement("insert into GG_EMPLOYEE(id,NAME) values(?,?)");
                pst.setInt(1,67);
                pst.setString(2,"oooooooo");
                pst.addBatch();
                pst.setInt(1,68);
                pst.setString(2,"ppppp");
                pst.addBatch();
                pst.executeBatch();

•Session 的 doWork(Work) 方法用于执行 Work 对象指定的操作, 即调用 Work 对象的 execute() 方法. Session 会把当前使用的数据库连接传递给 execute() 方法.

hibernate可以配置c3p0数据源的属性

•hibernate.jdbc.fetch_size：实质是调用 Statement.setFetchSize() 方法设定 JDBC 的 Statement 读取数据的时候每次从数据库中取出的记录条数。

hbm.xml映射文件

class属性

dynamic-update: 若设置为 true, 表示当更新一个对象时, 会动态生成 update 语句, update 语句中仅包含所有取值需要更新的字段. 默认值为 false。

id 属性 generator 的主键生成策略 mysql 的identify,oracle 的sequence（支持序列）

•native 标识符生成器依据底层数据库对自动生成标识符的支持能力, 来选择使用 identity, sequence 或 hilo 标识符生成器.

•适用范围:

–由于 native 能根据底层数据库系统的类型, 自动选择合适的标识符生成器, 因此很适合于跨数据库平台开发

–OID 必须为 long, int 或 short 类型, 如果把 OID 定义为 byte 类型, 在运行时会抛出异常

Java 大对象类型的 Hiberante 映射

MySQL中tinytext、text、mediumtext和longtext详解

hibnernate一对多关联关系

比如多个订单对应多个客户多对一的配置

这里是多对一的映射子啊order的hbm.xml配置如下：

对应orders表

比如一个客户对应多个订单一对多的配置

cascade 属性对表进行级联操作。

多对多的映射关系

映射继承关系：

 

•Hibernate支持三种继承映射策略：

–使用 subclass 进行映射：将域模型中的每一个实体对象映射到一个独立的表中，也就是说不用在关系数据模型中考虑域模型中的继承关系和多态。

–使用 joined-subclass 进行映射： 对于继承关系中的子类使用同一个表，这就需要在数据库表中增加额外的区分子类类型的字段。

采用 union-subclass 元素的继承映射

•采用 union-subclass 元素可以实现将每一个实体对象映射到一个独立的表中。

hibernate的检索策略

(1)一对多，多对多

多对一，一对一

•<set> 元素有一个 batch-size 属性, 用来为延迟检索策略或立即检索策略设定批量检索的数量. 批量检索能减少 SELECT 语句的数目, 提高延迟检索或立即检索的运行性能.

Hibernate 检索方式

–HQL 检索方式: 使用面向对象的 HQL 查询语言

–QBC 检索方式: 使用 QBC(Query By Criteria) API 来检索对象. 这种 API 封装了基于字符串形式的查询语句, 提供了更加面向对象的查询接口.

–本地 SQL 检索方式: 使用本地数据库的 SQL 查询语句

hql功能
–在查询语句中设定各种查询条件

–支持投影查询, 即仅检索出对象的部分属性

–支持分页查询

–支持连接查询

–支持分组查询, 允许使用 HAVING 和 GROUP BY 关键字

–提供内置聚集函数, 如 sum(), min() 和 max()

–支持子查询

–支持动态绑定参数

能够调用 用户定义的 SQL 函数或标准的 SQL 函数

HQL 检索方式
通过 Session 的 createQuery() 方法创建一个 Query 对象, 它包括一个 HQL 查询语句. HQL 查询语句中可以包含命名参数
动态绑定参数
调用 Query 相关方法执行查询语句. 


按参数名字绑定: 在 HQL 查询语句中定义命名参数, 命名参数以 “:” 开头.
按参数位置绑定: 在 HQL 查询语句中用 “?” 来定义参数位置.

相关方法:
setEntity(): 把参数与一个持久化类绑定
setParameter(): 绑定任意类型的参数. 该方法的第三个参数显式指定 Hibernate 映射类型

demo

命名查询 在映射文件中进行和class 同级
 <query name="salaryEmps"><![CDATA[ FROM Employee e where e.salary=? ]]></query>

使用情况
 Query query = session.getNamedQuery("salaryEmps");//命名查询
        query.setFloat(0,66f);
        List list = query.list();

hql投影查询: 查询结果仅包含实体的部分属性. 通过 SELECT 关键字实现.
String hql="select e.name ,e.email from Employee e";
        Query query =session.createQuery(hql);
        List<Object[]> list = query.list();
       for(Object o[]:list){
           System.out.println(Arrays.asList(o));
       }
Hibernate: 
    select
        employee0_.NAME as col_0_0_,
        employee0_.EMAIL as col_1_0_ 
    from
        GG_EMPLOYEE employee0_
[cc, 21]
[cc, 21]
[cc, 21]


操作数组很是不爽
所以直接操作Employee对象
String hql="select new Employee(e.name ,e.email) from Employee e";
        Query query =session.createQuery(hql);
        List<Employee> list = query.list();
       for(Employee employee:list){
           System.out.println(employee.getName()+","+employee.getEmail());
       }

但是必须有对应的构造器：
  public Employee(String name, String email) {
        this.name = name;
        this.email = email;
    }
        

报表查询：HQL 利用 GROUP BY 关键字对数据分组, 用 HAVING 关键字对分组数据设定约束条件.

String hql="select min(e.salary) from Employee e group by email";

左（外）连接
 String hql="from Department d left join  d.emps";
内连接
 String hql="from Department d inner join  d.emps";

迫切左（外）连接
 String hql="from Department d left join  d.emps";
迫切内连接
 String hql="from Department d inner join  d.emps";

•迫切左外连接:

–LEFT JOIN FETCH 关键字表示迫切左外连接检索策略.

–list() 方法返回的集合中存放实体对象的引用, 每个 Department 对象关联的 Employee  集合都被初始化, 存放所有关联的 Employee 的实体对象.

–查询结果中可能会包含重复元素, 可以通过一个 HashSet 来过滤重复元素

•左外连接:

–LEFT JOIN 关键字表示左外连接查询.

–list() 方法返回的集合中存放的是对象数组类型

–根据配置文件来决定 Employee 集合的检索策略.

–如果希望 list() 方法返回的集合中仅包含 Department 对象, 可以在HQL 查询语句中使用 SELECT 关键字

 

QBC 查询就是通过使用 Hibernate 提供的 Query By Criteria API 来查询对象，这种 API 封装了 SQL 语句的动态拼装，对查询提供了更加面向对象的功能接口

       //1. 创建一个 Criteria 对象
        Criteria criteria = session.createCriteria(Employee.class);
    
        //2. 添加查询条件: 在 QBC 中查询条件使用 Criterion 来表示
        //Criterion 可以通过 Restrictions 的静态方法得到
        criteria.add(Restrictions.eq("email", "21"));
        criteria.add(Restrictions.gt("salary", 55f));
        //3. 执行查询
        Employee employee = (Employee) criteria.uniqueResult();
        System.out.println(employee);

-------------------------------------------
	//1. AND: 使用 Conjunction 表示
		//Conjunction 本身就是一个 Criterion 对象
		//且其中还可以添加 Criterion 对象
		Conjunction conjunction = Restrictions.conjunction();
		conjunction.add(Restrictions.like("name", "a", MatchMode.ANYWHERE));
		Department dept = new Department();
		dept.setId(80);
		conjunction.add(Restrictions.eq("dept", dept));
		System.out.println(conjunction); 
		
		//2. OR
		Disjunction disjunction = Restrictions.disjunction();
		disjunction.add(Restrictions.ge("salary", 6000F));
		disjunction.add(Restrictions.isNull("email"));
		
		criteria.add(disjunction);
		criteria.add(conjunction);
		
		criteria.list();
	}
---------------------------------------
Criteria criteria = session.createCriteria(Employee.class);
		
		//统计查询: 使用 Projection 来表示: 可以由 Projections 的静态方法得到
		criteria.setProjection(Projections.max("salary"));

------------------------------------------------
	Criteria criteria = session.createCriteria(Employee.class);
		
		//1. 添加排序
		criteria.addOrder(Order.asc("salary"));
		criteria.addOrder(Order.desc("email"));
		
		//2. 添加翻页方法
		int pageSize = 5;
		int pageNo = 3;
		criteria.setFirstResult((pageNo - 1) * pageSize)
		        .setMaxResults(pageSize)
		        .list();

 

本地SQL查询来完善HQL不能涵盖所有的查询特性
本地sql创建createSQLQuery("")
String sql="select name,email from GG_EMPLOYEE";
        SQLQuery query = session.createSQLQuery(sql);
        List<Object[]> list = query.list();
        for(Object[] employee:list){
            System.out.println(Arrays.asList(employee[0]+","+employee[1]));//
        }

注意hql语句也可以进行删除，修改操作
 String hql="delete  from Department e where e.id=?";
        session.createQuery(hql).setInteger(0,5).executeUpdate();

 Hibernate 缓存

•Hibernate中提供了两个级别的缓存

–第一级别的缓存是 Session 级别的缓存，它是属于事务范围的缓存。这一级别的缓存由 hibernate 管理的,默认是开启的

–第二级别的缓存是 SessionFactory 级别的缓存，它是属于进程范围的缓存.

demo:

 String hql="select new Employee(e.name ,e.email) from Employee e";
        session.createQuery(hql).list();
        session.close();
        session= sessionFactory.openSession();
        session.createQuery(hql).list();
        session.close();
//这里会发送两条select语句 因为session 的不同一个session

适合放入二级缓存中的数据:
很少被修改
不是很重要的数据, 允许出现偶尔的并发问题
不适合放入二级缓存中的数据:
经常被修改
财务数据, 绝对不允许出现并发问题
与其他应用程序共享的数据

二级缓存是可配置的的插件,所以我们可以配置二级缓存

步骤1：依赖
 <dependency>
      <groupId>org.hibernate</groupId>
      <artifactId>hibernate-core</artifactId>
      <version>3.6.10.Final</version>
    </dependency>
    <dependency>
      <groupId>org.hibernate</groupId>
      <artifactId>hibernate-ehcache</artifactId>
      <version>3.6.7.Final</version>
    </dependency>

步骤2：config配置文件
<property name="cache.use_second_level_cache">true</property>
    <!-- 配置使用的二级缓存的产品 -->
    <property name="hibernate.cache.provider_class">org.hibernate.cache.EhCacheProvider</property>

  <!--<mapping resource="com/ecpss/Demo/joined/subclass/Person.hbm.xml"></mapping>-->
<!--配置那个类使用二级缓存-->
    <class-cache class="com.ecpss.Demo.oracle.entities.Employee" usage="read-write"></class-cache>

步骤三：加ehcache.xml到类路径下

实际上也可以在 .hbm.xml 文件中配置对哪些类使用二级缓存, 及二级缓存的策略是什么. 
<class name="com.ecpss.Demo.oracle.entities.Department" table="GG_DEPARTMENT">
        <cache usage="read-write"></cache>


 集合级别的二级缓存的配置

I. 配置对集合使用二级缓存

<collection-cache usage="read-write" collection="com.atguigu.hibernate.entities.Department.emps"/>

也可以在 .hbm.xml 文件中进行配置

<set name="emps" table="GG_EMPLOYEE" inverse="true" lazy="true">
	<cache usage="read-write"/>
    <key>
        <column name="DEPT_ID" />
    </key>
    <one-to-many class="com.atguigu.hibernate.entities.Employee" />
</set>

II. 注意: 还需要配置集合中的元素对应的持久化类也使用二级缓存! 否则将会多出 n 条 SQL 语句. 


查询缓存: 默认情况下, 设置的缓存对 HQL 及 QBC 查询时无效的, 但可以通过以下方式使其是有效的

I.  在 hibernate 配置文件中声明开启查询缓存

<property name="cache.use_query_cache">true</property>

II. 调用 Query 或 Criteria 的 setCacheable(true) 方法

Session 对象的本地线程绑定

<!--配置管理session的方式-->
    <property name="current_session_context_class">thread</property>

public class HibernateUtils {
    private HibernateUtils(){}
    public Session getSession(){
        return getSessionFactory().getCurrentSession();
    }

hibernate常见问题：解决

懒加载异常

LazyInitializationException session关闭了 ，对象却没有加载出来。

代理对象之前已经关闭了 Session。

    这个异常出现的原因主要是使用懒加载机制加载数据时，hibernate在从数据库中调数据的时候是不会把关联的对象查出来的，而是保存一个获取值得方法，在你使用 getXXX()调用的时候，hiberante会利用这个保存的方法去从数据库中取数据。而往往我们在jsp页面中使用getXXX()准备展示数据的时候，而此时session已关闭，所以就会出现异常

解决方案 链接地址

比如 执行 get 方法: 会立即加载对象. 
        执行 load 方法, 若不适用该对象, 则不会立即执行查询操作, 而返回一个代理对象

  Transaction transaction = session.beginTransaction();
        NewsEntity newsEntity = (NewsEntity) session.load(NewsEntity.class, 1);//不会发送

延迟加载 用的时候才会加载，不用的时候不会加载
System.out.println(newsEntity);//这个时候才会发送select 语句

get 是 立即检索, load 是延迟检索.

与spring进行整合

代码分享在github上了地址

1  主要的配置spring的配置文件

<context:component-scan base-package="com.ecpsss"></context:component-scan>
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="user" value="root"></property>
        <property name="password" value="1234"></property>
        <property name="driverClass" value="com.mysql.jdbc.Driver"></property>
        <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/abcd"></property>

        <property name="initialPoolSize" value="5"></property>
        <property name="maxPoolSize" value="10"></property>
    </bean>

    <bean id="sessionFactory" class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">
        <property name="dataSource" ref="dataSource"></property>
        <property name="configLocation" value="classpath:hibernate.cfg.xml"></property>
        <property name="mappingLocations" value="classpath:mappings/*.hbm.xml"></property>
    </bean>

    <!-- 用注解来实现事物管理 -->
    <bean id="txManager" class="org.springframework.orm.hibernate4.HibernateTransactionManager">
        <property name="sessionFactory" ref="sessionFactory"/>
    </bean>
    <tx:annotation-driven transaction-manager="txManager"/>

2  hibernate的配置文件

<session-factory>
    <!-- 方言 -->
    <property name="hibernate.dialect">org.hibernate.dialect.MySQL5InnoDBDialect</property>

    <!-- 是否显示及格式化 SQL -->
    <property name="hibernate.show_sql">true</property>
    <property name="hibernate.format_sql">true</property>

    <!-- 生成数据表的策略 -->
    <property name="hibernate.hbm2ddl.auto">update</property>

注意：用哪个版本的依赖就用那个版本的数据源 和事务管理器

如果使用getCurrentSession需要在当前类上面加上事务如图：

此外HibernateTemplate管理sessionFactory可以进行数据操作

 <bean id="hibernateTemplate" class="org.springframework.orm.hibernate4.HibernateTemplate">
            <property name="sessionFactory" ref="sessionFactory"></property>
  </bean>

最后配置依赖

  <dependency>
      <!-- spring核心工具包 -->
      <groupId>org.springframework</groupId>
      <artifactId>spring-core</artifactId>
      <version>4.3.7.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>4.3.7.RELEASE</version>
    </dependency>
    <dependency>
      <!-- springIOC基础实现 -->
      <groupId>org.springframework</groupId>
      <artifactId>spring-beans</artifactId>
      <version>4.3.7.RELEASE</version>
    </dependency>
    <!-- spring web相关核心 -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-web</artifactId>
      <version>4.3.7.RELEASE</version>
    </dependency>
    <dependency>		<!-- aop 面向切面编程 -->
      <groupId>org.springframework</groupId>
      <artifactId>spring-aop</artifactId>
      <version>4.3.7.RELEASE</version>
    </dependency>
    <dependency>		<!-- 事务 -->
      <groupId>org.springframework</groupId>
      <artifactId>spring-tx</artifactId>
      <version>4.3.7.RELEASE</version>
    </dependency>
    <dependency>		<!-- orm 整合第三方orm实现 -->
      <groupId>org.springframework</groupId>
      <artifactId>spring-orm</artifactId>
      <version>4.3.7.RELEASE</version>
    </dependency>
    <!-- 对JDBC 的简单封装 -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-jdbc</artifactId>
      <version>4.3.7.RELEASE</version>
    </dependency>
    <!-- spring 表达式语言-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-expression</artifactId>
      <version>4.3.7.RELEASE</version>
    </dependency>
    <!-- 测试框架-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-test</artifactId>
      <version>4.3.7.RELEASE</version>
    </dependency>

    <!-- hibernate相关 start-->
    <dependency>
      <groupId>org.hibernate</groupId>
      <artifactId>hibernate-core</artifactId>
      <version>4.3.8.Final</version>
    </dependency>
    <dependency>
      <groupId>org.hibernate</groupId>
      <artifactId>hibernate-entitymanager</artifactId>
      <version>4.3.8.Final</version>
    </dependency>
    <dependency>
      <groupId>org.hibernate</groupId>
      <artifactId>hibernate-ehcache</artifactId>
      <version>4.3.8.Final</version>
    </dependency>

    <!-- hibernate相关 end -->

    <!-- 数据库相关 -->
    <!-- 阿里druid连接池 -->
    <!--<dependency>-->
      <!--<groupId>com.alibaba</groupId>-->
      <!--<artifactId>druid</artifactId>-->
      <!--<version>1.0.18</version>-->
    <!--</dependency>-->
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>5.1.39</version>
    </dependency>
    <!-- 数据库相关 -->
    <!-- json相关 -->
    <!-- 日志相关 statr -->
    <dependency>
      <groupId>log4j</groupId>
      <artifactId>log4j</artifactId>
      <version>1.2.17</version>
    </dependency>
    <dependency>
      <groupId>org.apache.logging.log4j</groupId>
      <artifactId>log4j-api</artifactId>
      <version>2.6</version>
    </dependency>
    <dependency>
      <groupId>org.apache.logging.log4j</groupId>
      <artifactId>log4j-core</artifactId>
      <version>2.6</version>
    </dependency>

    <dependency>
      <groupId>com.mchange</groupId>
      <artifactId>c3p0</artifactId>
      <version>0.9.2.1</version>
    </dependency>

 hql，即Hibernate Query  Language。它与我们熟知的sql很类似，它最大的特点就是对查询进行了面向对象的封装，下面会在具体例子中说明。

sql查询的是数据库中的表或字段，而hql是面向对象的，具有继承、多态、关联等特性，它的是对象。

1，创建Configuration对象

其中new Configuration()方法主要是初始化Configuration对象中的一些成员变量。

 

 

ORM的实现原理
使用Hibernate的开发人员都知道，在使用它实现ORM功能的时候，主要的文件有：映射类（*.java）、映射文件（*.hbm.xml）以及数据库配置文件（*.properties或*.cfg.xml），它们各自的作用如下。

⑴  映射类：它的作用是描述数据库表的结构，表中的字段在类中被描述成属性，将来就可以实现把表中的记录映射成为该类的对象。

⑵  映射文件：它的作用是指定数据库表和映射类之间的关系，包括映射类和数据库表的对应关系、表字段和类属性类型的对应关系以及表字段和类属性名称的对应关系等。

⑶      数据库配置文件：它的作用是指定与数据库连接时需要的连接信息，比如连接哪中数据库、登录用户名、登录密码以及连接字符串等。在这三种主要的文件中，映射类为普通Java源文件、映射文件为XML格式、数据库配置文件为Properties格式或者是XML格式。想理解“映射”首先我们需要知道如何解析这三种文件，即解析XML格式文件、解析Properties格式文件和解析Java类文件。

hsq语句转为抽象语法树对数据表操作