hibernate 订阅
Hibernate是一个开放源代码的对象关系映射框架,它对JDBC进行了非常轻量级的对象封装,它将POJO与数据库表建立映射关系,是一个全自动的orm框架,hibernate可以自动生成SQL语句,自动执行,使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。 Hibernate可以应用在任何使用JDBC的场合,既可以在Java的客户端程序使用,也可以在Servlet/JSP的Web应用中使用,最具革命意义的是,Hibernate可以在应用EJB的JaveEE架构中取代CMP,完成数据持久化的重任。 展开全文
Hibernate是一个开放源代码的对象关系映射框架,它对JDBC进行了非常轻量级的对象封装,它将POJO与数据库表建立映射关系,是一个全自动的orm框架,hibernate可以自动生成SQL语句,自动执行,使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。 Hibernate可以应用在任何使用JDBC的场合,既可以在Java的客户端程序使用,也可以在Servlet/JSP的Web应用中使用,最具革命意义的是,Hibernate可以在应用EJB的JaveEE架构中取代CMP,完成数据持久化的重任。
信息
关键技术
数据持久化
典型应用
EJB的J2EE架构中取代CMP
作    用
数据库与界面之间的桥梁
中文名
对象关系映射框架
属    性
开放源代码的对象关系映射框架
外文名
Hibernate
Hibernate简介
Hibernate作为数据库与界面之间的桥梁,需要面向对象思想操纵对象。对象可能是普通JavaBeans/POJO。应用程序通过抽象将应用从底层事务隔离开。使用底层的API或Transaction对象完成轻量级框架提供一级缓存和二级缓存。Hibernate直接提供相关支持,底层驱动可以随意切换数据库,快速简洁。使业务层与具体数据库分开,只针对Hibernate 进行开发,完成数据和对象的持久化。针对不同的数据库形成不同的SQL 查询语句,降低数据库之间迁移的成本。Hibernate支持多种缓存机制,Hibernate适配MS SQLSERVER、ORACLE、SQL、H2、Access和Mysql等多种数据库。Hibernate用反射机制实现持久化对象操作,实现与IDE(Integrated Development Environment)的耦合度。Hibernate使用数据库和配置信息为应用程序提供持久化服务。从配置文件中读取数据库相关参数,将持久化类和数据表对应使用。用Hibernate API对象持久化,利用映像信息将持久化操作翻译为SQL语句进行查询。Hibernate框架技术最关键是数据持久化,是将数据保存到持久层的过程。持久层的数据在掉电后也不会丢失的数据。持久层是基于Hibernate技术的检索系统开发的基本。系统结构的层次模型有三个阶段。整个过程首先实现应用层和数据层。数据层保存持久化数据,应用层接收输入的数据。然后通过MVC 模式实现业务逻辑与表示层的分开。表示层和用户实现交互,业务逻辑层处理数据持久化操作。将第二阶段业务逻辑层的功能部署拆分后,业务逻辑层完成核心业务逻辑处理,持久层完成对象持久化。降低业务逻辑层复杂度的同时将数据持久化让其他组件完成。 [1] 
收起全文
精华内容
下载资源
问答
  • hibernate

    千次阅读 2020-09-24 23:52:13
    hibernate.cfg.xml <?xml version='1.0' encoding='utf-8'?> <!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration DTD 3.0//EN" ...

    1.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>
        <session-factory>
            <property name="connection.driver_class">com.mysql.jdbc.Driver</property>
            <property name="connection.password">yo1ur22s12ord</property>
            <property name="connection.url">jdbc:mysql://123.415.182.94:3306/test1?serverTimezone=UTC</property>
            <property name="connection.username">root</property>
    
            <property name="hbm2ddl.auto">update</property>
            <property name="dialect">org.hibernate.dialect.MySQLDialect</property>
            <property name="show_sql">true</property>
            <property name="hibernate.dialect">org.hibernate.dialect.MySQL5Dialect</property>
            <!--        xml-->
            <mapping resource="cn/lin/orm/entity/book.nbt.xml"/>
            <!--        注解-->
    		<mapping class="cn.lin.orm.entity.Book"/>
    	</session-factory>
    </hibernate-configuration>
    

    2,book.hbt.xml

    <!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="cn.lin.orm.entity.Book" table="t_book">
            <id name="id">
                <column name="id"/>
                <generator class="identity"/>
            </id>
    
            <property name="name">
                <column name="name"/>
            </property>
    
            <property name="price">
                <column name="price"/>
            </property>
    
        </class>
    
    </hibernate-mapping>
    

    3,注解

    package cn.lin.orm.entity;
    
    import javax.persistence.*;
    
    @Entity
    @Table(name="t_book")
    public class Book {
        @Id
        @GeneratedValue(strategy = GenerationType.IDENTITY)
        private Integer id;
        @Column(name="name")
        private String name;
        @Column(name="price")
        private double price;
        @Column(name = "author")
        private String author;
    
        @Override
        public String toString() {
            return "Book{" +
                    "id=" + id +
                    ", name='" + name + '\'' +
                    ", price=" + price +
                    ", author='" + author + '\'' +
                    '}';
        }
    
        public Integer getId() {
            return id;
        }
    
        public void setId(Integer id) {
            this.id = id;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public double getPrice() {
            return price;
        }
    
        public void setPrice(double price) {
            this.price = price;
        }
    
        public String getAuthor() {
            return author;
        }
    
        public void setAuthor(String author) {
            this.author = author;
        }
    }
    

    4.pom.xml

    <?xml version="1.0" encoding="UTF-8"?>
    <project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 				http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    
    <groupId>org.example</groupId>
    <artifactId>com.lin</artifactId>
    <version>1.0-SNAPSHOT</version>
    
    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13</version>
        </dependency>
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-core</artifactId>
            <version>5.4.17.Final</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.19</version>
        </dependency>
    </dependencies>
    
    <build>
        <resources>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.xml</include>
                </includes>
            </resource>
            <resource>
                <directory>src/main/resources</directory>
                <includes>
                    <include>**/*.xml</include>
                </includes>
            </resource>
        </resources>
    </build>
    
    
    </project>
    

    5.测试类

    import cn.lin.orm.entity.Book;
    import org.hibernate.Session;
    import org.hibernate.SessionFactory;
    import org.hibernate.Transaction;
    import org.hibernate.cfg.Configuration;
    import org.junit.Before;
    import org.junit.Test;
    
    
    public class BookTest {
        private SessionFactory factory;
    
        @Before
        public void init(){
            Configuration cfg = new Configuration().configure();
            factory = cfg.buildSessionFactory();
        }
        @Test
        public void testSave(){
            Session session = factory.openSession();
            //开启事务
            Transaction tx = session.beginTransaction();
            Book book = new Book();
            book.setName("python");
            book.setAuthor("python");
            book.setPrice(100);
            session.save(book);
            tx.commit();
            session.close();
    
        }
        @Test
        public void get(){
            Session session = factory.openSession();
            Book book = session.get(Book.class,5);
            System.out.println(book);
            session.close();
        }
        @Test
        public void delete(){
            Session session = factory.openSession();
            Transaction tx = session.beginTransaction();
            Book book = new Book();
            book.setId(3);
            session.delete(book);
            tx.commit();
            session.close();
    
    
        }
        @Test
        public void update(){
            Session session = factory.openSession();
            Transaction tx = session.beginTransaction();
            Book book = new Book();
            book.setId(5);
            book.setName("java1");
            book.setPrice(8);
            book.setAuthor("lin");
            session.update(book);
            tx.commit();
            session.close();
    
    
    
        }
    }
    

    错误1

    org.hibernate.tool.schema.spi.CommandAcceptanceException: Error executing DDL via JDBC Statement错误

    解决方案:
    在本项目的.cfg.xml配置中加入:

    <property name="hibernate.dialect">org.hibernate.dialect.MySQL5Dialect</property>
    
    展开全文
  • springboot集成hibernate

    热门讨论 2017-05-22 09:28:34
    springboot集成hibernate无jpa,在dao中使用SessionFactory操作数据库
  • Hibernate入门第一讲——Hibernate框架的快速入门

    万次阅读 多人点赞 2019-08-04 14:59:27
    Hibernate框架介绍什么是Hibernate我们可以从度娘上摘抄这样有关Hibernate的介绍: Hibernate是一个开放源代码的对象关系映射框架,它对JDBC进行了非常轻量级的对象封装,它将POJO与数据库表建立映射关系,是一个全...

    Hibernate框架的概述

    什么是框架?

    框架指的是软件的半成品,已经完成了部分功能。

    JavaEE开发的三层架构

    了解框架的基本概念之后,我们就来看看Hibernate框架处于JavaEE开发的经典三层架构中的什么位置。
    在这里插入图片描述
    温馨提示:虽然Servlet+JSP+JavaBean+JDBC使用这套架构可以开发市面的所有应用(拥有它,你就能打天下),但是在企业中并不会使用(过于底层),这还有个屌用啊!企业中开发一般使用SSH(Struts2+Spring+Hibernate)和SSM(SpringMVC+Spring+MyBatis)。

    Hibernate概述

    什么是Hibernate?

    我们可以从度娘上看到这样有关Hibernate的介绍:
    在这里插入图片描述
    从中,我们可以得出这样的结论:Hibernate是一个轻量级的JDBC封装,也就是说,我们可以使用Hibernate来完成原来我们使用JDBC完成的操作,也就是与数据库的交互操作。它是在Dao层去使用的。总而言之,Hibernate就是一个持久层的ORM框架

    什么是ORM?

    使用传统的JDBC开发应用系统时,如果是小型应用系统,并不觉得有什么麻烦,但是对于大型应用系统的开发,使用JDBC就会显得力不从心。例如对几十、几百张包含几十个字段的表进行插入操作时,编写的SQL语句不但很长,而且繁琐,容易出错;在读取数据时,需要写多条getXxx语句从结果集中取出各个字段的信息,不但枯燥重复,并且工作量非常大。为了提高数据访问层的编程效率,Gavin King开发出了一个当今最流行的的ORM框架,它就是Hibernate框架。
    所谓的ORM就是利用描述对象和数据库表之间映射的元数据,自动把Java应用程序中的对象,持久化到关系型数据库的表中。通过操作Java对象,就可以完成对数据库表的操作。可以把ORM理解为关系型数据和对象的一个纽带,开发人员只需要关注纽带一端映射的对象即可。ORM原理如下图所示。
    在这里插入图片描述
    说那么多,无非就是想说说ORM是个什么东西,对象关系映射(英语:Object Relation Mapping,简称ORM,或O/RM,或O/R mapping),指的是将一个Java中的对象与关系型数据库中的表建立一种映射关系,从而操作对象就可以操作数据库中的表。就这么简单,说那么多干嘛!

    为什么要学习Hibernate框架?

    与其它操作数据库的技术相比,Hibernate具有以下几点优势:

    • Hibernate对JDBC访问数据库的代码做了轻量级封装,大大简化了数据访问层繁琐的重复性代码,并且减少了内存消耗,加快了运行效率;
    • Hibernate是一个基于JDBC的主流持久化框架,是一个优秀的ORM实现,它很大程度的简化了DAO(Data Access Object,数据访问对象)层编码工作;
    • Hibernate的性能非常好,映射的灵活性很出色。它支持很多关系型数据库,从一对一到多对多的各种复杂关系;
    • 可扩展性强,由于源代码的开源以及API的开放,当本身功能不够用时,可以自行编码进行扩展。

    总结:Hibernate是企业级开发中的主流框架,映射的灵活性很出色,并且它支持很多关系型数据库。

    Hiberate框架学习目标

    由于之前学过Hiberate框架,所以这就等于是在复习了。对于Hiberate框架的学习重点,可以总结为:

    1. 掌握Hiberate的基本配置——即搭建Hiberate开发环境;
    2. 掌握Hiberate常用API——即如何使用Hiberate框架进行开发;
    3. 掌握Hiberate的关联映射——解决表与表之间存在的关系问题,有1:n(一对多)、 1:1(一对一)、m:n(多对多)关系;
    4. 掌握Hiberate的检索方式——即掌握Hiberate的查询;
    5. 掌握Hiberate的优化方式——即提高Hiberate的效率。

    Hibernate快速入门

    介绍完Hibernate框架之后,我们来快速入门Hibernate,对其有一个直观的了解。

    下载Hibernate5

    大家可去官网下载Hibernate,我下载的是
    这里写图片描述
    所以,之后有关Hibernate的系列文章都是以这个版本为蓝图展开的。下载解压缩之后,可以看到如下目录结构:
    这里写图片描述

    其中,在lib/required目录下,包含运行Hibernate项目所必须的jar包:
    这里写图片描述

    创建一个普通的Java项目,导入Hibernate框架相关依赖jar包

    创建一个普通的Java项目,例如hibernate_demo01,然后导入Hibernate框架相关依赖jar包。

    • 首先导入Hibernate开发必须的jar包,即lib/required目录下所有的jar包:
      这里写图片描述

    • 再导入MySQL数据库的驱动jar包:
      这里写图片描述

    • 最后导入日志记录相关的jar包:
      这里写图片描述
      导入完日志相关的jar包之后,我们还要导入日志记录文件,日志记录文件咱也是第一次接触,不知道咋写啊?没关系,找到project/etc/log4j.properties文件,很明显,它就是日志记录文件,将它拷贝复制到我们项目的src目录下,打开它,这里面的内容有点多啊!而且我们现在也不知道是什么意思,咋办?先跟着我将其内容精简为下面这样,后面我再来为大家做一点解释。

      ### direct log messages to stdout ###
      log4j.appender.stdout=org.apache.log4j.ConsoleAppender
      log4j.appender.stdout.Target=System.err
      log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
      log4j.appender.stdout.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n
      
      ### direct messages to file mylog.log ###
      log4j.appender.file=org.apache.log4j.FileAppender
      log4j.appender.file.File=c\:mylog.log
      log4j.appender.file.layout=org.apache.log4j.PatternLayout
      log4j.appender.file.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n
      
      ### set log levels - for more verbose logging change 'info' to 'debug' ###
      # error warn info debug trace
      log4j.rootLogger= info, stdout
      

    这样工程的整个结构就变成:
    在这里插入图片描述

    创建数据库与表

    正如前面所说,Hibernate是一个轻量级的JDBC封装,也就是说,我们可以使用Hibernate来完成原来我们使用JDBC完成的操作,也就是与数据库的交互操作。所以我们首先要创建数据库与表,这里我使用的数据库是MySQL。

    create database hibernate_demo01;
    use hibernate_demo01;
    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;
    

    创建实体类

    我们在com.meimeixia.hibernate.demo01包中创建一个实体类——Customer.java,如下:

    package com.meimeixia.hibernate.demo01;
    
    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 Long getCust_id() {
    		return cust_id;
    	}
    	public void setCust_id(Long cust_id) {
    		this.cust_id = cust_id;
    	}
    	public String getCust_name() {
    		return cust_name;
    	}
    	public void setCust_name(String cust_name) {
    		this.cust_name = cust_name;
    	}
    	public String getCust_source() {
    		return cust_source;
    	}
    	public void setCust_source(String cust_source) {
    		this.cust_source = cust_source;
    	}
    	public String getCust_industry() {
    		return cust_industry;
    	}
    	public void setCust_industry(String cust_industry) {
    		this.cust_industry = cust_industry;
    	}
    	public String getCust_level() {
    		return cust_level;
    	}
    	public void setCust_level(String cust_level) {
    		this.cust_level = cust_level;
    	}
    	public String getCust_phone() {
    		return cust_phone;
    	}
    	public void setCust_phone(String cust_phone) {
    		this.cust_phone = cust_phone;
    	}
    	public String getCust_mobile() {
    		return cust_mobile;
    	}
    	public void setCust_mobile(String cust_mobile) {
    		this.cust_mobile = cust_mobile;
    	}
    	@Override
    	public String toString() {
    		return "Customer [cust_id=" + cust_id + ", cust_name=" + cust_name + ", cust_source=" + cust_source
    				+ ", cust_industry=" + cust_industry + ", cust_level=" + cust_level + ", cust_phone=" + cust_phone
    				+ ", cust_mobile=" + cust_mobile + "]";
    	}
    	
    }
    

    创建Hibernate的相关配置文件

    准备好以上工作之后,我们终于要踏入Hibernate的学习中了。首先我们要编写Hibernate的相关配置文件,Hibernate的相关配置文件分为两种:

    1. Xxx.hbm.xml:它主要是用于描述类与数据库中的表的映射关系;
    2. hibernate.cfg.xml:它是Hibernate框架的核心配置文件。

    有关这两个配置文件的详细介绍,我后面会给大家讲解,如果就在这里弄的话,违背了我的初衷了,本文只是在教初学者怎样快速入门Hibernate。

    创建映射配置文件

    首先我们要学会如何编写映射配置文件,大家要知道编写完的映射配置文件应与实体类在同一个包下,并且名称应是类名.hbm.xml,所以我们要在com.meimeixia.hibernate.demo01包下创建一个Customer.hbm.xml文件,但是它的约束应该怎么写呢?可以在Hibernate的核心jar包——hibernate-core-5.0.7.Final.jar的org.hibernate包下查找到hibernate-mapping-3.0.dtd文件,打开该文件,找到如下内容:
    在这里插入图片描述
    然后复制黏贴到Customer.hbm.xml文件中即可。这里我先给出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="com.meimeixia.hibernate.demo01.Customer" table="cst_customer">
    		<!-- 建立类中的属性与表中的主键相对应 -->
    		<id name="cust_id" column="cust_id">
    			<!-- 主键的生成策略,后面会讲,现在使用的是本地生成策略 -->
    			<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>
    

    创建核心配置文件

    核心配置文件主要是Hibernate框架所使用的,它主要包含了连接数据库的相关信息和Hibernate的相关配置等。现在我们要学会如何编写Hibernate的核心配置文件,大家也要知道编写完的核心配置文件应在src目录下,并且名称应是hibernate.cfg.xml,所以我们要在src目录下创建一个hibernate.cfg.xml文件,但是它的约束又应该怎么写呢?同样可以在Hibernate的核心jar包——hibernate-core-5.0.7.Final.jar的org.hibernate包下查找到hibernate-configuration-3.0.dtd文件,打开该文件,找到如下内容:
    在这里插入图片描述
    然后复制黏贴到hibernate.cfg.xml文件中即可。在这个文件中到底该如何配置呢?我们可以参考hibernate-release-5.0.7.Final\project\etc\hibernate.properties文件。这里我先给出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>
    	<session-factory>
    		<!-- 下面是三个必须要有的配置 -->
    		<!-- 配置连接MySQL数据库的基本参数 -->
    		<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
    		<property name="hibernate.connection.url">jdbc:mysql:///hibernate_demo01</property>
    		<property name="hibernate.connection.username">root</property>
    		<property name="hibernate.connection.password">liayun</property>
    		
    		<!-- 配置Hibernate的方言 -->
    		<property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
    		
    		<!-- 下面两个是可选的配置哟! -->
    		<!-- 打印sql语句 -->
    		<property name="hibernate.show_sql">true</property>
    		<!-- 格式化sql语句 -->
    		<property name="hibernate.format_sql">true</property>
    		
    		<!-- 告诉Hibernate的核心配置文件加载哪个映射文件 -->
    		<mapping resource="com/meimeixia/hibernate/demo01/Customer.hbm.xml"/>
    	</session-factory>
    </hibernate-configuration>
    

    Hibernate快速入门开发测试

    在com.meimeixia.hibernate.demo01包下创建一个单元测试类——HibernateDemo1.java。

    package com.meimeixia.hibernate.demo01;
    
    import org.hibernate.Session;
    import org.hibernate.SessionFactory;
    import org.hibernate.Transaction;
    import org.hibernate.cfg.Configuration;
    import org.junit.Test;
    
    /**
     * Hibernate的入门案例
     * @author liayun
     *
     */
    public class HibernateDemo1 {
    	
    	//保存用户的案例
    	@Test
    	public void demo1() {
    		//1. 加载Hibernate的核心配置文件
    		Configuration configuration = new Configuration().configure();
    		//如果在Hibernate的核心配置文件没有设置加载哪个映射文件,则可手动加载映射文件
    		//configuration.addResource("com/meimeixia/hibernate/demo01/Customer.hbm.xml");
    		
    		//2. 创建SessionFactory对象,类似于JDBC中的连接池
    		SessionFactory sessionFactory = configuration.buildSessionFactory();
    		
    		//3. 通过SessionFactory获取到Session对象,类似于JDBC中的Connection
    		Session session = sessionFactory.openSession();
    		
    		//4. 手动开启事务,(最好是手动开启事务)
    		Transaction transaction = session.beginTransaction();
    		
    		//5. 编写代码
    		Customer customer = new Customer();
    		customer.setCust_name("张小敬aaa");
    		
    		session.save(customer);//保存一个用户
    		
    		//6. 事务提交
    		transaction.commit();
    		
    		//7. 释放资源
    		session.close();
    		sessionFactory.close();
    	}
    	
    }
    

    测试如若都无任何问题,则我们就算入门Hibernate了。

    Hibernate执行原理总结

    可从度娘上看到如下文字:
    在这里插入图片描述
    码字不易,希望大家能够喜欢!

    展开全文
  • hibernate-validator jar 包

    2016-07-18 11:05:07
    hibernate-validator用于验证对象属性。包含hibernate-validator-4.3.0.Final.jar、jboss-logging-3.1.0.CR2.jar、validation-api-1.0.0.GA.jar三个包
  • 最新版本的Struts2+Spring4+Hibernate4框架整合

    千次下载 热门讨论 2014-10-15 14:39:34
    项目原型:Struts2.3.16 + Spring4.1.1 + Hibernate4.3.6 二、 项目目的: 整合使用最新版本的三大框架(即Struts2、Spring4和Hibernate4),搭建项目架构原型。 项目架构原型:Struts2.3.16 + Spring4.1.1 + ...
  • hibernate需要的jar包

    千次下载 热门讨论 2016-03-18 15:57:34
    hibernate配置时所需要的jar包。
  • hibernate3.3.2官方完整版(hibernate开发)

    千次下载 热门讨论 2013-09-22 21:48:56
    hibernate3.3.2.zip,此压缩包包含hibernate-distribution-3.3.2.GA、hibernate-annotations-3.4.0.GA及slf4j-1.5.8。使用此压缩包内jar包即可进行hibernate开发。
  • hibernate-tools-4.3.1.Final

    2015-10-19 15:26:02
    hibernate-tools-4.3.1.Final.jar 可以逆向生成数据库的注释,替换Eclipse目录下相应版本的包,在Eclipse mar先安装Jboss Tools插件,再替换Eclipse下相应的jar文件(在目录下搜索hibernate-tools-4),重启Eclipse...
  • hibernate4必备jar包

    2015-10-01 22:41:17
    hibernate4必备jar包,是hibernate4运行时缺一不可的
  • 随着struts的安全问题的暴露,原由Struts2+spring+hibernate构成的SSH2已经被越来越多的开发者所弃用,反而,由Spring+SpringMVC+Hibernate构成的SSH框架越来越受欢迎!这里提供了一个案例代码,希望对大家搭建环境...
  • hibernate 最新的开发包, 网上搜了下, 国内居然很少有最新版的下载资源, 从官方网站下载下来传CSDN上, 但是大小限制只能70M, 所以只能放到百度云盘.
  • HIbernate4.3.6整合c3p0所需jar

    千次下载 热门讨论 2014-07-27 09:21:02
    org.hibernate.service.spi.ServiceException: Unable to create requested service [org.hibernate.engine.jdbc.connections.spi.ConnectionProvider] at org.hibernate.service.internal....
  • hibernate-release-5.0.2.Final API.chm

    热门讨论 2015-10-29 16:13:54
    hibernate-release-5.0.2.Final API.chm 参考文档,有了这个,就不用联网查看API参考文档了
  • Hibernate入门第三讲——Hibernate的常见配置

    万次阅读 多人点赞 2019-08-05 08:34:30
    在《Hibernate快速入门》一文中,我有讲到Hibernate的两个配置文件,今天就来详细地介绍这两个配置文件。Hibernate的配置详解在Hibernate中,我们使用时主要有两种配置文件: 核心配置文件——hibernate.cfg.xml...

    《Hibernate入门第一讲——Hibernate框架的快速入门》一讲中,我有讲到Hibernate的两个配置文件,今天就来详细地介绍这两个配置文件。在Hibernate中,我们主要使用两种配置文件:

    • 核心配置文件——hibernate.cfg.xml(主要描述Hibernate的相关配置);
    • 映射配置文件——xxx.hbm.xml。

    映射配置文件

    映射配置文件的名称是类名.hbm.xml,它一般放置在实体类所在的包下。这个配置文件的主要作用是建立表与类之间的映射关系。下面我来粗略地介绍一下该映射配置文件,当然你可以在以后的Hibernate学习中逐渐地补全一些细枝末节。

    • 如果统一声明包名,那么在<class>标签的name属性的值中就不需要写类的全名了;
      在这里插入图片描述

    • 关于<class>标签配置的详细介绍:

      • 该标签用来建立类与表的映射关系。
      • 该标签中有如下这些属性:
        • name属性:类的全路径
        • table属性:映射到数据库里面的那个表的名称,如果表的名称与类名一致,那么table属性可以省略
        • catalog属性:数据库名称,可以省略,如果省略,则参考核心配置文件中url路径中的库名称
    • 关于<id>标签配置的详细介绍:
      在这里插入图片描述
      首先该标签必须存在,该标签用来建立类中的id属性与表中的主键的对应关系。该标签中有如下这些属性:

      • name:类中的属性名称
      • column:表中的主键名称,类中的属性名和表中的字段名(主键名)如果一致,column可以省略
      • length:字段长度,如果length忽略不写,且你的表是自动创建这种方案,那么length的默认长度是255(可以根据你的映射文件自动建表,如果现在数据库里面是没有表的,那么只要一运行咱们的程序,它就可以帮你把表建起来。如果你没有给定长度,那么它便会使用默认长度,像字符串的长度默认就是255)
      • type:指定类型,你可以不用写,Hibernate会帮你自动转换

      该标签中的<generator>子标签主要是描述主键生成策略的,这里就不做篇幅来介绍了,请看后面的文章。

    • 关于<property>标签

      • 该标签用来建立类中的普通属性与表中非主键字段的对应关系。
      • 该标签中有如下这些属性:
        • name:类中的属性名
        • column:表中的字段名
        • length:长度
        • type:类型
        • not-null:设置是否非空
        • unique:设置唯一

    关于Hibernate映射配置文件中的类型问题

    对于type属性它的取值可以有三种:

    1. Java中的数据类型;
    2. Hibernate中的数据类型;
    3. SQL的数据类型。

    可参考下表:
    在这里插入图片描述
    这样看来,我实体类(Customer.java)的映射配置文件可以写为:
    在这里插入图片描述
    或者
    在这里插入图片描述

    核心配置文件

    Hibernate的核心配置文件,即hibernate.cfg.xml,主要用来描述Hibernate的相关配置。对于Hibernate的核心配置文件它有两种方式:

    • 第一种方式:属性文件,即hibernate.properties,其内容应该是这样子的:

      hibernate.connection.driver_class=com.mysql.jdbc.Driver
      ...
      hibernate.show_sql=true
      

      温馨提示:这种属性文件的方式不能引入映射文件,须手动编写代码加载映射文件。

    • 第二种方式:XML文件,即hibernate.cfg.xml。

    我们在开发中使用比较多的是hibernate.cfg.xml这种方式,原因是它的配置能力更强,并且易于修改。所以我主要讲解的是hibernate.cfg.xml这种配置方式。我就以《Hibernate入门第一讲——Hibernate框架的快速入门》一文案例中的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>
    	<session-factory>
    		<!-- 下面是三个必须要有的配置 -->
    		<!-- 配置连接MySQL数据库的基本参数 -->
    		<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
    		<property name="hibernate.connection.url">jdbc:mysql:///hibernate_demo01</property>
    		<property name="hibernate.connection.username">root</property>
    		<property name="hibernate.connection.password">liayun</property>
    		
    		<!-- 配置Hibernate的方言 -->
    		<property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
    		
    		<!-- 下面两个是可选的配置哟! -->
    		<!-- 打印sql语句 -->
    		<property name="hibernate.show_sql">true</property>
    		<!-- 格式化sql语句 -->
    		<property name="hibernate.format_sql">true</property>
    		
    		<!-- 告诉Hibernate的核心配置文件加载哪个映射文件 -->
    		<mapping resource="com/meimeixia/hibernate/demo01/Customer.hbm.xml"/>
    	</session-factory>
    </hibernate-configuration>
    

    可将以上配置文件的内容分为3部分来看待:

    • 加载数据库相关信息
      在这里插入图片描述
    • Hibernate的相关配置
      在这里插入图片描述
    • 加载映射配置文件
      在这里插入图片描述

    温馨提示:对于hibernate.cfg.xml配置文件中的要配置的内容可以参考project/etc/hibernate.properties文件中的配置。如果你查阅hibernate.properties文件,便可发现有如下内容:
    在这里插入图片描述
    那么hibernate.hbm2ddl.auto这个玩意到底是个什么东东呢?这儿我就来详解讲讲,先说结论:配置这个玩意之后,我们就可以进行表的自动创建。这个玩意有如下5个取值:

    • none:不使用Hibernate帮我们自动建表;

    • create:如果数据库中已经有了表,则删除原有表,重新创建;如果没有表,则新建表。即每次都会创建一个新的表,但不删除,一般在测试中使用。下面我来举例说明该属性值,要知道我也是在《Hibernate入门第一讲——Hibernate框架的快速入门》一文案例的基础上来讲解的。
      首先在hibernate.cfg.xml配置文件中加入如下内容:

      <!-- 自动创建表 -->
      <property name="hibernate.hbm2ddl.auto">create</property>
      

      在这里插入图片描述
      然后执行单元测试类——HibernateDemo1.java中的demo1()方法:

      package com.meimeixia.hibernate.demo01;
      
      import org.hibernate.Session;
      import org.hibernate.SessionFactory;
      import org.hibernate.Transaction;
      import org.hibernate.cfg.Configuration;
      import org.junit.Test;
      
      /**
       * Hibernate的入门案例
       * @author liayun
       *
       */
      public class HibernateDemo1 {
      	
      	//保存用户的案例
      	@Test
      	public void demo1() {
      		//1. 加载Hibernate的核心配置文件
      		Configuration configuration = new Configuration().configure();
      		//如果在Hibernate的核心配置文件没有设置加载哪个映射文件,则可手动加载映射文件
      		//configuration.addResource("com/meimeixia/hibernate/demo01/Customer.hbm.xml");
      		
      		//2. 创建SessionFactory对象,类似于JDBC中的连接池
      		SessionFactory sessionFactory = configuration.buildSessionFactory();
      		
      		//3. 通过SessionFactory获取到Session对象,类似于JDBC中的Connection
      		Session session = sessionFactory.openSession();
      		
      		//4. 手动开启事务,(最好是手动开启事务)
      		Transaction transaction = session.beginTransaction();
      		
      		//5. 编写代码
      		Customer customer = new Customer();
      		customer.setCust_name("叶子");
      		
      		session.save(customer);//保存一个用户
      		
      		//6. 事务提交
      		transaction.commit();
      		
      		//7. 释放资源
      		session.close();
      		sessionFactory.close();
      	}
      	
      }
      

      此刻,hibernate_demo01数据库里面应该是有cst_customer表的,那么一旦运行以上测试方法,不出意外,我们就能在Eclipse的控制台上看到删表和建表的sql语句:
      在这里插入图片描述
      如果要是hibernate_demo01数据库里面没有cst_customer表,那么一旦运行以上测试方法,我们就只能在Eclipse的控制台上看到建表的sql语句了。

    • create-drop
      如果数据库中已经有表,则删除原有表,再新建一个新表,然后执行操作,执行操作完毕之后再删除这个表(妈的,这可真是毛病啊!幸好,你以后不会用到它);如果没有表,则新建一个,使用完了删除该表,一般也是做测试时用。如果你要对create-drop该属性值进行测试,也很简单,可以像下面这样子做。
      在这里插入图片描述

    • update
      如果数据库中有表,则不创建,使用原有表;如果没有表则创建新表,并且如果映射不匹配,会自动更新表结构。下面我来说道说道该属性值,首先在hibernate.cfg.xml配置文件中加入如下内容:

      <!-- 自动创建表 -->
      <property name="hibernate.hbm2ddl.auto">update</property>
      

      在这里插入图片描述
      然后在实体类——Customer.java中增加一个属性,比如说private String cust_sex

      package com.meimeixia.hibernate.demo01;
      
      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;
      	private String cust_sex;
      	
      	public Long getCust_id() {
      		return cust_id;
      	}
      	public void setCust_id(Long cust_id) {
      		this.cust_id = cust_id;
      	}
      	public String getCust_name() {
      		return cust_name;
      	}
      	public void setCust_name(String cust_name) {
      		this.cust_name = cust_name;
      	}
      	public String getCust_source() {
      		return cust_source;
      	}
      	public void setCust_source(String cust_source) {
      		this.cust_source = cust_source;
      	}
      	public String getCust_industry() {
      		return cust_industry;
      	}
      	public void setCust_industry(String cust_industry) {
      		this.cust_industry = cust_industry;
      	}
      	public String getCust_level() {
      		return cust_level;
      	}
      	public void setCust_level(String cust_level) {
      		this.cust_level = cust_level;
      	}
      	public String getCust_phone() {
      		return cust_phone;
      	}
      	public void setCust_phone(String cust_phone) {
      		this.cust_phone = cust_phone;
      	}
      	public String getCust_mobile() {
      		return cust_mobile;
      	}
      	public void setCust_mobile(String cust_mobile) {
      		this.cust_mobile = cust_mobile;
      	}
      	public String getCust_sex() {
      		return cust_sex;
      	}
      	public void setCust_sex(String cust_sex) {
      		this.cust_sex = cust_sex;
      	}
      	@Override
      	public String toString() {
      		return "Customer [cust_id=" + cust_id + ", cust_name=" + cust_name + ", cust_source=" + cust_source
      				+ ", cust_industry=" + cust_industry + ", cust_level=" + cust_level + ", cust_phone=" + cust_phone
      				+ ", cust_mobile=" + cust_mobile + "]";
      	}
      	
      }
      

      接着修改实体类的映射配置文件(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="com.meimeixia.hibernate.demo01.Customer" table="cst_customer">
      		<!-- 建立类中的属性与表中的主键相对应 -->
      		<id name="cust_id" column="cust_id">
      			<!-- 主键的生成策略,后面会讲,现在使用的是本地生成策略 -->
      			<generator class="native" />
      		</id>
      		
      		<!-- 建立类中的普通属性和表中的字段相对应 -->
      		<property name="cust_name" column="cust_name" length="32" />
      		<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" />
      		<property name="cust_sex" column="cust_sex" />
      	</class>
      </hibernate-mapping>
      

      最后运行单元测试类(HibernateDemo1.java)中的demo1()方法:

      package com.meimeixia.hibernate.demo01;
      
      import org.hibernate.Session;
      import org.hibernate.SessionFactory;
      import org.hibernate.Transaction;
      import org.hibernate.cfg.Configuration;
      import org.junit.Test;
      
      /**
       * Hibernate的入门案例
       * @author liayun
       *
       */
      public class HibernateDemo1 {
      	
      	//保存用户的案例
      	@Test
      	public void demo1() {
      		//1. 加载Hibernate的核心配置文件
      		Configuration configuration = new Configuration().configure();
      		//如果在Hibernate的核心配置文件没有设置加载哪个映射文件,则可手动加载映射文件
      		//configuration.addResource("com/meimeixia/hibernate/demo01/Customer.hbm.xml");
      		
      		//2. 创建SessionFactory对象,类似于JDBC中的连接池
      		SessionFactory sessionFactory = configuration.buildSessionFactory();
      		
      		//3. 通过SessionFactory获取到Session对象,类似于JDBC中的Connection
      		Session session = sessionFactory.openSession();
      		
      		//4. 手动开启事务,(最好是手动开启事务)
      		Transaction transaction = session.beginTransaction();
      		
      		//5. 编写代码
      		Customer customer = new Customer();
      		customer.setCust_name("叶美美");
      		
      		session.save(customer);//保存一个用户
      		
      		//6. 事务提交
      		transaction.commit();
      		
      		//7. 释放资源
      		session.close();
      		sessionFactory.close();
      	}
      	
      }
      

      此时,我们只能在Eclipse的控制台上看到向cst_customer表中插入记录的sql语句了。
      在这里插入图片描述
      你这个时候再去查看cst_customer表可发现该表多出了一个cust_sex字段。
      在这里插入图片描述
      这就已说明了如果映射不匹配,会自动更新表结构。但是注意:只能添加,不能说我这个表里面有3个字段,我映射2个了,然后它就帮我删了,这是不行的!

    • validate
      如果没有表,不会创建表,只会使用数据库中原有的表。它的作用主要是校验映射关系和表结构。为了便于测试validate,先做这样子的准备工作:首先将实体类(Customer.java)中的cust_sex属性去掉,然后再在映射配置文件(Customer.hbm.xml)去掉该cust_sex属性和表中字段的映射,接着将hibernate.cfg.xml配置文件的hibernate.hbm2ddl.auto属性设置为create,最后运行单元测试类(HibernateDemo1.java)中的demo1()方法,这样数据库中就创建好了一个新的cst_customer表,并且已经插入一条记录。
      在这里插入图片描述
      这样,一切都是新的,会更方便我们测试validate。这里再次在实体类(Customer.java)中增加cust_sex属性,

      package com.meimeixia.hibernate.demo01;
      
      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;
      	private String cust_sex;
      	
      	public Long getCust_id() {
      		return cust_id;
      	}
      	public void setCust_id(Long cust_id) {
      		this.cust_id = cust_id;
      	}
      	public String getCust_name() {
      		return cust_name;
      	}
      	public void setCust_name(String cust_name) {
      		this.cust_name = cust_name;
      	}
      	public String getCust_source() {
      		return cust_source;
      	}
      	public void setCust_source(String cust_source) {
      		this.cust_source = cust_source;
      	}
      	public String getCust_industry() {
      		return cust_industry;
      	}
      	public void setCust_industry(String cust_industry) {
      		this.cust_industry = cust_industry;
      	}
      	public String getCust_level() {
      		return cust_level;
      	}
      	public void setCust_level(String cust_level) {
      		this.cust_level = cust_level;
      	}
      	public String getCust_phone() {
      		return cust_phone;
      	}
      	public void setCust_phone(String cust_phone) {
      		this.cust_phone = cust_phone;
      	}
      	public String getCust_mobile() {
      		return cust_mobile;
      	}
      	public void setCust_mobile(String cust_mobile) {
      		this.cust_mobile = cust_mobile;
      	}
      	public String getCust_sex() {
      		return cust_sex;
      	}
      	public void setCust_sex(String cust_sex) {
      		this.cust_sex = cust_sex;
      	}
      	@Override
      	public String toString() {
      		return "Customer [cust_id=" + cust_id + ", cust_name=" + cust_name + ", cust_source=" + cust_source
      				+ ", cust_industry=" + cust_industry + ", cust_level=" + cust_level + ", cust_phone=" + cust_phone
      				+ ", cust_mobile=" + cust_mobile + "]";
      	}
      	
      }
      

      接着在实体类的映射配置文件(Customer.hbm.xml)中加上该cust_sex属性和表中字段的映射。

      <?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="com.meimeixia.hibernate.demo01.Customer" table="cst_customer">
      		<!-- 建立类中的属性与表中的主键相对应 -->
      		<id name="cust_id" column="cust_id">
      			<!-- 主键的生成策略,后面会讲,现在使用的是本地生成策略 -->
      			<generator class="native" />
      		</id>
      		
      		<!-- 建立类中的普通属性和表中的字段相对应 -->
      		<property name="cust_name" column="cust_name" length="32" />
      		<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" />
      		<property name="cust_sex" column="cust_sex" />
      	</class>
      </hibernate-mapping>
      

      从上可以看出表结构与映射文件已经不匹配了。下面将hibernate.cfg.xml配置文件的hibernate.hbm2ddl.auto属性设置为validate。

      <!-- 自动创建表 -->
      <property name="hibernate.hbm2ddl.auto">validate</property>
      

      在这里插入图片描述
      再次运行单元测试类(HibernateDemo1.java)中的demo1()方法,这时就能看到报如下异常:
      在这里插入图片描述
      也即说明了如果表结构与映射文件不匹配,会报异常。

    展开全文
  • Hibernate连接Mycat例子详解

    热门讨论 2015-05-07 11:49:44
    使用Java持久层框架Hibernate连接Mycat分布式数据库中间件的简单例子详解,包含完整实例源码、编译代码所需的全部Lib库文件,说明文档,以及数据库相关SQL文件。
  • 项目原型:Struts2.3.16 + Spring4.1.1 + Hibernate4.3.6 + Quartz2.2.1 二、 项目目的: 整合使用最新版本的三大框架(即Struts2、Spring4和Hibernate4),搭建项目架构原型。 项目架构原型:Struts2.3.16 + ...
  • hibernate-release-4.2.21.Final官方原版

    热门讨论 2015-11-19 09:19:52
    hibernate-release-4.2.21.Final官方原版
  • 用Maven整合SpringMVC+Spring+Hibernate 框架

    热门讨论 2014-09-28 17:06:26
    用Maven整合Spring SpringMvc Hibernate 框架 ,仅实现简单的插入数据库数据功能。具体搭建地址: http://blog.csdn.net/js931178805/article/details/39642743
  • hibernate-annotations jar包

    千次下载 热门讨论 2013-07-10 14:15:29
    使用注解Annotation时用的jar包。 包括: hibernate-commons-annotations-3.3.0.ga.jar hibernate-entitymanager.jar ejb3-persistence.jar hibernate-annotations.jar
  • Eclipse中Hibernate插件。
  • hibernate-3.6.10.Final.rar

    热门讨论 2014-04-07 12:40:30
    hibernate-3.6.10.Final.rar,用于Java开发中的Hibernate技术
  • 完美整合,自己动手写的代码,希望可以帮到大家,下载时一定注意版本
  • SpringMVC+Hibernate+Spring整合实例

    千次下载 热门讨论 2013-05-31 15:49:34
    SpringMVC+Hibernate+Spring整合实例源码下载,很完整的例子,需要的可以下载源码学习
  • 达梦Hibernate方言2.0至4.0
  • 因为Hibernate在读出hbm.xml文件时需要通过网络读取到hibernate-mapping-3.0.dtd 文件。 如果没有网络不能正常工作。 所以提供上述文件。 以及hibernate-mapping-3.0.dtd,hibernate-configuration-3.0.dtd提供下载...
  • hibernate-release-4.3.5.Final.zip

    热门讨论 2014-05-27 18:10:42
    hibernate-release-4.3.5.Final.zip 最新 稳定 最终版
  • Maven搭建spring_struts2_Hibernate_demo

    热门讨论 2015-03-01 15:09:23
    Maven搭建spring_struts2_Hibernate项目源码,包括数据库,博客地址:http://blog.csdn.net/fengshizty/article/details/43794911
  • Hibernate3的依赖包

    千次下载 热门讨论 2013-08-20 08:27:03
    HIbernate3框架的依赖包。 使用说明:下载完成后,直接将解压缩后文件夹中的jar包引入到Eclipse中即可
  • Hibernate之配置文件

    千次阅读 2018-05-08 17:31:56
    在上一篇博客中我已经说明了jar包的下载,jar中提供给了我们很多关于hibernate的配置信息,这里主要说明几样平常项目常用的. 进入源码包 . 1.连接数据库四要素 ## MySQL #hibernate.dialect org....

    在上一篇博客中我已经说明了jar包的下载,jar中提供给了我们很多关于hibernate的配置信息,这里主要说明几样平常项目常用的.
    这里写图片描述

    进入源码包

    这里写图片描述

    .
    这里写图片描述

    1.连接数据库四要素

    ## MySQL
    
    #hibernate.dialect org.hibernate.dialect.MySQLDialect
    #hibernate.dialect org.hibernate.dialect.MySQLInnoDBDialect
    #hibernate.dialect org.hibernate.dialect.MySQLMyISAMDialect
    #hibernate.connection.driver_class com.mysql.jdbc.Driver
    #hibernate.connection.url jdbc:mysql:///test
    #hibernate.connection.username gavin
    #hibernate.connection.password

    2.配置数据源

    若不使用第三方数据源,则使用默认配置数据源

    #hibernate.connection.provider_class org.hibernate.connection.DriverManagerConnectionProvider
    #hibernate.connection.provider_class org.hibernate.connection.DatasourceConnectionProvider
    #hibernate.connection.provider_class org.hibernate.connection.C3P0ConnectionProvider
    #hibernate.connection.provider_class org.hibernate.connection.ProxoolConnectionProvider

    3.配置当前Session的上下文

    指定当前session为上下文,(同一线程内使用的session为同一Session)

    <!-- session -->
        <property name="hibernate.current_session_context_class">thread</property>

    4.自动建表

    <!-- 自动建表 -->
        <property name="hibernate.hbm2ddl.auto">true</property>

    5.SQL语句显示在控制台

     <!-- 显示SQL语句-->
        <property name="show_sql">true</property>
        <!-- 显示语句格式 -->
        <property name="format_sql">true</property>

    6.注册映射文件

    <mapping resource="com/xxx/User.hbm.xml" />

    =========hibernate.properties============

    #
    # Hibernate, Relational Persistence for Idiomatic Java
    #
    # License: GNU Lesser General Public License (LGPL), version 2.1 or later.
    # See the lgpl.txt file in the root directory or <http://www.gnu.org/licenses/lgpl-2.1.html>.
    #
    
    ######################
    ### Query Language ###
    ######################
    
    ## define query language constants / function names
    
    hibernate.query.substitutions yes 'Y', no 'N'
    
    
    ## select the classic query parser
    
    #hibernate.query.factory_class org.hibernate.hql.internal.classic.ClassicQueryTranslatorFactory
    
    
    
    #################
    ### Platforms ###
    #################
    
    ## JNDI Datasource
    
    #hibernate.connection.datasource jdbc/test
    #hibernate.connection.username db2
    #hibernate.connection.password db2
    
    
    ## HypersonicSQL
    
    hibernate.dialect org.hibernate.dialect.HSQLDialect
    hibernate.connection.driver_class org.hsqldb.jdbcDriver
    hibernate.connection.username sa
    hibernate.connection.password
    hibernate.connection.url jdbc:hsqldb:./build/db/hsqldb/hibernate
    #hibernate.connection.url jdbc:hsqldb:hsql://localhost
    #hibernate.connection.url jdbc:hsqldb:test
    
    ## H2 (www.h2database.com)
    #hibernate.dialect org.hibernate.dialect.H2Dialect
    #hibernate.connection.driver_class org.h2.Driver
    #hibernate.connection.username sa
    #hibernate.connection.password
    #hibernate.connection.url jdbc:h2:mem:./build/db/h2/hibernate
    #hibernate.connection.url jdbc:h2:testdb/h2test
    #hibernate.connection.url jdbc:h2:mem:imdb1
    #hibernate.connection.url jdbc:h2:tcp://dbserv:8084/sample;     
    #hibernate.connection.url jdbc:h2:ssl://secureserv:8085/sample;     
    #hibernate.connection.url jdbc:h2:ssl://secureserv/testdb;cipher=AES
    
    ## MySQL
    
    #hibernate.dialect org.hibernate.dialect.MySQLDialect
    #hibernate.dialect org.hibernate.dialect.MySQLInnoDBDialect
    #hibernate.dialect org.hibernate.dialect.MySQLMyISAMDialect
    #hibernate.connection.driver_class com.mysql.jdbc.Driver
    #hibernate.connection.url jdbc:mysql:///test
    #hibernate.connection.username gavin
    #hibernate.connection.password
    
    
    ## Oracle
    
    #hibernate.dialect org.hibernate.dialect.Oracle8iDialect
    #hibernate.dialect org.hibernate.dialect.Oracle9iDialect
    #hibernate.dialect org.hibernate.dialect.Oracle10gDialect
    #hibernate.connection.driver_class oracle.jdbc.driver.OracleDriver
    #hibernate.connection.username ora
    #hibernate.connection.password ora
    #hibernate.connection.url jdbc:oracle:thin:@localhost:1521:orcl
    #hibernate.connection.url jdbc:oracle:thin:@localhost:1522:XE
    
    
    ## PostgreSQL
    
    #hibernate.dialect org.hibernate.dialect.PostgreSQLDialect
    #hibernate.connection.driver_class org.postgresql.Driver
    #hibernate.connection.url jdbc:postgresql:template1
    #hibernate.connection.username pg
    #hibernate.connection.password
    
    
    ## DB2
    
    #hibernate.dialect org.hibernate.dialect.DB2Dialect
    #hibernate.connection.driver_class com.ibm.db2.jcc.DB2Driver
    #hibernate.connection.driver_class COM.ibm.db2.jdbc.app.DB2Driver
    #hibernate.connection.url jdbc:db2://localhost:50000/somename
    #hibernate.connection.url jdbc:db2:somename
    #hibernate.connection.username db2
    #hibernate.connection.password db2
    
    ## TimesTen
    
    #hibernate.dialect org.hibernate.dialect.TimesTenDialect
    #hibernate.connection.driver_class com.timesten.jdbc.TimesTenDriver
    #hibernate.connection.url jdbc:timesten:direct:test
    #hibernate.connection.username
    #hibernate.connection.password 
    
    ## DB2/400
    
    #hibernate.dialect org.hibernate.dialect.DB2400Dialect
    #hibernate.connection.username user
    #hibernate.connection.password password
    
    ## Native driver
    #hibernate.connection.driver_class COM.ibm.db2.jdbc.app.DB2Driver
    #hibernate.connection.url jdbc:db2://systemname
    
    ## Toolbox driver
    #hibernate.connection.driver_class com.ibm.as400.access.AS400JDBCDriver
    #hibernate.connection.url jdbc:as400://systemname
    
    
    ## Derby (not supported!)
    
    #hibernate.dialect org.hibernate.dialect.DerbyDialect
    #hibernate.connection.driver_class org.apache.derby.jdbc.EmbeddedDriver
    #hibernate.connection.username
    #hibernate.connection.password
    #hibernate.connection.url jdbc:derby:build/db/derby/hibernate;create=true
    
    
    ## Sybase
    
    #hibernate.dialect org.hibernate.dialect.SybaseDialect
    #hibernate.connection.driver_class com.sybase.jdbc2.jdbc.SybDriver
    #hibernate.connection.username sa
    #hibernate.connection.password sasasa
    #hibernate.connection.url jdbc:sybase:Tds:co3061835-a:5000/tempdb
    
    
    ## Mckoi SQL
    
    #hibernate.dialect org.hibernate.dialect.MckoiDialect
    #hibernate.connection.driver_class com.mckoi.JDBCDriver
    #hibernate.connection.url jdbc:mckoi:///
    #hibernate.connection.url jdbc:mckoi:local://C:/mckoi1.0.3/db.conf
    #hibernate.connection.username admin
    #hibernate.connection.password nimda
    
    
    ## SAP DB
    
    #hibernate.dialect org.hibernate.dialect.SAPDBDialect
    #hibernate.connection.driver_class com.sap.dbtech.jdbc.DriverSapDB
    #hibernate.connection.url jdbc:sapdb://localhost/TST
    #hibernate.connection.username TEST
    #hibernate.connection.password TEST
    #hibernate.query.substitutions yes 'Y', no 'N'
    
    
    ## MS SQL Server
    
    #hibernate.dialect org.hibernate.dialect.SQLServerDialect
    #hibernate.connection.username sa
    #hibernate.connection.password sa
    
    ## JSQL Driver
    #hibernate.connection.driver_class com.jnetdirect.jsql.JSQLDriver
    #hibernate.connection.url jdbc:JSQLConnect://1E1/test
    
    ## JTURBO Driver
    #hibernate.connection.driver_class com.newatlanta.jturbo.driver.Driver
    #hibernate.connection.url jdbc:JTurbo://1E1:1433/test
    
    ## WebLogic Driver
    #hibernate.connection.driver_class weblogic.jdbc.mssqlserver4.Driver
    #hibernate.connection.url jdbc:weblogic:mssqlserver4:1E1:1433
    
    ## Microsoft Driver (not recommended!)
    #hibernate.connection.driver_class com.microsoft.jdbc.sqlserver.SQLServerDriver
    #hibernate.connection.url jdbc:microsoft:sqlserver://1E1;DatabaseName=test;SelectMethod=cursor
    
    ## The New Microsoft Driver 
    #hibernate.connection.driver_class com.microsoft.sqlserver.jdbc.SQLServerDriver
    #hibernate.connection.url jdbc:sqlserver://localhost
    
    ## jTDS (since version 0.9)
    #hibernate.connection.driver_class net.sourceforge.jtds.jdbc.Driver
    #hibernate.connection.url jdbc:jtds:sqlserver://1E1/test
    
    ## Interbase
    
    #hibernate.dialect org.hibernate.dialect.InterbaseDialect
    #hibernate.connection.username sysdba
    #hibernate.connection.password masterkey
    
    ## DO NOT specify hibernate.connection.sqlDialect
    
    ## InterClient
    
    #hibernate.connection.driver_class interbase.interclient.Driver
    #hibernate.connection.url jdbc:interbase://localhost:3060/C:/firebird/test.gdb
    
    ## Pure Java
    
    #hibernate.connection.driver_class org.firebirdsql.jdbc.FBDriver
    #hibernate.connection.url jdbc:firebirdsql:localhost/3050:/firebird/test.gdb
    
    
    ## Pointbase
    
    #hibernate.dialect org.hibernate.dialect.PointbaseDialect
    #hibernate.connection.driver_class com.pointbase.jdbc.jdbcUniversalDriver
    #hibernate.connection.url jdbc:pointbase:embedded:sample
    #hibernate.connection.username PBPUBLIC
    #hibernate.connection.password PBPUBLIC
    
    
    ## Ingres
    
    ## older versions (before Ingress 2006)
    
    #hibernate.dialect org.hibernate.dialect.IngresDialect
    #hibernate.connection.driver_class ca.edbc.jdbc.EdbcDriver
    #hibernate.connection.url jdbc:edbc://localhost:II7/database
    #hibernate.connection.username user
    #hibernate.connection.password password
    
    ## Ingres 2006 or later
    
    #hibernate.dialect org.hibernate.dialect.IngresDialect
    #hibernate.connection.driver_class com.ingres.jdbc.IngresDriver
    #hibernate.connection.url jdbc:ingres://localhost:II7/database;CURSOR=READONLY;auto=multi
    #hibernate.connection.username user
    #hibernate.connection.password password
    
    ## Mimer SQL
    
    #hibernate.dialect org.hibernate.dialect.MimerSQLDialect
    #hibernate.connection.driver_class com.mimer.jdbc.Driver
    #hibernate.connection.url jdbc:mimer:multi1
    #hibernate.connection.username hibernate
    #hibernate.connection.password hibernate
    
    
    ## InterSystems Cache
    
    #hibernate.dialect org.hibernate.dialect.Cache71Dialect
    #hibernate.connection.driver_class com.intersys.jdbc.CacheDriver
    #hibernate.connection.username _SYSTEM
    #hibernate.connection.password SYS
    #hibernate.connection.url jdbc:Cache://127.0.0.1:1972/HIBERNATE
    
    
    #################################
    ### Hibernate Connection Pool ###
    #################################
    
    hibernate.connection.pool_size 1
    
    
    
    ###########################
    ### C3P0 Connection Pool###
    ###########################
    
    #hibernate.c3p0.max_size 2
    #hibernate.c3p0.min_size 2
    #hibernate.c3p0.timeout 5000
    #hibernate.c3p0.max_statements 100
    #hibernate.c3p0.idle_test_period 3000
    #hibernate.c3p0.acquire_increment 2
    #hibernate.c3p0.validate false
    
    
    
    ##############################
    ### Proxool Connection Pool###
    ##############################
    
    ## Properties for external configuration of Proxool
    
    hibernate.proxool.pool_alias pool1
    
    ## Only need one of the following
    
    #hibernate.proxool.existing_pool true
    #hibernate.proxool.xml proxool.xml
    #hibernate.proxool.properties proxool.properties
    
    
    
    #################################
    ### Plugin ConnectionProvider ###
    #################################
    
    ## use a custom ConnectionProvider (if not set, Hibernate will choose a built-in ConnectionProvider using hueristics)
    
    #hibernate.connection.provider_class org.hibernate.connection.DriverManagerConnectionProvider
    #hibernate.connection.provider_class org.hibernate.connection.DatasourceConnectionProvider
    #hibernate.connection.provider_class org.hibernate.connection.C3P0ConnectionProvider
    #hibernate.connection.provider_class org.hibernate.connection.ProxoolConnectionProvider
    
    
    
    #######################
    ### Transaction API ###
    #######################
    
    ## Enable automatic flush during the JTA beforeCompletion() callback
    ## (This setting is relevant with or without the Transaction API)
    
    #hibernate.transaction.flush_before_completion
    
    
    ## Enable automatic session close at the end of transaction
    ## (This setting is relevant with or without the Transaction API)
    
    #hibernate.transaction.auto_close_session
    
    
    ## the Transaction API abstracts application code from the underlying JTA or JDBC transactions
    
    #hibernate.transaction.factory_class org.hibernate.transaction.JTATransactionFactory
    #hibernate.transaction.factory_class org.hibernate.transaction.JDBCTransactionFactory
    
    
    ## to use JTATransactionFactory, Hibernate must be able to locate the UserTransaction in JNDI
    ## default is java:comp/UserTransaction
    ## you do NOT need this setting if you specify hibernate.transaction.manager_lookup_class
    
    #jta.UserTransaction jta/usertransaction
    #jta.UserTransaction javax.transaction.UserTransaction
    #jta.UserTransaction UserTransaction
    
    
    ## to use the second-level cache with JTA, Hibernate must be able to obtain the JTA TransactionManager
    
    #hibernate.transaction.manager_lookup_class org.hibernate.transaction.JBossTransactionManagerLookup
    #hibernate.transaction.manager_lookup_class org.hibernate.transaction.WeblogicTransactionManagerLookup
    #hibernate.transaction.manager_lookup_class org.hibernate.transaction.WebSphereTransactionManagerLookup
    #hibernate.transaction.manager_lookup_class org.hibernate.transaction.OrionTransactionManagerLookup
    #hibernate.transaction.manager_lookup_class org.hibernate.transaction.ResinTransactionManagerLookup
    
    
    
    ##############################
    ### Miscellaneous Settings ###
    ##############################
    
    ## print all generated SQL to the console
    
    #hibernate.show_sql true
    
    
    ## format SQL in log and console
    
    hibernate.format_sql true
    
    
    ## add comments to the generated SQL
    
    #hibernate.use_sql_comments true
    
    
    ## generate statistics
    
    #hibernate.generate_statistics true
    
    
    ## auto schema export
    
    #hibernate.hbm2ddl.auto create-drop
    #hibernate.hbm2ddl.auto create
    #hibernate.hbm2ddl.auto update
    #hibernate.hbm2ddl.auto validate
    
    
    ## specify a default schema and catalog for unqualified tablenames
    
    #hibernate.default_schema test
    #hibernate.default_catalog test
    
    
    ## enable ordering of SQL UPDATEs by primary key
    
    #hibernate.order_updates true
    
    
    ## set the maximum depth of the outer join fetch tree
    
    hibernate.max_fetch_depth 1
    
    
    ## set the default batch size for batch fetching
    
    #hibernate.default_batch_fetch_size 8
    
    
    ## rollback generated identifier values of deleted entities to default values
    
    #hibernate.use_identifier_rollback true
    
    
    ## enable bytecode reflection optimizer (disabled by default)
    
    #hibernate.bytecode.use_reflection_optimizer true
    
    
    
    #####################
    ### JDBC Settings ###
    #####################
    
    ## specify a JDBC isolation level
    
    #hibernate.connection.isolation 4
    
    
    ## enable JDBC autocommit (not recommended!)
    
    #hibernate.connection.autocommit true
    
    
    ## set the JDBC fetch size
    
    #hibernate.jdbc.fetch_size 25
    
    
    ## set the maximum JDBC 2 batch size (a nonzero value enables batching)
    
    #hibernate.jdbc.batch_size 5
    #hibernate.jdbc.batch_size 0
    
    
    ## enable batch updates even for versioned data
    
    hibernate.jdbc.batch_versioned_data true
    
    
    ## enable use of JDBC 2 scrollable ResultSets (specifying a Dialect will cause Hibernate to use a sensible default)
    
    #hibernate.jdbc.use_scrollable_resultset true
    
    
    ## use streams when writing binary types to / from JDBC
    
    hibernate.jdbc.use_streams_for_binary true
    
    
    ## use JDBC 3 PreparedStatement.getGeneratedKeys() to get the identifier of an inserted row
    
    #hibernate.jdbc.use_get_generated_keys false
    
    
    ## choose a custom JDBC batcher
    
    # hibernate.jdbc.factory_class
    
    
    ## enable JDBC result set column alias caching 
    ## (minor performance enhancement for broken JDBC drivers)
    
    # hibernate.jdbc.wrap_result_sets
    
    
    ## choose a custom SQL exception converter
    
    #hibernate.jdbc.sql_exception_converter
    
    
    
    ##########################
    ### Second-level Cache ###
    ##########################
    
    ## optimize cache for minimal "puts" instead of minimal "gets" (good for clustered cache)
    
    #hibernate.cache.use_minimal_puts true
    
    
    ## set a prefix for cache region names
    
    hibernate.cache.region_prefix hibernate.test
    
    
    ## disable the second-level cache
    
    #hibernate.cache.use_second_level_cache false
    
    
    ## enable the query cache
    
    #hibernate.cache.use_query_cache true
    
    
    ## store the second-level cache entries in a more human-friendly format
    
    #hibernate.cache.use_structured_entries true
    
    
    ## choose a cache implementation
    
    #hibernate.cache.region.factory_class org.hibernate.cache.infinispan.InfinispanRegionFactory
    #hibernate.cache.region.factory_class org.hibernate.cache.infinispan.JndiInfinispanRegionFactory
    #hibernate.cache.region.factory_class org.hibernate.cache.internal.EhCacheRegionFactory
    #hibernate.cache.region.factory_class org.hibernate.cache.internal.SingletonEhCacheRegionFactory
    hibernate.cache.region.factory_class org.hibernate.cache.internal.NoCachingRegionFactory
    
    ## choose a custom query cache implementation
    
    #hibernate.cache.query_cache_factory
    
    
    
    ############
    ### JNDI ###
    ############
    
    ## specify a JNDI name for the SessionFactory
    
    #hibernate.session_factory_name hibernate/session_factory
    
    
    ## Hibernate uses JNDI to bind a name to a SessionFactory and to look up the JTA UserTransaction;
    ## if hibernate.jndi.* are not specified, Hibernate will use the default InitialContext() which
    ## is the best approach in an application server
    
    #file system
    #hibernate.jndi.class com.sun.jndi.fscontext.RefFSContextFactory
    #hibernate.jndi.url file:/
    
    #WebSphere
    #hibernate.jndi.class com.ibm.websphere.naming.WsnInitialContextFactory
    #hibernate.jndi.url iiop://localhost:900/

    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">
    <!-- Generated by MyEclipse Hibernate Tools.                   -->
    <hibernate-configuration>
    
    <session-factory>
        <!-- 数据库方言 -->
        <property name="dialect">org.hibernate.dialect.MySQLDialect</property>
        <!--四要素-->
        <property name="connection.url">jdbc:mysql://localhost:3306/hib</property>
        <property name="connection.username">root</property>
        <property name="connection.password">123456</property>
        <property name="connection.driver_class">com.mysql.jdbc.Driver</property>
        <!-- 配置C3P0数据源 -->
        <property name="hibernate.connection.provider_class">
        org.hibernate.connection.C3P0ConnectionProvider</property>
        <property name="myeclipse.connection.profile">mysql</property>
        <!-- session -->
        <property name="hibernate.current_session_context_class">thread</property>
        <!-- 自动建表 -->
        <property name="hibernate.hbm2ddl.auto">true</property>
        <!-- 显示SQL语句-->
        <property name="show_sql">true</property>
        <!-- 显示语句格式 -->
        <property name="format_sql">true</property>
        <!-- 注册配置文件 -->
        <mapping resource="com/xxx/User.hbm.xml" />
    </session-factory>
    
    </hibernate-configuration>
    展开全文
  • springMVC+Spring3+hibernate4整合实现增删改查demo 1修改beans.xml 中自己数据库用户名 和密码 2在数据库中建立一个名字为springmvc的数据库 3导入eclipse 启动即可运行 4:...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 521,498
精华内容 208,599
关键字:

hibernate