一、什么是Hibernate框架:
1.Hibernate是一个操作数据库的框架,实现了对JDBC的封装;
2.Hibernate是一个ORM(对象关系映射)框架,我们在写程序时 ,用的是面向对象的方法,但是在关系型数据库里,存的是一条条的数据,为了用纯面向对象的思想解决问题,所有需要将程序中的对象和数据库的记录建立起映射关系,ORM就是这样的技术,而Hibernate就是这样一个框架,以操作对象的方式操作数据库。
3.Hibernate简化了代码的编写,原生态的JDBC需要很多代码来实现操作数据库,在这里用Hibernate只需要很少的代码就可以实现。
4.使用Hibernate的基本流程是:配置实现类与数据库表的映射关系,产生sessionFactory,打开session通道拿到session对象,开启事务,完成操作,关闭session。
5.Hibernate屏蔽了数据库的差异,增强了对数据库的可移植性。
6.使用Hibernate时,先要配置hibernate.cfg.xml文件,其中配置数据库连接信息和方言等,还要为每个实体配置相应的hbm.xml文件(Hibernate的映射文件),当然,也可以采用注解编程实现映射关系,hibernate.cfg.xml文件中需要登记每个hbm.xml文件。
二、Hibernate项目的基本搭建:
步骤:
–创建工程,导入依赖;
–创建Hibernate核心配置文件;
–创建持久化类;
–创建对象-关系映射文件;
–通过Hibernate API编写访问数据库的代码。
具体实现:
1、创建一个maven项目,在pom.xml文件中导入hibernate所有相关的jar包依赖:
为了方便,在这里我直接导入ssh整合项目常用的依赖。
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.zwp</groupId>
<artifactId>ssh-test</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>war</packaging>
<!-- 属性 -->
<properties>
<spring.version>4.2.4.RELEASE</spring.version>
<hibernate.version>5.0.7.Final</hibernate.version>
<struts.version>2.3.24</struts.version>
</properties>
<!-- 锁定版本,struts2-2.3.24、spring4.2.4、hibernate5.0.7 -->
<dependencyManagement>
<dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aspects</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-orm</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-web</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-core</artifactId>
<version>${hibernate.version}</version>
</dependency>
<dependency>
<groupId>org.apache.struts</groupId>
<artifactId>struts2-core</artifactId>
<version>${struts.version}</version>
</dependency>
<dependency>
<groupId>org.apache.struts</groupId>
<artifactId>struts2-spring-plugin</artifactId>
<version>${struts.version}</version>
</dependency>
</dependencies>
</dependencyManagement>
<!-- 依赖管理 -->
<dependencies>
<!-- spring -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aspects</artifactId>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-orm</artifactId>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-web</artifactId>
</dependency>
<!-- 导入 struts2 -->
<dependency>
<groupId>org.apache.struts</groupId>
<artifactId>struts2-core</artifactId>
</dependency>
<dependency>
<groupId>org.apache.struts</groupId>
<artifactId>struts2-spring-plugin</artifactId>
</dependency>
<!-- hibernate -->
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-core</artifactId>
</dependency>
<!-- 数据库驱动 -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.6</version>
<scope>runtime</scope>
</dependency>
<!-- c3p0 -->
<dependency>
<groupId>c3p0</groupId>
<artifactId>c3p0</artifactId>
<version>0.9.1.2</version>
</dependency>
<!-- servlet jsp -->
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>servlet-api</artifactId>
<version>2.5</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>jsp-api</artifactId>
<version>2.0</version>
<scope>provided</scope>
</dependency>
<!-- 日志 -->
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-log4j12</artifactId>
<version>1.7.2</version>
</dependency>
<!-- junit -->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.9</version>
<scope>test</scope>
</dependency>
<!-- jstl -->
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>jstl</artifactId>
<version>1.2</version>
</dependency>
</dependencies>
<build>
<plugins>
<!-- 设置编译版本为1.8 -->
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<configuration>
<source>1.8</source>
<target>1.8</target>
<encoding>UTF-8</encoding>
</configuration>
</plugin>
<!-- 默认的tomcat6不支持jdk1.8,访问页面时报错:页面编译成.class失败
解决:配置tomcat7插件:mvn命令改为:tomcat7:run -->
<plugin>
<groupId>org.apache.tomcat.maven</groupId>
<artifactId>tomcat7-maven-plugin</artifactId>
<version>2.2</version>
<configuration>
<url>http://127.0.0.1:8080/manager/text</url>
<server>tomcat8</server>
<path>/</path>
</configuration>
</plugin>
</plugins>
</build>
</project>
2、创建Hibernate的主配置文件,命名:hibernate.cfg.xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
<session-factory>
<!-- 连接数据库 -->
<property name="connection.driver_class">com.mysql.jdbc.Driver</property>
<property name="connection.url">jdbc:mysql:///ssh-test</property>
<property name="connection.username">root</property>
<property name="connection.password">admin</property>
<!-- 设置数据库方言 -->
<property name="hibernate.dialect">org.hibernate.dialect.MySQL5Dialect</property>
<!-- 输出底层sql语句 -->
<property name="hibernate.show_sql">true</property>
<!-- format输出的底层sql语句格式 -->
<property name="hibernate.format_sql">true</property>
<!-- 自动创建表;update:如果已经有表,更新,如果没有,创建 -->
<property name="hibernate.hbm2ddl.auto">update</property>
<!-- 把映射文件放到核心配置文件中 -->
<mapping resource="com/zwp/domain/User.hbm.xml" />
</session-factory>
</hibernate-configuration>
3、创建持久化类:
//持久化对象:
public class User {
private int uid;
private String username;
private String password;
private String address;
public int getUid() {
return uid;
}
public void setUid(int uid) {
this.uid = uid;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
}
4、创建对象-关系映射文件:命名:类名.hbm.xml
并把映射文件放到核心配置文件hibernate.cfg.xml中,在第二步中已经写出来了。
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<!-- 创建映射配置文件 -->
<hibernate-mapping>
<!-- 1.配置类和对应表 class标签:name属性:实体类全路径;table属性:数据库表名称,数据库需要自己建立,如果不建立,会报异常 -->
<class name="com.zwp.domain.User" table="t_user">
<!-- 2.配置实体类id和表id对应,
hibernate要求实体类有一个属性唯一致,hibernate要求表有字段作为唯一值 -->
<!-- id标签:name属性:实体类里面id属性名称;column属性:生成的表字段名称 -->
<id name="uid" column="uid">
<!-- 设置uid的增长策略;native:就是生成表id主键自动增长,实体类的主键类型是int类型-->
<generator class="native"></generator>
<!-- 设置uid的增长策略;uuid:就是生成表id随机uuid,实体类的主键类型是String类型-->
<!-- <generator class="uuid"></generator> -->
</id>
<!-- 3.配置其他属性和表字段对应;name属性:实体类属性名称;column属性:生成表字段名称 -->
<property name="username" column="username"></property>
<property name="password" column="password"></property>
<property name="address" column="address"></property>
</class>
</hibernate-mapping>
5、测试:
//Hibernate的测试类
public class HibernateTest {
//添加一条数据的测试
@Test
public void testAdd(){
//第一步:加载hibernate核心配置文件
Configuration cfg=new Configuration();
cfg.configure();
//第二步:建立sessionFactory
//读取hibernate核心配置文件的内容,创建sessionFactory
//在这个过程中,会根据映射关系,在配置数据里面把表创建
SessionFactory sessionFactory = cfg.buildSessionFactory();
//第三步:使用SessionFactory常见session对象
Session session = sessionFactory.openSession();
//第四步:开启事务:
Transaction tx = session.beginTransaction();
//第五步:写具体的逻辑crud操作:
//添加功能:
User user = new User();
user.setUsername("zhangweipeng");
user.setPassword("123456");
user.setAddress("中国");
session.save(user);
//第六步:提交事务
tx.commit();
//第七步:关闭资源
session.close();
sessionFactory.close();
}
}
至此,如果测试成功的话,那么一个简单的hibernate的项目已经搭建完成。
附:项目结构:
三、常用Hibernate方法的使用:
1、hibernate常用方法:
//Hibernate的测试类
public class HibernateTest {
@Test
public void testAdd(){
//第一步:加载hibernate核心配置文件
Configuration cfg=new Configuration();
cfg.configure();
//第二步:建立sessionFactory
//读取hibernate核心配置文件的内容,创建sessionFactory
//在这个过程中,会根据映射关系,在配置数据里面把表创建
SessionFactory sessionFactory = cfg.buildSessionFactory();
//第三步:使用SessionFactory常见session对象
Session session = sessionFactory.openSession();
//第四步:开启事务:
Transaction tx = session.beginTransaction();
//第五步:写具体的逻辑crud操作之添加功能:
User user = new User();
user.setUsername("zhangweipeng");
user.setPassword("123456");
user.setAddress("中国");
session.save(user);
//第六步:提交事务
tx.commit();
//第七步:关闭资源
session.close();
sessionFactory.close();
}
@Test
public void testSel(){
Configuration cfg=new Configuration();
cfg.configure();
SessionFactory sessionfactory=cfg.buildSessionFactory();
Session session=sessionfactory.openSession();
Transaction tx=session.beginTransaction();
//第五步:写具体逻辑crud操作之查询功能:
//调用session的get方法,第一个参数:实体类class;第二个参数:id值
User user=session.get(User.class, 1);
System.out.println(user.toString());
tx.commit();
session.close();
sessionfactory.close();
}
@Test
public void testUpadte(){
Configuration cfg=new Configuration();
cfg.configure();
SessionFactory sessionfactory=cfg.buildSessionFactory();
Session session=sessionfactory.openSession();
Transaction tx=session.beginTransaction();
//第五步:写具体逻辑crud操作之修改功能:
//5.1根据id进行查询
User user=session.get(User.class, 1);
//5.2设置修改值
user.setUsername("updateUsername");
//调用session的update修改;持久态会自动更新数据库,可以不调用update
//session.update(user);
tx.commit();
session.close();
sessionfactory.close();
}
@Test
public void testDel(){
Configuration cfg=new Configuration();
cfg.configure();
SessionFactory sessionfactory=cfg.buildSessionFactory();
Session session=sessionfactory.openSession();
Transaction tx=session.beginTransaction();
//第五步:写具体逻辑crud操作之删除功能:
//常用:1:根据id删除
User user=session.get(User.class, 2);
session.delete(user);
//不常用:
//User user=new User();
//user.setUid(4);
//session.delete(user);
tx.commit();
session.close();
sessionfactory.close();
}
//saveOrUpdate()方法的使用
@Test
public void testsavaOrUpdate(){
Configuration cfg=new Configuration();
cfg.configure();
SessionFactory sessionfactory=cfg.buildSessionFactory();
Session session=sessionfactory.openSession();
Transaction tx=session.beginTransaction();
// 瞬时态的情况:
// User user =new User();
// user.setUsername("张三");
// user.setPassword("5646548");
// user.setAddress("中国");
// //实体类对象的状态是瞬时态,则执行添加操作
// session.saveOrUpdate(user);
// 持久态的情况:
// User user=session.get(User.class, 1);
// user.setUsername("李四");
// //实体类对象的状态是持久态,则执行修改操作
// session.saveOrUpdate(user);
//托管态的情况:
User user=new User();
user.setUid(6);
user.setUsername("王五");
user.setPassword("132156");
user.setAddress("印度");
//实体类对象的状态是托管态,则执行修改操作
session.saveOrUpdate(user);
tx.commit();
session.close();
sessionfactory.close();
}
}
hibernate中实体类对象有三种状态:
(1)瞬时态:实体类对象没有id值,与session也没有关联
(2)持久态:实体类对象有id值,与session有关联
(3)托管态:实体类对象有id值,与session没有关联
2、封装工具类:
从上面的几个测试方法可以看出,我们一直在重复使用同一段代码去创建并获取session,开启事务,为了提高代码的利用率,我们将重复使用的代码抽取出来,封装成一个工具类。
//Hibernate的util工具类:
public class HibernateUtil {
static Configuration cfg=null;
static SessionFactory sessionfactory=null;
//静态代码块实现
static{
//加载核心配置文件
cfg=new Configuration();
cfg.configure();
sessionfactory=cfg.buildSessionFactory();
}
//提供返回与本地线程的session方法
//需要在hibernate.cfg.xml中加入下面配置
//<property name="hibernate.current_session_context_class">thread</property>
public static Session getSeesionObject()
{
return sessionfactory.getCurrentSession();
}
//提供方法返回sessionFactory
public static SessionFactory getSessionFactory()
{
return sessionfactory;
}
}
3、hibernate的规范写法:
//hibernate规范写法:
@Test
public void test(){
//得到与本地连接的session
Session session = null;
Transaction tx=null;
try
{
//与本地线程绑定的session
session=HibernateUtil.getSeesionObject();
tx=session.beginTransaction();
User user=new User();
user.setUsername("张维鹏");
user.setPassword("123");
user.setAddress("中国");
session.save(user);
tx.commit();
}catch(Exception e){
e.printStackTrace();
tx.rollback();
}
finally
{
//session.close();//与本地线程绑定的session,不需要手动关闭
//sessionfactory.close();
}
}
四、hibernate常用对象api的使用:
1、Query对象:
①使用query对象,不需要写sql语句,但是要写hql语句。
Hql:hibernate query language,hibernate提供查询语句,与sql相似。
②hql和sql语句区别:
Sql语句操作表和表字段;hql语句操作实体类和属性。
③查询所有hql语句:from 实体类名称
④Query对象使用
–创建Query对象;
–调用query对象里面的方法得到结果。
2.Criteria对象:
①使用这个对象查询操作,不需要写语句,直接调用方法实现
②实现过程:
–创建criteria对象;
–调用对象里面的方法得到结果。
3、SQLQuery对象:
①使用hibernate时候,调用底层sql实现;
②实现过程:
–创建SQLQuery对象;
–调用对象的方法。
4、代码实现:
//使用Query对象
@Test
public void testQuery(){
SessionFactory sessionfactory = null;
Session session = null;
Transaction tx=null;
try{
sessionfactory=HibernateUtil.getSessionFactory();
session=sessionfactory.openSession();
tx=session.beginTransaction();
//1.创建Query对象,方法里面写hql语句
Query query=session.createQuery("from User");
//2.调用query对象的方法
List<User> list=query.list();
for(User user:list){
System.out.println(user.toString());
}
tx.commit();
}catch(Exception e){
e.printStackTrace();
tx.rollback();
}
finally{
session.close();
sessionfactory.close();
}
}
//使用Criteria对象
@Test
public void testCriteria(){
SessionFactory sessionfactory = null;
Session session = null;
Transaction tx=null;
try{
sessionfactory=HibernateUtil.getSessionFactory();
session=sessionfactory.openSession();
tx=session.beginTransaction();
//1.创建Criteria对象,参数写类名
Criteria criteria=session.createCriteria(User.class);
//2.调用criteria对象的方法
List<User> list=criteria.list();
for(User user:list){
System.out.println(user.toString());
}
tx.commit();
}catch(Exception e){
e.printStackTrace();
tx.rollback();
}
finally{
session.close();
sessionfactory.close();
}
}
//使用SQLQuery对象
@Test
public void testSQLQuery(){
SessionFactory sessionfactory = null;
Session session = null;
Transaction tx=null;
try{
sessionfactory=HibernateUtil.getSessionFactory();
session=sessionfactory.openSession();
tx=session.beginTransaction();
//1.创建SQLQuery对象,参数写底层sql语句
SQLQuery sqlquery=session.createSQLQuery("select * from t_user");
//调用SQLQuery对象的方法
//2.1 list默认返回的是数组的形式
/* List<Object[]> list=sqlquery.list();
for(Object[] objects:list){
//System.out.println(objects);
System.out.println(Arrays.toString(objects));
}*/
//2.2设置返回的是对象的形式:
sqlquery.addEntity(User.class);
//调用SQLQuery对象的方法
List<User> list =sqlquery.list();
for(User user:list){
System.out.println(user.toString());
}
tx.commit();
}catch(Exception e){
e.printStackTrace();
tx.rollback();
}
finally
{
session.close();
sessionfactory.close();
}
}
五、hibernate缓存:
一级缓存:
(1)一级缓存是默认打开的;
(2)一级缓存作用范围,是从session创建到session关闭;
(3)一级缓存存储的数据,必须是持久态数据。
发布者:全栈程序员-用户IM,转载请注明出处:https://javaforall.cn/114723.html原文链接:https://javaforall.cn
【正版授权,激活自己账号】: Jetbrains全家桶Ide使用,1年售后保障,每天仅需1毛
【官方授权 正版激活】: 官方授权 正版激活 支持Jetbrains家族下所有IDE 使用个人JB账号...