Hibernate与JPA的DAO注解的全解和例子

Java、Hibernate(JPA)注解大全

一、常用：
@NotFound(action=NotFoundAction.IGNORE)

使用hibernate
注解配置实体类的关联关系，在many-to-one,one-to-one关联中，一边引用自另一边的属性，如果属性值为某某的数据在数据库不存在了，hibernate默认会抛出异常。解决此问题，加上如下注解就可以了：

@NotFound(action=NotFoundAction.IGNORE)，意思是找不到引用的外键数据时忽略，NotFound默认是exception

cascade = CascadeType.REFRESH，cascade=CascadeType.ALL

cascade表示级联操作 
   CascadeType.MERGE级联更新：若items属性修改了那么order对象保存时同时修改items里的对象。对应EntityManager的merge方法
   CascadeType.PERSIST级联刷新：获取order对象里也同时也重新获取最新的items时的对象。对应EntityManager的refresh(object)方法有效。即会重新查询数据库里的最新数据  
  

  CascadeType.REFRESH级联保存：对order对象保存时也对items里的对象也会保存。对应EntityManager的presist方法  

  CascadeType.REMOVE级联删除：对order对象删除也对items里的对象也会删除。对应EntityManager的remove方法  

CascadeType.PERSIST只有A类新增时，会级联B对象新增。若B对象在数据库存（跟新）在则抛异常（让B变为持久态）

CascadeType.MERGE指A类新增或者变化，会级联B对象（新增或者变化）

CascadeType.REMOVE只有A类删除时，会级联删除B类；

CascadeType.ALL包含所有；

CascadeType.REFRESH没用过。

综上：大多数情况用CascadeType.MERGE就能达到级联跟新又不报错，用CascadeType.ALL时要斟酌下CascadeType.REMOVE

@Fetch:

定义了加载关联关系的获取策略. FetchMode 可以是

SELECT (在需要加载关联的时候触发select操作),     SUBSELECT(只对集合有效,使用了子查询策略,详情参考Hibernate参考文档)

JOIN (在加载主实体(owner entity)的时候使用SQL JOIN来加载关联关系).

JOIN 将覆写任何延迟属性 (通过 JOIN策略加载的关联将不再具有延迟性).

fetch=FetchType.LAZY
Hibernate的数据加载方式：
1.即时加载 immediately loading

       实体加载完成后，立即加载其关联的数据。
2.延迟加载lazy loading

       实体相关联的数据在第一次访问时再进行读取。
3.预先加载 eager loading

        与immediately loading类似，但实体和相关联的数据是通过一条sql同时读取。
4.批量加载 batch loading

二、详细说明

1、@Entity(name=”EntityName”)

必须,name为可选,对应数据库中一的个表

2、@Table(name=””,catalog=””,schema=””)

可选,通常和@Entity配合使用,只能标注在实体的class定义处,表示实体对应的数据库表的信息

name:可选,表示表的名称.默认地,表名和实体名称一致,只有在不一致的情况下才需要指定表名

catalog:可选,表示Catalog名称,默认为Catalog(“”).

schema:可选,表示Schema名称,默认为Schema(“”).
3、@id

必须
@id定义了映射到数据库表的主键的属性,一个实体只能有一个属性被映射为主键.置于getXxxx()前.

4、@GeneratedValue(strategy=GenerationType,generator=””)

可选
strategy:表示主键生成策略,有AUTO,INDENTITY,SEQUENCE 和 TABLE 4种,分别表示让ORM框架自动选择,
根据数据库的Identity字段生成,根据数据库表的Sequence字段生成,以有根据一个额外的表生成主键,默认为AUTO
generator:表示主键生成器的名称,这个属性通常和ORM框架相关,例如,Hibernate可以指定uuid等主键生成方式.
示例:
@Id
@GeneratedValues(strategy=StrategyType.SEQUENCE)
public int getPk() {
return pk;
}

5、@Basic(fetch=FetchType,optional=true)

