1.Hibernate简介
Hibernate是一个开放源代码的对象关系映射(ORM)框架，它对JDBC进行了非常轻量级的对象封装，它将POJO与数据库表建立映射关系，是一个全自动的orm框架，hibernate可以自动生成SQL语句，自动执行，使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。
为什么要使用Hibernate
这个需要从Hibernate的起源开始分析。 Hibernate之父Gavin发现咱们以前的开发效率太低，特别在Java这种面向对象的语言在与关系型数据库之间的数据交互太麻烦了。于是开发出了hibernate。 我对他当时的思维的理解是，我们是Java程序员，就算我不懂SQL，我认为自己也应该可以来操作数据库。
面试题：为什么要使用Hibernate?
首先简单解释一下hibernate是一个ORM的框架，底层依然使用JDBC。 然后简述一下它与JDBC之间的优缺点.
Hibernate的优缺点
优点与缺点都是相对的，那么讲一个东西的优缺点我们都需要一个参数对比，而咱们要来进行对比的咱们操作数据的原生的JDBC：
JDBC的优缺点
本质:处理Java对象和关系型数据库表之间的转换
优点:
操作数据库最底层,性能最高(需要你是有相应的经验，并且是一个数据库高手)
缺点:
1.使用复杂(重复代码太多)
2.移植数据库很麻烦,改动比较多 主键的生成方式不同(mysql使用自增，oracle使用序列) 分页的sql语句也是不同(mysql使用limit，oracle使用ROWNUM)
3.性能优化得自己处理,没有提供数据的缓存
4.面向sql语句操作，不是面向对象的
hibernate的优缺点
本质:处理Java对象和关系型数据库表之间的转换，只是对JDBC再次做了一层封装
优点:
1.程序员操作很简单，代码简单 session.save(user);
2.直接面向对象操作
3.提供世界级数据缓存(现在几乎所有的ORM框架的缓存都是学的Hibernate) 一级缓存，二级缓存，查询缓存
4.数据库移植性很强，很少的修改 把各种数据库抽取了一个方言接口 不同数据库实现一个方言接口，如果换了数据库，必须修改方言实现，驱动jar文 件，连接数据库信息。
缺点:
1.不能干预sql语句的生成 session.get(User.class,id); 默认查询t_user表的所有字段 自动生成select user0_.id,user0_.name,user0_.age from t_user user0_ where user0_.id=?
2.一个项目中，如果对sql语句的优化要求比较高，不适合用hibernate(不过可以使用 Hibernate对原生sql的支持来解决)
3.如果一张表中有上亿级别的数据量，也不适合用hibernate，其实也不适合用jdbc(可 以使用数据库读写分离，分库分表方案解决)
面试题：查询1千万条数据，怎么才是最快的？ 先把数据放到缓存(内存)中？
1000千万条数据 分页显示1000条
执行SQL：查出1000条显示
在查询完之后，偷偷的查询下一页的数据，放到缓存中
Hibernate的历史
Hibernate：之前EJB完成ORM是非常复杂的，Hibernate的作者是Gavin King。
PS：也许Cirrus Technologies的老板做梦也想不到两年以后，这个小伙子开发出的那个产品会成为全世界最流行的O/R Mapping工具，而那个对SQL和数据库一窍不通的小伙子居然会成为全世界J2EE数据库解决方案的领导者。
01年末:hibernate的第一个版本
03 年6月,HIbernate2获得Jolt 2004 大奖，9被JBoss收纳为子项目
PS：2003年9月，Gavin King在他网站上向全世界发起挑战：谁要是能对一段代码用JDBC开发做到效率比hibernate高好多，就给他100美金
05 年3月,Hibernate3正式发布
10 年4月，3.5发布,支持JPA
2.hibernate入门
简单使用hibernate做CRUD
步骤
0.拷贝jar包
1.建立model
2.建立映射文件
3.建立hibernate核心配置文件
4.编辑dao实现类
5.测试
0.拷贝jar包
1.建立model---LoginUser
package com.hibernate.day01.model; /**
* Created by asus on 2017/6/1.
*/ public class LoginUser {
private Integer id;
private String password;
private String userName;
private Integer age;
private Integer salary;
private String createTime; public Integer getSalary() {
return salary;
} public void setSalary(Integer salary) {
this.salary = salary;
} public String getCreateTime() {
return createTime;
} public void setCreateTime(String createTime) {
this.createTime = createTime;
} public Integer getAge() {
return age;
} public void setAge(Integer age) {
this.age = age;
} public Integer getId() {
return id;
} public void setId(Integer id) {
this.id = id;
} public String getPassword() {
return password;
} public void setPassword(String password) {
this.password = password;
} public String getUserName() {
return userName;
} public void setUserName(String userName) {
this.userName = userName;
}
}
LoginUser
2.建立映射文件---loginuser.hbm.xml
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD3.0//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<!-- 映射文件 -->
<!-- 在映射文件出现的name属性都是指的java的类名，属性名 -->
<!-- 在映射文件出现的column属性都是指的数据库表的字段(列)名:也可以不写，使用name属性的值 -->
<!-- 在映射文件出现的type属性是:1.java的全限定类名java.lang.Long 2.也可以是hibernate的类型名称long 3.也可以不写,hibernate会通过反射技术获取java的类型 -->
<hibernate-mapping package="com.hibernate.day01.model">
<!-- class表示一个由hibernate管理的持久对象,对应数据库的一个表 -->
<!-- table数据库的表名 -->
<class name="LoginUser" table="login_user">
<!-- id元素（节点）是必须的，是代表表的主键 -->
<id name="id" column="id">
<!-- generator表示主键的生成方式,多数都是使用native -->
<!-- native自动选择数据库本地的策略: -->
<!-- mysql:AUTO_INCREMENT自增 --><!-- oracle:序列 -->
<generator class="native" />
</id>
<!-- 非主键属性 -->
<property name="userName" column="user_name" />
<property name="password" column="password"/>
<!-- <!– default="25"还必须同时配置一个属性insert="false",表示不出现在insert语句 –>
<property name="age" insert="false">
<column name="age" default="25" />
</property>
<!– update=false:一经保存就不能修改属性:身份证号码,创建时间 –>
<property name="createTime" column="create_time" update="false"/>-->
</class>
</hibernate-mapping>
loginuser.hbm.xml
3.建立hibernate核心配置文件---hibernate2.cfg.xml
<!DOCTYPE hibernate-configuration PUBLIC
"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd"> <hibernate-configuration>
<session-factory>
<!-- Database connection settings
-->
<property name="connection.driver_class">com.mysql.jdbc.Driver</property>
<property name="connection.url">jdbc:mysql://10.3.2.25:3306/hibernate</property>
<property name="connection.username">root</property>
<property name="connection.password">admin</property>
<!-- JDBC connection pool (use the built -in) JDBC连接池（使用内置） -->
<!-- <property name="connection.pool_size">1</property>-->
<!-- SQL dialect -->
<property name="dialect">org.hibernate.dialect.MySQLDialect</property>
<!-- Enable Hibernate's automatic session context management
hibernate将session从当前线程中释放，并且关闭session
-->
<!-- <property name="current_session_context_class">thread</property>-->
<!-- Disable the second-level cache -->
<!-- <property name="cache.provider_class">org.hibernate.cache.NoCacheProvider</property>-->
<!-- Echo all executed SQL to stdout -->
<property name="show_sql">true</property>
<!-- Drop and re-create the database schema on startup-->
<property name="hbm2ddl.auto">update</property>
<mapping resource="mapper/loginuser.hbm.xml"/>
<!-- <mapping class="com.hibernate.day01.model.LoginUser" />-->
</session-factory>
</hibernate-configuration>
hibernate.cfg.xml
4.编辑dao实现类
package com.hibernate.day01.dao.impl; import com.hibernate.day01.dao.ILoginUserDao;
import com.hibernate.day01.model.LoginUser;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration; import java.util.List; /**
* Created by asus on 2017/6/1.
*/
public class LoginUserDao implements ILoginUserDao {
@Override
public void save(LoginUser loginUser) {
// 读取并且解析配置文件(包含映射文件)
Configuration configuration = new Configuration();
// 加载默认配置文件hibernate.cfg.xml
// configuration.configure();
// 加载非默认配置文件hibernate.cfg.xml
configuration.configure("hibernate2.cfg.xml");
// 生成会话工厂(真正解析配置文件)
SessionFactory sessionFactory = configuration.buildSessionFactory();
// 获取Session对象
Session session = sessionFactory.openSession();
// 开启事务
// 用法1
//Transaction transaction = session.getTransaction();
// transaction.begin();
// 用法2 hibernate默认情况下是没有开启事务的,必须手动开启事务
session.beginTransaction();
// 操作CUD
session.save(loginUser);// 持久状态
// 提交事务
session.getTransaction().commit();
// 关闭资源
session.close();// 游离状态
sessionFactory.close();
}
@Override
public void delete(Integer id) {
//创建读取文件的类
Configuration configuration=new Configuration();
//加载文件
configuration.configure("hibernate2.cfg.xml");
//获得sessionFactory对象
SessionFactory sessionFactory = configuration.buildSessionFactory();
//获得session
Session session = sessionFactory.openSession();
//开启事务
session.beginTransaction();
//执行操作
LoginUser loginUser=new LoginUser();
loginUser.setId(id);
session.delete(loginUser);//删除状态
//关闭事务
session.getTransaction().commit();
//关闭session
session.close();
//关闭sessionFactory
sessionFactory.close(); } @Override
public void update(LoginUser loginUser) {
//创建读取文件的类
Configuration configuration=new Configuration();
//加载文件
configuration.configure("hibernate2.cfg.xml");
//获得sessionFactory对象
SessionFactory sessionFactory = configuration.buildSessionFactory();
//获得session
Session session = sessionFactory.openSession();
//开启事务
session.beginTransaction();
//执行操作
session.update(loginUser);
//关闭事务
session.getTransaction().commit();
//关闭session
session.close();
//关闭sessionFactory
sessionFactory.close();
} @Override
public LoginUser getLoginUser(Integer id) {
//创建读取文件的类
Configuration configuration=new Configuration();
//加载文件
configuration.configure("hibernate2.cfg.xml");
//获得sessionFactory对象
SessionFactory sessionFactory = configuration.buildSessionFactory();
//获得session
Session session = sessionFactory.openSession();
//开启事务
// session.beginTransaction(); 查询操作不需要事务
//执行操作
LoginUser loginUser=(LoginUser) session.get(LoginUser.class,id);
//关闭事务
// session.getTransaction().commit();
//关闭session
session.close();
//关闭sessionFactory
sessionFactory.close();
return loginUser;
} @Override
public List<LoginUser> getList() {
//创建读取文件的类
Configuration configuration=new Configuration();
//加载文件
configuration.configure("hibernate2.cfg.xml");
//获得sessionFactory对象
SessionFactory sessionFactory = configuration.buildSessionFactory();
//获得session
Session session = sessionFactory.openSession();
//开启事务
// session.beginTransaction();
//执行操作
String hql="select o from com.hibernate.day01.model.LoginUser o";
Query query = session.createQuery(hql);
List<LoginUser> list = query.list();
//关闭事务
// session.getTransaction().commit();
//关闭session
session.close();
//关闭sessionFactory
sessionFactory.close();
return list;
} }
LoginUserDao
5.测试
import com.hibernate.day01.dao.impl.LoginUserDao;
import com.hibernate.day01.dao.impl.ProductDao;
import com.hibernate.day01.model.LoginUser;
import com.hibernate.day01.model.Product;
import org.junit.Test; import java.util.List; /**
* Created by asus on 2017/6/1.
*/
public class HibernateTest {
@Test
public void testSave(){
LoginUserDao loginUserDao=new LoginUserDao();
LoginUser loginUser=new LoginUser();
loginUser.setUserName("tesg");
loginUser.setPassword("47894");
loginUser.setAge(58);
loginUserDao.save(loginUser);
}
@Test
public void testDelete(){
LoginUserDao loginUserDao=new LoginUserDao();
loginUserDao.delete(9);
}
@Test
public void testUpdate(){
LoginUserDao loginUserDao=new LoginUserDao();
LoginUser loginUser=new LoginUser();
loginUser.setId(10);
loginUser.setUserName("已经改了2");
loginUserDao.update(loginUser);
}
@Test
public void testGet(){
LoginUserDao loginUserDao=new LoginUserDao();
LoginUser loginUser = loginUserDao.getLoginUser(10);
System.out.println("--------loginUser-----"+loginUser);
}
@Test
public void testList(){
LoginUserDao loginUserDao=new LoginUserDao();
List<LoginUser> list = loginUserDao.getList();
System.out.println("---------list----"+list.size());
}
}
HibernateTest
hibernate简单实现CRUD完成