User.java
1 package com.test.bean;
2
3 import java.util.Date;
4 import java.util.HashSet;
5 import java.util.Set;
6
7 import javax.persistence.Basic;
8 import javax.persistence.CascadeType;
9 import javax.persistence.Column;
10 import javax.persistence.Entity;
11 import javax.persistence.FetchType;
12 import javax.persistence.GeneratedValue;
13 import javax.persistence.Id;
14 import javax.persistence.JoinColumn;
15 import javax.persistence.JoinTable;
16 import javax.persistence.Lob;
17 import javax.persistence.ManyToMany;
18 import javax.persistence.ManyToOne;
19 import javax.persistence.OneToOne;
20 import javax.persistence.Table;
21 import javax.persistence.Temporal;
22 import javax.persistence.TemporalType;
23 import javax.persistence.Transient;
24
25 import org.hibernate.annotations.GenericGenerator;
26 /**
27 * 标注@Entity注释的类，表示该类是一个可持久化的实体
28 * 其中Entity中的“name”属性表示实体的名称，若不做设置，默认为标注实体的类的名称,一般默认；
29 * 表@Table 属性不区分大小写
30 * name属性表示实体所对应表的名称，默认表名为实体的名称。
31 * catalog和schema属性表示实体指定的目录名或是数据库名，这根据不同的数据库类型有所不同。
32 * uniqueConstraints属性表示该实体所关联的唯一约束条件，一个实体可以有多个唯一约束条件，默认没有约束条件。
33 * 若使用uniqueConstraints标记时，需要配合标记UniqueConstraint标记来使用。
34 * 例如：uniqueConstraints = {@UniqueConstraint(columnNames = { "name", "email" }),@UniqueConstraint(columnNames = { "col_1", "col_2" })}
35 */
36 @Entity
37 @Table(name="UserInfos")
38 public class User {
39 // 普通属性
40 /**
41 * 一个实体类至少要有一个主键（Primary Key），设置主键@Id
42 * 生成策略@GeneratedValue用于主键的生成策略
43 * @Target({METHOD, FIELD}) @Retention(RUNTIME)
44 * public @interface GeneratedValue {
45 * GenerationType strategy() default AUTO;
46 * strategy属性表示生成主键的策略。有四种类型，分别定义在枚举类型GenerationType中
47 *
48 * String generator() default "";
49 * generator为不同策略类型所对应的生成的规则名，它的值根据不同的策略有不同的设置。
50 * }
51 */
52 @Id
53 @GeneratedValue(generator="system-uuid")
54 @GenericGenerator(name="system-uuid", strategy="uuid")
55 @Column(length=32)
56 private String id;
57
58 /**
59 * @Target({METHOD, FIELD}) @Retention(RUNTIME)
60 * public @interface Column {
61 * String name() default "";
62 * 字段名称
63 *
64 * boolean unique() default false;
65 * unique属性表示该字段是否为唯一标识，默认为false。如果表中有一个字段需要唯一标识，则既可以使用该标记，
66 * 也可以使用@Table标记中的@UniqueConstraint。
67 *
68 * boolean nullable() default true;
69 * nullable属性表示该字段是否可以为null值，默认为true。
70 *
71 * boolean insertable() default true;
72 * insertable属性表示在使用“INSERT”脚本插入数据时，是否需要插入该字段的值。
73 *
74 * boolean updatable() default true;
75 * updatable属性表示在使用“UPDATE”脚本插入数据时，是否需要更新该字段的值。
76 * insertable和updatable属性一般多用于只读的属性，例如主键和外键等。这些字段的值通常是自动生成的。
77 *
78 * String columnDefinition() default "";
79 * columnDefinition属性表示创建表时，该字段创建的SQL语句，一般用于通过Entity生成表定义时使用。
80 *
81 * String table() default "";
82 * table属性表示当映射多个表时，指定表的表中的字段。默认值为主表的表名。
83 *
84 * int length() default 255;
85 * length属性表示字段的长度，当字段的类型为varchar时，该属性才有效，默认为255个字符。
86 *
87 * int precision() default 0;
88 * int scale() default 0;
89 * precision属性和scale属性表示精度，当字段类型为double时，precision表示数值的总长度，scale表示小数点所占的位数。
90 * }
91 *
92 *
93 *
94 * @Target({METHOD, FIELD}) @Retention(RUNTIME)
95 * public @interface Basic {
96 * FetchType fetch() default EAGER;
97 * 有两种加载方式，LAZY和EAGER。EAGER 表示即时加载、LAZY表示惰性加载。默认为即时加载
98 *
99 * boolean optional() default true;
100 * 属性optional表示属性是否可为null，不能用于Java基本数据类型byte，int，short，long，boolean，char，float，double的使用。
101 * }
102 */
103 @Basic(fetch=FetchType.EAGER)
104 @Column(length = 50,name="USER_CODING", nullable=false)
105 private String userCoding;// 用户编码
106
107 @Column(length = 50,name="USER_NAME", nullable=false)
108 private String userName;
109
110 /**
111 * 标注@Temporal注释来说明转化成java.util包中的类型。
112 * 默认为TemporalType.TIMESTAMP类型
113 * java.sql.Date日期型，精确到年月日，例如“2008-08-08”
114 * java.sql.Time时间型，精确到时分秒，例如“20:00:00”
115 * java.sql.Timestamp时间戳，精确到纳秒，例如“2008-08-08 20:00:00.000000001”
116 */
117 @Column(name="USER_BIRTHDAY")
118 @Temporal(TemporalType.DATE)
119 private Date userBirthday;// 用户生日
120
121 @Column(length = 50,name="IDCARD")
122 private String IDCard;// 身份证号码
123
124 /**
125 * 当容器加载实体时，将认为标注了@Transient注释的属性是非持久化的，将不会对应到表中的字段。
126 */
127 @Transient
128 private String userHomeplace;// 用户出生地（籍贯）
129
130 @Column(length = 25,name="USER_STATURE")
131 private String userStature;// 用户身高
132
133 @Column(length = 25,name="USER_AVOIRDUPOIS")
134 private String userAvoirdupois;// 用户体重
135
136 @Column(length = 25,name="USER_HEALTH_STATUS")
137 private String userHealthStatus;// 用户健康情况
138
139 @Column(length = 5, name="USER_MARRIAGE_STATUS")
140 private Integer userMarriageStatus;// 用户婚姻情况 未婚：0 已婚：1
141
142 @Column(length = 25, name="USER_HOMEPHONE")
143 private String userHomephone;// 用户固定电话
144
145 @Column(length = 25, name="USER_MOBILETELEPHONE")
146 private String userMobileTelephone;// 用户移动电话
147
148 @Column(length = 50,name="USER_EMAIL")
149 private String userEmail;// 用户电子邮箱
150
151 @Column(length = 50, name="USERD_WELLINGPLACE")
152 private String userDwellingPlace;// 用户住址
153
154 @Column(length = 10, name="USER_POST_CODING")
155 private String userPostCoding;// 用户邮政编码
156
157 @Column(length = 50, name="DEGREE")
158 private String degree;// 临时保存学历用
159
160 @Column(length = 50, name="JOIN_WORK_DATE")
161 private String joinworkdate; // 参加工作日期
162
163 /**
164 * @Lob适用于标注字段类型为Clob和Blob类型。
165 * Clob（Character Large Ojects）类型是长字符串类型，映射为实体中的类型可为char[]、Character[]、或者String类型。
166 * Blob（Binary Large Objects）类型是字节类型，映射为实体中的类型可为byte[]、Byte[]、或者实现了Serializable接口的类。
167 * 因为这两种类型的数据一般占用的内存空间比较大，所以通常使用惰性加载的方式，所以一般都要与@Basic标记同时使用，设置加载方式为FetchType.LAZY。
168 */
169 @Lob
170 @Column(name="USER_PHOTO")
171 @Basic(fetch=FetchType.LAZY)
172 private byte[] userPhoto;// 用户照片
173
174 //关联属性《一对一外键关联》一个user创建一个certificate
175 /**
176 * @Target({METHOD, FIELD}) @Retention(RUNTIME)
177 * public @interface OneToOne {
178 * Class targetEntity() default void.class;
179 * targetEntity属性表示默认关联的实体类型，默认为当前标注的实体类。例如使用默认设置与以下所示的设置的效果相同。一般情况使用默认设置就可以了。
180 *
181 * CascadeType[] cascade() default {};
182 * cascade属性表示与此实体一对一关联的实体的联级样式类型。联级样式是当对实体进行操作时策略，默认情况下，不关联任何操作。
183 *
184 * FetchType fetch() default EAGER;
185 * fetch属性是该实体的加载方式，默认为及时加载EAGER，也可以使用惰性加载LAZY。
186 *
187 * boolean optional() default true;
188 * optional属性表示关联的该实体是否能够存在null值。默认为true，表示可以存在null值。
189 * 如果设置为false，则该实体不能为null，并且要同时配合使用@JoinColumn标记，将保存实体关系的字段设置为唯一的unique=true、
190 * 不为nullnullable=false,并且不能更新的updatable=false。
191 *
192 * String mappedBy() default "";
193 * mappedBy属性用于双向关联实体时，标注在不保存关系的实体中
194 * }
195 *
196 *@Target({METHOD, FIELD}) @Retention(RUNTIME)
197 *public @interface JoinColumn {
198 * String name() default "";
199 * String referencedColumnName() default "";
200 * boolean unique() default false;
201 * boolean nullable() default true;
202 * boolean insertable() default true;
203 * boolean updatable() default true;
204 * String columnDefinition() default "";
205 * String table() default "";
206 *}
207 * 1.@JoinColumn与@Column标记一样，是用于注释表中的字段的。它的属性与@Column属性有很多相同之处
208 * 2.@JoinColumn注释的是保存表与表之间关系的字段，它要标注在实体属性上
209 * 3.与@Column标记一样，name属性是用来标识表中所对应的字段的名称。
210 * 4.OneToOne中name=关联表的名称+“_”+ 关联表主键的字段名
211 *
212 */
213 @OneToOne(cascade=CascadeType.ALL, fetch=FetchType.LAZY)
214 @JoinColumn(name="CERTIFICATE_MAKER",unique=true, nullable=false,updatable=false)
215 private Certificate certificate;
216
217 // 关联属性《多对一 多个user属于一个department和Nation》
218 /**
219 * @Target({METHOD, FIELD}) @Retention(RUNTIME)
220 * public @interface ManyToOne {
221 * Class targetEntity() default void.class;
222 * CascadeType[] cascade() default {};
223 * FetchType fetch() default EAGER;
224 * boolean optional() default true;
225 * }
226 */
227 @ManyToOne(cascade=CascadeType.ALL)
228 @JoinColumn(name="department_id")
229 private Department department;// 用户部门信息
230
231 @ManyToOne(cascade=CascadeType.ALL)
232 @JoinColumn(name="userNation_id")
233 private Nation userNation;// 用户的民族编码
234
235
236 // 关联属性《多对多》
237 /**
238 * @Target({METHOD, FIELD})
239 * public @interface JoinTable {
240 * String name() default "";
241 * name属性表示实体所对应表的名称,name属性为连接两个表的表名称。若不指定，则使用默认的表名称如下所示。“表名1”+“_”+“表名2”。
242 *
243 * String catalog() default "";
244 * String schema() default "";
245 * catalog和schema属性表示实体指定的目录名或是数据库名，这根据不同的数据库类型有所不同。
246 *
247 * JoinColumn[] joinColumns() default {};
248 * joinColumns属性表示，在保存关系中的表中，所保存关联关系的外键的字段。并配合@JoinColumn标记使用。
249 *
250 * JoinColumn[] inverseJoinColumns() default {};
251 * inverseJoinColumns属性与joinColumns属性类似，它保存的是保存关系的另一个外键字段。
252 *
253 * UniqueConstraint[] uniqueConstraints default {};
254 * uniqueConstraints属性表示该实体所关联的唯一约束条件，一个实体可以有多个唯一约束条件，默认没有约束条件。
255 * 若使用uniqueConstraints标记时，需要配合标记UniqueConstraint标记来使用。
256 * 例如：uniqueConstraints = {@UniqueConstraint(columnNames = { "name", "email" }),@UniqueConstraint(columnNames = { "col_1", "col_2" })}
257 * }
258 */
259 @ManyToMany(cascade=CascadeType.ALL)
260 @JoinTable(
261 name="re_user_item",
262 joinColumns={
263 @JoinColumn(name="user_id",referencedColumnName="id")
264 },
265 inverseJoinColumns={
266 @JoinColumn(name="item_id",referencedColumnName="id")
267 }
268 )
269 private Set<Item> items = new HashSet<Item>();// 用户可以参加的项目
270
271 public String getId() {
272 return id;
273 }
274
275 public void setId(String id) {
276 this.id = id;
277 }
278
279 public String getUserCoding() {
280 return userCoding;
281 }
282
283 public void setUserCoding(String userCoding) {
284 this.userCoding = userCoding;
285 }
286
287 public String getUserName() {
288 return userName;
289 }
290
291 public void setUserName(String userName) {
292 this.userName = userName;
293 }
294
295 public Date getUserBirthday() {
296 return userBirthday;
297 }
298
299 public void setUserBirthday(Date userBirthday) {
300 this.userBirthday = userBirthday;
301 }
302
303 public String getIDCard() {
304 return IDCard;
305 }
306
307 public void setIDCard(String card) {
308 IDCard = card;
309 }
310
311 public String getUserHomeplace() {
312 return userHomeplace;
313 }
314
315 public void setUserHomeplace(String userHomeplace) {
316 this.userHomeplace = userHomeplace;
317 }
318
319 public String getUserStature() {
320 return userStature;
321 }
322
323 public void setUserStature(String userStature) {
324 this.userStature = userStature;
325 }
326
327 public String getUserAvoirdupois() {
328 return userAvoirdupois;
329 }
330
331 public void setUserAvoirdupois(String userAvoirdupois) {
332 this.userAvoirdupois = userAvoirdupois;
333 }
334
335 public String getUserHealthStatus() {
336 return userHealthStatus;
337 }
338
339 public void setUserHealthStatus(String userHealthStatus) {
340 this.userHealthStatus = userHealthStatus;
341 }
342
343 public Integer getUserMarriageStatus() {
344 return userMarriageStatus;
345 }
346
347 public void setUserMarriageStatus(Integer userMarriageStatus) {
348 this.userMarriageStatus = userMarriageStatus;
349 }
350
351 public String getUserHomephone() {
352 return userHomephone;
353 }
354
355 public void setUserHomephone(String userHomephone) {
356 this.userHomephone = userHomephone;
357 }
358
359 public String getUserMobileTelephone() {
360 return userMobileTelephone;
361 }
362
363 public void setUserMobileTelephone(String userMobileTelephone) {
364 this.userMobileTelephone = userMobileTelephone;
365 }
366
367 public String getUserEmail() {
368 return userEmail;
369 }
370
371 public void setUserEmail(String userEmail) {
372 this.userEmail = userEmail;
373 }
374
375 public String getUserDwellingPlace() {
376 return userDwellingPlace;
377 }
378
379 public void setUserDwellingPlace(String userDwellingPlace) {
380 this.userDwellingPlace = userDwellingPlace;
381 }
382
383 public String getUserPostCoding() {
384 return userPostCoding;
385 }
386
387 public void setUserPostCoding(String userPostCoding) {
388 this.userPostCoding = userPostCoding;
389 }
390
391 public String getDegree() {
392 return degree;
393 }
394
395 public void setDegree(String degree) {
396 this.degree = degree;
397 }
398
399 public String getJoinworkdate() {
400 return joinworkdate;
401 }
402
403 public void setJoinworkdate(String joinworkdate) {
404 this.joinworkdate = joinworkdate;
405 }
406
407 public byte[] getUserPhoto() {
408 return userPhoto;
409 }
410
411 public void setUserPhoto(byte[] userPhoto) {
412 this.userPhoto = userPhoto;
413 }
414
415 public Certificate getCertificate() {
416 return certificate;
417 }
418
419 public void setCertificate(Certificate certificate) {
420 this.certificate = certificate;
421 }
422
423 public Department getDepartment() {
424 return department;
425 }
426
427 public void setDepartment(Department department) {
428 this.department = department;
429 }
430
431 public Nation getUserNation() {
432 return userNation;
433 }
434
435 public void setUserNation(Nation userNation) {
436 this.userNation = userNation;
437 }
438
439 public Set<Item> getItems() {
440 return items;
441 }
442
443 public void setItems(Set<Item> items) {
444 this.items = items;
445 }
446
447 }
448
Certificate.java
1 package com.test.bean;
2
3 import javax.persistence.Column;
4 import javax.persistence.Entity;
5 import javax.persistence.GeneratedValue;
6 import javax.persistence.Id;
7 import javax.persistence.OneToOne;
8 import javax.persistence.Table;
9
10 import org.hibernate.annotations.GenericGenerator;
11
12 /**
13 *<br> 文 件 名: Certificate.java
14 *<br> 创 建 人： zzn
15 *<br> 创建日期： Jul 7, 2010 3:41:45 PM
16 */
17 @Entity
18 @Table(name="certificate")
19 public class Certificate {
20
21 @Id
22 @GeneratedValue(generator = "system-uuid")
23 @GenericGenerator(name = "system-uuid", strategy = "uuid")
24 @Column(length=32)
25 private String id;
26
27 @Column(name="CERTIFICATE_NAME", length=100, nullable=false)
28 private String certificateName;// 证书名称
29
30 @Column(name="CERTIFICATE_CODE", length=100, nullable=false)
31 private String certificateCode;// 证书编号
32
33 @Column(name="VALID_DATE", length=50)
34 private String validDate;// 有效期;
35
36 @Column(name="MAKE_DATE", length=100)
37 private String makeDate;// 创建日期
38
39 @OneToOne(mappedBy = "certificate")
40 private User user;
41
42 public User getUser() {
43 return user;
44 }
45 public void setUser(User user) {
46 this.user = user;
47 }
48 public String getId() {
49 return id;
50 }
51 public void setId(String id) {
52 this.id = id;
53 }
54 public String getCertificateName() {
55 return certificateName;
56 }
57 public void setCertificateName(String certificateName) {
58 this.certificateName = certificateName;
59 }
60 public String getCertificateCode() {
61 return certificateCode;
62 }
63 public void setCertificateCode(String certificateCode) {
64 this.certificateCode = certificateCode;
65 }
66 public String getValidDate() {
67 return validDate;
68 }
69 public void setValidDate(String validDate) {
70 this.validDate = validDate;
71 }
72 public String getMakeDate() {
73 return makeDate;
74 }
75 public void setMakeDate(String makeDate) {
76 this.makeDate = makeDate;
77 }
78
79 }
80
Nation.java
1 package com.test.bean;
2
3 import java.util.HashSet;
4 import java.util.Set;
5
6 import javax.persistence.Column;
7 import javax.persistence.Entity;
8 import javax.persistence.GeneratedValue;
9 import javax.persistence.Id;
10 import javax.persistence.OneToMany;
11 import javax.persistence.Table;
12
13 import org.hibernate.annotations.GenericGenerator;
14
15 /**
16 *<br> 文 件 名: Nation.java
17 *<br> 创 建 人： zzn
18 *<br> 创建日期： Jul 7, 2010 3:41:34 PM
19 */
20 @Entity
21 @Table(name="nation")
22 public class Nation {
23
24 @Id
25 @GeneratedValue(generator = "system-uuid")
26 @GenericGenerator(name = "system-uuid", strategy = "uuid")
27 @Column(length=32)
28 private String id;
29
30 @Column(length=50,name="NATION_NAME")
31 private String nationName;// 民族名称
32
33 /**
34 * 如果使用了List集合,可以同时配合注释@OrderBy使查询出来的集合类按照一定的顺序排列
35 * 例如：@OrderBy("id ASC，postcode DESC")postcode是属性
36 * @OneToMany(mappedBy="customer")
37 * @OrderBy("postcode ASC")
38 * public List<AddressEO> getAddresses() {
39 * return addresses;
40 * }
41 *
42 * 如果使用了Map集合，可以同时配合注释@MapKey指定Map中存放的key值。
43 * 如：@MapKey(name="id")将AddressEO中的属性id作为key值保存在Map中。
44 * @OneToMany(mappedBy="customer")
45 * @MapKey(name="id")
46 * public Map<Integer, AddressEO> getAddresses() {
47 * return addresses;
48 * }
49 */
50 @OneToMany(mappedBy="userNation")
51 private Set<User> user = new HashSet<User>();
52
53 @Override
54 public int hashCode() {
55 final int PRIME = 31;
56 int result = 1;
57 result = PRIME * result + ((id == null) ? 0 : id.hashCode());
58 result = PRIME * result + ((nationName == null) ? 0 : nationName.hashCode());
59 return result;
60 }
61
62 @Override
63 public boolean equals(Object obj) {
64 if (this == obj)
65 return true;
66 if (obj == null)
67 return false;
68 if (getClass() != obj.getClass())
69 return false;
70 final Nation other = (Nation) obj;
71 if (id == null) {
72 if (other.id != null)
73 return false;
74 } else if (!id.equals(other.id))
75 return false;
76 if (nationName == null) {
77 if (other.nationName != null)
78 return false;
79 } else if (!nationName.equals(other.nationName))
80 return false;
81 return true;
82 }
83
84 public String getId() {
85 return id;
86 }
87
88 public void setId(String id) {
89 this.id = id;
90 }
91
92 public String getNationName() {
93 return nationName;
94 }
95
96 public void setNationName(String nationName) {
97 this.nationName = nationName;
98 }
99
100 public Set<User> getUser() {
101 return user;
102 }
103
104 public void setUser(Set<User> user) {
105 this.user = user;
106 }
107
108
109 }
110
Department.java
1 package com.test.bean;
2
3 import java.util.Date;
4 import java.util.HashSet;
5 import java.util.Set;
6
7 import javax.persistence.Column;
8 import javax.persistence.Entity;
9 import javax.persistence.GeneratedValue;
10 import javax.persistence.Id;
11 import javax.persistence.OneToMany;
12 import javax.persistence.Table;
13 import javax.persistence.Temporal;
14 import javax.persistence.TemporalType;
15
16 import org.hibernate.annotations.GenericGenerator;
17
18
19 /**
20 *<br> 文 件 名: Department.java
21 *<br> 创 建 人： zzn
22 *<br> 创建日期： Jul 7, 2010 1:08:09 PM
23 */
24 @Entity
25 @Table(name="DEPARTMENTS")
26 public class Department {
27
28 @Id
29 @GeneratedValue(generator = "system-uuid")
30 @GenericGenerator(name = "system-uuid", strategy = "uuid")
31 @Column(length=32)
32 private String id;
33
34 @Column(name="CREATE_TIME")
35 @Temporal(TemporalType.DATE)
36 private Date createTime; //创建时间
37
38 @Column(name="DEPARTMENT_NAME", length=100)
39 private String departmentName;// 部门名称
40
41 @Column(name="DEPARTMENT_CODING", length=100)
42 private String departmentCoding;// 部门编号
43
44 @Column(name="DEPARTMENT_MANAGER", length=100)
45 private String departmentManager;// 部门经理
46
47 @Column(name="DEPARTMEN_TTELEPHONE", length=50)
48 private String departmentTelephone;// 联系电话
49
50 @Column(name="DEPARTMENT_FOUNCTION_DESC", length=1000)
51 private String departmentFounctionDesc;// 部门职能描述
52
53 @Column(name="LINK_MAN", length=25)
54 private String linkMan;// 培训联系人
55
56 /**
57 * @Target({METHOD, FIELD}) @Retention(RUNTIME)
58 * public @interface OneToMany {
59 * Class targetEntity() default void.class;
60 * targetEntity属性表示默认关联的实体类型。因为一对多的实体集合时保存在集合类中，所以必须指明集合类中保存的具体类型。
61 * 1/指定集合泛型的具体类型;2/指定targetEntity属性类型
62 * 1.本例；2.@OneToMany(targetEntity=User.class,cascade = CascadeType.ALL)
63 *
64 * CascadeType[] cascade() default {};
65 * cascade属性表示与此实体一对多关联的实体的联级样式类型。联级样式是当对实体进行操作时策略，默认情况下，不关联任何操作。
66 * 本例：当删除Department时会同时删除所有的User
67 *
68 * FetchType fetch() default LAZY;
69 * fetch属性默认为惰性加载LAZY的，本例：加载Department延迟加载User
70 *
71 * String mappedBy() default "";
72 * mappedBy属性只有在实体间双向关联时使用。
73 * mappedBy属性的值为User实体中所引用的department实体的属性名
74 * }
75 */
76 @OneToMany(mappedBy="department")
77 private Set<User> userInfos = new HashSet<User>();// 部门成员信息
78
79 // private Department fatherDepartment;// 上级直属部门
80
81 // private Set<Department> departments = new HashSet<Department>();// 所包含部门
82
83 // private Set<String> parentsId = new HashSet<String>();//父部门id
84
85 public String getId() {
86 return id;
87 }
88 public void setId(String id) {
89 this.id = id;
90 }
91 public Date getCreateTime() {
92 return createTime;
93 }
94 public void setCreateTime(Date createTime) {
95 this.createTime = createTime;
96 }
97 public String getDepartmentName() {
98 return departmentName;
99 }
100 public void setDepartmentName(String departmentName) {
101 this.departmentName = departmentName;
102 }
103 public String getDepartmentCoding() {
104 return departmentCoding;
105 }
106 public void setDepartmentCoding(String departmentCoding) {
107 this.departmentCoding = departmentCoding;
108 }
109 public String getDepartmentManager() {
110 return departmentManager;
111 }
112 public void setDepartmentManager(String departmentManager) {
113 this.departmentManager = departmentManager;
114 }
115 public String getDepartmentTelephone() {
116 return departmentTelephone;
117 }
118 public void setDepartmentTelephone(String departmentTelephone) {
119 this.departmentTelephone = departmentTelephone;
120 }
121 public String getDepartmentFounctionDesc() {
122 return departmentFounctionDesc;
123 }
124 public void setDepartmentFounctionDesc(String departmentFounctionDesc) {
125 this.departmentFounctionDesc = departmentFounctionDesc;
126 }
127 public String getLinkMan() {
128 return linkMan;
129 }
130 public void setLinkMan(String linkMan) {
131 this.linkMan = linkMan;
132 }
133 public void setUserInfos(Set<User> userInfos) {
134 this.userInfos = userInfos;
135 }
136 public Set<User> getUserInfos() {
137 return userInfos;
138 }
139 // public Department getFatherDepartment() {
140 // return fatherDepartment;
141 // }
142 // public void setFatherDepartment(Department fatherDepartment) {
143 // this.fatherDepartment = fatherDepartment;
144 // }
145 // public Set<Department> getDepartments() {
146 // return departments;
147 // }
148 // public Set<String> getParentsId() {
149 // return parentsId;
150 // }
151 // public void setDepartments(Set<Department> departments) {
152 // this.departments = departments;
153 // }
154 // public void setParentsId(Set<String> parentsId) {
155 // this.parentsId = parentsId;
156 // }
157
158 }
159
Item.java
1 package com.test.bean;
2
3 import java.util.Date;
4 import java.util.HashSet;
5 import java.util.Set;
6
7 import javax.persistence.Column;
8 import javax.persistence.Entity;
9 import javax.persistence.EnumType;
10 import javax.persistence.Enumerated;
11 import javax.persistence.GeneratedValue;
12 import javax.persistence.Id;
13 import javax.persistence.ManyToMany;
14 import javax.persistence.Table;
15 import javax.persistence.Temporal;
16 import javax.persistence.TemporalType;
17
18 import org.hibernate.annotations.GenericGenerator;
19
20 /**
21 *<br> 文 件 名: Item.java
22 *<br> 创 建 人： zzn
23 *<br> 创建日期： Jul 7, 2010 3:42:30 PM
24 */
25 @Entity
26 @Table(name="item")
27 public class Item {
28
29 @Id
30 @GeneratedValue(generator = "system-uuid")
31 @GenericGenerator(name = "system-uuid", strategy = "uuid")
32 @Column(length=32)
33 private String id;
34
35 @Column(name="ITEM_NUMBER", length=100)
36 private String itemNumber; /* 项目_编号 */
37
38 @Column(name="ITEM_NAME", length=100)
39 private String name; /* 项目名称 */
40
41 @Column(name="TYPE", length=10)
42 private String type; /* 所含类型 */ //1.外送 2.内部 3.在岗辅导 4.在线学习 5.学历与进修
43
44 @Temporal(TemporalType.DATE)
45 @Column(name="START_TIME")
46 private Date startTime; /* 开始时间 */
47
48 @Temporal(TemporalType.DATE)
49 @Column(name="END_TIME")
50 private Date endTime; /* 结束时间 */
51
52 @Temporal(TemporalType.DATE)
53 @Column(name="EDIT_TIME")
54 private Date editTime; /* 编辑时间 */
55
56 @Column(name="ITEM_TIME", length=10)
57 private Integer item_time; /*项目学时*/
58
59 @Column(name="CREDIT_HOUR", length=10)
60 private Integer creditHour;/* 获得学分 */
61
62 @Column(name="TRAIN_MANAGER", length=10)
63 private String trainManager; /* 培训经理 */
64
65 @Column(name="ITEM_TARGER", length=1000)
66 private String itemTarget; /* 项目目标 */
67
68 @Column(name="TRAINING_ADDRESS", length=200)
69 private String trainingAddress; //培训地址
70
71 @Column(name="REMARK", length=1000)
72 private String remark;//备注
73
74 @Column(name="ITEM_STATUS", length=20)
75 @Enumerated(EnumType.STRING)
76 private String status;
77
78 //项目状态
79 public enum itemStatus{
80 未开始,运行中,关闭
81 }
82
83 @Column(name="ITEM_PROPERTY", length=20)
84 @Enumerated(EnumType.STRING)
85 private String property;
86
87 public enum itemProperty{
88 新员工类,岗前培训类,定岗或转正培训类,绩效提升类,晋升类
89 }
90
91 @ManyToMany(mappedBy="items")
92 private Set<User> userId = new HashSet<User>(); // 针对选修项目,指定可以参与该项目的用户
93
94 // private Department depaId;//所属部门;项目（n）-->部门（1）(单向)
95
96 // private Set<Certificate> certificates;//项目颁发的证书
97
98 public String getId() {
99 return id;
100 }
101 public void setId(String id) {
102 this.id = id;
103 }
104 public String getItemNumber() {
105 return itemNumber;
106 }
107 public void setItemNumber(String itemNumber) {
108 this.itemNumber = itemNumber;
109 }
110 public String getName() {
111 return name;
112 }
113 public void setName(String name) {
114 this.name = name;
115 }
116 public String getType() {
117 return type;
118 }
119 public void setType(String type) {
120 this.type = type;
121 }
122 public Date getStartTime() {
123 return startTime;
124 }
125 public void setStartTime(Date startTime) {
126 this.startTime = startTime;
127 }
128 public Date getEndTime() {
129 return endTime;
130 }
131 public void setEndTime(Date endTime) {
132 this.endTime = endTime;
133 }
134 public Date getEditTime() {
135 return editTime;
136 }
137 public void setEditTime(Date editTime) {
138 this.editTime = editTime;
139 }
140 public Integer getItem_time() {
141 return item_time;
142 }
143 public void setItem_time(Integer item_time) {
144 this.item_time = item_time;
145 }
146 public Integer getCreditHour() {
147 return creditHour;
148 }
149 public void setCreditHour(Integer creditHour) {
150 this.creditHour = creditHour;
151 }
152 public String getTrainManager() {
153 return trainManager;
154 }
155 public void setTrainManager(String trainManager) {
156 this.trainManager = trainManager;
157 }
158 public Set<User> getUserId() {
159 return userId;
160 }
161 public void setUserId(Set<User> userId) {
162 this.userId = userId;
163 }
164 public String getItemTarget() {
165 return itemTarget;
166 }
167 public void setItemTarget(String itemTarget) {
168 this.itemTarget = itemTarget;
169 }
170 public String getTrainingAddress() {
171 return trainingAddress;
172 }
173 public void setTrainingAddress(String trainingAddress) {
174 this.trainingAddress = trainingAddress;
175 }
176 public String getRemark() {
177 return remark;
178 }
179 public void setRemark(String remark) {
180 this.remark = remark;
181 }
182 // public Department getDepaId() {
183 // return depaId;
184 // }
185 // public void setDepaId(Department depaId) {
186 // this.depaId = depaId;
187 // }
188 public String getProperty() {
189 return property;
190 }
191 public void setProperty(String property) {
192 this.property = property;
193 }
194 public String getStatus() {
195 return status;
196 }
197 public void setStatus(String status) {
198 this.status = status;
199 }
200
201 // public Set<Certificate> getCertificates() {
202 // return certificates;
203 // }
204 // public void setCertificates(Set<Certificate> certificates) {
205 // this.certificates = certificates;
206 // }
207 }
208
Resource.java
1 package com.test.bean;
2
3 import java.io.Serializable;
4
5 import javax.persistence.Column;
6 import javax.persistence.GeneratedValue;
7 import javax.persistence.Id;
8
9 import org.hibernate.annotations.GenericGenerator;
10
11 /**
12 *<br> 文 件 名: Resources.java
13 *<br> 创 建 人： zzn
14 *<br> 创建日期： Jul 14, 2010 10:15:39 AM
15 */
16
17 /**
18 *####################################################################################################################################
19 * 1.继承关系的实体保存在一个表（Single Table per Class Hierarchy Strategy）
20 * 建议：这种方法虽然只有一个表，但是会出现很多的null值，所以不建议使用
21 * 继承关系的实体中，所有的实体类都映射到一个表中，表中使用一个特殊的标识字段（discriminator column），来标识一条记录属于那个子类。
22 * 如：
23 * @Entity
24 * 使用@Entity注释，标识该类以及所有的子类都映射到指定的表中，如果不标注，也可使用默认值。
25 *
26 * @Table(name = "Resource")
27 *
28 * @Inheritance(strategy=InheritanceType.SINGLE_TABLE)
29 * 使用@Inheritance注释，标识该类的子类继承映射的方式,InheritanceType有三种类型,三种类型定义为常量，默认为SINGLE_TABLE。
30 * public enum InheritanceType{ SINGLE_TABLE, JOINED, TABLE_PER_CLASS };
31 * SINGLE_TABLE表示继承关系的实体保存在一个表；JOINED表示每个实体子类保存在一个表；TABLE_PER_CLASS表示每个实体类保存在一个表
32 *
33 * @DiscriminatorColumn(name="resource_type",discriminatorType=DiscriminatorType.STRING)
34 * 使用@DiscriminatorColumn注释，标识改继承层次上所区别每个实体的类型字段。
35 * @Target({TYPE}) @Retention(RUNTIME)
36 * public @interface DiscriminatorColumn {
37 * String name() default "DTYPE";
38 * DiscriminatorType discriminatorType() default STRING;
39 * String columnDefinition() default "";
40 * int length() default 31;
41 * }
42 * 注意：
43 * 1.@DiscriminatorColumn只能标注在顶层的类中，而不能标注在子类中。
44 * 2.@DiscriminatorColumn只在继承策略为“SINGLE_TABLE”和“JOINED”时使用。
45 * 3.name属性表示所标识具体类型的字段名称，默认为“DTYPE”
46 * 4.discriminatorType属性表示标识值的类型，默认为STRING字符串。public enum DiscriminatorType { STRING, CHAR, INTEGER };
47 * 5.columnDefinition属性表示生成字段的DDL语句，与@Column中的columnDefinition属性类似。
48 * 6.length属性表示为标识值的长度，默认为31。该属性只在使用DiscriminatorType. STRING时才需要设置。
49 *
50 * @DiscriminatorValue("resource")
51 * 使用@DiscriminatorValue注释，标注该实体类所实体标识字段的值.value的值表示所该实体的标注值。
52 * 如 @DiscriminatorValue("courseware")表示 标识字段resource_type的值为courseware是，可以认为是Courseware实体
53 *####################################################################################################################################
54 * 2.每个子类实体保存在一个表（Joined Subclass Strategy）
55 * 所有实体类的基类保存在一个表中，每增加一个子类增加一个映射子类的表。子类的表与父类中的通过主键（Primary Key）来关联。类似父类与子类之间是一对一的关系映射。
56 * 如：
57 * @Entity
58 * @Table(name = "Resource")
59 * @Inheritance(strategy=InheritanceType.JOINED)
60 * @DiscriminatorColumn(name="resource_type",discriminatorType=DiscriminatorType.STRING)
61 * @DiscriminatorValue("resource")
62 * 注意：这种用的比较多。采用每个实体类保存在一个表的继承策略，虽然避免了表中大量null值的数据，但每个实体是通过关联来获得的。
63 * 当有多个子类时，进行大量的查询会耗时很大，所以采取此策略时需要注意这些问题。
64 *#####################################################################################################################################
65 * 3.每个实体类保存在一个表（Table per Class Strategy）
66 * 每个实体都保存为一个表中，每个表中都包含实体类的所有属性（父类的和子类的）。
67 * @Entity
68 * @Table(name = "Resource")
69 * @Inheritance(strategy = InheritanceType.TABLE_PER_CLASS)
70 * @TableGenerator(
71 * name = "employee_gen",
72 * able = "tb_generator",
73 * pkColumnName = "gen_name",
74 * valueColumnName = "gen_value",
75 * pkColumnValue = "employee_id",
76 * allocationSize = 1)
77 */
78 public class Resource implements Serializable{
79 private static final long serialVersionUID = 8763866117518530428L;
80 @Id
81 @GeneratedValue(generator="system-uuid")
82 @GenericGenerator(name="system-uuid", strategy="uuid")
83 @Column(length=32)
84 private String id;
85
86 @Column(length = 50,name="NAME", nullable=false)
87 private String name; //名称
88
89 @Column(length = 50,name="resNumber")
90 private String resNumber; //编号
91
92 @Column(length = 1000,name="description")
93 private String description; //描述
94
95 public String getId() {
96 return id;
97 }
98
99 public void setId(String id) {
100 this.id = id;
101 }
102
103 public String getName() {
104 return name;
105 }
106
107 public void setName(String name) {
108 this.name = name;
109 }
110
111 public String getResNumber() {
112 return resNumber;
113 }
114
115 public void setResNumber(String resNumber) {
116 this.resNumber = resNumber;
117 }
118
119 public String getDescription() {
120 return description;
121 }
122
123 public void setDescription(String description) {
124 this.description = description;
125 }
126
127
128
129 }
130
Courseware.java
1 package com.test.bean;
2
3 import java.io.Serializable;
4
5 import javax.persistence.Column;
6
7 /**
8 *<br> 文 件 名: Courseware.java
9 *<br> 创 建 人： zzn
10 *<br> 创建日期： Jul 14, 2010 10:43:05 AM
11 */
12 /**
13 * 1.继承关系的实体保存在一个表
14 * @Entity
15 * @DiscriminatorValue("courseware")
16 *
17 * 2.每个子类实体保存在一个表
18 * @Entity
19 * @Table(name = "courseware_resource")
20 * @DiscriminatorValue("courseware")
21 * @PrimaryKeyJoinColumn(name="id")
22 *
23 * 3.每个实体类保存在一个表
24 * @Entity
25 * @Table(name = "courseware")
26 *
27 */
28
29 public class Courseware extends Resource implements Serializable {
30 private static final long serialVersionUID = 5859492207003397084L;
31
32 /**
33 * 如果是1.继承关系的实体保存在一个表，id用的是父类的id
34 * 如果是2.每个子类实体保存在一个表，主键关联
35 *
36 */
37 //private String id;
38
39 @Column(name="courseTime")
40 private Integer courseTime; //学时
41
42 @Column(name="coursePoint")
43 private Integer coursePoint; //学分
44
45 @Column(name="aim", length=1000)
46 private String aim; //目标
47
48 // @Override
49 // public String getId() {
50 // return id;
51 // }
52 //
53 // @Override
54 // public void setId(String id) {
55 // this.id = id;
56 // }
57
58 public Integer getCourseTime() {
59 return courseTime;
60 }
61
62 public void setCourseTime(Integer courseTime) {
63 this.courseTime = courseTime;
64 }
65
66 public Integer getCoursePoint() {
67 return coursePoint;
68 }
69
70 public void setCoursePoint(Integer coursePoint) {
71 this.coursePoint = coursePoint;
72 }
73
74 public String getAim() {
75 return aim;
76 }
77
78 public void setAim(String aim) {
79 this.aim = aim;
80 }
81
82 }
83
参考资料：
http://blog.csdn.net/EJB_JPA/archive/2008/05.aspx