可选
@Basic表示一个简单的属性到数据库表的字段的映射,对于没有任何标注的getXxxx()方法,默认即为@Basic
fetch: 表示该属性的读取策略,有EAGER和LAZY两种,分别表示主支抓取和延迟加载,默认为EAGER.
optional:表示该属性是否允许为null,默认为true
示例:

@Basic(optional=false)
public String getAddress() {
return address;
}

6、@Column
可选
@Column描述了数据库表中该字段的详细定义,这对于根据JPA注解生成数据库表结构的工具非常有作用.
name:表示数据库表中该字段的名称,默认情形属性名称一致
nullable:表示该字段是否允许为null,默认为true
unique:表示该字段是否是唯一标识,默认为false
length:表示该字段的大小,仅对String类型的字段有效
insertable:表示在ORM框架执行插入操作时,该字段是否应出现INSETRT语句中,默认为true
updateable:表示在ORM框架执行更新操作时,该字段是否应该出现在UPDATE语句中,默认为true.对于一经创建就不可以更改的字段,该属性非常有用,如对于birthday字段.
columnDefinition: 表示该字段在数据库中的实际类型.通常ORM框架可以根据属性类型自动判断数据库中字段的类型,但是对于Date类型仍无法确定数据库中字段类型究竟是 DATE,TIME还是TIMESTAMP.此外,String的默认映射类型为VARCHAR,如果要将String类型映射到特定数据库的BLOB或 TEXT字段类型,该属性非常有用.
示例:
@Column(name=”BIRTH”,nullable=”false”,columnDefinition=”DATE”)
public String getBithday() {
return birthday;
}

7、@Transient

可选
@Transient表示该属性并非一个到数据库表的字段的映射,ORM框架将忽略该属性.
如果一个属性并非数据库表的字段映射,就务必将其标示为@Transient,否则,ORM框架默认其注解为@Basic
示例:
//根据birth计算出age属性
@Transient
public int getAge() {
return getYear(new Date()) – getYear(birth);

}

8、@ManyToOne(fetch=FetchType,cascade=CascadeType)

可选
@ManyToOne表示一个多对一的映射,该注解标注的属性通常是数据库表的外键
optional:是否允许该字段为null,该属性应该根据数据库表的外键约束来确定,默认为true
fetch:表示抓取策略,默认为FetchType.EAGER
cascade:表示默认的级联操作策略,可以指定为ALL,PERSIST,MERGE,REFRESH和REMOVE中的若干组合,默认为无级联操作
targetEntity:表示该属性关联的实体类型.该属性通常不必指定,ORM框架根据属性类型自动判断targetEntity.
示例:
//订单Order和用户User是一个ManyToOne的关系
//在Order类中定义
@ManyToOne()
@JoinColumn(name=”USER”)
public User getUser() {
return user;
}

9、@JoinColumn
可选
@JoinColumn和@Column类似,介量描述的不是一个简单字段,而一一个关联字段,例如.描述一个@ManyToOne的字段.
name:该字段的名称.由于@JoinColumn描述的是一个关联字段,如ManyToOne,则默认的名称由其关联的实体决定.
例如,实体Order有一个user属性来关联实体User,则Order的user属性为一个外键,
其默认的名称为实体User的名称+下划线+实体User的主键名称
示例:
见@ManyToOne

10、@OneToMany(fetch=FetchType,cascade=CascadeType)
可选
@OneToMany描述一个一对多的关联,该属性应该为集体类型,在数据库中并没有实际字段.
fetch:表示抓取策略,默认为FetchType.LAZY,因为关联的多个对象通常不必从数据库预先读取到内存
cascade:表示级联操作策略,对于OneToMany类型的关联非常重要,通常该实体更新或删除时,其关联的实体也应当被更新或删除
例如:实体User和Order是OneToMany的关系,则实体User被删除时,其关联的实体Order也应该被全部删除
示例:
@OneTyMany(cascade=ALL)
public List getOrders() {
return orders;
}

