篇一:JPA注解,ORM数据库映射
转自他人文档
核心提示:JPA 注解的几个要点 1.设置Pojo为实体 @Entity //标识这个pojo是一个jpa实体 public class Users implements
Serializable{ } 2.设置表名 @Entity @Table (name= users ) //指定表名为users public class Users implements Serializable{ } 3.设置主键 public
JPA 注解的几个要点
1.设置Pojo为实体
1. @Entity //标识这个pojo是一个jpa实体
2. public class Users implements Serializable {
3. }
2.设置表名
1. @Entity
2. @Table(name = "users") //指定表名为users
3. public class Users implements Serializable {
4. }
3.设置主键
1. public class Users implements Serializable {
2. @Id
3. private String userCode;
4. 设置字段类型
通过@Column注解设置,包含的设置如下
.name:字段名
.unique:是否唯一
.nullable:是否可以为空
.inserttable:是否可以插入
.updateable:是否可以更新
.columnDefinition: 定义建表时创建此列的DDL
.secondaryTable: 从表名。如果此列不建在主表上(默认建在主表),该属性定义该列所在从表的名字。
1. @Column(name = "user_code", nullable = false,
length=32)//设置属性userCode对应的字段为user_code,长度为32,非空
2. private String userCode;
precision=12, scale=2)//设置属性wages对应的字段为
user_wages,12位数字可保留两位小数,可以为空
4. private double wages;
5. @Temporal(TemporalType.DATE)//设置为时间类型
6. private Date joinDate;
5.字段排序
在加载数据的时候可以为其指定顺序,使用@OrderBy注解实现
1. @Table(name = "USERS")
2. public class User {
3. @OrderBy(name = "group_name ASC, name DESC")
4. private List books = new ArrayList();
5. }
6.主键生成策略
1. public class Users implements Serializable {
2. @Id
3. @GeneratedValue(strategy=GenerationType.IDENTITY)//主键自
增,注意,这种方式依赖于具体的数据库,如果数据库不支持自增主键,那么这个类型是没法用的
4. @Column(name = "user_id", nullable = false)
5. private int userId;
6.
7.
8. public class Users implements Serializable {
9. @Id
10.@GeneratedValue(strategy=GenerationType.TABLE)//通过一个
表来实现主键id的自增,这种方式不依赖于具体的数据库,可以解决数据迁移的问题
11.@Column(name = "user_code", nullable = false)
12.private String userCode;
13.
14.
15.public class Users implements Serializable {
16.@Id
17.@GeneratedValue(strategy=GenerationType.SEQUENCE)//通过
Sequence来实现表主键自增,这种方式依赖于数据库是否有SEQUENCE,如果没有就不能用
18.@SequenceGenerator(name="seq_user")
20.private int userId;
7.一对多映射关系
有T_One和T_Many两个表,他们是一对多的关系,注解范例如下 主Pojo
子Pojo 1. @Entity 2. @Table(name = "T_ONE") 3. public class One implements Serializable { 4. private static final long serialVe 5. rsionUID = 1L; 6. @Id 7. @Column(name = "ONE_ID", nullable = false) 8. private String oneId; 9. @Column(name = "DESCRIPTION") 10.private String description; 11.@OneToMany(cascade = CascadeType.ALL, mappedBy = "oneId")//指向多的那方的pojo的关联外键字段 12.private Collection<Many> manyCollection;
1. @Entity
2. @Table(name = "T_MANY")
3. public class Many implements Serializable {
4. private static final long serialVersionUID = 1L;
5. @Id
6. @Column(name = "MANY_ID", nullable = false)
7. private String manyId;
8. @Column(name = "DESCRIPTION")
9. private String description;
10.
11.@JoinColumn(name = "ONE_ID", referencedColumnName =
"ONE_ID")//设置对应数据表的列名和引用的数据表的列名
12.@ManyToOne//设置在“一方”pojo的外键字段上
13.private One oneId;
8.多对多映射关系
貌似多对多关系不需要设置级联,以前用hibernate的时候着实为多对多的级联头疼了一阵子,JPA的多对多还需要实际的尝试一下才能有所体会。
估计JPA的多对多也是可以转换成两个一对多的。
第一个Pojo
1. @Entity
2. @Table(name = "T_MANYA")
3. public class ManyA implements Serializable {
4. private static final long serialVersionUID = 1L;
5. @Id
6. @Column(name = "MANYA_ID", nullable = false)
7. private String manyaId;
8. @Column(name = "DESCRIPTION")
9. private String description;
10.@ManyToMany
11.@JoinTable(name = "TMANY1_TMANY2", joinColumns =
{@JoinColumn(name = "MANYA_ID", referencedColumnName = "MANYA_ID")}, inverseJoinColumns = {@JoinColumn(name = "MANYB_ID", referencedColumnName = "MANYB_ID")})
12.private Collection<ManyB> manybIdCollection;
第二个Pojo
1. @Entity
2. @Table(name = "T_MANYB")
3. public class ManyB implements Serializable {
4. private static final long serialVersionUID = 1L;
5. @Id
6. @Column(name = "MANYB_ID", nullable = false)
7. private String manybId;
8. @Column(name = "DESCRIPTION")
9. private String description;
10.@ManyToMany(mappedBy = "manybIdCollection")
11.private Collection<ManyA> manyaIdCollection;
9.一对一映射关系
主Pojo
1. @Entity
2. @Table(name = "T_ONEA")
3. public class OneA implements Serializable {
4. private static final long serialVersionUID = 1L;
5. @Id
6. @Column(name = "ONEA_ID", nullable = false)
7. private String oneaId;
8. @Column(name = "DESCRIPTION")
9. private String description;
10.@OneToOne(cascade = CascadeType.ALL, mappedBy = "oneA")//
主Pojo这方的设置比较简单,只要设置好级联和映射到从Pojo的外键就可以了。
11.private OneB oneB;
从Pojo
1. @Entity
2. @Table(name = "T_ONEB")
3. public class OneB implements Serializable {
4. private static final long serialVersionUID = 1L;
5. @Id
6. @Column(name = "ONEA_ID", nullable = false)
7. private String oneaId;
8. @Column(name = "DESCRIPTION")
9. private String description;
10.@JoinColumn(name = "ONEA_ID", referencedColumnName =
"ONEA_ID", insertable = false, updatable = false)//设置从方指向主方的关联外键,这个ONEA_ID其实是表T_ONEA的主键
11.@OneToOne
12.private OneA oneA;
10 大字段
1. @Lob //对应Blob字段类型
2. @Column(name = "PHOTO")
3. private Serializable photo;
4. @Lob //对应Clob字段类型
5. @Column(name = "DESCRIPTION")
6. private String description;
11.瞬时字段
不需要与数据库映射的字段,在保存的时候不需要保存倒数据库
1. @Transient
2. private int tempValue;
3.
4. public int getTempValue(){
5. get tempValue;
6. }
7.
8. public void setTempValue(int value){
9. this.tempValue = value;
10.}
篇二:jpa多对多映射案例
jpa多对多映射案例
学生和老师就是多对多的关系。一个学生有多个老师,一个老师教多个学生。多对多映射采取中间表连接的映射策略,建立的中间表将分别引入两边的主键作为外键。jpa 对于中间表的元数据提供了可配置的方式,用户可以自定义中间表的表名,列名。
下面就以学生和老师为例介绍多对多映射关系的实例开发
Student实体类
复制代码
package com.ljq.entity;
import java.util.HashSet;
import java.util.Set;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.ManyToMany;
@SuppressWarnings("serial")
@Entity
public class Student implements java.io.Serializable {
/** 学生ID **/
private Integer studentid;
/** 学生姓名 **/
private String name;
private Set<Teacher> teachers=new HashSet<Teacher>();
public Student() {
super();
}
public Student(String name) {
super();
this.name = name;
}
@Id
@GeneratedValue
public Integer getStudentid() {
return studentid;
}
public void setStudentid(Integer studentid) {
this.studentid = studentid;
}
@Column(nullable=false,length=32)
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
//@ManyToMany注释表示Student是多对多关系的一边,mappedBy属性定义了Student为双向关系的维护端
//Teacher表是关系的维护者,owner side,有主导权,它有个外键指向Student表。@ManyToMany(mappedBy = "students")
public Set<Teacher> getTeachers() {
return teachers;
}
public void setTeachers(Set<Teacher> teachers) {
this.teachers = teachers;
}
}
复制代码
Teacher实体类
复制代码
package com.ljq.entity;
import java.util.HashSet;
import java.util.Set;
import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.JoinTable;
import javax.persistence.ManyToMany;
@SuppressWarnings("serial")
@Entity
public class Teacher implements java.io.Serializable {
/** 教师ID **/
private Integer teacherid;
/** 教师姓名 **/
private String name;
private Set<Student> students=new HashSet<Student>();
public Teacher() {
super();
}
public Teacher(String name) {
super();
this.name = name;
}
@Id
@GeneratedValue
public Integer getTeacherid() {
return teacherid;
}
public void setTeacherid(Integer teacherid) {
this.teacherid = teacherid;
}
@Column(nullable=false,length=32)
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
//@ManyToMany注释表示Teacher是多对多关系的一端。
//@JoinTable描述了多对多关系的数据表关系。name属性指定中间表名称,joinColumns定义中间表与Teacher表的外键关系。
//中间表Teacher_Student的Teacher_ID列是Teacher表的主键列对应的外键列,inverseJoinColumns属性定义了中间表与另外一端(Student)的外键关系。
@ManyToMany(cascade = CascadeType.PERSIST, fetch = FetchType.LAZY)
@JoinTable(name = "Teacher_Student",
joinColumns = { @JoinColumn(name = "Teacher_ID", referencedColumnName = "teacherid") },
inverseJoinColumns = { @JoinColumn(name
referencedColumnName = "studentid") })
public Set<Student> getStudents() {
return students;
}
public void setStudents(Set<Student> students) {
this.students = students;
}
/**
* 添加学生
*
* @param student
*/
public void addStudent(Student student) {
if (!this.students.contains(student)) {
this.students.add(student);
student.setTeacher(this);
}
}
/**
* 删除学生
*
* @param student
*/
public void removeStudent(Student student) {
if(this.students.contains(student)){
student.setTeacher(null);
//this.students.remove(student);
}
}
}
复制代码
ManyToManyTest测试类
复制代码
package com.ljq.test;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import org.junit.Test; = "Student_ID",
import com.ljq.entity.Student;
import com.ljq.entity.Teacher;
public class ManyToManyTest {
@Test
public void save() {
EntityManagerFactory factory = Persistence.createEntityManagerFactory("ljq");EntityManager em=factory.createEntityManager();
em.getTransaction().begin();
em.persist(new Teacher("张老师"));
em.persist(new Student("小张"));
em.getTransaction().commit();
em.close();
factory.close();
}
/**
* 为老师添加一个学生
*
*/
@Test
public void build() {
EntityManagerFactory factory = Persistence.createEntityManagerFactory("ljq");EntityManager em=factory.createEntityManager();
em. getTransaction().begin();
Teacher teacher = em.find(Teacher.class, 2);
teacher.addStudent(em.getReference(Student.class, 2));
em.getTransaction().commit();
em.close();
factory.close();
}
/**
* 解除学生跟老师的关系
*
*/
@Test
public void remove() {
篇三:hibernate映射的数据类型
Hibernate映射类型分为两种:内置的映射类型和客户化映射类型。内置映射类型负责把一些常见的Java类型映射到相应的SQL类型;此外,Hibernate还允许用户实现UserType或CompositeUserType接口,来灵活地定制客户化映射类型
1.内置映射类型
1).Java基本类型的Hibernate映射类型
Java类型 int/Integer long/Long short/Short byte/Byte float/Float double/Double BigDecimal
char/Character/String String
boolean/Boolean boolean/Boolean boolean/Boolean
2). Java时间和日期类型的Hibernate映射类型
Hibernate映射类型 int/integer long short byte float double
big_decimal character string boolean yes/no
true/false 标准SQL类型 INTEGER BIGINT SAMLLINT TINYINT FLOAT DOUBLE NUMBERIC CHAR(1) VARCHAR BIT
CHAR(1)('Y'/'N') CHAR(1)('T'/'F')
Java类型
java.util.Date/java.sql.Date java.util.Date/java.sql.TIme
java.util.Date/java.sql.Timestamp java.util.Calendar java.util.Calendar
Hibernate映射类型 date time
timestamp calendar
calendar_date 标准SQL类型DATE TIME
TIMESTAMP TIMESTAMP DATE
* 当程序类型为java.sql.Timestamp, 数据库中表属性类型为timestamp的情况下,即使用户以空值插入数据,数据库系统仍然会自动填充timestamp的值
3). Java 大对象类型的Hibernate映射类型
Java类型 byte[] String
serializable java.sql.Clob java.sql.Blob Hibernate映射类型 binary text
实现serializable接口的一个java类 clob blob 标准SQL类型 VARBINARY/BLOB CLOB
VARBINARY/BLOB CLOB BLOB
* 在应用程序中通过Hibernate来保存java.sql.Clob或者java.sql.Blob实例时,必须包含两个步骤:
a. 在一个数据库事务中先保存一个空的Blob或Clob实例;b. 接着锁定这条记录,更新在步骤(1)中保存的Blob或Clob实例,把二进制数据或长文本数据写到Blob或Clob实例中。
1
2Session session = sessionFactory.openSession(); 3Transaction tx = session.beginTransaction(); 4Customer customer = new Customer();
5customer.setDescription(Hibernate.createClob("")); //先保存一个空的clob 6session.save(customer); 7session.flush(); 8//锁定这条记录
9session.refresh(customer,LockMode.UPGRADE);
10oracle.sql.CLOB clob = (oracle.sql.CLOB) customer.getDescription(); 11java.io.Writer pw = clob.getCharacterOutStream();
12pw.write(longText);//longText是一个长度超过255的字符串 13pw.close(); 14tx.commit(); 15session.close();
* 一个java类型对应多个Hibernate映射类型的场合。例如,如果持久化类的属性为java.util.Date类型,对应的Hibernate映射类型可以是date,time
或timestamp。此时必须根据对应的数据库表的字段的SQL类型,来确定Hibernate映射类型。如果字段为Date类型,则hibernate映射为datge,如果为TIME则为time,如果为TIMESTAMP则为timestamp。
《jpa1000字类型映射》
由:免费论文网互联网用户整理提供,链接地址:
http://m.csmayi.cn/show/93870.html
转载请保留,谢谢!
- 下一篇:java转正申请3000字