1.hibernate七步走完成增删改查

一、hibernate框架介绍如下

1.框架=模板

2.Hibernate是对象模型与关系数据库模型之间的桥梁

3.hibernate持久化概念

什么是ORM

ORM是对象关系映射,是一种数据持久化操作(增删改查),

它在对象模型和关系型数据库之间建立起对应关系,并且提供了一种机制,通过javabean对象去操作数据库中数据.

4.hiberante概念

hibernate就是采用orm对象关系映射技术的持久化开发框架.

5.hibernate优缺点及使用场合

1.优点

hibernate很强大,减少了传统jdbc链接数据库的代码,提供了持久化代码的开发速度,降低了维护成本.

hibernate支持很多面向对象的特性.如组合,继承,多态等.使得开发人员必须在面向业务领域的对象模型和面向数据库的关系数据库模型之间来回切换,方便开发人员进行面向对象的设计和开发.

可移植性好.系统不会绑定在某个特定的关系型数据上,对于系统更换数据库,通常只需要修改hibernate配置文件即可正常运行

hibernate框架是开源免费的,可以在需要时研究源代码,改写源代码,进行功能定制,具有可扩展性.

2.缺点

不适合以数据为中心大量使用存储过程的应用.

大规模的批量插入,修改和删除不适用于hibernate

3.适用场合

hibernate适用于大中型项目

hibernate不适用于小型项目,

hibernate不适合用于关系模型设计不合理,不规范的系统

6.hibernate框架搭建步骤:

1.下载需要的jar包

（1）slf4j-log4j12-1.5.8.jar

hibernate日志记录文件,在控制台打印系统内部完成操作的一些结果,比如hiberante给你拼装的sql,和hibernate启动信息

（2）antlr-2.7.6.jar

语法分析器

（3）commons-collections-3.1.jar

各种集合类和集合工具类的封装

（4） commons-dbcp.jar

（5）commons-dbcp-1.2.1.jar

（6） commons-lang-1.0.1.jar

（7）commons-logging-1.0.4.jar

（8）commons-pool-1.2.jar

数据池

（9）dom4j-1.6.1.jar

XML的读写

（10）hibernate3.jar

hiberante核心文件封装了hibernate使用的接口和类

（11）javassist-3.9.0.GA.jar

分析,编辑和创建java字节码的类库

（12）jta.jar

java事务API

（13）log4j-1.2.8.jar

日志操作

（14）slf4j-api-1.5.8.jar

2.将上述jar文件和oracle的jar文件加载到web项目中

3.在src下创建hibernate主配置文件hiberante.cfg.xml

该配置文件主要用于配置数据库链接和hibernate运行时所需要的各种特性.

该文件要在web项目的src根目录下创建

步骤:

选中src

new

xml(Basic Template)

输入名字:hibernate.cfg.xml

选择 create xml file from a DTD file

选择Select XML Catalog entry

在XML Catalog列表框中找到 "-//Hibernate/Hibernate Configuration DTD 3.0 // EN"

常用参数说明

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd" >
 3 <hibernate-configuration>
 4    <!-- session会话工厂配置数据源 -->
 5    <session-factory>
 6        <!-- 1.链接数据库的driver -->
 7        <property name="connection.driver_class">oracle.jdbc.driver.OracleDriver</property>
 8        <!-- 2.链接数据库的url -->
 9        <property name="connection.url">jdbc:oracle:thin:@127.0.0.1:1521:orcl</property>
10        <!-- 3.链接数据库的用户名 -->
11        <property name="connection.username">scott</property>
12        <!-- 4.链接数据库的密码 -->
13        <property name="connection.password">tiger</property>
14        <!-- 5.配置数据库的方言 -->
15        <property name="dialect">org.hibernate.dialect.Oracle10gDialect</property>
16        <!-- 6.配置是否在控制台显示hibernate封装的sql -->
17        <property name="show_sql">true</property>
18        <!-- 7.sql语句格式化 -->
19        <property name="format_sql">true</property>
20    </session-factory>
21 </hibernate-configuration>

二、使用hibernate实现全套正删改查

2.1 创建项目Hibernate_Part1并在项目的WebRoot下的WEB-INF下的lib文件下加入如下jar文件：

 1 slf4j-log4j12-1.5.8.jar
 2 antlr-2.7.6.jar
 3 commons-collections-3.1.jar
 4 commons-dbcp.jar
 5 commons-dbcp-1.2.1.jar
 6 commons-lang-1.0.1.jar
 7 commons-logging-1.0.4.jar
 8 commons-pool-1.2.jar
 9 dom4j-1.6.1.jar