11、@OneToOne(fetch=FetchType,cascade=CascadeType)

可选
@OneToOne描述一个一对一的关联
fetch:表示抓取策略,默认为FetchType.LAZY
cascade:表示级联操作策略
示例:
@OneToOne(fetch=FetchType.LAZY)
public Blog getBlog() {

return blog;

}

12、@ManyToMany
可选
@ManyToMany 描述一个多对多的关联.多对多关联上是两个一对多关联,但是在ManyToMany描述中,中间表是由ORM框架自动处理
targetEntity:表示多对多关联的另一个实体类的全名,例如:package.Book.class
mappedBy:表示多对多关联的另一个实体类的对应集合属性名称
示例:
User实体表示用户,Book实体表示书籍,为了描述用户收藏的书籍,可以在User和Book之间建立ManyToMany关联
@Entity
public class User {

private List books;

@ManyToMany(targetEntity=package.Book.class)

public List getBooks() {

return books;

}

public void setBooks(List books) {

this.books=books;

}

}

@Entity

public class Book {

private List users;

@ManyToMany(targetEntity=package.Users.class, mappedBy=”books”)

public List getUsers() {

return users;

}

public void setUsers(List users) {

this.users=users;

}

}

两个实体间相互关联的属性必须标记为@ManyToMany,并相互指定targetEntity属性,
需要注意的是,有且只有一个实体的@ManyToMany注解需要指定mappedBy属性,指向targetEntity的集合属性名称
利用ORM工具自动生成的表除了User和Book表外,还自动生成了一个User_Book表,用于实现多对多关联
13、@MappedSuperclass

可选
@MappedSuperclass可以将超类的JPA注解传递给子类,使子类能够继承超类的JPA注解
示例:
@MappedSuperclass

public class Employee() {

….

}

@Entity

public class Engineer extends Employee {

…..

}

@Entity

public class Manager extends Employee {

…..

}

14、@Embedded

可选
@Embedded将几个字段组合成一个类,并作为整个Entity的一个属性.
例如User包括id,name,city,street,zip属性.
我们希望city,street,zip属性映射为Address对象.这样,User对象将具有id,name和address这三个属性.
Address对象必须定义为@Embededable
示例:

@Embeddable

public class Address {city,street,zip}

@Entity

public class User {

@Embedded

public Address getAddress() {

……….

}

}

 

Hibernate验证注解

 

注解适用类型说明示例@PatternString通过正则表达式来验证字符串@attern(regex=”[a-z]{6}”)@LengthString验证字符串的长度@length(min=3,max=20) @EmailString验证一个Email地址是否有效@email@RangeLong验证一个整型是否在有效的范围内@Range(min=0,max=100)@MinLong验证一个整型必须不小于指定值@Min(value=10)@MaxLong验证一个整型必须不大于指定值@Max(value=20)@Size集合或数组集合或数组的大小是否在指定范围内@Size(min=1,max=255)

 
以上每个注解都可能性有一个message属性，用于在验证失败后向用户返回的消息，还可以三个属性上使用多个注解

======================================================================================

连接数据库配置文件：hibernate.cfg.xml

<?xml version="1.0" encoding="UTF-8"?>

<!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>
    <property name="connection.username">root</property>
    <property name="connection.password">200869</property>
    <property name="connection.driver.class">com.mysql.jdbc.Driver</property>
    <property name="connection.url">jdbc:mysql://localhost/hibernate</property>
    <property name="dialect">org.hibernate.dialect.MySQLDialect</property>
    <property name="connection.useUnicode">true </property>   
    <property name="connection.characterEncoding">UTF-8 </property> 
   
    <property name="show_sql">true</property>
    <property name="format_sql">true</property>
    <property name="hbm2ddl.auto">update</property>
    <!-- 要用到当前的单例的Currentsession要配置 -->
    <property name="current_session_context_class">thread</property>
   
    <mapping class="com.lohas.entity.Students"/>
    </session-factory>

