Hibernate相关
什么是Hibernate
Hibernate （开放源代码的对象关系映射框架）
Hibernate是一个开放源代码的对象关系映射框架，它对JDBC进行了非常轻量级的对象封装，它将POJO（Plain Ordinary Java Object）简单的Java对象，实际就是普通JavaBeans与数据库表建立映射关系，是一个全自动的orm框架，hibernate可以自动生成SQL语句，自动执行，使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。 Hibernate可以应用在任何使用JDBC的场合，既可以在Java的客户端程序使用，也可以在Servlet/JSP的Web应用中使用，最具革命意义的是，Hibernate可以在应用EJB的J2EE架构中取代CMP，完成数据持久化的重任。
基础概念
1.数据持久化?
数据持久化就是将内存中的数据模型转换为存储模型,以及将存储模型转换为内存中的数据模型的统称. 数据模型可以是任何数据结构或对象模型,存储模型可以是关系模型、XML、二进制流等。cmp和Hibernate只是对象模型到关系模型之间转换的不同实现。
简单的理解就是:原本数据在应用程序中出现后,程序关闭数据消失.我们为了将数据保存下来,保存的过程称之为数据持久化.
2.如何数据持久化?
数据持久化方式一般为将数据存储在文本文件或者数据库中。
Java实现方式为JDBC连接数据库,对数据进行操作或者通过IO流的形式存储在文本文件中。
3.JDBC?
JDBC（Java Data Base Connectivity,java数据库连接）是一种用于执行SQL语句的Java API，可以为多种关系数据库提供统一访问，它由一组用Java语言编写的类和接口组成。JDBC提供了一种基准，据此可以构建更高级的工具和接口，使数据库开发人员能够编写数据库应用程序.
JDBC是基础的实现对数据库操作的方式，为什么会有Hibernate?因为Hibernate将对数据库的操作转换为对Java对象的操作，从而简化开发。通过修改一个“持久化”对象的属性从而修改数据库表中对应的记录数据。
4.ORM框架?
对象-关系映射（Object/Relation Mapping，简称ORM），是随着面向对象的软件开发方法发展而产生的。面向对象的开发方法是当今企业级应用开发环境中的主流开发方法，关系数据库是企业级应用环境中永久存放数据的主流数据存储系统。对象和关系数据是业务实体的两种表现形式，业务实体在内存中表现为对象，在数据库中表现为关系数据。内存中的对象之间存在关联和继承关系，而在数据库中，关系数据无法直接表达多对多关联和继承关系。因此，对象-关系映射(ORM)系统一般以中间件的形式存在，主要实现程序对象到关系数据库数据的映射。
5.如果没有Hibernate如何编程？
对数据库操作进行CRUD?即增删改查
//1.加载驱动程序
Class.forName("com.mysql.jdbc.Driver");
//2.获得数据库的连接
Connection conn = DriverManager.getConnection(URL, NAME, PASSWORD);
//3.通过数据库的连接操作数据库，实现增删改查
Statement stmt = conn.createStatement();
ResultSet rs = stmt.executeQuery("SQL语句");
//获得结果集6.Hiberna大致实现?
创建POJO类
public class User {
//实体类的属性和表的字段名称一一对应
private int id;
private String UserName;
private String Password;
public User(){
}
User(String UserName,String Password){
this.UserName=UserName;
this.Password=Password;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getUserName() {
return UserName;
}
public void setUserName(String userName) {
UserName = userName;
}
public String getPassword() {
return Password;
}
public void setPassword(String password) {
Password = password;
}
}配置映射文件
xx.hbm.xml,数据库配置hibernate.cfg.xml
User user=new User();
//POJO类
Configuration cfg = new Configuration().configure();
//使用new Configuration().configure();来读取hibernate.cfg.xml配置文件
SessionFactory sf= cfg.buildSessionFactory();
//创建一个数据库对应一个SessionFactory
//session是非线程安全，一般是一个请求一个session.
session = sf.openSession();
//手动开启事务(可以在hibernate.cfg.xml配置文件中配置自动开启事务)
session.beginTransaction();
/*保存数据，此处的数据是保存对象，这就是hibernate操作对象的好处，我们不用写那么多的JDBC代码，只要利用session操作对象，至于hibernat如何存在对象，这不需要我们去关心它，
* 这些都有hibernate来完成。我们只要将对象创建完后，交给hibernate就可以了。 */
session.save(user);
//事物类型
session.getTransaction().commit();
//提交请求实现Hibern框架编程
配置环境
1.下载Hibernate:
http://hibernate.org/orm/downloads/
点击绿色按钮,在跳转页面后自动下载
2.添加jar包：
Hibernate所需包:
依赖路径:
hibernate-release-xxxx.Final\lib\required
JDBC-Connection所需包
https://dev.mysql.com/downloads/connector/
步骤一、
步骤二、
3.拷贝并配置文件hibernate.cfg.xml , log4j.properties
依赖路径:hibernate-release-xxxx.Final\project\etc
<!--
~ Hibernate, Relational Persistence for Idiomatic Java
~
~ License: GNU Lesser General Public License (LGPL), version 2.1 or later.
~ See the lgpl.txt file in the root directory or <http://www.gnu.org/licenses/lgpl-2.1.html>.
-->
<!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 name="foo">
<!-- 配置MySQl数据库的连接参数 -->
<property name="hibernate.dialect">org.hibernate.dialect.MySQL57Dialect</property>
<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
<property name="hibernate.connection.url">jdbc:mysql://localhost:3306/demo</property>
<property name="hibernate.connection.username">root</property>
<property name="hibernate.connection.password">root</property>
<!--<property name="show_sql">true</property>-->
<!--
<mapping resource="org/hibernate/test/legacy/Simple.hbm.xml"/>
<class-cache
class="org.hibernate.test.legacy.Simple"
region="Simple"
usage="read-write"/>
-->
<mapping resource="com/BoomMan/Struct/User.hbm.xml"/>
</session-factory>
</hibernate-configuration>4.数据库建表,POJO类创建
/**
* Creat By BoomMan
* Time : 2017.05.03
* users表所对应的实体类
*/
public class User {
//实体类的属性和表的字段名称一一对应
private int id;
private String UserName;
private String Password;
public User(){
}
User(String UserName,String Password){
this.UserName=UserName;
this.Password=Password;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getUserName() {
return UserName;
}
public void setUserName(String userName) {
UserName = userName;
}
public String getPassword() {
return Password;
}
public void setPassword(String password) {
Password = password;
}
}5.拷贝并配置映射文件*.hbm.xml
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<!--
<hibernate-mapping>一般不去配置，采用默认即可。
default-cascade="none"：默认的级联风格，表与表联动。
default-lazy="true"：默认延迟加载
-->
<hibernate-mapping>
<!--
<class>：使用class元素定义一个持久化类。
name="cn.javass.user.vo.UserModel"：持久化类的java全限定名；
table="tbl_user"：对应数据库表名；
mutable="true"：默认为true，设置为false时则不可以被应用程序更新或删除；
dynamic-insert="false"：默认为false，动态修改那些有改变过的字段，而不用修改所有字段；
dynamic-update="false"：默认为false，动态插入非空值字段；
select-before-update="false"：默认为false，在修改之前先做一次查询，与用户的值进行对比，有变化都会真正更新；
optimistic-lock="version"：默认为version(检查version/timestamp字段)，取值：all(检查全部字段)、dirty(只检查修改过的字段)、
none(不使用乐观锁定)，此参数主要用来处理并发，每条值都有固定且唯一的版本，版本为最新时才能执行操作；
-->
<class name="com.BoomMan.Struct.User" table="user" dynamic-insert="true" dynamic-update="true" optimistic-lock="version">
<!--
<id>：定义了该属性到数据库表主键字段的映射。
name="userId"：标识属性的名字；
column="userId"：表主键字段的名字，如果不填写与name一样；
-->
<id name="id" column="id">
<!-- <generator>：指定主键由什么生成，推荐使用uuid，assigned指用户手工填入。 -->
<generator class="native"/>
</id>
<!--
<version/>：使用版本控制来处理并发，要开启optimistic-lock="version"和dynamic-update="true"。
name="version"：持久化类的属性名，column="version"：指定持有版本号的字段名；
-->
<!-- 这里应该用序列化和反序列化
<version name="id" column="version"/>
-->
<!--
<property>：为类定义一个持久化的javaBean风格的属性。
name="name"：标识属性的名字，以小写字母开头；
column="name"：表主键字段的名字，如果不填写与name一样；
update="true"/insert="true"：默认为true，表示可以被更新或插入；
-->
<property name="userName" column="UserName"/>
<property name="password" column="Password"/>
<!--
组件映射：把多个属性打包在一起当一个属性使用，用来把类的粒度变小。
<component name="属性，这里指对象">
<property name="name1"></property>
<property name="name2"></property>
</component>
-->
<!--
<join>:一个对象映射多个表，该元素必须放在所有<property>之后。
<join table="tbl_test：子表名">
<key column="uuid：子表主键"></key>
<property name="name1：对象属性" column="name：子表字段"></property>
</join>
-->
</class>
</hibernate-mapping>6.测试运行
public static void main(String[] args) {
Configuration cfg = null;
SessionFactory sf = null;
Session session = null;
User user=new User();
user.setUserName("BoomMan");
user.setPassword("000");
/*
* org.hibernate.cfg.Configuration类的作用：
* 读取hibernate配置文件(hibernate.cfg.xml或hiberante.properties)的.
* new Configuration()默认是读取hibernate.properties
* 所以使用new Configuration().configure();来读取hibernate.cfg.xml配置文件
*/
cfg = new Configuration().configure();
/*
* 创建SessionFactory
* 一个数据库对应一个SessionFactory
* SessionFactory是线线程安全的。
*/
sf = cfg.buildSessionFactory();
try {
//创建session
//此处的session并不是web中的session
//session只有在用时，才建立concation,session还管理缓存。
//session用完后，必须关闭。
//session是非线程安全，一般是一个请求一个session.
session = sf.openSession();
//手动开启事务(可以在hibernate.cfg.xml配置文件中配置自动开启事务)
session.beginTransaction();
/*
* 保存数据，此处的数据是保存对象，这就是hibernate操作对象的好处，
* 我们不用写那么多的JDBC代码，只要利用session操作对象，至于hibernat如何存在对象，这不需要我们去关心它，
* 这些都有hibernate来完成。我们只要将对象创建完后，交给hibernate就可以了。
*/
session.save(user);
session.getTransaction().commit();
} catch (HibernateException e) {
e.printStackTrace();
//回滚事务
session.getTransaction().rollback();
} finally {
//关闭session
session.close();
sf.close();
}
}
扫一扫
234
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