10 hibernate3.jar
11 javassist-3.9.0.GA.jar
12 jta.jar
13 log4j-1.2.8.jar
14 slf4j-api-1.5.8.jar

hibernate框架所需要的jar

2.2 在项目的src下创建hibernate.cfg.xml主配置文件

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd" >
 3 <hibernate-configuration>
 4   <session-factory>
 5   <!-- oracle驱动 -->
 6     <property name="connection.driver_class">oracle.jdbc.driver.OracleDriver</property>
 7     <!-- 连接 数据库url-->
 8     <property name="connection.url">jdbc:oracle:thin:@127.0.0.1:1521:orcl</property>
 9     <!-- 连接数据库用户名 -->
10     <property name="connection.username">scott</property>
11     <!-- 连接数据库密码 -->
12     <property name="connection.password">tiger</property>
13     <!-- 数据库 方言-->
14     <property name="dialect">org.hibernate.dialect.Oracle10gDialect</property>
15     <!-- 显示sql语句 -->
16     <property name="show_sql">true</property>
17     <!-- sql语句格式化 -->
18     <property name="format_sql">true</property>
19
20     <!--注册映射文件 -->
21     <mapping resource="com/entity/Dept.hbm.xml"/>
22   </session-factory>
23 </hibernate-configuration>

hibernate.cfg.xml

2.3 在src下的com.entity包下创建Dept.java文件

 1 package com.entity;
 2
 3
 4 public class Dept{
 5
 6 private Integer  deptno;
 7    private String deptname;
 8    private String loc;
 9
10 public Dept() {
11 }
12
13 public Dept(Integer deptno, String deptname, String loc) {
14     this.deptno = deptno;
15     this.deptname = deptname;
16     this.loc = loc;
17 }
18
19 public Integer getDeptno() {
20     return deptno;
21 }
22
23 public void setDeptno(Integer deptno) {
24     this.deptno = deptno;
25 }
26
27 public String getDeptname() {
28     return deptname;
29 }
30
31 public void setDeptname(String deptname) {
32     this.deptname = deptname;
33 }
34
35 public String getLoc() {
36     return loc;
37 }
38
39 public void setLoc(String loc) {
40     this.loc = loc;
41 }
42
43 @Override
44 public String toString() {
45     return "Dept [deptname=" + deptname + ", deptno=" + deptno + ", loc=" + loc
46             + "]";
47 }
48
49
50 }

Dept.java

2.4 在src下的com.entity包下创建Dept.hbm.xml文件

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd" >
 3 <hibernate-mapping>
 4    <class name="com.entity.Dept" table="DEPT">
 5       <id name="deptno" type="java.lang.Integer" column="DEPTNO">
 6          <generator class="assigned"/>
 7       </id>
 8       <property name="deptname" type="java.lang.String" column="DNAME"/>
 9       <property name="loc" type="java.lang.String" column="LOC"/>
10    </class>
11 </hibernate-mapping>

Dept.hbm.xml

