1.HelloWorld
  a.xml
  b.annotation
2.Hibernate原理模拟，什么是O/R Mapping以及为什么要有这个?
3.常见的O/RKUANGJIAN
4.基础配置
5.核心接口介绍
6.对象的三种状态
7.ID生成策略
8.关系映射
9.hibernate查询（HQL)
10.在struts基础上继续完善项目
11.性能优化
12.补充话题
-----------------------------
风格：
1.先脉络，后细节
2.先操作，后原理
3.重Annotation（JPA（EJB）、hibernate（重）-extension（轻）），轻xml配置文件
--------------------------------
spring作用：spring提倡编程理念是面向接口编程，面向抽象编程，好处是换实现的时候非常容易，spring会把service注入到action里面去，会把dao注入到service里面去，还会针对

service进行声明式的事务管理。
--------------------------------
hibernate：访问Configuration（直接访问或者单例），创建builSessionFactory(),通过openSession()创建session对象，调用session的save方法，把实体对象传进去就好了，直接

persistent到DB。
-----------------------------------
O/R:Object/Relationship，
--------------------
hibernate3.jar
antlr .jar
commons-collections.jar
dom4j.jar
javassist.GA.jar
jta.jar
slf4j-api.jar
slf4j-nop.jar
----------------------
annotation：
1：hibernate3.0以后开始支持annotation，目标是建立一个能符合jpa标准的annotation。
2.引包：
hibernate-annotation.jar
ejb3-persistence.jar(符合了jpa标准的annotation的实现)
hibernate-commons-annotation.jar(进行反射时需要的一个包)
3.jpa是一种标准，hibernate是它的实现；jdbc是一种标准，各种数据库的driver是它的实现
4.@Id一般写在get方法上，也可以写在属性上，但是属性是private，所以写在get上更好。
5.引入javax.persistence.Entity;
==================================================
what is and why O/R Mapping:
1.JDBC操作数据库很繁琐
2.sql语句编写并不是面向对象的
3.可以在对象和关系表之间建立关联来简化编程
4.O/R Mapping跨数据库平台（换配置文件的方言）
5.O/R Mapping简化编程（hibernate可以自动建表）
---------------------------------------
课程内容：
1.helloworld：a.xml;b.annotation
2.hibernate原理模拟，什么是O/R Mapping以及为什么要有O/R Mapping
3.常见的O/R框架
4.基础配置
5.核心接口介绍
6.对象的三种状态
7.ID生成策略
8.关系映射
9.查询（HQL)
10.性能优化
---------------------------
一对一关联：
1.单项外键关联：在一个对象里面设置另外一个对象的引用，另外一个对象里面不设置；在数据库里面用外键来关联。Annotation:@One2One @JoinColumn
2.双向外键关联：程序里双向关联，数据库里用外键关联。Annotation:@One2One(mappedBy)。凡是双向必设mappedBy
3.联合主键：@JoinColumns
---------------------------
常见O/R Mapping框架：
1.hibernate
2.toplink
3.jdo
4.ibatis
5.JPA
================================
slf是个接口是个标准，具体的实现可以是：slf4j nodependence(不多，hibernate采用)、log4j、jdk loggin api、apache commons-log

=============================
1.UUID 128位，要求必须是string类型。
2.如果使用hibernate自动建立oracle表，表明不能以下划线开头
3.id生成策略：AUTO（重点）、IDENTITY(MYSQL、SQL SERVER支持)、SEQUENCE(ORACLE)、TABLE（可以忘记）
4.指定ID生成策略：
get方法上写：
@GenerateValue(stategy=GenerationType.SEQUENCE,generator="下方的名字")
类上写：
@SequenceGenerator(name="生成器名字",sequenceName="真正生成到数据库里的名字")

TableGgenerator了解即可，太复杂，可以忘记
================================
核心开发接口：
1.SessionFactory可以简单理解为跟数据库的连接还有更复杂的，一个数据源配置一个。

2.openSession和getCurrentSession（两个不能同时混用）
a、open永远是打开新的，需要close
b、g如果当前环境里有未commit的session，就会使用当前环境的，一但commit，再拿就是新的了。用途：界定事务边界；事务提交自动close。

