hibernate 表关联 多对一 一对多 多对多

Xml代码   收藏代码
  1. 首先是xml文件配置的多对一:  
  2.   
  3. <many-to-one name="brand" column="brand" class="com.tch.model.Brand" />  
  4. brand是实体类中的属性,class对于类的全称  column对于外键  
  5.     
  6. xml文件配置的一对多:             
  7. <set name="productstock" inverse="true" cascade="all" lazy="true" batch-size="30">  
  8.             <key column name="product" /> //外键          
  9.             <one-to-many class="com.tch.model.stock.ProductStock" />  
  10. set>  
  11.   
  12. 多对多只需要将 one-to-many换成many-to-many即可  
  13.   
  14. 单向一对一可以通过component配置:  
  15. <component name="wmsExtend" class="com.tch.model.Pro">  
  16.             <property name="pfDateFlag" type="java.lang.String" column="pfDateFlag" />  
  17. component>  
  18.   
  19.   
  20. 注解配置一对多:  
  21.   
  22. @OneToMany(cascade = javax.persistence.CascadeType.ALL, fetch = FetchType.LAZY, mappedBy = "mallStore")   //mallStore是多的一方里面保存的一的一方的属性。  
  23. @BatchSize(size=50)   
  24.   
  25.   
  26. 注解配置多对一:  
  27.   
  28. @ManyToOne(optional = falsefetch = FetchType.LAZY,cascade=....)  
  29. @JoinColumn(name = "foreign_key"nullable = false)  
  30.   
  31. 注解配置多对多:  
  32. @ManyToMany(mappedBy="",cascade=CascadeType.ALL,fetch=FetchType.LAZY)  
  33. @JoinTable(name="",joinColumns={@JoinColumn(name="")},inverseJoinColumns={@JoinColumn(name="")})  

 

下面是马士兵视频的笔记,转自   

hibernate马士兵笔记

