26.Hibernate-主键和映射.md
目录
1.复合主键映射
数据库表可以用复合主键映射。但是复合主键映射使用时候需要注意:在配置文件中,需要使用一个对象来表示复合主键
- 单一主键
<class name="Employee" table="employee">
<!-- 主键 注意和类成员和表列名称的一致对应 -->
<id name="empId" column="EmpId" >
<!-- 主键的生成策略:
1.identity 自增长(mysql,db2)
2.sequence 自增长(序列), oracle中自增长是以序列方法实现
3.native 自增长【会根据底层数据库自增长的方式选择identity或sequence】
如果是mysql数据库, 采用的自增长方式是identity
如果是oracle数据库, 使用sequence序列的方式实现自增长
4.increment 自增长(会有并发访问的问题,一般在服务器集群环境使用会存在问题。)
5.assigned 指定主键生成策略为手动指定主键的值
6.uuid 指定uuid随机生成的唯一的值
7.foreign (外键的方式, one-to-one讲)
-->
<generator class="native" />
</id>
<!-- 非主键,同样一一映射
name:类的属性名称
column:表的字段名称
length:设定字段的长度,默认为255
type:设定映射表的类型,如果不写匹配类对应属性的类型
java类型:必须带完整包名:java.lang.String
hibernate类型:全部都是小写
-->
<property name="empName" column="EmpName"></property>
<property name="workDate" column="WorkDate"></property>
</class>
- 复合主键
a. 首先需要将数据库表对应的对象类中的复合主键,提取为一个对象。所以需要新建一个类,将这个类对象作为表对象的属性。
特别要注意的是这个复合主键类对象一定要实现序列化方法
package per.liyue.code.hibernatehello;
import java.io.Serializable;
public class CompositeKeys implements Serializable {
private String name = null;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
private int id = 0;
}
b. 将序列化的对象添加到表对应的类对象中
public class Employee {
private CompositeKeys keys;
private String empName;
private Date workDate;
......
}
c. 在配置文件中将符合主键配置
<class name="Employee" table="employee">
<composite-id name="keys">
<key-property name="name" type="String"></key-property>
<key-property name="id" type="int"></key-property>
</composite-id>
<!-- 非主键,同样一一映射
name:类的属性名称
column:表的字段名称
length:设定字段的长度,默认为255
type:设定映射表的类型,如果不写匹配类对应属性的类型
java类型:必须带完整包名:java.lang.String
hibernate类型:全部都是小写
-->
<property name="empName" column="EmpName"></property>
<property name="workDate" column="WorkDate"></property>
</class>
目录
2.集合映射
2.1Set集合
假若有如下的数据库表:
- 那么对应的类对象应该是
package per.liyue.code.hibernatecollection;
import java.util.Set;
/*
* 带有集合的类
*/
public class User {
private int userId;
private String userName;
public int getUserId() {
return userId;
}
public void setUserId(int userId) {
this.userId = userId;
}
public String getUserName() {
return userName;
}
public void setUserName(String userName) {
this.userName = userName;
}
public Set<String> getUserEmail() {
return userEmail;
}
public void setUserEmail(Set<String> userEmail) {
this.userEmail = userEmail;
}
//一个Set集合,对应数据库中的表,这个表的外键是User表的主键
private Set<String> userEmail;
}
- 配置映射文件:
要注意的是Set集合的配置,对应的数据类型必须填写
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<!-- Generated Nov 9, 2006 6:27:53 PM by Hibernate Tools 3.2.0.beta7 -->
<!-- package:类对象所在的包
auto-import:表面是自动导入包,如果设定为false,则需要在执行hql语句时候将包名写清楚:
Demo:在true时候可以写为session.createQuery("from Employee").list();
在false时候必须写为session.createQuery("from per.liyue.code.hibernatehello.Employee").list();
-->
<hibernate-mapping package="per.liyue.code.hibernatecollection" auto-import="true">
<!-- 类与表的对应
name:类名称
table:表名称
-->
<class name="User" table="user">
<!-- 主键 注意和类成员和表列名称的一致对应 -->
<id name="userId" column="UserId" >
<generator class="native" />
</id>
<property name="userName" column="UserName"></property>
<!-- Set集合配置:
set-name:要映射的Set集合类
set-table:要映射的Set表
key-column:指定集合表的外键,也就是User表的主键
element-type:集合表其他字段的类型,必须填写!!!
element-column:集合表其他自动的表列名称
-->
<set name="userEmail" table="UserEmail">
<key column="UserId"></key>
<element type="string" column="EmailAddress"></element>
</set>
</class>
</hibernate-mapping>
- 配置Hibernate配置文件:
<!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 name="foo">
<!-- 数据库连接配置 -->
<!-- 连接类 -->
<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
<!-- 连接数据库 -->
<property name="hibernate.connection.url">jdbc:mysql:///hi</property>
<!-- 连接用户名 -->
<property name="hibernate.connection.username">root</property>
<!-- 连接密码 -->
<property name="hibernate.connection.password">root</property>
<!-- 数据库方言 -->
<property name="hibernate.dialect">org.hibernate.dialect.MySQL5Dialect</property>
<!-- 其他配置 -->
<property name="hibernate.show_sql"></property>
<property name="hibernate.hbm2ddl.auto">update</property>
<!-- 加载所有的映射 -->
<mapping resource="per/liyue/code/hibernatehello/Employee.hbm.xml"/>
<mapping resource="per/liyue/code/hibernatecollection/User.hbm.xml"/>
</session-factory>
</hibernate-configuration>
- 最后保存数据
package per.liyue.code.hibernatecollection;
import java.util.HashSet;
import java.util.Set;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import org.junit.Test;
public class App {
private static SessionFactory sf;
static{
sf = new Configuration().configure().buildSessionFactory();
}
@Test
public void setOperation(){
Session s = sf.openSession();
s.beginTransaction();
/*
* Set:保存带Set的集合
*/
User user = new User();
user.setUserId(2);
user.setUserName("李四");
Set<String> email = new HashSet<>();
email.add("a@a.com");
email.add("b@b.com");
user.setUserEmail(email);
s.save(user);
s.getTransaction().commit();
s.close();
sf.close();
}
}
2.2其他集合
其他集合大体上类似Set集合,但是具体有不同
list
list在配置文件中需要指定一个索引,因为list是有序的!!!map
map中key和value都需要指定类型
Demo:
将上文中的例子修改
package per.liyue.code.hibernatecollection;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
/*
* 带有集合的类
*/
public class User {
private int userId;
private String userName;
public int getUserId() {
return userId;
}
public void setUserId(int userId) {
this.userId = userId;
}
public String getUserName() {
return userName;
}
public void setUserName(String userName) {
this.userName = userName;
}
public Set<String> getUserEmail() {
return userEmail;
}
public void setUserEmail(Set<String> userEmail) {
this.userEmail = userEmail;
}
//一个Set集合,对应数据库中的表,这个表的外键是User表的主键
private Set<String> userEmail;
//一个List集合
private List<String> userPhoneNumber = new ArrayList<>();
public List<String> getUserPhoneNumber() {
return userPhoneNumber;
}
public void setUserPhoneNumber(List<String> userPhoneNumber) {
this.userPhoneNumber = userPhoneNumber;
}
//一个Map集合
private Map<String, String> userAddress = new HashMap<>();
public Map<String, String> getUserAddress() {
return userAddress;
}
public void setUserAddress(Map<String, String> userAddress) {
this.userAddress = userAddress;
}
}
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<!-- Generated Nov 9, 2006 6:27:53 PM by Hibernate Tools 3.2.0.beta7 -->
<!-- package:类对象所在的包
auto-import:表面是自动导入包,如果设定为false,则需要在执行hql语句时候将包名写清楚:
Demo:在true时候可以写为session.createQuery("from Employee").list();
在false时候必须写为session.createQuery("from per.liyue.code.hibernatehello.Employee").list();
-->
<hibernate-mapping package="per.liyue.code.hibernatecollection" auto-import="true">
<!-- 类与表的对应
name:类名称
table:表名称
-->
<class name="User" table="user">
<!-- 主键 注意和类成员和表列名称的一致对应 -->
<id name="userId" column="user_id" >
<generator class="native" />
</id>
<property name="userName" column="user_name"></property>
<!-- Set集合配置:
set-name:要映射的Set集合类
set-table:要映射的Set表
key-column:指定集合表的外键,也就是User表的主键
element-type:集合表其他字段的类型
element-column:集合表其他自动的表列名称
-->
<set name="userEmail" table="UserEmail">
<key column="user_id"></key>
<element type="string" column="email_address"></element>
</set>
<!-- List集合配置
list-index:需要为list指定排序,因为list是有序的
-->
<list name="userPhoneNumber" table="UserPhoneNumber">
<key column="user_id"></key>
<list-index column="list_index"></list-index>
<element type="string" column="phone_number"></element>
</list>
<!-- Map集合配置
-->
<map name="userAddress">
<key column="user_id"></key>
<map-key type="string" column="area"></map-key>
<element type="string" column="address"></element>
</map>
</class>
</hibernate-mapping>
最后再修改实现类
package per.liyue.code.hibernatecollection;
import java.util.HashSet;
import java.util.Set;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import org.junit.Test;
public class App {
private static SessionFactory sf;
static{
sf = new Configuration().configure().buildSessionFactory();
}
@Test
public void setOperation(){
Session s = sf.openSession();
s.beginTransaction();
/*
* Set:保存带Set的集合
*/
User user = new User();
user.setUserId(2);
user.setUserName("孙五");
Set<String> email = new HashSet<>();
email.add("c@a.com");
email.add("d@b.com");
user.setUserEmail(email);
/*
* List:保存List
*/
user.getUserPhoneNumber().add("189898989");
user.getUserPhoneNumber().add("108080808");
/*
* Map:保存Map
*/
user.getUserAddress().put("上海", "浦东");
user.getUserAddress().put("杭州", "西湖");
s.save(user);
s.getTransaction().commit();
s.close();
sf.close();
}
}
目录
3.集合数据的读取
集合数据的读取采用懒加载方式:当映射正确的时候,使用到相关集合数据,hibernate才会想数据库发送执行语句
Demo:
将上述例子中的App类中增加读取函数
@Test
public void GetCollection(){
Session s = sf.openSession();
s.beginTransaction();
User user = (User) s.get(User.class, 4);
System.out.println("查询到用户的信息:");
System.out.println("用户ID:" + user.getUserId());
System.out.println("用户名字:" + user.getUserName());
/*
* 懒加载:当有正确的映射时候,只有当使用集合相关数据时候,hibernate才会想数据库发送相关语句
*/
System.out.println("用户邮箱:" + user.getUserEmail());
System.out.println("用户电话: " + user.getUserPhoneNumber());
System.out.println("用户地址: " + user.getUserAddress());
s.getTransaction().commit();
s.close();
sf.close();
}
可以得到结果:
查询到用户的信息:
用户ID:4
用户名字:孙五
用户邮箱:[d@b.com, c@a.com]
用户电话: [189898989, 108080808]
用户地址: {上海=浦东, 杭州=西湖}
目录
4.一对多和多对一映射
4.1概念
实际开发中,有很多情况例如上面的主数据类中保存了子数据类的对象,当时常常这个集合对象内容不是单一的基本数据类型,需要用对象方式来保存更多的数据。这个时候就存在了一对多和多对一的映射关系
4.2配置和开发
4.2.1关键点
配置的关键在于对主数据类和子数据类都可以配置对应的配置文件:
- 单向关联:配置一对多
- 单向关联:配置多对一
- 双向关联:配置上面两种单向关联均配置
注意:配置了哪一种情况,就可以根据哪一种情况来操作数据。也就是说配置了一对多则可以通过一来维护多(保存时候保存一关联保存多),配置了多对一则可以通过多来维护一(保存时候保存多关联保存一)。因此在使用时候,为了提高效率,建议先保存一的一方再去保存多,因为反过来的话执行一次insert后还要多执行一次update,会降低执行效率!
4.2.2实例
有数据关系:
编写主数据类和子数据类:
package per.liyue.code.hibernate_multimapping;
import java.util.HashSet;
import java.util.Set;
/*
* 主数据类对象,包含了一个集合类型的属性,内容是另一个类的对象
*/
public class Department {
private int depId;
private String depName;
private Set<Employee> employee = new HashSet<Employee>();
public int getDepId() {
return depId;
}
public void setDepId(int depId) {
this.depId = depId;
}
public String getDepName() {
return depName;
}
public void setDepName(String depName) {
this.depName = depName;
}
public Set<Employee> getEmployee() {
return employee;
}
public void setEmployee(Set<Employee> employee) {
this.employee = employee;
}
}
package per.liyue.code.hibernate_multimapping;
/*
* 子数据类,这个类的对象是主数据类的集合元素
*/
public class Employee {
private int empId;
public int getEmpId() {
return empId;
}
public void setEmpId(int empId) {
this.empId = empId;
}
private String empName;
public String getEmpName() {
return this.empName;
}
public void setEmpName(String empName) {
this.empName = empName;
}
//多对一:
private Department dept;
public Department getDept() {
return dept;
}
public void setDept(Department dept) {
this.dept = dept;
}
}
- 配置两个类的配置文件
- 一对多的配置
<!-- 主数据类的配置文件 -->
<set name="主数据类中的子数据类的类对象" table="子数据类的表名称">
<key column="主数据类的主键(也就是子数据类的外键)"></key>
<one-to-many class="子数据类的类名称,注意同一个包下可以不带包名称,注意不要在不同包下重复用一个类名称"/>
</set>
* 多对一的配置
<!-- 子数据类的配置文件 -->
<many-to-one name="子数据类中的主数据类对象" column="子数据类的外键(主数据类的主键)" class="主数据类名称"></many-to-one>
- Demo:
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<!-- Generated Nov 9, 2006 6:27:53 PM by Hibernate Tools 3.2.0.beta7 -->
<!-- package:类对象所在的包
auto-import:表面是自动导入包,如果设定为false,则需要在执行hql语句时候将包名写清楚:
Demo:在true时候可以写为session.createQuery("from Employee").list();
在false时候必须写为session.createQuery("from per.liyue.code.hibernatehello.Employee").list();
-->
<hibernate-mapping package="per.liyue.code.hibernate_multimapping" auto-import="true">
<class name="Department" table="Department">
<!-- 主键 -->
<id name="depId" column="dep_id" >
<generator class="native" />
</id>
<property name="depName" column="dep_name"></property>
<!-- 设置一对多关系:
name:集合中的类对象对应的类
table:集合中类对象对应的表
key:子数据类中对应外键
one-to-many:子数据类对应的类,如果是同一个包下的类可以不写包名
-->
<set name="employee" table="Employee">
<key column="dep_id"></key>
<one-to-many class="Employee"/>
</set>
</class>
</hibernate-mapping>
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<!-- Generated Nov 9, 2006 6:27:53 PM by Hibernate Tools 3.2.0.beta7 -->
<!-- package:类对象所在的包
auto-import:表面是自动导入包,如果设定为false,则需要在执行hql语句时候将包名写清楚:
Demo:在true时候可以写为session.createQuery("from Employee").list();
在false时候必须写为session.createQuery("from per.liyue.code.hibernatehello.Employee").list();
-->
<hibernate-mapping package="per.liyue.code.hibernate_multimapping" auto-import="true">
<class name="Employee" table="Employee">
<!-- 主键 -->
<id name="empId" column="emp_id" >
<generator class="native" />
</id>
<property name="empName" column="emp_name"></property>
<!-- 设置多对一关系:
name:映射的主类对象
column:外键的字段名称
class:映射主类
-->
<many-to-one name="dept" column="dep_id" class="Department"></many-to-one>
</class>
</hibernate-mapping>
- 执行语句
package per.liyue.code.hibernate_multimapping;
import java.util.HashSet;
import java.util.Set;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import org.junit.Test;
public class App_Save {
private static SessionFactory sf;
static{
sf = new Configuration().configure().buildSessionFactory();
}
@Test
/*
* 一维护多,无论保存时候先保存部门还是后保存部门,必须要多执行相应的update语句保证id一致。
*/
public void DemoOne2Many(){
Session s = sf.openSession();
s.beginTransaction();
Department dept = new Department();
dept.setDepName("硬件开发部");
Employee zhangSan = new Employee();
zhangSan.setEmpName("王五");
Employee liSi = new Employee();
liSi.setEmpName("赵二");
/*
*这里的映射关系是一对多,也就是通过部门来维护员工
*/
dept.getEmployee().add(zhangSan);
dept.getEmployee().add(liSi);
s.save(zhangSan);
s.save(liSi);
s.save(dept);
s.getTransaction().commit();
s.close();
sf.close();
}
@Test
/*
* 推荐方式:通过多来维护一,这样高效!
*/
public void DemoMany2One(){
Session s = sf.openSession();
s.beginTransaction();
Department dept = new Department();
dept.setDepName("软件开发部");
Employee zhangSan = new Employee();
zhangSan.setEmpName("张三");
Employee liSi = new Employee();
liSi.setEmpName("李四");
/*
*这里的映射关系是多对一,也就是通过员工来维护部门
*/
zhangSan.setDept(dept);
liSi.setDept(dept);
//这个时候如果部门保存在后面,则保存员工时候没有部门编号,会增加两条update语句
s.save(dept);
s.save(zhangSan);
s.save(liSi);
s.getTransaction().commit();
s.close();
sf.close();
}
}
执行的语句结果
一对多的情况:
Hibernate: insert into Employee (emp_name, dep_id) values (?, ?)
Hibernate: insert into Employee (emp_name, dep_id) values (?, ?)
Hibernate: insert into Department (dep_name) values (?)
Hibernate: update Employee set dep_id=? where emp_id=?
Hibernate: update Employee set dep_id=? where emp_id=?
多对一的情况:
Hibernate: insert into Department (dep_name) values (?)
Hibernate: insert into Employee (emp_name, dep_id) values (?, ?)
Hibernate: insert into Employee (emp_name, dep_id) values (?, ?)
在hibernate中唯一的方式把对象映射为外键的方式:many-to-one
建议通过多对一来维护,这样操作高效!
- 读取数据
- 懒加载:在执行的时候hibernate才发送并执行相关SQL语句
package per.liyue.code.hibernate_multimapping;
import java.util.HashSet;
import java.util.Set;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import org.junit.Test;
public class App_Get {
private static SessionFactory sf;
static{
sf = new Configuration().configure().buildSessionFactory();
}
@Test
/*
* 一对多和多对一的读取
*/
public void DemoOne2Many(){
Session s = sf.openSession();
s.beginTransaction();
Department dep = (Department)s.get(Department.class, 1);
System.out.println("从部门读取:" + dep.getDepId());
/*
* 懒加载:不执行下面的调用,hibernate不会向数据库发送相关语句并执行
*/
System.out.println("从部门读取:" + dep.getEmployee());
Employee emp = (Employee)s.get(Employee.class, 2);
System.out.println("从员工读取:" + emp.getEmpName());
System.out.println("从员工读取:" + emp.getDept());
s.getTransaction().commit();
s.close();
sf.close();
}
}
目录
5.反转:inverse
5.1概念
- 表示反转控制,取消控制
- 在一对多和多对一的关系中,一的一方可以设置inverse属性。
5.2实例
5.2.1配置
在上面的Department.hbm.xml中,在一对多的映射中可以设定:
<set name="employee" table="Employee" inverse="false">
<key column="dep_id"></key>
<one-to-many class="Employee"/>
</set>
这里的false是默认值,表示主数据类有控制权限,如果设置为true则表示没有控制权限
5.2.2影响
- 保存:有影响,解除关联后,子数据类依旧会保存,但是外键关联取消,保存为NULL
- 读取:无影响
- 解除关联关系:有影响,解除关联关系的用法是先读取,然后主类调用clear()方法。如果解除,则则不能解除关系,但是不报错
- 删除:有影响,解除后如果外键有值,删除会违反主外键约束而报错,如果外键没有值为NULL,则可以删除
目录
6.级联:cascade
6.1概念
级联操作的设置,在一对多和多对一均可配置。如在配置文件中:
<set name="employee" table="Employee" inverse="false" cascade="none">
<key column="dep_id"></key>
<one-to-many class="Employee"/>
</set>
6.2配置
只在一对多一方配置
级联操作有以下几种配置:
- none:默认值,不级联操作
- save-update:设置级联保存和更新。注意:save和update不能拆分使用
- save-update,delete:设置级联保存、更新和删除
- all: 全部
6.3inserse和cascade区别
不能在一起使用
目录
7.多对多映射
7.1关系
在实际应用中有多对多的映射关系:
不同的人有不同的角色,不同的角色对应多个人。在数据库中二者的关联关系通常放到另一个表中。形成了多对多映射
7.2配置和实现
7.2.1定义两个数据类
package per.liyue.code.hibernate_mu2mu;
import java.util.HashSet;
import java.util.Set;
/*
* 数据类角色
*/
public class Role {
private int roleId;
private String roleName;
//包含另一个数据类对象
private Set<Person> person = new HashSet<>();
public int getRoleId() {
return roleId;
}
public void setRoleId(int roleId) {
this.roleId = roleId;
}
public String getRoleName() {
return roleName;
}
public void setRoleName(String roleName) {
this.roleName = roleName;
}
public Set<Person> getPerson() {
return person;
}
public void setPerson(Set<Person> person) {
this.person = person;
}
}
7.2.2配置二者的映射关系
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<!-- Generated Nov 9, 2006 6:27:53 PM by Hibernate Tools 3.2.0.beta7 -->
<!-- package:类对象所在的包
auto-import:表面是自动导入包,如果设定为false,则需要在执行hql语句时候将包名写清楚:
Demo:在true时候可以写为session.createQuery("from Employee").list();
在false时候必须写为session.createQuery("from per.liyue.code.hibernatehello.Employee").list();
-->
<hibernate-mapping package="per.liyue.code.hibernate_mu2mu" auto-import="true">
<class name="Role" table="Role">
<!-- 主键 -->
<id name="roleId" column="r_id" >
<generator class="native" />
</id>
<property name="roleName" column="r_name"></property>
<!-- 设置多对多关系:
name:
-->
<set name="person" table="Reletionship" inverse="false" cascade="none">
<key column="r_id"></key>
<many-to-many column="per_id" class="Person"></many-to-many>
</set>
</class>
</hibernate-mapping>
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<!-- Generated Nov 9, 2006 6:27:53 PM by Hibernate Tools 3.2.0.beta7 -->
<!-- package:类对象所在的包
auto-import:表面是自动导入包,如果设定为false,则需要在执行hql语句时候将包名写清楚:
Demo:在true时候可以写为session.createQuery("from Employee").list();
在false时候必须写为session.createQuery("from per.liyue.code.hibernatehello.Employee").list();
-->
<hibernate-mapping package="per.liyue.code.hibernate_mu2mu" auto-import="true">
<class name="Person" table="Person">
<!-- 主键 -->
<id name="personId" column="per_id" >
<generator class="native" />
</id>
<property name="personName" column="per_name"></property>
<!-- 设置多对多关系:
name:另一个类对象的实例名称
talbe:二者关系的数据库映射表
key-column:当前类的主键,关系表的外键
many-to-mangy-column:另一个类的主键,关系表中的另一个外键
many-to-mangy-class:另一个类的类名称
-->
<set name="role" table="Reletionship" inverse="false" cascade="none" >
<key column="per_id"></key>
<many-to-many column="r_id" class="Role"></many-to-many>
</set>
</class>
</hibernate-mapping>
7.2.3实现业务
package per.liyue.code.hibernate_mu2mu;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import org.junit.Test;
import per.liyue.code.hibernate_multimapping.Department;
import per.liyue.code.hibernate_multimapping.Employee;
public class App {
private static SessionFactory sf;
static{
sf = new Configuration().configure().buildSessionFactory();
}
@Test
/*
*
*/
public void DemoMany2Many(){
Session s = sf.openSession();
s.beginTransaction();
//创建
Person p_zhangsan = new Person();
p_zhangsan.setPersonName("张三");
Person p_lisi = new Person();
p_lisi.setPersonName("李四");
Role r_teacher = new Role();
r_teacher.setRoleName("教师");
Role r_student = new Role();
r_student.setRoleName("学生");
Role r_developer = new Role();
r_developer.setRoleName("开发");
//关系
p_zhangsan.getRole().add(r_teacher);
p_zhangsan.getRole().add(r_developer);
p_lisi.getRole().add(r_student);
//保存
s.save(p_zhangsan);
s.save(p_lisi);
s.save(r_teacher);
s.save(r_student);
s.save(r_developer);
s.getTransaction().commit();
s.close();
sf.close();
}
}
8.映射关系配置总结
- 一对多:
<set name="映射的集合属性" table="(可选)集合属性对应的外键表">
<key column="外键表的,外键字段" />
<one-to-many class="集合元素的类型" />
</set>
- 多对一:
<many-to-one name="对象属性" class="对象类型" column="外键字段字段" />
- 多对多
<set name="" table="">
<key column="" />
<many-to-many column="" class="">
</set>
目录
8.一对一映射
8.1分类
可以有两种一对一映射:
- 基于外键,外键唯一
- 基于主键
假设有用户和身份证的一一映射,可以有下面的两种数据库表关系
那么两种模型下的实例为:
8.2有主键的映射
8.2.1类对象
8.2.2配置文件
8.2.3主配置和实现
8.3无主键的映射
8.3.1类对象
8.3.2配置文件
8.3.3主配置和实现
目录
9.组件映射
9.1适用范围
- 组件映射指的是一个类中包含了另一个类的对象。是包含与被包含的概念
- 映射会将两个类映射到一个表中
9.2实例
9.2.1类
package per.liyue.code.component_demo;/** * Created by liyue on 2016/10/21. */public class User{ private int id; private String name; private Wheel wheel;}```
```java
package per.liyue.code.component_demo;/** * Created by liyue on 2016/10/21. */public class Wheel{ private int count; public int getCount() { return count; } public void setCount(int count) { this.count = count; } public int getSize() { return size; } public void setSize(int size) { this.size = size; } private int size;}```
## 9.2.2配置文件
```xml
<?xml version="1.0"?><!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"><!-- Generated Nov 9, 2006 6:27:53 PM by Hibernate Tools 3.2.0.beta7 --><!-- package:类对象所在的包 auto-import:表面是自动导入包,如果设定为false,则需要在执行hql语句时候将包名写清楚: Demo:在true时候可以写为session.createQuery("from Employee").list(); 在false时候必须写为session.createQuery("from per.liyue.code.hibernatehello.Employee").list(); --><hibernate-mapping package="per.liyue.code.component_demo.User" auto-import="true"> <class name="User" table="t_User"> <!-- 主键 --> <id name="id" column="user_id" > <generator class="native" /> </id> <property name="name" column="user_name"></property> <!-- 组件关系 --> <component name="wheel"> <!--组件成员--> <property name="count"></property> <property name="size"></property> </component> </class></hibernate-mapping>```
---
[toc]
---
# 10.继承映射
## 10.1概念
### 10.1.1简单继承
有多少个子类写多少个配置文件
// 动物类
public abstract class Animal {
private int id;
private String name;
<class name="Cat" table="t_Cat">
<!-- 简单继承映射: 父类属性直接写 -->
<id name="id">
<generator class="native"></generator>
</id>
<property name="na"></property>
<property name="catchMouse"></property>
</class>
@Test
public void getSave() {
Session session = sf.openSession();
session.beginTransaction();
// 保存
// Cat cat = new Cat();
// cat.setName("大花猫");
// cat.setCatchMouse("抓小老鼠");
// session.save(cat);
// 获取时候注意:当写hql查询的使用,通过父类查询必须写上类的全名
Query q = session.createQuery("from cn.itcast.e_extends1.Animal");
List<Animal> list = q.list();
System.out.println(list);
session.getTransaction().commit();
session.close();
}
### 10.1.2复杂继承
* 多个子类共用一个表
不推荐使用,因为违反数据库设计原则。在子类数量众多且属性单一情况下适用。
* 每个子类用一个表
* 父类不对应表
## 10.2实例
26.Hibernate-主键和映射.md的更多相关文章
- 010一对一 主键关联映射_双向(one-to-one)
² 两个对象之间是一对一的关系,如Person-IdCard(人—身份证号) ² 有两种策略可以实现一对一的关联映射 主键关联:即让两个对象具有相同的主键值,以表明它们之间的一一对应的关系:数据库 ...
- 009一对一 主键关联映射_单向(one-to-one)
009一对一 主键关联映射_单向(one-to-one) ² 两个对象之间是一对一的关系,如Person-IdCard(人—身份证号) ² 有两种策略可以实现一对一的关联映射 主键关联:即让两个 ...
- Hibernate主键生成策略详解
转载自:http://blog.csdn.net/wanghuan203/article/details/7562395 hibernate提供的主键生成策略,使我们可以在实体类的映射xml文件中设定 ...
- 基于按annotation的hibernate主键生成策略
基于按annotation的hibernate主键生成策略 博客分类: Hibernate HibernateJavaJPAOracleMySQL 这里讨论代理主键,业务主键(比如说复合键等)这里不 ...
- jpa基于按annotation的hibernate主键生成策略
JPA注解持久化类很方便,需要jar包:ejb3-persistence.jar下载 一.JPA通用策略生成器 通过annotation来映射hibernate实体的,基于annotation的hib ...
- hibernate主键生成机制与save返回
主键生成机制为assigned时,save之后通过get得不到id(主键),使用identity可以. hibernate主键生成机制1) assigned主键由外部程序负责生成,无需Hibernat ...
- Hibernate 主键策略
Hibernate主键生成策略 .自动增长identity 适用于MySQL.DB2.MS SQL Server,采用数据库生成的主键,用于为long.short.int类型生成唯一标识 使用SQL ...
- Hibernate主键自增策略
hibernate 主键生成策略配置: 通过 实体类映射文件中 <id>元素的 子元素 <generator> 元素进行配置 <generator> 常用配置: ( ...
- java框架篇---hibernate主键生成策略
Hibernate主键生成策略 1.自动增长identity 适用于MySQL.DB2.MS SQL Server,采用数据库生成的主键,用于为long.short.int类型生成唯一标识 使用SQL ...
随机推荐
- WEBBASE篇: 第九篇, JavaScript知识4
JavaScript 4 练习1 <!doctype html> <html lang="en"> <head> <meta charse ...
- js 在线引用
<!DOCTYPE html> <html> <head> <meta charset="utf-8" /> <meta ht ...
- Concordion test
reference documents http://concordion.org/Example.html
- 学习笔记TF040:多GPU并行
TensorFlow并行,模型并行,数据并行.模型并行根据不同模型设计不同并行方式,模型不同计算节点放在不同硬伯上资源运算.数据并行,比较通用简便实现大规模并行方式,同时使用多个硬件资源计算不同bat ...
- 【Jmeter】api性能测试总结
1.前提概念 平时常用的性能测试:api性能测试+场景性能测试:今天就说一说api性能测试 2.如何进行性能测试? 需求:对某api进行性能测试,看看最大承受的并发数,分析下图表 分析: 错误思路:当 ...
- JS 60秒后重发送验证码
//settime($("#getPhoneCode"),60); function settime($obj, time) { if (time == 0) { $obj.att ...
- 对JVM的简单了解
- 1、minimum-depth-of-binary-tree
题目描述 Given a binary tree, find its minimum depth.The minimum depth is the number of nodes along the ...
- Zabbix监控进程(进程消失后钉钉报警)
用于python报警的脚本如下:(钉钉机器人的连接需要修改) #!/usr/bin/python3# -*- coding: utf-8 -*-# Author: aiker@gdedu.ml# My ...
- docker 学习(九) docker部署静态网站
一: dockerfile, 把Dockerfile和myfolder放在一个目录下: FROM httpd:2.4 COPY ./myfolder/ /usr/local/apache2/htdo ...