hibernate的配置, 增删改查

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

增删改必须开启事务才行

hibernate加载文件的两种方式 configure

1.引包

 antlr-2.7.6.jar
 backport-util-concurrent.jar
 c3p0-0.9.1.jar
 commons-collections-3.1.jar
 commons-logging-1.1.1.jar
 dom4j-1.6.1.jar
 ehcache-1.5.0.jar
 hibernate3.jar
 javassist-3.9.0.GA.jar
 jta-1.1.jar
 log4j.jar
 mysql-connector-java-5.1.10-bin.jar
 slf4j-api-1.5.8.jar
 slf4j-log4j12.jar

2.建立Person.java类

 package cn.itcast.hibernate.sh.domain;

 import java.io.Serializable;

 /**
  * 对象的序列化的作用：让对象在网络上传输,以二进制的形式传输
  * @author Think
  * Serializable标示接口
  */
 public class Person implements Serializable{
     private Long pid;
     private String pname;
     private String psex;
     public Long getPid() {
         return pid;
     }
     public void setPid(Long pid) {
         this.pid = pid;
     }
     public String getPname() {
         return pname;
     }
     public void setPname(String pname) {
         this.pname = pname;
     }
     public String getPsex() {
         return psex;
     }
     public void setPsex(String psex) {
         this.psex = psex;
     }

 }

3.建立 在类的同包下

Person.hbm.xml

 <?xml version="1.0" encoding="utf-8"?>
 <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
 "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
 <hibernate-mapping>
     <!--
         用来描述一个持久化类
         name  类的全名
          table 可以不写  默认值和类名一样
          catalog  数据库的名称  一般不写
      -->
     <class name="cn.itcast.hibernate.sh.domain.Person">
         <!--
             标示属性  和数据库中的主键对应
             name  属性的名称
             column 列的名称
          -->
         <id name="pid" column="pid" length="200" type="java.lang.Long">
             <!--
                 主键的产生器
                   就该告诉hibernate容器用什么样的方式产生主键
              -->
             <generator class="increment"></generator>
         </id>
         <!--
             描述一般属性
          -->
         <property name="pname" column="pname" length="20" type="string">
         </property>

         <property name="psex" column="psex" length="10" type="java.lang.String"></property>
     </class>
 </hibernate-mapping>

在src中建立 hibernate.cfg.xml

 <?xml version='1.0' encoding='utf-8'?>
 <!DOCTYPE hibernate-configuration PUBLIC
         "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
         "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
 <hibernate-configuration>
     <!--
         一个session-factory只能连接一个数据库
     -->
 <session-factory>
     <!--
         数据库的用户名
     -->
     <property name="connection.username">root</property>
     <!--
         密码
     -->
     <property name="connection.password">friends</property>
     <!--
         url
     -->
     <property name="connection.url">
         jdbc:mysql://localhost:3306/hibernate_basic
     </property>

     <property name="hibernate.dialect">org.hibernate.dialect.MySQLInnoDBDialect</property>

     <!--
         作用：根据持久化类和映射文件生成表
         validate
         create-drop
         create
         update
     -->
     <property name="hbm2ddl.auto">update</property>
     <!--
         显示hibernate内部生成的sql语句
     -->
     <property name="show_sql">true</property>
     <mapping resource="cn/itcast/hibernate/sh/domain/Person.hbm.xml" />

 </session-factory>
 </hibernate-configuration>

