hibernate笔记总结

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先将记录的主键获取,然后需要哪个记录,
再根据主键条件去数据库查询.