jpa1000字类型映射

篇一：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://www.csmayi.cn/show/93870.html
转载请保留,谢谢!

• 上一篇：IT行业职业生涯规划3000字
• 下一篇：java转正申请3000字