• Hibernate4实战之Hibernate4注解零配置<转>

    @Entity，注册在类头上，将一个类声明为一个实体bean(即一个持久化POJO类) 。
    @Table，注册在类头上，注解声明了该实体bean映射指定的表（table）。
    @Id用来注册主属性，@GeneratedValue用来注册主属性的生成策略，@Column用来注册属性，@Version用来注册乐观锁，@Transient用来注册不是属性。
    以上的@Id、@GeneratedValue、 @Column 、 @Version，可以用来注册属性，既可以写在Java类的属性上，也可以注册在属性对应的getter上。
    @Transient注册在多余的属性或多余的getter上，但是必须与以上的@Column等对应。
    @Column
    标识属性对应的字段，示例：@Column(name=“userName")

    java代码：
    查看复制到剪贴板打印
    1. @Column(   
    2.     name="columnName";                                (1)   
    3.     boolean unique() default false;                   (2)   
    4.     boolean nullable() default true;                  (3)   
    5.     boolean insertable() default true;                (4)   
    6.     boolean updatable() default true;                 (5)   
    7.     String columnDefinition() default "";             (6)   
    8.     String table() default "";                        (7)   
    9.     int length() default 255;                         (8)   
    10.     int precision() default 0; // decimal precision   (9)   
    11.     int scale() default 0; // decimal scale           (10)  
    @Column(
    name="columnName";                                (1)
    boolean unique() default false;                   (2)
    boolean nullable() default true;                  (3)
    boolean insertable() default true;                (4)
    boolean updatable() default true;                 (5)
    String columnDefinition() default "";             (6)
    String table() default "";                        (7)
    int length() default 255;                         (8)
    int precision() default 0; // decimal precision   (9)
    int scale() default 0; // decimal scale           (10)
    (1) name 可选,列名(默认值是属性名)
    (2) unique 可选,是否在该列上设置唯一约束(默认值false)
    (3) nullable 可选,是否设置该列的值可以为空(默认值false)
    (4) insertable 可选,该列是否作为生成的insert语句中的一个列(默认值true)
    (5) updatable 可选,该列是否作为生成的update语句中的一个列(默认值true)
    (6) columnDefinition 可选: 为这个特定列覆盖SQL DDL片段 (这可能导致无法在不同数据库间移植)
    (7) table 可选,定义对应的表(默认为主表)
    (8) length 可选,列长度(默认值255)
    (8) precision 可选,列十进制精度(decimal precision)(默认值0)
    (10) scale 可选,如果列十进制数值范围(decimal scale)可用,在此设置(默认值0)
    @Id，标识这个属性是实体类的唯一识别的值。
    注意：这个注解只能标注单一列构成的主键，如tbl_grade那种有两个字段组成的联合主键由其他注解标识。
    回忆*.hbm.xml：
    <id name= "uuid">
    <generator class= "assigned"/>
            </id>
    @Id，只是标识这个属性是主键，但是并没有指出其生成策略，如上例中的assigned就是由程序员指定的生成策略。
    如果仅仅写出@Id，即是使用assigned生成略，如：

    java代码：
    查看复制到剪贴板打印
    1. @Id  
    2. @Column  
    3. private int uuid;   
    4. 如果想使用Oracle支持的sequence取主键，必须通过@GeneratedValue来指定生成策略，而由@SequenceGenerator指定如何使用sequence。   
    5. @Id  
    6. @Column  
    7. @GeneratedValue(   
    8. strategy = GenerationType.SEQUENCE,//使用sequence生成主键   
    9. generator =“generator“//引用下面名为gernator的生成策略   
    10. )   
    11. @SequenceGenerator(   
    12. name = “generator”,//定义名为generator的生成策略   
    13. allocationSize = 1，//每次sequence加1   
    14. name=“seq_a”//引用名为seq_a的sequence   
    15. )   
    16. private int uuid;   
    17. @Version  
    @Id
@Column
private int uuid;
如果想使用Oracle支持的sequence取主键，必须通过@GeneratedValue来指定生成策略，而由@SequenceGenerator指定如何使用sequence。
@Id
@Column
@GeneratedValue(
strategy = GenerationType.SEQUENCE,//使用sequence生成主键
generator =“generator“//引用下面名为gernator的生成策略
)
@SequenceGenerator(
name = “generator”,//定义名为generator的生成策略
allocationSize = 1，//每次sequence加1
name=“seq_a”//引用名为seq_a的sequence
)
private int uuid;
@Version
    标识这个属性用来映射乐观锁的version
    @Transient
    标识这个属性不用持久化
    @Embeddable【小对象的头上】
    标识实体中可以定义一个嵌入式组件(embedded component)。组件类必须在类一级定义@Embeddable注解。
    @Embedded【大对象的属性头上】
    引用定义的小对象。
    @Embeddable【小对象的头上】
    标识实体中可以定义一个嵌入式组件(embedded component)。组件类必须在类一级定义@Embeddable注解。
    注意：如果这个小对象作为复合主键，一定要实现Serializable接口。这并不是注解决定的，而是Hibernate的主键都需要实现Serializable接口。
    @EmbeddedId 【大对象的属性头上】
    引用定义的小对象作为主键。
    注意：不需要再使用@Id注解。
     
    标准的1:1
       
    XML的配置

    java代码：
    查看复制到剪贴板打印
    1. 主1【tbl_product】：   
    2. <one-to-one name="info" cascade="all"/>   
    3. 从1【tbl_product_info】：   
    4. <id name="uuid">   
    5. <generator class=“foreign【写死，使用外来生成策略】">   
    6. <param name=“property”>product【引用自己的Java属性名】 </param>   
    7. </generator>   
    8. </id>   
    9. <one-to-one name="product"/>  
    主1【tbl_product】：
<one-to-one name="info" cascade="all"/>
从1【tbl_product_info】：
<id name="uuid">
<generator class=“foreign【写死，使用外来生成策略】">
<param name=“property”>product【引用自己的Java属性名】 </param>
</generator>
</id>
<one-to-one name="product"/>
    注解的配置

    java代码：
    查看复制到剪贴板打印
    1. 主1【tbl_product】：   
    2. @OneToOne(cascade=CascadeType.ALL)   
    3. @PrimaryKeyJoinColumn  
    4. private ProductInfoModel info;   
    5. 从1【tbl_product_info】：   
    6. @Id  
    7. @Column  
    8. @GeneratedValue(generator=“copy【引用生成策略】")   
    9. @GenericGenerator(name=“copy【定义生成策略】”,strategy=“foreign【写死，使用外来策略】”,parameters=@Parameter(name=“property”,value=“product【引用自己的Java属性】"))   
    10. private int uuid;   
    11. @OneToOne(mappedBy=“info【引用对方的Java属性】")   
    12. private ProductModel product;   
    13.    
    主1【tbl_product】：
@OneToOne(cascade=CascadeType.ALL)
@PrimaryKeyJoinColumn
private ProductInfoModel info;
从1【tbl_product_info】：
@Id
@Column
@GeneratedValue(generator=“copy【引用生成策略】")
@GenericGenerator(name=“copy【定义生成策略】”,strategy=“foreign【写死，使用外来策略】”,parameters=@Parameter(name=“property”,value=“product【引用自己的Java属性】"))
private int uuid;
@OneToOne(mappedBy=“info【引用对方的Java属性】")
private ProductModel product;
    标准的1:M
      
    XML的配置
     

    java代码：
    查看复制到剪贴板打印
    1. 1【tbl_parent】：   
    2.  <set name="children">   
    3.         <key column=“puuid【对方的数据库外键列名】"/>   
    4.         <one-to-many class=“cn.javass.model.c.ChildModel【对方的Java类名】"/>   
    5.   </set>   
    6. 多【tbl_child】：   
    7. <many-to-one name=“parent” column=“puuid【自己的数据库外键列名】"/>  
    1【tbl_parent】：
 <set name="children">
        <key column=“puuid【对方的数据库外键列名】"/>
        <one-to-many class=“cn.javass.model.c.ChildModel【对方的Java类名】"/>
  </set>
多【tbl_child】：
<many-to-one name=“parent” column=“puuid【自己的数据库外键列名】"/>
    注解的配置
     

    java代码：
    查看复制到剪贴板打印
    1. 1【tbl_parent】：   
    2. @OneToMany  
    3. @JoinColumn(name="puuid【对方的数据库外键列名】")   
    4. private Set<ChildModel> children = new HashSet<ChildModel>();   
    5. 多【tbl_child】：   
    6. @ManyToOne  
    7. @JoinColumn(name="puuid【自己的数据库外键列名】")   
    8. private ParentModel parent;   
    9.    
    1【tbl_parent】：
@OneToMany
@JoinColumn(name="puuid【对方的数据库外键列名】")
private Set<ChildModel> children = new HashSet<ChildModel>();
多【tbl_child】：
@ManyToOne
@JoinColumn(name="puuid【自己的数据库外键列名】")
private ParentModel parent;
    标准的1:M
     
     
    XML的配置

    java代码：
    查看复制到剪贴板打印
    1. <set name=“courses” table=“tbl_grade【联接表】">   
    2.         <key column=“suuid【联接表里代表自己的数据库字段名】"/>   
    3.         <many-to-many column=“cuuid【联接表里代表对方的数据库字段名】” class=“cn.javass.model.e.CourseMode【对方的类名】l"/>   
    4. </set>   
    5. 注解的配置   
    6. @ManyToMany  
    7. @JoinTable(   
    8. name=“tbl_grade【联接表】",   
    9. joinColumns=@JoinColumn(name="suuid【联接表里代表自己的数据库字段名】"),   
    10. inverseJoinColumns=@JoinColumn(name="cuuid 【联接表里代表对方的数据库字段名】” )   
    11. )   
    12. private Set<CourseModel> courses = new HashSet<CourseModel>();   
    13.    
    <set name=“courses” table=“tbl_grade【联接表】">
        <key column=“suuid【联接表里代表自己的数据库字段名】"/>
        <many-to-many column=“cuuid【联接表里代表对方的数据库字段名】” class=“cn.javass.model.e.CourseMode【对方的类名】l"/>
</set>
注解的配置
@ManyToMany
@JoinTable(
name=“tbl_grade【联接表】",
joinColumns=@JoinColumn(name="suuid【联接表里代表自己的数据库字段名】"),
inverseJoinColumns=@JoinColumn(name="cuuid 【联接表里代表对方的数据库字段名】” )
)
private Set<CourseModel> courses = new HashSet<CourseModel>();
    标准的1:M
     
       
    XML的配置
     

    java代码：
    查看复制到剪贴板打印
    1. 主1【tbl_product】：   
    2. <one-to-one name=“info” foreign-key=“puuid【对方的数据库外键列名】" cascade="all"/>   
    3. 从1【tbl_product_info】：   
    4. <many-to-one name=“product” column=“puuid【自己的数据库外键列名】” unique=“true【写死】"/>  
    主1【tbl_product】：
<one-to-one name=“info” foreign-key=“puuid【对方的数据库外键列名】" cascade="all"/>
从1【tbl_product_info】：
<many-to-one name=“product” column=“puuid【自己的数据库外键列名】” unique=“true【写死】"/>
    注解的配置
     

    java代码：
    查看复制到剪贴板打印
    1. 主1【tbl_product】：   
    2. @OneToOne(cascade=CascadeType.ALL,mappedBy=“product【对方的Java类属性名 】")   
    3. private ProductInfoModel info;   
    4. 从1【tbl_product_info】：   
    5. @OneToOne  
    6. @JoinColumn(name=“puuid【自己的数据库外键列名】")   
    7. private ProductModel product;  
    主1【tbl_product】：
@OneToOne(cascade=CascadeType.ALL,mappedBy=“product【对方的Java类属性名 】")
private ProductInfoModel info;
从1【tbl_product_info】：
@OneToOne
@JoinColumn(name=“puuid【自己的数据库外键列名】")
private ProductModel product;
    标准的1:M
     
     
     
     
    XML的配置

    java代码：
    查看复制到剪贴板打印
    1. 1【tbl_parent】：   
    2. <set name=“children” table=“tbl_parent_child【联接表】">   
    3.         <key column=“puuid【联接表里代表自己的数据库列名】"/>   
    4.         <many-to-many column=“cuuid【联接表里代表对方的数据库列名】” unique=“true【写死】”   
    5. class=“cn.javass.model.d.ChildModel【对方的Java类名】"/>   
    6.         </set>   
    7. <join table=“tbl_parent_child【联接表】">   
    8.         <key column="cuuid【联接表里代表自己的数据库列名】"/>   
    9.         <many-to-one name="parent" column="puuid【联接表里代表对方的数据库列名】" unique="true【写死】"/>   
    10. </join>  
    1【tbl_parent】：
<set name=“children” table=“tbl_parent_child【联接表】">
        <key column=“puuid【联接表里代表自己的数据库列名】"/>
        <many-to-many column=“cuuid【联接表里代表对方的数据库列名】” unique=“true【写死】”
class=“cn.javass.model.d.ChildModel【对方的Java类名】"/>
        </set>
<join table=“tbl_parent_child【联接表】">
        <key column="cuuid【联接表里代表自己的数据库列名】"/>
        <many-to-one name="parent" column="puuid【联接表里代表对方的数据库列名】" unique="true【写死】"/>
</join>
    注解的配置

    java代码：
    查看复制到剪贴板打印
    1. 1【tbl_parent】：   
    2. @OneToMany(mappedBy="parent【对方的Java类属性名 】")   
    3. private Set<ChildModel> children = new HashSet<ChildModel>();   
    4. 多【tbl_child】：   
    5. @ManyToOne  
    6. @JoinTable(   
    7. name=“tbl_parent_child【联接表】",   
    8. joinColumns=@JoinColumn(name="cuuid【联接表里代表自己的数据库字段名】"),   
    9. inverseJoinColumns=@JoinColumn(name="puuid【联接表里代表对方的数据库字段名】")   
    10. )   
    11. private ParentModel parent;  
    1【tbl_parent】：
@OneToMany(mappedBy="parent【对方的Java类属性名 】")
private Set<ChildModel> children = new HashSet<ChildModel>();
多【tbl_child】：
@ManyToOne
@JoinTable(
name=“tbl_parent_child【联接表】",
joinColumns=@JoinColumn(name="cuuid【联接表里代表自己的数据库字段名】"),
inverseJoinColumns=@JoinColumn(name="puuid【联接表里代表对方的数据库字段名】")
)
private ParentModel parent;
     
    标准的1:M
     
     
     
     
    XML的配置

    java代码：
    查看复制到剪贴板打印
    1. 1【tbl_product】：   
    2. <join table=“tbl_product_relation【联接表】">   
    3.         <key column=“puuid【联接表里代表自己的列名】"/>   
    4.         <many-to-one name=“course【自己的Java属性名】” column=“cuuid【联接表里代表对方的列名】” unique=“true【写死】"/>   
    5.  </join>  
    1【tbl_product】：
<join table=“tbl_product_relation【联接表】">
        <key column=“puuid【联接表里代表自己的列名】"/>
        <many-to-one name=“course【自己的Java属性名】” column=“cuuid【联接表里代表对方的列名】” unique=“true【写死】"/>
 </join>
    注解的配置

    java代码：
    查看复制到剪贴板打印
    1. 1【tbl_product】：   
    2. @ManyToOne  
    3. @JoinTable(   
    4. name=" tbl_product_relation 【联接表】",   
    5. joinColumns=@JoinColumn(name="suuid【联接表里代表自己的列名】"),   
    6. inverseJoinColumns=@JoinColumn(name="cuuid【联接表里代表对方的列名】",unique=true【写死】)   
    7. )   
    8. private CourseModel course;  
    1【tbl_product】：
@ManyToOne
@JoinTable(
name=" tbl_product_relation 【联接表】",
joinColumns=@JoinColumn(name="suuid【联接表里代表自己的列名】"),
inverseJoinColumns=@JoinColumn(name="cuuid【联接表里代表对方的列名】",unique=true【写死】)
)
private CourseModel course;
     
  • 相关阅读:
    67家基金子公司背景脉络梳理
    港股奇葩术语知多少
    68家信托公司7大派系股东分食图谱
    港股术语
    流动性陷阱
    ORACLE归档模式和非归档模式的利与弊
    肥尾效应
    DVP
    金融衍生品如何定价
    绿鞋机制
  • 原文地址：https://www.cnblogs.com/winkey4986/p/2575019.html
Copyright © 2020-2023  润新知