hibernate 注解方式实现复合主键 有时一个实体的主键可能同时为多个，例如同样是之前使用的“CustomerEO”实体，需要通过name 和 email 来查找指定实体，当且仅当name 和email 的值完全相同时，才认为是相同的实体对象。要配置这样的复合主键，步骤如以下所示。
（1）编写一个复合主键的类CustomerPK ，代码如下。 CustomerPK.java
双击代码全选
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 import java.io.Serializable;
public class CustomerPK implements Serializable {
public CustomerPK() {
}
public CustomerPK(String name, String email) {
https://www.doczj.com/doc/4018247316.html, = name; this.email = email; }
private String email;
public String getEmail() {
return email; }
public void setEmail(String email) { this.email = email; }
private String name;
public String getName() {
return name; }
public void setName(String name) { https://www.doczj.com/doc/4018247316.html, = name;
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65 }
@Override
public int hashCode() {
final int PRIME = 31;
int result = 1;
result = PRIME * result
+ ((email == null) ? 0 : email.hashCode());
result = PRIME * result + ((name == null) ? 0 : name.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() !=
obj.getClass())
return false;
final CustomerPK other = (CustomerPK) obj;
if (email == null) {
if (other.email != null)
return false;
} else if
(!email.equals(other.email))
return false;
if (name == null) {
if (https://www.doczj.com/doc/4018247316.html, != null)
return false;
} else if
(!name.equals(https://www.doczj.com/doc/4018247316.html,))
return
false;
return true;
}
}
作为符合主键类，要满足以下几点要求。
l 必须实现Serializable 接口。
l 必须有默认的public 无参数的构造方法。
l 必须覆盖equals 和hashCode 方法。equals 方法用于判断两个对象是否相同，EntityManger 通过find 方法来查找Entity 时，是根据equals 的返回值来判断的。本例中，只有对象的name 和email 值完全相同时或同一个对象时则返回true ，否则返回false 。 hashCode 方法返回当前对象的哈希码，生成的hashCode 相同的概率越小越好，算法可以进行优化。
（2）通过 @IdClass 注释在实体中标注复合主键，实体代码如下。
双击代码全选
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 @Entity
@Table(name = "customer")
@IdClass(CustomerPK.class)
public class CustomerEO implements java.io.Serializable {
private Integer id;
public Integer getId() {
return this.id;
}
public void setId(Integer id) {
this.id = id;
}
private String name;
@Id
public String getName() {
return https://www.doczj.com/doc/4018247316.html,;
}
public void setName(String name) { https://www.doczj.com/doc/4018247316.html, = name;
25 26 27 28 29 30 31 32 33 34 35 36
}
private String email; @Id
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
} 标注复合主键时需要注意以下几个问题。
l @IdClass 标注用于标注实体所使用主键规则的类。它的定义如下所示。
1 2 3 4 @Target({TYPE}) @Retention(RUNTIME)
public @interface IdClass {
Class value();
}
属性Class 表示符合主键所使用的类，本例中使用CustomerPK 这个复合主键类。
l 在实体中同时标注主键的属性。本例中在email 和name 的getter 方法前标注@Id ，表示符合主键使用这两个属性。
（3）这样 定义实体的复合主键后，通过以下代码便可以获得指定的实体对象：
1 2 CustomerPK cpk = new
CustomerPK("Janet","janetvsfei@https://www.doczj.com/doc/4018247316.html,");
CustomerEO instance = entityManager.find(CustomerEO.class, cpk);
spring4.x + hibernate4.x 配置详解 关于spring和hibernate的使用以及特征等等，在此不再啰嗦，相信大家也都知道，或者去搜索一下即可。 本篇博文的内容主要是我最近整理的关于spring4.x 和hibernate 4.x 相关配置和使用方式，当然spring3.x以及hibernate4.x也可以借鉴。 首先是配置文件web.xml 增加以下代码即可
https://www.doczj.com/doc/4018247316.html,/cnbxj/blog/item/810acd01ca716b0d1c95837c.html Hibernate JPA标记学习 1.@Entity 通过注释@Entity或者（@Entity()）表示被标示的类对应数据库中的一张表。 } @Entity public class TravelProfile { ... } 上面的例子告诉O/R映射引擎，类TravelProfile是可以持久化的，同时它对应数据库中的一张表。但是它没有指明对应哪个数据库中的哪张表。 2.元数据映射标记 2.1 @Table @Table()标记为实体初始化一张表，定义如下： @Target({TYPE}) @Retention(RUNTIME) public @interface Table { String name() default ""; String catalog() default ""; String schema() default ""; UniqueConstraint[] uniqueConstraints() default {}; } Name:指明表的名字。（可选） Catalog:表示表的catalog.（可选） Schema:表示表的schema.（可选） uniqueConstraints:制定表的唯一约束。（可选） 因为所有的属性都是可选的，也就是说@Table可以在进行映射的时候可以不标明。当不标明的情况下表的名字就是实体的类名。表属于的schema就是所属实体单元集的schema（就是当前连接数据库的用户）。 下面给出的例子中，指明表为CUST,所属的schema为RECORDS： @Entity @Table(name="CUST", schema="RECORDS") public class Customer { ... } 2.2 @UniqueConstraint标记 @UniqueConstraint用来指定表字段的唯一约束，定义如下： @Target({}) @Retention(RUNTIME) public @interface UniqueConstraint { String[] columnNames(); } columnNames：制定唯一约束的字段。 @Entity @Table(
SpringMVC框架搭建说明 Spring4.1.4 + hibernate4.3.8 1、web.xml配置 程序运行时从web.xml开始，加载顺序为：context-param -> listener -> filter ->structs (如果使用structs的话)-> servlet 如下为web.xml的配置说明
hibernate数据持久化组件 1.基本概念: 1）对象持久化:把数据保存在永久的存储介质中（数据库）。 2）ORM（object relation mapping）对象关系映射。 3）POJO（PlainOldJavaObject）类是标准的Java Bean。PO持久化对象用于插入数据时候所使用POJO对象,BO业务对象,VO值对象 4）Hibernate就是一个可以自动的根据xml完成对象关系映射，并持久化到数据库的开源组件,底层也是由JDBC实现的。通过xml文件的配置，对数据库的底层的方言，以及数据库连接所需的信息，以及连接数据库的驱动。 5）hibernate的系统配置文件的名字一般叫做hibernate.cfg.xml，一般是映射类名.hbm.xml。一般将映射类的xml文件和实体类放在一起。 a）对象映射元文件: hibernate的映射类的XXXX.hbm.xml的写法（XXX一般跟所对应的POJO类的类名相同）
第一次课： 持久化：就是把瞬时状态的数据转变为持久化状态的数据，这一个过程就是持久化。 （java中内存分为：栈（变量，方法，形参都是在栈上），堆（new出来的对象在堆上）） 1）瞬时状态：刚new出来，在内存中存在的对象就是瞬时状态的。如果程序结束，对象就会被回收。 2）持久化状态：在磁盘或者是数据库中存在的数据就是持久状态。 Hibernate是什么？ 1）是一个优秀的持久化框架，对jdbc进行进一步的封装。（hibernate，ibatis ）。 2）是一个ORM (Object relation mapping ). Mysql,oracle,access 是关系型数据库 = hibernate操作的是对象。 使用hibernate的步骤：1）新建项目 2）引入jar包（hibernate最少依赖8个jar包） 3）新建 hibernate配置文件（hibernate.cfg.xml） ,放在src根目录下面。 用于数据库的配置信息。
**学院课程考试试卷课程名称：《Hibernate:使用Hibernate&EJB开发持久层企业及应用》（A）卷 年级：班级： 姓名：_______________ 学号：_________________ 考试(考查) 闭卷 题号1-20 21-40 41-50 总分 分数 选择题（每题2分，共计100分） 1. 一个持久化类的实例可能存在的状态有（）。[选三项] A．瞬态 B．持久态 C．隔离态 D．游离态 2. 面向对象概念中的对象与面向关系概念中的（）相对应。 A．表 B．表的行 C．表的列 D．表中行的数据 3. 下面说法正确的是（）。[选三项] A．Hibernate是一个开放源代码的对象关系映射框架 B．Hibernate是对JDBC进行了轻量级的对象封装 C．Hibernate可以大大减少操作数据库的工作量 D．Hibernate提供了数据查询机制，但没有提供恢复机制 4. JDBC编程的缺点（ acd）。[选三项] A．实现业务逻辑的代码和数据库访问代码掺杂在一起， 使程序结构不清晰，可读性差 B．在程序代码中嵌入面向关系的SQL语句，使开发人员 能完全运用面向对象的思维来编写程序 C．业务逻辑和关系数据模型绑定，如果关系数据模型发 生变化，例如修改了CUSTOMERS表的结构，那么必须手工修 改程序代码中所有相关的SQL语句，这增加了维护软件的难度 D．如果程序代码中的SQL语句包含语法错误，在编译时不 能检查这种错误，只有在运行时才能发现这种错误，这增加了 调试程序的难度
-------------------------------------- 装-------------------------------------- 订------------------------------线 ---------------------------------------- 5. Hibernate 映射文件中
3. hibernate.hbm2ddl.auto : 在SessionFactory 创建时，自动检查数据库结构，或者将数据库schema 的DDL 导出到数据库。使用create-drop 时，在显式关闭SessionFactory 时，将删除掉数据库schema。 例如：validate | update | create | create-drop create :如果没有表就创建 update ：如果表结构更新，就更新 validate ：每次插入表的时候看看表结构有没有更新。 理论上是先建类后建表：这个时候只要你的类建好了，可以跨数据库。 实际中先建表比先建类多，建好表以后要对数据库进行优化，比如建索引，建试图，各种各样的优化。 project\etc目录下面有很多示例性的文档，log4j的文档就在那个下面。 SessionFactory sessionFactory = new AnnotationConfiguration().configure().buildSessionFactory(); SessionFactory的建立是很耗费时间的，应该像连接池一样，只建立一次，以后要用就直接从那用。 Hibernate文档建议我们自己写一个辅助类，用单例来做。 JUnit的一个bug： @BeforeClass public static void beforeClass() { sessionFactory = new AnnotationConfiguration().configure().buildSessionFactory(); } 在这句话的时候 配置文件如果有的时候写错了，她悄悄把错误隐藏起来了。 解决的方法:可以对这句话加try catch块 8.表名和类名不一致的时候： @Entity @Table(name="_teacher")
注解整理笔记 @是java中的注解。 JPA全称Java Persistence API.JPA通过JDK 5.0注解或XML描述对象－关系表的映射关系，并将运行期的实体对象持久化到数据库中。 1@SuppressWarnings("serial") 实体类注解例子 2@Entity 3@Table(name = "T_BASE_ROLE") 5@Cache(usage = CacheConcurrencyStrategy.NONSTRICT_READ_WRITE, region = CacheConstants.HIBERNATE_CACHE_BASE) //jackson标记不生成json对象的属性 4@JsonIgnoreProperties (value = { "hibernateLazyInitializer" , "handler","fieldHandler" ,"resources","users"}) public class Role extends BaseEntity implements Serializable { 6@Id 7@GeneratedV alue(strategy = GenerationType.AUTO) 8@Column(name = "ID") public Long getId() { return id;} @Excel(exportName="记录创建者", exportFieldWidth = 30) protected String createUser; 9@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+08:00") @Column(name = "CREATE_TIME", updatable = false) 10@Temporal(TemporalType.TIMESTAMP) public Date getCreateTime() { return createTime;} 11@ManyToMany(cascade = {CascadeType.PERSIST, CascadeType.MERGE}, fetch = https://www.doczj.com/doc/4018247316.html,ZY) 12@JoinTable(name = "T_BASE_ROLE_RESOURCE", joinColumns = { @JoinColumn(name = "ROLE_ID") }, inverseJoinColumns = { @JoinColumn(name = "RESOURCE_ID") }) 13@OrderBy("id") public List
整合SSH框架 整合框架版本：hibernate-distribution-3.6.0.Final-dist + spring-framework-2.5.6.SEC01-with-dependencies + struts-2.1.8.1 一、搭建工具 Windows 、Tomcat 6.0+ 、MyEclipse、SQLServer2008 R2 、Google 二、创建工程 新建WEB项目工程（MyEclipse），包含web.xml配置文件。 三、添加框架环境Junit4 右击新建的项目，选择Build Path —> Add Library —> Junit —> 选择Junit4 —> 确定完成单元测试的添加。 四、添加框架环境Struts2 1.解压struts- 2.1.8.1 ，如下图所示： 可在apps文件里，随机选择一个.war文件解压，到WEB-INF→lib下的基础jar文件：
复制黏贴添加到项目工程的lib下。也可将lib下的全部jar（71个）都复制到项目中来，不过很多用不到。我们崇尚即用即加的原则…… 2. 配置struts.xml和web.xml文件，如下： web.xml:
一．Hibernate的流程 1．开发数据库，建立数据库表 2．通过DB Browser配置数据库连接 3．添加Hibernate的支持 （1）添加hibernate需要的jar包到WEB-INF/lib下 （2）添加hibernate.cfg.xml配置文件 （3）添加了HibernateSessionFactory.java类（session工厂类，用来产生session）4．映射表 （1）添加PO持久化类如：https://www.doczj.com/doc/4018247316.html,er.java （2）添加了持久化类和关系表对应配置文件如：User.hbm.xml（映射了类和表、属性和列之间对应，主键生成方式） 5．编写业务接口及实现类 6．编写测试类进行测试 二．Hibernate的基本配置 1．hibernate.cfg.xml
Hibernate Annotation 使用hibernate Annotation来映射实体 准备工作 下载 hibernate-distribution-3.3.2.GA hibernate-annotations-3.4.0.GA slf4j 导入相关依赖包 Hibernate HOME： \hibernate3.jar \lib\bytecode（二进制） \lib\optional（可选的） \lib\required（必须的） 导入required下的所有jar包 antlr-2.7.6.jar commons-collections-3.1.jar dom4j-1.6.1.jar hibernate3.jar javassist-3.9.0.GA.jar jta-1.1.jar slf4j-api-1.5.10.jar slf4j-log4j12-1.5.10.jar log4j-1.2.14.jar mysql.jar ---Annotation包 ejb3-persistence.jar hibernate-annotations.jar hibernate-commons-annotations.jar
简单的例子，通过annotation注解来映射实体PO 1、建立（Java Project）项目：hibernate_0100_annotation_HelloWorld_default 2、在项目根下建立lib目录 a)导入相关依赖jar包 antlr-2.7.6.jar commons-collections-3.1.jar dom4j-1.6.1.jar ejb3-persistence.jar hibernate-annotations.jar hibernate-commons-annotations.jar hibernate3.jar javassist-3.9.0.GA.jar jta-1.1.jar log4j-1.2.14.jar mysql.jar slf4j-api-1.5.10.jar slf4j-log4j12-1.5.10.jar 3、建立PO持久化类cn.serup.model.Teacher 内容如下 package cn.serup.model; import javax.persistence.Entity; import javax.persistence.Id; //@Entity表示该是实体类 @Entity public class Teacher { private int id ; private String username ; private String password ; //ID为主键，主键手动分配 @Id public int getId() { return id; } public void setId(int id) { this.id = id;
说明： 本文对hibernate的一对多、多对一、多对多的关联 示例代码是Order类和OrderItem类的一对多的关系 1.一对多 1.1注解方式： @OneToMany 代码示例如下： 双向关联，维护端在“多”的一端 Public class Order implements Serializable { Private Set