轻松学Java Web开发之Hibernate配置和会话

合集下载

hibernate的基本用法

hibernate的基本用法

hibernate的基本用法Hibernate是一个开源的Java框架,用于简化数据库操作。

它为开发人员提供了一个更加简单、直观的方式来管理数据库,同时也提高了应用程序的性能和可维护性。

本文将逐步介绍Hibernate的基本用法,包括配置、实体映射、数据操作等。

一、配置Hibernate1. 下载和安装Hibernate:首先,我们需要下载Hibernate的压缩包并解压。

然后将解压后的文件夹添加到Java项目的构建路径中。

2. 创建Hibernate配置文件:在解压后的文件夹中,可以找到一个名为"hibernate.cfg.xml"的文件。

这是Hibernate的主要配置文件,我们需要在其中指定数据库连接信息和其他相关配置。

3. 配置数据库连接:在"hibernate.cfg.xml"文件中,我们可以添加一个名为"hibernate.connection.url"的属性,用于指定数据库的连接URL。

除此之外,还需要指定数据库的用户名和密码等信息。

4. 配置实体映射:Hibernate使用对象关系映射(ORM)来将Java类映射到数据库表。

我们需要在配置文件中使用"mapping"元素来指定实体类的映射文件。

这个映射文件描述了实体类与数据库表之间的对应关系。

二、实体映射1. 创建实体类:我们需要创建一个Java类,用于表示数据库中的一行数据。

这个类的字段通常与数据库表的列对应。

同时,我们可以使用Hibernate提供的注解或XML文件来配置实体的映射关系。

2. 创建映射文件:可以根据个人喜好选择使用注解还是XML文件来配置实体类的映射关系。

如果使用XML文件,需要创建一个与实体类同名的XML文件,并在其中定义实体类与数据库表之间的映射关系。

3. 配置实体映射:在配置文件中,我们需要使用"mapping"元素来指定实体类的映射文件。

Hibernate学习笔记

Hibernate学习笔记

Hibernate项目的构建与配置1.在项目里倒入Hibernate所必须的Jar包(1)Hibernate框架可以使用在任何的Java项目里,并不一定是Web项目。

只需要在项目里倒入Hibernate所必须要使用的jar包就可以了。

(2)在Hibernate的官网下载hibernate-release-4.2.2.Final.zip解压,要使用Hibernate必须导入的jar包就在目录“hibernate-release-4.2.2.Final\lib\required”下。

倒入此路径下的所有jar包就可以了。

2.配置hibernate.cfg.xml文件(1)配置hibernate.cfg.xml文件可以参考“\project\etc”目录下的hibernate.cfg.xml文件与hibernate.properties文件。

(2)使用Hibernate连接MySQL的hibernate.cfg.xml配置文件如下:<hibernate-configuration><session-factory>(设置显示Hibernate产生的SQL语句)<property name="show_sql">true</property>(设置MySQL的SQL语法的方言)<property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>(设置MySQL的驱动程序)<property name="hibernate.connection.driver_class">org.gjt.mm.mysql.Driver</property>(设置MySQL的数据库路径、用户名、密码)<property name="hibernate.connection.url">jdbc:mysql:///java</property><property name="ername">root</property><property name="hibernate.connection.password">lizhiwei</property>(设置当数据库要保存的表不存在时,就新建表)<property name="hibernate.hbm2ddl.auto">update</property>(设置对象与数据库表的关系映射文件)<mapping resource="vo/User.hbm.xml"/></session-factory></hibernate-configuration>(3)此配置文件一般放在项目的src目录下。

hibernate配置

hibernate配置
属性可以是update、create和drop-create三个值。
目录
1 Hibernate概述 2 第一个Hibernate程序 3 Hibernate的配置文件 4 深入理解持久化对象 5 Hibernate的映射文件 6持久化对象 如果PO 实例与Session实例关联起来,且该实例关联到数据库的记录
脱管对象 如果PO实例曾经与Session实例关联过,但是因为Session的关闭等原 因,PO实例脱离了Session 的管理
Hibernate全面解决方案架构解释
事务(Transaction) 代表一次原子操作,它具有数据库事务的概念 但它通过抽象,将应用程序从底层的具体的JDBC、JTA和CORBA 事务中隔离开。 一个Session 之内可能包含多个Transaction对象。 所有的持久化操作都应该在事务管理下进行,即使是只读操作。
管态,对该对象操作无须锁定数据库,不会造成性能的下降。
持久化对象的状态迁移
持久化实体: 1、Serializable save(object obj) 将对象变为持久化状态 2、void persist(object obj) 将对象转化为持久化状态 3、Serializable save(object obj,object pk) 将obj对象转化为持久化状态,该对象保存到数据库,指定主键值 4、void persist(object obj,object pk) 也加了一个设定主键
Hibernate工作原理
Configuration cfg = new Configuration().configure();
开始
启动hibernate
构建Configuration 实例,初始 化该实例中的所有变量

Hibernate关联关系注解配置简单理解

Hibernate关联关系注解配置简单理解

Hibernate关联关系注解配置简单理解Hibernate关联关系注解配置什么是关联关系?关联关系有哪⼏种?关联关系指实体之间的关系,也就是表与表之间的关系。

⼀个关系⽤两个属性来描述,数量性和⽅向性。

从数量上来看,表与表之间主要有三种关系,⼀对⼀,⼀对多,多对多。

加上关系的⽅向,还有⼀个多对⼀。

hibernate中关联关系的维护在实际的业务开发中,对于两个有关联的数据库实体,⽐如学⽣对教室,我们通常还需要在操作⼀⽅时,维护两⽅彼此之间的关系。

关系的维护分为两类:1.级联Cascade,在操作⼀⽅时,是否对另⼀⽅也执⾏同样的操作。

2.外键的维护inverse,在操作⼀⽅时,是否⾃动维护外键关系。