2.5 在src下的com.dao包下创建DeptDao.java文件

  1 package com.dao;
  2 import java.io.Serializable;
  3
  4 import org.hibernate.Session;
  5 import org.hibernate.SessionFactory;
  6 import org.hibernate.Transaction;
  7 import org.hibernate.cfg.Configuration;
  8
  9 import com.entity.Dept;
 10
 11 public class DeptDao implements Serializable{
 12     /**
 13      *
 14      */
 15     private static final long serialVersionUID = 7318695909579058942L;
 16
 17
 18     /**
 19      * 1.get方法查询当查不到返回null
 20      * 关闭session能读取到
 21      * @param id
 22      */
 23     public static void getDept(Integer id){
 24         //1.读取配置文件
 25         Configuration configuration=new Configuration().configure("/hibernate.cfg.xml");
 26
 27         //2.创建Session工厂
 28         SessionFactory sessionFactory=configuration.buildSessionFactory();
 29
 30         //3.打开Session
 31         Session session=sessionFactory.openSession();
 32
 33         //4.开启事务(查询不需要)
 34         Transaction tx=session.beginTransaction();
 35
 36         //5.执行操作
 37         Dept dept=(Dept) session.get(Dept.class, id);
 38         if(dept!=null){
 39             System.out.println("查到了");
 40                System.out.println(dept);
 41
 42         }else{
 43             System.out.println("没查到");
 44         }
 45
 46          //6.提交事务（查询不需要）
 47         tx.commit();
 48
 49
 50         //7.关闭session
 51         session.close();
 52
 53
 54
 55
 56     }
 57
 58     /**
 59      * 2.load方法查询当查不到报出异常
 60      * 关闭session读取不到，报出异常
 61      * @param id
 62      */
 63     public static void loadDept(Integer id){
 64         //1.读取配置文件
 65         Configuration configuration=new Configuration().configure("/hibernate.cfg.xml");
 66
 67         //2.创建Session工厂
 68         SessionFactory sessionFactory=configuration.buildSessionFactory();
 69
 70         //3.打开Session
 71         Session session=sessionFactory.openSession();
 72
 73         //4.开启事务(查询不需要)
 74         Transaction tx=session.beginTransaction();
 75
 76         //5.执行操作
 77         Dept dept=(Dept) session.load(Dept.class, id);
 78
 79          //6.提交事务（查询不需要）
 80         tx.commit();
 81
 82         System.out.println(dept);
 83
 84         //7.关闭session
 85         session.close();
 86
 87     }
 88
 89     /**
 90      * 添加
 91      * @param dept
 92      */
 93     public static void saveDept(Dept dept){
 94         //1.读取配置文件
 95         Configuration configuration=new Configuration().configure("/hibernate.cfg.xml");
 96
 97         //2.创建Session工厂
 98         SessionFactory sessionFactory=configuration.buildSessionFactory();
 99
100         //3.打开Session
101         Session session=sessionFactory.openSession();
102
103         //4.开启事务
104         Transaction tx=session.beginTransaction();
105
106         //5.执行操作
107          session.save(dept);
108
109
110          //6.提交事务
111          tx.commit();
112
113          System.out.println("插入成功");
114
115         //7.关闭session
116         session.close();
117     }
118
119     /**
120      * 修改1
121      * 先查询单条再次修改
122      * @param dept
123      */
124     public static void updateDept(Integer id){
125         //1.读取配置文件
126         Configuration configuration=new Configuration().configure("/hibernate.cfg.xml");
127
128         //2.创建Session工厂
129         SessionFactory sessionFactory=configuration.buildSessionFactory();
130
131         //3.打开Session
132         Session session=sessionFactory.openSession();
133
134         //4.开启事务
135         Transaction tx=session.beginTransaction();
136
137         //5.执行操作
138         //查询
139          Dept dept=(Dept) session.get(Dept.class, id);
140
141          //修改
142          dept.setDeptname("不知道");
143          //6.提交事务
144          tx.commit();
145
146          System.out.println("修改成功");
147
148         //7.关闭session
149         session.close();
150     }
151
152
153     /**
154      * 删除对象
155      * 先查询单条再删除
156      * @param dept
157      */
158     public static void deleteDept(Integer id){
159         //1.读取配置文件
160         Configuration configuration=new Configuration().configure("/hibernate.cfg.xml");
161
162         //2.创建Session工厂
163         SessionFactory sessionFactory=configuration.buildSessionFactory();
164
165         //3.打开Session
166         Session session=sessionFactory.openSession();
167
168         //4.开启事务
169         Transaction tx=session.beginTransaction();
170
171         //5.执行操作
172         //查询
173          Dept dept=(Dept) session.get(Dept.class, id);
174
175          //删除对象
176          session.delete(dept);
177
178          //6.提交事务
179          tx.commit();
180
181          System.out.println("删除成功");
182
183         //7.关闭session
184         session.close();
185     }
186
187     public static void main(String[] args) {
188 //        getDept(10);
189 //        loadDept(10);
190 //        Dept dept=new Dept(1, "TB07", "青鸟学社");
191 //        saveDept(dept);
192 //        updateDept(1);
193 //        getDept(1);
194         deleteDept(1);
195         getDept(1);
196     }
197
198
199 }

DeptDao.java

2.6 运行结果自己试试看就知道了

三、使用hibernate的工具类实现全套正删改查

2.1 创建项目Hibernate_Part1并在项目的WebRoot下的WEB-INF下的lib文件下加入如下jar文件：

hibernate框架所需要的jar

2.2 在项目的src下创建hibernate.cfg.xml主配置文件

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd" >
 3 <hibernate-configuration>
 4   <session-factory>
 5      <property name="connection.driver_class">oracle.jdbc.driver.OracleDriver</property>
 6      <property name="connection.url">jdbc:oracle:thin:@127.0.0.1:1521:orcl</property>
 7      <property name="connection.username">holly</property>
 8      <property name="connection.password">sys</property>
 9      <property name="dialect">org.hibernate.dialect.Oracle10gDialect</property>