Java代码   收藏代码
  1. 1 新建项目   
  2. 2 学习建立user-library-hibernate,并加入相应的jar包   
  3.   a项目右键-build path-configure build path-add library   
  4.   b选择user-library,在其中新建library,命命为hibernate   
  5.   c 在该library中加入hibernate所需要的jar包   
  6.              hibernate3.3.2   
  7. /hibernate3.jar   
  8. /lib/required目录下的所有包 6个   
  9. Sl4j-nop jar   
  10. 3 引入mysql的JDBC驱动包   
  11. 4 在MYSQL中建数据库和相应的表student(id,name,age)   
  12. 5 建立hibernate配置文件hibernate.cfg.xml   
  13. 参考文档中COPY,修改对应的数据库连接,   
  14. 6 建立student类   
  15. 7 建立映射文件Student.hbm.xml 参考相应文档   
  16. 8 将映射文件加到hibernate-cfg.xml中   
  17.   
  18. 搭建日志环境并配置显示DDL语句   
  19. slf的实现:slf4j nodep ,log4j ,jdk logging api ,apache common-log.   
  20. slf4j.nop.jar是slf-api.jar其相应的接口实现   
  21. 把slf的接口对到log4j的实现,在user library中hibernate,把slf的实现slf4j-nop-1.5.8.jar去掉,添加log4j的实现log4j-1.2.15.jar,再添加一个slf-api和log4j转换器slf4j-log4j12-1.5.8.jar.   
  22. 把slf的接口转换成log4j的接口.最后添加一个log4j的配置文件log4j.properties   
  23.   
  24.   
  25. 利用HIBERNATE导出数据库建表   
  26. //读取配置文件hibernate.cfg.xml   
  27. Configuration cfg=new AnnotationConfiguration().configure();(有注解时使用AnnotationConfiguration),configure()可以手动指定配置文件名称.   
  28. Configuration cfg=new Configuration(),会默认读取hibernate.properties文件   
  29. //创建schemaExport对象   
  30. import org.hibernate.tool.hbm2ddl.SchemaExport;   
  31. SchemaExport export=new SchemaExport(cfg);   
  32. //创建数据库表   
  33. export.create(truetrue);   
  34.   
  35.   
  36. 对象映射(采用Annotation注解方式)   
  37. 1 建表   
  38.   Create table teacher(id int primary key,name varchar(20),title varchar(20));   
  39. 2 创建teacher类,并进行注解@   
  40. import javax.persistence.Entity;   
  41. import javax.persistence.Id;   
  42. 在bean中加注解   
  43. @ Entity,@Id(加在getId()上面)   
  44. 3 在hibernate中加入annotation相应的jar包   
  45.              hibernate-annotations.jar   
  46.              /lib目录下加入相应的包ejb3-persistence.jar, hibernate-commons-annotations.jar   
  47. 注意:annotation文档中并没有提到hibernate-annotations.jar包   
  48. 4 参考annotation文档建立对应的注解   
  49. 5 在hibernate.cfg.xml中建立映射   
  50. class=”com.xx.xx”/>   
  51. 6 示例   
  52. //AnnotationConfiguration;   
  53.              Configuration cfg=new AnnotationConfiguration();   
  54.              SessionFactory sf=cfg.configure().buildSessionFactory();   
  55.              Session session=sf.openSession();   
  56.              session.beginTransaction();   
  57.              session.save(t);//   
  58.              session.getTransaction().commit();   
  59.              session.close();   
  60.              sf.close();   
  61.   
  62.   
  63. 对象映射(采用配置文件方式)   
  64. 1 在相应的类中建立对应的配置文件.   
  65. 例如Student类对应的配置文件Student.hbm.xml   
  66. package="com.model">   
  67.        <class name="Student" table=" Student" >   
  68.              "id" column="id">   
  69.              "name" column="name" />   
  70.              "age" column="age" />   
  71.        class>   
  72.    
  73. 2 在hibernate.cfg.xml中添加该映射文件Student.hbm.xml即可   
  74.        
  75.     "com/model/Student.hbm.xml"/>注意包名的写法   
  76. 3 示例   
  77. //读取配置文件hibernate.cfg.xml   
  78.              Configuration cfg=new Configuration().configure();   
  79. //创建SessionFactory   
  80.              SessionFactory sf=cfg.configure().buildSessionFactory();   
  81. //创建session   
  82.              Session session=sf.openSession();   
  83.              session.beginTransaction();   
  84.              session.save(s);   
  85.              session.getTransaction().commit();   
  86.              session.close();   
  87.              sf.close();   
  88.   
  89. hibernate.cfg.xml配置   
  90. hibernate.hbm2ddl.auto属性   
  91. 取值: validate | update | create | create-drop   
  92. 在sessionfactory创建时,自动检查数据结构,或者将数据库schema(表)的DDL导出到数据库,使用create-drop时,在显式关闭sessionfactory时,将drop掉数据库schema.   
  93. validate               加载hibernate时,验证创建数据库表结构   
  94. create                  每次加载hibernate,重新创建数据库表结构   
  95. create-drop        加载hibernate时创建,退出是删除表结构   
  96. update                 加载hibernate自动更新数据库结构   
  97.   
  98.   
  99. 表名和类名不同的情况时,对表名进行配置   
  100. 1 在注解中   
  101. import javax.persistence.Table;   
  102. @Table(name=”TableName”)   
  103. 2 在XML文件中   
  104. package="com.model">   
  105.                   <class name="Teacher" table="Teacher" >配置对应的table属性为相应的表名   
  106.                                    "id" column="id">   
  107.                   …   
  108.                   class>   
  109.    
  110.   
  111. 字段名和属性名相同,默认为   
  112. 对于annotation,如果什么注解都不写的话,相当于加了注解@Basic   
  113. 实体bean中所有的非statictransient的属性都可以被持久化, 除非你将其注解为@Transient.所有没有定义注解的属性等价于在其上面添加了@Basic注解. 通过 @Basic注解可以声明属性的获取策略(fetch strategy):   
  114. 对于XML文件中不用写column.   
  115.   
  116. 字段名和属性名不同时   
  117. Annotation:@column(name=”column_name”)加上相应的getXXX()方法上   
  118. XML:column属性   
  119.   
  120. 不需要persistence的字段   
  121. import javax.persistence.Transient;   
  122. @ Transient 意思是说这个属性是透明的,不进行持久化,存储的时候不存进去   
  123.   
  124. 映射日期和时间类型,指定时间精度   
  125. Annotation:   
  126. import javax.persistence.Temporal;   
  127. @Temporal(TemporalType.TIME)   
  128. XML:指定type   
  129. <class name="Teacher" table="Teacher" >   
  130.                                    "id" column="id">   
  131.                                    "name" type="time" />type=time或date   
  132. class>   
  133.   
  134. 枚举类型的转换   
  135. @Enumerated(EnumType.STRING)   
  136.   
  137. 字段映射的位置   
  138. 推荐写在gexXXX方法上   
  139.   
  140. Hibernate映射类型   
  141.   
  142. Hibernate 映射类型   
  143. Java 类型   
  144. 标准 SQL 类型   
  145. 大小和取值范围   
  146.   
  147. integer 或者 int   
  148. int 或者 java.lang.Integer   
  149. INTEGER   
  150. 4 字节   
  151.   
  152. long   
  153. long  Long   
  154. BIGINT   
  155. 8 字节   
  156.   
  157. short   
  158. short  Short   
  159. SMALLINT   
  160. 2 字节   
  161.   
  162. byte   
  163. byte  Byte   
  164. TINYINT   
  165. 1 字节   
  166.   
  167. float   
  168. float  Float   
  169. FLOAT   
  170. 4 字节   
  171.   
  172. double   
  173. double  Double   
  174. DOUBLE   
  175. 8 字节   
  176.   
  177. big_decimal   
  178. java.math.BigDecimal   
  179. NUMERIC   
  180. NUMERIC(8,2)8 位   
  181.   
  182. character   
  183. char  Character  String   
  184. CHAR(1)   
  185. 定长字符   
  186.   
  187. string   
  188. String   
  189. VARCHAR   
  190. 变长字符串   
  191.   
  192. boolean   
  193. boolean  Boolean   
  194. BIT   
  195. 布尔类型   
  196.   
  197. yes_no   
  198. boolean  Boolean   
  199. CHAR(1) (Y-N)   
  200. 布尔类型   
  201.   
  202. true_false   
  203. boolean  Boolean   
  204. CHAR(1) (T-F)   
  205. 布尔类型   
  206.   
  207.   
  208.   
  209. 2 、 Java 时间和日期类型的 Hibernate 映射   
  210.   
  211. 映射类型   
  212. Java 类型   
  213. 标准 SQL 类型   
  214. 描述   
  215.   
  216. date   
  217. util.Date 或者 sql.Date   
  218. DATE   
  219. YYYY-MM-DD   
  220.   
  221. time   
  222. Date    Time   
  223. TIME   
  224. HH:MM:SS   
  225.   
  226. timestamp   
  227. Date   Timestamp   
  228. TIMESTAMP   
  229. YYYYMMDDHHMMSS   
  230.   
  231. calendar   
  232. calendar   
  233. TIMESTAMP   
  234. YYYYMMDDHHMMSS   
  235.   
  236. calendar_date   
  237. calendar   
  238. DATE   
  239. YYYY-MM-DD   
  240.   
  241.   
  242.   
  243. 3 、 Java 大对象类型的 Hibernate 映射类型   
  244.   
  245. 映射类型   
  246. Java 类型   
  247. 标准 SQL 类型   
  248. MySQL 类型   
  249. Oracle 类型   
  250.   
  251. binary   
  252. byte[]   
  253. VARBINARY( 或 BLOB)   
  254. BLOB   
  255. BLOB   
  256.   
  257. text   
  258. String   
  259. CLOB   
  260. TEXT   
  261. CLOB   
  262.   
  263. serializable   
  264. Serializable 接口任意实现类   
  265. VARBINARY( 或 BLOB)   
  266. BLOB   
  267. BLOB   
  268.   
  269. clob   
  270. java.sql.Clob   
  271. CLOB   
  272. TEXT   
  273. CLOB   
  274.   
  275. blob   
  276. java.sql.Blob   
  277. BLOB   
  278. BLOB   
  279. BLOB   
  280.   
  281.   
  282.   
  283.        在程序中通过 Hibernate 来保存 java.sql.Clob 或者 java.sql.Blob 实例时,必须包含两个步骤:   
  284. 1        在一个数据库事务中先保存一个空的 Blob 或 Clob 实例。   
  285. 2             接着锁定这条记录,更新上面保存的 Blob 或 Clob 实例,把二进制数据或文本数据写到 Blob 或 Clob 实例中   
  286.   
  287. Hibernate SQL方言 (hibernate.dialect)   
  288.   
  289. RDBMS   
  290. 方言   
  291.   
  292. DB2   
  293. org.hibernate.dialect.DB2Dialect   
  294.   
  295. DB2 AS/400   
  296. org.hibernate.dialect.DB2400Dialect   
  297.   
  298. DB2 OS390   
  299. org.hibernate.dialect.DB2390Dialect   
  300.   
  301. PostgreSQL   
  302. org.hibernate.dialect.PostgreSQLDialect   
  303.   
  304. MySQL   
  305. org.hibernate.dialect.MySQLDialect   
  306.   
  307. MySQL with InnoDB   
  308. org.hibernate.dialect.MySQLInnoDBDialect   
  309.   
  310. MySQL with MyISAM   
  311. org.hibernate.dialect.MySQLMyISAMDialect   
  312.   
  313. Oracle (any version)   
  314. org.hibernate.dialect.OracleDialect   
  315.   
  316. Oracle 9i/10g   
  317. org.hibernate.dialect.Oracle9Dialect   
  318.   
  319. Sybase   
  320. org.hibernate.dialect.SybaseDialect   
  321.   
  322. Sybase Anywhere   
  323. org.hibernate.dialect.SybaseAnywhereDialect   
  324.   
  325. Microsoft SQL Server   
  326. org.hibernate.dialect.SQLServerDialect   
  327.   
  328. SAP DB   
  329. org.hibernate.dialect.SAPDBDialect   
  330.   
  331. Informix   
  332. org.hibernate.dialect.InformixDialect   
  333.   
  334. HypersonicSQL   
  335. org.hibernate.dialect.HSQLDialect   
  336.   
  337. Ingres   
  338. org.hibernate.dialect.IngresDialect   
  339.   
  340. Progress   
  341. org.hibernate.dialect.ProgressDialect   
  342.   
  343. Mckoi SQL   
  344. org.hibernate.dialect.MckoiDialect   
  345.   
  346. Interbase   
  347. org.hibernate.dialect.InterbaseDialect   
  348.   
  349. Pointbase   
  350. org.hibernate.dialect.PointbaseDialect   
  351.   
  352. FrontBase   
  353. org.hibernate.dialect.FrontbaseDialect   
  354.   
  355. Firebird   
  356. org.hibernate.dialect.FirebirdDialect   
  357.   
  358.   
  359.   
  360.   
  361.   
  362. ID生成策略   
  363. 1.XML方式配置   
  364. 可选的子元素是一个Java类的名字, 用来为该持久化类的实例生成唯一的标识。如果这个生成器实例需要某些配置值或者初始化参数, 用元素来传递。   
  365. "id" type="long" column="cat_id">   
  366.         class="org.hibernate.id.TableHiLoGenerator">   
  367.                 "table">uid_table   
  368.                 "column">next_hi_value_column   
  369.            
  370.    
  371. 所有的生成器都实现org.hibernate.id.IdentifierGenerator接口。 这是一个非常简单的接口;某些应用程序可以选择提供他们自己特定的实现。当然, Hibernate提供了很多内置的实现。下面是一些内置生成器的快捷名字:   
  372. l  increment 用于为longshort或者int类型生成 唯一标识。只有在没有其他进程往同一张表中插入数据时才能使用。 在集群下不要使用。   
  373. l  identity 对DB2,MySQL, MS SQL Server, Sybase和HypersonicSQL的内置标识字段提供支持。 返回的标识符是longshort 或者int类型的。   
  374. l  sequence 在DB2,PostgreSQL, Oracle, SAP DB, McKoi中使用序列(sequence), 而在Interbase中使用生成器(generator)。返回的标识符是longshort或者 int类型的。   
  375. l  hilo 使用一个高/低位算法高效的生成longshort 或者 int类型的标识符。给定一个表和字段(默认分别是 hibernate_unique_key 和next_hi)作为高位值的来源。 高/低位算法生成的标识符只在一个特定的数据库中是唯一的。   
  376. l  seqhilo 使用一个高/低位算法来高效的生成longshort 或者 int类型的标识符,给定一个数据库序列(sequence)的名字。   
  377. l  uuid 用一个128-bit的UUID算法生成字符串类型的标识符, 这在一个网络中是唯一的(使用了IP地址)。UUID被编码为一个3216进制数字的字符串。   
  378. l  guid 在MS SQL Server 和 MySQL 中使用数据库生成的GUID字符串。   
  379. l  native 根据底层数据库的能力选择identity, sequence 或者hilo中的一个。在mysql中默认的是auto_increment,SQLSERVER中是identity.   
  380. l  assigned 让应用程序在save()之前为对象分配一个标示符。这是 元素没有指定时的默认生成策略。  
  381. l  select 通过数据库触发器选择一些唯一主键的行并返回主键值来分配一个主键。   
  382. l  foreign 使用另外一个相关联的对象的标识符。通常和联合起来使用。   
  383. l  sequence-identity 一种特别的序列生成策略,使用数据库序列来生成实际值,但将它和JDBC3的getGeneratedKeys结合在一起,使得在插入语句执行的时候就返回生成的值。目前为止只有面向JDK 1.4的Oracle 10g驱动支持这一策略。注意,因为Oracle驱动程序的一个bug,这些插入语句的注释被关闭了。(原文:Note comments on these insert statements are disabled due to a bug in the Oracle drivers.)   
  384. 2 annotation中配置id生成策略   
  385. 使用@Id注解可以将实体bean中的某个属性定义为标识符(identifier). 该属性的值可以通过应用自身进行设置, 也可以通过Hiberante生成(推荐).   
  386. 使用 @GeneratedValue注解可以定义该标识符的生成策略: 有四种策略   
  387. l  AUTO -默认值.可以是identity column类型,或者sequence类型或者table类型,取决于不同的底层数据库..对于MYSQL,是auto_increment,对于Oracle是hibernate-sequence.   
  388. l  TABLE - 使用表保存id值 (了解)   
  389. l  IDENTITY - identity column   
  390. l  SEQUENCE - @SequenceGenerator   
  391. @GeneratedValue(strategy=GenerationType.XXXX)   
  392. XXXX取值为Type.SEQUENCE|TABLE|AUTO|IDENTITY不同的数据库对应着不同的生成策略.   
  393. 1   
  394. 实体类注解   
  395. @Entity   
  396. 主键进行注解   
  397. @Id   
  398. @GeneratedValue   
  399. 默认值是@GeneratedValue(strategy=GenerationType.AUTO)   
  400. 2   
  401. 使用SequenceGenerator   
  402. @Entity   
  403. @SequenceGenerator(   
  404. name="teacher_SEQUENCE",sequenceName="teacher_SEQUENCE_DB")   
  405. name是用户自定义的generator生成器的名字, sequenceName是生成到数据库后sequence对象的名字.   
  406. 在实体中注解好后,就可以在id注解上写上对应的   
  407. @Id   
  408. @GeneratedValue(   
  409. strategy=GenerationType.IDENTITY,generator="teacher_SEQUENCE")   
  410. 3   
  411. 表生成器(了解),这种方式会另外生成一个表.   
  412. 实体类注解   
  413. @Entity   
  414. @javax.persistence.TableGenerator(//了解,更适合用于跨平台跨数据库.   
  415.            name="TEACHER_GEN"//生成器generator的名字   
  416.            table="GENERATOR_TABLE",//生成的表名   
  417.            pkColumnName = "pk_key",//生成的表的字段名   
  418.            valueColumnName = "pk_value",//生成的表的字段的值   
  419.            pkColumnValue="teacher",// pk_key字段的值   
  420.            allocationSize=1//自增变量   
  421.        )   
  422. 主键注解   
  423. @Id   
  424. @GeneratedValue(strategy=GenerationType.TABLE,generator="TEACHER_GEN")   
  425.   
  426.   
  427. l  联合主键生成策略   
  428. 一般采用这种方式,比如有一个类Student(id,name,age),为了产生联合主键,把id和name分离出来.   
  429. Student(pk,age) StudentPk(id,name)   
  430. StudentPk类必需实现序列化接口implements java.io.Serializable.   
  431. StudentPk类必需重写boolean equals() ,int hasCode()方法   
  432. @Override   
  433.                   public boolean equals(Object o) {   
  434.                                    if(o instanceof StudentPk) {   
  435.                                                      StudentPk pk = (StudentPk)o;   
  436.                                                      if(this.id == pk.getId() && this.name.equals(pk.getName())) {   
  437.                                                                        return true;   
  438.                                                      }   
  439.                                    }   
  440.                                    return false;   
  441.                   }   
  442.                     
  443.                   @Override   
  444.                   public int hashCode() {   
  445.                                    return this.name.hashCode();   
  446.                   }   
  447. 联合主键生成策略XML配置方法   
  448. "pk" class="com.hibernate.StudentPk">   
  449.                     "id">   
  450.                     "name">   
  451.    
  452. 联合主键生成策略annotation配置方法   
  453. 定义组合主键的三种方式:   
  454. l  (少用)将组件类注解为@Embeddable,并将组件的属性注解为@Id.   
  455. 实体模型Teacher(teacherPK,age) TeacherPk(id,name)   
  456. 在TeacherPk(id,name)中把类注解@Embeddable   
  457. 在Teacher(teacherPK,age)中把组件属性teacherPK注解@Id   
  458. l  将组件的属性注解为@EmbeddedId.   
  459. 实体模型Teacher(teacherPK,age) TeacherPk(id,name)   
  460. 只需要在Teacher(teacherPK,age)中把组件属性teacherPK注解@EmbeddedId   
  461. l  (推荐使用)将类注解为@IdClass,并将该实体中所有属于主键的属性都注解为@Id.   
  462. 实体模型Teacher(id,name,age) TeacherPk(id,name)   
  463. 在Teacher(id,name,age)中把类注解@IdClass(value=”TeacherPk.Class”),在主键属性id,name上注解@Id即可.当IdClass()中只有一个属性默认写成IdClass(TeacherPk.Class).也就是说Teacher里面的组件属性id,name,合起来刚好是类TeacherPk.   
  464.   
  465.   
  466. 对象的三种状态   
  467.   
  468. 三种状态的区别在于:   
  469. 有没有ID,ID在数据库中有没有,在内存中有没有(session缓存)   
  470. 三种状态   
  471. Transient:内存中的一个对象,没有ID,缓存中也没有   
  472. Persistent:内存中有,缓存中有,数据库中有ID   
  473. Detached:内存中有,缓存中没有,数据库有ID   
  474.   
  475. 核心接口开发介绍   
  476. Configuration   
  477. 1 AnnotationConfiguration   
  478. 2 进行配置信息的管理   
  479. 3 用来产生SessionFactory:buildSessionFactory()   
  480. 4 可以在configure()方法中指定hibernate配置文件   
  481.   
  482. SchemaExport   
  483. 可以在程序中控制生成建表语名.   
  484. 位于包import org.hibernate.tool.hbm2ddl.SchemaExport;   
  485. create(boolean script,boolean export)   
  486. script - print the DDL to the console   
  487. export - export the script to the database   
  488. Configuration cfg=new AnnotationConfiguration().configure();   
  489. SchemaExport export=new SchemaExport(cfg);   
  490. export.create(truetrue);   
  491. 或者   
  492. new SchemaExport(new AnnotationConfiguration().configure()).create(falsetrue);   
  493.   
  494. SessionFactory   
  495. 1 用来产生和管理sesssion   
  496. 2 通常情况下,每个应用只需要一个SessionFactory,除非要访问多个数据库的情况   
  497. 3 openSession()与openSession()   
  498. l  openSession()总是创建新的session,需要手动close().   
  499. l  getCurrentSession()事务自动提交并且自动关闭.从上下文环境中获得session,如果当时环境中不存就创建新的.如果环境中存在就使用环境中的,而且每次得到的都是同一个session(在session提交之前,提交之后就是新的了).用途:界定事务边界.   
  500. l  所谓的上下文参见配置文件   
  501. "current_session_context_classs">thread   
  502. 取值范围 jta | thread | managed | custom.Class   
  503.   
  504. JTA简介   
  505.   
  506. Session   
  507. 管理一个数据库的任务单元,即管理数据库中的增删改查操作,提交事务.   
  508. 方法CRUD:save(),delete(),update(),saveOrUpdate(),load(),get(),clear().   
  509. session.beginTransaction();   
  510. session.save(Object obj);   
  511. session.getTransaction().commit();   
  512. session.close();   
  513.   
  514. get()与load()的区别   
  515. l  查找时,都会优先从session的缓存中查找.   
  516. l  查找不存在对应记录时,表现不一样.load方法查找不到时不会报错,get查找不到时会报错.   
  517. l  Load返回的是代理对象,等到真正要用到对象的内容时才发起SQL语句.get直接发起SQL语句从数据库中取出,不会延迟.   
  518. Update()方法   
  519. 1 用来更新detached对象,更新完成之后成为persistent.   
  520. 2 更新transient对象会报错. 更新自己设定id(前提是id在数据库中存在)的transient对象可以.   
  521. 3 持久化的对象只要设定不同字段就会发生更新   
  522. 4 更新部分更改的字段(三种方法)   
  523. l  XML设定property标签的update=true|false属性,   
  524. annotation设定@Column(updatable=false)属性,这种方式少用,不灵活.   
  525. l  XML设定class标签的dynamic-update=”true”属性,   
  526. 同一个session中可以,跨session不行.跨session时的实现方法不过可以用session的merge().merge方法会先从数据库load,将得到的和数据库中的进行对比,再update更改过的字段.   
  527. JPA1.0 Annotation没有对应的属性,Hibernate   
  528. l  使用HQL(EJBQL)(建议使用)   
  529. clear()方法:   
  530. 清除session中的缓存.调用clear()方法会强制清除session缓存.不会与数据库打交道.   
  531. flush()方法:   
  532. 当session的事务提交后,会强制进行从内存(session缓存)到数据库的同步.默认情况下是session的事务提交时才同步.不常用.   
  533.   
  534. Query接口   
  535.   
  536. 关系映射   
  537. 这里的关系映射指的是对象之间的关系,并不是指数据库的关系. 关系映射解决的问题是,当对象处于各种关系时,数据库表该如何映射,编程时如何处理.   
  538. 一对一:单向(主键,外键),双向(主键,外键)   
  539. 一对多:单向,双向(和多对一双向相同)   
  540. 多对一:单向,双向(一对多双向和多对一双向是一样的)   
  541. 多对多:单向,双向   
  542. (一对一单/双向主键关联映射,只作了解)   
  543. 集合映射:list ,map,set   
  544. 继承映射(了解):单表,多表,一张主表多张子表   
  545. 组件映射:@Embeddable,@Embedded   
  546.   
  547.   
  548.   
  549. 一对一(one to one) 单向关联映射   
  550. 两个对象是一对一的的关系.   
  551. 有两种策略可以实现一对一的关联映射   
  552. l  主键关联:即让两个对象具有相同的主键值,以表明他们之间的一对一的对应关系;数据库表不会有额外的字段来维护他们之间的关系,仅通过表的主键关系来维护.一对一主键关联映射默认了级联属性,其关联对象会同时存储.所以不会抛出TransientObjectException异常.   
  553. l  唯一外键关联:外键关联,本来是用于多对一的配置,但是如果加上唯一的限制之后,也可以表示一对一的关联关系. unique="true".   
  554. 单向关联,如Person-person_id;加载person信息时能关联对应的person_id信息   
  555. 双向关系,加载任何一方,都能关联出别一方的信息.   
  556. 注意id的主键生成策略,foreign使用另外一个相关联的对象的标识符。通常和联合起来使用。   
  557. 类Person(id,name,idCard),   
  558. 类IdCard(id,cardNo)   
  559.   
  560. 一对一(单向)基于主键关联映射(了解)   
  561. XML配置方法   
  562. 一对一单向主键关联通常使用一个特定的id生成器。   
  563. <class name="Person" table=”t_person”>   
  564.     "id" >   
  565.         class="foreign">   
  566.             "property">idCard   
  567.            
  568.        
  569.     "idCard" constrained="true"/>   
  570. class>   
  571. one-to-one不会加载字段,它告诉HIBERNATE怎样加载其引用对象.如何加载呢,默认根据主键加载其引用对象.如在t_person中查到id=2,自动加载t_idCard中id=2的对象信息. constrained="true",表明person主键是个外键,表示当前主键上存在着idCard约束,当前主键id作为外键,参照了idCard.   
  572. "property">idCard表明person中的id来源于idCard,也就是共享idCard的主键.   
  573. Annotation配置一对一(单向)主键关联映射.(BUG)   
  574. @OneToOne   
  575. @PrimaryKeyJoinColumn   
  576. 有BUG,系统不会生成主键映射.推荐使用XML配置方法.   
  577.   
  578. 一对一(单向)基于外键关联映射   
  579. 和单向多对一关联几乎是一样的。唯一不同的就是单向一对一关联中的外键字段具有唯一性约束。这种方法会在表中生成一个新的外键字段.如果不限制外字段的唯一性约束,就会导致产生多对一的关联. 指定多的一端unique="true",这样就限制了多的一端的多重性为一.   
  580. <class name="Person" table=”t_person”>   
  581.     "id" >   
  582.         class="native"/>   
  583.    
  584.    
  585.     "idCard" column="addressId" unique="true"        not-null="true"/>   
  586. class>   
  587. 这种状态注意TransientObjectException异常.在保存时就先保存外键idCard,再保存Person类.   
  588. 一对一单向外键关联Annotation配置   
  589. @OneToOne   
  590. @JoinColumn(name="指定生成的外键字段名字")   
  591.   
  592. 一对一(双向)主键关联映射(了解)   
  593. PersonßàIdCard.在另一端也加上一个一对一的单向关联映射.   
  594. 模型对象   
  595. Person(id,name,idCard)   
  596. IdCard(id,cardNo,person)中,双方都持有对方的属性引用.   
  597. 一对一(双向)主键关联映射XML配置方式   
  598. 在IdCard配置中建立映射,"person"/>指示Hibernate如何加载,默认情况下根据主键加载.也就是在基于单向一对一的映射中, 在另一端也加上一个单向一对一的主键关联映射.   
  599. 在Person一端配置   
  600. <class name="Person" table=”t_person”>   
  601.     "id" >   
  602.         class="foreign">   
  603.             "property">idCard   
  604.            
  605.        
  606.     "idCard" constrained="true"/>   
  607. class>   
  608. 在另一端IdCard配置   
  609. <class name=" IdCard " table=”t_idCard”>   
  610.     "id" >   
  611.         class="native"/>   
  612.    
  613.    
  614.     "person" property-ref=”idCard” />   
  615. class>   
  616. 一对一(双向)主键关联映射Annotation(有BUG)   
  617. 在两端各自的引用属性上加上   
  618. @OneToOne   
  619. @PrimaryKeyJoinColumn   
  620.   
  621. 一对一(双向)唯一外键关联映射   
  622. Personß----àIdCard.在另一端也加上一个一对一的单向关联映射.   
  623. 在模型对象   
  624. Person(id,name,idCard)   
  625. IdCard(id,cardNo,person),   
  626. 双方都持有对方的属性引用.   
  627. 需要在另一端加上,指示hibernate如何加载,默认情况下根据主键加载person;因为外键关联映射中,两个实体的关系是由person的外键idCard来维护的,所以不能指定person的主键来加载person,而应根据person的外键idCard来加载person对象.   
  628. 一对一双向外键关联映射XML配置方式   
  629. Person一端:用多对一配置外键唯一形成一对一的配置方式.   
  630. <class name="Person" table=”t_person”>   
  631.     "id" >   
  632.         class="native"/>   
  633.    
  634.    
  635.     "idCard" column="addressId" unique="true"/>class>   
  636. IdCard一端:一对一,引用另一端外键   
  637. <class name=" IdCard " table=”t_idCard”>   
  638.     "id" >   
  639.         class="native"/>   
  640.    
  641.    
  642. "person" property-ref="idCard"/>   
  643. class>   
  644. 要想加载idCard,如果不加property-ref,默认根据person主键id来加载,property- ref="idCard"就指示hibernate从person里面的idCard属性来加载.   
  645. 一对一双向外键关联映射Annotation配置方式   
  646. 双方互持对方的属性的引用   
  647. 关系模型   
  648. Husband(id,name,wife)   
  649. Wife(id,name,husband)   
  650. 在Husband一端的wife属性上注解   
  651. @OneToOne   
  652. //@JoinColumn   
  653. 在Wife一端的husband加上注解,mappedBy   
  654. @OneToOne(mappedBy="wife")引用属性   
  655. 加上mappedBy属性后就可以在wife这一端告知这个关联是在wife属性上设置的.就不用管理wife这一端生成的husband的设置.生成的wife表格不会有husband字段.   
  656. 规律:有双向关联时mappedBy通常必设.   
  657.   
  658. 联合主键一对一单向外键关联映射   
  659. 对象模型   
  660. Wife(id,name,age) WifePk(id,name)   
  661. Husband(id,name,wife)   
  662. 1 在Wife中建立联合主键生成策略   
  663.   @IdClass(WifePk.Class)   
  664.   @Id   
  665. 2 在Husband中添加个外键即可   
  666.   @OneToOne   
  667. 3自定义Husband中外键的名字   
  668.     @OneToOne   
  669. @JoinColumns(   
  670.               {   
  671.                     @JoinColumn(name="wifeId", referencedColumnName="id"),   
  672.                     @JoinColumn(name="wifeName", referencedColumnName="name")   
  673.               }   
  674.        )   
  675. XML配置方式:略   
  676.   
  677. 组件映射   
  678. 对象关系:一个对象是另一个对象的一部分   
  679. 数据库表:是一张表   
  680. Annotation:@Embeddable,@Embedded   
  681. XML:   
  682. 对象模型   
  683. Husband(id,name,wife)   
  684. Wife(wifeName,wifeAge)   
  685. Annotation:   
  686. 在Husband的wife属性上建立注解   
  687. @Embedded 表明该对象是从别的位置嵌入过来的,是不需要单独映射的表.   
  688. 这种方式生成的表为husband(id,name,wifename,wifeage),不会生成wife表.   
  689. @AttributeOverride注解可以覆盖该属性对应的嵌入式对象的列映射:   
  690. XML:   
  691. <class name="Husband" >   
  692.              "id">   
  693.                     class="native"/>               
  694.    
  695.              "name">   
  696.              "wife">   
  697.                     "wifeName"/>                     
  698. "wifeAge"/>   
  699.                 
  700. class>   
  701.   
  702. 多对一(many to one)单向关联映射   
  703. 多对一的数据库设计原则:在多的那下端加外键   
  704. //注意在创建实体类属性时应尽量避免与SQL语句中的关键字重名.   
  705. 多对一单向关联映射   
  706. 实体模型(User多对一Group)   
  707. User(id,name,group)多   
  708. Group(id,groupname)一   
  709.   
  710. Annotation配置   
  711. @Entity   
  712. @Table(name="t_group")//注意表名与SQL中关键字重名   
  713. 只需要在多的一端User属性group进行注解配置   
  714. @ManyToOne   
  715. @JoinColumn(name=”groupId”)   
  716. XML配置   
  717. "group" column="groupId" />   
  718. 标签会在”多”的一端添加外键,相当于在数据库中添加外键   
  719. 生成的表为user(id,name,groupid),t_group(id,groupname)   
  720. 属性cascade   
  721. "group" column="groupid" cascade="all"/>   
  722. 取值all,none,save-update,delete,对象间的级联操作,只对增删改起作用.   
  723. 在存储时User时,设置了cascade="all"会自动存储相应的t_group.而不用管user关联的对象(通常情况下会优先存储关联的对象,然后再存储user).   
  724.   
  725. 一对多(one to many)单向关联映射   
  726. 模型(group一对多user)   
  727. Group(id,name,users)一   
  728. User(id,name)多   
  729. 设计时在一的这一端存在着多的集合,生成的数据库表通常是在多的一端生成外键.   
  730. Set users=new HashSet()   
  731. 一对多单向外键关联映射   
  732. 在一的这一端Group端users属性上进行注解配置   
  733. @OneToMany   
  734. @JoinColumn(name="groupId")   
  735. 如果不指定生成的外键列@JoinColumn(name="groupId"),默认会生成多对多的关系,产生一张中间表.   
  736. XML配置中配置一的那一端Group   
  737. <class name="com.hibernate.Group" table="t_group">   
  738.              "id">   
  739.                     class="native"/>   
  740.                 
  741.              "name"/>   
  742.              "users">   
  743.                     "groupId"/>指定生成外键字段的名字   
  744.                     class="com.hibernate.User"/>   
  745.                 
  746. class>   
  747.   
  748.   
  749. 规律:   
  750. l  单向时, 一方存在另一方的引用,数据库表中体现为外键.配置时一般只用配置一端.   
  751. l  双向时,双方互持对方的引用,要进行双向两端的配置.基于annotation的双向配置中,在一端配置好后,在另一端必须用指定mappedby属性.   
  752. l  关于一对多/多对一数据库设计时,总是在多的一端加外键.通常在多的一端指定生成的外键名称.   
  753.   
  754. 一对多/多对一双向关联   
  755. 一对多与多对一的双向关联是同一种情况.   
  756. 关系模型(group一对多user)   
  757. Group(id,name,users)一   
  758. User(id,name,group)多   
  759. Set users=new HashSet()   
  760. 配置规则:一般以多的一端为主,先配置多的一端   
  761. 在多的一端User端配置group   
  762. @ManyToOne   
  763. 在一的一端Group端配置时,在users只需要加个mappedBy="group"   
  764. @OneToMany(mappedBy="group")   
  765. XML配置   
  766. Group中   
  767. "users">   
  768.        "groupId"/>                   
  769. class="com.hibernate.User"/>   
  770.    
  771. 在User中   
  772. "group" column="groupId"/>   
  773. 务必确保在多的一端生成的生成的外键和一的一方生成的外键的名字相同,都为groupId.   
  774. 如果名字不同则会在多的一端生成多余的外键.   
  775. create table t_group (   
  776.         id integer not null auto_increment,   
  777.         name varchar(255),   
  778.         primary key (id)   
  779.     )   
  780. create table t_user (   
  781.         id integer not null auto_increment,   
  782.         name varchar(255),   
  783.         groupId integer,   
  784.         primary key (id)   
  785.     )   
  786. alter table t_user   
  787.         add index FKCB63CCB6C3D18669 (groupId),   
  788.         add constraint FKCB63CCB6C3D18669   
  789.         foreign key (groupId) references t_group (id)   
  790.   
  791. 多对多单向关联   
  792. 关系举例:老师à学生,老师需要知道自己教了哪些学生,但学生不知道自己被哪些老师来教.   
  793. 数据库:中间表   
  794. Annotation:@ManyToMany   
  795. XML:   
  796. 关系模型(Teache多对多Student),从Teacher这一端能关联到students.   
  797. Teacher(id,name,students)多   
  798. Student(id,name)多   
  799. Set students=new HashSet()   
  800. 在Teacher那一端配置   
  801. @ManyToMany   
  802. 如果手动指定生成的中间表的表名和字段名   
  803. @JoinTable(   
  804. name="t_s",  //表名   
  805.        joinColumns={@JoinColumn(name="teacher_id")},//指向teacher表   
  806.        inverseJoinColumns={@JoinColumn(name="student_id")}//指向另一张表   
  807.              )   
  808. 生成的表为   
  809. create table Student (   
  810.         id integer not null auto_increment,   
  811.         name varchar(255),   
  812.         primary key (id)   
  813. )   
  814. create table Teacher (   
  815.         id integer not null auto_increment,   
  816.         name varchar(255),   
  817.         primary key (id)   
  818. )   
  819. create table t_s (//生成的中间表   
  820.         teacher_id integer not null,   
  821.         student_id integer not null,   
  822.         primary key (teacher_id, student_id)   
  823.     )   
  824. t_s表的两个属性分别references其它表的主键.   
  825. XML中   
  826. <class name="com.xxx.Teacher">   
  827.              "id">   
  828.                     class="native"/>   
  829.                 
  830.              "name"/>   
  831.              "students" table="t_s">table定义中间表的表名   
  832.                     "teacher_id">   
  833.                     class="com.xxx.Student" column="student_id"/>   
  834.                 
  835. class>   
  836.   
  837. 多对多双向关联   
  838. 关系举例:老师ßà学生,老师需要知道自己教了哪些学生,学生也知道自己有哪些老师.   
  839. 数据库:中间表   
  840. Annotation:@ManyToMany   
  841. XML:   
  842. 多对多单向配置只需要在一端进行配置就可以了.   
  843. 关系模型(Teache多对多Student)   
  844. Teacher(id,name,students)多   
  845. Student(id,name,teachers)多   
  846. Set students=new HashSet()   
  847. Set teachers = new HashSet();   
  848. Annotation配置   
  849. 在Teacher这一端的students上配置   
  850. @ManyToMany   
  851.        @JoinTable(name="t_s",   
  852.              joinColumns={@JoinColumn(name="teacher_id")},   
  853.              inverseJoinColumns={@JoinColumn(name="student_id")}   
  854.              )   
  855. 在Student一端的teachers只需要配置   
  856. @ManyToMany(mappedBy="students")   
  857. XML配置方式:两端配置一样,注意表名和生成的中间表的字段属性名要一致   
  858. Teacher那一端配置   
  859. "students" table="t_s">   
  860.        "teacher_id"/>   
  861.        class="com.xxx.Student" column="student_id"/>   
  862.    
  863. 在Student那一端配置   
  864. "teachers" table="t_s">   
  865.        "student_id">   
  866.        class="com.xxx.Teacher" column="teacher_id"/>   
  867.    
  868. 生成的数据库表和上面是一样的.   
  869.   
  870. 树状结构的设计(重要)   
  871. 设计思想:数据库模型,面向对象模式,关系映射,CRUD   
  872. 数据库模型:表(id,name,pid)   
  873. 实体模型:父结点ß一对多à子结点,一对多/多对一双向关联映射,一个子结点只有一个父结点,一个父结点有多个子结点.   
  874. Class Org   
  875. private int id;   
  876.        private String name;   
  877.        private Set children = new HashSet();   
  878.        private Org parent;   
  879. 关系映射:在同一个类中使用@ManyToOne@OneToMany   
  880. 在父结点parent上   
  881. @ManyToOne     
  882. @JoinColumn(name="parent_id")   
  883. public Org getParent() {   
  884.              return parent;   
  885.        }   
  886. 在子结点children上   
  887. @OneToMany(cascade=CascadeType.ALL, mappedBy="parent")   
  888. public Set getChildren() {   
  889.              return children;   
  890.        }   
  891.   
  892.   
  893. 基本关联关系对象的CRUD   
  894. 1 想删除或者更新,先做load,除非精确知道ID.   
  895. 2 Cascade属性(是一个数组)管理CUD,只是为了编程的方便,不要把它的功能看得太大.   
  896. cascade={CascadeType.ALL}   
  897. CascadeType取值   
  898. ALL    Cascade all operations所有情况   
  899. MERGE  Cascade merge operation合并(merge=save+update)   
  900. PERSIST  Cascade persist operation存储 persist()   
  901. REFRESH  Cascade refresh operation刷新   
  902. REMOVE   Cascade remove operation删除   
  903. 规律,双向关系要是程序中设定双向关联.还要设置mappedBy   
  904. 3 Fetch属性,读取,管理R(Retrieve查询)   
  905. fetch = FetchType.LAZY|EAGER   
  906. Hibernate Annotation的默认的FetchType在ManyToOne是EAGER的,在OneToMany上默认的是LAZY.   
  907. 如果指定OneToOne的fetch=FetchType.LAZY,会延迟对关联对象的加载,不管是load还是get.   
  908. 在XML中,在外键属性上设置inverse=”true|false”进行设置.   
  909. 4 如果想消除关联关系,先设定关系为NULL就可以打破关联关系,再删除对应记录.如果不删除相关的记录,该记录就成为垃圾数据.   
  910. 5 O/R Mapping编程模型   
  911. A 映射模型(映射数据库)   
  912.        1 JPA ANNOTATION   
  913.        2 hibernate annotation extension   
  914.        3 hibernate xml   
  915.        4 jpa xml   
  916. B 编程接口(增删改查)   
  917.        1 jpa   
  918.        2 hibernate   
  919. C 数据库查询语言   
  920.        1 HQL   
  921.        2 EJBQL (JPQL)   
  922. 6   
  923.   
  924. 集合映射(不太重要)   
  925. Set   
  926. List   
  927. @OrderBy(“属性名 ASC|DESC”)   
  928. Map   
  929.        @MapKey(name=”字段名”)   
  930. private Map users = new HashMap();   
  931.   
  932. 继承映射(不太重要)   
  933. 三种模式:TABLE_PER_CLASS| JOINED| SINGLE_TABLE   
  934. strategy=InheritanceType.XXX   
  935. 关系模式就是一种方式,在数据库的表有三种表现形式.   
  936. SINGLE_TABLE模式   
  937. Person, Student和Teacher继承Person   
  938. Person(id,name)   
  939. Student(score)   
  940. Teacher(title)   
  941. 在Student实体中   
  942. @Entity   
  943. @DiscriminatorValue("student")   
  944. 在Teacher中   
  945. @Entity   
  946. @DiscriminatorValue("teacher")   
  947. 在Person中   
  948. @Entity   
  949. @Inheritance(strategy=InheritanceType.SINGLE_TABLE)   
  950. @DiscriminatorColumn(name="discriminator",discriminatorType=   
  951. DiscriminatorType.STRING)   
  952. @DiscriminatorValue("person")   
  953. 生成的表为   
  954.     create table Person (   
  955.         discriminator varchar(31) not null,   
  956.         id integer not null auto_increment,   
  957.         name varchar(255),   
  958.         score integer,   
  959.         title varchar(255),   
  960.         primary key (id)   
  961.     )   
  962. TABLE_PER_CLASS模式   
  963. 这种方式也比较麻烦,注意id生成策略.   
  964. Person, Student和Teacher继承Person   
  965. Person(id,name)   
  966. Student(score)   
  967. Teacher(title)   
  968. 在Person中   
  969. @Entity   
  970. @Inheritance(strategy=InheritanceType.TABLE_PER_CLASS)   
  971. @TableGenerator(//ID生成策略采用表生成策略   
  972.              name="t_gen",   
  973.              table="t_gen_table",   
  974.              pkColumnName="t_pk",   
  975.              valueColumnName="t_value",   
  976.              pkColumnValue="person_pk",   
  977.              initialValue=1,   
  978.              allocationSize=1   
  979.              )   
  980. 主键映射   
  981. @Id   
  982. @GeneratedValue(generator="t_gen", strategy=GenerationType.TABLE)   
  983. 生成了三张表+一张生成主键的临时表   
  984. create table Person (   
  985.         id integer not null,   
  986.         name varchar(255),   
  987.         primary key (id)   
  988. )   
  989. create table Student (   
  990.         id integer not null,   
  991.         name varchar(255),   
  992.         score integer not null,   
  993.         primary key (id)   
  994.     )   
  995. create table Teacher (   
  996.         id integer not null,   
  997.         name varchar(255),   
  998.         title varchar(255),   
  999.         primary key (id)   
  1000.     )   
  1001. create table t_gen_table (   
  1002.          t_pk varchar(255),   
  1003.          t_value integer   
  1004.     )   
  1005. JOINED模式   
  1006. 这种方式最为简单.   
  1007. Person, Student和Teacher继承Person   
  1008. Person(id,name)   
  1009. Student(score)   
  1010. Teacher(title)   
  1011. 在Person中   
  1012. @Entity   
  1013. @Inheritance(strategy=InheritanceType.JOINED)   
  1014. 生成的表为:   
  1015. create table Person (   
  1016.         id integer not null auto_increment,   
  1017.         name varchar(255),   
  1018.         primary key (id)   
  1019.     )   
  1020. create table Student (   
  1021.         score integer not null,   
  1022.         id integer not null,   
  1023.         primary key (id)   
  1024.     )   
  1025. create table Teacher (   
  1026.         title varchar(255),   
  1027.         id integer not null,   
  1028.         primary key (id)   
  1029.     )   
  1030. 两个外键约束表Student和Teacher里面的id分别references Person(id)   
  1031.   
  1032.   
  1033.   
  1034.   
  1035.   
  1036. Hibernate查询(HQL)   
  1037. QL(Query Language)   
  1038. NativeSQL>HQL>EJBQL(JP QL1.0)>QBC(Query by Criteria)>   
  1039. QBE(Query by Example)   
  1040. EJBQL是HQL的一个子集.   
  1041. 没必要把EJBQL和HQL区分得特别清楚,能够满足需求和设计.   
  1042. QL和导航关系结合,共同为查询提供服务.   
  1043.   
  1044. :占位符   
  1045. Query q = session.createQuery("from Category c where c.id > :min and c.id < :max");   
  1046. q.setParameter("min",2);   
  1047. q.setParameter("max",8);   
  1048. 或者q.setInteger("min",2);   
  1049. q.setInteger("max",8);   
  1050. 类似于JDBC里面的PreparedStatement   
  1051.   
  1052. 链式编程   
  1053. Query q = session.createQuery("from Category c where c.id > :min and c.id < :max")   
  1054.        .setInteger("min",2)   
  1055.        .setInteger("max",8);   
  1056.   
  1057. Query q = session.createQuery("from Category c where c.id > ? and c.id < ?");   
  1058. q.setParameter(02)   
  1059. .setParameter(1,8);   
  1060.   
  1061. 分页显示   
  1062. Query q = session.createQuery("from Category c order by c.name desc");   
  1063. q.setFirstResult(2);//设置起始记录位置.   
  1064. q.setMaxResults(4);//设置每页显示的最大记录数   
  1065.   
  1066. q.uniqueResult()//返回唯一的一条记录.   
  1067.   
  1068. Is null   
  1069. Is empty 测试集合是否为空   
  1070.   
  1071. NamedQueries 命名查询   
  1072. 把查询语句集中放在一个位置中.   
  1073. SQLQuery q = session.createSQLQuery("select * from category limit 2,4").addEntity(Category.class);   
  1074.   
  1075.   
  1076. 使用数据库本   
  1077.   
  1078.   
  1079. 性能优化   
  1080. 1 注意session.clear()的运用,尤其是不断分页循环的时候   
  1081.   A 在一个大集合中进行遍历,取出其中含有敏感字的对象   
  1082.   B 另一种形式的内存泄露.   
  1083. 2 1+N问题   
  1084. LAZY ,BatchSize,join fetch   
  1085. 3list和iterator的区别   
  1086. list取所有   
  1087. iterator先取ID,等到要用的时候再根据ID取出对象.   
  1088. session中list第二次发出,仍会到数据库中查询数据.iterator第二次首先查找session级缓存.   
  1089.   
  1090. 4一级缓存和二级缓存和查询缓存   
  1091. A 缓存   
  1092. B 一级缓存,session级别的缓存   
  1093. C 二级缓存,SessionFactory级别的缓存,可以跨越session级别存在.   
  1094. 适合放二级缓存:   
  1095. 经常被访问,改动不大不会经常访问,数量有限.如:用户权限,组织机构   
  1096. D 打开二级缓存   
  1097. Hibernate.cfg.xml   
  1098. "cache.use_second_level_cache">true   
  1099. 使用ehcache   
  1100. JAR文件:\lib\optional ehcache-1.2.3.jar   
  1101. "cache.provider_class">org.hibernate.cache.EhCacheProvider   
  1102. 使用配置文件ehcache.xml,将其复制到src目录下.   
  1103. Annotation注解:@Cache   
  1104. import org.hibernate.annotations.Cache;   
  1105. import org.hibernate.annotations.CacheConcurrencyStrategy;   
  1106. @Cache(usage = CacheConcurrencyStrategy.READ_WRITE)   
  1107. @Cache(   
  1108.     CacheConcurrencyStrategy usage();                 (1)   
  1109.     String region() default "";                       (2)   
  1110.     String include() default "all";                   (3)   
  1111. )   
  1112. (1)             usage: 给定缓存的并发策略(NONE, READ_ONLY, NONSTRICT_READ_WRITE, READ_WRITE, TRANSACTIONAL)   
  1113. (2)             region (可选的):缓存范围(默认为类的全限定类名或是集合的全限定角色名)   
  1114. (3)             include (可选的):值为all时包括了所有的属性(proterty), 为non-lazy时仅含非延迟属性(默认值为all)   
  1115. E load默认使用二级缓存,iterator默认使用二级缓存   
  1116. Flist默认向二级缓存添加数据,但是查询的时候不使用.   
  1117. G 如果Query需要使用二级缓存,则打开查询缓存   
  1118. "cache.use_query_cache">true   
  1119. 需要调用Query setCachable(true)方法指明使用二级缓存.   
  1120.   
  1121.   
  1122. 查询缓存:相同的Sql查询   
  1123.   
  1124.   
  1125. 缓存算法   
  1126. LRU,LFU, FIFO   
  1127. Least Recently Used   
  1128. Least Frequently Userd   
  1129. First In First Out   
  1130. memoryStoreEvictionPlicy=”LRU”(ehcache)   
  1131.   
  1132. 事务   
  1133. ACID   
  1134. 原子性(Atomicity)、一致性(Consistency)、隔离性(Isolation)、持久性(Durability)。   
  1135.   当事务处理系统创建事务时,将确保事务有某些特性。组件的开发者们假设事务的特性应该是一些不需要他们亲自管理的特性。这些特性称为ACID特性。   
  1136. ACID就是:原子性(Atomicity )、一致性( Consistency )、隔离性( Isolation)和持久性(Durabilily)。   
  1137. 1. 原子性   
  1138.      原子性属性用于标识事务是否完全地完成,一个事务的任何更新要在系统上完全完成,如果由于某种原因出错,事务不能完成它的全部任务,系统将返回到事务开始前的状态。   
  1139.      让我们再看一下银行转帐的例子。如果在转帐的过程中出现错误,整个事务将会回滚。只有当事务中的所有部分都成功执行了,才将事务写入磁盘并使变化永久化。   
  1140.      为了提供回滚或者撤消未提交的变化的能力,许多数据源采用日志机制。例如,SQL Server使用一个预写事务日志,在将数据应用于(或提交到)实际数据页面前,先写在事务日志上。但是,其他一些数据源不是关系型数据库管理系统 (RDBMS),它们管理未提交事务的方式完全不同。只要事务回滚时,数据源可以撤消所有未提交的改变,那么这种技术应该可用于管理事务。   
  1141. 2. 一致性   
  1142.     事务在系统完整性中实施一致性,这通过保证系统的任何事务最后都处于有效状态来实现。如果事务成功地完成,那么系统中所有变化将正确地应用,系统处于有效 状态。如果在事务中出现错误,那么系统中的所有变化将自动地回滚,系统返回到原始状态。因为事务开始时系统处于一致状态,所以现在系统仍然处于一致状态。   
  1143.     再让我们回头看一下银行转帐的例子,在帐户转换和资金转移前,帐户处于有效状态。如果事务成功地完成,并且提交事务,则帐户处于新的有效的状态。如果事务出错,终止后,帐户返回到原先的有效状态。   
  1144.     记住,事务不负责实施数据完整性,而仅仅负责在事务提交或终止以后确保数据返回到一致状态。理解数据完整性规则并写代码实现完整性的重任通常落在开发者肩上,他们根据业务要求进行设计。   
  1145.     当许多用户同时使用和修改同样的数据时,事务必须保持其数据的完整性和一致性。因此我们进一步研究A C I D特性中的下一个特性:隔离性。   
  1146. 3. 隔离性   
  1147.    在隔离状态执行事务,使它们好像是系统在给定时间内执行的唯一操作。如果有两个事务,运行在相同的时间内,执行相同的功能,事务的隔离性将确保每一事务在系统中认为只有该事务在使用系统。   
  1148.    这种属性有时称为串行化,为了防止事务操作间的混淆,必须串行化或序列化请求,使得在同一时间仅有一个请求用于同一数据。   
  1149. 重要的是,在隔离状态执行事务,系统的状态有可能是不一致的,在结束事务前,应确保系统处于一致状态。但是在每个单独的事务中,系统的状态可能会发生变化。如果事务不是在隔离状态运行,它就可能从系统中访问数据,而系统可能处于不一致状态。通过提供事   
  1150. 务隔离,可以阻止这类事件的发生。   
  1151.     在银行的示例中,这意味着在这个系统内,其他过程和事务在我们的事务完成前看不到我们的事务引起的任何变化,这对于终止的情况非常重要。如果有另一个过程 根据帐户余额进行相应处理,而它在我们的事务完成前就能看到它造成的变化,那么这个过程的决策可能   
  1152.      建立在错误的数据之上,因为我们的事务可能终止。这就是说明了为什么事务产生的变化,直到事务完成,才对系统的其他部分可见。   
  1153.      隔离性不仅仅保证多个事务不能同时修改相同数据,而且能够保证事务操作产生的变化直到变化被提交或终止时才能对另一个事务可见,并发的事务彼此之间毫无影 响。这就意味着所有要求修改或读取的数据已经被锁定在事务中,直到事务完成才能释放。大多数数据库,例如SQL Server以及其他的RDBMS,通过使用锁定来实现隔离,事务中涉及的各个数据项或数据集使用锁定来防止并发访问。   
  1154. 4. 持久性   
  1155.       持久性意味着一旦事务执行成功,在系统中产生的所有变化将是永久的。应该存在一些检查点防止在系统失败时丢失信息。甚至硬件本身失败,系统的状态仍能通过 在日志中记录事务完成的任务进行重建。持久性的概念允许开发者认为不管系统以后发生了什么变化,完   
  1156. 成的事务是系统永久的部分。   
  1157.      在银行的例子中,资金的转移是永久的,一直保持在系统中。这听起来似乎简单,但这,依赖于将数据写入磁盘,特别需要指出的是,在事务完全完成并提交后才写入磁盘的。   
  1158.      所有这些事务特性,不管其内部如何关联,仅仅是保证从事务开始到事务完成,不管事务成功与否,都能正确地管理事务涉及的数据   当事务处理系统创建事务 时,将确保事务有某些特性。组件的开发者们假设事务的特性应该是一些不需要他们亲自管理的特性。这些特性称为ACID特性。 

你可能感兴趣的:(hibernate)