// 通知持久化引擎该类是一个实体
@Entity
@Table(name = "employee", schema="springdao")
public class Employee implements Serializable {
/**
* serialVersionUID:TODO
* @since JDK 1.7
*/
private static final long serialVersionUID = -581308461934077076L;
// 注解了持久化标识,即唯一的标识键
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Integer id;
private String name;
private Long salary;
private String phoneNum;
@Basic(fetch = FetchType.LAZY)
@Lob @Column(name = "picture") // 大型对象的延迟加载
private Byte[] picture;
@Enumerated(EnumType.STRING) // 默认的是插入序号 用插入值可以避免增加新的枚举类型序号的变化
private EmployeeType type;
@Temporal(TemporalType.DATE) //java.util 日期类型需要指明隐射时JDBC处理的方式
private Calendar dob;
@Temporal(TemporalType.TIMESTAMP)
private Date startDate;
@Transient
private String combineArrt; // 忽略,不将其映射到数据库
// 当定义双向一对多(或多对一)关系时:
// 多对一一方是所有方,在该方定义连接列
// 一对多是反方,所以必须使用 mappedBy 元素,否则会生成一个中间联结表
@ManyToOne
@JoinColumn(name = "dept_id") // JoinColumn 来实现外键关联,默认的话为
private Department department; // 源实体中的关系特性的名称_目标实体的主键名
// 按照惯例逻辑映射先出现,因为物理映射有默认值
@OneToOne(fetch = FetchType.LAZY)
@JoinColumn(name = "pspace_id")
private ParkingSpace parkingSpace;
// 多对多关系的实现是中间表(join table),但是必须要有一方是mappedBy
@ManyToMany
@JoinTable(name = "emp_proj",
joinColumns = @JoinColumn(name = "emp_id"),
inverseJoinColumns = @JoinColumn(name = "proj_id")
)
private Collection<Project> projects;
// 单项一对多关系,需要中间表
@OneToMany
@JoinTable(name = "emp_phone",
joinColumns = @JoinColumn(name = "emp_id"),
inverseJoinColumns = @JoinColumn(name = "phone_id")
)
private Collection<Phone> phones;
public Employee() {}
public Employee(Integer id) { this.id = id; }
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Long getSalary() {
return salary;
}
public void setSalary(Long salary) {
this.salary = salary;
}
public String getPhoneNum() {
return phoneNum;
}
public void setPhoneNum(String phoneNum) {
this.phoneNum = phoneNum;
}
public Byte[] getPicture() {
return picture;
}
public void setPicture(Byte[] picture) {
this.picture = picture;
}
public EmployeeType getType() {
return type;
}
public void setType(EmployeeType type) {
this.type = type;
}
public String getCombineArrt() {
return this.id + "; " + this.name;
}
public void setCombineArrt(String combineArrt) {
this.combineArrt = combineArrt;
}
public Calendar getDob() {
return dob;
}
public void setDob(Calendar dob) {
this.dob = dob;
}
public Date getStartDate() {
return startDate;
}
public void setStartDate(Date startDate) {
this.startDate = startDate;
}
public Department getDepartment() {
return department;
}
public void setDepartment(Department department) {
this.department = department;
}
public ParkingSpace getParkingSpace() {
return parkingSpace;
}
public void setParkingSpace(ParkingSpace parkingSpace) {
this.parkingSpace = parkingSpace;
}
public Collection<Project> getProjects() {
return projects;
}
public void setProjects(Collection<Project> projects) {
this.projects = projects;
}
@Override
public String toString() {
return "Employee [id=" + id + ", name=" + name + ", salary=" + salary
+ ", phoneNum=" + phoneNum + ", picture="
+ Arrays.toString(picture) + ", type=" + type + ", dob=" + dob
+ ", startDate=" + startDate + ", combineArrt=" + combineArrt
+ "]";
}
}
@Entity
@Table(name = "addresstwo")
public class AddressTwo implements Serializable {
/**
* serialVersionUID:TODO
* @since JDK 1.7
*/
private static final long serialVersionUID = 4003827955642961159L;
@TableGenerator(name = "Address_Gen",
table = "id_gen",
pkColumnName = "gen_name",
valueColumnName = "gen_val",
pkColumnValue = "Addr_Gen",
initialValue = 10000,
allocationSize = 100)
@Id @GeneratedValue(strategy = GenerationType.TABLE, generator = "Address_Gen")
private int id;
private String name;
public AddressTwo() {}
public AddressTwo(int id, String name) {
this.id = id;
this.name = name;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return ToStringBuilder.reflectionToString(this);
}
}
@Entity
@Table(name = "department")
public class Department implements Serializable {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private int id;
private String name;
@OneToMany(mappedBy = "department")
private Collection<Employee> employees;
public Department() {}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Collection<Employee> getEmployees() {
return employees;
}
public void setEmployees(Collection<Employee> employees) {
this.employees = employees;
}
@Override
public String toString() {
return "Department [id=" + id + ", name=" + name + ", employees="
+ employees + "]";
}
}
@Entity
@Table(name = "park_space")
public class ParkingSpace implements Serializable {
/**
* serialVersionUID:TODO
* @since JDK 1.7
*/
private static final long serialVersionUID = 7356683100796513602L;
@Id @GeneratedValue(strategy = GenerationType.IDENTITY)
private int id;
private int lot;
private String location;
// 双向onetoone mappedBy 还是表明 Employee 是源实体,放在没有定义联结列的实体上
@OneToOne(mappedBy = "parkingSpace")
private Employee employee;
public ParkingSpace() {}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public int getLot() {
return lot;
}
public void setLot(int lot) {
this.lot = lot;
}
public String getLocation() {
return location;
}
public void setLocation(String location) {
this.location = location;
}
public Employee getEmployee() {
return employee;
}
public void setEmployee(Employee employee) {
this.employee = employee;
}
@Override
public String toString() {
return ToStringBuilder.reflectionToString(this);
}
}
@Entity
@Table(name = "project")
public class Project implements Serializable {
/**
* serialVersionUID:TODO
* @since JDK 1.7
*/
private static final long serialVersionUID = 7315080326584390902L;
@Id @GeneratedValue(strategy = GenerationType.IDENTITY)
private int id;
private String proName;
@ManyToMany(mappedBy = "projects")
private Collection<Employee> employees;
public Project() {}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getProName() {
return proName;
}
public void setProName(String proName) {
this.proName = proName;
}
public Collection<Employee> getEmployees() {
return employees;
}
public void setEmployees(Collection<Employee> employees) {
this.employees = employees;
}
@Override
public String toString() {
return ToStringBuilder.reflectionToString(this);
}
}
@Entity
@Table(name = "phone")
public class Phone implements Serializable {
/**
* serialVersionUID:TODO
* @since JDK 1.7
*/
private static final long serialVersionUID = 682045004499830046L;
@Id @GeneratedValue(strategy = GenerationType.IDENTITY)
private int id;
private int type;
private String num;
public Phone() {}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public int getType() {
return type;
}
public void setType(int type) {
this.type = type;
}
public String getNum() {
return num;
}
public void setNum(String num) {
this.num = num;
}
@Override
public String toString() {
return "Phone [id=" + id + ", type=" + type + ", num=" + num + "]";
}
}
@Entity
@Table(name = "head")
public class Head implements Serializable {
/**
* serialVersionUID:TODO
* @since JDK 1.7
*/
private static final long serialVersionUID = 1856809533670124595L;
@Id @GeneratedValue(strategy = GenerationType.IDENTITY)
private int id;
private String name;
@OneToOne(optional = false, cascade = CascadeType.ALL)
@JoinColumn(name = "nose_id")
private Nose nose;
public Head() {}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Nose getNose() {
return nose;
}
public void setNose(Nose nose) {
this.nose = nose;
}
@Override
public String toString() {
return "Head [id=" + id + ", name=" + name + "]";
}
}
@Entity
@Table(name = "nose")
public class Nose implements Serializable {
/**
* serialVersionUID:TODO
* @since JDK 1.7
*/
private static final long serialVersionUID = 8615516251260117582L;
@Id @GeneratedValue(strategy = GenerationType.IDENTITY)
private int id;
private String name;
@OneToOne(mappedBy = "nose")
private Head head;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Head getHead() {
return head;
}
public void setHead(Head head) {
this.head = head;
}
@Override
public String toString() {
return "Nose [id=" + id + ", name=" + name + "]";
}
}
/**
* ClassName:Animal <br/>
* Function: 嵌入对象 embedded object. <br/>
* Reason: TODO ADD REASON. <br/>
* Date: 2014年7月4日 下午1:58:45 <br/>
* @author zhangzhaoyu
* @version
* @since JDK 1.7
* @see
*/
@Entity
@Table(name = "animal")
public class Animal implements Serializable {
/**
* serialVersionUID:TODO
* @since JDK 1.7
*/
private static final long serialVersionUID = 3295314624812247524L;
@Id @GeneratedValue(strategy = GenerationType.IDENTITY)
private int id;
private String name;
private String age;
@Embedded
private LiveAddress liveAddress;
public Animal() {}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getAge() {
return age;
}
public void setAge(String age) {
this.age = age;
}
@Override
public String toString() {
return "Animal [id=" + id + ", name=" + name + ", age=" + age
+ ", liveAddress=" + liveAddress + "]";
}
}
/**
* ClassName:Bird <br/>
* Function: 重命名嵌入字段的值. <br/>
* Reason: TODO ADD REASON. <br/>
* Date: 2014年7月4日 下午2:12:46 <br/>
* @author zhangzhaoyu
* @version
* @since JDK 1.7
* @see
*/
@Entity
@Table(name = "exercise_bird")
public class Bird implements Serializable {
/**
* serialVersionUID:TODO
* @since JDK 1.7
*/
private static final long serialVersionUID = -317303554096481889L;
@Id @GeneratedValue(strategy = GenerationType.IDENTITY)
private int id;
private String name;
@Embedded
@AttributeOverrides({
@AttributeOverride(name = "state", column = @Column(name = "bird_state")),
@AttributeOverride(name = "zip", column = @Column(name = "bird_zip"))
})
private LiveAddress liveAddress;
public Bird() {}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public LiveAddress getLiveAddress() {
return liveAddress;
}
public void setLiveAddress(LiveAddress liveAddress) {
this.liveAddress = liveAddress;
}
@Override
public String toString() {
return "Bird [id=" + id + ", name=" + name + ", liveAddress="
+ liveAddress + "]";
}
}
/**
* ClassName:LiveAddress <br/>
* Function: 嵌入对象 embedded object. <br/>
* Reason: TODO ADD REASON. <br/>
* Date: 2014年7月4日 下午2:01:44 <br/>
* @author zhangzhaoyu
* @version
* @since JDK 1.7
* @see
*/
@Embeddable @Access(AccessType.FIELD)
public class LiveAddress implements Serializable {
private String street;
private String city;
private String state;
@Column(name = "zip_code")
private String zip;
}
分享到:
相关推荐
10. **存储过程**:JPA 2.0允许调用数据库的存储过程,并将其结果映射到Java对象。 **源代码与JavaDoc** 源代码可以帮助开发者理解JPA 2.0内部的工作机制,对于学习和调试非常有价值。JavaDoc则提供了详细的API...
JPA2.0作为JPA的一个重大版本更新,在原有基础上增加了许多新功能和改进,使得数据持久化变得更加简单高效。 - **新特性**: - **支持JSR-303验证注解**:允许在实体类上直接使用JSR-303的验证注解,如`@NotNull`...
- jpa2.0:这是JPA 2.0规范的简写标签,常用于搜索和分类相关文档和资源。 - 英文:强调了文档的语言版本是英文。 - 手册:通常指的是一份详尽的指导书,包含理论讲解、操作指南以及实例演示等。 - jsr317:与描述中...
**Java Persistence API (JPA) 2.0 Jar 包** Java Persistence API 是Java平台上的一个标准接口,用于处理对象关系映射(ORM),它允许Java开发者以面向对象的方式操作数据库,而无需直接编写SQL语句。JPA 2.0是这...
使用JPA,我们需要定义实体类(Entity),它们映射到数据库表。例如,一个名为`User`的实体: ```java @Entity public class User { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Long id;...
JPA 2.0作为ORM框架,提供了一种统一的API来管理Java对象与数据库之间的映射。它在JPA 1.0的基础上增加了更多的功能,如 Criteria API、JPQL(Java Persistence Query Language)增强、多租户支持等,提高了开发者的...
初识JPA 2.0** Java Persistence API (JPA) 是Java平台上的一个标准,用于处理对象关系映射(ORM),它允许Java开发者将对象模型与关系数据库进行交互。JPA 2.0是这个标准的一个重要版本,引入了许多新特性和改进...
**OpenJPA 2.0** 是一款基于 Java Persistence API (JPA) 的开源持久层框架,用于实现对象关系映射(ORM)。它提供了一种标准化的方式将 Java 对象与数据库表进行映射,并支持对数据进行查询和更新操作。OpenJPA 2.0...
Java Persistence API(JPA)是Java平台上的一个标准,用于管理关系数据库中的对象-关系映射(ORM)。JPA 2.0是该规范的一个重要版本,它在JPA 1.0的基础上引入了许多增强功能,提高了开发人员的生产力和数据库操作...
标题 "Spring3+Struts2+JPA2.0" 提到的是一个经典的Java企业级应用开发框架组合,主要用于构建高效、可维护性高的Web应用程序。这个组合将Spring的依赖注入和事务管理、Struts2的MVC架构以及JPA(Java Persistence ...
该草案获得JSR-317专家组全部通过 新增了大量的特性包括类型安全的动态查询(Criteria API );加入了大量必须的 ORM 映射增强特性;标准的二级缓存,标准的 JDBC ... 目前hibernate 3.5 已经提供了jpa2.0的全部实现;
Java Persistence API(JPA)是Java平台上的一个标准,用于处理对象关系映射(ORM),使开发者能够将数据库操作与业务逻辑更紧密地结合。在多线程和并发环境中,数据一致性与安全性至关重要,为此,JPA 提供了锁机制...
JPA提供了一种对象/关系映射(ORM)框架,将面向对象的程序设计与关系数据库的结构进行了解耦。 2. **Hibernate JPA的扩展性**:Hibernate是JPA的一个实现,以其强大的功能和灵活性赢得了广泛认可。Hibernate JPA ...
综上所述,为了在Weblogic中使用JPA2.0,你需要仔细阅读README.MD文件,遵循其中的指南进行配置,并结合`javax.persistence_1.1.0.0_2-0.jar`和`com.oracle.jpa2support_1.0.0.0_2-1.jar`这两个库来实现JPA2.0的兼容...
在Java EE 6平台中,Java Persistence API(JPA)迎来了其2.0版本,这是一个重要的更新,为开发者提供了更多的功能和优化,使得对象/关系映射(O/R Mapping)更为强大和灵活。JPA 2.0的主要增强包括以下几个方面: ...
**JPA (Java Persistence API)** 是一种用于管理关系型数据库的对象-关系映射(ORM)标准。它为开发者提供了一种灵活且强大的方式来处理数据库操作,无需编写繁琐的SQL语句。JPA规范由Java Community Process (JCP)...
- **额外的对象-关系映射(ORM)**:JPA2.0扩展了ORM的能力,使得开发者能够更精细地控制数据模型与数据库表之间的映射。 - **更多的对象建模灵活性**:JPA2.0提供了更多的方式来适应复杂的数据模型,如双向关联、...
Spring 3.2、Hibernate 4.2 和 JPA 2.0 是Java开发中用于构建企业级应用程序的重要框架和规范。在这个实例中,我们将会深入探讨这些技术如何协同工作,以及如何通过全注解的方式来简化开发过程。 首先,Spring 3.2 ...
Java Persistence API (JPA) 2.0是一个用于管理持久性和对象/关系映射的Java API,适用于Java EE和Java SE环境。其主要目标是为Java应用开发者提供一个使用Java域模型来管理关系数据库的对象/关系映射设施。 在JPA ...
JPA 2.0引入了许多增强功能,比如支持@OneToMany和@ManyToMany关系的双向映射,新增了@Temporal注解以处理日期和时间,增强了Criteria API,引入了@SecondaryTable注解以支持多表映射,还引入了Entity Graph来优化...