JPA相关注解(@Table @Entity @MappedSuperclass)

一句话简介

Java Persistence API定义了一种定义，可以将常规的普通Java对象（有时被称作POJO）映射到数据库

映射规则：

实体类__必须__用 @javax.persistence.Entity 进行注解；
必须__使用 @javax.persistence.__Id 来注解一个主键；
实体类必须拥有一个 public 或者 protected 的无参构造函数，之外实体类还可以拥有其他的构造函数；
实体类必须是一个 顶级类（top-level class）。一个枚举（enum）或者一个接口（interface）不能被注解为一个实体；
实体类不能是 final 类型的，也 不能有 final 类型的方法；
如果实体类的一个实例需要用传值的方式调用（例如，远程调用），则这个实体类必须实现（implements）java.io.Serializable 接口。
不与@Table结合的话表名默认为 SnakeCaseStrategy(命名策略 )为表名
若使用 name属性且没有与@Table结合则表名为 name值的SnakeCaseStrategy(命名策略 )
```
@Entity  
public class UserEntity{...} 表名 user_entity  
@Entity(name="UE")  
public class UserEntity{...} 表名 ue  
@Entity(name="UsEntity")  
public class UserEntity{...} 表名 us_entity
```
映射规则可以通过使用 @Table 和 @Column 注解修改

@Table
- @Table注解的常用选项是 name，用于指明数据库的表名
- @Table注解还有两个选项 catalog 和 schema 用于设置表所属的数据库目录或模式，通常为数据库名

@Column

@Column注解用来改变class中字段名与db中表的字段名的映射规则

@Column注释定义了将成员属性映射到关系表中的哪一列和该列的结构信息，属性如下：
　　1）name：映射的列名。如：映射tbl_user表的name列，可以在name属性的上面或getName方法上面加入；
　　2）unique：是否唯一；
　　3）nullable：是否允许为空；
　　4）length：对于字符型列，length属性指定列的最大字符长度；
　　5）insertable：是否允许插入；
　　6）updatetable：是否允许更新；
　　7）columnDefinition：定义建表时创建此列的DDL；
　　8）secondaryTable：从表名。如果此列不建在主表上（默认是主表），该属性定义该列所在从表的名字

hibernate中@Entity和@Table的区别：

@Entity说明这个class是实体类，并且使用默认的orm规则，即class名即数据库表中表名，class字段名即表中的字段名如果想改变这种默认的orm规则，就要使用@Table来改变class名与数据库中表名的映射规则，@Column来改变class中字段名与db中表的字段名的映射规则

@MappedSuperclass和@Entity的区别

使用场景

数据库表中都需要id来表示编号，id是这些映射实体类的通用的属性，交给jpa统一生成主键id编号，那么使用一个父类来封装这些通用属性，并用@MappedSuperclas标识。

示例

public abstract class IdEntity {
    protected Integer id;
    public abstract Integer getId();
    public abstract void setId(Integer id);

}

@MappedSuperclass
public abstract class BaseEntity extends IdEntity {

    @Id
    @GeneratedValue
    @Column(length=20)   
    public Integer getId() {
        return this.id;
    }
    public void setId(Integer id) {
        this.id = id;
    }

}

@Entity
@Table(name="yyw_user")
@Cache(usage= org.hibernate.annotations.CacheConcurrencyStrategy.READ_WRITE)
public class User extends BaseEntity {
    @Column(length=20,nullable=false)
    private String name;
    @Column(length=20,nullable=true)
    private String password;

    public User(){}
    public User(String name, String password) {
        super();
        this.name = name;
        this.password = password;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }

    public String getPassword() {
        return password;
    }
    public void setPassword(String password) {
        this.password = password;
    }
    @Override
    public String toString() {
        return "User [name=" + name + ", id=" + id + ", password=" + password
                + "]";
    }
}

@Entity
@Table(name="yyw_subjects")
@Cache(usage= org.hibernate.annotations.CacheConcurrencyStrategy.READ_WRITE)
public class Subject extends BaseEntity {

    @Column(length=20,nullable=false)
    private String content;
    public Subject(){}
    public Subject(String content){
        this.content = content;
    }
    public String getContent() {
        return content;
    }
    public void setContent(String content) {
        this.content = content;
    }
    @Override
    public String toString() {
        return "Subject [id=" + id + ", content=" + content + "]";
    }
}

注意:

标注为@MappedSuperclass的类将不是一个完整的实体类，他将 不会映射到数据库表，但是 他的属性都将映射到其子类的数据库字段中。
标注为@MappedSuperclass的类 不能再标注@Entity或@Table注解，也 无需实现序列化接口。

