精华内容
下载资源
问答
  • js开源的ORM对象关系映射框架Onela是基于node . js开源的基于对象的映射框架、支持各种关系数据库数据基础设施。重大更新:v2.0.0版本发布此版本重大更新,原有如果使用了V2.0.0之前的版本请注意,升级到最新版,最原有...
  • Hibernate也是目前Java开发中最为流行的数据库持久层框架,现 发布于 2017-04-15 08:31:39 | 91 次阅读 Hibernate 是一种 Java 语言下的对象关系映射解决方案。 它是使用 GNU 宽通用公共许可证发行的自由、开源的...

    Hibernate ORM 5.1.11.Final 发布了。这可能是 5.1 系列的最后一个版本,建议迁移到 5.2 以备修复未来不可知的 bug。即将创建的另外一个版本的 5.1 系列,是为了修复一些即将出现的 WildFly 版本中包含的 bug。更新内容:错误[HHH-10418] - ClassCastException thrown in SessionFactoryImpl for named regions containing

    发布于 2018-01-12 08:53:36 | 86 次阅读

    Hibernate 5.0.16 已发布,暂未发现该版本更新内容。详情点此查看。Hibernate 是一种 Java 语言下的对象关系映射解决方案。它是使用 GNU 宽松通用公共许可证发行的自由、开源的软件。它为面向对象的领域模型到传统的关系型数据库的映射,提供了一个使用方便的框架。Hibernate 也是目前 Java 开发中最为流行的数据库持久层框

    发布于 2017-11-07 16:57:40 | 76 次阅读

    Hibernate ORM 5.1.10 和 5.0.15 发布了。Hibernate 是一种 Java 语言下的对象关系映射解决方案。它是使用 GNU 宽松通用公共许可证发行的自由、开源的软件。它为面向对象的领域模型到传统的关系型数据库的映射,提供了一个使用方便的框架。Hibernate 也是目前 Java 开发中最为流行的数据库持久层框架,现已归 JBO

    发布于 2017-08-20 08:26:18 | 83 次阅读

    Hibernate ORM 5.1.8.Final 已发布,该版本可能是 5.1 系列最后的一个版本,修复了一些 bug。不过为了将来能收到 bug 修复的更新,建议迁移至 5.2  系列。详细更新内容:Bug 修复[HHH-9329] - Join With SQL generation regression[HHH-10907] - Fix connection leak problem in hibernate-core tests[HHH-11133] - Au

    发布于 2017-06-25 08:00:46 | 78 次阅读

    Hibernate 5.0.14 发布了。Hibernate 是一种 Java 语言下的对象关系映射解决方案。 它是使用 GNU 宽通用公共许可证发行的自由、开源的软件。它为面向对象的领域模型到传统的关系型数据库的映射,提供了一个使用方便的框架。Hibernate 也是目前 Java 开发中最为流行的数据库持久层框架,现已归 JBOSS 所有。更新内容请参考提

    发布于 2017-06-15 18:56:38 | 67 次阅读

    Hibernate ORM 5.1.7 最终版已发布,这可能是 5.1 系列的最后一个版本,建议提前迁移到 5.2 以备接收后续的 bug 修复。Hibernate ORM 5.1.7.Final:tag 请查看 此处更新列表请点击 此处 发行包在 SourceForge 和 BinTray下载地址:http://hibernate.org/orm/downloads/

    发布于 2017-05-23 11:27:17 | 78 次阅读

    Hibernate 5.1.6 发布了。Hibernate 是一种 Java 语言下的对象关系映射解决方案。 它是使用 GNU 宽通用公共许可证发行的自由、开源的软件。它为面向对象的领域模型到传统的关系型数据库的映射,提供了一个使用方便的框架。Hibernate 也是目前 Java 开发中最为流行的数据库持久层框架,现已归 JBOSS 所有。更新内容请参考提

    发布于 2017-05-12 16:27:02 | 79 次阅读

    hibernate-orm 第十个 bug 修复版本 5.2.10 发布了。Hibernate 是一种Java语言下的对象关系映射解决方案。 它是使用GNU宽通用公共许可证发行的自由、开源的软件。它为面向对象的领域模型到传统的关系型数据库的映射,提供了一个使用方便的框架。Hibernate也是目前Java开发中最为流行的数据库持久层框架,现

    发布于 2017-04-15 08:31:39 | 91 次阅读

    Hibernate 是一种 Java 语言下的对象关系映射解决方案。 它是使用 GNU 宽通用公共许可证发行的自由、开源的软件。它为面向对象的领域模型到传统的关系型数据库的映射,提供了一个使用方便的框架。Hibernate 也是目前 Java 开发中最为流行的数据库持久层框架,现已归 JBOSS 所有。Hibernate 5.0.13 发布了。该版本暂未提供更

    发布于 2017-03-29 16:21:21 | 108 次阅读

    Hibernate 4.2.26.final 发布了。Hibernate 是一种 Java 语言下的对象关系映射解决方案。 它是使用 GNU 宽通用公共许可证发行的自由、开源的软件。它为面向对象的领域模型到传统的关系型数据库的映射,提供了一个使用方便的框架。Hibernate 也是目前 Java 开发中最为流行的数据库持久层框架,现已归 JBOSS 所有。该版本暂未

    发布于 2017-03-23 18:26:33 | 75 次阅读

    Hibernate 5.2.9 发布了。Hibernate 是一种 Java 语言下的对象关系映射解决方案。 它是使用 GNU 宽通用公共许可证发行的自由、开源的软件。它为面向对象的领域模型到传统的关系型数据库的映射,提供了一个使用方便的框架。Hibernate 也是目前 Java 开发中最为流行的数据库持久层框架,现已归 JBOSS 所有。更新内容:Bug[HHH

    发布于 2017-03-17 12:24:49 | 177 次阅读

    Hibernate 5.1.5 发布了。Hibernate 是一种 Java 语言下的对象关系映射解决方案。 它是使用 GNU 宽通用公共许可证发行的自由、开源的软件。它为面向对象的领域模型到传统的关系型数据库的映射,提供了一个使用方便的框架。Hibernate 也是目前 Java 开发中最为流行的数据库持久层框架,现已归 JBOSS 所有。目前更新文档里面

    发布于 2017-03-14 15:23:49 | 98 次阅读

    Hibernate 5.2.8 发布了。Hibernate 是一种 Java 语言下的对象关系映射解决方案。 它是使用 GNU 宽通用公共许可证发行的自由、开源的软件。它为面向对象的领域模型到传统的关系型数据库的映射,提供了一个使用方便的框架。Hibernate 也是目前 Java 开发中最为流行的数据库持久层框架,现已归 JBOSS 所有。完整更新列表请点

    发布于 2017-02-21 10:54:23 | 99 次阅读

    Hibernate ORM 5.2 的第七个 bug 修复版本发布了。完整的变更列表可以点击这里查看(没有 Hibernate Jira 帐户的用户点击这里)。GitHub 发布页面,发布主页下载地址:http://hibernate.org/orm/downloads/Source code (zip)Source code (tar.gz)

    发布于 2017-01-20 18:46:51 | 98 次阅读

    Hibernate ORM 5.0.12.Final 和 5.1.4.Final 发布了。Hibernate 是一种 Java 语言下的对象关系映射解决方案。 它是使用 GNU 宽松通用公共许可证发行的自由、开源的软件。它为面向对象的领域模型到传统的关系型数据库的映射,提供了一个使用方便的框架。Hibernate ORM 5.0.12.Final:tag is here;changes are listed&nbs

    发布于 2017-01-20 16:50:27 | 110 次阅读

    Hibernate ORM 5.2.6 发布了,Hibernate是一种Java语言下的对象关系映射解决方案。 它是使用GNU宽通用公共许可证发行的自由、开源的软件。它为面向对象的领域模型到传统的关系型数据库的映射,提供了一个使用方便的框架。此版本暂未提供更新内容。下载地址:Source code (zip)Source code (tar.gz)

    发布于 2016-12-21 08:26:29 | 98 次阅读

    简介 | IntroHibernate 增强工具包 - 只做增强不做改变,更加精简持久层CRUD操作优点 | Advantages纯正血统:完全继承原生 Hibernate 的所有特性最少依赖:仅仅依赖 Hibernate自动生成代码:简化操作,使其专注于业务自定义操作:提供大量API,使开发更加顺畅简化操作:只需专注于业务,数据库操作请交给&nb

    发布于 2016-12-06 15:02:28 | 125 次阅读

    Hibernate ORM 5.2.5 发布了,Hibernate是一种Java语言下的对象关系映射解决方案。 它是使用GNU宽通用公共许可证发行的自由、开源的软件。它为面向对象的领域模型到传统的关系型数据库的映射,提供了一个使

    发布于 2016-11-25 18:50:02 | 120 次阅读

    Hibernate ORM 5.1.3 和 5.2.5 发布了,Hibernate是一种Java语言下的对象关系映射解决方案。 它是使用GNU宽通用公共许可证发行的自由、开源的软件。它为面向对象的领域模型到传统的关系型数据库的映射

    发布于 2016-11-25 18:24:47 | 121 次阅读

    Hibernate ORM 5.2.4.final 发布了,Hibernate是一种Java语言下的对象关系映射解决方案。 它是使用GNU宽通用公共许可证发行的自由、开源的软件。它为面向对象的领域模型到传统的关系型数据库的映射,提供了一个使用方便的框架。更新内容:新功能equals / hashCode实现的最佳实践改进 改进不可变/只读实体和不可变

    发布于 2016-10-28 07:46:59 | 91 次阅读

    展开全文
  • 开源对象关系映射框架Hibernate知识培训开源对象关系映射框架Hibernate知识培训
  • Inloquent:基于C ++ Qt的类似Laravel-Eloquent的对象关系映射框架
  • hibernate是一个开放源代码的对象关系映射框架,它对JDBC进行了非常轻量级的对象封装,它将POJO与数据库表建立映射关系,是一个全自动的orm框架,hibernate可以自动生成SQL语句,自动执行,使得Java程序员可以...
    hibernate是一个开放源代码的对象关系映射框架,它对JDBC进行了非常轻量级的对象封装,它将POJO与数据库表建立映射关系,是一个全自动的orm框架,hibernate可以自动生成SQL语句,自动执行,使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。 
    
    展开全文
  • Hibernate(开放源代码的对象关系映射框架) 1.简介 Hibernate是一个开放源代码的对象关系映射框架,它对JDBC进行了非常轻量级的对象封装,它将POJO与数据库表建立映射关系,是一个全自动的orm框架,hibernate可以...

    Hibernate(开放源代码的对象关系映射框架)

    1.简介

    Hibernate是一个开放源代码的对象关系映射框架,它对JDBC进行了非常轻量级的对象封装,它将POJO与数据库表建立映射关系,是一个全自动的orm框架,hibernate可以自动生成SQL语句,自动执行,使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。 Hibernate可以应用在任何使用JDBC的场合,既可以在Java的客户端程序使用,也可以在Servlet/JSP的Web应用中使用,最具革命意义的是,Hibernate可以在应用EJB的JaveEE架构中取代CMP,完成数据持久化的重任。

    2.ORM

    ORM:Object Relational Mapping(对象关系映射)。指将一个Java中的对象与关系型数据库中的表建立一种映射关系,从而通过操作对象就可以操作数据库中的表。在这里插入图片描述

    3.Hibernate特点

    在这里插入图片描述

    4.Hibernate入门

    4.1 Hibernate目录结构

    在这里插入图片描述

    • documentation Hibernate开发文档

    • lib Hibernate开发包

      • required Hibernate开发必须的依赖包
      • optional Hibernate开发可选jar包
    • project Hibernate提供的项目

    4.2Hibernate项目的创建(eclipse)

    4.2.1创建数据表(数据库中创建)

    CREATE TABLE `cst_customer` (
      `cust_id` BIGINT(32) NOT NULL AUTO_INCREMENT COMMENT '客户编号(主键)',
      `cust_name` VARCHAR(32) NOT NULL COMMENT '客户名称(公司名称)',
      `cust_source` VARCHAR(32) DEFAULT NULL COMMENT '客户信息来源',
      `cust_industry` VARCHAR(32) DEFAULT NULL COMMENT '客户所属行业',
      `cust_level` VARCHAR(32) DEFAULT NULL COMMENT '客户级别',
      `cust_phone` VARCHAR(64) DEFAULT NULL COMMENT '固定电话',
      `cust_mobile` VARCHAR(16) DEFAULT NULL COMMENT '移动电话',
      PRIMARY KEY (`cust_id`)
    ) ENGINE=INNODB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;
    

    4.2.2创建实体类(与要连接的表相对应)

    public class Customer {
    	private Long cust_id;
    	private String cust_name;
    	private String cust_source;
    	private String cust_industry;
    	private String cust_level;
    	private String cust_phone;
    	private String cust_mobile;
    	public Customer() {
    		super();
    		// TODO Auto-generated constructor stub
    	}
    }
    

    4.2.3创建映射

    在与实体类相同的包下创建映射文件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>
        <!-- 建立类与表的映射 -->
        <class name="Demo01.Customer" table="cst_customer">
            <id name="cust_id" column="cust_id">
                <!-- 设置主键的生成策略:native--自增 -->
                <generator class="native"/>
            </id>
            <property name="cust_name" column="cust_name"/>
            <property name="cust_source" column="cust_source"/>
            <property name="cust_industry" column="cust_industry"/>
            <property name="cust_level" column="cust_level"/>
            <property name="cust_phone" column="cust_phone"/>
            <property name="cust_mobile" column="cust_mobile"/>
        </class>
    </hibernate-mapping>
    

    4.2.4创建核心配置文件

    在src目录下创建hibernate.cfg.xml

    <?xml version='1.0' encoding='utf-8'?>
    <!DOCTYPE hibernate-configuration PUBLIC
            "-//Hibernate/Hibernate Configuration DTD//EN"
            "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
    <hibernate-configuration>
        <session-factory>
            <property name="connection.url" >jdbc:mysql:///hibernate01</property>
            <property name="connection.driver_class">com.mysql.jdbc.Driver</property>
            <property name="connection.username">root</property>
            <property name="connection.password">123456</property>
    
            <!-- DB schema will be updated if needed -->
            <!-- <property name="hbm2ddl.auto">update</property>-->
           <!-- 配置数据库方言-->
            <property name="dialect">org.hibernate.dialect.MySQLDialect</property>
            <!--映射文件路径-->
            <mapping resource="Demo01/Customer.hbm.xml"/>
        </session-factory>
    </hibernate-configuration>
    

    4.2.5测试代码

    
    import org.hibernate.Session;
    import org.hibernate.SessionFactory;
    import org.hibernate.Transaction;
    import org.hibernate.cfg.Configuration;
    import org.junit.jupiter.api.Test;
    
    public class HibernateDemo01 {
        @Test
        public void demo1(){
            //加载hibernate核心配置文件
            Configuration configuration = new Configuration().configure();
            //创建一个session工厂类似于jdbc的连接池
            SessionFactory sessionFactory = configuration.buildSessionFactory();
            //通过sessionFactory获取session对象
            Session session = sessionFactory.openSession();
            //开启事务
            Transaction transaction = session.beginTransaction();
            //编写代码
            Customer customer = new Customer();
            customer.setCust_name("gx");
            //保存
            session.save(customer);
            //提交事务
            transaction.commit();
            //释放资源
            session.close();
        }
    }
    

    5.Hibernate的常见配置

    5.1Hibernate映射配置

    文件Customer.hbm.xml

    • class标签属性配置

      • 该标签用来建立类与表的映射关系
      • 属性
        • name:类的全路径
        • table :表名(类名和表名如果一致那么table可以省略)
        • ctatlog:数据库名
      <class name="Demo01.Customer" table="cst_customer">
      
    • id标签配置

      • 标签用来建立类中属性与表中主键的对应关系
      • 属性
        • name:类中的属性
        • column:表中的字段名(类中属性名和表中字段名如果一致那么column可以省略)
        • length:长度
        • type:类型
      <id name="cust_id" column="cust_id">
                  <!-- 设置主键的生成策略:native--自增 -->
                  <generator class="native"/>
      </id>
      
    • property

      • 标签用来建立类中普通属性与表字段之间的对应关系
      • 属性
        • name:类中的属性
        • column:表中的字段名
        • length:长度(Hibernate如果在运行前没有建立定义的表,那么在运行时就会自动建表,这时表中对应字段的长度就是此处设置的长度)
        • type:类型
        • not-noll:设置非空
        • unique:是否唯一
       <property name="cust_name" column="cust_name"/>
              <property name="cust_source" column="cust_source"/>
              <property name="cust_industry" column="cust_industry"/>
              <property name="cust_level" column="cust_level"/>
              <property name="cust_phone" column="cust_phone"/>
              <property name="cust_mobile" column="cust_mobile"/>
      

    5.2Hibernate核心配置

    两种方式:

    1.属性文件配置

    hibernate.properties

    键值对配置

    注意:该方式不能引入配置文件,若想引入需要通过代码配置需要手动编写代码加载映射文件。

    2.XMl文件配置

    hibernate.cfg.xml

    • 必须的配置

      • 连接数据库的基本参数
        • 驱动类
        • url路径
        • 用户名
        • 密码
      <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
      <property name="hibernate.connection.url">jdbc:mysql:///hibernate01</property>
      <property name="hibernate.connection.username">root</property>
      <property name="hibernate.connection.password">123456</property>
      
      • 方言
      <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
      
    • 可选配置

      • 显示sql:hibernate.show_sql
      • 格式化sql:hibernate.format_sql
      • 自动建表:hibernate.hbm2ddl.auto
        • none:不使用Hibernate自动建表
        • create:如果数据库中已经有表,先删除原来的表,在创建新表。如果没有表就新建表
        • create-drop;如果数据库中已经有表,先删除原来的表,在创建新表。如果没有表就新建表。使用完成后删除该表
        • update:如果数据库中有表,就使用原来的表,若没有就新建表。如果映射文件中表字段与数据库中的对应表不一致,那么就会新建对应字段。(即更改表结构)
        • validate:如果没有表,不会创建表,只会使用原有表,作用:校验映射与表结构
      <!-- 打印SQL -->
      <property name="hibernate.show_sql">true</property>
      <!-- 格式化SQL -->
      <property name="hibernate.format_sql">true</property>
      <!-- 自动创建表 -->
      <property name="hibernate.hbm2ddl.auto">create</property>
      
    • 映射文件的引入

      • 配置映射文件位置(使用mapping标签)
      <mapping resource="hibernate/Demo1/Custmoer.hbm.xml"/>
      

    6.Hibernate的核心API

    6.1 Configuration:Hibernate的配置对象

    ​ Configuration 类的作用是对Hibernate 进行配置,以及对它进行启动。在Hibernate 的启动过程中,Configuration 类的实例首先定位映射文档的位置,读取这些配置,然后创建一个SessionFactory对象。虽然Configuration 类在整个Hibernate 项目中只扮演着一个很小的角色,但它是启动hibernate 时所遇到的第一个对象。

    6.1.1作用

    6.1.1.1加载核心配置文件
    1. hibernate.properties

    Configuration configuration = new Configuration();

    1. hibernate.cfg.xml

    Configuration configuration = new Configuration().configure();

    6.1.1.1.2加载映射文件

    配置属性文件时无法加载映射文件故映射文件只能手动加载,xml文件也可以使用该方法加载

    configuration.addResource("hibernate/Demo1/Custmoer.hbm.xml");
    

    6.2 SessionFactory:session工厂

    SessionFactory接口负责初始化Hibernate。它充当数据存储源的代理,并负责创建Session对象。这里用到了工厂模式。需要注意的是SessionFactory并不是轻量级的,因为一般情况下,一个项目通常只需要一个SessionFactory就够,当需要操作多个数据库时,可以为每个数据库指定一个SessionFactory。

    SessionFactory内部维护了Hibernate的连接池和Hibernate的二级缓存。是对象安全对象,一个项目创建一个对象即可

    6.2.1 配置数据库连接池

    <property name="connection.provider_class">org.hibernate.connection.C3P0ConnectionProvider</property>
    <!--在连接池中可用的数据库连接的最少数目 -->
    <property name="c3p0.min_size">5</property>
    <!--在连接池中所有数据库连接的最大数目  -->
    <property name="c3p0.max_size">20</property>
    <!--设定数据库连接的过期时间,以秒为单位,如果连接池中的某个数据库连接处于空闲状态的时间超过了timeout时间,就会从连接池中清除 -->
    <property name="c3p0.timeout">120</property>
    <!--每3000秒检查所有连接池中的空闲连接 以秒为单位-->
    <property name="c3p0.idle_test_period">3000</property>
    

    6.2.2 抽取工具类

    import org.hibernate.Session;
    import org.hibernate.SessionFactory;
    import org.hibernate.cfg.Configuration;
    
    public class HibernateUtils {
    	
    	public static final Configuration cfg;
    	public static final SessionFactory sf;
    	
    	static {
    		cfg=new Configuration().configure();
    		sf=cfg.buildSessionFactory();
    	}
    	
    	public static Session openSession() {
    		return sf.openSession();
    	}
    }
    

    6.3 Session:类似Connection对象是连接对象

    ​ Session接口负责执行被持久化对象的CRUD操作(CRUD的任务是完成与数据库的交流,包含了很多常见的SQL语句)。但需要注意的是Session对象是非线程安全的。同时,Hibernate的session不同于JSP应用中的HttpSession。这里当使用session这个术语时,其实指的是Hibernate中的session,而以后会将HttpSession对象称为用户session。

    Session代表Hibernate与数据库连接池的连接对象。线程不安全,与数据库交互的桥梁

    6.3.1 Session中的api

    6.3.1.1保存方法

    Serialzable save(Object o);

    public void demo6() {
    		Session session = HibernateUtils.openSession();
    		Transaction transaction = session.beginTransaction();
    		
    		Customer c = new Customer();
    		c.setCust_name("gfws");
    		session.save(c);
    		
    		transaction.commit();
    		session.close();
    	}
    
    6.3.1.2 查询方法

    T get(Class c,Serializable id);

    T load(Class c,Serializable id);

    public void demo1() {
    		Session session = HibernateUtils.openSession();
    		Transaction transaction = session.beginTransaction();
    		
    		/**
    		 * get方法
    		 * 	* 采用的是立即加载,执行到这行代码的时候,就会马上发送SQL语句去查询。
    		 *  * 查询后返回是真实对象本身。
    		 * 	* 查询一个找不到的对象的时候,返回null
    		 * 
    		 * load方法
    		 * 	* 采用的是延迟加载(lazy懒加载),执行到这行代码的时候,不会发送SQL语句,当真正使用这个对象的时候才会发送SQL语句。
    		 *  * 查询后返回的是代理对象。javassist-3.18.1-GA.jar 利用javassist技术产生的代理。
    		 *  * 查询一个找不到的对象的时候,返回ObjectNotFoundException
    		 */
    		/*Customer customer = session.get(Customer.class, 1l);
    		System.out.println(customer);*/
    		
    		Customer customer = session.load(Customer.class, 2l);
    		System.out.println(customer);
    		
    		transaction.commit();
    		session.close();
    	}
    

    查询所有

    public void demo5() {
    		Session session = HibernateUtils.openSession();
    		Transaction transaction = session.beginTransaction();
    		
    		//通过HQL:Hibernate Query Language面向对象查询语言
    		/*Query query = session.createQuery("from Customer");
    		List<Customer> list = query.list();
    		for (Customer customer : list) {
    			System.out.println(customer);
    		}*/
    		//使用普通SQL语句查询
    		SQLQuery sql = session.createSQLQuery("select * from cst_customer");
    		List<Object[]> list = sql.list();
    		for (Object[] object : list) {
    			System.out.println(Arrays.toString(object));
    		}
    		
    		transaction.commit();
    		session.close();
    	}
    
    6.3.1.3 修改方法

    void update(Object o);

    public void demo2() {
    		Session session = HibernateUtils.openSession();
    		Transaction transaction = session.beginTransaction();
    		//直接创建对象进行修改
    		/*Customer c = new Customer();
    		c.setCust_name("hh");
    		c.setCust_id(1l);*/
    		
    		//先查询后修改(推荐)
    		Customer c = session.get(Customer.class, 2l);
    		c.setCust_name("gx");
    		session.update(c);
    		
    		transaction.commit();
    		session.close();
    	}
    
    6.3.1.4 删除方法

    void delete(Object o);

    public void demo3() {
    		Session session = HibernateUtils.openSession();
    		Transaction transaction = session.beginTransaction();
    		//直接创建对象进行删除
    		/*Customer c = new Customer();
    		c.setCust_id(4l);*/
    		
    		//先查询后删除(推荐)--级联删除
    		Customer c = session.get(Customer.class, 1l);		
    		session.delete(c);
    		
    		transaction.commit();
    		session.close();
    	}
    
    6.3.1.5 保存或更新

    void saveOrUpdate(Object o);

    public void demo4() {
    		Session session = HibernateUtils.openSession();
    		Transaction transaction = session.beginTransaction();
    		//如果要删除或保存对象的属性与现有数据库中的都不相同就保存,如有相同就对有相同的那一列修改
    		Customer c = new Customer();
    		/*c.setCust_name("wf");*/
    		c.setCust_id(2l);
    		c.setCust_name("fx");
    		session.saveOrUpdate(c);
    		transaction.commit();
    		session.close();
    	}
    

    6.4 Transaction :事务对象

    Hibernate中管理事务的对象

    commit();

    rollback();

    展开全文
  • Hibernate是一个开放源代码的对象关系映射框架,它对JDBC进行了非常轻量级的对象封装,它将POJO与数据库表建立映射关系,是一个全自动的orm框架,hibernate可以自动生成SQL语句,自动执行,使得Java程序员可以...

          Hibernate是一个开放源代码的对象关系映射框架,它对JDBC进行了非常轻量级的对象封装,它将POJO与数据库表建立映射关系,是一个全自动的orm框架,hibernate可以自动生成SQL语句,自动执行,使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。 Hibernate可以应用在任何使用JDBC的场合,既可以在Java的客户端程序使用,也可以在Servlet/JSP的Web应用中使用,最具革命意义的是,Hibernate可以在应用EJB的J2EE架构中取代CMP,完成数据持久化的重任。

        核心接口和类

          Hibernate的核心类和接口一共有6个,分别为:Session、SessionFactory、Transaction、Query、Criteria和Configuration。这6个核心类和接口在任何开发中会用到。通过这些接口,不仅可以对持久化对象进行存取,还能够进行事务控制。下面对这6个核心接口和类分别加以介绍。
        Session
         Session接口负责执行被持久化对象的CRUD操作(CRUD的任务是完成与数据库的交流,包含了很多常见的SQL语句)。但需要注意的是Session对象是非线程安全的。同时,Hibernate的session不同于JSP应用中的HttpSession。这里当使用session这个术语时,其实指的是Hibernate中的session,而以后会将HttpSession对象称为用户session。

        HibernateSessionFactory

          SessionFactory接口负责初始化Hibernate。它充当数据存储源的代理,并负责创建Session对象。这里用到了工厂模式。需要注意的是SessionFactory并不是轻量级的,因为一般情况下,一个项目通常只需要一个SessionFactory就够,当需要操作多个数据库时,可以为每个数据库指定一个SessionFactory。

        HibernateTransaction

          Transaction 接口是一个可选的API,可以选择不使用这个接口,取而代之的是Hibernate 的设计者自己写的底层事务处理代码。 Transaction 接口是对实际事务实现的一个抽象,这些实现包括JDBC的事务、JTA 中的UserTransaction、甚至可以是CORBA 事务。之所以这样设计是能让开发者能够使用一个统一事务的操作界面,使得自己的项目可以在不同的环境和容器之间方便地移植。

        HibernateQuery

         Query接口让你方便地对数据库及持久对象进行查询,它可以有两种表达方式:HQL语言或本地数据库的SQL语句。Query经常被用来绑定查询参数、限制查询记录数量,并最终执行查询操作。

        HibernateCriteria

        Criteria接口与Query接口非常类似,允许创建并执行面向对象的标准化查询。值得注意的是Criteria接口也是轻量级的,它不能在Session之外使用。

        HibernateConfiguration

        Configuration 类的作用是对Hibernate 进行配置,以及对它进行启动。在Hibernate 的启动过程中,Configuration 类的实例首先定位映射文档的位置,读取这些配置,然后创建一个SessionFactory对象。虽然Configuration 类在整个Hibernate 项目中只扮演着一个很小的角色,但它是启动hibernate 时所遇到的第一个对象。
     
         

       ssh框架   

          Ssh为 struts+spring+hibernate的一个集成框架,是目前较流行的一种Web应用程序开源框架。
          集成SSH框架的系统从职责上分为四层:表示层业务逻辑层数据持久层和域模块层,以帮助开发人员在短期内搭建结构清晰、可复用性好、维护方便的Web应用程序。其中使用Struts作为系统的整体基础架构,负责MVC的分离,在Struts框架的模型部分,控制业务跳转,利用Hibernate框架对持久层提供支持,Spring做管理,管理struts和hibernate。具体做法是:用面向对象的分析方法根据需求提出一些模型,将这些模型实现为基本的Java对象,然后编写基本的DAO(Data Access Objects)接口,并给出Hibernate的DAO实现,采用Hibernate架构实现的DAO类来实现Java类与数据库之间的转换和访问,最后由Spring做管理,管理struts和hibernate
          系统的基本业务流程是: 在表示层中,首先通过JSP页面实现交互界面,负责接收请求(Request)和传送响应(Response),然后Struts根据配置文件(struts-config.xml)将ActionServlet接收到的Request委派给相应的Action处理。在业务层中,管理服务组件的Spring IoC容器负责向Action提供业务模型(Model)组件和该组件的协作对象数据处理(DAO)组件完成业务逻辑,并提供事务处理、缓冲池等容器组件以提升系统性能和保证数据的完整性。而在持久层中,则依赖于Hibernate的对象化映射和数据库交互,处理DAO组件请求的数据,并返回处理结果。
     
      框架结构

        ssh框架Struts1

         Struts对Model,View和Controller都提供了对应的组件。
         ActionServlet,这个类是Struts1的核心控制器,负责拦截来自用户的请求。
         Action,这个类通常由用户提供,该控制器负责接收来自ActionServlet的请求,并根据该请求调用模型的业务逻辑方法处理请求,并将处理结果返回给JSP页面显示。
     
         Model部分:
         由ActionForm和JavaBean组成,其中ActionForm用于将用户的请求参数封装成ActionForm对象,该对象被ActionServlet转发给Action,Action根据ActionForm里面的请求参数处理用户的请求。
         JavaBean则封装了底层的业务逻辑,包括数据库访问等。
     
        View部分:
        该部分采用JSP(或HTML、PHP……)实现。
        Struts提供了丰富的标签库,通过标签库可以减少脚本的使用,自定义的标签库可以实现与Model的有效交互,并增加了现实功能。对应上图的JSP部分。
     
        Controller组件:
        Controller组件有两个部分组成——系统核心控制器,业务逻辑控制器。
       系统核心控制器,对应上边的ActionServlet。该控制器继承了HttpServlet类,因此可以配置成标注的Servlet。该控制器负责拦截所有的HTTP请求,然后根据用户请求决定是否要转给业务逻辑控制器。
        业务逻辑控制器,负责处理用户请求,本身不具备处理能力,而是调用Model来完成处理。对应Action部分。

        ssh框架Spring

         Spring是一个开源框架,它由Rod Johnson创建。它是为了解决企业应用开发的复杂性而创建的。Spring使用基本的JavaBean来完成以前只可能由EJB完成的事情。然而,Spring的用途不仅限于服务器端的开发。从简单性、可测试性松耦合的角度而言,任何Java应用都可以从Spring中受益。
         目的:解决企业应用开发的复杂性
         功能:使用基本的JavaBean代替EJB,并提供了更多的企业应用功能
         范围:任何Java应用
         简单来说,Spring是一个轻量级的控制反转(IoC)和面向切面(AOP)的容器框架。
         轻量——从大小与开销两方面而言Spring都是轻量的。完整的Spring框架可以在一个大小只有1MB多的JAR文件里发布。并且Spring所需的处理开销也是微不足道的。此外,Spring是非侵入式的:典型地,Spring应用中的对象不依赖于Spring的特定类。
    控制反转——Spring通过一种称作控制反转(IoC)的技术促进了松耦合。当应用了IoC,一个对象依赖的其它对象会通过被动的方式传递进来,而不是这个对象自己创建或者查找依赖对象。你可以认为IoC与JNDI相反——不是对象从容器中查找依赖,而是容器在对象初始化时不等对象请求就主动将依赖传递给它。
    面向切面——Spring提供了面向切面编程的丰富支持,允许通过分离应用的业务逻辑与系统级服务(例如审计(auditing)和事务(transaction)管理)进行内聚性的开发。应用对象只实现它们应该做的——完成业务逻辑——仅此而已。它们并不负责(甚至是意识)其它的系统级关注点,例如日志或事务支持。
         容器——Spring包含并管理应用对象的配置和生命周期,在这个意义上它是一种容器,你可以配置你的每个bean如何被创建——基于一个可配置原型(prototype),你的bean可以创建一个单独的实例或者每次需要时都生成一个新的实例——以及它们是如何相互关联的。然而,Spring不应该被混同于传统的重量级的EJB容器,它们经常是庞大与笨重的,难以使用。
          框架——Spring可以将简单的组件配置、组合成为复杂的应用。在Spring中,应用对象被声明式地组合,典型地是在一个XML文件里。Spring也提供了很多基础功能(事务管理、持久化框架集成等等),将应用逻辑的开发留给了你。
    所有Spring的这些特征使你能够编写更干净、更可管理、并且更易于测试的代码。它们也为Spring中的各种模块提供了基础支持。

         ssh框架Hibernate

          Hibernate是一个开放源代码的对象关系映射框架,它对JDBC进行了非常轻量级的对象封装,使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。 Hibernate可以应用在任何使用JDBC的场合,既可以在Java的客户端程序使用,也可以在Servlet/JSP的Web应用中使用,最具革命意义的是,Hibernate可以在应用EJB的J2EE架构中取代CMP,完成数据持久化的重任。
          Hibernate的核心接口一共有5个,分别为:Session、SessionFactory、Transaction、Query和Configuration。这5个核心接口在任何开发中都会用到。通过这些接口,不仅可以对持久化对象进行存取,还能够进行事务控制。下面对这五个核心接口分别加以介绍。
    ·Session接口:Session接口负责执行被持久化对象的CRUD操作(CRUD的任务是完成与数据库的交流,包含了很多常见的SQL语句。)。但需要注意的是Session对象是非线程安全的。同时,Hibernate的session不同于JSP应用中的HttpSession。这里当使用session这个术语时,其实指的是Hibernate中的session,而以后会将HttpSession对象称为用户session。
         ·SessionFactory接口:SessionFactory接口负责初始化Hibernate。它充当数据存储源的代理,并负责创建Session对象。这里用到了工厂模式。需要注意的是SessionFactory并不是轻量级的,因为一般情况下,一个项目通常只需要一个SessionFactory就够,当需要操作多个数据库时,可以为每个数据库指定一个SessionFactory。
        ·Configuration接口:Configuration接口负责配置并启动Hibernate,创建SessionFactory对象。在Hibernate的启动的过程中,Configuration类的实例首先定位映射文档位置、读取配置,然后创建SessionFactory对象。
        ·Transaction接口:Transaction接口负责事务相关的操作。它是可选的,开发人员也可以设计编写自己的底层事务处理代码。
        ·Query和Criteria接口:Query和Criteria接口负责执行各种数据库查询。它可以使用HQL语言或SQL语句两种表达方式。

    转载于:https://www.cnblogs.com/wenwen123/p/5658625.html

    展开全文
  • Android数据库框架——GreenDao轻量级的对象关系映射框架,永久告别sqlite 前不久,我在写了ORMLite这个框架的博文Android数据库框架——ORMLite轻量级的对象关系映射(ORM)Java包 但是对于我个人来说,我可能更加...
  • Hibernate是一个开放源代码的对象关系映射框架,它对JDBC进行了非常轻量级的对象封装,它将POJO与数据库表建立映射关系,是一个全自动的orm框架,hibernate可以自动生成SQL语句,自动执行,使得Java程序员可以...
  • OMapper 提供了一个简单的库用来简化对象/Bean 与其他设计层面的映射,使用 Java 的注解。示例代码:/*** The Class Bean2.*/@Mappablepublic class Bean2 {/** The name. */@Source(type = org.o...
  • Hibernate (开放源代码的对象关系映射框架)入门1 什么是hibernate2 导入 Hibernate 库文件及开发所用数据库的驱动文件3 web3.1配置4 创建 Hibernate 配置文件 hibernate.cfg.xml5 创建映射的类6 user.hbm.xml配置7...
  • hibernate是一个开源的ORM(对象关系映射框架,也是一个持久层的框架,它对JDBC做了非常轻量级的封装。 Hibernate核心(六大接口+两个配置文件) Configuration:负责配置并启动Hibernate SessionFactory:负责...
  • Hibernate是一个开放源代码的对象关系映射框架,它对JDBC进行了非常轻量级的对象封装,它将POJO与数据库表建立映射关系,是一个全自动的orm框架,hibernate可以自动生成SQL语句,自动执行,使得Java程序员可以...
  • Reladomo是用于Java的对象关系映射(ORM)框架,具有以下企业功能: 强类型的编译时检查查询语言 双时态链 透明的多模式支持 完全支持可单元测试的代码 有关更多详细信息,请参见。 我该怎么办? 将数据建模为...
  • 一、基本介绍1、它对JDBC进行了非常轻量级的对象封装,它将POJO与数据库表建立映射关系,是一个全自动的orm(对象关系映射框架,hibernate可以自动生成SQL语句,自动执行; Hibernate可以应用在任何使用JDBC的场合...
  • 前面介绍了ormlite操作单张表以及多表之间的一对多(多对一)的关系(请参考android对象关系映射框架ormlite学习之单表操作和android关系映射框架ormlite学习之OneToMany),但是我们还经常会遇到多对多的数据库表...
  • 1 orm:就是将对象关系数据库建立一种映射关系,精确的,一对一的,保证你对对象的某一个操作,比如修改对象属性,创建新的对象等,唯一的对应数据的一种修改数据的操作或者增加数据的操作.orm框架就是提供这种操作的,...
  • Hibernate是一个开放源代码的对象关系映射框架,它对JDBC进行了非常轻量级的对象封装,使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。 Hibernate是一个优秀的持久化框架 什么是持久化:将程序数据在...
  • final BabyCap babyCap = babyCapList.get(position); holder.buttonDelete.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View v) { babyCapViewModel.deleteBabyCaps...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 10,755
精华内容 4,302
关键字:

对象关系映射框架