Hibernate的註解

以Hibernate3.3作爲例子。

 

一、常用的註解

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等主鍵生成方式

 

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

可選

@Basic表示一個簡單的屬性到數據庫表的字段的映射，對於沒有任何標註的getXxxx()方法，默認即爲@Basic
fetch：表示該屬性的讀取策略，有EAGER和LAZY兩種，分別表示主支抓取和延遲加載，默認爲EAGER
optional：表示該屬性是否允許爲null，默認爲true

 

6.@Column(name = "", unique = true, nullable = false, precision = 9, scale = 0)

可選

@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字段類型，該屬性非常有用

 

7.@Transient

可選

@Transient表示該屬性並非一個到數據庫表的字段的映射，ORM框架將忽略該屬性。如果一個屬性並非數據庫表的字段映射，就務必將其標示爲@Transient，否則，ORM框架默認其註解爲@Basic

 

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

可選

@ManyToOne表示一個多對一的映射，該註解標註的屬性通常是數據庫表的外鍵
optional：是否允許該字段爲null，該屬性應該根據數據庫表的外鍵約束來確定，默認爲true
fetch：表示抓取策略，默認爲FetchType.EAGER
cascade：表示默認的級聯操作策略，可以指定爲ALL、PERSIST、MERGE、REFRESH和REMOVE中的若干組合，默認爲無級聯操作
targetEntity：表示該屬性關聯的實體類型，該屬性通常不必指定，ORM框架根據屬性類型自動判斷targetEntity

 

9.@JoinColumn

可選

@JoinColumn和@Column類似，介量描述的不是一個簡單字段，而一一個關聯字段，例如，描述一個@ManyToOne的字段
name：該字段的名稱。由於@JoinColumn描述的是一個關聯字段，如ManyToOne，則默認的名稱由其關聯的實體決定

 

10.@OneToMany(fetch = FetchType, cascade = CascadeType) 

可選

@OneToMany描述一個一對多的關聯，該屬性應該爲集體類型，在數據庫中並沒有實際字段
fetch：表示抓取策略，默認爲FetchType.LAZY，因爲關聯的多個對象通常不必從數據庫預先讀取到內存
cascade：表示級聯操作策略，對於OneToMany類型的關聯非常重要，通常該實體更新或刪除時，其關聯的實體也應當被更新或刪除

 

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

可選

@OneToOne描述一個一對一的關聯
fetch：表示抓取策略,默認爲FetchType.LAZY
cascade：表示級聯操作策略

12.@ManyToMany

可選

@ManyToMany描述一個多對多的關聯，多對多關聯上是兩個一對多關聯，但是在ManyToMany描述中，中間表是由ORM框架自動處理
targetEntity：表示多對多關聯的另一個實體類的全名，例如：package.Book.class
mappedBy：表示多對多關聯的另一個實體類的對應集合屬性名稱

 

13.@MappedSuperclass

可選
@MappedSuperclass可以將超類的JPA註解傳遞給子類，使子類能夠繼承超類的JPA註解

 

14.@Embedded

可選
@Embedded將幾個字段組合成一個類，並作爲整個Entity的一個屬性

 

二、新建一Java Project，並搭建Hibernate3.3框架

 1.必須打勾，支持Hibernate的註解

 

2.打不打勾都行

 

 

三、映射兩個實體類：

Employee類：

package org.e276.entity;

import java.util.Date;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.SequenceGenerator;
import javax.persistence.Table;
import javax.persistence.Temporal;
import javax.persistence.TemporalType;

/**
 * Employee entity. @author MyEclipse Persistence Tools
 */
@Entity
@Table(name = "EMPLOYEE", schema = "Y2")
public class Employee implements java.io.Serializable {

	// Fields

	private Integer id;
	private Department department;
	private String name;
	private Boolean sex;
	private Double salary;
	private Date birthday;

	// Constructors

	/** default constructor */
	public Employee() {
	}

	/** minimal constructor */
	public Employee(Integer id) {
		this.id = id;
	}

	/** full constructor */
	public Employee(Integer id, Department department, String name, Boolean sex, Double salary,
			Date birthday) {
		this.id = id;
		this.department = department;
		this.name = name;
		this.sex = sex;
		this.salary = salary;
		this.birthday = birthday;
	}

	// Property accessors
	@Id
	@GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "generator")
	@SequenceGenerator(name = "generator", sequenceName = "emp_seq")
	@Column(name = "ID", unique = true, nullable = false, precision = 9, scale = 0)
	public Integer getId() {
		return this.id;
	}

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

	@ManyToOne(fetch = FetchType.EAGER)
	@JoinColumn(name = "DEPART_ID")
	public Department getDepartment() {
		return this.department;
	}

	public void setDepartment(Department department) {
		this.department = department;
	}

	@Column(name = "NAME", length = 20)
	public String getName() {
		return this.name;
	}

	public void setName(String name) {
		this.name = name;
	}

	@Column(name = "SEX", precision = 1, scale = 0)
	public Boolean getSex() {
		return this.sex;
	}

	public void setSex(Boolean sex) {
		this.sex = sex;
	}

	@Column(name = "SALARY", precision = 8)
	public Double getSalary() {
		return this.salary;
	}

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

	@Temporal(TemporalType.DATE)
	@Column(name = "BIRTHDAY", length = 7)
	public Date getBirthday() {
		return this.birthday;
	}

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

	@Override
	public String toString() {
		return "Employee [id=" + id + ", department=" + department + ", name=" + name + ", sex="
				+ sex + ", salary=" + salary + ", birthday=" + birthday + "]";
	}
	
}

 