</hibernate-configuration>

Students.java

package com.lohas.entity;

import java.util.Date;

import javax.persistence.Embeddable;
import javax.persistence.Embedded;
import javax.persistence.EmbeddedId;
import javax.persistence.Entity;//JPA注解
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.Table;
import javax.persistence.Transient;

import org.hibernate.annotations.GenericGenerator;


//@Entity(name="t_Students")//带表名的，如果没有则默认为类的第一个字母小写的表名
/**
 * 
 * @author Lohas
 * @Table(name="",catalog="",schema="")
 * name:可选，映射表的名称，默认表名和实体名称一致,只有在不一致的情况下指定表名
 * catalog:可选，表示目录，默认值为空（各种数据库支持不同）
 * schema:可选，表示模式（各种数据库支持不同）
 */
@Entity
//@Table(name="t_student",schema="hibernate")
public class Students {
/**
* @Id
* 可置于主键属性或者getXxx()前
* 如果有多个属性定义为主键属性，该实体类必须实现serializable接口
* 
* @GeneratedValue:可选，用于定义主键生成策略
* @GeneratedValue(strategy=GenerationType,generator="")
* strategy表示主键生成策略，取值：
* GenerationType.AUTO:根据底层数据库自动选择（默认）

*{@GeneratedValue等同@GeneratedValue(strategy=GenerationType.AUTO)}
* String类型不能指定：GenerationType.AUTO
* GenerationType.IDENTITY：根据数据库的IDENTITY字段生成
* GenerationType.SEQUENCE：使用SEQUENCE来决定主键的取值（oracle,db2）
* GenerationType.TABLE：使用指定表来决定主键取值，结合@TableGenerator使用
* 
* generator：主键生成器
* @GeneratedValue(generator="sid")//generator="sid"与name="sid"一样
* @GenericGenerator(name="sid",strategy="assigned")//assigned:手动赋值
* 
* @Column:可将属性映射到列，描述了数据库表中该字段的详细定义
* name:可选，表示数据库表中该字段的名称，默认情形名称一致
* nullable:可选，表示该字段是否允许为null,默认为true
* unique:可选，表示该字段是否是唯一标识，默认为false
* length:可选，表示该字段的大小，仅对String类型的字段有效，默认值255
* (如果是主键不能使用默认值)
* insertable:可选，表示在ORM框架执行插入操作，该字段是否应出现Insert语句中，默认为true
* updateable：可选，表示在ORM框架执行更新操作，该字段是否应出现update语句中，默认为true
* 对于一经创建就不可以更改的字段，该属性非常有用，如对于birthday字段
* 
* @Embedded:注释属性的，表示该属性的类是嵌入类
* 注意：同时嵌入类也必须标注@Embeddable注解 
* 
* @Embeddable //表示是一个嵌入类，这个类的对象在另一个实体类中充当属性
* 
* @EmbeddedId:使用嵌入式主键类实现复合主键。
* 注意：嵌入式主键类必须实现Serializable街道口 ，必须有默认的
* public无参数的构造方法，必覆盖equals和hashCode方法
* 
* @Transient:可选，表示该属性并非一个到数据库的字段的映射，ORM框架将
* 忽略该属性，如果一个属性并非数据库的字段映射，就务必将其标示为@Transient
* 否则ORM框架默认其注解为@Basic
*/

// @Id

// @GeneratedValue(strategy=GenerationType.AUTO)

// @GeneratedValue(generator="sid")//generator="sid"与name="sid"一样
// @GenericGenerator(name="sid",strategy="assigned")//assigned:手动赋值
// private int sid;
//@Column(length=8)
@EmbeddedId//(复合主键)
private PersonPK pk;
private String sname;
private String gender;
private Date birthday;
private String major;
@Transient
private double salary;
// private String address;
@Embedded
private Address add;

public Students(){

}

public Students(/*int sid*/ StudentPK pk, String sname, String gender, Date birthday, String major,Address add) {
// super();
// this.sid = sid;
this.pk = pk;
this.sname = sname;
this.gender = gender;
this.birthday = birthday;
this.major = major;
// this.address = address;
this.add = add;
}

//@Id
// public int getSid() {
// return sid;
// }
//
// public void setSid(int sid) {
// this.sid = sid;
// }

public String getSname() {
return sname;
}

public void setSname(String sname) {
this.sname = sname;
}

public String getGender() {
return gender;
}

public void setGender(String gender) {
this.gender = gender;
}

public Date getBirthday() {
return birthday;
}

public void setBirthday(Date birthday) {
this.birthday = birthday;
}

public String getMajor() {
return major;
}

public void setMajor(String major) {
this.major = major;
}

public Address getAdd() {
return add;
}

public void setAdd(Address add) {
this.add = add;
}

public StudentPK getPk() {
return pk;
}

public void setPk(StudentPK pk) {
this.pk = pk;
}

public double getSalary() {
return salary;
}

public void setSalary(double salary) {
this.salary = salary;
}

}