⽐如如果将多⽅的对象添加给以⼀的⼀⽅,因为外键由多⽅维护,hibernate 为了保证添加的这个多⽅对象的外键是正确的,会⾃动给这个多⽅的外键设置值(也就是⼀的⼀⽅的主键)外键维护,在xml配置中使⽤inverse属性,在注解中使⽤mappedBy注解来声明。

cascade与inverse1.cascade,指把对当前对象的操作级联到关联对象上。

⼀般在one to one ,one to many设置级联。

配置了这个属性后,当对当前对象执⾏如save等更新数据库的操作时,当前实体所关联的实体也会执⾏相应的操作。

2.inverse默认值为true, 表⽰让对⽅来维护关系。

设为false,⾃⼰维护关系。

inverse主要有两个作⽤:1)维护外键主控⽅保存时,是否⾃动update被控⽅的外键字段。

外键字段指向的就是当前保存的实体。

2)维护级联决定当前设置的级联是否有⽤,⾃⼰维护关系时,对⽅设置的级联就不会⽣效,对⽅保存时不会让本⽅也保存。

⽽对⽅维护关系,则与此相反。

@mappedBy注解1)mappedBy(name="对⽅标准代表当前实体的属性“)2)只存在于OneToOne,OneToMany,ManyToMany, 不能在ManyToOne中3)与joincolumn或jointable互斥。

Eclipse下配置和使用Hibernate Tools

Eclipse下配置和使用Hibernate Tools

Eclipse下配置和使用Hibernate Tools文章分类:Web前端关键字: hibernate tools eclipse 插件配置Hibernate Tools可以通过访问已经建立好的数据库以反向工程方式生成POJO文件。

今天就来说一下如何使用Hibernate Tools来生成POJO。

1、首先,要去Hibernate的网站下载这个工具包。

一个大约14M的ZIP压缩文件。

/sourceforge/jboss/HibernateTools-3.2.4.Beta1-R200810311334.zip2、解压缩下载好的文件,释放出features和plugins这两个文件夹和其中的内容。

完成后将这两个文件夹复制到Eclipse的目录下(这两个文件夹在Eclipse中是默认存在的,直接复制就行了)。

3、到这步为止HibernateTools的安装就算结束了,下面开始配置和具体使用。

一开始选择工程下的SRC 目录,然后右键New->Other->Hibernate->Hibernate Configuration File(cfg.xml),在弹出的窗口中选择Next ,进入到下面的选项中。

注意,这个地方有几项是一定要填写的。

他们分别是Database dialect(数据库方言)、Driver class(数据库驱动)、Connection URL(链接字符串)以及Username和Password(访问数据库的用户名和密码)。

上图图中使用的是MySQL5数据库的配置,vane是我机器中已经创建好的数据库。

使用其他数据库的时候会略有不同。

填好之后选择Finish。

4、选择Eclipse的下拉菜单Window->Show View->Other->Hibernate->Hibernate Configurations,现在就可以查看Hibernate的配置窗口了。

hibernate框架的工作原理

hibernate框架的工作原理

hibernate框架的工作原理Hibernate框架的工作原理Hibernate是一个开源的ORM(Object-Relational Mapping)框架,它将Java对象映射到关系型数据库中。

它提供了一种简单的方式来处理数据持久化,同时也提供了一些高级特性来优化性能和可维护性。

1. Hibernate框架的基本概念在开始讲解Hibernate框架的工作原理之前,需要先了解一些基本概念:Session:Session是Hibernate与数据库交互的核心接口,它代表了一个会话,可以用来执行各种数据库操作。

SessionFactory:SessionFactory是一个线程安全的对象,它用于创建Session对象。

通常情况下,应用程序只需要创建一个SessionFactory对象。

Transaction:Transaction是对数据库操作进行事务管理的接口。

在Hibernate中,所有对数据库的操作都应该在事务中进行。

Mapping文件:Mapping文件用于描述Java类与数据库表之间的映射关系。

它定义了Java类属性与数据库表字段之间的对应关系。

2. Hibernate框架的工作流程Hibernate框架主要分为两个部分:持久化层和业务逻辑层。

其中,持久化层负责将Java对象映射到数据库中,并提供数据访问接口;业务逻辑层则负责处理业务逻辑,并调用持久化层进行数据访问。

Hibernate框架的工作流程如下:2.1 创建SessionFactory对象在应用程序启动时,需要创建一个SessionFactory对象。

SessionFactory是一个线程安全的对象,通常情况下只需要创建一个即可。

2.2 创建Session对象在业务逻辑层需要进行数据访问时,需要先创建一个Session对象。

Session是Hibernate与数据库交互的核心接口,它代表了一个会话,可以用来执行各种数据库操作。

2.3 执行数据库操作在获取了Session对象之后,就可以执行各种数据库操作了。

最经典的hibernate教程 从入门到精通 第一篇(共四篇)

最经典的hibernate教程 从入门到精通 第一篇(共四篇)

• </session-factory>
准备3:添加实体类和映射文件(UserInfo.hbm.xml)
使用Hibernate的7个步骤:
1、 Configuration 7、 关闭Session 2、 创建 SessionFactory
6、 提交事务 5、
3、 打开 Session 4、 开始一个事务
2-1):添加配置文件 -- hibernate.cfg.xml
<session-factory> <property name="connection.url"> jdbc:microsoft:sqlserver://localhost:1433;Database=pubs </property> <property name="ername">sa</property> <property name="connection.password">pwd</property> <property name="connection.driver_class"> com.microsoft.jdbc.sqlserver.SQLServerDriver </property> <property name="dialect"> org.hibernate.dialect.SQLServerDialect </property> <property name="show_sql">true</property> <mapping resource="com/aptech/jb/entity/User.hbm.xml" /> </session-factory>

简述hibernate查询数据库的步骤

简述hibernate查询数据库的步骤

简述hibernate查询数据库的步骤Hibernate是一个开源的Java持久化框架,它可以帮助开发者简化数据库操作,提高开发效率。

