hibernate的配置, 增删改查

路径：查找路径实际上都是查找编译后的对应的路径，在bin文件夹中总

增删改必须开启事务才行

hibernate加载文件的两种方式 configure

1.引包

 1 antlr-2.7.6.jar
 2 backport-util-concurrent.jar
 3 c3p0-0.9.1.jar
 4 commons-collections-3.1.jar
 5 commons-logging-1.1.1.jar
 6 dom4j-1.6.1.jar
 7 ehcache-1.5.0.jar
 8 hibernate3.jar
 9 javassist-3.9.0.GA.jar
10 jta-1.1.jar
11 log4j.jar
12 mysql-connector-java-5.1.10-bin.jar
13 slf4j-api-1.5.8.jar
14 slf4j-log4j12.jar

View Code

2.建立Person.java类

 1 package cn.itcast.hibernate.sh.domain;
 2 
 3 import java.io.Serializable;
 4 
 5 /**
 6  * 对象的序列化的作用：让对象在网络上传输,以二进制的形式传输
 7  * @author Think
 8  * Serializable标示接口
 9  */
10 public class Person implements Serializable{
11     private Long pid;
12     private String pname;
13     private String psex;
14     public Long getPid() {
15         return pid;
16     }
17     public void setPid(Long pid) {
18         this.pid = pid;
19     }
20     public String getPname() {
21         return pname;
22     }
23     public void setPname(String pname) {
24         this.pname = pname;
25     }
26     public String getPsex() {
27         return psex;
28     }
29     public void setPsex(String psex) {
30         this.psex = psex;
31     }
32     
33     
34     
35 }

3.建立在类的同包下

Person.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         用来描述一个持久化类
 7         name  类的全名
 8          table 可以不写  默认值和类名一样 
 9          catalog  数据库的名称  一般不写
10      -->
11     <class name="cn.itcast.hibernate.sh.domain.Person">
12         <!-- 
13             标示属性  和数据库中的主键对应
14             name  属性的名称
15             column 列的名称
16          -->
17         <id name="pid" column="pid" length="200" type="java.lang.Long">
18             <!-- 
19                 主键的产生器
20                   就该告诉hibernate容器用什么样的方式产生主键
21              -->
22             <generator class="increment"></generator>
23         </id>
24         <!-- 
25             描述一般属性
26          -->
27         <property name="pname" column="pname" length="20" type="string">
28         </property>
29         
30         <property name="psex" column="psex" length="10" type="java.lang.String"></property>
31     </class>
32 </hibernate-mapping>

在src中建立 hibernate.cfg.xml

 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 <session-factory>
10     <!-- 
11         数据库的用户名
12     -->
13     <property name="connection.username">root</property>
14     <!-- 
15         密码
16     -->
17     <property name="connection.password">friends</property>
18     <!-- 
19         url
20     -->
21     <property name="connection.url">
22         jdbc:mysql://localhost:3306/hibernate_basic
23     </property>
24     
25     
26     <property name="hibernate.dialect">org.hibernate.dialect.MySQLInnoDBDialect</property>
27     
28     
29     <!-- 
30         作用：根据持久化类和映射文件生成表
31         validate
32         create-drop
33         create
34         update
35     -->
36     <property name="hbm2ddl.auto">update</property>
37     <!-- 
38         显示hibernate内部生成的sql语句
39     -->
40     <property name="show_sql">true</property>
41     <mapping resource="cn/itcast/hibernate/sh/domain/Person.hbm.xml" />
42 
43 </session-factory>
44 </hibernate-configuration>

写测试语句

 1 package cn.itcast.hibernate.sh.test;
 2 
 3 
 4 import org.hibernate.Session;
 5 import org.hibernate.SessionFactory;
 6 import org.hibernate.Transaction;
 7 import org.hibernate.cfg.Configuration;
 8 import org.junit.Test;
 9 
10 import cn.itcast.hibernate.sh.domain.Person;
11 
12 public class CreateTable {
13     @Test
14     public void testCreateTableAndInsertData()
15     {
16         //在数据库下创建了表
17         //根据这语句的意思<property name="hbm2ddl.auto">update</property>
18         Configuration configuration=new Configuration();
19         //这种加载方式的源码是      configure( "/hibernate.cfg.xml" );
20         //configuration.configure();
21         
22         //第二种加载方式  
23         //参数resource代表加载配置文件的名称和路径
24         configuration.configure("/cn/itcast/hibernate/sh/domain/hibernate.cfg.xml");
25         
26         
27          SessionFactory sessionFactory=configuration.buildSessionFactory();
28         Session session=sessionFactory.openSession();
29         //------------------------------
30         
31         //因为 主键id increasement 所以 递增添加数据
32         //往数据库中添加数据， 对象的持久化
33         Transaction transaction= session.beginTransaction();
34         Person person=new Person();
35         person.setPname("aaaaaaaaaaaa");
36         person.setPsex("男");
37         session.save(person);
38         transaction.commit();
39         session.close();
40     }
41 }

