Hibernate註解編程
<!-- EJB註解編程 -->
<hibernate-configuration>
<session-factory>
<property name="hibernate.connection.url">
jdbc:mysql://localhost:3306/test
</property>
<property name="hibernate.connection.driver_class">
com.mysql.jdbc.Driver
</property>
<property name="hibernate.connection.username">root</property>
<property name="hibernate.connection.password">imti</property>
<property name="hibernate.dialect">
org.hibernate.dialect.MySQLDialect
</property>
<mapping class="com.xmxz.hibernate.annotation.IdCard" />
<mapping class="com.xmxz.hibernate.annotation.Person" />
</session-factory>
</hibernate-configuration>
<!—XML映射 -->
<hibernate-configuration>
<session-factory>
<property name="hibernate.connection.url">
jdbc:mysql://localhost:3306/test
</property>
<property name="hibernate.connection.driver_class">
com.mysql.jdbc.Driver
</property>
<property name="hibernate.connection.username">root</property>
<property name="hibernate.connection.password">imti</property>
<property name="hibernate.dialect">
org.hibernate.dialect.MySQLDialect
</property>
<property name="hibernate.show_sql">true</property>
<property name="hibernate.hbm2ddl.auto">update</property>
<mapping resource="com/xmxz/hibernate/mobile/Operator.hbm.xml" />
<mapping
resource="com/xmxz/hibernate/mobile/MobileUser.hbm.xml" />
<mapping
resource="com/xmxz/hibernate/mobile/FillMoneyCard.hbm.xml" />
<mapping resource="com/xmxz/hibernate/mobile/SPConst.hbm.xml" />
<mapping resource="com/xmxz/hibernate/mobile/MobileSP.hbm.xml" />
<mapping
resource="com/xmxz/hibernate/mobile/FillMoneyHistory.hbm.xml" />
<mapping resource="com/xmxz/hibernate/mobile/Message.hbm.xml" />
</session-factory>
</hibernate-configuration>
ExportDB
public class ExportDB {
public static void main(String[] args) {
// 讀取hibernate.cfg.xml文件
Configuration cfg = new Configuration() .configure("");
SchemaExport export = new SchemaExport(cfg);
export.create(true, true);
}
}
HibernateUtils
public class HibernateUtils {
private static SessionFactory factory;
static {// 單例模式
try {
Configuration cfg = new Configuration().configure();
factory = cfg.buildSessionFactory();
} catch (HibernateException e) {
e.printStackTrace();
}
}
/**
* 獲取當前的會話工廠
* @return
*/
public static SessionFactory getSessionFactory() {
return factory;
}
/**
* 獲取當前的會話
* @return
*/
public static Session getSession() {
return factory.openSession();
}
/**
* 關閉會話（session）
* @param session當前的會話
*/
public static void closeSession(Session session) {
if (session != null) {
if (session.isOpen()) {
session.close();
}
}
}
}
ExportDBAnnotation
public class ExportDBAnnotation {
public static void main(String[] args) {
// 讀取hibernate.cfg.annotation.xml文件
Configuration cfg = new AnnotationConfiguration()
.configure("hibernate.cfg.annotation.xml");
SchemaExport export = new SchemaExport(cfg);
// export.setFormat(true);
// 設置保存SQL腳本的文件名
// export.setOutputFile("new.sql");
// 輸出SQL腳本，並執行SQL腳本
export.create(true, true);
}
}
HibernateAnnotationUtils
/**
* 使用EJB註解做的
* @author Administrator
*/
public class HibernateAnnotationUtils {
private static SessionFactory factory;
static {// 單例模式
try {
Configuration cfg = new AnnotationConfiguration()
.configure("hibernate.cfg.annotation.xml");
factory = cfg.buildSessionFactory();
} catch (HibernateException e) {
e.printStackTrace();
}
}
public static SessionFactory getSessionFactory() {
return factory;
}
public static Session getSession() {
return factory.openSession();
}
public static void closeSession(Session session) {
if (session != null) {
if (session.isOpen()) {
session.close();
}
}
}
}
【一對一】關係映射
模型：人 和 身份證 通過人可以得知身份證號碼，根據身份證號碼可以得知人
Person
/**
* 人（通過外鍵實現一對一關係）
* @author Administrator
*/
// 屏蔽缺少“serialVersionUID”定義警告
@SuppressWarnings("serial")
// 指明實體Bean名，默認值是類名
@Entity(name = "Person")
// 實體對應的數據表 name表名；uniqueConstraints唯一約束性；主鍵
@Table(name = "t_person", uniqueConstraints = { @UniqueConstraint(columnNames = { "id" }) })
public class Person implements Serializable {
private Integer id;
private String name;
private IdCard idCard;
@Id
// 主鍵唯一標識
@Column(name = "id")
// 字段名
@GeneratedValue(strategy = GenerationType.AUTO)
// 自動增加
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
@Column(name = "name", length = 16, nullable = false)
//name字段名，length字段最大字符長度，nullable是否允許爲空，precision字段精度，scale小數位數
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
//optional是否允許該字段爲null,該屬性應該根據數據庫表的外鍵約束來確定,默認爲true
@JoinColumn(name = "cardID")
@OneToOne(cascade = CascadeType.ALL, optional = false)
public IdCard getIdCard() {
return idCard;
}
public void setIdCard(IdCard idCard) {
this.idCard = idCard;
}
}
IdCard
/**
* 身份證（通過外鍵實現一對一關係）
* @author Administrator
*/
// 屏蔽缺少“serialVersionUID”定義警告
@SuppressWarnings("serial")
// 指明實體Bean名，默認值是類名
@Entity(name = "IdCard")
// 實體對應的數據表 name表名；uniqueConstraints唯一約束性；主鍵
@Table(name = "t_idcard", uniqueConstraints = { @UniqueConstraint(columnNames = { "id" }) })
public class IdCard implements Serializable {
private Integer id;
private String cardNo;
private Person person;
@Id
// 主鍵唯一標識
@Column(name = "id")
// 字段名
@GeneratedValue(strategy = GenerationType.AUTO)
// 自動增加
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
@Column(name = "cardNo", length = 32, nullable = false)
//name字段名，length字段最大字符長度，nullable是否允許爲空，precision字段精度，scale小數位數
public String getCardNo() {
return cardNo;
}
public void setCardNo(String cardNo) {
this.cardNo = cardNo;
}
// 表示該屬性並非一個到數據庫表的字段的映射,ORM框架將忽略該屬性
@OneToOne(cascade = { CascadeType.PERSIST, CascadeType.MERGE }, mappedBy = "idCard")
public Person getPerson() {
return person;
}
public void setPerson(Person person) {
this.person = person;
}
}
【一對一】測試類
OneToOneTest
/**
* 一對一關係映射（雙向）唯一外鍵關聯
* @author Administrator
*/
public class OneToOneTest extends TestCase {
public void testSave() {
Session session = null;
Transaction tx = null;
try {
session = HibernateAnnotationUtils.getSession();
tx = session.beginTransaction();// 開啓事務
IdCard idCard = new IdCard();
idCard.setCardNo("210211197809204977");
session.save(idCard);// ※※※※※
Person person = new Person();
person.setName("馬遠志");
person.setIdCard(idCard);
session.save(person);
// 事務提交
tx.commit();
} catch (HibernateException e) {
e.printStackTrace();
// 事務回滾
tx.rollback();
} finally {
// 關閉會話
HibernateAnnotationUtils.closeSession(session);
}
}
public void testLoad() {
Session session = null;
Transaction tx = null;
try {
session = HibernateAnnotationUtils.getSession();
tx = session.beginTransaction();// 開啓事務
Person person = (Person) session.load(Person.class, 1);
System.out.println("姓名：" + person.getName());
System.out.println("身份證：" + person.getIdCard().getCardNo());
tx.commit();
} catch (HibernateException e) {
e.printStackTrace();
tx.rollback();
} finally {
HibernateAnnotationUtils.closeSession(session);
}
}
public void testLoad1() {
Session session = null;
Transaction tx = null;
try {
session = HibernateAnnotationUtils.getSession();
tx = session.beginTransaction();// 開啓事務
IdCard idCard = (IdCard) session.load(IdCard.class, 1);
System.out.println("身份證：" + idCard.getCardNo());
System.out.println("姓名：" + idCard.getPerson().getName());
tx.commit();
} catch (HibernateException e) {
e.printStackTrace();
tx.rollback();
} finally {
HibernateAnnotationUtils.closeSession(session);
}
}
}
【一對多】關係映射
模型：班級 和 學生 一個班級有多名學生，一個學生屬於某個班級
Classes
/**
* 班級
* @author Administrator
*/
// 屏蔽缺少“serialVersionUID”定義警告
@SuppressWarnings("serial")
// 指明實體Bean名，默認值是類名
@Entity(name = "Classes")
// 實體對應的數據表 name表名；uniqueConstraints唯一約束性；主鍵
@Table(name = "t_classes", uniqueConstraints = { @UniqueConstraint(columnNames = { "id" }) })
public class Classes implements Serializable {
private Integer id;
private String name;
private Set students;
@Id
// 主鍵唯一標識
@Column(name = "id")
// 字段名
@GeneratedValue(strategy = GenerationType.AUTO)
// 自動增加
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
@Column(name = "name", length = 16, nullable = false)
//name字段名，length字段最大字符長度，nullable是否允許爲空，precision字段精度，scale小數位數
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@OneToMany(fetch = FetchType.LAZY, cascade = { CascadeType.ALL }, targetEntity = Student.class, mappedBy = "classes")
public Set getStudents() {
return students;
}
public void setStudents(Set students) {
this.students = students;
}
}
Student
/**
* 學生
* @author Administrator
*/
// 屏蔽缺少“serialVersionUID”定義警告
@SuppressWarnings("serial")
// 指明實體Bean名，默認值是類名
@Entity(name = "Student")
// 實體對應的數據表 name表名；uniqueConstraints唯一約束性；主鍵
@Table(name = "t_student", uniqueConstraints = { @UniqueConstraint(columnNames = { "id" }) })
public class Student implements Serializable {
private Integer id;
private String name;
private Date createTime;
private Classes classes;
@Id
// 主鍵唯一標識
@Column(name = "id")
// 字段名
@GeneratedValue(strategy = GenerationType.AUTO)
// 自動增加
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
@Column(name = "name", length = 16, nullable = false)
//name字段名，length字段最大字符長度，nullable是否允許爲空，precision字段精度，scale小數位數
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
// optional是否允許該字段爲null,該屬性應該根據數據庫表的外鍵約束來確定,默認爲true
@ManyToOne(fetch = FetchType.EAGER, cascade = { CascadeType.ALL }, optional = true)
@JoinColumn(name = "classesid")
public Classes getClasses() {
return classes;
}
public void setClasses(Classes classes) {
this.classes = classes;
}
@Column(name = "createTime")
// 字段名稱
@Temporal(TemporalType.TIMESTAMP)
// 日期型字段：日期時間型
// @Temporal(TemporalType.DATE)
public Date getCreateTime() {
return createTime;
}
public void setCreateTime(Date createTime) {
this.createTime = createTime;
}
}
【一對多】測試類
初始化數據
InitData
/**
* 初始化數據
* @author Administrator
*/
public class InitData {
public static void main(String[] args) {
Session session = null;
Transaction tx = null;
try {
session = HibernateAnnotationUtils.getSession();
tx = session.beginTransaction();// 開啓事務
for (int i = 0; i < 10; i++) {
Classes classes = new Classes();
classes.setName("班級" + i);
session.save(classes);
for (int j = 0; j < 10; j++) {
Student student = new Student();
student.setName("班級" + i + "的學生" + j);
student.setCreateTime(randomDate("2008-01-01","2008-03-01"));
// 在內存中建立由student指向classes的引用
student.setClasses(classes);
session.save(student);
}
}
for (int i = 0; i < 5; i++) {
Classes classes = new Classes();
classes.setName("無學生班級" + i);
session.save(classes);
}
for (int i = 0; i < 10; i++) {
Student student = new Student();
student.setName("無業遊民" + i);
session.save(student);
}
// 事務提交
tx.commit();
} catch (Exception e) {
e.printStackTrace();
// 事務回滾
tx.rollback();
} finally {
// 關閉會話
HibernateAnnotationUtils.closeSession(session);
}
}
/**
* 獲取隨機日期
* @param beginDate起始日期，格式爲：yyyy-MM-dd
* @param endDate結束日期，格式爲：yyyy-MM-dd
* @return
*/
private static Date randomDate(String beginDate, String endDate) {
try {
DateFormat format = new SimpleDateFormat("yyyy-MM-dd");
Date start = format.parse(beginDate);
Date end = format.parse(endDate);
if (start.getTime() >= end.getTime()) {
return null;
}
long date = random(start.getTime(), end.getTime());
return new Date(date);
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
/**
* 產生隨機數
* @param begin
* @param end
* @return
*/
private static long random(long begin, long end) {
long rtn = begin + (long) (Math.random() * (end - begin));
if (rtn == begin || rtn == end) {
return random(begin, end);
}
return rtn;
}
}
OneToManyTest
public class OneToManyTest extends TestCase {
public void testLoad1() {
Session session = null;
Transaction tx = null;
try {
session = HibernateAnnotationUtils.getSession();
tx = session.beginTransaction();// 開啓事務
Classes classes = (Classes) session.load(Classes.class, 1);
System.out.println("班級名稱：" + classes.getName());
Set students = classes.getStudents();
for (Iterator iter = students.iterator(); iter.hasNext();) {
Student student = (Student) iter.next();
System.out.println("姓名：" + student.getName());
}
tx.commit();
} catch (HibernateException e) {
e.printStackTrace();
tx.rollback();
} finally {
HibernateAnnotationUtils.closeSession(session);
}
}
public void testLoad2() {
Session session = null;
Transaction tx = null;
try {
session = HibernateAnnotationUtils.getSession();
tx = session.beginTransaction();// 開啓事務
Student student = (Student) session.load(Student.class, 1);
System.out.println("姓名：" + student.getName());
System.out.println("班級名稱：" + student.getClasses().getName());
tx.commit();
} catch (Exception e) {
e.printStackTrace();
tx.rollback();
} finally {
HibernateAnnotationUtils.closeSession(session);
}
}
}
【多對多】關係映射
模型：用戶 和 角色 一個用戶擁有多個角色，一個角色中存在多個用戶
Role
/**
* 角色對象 被關係維護端
* @author Administrator
*/
// 屏蔽缺少“serialVersionUID”定義警告
@SuppressWarnings("serial")
// 指明實體Bean名，默認值是類名
@Entity(name = "Role")
// 實體對應的數據表 name表名；uniqueConstraints唯一約束性；主鍵
@Table(name = "t_roles", uniqueConstraints = { @UniqueConstraint(columnNames = { "id" }) })
public class Role {
private int id;
private String name;
private Set users;
@Id
// 主鍵唯一標識
@Column(name = "id")
// 字段名
@GeneratedValue(strategy = GenerationType.AUTO)
// 自動增加
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
@Column(name = "name", length = 16, nullable = false)
//name字段名，length字段最大字符長度，nullable是否允許爲空，precision字段精度，scale小數位數
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
//被關係維護端
@ManyToMany(cascade=CascadeType.REFRESH,mappedBy="roles",targetEntity=User.class)
public Set getUsers() {
return users;
}
public void setUsers(Set users) {
this.users = users;
}
}
User
/**
* 用戶對象
* @author Administrator
*/
// 屏蔽缺少“serialVersionUID”定義警告
@SuppressWarnings("serial")
// 指明實體Bean名，默認值是類名
@Entity(name = "User")
// 實體對應的數據表 name表名；uniqueConstraints唯一約束性；主鍵
@Table(name = "t_user", uniqueConstraints = { @UniqueConstraint(columnNames = { "id" }) })
public class User {
private int id;
private String name;
private Set roles;
@Id
// 主鍵唯一標識
@Column(name = "id")
// 字段名
@GeneratedValue(strategy = GenerationType.AUTO)
// 自動增加
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
@Column(name = "name", length = 16, nullable = false)
//name字段名，length字段最大字符長度，nullable是否允許爲空，precision字段精度，scale小數位數
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
// 設置關聯表
// inverseJoinColumns 被關係維護端在關聯表中的外鍵
// joinColumns 關係維護端在關聯表中的外鍵
@JoinTable(name = "t_role_user", inverseJoinColumns = @JoinColumn(name = "roleID"), joinColumns = @JoinColumn(name = "userID"))
@ManyToMany(cascade = CascadeType.REFRESH,targetEntity=Role.class)
public Set getRoles() {
return roles;
}
public void setRoles(Set roles) {
this.roles = roles;
}
}
【多對多】測試類
ManyToManyTest
/**
* 多對多關聯映射（雙向）
* @author Administrator
*/
public class ManyToManyTest extends TestCase {
public void testSave() {
Session session = null;
Transaction tx = null;
try {
session = HibernateAnnotationUtils.getSession();
tx = session.beginTransaction();// 開啓事務
Role r1 = new Role();
r1.setName("數據錄入人員");
session.save(r1);
Role r2 = new Role();
r2.setName("商務主管");
session.save(r2);
Role r3 = new Role();
r3.setName("總經理");
session.save(r3);
User u1 = new User();
u1.setName("張三");
Set u1Roles = new HashSet();
u1Roles.add(r1);
u1Roles.add(r2);
u1.setRoles(u1Roles);
User u2 = new User();
u2.setName("李四");
Set u2Roles = new HashSet();
u2Roles.add(r2);
u2Roles.add(r3);
u2.setRoles(u2Roles);
User u3 = new User();
u3.setName("王五");
Set u3Roles = new HashSet();
u3Roles.add(r1);
u3Roles.add(r2);
u3Roles.add(r3);
u3.setRoles(u3Roles);
session.save(u1);
session.save(u2);
session.save(u3);
// 事務提交
tx.commit();
} catch (Exception e) {
e.printStackTrace();
// 事務回滾
tx.rollback();
} finally {
// 關閉會話
HibernateAnnotationUtils.closeSession(session);
}
}
public void testLoad() {
Session session = null;
Transaction tx = null;
try {
session = HibernateAnnotationUtils.getSession();
tx = session.beginTransaction();// 開啓事務
User user = (User) session.load(User.class, 1);
System.out.println(user.getName());
for (Iterator iter = user.getRoles().iterator(); iter.hasNext();) {
Role role = (Role) iter.next();
System.out.println(role.getName());
}
// 事務提交
tx.commit();
} catch (Exception e) {
e.printStackTrace();
// 事務回滾
tx.rollback();
} finally {
// 關閉會話
HibernateAnnotationUtils.closeSession(session);
}
}
public void testLoad1() {
Session session = null;
Transaction tx = null;
try {
session = HibernateAnnotationUtils.getSession();
tx = session.beginTransaction();// 開啓事務
Role role = (Role) session.load(Role.class, 1);
System.out.println(role.getName());
for (Iterator iter = role.getUsers().iterator(); iter.hasNext();) {
User user = (User) iter.next();
System.out.println(user.getName());
}
// 事務提交
tx.commit();
} catch (Exception e) {
e.printStackTrace();
// 事務回滾
tx.rollback();
} finally {
// 關閉會話
HibernateAnnotationUtils.closeSession(session);
}
}
}
【component組件】關係映射
模型：員工和用戶都存在公共的屬性：電子郵件、聯繫地址、郵政編碼、聯繫電話
Contact
/**
* 公共部分 component（組件、部分）映射
* @author Administrator
*/
@Embeddable
// 表明該類將作爲一個組件類型
public class Contact {
private String email;// 電子郵件
private String address;// 聯繫地址
private String zipCode;// 郵政編碼
private String contactTel;// 聯繫電話
public Contact() {
}
public Contact(String email, String address, String zipCode,
String contactTel) {
this.email = email;
this.address = address;
this.zipCode = zipCode;
this.contactTel = contactTel;
}
@Column(name = "email", length = 64, nullable = true)
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
@Column(name = "address", length = 64, nullable = true)
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
@Column(name = "zipCode", length = 6, nullable = true)
public String getZipCode() {
return zipCode;
}
public void setZipCode(String zipCode) {
this.zipCode = zipCode;
}
@Column(name = "contactTel", length = 32, nullable = true)
public String getContactTel() {
return contactTel;
}
public void setContactTel(String contactTel) {
this.contactTel = contactTel;
}
}
Employee
/**
* 用戶 component（組件、部分）映射
* @author Administrator
*/
// 屏蔽缺少“serialVersionUID”定義警告
@SuppressWarnings("serial")
// 指明實體Bean名，默認值是類名
@Entity(name = "Employee")
// 實體對應的數據表 name表名；uniqueConstraints唯一約束性；主鍵
@Table(name = "t_employee", uniqueConstraints = { @UniqueConstraint(columnNames = { "id" }) })
public class Employee {
private int id;
private String name;
// 組件類型
@Embedded
private Contact contact;
@Id
// 主鍵唯一標識
@Column(name = "id")
// 字段名
@GeneratedValue(strategy = GenerationType.AUTO)
// 自動增加
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
@Column(name = "name", length = 16, nullable = false)
//name字段名，length字段最大字符長度，nullable是否允許爲空，precision字段精度，scale小數位數
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Contact getContact() {
return contact;
}
public void setContact(Contact contact) {
this.contact = contact;
}
}
【component組件】測試類
ComponentTest
/**
* component（組件、部分）映射
* @author Administrator
*/
public class ComponentTest extends TestCase {
public void testSave() {
Session session = null;
Transaction tx = null;
try {
session = HibernateAnnotationUtils.getSession();
tx = session.beginTransaction();// 開啓事務
Employee user = new Employee();
user.setName("張三");
Contact contact = new Contact();
contact.setAddress("xxxxx");
contact.setEmail("[email protected]");
contact.setZipCode("111000");
contact.setContactTel("13555811111");
user.setContact(contact);
session.save(user);
// 事務提交
tx.commit();
} catch (Exception e) {
e.printStackTrace();
// 事務回滾
tx.rollback();
} finally {
// 關閉會話
HibernateAnnotationUtils.closeSession(session);
}
}
public void testLoad() {
Session session = null;
Transaction tx = null;
try {
session = HibernateAnnotationUtils.getSession();
tx = session.beginTransaction();// 開啓事務
Employee user = (Employee) session.load(Employee.class, 1);
System.out.println("姓名：" + user.getName());
System.out.println("地址：" + user.getContact().getAddress());
// 事務提交
tx.commit();
} catch (Exception e) {
e.printStackTrace();
// 事務回滾
tx.rollback();
} finally {
// 關閉會話
HibernateAnnotationUtils.closeSession(session);
}
}
}
【composite複合主鍵】關係映射
模型：員工發放工資，按年按月發放工資，年月做一個複合主鍵
WagePK 此類必須實現Serializable接口，重寫hashCode和equals方法
/**
* 複合主鍵映射
* @author Administrator
*/
public class WagePK implements Serializable {
// 工資年
private int wageYear;
// 工資月
private int wageMonth;
@Column(name = "wageYear", nullable = false)
public int getWageYear() {
return wageYear;
}
public void setWageYear(int wageYear) {
this.wageYear = wageYear;
}
@Column(name = "wageMonth", nullable = false)
public int getWageMonth() {
return wageMonth;
}
public void setWageMonth(int wageMonth) {
this.wageMonth = wageMonth;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + wageMonth;
result = prime * result + wageYear;
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
final WagePK other = (WagePK) obj;
if (wageMonth != other.wageMonth)
return false;
if (wageYear != other.wageYear)
return false;
return true;
}
}
Wage
/**
* 工資
* @author 馬遠志
*/
// 屏蔽缺少“serialVersionUID”定義警告
@SuppressWarnings("serial")
// 指明實體Bean名，默認值是類名
@Entity(name = "Wage")
// 複合主鍵的實體類
@IdClass(WagePK.class)
// 實體對應的數據表 name表名；uniqueConstraints唯一約束性；主鍵
@Table(name = "t_wage")
public class Wage {
// 工資年
@Id
private int wageYear;
// 工資月
@Id
private int wageMonth;
// 開工資日期
private Date createDate;
// 工資金額
private float money;
public int getWageYear() {
return wageYear;
}
public void setWageYear(int wageYear) {
this.wageYear = wageYear;
}
public int getWageMonth() {
return wageMonth;
}
public void setWageMonth(int wageMonth) {
this.wageMonth = wageMonth;
}
@Column(name = "createDate")
// 字段名稱
@Temporal(TemporalType.DATE)
// 日期型字段：日期
// @Temporal(TemporalType.TIMESTAMP)
public Date getCreateDate() {
return createDate;
}
public void setCreateDate(Date createDate) {
this.createDate = createDate;
}
@Column(name = "money", nullable = false)
public float getMoney() {
return money;
}
public void setMoney(float money) {
this.money = money;
}
}
【composite複合主鍵】測試類
CompositeTest
/**
* 複合組件映射
* @author Administrator
*/
public class CompositeTest extends TestCase {
public void testSave() {
Session session = null;
Transaction tx = null;
try {
session = HibernateAnnotationUtils.getSession();
tx = session.beginTransaction();// 開啓事務
Wage wage = new Wage();
wage.setWageYear(2008);
wage.setWageMonth(8);
wage.setCreateDate(new Date());
wage.setMoney(500.5f);
session.save(wage);
// 事務提交
tx.commit();
} catch (Exception e) {
e.printStackTrace();
// 事務回滾
tx.rollback();
} finally {
// 關閉會話
HibernateAnnotationUtils.closeSession(session);
}
}
public void testLoad() {
Session session = null;
Transaction tx = null;
try {
session = HibernateAnnotationUtils.getSession();
tx = session.beginTransaction();// 開啓事務
WagePK pk = new WagePK();
pk.setWageYear(2008);
pk.setWageMonth(8);
Wage wage = (Wage) session.load(Wage.class, pk);
System.out.println("開資日期：" + wage.getCreateDate());
System.out.println("金額：" + wage.getMoney());
// 事務提交
tx.commit();
} catch (Exception e) {
e.printStackTrace();
// 事務回滾
tx.rollback();
} finally {
// 關閉會話
HibernateAnnotationUtils.closeSession(session);
}
}
}
使用的jar包：ejb3-persistence.jar、hibernate-annotations.jar、hibernate-commons-annotations.jar、antlr-2.7.6.jar、commons-collections-3.1.jar、dom4j-1.6.1.jar、hibernate3.jar、javassist-3.4.GA.jar、jta-1.1.jar、log4j-1.2.16.jar、slf4j-api-1.6.4.jar、slf4j-log4j12-1.6.4.jar
Hibernate_使用註解
發表評論
所有評論
還沒有人評論，想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章