hibernate3 Annotation的使用

注解映射必须满足两大条件：Hibernate3.2以上版本和JSEE 5。

@Entity 类注释，所有要持久化的类都要有

Java代码

 

1. @Entity  
2. public class Org  implements java.io.Serializable {   
3. }  

 

@Entitypublic class Org implements java.io.Serializable {}

@Id 主键

Java代码

 

1. @Id  
2.      @GeneratedValue  
3.      private String orgId;   
4.      private String orgName;  

 

@Id @GeneratedValue private String orgId; private String orgName;

@Column(name="...") 该属性对应表中的字段是什么，没有name表示一样

@Table 对象与表映射

@UniqueConstraint 唯一约束

@Version 方法和字段级，乐观锁用法，返回数字和timestamp，数字为首选

@Transient 暂态属性，表示不需要处理

@Basic 最基本的注释。有两个属性：fetch是否延迟加载，optional是否允许null

@Enumerated 枚举类型

@Temporal 日期转换。默认转换Timestamp

@Lob 通常与@Basic同时使用，提高访问速度。

@Embeddable 类级，表可嵌入的

@Embedded 方法字段级，表被嵌入的对象和@Embeddable一起使用

@AttributeOverrides 属性重写

@AttributeOverride 属性重写的内容和@AttributeOverrides一起嵌套使用

@SecondaryTables 多个表格映射

@SecondaryTable 定义辅助表格映射和@SecondaryTables一起嵌套使用

@GeneratedValue 标识符生成策略，默认Auto

表与表关系映射

@OneToOne：一对一映射。它包含五个属性：

targetEntity:关联的目标类

Cascade:持久化时的级联操作，默认没有

fetch:获取对象的方式，默认EAGER

Optional:目标对象是否允许为null，默认允许

mappedBy:定义双向关联中的从属类。

单向：

@JoinColumn:定义外键(主表会多一字段，做外键)

@OneToMany：一对多映射；@ManyToOne：多对一映射

单向一对多：

@OneToMany(cascade=CascadeType.ALL)

@JoinColumn(name="book_oid")/**book：表；oid：book表的主键；无name会按此规则自动生成*/

单向多对一：

@ManyToOne(cascade=CascadeType.ALL)

@JoinColumn(name="author_oid")

关联表格一对多：

@OneToMany(cascade=CascadeType.ALL)

@JoinTable(joinColumn={@JoinColumn(name="BOOK_OBJECT_OID")},inverseJoinColumns={@JoinColumn(name="AUTHER_OBJECT_OID")})

双向一对多或多对一：

不需要多一张表，只是使用mappedBy:使用在One一方，值为One方类名表示Many的从属类。

Java代码

 

1. @Entity  
2. public class Org  implements java.io.Serializable {   
3.   
4.   
5.     // Fields       
6.     @Id  
7.     @GeneratedValue  
8.      private String orgId;   
9.      private String orgName;   
10.      @OneToMany(mappedBy = "org")   
11.      private List<Department> departments;   
12.   
13.     // Constructors   
14. ...   
15.     // Property accessors   
16. ...   
17. }  

 