写测试语句

 package cn.itcast.hibernate.sh.test;

 import org.hibernate.Session;
 import org.hibernate.SessionFactory;
 import org.hibernate.Transaction;
 import org.hibernate.cfg.Configuration;
 import org.junit.Test;

 import cn.itcast.hibernate.sh.domain.Person;

 public class CreateTable {
     @Test
     public void testCreateTableAndInsertData()
     {
         //在数据库下创建了表
         //根据这语句的意思<property name="hbm2ddl.auto">update</property>
         Configuration configuration=new Configuration();
         //这种加载方式的源码是      configure( "/hibernate.cfg.xml" );
         //configuration.configure();

         //第二种加载方式
         //参数resource代表加载配置文件的名称和路径
         configuration.configure("/cn/itcast/hibernate/sh/domain/hibernate.cfg.xml");

          SessionFactory sessionFactory=configuration.buildSessionFactory();
         Session session=sessionFactory.openSession();
         //------------------------------

         //因为 主键id increasement 所以 递增添加数据
         //往数据库中添加数据， 对象的持久化
         Transaction transaction= session.beginTransaction();
         Person person=new Person();
         person.setPname("aaaaaaaaaaaa");
         person.setPsex("男");
         session.save(person);
         transaction.commit();
         session.close();
     }
 }

测试二。 CRUD

 package cn.itcast.hibernate.sh.test;

 import java.util.List;

 import org.hibernate.Session;
 import org.hibernate.SessionFactory;
 import org.hibernate.Transaction;
 import org.hibernate.cfg.Configuration;
 import org.junit.Test;

 import cn.itcast.hibernate.sh.domain.Person;

 public class CreateTable
 {
     //除了查询，其他操作必须开启事务 否则 不成功
     @Test
     public void testCreateTable()
     {
         //在数据库下创建了表
         //根据这语句的意思<property name="hbm2ddl.auto">update</property>
         Configuration configuration=new Configuration();
         //这种加载方式的源码是      configure( "/hibernate.cfg.xml" );
         //configuration.configure();

         //第二种加载方式
         //参数resource代表加载配置文件的名称和路径
         configuration.configure("/hibernate.cfg.xml");
　　　　　　　configuration.buildSessionFactory();　
     }

     @Test
     public void testInsertData()
     {
         Session session = getSession();
         //------------------------------

         //因为 主键id increasement 所以 递增添加数据
         //往数据库中添加数据， 对象的持久化
         Transaction transaction= session.beginTransaction();
         Person person=new Person();
         person.setPname("aaaaaaaaaaaa");
         person.setPsex("男");
         /**
          * 参数必须持久化对象
          */
         session.save(person);
         transaction.commit();

         session.close();
     }

     private Session getSession() {
         //在数据库下创建了表
         //根据这语句的意思<property name="hbm2ddl.auto">update</property>
         Configuration configuration=new Configuration();
         //这种加载方式的源码是      configure( "/hibernate.cfg.xml" );
         //configuration.configure();

         //第二种加载方式
         //参数resource代表加载配置文件的名称和路径
         configuration.configure();

         SessionFactory sessionFactory=configuration.buildSessionFactory();
         Session session=sessionFactory.openSession();
         return session;
     }
     @Test
     public void testQueryPerson()
     {
         Session session=getSession();
         List<Person> list=session.createQuery("from Person").list();
         for(Person p:list)
         {
             System.out.println(p);
         }
         session.close();
     }
     @Test
     public void testQueryPersonById()
     {
         Session session=getSession();
         /**
          * 按照主键的方式查询数据库表中的记录
          * 第二个参数的类型必须和持久化中标示符的类型保持一致
          */
         Person person=(Person) session.get(Person.class, 1L);
         System.out.println(person);

         session.close();
     }
     /**
      * hibernate内部会检查标示符，看标示符中的值在数据库相应的表中有没有对应的记录，如果有，则删除
      */
     @Test
     public void testDelPersonById()
     {
         Session session=getSession();
         Transaction t=session.beginTransaction();
         /**
          * 1、根据id把值从数据库中查找出来
          * 2、把对象删除掉
          */
         Person person=(Person) session.get(Person.class, 1L);
         session.delete(person);

         /**
          * 1、新创建一个person对象
          * 2、给person对象的标示符赋值
          * 3、调用session.delete方法删除
          */
 //        Person person = new Person();
 //        //person.setPid(2L);
 //        session.delete(person);

         System.out.println(person);
         t.commit();
         session.close();
     }
     @Test
     public void testupdatePersonById()
     {
         Session session=getSession();
         Transaction t=session.beginTransaction();
         /**
          * 1、根据id把持久化对象提取出来
          * 2、进行修改
          * 3、执行upate操作
          */

         Person person=(Person) session.get(Person.class, 2L);
         person.setPsex("人妖");

         //第二种方式，其他值都要一一设 否则为null了
 //        Person person = new Person();
 //        person.setPid(1L);
         session.update(person);
         System.out.println(person);
         t.commit();
         session.close();
     }

     //在hibernate中，不运行出现两个持久化对象，但是标识符是一样的
     @Test
     public void testIdentity(){
         Session session = this.getSession();
         Transaction transaction = session.beginTransaction();
         Person person = (Person)session.get(Person.class, 2L);
         Person person2 = new Person();
         person2.setPid(2L);
         session.update(person2);
         transaction.commit();
         session.close();
     }
 }

