hiberante O/R映射,注解,查询语言,标准查询,原生SQL,缓存,批处理、，

Hibernate O/R 映射:

(1).集合映射:在多对一的实体类中,我们可以使用一个集合用来保存多的哪一
   方的数据hibernate支持的集合有:Set，SortedSet(它和 \
  <set> 元素匹配并且用 java.util.TreeSet 初始化。sort 属
  性可以设置成比较器或者自然排序)，List， Collection，
   Map，SortedMap(它和 \<map> 元素匹配并且用
  java.util.TreeMap 初始化。sort 属性可以设置成比较器或
  者 自然排序)

     (2).映射类型:Many-to-One，One-to-One，One-to-Many，Many-toMany

Hibernate 注解:

需要导入jar:

1.hibernate-annotations.jar

 2.hibernate-comons-annotations.jar 

 3.ejb3-persistence.jar

下载地址:注解jar下载

     常用注解:常用注解参考

Hibernate 查询语言(HQL):

1.这是hibernate自己提供的查询语言，是基于对象和属性的，而不是像sql里面基于表和列，但是其他的都和sql一模一样没有什么区别(属性名和对象名区分大小写)

2.比如:String hql = "FROM Employee";
Query query = session.createQuery(hql);
List results = query.list();Hibernate 标准查询:
1.Hibernate 提供了操纵对象和相应的 RDBMS 表中可用的数据的替代方法。一种方法是标准的 API，它允许你建立一个标准的可编程查询对象来应用过滤规则和逻辑条件。

Hibernate Session 接口提供了 createCriteria() 方法，可用于创建一个 Criteria 对象，使当您的应用程序执行一个标准查询时返回一个持久化对象的类的实例
d571

2.//session获取到Criteria对象绑定那个对象的增删改查
Criteria cr = session.createCriteria(Employee.class);
//通过add方法给语句增加限制
cr.add(Restrictions.eq("salary", 2000));
List results = cr.list();
3.使用And和Or:

Criteria cr = session.createCriteria(Employee.class);

Criterion salary = Restrictions.gt("salary", 2000);
Criterion name = Restrictions.ilike("firstNname","zara%");

// To get records matching with OR condistions
LogicalExpression orExp = Restrictions.or(salary, name);
cr.add( orExp );

// To get records matching with AND condistions
LogicalExpression andExp = Restrictions.and(salary, name);
cr.add( andExp );

List results = cr.list();

4.提供分页操作:

Criteria cr = session.createCriteria(Employee.class);
//这种方法需要一个代表你的结果集的第一行的整数，以第 0 行为开始
cr.setFirstResult(1);
//这个方法设置了 Hibernate 检索对象的 maxResults
cr.setMaxResults(10);
List results = cr.list();

5.排序:

Criteria cr = session.createCriteria(Employee.class);
// To get records having salary more than 2000
cr.add(Restrictions.gt("salary", 2000));

// To sort records in descening order
crit.addOrder(Order.desc("salary"));

// To sort records in ascending order
crit.addOrder(Order.asc("salary"));

List results = cr.list();

6.聚合:

Criteria cr = session.createCriteria(Employee.class);

// To get total row count.
cr.setProjection(Projections.rowCount());

// To get average of a property.
cr.setProjection(Projections.avg("salary"));

// To get distinct count of a property.
cr.setProjection(Projections.countDistinct("firstName"));

// To get maximum of a property.
cr.setProjection(Projections.max("salary"));

// To get minimum of a property.
cr.setProjection(Projections.min("salary"));

// To get sum of a property.
cr.setProjection(Projections.sum("salary"));

Hibernate 原生SQL:
1.如果你想使用数据库特定的功能如查询提示或 Oracle 中的 CONNECT 关键字的话，你可以使用原生 SQL 数据库来表达查询。Hibernate 3.x 允许您为所有的创建，更新，删除，和加载操作指定手写 SQL
，包括存储过程。
您的应用程序会在会话界面用 createSQLQuery() 方法创建一个原生
SQL 查询.

2.String sql = "SELECT * FROM EMPLOYEE WHERE id = :employee_id";
SQLQuery query = session.createSQLQuery(sql);
query.addEntity(Employee.class);
query.setParameter("employee_id", 10);
List results = query.list();Hibernate 缓存:
一级缓存:

第一级缓存是 Session 缓存并且是一种强制性的缓存，所有的要求都必须通过它。

Session 对象在它自己的权利之下，在将它提交给数据库之前保存一个对象。

