AQ#说明
1.基础的jar包
required + jpa + mysql数据库连接
1.下载地址
http://hibernate.org/orm/downloads/
https://sourceforge.net/projects/hibernate/files/hibernate-orm/
https://sourceforge.net/projects/hibernate/files/
2.ORM概念
O Object 对象
Java对象
R Relation 关系
数据库表
M Mapping 映射
dao中的增删改查操作 方式：1.xx.hbm.xml 2.注解
ORM是规则是概念
ORM的实现
hibernate框架
mybatis框架
自己代码实现（反射）
3.对dao操作，有哪些选择，优缺点
1.jdbc
2.DbUtils组件
3.自己封装jdbc工具类，简化jdbc操作
4.hibernate框架
5.mybatis框架
对比
执行效率最高：纯jdbc操作
开发效率最高：hibernate
兼容性好：hibernate，可以跨数据库平台
4.使用步骤：
1.建库、建表
2.写实体类
3.写映射文件
4.写数据库配置文件
5.测试api
基本映射 base
主键映射
基本主键映射
复合主键映射
复合属性 compattr
修改列名2种方式
集合映射 collection
基本数据类型/自定义类型
List
Set
Map
关联映射 oneway/bothway
单向关联（一边配置关联）：oneway
一对一（1--1）：
一对多（1--N）：
多对一（N--1）：
多对多（N--N）：
双向关联（两边配置关联）：两边都可以查询 bothway
一对一（1--1）：@OneToOne 加了mappedBy的表时主表，另外一张是从表
一对多（1--N）：
多对多（N--1）：@ManyToMany
从表中生成外键，配置@JoinCloumn的是从表 先保存主表，再保存从表
继承映射 extend
所有的持久化都会生成表(子类表会引用父类表的主键列)
单个表(只生成一张表)
所有的持久化都会生成表(子类会把父类中的属性继承过来生成在自己的表中)
代码
onfiguration cf = new Configuration();
cf.configure("com/shuai/hibernate/bothway/onetomany/hibernate.cfg.xml");
ServiceRegistry serviceRegistry = new StandardServiceRegistryBuilder()
.applySettings(cf.getProperties()).build();
SessionFactory sessionFactory = cf.buildSessionFactory(serviceRegistry);
Session session = sessionFactory.getCurrentSession();
Transaction transaction = session.beginTransaction();
//数据库操作
transaction.commit();
基础
//1.注解方式
@Entity //把pojo转化成持久化类
@Table(name="user") // 指定表名
public class User {
@Id //主键列
@GeneratedValue(strategy=GenerationType.AUTO) //自增长
@Column(name="u_id") //指定数据库列名 如果不写就跟属性名一致 (映射列名 )
private int id;
@Column(name="u_name", //列名
length=50, //长度
nullable=true, //非空约束
unique=true)// 唯一约束
private String name;
@Column(name="u_age", //列名
columnDefinition="int(10) NOT NULL default 20") //规定长度 和 初始化值
private int age;
@Column(name="u_address",
insertable=false, // 不允许插入
updatable=false)// 不允许修改
private String address;
@Column(name="u_salary", precision=6, // 总位数
scale=2) // 小数点后面位数
private BigDecimal salary;
@Lob // 映射大的二进制或大的文本
private byte[] pictrue;
/*
* TemporalType.DATE : yyyy-MM-dd
* TemporalType.TIME : HH:mm:ss
* TemporalType.TIMESTAMP : yyyy-MM-dd HH:mm:ss
* */
@Temporal(TemporalType.TIMESTAMP) //日期格式
private Date birthday;
@Transient // @Transient|transient 指定不是持久化的属性(不会生成表中列)
private String remark;
}
//2.配置文件方式
public class User {
private int id;
private String name;
private String password;
}
//配置User.hbm.xml
<class name="com.shuai.hibernate.domain.User" table="t_user">
<id name="id" column="u_id">
<generator class="native"></generator>
</id>
<property name="name" column="u_name"></property>
<property name="password" column="u_password"></property>
</class>
<!--
class 是映射一个对象
name 是Java类
table 是表
property 映射属性
name 是类的属性名
column 是表中的属性名
length 是指定表中字段的长度 默认是255
type 是表中字段的类型
not-null 是否能为空 非空约束
unique 是否唯一 唯一约束
id 是主键映射 在hibernate中表中必须要有主键
generator 主键生成策略
native 主键自增长
identity MySQL中的自增长方式
sequence Oracle中的序列增长方式
increment 自增长但是不支持并发
assigned 手动指定主键的值
uuid 使用uuid做为主键 主键是String类型
foreign 外键策略 一对一映射时用到
-->
主键/联合主键
//主键
@Entity
@Table(name="user")
public class User {
/*
* GenerationType.IDENTITY: 适宜MySQL、SqlServer有自增长列的数据库
* GenerationType.SEQUENCE：适宜Oracle这种没有自增长有sequence的数据库
* GenerationType.AUTO：让Hibernate根据数据库方言自动选择主键生成策略
* GenerationType.TABLE: 适宜所有的数据库,因为它会单独生成一张表来维护主键生成
* */
@Id
@GeneratedValue(strategy=GenerationType.AUTO)
private int id;
}
//联合主键
public class PersonKey implements Serializable{
private String firstName;
private String lastName;
}
@Entity
@Table(name="Person")
public class Person {
@Embedded
private PersonKey key;
}
//修改联合主键表中名字-第一种方式
public class PersonKey implements Serializable{
private String firstName;
private String lastName;
}
@Entity
@Table(name="Person")
public class Person {
@Embedded
@AttributeOverrides({@AttributeOverride(name="firstName", column=@Column(name="F_NAME")),
@AttributeOverride(name="lastName", column=@Column(name="L_NAME"))})
private PersonKey key;
}
//修改联合主键表中名字-第二种方式
public class PersonKey implements Serializable{
@Column(name="FIRST_NAME")
private String firstName;
@Column(name="LAST_NAME")
private String lastName;
}
@Entity
@Table(name="Person")
public class Person {
@Embedded
private PersonKey key;
}
//配置文件
public class PersonKeys implements Serializable{
private String username;
private int password;
}
public class Person {
private PersonKeys keys;
private int age;
}
//Person.hbm.xml配置
<class name="com.shuai.hibernate.domain.Person" table="t_person">
<composite-id name="keys">
<key-property name="username"></key-property>
<key-property name="password"></key-property>
</composite-id>
<property name="age" column="u_age"></property>
</class>
继承体系中生成表的情况 InheritanceType.JOINED
@Entity
@Table(name="person") //生成person表
@Inheritance(strategy=InheritanceType.JOINED) //所有的持久化都会生成表(子类表会引用父类表的主键列)
public class Person{
@Id
@GeneratedValue(strategy=GenerationType.AUTO)
private int id;
private String name;
}
@Entity
public class Student extends Person{
private String subject;
}
注意：
@Inheritance(strategy=InheritanceType.JOINED)
所有的持久化都会生成表(子类表会引用父类表的主键列)
继承体系中生成表的情况 InheritanceType.SINGLE_TABLE
@Entity
@Table(name="person") //生成person表
@Inheritance(strategy=InheritanceType.SINGLE_TABLE)// 单个表
@DiscriminatorColumn(name="per_stu",discriminatorType=DiscriminatorType.INTEGER)// 辨别者列
@DiscriminatorValue("1")// 辨别者列值
public class Person {}
@Entity
@DiscriminatorValue("2") //辨别者列值
public class Student{}
注意：
@DiscriminatorColumn(name="per_stu",discriminatorType=DiscriminatorType.INTEGER)// 辨别者列
person表中会生成一个per_stu列。
当存入Person对象时，per_stu列的值是1
当存入Student对象时，per_stu列的值是2
继承体系中生成表的情况
@Entity
@Table(name="person")
@Inheritance(strategy=InheritanceType.TABLE_PER_CLASS)// 所有的持久化都会生成表(子类会把父类中的属性继承过来生成在自己的表中)
public class Person{}
@Entity
public class Student{}
注意：
所有的持久化都会生成表(子类会把父类中的属性继承过来生成在自己的表中)
这种策略主键不能用自增长
查询时会出现union运算
总结保存List/Set/Map
List
@ElementCollection
@CollectionTable
@OrderColumn
@Embeddable - 注解集合中的类
Set
@ElementCollection
@CollectionTable
@Embeddable - 注解集合中的类
Map
@ElementCollection
@CollectionTable
@MapKeyColumn
@Embeddable - 注解集合中的类
保存List
Person.java
@ElementCollection(fetch=FetchType.LAZY,targetClass=String.class)
@CollectionTable(name="address")
@OrderColumn(name="a_id")
private List<String> address = new ArrayList<String>();
注意：
@OrderColumn(name="a_id")
a_id是自增长id
@CollectionTable(name="address")
address是表名
生成的address表中会有一个Person_id 是Person的主键id
@Embeddable
Address.java
里面就是一些属性，可以没有主键
此类不会生成表
User.java
@ElementCollection(fetch=FetchType.LAZY,targetClass=Address.class)
@CollectionTable(name="user_address")
@OrderColumn(name="u_a_id")
private List<Address> address = new ArrayList<Address>();
注意：
@OrderColumn(name="u_a_id")
u_a_id 是自增长的id
@CollectionTable(name="user_address")
user_address是表名
生成的user_address表中会有一个User_id是user表的主键id
保存Set
Person.java
@ElementCollection(fetch=FetchType.LAZY,targetClass=String.class)
@CollectionTable(name="p_address")
private Set<String> address = new HashSet<String>();
注意：
@CollectionTable(name="p_address")
p_address 是表名
在表中会有一个Person_id是person表中的主键
@Embeddable
Address.java
里面就是一些属性，可以没有主键
此类不会生成表
User.java
@ElementCollection(fetch=FetchType.LAZY,targetClass=Address.class)
@CollectionTable(name="user_address")
private Set<Address> address = new HashSet<Address>();
注意：
@CollectionTable(name="user_address")
user_address 是表名
在表中会有一个User_id是user表中的主键
保存Map
Person.java
@ElementCollection(fetch=FetchType.LAZY,targetClass=String.class)
@CollectionTable(name="p_address")
@MapKeyColumn(name="m_key")
private Map<String,String> address = new HashMap<String,String>();
注意：
@MapKeyColumn(name="m_key")
是Map的键
@CollectionTable(name="p_address")
是表名
在生成的表中会有一个Person_id对应person表中的id
@Embeddable
Address.java
里面就是一些属性，可以没有主键
此类不会生成表
User.java
@ElementCollection(fetch=FetchType.LAZY,targetClass=Address.class)
@CollectionTable(name="user_address")
@MapKeyColumn(name="map_key")
private Map<String,Address> address = new HashMap<String,Address>();
注意：
@MapKeyColumn(name="map_key")
是Map的键
@CollectionTable(name="user_address")
是表名
在生成的表中会有一个User_id对应user表中的id
总结
双向关联
多对多
多对一
一对多
一对一
单向关联
多对多
多对一
一对多
一对一
双向关联
先保存主表，再保存从表
有mappedBy的类中是主表。
单向关联
先保存主表，再保存从表
有@JoinColumn的类是从表。
单向关联-一对一
Teacher.java
@OneToOne(fetch=FetchType.LAZY,targetEntity=Student.class)
@JoinColumn(name="s_id",unique=true,referencedColumnName="sid")
private Student student;
Student.java
private int sid;
注意：
@JoinColumn(name="s_id",unique=true,referencedColumnName="sid")
name：在teacher表中创建一个s_id的字段，用来存储一条student数据的sid
referencedColumnName：关联student表中的sid字段
单向关联-一对多
Teacher.java
private int tid;
@OneToMany(fetch=FetchType.LAZY,targetEntity=Student.class)
@JoinColumn(name="t_id",referencedColumnName="tid")
private Set<Student> students = new HashSet<Student>();
Student.java - 保存外键
private int sid;
注意：
@JoinColumn(name="t_id",referencedColumnName="tid")
name ：会在student表中添加t_id字段，关联的是teacher表中的tid字段。
单向关联-多对一
Teacher.java
private int tid;
Student.java - 保存外键
@ManyToOne(fetch=FetchType.LAZY,targetEntity=Teacher.class)
@JoinColumn(name="t_id",referencedColumnName="tid")
private Teacher teacher;
注意：
@JoinColumn(name="t_id",referencedColumnName="tid")
name ：会在student表中创建一个t_id字段，关联teacher表中的tid字段
单向关联-多对多
Teacher.java
private int tid;
@ManyToMany(fetch=FetchType.LAZY,targetEntity=Student.class)
@JoinTable(name="t_tech_stu",
joinColumns=@JoinColumn(name="t_id",referencedColumnName="tid"),
inverseJoinColumns=@JoinColumn(name="s_id",referencedColumnName="sid"))
private Set<Student> students = new HashSet<Student>();
Student.java
private int sid;
注意：
@JoinTable(name="t_tech_stu",
joinColumns=@JoinColumn(name="t_id",referencedColumnName="tid"),
inverseJoinColumns=@JoinColumn(name="s_id",referencedColumnName="sid"))
name ：是中间表名
joinColumns ：
inverseJoinColumns ：
双向关联-一对一
Teacher.java
private int tid;
@OneToOne(fetch=FetchType.LAZY,targetEntity=Student.class,mappedBy="teacher")
private Student student;
Student.java
private int sid;
@OneToOne(fetch=FetchType.LAZY,targetEntity=Teacher.class)
@JoinColumn(name="t_id",referencedColumnName="tid",unique=true)
private Teacher teacher;
注意：
@JoinColumn(name="t_id",referencedColumnName="tid",unique=true)
name ：在student表中创建一个t_id的字段，关联teacher表中的tid字段
@OneToOne(fetch=FetchType.LAZY,targetEntity=Student.class,mappedBy="teacher")
mappedBy ：表示teacher表不维护关联字段。交给student表管理。
双向关联-一对多
Teacher.java
private int tid;
@OneToMany(fetch=Fetch.LAZY,targetEntity=Student.class,mappedBy="teacher")
private Set<Student> students = new HashSet<Student>();
Student.java
private int sid;
@ManyToOne(fetch=Fetch.LAZY,targetEntity=Teacher.class)
@JoinColumn(name="t_id",referencedColumnName="tid")
private Teacher teacher;
注意：
@JoinColumn(name="t_id",referencedColumnName="tid")
name ：在student表中创建一个t_id字段，关联teacher表中的tid字段
@OneToMany(fetch=Fetch.LAZY,targetEntity=Student.class,mappedBy="teacher")
mappedBy ：表示不维护关联字段
双向关联-多对多
Teacher.java
private int tid;
@ManyToMany(fetch=FetchType.LAZY,targetEntity=Student.class,mappedBy="teachers")
private Set<Student> students = new HashSet<Student>();
Student.java
private int sid;
@ManyToMany(fetch=FetchType.LAZY,targetEntity=Teacher.class)
@JoinTable(name="t_teach_stu",
joinColumns=@JoinColumn(name="s_id",referencedColumnName="sid"),
inverseJoinColumns=@JoinColumn(name="t_id",referencedColumnName="tid"))
private Set<Teacher> teachers = new HashSet<Teacher>();
注意：
@ManyToMany(fetch=FetchType.LAZY,targetEntity=Student.class,mappedBy="teachers")
mappedBy : 表示不维护外键
@JoinTable(name="t_teach_stu",
joinColumns=@JoinColumn(name="s_id",referencedColumnName="sid"),
inverseJoinColumns=@JoinColumn(name="t_id",referencedColumnName="tid"))
name ：中间表名
joinColumns ：
inverseJoinColumns ：
网友评论