一。实体Bean
每个持久化POJO类都是一个实体Bean, 通过在类的定义中使用@Entity 注解来进行声明。
声明实体Bean
@Entity
public class Flight implements Serializable {
Long id;
@Id
public Long getId() { return id; }
public void setId(Long id) { this.id = id; }
}
@Entity 注解将一个类声明为实体Bean, @Id 注解声明了该实体Bean的标识属性。
Hibernate 可以对类的属性或者方法进行注解。属性对应field类别，方法的getXxx()对应property类别。
定义表
通过@Table 为实体Bean指定对应数据库表，目录和schema的名字。
@Entity
@Table(name="tbl_sky")
public class Sky implements Serializable {
...
@Table 注解包含一个schema和一个catelog 属性，使用
@UniqueConstraints 可以定义表的唯一约束。
@Table(name="tbl_sky",
uniqueConstraints = {@UniqueConstraint(columnNames={"month", "day"})} )
上述代码在"month" 和"day" 两个field 上加上unique constrainst.
@Version 注解用于支持乐观锁版本控制。
@Entity
public class Flight implements Serializable {
...
@Version
@Column(name="OPTLOCK")
public Integer getVersion() { ... }
}
version属性映射到"OPTLOCK" 列，entity manager 使用这个字段来检测冲突。一般可以用数字或者timestamp 类型来支持version.
实体Bean中所有非static 非transient 属性都可以被持久化，除非用
@Transient注解。
默认情况下，所有属性都用@Basic 注解。
public transient int counter; //transient property
private String firstname; //persistent property
@Transient
String getLengthInMeter() { ... } //transient property
String getName() {... } // persistent property
@Basic
int getLength() { ... } // persistent property
@Basic(fetch = https://www.doczj.com/doc/d21781698.html,ZY)
String getDetailedComment() { ... } // persistent property
@Temporal(TemporalType.TIME)
java.util.Date getDepartureTime() { ... } // persistent property
@Enumerated(EnumType.STRING)
Starred getNote() { ... } //enum persisted as String in database
上述代码中counter, lengthInMeter 属性将忽略不被持久化，而firstname, name, length 被定义为可持久化和可获取的。
@TemporalType.(DATE,TIME,TIMESTAMP)分别Map java.sql.(Date, Time, Timestamp).
@Lob注解属性将被持久化为Blog 或Clob 类型。具体的java.sql.Clob, Character[], char[] 和https://www.doczj.com/doc/d21781698.html,ng.String 将被持久化为Clob 类型. java.sql.Blob, Byte[], byte[] 和serializable type 将被持久化为Blob 类型。
@Lob
public String getFullText() {
return fullText; // clob type
}
@Lob
public byte[] getFullCode() {
return fullCode; // blog type
}
@Column 注解将属性映射到列。
@Entity
public class Flight implements Serializable {
...
@Column(updatable = false, name = "flight_name", nullable = false, length=50)
public String getName() { ... }
定义name 属性映射到flight_name column, not null, can't update, length equal 50
@Column(
name="columnName"; (1) 列名
boolean unique() default false; (2) 是否在该列上设置唯一约束
boolean nullable() default true; (3) 列可空？
boolean insertable() default true; (4) 该列是否作为生成insert语句的一个列
boolean updatable() default true; (5) 该列是否作为生成update语句的一个列
String columnDefinition() default ""; (6) 默认值
String table() default ""; (7) 定义对应的表（deault 是主表）int length() default 255; (8) 列长度
int precision() default 0; // decimal precision (9) decimal精度
int scale() default 0; // decimal scale (10) decimal长度
嵌入式对象（又称组件）也就是别的对象定义的属性
组件类必须在类一级定义@Embeddable 注解。在特定的实体关联属性上使用@Embeddable 和@AttributeOverride 注解可以覆盖该属性对应的嵌入式对
象的列映射。
@Entity
public class Person implements Serializable {
// Persistent component using defaults
Address homeAddress;
@Embedded
@AttributeOverrides( {
@AttributeOverride(name="iso2", column =
@Column(name="bornIso2") ),
@AttributeOverride(name="name", column =
@Column(name="bornCountryName") )
} )
Country bornIn;
...
}
@Embeddable
public class Address implements Serializable {
String city;
Country nationality; //no overriding here
}
@Embeddable
public class Country implements Serializable {
private String iso2;
@Column(name="countryName") private String name;
public String getIso2() { return iso2; }
public void setIso2(String iso2) { this.iso2 = iso2; }
public String getName() { return name; }
public void setName(String name) { https://www.doczj.com/doc/d21781698.html, = name; }
...
}
Person 类定义了Address 和Country 对象，具体两个类实现见上。无注解属性默认值：
?属性为简单类型，则映射为@Basic
?属性对应的类型定义了@Embeddable 注解，则映射为@Embedded
?属性对应的类型实现了Serializable,则属性被映射为@Basic并在一个列中保存该对象的serialized版本。
?属性的类型为java.sql.Clob or java.sql.Blob, 则映射到@Lob 对应的类型。
映射主键属性
@Id 注解可将实体Bean中某个属性定义为主键，使用@GenerateValue注解可以定义该标识符的生成策略。
? AUTO - 可以是identity column, sequence 或者table 类型，取决于不同底层的数据库
? TABLE - 使用table保存id值
? IDENTITY - identity column
? SEQUENCE - seque
nce
@Id @GeneratedValue(strategy=GenerationType.SEQUENCE,
generator="SEQ_STORE")
public Integer getId() { ... }
@Id @GeneratedValue(strategy=GenerationType.IDENTITY)
public Long getId() { ... }
AUTO 生成器，适用与可移值的应用，多个@Id可以共享同一个identifier生成器，只要把generator属性设成相同的值就可以。通过@SequenceGenerator 和@TableGenerator 可以配置不同的identifier 生成器。
table="GENERATOR_TABLE" pk-column-name="key" value-column-name="hi" pk-column-value="EMP" allocation-size="20"/> //and the annotation equivalent @javax.persistence.TableGenerator( name="EMP_GEN", table="GENERATOR_TABLE", pkColumnName = "key", valueColumnName = "hi" pkColumnValue="EMP", allocationSize=20 ) sequence-name="my_sequence" allocation-size="20"/> //and the annotation equivalent @javax.persistence.SequenceGenerator( name="SEQ_GEN", sequenceName="my_sequence", allocationSize=20 ) The next example shows the definition of a sequence generator in a class scope: @Entity @javax.persistence.SequenceGenerator( name="SEQ_STORE", sequenceName="my_sequence" ) public class Store implements Serializable { private Long id; @Id @GeneratedValue(strategy=GenerationType.SEQUENCE, generator="SEQ_STORE") public Long getId() { return id; } } Store类使用名为my_sequence的sequence，并且SEQ_STORE生成器对于其他类是不可见的。 通过下面语法，你可以定义组合键。 ?将组件类注解为@Embeddable，并将组件的属性注解为@Id ?将组件的属性注解为@EmbeddedId ?将类注解为@IdClass，并将该实体中所有主键的属性都注解为@Id @Entity @IdClass(FootballerPk.class) public class Footballer { //part of the id key @Id public String getFirstname() { return firstname; } public void setFirstname(String firstname) { this.firstname = firstname; } //part of the id key @Id public String getLastname() { return lastname; } public void setLastname(String lastname) { https://www.doczj.com/doc/d21781698.html,stname = lastname; } public String getClub() { return club; } public void setClub(String club) { this.club = club; } //appropriate equals() and hashCode() implementation } @Embeddable public class FootballerPk implements Serializable { //same name and type as in Footballer public String getFirstname() { return firstname; } public void setFirstname(String firstname) { this.firstname = firstname; } //same name and type as in Footballer public String getLastname() { return lastname; } public void setLastname(String lastname) { https://www.doczj.com/doc/d21781698.html,stname = lastname; } //appropriate equals() and hashCode() implementation } @Entity @AssociationOverride( name="id.channel", joinColumns = @JoinColumn(name="chan_id") ) public class TvMagazin { @EmbeddedId public TvMagazinPk id; @Temporal(TemporalType.TIME) Date time; } @Embeddable public class TvMagazinPk implements Serializable { @ManyToOne public Channel channel; public String name; @ManyToOne public Presenter presenter; } 映射继承关系 EJB支持3种类型的继承。 ? Table per Class Strategy: the ? Single Table per Class Hierarchy Strategy: the ? Joined Subclass Strategy: the @Inheritance 注解来定义所选的之类策略。 每个类一张表 @Entity @Inheritance(strategy = InheritanceType.TABLE_PER_CLASS) public class Flight implements Serializable { 有缺点，如多态查询或关联。Hibernate 使用SQL Union 查询来实现这种策略。这种策略支持双向的一对多关联，但不支持IDENTIFY 生成器策略，因为ID必须在多个表间共享。一旦使用就不能使用AUTO和IDENTIFY生成器。 每个类层次结构一张表 @Entity @Inheritance(strategy=InheritanceType.SINGLE_TABLE) @DiscriminatorColumn( name="planetype", discriminatorType=DiscriminatorType.STRING ) @DiscriminatorValue("Plane") public class Plane { ... } @Entity @DiscriminatorValue("A320") public class A320 extends Plane { ... } 整个层次结构中的所有父类和子类属性都映射到同一个表中，他们的实例通过一个辨别符列（discriminator）来区分。 Plane 是父类。@DiscriminatorColumn注解定义了辨别符列。对于继承层次结构中的每个类, @DiscriminatorValue 注解指定了用来辨别该类的值。辨别符列名字默认为DTYPE，其默认值为实体名。其类型为DiscriminatorType.STRING。 连接的子类 @Entity @Inheritance(strategy=InheritanceType.JOINED) public class Boat implements Serializable { ... } @Entity public class Ferry extends Boat { ... } @Entity @PrimaryKeyJoinColumn(name="BOAT_ID") public class AmericaCupClass extends Boat { ... } 以上所有实体使用JOINED 策略Ferry和Boat class使用同名的主键关联(eg: Boat.id = Ferry.id)，AmericaCupClass 和Boat 关联的条件为Boat.id = AmericaCupClass.BOAT_ID. 从父类继承的属性 @MappedSuperclass public class BaseEntity { @Basic @Temporal(TemporalType.TIMESTAMP) public Date getLastUpdate() { ... } public String getLastUpdater() { ... } ... } @Entity class Order extends BaseEntity { @Id public Integer getId() { ... } ... } 继承父类的一些属性，但不用父类作为映射实体，这时候需要 @MappedSuperclass 注解。上述实体映射到数据库中的时候对应Order 实体Bean, 其具有id, lastUpdate, lastUpdater 三个属性。如果没有 @MappedSuperclass 注解,则父类中属性忽略，这是Order 实体Bean 只有id 一个属性。 映射实体Bean的关联关系 一对一 使用@OneToOne 注解可以建立实体Bean之间的一对一关系。一对一关系有3种情况。 ?关联的实体都共享同样的主键。 @Entity public class Body { @Id public Long getId() { return id; } @OneToOne(cascade = CascadeType.ALL) @PrimaryKeyJoinColumn public Heart getHeart() { return heart; } ... } @Entity public class Heart { @Id public Long getId() { ...} } 通过@PrimaryKeyJoinColumn 注解定义了一对一的关联关系。 ?其中一个实体通过外键关联到另一个实体的主键。注：一对一，则外键必须为唯一约束。 @Entity public class Customer implements Serializable { @OneToOne(cascade = CascadeType.ALL) @JoinColumn(name="passport_fk") public Passport getPassport() { ... } @Entity public class Passport implements Serializable { @OneToOne(mappedBy = "passport") public Customer getOwner() { ... } 通过@JoinColumn注解定义一对一的关联关系。如果没有@JoinColumn注解，则系统自动处理，在主表中将创建连接列，列名为：主题的关联属性名+ 下划线+ 被关联端的主键列名。上例为passport_id, 因为Customer 中关联属性为passport, Passport 的主键为id. ?通过关联表来保存两个实体之间的关联关系。注：一对一，则关联表每个外键都必须是唯一约束。 @Entity public class Customer implements Serializable { @OneToOne(cascade = CascadeType.ALL) @JoinTable(name = "CustomerPassports", joinColumns = @JoinColumn(name="customer_fk"), inverseJoinColumns = @JoinColumn(name="passport_fk") ) public Passport getPassport() { ... } @Entity public class Passport implements Serializable { @OneToOne(mappedBy = "passport") public Customer getOwner() { ... } Customer 通过CustomerPassports 关联表和Passport 关联。该关联表通过passport_fk 外键指向Passport 表，该信心定义为inverseJoinColumns 的属性值。通过customer_fk 外键指向Customer 表，该信息定义为joinColumns 属性值。 多对一 使用@ManyToOne 注解定义多对一关系。 @Entity() public class Flight implements Serializable { @ManyToOne( cascade = {CascadeType.PERSIST, CascadeType.MERGE} ) @JoinColumn(name="COMP_ID") public Company getCompany() { return company; } ... } 其中@JoinColumn 注解是可选的，关键字段默认值和一对一关联的情况相似。列名为：主题的关联属性名+ 下划线+ 被关联端的主键列名。本例中为company_id,因为关联的属性是company, Company的主键为id. @ManyToOne 注解有个targetEntity属性，该参数定义了目标实体名。通常不需要定义，大部分情况为默认值。但下面这种情况则需要targetEntity 定义（使用接口作为返回值，而不是常用的实体）。 @Entity() public class Flight implements Serializable { @ManyToOne(cascade= {CascadeType.PERSIST,CascadeType.MERGE},targetEntity= CompanyImpl.class) @JoinColumn(name="COMP_ID") public Company getCompany() { return company; } ... } public interface Company { ... 多对一也可以通过关联表的方式来映射，通过@JoinTable 注解可定义关联表。该关联表包含指回实体的外键（通过@JoinTable.joinColumns）以及指向目标实体表的外键（通过@JoinTable.inverseJoinColumns）. @Entity() public class Flight implements Serializable { @ManyToOne( cascade = {CascadeType.PERSIST, CascadeType.MERGE} ) @JoinTable(name="Flight_Company", joinColumns = @JoinColumn(name="FLIGHT_ID"), inverseJoinColumns = @JoinColumn(name="COMP_ID") ) public Company getCompany() { return company; } ... } 集合类型 一对多 @OneToMany 注解可定义一对多关联。一对多关联可以是双向的。 双向 规范中多对一端几乎总是双向关联中的主体（owner）端，而一对多的关联注解为@OneToMany(mappedBy=) @Entity public class Troop { @OneToMany(mappedBy="troop") public Set ... } @Entity public class Soldier { @ManyToOne @JoinColumn(name="troop_fk") public Troop getTroop() { ... } Troop 通过troop属性和Soldier建立了一对多的双向关联。在mappedBy 端不必也不能定义任何物理映射。 单向 @Entity public class Customer implements Serializable { @OneToMany(cascade=CascadeType.ALL, fetch=FetchType.EAGER) @JoinColumn(name="CUST_ID") public Set ... } @Entity public class Ticket implements Serializable { ... //no bidir } 一般通过连接表来实现这种关联，可以通过@JoinColumn注解来描述这种单向关联关系。上例Customer 通过CUST_ID 列和Ticket 建立了单向关联关系。 通过关联表来处理单向关联 @Entity public class Trainer { @OneToMany @JoinTable( name="TrainedMonkeys", joinColumns = @JoinColumn( name="trainer_id"), inverseJoinColumns = @JoinColumn( name="monkey_id") ) public Set ... } @Entity public class Monkey { ... //no bidir } 通过关联表来处理单向一对多关系是首选，这种关联通过@JoinTable 注解来进行描述。上例子中Trainer 通过TrainedMonkeys表和Monkey建立了单向关联关系。其中外键trainer_id关联到Trainer(joinColumns)而外键monkey_id关联到Monkey(inverseJoinColumns). 默认处理机制 通过连接表来建立单向一对多关联不需要描述任何物理映射，表名由一下3个部分组成，主表(owner table)表名+ 下划线+ 从表(the other side table)表名。指向主表的外键名:主表表名+下划线+主表主键列名指向从表的外键定义为唯一约束，用来表示一对多的关联关系。 @Entity public class Trainer { @OneToMany public Set ... } @Entity public class Tiger { ... //no bidir } 上述例子中Trainer 和Tiger 通过Trainer_Tiger 连接表建立单向关联关系。其中外键trainer_id 关联到Trainer表，而外键trainedTigers_id 关联到Tiger 表。 多对多 通过@ManyToMany 注解定义多对多关系，同时通过@JoinTable 注解描述关联表和关联条件。其中一端定义为owner, 另一段定义为inverse(对关联表进行更新操作，这段被忽略)。 @Entity public class Employer implements Serializable { @ManyToMany( targetEntity=org.hibernate.test.metadata.manytomany.Employee.class, cascade={CascadeType.PERSIST, CascadeType.MERGE} ) @JoinTable( name="EMPLOYER_EMPLOYEE", joinColumns=@JoinColumn(name="EMPER_ID"), inverseJoinColumns=@JoinColumn(name="EMPEE_ID") ) public Collection getEmployees() { return employees; } ... } @Entity public class Employee implements Serializable { @ManyToMany( cascade = {CascadeType.PERSIST, CascadeType.MERGE}, mappedBy = "employees", targetEntity = Employer.class ) public Collection getEmployers() { return employers; } } 默认值： 关联表名：主表表名+ 下划线+ 从表表名；关联表到主表的外键：主表表名+ 下划线+ 主表中主键列名；关联表到从表的外键名：主表中用于关联的属性名+ 下划线+ 从表的主键列名。 用cascading 实现传播持久化（Transitive persistence） cascade 属性接受值为CascadeType 数组，其类型如下： ?CascadeType.PERSIST: cascades the persist (create) operation to associated entities persist() is called or if the entity is managed 如果一个实体 是受管状态，或者当persist() 函数被调用时，触发级联创建(create)操作。 ?CascadeType.MERGE: cascades the merge operation to associated entities if merge() is called or if the entity is managed 如果一个实体是受管状态，或者当merge() 函数被调用时，触发级联合并(merge)操作。 ?CascadeType.REMOVE: cascades the remove operation to associated entities if delete() is called 当delete() 函数被调用时，触发级联删除(remove)操作。 ?CascadeType.REFRESH: cascades the refresh operation to associated entities if refresh() is called 当refresh() 函数被调用时，出发级联更新(refresh)操作。 ?CascadeType.ALL: all of the above 以上全部 映射二级列表 使用类一级的@SecondaryTable 和@SecondaryTables 注解可以实现单 个实体到多个表的映射。使用@Column 或者@JoinColumn 注解中的table 参数可以指定某个列所属的特定表。 @Entity @Table(name="MainCat") @SecondaryTables({ @SecondaryTable(name="Cat1", pkJoinColumns={ @PrimaryKeyJoinColumn(name="cat_id", referencedColumnName="id")}), @SecondaryTable(name="Cat2", uniqueConstraints={ @UniqueConstraint(columnNames={"storyPart2"})}) }) public class Cat implements Serializable { private Integer id; private String name; private String storyPart1; private String storyPart2; @Id @GeneratedValue public Integer getId() { return id; } public String getName() { return name; } @Column(table="Cat1") public String getStoryPart1() { return storyPart1; } @Column(table="Cat2") public String getStoryPart2() { return storyPart2; } 上述例子中，name 保存在MainCat 表中，storyPart1保存在Cat1 表中，storyPart2 保存在Cat2 表中。Cat1 表通过外键cat_id 和MainCat 表关联，Cat2 表通过id 列和MainCat 表关联。对storyPart2 列还定义了唯一约束。 映射查询 使用注解可以映射EJBQL/HQL 查询，@NamedQuery 和@NamedQueries 是可以使用在类级别或者JPA的XML文件中的注解。 ... ... @Entity @NamedQuery(name="night.moreRecentThan", query="select n from Night n where n.date >= :date") public class Night { ... } public class MyDao { doStuff() { Query q = s.getNamedQuery("night.moreRecentThan"); q.setDate( "date", aMonthAgo ); List results = q.list(); ... } ... } 可以通过定义QueryHint 数组的hints 属性为查询提供一些hint 信息。下图是一些Hibernate hints: 映射本地化查询 通过@SqlResultSetMapping 注解来描述SQL 的resultset 结构。如果定义多个结果集映射，则用@SqlResultSetMappings。 @NamedNativeQuery(name="night&area", query="select night.id nid, night.night_duration, " + " night.night_date, area.id aid, night.area_id, https://www.doczj.com/doc/d21781698.html, " + "from Night night, Area area where night.area_id = area.id", resultSetMapping="joinMapping") @SqlResultSetMapping( name="joinMapping", entities={ @EntityResult(entityClass=org.hibernate.test.annotations.query.Night.class, fields = { @FieldResult(name="id", column="nid"), @FieldResult(name="duration", column="night_duration"), @FieldResult(name="date", column="night_date"), @FieldResult(name="area", column="area_id"), discriminatorColumn="disc" }), 课程内容 1.面向接口（抽象）编程的概念与好处 2.IOC/DI的概念与好处 a)inversion of control b)dependency injection 3.AOP的概念与好处 4.Spring简介 5.Spring应用IOC/DI（重要） a)xml b)annotation 6.Spring应用AOP（重要） a)xml b)annotation 7.Struts2.1.6 + Spring2.5.6 + Hibernate3.3.2整合（重要） a)opensessionInviewfilter（记住，解决什么问题，怎么解决） 8.Spring JDBC 面向接口编程（面向抽象编程） 1.场景：用户添加 2.Spring_0100_AbstractOrientedProgramming a)不是AOP:Aspect Oriented Programming 3.好处：灵活 什么是IOC（DI），有什么好处Dependecy Injection （依赖注入）依赖UserDAO a)IOC (inversion of control)控制反转，交给容器来控制 1.把自己new的东西改为由容器提供 a)初始化具体值 b)装配 2.好处：灵活装配 Spring简介 1.项目名称：Spring_0200_IOC_Introduction 2.环境搭建 a)只用IOC i.spring.jar , jarkata-commons/commons-loggin.jar 3.IOC容器 a)实例化具体bean b)动态装配 4.AOP支持 a)安全检查 b)管理transaction Spring IOC配置与应用 1.FAQ:不给提示： a)window – preferences – myeclipse – xml – xml catalog b)User Specified Entries – add i.Location: D:\share\0900_Spring\soft\spring-framework-2.5.6\dist\resources\sprin g-beans-2.5.xsd ii.URI: file:///D:/share/0900_Spring/soft/spring-framework-2.5.6/dist/resource s/spring-beans-2.5.xsd iii.Key Type: Schema Location iv.Key: https://www.doczj.com/doc/d21781698.html,/schema/beans/spring-beans-2.5.xsd 2.注入类型 a)Spring_0300_IOC_Injection_Type b)setter（重要） c)构造方法（可以忘记） d)接口注入（可以忘记） 3.id vs. name a)Spring_0400_IOC_Id_Name b)name可以用特殊字符 4.简单属性的注入 a)Spring_0500_IOC_SimpleProperty b) spring4.x + hibernate4.x 配置详解 关于spring和hibernate的使用以及特征等等，在此不再啰嗦，相信大家也都知道，或者去搜索一下即可。 本篇博文的内容主要是我最近整理的关于spring4.x 和hibernate 4.x 相关配置和使用方式，当然spring3.x以及hibernate4.x也可以借鉴。 首先是配置文件web.xml 增加以下代码即可 SpringMVC框架搭建说明 Spring4.1.4 + hibernate4.3.8 1、web.xml配置 程序运行时从web.xml开始，加载顺序为：context-param -> listener -> filter ->structs (如果使用structs的话)-> servlet 如下为web.xml的配置说明 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中内存分为：栈（变量，方法，形参都是在栈上），堆（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 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 Annotations 参考文档 3.2.0 CR1 目录 前言 1. 翻译说明 2. 版权声明 前言 1. 创建一个注解项目 1.1. 系统需求 1.2. 系统配置 2. 实体Bean 2.1. 简介 2.2. 用EJB3注解进行映射 2.2.1. 声明实体bean 2.2.1.1. 定义表(Table) 2.2.1.2. 乐观锁定版本控制 2.2.2. 映射简单属性 2.2.2.1. 声明基本的属性映射 2.2.2.2. 声明列属性 2.2.2. 3. 嵌入式对象(又名组件) 2.2.2.4. 无注解之属性的默认值 2.2.. 映射主键属性 2.2.4. 映射继承关系 2.2.4.1. 每个类一张表 2.2.4.2. 每个类层次结构一张表 2.2.4. 3. 连接的子类 2.2.4.4. 从父类继承的属性 2.2.5. 映射实体Bean的关联关系 2.2.5.1. 一对一(One-to-one) 2.2.5.2. 多对一(Many-to-one) 2.2.5. 3. 集合类型 2.2.5.4. 用cascading实现传播性持久化(Transitive persistence) 2.2.5.5. 关联关系获取 2.2.6. 映射复合主键与外键 2.2.7. 映射二级表(secondary tables) 2.3. 映射查询 2.3.1. 映射EJBQL/HQL查询 2.3.2. 映射本地化查询 2.4. Hibernate独有的注解扩展 2.4.1. 实体 2.4.2. 标识符 2.4. 3. 属性 2.4. 3.1. 访问类型 2.4. 3.2. 公式 2.4. 3.3. 类型 2.4. 3. 4. 索引 2.4. 3.5. @Parent 2.4. 3.6. 生成的属性 2.4.4. 继承 2.4.5. 关于单个关联关系的注解 2.4.5.1. 延迟选项和获取模式 2.4.6. 关于集合类型的注解 2.4.6.1. 参数注解 2.4.6.2. 更多的集合类型 2.4.7. 缓存 2.4.8. 过滤器 2.4.9. 查询 3. 通过XML覆写元数据 3.1. 原则 3.1.1. 全局级别的元数据 3.1.2. 实体级别的元数据 3.1.3. 属性级别的元数据 3.1. 4. 关联级别的元数据 4. Hibernate验证器 4.1. 约束 4.1.1. 什么是约束？ 4.1.2. 内建约束 4.1.3. 错误信息 4.1.4. 编写你自己的约束 4.1. 5. 注解你的领域模型 4.2. 使用验证器框架 4.2.1. 数据库schema层次验证 4.2.2. Hibernate基于事件的验证 4.2.3. 程序级验证 4.2.4. 验证信息 5. Hibernate与Lucene集成 5.1. 使用Lucene为实体建立索引 5.1.1. 注解领域模型 5.1.2. 启用自动索引 A. 术语表 前言 WARNING! This is a translated version of the English Hibernate reference documentation. The translated version might not be up to date! However, the differences should only be very minor. Consult the English reference documentation if you are missing information or encounter a translation error. If you like to contribute to a particular translation, contact us on the Hibernate developer mailing list. Translator(s): RedSaga Translate Team 满江红翻译团队 说明： 本文对hibernate的一对多、多对一、多对多的关联 示例代码是Order类和OrderItem类的一对多的关系 1.一对多 1.1注解方式： @OneToMany 代码示例如下： 双向关联，维护端在“多”的一端 Public class Order implements Serializable { Private Set 注解整理笔记 @是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/d21781698.html,ZY) 12@JoinTable(name = "T_BASE_ROLE_RESOURCE", joinColumns = { @JoinColumn(name = "ROLE_ID") }, inverseJoinColumns = { @JoinColumn(name = "RESOURCE_ID") }) 13@OrderBy("id") public List Struts2框架 一、简介 Struts2是一个相当强大的Java Web开源框架，是一个基于POJO的Action 的MVC Web框架。它基于当年的WebWork和XWork框架，继承其优点，同时做了相当的改进。 1、Struts2基于MVC架构，框架结构清晰，开发流程一目了然，开发人员可 以很好的掌控开发的过程。 2、使用OGNL进行参数传递。OGNL提供了在Struts2里访问各种作用域的 数据的简单方式，你可以方便的获取Request、Attribute、Application、 Session、Parameters中的数据。大大简化了开发人员在获取这些数据是的 代码量。 3、强大的拦截器。Struts2的拦截器是一个Action级别的AOP，Struts2中的 许多特性都是通过拦截器来实现的，例如异常处理、文件上传、验证等。 拦截器是可配置与重用的，可以将一些通用的功能如：登录验证、权限 验证等置于拦截器中以完成了系统中的权限验证功能。 4、易于测试。Struts2的Action都是简单的POJO，这样可以方便的对Struts2 的Action编写测试用例，大大方便了Java Web项目的测试。 5、易于扩展的插件机制。在Struts2添加扩展是一件愉快而轻松的事情，只 需要将所需要的Jar包放到WEB-INF/lib文件中，在Struts.xml中做一些 简单的设置就可以实现扩展。 6、模块化管理。Struts2已经把模块化作为了体系架构中的基本思想，可以 通过三种方法来将应用程序模块化：将配置信息拆分成多个文件把自包 含的应用模块创建为插件创建的框架特性，即将于特定应用无关的新功 能组织成插件，以添加到多个应用中去。 7、全局结果与声明式异常。为应用程序添加全局的Result，和在配置文件中 对异常进行处理，这样当处理过程中出现指定异常时，可以跳转到特定 页面。 二、Struts2的工作机制 在Struts2框架中的处理大概分为： 1、客户端初始化一个指向Servlet容器（如Tomcat）的请求； 2、这个请求经过一系列的过滤器（Filter）（这些过滤器中有一个叫做 ActionContextCleanUp的可选过滤器，这个过滤器对于Struts2和其他框 架的集成很有帮组，例如：SiteMeshPlugin）； 3、接着FilterDispatcher被调用，FilterDispatcher询问ActionMapper来决定 这个请求是否需要调用某个Action； 4、如果ActionMapper决定需要调用某个Action，FilterDispatcher把请求的 处理交给ActionProxy； 5、ActionProcy通过Configuration Manager询问框架的配置文件，找到需要 调用的Action类； 6、ActionProxy创建一个ActionInvocation实例。 7、ActionInvocation实例使用命令模式来调用，在调用Action的过程前后， 整合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: 1. Hibernate Annotation关系映射有下面几种类型： 1)一对一外键关联映射（单向） 2)一对一外键关联映射（双向） 3)一对一主键关联映射（不重要，有需要看下文档即可） 在实际中很少用，使用注解@PrimaryKeyJoinColumn 意思是说，我的主键去参考另外一张表中的主键，作为我的主键，但是在我测试使用 注解一对一主键关联映射，在生成表的时候，数据库中并没有生成关联，使用XML 映射可以生成。Annotation注解一对一主键关联映，有些bug。不过没空去研究它。 因为在实际开发中一对一很少用。在实际开发中我机会没有用过，主键关联就更少了 4)多对一关联映射（单向） 5)一对多关联映射（单向） 6)一对多关联映射（双向） 7)多对多关联映射（单向） 8)多对多关联映射（双向） 2.介绍各种映射用法 1）一对一外键关联映射（单向）Husband ---> Wife public class Husband{ private Wife wife; @OneToOne(cascade=CascadeType.ALL) @JoinColumn(name="wife_id",unique=true) public Wife getWife(){…} … } public class Wife{ } 一对一外键关联，使用@OneToOne，并设置了级联操作 @JoinColum设置了外键的名称为wife_id（数据库字段名），如果不设置，则默认为另一类的属性名+ _id 外键的值是唯一的(unique)，不可重复，与另一类的主键一致 2）一对一外键关联映射（双向）Husband <---> Wife public class Husband{ private Wife wife; @OneToOne(cascade=CascadeType.ALL) @JoinColumn(name="wife_id",unique=true) public Wife getWife(){…} ... } public class Wife{ private Husband husband; @OneToOne(mappedBy="wife",cascade=CascadeType.ALL) public Husband getHusband(){…} ... } 一对一双向关联关系，使用@OneToOne 注意：需要加上mappedBy="wife"，如果不加上的话，Wife也会生成一个外键（husband_id）。mappedby="wife"需要指向与他关联对象的一个属性(即Husband类里面的wife属性)，这里的会在Husband表里面生成个外键wife_id字段，而Wife表里则不会生成。这里Husband作为维护端即主Spring+hibernate
spring4.x + hibernate4.x 配置详解
springmvc框架搭建之xml配置说明(spring4+hibernate4)
马士兵hibernate文档 (个人完善版)
hibernate学习笔记
hibernate_annotation
中文版hibernate-annotations-3.4.0.CR1-doc
hibernate关联注解
注解整理笔记
Struts2+Spring+Hibernate的工作流程及原理(整理的)
Struts+Spring+Hibernate框架搭建
hibernate关系映射注解配置
相关主题
文本预览