Department類：

package org.e276.entity;

import java.util.ArrayList;
import java.util.List;
import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.OneToMany;
import javax.persistence.OrderBy;
import javax.persistence.SequenceGenerator;
import javax.persistence.Table;
import org.hibernate.annotations.Formula;

/**
 * Department entity. @author MyEclipse Persistence Tools
 */
@Entity
@Table(name = "DEPARTMENT", schema = "Y2")
public class Department implements java.io.Serializable {

	// Fields

	private Integer id;
	private Integer count;//作爲只讀屬性，表中沒有這列
	private String name;
	private List<Employee> employees = new ArrayList<Employee>(0);

	// Constructors

	/** default constructor */
	public Department() {
	}

	/** minimal constructor */
	public Department(Integer id, String name) {
		this.id = id;
		this.name = name;
	}

	/** full constructor */
	public Department(Integer id, String name, List<Employee> employees) {
		this.id = id;
		this.name = name;
		this.employees = employees;
	}

	// Property accessors
	@Id
	@GeneratedValue(strategy=GenerationType.SEQUENCE,generator="generator")
	@SequenceGenerator(name="generator",sequenceName="depart_seq")
	@Column(name = "ID", unique = true, nullable = false, precision = 4, scale = 0)
	public Integer getId() {
		return this.id;
	}

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

	@Column(name = "NAME", nullable = false, length = 20)
	public String getName() {
		return this.name;
	}

	public void setName(String name) {
		this.name = name;
	}

	@OneToMany(cascade = CascadeType.ALL, fetch = FetchType.LAZY, mappedBy = "department")
	@OrderBy("salary desc")
	public List<Employee> getEmployees() {
		return this.employees;
	}

	public void setEmployees(List<Employee> employees) {
		this.employees = employees;
	}

	//注意前後一定要有括號，查詢時是作爲一列存在的子查詢
	@Formula("(select count(*) from department)")
	public Integer getCount() {
		return count;
	}

	public void setCount(Integer count) {
		this.count = count;
	}

}

 

七、Hibernate的配置文件

<?xml version='1.0' encoding='UTF-8'?>
<!DOCTYPE hibernate-configuration PUBLIC
          "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
          "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<!-- Generated by MyEclipse Hibernate Tools.                   -->
<hibernate-configuration>

<session-factory>
	<property name="dialect">
		org.hibernate.dialect.Oracle10gDialect
	</property>
	<property name="connection.url">
		jdbc:oracle:thin:@localhost:1521:orcl
	</property>
	<property name="connection.username">y2</property>
	<property name="connection.password">bdqn</property>
	<property name="connection.driver_class">
		oracle.jdbc.driver.OracleDriver
	</property>
	<property name="myeclipse.connection.profile">Y2</property>
	<property name="show_sql">true</property>
	<property name="format_sql">true</property>
	<mapping class="org.e276.entity.Department" />
	<mapping class="org.e276.entity.Employee" />

</session-factory>

</hibernate-configuration>

 

 

八、測試類（使用了Junit 4.0）：

package org.e276.test;

import java.util.Date;
import java.util.List;
import org.e276.entity.Department;
import org.e276.entity.Employee;
import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.AnnotationConfiguration;
import org.junit.After;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;

/**
 * 測試類
 * 
 * @author miao
 * 
 */
public class TestEmployee {

	static SessionFactory factory = null;
	private Session session;
	private Transaction tx;

	@BeforeClass
	public static void setUpBeforeClass() throws Exception {
		factory = new AnnotationConfiguration().configure("hibernate.cfg.xml")
				.buildSessionFactory();
	}

	@AfterClass
	public static void tearDownAfterClass() throws Exception {
		factory = null;
	}

	@Before
	public void setUp() throws Exception {
		session = factory.openSession();
		tx = session.beginTransaction();
	}

	@After
	public void tearDown() throws Exception {
		tx.commit();
		session.close();
	}

	/**
	 * 查詢部門的信息 部門名字 部門總數 員工數
	 */
	public void findDepartInfo() {
		Department department = (Department) session.get(Department.class, 3);
		// 得到部門名字
		System.out.println("部門名字是：" + department.getName());
		// 輸出部門總數
		System.out.println("部門總數是：" + department.getCount());
		// 得到員工集合
		List<Employee> employees = department.getEmployees();
		// 輸出員工，按工資降序排列
		for (Employee employee : employees) {
			System.out.println(employee);
		}
	}

	/**
	 * 查詢所有的員工
	 */
	@Test
	public void findAllEmployee() {
		@SuppressWarnings("unchecked")
		List<Employee> employees = session.createQuery("from Employee").list();
		for (Employee employee : employees) {
			System.out.println(employee);
		}
	}

	/**
	 * 插入員工信息
	 */
	public void addEmployee() {
		Department department = (Department) session.get(Department.class, 3);
		Employee employee = new Employee();
		employee.setDepartment(department);
		employee.setName("小夥伴");
		employee.setSex(false);
		employee.setBirthday(new Date());
		employee.setSalary(3800.00);
		try {
			// 保存
			session.save(employee);
			System.out.println("添加成功！");
		} catch (HibernateException e) {
			System.out.println("添加失敗！");
			e.printStackTrace();
		}
	}
}