hibernate的crud操作

1：hibernate操作的帮助类

public class hibernateUtil {

	public static SessionFactory factory;
	static{
		Configuration cfg = new Configuration();
		cfg.configure();
	    factory = cfg.buildSessionFactory();
	}
}

 2：hibernate的持久化类

//pojo持久化类
//对象的序列化的作用：让对象在网络上传输,以二进制的形式传输
public class Person implements Serializable{
    private String id;
    private String name;
    public Person()
    {
       //提供一个默认的构造函数，Session.get利用反射时候根据这个
    }
    public String getId() {
        return id;
    }
    public void setId(String id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }  
}

3：hibernate的持久化类和mysql表的映射关系

<?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：表名，和类名一样可以不写
 -->
<class name="com.hibernate.domain.Person" table="Person">
   <!-- 
     id为标示属性，和数据库的id对应
     name为属性的名词，column为列的名词，一样也可以不写
     generator为主键产生器，手动，自动，要告诉hibernate容器用什么方式产生主键
    -->
   <id name="id" column="id" length="20" >
       <!-- <generator class="increment"></generator> -->
      <!--  <generator class="identity"></generator> -->
      <!--   <generator class="assigned"></generator> -->
          <generator class="uuid"></generator>
   </id>
   
   <!-- 
            描述一般属性,length可以不写，但是默认是最大值
       type属性有2种写法java类型如java.lang.String和hibernate类型string(小写)
             但java类型效率更高，因为hibernate也要转为java类型在和sql进行对应varchar
    -->
    <property name="name" column="name" length="20" type="string"></property>
</class>
</hibernate-mapping>

4:hibernate的配置文件

<?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>
<!-- hibernate的配置文件，数据库连接和mapping -->

  <!-- 
        一个session-factory只能连接一个数据库
    -->
<session-factory>
    <!-- 
        数据库的用户名
    -->
    <property name="connection.username">root</property>
    <!-- 
        密码
    -->
    <property name="connection.password">123</property>
    <!-- 
        url
    -->
    <property name="connection.url">
        jdbc:mysql://localhost:3306/hibernate
    </property>
    <!-- 
        作用：根据持久化类和映射文件生成表
        validate
        create-drop
        create
        update
    -->
    <property name="hbm2ddl.auto">update</property>
    <!-- 
        显示hibernate内部生成的sql语句
    -->
    <property name="show_sql">true</property>
    <mapping resource="com/hibernate/domain/hibernate.hbm.xml" />
  </session-factory>
</hibernate-configuration>

5：完成hibernate的crud操作

package com.hibernate.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 com.hibernate.Util.hibernateUtil;
import com.hibernate.domain.Person;

//数据库的增删改查总结
/*
 * 1:查询不用事务，增删改用事务
 * 2：添加不用查找id，查询删除更新都要根据id找到这个对象进行操作
 * 3:crud操作都通过核心session操作
 */
public class PersonTest extends hibernateUtil {

    /*
     * 判断一个类是不是持久化类 1：加载配置文件 2：在配置文件中加载映射文件 3：解析映射文件的class name是否存在，存在就是持久化类
     */
    // session.save()
    @Test
    public void savePerson() {
        // 通过继承hibernateUtil自动生成sessionFactory
        // 下面的公共代码可以继承hibernateUtil来实现
        /*
         * Configuration cfg = new Configuration(); cfg.configure();
         * //启动和加载hibernate的配置文件hibernate.cfg.xml SessionFactory factory =
         * cfg.buildSessionFactory();
         */

        /*
         * hibernate把配置文件中的数据库连接信息，映射文件和持久化类的信息封装到sessionFactory中
         * sessionFactory单列模式，该类本身是线程安全的 sessionFactory是重量级了类，肯定啊封装了怎么多东西
         */
        Session session = factory.openSession();
        // openSession打开数据库连接--->查询
        // ---->增删改-->要开启事务--cud--提交事务-->关闭连接
        Transaction tran = session.beginTransaction();

        Person p = new Person();
        p.setName("xxxxx");
        session.save(p);
        // save相当于自动拼sql insert into Person(id,name) value(?,?)
        // 客户端的操作必须是持久化对象p
        tran.commit();
        session.close();
    }

    // session.createQuery
    @Test
    public void QueryPerson() {
        // 查询所有
        Session session = factory.openSession();
        // hibernate的查询语句是HQL语句from 类名
        List<Person> persons = session.createQuery("from Person").list();
        for (Person p : persons) {
            System.out.println(p.getName());
        }
        session.close();
    }

    // session.get
    @Test
    public void queryPersonById() {
        Session session = factory.openSession();
        // 利用session.get()产生Person对象，调用的是默认的构造函数，所有一定要用构造函数
        Person p = (Person) session.get(Person.class, 1);
        System.out.println(p.getName());
        session.close();
    }

    //hibernate内部根据标识符，看标识符在数据库中相应的表中，有就删除
    //session.delete()
    @Test
    public void deletePerson() {
        Session session = factory.openSession();
        Transaction tran = session.beginTransaction();
       /*
        * 1:找出要删除的id
        * 2:删除该id对应的记录
        */
        Person person=(Person) session.get(Person.class, 3);
        session.delete(person);
        tran.commit();
        session.close();
    }
    
    @Test
    public void updatePerson() {
        Session session = factory.openSession();
        Transaction tran = session.beginTransaction();
       /*
        * 1:找出要更新的id
        * 2:进行修改
        * 3;进行update操作
        */
        Person person=(Person) session.get(Person.class, 4);
        person.setName("林小小");
        session.update(person);
        tran.commit();
        session.close();
    }
}