`

JPA注解总结

 
阅读更多
1.实体类上使用的注解

1. @Entity                                        这个注解将Pojo对象声明为一个JPA实体
2. @Table (name="table_name")      指定该实体对应数据库中具体的表名
3. @Cache(usage = CacheConcurrencyStrategy.READ_WRITE) 缓存策略
4. @SequenceGenerator(name = "sequence_ora",sequenceName="SEQUENCE_ORACLE")定义使用的Sequence,主要是oracle数据库使用，用来生成主键

CacheConcurrencyStrategy有五种缓存方式：


1.    CacheConcurrencyStrategy.NONE，不适用，默认
2.    CacheConcurrencyStrategy.READ_ONLY ，只读模式，在此模式下，如果对数据进行更新操作，会有异常；
3.    CacheConcurrencyStrategy.READ_WRITE ，读写模式在更新缓存的时候会把缓存里面的数据换成一个锁，其它事务如果去取相应的缓存数据，发现被锁了，直接就去数据库查询；
4.    CacheConcurrencyStrategy.NONSTRICT_READ_WRITE ，不严格的读写模式则不会的缓存数据加锁；
5.    CacheConcurrencyStrategy.TRANSACTIONAL ，事务模式指缓存支持事务，当事务回滚时，缓存也能回滚，只支持 JTA  环境。

示例：
1. @Entity
2. @Table(name="GE_USER")
3. @Cache(usage = CacheConcurrencyStrategy.READ_WRITE)
4. public class User implements Serializable {   
5. }  

2.字段上的注解
@Id主键               该注解声明该属性为主键
@Column(name = "column_name", nullable = false)      定义列属性
@OrderBy(name = "id ASC, name DESC")      排序,可多个
@Temporal(TemporalType.DATE)     定义日期的格式 yyyyMMdd  或者 yyyyMMdd HH:mm:ss
@Transient                                      瞬时属性，不会保存入库

Column注解设置，包含的设置如下(一般定义name属性即可)

1. name：字段名
2. unique：是否唯一
3. nullable：是否可以为空
4. inserttable：是否可以插入
5. updateable：是否可以更新
6. columnDefinition: 定义建表时创建此列的DDL
7. secondaryTable: 从表名。如果此列不建在主表上（默认建在主表），该属性定义该列所在从表的名字。 

public class Users implements Serializable {    
	 @Id    
	 private String userCode; @Column(name = "user_code", nullable = false, length=32)//设置属性userCode对应的字段为user_code，长度为32，非空
    

 private String userCode;    
	  @Column(name = "user_wages", nullable = true, precision=12, scale=2)//设置属性wages对应的字段为user_wages，12位数字可保留两位小数，可以为空    
	  private double wages;    
	  @Temporal(TemporalType.DATE)//设置为时间类型    
	  private Date joinDate;

3.字段排序
在加载数据的时候可以为其指定顺序，使用@OrderBy注解实现

  
@Table(name = "USERS")    
	  public class User {    
	  @OrderBy(name = "group_name ASC, name DESC")    
	  private List books = new ArrayList();    
	  }
  
4.主键生成策略

主键生成测略 

Annotation的ID生成策略
@Id 
@GeneratedValue(strategy=GenerationType.IDENTITY)//不能用于oracle，因为不支持IDENTITY; oracle是SEQUENCE

指定SEQUENCE名
     类上添加@SequenceGenerator
@SequenceGenerator(name = "sequence_ora",sequenceName="SEQUENCE_ORACLE") //数据库中的sequence名:SEQUENCE_ORACLE  
@Id 
@GeneratedValue(strategy=GenerationType.SEQUENCE,generator="sequence_ora")//指定定义的sequence名 

用表存储自增长值
     类上添加@TableGenerator
@TableGenerator(name="sequence_mysql",table="generator_mysql") 
@Id 
@GeneratedValue(strategy=GenerationType.TABLE,generator="sequence_mysql") 

使用UUID生成主键
  @GeneratedValue(generator = "system-uuid")
  @GenericGenerator(name = "system-uuid", strategy = "uuid")


public class Users implements Serializable {    
	 @Id    
	 @GeneratedValue(strategy=GenerationType.IDENTITY)//主键自增，注意，这种方式依赖于具体的数据库，如果数据库不支持自增主键，那么这个类型是没法用的    
	 @Column(name = "user_id", nullable = false)    
	 private int userId;
  
   
public class Users implements Serializable {    
	 @Id    
	  @GeneratedValue(strategy=GenerationType.TABLE)//通过一个表来实现主键id的自增，这种方式不依赖于具体的数据库，可以解决数据迁移的问题    
	  @Column(name = "user_code", nullable = false)    
	  private String userCode;
   
        
 public class Users implements Serializable {    
	  @Id    
	  @GeneratedValue(strategy=GenerationType.SEQUENCE)//通过Sequence来实现表主键自增，这种方式依赖于数据库是否有SEQUENCE，如果没有就不能用    
	  @SequenceGenerator(name="seq_user")    
	  @Column(name = "user_id", nullable = false)    
	  private int userId;
  
以下类在网上摘录
5.一对多映射关系
有T_One和T_Many两个表，他们是一对多的关系，注解范例如下
主Pojo 
 @Entity    
	 @Table(name = "T_ONE")    
	 public class One implements Serializable {    
	 private static final long serialVersionUID = 1L;    
	 @Id    
	 @Column(name = "ONE_ID", nullable = false)    
	 private String oneId;    
	 @Column(name = "DESCRIPTION")    
	 private String description;    
	  @OneToMany(cascade = CascadeType.ALL, mappedBy = "oneId")//指向多的那方的pojo的关联外键字段    
	  private Collection<Many> manyCollection;
  
子Pojo 
 @Entity    
	 @Table(name = "T_MANY")    
	 public class Many implements Serializable {    
	 private static final long serialVersionUID = 1L;    
	 @Id    
	 @Column(name = "MANY_ID", nullable = false)    
	 private String manyId;    
	 @Column(name = "DESCRIPTION")    
	 private String description;    
	    
	  @JoinColumn(name = "ONE_ID", referencedColumnName = "ONE_ID")//设置对应数据表的列名和引用的数据表的列名    
	  @ManyToOne//设置在“一方”pojo的外键字段上    
	  private One oneId;
  
6.多对多映射关系
貌似多对多关系不需要设置级联，以前用hibernate的时候着实为多对多的级联头疼了一阵子，JPA的多对多还需要实际的尝试一下才能有所体会。
估计JPA的多对多也是可以转换成两个一对多的。

第一个Pojo 
 @Entity    
	 @Table(name = "T_MANYA")    
	 public class ManyA implements Serializable {    
	 private static final long serialVersionUID = 1L;    
	 @Id    
	 @Column(name = "MANYA_ID", nullable = false)    
	 private String manyaId;    
	 @Column(name = "DESCRIPTION")    
	 private String description;    
	  @ManyToMany    
	  @JoinTable(name = "TMANY1_TMANY2", joinColumns = {@JoinColumn(name = "MANYA_ID", referencedColumnName = "MANYA_ID")}, inverseJoinColumns = {@JoinColumn(name = "MANYB_ID", referencedColumnName = "MANYB_ID")})    
	  private Collection<ManyB> manybIdCollection;

第二个Pojo 
 @Entity    
	 @Table(name = "T_MANYB")    
	 public class ManyB implements Serializable {    
	 private static final long serialVersionUID = 1L;    
	 @Id    
	 @Column(name = "MANYB_ID", nullable = false)    
	 private String manybId;    
	 @Column(name = "DESCRIPTION")    
	 private String description;    
	  @ManyToMany(mappedBy = "manybIdCollection")    
	  private Collection<ManyA> manyaIdCollection;
  
7.一对一映射关系
主Pojo 
 @Entity    
	  @Table(name = "T_ONEA")    
	  public class OneA implements Serializable {    
	  private static final long serialVersionUID = 1L;    
	  @Id    
	  @Column(name = "ONEA_ID", nullable = false)    
	  private String oneaId;    
	  @Column(name = "DESCRIPTION")    
	  private String description;    
	  @OneToOne(cascade = CascadeType.ALL, mappedBy = "oneA")//主Pojo这方的设置比较简单，只要设置好级联和映射到从Pojo的外键就可以了。    
	  private OneB oneB;
  
从Pojo 
@Entity    
	 @Table(name = "T_ONEB")    
	 public class OneB implements Serializable {    
	 private static final long serialVersionUID = 1L;    
	 @Id    
	 @Column(name = "ONEA_ID", nullable = false)    
	 private String oneaId;    
	 @Column(name = "DESCRIPTION")    
	 private String description;    
	  @JoinColumn(name = "ONEA_ID", referencedColumnName = "ONEA_ID", insertable = false, updatable = false)//设置从方指向主方的关联外键，这个ONEA_ID其实是表T_ONEA的主键    
	 @OneToOne    
	 private OneA oneA;
  

8. 大字段
  
@Lob //对应Blob字段类型    
	 @Column(name = "PHOTO")    
	 private Serializable photo;    
	 @Lob //对应Clob字段类型    
	 @Column(name = "DESCRIPTION")    
	 private String description;
 

9.瞬时字段
不需要与数据库映射的字段，在保存的时候不需要保存倒数据库 

@Transient    
	private int tempValue;    
	  
	public int getTempValue(){    
	get tempValue;    
	}    
	  
	public void setTempValue(int value){    
	this.tempValue = value;    
	 }
 
分享到：
JSP小结
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    JPA注解总结大全！！！！

    ### JPA注解总结大全 Java Persistence API (JPA) 是一种用于管理关系数据库中的对象/关系映射的标准。本文将详细介绍与 JPA 相关的一些常用注解及其使用方法，帮助开发者更好地理解和掌握 JPA 的核心功能。 #### ...

    JPA注解实现联合主键

    ### JPA注解实现联合主键 在关系型数据库中，单个字段作为主键的情况较为常见，但在某些场景下，我们需要使用多个字段共同作为主键来唯一标识表中的每一条记录，这就是所谓的“联合主键”。而在Java持久化框架...

    JPA注解 和hibernate 建表

    JPA注解和Hibernate建表 一、JPA概述 Java Persistence API（JPA）是Sun官方提出的Java持久化规范，它只是一个规范不是一个产品。JPA的主要目标是提供一种简洁、易用的方式来访问、操作和管理Java应用程序中的数据...

    JPA注解@Access实例

    **JPA注解@Access详解** Java Persistence API (JPA) 是Java中用于对象关系映射（ORM）的标准框架，它允许开发人员将Java类与数据库表进行映射，从而简化数据操作。在JPA中，`@Access`注解是用于指定实体属性访问...

    hibernate+jpa注解实现最简单的增删改查

    **hibernate+jpa注解实现最简单的增删改查** 在Java开发中，Hibernate和JPA（Java Persistence API）是两种广泛使用的对象关系映射（ORM）框架，它们简化了与数据库交互的过程，使开发者可以使用面向对象的方式来...

Magicbox
Global site tag (gtag.js) - Google Analytics