session上下文：在配置文件里，
<property name="current_session_context_class">thread(常用getCurrentSession用的就是它)、managed（用到应用服务器，手工管理事务时，极少）、jta、custom（自定义管理

currentsession）</property>
-------------------------------------
client----OrderManager----JTATransaction Manager ---DB2 DB2

如果多台数据库服务器操作，A数据库操作失败，B数据库也同时回滚，利用数据库驱动来实现，这种情况下用的驱动是XADriver，Java EE要求的。

Transaction Manager是由Application Server提供。tomcat目前不具备这种能力，要借助第三方类库，例如spring，jboss可以，weblogic可以。

JTATransactionManager（JAVA TRANSACTION API）一般我们称之为JTA事务，所以一般事务有两种，1、依赖数据库本身，Connection事务（一个数据库）、JTA事务（分布式）。
-----------------------------------
hibernate 对象的三种状态：
___new____Transient(new)___Save、SaveOrUpdate___Persistent(有ID的)___close___Detached.

三种状态的区分关键在于：有没有ID，ID在数据库中有没有，在内存中有没有（session缓存）。

 transient:内存中一个对象，没ID，缓存中也没有
persistent：内存中有，缓存中有，数据库中有，有ID
detached：内存有，缓存没有，数据库有，有ID。
------------------------------------------
取对象时，用session.get方法和session.load方法的区别
1.不存在对应记录时表现不一样（get会报错，load不会）
2.get：马上回发出sql语句，然后从数据库里取出值来装到对象里取。
  load：返回的是这个对象的代理，代理并没有发出语句，这条sql语句其实是在需要用对象的属性时才会发出。
3.get语句直接从数据库中加载，不会延迟。
------------------------------------------------------
update:
1.用来更新detached对象，更新完成后转为persistent状态
2.更新transient对象会报错
3.更新自己设定id的transient对象可以（数据库有对应记录）
4.persistent状态的对象只要设定不能字段就会发生更新
5.merge:需要先从数据库里查出当前对象，再比较不同，再合并。（比较麻烦）6.更改部分字段
    a、xml设定property标签的update属性，annotation设定@Column的updatable属性，不过这种方式很少用，因为不灵活
    b、使用xml中的dynamic-update属性，JPA1.0 Annotation没有对应的东西。
    c、使用HQL(EJBQL)----建议采用此种方法
7.session.createQuery
可以是select语句也可以是update语句，语句中不是采用表明，而是实体对象名.

8.clear方法：无论是load还是get都会首先查找缓存（一级缓存），如果没有，才会去数据库查找，调用clear()可以强制清除session缓存

9.flush方法：可以强制进行从内存到数据库的同步

===========================================
关系映射（一对一，一对多，多对多）

对象之间的关系
1.这里的关系映射指的是对象之间的关系，并不是数据库的关系。

============================================
关联关系中的CRUD_Cascade_Fetch
1.设定cascade可以设定在持久化时对于关联对象的操作（CUD,R归Fetch管）
2.cascade仅仅是帮我们省了编程的麻烦而已，不要把的作用看的太大
  a、cascade的属性致命做什么操作的时候关联对象是绑在一起的
  b、Merge=save+update
  c、refresh=A里面需要读B改过之后的数据
3.铁律：双向关系在程序中要设定双向关联
4.铁律：双向mappedBy
5.fetch
  a、铁律：双向不要两边设置Eager（会有多余的查询语句发出）
  b、对多方设置fetch的时候要谨慎，结合具体应用，一般用lazy不用eager，特殊情况（多方数量不多的时候可以考虑，提高效率的时候可以考虑）
6.O/R Mapping模型编程
  a、映射模型
    a1.jpa annotation(用的最多)
    a2.hibernate annotation extension
    a3.hiberna xml
    a4.jpa xml
  b、编程接口