参考：

 package cn.itcast.hibernate.sh.test;

 import java.io.Serializable;
 import java.util.List;

 import org.hibernate.Session;

 import org.hibernate.Transaction;
 import org.junit.Test;

 import cn.itcast.hibernate.sh.domain.Person;
 import cn.itcast.hibernate.sh.utils.HiberanteUtils;

 public class PersonTest extends HiberanteUtils{
     @Test
     public void testSavePerson(){
         Session session = sessionFactory.openSession();
         Transaction transaction = session.beginTransaction();

         Person person = new Person();
         person.setPname("上海第一期班长");
         person.setPsex("女");

         /**
          * 参数必须持久化对象
          */
         session.save(person);

         transaction.commit();
         session.close();
     }

     @Test
     public void testQueryPerson(){
         Session session = sessionFactory.openSession();
         List<Person> personList = session.createQuery("from Person").list();
         for(Person person:personList){
             System.out.println(person.getPname());
         }
         session.close();
     }

     @Test
     public void testQueryPersonByID(){
         Session session = sessionFactory.openSession();
         /**
          * 按照主键的方式查询数据库表中的记录
          * 第二个参数的类型必须和持久化中标示符的类型保持一致
          */
         Person person = (Person)session.get(Person.class, 1L);
         System.out.println(person.getPname());
         session.close();
     }

     /**
      * hibernate内部会检查标示符，看标示符中的值在数据库相应的表中有没有对应的记录，如果有，则删除
      */
     @Test
     public void testDeletePerson(){
         Session session = sessionFactory.openSession();
         Transaction transaction = session.beginTransaction();
         /**
          * 1、根据id把值从数据库中查找出来
          * 2、把对象删除掉
          */
 //        Person person = (Person)session.get(Person.class, 1L);
 //        session.delete(person);

         /**
          * 1、新创建一个person对象
          * 2、给person对象的标示符赋值
          * 3、调用session.delete方法删除
          */
         Person person = new Person();
         //person.setPid(2L);
         session.delete(person);
         transaction.commit();
         session.close();
     }

     @Test
     public void testUpdatePerson(){
         Session session = sessionFactory.openSession();
         Transaction transaction = session.beginTransaction();

         /**
          * 1、根据id把持久化对象提取出来
          * 2、进行修改
          * 3、执行upate操作
          */
         Person person = (Person)session.get(Person.class, 1L);
         person.setPsex("不详");
 //        Person person = new Person();
 //        person.setPid(1L);
         session.update(person);
         transaction.commit();
         session.close();
     }

     @Test
     public void testIdentity(){
         Session session = sessionFactory.openSession();
         Transaction transaction = session.beginTransaction();
         Person person = (Person)session.get(Person.class, 1L);
         Person person2 = new Person();
         //person2.setPid(1L);
         session.update(person2);
         transaction.commit();
         session.close();
     }
 }

原理性和排错

排错