测试二。 CRUD

  1 package cn.itcast.hibernate.sh.test;
  2 
  3 import java.util.List;
  4 
  5 import org.hibernate.Session;
  6 import org.hibernate.SessionFactory;
  7 import org.hibernate.Transaction;
  8 import org.hibernate.cfg.Configuration;
  9 import org.junit.Test;
 10 
 11 import cn.itcast.hibernate.sh.domain.Person;
 12 
 13 public class CreateTable 
 14 {
 15     //除了查询，其他操作必须开启事务 否则 不成功
 16     @Test
 17     public void testCreateTable()
 18     {
 19         //在数据库下创建了表
 20         //根据这语句的意思<property name="hbm2ddl.auto">update</property>
 21         Configuration configuration=new Configuration();
 22         //这种加载方式的源码是      configure( "/hibernate.cfg.xml" );
 23         //configuration.configure();
 24         
 25         //第二种加载方式  
 26         //参数resource代表加载配置文件的名称和路径
 27         configuration.configure("/hibernate.cfg.xml");
　　　　　　　configuration.buildSessionFactory();　
 28     }
 29     
 30     @Test
 31     public void testInsertData()
 32     {
 33         Session session = getSession();
 34         //------------------------------
 35         
 36         //因为 主键id increasement 所以 递增添加数据
 37         //往数据库中添加数据， 对象的持久化
 38         Transaction transaction= session.beginTransaction();
 39         Person person=new Person();
 40         person.setPname("aaaaaaaaaaaa");
 41         person.setPsex("男");
 42         /**
 43          * 参数必须持久化对象
 44          */
 45         session.save(person);
 46         transaction.commit();
 47         
 48         session.close();
 49     }
 50 
 51     private Session getSession() {
 52         //在数据库下创建了表
 53         //根据这语句的意思<property name="hbm2ddl.auto">update</property>
 54         Configuration configuration=new Configuration();
 55         //这种加载方式的源码是      configure( "/hibernate.cfg.xml" );
 56         //configuration.configure();
 57         
 58         //第二种加载方式  
 59         //参数resource代表加载配置文件的名称和路径
 60         configuration.configure();
 61         
 62         
 63         SessionFactory sessionFactory=configuration.buildSessionFactory();
 64         Session session=sessionFactory.openSession();
 65         return session;
 66     }
 67     @Test
 68     public void testQueryPerson()
 69     {
 70         Session session=getSession();
 71         List<Person> list=session.createQuery("from Person").list();
 72         for(Person p:list)
 73         {
 74             System.out.println(p);
 75         }
 76         session.close();
 77     }
 78     @Test
 79     public void testQueryPersonById()
 80     {
 81         Session session=getSession();
 82         /**
 83          * 按照主键的方式查询数据库表中的记录
 84          * 第二个参数的类型必须和持久化中标示符的类型保持一致
 85          */
 86         Person person=(Person) session.get(Person.class, 1L);
 87         System.out.println(person);
 88         
 89         session.close();
 90     }
 91     /**
 92      * hibernate内部会检查标示符，看标示符中的值在数据库相应的表中有没有对应的记录，如果有，则删除
 93      */
 94     @Test
 95     public void testDelPersonById()
 96     {
 97         Session session=getSession();
 98         Transaction t=session.beginTransaction();
 99         /**
100          * 1、根据id把值从数据库中查找出来
101          * 2、把对象删除掉
102          */
103         Person person=(Person) session.get(Person.class, 1L);
104         session.delete(person);
105         
106         
107         /**
108          * 1、新创建一个person对象
109          * 2、给person对象的标示符赋值
110          * 3、调用session.delete方法删除
111          */
112 //        Person person = new Person();
113 //        //person.setPid(2L);
114 //        session.delete(person);
115         
116         
117         System.out.println(person);
118         t.commit();
119         session.close();
120     }
121     @Test
122     public void testupdatePersonById()
123     {
124         Session session=getSession();
125         Transaction t=session.beginTransaction();
126         /**
127          * 1、根据id把持久化对象提取出来
128          * 2、进行修改
129          * 3、执行upate操作
130          */
131         
132         
133         Person person=(Person) session.get(Person.class, 2L);
134         person.setPsex("人妖");
135         
136         //第二种方式，其他值都要一一设 否则为null了
137 //        Person person = new Person();
138 //        person.setPid(1L);
139         session.update(person);
140         System.out.println(person);
141         t.commit();
142         session.close();
143     }
144     
145     //在hibernate中，不运行出现两个持久化对象，但是标识符是一样的
146     @Test
147     public void testIdentity(){
148         Session session = this.getSession();
149         Transaction transaction = session.beginTransaction();
150         Person person = (Person)session.get(Person.class, 2L);
151         Person person2 = new Person();
152         person2.setPid(2L);
153         session.update(person2);
154         transaction.commit();
155         session.close();
156     }
157 }