@Entitypublic class Org implements java.io.Serializable { // Fields @Id @GeneratedValue private String orgId; private String orgName; @OneToMany(mappedBy = "org") private List<Department> departments; // Constructors... // Property accessors...}

Java代码

 

1. @Entity  
2. public class Department  implements java.io.Serializable {   
3.   
4.   
5.     // Fields       
6.     @Id  
7.     @GeneratedValue  
8.      private String id;   
9.      private String name;   
10.      @ManyToOne(fetch=FetchType.EAGER)   
11.      @JoinColumn(name="org_orgId")   
12.      private Org org;   
13.      @OneToMany(mappedBy = "department")   
14.      private List<Employee> employees;   
15.   
16.     // Constructors   
17.   
18.     public List<Employee> getEmployees() {   
19.         return employees;   
20.     }   
21.   
22.     public void setEmployees(List<Employee> employees) {   
23.         this.employees = employees;   
24.     }   
25.   
26.     public Org getOrg() {   
27.         return org;   
28.     }   
29.   
30.     public void setOrg(Org org) {   
31.         this.org = org;   
32.     }   
33.   
34.     /** default constructor */  
35.              .   
36.              .   
37.              .   
38.        
39. }  

 

@Entitypublic class Department implements java.io.Serializable { // Fields @Id @GeneratedValue private String id; private String name; @ManyToOne(fetch=FetchType.EAGER) @JoinColumn(name="org_orgId") private Org org; @OneToMany(mappedBy = "department") private List<Employee> employees; // Constructors public List<Employee> getEmployees() { return employees; } public void setEmployees(List<Employee> employees) { this.employees = employees; } public Org getOrg() { return org; } public void setOrg(Org org) { this.org = org; } /** default constructor */ . . . }

Java代码

 

1. @Entity  
2. public class Employee  implements java.io.Serializable {   
3.   
4.   
5.     // Fields       
6.     @Id  
7.     @GeneratedValue  
8.      private String employeeId;   
9.      private String employeeName;   
10.      private String passWord;   
11.      private Integer age;   
12.      private Integer sex;   
13.      @ManyToOne(fetch=FetchType.EAGER)   
14.      @JoinColumn(name="department_id")   
15.      private Department department;   
16.   
17.         
18.     public Department getDepartment() {   
19.         return department;   
20.     }   
21.   
22.     public void setDepartment(Department department) {   
23.         this.department = department;   
24.     }   
25.   
26.     /** default constructor */  
27.     ...   
28.     // Property accessors   
29.     ...   
30. }  

 

@Entitypublic class Employee implements java.io.Serializable { // Fields @Id @GeneratedValue private String employeeId; private String employeeName; private String passWord; private Integer age; private Integer sex; @ManyToOne(fetch=FetchType.EAGER) @JoinColumn(name="department_id") private Department department; public Department getDepartment() { return department; } public void setDepartment(Department department) { this.department = department; } /** default constructor */ ... // Property accessors ...}

双向多对多：@ManyToMany.单向多对多这里不在赘述（没有太多实际意义）

这个比较简单，看下代码就明白了：

Java代码

 

1. @Entity  
2. public class Book  implements java.io.Serializable {   
3.     @Id  
4.     private int id;   
5.     private String name;   
6.     private float money;   
7.     @ManyToMany(cascade = CascadeType.ALL)   
8.     private List<Author> authors;   
9.        
10.   
11.     public List<Author> getAuthors() {   
12.         return authors;   
13.     }   
14.     public void setAuthors(List<Author> authors) {   
15.         this.authors = authors;   
16.     }   
17.        
18.          ...   
19. }  

 

@Entitypublic class Book implements java.io.Serializable { @Id private int id; private String name; private float money; @ManyToMany(cascade = CascadeType.ALL) private List<Author> authors; public List<Author> getAuthors() { return authors; } public void setAuthors(List<Author> authors) { this.authors = authors; } ...}

 

Java代码

 

1. @Entity  
2. public class Author  implements java.io.Serializable {   
3.     @Id  
4.     private int id;   
5.     private String name;   
6.     private int age;   
7.     @ManyToMany(mappedBy="authors")   
8.     private List<Book> books;   
9.        
10.   
11.     public List<Book> getBooks() {   
12.         return books;   
13.     }   
14.   
15.     public void setBooks(List<Book> books) {   
16.         this.books = books;   
17.     }   
18.   
19.          ...   
20. }  

 

@Entitypublic class Author implements java.io.Serializable { @Id private int id; private String name; private int age; @ManyToMany(mappedBy="authors") private List<Book> books; public List<Book> getBooks() { return books; } public void setBooks(List<Book> books) { this.books = books; } ...}

 

需要注意的是：注释最好加在属性上，不要加在get方法上，那样做有时候就会出错。比如:@ManyToMany的时候就会报错！

 

 

注意import javax.xx.Entity ，而不是org.hibernate.xx.Entity。  

Descn属性不存在于数据库中，用@Transient 注明  

------------------------------------------  

1,需要: Hibernate库文件,Hibernate Annotations库,ejb3-persstence.jar(Java 持久化API)  

sessionFactory=new AnnotationConfiguration().buildSessionFactory();  

------------------------------------------  

2,<bean id="sessionFactory" class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">  

     <property name="annotatedClasses">  

      <list>  