hibernate关联没有看完，以后补充
=================================================================
HQL(hibernate query language)
HQL vs EJBQL
1.功能从大到小：NativeSQL>HQL>EJBQL(JP QL 1.0 HQL的子集)>QBC(Query By Critera)>QBE(Query By Example)
2.总结：QL应该和导航关系结合，共同为查询提供服务。
---------------------------------------------------
HQL传参时，冒号是占位符。
--------------------------------------------------
count(*)返回的是long类型。
聚合函数（max、min返回的是Object类型
----------------------------------------------------
如果用in和exists都可以，则用exists，执行效率高。
---------------------------------------------------
性能优化：
1.注意session.clear的运用，尤其在不断分页循环的时候
    a、在一个大集合中进行遍历，遍历msg，去除其中的含有敏感字样的对象
    b、另外一种形式的内存泄露（打开连接不关闭，用文件之后不释放。在语法级别上是没有内存泄露的，因为不需要手动回收内存，但是如果不谨慎处理，将会产生内存泄露。）
2.1+N问题
描述：（如果在一个对象里面关联了另外一个对象，同时fatchType为eager，最典型的manyToOne，如果取many，那么关联的对象都会单独再发一条sql语句取出来。所以就发了一条，外加N条

。
解决：A或C。不想用关联属性则用A，想用则用C。fetchType设为lazy，N条在合适的时候才会发出
    a、Lazy
    b、BatchSize
    c、join fetch
3.list和iterate不同之处
    a、list取所有
    b、literate先取ID，等用到的时候再根据ID取得对象
    c、session中list第二次发出，仍会到数据库查询
    d、literate第二次，首先找session级缓存
4.一级缓存和二级缓存和查询缓存
    a、什么是缓存
    b、什么是一级缓存，session级别的缓存
    c、什么是二级缓存，SessionFactory级别的缓存，可以跨越session存在
          i.经常被访问
          ii、改动不大不会经常改动
          iii、数量有限
    d、打开二级缓存
             i、hibernate.cfg.xml设定
<property name="cache.use_second_level_cache">true</property>
        <property name="cache.provider_class">org.hibernate.cache.EhCacheProvider</property>  
在查询时标明使用查询缓存
session.createQuery("from table").setCacheable(true).list();
             ii、@Cache注解
    e、iterate、load默认使用二级缓存
    f、list默认往二缓存加数据，但是查询的时候不使用
    g、如果要query用二级缓存，需打开查询缓存(查询缓存依赖二级缓存)
    i.LRU、LFU、FIFO
    1.Least Recently Used
    2、Least Frequently Used(命中率极地）
    3、First in First Out
    ii、memoryStoreEvictionPolicy="LRU"(ehcache.xml)
5、事务冰法处理
    a、事务：ACID
        i.Atiomic(原子性）、Consistency(一致性）、Itegrity(独立性)、Durability(持久性）
    b、事务并发时可能出现的问题
    i、第一类丢失更新（Lost Update)-只要支持事务就不会出现这种问题
    ii、脏读（Dirty Read） -读了另外一个事务没有提交的数据
    iii、幻读（phantom  read主要针对插入和删除）
    iv、不可重复读（non-repeatable read）
    v、第二类丢失更新（不可重复读的特殊情况second lost update problem）
    c、事务的隔离机制
    i、查看java.sql.Connection文档
    ii、每种数据库的支持程度不一样，orable支持两种，mysql支持四种（mysql查询隔离：select @@tx_isolation)
            1、READ UNCOMMITTED(1)、READ COMMITTED(2)、REPEATABLE READ(4)、SERIALTIZABLE(8)
        2、只要数据库支持事务，就不可能出现第一类丢失更新
        3、read-uncommitted会出现dirty read、phantom-read、non-repeatable问题
        4、read-commited不会出现dirty read，因为只有另一个事务提交才会读出现结果，但仍会出现non-repeatable read、phantom-read
        5、repeatable read
        6、SERIALTIZABLE解决一切问题
    d、设定hibernate的事务隔离级别
    i、hibernate.connection.isolation=2(默认为2、2是READ COMMITTED，避免了脏读，效率也可以)
    ii、用悲观所解决repeatable read的问题（依赖于数据库的锁）
        1、select...for update
        2、load[xx.class,i,LockMode,Upgrade)
            a、LockMode:none无锁的机制，Transaction结束时，切换到此模式
            b、LockMode:read在查询的时候，hibernate会自动获取锁
            c、LocdeMode:write,insert update hibernate会自动获取锁
            d、以上三种锁的模式，是hibernate内部使用的
            e、LokeMode:UPGRADE_NOWAIT,oracle支持锁的方式

Hibernate知识点总结