- 浏览: 556632 次
- 性别:
- 来自: 武汉
文章分类
- 全部博客 (533)
- spring (8)
- struts (21)
- hibernate (17)
- java其他 (73)
- 设计模式 (2)
- 开发软件/插件 (26)
- android (8)
- extjs4 (1)
- 网络编程 (4)
- 生活杂记 (3)
- ibatis (5)
- 应用服务器 (4)
- js (26)
- html/css (16)
- linux (0)
- db (32)
- jsp/servlet (13)
- xml (9)
- webservice (10)
- 错误/异常处理 (23)
- 线程 (10)
- maven (7)
- lucene (2)
- python (0)
- 报表 (1)
- mongodb (6)
- restful (6)
- ssl (1)
最新评论
-
zmwxiaoming:
...
struts2拦截器验证登陆状态 -
u012413283:
感谢楼主,同样的问题解决了
eclipse下安装m2e的maven插件报错的各类解决方案(含pom editor没装好的解决方案) -
javalucky:
你妹,想不吐槽都不行啊,eclipse 那来的maven4My ...
clipse加载maven工程提示pom.xml无法解析org.apache.maven.plugins:maven-resources-plugin: -
zhaoyh82:
感谢楼主
eclipse下安装m2e的maven插件报错的各类解决方案(含pom editor没装好的解决方案) -
hua2011:
按照楼主说的,还是没有出现pom editor编辑器,麻烦楼主 ...
eclipse下安装m2e的maven插件报错的各类解决方案(含pom editor没装好的解决方案)
1.什么是Hibernate,有什么用?什么时候使用?
Hibernate框架,用于对数据库访问和操作.是对JDBC的轻量级封装.
Hibernate现已被JBOSS公司收购,用于实现EJB中的EntityBean
JavaEE EJB-->EJB容器-->JBOSS,Weblogic,WebSphere
EJB有三种类型
SessionBean(会话Bean),用于封装业务逻辑
EntityBean(实体Bean),用于封装对数据库的操作
MessageDrivenBean(消息驱动Bean),封装基于消息的处理机制
2.什么是ORM技术,有何作用和优势
Object-Relation-Mapping对象关系映射,
用于实现对象和关系数据库之间的映射,当应用程序需要对
数据库操作时,只需要对这些对象操作即可.
常用的ORM技术有很多,例如
1.Hibernate
2.iBATIS
3.JPA
4.其他.......
=============Hibernate简介=============
Hibernate是一款实现ORM技术的框架
Hibernate是对JDBC轻量级封装
Hibernate适用于对数据库访问和操作,
为应用程序构建一个持久层.
Hibernate是以操作对象的方式,实现对数据库的操作.
减少了数据库操作的代码.
3.Hibernate框架体系结构
1)hibernate.properties或者hibernate.cfg.xml
主配置文件,定义了数据库连接参数,框架的一些系统参数等
2)持久类 Person.java
数据表对应的Java类
3)Mapping文件 Person.hbm.xml
用于描述持久类和数据表之间的映射关系.
4.Hibernate框架的核心API
1)Configuration
负责读取Hibernate.cfg.xml和hbm.xml映射描述文件,
创建SessionFactory实例.
2)SessionFactory
负责创建Session对象,管理了预编译的SQL语句
3)Session
负责执行增加,删除,修改,查询操作.Session是对Connection的封装.
4)Query
负责执行HQL查询语句.
5)Transaction
负责事务控制,Hibernate必须使用代码控制事务,
否则不会对数据库造成修改
eg. Configuration config=new Configuration();
config.configure();
SessionFactory sf=config.buildSessionFactory();
Session session=sf.openSession();
5.Hibernate应用示例(对dangdang.d_user表操作)
1)引入Hibernate开发包+驱动开发包
hibernate3.jar
commons-collections-2.1.1.jar
commons-logging-1.0.4.jar
dom4j-1.6.1.jar
mysql-connector-java-5.1.6-bin.jar
cglib-2.1.3.jar
asm.jar
2)定义hibernate.cfg.xml主配置文件
<hibernate-configuration>
<session-factory>
<property name="connection.driver_class">
com.mysql.jdbc.Driver
</property>
<property name="connection.url">
jdbc:mysql://127.0.0.1:3306/xgf
</property>
<property name="connection.username">root</property>
<property name="connection.password">xgfdiao</property>
<property name="dialect">
org.hibernate.dialect.MySQLDialect
</property>
<property name="hbm2ddl.auto">update</property>
<property name="show_sql">true</property>
<property name="format_sql">true</property>
<mapping resource="mapping/School.hbm.xml" />
<mapping resource="mapping/Header.hbm.xml" />
<mapping resource="mapping/Person.hbm.xml" />
<mapping resource="mapping/Person_home.hbm.xml" />
</session-factory>
</hibernate-configuration>
3)定义持久类文件
<hibernate-mapping
package="entity">
<class name="Header" table="header">
<id name="id" column="id" type="integer">
<generator class="assigned"></generator>
</id>
<property name="hname" type="string">
<column name="hname"></column>
</property>
<property name="address" type="string">
<column name="address"></column>
</property>
<!-- 一对一映射 Product-->
<one-to-one name="sc" property-ref="he" cascade="all"><!-- 添加cascade="all"后,将同步两个表的数据操作 -->
</one-to-one>
</class>
</hibernate-mapping>
4)定义hbm.xml映射描述文件,在hibernate.cfg.xml
添加<mapping>元素.
<mapping resource="mapping/Person_home.hbm.xml" />
5)使用核心API进行操作
===================================================================
1.Hibernate主键生成方式
1)内置的快捷名
a. identity : 如果数据库支持自动增长,设计表时指定该功能
适用于MySQL,SQL Server
b. sequence : 如果数据支持sequence,主键由sequence生成
适用于Oracle
c. native : 根据数据库类型,自动选择identity,sequence,hilo
d.increment : 发送select max(id) from table语句获取主键值
e.assinged : 忽略,需要在程序中指定主键值.
f.uuid : 根据UUID算法生成一个字符串类型的主键值
适用于主键类型为varchar类型
g.hilo : 采用高低位算法生成一个数值类型的主键值
h.foreign : 使用另一个相关联对象的属性值充当主键值.
适用于一对一关系的数据表
2)自定义主键生成方式
a.编写主键生成器类,要实现IdentifierGenerator接口
在约定的generator方法中编写生成主键的逻辑
b.使用格式为<generator class="包名.类名">
2. Hibernate类型
在映射描述文件中,<property type="类型">,
type属性可以指定Java类型,也可以指定Hibernate类型
*1) 基本类型
integer,long,short,byte,double,float,character,
boolean,yes_no,true_false
*2)字符串类型
string
*3)日期和时间
date,time,timestamp
4)大的数值类型(了解下BigDecaimal,BigInteger)
big_decimal,big_integer
5)java.sql.Clob,java.sql.Blob
clob,blob
Hibernate也允许自定义类型.
3.Hibernate中对象的状态
1)临时状态
刚new出来的对象 ,session.delete()方法后
2)持久状态
调用session的load(),get(),save(),update()方法后,
该对象受Session管理,具有持久性的特征.
Hibernate可以将持久对象的信息保存到数据库中.(持久性)
3)脱管状态
调用session的close(),clear()方法后
注意:临时和脱管状态的对象,可以随时被垃圾回收,
不能与数据库同步.
4.高级映射
1)联合主键映射(参考Person.java,Person.hbm.xml)
2)组件映射(参考Order.java,Address.java,Order.hbm.xml)
(参考Emp.java,EmpAddress.java,Emp.hbm.xml)
=======数据库单表:最简单最基本的映射,联合主键映射,组件映射=======
3)一对一关系
a.基于主键关联的1:1
(1)需要添加对方类型的属性
public class Person implements Serializable{
private int id;
private String name;
private int age;
private Person_home ph;<-添加对方类型的属性
......
}
public class Person_home implements Serializable{
private int id;
private int person_num;
private String home_adr;
private Person per;<-添加对方类型的属性
......
}
(2)在映射描述文件中添加<one-to-one>的定义
<one-to-one name="对方在本类中的属性名" fetch="join"></one-to-one>
如<hibernate-mapping
package="entity">
<class name="Person" table="person">
<id name="id" column="id" type="integer">
<generator class="assigned"></generator>
</id>
<property name="name" type="string">
<column name="name"></column>
</property>
<property name="age" type="integer">
<column name="age"></column>
</property>
<!-- 一对一映射 Person_home-->
<!--执行同步插入,更新,删除时从主动方发起,即添加了cascade="all"的一方-->
<one-to-one name="ph" fetch="join" cascade="all" ></one-to-one>
</class>
</hibernate-mapping>
被动方<hibernate-mapping
package="entity">
<class name="Person_home" table="person_home">
<id name="id" column="id" type="integer">
<!-- 指定person_home的id参考person的id值,在执行ddl操作时,无需指定也可以保持与对方的同步 -->
<generator class="foreign">
<param name="property">per</param>
</generator>
<!-- 也可以写成下面,只是在执行ddl操作时要注意与Person 一方的同步 -->
<generator class="assigned"></generator>
</id>
<property name="person_num" type="integer">
<column name="person_num"></column>
</property>
<property name="home_adr" type="string">
<column name="home_adr"></column>
</property>
<!-- 一对一映射 person-->
<one-to-one name="per" fetch="join">
</one-to-one>
</class>
</hibernate-mapping>
意思是Person中的id主属性与Person_home中的id主属性关联
fetch属性用于指定抓取策略.可以指定join和select值
join:是指联合查询,select:是指单独发送一条select语句查询
b.基于主外键关联的1:1
(1)主键Header表到外键School表的1:1
需要添加对方类型的属性
public class Header implements Serializable{
private int id;
private String hname;
private String address;
//主键到外键的映射
private School sc;<-添加对方的属性
......
}
public class School implements Serializable{
private int id;
private String name;
// private int hid;
//外键到主键,添加到主键的关联属性后,将存在重复的的属性hid去掉,否则发生异常
private Header he;<-添加对方的属性
......
}
(2)添加对方的映射
主表中
<hibernate-mapping
package="entity">
<class name="Header" table="header">
<id name="id" column="id" type="integer">
<generator class="assigned"></generator>
</id>
<property name="hname" type="string">
<column name="hname"></column>
</property>
<property name="address" type="string">
<column name="address"></column>
</property>
<!-- 一对一映射 School-->
<one-to-one name="sc" property-ref="he" cascade="all"><!-- 添加cascade="all"后,将同步两个表的数据操作 -->
</one-to-one>
</class>
</hibernate-mapping>
外键表中
<hibernate-mapping package="entity">
<class name="School" table="school">
<id name="id" column="id" type="integer">
<generator class="assigned"></generator>
</id>
<property name="name" type="string">
<column name="name"></column>
</property>
<!-- hid的映射关系在添加一对一映射关系后要删除 -->
<!-- 一对一映射 Header-->
<many-to-one unique="true" name="he" class="Header" column="hid" ><!-- 将原来的hid映射关系去掉 -->
</many-to-one>
</class>
</hibernate-mapping>
添加外键约束的sql语句
alter table t_card
add constraint foreign key (emp_id)
references t_employee(id);
===========================================================
1,一对多,多对一关系和组件映射
Order表和Item表的一对多,多对一关系。其中Order表的某些属性又对应了另一个Address表.使用组件映射到Address。
Step1,分别在各自类中添加对方的属性
public class Order implements Serializable{
private int id;
private int status;
private long order_time;
private String order_desc;
private double total_price;
private Address address;//组件映射
//order-->item的一对多
private Set<Item> items;
......
}
****
public class Item implements Serializable{
private int id;
//private int order_id;//和一对一关系一样,添加了Order属性后必须删除关联属性,否则出错
private int product_id;
private String product_name;
private double dang_price;
private int product_num;
private double amount;
//添加item-->order多对一关系的属性
private Order order;
......
}
Step2,在映射文件中添加关系
在主表中:
<hibernate-mapping package="tarena.day3.domain">
<class name="Order" table="d_order">
<id name="id" column="id" type="integer">
<generator class="native"></generator>
</id>
<property name="status" type="integer">
<column name="status"></column>
</property>
<property name="order_time" type="long">
<column name="order_time"></column>
</property>
<property name="order_desc" type="string">
<column name="order_desc"></column>
</property>
<property name="total_price" type="double">
<column name="total_price"></column>
</property>
<!-- 主键表order到外键表item的一对多 -->
<set name="items" inverse="true">
<!-- 指定与当前主键关联的外键字段 -->
<key column="order_id"></key>
<one-to-many class="Item"/>
</set>
<!-- 组件映射 -->
<component name="address" class="Address">
<property name="userId" type="integer">
<column name="user_id"></column>
</property>
<property name="name" type="string">
<column name="receive_name"></column>
</property>
<property name="full_address" type="string">
<column name="full_address"></column>
</property>
<property name="postal_code" type="string">
<column name="postal_code"></column>
</property>
<property name="mobile" type="string">
<column name="mobile"></column>
</property>
<property name="phone" type="string">
<column name="phone"></column>
</property>
</component>
</class>
</hibernate-mapping>
在从表中:
<hibernate-mapping package="tarena.day3.domain">
<class name="Item" table="d_item">
<id name="id" column="id" type="integer">
<generator class="native"></generator>
</id>
<!--
<property name="order_id" type="integer">
<column name="order_id"></column>
</property>
-->
<property name="product_id" type="integer">
<column name="product_id"></column>
</property>
<property name="product_name" type="string">
<column name="product_name"></column>
</property>
<property name="dang_price" type="double">
<column name="dang_price"></column>
</property>
<property name="product_num" type="integer">
<column name="product_num"></column>
</property>
<property name="amount" type="double">
<column name="amount"></column>
</property>
<!-- item到order多对一关系 -->
<many-to-one name="order" class="Order" column="order_id"></many-to-one>
</class>
</hibernate-mapping>
=====================================
多对多关系和表间继承关系
------------------多对多--------------------------
多对多在数据库中需要对应3张数据表
d_category--->d_category_product<---d_product<---继承于--d_book
a.在持久类中添加集合类型的属性,用于多对多关联
public class Category implements Serializable{
private int id;
private int turn;
private String en_name;
private String name;
private String description;
private int parent_id;
//category-->product的多对多
private Set<Product> pros;
......
}
public class Product implements Serializable{
private int id;
private String product_name;
private String description;
private long add_time;
private double fixed_price;
private double dang_price;
private String keywords;
private int has_deleted;
private String product_pic;
//product-->category的多对多
private Set<Category> cats;
......
}
public class Book extends Product implements Serializable{
private int id;
private String author;
private String publishing;
private long publish_time;
private String word_number;
private String which_edtion;
private String total_page;
private long print_time;
private String print_number;
private String isbn;
private String author_summary;
private String catalogue;
......
}
b.在映射描述文件中,使用以下格式.使用继承关联后,无须为子表定义映射文件
<set name="集合属性名" table="关系表">
<key column="与当前类型对应的关系表字段"/>
<many-to-many class="集合元素类型"
column="与元素类型对应的关系表字段"/>
</set>
在Category.hbm.xml中
<hibernate-mapping package="tarena.day3.domain">
<class name="Category" table="d_category">
<id name="id" column="id" type="integer">
<generator class="native"></generator>
</id>
<property name="turn" type="integer">
<column name="turn"></column>
</property>
<property name="en_name" type="string">
<column name="en_name"></column>
</property>
<property name="name" type="string">
<column name="name"></column>
</property>
<property name="description" type="string">
<column name="description"></column>
</property>
<property name="parent_id" type="integer">
<column name="parent_id"></column>
</property>
<!-- 多对多 -->
<set name="pros" inverse="true" table="d_category_product">
<key column="cat_id"></key>
<!-- 指定集合元素 -->
<many-to-many class="Product" column="product_id"></many-to-many>
</set>
</class>
</hibernate-mapping>
在Product.hbm.xml中
<hibernate-mapping package="tarena.day3.domain">
<class name="Product" table="d_product">
<id name="id" column="id" type="integer">
<generator class="native"></generator>
</id>
<property name="product_name" type="string">
<column name="product_name"></column>
</property>
<property name="description" type="string">
<column name="description"></column>
</property>
<property name="add_time" type="long">
<column name="add_time"></column>
</property>
<property name="fixed_price" type="double">
<column name="fixed_price"></column>
</property>
<property name="dang_price" type="double">
<column name="dang_price"></column>
</property>
<property name="keywords" type="string">
<column name="keywords"></column>
</property>
<property name="has_deleted" type="integer">
<column name="has_deleted"></column>
</property>
<property name="product_pic" type="string">
<column name="product_pic"></column>
</property>
<!-- product到category的多对多 -->
<set name="cats" table="d_category_product">
<key column="product_id"></key>
<many-to-many class="Category" column="cat_id"></many-to-many>
</set>
<!-- 定义继承关系的映射Book -->
<joined-subclass name="Book" table="d_book">
<!-- d_book中的id与d_product中的id对等 -->
<key column="id"></key>
<property name="author" type="string">
<column name="author"></column>
</property>
<property name="publishing" type="string">
<column name="publishing"></column>
</property>
<property name="publish_time" type="long">
<column name="publish_time"></column>
</property>
<property name="word_number" type="string">
<column name="word_number"></column>
</property>
<property name="which_edtion" type="string">
<column name="which_edtion"></column>
</property>
<property name="total_page" type="string">
<column name="total_page"></column>
</property>
<property name="print_time" type="long">
<column name="print_time"></column>
</property>
<property name="print_number" type="string">
<column name="print_number"></column>
</property>
<property name="isbn" type="string">
<column name="isbn"></column>
</property>
<property name="author_summary" type="text">
<column name="author_summary"></column>
</property>
<property name="catalogue" type="text">
<column name="catalogue"></column>
</property>
</joined-subclass>
</class>
</hibernate-mapping>
==============================================================================
1.如何使用MyEclipse工具生成持久类和映射文件
1)由数据表生成持久类和映射文件
a.配置DB Browser中的数据库连接
b.创建工程,添加Hibernate框架支持
工程右键-->MyEclipse-->Add Hibernate Capability
c. 选择Hibernate版本和jar包引入方式
d.创建hibernate.cfg.xml主配置文件
e.设置主配置文件中的Db连接参数
f.创建HibernateSessionFactory工具类
--------工程具有了jar,主配置文件,工具类-------------
g.进入DB Browser,选择数据表右键,
选择Hibernate Reverse Engine
h.选择生成文件所放位置,设置hbm.xml,
持久类POJO,DAO选项
i.设置hbm.xml中type采用的类型,以及ID主键的生成方式
j.设置数据表对应的持久类的名称(包名.类名),
最后单击完成
2)由持久类和映射文件生成数据表
a.在hibernate.cfg.xml主配置文件,添加hbm2ddl配置
<property name="hbm2ddl.auto">update</property>
hbm2ddl工具可以根据hbm内容生成ddl语句,创建或修改数据表结构
b.执行save添加操作,触发hbm2ddl工具
2.Hibernate查询,HQL查询语句
HQL属于面向对象查询语言,结构与SQL相似,
将SQL中表名和字段名用类名和属性替代.
类名和属性名大小写敏感.
1),单表查询,简单查询
查询所有:
String hql="from User";
Query query=session.createQuery(hql);
List<User> users=query.list();
for(User u:users){
System.out.println(u);//在User中覆盖了toString方法
}
查询记录条数:
String hql="select count(*) from User";
Query query=session.createQuery(hql);
List<Integer> num=query.list();
System.out.println("人数是"+num.get(0));
查询部分字段:
String hql="select email,nickname from User";
Query query=session.createQuery(hql);
List<Object[]> os=query.list();
for(Object[] o:os){
System.out.println("email:"+o[0]+"nickname:"+o[1]);
}
通过构造对象查询:
String hql="select new User(email,password,userIntegral) from User";
Query query=session.createQuery(hql);
List<User> us=query.list();
for(User u:us){
System.out.println(u.getEmail()+" "+u.getPassword()+" "+u.getUserIntegral());
}
依据条件查询:
String hql="from User where nickname=:name";
Query query=session.createQuery(hql);
query.setString("name", "mingming");
List<User> us=query.list();
for(User u:us){
System.out.println(u);
}
2). 联合查询:
step1:在各自类中添加对方类型的属性
public class User implements java.io.Serializable {
private Integer id;
private String email;
private String nickname;
private String password;
private Integer userIntegral;
private String isEmailVerify;
private String emailVerifyCode;
private String hasDeleted;
private long lastLoginTime;
private String lastLoginIp;
private Set<Address> adrs;//到Address的一对多关系
......
}
public class Address implements java.io.Serializable {
private Integer id;
//private Integer userId;//添加多对一关系后,注释掉相关属性,防止发生异常,映射文件中也需作相应更改
private String receiveName;
private String fullAddress;
private String postalCode;
private String mobile;
private String phone;
private User user;//到User的多对一关系
......
}
step2:添加相关映射关系
<hibernate-mapping>
<class name="entity.Address" table="d_receive_address" catalog="dang">
<id name="id" type="integer">
<column name="id" />
<generator class="native"></generator>
</id>
<property name="receiveName" type="string">
<column name="receive_name" length="20" not-null="true" />
</property>
<property name="fullAddress" type="string">
<column name="full_address" length="200" not-null="true" />
</property>
<property name="postalCode" type="string">
<column name="postal_code" length="8" not-null="true" />
</property>
<property name="mobile" type="string">
<column name="mobile" length="15" />
</property>
<property name="phone" type="string">
<column name="phone" length="20" />
</property>
<!-- 到User的多对一映射 -->
<many-to-one name="user" column="user_id" class="entity.User"></many-to-one>
</class>
</hibernate-mapping>
<hibernate-mapping>
<class name="entity.User" table="d_user" catalog="dang">
<id name="id" type="integer">
<column name="id" />
<generator class="native"></generator>
</id>
<property name="email" type="string">
<column name="email" length="50" not-null="true" />
</property>
<property name="nickname" type="string">
<column name="nickname" length="50" />
</property>
<property name="password" type="string">
<column name="password" length="50" not-null="true" />
</property>
<property name="userIntegral" type="integer">
<column name="user_integral" not-null="true" />
</property>
<property name="isEmailVerify" type="string">
<column name="is_email_verify" length="3" />
</property>
<property name="emailVerifyCode" type="string">
<column name="email_verify_code" length="60" />
</property>
<property name="hasDeleted" type="string">
<column name="has_deleted" length="5" />
</property>
<property name="lastLoginTime" type="long">
<column name="last_login_time" />
</property>
<property name="lastLoginIp" type="string">
<column name="last_login_ip" length="15" />
</property>
<!-- 到address的一对多映射 -->
<set name="adrs" inverse="true">
<key column="user_id"></key>
<one-to-many class="entity.Address"/>
</set>
</class>
</hibernate-mapping>
step3.查询操作
StringBuffer hql = new StringBuffer();
hql.append("SELECT ");
hql.append(" d1.id,d1.nickname,d2.postalCode,d2.fullAddress ");
hql.append(" FROM User d1 join d1.adrs d2 ");//HQL语句中没有on
Query query = session.createQuery(hql.toString());
List list=query.list();
for (int i = 0; i < list.size(); i++) {
Object[] obj = (Object[]) list.get(i);
System.out.println(obj[0] + " " + obj[1] + " " + obj[2] + " "
+ obj[3]);
}
//分页查询
String hql="from User";
Query query=session.createQuery(hql);
query.setMaxResults(2);//指定抓取记录的最大数
query.setFirstResult(1);//指定抓取记录的起始点
List<User> us=query.list();
for(User u:us){
System.out.println(u);
}
//联合查询
StringBuffer hql = new StringBuffer();
hql.append("SELECT ");
hql.append(" d1.id,d1.nickname,count(d2.fullAddress) ");
hql.append(" FROM User d1 join d1.adrs d2 ");
hql.append(" GROUP BY d1.id");
Query query = session.createQuery(hql.toString());
List list=query.list();
for (int i = 0; i < list.size(); i++) {
Object[] obj = (Object[]) list.get(i);
System.out.println(obj[0] + " " + obj[1] + " " + obj[2]);
}
//联合查询
StringBuffer hql = new StringBuffer();
hql.append("SELECT ");
hql.append(" d1.user.id,d1.user.nickname,count(d1.fullAddress) ");
hql.append(" FROM Address d1 ");
hql.append(" GROUP BY d1.user.id");
Query query = session.createQuery(hql.toString());
List list=query.list();
for (int i = 0; i < list.size(); i++) {
Object[] obj = (Object[]) list.get(i);
System.out.println(obj[0] + " " + obj[1] + " " + obj[2]);
}
============================================
(了解)3.Hibernate高级特性以及性能优化
1)延迟加载 : 当程序执行getter方法获取时,才发送sql语句加载数据.
延迟加载给程序带来好处,但是要避免session过早关闭问题
a. load()和get()两个方法区别
load()采用延迟加载机制,返回的是一个proxy代理对象
get()没有采用延迟加载,返回的是一个对象实例
b.Hibernate.initialize(user)
可以强制user对象实例化
c.hbm映射描述文件中,<class>,<property>,<set>等元素
都可以使用lazy属性,默认lazy="true",启用延迟加载
lazy="false"禁用延迟加载.
2)缓存机制
Hibernate每次查询先去缓存中查找,没有才去数据库查询.
a.一级缓存
Session级别的缓存,缓存load,get出来的单个对象.默认开启.
使用同一个Session对象多次查询同一个User对象,
只会发送一次SQL取数据库获取
b.二级缓存
SessionFactory级别的缓存.默认情况是关闭.
(1)首先在hibernate.cfg.xml中指定EhCache缓存策略
<property name="hibernate.cache.provider_class">
org.hibernate.cache.EhCacheProvider
</property>
(2)在src下添加ehcache.xml配置文件
(3)在User.hbm.xml中添加<cache/>定义
<cache usage="read-only"/> ,如果涉及更新,使用read-write
c.查询缓存
缓存HQL查询结果集,对相同的HQL查询语句,只去数据库查询一次.
(1)首先在hibernate.cfg.xml中启用查询缓存
<property name="hibernate.cache.use_query_cache">true</property>
(2)在query.list()执行之前,调用query.setCacheable(true);
d.缓存的清除
session.evict(user);//清除缓存中的指定对象
session.clear();//清除缓存的所有内容
sessionfactory.evict();//清除二级缓存中的指定对象
================================================================
==========补充===============
1. <set inverse=true/> 关系维护交给对方,
关系维护指的是update关系字段的值
A id <---> B a_id
1001 1001--->NULL
2.cascade级联操作
一对一:可以使用级联删除
一对多,多对多:删除操作等不推荐使用级联,
级联删除效率低,可以写HQL执行
HQL : delete from Item where order.id=?
HQL : delete from Order where id=?
3.自定义主键生成方式
参考(Student示例)
4.query.list()和query.iterator()
1)list将所有记录获取,放入list集合中
2)iterator先将记录的主键获取,然后需要哪个记录,
再根据主键条件去数据库查询.
发表评论
-
JPA的Embeddable注解
2013-06-17 14:17 1050来源于http://zjsword2000.blog.163 ... -
hibernate注解demo
2013-06-13 17:21 1378用一个简单的例子,来记一下,hibernate的部分注解的使 ... -
hibernate连接查询总结
2013-06-09 11:20 1380假使现在有两张关联表,customer和order,一般情况 ... -
hibernate检索策略总结
2013-06-08 15:19 1321大致说来,hibernate提供了3中检索 ... -
Hibernate Tools的使用
2013-06-08 10:18 1045- Hibernate的配置文件hibernate.c ... -
hibernate一对多关联关系配置经验
2013-05-02 14:02 1693假使有一个order表和一个customer表,那么它们两者 ... -
Hibernate并发控制乐观锁实现-Version
2013-03-29 09:31 996通过在表中及POJO中增加一个version字段来表示 ... -
object references an unsaved transient instance - save the transient instance be
2012-12-27 16:10 961异常1:not-null property refere ... -
hibernate的锁
2012-11-08 15:33 3445业务实现过程中,难免需要保证数据访问的排他性。如金融系统的日 ... -
hibernate的事务管理
2012-11-08 14:05 1411在讲解hibernate的事物管理之前,我们必须首先明白一些 ... -
hibernate的缓存
2012-11-06 16:17 1095缓存是数据库在内存中 ... -
hibernate数据加载方式[及时,延时,预先,批量]
2012-11-06 13:44 1038在传统的JDBC操作里,通常通过sql语句查询加载所需要的数 ... -
hibernate引用查询和联合查询
2012-11-06 10:50 1581一、引用查询 日常开发时常会如下的编码规范:“ ... -
hibernate联合主键
2012-11-05 11:19 1470在日常开发中,有时候会出现要求两个或以上字段联合做主键的表, ... -
hibernate的11种主键生成方式
2012-11-04 14:06 1306hibernate提供了很多种主键的生成方式,以解决实际开发 ... -
Hibernate面试题
2012-11-04 09:37 1644什么是Hibernate的并发机制?怎么去处理并发问题? ...
相关推荐
### Hibernate知识点总结 #### 一、配置与初始化 在配置Hibernate时,首先需要明确几个重要的配置选项及其作用: 1. **show_sql**: 这个属性用于控制Hibernate是否会在执行SQL语句时将其输出到控制台。设置为`...
**Hibernate学习笔记与总结** Hibernate 是一款开源的对象关系映射(ORM)框架,它为Java开发者提供了一种在关系数据库上操作对象数据的便捷方式。本文将深入探讨Hibernate的核心概念、配置、实体类、映射文件、...
在深入探讨《hibernate笔记.txt》所提及的关键知识点前,我们先来解析一下标题和描述中的核心概念。“自上而下的依赖,单向依赖,层与层之间最好依赖抽象”,这一描述实际上触及了软件架构设计中的关键原则,特别是...
【标签】:Hibernate, Annotation, 笔记, 总结, 注解 【正文】: Hibernate Annotation是Hibernate框架的一个重要特性,它允许开发者直接在Java类上使用注解来定义对象的数据库映射,从而避免了传统的XML配置文件...
### 马士兵Hibernate学习笔记知识点总结 #### 一、课程内容概览 - **HelloWorld**:通过简单的示例程序介绍如何启动一个基于Hibernate的Java项目。 - **Hibernate原理模拟**:解释O/R Mapping的概念及其重要性。 -...
《Hibernate学习笔记特别详细》 Hibernate,作为一款开源的Object-Relational Mapping(ORM)框架,为Java开发者提供了强大的数据库操作支持...在学习过程中,不断实践和总结,将有助于你成为Hibernate的熟练使用者。
在Hibernate框架中,实体对象具有三种主要的状态:瞬时态(Transient)、持久态(Persistent)以及脱管态(Detached)。这些状态有助于理解对象与数据库之间的交互过程。 - **瞬时态**:对象尚未被持久化到数据库中...
### Hibernate笔记 #### 一、概述 Hibernate 是一个开源的对象关系映射(ORM)框架,它简化了Java应用程序与数据库之间的交互过程。通过使用Hibernate,开发者可以将对象模型与关系型数据库模型进行映射,从而避免...
总结起来,"韩顺平hibernate笔记及图解"涵盖了Hibernate的基础概念、核心组件、对象关系映射、查询机制、事务管理以及实体间的关系等内容。通过学习这份笔记,开发者能深入理解Hibernate的工作原理和使用技巧,提升...
### Struts、Spring、Hibernate&Ajax 学习笔记总结 #### Struts 部分 **Struts** 是 Java 开源框架中最早出现且最具影响力的框架之一,它出自 Apache 组织,是 Java Web 应用开发的标准之一。Struts 以 MVC(Model...
Hibernate 是一个流行的开源 ORM(对象关系映射)框架,它为 Java 开发人员提供了一种在应用程序中管理和操作关系数据库的便捷方式。通过 Hibernate,开发者可以将 Java 对象与数据库中的记录进行映射,从而避免直接...
总结,这个“留言管理程序”通过Struts处理用户交互,Spring管理业务逻辑和数据访问,Hibernate处理数据库操作,形成了一套完整的解决方案。这种三层架构的设计模式,有利于代码的模块化和解耦,提高了代码的可读性...
### Hibernate实战笔记——深入解析对象关系映射与优化策略 #### 一、对象关系映射(ORM)概念 - **什么是持久化**:在计算机科学领域,“持久化”指的是将程序的数据状态保存到非易失性的存储介质中,以便可以在...
### Hibernate 学习笔记知识点概览 #### 一、Hibernate 概述 - **定义**:Hibernate 是一款开源的对象关系映射(ORM)框架,它实现了将 Java 应用程序中的对象模型映射到关系型数据库中的记录。通过 ORM 技术,...
根据提供的文件内容,以下是对Hibernate及Mybatis相关知识点的详细总结: ###Hibernate基础配置 Hibernate的配置文件是XML格式,它主要包含数据库连接信息、方言选择、映射文件等。HibernateUtil配置涉及到...
**Hibernate学习笔记与大纲** Hibernate 是一款开源的Java语言下的对象关系映射(ORM)框架,它极大地简化了数据库操作,使得开发人员可以使用面向对象的方式处理数据,而无需过多关注底层的SQL语句。本笔记将深入...
总结,Hibernate3作为强大的O/R Mapping框架,通过对象关系映射简化了数据库操作,提高了开发效率,并提供了丰富的查询机制和最佳实践建议。学习和掌握Hibernate有助于提升Java应用的数据管理能力。
总结来说,Hibernate笔记涵盖了ORM的核心概念,包括配置、对象模型、事务处理、查询、关联映射以及性能优化等多个方面。通过深入学习,你可以掌握如何高效地利用Hibernate进行数据库操作,提升开发效率和代码质量。