在Hibernate中,查询数据库是非常常见的操作,本文将以标题的方式,简述Hibernate查询数据库的步骤。

一、配置Hibernate在开始使用Hibernate查询数据库之前,首先需要进行Hibernate 的配置工作。

包括创建Hibernate配置文件(hibernate.cfg.xml),配置数据库连接信息、数据库方言等。

同时,还需要配置实体类与数据库表之间的映射关系(Hibernate映射文件)。

二、创建SessionFactorySessionFactory是Hibernate的核心接口之一,它负责创建Session对象,是实现Hibernate查询的基础。

在Hibernate中,SessionFactory是线程安全的,通常一个应用程序只需要一个SessionFactory实例。

三、打开Session在进行数据库查询之前,需要先打开一个Session。

Session是Hibernate中的一个重要概念,它代表一个与数据库的会话。

可以通过SessionFactory的openSession方法来打开一个Session。

四、开始事务在进行数据库查询操作之前,通常需要开启一个事务。

通过调用Session的beginTransaction方法,开始一个事务。

事务的开启可以保证数据的一致性和完整性。

五、执行查询操作在Hibernate中,有多种查询方式可以选择。

常见的查询方式包括HQL查询、QBC查询和Native SQL查询。

HQL(Hibernate Query Language)是Hibernate提供的一种面向对象的查询语言,类似于SQL语句。

QBC(Criteria Query)是一种基于Criteria的查询方式,可以通过CriteriaBuilder来构建查询条件。

hibernate 使用线程级session

hibernate 使用线程级session

在各种Session 管理方案中,ThreadLocal 模式得到了大量使用。

ThreadLocal 是Java 中一种较为特殊的线程绑定机制。

通过ThreadLocal存取的数据,总是与当前线程相关,也就是说,JVM 为每个运行的线程,绑定了私有的本地实例存取空间,从而为多线程环境常出现的并发访问问题提供了一种隔离机制。

首先,我们需要知道,SessionFactory负责创建Session,SessionFactory是线程安全的,多个并发线程可以同时访问一个SessionFactory 并从中获取Session 实例。

而Session并非线程安全,也就是说,如果多个线程同时使用一个Session实例进行数据存取,则将会导致Session 数据存取逻辑混乱。

