Hibernate的任何对数据有改动的操作，都应该被放在事务里面.
在事务中的多个操作行为，要么都成功，要么都失败
hibernate中的事务由s.beginTransaction();开始
由s.getTransaction().commit();结束
本例子，执行了两个操作
第一个，删除id=8的产品，这个是会成功的
第二个，修改id=11的产品，使得其产品名称超过了数据库中设置的长度30，这个是会失败的。
因为这两个操作都是在一个事务中，而且第二个操作失败了，所以最后的结果是两个操作都没有生效
SessionFactory sf = new Configuration().configure().buildSessionFactory();
Session s = sf.openSession();
s.beginTransaction();
Product p9 = (Product)s.get(Product.class, 9);
s.delete(p9);
Product p11 = (Product)s.get(Product.class, 11);
p11.setName("长度超过30的字符串作为产品名称长度超过30的字符串作为产品名称长度超过30的字符串作为产品名称长度超过30的字符串作为产品名称");
s.update(p11);
s.getTransaction().commit();
s.close();
sf.close();
MYSQL 表的类型必须是INNODB才支持事务
属性的延迟加载:
当使用load的方式来获取对象的时候，只有访问了这个对象的属性，hibernate才会到数据库中进行查询。否则不会访问数据库
在打印log1之前，是不会打印出sql语句的，只有在访问属性“getName()"的时候，才会访问数据库
SessionFactory sf = new Configuration().configure().buildSessionFactory();
Session s = sf.openSession();
Product p = (Product)s.load(Product.class, 1);
System.out.println("log1");
System.out.println(p.getName());
System.out.println("log2");
s.close();
sf.close();
结果：
延迟加载又叫lazyload，在one-many many-many的时候都可以使用关系的延迟加载
修改配置文件 Category.hbm.xml
<set name="products" lazy="false">
改为
<set name="products" lazy="true">
表示通过Category获取产品是延迟加载的
执行15行的时候，只会查询Category表的信息，不会查询product_表
只有在执行18行，通过category取products的时候，才会进行对product_表的查询
什么是级联？ 简单的说，没有配置级联的时候，删除分类，其对应的产品不会被删除。 但是如果配置了恰当的级联，那么删除分类的时候，其对应的产品都会被删除掉。
包括上一步说的删除用得级联，级联有4种类型：
all：所有操作都执行级联操作；
none：所有操作都不执行级联操作；
delete：删除时执行级联操作；
save-update：保存和更新时执行级联操作；
级联通常用在one-many和many-to-many上，几乎不用在many-one上。
delete 级联
Category c = (Category) s.get(Category.class, 3);
s.delete(c);
并且为Category.hbm.xml 加上
<set name="products" cascade="delete" lazy="false">
运行代码就会发现，删除分类的时候，会把分类下对应的产品都删除掉，否则只会把产品对应的cid设置为空
SessionFactory sf = new Configuration().configure().buildSessionFactory();
Session s = sf.openSession();
s.beginTransaction();
Category category = (Category)s.get(Category.class, 2);
s.delete(category);
s.getTransaction().commit();
s.close();
sf.close();
save-update 级联
Category c = (Category) s.get(Category.class, 5);
Product p1 = new Product();
p1.setName("product_501");
Product p2 = new Product();
p2.setName("product_502");
Product p3 = new Product();
p3.setName("product_503");
并且为Category.hbm.xml 加上
<set name="products" cascade="save-update" lazy="false">
SessionFactory sf = new Configuration().configure().buildSessionFactory();
Session s = sf.openSession();
s.beginTransaction();
Category category = (Category)s.get(Category.class, 3);
Product p1 = new Product();
p1.setName("product_501");
Product p2 = new Product();
p2.setName("product_502");
Product p3 = new Product();
p3.setName("product_503");
category.getProductSet().add(p1);
category.getProductSet().add(p2);
category.getProductSet().add(p3);
s.getTransaction().commit();
s.close();
sf.close();
all和none级联
all 就是 delete+save-update
none 就是没有，默认就是none
hibernate默认是开启一级缓存的，一级缓存存放在session上
两次获取id=1的category对象
第一次通过id=1获取对象的时候，session中是没有对应缓存对象的，所以会在"log1"后出现sql查询语句。
第二次通过id=1获取对象的时候，session中有对应的缓存对象，所以在"log2"后不会出现sql查询语句
所以总共会看到一次SQL语句出现
SessionFactory sf = new Configuration().configure().buildSessionFactory();
Session s = sf.openSession();
System.out.println("log1");
Product p1 = (Product)s.get(Product.class, 1);
System.out.println("log2");
Product p2 = (Product)s.get(Product.class, 1);
System.out.println("log3");
s.close();
sf.close();
结果：
Hibernate的一级缓存是在Session上，二级缓存是在SessionFactory上
创建了两个Session
在第一个Session里
第一次获取id=1的Category 会执行SQL语句
在第二个Session里
获取id=1的Category，会执行SQL语句，因为在第二个Session，没有缓存该对象。
所以总共会看到两条SQL语句。
hibernate.cfg.xml 中增加对二级缓存的配置
在hibernate.cfg.xml中开启二级缓存的配置
hibernate本身不提供二级缓存，都是使用第三方的二级缓存插件
这里使用的是 EhCache提供的二级缓存
<property name="hibernate.cache.use_second_level_cache">true</property>
<propertyname="hibernate.cache.provider_class">org.hibernate.cache.EhCacheProvider</property>
在src目录下，创建一个ehcache.xml用于EHCache的缓存配置
<ehcache>
<diskStore path="java.io.tmpdir"/>
<defaultCache
maxElementsInMemory="10000"
eternal="false"
timeToIdleSeconds="120"
timeToLiveSeconds="120"
overflowToDisk="true"
/>
</ehcache>
设置HBM
对于要进行二级缓存的实体类，进行配置，增加<cache usage="read-only" />
<hibernate-mapping package="com.how2java.pojo">
<class name="Category" table="category_">
<cache usage="read-only" />
<id name="id" column="id">
<generator class="native">
</generator>
</id>
<property name="name" />
<set name="products" lazy="true">
<key column="cid" not-null="false" />
<one-to-many class="Product" />
</set>
</class>
</hibernate-mapping>
通过id获取Product对象有两种方式，分别是get和load
他们的区别分别在于
1. 延迟加载
2. 对于id不存在的时候的处理
load方式是延迟加载，只有属性被访问的时候才会调用sql语句
get方式是非延迟加载，无论后面的代码是否会访问到属性，马上执行sql语句
对于id不存在的对象的处理
都通过id=500去获取对象
1. get方式会返回null
2. load方式会抛出异常
Hibernate有两种方式获得session,分别是：
openSession和getCurrentSession
他们的区别在于
1. 获取的是否是同一个session对象
openSession每次都会得到一个新的Session对象
getCurrentSession在同一个线程中，每次都是获取相同的Session对象，但是在不同的线程中获取的是不同的Session对象
2. 事务提交的必要性
openSession只有在增加，删除，修改的时候需要事务，查询时不需要的
getCurrentSession是所有操作都必须放在事务中进行，并且提交事务后，session就自动关闭，不能够再进行关闭
Hibernate有缓存机制，可以通过用id作为key把product对象保存在缓存中
同时hibernate也提供Query的查询方式。假设数据库中有100条记录，其中有30条记录在缓存中，但是使用Query的的list方法，就会所有的100条数据都从数据库中查询，而无视这30条缓存中的记录
N+1是什么意思呢，首先执行一条sql语句，去查询这100条记录，但是，只返回这100条记录的ID
然后再根据id,进行进一步查询。
如果id在缓存中，就从缓存中获取product对象了，否则再从数据库中获取
Hibernate使用Iterator实现N 1
首先通过Query的iterator把所有满足条件的Product的id查出来
然后再通过it.next()查询每一个对象
如果这个对象在缓存中，就直接从缓存中取了
否则就从数据库中获取
N+1中的1，就是指只返回id的SQL语句，N指的是如果在缓存中找不到对应的数据，就到数据库中去查
SessionFactory sf = new Configuration().configure().buildSessionFactory();
Session s = sf.openSession();
Query q = s.createQuery("from Product p where p.name like ?");
q.setString(0, "%pa%");
Iterator<Product> it = q.iterate();
while (it.hasNext()) {
Product p = it.next();
System.out.println(p.getName());
}
s.close();
sf.close();
返回满足条件的总数
SessionFactory sf = new Configuration().configure().buildSessionFactory();
Session s = sf.openSession();
Query q = s.createQuery("select count(*) from Product p where p.name like ?");
q.setString(0, "%ip%");
long total = (long)q.uniqueResult();
System.out.println(total);
s.close();
sf.close();
Hibernate使用乐观锁来处理脏数据问题
首先看不使用乐观锁的情况
故意创造一个场景来制造脏数据。
1. 通过session1得到id=1的对象 product1
2. 在product1原来价格的基础上增加1000
3. 更新product1之前，通过session2得到id=1的对象product2
4. 在product2原来价格的基础上增加1000
5. 更新product1
6. 更新product2
最后结果是product的价格只增加了1000，而不是2000
SessionFactory sf = new Configuration().configure().buildSessionFactory();
Session s1 = sf.openSession();
Session s2 = sf.openSession();
s1.beginTransaction();
s2.beginTransaction();
Product p1 = (Product)s1.get(Product.class, 1);
System.out.println("产品原本价格是："+p1.getPrice());
p1.setPrice(p1.getPrice()+1000);
Product p2 = (Product)s2.get(Product.class, 1);
p2.setPrice(p2.getPrice()+1000);
s1.update(p1);
s2.update(p2);
s1.getTransaction().commit();
s2.getTransaction().commit();
Product p = (Product)s1.get(Product.class, 1);
System.out.println("经过两次价格增加后，价格变为；"+p.getPrice());
s1.close();
s2.close();
sf.close();
修改配置文件 Product.hbm.xml
<version name="version" column="ver" type="int"></version>
增加一个version字段，用于版本信息控制。这就是乐观锁的核心机制。
比如session1获取product1的时候，version=1。 那么session1更新product1的时候，就需要确保version还是1才可以进行更新，并且更新结束后，把version改为2。
修改 Product.java
增加version属性
private int version;
public int getVersion() {
return version;
}
public void setVersion(int version) {
this.version = version;
}
重新运行一样的代码
做同样的业务就会抛出异常，提示该行已经被其他事务删除或者修改过了，本次修改无法生效。
这样就保证了数据的一致性。
原理
1. 假设数据库中产品的价格是10000，version是10
2. session1,session2分别获取了该对象
3. 都修改了对象的价格
4. session1试图保存到数据库，检测version依旧=10，成功保存，并把version修改为11
5. session2试图保存到数据库，检测version=11，说明该数据已经被其他人动过了。 保存失败，抛出异常
建立数据库连接时比较消耗时间的，所以通常都会采用数据库连接池的技术来建立多条数据库连接，并且在将来持续使用，从而节约掉建立数据库连接的时间
hibernate本身是提供了数据库连接池的，但是hibernate官网也不推荐使用他自带的数据库连接池。
一般都会使用第三方的数据库连接池
C3P0是免费的第三方的数据库连接池，并且有不错的表现
导入c3po-0.9.1.jar,并在hiberna.cfg.xml加入以下
<property name="hibernate.connection.provider_class">
org.hibernate.connection.C3P0ConnectionProvider
</property>
<property name="hibernate.c3p0.max_size">20</property>
<property name="hibernate.c3p0.min_size">5</property>
<property name="hibernate.c3p0.timeout">50000</property>
<property name="hibernate.c3p0.max_statements">100</property>
<property name="hibernate.c3p0.idle_test_period">3000</property>
<!-- 当连接池耗尽并接到获得连接的请求，则新增加连接的数量 -->
<property name="hibernate.c3p0.acquire_increment">2</property>
<!-- 是否验证，检查连接 -->
<property name="hibernate.c3p0.validate">false</property>
记得要把上一步的二级缓存的相关配置去掉
<!-- <cache usage="read-only" />-->