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();
    }
}

原理性和排错

排错