Hibernate注解
Hibernate注解
常用的hibernate annotation标签如下:
@Entity
--注释声明该类为持久类。
@Table(name="promotion_info")
--持久性映射的表(表名="promotion_info)。
@Column（name=”DESC”,nullable=false,length=512)
--用于指定持久属性或字段的映射列。
@Id
--注释可以表明哪种属性是该类中的独特标识符(即相当于数据表的主键)。
@GeneratedValue
--定义自动增长的主键的生成策略。
@Transient
--将忽略这些字段和属性,不用持久化到数据库。
@Temporal(TemporalType.TIMESTAMP)
--声明时间格式。
@Enumerated
--声明枚举
@Version
--声明添加对乐观锁定的支持
@OneToOne
--可以建立实体bean之间的一对一的关联
@OneToMany
--可以建立实体bean之间的一对多的关联
@ManyToOne
--可以建立实体bean之间的多对一的关联
@ManyToMany
--可以建立实体bean之间的多对多的关联
@Formula
--一个SQL表达式，这种属性是只读的,不在数据库生成属性(可以使用sum、average、max等)
@OrderBy
--Many端某个字段排序(List)
下面是对以上常用Hibernate注解标签的详细介绍与举例：
@Entity
--注释声明该类为持久类。将一个Javabean类声明为一个实体的数据库表映射类,最好实现序列化.此时,默认情况下,所有的类属性都为映射到数据表的持久性字段.若在类中,添加另外属性,而非映射来数据库的, 要用下面的Transient来注解.
@Table(name="promotion_info")
--持久性映射的表(表名="promotion_info).@T able是类一级的注解,定义在@Entity下,
为实体bean映射表,目录和schema的名字,默认为实体bean的类名,不带包名.
示例：
@Entity
@T able(name="CUST", schema="RECORDS")
public class Customer { ... }
@Column（name=”DESC”,nullable=false,length=512)
--用于指定持久属性或字段的映射列。如果没有指定Column 注释，则应用默认值。
该注释下的一些具体属性如下：
①unique属性表示该字段是否为唯一标识，默认为false。如果表中有一个字段需要唯一标识，则既可以使用该标记，也可以使用@T able标记中的@UniqueConstraint。
②nullable属性表示该字段是否可以为null值，默认为true。
③insertable属性表示在使用“INSERT”脚本插入数据时，是否需要插入该字段的值。
④updatable属性表示在使用“UPDATE”脚本插入数据时，是否需要更新该字段的值。insertable和updatable属性一般多用于只读的属性，例如主键和外键等。这些字段的值通常是自动生成的。
⑤columnDefinition属性表示创建表时，该字段创建的SQL语句，一般用于通过Entity 生成表定义时使用。
⑥table属性表示当映射多个表时，指定表的表中的字段。默认值为主表的表名。
⑦length属性表示字段的长度，当字段的类型为varchar时，该属性才有效，默认为255个字符。
⑧precision属性和scale属性表示精度，当字段类型为double时，precision表示数值的总长度，scale表示小数点所占的位数。
示例1：
@Column(name="DESC", nullable=false, length=512)
public String getDescription() { return description; }
示例2：
@Column(name="DESC",columnDefinition="CLOB
NOT NULL",table="EMP_DETAIL")
@Lob
public String getDescription() {
return description;
}
示例3：
@Column(name="ORDER_COST", updatable=false, precision=12, scale=2)
public BigDecimal getCost() { return cost; }
@Id
--注释可以表明哪种属性是该类中的独特标识符(即相当于数据表的主键)。
示例：
@Id
public Long getId() { return id; }
@GeneratedValue
--定义自动增长的主键的生成策略.
示例1：
@Id
@GeneratedValue(strategy=SEQUENCE,
generator="CUST_SEQ")
@Column(name="CUST_ID")
public Long getId() { return id; }
示例2：
@Id
@GeneratedValue(strategy=TABLE,
generator="CUST_GEN")
@Column(name="CUST_ID")
Long id;
@Transient
--将忽略这些字段和属性,不用持久化到数据库.适用于,在当前的持久类中,某些属性不是用于映射到数据表,而是用于其它的业务逻辑需要,这时,须将这些属性进行transient的注解.否则系统会因映射不到数据表相应字段而出错.
示例：
@Entity
public class Employee {
@Id int id;
@Transient User currentUser;
...
}
@Temporal(TemporalType.TIMESTAMP)
--声明时间格式
示例：
@Temporal(DATE)
protected java.util.Date endDate;
@Enumerated
--声明枚举
示例：
public enum EmployeeStatus {FULL_TIME, PART_TIME, CONTRACT}
public enum SalaryRate {JUNIOR, SENIOR, MANAGER, EXECUTIVE}
@Entity public class Employee {
public EmployeeStatus getStatus() {...}
@Enumerated(STRING)
public SalaryRate getPayScale() {...}
...
}
@Version
--声明添加对乐观锁定的支持
示例：
@Version
@Column(name="OPTLOCK")
protected int getVersionNum() { return versionNum; }
@OneToOne
--可以建立实体bean之间的一对一的关联
一般不必显式指定关联的目标实体，因为通常可以根据引用的对象类型推断出来。
示例1：
映射外键列的一对一关联在Customer 类中：
@OneToOne(optional=false)
@JoinColumn(
name="CUSTREC_ID", unique=true, nullable=false, updatable=false)
public CustomerRecord getCustomerRecord() { return customerRecord; }
在CustomerRecord 类中：
@OneToOne(optional=false, mappedBy="customerRecord")
public Customer getCustomer() { return customer; }
示例2：假定源和目标共享同一个主键值的一对一关联。
在Employee 类中：
@Entity
public class Employee {
@Id Integer id;
@OneToOne @PrimaryKeyJoinColumn
EmployeeInfo info;
...
}
对于EmployeeInfo 类：
@Entity
public class EmployeeInfo {
@Id Integer id;
...
}
@OneToMany
--可以建立实体bean之间的一对多的关联
如果将Collection 的元素类型指定为generic 类型，则不必指定关联的目标实体类型；否则必须指定目标实体类。
示例1：
使用generic 的一对多关联在Customer 类中：
@OneToMany(cascade=ALL, mappedBy="customer")
public SetgetOrders() { return orders; }
在Order 类中：
@ManyToOne
@JoinColumn(name="CUST_ID", nullable=false)
public Customer getCustomer() { return customer; }
示例2：没有使用generic 的一对多关联
在Customer 类中：
@OneToMany(targetEntity=com.acme.Order.class,
cascade=ALL, mappedBy="customer")
public Set getOrders() { return orders; }
在Order 类中：
@ManyToOne
@JoinColumn(name="CUST_ID", nullable=false)
public Customer getCustomer() { return customer; }
@ManyToOne
--可以建立实体bean之间的多对一的关联
此注释定义对另一个带有多对一多样性的实体类的单值关联。一般不必显式指定目标实体，因为通常可以根据引用的对象类型推断出来。
示例：
@ManyToOne(optional=false)
@JoinColumn(name="CUST_ID", nullable=false, updatable=false)
public Customer getCustomer() { return customer; }
@ManyToMany
--可以建立实体bean之间的多对多的关联
如果将Collection 的元素类型指定为generic 类型，则不必指定关联的目标实体类；否则必须指定。
每个多对多关联都有两端：拥有端和非拥有端（或反向端）。连接表是对拥有端指定的。
如果关联是双向的，则两端都由拥有端指定。
OneToMany注释的注释元素也适用于ManyToMany 注释。
示例1：
在Customer 类中：
@ManyToMany
@JoinT able(name="CUST_PHONES")
public Set getPhones() { return phones; }
在PhoneNumber 类中：
@ManyToMany(mappedBy="phones")
public Set getCustomers() { return customers; }
示例2：
在Customer 类中：
@ManyToMany(targetEntity=com.acme.PhoneNumber.class)
public Set getPhones() { return phones; }
在PhoneNumber 类中：
@ManyToMany(targetEntity=com.acme.Customer.class, mappedBy="phones")
public Set getCustomers() { return customers; }
示例3：
在Customer 类中：
@ManyToMany
@JoinT able(name="CUST_PHONE", joinColumns=
@JoinColumn(name="CUST_ID", referencedColumnName="ID"),
inverseJoinColumns=
@JoinColumn(name="PHONE_ID", referencedColumnName="ID") )
public SetgetPhones() { return phones; }
在PhoneNumberClass 中：
@ManyToMany(mappedBy="phones")
public Set getCustomers() { return customers; }
@Formula
--一个SQL表达式，这种属性是只读的,不在数据库生成属性(可以使用sum、average、max等)
@Formula("(select COUNT(*) from user)")
private int count;
@OrderBy
--Many端某个字段排序(List)
此注释指定获取关联时，使用Collection 定义了值的关联元素的排列顺序。
value 排序元素的语法为orderby_list，如下所示：
orderby_list::= orderby_item [,orderby_item]*
orderby_item::= property_or_field_name [ASC | DESC]
如果没有指定ASC 或DESC，则假定为ASC（升序）。
如果没有指定排序元素，则假定使用关联实体的主键进行排序。
属性或字段名称必须对应于关联类的持久属性或字段名称。排序中使用的属性或字段必须对应于支持比较运算符的列。
示例：
@Entity public class Course {
...
@ManyToMany
@OrderBy("lastname ASC")
public List getStudents() {...}; ... }
@Entity
public class Student { ...
@ManyToMany(mappedBy="students")
@OrderBy // PK is assumed
public List getCourses() {...}; ... }
Spring+hibernate
课程内容 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.wendangku.net/doc/7a9526151.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 增加以下代码即可 spring4.x + hibernate4.x 配置详解
springmvc框架搭建之xml配置说明(spring4+hibernate4)
SpringMVC框架搭建说明 Spring4.1.4 + hibernate4.3.8 1、web.xml配置 程序运行时从web.xml开始，加载顺序为：context-param -> listener -> filter ->structs (如果使用structs的话)-> servlet 如下为web.xml的配置说明
马士兵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")
hibernate学习笔记
第一次课： 持久化：就是把瞬时状态的数据转变为持久化状态的数据，这一个过程就是持久化。 （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 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.4.0.CR1-doc
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关联注解
说明： 本文对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.wendangku.net/doc/7a9526151.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+Spring+Hibernate的工作流程及原理(整理的)
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的过程前后，
Struts+Spring+Hibernate框架搭建
整合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. 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作为维护端即主
- hibernate注解配置
- hibernate注解
- Hibernate注解用法总结
- Hibernate学习入门教程
- JPA注解
- Maven搭建MyEclipse10+Struts2.1+Spring3.3+Hibernate3.3全注解框架
- hibernate用注解(annotation)配置sequence
- 20171124魏博文Springmvc Hibernate框架结合使用
- hibernate注解(Hibernate注解)
- 中文版hibernate-annotations-3.4.0.CR1-doc
- hibernate关系映射注解配置
- hibernate映射关系学习笔记
- hibernate annotation 双向 one-to-one 注解
- Hibernate 实体类 注解 大全
- 使用Hibernate查询数据
- 马士兵hibernate文档 (个人完善版)
- Hibernate注解
- Hibernate介绍及Hibernate4新特性
- hibernate--java数据类型和各种数据库类型的映射关系图
- 对Hibernate Formula作用的全析