Hibernate 环境搭建

Hibernate 工作流程

1、创建工程并导包

2、在src根目录下创建配置文件：hibernate.cfg.xml（也可以创建在src其他文件夹下，但是在后面的配置中，需要指明路径）

 1 <?xml version=‘1.0‘ encoding=‘utf-8‘?>
 2 <!DOCTYPE hibernate-configuration PUBLIC
 3         "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
 4         "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
 5 <hibernate-configuration>
 6 <!-- 是用来描述数据库的连接 -->
 7 <session-factory>
 8     <!-- 驱动 -->
 9     <property name="connection.driver_class">com.mysql.jdbc.Driver</property>
10     <!-- url-->
11     <property name="connection.url">jdbc:mysql://localhost:3306/hibernatetest</property>
12     <!-- username -->
13     <property name="connection.username">root</property>
14     <!-- password -->
15     <property name="connection.password">mysql</property>
16 <!--
17         hibernate针对建表的操作
18           update  如果有表，检查表的结构，如果没有则创建
19           create-drop 启动hibernate创建表，结束hibernate删除表
20           create  每次启动都重新创建表
21           validate 每次启动都检查表的结构
22      -->
23     <property name="hbm2ddl.auto">update</property>
24     <!-- 映射文件 -->
25     <mapping resource="cn/test/domain/Person.hbm.xml"/>
26 </session-factory>
27
28 </hibernate-configuration>

3、创建持久化层（一般实现Serializable 接口，并且要有一个默认构造函数【在后面反射中需要用到，否者会报错】）

 1 package cn.test.domain;
 2
 3 import java.io.Serializable;
 4
 5 public class Person implements Serializable {
 6     private long Pid;
 7     private String Pname;
 8     private String Page;
 9     public long getPid() {
10         return Pid;
11     }
12     public void setPid(long pid) {
13         Pid = pid;
14     }
15     public String getPname() {
16         return Pname;
17     }
18     public void setPname(String pname) {
19         Pname = pname;
20     }
21     public String getPage() {
22         return Page;
23     }
24     public void setPage(String page) {
25         Page = page;
26     }
27 }

4、创建映射文件，一般和持久化层在同一个文件夹下，命名方式一般为：持久化层类名.hbm.xml

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
 3 "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
 4 <hibernate-mapping>
 5     <!--
 6         class元素是用来描述持久化类
 7            name属性  类的全名
 8             table 该类对应的表名  可以不写，如果不写默认值就是类名
 9             catalog 数据库的名字  一般不用写
10      -->
11      <class name="cn.test.domain.Person" table="person">
12          <!--
13             主键
14               name描述的是属性的名称
15               column  数据库的字段的名称
16               type    类型
17               length  长度
18          -->
19          <id name="Pid" type="java.lang.Long" length="5">
20              <column name="pid"></column>
21              <!--
22                 主键的产生器
23                     increment 由hibernate产生
24              -->
25              <generator class="increment"></generator>
26          </id>
27
28          <!-- property是用来描述一般属性     -->
29          <property name="Pname" type="java.lang.String" length="5">
30              <column name="Pname"></column>
31          </property>
32          <!-- column可以不写，如果不写，默认属性的名称 -->
33          <property name="Page" type="java.lang.String" length="5"></property>
34      </class>
35 </hibernate-mapping>

4、测试

 1 public class MyTest {
 2     private static SessionFactory sessionFactory;
 3     static{
 4         Configuration configuration=new Configuration();
 5         //加载配置文件
 6         configuration.configure();
 7         //采用工厂模式创建SessionFactory
 8          sessionFactory=configuration.buildSessionFactory();
 9     }
10     @Test
11     public void testSave(){
12         Session session=sessionFactory.openSession();
13         //开启事物
14         Transaction transaction=session.beginTransaction();
15         Person person=new Person();
16         person.setPname("张三");
17         person.setPage("56");
18         session.save(person);//保存
19         transaction.commit();//提交事务
20         session.close();
21     }
22
23     @Test
24     public void testUpdate(){
25         Session session=sessionFactory.openSession();
26         Transaction transaction=session.beginTransaction();
27         //方法一：推荐；先获取要更新的对象，再更新
28         Person person=(Person) session.get(Person.class, 1L);//获取原来的值
29         person.setPage("100");
30         session.update(person);//更新
31
32         //方法二：不推荐；创建一个新的对象，覆盖旧的数据
33 //        Person person=new Person();
34 //        person.setPid(1L);
35 //        person.setPage("101");
36 //        session.update(person);
37         transaction.commit();
38         session.close();
39     }
40
41     @Test
42     public void testQuery(){
43         Session session=sessionFactory.openSession();
44         List<Person> list= session.createQuery("from Person").list();
45         System.err.println(list.size());
46     }
47
48     @Test
49     public void testQueryById(){
50         Session session=sessionFactory.openSession();
51         long l=1;
52         Person person= (Person) session.get(Person.class, l);
53         System.err.println(person.getPname()+"**********"+person.getPage());
54     }
55
56     @Test
57     public void testDelete(){
58         Session session=sessionFactory.openSession();
59         Transaction transaction=session.beginTransaction();
60          //方法一：
61 //        Person person= (Person) session.get(Person.class, 1L);
62 //        session.delete(person);
63         //方法二：
64         Person person=new Person();
65         person.setPid(1L);
66         session.delete(person);
67         transaction.commit();
68         session.close();
69     }