如果你对一个对象发出多个更新，Hibernate 会尝试尽可能长地延迟更新来减少发出的 SQL 更新语句的数目。

如果你关闭 session,所有缓存的对象丢失，或是存留，或是在数据库中被更新
  二级缓存:

我这里的环境搭建是hibernate 5以前的版本:

1.



2.映射文件中添加:

//必须添加在class标签的下面
<cache usage="read-only"/>
3.根配置文件中添加:

<!-- 启用二级缓存-->
<property name="cache.use_second_level_cache">true</property>
<property name="hibernate.cache.region.factory_class">
org.hibernate.cache.EhCacheRegionFactory
</property>

第二级缓存是一种可选择的缓存并且第一级缓存在任何想要在第二级缓存中找到一个对象前将总是被询问。第二级缓存可以在每一个类和每一个集合的基础上被安装，并且它主要负责跨会话缓存对象。

任何第三方缓存可以和 Hibernate 一起使用。org.hibernate.cache.CacheProvider 接口被提供，它必须实现来给 Hibernate 提供一个缓存实现的解决方法
Hibernate 批处理:
这里提供很多批处理的方式:我们只支持:/**
* 使用原生的jdbc API来完成批处理
*/
@org.junit.Test
public void Test02(){

Session session = SessionObtainUtil.getSessionObtain().getSessionInstance();

Transaction transaction = session.beginTransaction();

session.doWork(new Work() {

public void execute(Connection connection) throws SQLException {
// TODO Auto-generated method stub
//通过原生的jdbc来操作批量处理,效率最高,速度最快

String sql = "insert into emp values(?,?,?,?,?)";

PreparedStatement preparedStatement = connection.prepareStatement(sql);

Dept dept = new Dept(10);
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
Date date = null;
try {
date = simpleDateFormat.parse("2017-06-21");
} catch (ParseException e) {
e.printStackTrace();
}

for (int i = 0; i < 20; i++) {

Emp emp = new Emp(dept, "Joik_"+i, "Studen_Java", date);

preparedStatement.setString(1, null);
preparedStatement.setString(2, emp.getEname());
preparedStatement.setString(3, emp.getJob());
preparedStatement.setString(4, simpleDateFormat.format(emp.getHiredate()));
preparedStatement.setInt(5, emp.getDept().getDeptno());

preparedStatement.executeUpdate();

}
}
});

transaction.commit();
}
提供一套管理session的方式:package cn.et.TL.Hibernate.lesson03.utls;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.boot.MetadataSources;
import org.hibernate.boot.registry.StandardServiceRegistry;
import org.hibernate.boot.registry.StandardServiceRegistryBuilder;
/**
* 单实例
* @author 唐林
* @编写时间: 2017-6-22 上午10:38:47
*/
public class SessionObtainUtil {

private SessionFactory sessionFactory;
private Session session;
private static SessionObtainUtil sessionObtainUtil = new SessionObtainUtil();
public static SessionObtainUtil getSessionObtain(){

return sessionObtainUtil;
}

/**
* 生产sessionFactory对象
* @return
*/
public SessionFactory getSessionFactoryInstance(){
if(sessionFactory == null){

StandardServiceRegistry standardServiceRegistry=
new StandardServiceRegistryBuilder().configure().build();

sessionFactory =
new MetadataSources(standardServiceRegistry)
.buildMetadata().buildSessionFactory();
}
return sessionFactory;
}

/**
* 生产session对象方法,并且将session和当前的线程绑定
* 只要当前线程一结束,session自动关闭,不需要我们手动关闭
* @return
*/
public Session getSessionInstance(){
if(session == null){

//获取当前线程的session
session = getSessionFactoryInstance().getCurrentSession();
}
return session;
}
}

hibernate集成spring集成springMvc:

1.导入集成的核心jar:

<!-- 导入spring集成hibernate核心包 -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-orm</artifactId>
<version>4.3.2.RELEASE</version>
</dependency>
2.spring配置文件如下:
<bean id="factoryBean" class="org.springframework.orm.hibernate5.LocalSessionFactoryBean">

<property name="dataSource" ref="dataSource"></property>
<!-- 使用mappingResources来加载hibernate的映射文件 -->
<property name="mappingResources">
<array>
<value>cn/et/TL/SSHA/entity/Employee.hbm.xml</value>
</array>
</property>
</bean>

<!-- 创建操作jdbc的类 -->
<bean id="hibernateTemplate" class="org.springframework.orm.hibernate5.HibernateTemplate">

<property name="sessionFactory" ref="factoryBean"></property>
</bean>
3.其他的自己要用到什么就配置什么