        <value>com.onjava.modelplanes.domain.PlaneType</value>  

      </list>  

     </property>  

 </bean>  

------------------------------------------  

1,@Entity  

@Table(name = "teacher_info")  

@IdClass(UUIDHexGenerator.class)   

public class UserMember implements java.io.Serializable  

2,@entity通过getters/setters方法访问，或直接访问他的成员变量。  

@Entity(access = AccessType.PROPERTY)  

@Entity(access = AccessType.FIELD)  

------------------------------------------  

映射标识符  

1,@Id  

@GeneratedValue(strategy = GenerationType.AUTO)  

private String id;  

2,@Id(generate=GeneratorType.SEQUENCE, generator='SEQ_STORE')  

3,@Id(generate=GeneratorType.IDENTITY)  

------------------------------------------  

映射属性  

1,@Transient  

2,@Column(name="PLANE_ID", length=80, nullable=true)  

3,@Basic(fetch = FetchType.LAZY)  

4,@Serialized 凡标识@Serialized的属性将被序列化  

public Country getCountry() { ... }  

5,@Lob标识了存储对象可能是个CLOB或者BLOB。  

@Lob(type=LobType.CLOB)  

public String getFullText(){return fullText;}  

@Lob(type = LobType.BLOB)  

public byte[] getFullCode() {return fullCode;}  

@Version 定义乐观锁机制使用  

------------------------------------------  

关联关系:  

一、一对一:  

1,@OneToOne(mappedBy = "address")      

public User getUser() {      

      return user;      

}     

1、两边都定义了@OneToOne，但都没有定义mappedBy,则user和address表都会生成到对方的外键，双方都是这个关系的拥有者。   

2、两边都定义了@OneToOne，如果user定义了mappedBy，则在address表生成到user的外键，address是这个关系的拥有者；如果address定义  

了mappedBy，则在user表生成到address的外键，user是这个关系的拥有者。  

 

二、一对多,多对一:  

2,@ManyToOne( cascade = {CascadeType.PERSIST, CascadeType.MERGE} )  

3,@OneToMany(mappedBy="planeType",cascade=CascadeType.ALL, fetch=FetchType.EAGER)  

@OrderBy("name")  

public List<ModelPlane> getModelPlanes() {  

    return modelPlanes;  

}  

其中定义mappedBy的是@OneToMany,也就是说One这一方是关系的拥有者。Many一方的表中生成到关联类的外键。   

 

三、@ManyToMany    

private Set authors = new HashSet<Author>();      

@ManyToMany     

public Set<Author> getAuthors(){      

return authors;      

}       

 

private Set books = new HashSet<Book>();       

@ManyToMany(mappedBy="authors")      

public Set<Book> getBooks(){      

return books;      

}      

@ManyToMany会生成中间表，具体表名和字段可以通过@AssociationTable来定义，默认的就可以了，同样关系的非拥有者，需要定义mappedBy属性。  

------------------------------------------  

命名查询  

你也可以通过注解,利用@NameQueries和@NameQuery注解,如下:  

@NamedQueries(  

{   

@NamedQuery(name="planeType.findAll",query="select p from PlaneType p" ),  

@NamedQuery(name="planeType.delete",query="delete from PlaneType where id=:id" )  

 }  

)  

------------------------------------------  

内嵌对象（组件）  

@Embedded({  

   @AttributeOverride(name='iso2', column = @Column(name='bornIso2') ),  

   @AttributeOverride(name='name', column = @Column(name='bornCountryName') )  

         })  

    Country bornIn;  

    ...  

}  

 

@Embeddable(access = AccessType.FIELD)  

public class Address implements Serializable {  

    String city;  

    Country nationality;  

}  

 

 

@Embeddable  

public class Country implements Serializable {  

    private String iso2;  

    private String name;  

 

    public String getIso2() { return iso2; }  

    public void setIso2(String iso2) { this.iso2 = iso2; }  

 

    @Column(name='countryName')  

    public String getName() { return name; }  

    public void setName(String name) { this.name = name; }  