下面是一个典型的Servlet,我们试图通过一个类变量session实现Session的重用,以避免每次操作都要重新创建:public class TestServlet extends HttpServlet {private Session session;public void doGet( HttpServletRequest request,HttpServletResponse response)throws ServletException, IOException {session = getSession();doSomething();session.flush();}public void doSomething(){......//基于session的存取操作}}代码看上去正确无误,甚至在我们单机测试的时候可能也不会发生什么问题,但这样的代Hibernate Developer's Guide Version 1.0September 2, 2004 So many open source projects. Why not Open your Documents?码一旦编译部署到实际运行环境中,接踵而来的莫名其妙的错误很可能会使得我们摸不找头脑。

hibernate配置文件说明

hibernate配置文件说明

create:每次加载hibernate时都会删除上一次的生成的表,然后根据你的model类再重新来生成新表,哪怕两次没有任何改变也要这样执行。会导致数据库表数据丢失。
create-drop: 每次加载hibernate时根据model类生成表,但是sessionFactory一关闭,表就自动删除。
(2)hibernate.show_sql打印所有的SQL语句到控制台,可以通过设置org.hibernate.SQL类的日志策略到DEBUG级,实现同样的效果。取值 true|false。
(3)hibernate.format_sql 格式化SQL语句在打印到控制台或写入日志文件时。取值true|false。
hibernate.cache.provider_class=org.hibernate.cache.SingletonEhCacheProvider
hibernate.cache.provider_class=org.hibernate.cache.EhCacheProvider
# 二级缓存配置文件
#Batch Size越大,批量操作的向数据库发送sql的次数越少,速度就越快。
hibernate.jdbc.batch_size=50
#设置外连接抓取树的最大深度取值. 建议设置为0到3之间
#hibernate.max_fetch_depth
#是否显示最终执行的SQL(开发环境)
hibernate.show_sql=false
# 格式化显示的SQL
hibernate.format_sql=false
# 如果设置为true,Hiberante将为SQL产生注释,这样更利于调试。默认值为false。取值为true|false。

java学习经验Hibernate总结

java学习经验Hibernate总结

Hibernate工作原理及为什么要用?一原理:1.读取并解析配置文件2.读取并解析映射信息,创建SessionFactory3.打开Sesssion4.创建事务Transaction5.持久化操作6.提交事务7.关闭Session。

8.关闭SessionFactory为什么要用:1. 对JDBC访问数据库的代码做了封装,大大简化了数据访问层繁琐的重复性代码。

2. Hibernate是一个基于JDBC的主流持久化框架,是一个优秀的ORM实现。

他很大程度的简化DAO层的编码工作3. hibernate使用Java反射机制,而不是字节码增强程序来实现透明性。

4. hibernate的性能非常好,因为它是个轻量级框架。

映射的灵活性很出色。

它支持各种关系数据库,从一对一到多对多的各种复杂关系。

二Hibernate 的核心接口及其作用1 Configuration类:配置Hibernate启动Hibernate创建SessionFactory对象2 SessionFactory:初始化Hibernate创建Session对象线程安全—同一实例被多个线程共享重量级:代表一个数据库内部维护一个连接池2.1 openSession():总是创建新的session,需要手动close()2.2 getCurrentSession() : 必须在hibernate.cfg.xml设置session 上下文事务自动提交并且自动关闭session.从上下文环境中获得session,如果当时环境中不存就创建新的.如果环境中存在就使用环境中的,而且每次得到的都是同一个session (在session提交之前,提交之后就是新的了) 应用在一个session中有多个不同DAO操作处于一个事务时3 Session:负责保存、更新、删除、加载和查询对象轻量级--可以经常创建或销毁3.1 Load与get方法的区别:简单理解:load是懒加载,get是立即加载.load方法当使用查出来的对象时并且session未关闭,才会向数据库发sql, get会立即向数据库发sql返回对象3.3 merge(); 合并对象更新前会先select 再更新3.4clear()清空缓存,flush()将session中的数据同步到数据库两者组合使用于批量数据处理3.4Transaction commit() rollback()JPA: java persistence API 提供了一组操作实体bean的注解和API规范SchemaExporthiberante的生成数据库表(及其他ddl)的工具类可以通过这个工具类完成一些ddl四Hibernate查询查询语言主要有:HQL 、QBC (Query By Criteria条件查询) 、 Native SQLHql:1、属性查询2、参数查询、命名参数查询3、关联查询4、分页查询5、统计函数五优化抓取策略连接抓取(Join fetching)使用 OUTER JOIN(外连接)来获得对象的关联实例或者关联集合查询抓取(Select fetching)另外发送一条 SELECT 语句抓取当前对象的关联实体或集合另外可以配置hibernate抓取数量限制批量抓取(Batch fetching)另外可以通过集合过滤来限制集合中的数据量使用session.createFilter(topic.getReplies(),queryString).list();检索策略延迟检索和立即检索(优先考虑延迟检索)N+1问题指hibernate在查询当前对象时查询相关联的对象查询一端时会查询关联的多端集合对象解决方案:延迟加载连接抓取策略二级缓存集合过滤 BatchSize限制记录数量映射建议使用双向一对多关联,不使用单向一对多灵活使用单向一对多关联不用一对一,用多对一取代配置对象缓存,不使用集合缓存一对多集合使用Bag,多对多集合使用Set继承类使用显式多态表字段要少,表关联不要怕多,有二级缓存撑腰Hibernbate缓存机制性能提升的主要手段Hibernate进行查询时总是先在缓存中进行查询,如缓存中没有所需数据才进行数据库的查询.Hibernbate缓存:一级缓存 (Session级别)二级缓存(SessionFactory级别)查询缓存 (基于二级缓存存储相同参数的sql查询结果集)一级缓存(session缓存)Session缓存可以理解为session中的一个map成员, key为OID ,value为持久化对象的引用在session关闭前,如果要获取记录,hiberntae先在session缓存中查找,找到后直接返回,缓存中没有才向数据库发送sql三种状态的区别在于:对象在内存、数据库、session缓存三者中是否有OID临时状态内存中的对象没有OID, 缓存中没有OID,数据库中也没有OID 执行new或delete()后持久化状态内存中的对象有OID, 缓存中有OID,数据库中有OIDsave() load() get() update() saveOrUpdate() Query对象返回的集合游离(脱管)状态内存中的对象有OID, 缓存中没有OID,数据库中可能有OIDflush() close()后使用session缓存涉及三个操作:1将数据放入缓存2从缓存中获取数据3缓存的数据清理4二级缓存SessionFactory级别SessionFactory级别的缓存,它允许多个Session间共享缓存一般需要使用第三方的缓存组件,如: Ehcache Oscache、JbossCache等二级缓存的工作原理:在执行各种条件查询时,如果所获得的结果集为实体对象的集合,那么就会把所有的数据对象根据OID放入到二级缓存中。

Struts+Spring+Hibernate整合入门详解

Struts+Spring+Hibernate整合入门详解

3、运行eclipse,选择一个空目录作为工作区(工程结构如下:其中我们要写的Java代码在Java Resource: src(以后直接称src)下,网站根目录内容在WebContent下,类所在根目录是WEB-INF/classes,Eclipse 会自动将build/classes里面已经编译的类同步过去。

向WEB-INF下的lib目录添加如下所列的jar包。

(1)这些包在下载解压后Spring,Struts,Hibernate的lib目录或者dist/module目录下面(如果不在,可以到网上google一把。

列表中mysql-*.jar包是MySQL数据库的JDBC Driver)。

也可以把所有lib和dist 下的jar包拷贝过来(可以在系统复制这些jar包,然后到Eclipse里面选中WEB-INF里面的lib包,然后粘帖就可以了)。

但要注意全拷贝可能会存在冲突,如struts*plugin.jar等包不能引入,否则不能运行。

(2)这些Jar包是:antlr-2.7.2.jarcglib-nodep-2.1_3.jarcommons-beanutils-1.6.jarcommons-chain-1.1.jarcommons-collections-2.1.1.jarcommons-dbcp.jarcommons-digester.jarcommons-logging-1.0.4.jarcommons-logging-api-1.1.jarcommons-pool.jarcommons-validator-1.3.0.jardom4j-1.6.1.jarel-api.jarel-ri.jarfreemarker-2.3.8.jarhibernate3.jarjsf-api.jarjta.jarmysql-connector-java-3.0.14-production-bin.jarognl-2.6.11.jaroro-2.0.8.jarspring-hibernate3.jarspring.jarstruts-config.xmlstruts-core-1.3.5.jarstruts2-codebehind-plugin-2.0.9.jarstruts2-config-browser-plugin-2.0.9.jarstruts2-core-2.0.9.jarstruts2-jasperreports-plugin-2.0.9.jarstruts2-jfreechart-plugin-2.0.9.jarstruts2-jsf-plugin-2.0.9.jarstruts2-pell-multipart-plugin-2.0.9.jarstruts2-plexus-plugin-2.0.9.jarstruts2-sitegraph-plugin-2.0.9.jarstruts2-sitemesh-plugin-2.0.9.jarstruts2-spring-plugin-2.0.9.jarstruts2-struts1-plugin-2.0.9.jarstruts2-tiles-plugin-2.0.9.jartiles-api-2.0.4.jartiles-core-2.0.4.jartiles-jsp-2.0.4.jarindex.jsp的内容如表,我们暂时不分析。

Hibernate_映射配置文件详解

Hibernate_映射配置文件详解
–hibernate.properties –hibernate.cfg.xml
Prepared by TongGang
hibernate.cfg.xml的常用属性
• • • • • • • • • connection.url:数据库URL ername:数据库用户名 connection.password:数据库用户密码 connection.driver_class:数据库JDBC驱动 show_sql:是否将运行期生成的SQL输出到日志以供调试。取 show_sql 值 true | false dialect:配置数据库的方言,根据底层的数据库不同产生不 dialect 同的sql语句,Hibernate 会针对数据库的特性在访问时进行 优化。 hbm2ddl.auto:在启动和停止时自动地创建,更新或删除数据 hbm2ddl.auto 库模式。取值 create | update | create-drop resource:映射文件配置,配置文件名必须包含其相 mapping resource 对于根的全路径 connection.datasource :JNDI数据源的名称
• Class:定义一个持久化类 Class: • name (可选): 持久化类(或者接 (可选): 持久化类( 可选 口)的类名 • table (可选 - 默认是类的非全限 (可选 定名): 定名): 对应的数据库表名 • discriminator-value (可选 - 默 discriminator(可选 认和类名一样): 认和类名一样): 一个用于区分不 同的子类的值,在多态行为时使用。 同的子类的值,在多态行为时使用。 它可以接受的值包括 null 和 not null。 null。
Prepared by TongGang

Hibernate基础知识详解

Hibernate基础知识详解

Hibernate基础知识详解<hibernate-mapping><class name="*.*.*" table="t_customer" catalog="***"><id name="id" column="c_id"><generator class="identity"/></id><property name="name" column="c_name" length="20"/><set name="orders" inverse="false" cascade="save-update"><key column="c_customer_id"/></set></class></hibernate-mapping>(1)统⼀声明包名,这样在<class>中就不需要写类的全名。

(2)关于<class>标签配置name 属性:类的全名称table 表的名称,可以省略,这时表的名称就与类名⼀致catalog 属性:数据库名称可以省略.如果省略,参考核⼼配置⽂件中 url 路径中的库名称(3)关于<id>标签,<id>是⽤于建⽴类中的属性与表中的主键映射。

name 类中的属性名称column 表中的主键名称 column 它也可以省略,这时列名就与类中属性名称⼀致length 字段长度type 属性指定类型<generator>它主要是描述主键⽣成策略。

hibernate session方法

hibernate session方法

hibernate session方法Hibernate的Session是Hibernate框架中非常重要的一个接口,它代表了与数据库的一次会话。

Session提供了一系列的方法来执行CRUD(创建、读取、更新和删除)操作。

以下是一些常用的Session方法:1. save() - 保存一个实体对象到数据库中。

```javapublic void save(Object entity)```2. get() - 根据ID获取实体对象。

```javapublic T get(Class entityClass, Serializable id)```3. load() - 加载一个实体对象。

如果该对象尚未在Session中,Hibernate会查询数据库来获取它。

```javapublic T load(Class entityClass, Serializable id)```4. update() - 更新一个实体对象在数据库中的数据。

```javapublic void update(Object entity)```5. delete() - 从数据库中删除一个实体对象。

```javapublic void delete(Object entity)```6. find() - 执行一个HQL(Hibernate Query Language)查询并返回结果。

```javapublic List find(String queryString)7. createQuery() - 创建一个新的Query对象,该对象表示HQL或Criteria查询。

```javapublic Query createQuery(String queryString)```8. createCriteria() - 创建一个新的Criteria对象,该对象表示Criteria查询。

```javapublic Criteria createCriteria(Class persistentClass)```9. beginTransaction() - 开始一个新的事务。

hibernate学习笔记

hibernate学习笔记

Hibernate 学习笔记2010年7月9日星期五1目录1.学习纲要2.学习目的3.达标标准4.名词解释5.学习时间:两天又3小时(16~19pm)2具体内容2.1学习纲要2.1.1什么是hibernate?它是连接JAVA应用程序和关系数据库的中间件它对JDBC API进行了封装,负责JAVA对象的持久化在分层的软件架构中它位于持久化层,封装了所有数据访问细节,使业务逻辑层可以专注于实现业务逻辑。

它是一种ORM映射工具,能够建立面向对象的域模型和关系数据模型之间的映射2.1.2HIBERNATE原理依赖的技术有:JAVA反射机制(在org.hibernate.property中得到较多应用,通过INVORK()方法调用POJO对象的setter,getter方法设置和获取属性的值)i.Class类ii.getMethods方法得到Method类iii.Method类iv.invoke方法用来调用被反射类的方法CGLIB(用于对持久化类进行延迟加载时生成代理类)i.以asm项目为基础,对asm的功能进行封装和扩展,实现并扩展了JAVA的反射功能,可以在运行时状态下实现JAVA接口,扩展JAVA类ii.Asm项目是一个简洁的字节码工具,能够在运行的状态下动态的修改编译完成的JAVA类JAVASSIST(同CGLIB,是另一套解决方案,可以通过修改org.hibernate.cfg.Environment.java原码进行设置)i.是一个执行字节码操作的强有力的驱动代码库。

它允许开发者在代码被JAVA虚拟机载入之前定义一个新类或者修改类的的原代码。

XML技术(DOM4J)i.用来解析XML配置文件Antlr(another tool for language recognition)i.它是一个开源的工具,利用后缀为“.g”的文件来定义语法规则ii.Hibernate提供的语法规则有iii.Hql.giv.Hql-sql.gv.Sql-gen.gvi.Hibernate通过调用这些生成的解析类完成把HQL语句转为SQL语句的工作2.1.3HIBERNATE方法的内部实现略2.1.4Hibernate能做什么?2.1.5hibernate应用在哪些方面2.1.6Hibernate关联关系1.一对多关联<many-to-one name=”customer”column=”CUSTOMER_ID”class=”mypack.Customer”lazy=”false” not-null=”true”/>此种情况下不会加载关联的临时对象。

Hibernate学习总结

Hibernate学习总结

一.对象语言和操作数据库不匹配:模型不匹配(阻抗不匹配)①.可以使用JDBC手动转换;sql参数和jdbc中用对象赋值②.使用ORM(Object Relation Mapping对象关系映射)框架:hibernate 二.Hibernate安装配置①.配置文件Hibernate.cfg.xml和Hibernate.properties②.映射文件xxx.hbm.xml:对象模型和关系模型的映射三.开发流程1.由Domain Object -> mapping -> db2.有DB开始,用工具生成mapping和Domain Object3.由配置文件开始四.Domain Object限制1.默认的构造方法(必须的)2.有无意义的标示符id(主键) 可选3.非final的,对懒加载有影响可选Configuration SessionFactory Session Transaction Query CriteriaConfiguration类Configuration类负责配置并启动Hibernate,创建SessionFactory对象。

在Hibernate的启动的过程中,Configuration类的实例首先定位映射文档位置、读取配置,然后创建SessionFactory 对象。

SessionFactory接口SessionFactory接口负责初始化Hibernate。

它充当数据存储源的代理,并负责创建Session对象。

这里用到了工厂模式。

需要注意的是SessionFactory并不是轻量级的,因为一般情况下,一个项目通常只需要一个SessionFactory就够,当需要操作多个数据库时,可以为每个数据库指定一个SessionFactory。

Session接口Session接口负责执行被持久化对象的CRUD操作(CRUD的任务是完成与数据库的交流,包含了很多常见的SQL语句。

JavaWeb_(Hibernate框架)Hibernate中数据查询语句SQL基本用法

JavaWeb_(Hibernate框架)Hibernate中数据查询语句SQL基本用法

JavaWeb_(Hibernate框架)Hibernate中数据查询语句SQL基本⽤法本⽂展⽰三种在Hibernate中使⽤SQL语句进⾏数据查询基本⽤法 1、基本查询 2、条件查询 3、分页查询package com.Gary.dao;import java.util.List;import org.hibernate.Session;import org.hibernate.Transaction;import org.hibernate.query.NativeQuery;import er;import com.Gary.utils.HibernateUtils;public class SQLDao {public void find(){Session session = HibernateUtils.getSession();Transaction beginTransaction = session.beginTransaction();//开始进⾏SQL查询String sql = "select * from user";//创建sql查询对象NativeQuery query = session.createSQLQuery(sql);query.addEntity(User.class);//接收listList<User> list = query.list();//接收单⼀返回值 query.uniqyeResult();//输出第⼀个成员姓名System.out.println(list.get(0).getUsername());//结束SQL查询mit();session.close();}//SQL条件查询public void find2(){Session session = HibernateUtils.getSession();Transaction beginTransaction = session.beginTransaction();//开始进⾏SQL查询String sql = "select * from user where id = ?";//创建SQL查询对象NativeQuery query = session.createSQLQuery(sql);//封装参数,给第⼀个?赋值query.setParameter(1, "1");query.addEntity(User.class);//唯⼀返回值User user = (User) query.uniqueResult();System.out.println(user);//结束SQL查询mit();session.close();}//SQL分页查询public void find3(){Session session = HibernateUtils.getSession();Transaction beginTransaction = session.beginTransaction();//开始进⾏SQL查询String sql = "select * from user limit ? , ?";//创建SQL查询对象NativeQuery query = session.createSQLQuery(sql);//封装参数,给第⼀个?赋值query.setParameter(1, 0);//同理query.setParameter(2, 2);query.addEntity(User.class);//唯⼀返回值List<User> list = query.list();System.out.println(list.get(0).getUsername());//结束SQL查询mit();session.close();}}SQLDao.java 数据库user表 向数据库中添加假数据1、SQL基本查询 //开始进⾏SQL查询 String sql = "select * from user"; //创建sql查询对象 NativeQuery query = session.createSQLQuery(sql); query.addEntity(User.class); SQLDao.java向数据库发起查询请求public void find(){Session session = HibernateUtils.getSession();Transaction beginTransaction = session.beginTransaction();//开始进⾏SQL查询String sql = "select * from user";//创建sql查询对象NativeQuery query = session.createSQLQuery(sql);query.addEntity(User.class);//接收listList<User> list = query.list();//接收单⼀返回值 query.uniqyeResult();//输出第⼀个成员姓名System.out.println(list.get(0).getUsername());//结束SQL查询mit();session.close();}package com.Gary.dao;import java.util.List;import org.hibernate.Session;import org.hibernate.Transaction;import org.hibernate.query.NativeQuery;import er;import com.Gary.utils.HibernateUtils;public class SQLDao {public void find(){Session session = HibernateUtils.getSession();Transaction beginTransaction = session.beginTransaction();//开始进⾏SQL查询String sql = "select * from user";//创建sql查询对象NativeQuery query = session.createSQLQuery(sql);query.addEntity(User.class);//接收listList<User> list = query.list();//接收单⼀返回值 query.uniqyeResult();//输出第⼀个成员姓名System.out.println(list.get(0).getUsername());//结束SQL查询mit();session.close();}}SQLDao.java2、SQL条件查询//开始进⾏SQL查询String sql = "select * from user where id = ?";//创建SQL查询对象NativeQuery query = session.createSQLQuery(sql);//封装参数,给第⼀个?赋值query.setParameter(1, "1");query.addEntity(User.class); SQLDao.java向数据库发起查询请求public void find2(){Session session = HibernateUtils.getSession();Transaction beginTransaction = session.beginTransaction();//开始进⾏SQL查询String sql = "select * from user where id = ?";//创建SQL查询对象NativeQuery query = session.createSQLQuery(sql);//封装参数,给第⼀个?赋值query.setParameter(1, "1");query.addEntity(User.class);//唯⼀返回值User user = (User) query.uniqueResult();System.out.println(user);//结束SQL查询mit();session.close();}package com.Gary.dao;import java.util.List;import org.hibernate.Session;import org.hibernate.Transaction;import org.hibernate.query.NativeQuery;import er;import com.Gary.utils.HibernateUtils;public class SQLDao {public void find(){Session session = HibernateUtils.getSession();Transaction beginTransaction = session.beginTransaction();//开始进⾏SQL查询String sql = "select * from user";//创建sql查询对象NativeQuery query = session.createSQLQuery(sql);query.addEntity(User.class);//接收listList<User> list = query.list();//接收单⼀返回值 query.uniqyeResult();//输出第⼀个成员姓名System.out.println(list.get(0).getUsername());//结束SQL查询mit();session.close();}public void find2(){Session session = HibernateUtils.getSession();Transaction beginTransaction = session.beginTransaction();//开始进⾏SQL查询String sql = "select * from user where id = ?";//创建SQL查询对象NativeQuery query = session.createSQLQuery(sql);//封装参数,给第⼀个?赋值query.setParameter(1, "1");query.addEntity(User.class);//唯⼀返回值User user = (User) query.uniqueResult();System.out.println(user);//结束SQL查询mit();session.close();}}SQLDao.java3、SQL分页查询 //开始进⾏SQL查询 String sql = "select * from user limit ? , ?"; //创建SQL查询对象 NativeQuery query = session.createSQLQuery(sql); //封装参数,给第⼀个?赋值 query.setParameter(1, 0); //同理 query.setParameter(2, 2); query.addEntity(User.class); //唯⼀返回值 List<User> list = query.list(); SQLDao.java向数据库发起查询请求//SQL分页查询public void find3(){Session session = HibernateUtils.getSession();Transaction beginTransaction = session.beginTransaction();//开始进⾏SQL查询String sql = "select * from user limit ? , ?";//创建SQL查询对象NativeQuery query = session.createSQLQuery(sql);//封装参数,给第⼀个?赋值query.setParameter(1, 0);//同理query.setParameter(2, 2);query.addEntity(User.class);//唯⼀返回值List<User> list = query.list();System.out.println(list.get(0).getUsername());//结束SQL查询mit();session.close();}package com.Gary.dao;import java.util.List;import org.hibernate.Session;import org.hibernate.Transaction;import org.hibernate.query.NativeQuery;import er;import com.Gary.utils.HibernateUtils;public class SQLDao {public void find(){Session session = HibernateUtils.getSession();Transaction beginTransaction = session.beginTransaction();//开始进⾏SQL查询String sql = "select * from user";//创建sql查询对象NativeQuery query = session.createSQLQuery(sql);query.addEntity(User.class);//接收listList<User> list = query.list();//接收单⼀返回值 query.uniqyeResult();//输出第⼀个成员姓名System.out.println(list.get(0).getUsername());//结束SQL查询mit();session.close();}//SQL条件查询public void find2(){Session session = HibernateUtils.getSession();Transaction beginTransaction = session.beginTransaction();//开始进⾏SQL查询String sql = "select * from user where id = ?";//创建SQL查询对象NativeQuery query = session.createSQLQuery(sql);//封装参数,给第⼀个?赋值query.setParameter(1, "1");query.addEntity(User.class);//唯⼀返回值User user = (User) query.uniqueResult();System.out.println(user);//结束SQL查询mit();session.close();}//SQL分页查询public void find3(){Session session = HibernateUtils.getSession();Transaction beginTransaction = session.beginTransaction();//开始进⾏SQL查询String sql = "select * from user limit ? , ?";//创建SQL查询对象NativeQuery query = session.createSQLQuery(sql);//封装参数,给第⼀个?赋值query.setParameter(1, 0);//同理query.setParameter(2, 2);query.addEntity(User.class);//唯⼀返回值List<User> list = query.list();System.out.println(list.get(0).getUsername());//结束SQL查询mit();session.close();}}SQLDao.java。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
属性名
hibernate.dialect hibernate.show_sql hibernate.connection.url ername hibernate.connection.password hibernate.connection.driver_class hibernate.default_schema
属性名 name parameters 属性描述 用来设置标识生成器名 用来设置标识生成器所需的参数
strategy
用来设置Hibernate内置的生成策略
15.2.6 使用@Column注释实体类非 标识属性
一个实体类除了有标识,一般还会有许多其他属性, 这时可以使用@Column注释这些属性。@Column注 释最常用的属性为name属性,该属性用来设置数据 库表中的字段名。
@Entity注释用来将一个普通的JavaBean标注为实体 类。@Entity注释由一个可选的name属性,用来设置 属性名。并不是所有的JavaBean都能被标注为实体 类,必须要满足如图15.7所示的3个条件。
JavaBean类的访问权限只能是public 标注为实 体类的3 个条件 JavaBean中必须有一个访问权限为public的无参的构造方法 JavaBean类不能是抽象类
15.2.8 测试Annotations注释是否 成功完成映射
通过AnnotationSessionFactory可以加载Annotations注 释方式的映射。通过调用Session对象的各种方法就 可以完成各类数据库操作,如查询记录、添加记录 等。在创建测试类之前,首先同样需要在Hibernate 的配置文件hibernate.cfg.xml中添加映射信息。同映 射文件配置映射不同,这里需要指定class属性为需 要映射的实体类。具体配置方法如图15.15所示。
proxy
lazy



true
指定代理类接口,为延迟加载提供支持
指定是否使用延迟加载
dynamic-update
dynamic-insert


false
false
指定生成Update SQL时是否仅包含发生变动的字段
指定生成Insert SQL时,是否仅包含非空字段
注意:<hibernate-mapping>元素下可以由多个<class> 元素,但是一般推荐值添加一个。即一个实体类对 应一个映射文件。
15.2 使用Annotations配置映射
在JDK 5.0之后出现了一种新的注释技术Annotations, 而Hibernate也在其3.0之后的版本中添加了对 Annotations的支持。通过在实体类中添加Annotations 注释,可以达到替代映射文件的效果。
15.2.1 使用@Entity注释实体类
3.<id>元素
பைடு நூலகம்
每一个实体类中都包含一个唯一的标识,<id>元素 能够定义该属性和数据库表中的主键字段的映射。 <id>元素包括的常用属性如表15.4所示。
属性名 name 必选 否 默认值 无 描述 指定标识属性的名称,如果不指定,表示这个类没有标 识属性
type
column unsaved-value access
<mapping class="po.Employee" />
15.2.8 测试Annotations注释是否 成功完成映射
完成如上步骤后,映射信息就已经全部完成了,下 面我们就来创建一个测试类来测试使用Annotations 注释是否能成功完成映射。 我们首先打开MySQL数据库并在名为mysqltest的数 据库中建立一个tb_employee表,并在表中按照前面 所述的属性建立一条数据信息。
15.1.2 配置映射文件
映射文件是持久化操作中的一个重点,它是数据库 表和实体类之间的连接枢纽。通过映射文件, Hibernate就能知道实体类和那个数据库表相对应。 映射文件也是采用XML文档规范,这样设计可以使 其非常易读,而且容易修改。下面我们就对其包含 的各种元素分别做一简要介绍。
1.<hibernate-mapping>元素
映射文件的根节点为<hibernate-mapping>,该节点包 含一系列的可选属性,如schema和catalog属性。 schema属性指定了数据库表所在的schema名称。
属性名 schema catalog default-cascade default-access default-lazy auto-import package 必选 否 否 否 否 否 否 否 默认值 无 无 none property true true 无 描述 指定数据库schema的名称 指定数据库catalog的名称 指定默认的级联风格 指定访问所有属性的策略 指定默认加载风格 指定是否可以查询非全限定的类名 指定包前缀,若没有指定全限定的类名,将使用这个 作为包名
使用@Id注释实体类标识时将采用Hibernate的默认访 问策略,这时可以使用@GenerateValue注释覆盖标识 的默认访问策略。@GenerateValue注释包括两个属性, 即使用generator属性指定标识生成器名,使用 strategy属性指定标识生成策略。strategy属性的属性 值为一个枚举类型,其中包含了4个枚举值,如表 15.7所示。
15.2.5 使用@GenericGenerator注 释生成标识生成器
前面我们介绍了如何使用@GenerateValue注释的strategy属性来 指定生成策略,但是这些生成策略明显不能满足。这时可以使 用@GenericGenerator注释产生标识生成器,然后通过 @GenerateValue注释的generator属性来制定生成器的name属性, 这样就可以采用指定的生成器生成标识。 @GenericGenerator注释包含3个属性,其属性说明如表15.8所示。
15.2.3 使用@Id注释实体类标识
@Id注释用来对实体类的标识进行配置。一个实体类 一般只有一个标识,所以一个实体类中只出现一个 @Id注释。 注意:使用@Id注释实体类标识,一定要使用import 语句引入javax.persistence.Id类,该类为@Id注释依赖 类。
15.2.4 使用@GenerateValue注释 覆盖标识的默认访问策略
描述
Hibernate方言所对应的类名 设置是否在控制台输出SQL语句 设置数据库连接URL 设置数据库用户名 设置数据库密码 设置数据库连接驱动类 生成SQL时,schema/tablespace的全限定名
15.1.1 配置Hibernate
注意:使用XML文件配置Hibernate时,可以将属性 名简写,如将hibernate.show_sql直接写为show_sql。
注意:一个映射文件中只允许有一个<hibernatemapping>元素。
2.<class>元素
<class>元素用来配置一个实体类与一个数据库表的 关联。其中name属性用来指定实体类的名称,table 属性用来指定数据库表的名称。<class>元素的常用 属性如表15.3所示。
属性名 name table mutable 必选 否 否 否 默认值 无 无 true 描述 指定完全路径类名 指定数据库表名 指定类的实例是否可变
15.2.7 自定义 AnnotationSessionFactory类来获 得Session对象
前面我们介绍了如何使用Annotation注释来完成实体 类到数据库表的映射,这时还有一点需要特别注意。 在以前获得SessionFactory对象是通过调用 Configuration对象来实现的,但是这种方式不支持 Annotations注释映射。要支持Annotations就必须使用 AnnotationConfiguration类了。
属性名 catalog name schema uniqueConstraints 属性描述 用来设置数据库名 用来设置数据库表名 用来设置数据库表的所有者名称 用来设置数据库表的约束
注意:使用@Table注释实体类,一定要使用import语 句引入javax.persistence.Table类,该类为@Table注释 依赖类。
属性名 name type column access not-null generated 必选 否 否 否 否 否 否 默认值 无 无 无 property true never 描述 指定标识属性的名称,如果不指定,表示这个类没有 标识属性 指定标识属性的Hibernate类型 指定数据库表中主键字段的名称 指定Hibernate用来访问属性值的策略 指定属性是否允许为空 指定属性值是否由数据库生成
注意:使用@Entity注释实体类,一定要使用import 语句引入javax.persistence.Entity类,该类为@Entity 注释依赖类。
15.2.2 使用@Table注释实体类
@Table注释用来对实体类进行进一步注释,用来配 置实体类到数据库表映射的更详细的信息。@Table 注释包含的属性信息如表15.6所示。
15.3.1 Hibernate对象状态
一个实体类的实例可能处于3种不同的状态中的一种。 这3种状态分别为瞬时状态、持久状态和托管状态。 下面我们就来看这3种状态的详细说明,如图15.16所 示。
15.1 传统方式配置Hibernate
Hibernate的配置主要有两种方式:传统的配置方法 以及使用Annotations进行配置的方法。首先我们先 来学习传统的配置方式。
15.1.1 配置Hibernate
在使用Hibernate进行持久化之前,必须对Hibernate 进行一系列配置,如数据库连接URL、数据库用户 名和密码以及映射文件路径等。对于Hibernate的配 置,最常用的就是采用XML格式的方法进行配置。 Hibernate默认的配置文件为hibernate.cfg.xml,其包 含的配置属性如表15.1所示。
相关文档
最新文档