10      <property name="show_sql">true</property>
11      <property name="format_sql">true</property>
12
13      <mapping resource="com/entity/Teacher.hbm.xml"/>
14   </session-factory>
15 </hibernate-configuration>

hibernate.cfg.xml

2.3 在src下的com.entity包下创建Teacher.java文件

 1 package com.entity;
 2
 3 public class Teacher {
 4     private int id;
 5     private String name;
 6
 7     public Teacher() {
 8     }
 9
10     public Teacher( String name) {
11         this.name = name;
12     }
13     public Teacher(int id, String name) {
14         this.id = id;
15         this.name = name;
16     }
17
18     public int getId() {
19         return id;
20     }
21
22     public void setId(int id) {
23         this.id = id;
24     }
25
26     public String getName() {
27         return name;
28     }
29
30     public void setName(String name) {
31         this.name = name;
32     }
33
34     @Override
35     public String toString() {
36         return "Teacher [id=" + id + ", name=" + name + "]";
37     }
38
39
40
41
42 }

Teacher.java

2.4 在src下的com.entity包下创建Teacher.hbm.xml文件

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd" >
 3 <hibernate-mapping>
 4   <class name="com.entity.Teacher" table="TEACHER">
 5      <id name="id" type="java.lang.Integer" column="ID">
 6         <generator class="sequence">
 7            <param name="sequence">seq_teacher</param>
 8         </generator>
 9      </id>
10
11      <property name="name" type="java.lang.String" column="NAME"/>
12   </class>
13 </hibernate-mapping>

Teacher.hbm.xml

2.5 在src下的com.util包下创建HibernateUtil.java文件

 1 package com.util;
 2
 3 import org.hibernate.HibernateException;
 4 import org.hibernate.Session;
 5 import org.hibernate.SessionFactory;
 6 import org.hibernate.cfg.Configuration;
 7
 8 public class HibernateUtil {
 9     private  static ThreadLocal<Session> thread=new ThreadLocal<Session>();
10     private static Configuration config=null;
11     private static SessionFactory factory=null;
12
13     static{
14         try {
15             config=new Configuration().configure("/hibernate.cfg.xml");
16             factory=config.buildSessionFactory();
17         } catch (HibernateException e) {
18             System.out.println("读取配置文件失败");
19             e.printStackTrace();
20         }
21     }
22
23     public static Session getSession(){
24         Session session=thread.get();
25         if(session==null){
26             session=factory.openSession();
27             thread.set(session);
28         }
29         return session;
30
31     }
32
33     public static void closeSession(){
34         Session session=thread.get();
35         thread.set(null);
36         session.close();
37     }
38 }

HibernateUtil.java

2.6 在src下的com.dao包下创建TeacherDao.java文件

 1 package com.dao;
 2
 3 import org.hibernate.Session;
 4 import org.hibernate.Transaction;
 5
 6 import com.entity.Teacher;
 7 import com.util.HibernateUtil;
 8
 9 public class TeacherDao {
10     public static void main(String[] args) {
11         Teacher teacher=new Teacher(2,"死猪投资2");
12         //insertTeacher(teacher);
13         updateTeacher(teacher);
14         getTeacher(2);
15
16     }
17
18     private static void updateTeacher(Teacher teacher) {
19         Session session=HibernateUtil.getSession();
20         Transaction tx=session.beginTransaction();
21         session.merge(teacher);
22         tx.commit();
23         System.out.println("修改成功");
24         HibernateUtil.closeSession();
25
26     }
27
28     private static void getTeacher(int id) {
29         Session session=HibernateUtil.getSession();
30         Teacher teacher=(Teacher) session.get(Teacher.class, id);
31         System.out.println(teacher);
32         HibernateUtil.closeSession();
33     }
34
35     private static void insertTeacher(Teacher teacher) {
36         Session session=HibernateUtil.getSession();
37         Transaction tx=session.beginTransaction();
38         session.save(teacher);
39         tx.commit();
40         System.out.println("保存成功");
41         HibernateUtil.closeSession();
42     }
43
44
45
46 }

TeacherDao.java

2.7 运行结果自己试试看就知道了

时间： 2024-12-20 18:43:44

1.hibernate七步走完成增删改查的相关文章

【框架】[Hibernate]利用Hibernate进行单表的增删改查-Web实例

