hibernate注解详解
Table用来定义entity主表的name，catalog，schema等属性。
属性说明：
?name：表名
?catalog：对应关系数据库中的catalog
?schema：对应关系数据库中的schema
?UniqueConstraints：定义一个UniqueConstraint数组，指定需要建唯一约束的列
Java代码
1.@Entity
2.@Table(name="CUST")
3.public class Customer { ... }
@SecondaryTable
一个entity class可以映射到多表，SecondaryTable用来定义单个从表的名字，主键名字等属性。
属性说明：
?name：表名
?catalog：对应关系数据库中的catalog
?pkJoin：定义一个PrimaryKeyJoinColumn数组，指定从表的主键列
?UniqueConstraints：定义一个UniqueConstraint数组，指定需要建唯一约束的列
下面的代码说明Customer类映射到两个表，主表名是CUSTOMER，从表名是CUST_DETAIL，从表的主键列和主表的主键列类型相同，列名为CUST_ID。
Java代码
1.@Entity
2.@Table(name="CUSTOMER")
3.@SecondaryTable(name="CUST_DETAIL",pkJoin=@PrimaryKeyJoinColumn(name="CUST_ID"))
4.public class Customer { ... }
@SecondaryTables
当一个entity class映射到一个主表和多个从表时，用SecondaryTables来定义各个从表的属性。
属性说明：
?value：定义一个SecondaryTable数组，指定每个从表的属性。
1.@Table(name = "CUSTOMER")
2.@SecondaryTables( value = {
3.@SecondaryTable(name = "CUST_NAME", pkJoin = { @PrimaryKeyJoinColumn(name = "STMO_ID", refe
rencedColumnName = "id") }),
4.@SecondaryTable(name = "CUST_ADDRESS", pkJoin = { @PrimaryKeyJoinColumn(name = "STMO_ID", r
eferencedColumnName = "id") }) })
5.public class Customer {}
@UniqueConstraint
UniqueConstraint定义在Table或SecondaryTable元数据里，用来指定建表时需要建唯一约束的列。
属性说明：
?columnNames：定义一个字符串数组，指定要建唯一约束的列名。
Java代码
1.@Entity
2.@Table(name="EMPLOYEE",uniqueConstraints={@UniqueConstraint(columnNames={"EMP_ID", "EMP_NAM
E"})})
3.public class Employee { ... }
@Column
Column元数据定义了映射到数据库的列的所有属性：列名，是否唯一，是否允许为空，是否允许更新等。属性说明：
?unique：是否唯一
?nullable：是否允许为空
?insertable：是否允许插入
?updatable：是否允许更新
?columnDefinition：定义建表时创建此列的DDL
?secondaryTable：从表名。如果此列不建在主表上（默认建在主表），该属性定义该列所在从表的名字。
5.private byte[] picture;
@JoinColumn
如果在entity class的field上定义了关系（one2one或one2many等），我们通过JoinColumn来定义关系的属性。JoinColumn的大部分属性和Column类似。
属性说明：
?unique：是否唯一
?referencedColumnName：该列指向列的列名（建表时该列作为外键列指向关系另一端的指定列）?nullable：是否允许为空
?insertable：是否允许插入
?updatable：是否允许更新
?columnDefinition：定义建表时创建此列的DDL
?secondaryTable：从表名。如果此列不建在主表上（默认建在主表），该属性定义该列所在从表的名字。
下面的代码说明Custom和Order是一对一关系。在Order对应的映射表建一个名为CUST_ID的列，该列作为外键指向Custom对应表中名为ID的列。
Java代码
1.public class Custom {
2.@OneToOne
3.@JoinColumn(name="CUST_ID", referencedColumnName="ID", unique=true, nullable=true, upda
table=true)
4.public Order getOrder() {
5.return order;
6. }
@JoinColumns
如果在entity class的field上定义了关系（one2one或one2many等），并且关系存在多个JoinColumn，用JoinColumns定义多个JoinColumn的属性。
属性说明：
?value：定义JoinColumn数组，指定每个JoinColumn的属性。
下面的代码说明Custom和Order是一对一关系。在Order对应的映射表建两列，一列名为CUST_ID，该列作为外键指向Custom对应表中名为ID的列,另一列名为CUST_NAME，该列作为外键指向Custom对应表中名为NAME的列。
Java代码
1.public class Custom {
2.@OneToOne
3.@JoinColumns({
4.@JoinColumn(name="CUST_ID", referencedColumnName="ID"),
5.@JoinColumn(name="CUST_NAME", referencedColumnName="NAME")
6. })
7.public Order getOrder() {
8.return order;
9. }
@Id
声明当前field为映射表中的主键列。id值的获取方式有五种：TABLE, SEQUENCE, IDENTITY, AUTO, NONE。Oracle和DB2支持SEQUENCE，SQL Server和Sybase支持IDENTITY,mysql支持AUTO。所有的数据库都可以指定为AUTO，我们会根据不同数据库做转换。NONE(默认)需要用户自己指定Id的值。
属性说明：
?generate：主键值的获取类型
?generator：TableGenerator的名字（当generate=GeneratorType.TABLE才需要指定该属性）
下面的代码声明Task的主键列id是自动增长的。(Oracle和DB2从默认的SEQUENCE取值，SQL Server 和Sybase该列建成IDENTITY，mysql该列建成auto increment。)
Java代码
1.@Entity
2.@Table(name = "OTASK")
3.public class Task {
4.@Id(generate = GeneratorType.AUTO)
5.public Integer getId() {
6.return id;
7.}
8. }
@IdClass
当entity class使用复合主键时，需要定义一个类作为id class。id class必须符合以下要求:类必须声明为public，并提供一个声明为public的空构造函数。必须实现Serializable接，覆写equals()和hashCode（）方法。entity class的所有id field在id class都要定义，且类型一样。
属性说明：
?value：id class的类名
下面的代码声明Task的主键列id是自动增长的。(Oracle和DB2从默认的SEQUENCE取值，SQL Server 和Sybase该列建成IDENTITY，mysql该列建成auto increment。)
Java代码
1.public class EmployeePK implements java.io.Serializable{
2. String empName;
3. Integer empAge;
4.public EmployeePK(){}
5.public boolean equals(Object obj){ ......}
6.public int hashCode(){......}
7.}
8.@IdClass(value=com.acme.EmployeePK.class)
9.@Entity(access=FIELD)
10.public class Employee {
11.@Id String empName;
12.@Id Integer empAge;
13.}
@MapKey
在一对多，多对多关系中，我们可以用Map来保存集合对象。默认用主键值做key，如果使用复合主键，则用id class的实例做key，如果指定了name属性，就用指定的field的值做key。
属性说明：
name：用来做key的field名字
下面的代码说明Person和Book之间是一对多关系。Person的books字段是Map类型，用Book的isbn 字段的值作为Map的key。
Java代码
1.@Table(name = "PERSON")
2.public class Person {
3.@OneToMany(targetEntity = Book.class, cascade = CascadeType.ALL, mappedBy = "person")
4.@MapKey(name = "isbn")
5.private Map books = new HashMap();
6. }
@MappedSuperclass
使用@MappedSuperclass指定一个实体类从中继承持久字段的超类。当多个实体类共享通用的持久字段或属性时，这将是一个方便的模式。
您可以像对实体那样使用任何直接和关系映射批注（如@Basic 和@ManyToMany）对该超类的字段和属性进行批注，但由于没有针对该超类本身的表存在，因此这些映射只适用于它的子类。继承的持久字段或属性属于子类的表。
可以在子类中使用@AttributeOverride或@AssociationOverride来覆盖超类的映射配置。
@MappedSuperclass没有属性。
Java代码
1.//如何将Employee指定为映射超类
2.@MappedSuperclass
3.public class Employee {
4.@Id
5.protected Integer empId;
6.
7.@Version
8.protected Integer version;
9.
10.@ManyToOne
11.@JoinColumn(name="ADDR")
12.protected Address address;
13.}
14.
15.//如何在实体类中使用@AttributeOverride以覆盖超类中设置的配置。
16.@Entity
17.@AttributeOverride(name="address", column=@Column(name="ADDR_ID"))
18.public class PartTimeEmployee extends Employee {
19.@Column(name="WAGE")
20.protected Float hourlyWage;
21.}
@PrimaryKeyJoinColumn
在三种情况下会用到@PrimaryKeyJoinColumn
?继承。
?entity class映射到一个或多个从表。从表根据主表的主键列（列名为referencedColumnName 值的列），建立一个类型一样的主键列，列名由name属性定义。
?one2one关系，关系维护端的主键作为外键指向关系被维护端的主键，不再新建一个外键列。
属性说明：
?name：列名。
?referencedColumnName：该列引用列的列名
?columnDefinition：定义建表时创建此列的DDL
下面的代码说明Customer映射到两个表，主表CUSTOMER,从表CUST_DETAIL，从表需要建立主键列CUST_ID，该列和主表的主键列id除了列名不同，其他定义一样。
Java代码
1.@Entity
2.@Table(name="CUSTOMER")
3.@SecondaryTable(name="CUST_DETAIL",pkJoin=@PrimaryKeyJoinColumn(name="CUST_ID"，referencedCo
lumnName="id"))
4.public class Customer {
5.@Id(generate = GeneratorType.AUTO)
6.public Integer getId() {
7.return id;
8.}
9. }
下面的代码说明Employee和EmployeeInfo是一对一关系，Employee的主键列id作为外键指向EmployeeInfo的主键列INFO_ID。
Java代码
1.
2.@Table(name = "Employee")
3.public class Employee {
4.@OneToOne
5.@PrimaryKeyJoinColumn(name = "id", referencedColumnName="INFO_ID")
6.EmployeeInfo info;
7. }
@PrimaryKeyJoinColumns
如果entity class使用了复合主键，指定单个PrimaryKeyJoinColumn不能满足要求时，可以用PrimaryKeyJoinColumns来定义多个PrimaryKeyJoinColumn
属性说明：
?value：一个PrimaryKeyJoinColumn数组，包含所有PrimaryKeyJoinColumn
下面的代码说明了Employee和EmployeeInfo是一对一关系。他们都使用复合主键，建表时需要在Employee表建立一个外键，从Employee的主键列id,name指向EmployeeInfo的主键列INFO_ID和INFO_NAME
Java代码
1.@Entity
2.@IdClass(EmpPK.class)
3.@Table(name = "EMPLOYEE")
下面的代码说明versionNum属性作为这个类的version，映射到数据库中主表的列名是OPTLOCK
Java代码
1.@Version
2.@Column("OPTLOCK")
3.protected int getVersionNum() { return versionNum; }
@Lob
Lob指定一个属性作为数据库支持的大对象类型在数据库中存储。使用LobType这个枚举来定义Lob是二进制类型还是字符类型。
LobType枚举类型说明：
?BLOB 二进制大对象，Byte[]或者Serializable的类型可以指定为BLOB。
?CLOB 字符型大对象，char[]、Character[]或String类型可以指定为CLOB。
属性说明：
?fetch：定义这个字段是lazy loaded还是eagerly fetched。数据类型是FetchType枚举，默认为LAZY,即lazy loaded.
?type：定义这个字段在数据库中的JDBC数据类型。数据类型是LobType枚举，默认为BLOB。下面的代码定义了一个BLOB类型的属性和一个CLOB类型的属性
Java代码
1.@Lob
2.@Column(name="PHOTO" columnDefinition="BLOB NOT NULL")
3.protected JPEGImage picture;
4.
5.@Lob(fetch=EAGER, type=CLOB)
6.@Column(name="REPORT")
7.protected String report;
@JoinTable
JoinTable在many-to-many关系的所有者一边定义。如果没有定义JoinTable，使用JoinTable的默认值。属性说明：
?table：这个join table的Table定义。
?joinColumns：定义指向所有者主表的外键列，数据类型是JoinColumn数组。
?inverseJoinColumns：定义指向非所有者主表的外键列，数据类型是JoinColumn数组。
下面的代码定义了一个连接表CUST和PHONE的join table。join table的表名是CUST_PHONE，包含
两个外键，一个外键是CUST_ID，指向表CUST的主键ID，另一个外键是PHONE_ID，指向表PHONE 的主键ID。
Java代码
1.@JoinTable(
2.table=@Table(name=CUST_PHONE),
3.joinColumns=@JoinColumn(name="CUST_ID", referencedColumnName="ID"),
4.inverseJoinColumns=@JoinColumn(name="PHONE_ID", referencedColumnName="ID")
5.)
@TableGenerator
TableGenerator定义一个主键值生成器，在Id这个元数据的generate＝TABLE时，generator属性中可以使用生成器的名字。生成器可以在类、方法或者属性上定义。
生成器是为多个实体类提供连续的ID值的表，每一行为一个类提供ID值，ID值通常是整数。
属性说明：
?name：生成器的唯一名字，可以被Id元数据使用。
?table：生成器用来存储id值的Table定义。
?pkColumnName：生成器表的主键名称。
?valueColumnName：生成器表的ID值的列名称。
?pkColumnValue：生成器表中的一行数据的主键值。
?initialValue：id值的初始值。
?allocationSize：id值的增量。
下面的代码定义了两个生成器empGen和addressGen，生成器的表是ID_GEN
Java代码
1.@Entity
2.public class Employee {
3....
4.@TableGenerator(name="empGen",table=@Table(name="ID_GEN"),pkColumnName="GEN_KEY",
5. valueColumnName="GEN_VALUE",pkColumnValue="EMP_ID",allocationSize=1)
6.@Id(generate=TABLE, generator="empGen")
7.public int id;
8....
9.}
10.
11.@Entity
12.public class Address {
13....
14.@TableGenerator(name="addressGen",table=@Table(name="ID_GEN"),pkColumnValue="ADDR_ID")
15.@Id(generate=TABLE, generator="addressGen")
16.public int id;
17....
18.}
@SequenceGenerator
SequenceGenerator定义一个主键值生成器，在Id这个元数据的generator属性中可以使用生成器的名字。生成器可以在类、方法或者属性上定义。生成器是数据库支持的sequence对象。
属性说明：
?name：生成器的唯一名字，可以被Id元数据使用。
?sequenceName：数据库中，sequence对象的名称。如果不指定，会使用提供商指定的默认名称。
?initialValue：id值的初始值。
?allocationSize：id值的增量。
下面的代码定义了一个使用提供商默认名称的sequence生成器
Java代码
1.@SequenceGenerator(name="EMP_SEQ", allocationSize=25)
@DiscriminatorColumn
DiscriminatorColumn定义在使用SINGLE_TABLE或JOINED继承策略的表中区别不继承层次的列
属性说明：
?name：column的名字。默认值为TYPE。
?columnDefinition：生成DDL的sql片断。
?length：String类型的column的长度，其他类型使用默认值10。
下面的代码定义了一个列名为DISC，长度为20的String类型的区别列
Java代码
1.@Entity
2.@Table(name="CUST")
3.@Inheritance(strategy=SINGLE_TABLE,discriminatorType=STRING,discriminatorValue="CUSTOMER
")
4.@DiscriminatorColumn(name="DISC", length=20)
5.public class Customer { ... }
@NamedQuery
在使用JPA持久化规范的应用程序中，可以使用实体管理器动态创建和执行查询，也可以预定义查询并在运行时按名称执行。
使用@NamedQuery创建与@Entity或@MappedSuperclass关联的预定义查询，这些查询：?使用JPA查询语言进行基于任何基础数据库的可移植执行
?经常被使用
?比较复杂并且难于创建
?可以在不同实体之间共享
?只返回实体（从不返回标量值），并只返回一个类型的实体
属性说明：
?query：(必须属性)要指定查询，请将query 设置为JPA 查询语言（作为String）
?hints：默认值：空QueryHint 数组。默认情况下，JPA 持续性提供程序假设SQL 查询应完全按照query 属性提供的方式执行。要微调查询的执行，可以选择将hints设置为一个QueryHint 数组（请参阅@QueryHint）。在执行时，EntityManager 将向基础数据库传递提示。
?name:(必须属性)要指定查询名称，请将name设置为所需的String名称
下面的代码使用@NamedQuery批注定义一个JPA查询语言查询，该查询使用名为firstname的参数
Java代码
1.//使用 @NamedQuery 实现一个带参数的查询
2.@Entity
3.@NamedQuery(name="findAllEmployeesByFirstName",
4. query="SELECT OBJECT(emp) FROM Employee emp WHERE emp.firstName = :firstname
")
5.public class Employee implements Serializable {
6.…
7.}
8.
9.//执行命名查询
10.Query queryEmployeesByFirstName = em.createNamedQuery(“findAllEmployeesByFirstName”);
11.queryEmployeeByFirstName.setParameter(“firstName”,“John”);
12.Collection employees = queryEmployessByFirstName.getResultList();
@NamedQueries
如果需要指定多个@NamedQuery，则必须使用一个@NamedQueries指定所有命名查询
属性说明：
?value：要指定两个或更多属性覆盖，请将value设置为NamedQuery实例数组
Java代码
1.@Entity
2.@NamedQueries({@NamedQuery(name="findAllEmployeesByFirstName",
3. query="SELECT OBJECT(emp) FROM Employee emp WHERE emp.firstName = :firstname
"),
4.@NamedQuery(name="findAllEmployeesByLasttName",
5. query="SELECT OBJECT(emp) FROM Employee emp WHERE https://www.360docs.net/doc/a818042720.html,sstName = :lastname
")})
6.public class PartTimeEmployee extends Employee {
7.
8.}
@NamedNativeQuery
使用@NamedNativeQuery创建与@Entity或@MappedSuperclass关联的预定义查询，这些查询：?使用基础数据库的原生SQL
?经常被使用
?比较复杂并且难于创建
?可以在不同实体之间共享
?返回实体、标量值或两者的组合（另请参阅@ColumnResult、@EntityResult、@FieldResult 和@SqlResultSetMapping）
属性说明：
?query：(必须属性)要指定查询，请将query设置为SQL查询（作为String）
?hints：默认值：空QueryHint 数组。默认情况下，JPA 持续性提供程序假设SQL 查询应完全按照query 属性提供的方式执行。要微调查询的执行，可以选择将hints设置为一个QueryHint 数组（请参阅@QueryHint）。在执行时，EntityManager 将向基础数据库传递提示。
?name：(必须属性)要指定查询名称，请将name设置为所需的String名称
?resultClass：默认值：JPA 持续性提供程序假设结果类是关联实体的Class.要指定结果类，请将resultClass设置为所需的Class
?resultSetMapping：默认值：JPA持续性提供程序假设原生SQL查询中的SELECT语句：返回一个类型的实体；包括与返回的实体的所有字段或属性相对应的所有列；并使用与字段或属性名称（未使用AS语句）相对应的列名。要控制JPA持续性提供程序如何将JDBC结果集映射到实体字段或属性以及标量，请通过将resultSetMapping设置为所需的@SqlResultSetMapping的String 名称来指定结果集映射
Java代码
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.360docs.net/doc/a818042720.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.360docs.net/doc/a818042720.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作为维护端即主