    ...  

}  

------------------------------------------  

自定义的主键生成策略  

@javax.persistence.GeneratedIdTable(  

   name='GEN_TABLE',  

  table = @Table(name='GENERATOR_TABLE'),  

    pkColumnName = 'key',  

      valueColumnName = 'hi'  

)  

 

@javax.persistence.TableGenerator(  

    name='EMP_GEN',  

    tableName='GEN_TABLE',  

    pkColumnValue='EMP',  

    allocationSize=20  

)  

@javax.persistence.SequenceGenerator(  

    name='SEQ_GEN',  

    sequenceName='my_sequence'  

)  

package org.hibernate.test.metadata;  

 

 

 

school和userMember是一对多关系

 

1. import javax.persistence.CascadeType;  
2. import javax.persistence.Column;  
3. import javax.persistence.Entity;  
4. import javax.persistence.FetchType;  
5. import javax.persistence.GeneratedValue;  
6. import javax.persistence.Id;  
7. import javax.persistence.OneToMany;  
8. import javax.persistence.Table;  
9. import javax.persistence.Temporal;  
10. import javax.persistence.TemporalType;  
11.   
12. import org.hibernate.annotations.Formula;  
13. import org.hibernate.annotations.GenericGenerator;  
14.   
15. @Entity  
16. @Table(name = "school_info")  
17. public class SchoolInfo implements java.io.Serializable {  
18.   
19.     @Id  
20.     @GeneratedValue(generator = "system-uuid")  
21.     @GenericGenerator(name = "system-uuid", strategy = "uuid")  
22.     private String id;//hibernate的uuid机制,生成32为字符串  
23.   
24.     @Column(name = "actcodeId", updatable = false, nullable = true, length = 36)  
25.     private String actcodeId;  
26.   
27.     @Formula("select COUNT(*) from school_info")  
28.     private int count;  
29.   
30.     @Temporal(TemporalType.TIMESTAMP)//不用set,hibernate会自动把当前时间写入  
31.     @Column(updatable = false, length = 20)  
32.     private Date createTime;  
33.   
34.     @Temporal(TemporalType.TIMESTAMP)  
35.     private Date updateTime;// 刚开始我默认insertable=false,但会读取出错提示如下:  
36.     // Value '0000-00-00' can not be represented as java.sql.Timestamp  
37.   
38.     // mappedBy="school"就相当于inverse=true,(mappedBy指定的是不需要维护关系的一端)  
39.     // 应该注意的是mappedBy值对应@ManyToOne标注的属性,我刚开始写成"schoolId",让我郁闷了好一会

     

     

40.     @OneToMany(mappedBy = "school", cascade = CascadeType.ALL, fetch = FetchType.EAGER, targetEntity = UserMember.class)  
41.     // 用范性的话,就不用targetEntity了  
42.     private List users = new ArrayList();  
43.       
44. }  

@GeneratedValue(strategy=GenerationType.AUTO)我们常用的自增长机制,我这里采用的是hibernate的uuid生成机制.

 

需要注意的是import javax.xx.Entity ，而不是org.hibernate.xx.Entity。

郁闷的是我上面用到@Formula,生成的sql竟然是'select COUNT(*) from school_info as formula0_ from school_info schoolinfo0_,当然不能执行了,寻求正解中~!!!!!!!!!

UserMember.java(前面引入的包已经贴过了,下面就不贴了)

 

 

1. @Entity  
2. @Table(name = "teacher_info")//实体类和数据库表名不一致时,才用这个  
3. public class UserMember implements java.io.Serializable {  
4.   
5.     @Id  
6.     @GeneratedValue(generator = "system-uuid")  
7.     @GenericGenerator(name = "system-uuid", strategy = "uuid")  
8.     private String id;  
9.   
10.     @Column(updatable = false, nullable = false, length = 20)  
11.     private String logonName;  
12.       
13.     @Temporal(TemporalType.TIMESTAMP)  
14.     @Column(updatable = false, length = 20)  
15.     private Date createTime;  
16.   
17.     @Temporal(TemporalType.TIMESTAMP)  
18.     private Date updateTime;  
19.   
20.     @ManyToOne(cascade = { CascadeType.MERGE })  
21.     @JoinColumn(name = "schoolId")  
22.     private SchoolInfo school;  
23.     //注意该类就不用声明schoolId属性了,如果不用@JoinColumn指明关联的字段,hibernate默认会是school_id.