转载请注明出处:http://blog.csdn.net/qq_26525215 本文源自[大学之旅_谙忆的博客] 前面两篇博客已经将Hibernate的基础知识讲解得差不多了,差不多到写实例的时候了. 本篇只用hibernate进行单表的增删改查. 应用Hibernate,对students表进行增删改查. service层和DAO层,我都是直接写实现类了(因为这里主要是演示一下Hibernate的使用),如果是开发项目,注意一定要写接口! 准备数据库: 首先准备一个students表: cr

SSH学习四 Hibernate多对一的关系 + 增删改查

多对一关系实现起来不难,只需要在"多"的一方声明外键,声明外键在类的映射文件实现. 下面以老师学生为例,老师是1,学生是多 有一个有趣的地方,在Student类里面,没有声明teacherid这个属性,但是只要在配置文件声明了外键,那么就算类里面没有外键,配置文件的property也没有teacherid 下面是几个关键文件: 1.Student类(包含Student的增删改查) package com.learn.po; import org.hibernate.Session; i

Hibernate之API初识及增删改查实现

声明:关于hibernate的学习.非常大一部分东西都是概念性的. 大家最好手里都有一份学习资料,在我的博文中.我不会把书本上的概念一类的东西搬过来.那没有不论什么意义.关于hibernate的学习,我主要是通过演示项目让大家加深一些概念的理解,同一时候,也是为了让大家深层次的理解hibernate.而不仅仅是单纯的停留在概念上,假设仅仅是单纯的理解一些概念性的东西.到最后你们肯定会一无所获.并且过段时间就会忘记.所以以后的hibernate的学习.希望大家多看下演示项目.下载下来部署上演示看看

hibernate基本配置与简单增删改查

ORM(Object Relation Mapping)是对象关系映射,是一个思想,它的作用是在关系数据库与对象之间做一个自动映射,将数据库中的表格映射到一个类,也就是持久化类,数据表中每行映射为对象,行中的各个字段映射为对象的属性,这样可以在开发中使用面向对象的思想来操作数据库. 其中hibernate是ORM思想实现的一个持久层框架. 其中有三个主要的内容:1.持久化类(*.java) 2.映射文件(*.hbm.xml) 3.配置文件(*.cfg.xml) 使用Hibernate框架搭建一个

Hibernate实现最基本的增删改查

Hibernate提供了丰富的API对数据库进行操作. 其中Session是对数据库进行操作一个非常重要的类,他提供了对数据库增删改查的基本操作. 下面看一些具体示例,实例中实现了对数据库增加,删除,更新,根据ID查询,查询全部,分页查询,以及模糊查询 package dao; import java.util.List; import org.hibernate.HibernateException; import org.hibernate.Query; import org.hiberna

hibernate多对多关系配置--增删改查

hibernate多对多关联配置--并实现增删改查 hibernate就不多介绍了,这里就直接上我项目中使用的例子做说明. 数据模型 这是项目中用户和用户组的数据模型er图草稿,具体的model对象字段就以项目中的为主了. model类以及pojo接口,这里pojo接口用不上,大家测试的时候也可以去掉 package com.supre.model; import java.io.Serializable; import java.util.Set; public class User { pr

第七天 Delphi的增删改查学习

每次学着学着就过了凌晨,结果时间显示为第二天的日志了,真是醉了. 回到正题,今天学写了一个简单的程序,整个过程完全就是靠自己一点一点的去找资料进行学习,然后再加上自己的悟性,特别是最后那个数据库刷新功能的实现方法,真的是尝试了很多方法,脑子一直在不停的转,终于把这个难点给攻克了,也许高手看来是很简单,不过那一刻我真的很有成就感,哈哈,明天接着完成,争取尽早投简历. 按照老规矩,整理一下知识点吧. 1.cnpack插件可以辅助编程,提高效率,说实话真的很有用. 2.borderIcons可以设置是

6.实现struts2+hibernate实现学生列表的增删改查

1.dao 2.daoimpl 3.action 4.struts.xml(实现页面跳转)

Hibernate 批量增删改查操作

上文介绍Hibernate基本的增删改查,本例将介绍更实用的批量增删改查的操作的实现.本文中增删改查的操作,仅供参考.如果读者需要应用到实际的应用场景需要的话,需要在此基础上扩展与丰富. [转载使用,请注明出处:http://blog.csdn.net/mahoking] 在学习本例时,需要扩展一下Hibernate中Session的知识.Hibernate中的Session是一级缓存,可以理解为进程级的缓存.在进程运行期间一直存在.Session可以理解为一个可以操作数据库的对象 具体如何操作