参考：

  1 package cn.itcast.hibernate.sh.test;
  2 
  3 import java.io.Serializable;
  4 import java.util.List;
  5 
  6 import org.hibernate.Session;
  7 
  8 import org.hibernate.Transaction;
  9 import org.junit.Test;
 10 
 11 import cn.itcast.hibernate.sh.domain.Person;
 12 import cn.itcast.hibernate.sh.utils.HiberanteUtils;
 13 
 14 public class PersonTest extends HiberanteUtils{
 15     @Test
 16     public void testSavePerson(){
 17         Session session = sessionFactory.openSession();
 18         Transaction transaction = session.beginTransaction();
 19         
 20         Person person = new Person();
 21         person.setPname("上海第一期班长");
 22         person.setPsex("女");
 23         
 24         /**
 25          * 参数必须持久化对象
 26          */
 27         session.save(person);
 28         
 29         transaction.commit();
 30         session.close();
 31     }
 32     
 33     @Test
 34     public void testQueryPerson(){
 35         Session session = sessionFactory.openSession();
 36         List<Person> personList = session.createQuery("from Person").list();
 37         for(Person person:personList){
 38             System.out.println(person.getPname());
 39         }
 40         session.close();
 41     }
 42     
 43     @Test
 44     public void testQueryPersonByID(){
 45         Session session = sessionFactory.openSession();
 46         /**
 47          * 按照主键的方式查询数据库表中的记录
 48          * 第二个参数的类型必须和持久化中标示符的类型保持一致
 49          */
 50         Person person = (Person)session.get(Person.class, 1L);
 51         System.out.println(person.getPname());
 52         session.close();
 53     }
 54     
 55     
 56     /**
 57      * hibernate内部会检查标示符，看标示符中的值在数据库相应的表中有没有对应的记录，如果有，则删除
 58      */
 59     @Test
 60     public void testDeletePerson(){
 61         Session session = sessionFactory.openSession();
 62         Transaction transaction = session.beginTransaction();
 63         /**
 64          * 1、根据id把值从数据库中查找出来
 65          * 2、把对象删除掉
 66          */
 67 //        Person person = (Person)session.get(Person.class, 1L);
 68 //        session.delete(person);
 69         
 70         /**
 71          * 1、新创建一个person对象
 72          * 2、给person对象的标示符赋值
 73          * 3、调用session.delete方法删除
 74          */
 75         Person person = new Person();
 76         //person.setPid(2L);
 77         session.delete(person);
 78         transaction.commit();
 79         session.close();
 80     }
 81     
 82     @Test
 83     public void testUpdatePerson(){
 84         Session session = sessionFactory.openSession();
 85         Transaction transaction = session.beginTransaction();
 86         
 87         /**
 88          * 1、根据id把持久化对象提取出来
 89          * 2、进行修改
 90          * 3、执行upate操作
 91          */
 92         Person person = (Person)session.get(Person.class, 1L);
 93         person.setPsex("不详");
 94 //        Person person = new Person();
 95 //        person.setPid(1L);
 96         session.update(person);
 97         transaction.commit();
 98         session.close();
 99     }
100     
101     @Test
102     public void testIdentity(){
103         Session session = sessionFactory.openSession();
104         Transaction transaction = session.beginTransaction();
105         Person person = (Person)session.get(Person.class, 1L);
106         Person person2 = new Person();
107         //person2.setPid(1L);
108         session.update(person2);
109         transaction.commit();
110         session.close();
111     }
112 }

View Code

原理性和排错

排错