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("xxx@163.com");
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
09-17
09-17