今天主要去看公司的老框架, CRUD用的较多,所以总结一下步骤,以免忘记的时候温习
回顾 JDBC
工作过程：
-
加载驱动
-
建立连接
-
定义sql,发生sql语句
-
执行sql语句获得执行结果
-
处理返回结果
-
关闭资源
ORM对象关系映射
将汽车保存进数据库 ?
- 定义汽车类
- 定义类的属性
- 创建对象
DB 操作的做法
- 创建表
- 定义表中的字段
- 插入记录（一行）
将汽车保存到java程序的做法呢 ？
ORM:
面向对象的java语言和关系型数据库之间的对应关系
-
类----表
-
类属性----表中的字段
-
对象----数据库的记录
hibernate实现机制
hibernate 框架介绍
Hibernate是一个基于jdbc的开源的持久化框架，是一个优秀的ORM实现，它很大程度的简化了dao层编码工作。Hibernate对JDBC访问数据库的代码做了封装，大大简化了数据访问层繁琐的重复性代码。
在分层结构中处于持久化层，封装对数据库的访问细节，使业务逻辑层更专注于实现业务逻辑。是一个全自动的框架 ,基本的CRUD细节已经实现了
Src:hibernate.cfg.xml
描述数据的操作环境
Hibernate通过对jdbc的封装，以orm对象关系映射为基础，让程序员以完全面向对象的思想，实现对数据库的crud操作。在使用hibernate进行数据库的操作的时候，程序员不需要考虑sql语句的开发
Hello Hhibernate
新建java项目
建立hibernate的主配置文件
在src目录下，建立hibernate.cfg.xml
<?xml version="1.0" encoding="UTF-8"?>
<!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>
<!-- 配置数据库的连接信息 -->
<property name="connection.driver_class">com.mysql.jdbc.Driver</property>
<!-- jdbc:mysql://localhost:3306/1106 -->
<property name="connection.url">jdbc:mysql://localhost:3306/hibernate</property>
<property name="connection.username">root</property>
<property name="connection.password">root</property>
<!-- 配置hibernate操作的数据库对应的方言 hjibernate在操作数据库的过程中，需要将普通话，翻译为特定数据对应的方言sql语句，hibernate开发的应用程序
可以在不同的数据库上进行移植。 -->
<property name="dialect">org.hibernate.dialect.MySQLDialect</property>
<!-- 配置数据相关的其他属性 -->
<!-- hibenrate生产的sql语句是否在控制台进行打印 -->
<property name="show_sql">true</property>
<!-- 是否将产生的sql语句进行格式化 -->
<property name="format_sql">true</property>
<!-- 配置hibenrate的正向工程： hibernate的反向工程：由数据库中的表，产生java程序中的类 hibenrate的正向工程：由java中的类，产生数据库中对应的表
upate:如果数据库中存在某个java类对应的表，检查java类中的属性是否和数据库中的表字段一致，如果不一致进行更新 如果数据库中不存在表，会自动创建表。 -->
<property name="hbm2ddl">update</property>
<!-- 通过主配置文件，加载pojo的映射文件 -->
<mapping resource="com/spiritmark/pojo/Pet.hbm.xml" />
</session-factory>
</hibernate-configuration>
建立java类（实体类）
package com.bdqn.spiritmar.pojo;
public class Pet {
private Integer Id;
private String pname;
private String ptype;
private String color;
public Integer getId() {
return Id;
}
public void setId(Integer id) {
Id = id;
}
public String getPname() {
return pname;
}
public void setPname(String pname) {
this.pname = pname;
}
public String getPtype() {
return ptype;
}
public void setPtype(String ptype) {
this.ptype = ptype;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
}
1 <?xml version="1.0" encoding="UTF-8"?>
2 <!DOCTYPE hibernate-mapping PUBLIC
3 "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
4 "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
5 <!-- 描述java中的类和数据库的表映射关系 package:指定pojo所在的包 -->
6 <hibernate-mapping package="org.spirit.mark.pojo">
7 <!-- 描述类和表的关系 -->
8 <class name="Pet" table="t_pet">
9 <!-- 描述java对象的标识和数据库中的主键的对应关系 name:属性名 column:数据库的列表 type:属性的数据类型 -->
10 <id name="pid" column="pid" type="java.lang.Integer">
11 <!-- native:pid这一列在数据库中管理方式： 如:mysql 会自动使pid自增 oracle:会为该列产生一个序列 -->
12 <generator class="native"></generator>
13 </id>
14 <!-- 其他属性：简单属性 name:属性名 column:数据库的列表 type:属性的数据类型 -->
15 <property name="pname" column="pname" type="java.lang.String"></property>
16 <property name="ptype" column="ptype" type="java.lang.String"></property>
17 <property name="color" column="color" type="java.lang.String"></property>
18 </class>
19 </hibernate-mapping>
使用Hibernate的API
建立测试类，访问数据库
package com.bdqn.spiritmar.test;
import java.io.Serializable;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.junit.Test;
import org.guangsoft.pojo.Pet;
public class TestHibernate {
/*** * 添加一个宠物信息，为模板代码
* 单元测试：
* @Test
* 在定义单元测试方法的时候，方法不能有参数和返回值
* ***/
@Test
public void addPet()
{
//1 创建Configuration对象，用来加载hibernate的配置文件
Configuration cfg = new Configuration();
//2加载配置文件
cfg.configure("hibernate.cfg.xml");
//3通过cfg构造一个会话工厂对象
SessionFactory sf=cfg.buildSessionFactory();
//4获得数据库的会话对象，和数据库的连接
Session session = sf.openSession();
//5开始事务
Transaction tr=session.beginTransaction();
//6进行数据库的curd操作
Pet pet = new Pet();
pet.setPname("特朗普");
pet.setColor("绿色");
pet.setPtype("宝马");
//返回值为当前增加的记录的主键值
Serializable ser=session.save(pet);
System.out.println("ser="+ser);7 //7提交事务
tr.commit();
//8释放资源
session.close();
}
}
hibernate的基本操作（curd）
- 建立项目，加入jar
- 建立hibernate.cfg.xml
- 建立pojo类和对应的映射文件
定义Dao接口
1 package com.bdqn.spiritmark.dao;
2 import java.util.List;
3 import org.guangsoft.pojo.Student;
4 /***
5 *
6 * 学生表的crud操作定义
7 *
8 * ***/
9 public interface StudentDao
10 {
11 // 添加学生信息
12 public void saveStudent(Student stu);
13 // 删除学生信息
14 public void deleteStudent(Student stu);
15 // 修改学生信息
16 public void updateStudent(Student stu);
17 // 单条查询
18 public Student selStudentBySno(Integer sno);
19 // 查询所有学生信息
20 public List<Student> selStudentAll();
21 }
建立接口的实现类
1 package com.bdqn.spiritmark.dao.impl;
2 import java.util.List;
3 import org.hibernate.Session;
4 import org.hibernate.SessionFactory;
5 import org.hibernate.Transaction;
6 import org.hibernate.cfg.Configuration;
7 import org.guangsogt.dao.StudentDao;
8 import org.guangsoft.pojo.Student;
9 public class StudentDaoImpl implements StudentDao
10 {
11 /**
12 *
13 * 通过静态代码块加载配置文件
14 *
15 * ****/
16 static SessionFactory sf = null;
17 static
18 {
19 // 1 创建Configuration对象，用来加载hibernate的配置文件
20 Configuration cfg = new Configuration();
21 // 2加载配置文件
22 cfg.configure("hibernate.cfg.xml");
23 // 3通过cfg构造一个会话工厂对象
24 sf = cfg.buildSessionFactory();
25 }
26 @Override
27 public void saveStudent(Student stu)
28 {
29 // TODO Auto-generated method stub
30 // 获得数据库的会话对象
31 Session session = sf.openSession();
32 // 打开事务操作
33 Transaction tr = session.beginTransaction();
34 // 添加数据
35 session.save(stu);
36 // 提交事务
37 tr.commit();
38 // 关闭资源
39 session.close();
40 }
41 @Override
42 public void deleteStudent(Student stu)
43 {
44 // TODO Auto-generated method stub
45 // 1
46 Session session = sf.openSession();
47 // 2
48 Transaction tr = session.beginTransaction();
49 // 3
50 session.delete(stu);
51 // 4
52 tr.commit();
53 // 5
54 session.close();
55 }
56 @Override
57 public void updateStudent(Student stu)
58 {
59 // TODO Auto-generated method stub
60 // 1
61 Session session = sf.openSession();
62 // 2
63 Transaction tr = session.beginTransaction();
64 // 3
65 session.update(stu);
66 /***
67 *
68 * 如果传入的对象的唯一标识是null，那对数据库进行保存操作
69 *
70 * 如果传入的对象的唯一标识不是null，会进行更新操作，如果不存在
71 *
72 * **/
73 // session.saveOrUpdate(stu);
74 // 4
75 tr.commit();
76 // 5
77 session.close();
78 }
79 /**
80 *
81 * 单条查询
82 *
83 * ***/
84 @Override
85 public Student selStudentBySno(Integer sno)
86 {
87 // TODO Auto-generated method stub
88 // 1 session
89 Session session = sf.openSession();
90 // 2 查询操作事务是可以不需要的
91 // 3查询操作：参数1：需要查询的类对应的clas文件 参数2：查询条件（唯一标识）
92 Object obj = session.get(Student.class, sno);
93 return (Student) obj;
94 }
95 /*** 多条查询 ***/
96 @Override
97 public List<Student> selStudentAll()
98 {
99 // TODO Auto-generated method stub
100 // 1 session
101 Session session = sf.openSession();
102 // 2(通过hibernate提供的查询语句进行查询)
103 String hql = "from Student";
104 // 3执行hql语句
105 return session.createQuery(hql).list();
106 }
107 }
建立测试类
1 package com.bdqn.spiritmarktest;
2 import java.util.List;
3 import org.junit.Before;
4 import org.junit.Test;
5 import com.spirit.mark.dao.StudentDao;
6 import com.spirit.mark.impl.StudentDaoImpl;
7 import com.spirit.mark.pojo.Student;
8 public class TestCrud
9 {
10 // 声明Dao变量
11 StudentDao dao;
12 /***
13 *
14 * init方法在所有加@Test注解的方法执行之前，会自动执行。
15 *
16 * ***/
17 @Before
18 public void init()
19 {
20 dao = new StudentDaoImpl();
21 }
22 /**
23 *
24 * 测试增加学生的功能
25 *
26 * ***/
27 @Test
28 public void testSaveStudent()
29 {
30 Student stu = new Student();
31 stu.setSname("王岐山");
32 stu.setAddress("中南海");
33 stu.setBirthday("1956-10-10");
34 dao.saveStudent(stu);
35 }
36 /***
37 *
38 *
39 *
40 * 测试更新功能
41 *
42 * ***/
43 @Test
44 public void testUpdateStudent()
45 {
46 Student stu = new Student();
47 // 如果给定的id在数据库没有对应的记录，抛出异常
48 stu.setSno(19);
49 stu.setSname("迪迦");
50 stu.setAddress("光之国");
51 stu.setBirthday("1999-10-10");
52 dao.updateStudent(stu);
53 }
54 /***
55 *
56 * 进行单条查询
57 *
58 * ***/
59 @Test
60 public void testSelectStudentBySno()
61 {
62 Student s = dao.selStudentBySno(4);
63 System.out.println("-----" + s.getSno() + "\t" + s.getSname() + "\t"
64 + s.getAddress() + "\t" + s.getBirthday());
65 }
66 /***
67 *
68 * 测试多条查询
69 *
70 * ***/
71 @Test
72 public void testSelectStudentAll()
73 {
74 List<Student> list = dao.selStudentAll();
75 for (Student s : list)
76 {
77 System.out.println("-----" + s.getSno() + "\t" + s.getSname()
78 + "\t" + s.getAddress() + "\t" + s.getBirthday());
79 }
80 }
81 /***
82 *
83 * 测试删除
84 *
85 * **/
86 @Test
87 public void testDeleteStudent()
88 {
89 // 创建了对象，自己封装了id属性的值
90 /*
91 * Student stu = new Student();
92 *
93 * stu.setSno(4);
94 */
95 // 删除之前，先进行查询操作
96 Student stu = dao.selStudentBySno(3);
97 dao.deleteStudent(stu);
98 }
99 }
crud操作总结
Configuration ：加载hibernate的配置文件。
SessionFactory:会话工厂，在实际的程序也只存在一个对象。
Session:用来操作数据库的会话对象，产生事务对象
Transaction:事务控制对象
Session方法
-
BeginTransaction() 开始事务 -
Save() -
saveOrUpdate() -
delete()-
update()
-
-
get()/load();-
Query q = createQuery() -
q.list()
-
Query:执行数据库的查询操作，负责执行HQL语句