@SecondaryTable 的使用

将一个实体类映射到数据库 两张或更多表 中呢表中

示例

@Entity
 @SecondaryTables({
    @SecondaryTable(name = "Address"),
    @SecondaryTable(name = "Comments")
 })
 public class Forum implements Serializable {
    private static final long serialVersionUID = 1L;
    @Id
    @GeneratedValue
    private Long id;
    private String username;
    private String password;
    @Column(table = "Address", length = 100)
    private String street;
    @Column(table = "Address", nullable = false)
    private String city;
    @Column(table = "Address")
    private String conutry;
    @Column(table = "Comments")
    private String title;
    @Column(table = "Comments")
    private String Comments;
    @Column(table = "Comments")
    private Integer comments_length;

    // Getters and Setters
 }

ER图

图片pic1

其他注解

@ManyToOne （多对一）单向：不产生中间表，但可以用@Joincolumn（name=” “）来指定生成外键的名字，外键在多的一方表中产生

@OneToMany （一对多）单向：会产生中间表，此时可以用@onetoMany @Joincolumn（name=” “）避免产生中间表，并且指定了外键的名字（别看@joincolumn在一中写着，但它存在在多的那个表中,通常配合List 一起使用）

@OneToMany ,@ManyToOne 双向（两个注解一起用的）：如果不在@OneToMany中加mappedy属性就会产生中间表，此时通常在@ManyToOne的注解下再添上注解@Joincolumn(name=” “)来指定外键的名字(说明：多的一方为关系维护端，关系维护端负责外键记录的更新，关系被维护端没有权利更新外键记录)！（@OneToMany(mappedBy=”一对多中，多中一的属性”)出现mapby为被维护端|||默认为延迟加载)

//用例：
@ManyToOne(fetch=FetchType.LAZY)
@JoinColumn(name="child_id")
private OrderChild orderChild;

@OneToMany(mappedBy="orderChild",fetch=FetchType.LAZY,cascade={CascadeType.MERGE})
@NotFound(action=NotFoundAction.IGNORE)//代表可以为空，允许为null
private List<OrderChildGoods> goodsList;
//hibernate中@ManyToOne默认是立即加载，@OneToMany默认是懒加载

//但是如果加上了@NotFound之后设置的fetch=FetchType.LAZY是不起作用的，也就是设置@NotFound后变为了立即加载eager

@JoinColumn

@ManyToOne //多个公告对于一个管理员
@JoinColumn(columnDefinition="BIGINT(20) NOT NULL COMMENT '创建管理员ID'")
//JoinColumn 不添加name属性，按照生成数据库字段的规则_id 数据库中字段 create_admin_id
private Admin createAdmin;

@Lob 大对象存储类型

@Lob
@Column(columnDefinition = "TEXT COMMENT '商品描述'")
private String note;
//`note` text CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL COMMENT '商品描述',

@Transient 将不需要序列化的属性前添加关键字transient @Transient详情

@Embeddable 嵌套映射

@CreationTimestamp 根据当前时间来生成默认的时间戳（insert时生成）

@UpdateTimestamp 根据当前时间来生成默认的时间戳（update是更新）

@Inheritance Hibernate继承策略,总共有三种SINGLE_TABLE、TABLE_PER_CLASS 和 JOINED

@id

如果是主键id，还会用到@Id注解

@Id注释指定表的主键，它可以有多种生成方式：
　　1）TABLE：容器指定用底层的数据表确保唯一；
　　2）SEQUENCE：使用数据库德SEQUENCE列莱保证唯一（Oracle数据库通过序列来生成唯一ID）；
　　3）IDENTITY：使用数据库的IDENTITY列莱保证唯一；
　　4）AUTO：由容器挑选一个合适的方式来保证唯一；
　　5）NONE：容器不负责主键的生成，由程序来完成。

双向关联模型

@Entity
@Table(name="address")
public class AddressEO implements java.io.Serializable {

  @ManyToOne(cascade = { CascadeType.ALL })
  @JoinColumn(name="customer_id")//外键字段
  private CustomerEO customer;

  // ...
}

@Entity
@Table(name="customer")
public class CustomerEO {

  @OneToMany(mappedBy="customer")
  private Collection<AddressEO> addresses = new ArrayList<AddressEO>();

  // ...
}
//其中，@OneToMany标记中的mappedBy属性的值为AddressEO实体中所引用的CustomerEO实体的属性名

总结

@Entity @Table 区别通过上面博文可得出
@Entity @Table 通常同时出现
@MappedSuperclass类相当于把通用属性放在一起，再让之类继承实现

参考链接

PREVIOUSVO与DTO的区别