Address.java(测试@Embeddable)

package com.lohas.entity;

import javax.persistence.Embeddable;


@Embeddable //表示是一个嵌入类，这个类的对象在另一个实体类中充当属性
public class Address {

private String postCode;
private String address;
private String phone;

public Address(){

}

public Address(String postCode, String address, String phone) {
// super();
this.postCode = postCode;
this.address = address;
this.phone = phone;
}

public String getPostCode() {
return postCode;
}

public void setPostCode(String postCode) {
this.postCode = postCode;
}

public String getAddress() {
return address;
}

public void setAddress(String address) {
this.address = address;
}

public String getPhone() {
return phone;
}

public void setPhone(String phone) {
this.phone = phone;
}

}

StudentPK.java(测试@Embeddable和@EmbeddedId复合主键)

package com.lohas.entity;

import java.io.Serializable;

import javax.persistence.Column;
import javax.persistence.Embeddable;

@Embeddable
public class StudentPK implements Serializable{

/**
* 
*/
private static final long serialVersionUID = 1L;
@Column(length=18)
private String id;
@Column(length=8)
private String sid;

public StudentPK(){

}

public String getId() {
return id;
}

public void setId(String id) {
this.id = id;
}

public String getSid() {
return sid;
}

public void setSid(String sid) {
this.sid = sid;
}

@Override
public boolean equals(Object obj) {
return super.equals(obj);
}

@Override
public int hashCode() {
return super.hashCode();
}

}

TestStudents.java(测试类)

package com.lohas.test;

import java.util.Date;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.hibernate.service.ServiceRegistry;
import org.hibernate.service.ServiceRegistryBuilder;
import org.hibernate.tool.hbm2ddl.SchemaExport;
import org.junit.Test;


import com.lohas.entity.Address;
import com.lohas.entity.StudentPK;
import com.lohas.entity.Students;


public class TestStudents {

@Test
public void testShemaExport(){
//创建hibernate配置对象
Configuration config = new Configuration().configure();
//创建服务注册对象
ServiceRegistry serviceRegistry = new ServiceRegistryBuilder().applySettings(config.getProperties())
.buildServiceRegistry();
// 创建工厂对象
SessionFactory sessionFactory = config.buildSessionFactory(serviceRegistry);
//创建会话
Session session = sessionFactory.getCurrentSession();
//创建事务
Transaction tx = session.beginTransaction();

// Address add = new Address("007","广州","13800138000");
// Students s = new Students (1,"Lohas","男",new Date(),"java",add);

Address add = new Address("007","广州","13800138000");
StudentPK pk= new StudentPK ();
pk.setId("123456789012345678");
pk.setSid("12345678");

Students s = newStudents(pk,"Lohas","男",new Date(),"java",add);
session.save(s);
tx.commit();

// SchemaExport export = new SchemaExport(config);
// export.create(true,true);
}
}