Hibernate回顾CRUD

Hibernate配置文件

<?xml version='1.0' encoding='utf-8'?>
<!DOCTYPE hibernate-configuration PUBLIC
        "-//Hibernate/Hibernate Configuration DTD//EN"
        "src/dtd/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
    <session-factory>
        <!--一个sessionFactory代表一个数据库描述-->
        <!--链接数据库的URL-->
        <property name="connection.url">
            jdbc:mysql://localhost:3306/itheima?characterEncoding=UTF-8
        </property>
        <!--链接数据库的驱动-->
        <property name="connection.driver_class">com.mysql.jdbc.Driver</property>
        <!--链接数据库的密码-->
        <property name="connection.username">root</property>
        <!--链接数据库的用户名-->
        <property name="connection.password">1234</property>
        <!-- DB schema will be updated if needed -->
        <!-- <property name="hbm2ddl.auto">update</property> -->
        <!--方言-->
        <!--告诉hibernate用什么样的数据库，将来会生成什么样的语句-->
        <property name="dialect">
            org.hibernate.dialect.MySQLDialect
         </property>
        <!--
             hibernate 对表的策略
              validate  在hibernate 容器启动的时候，
                        根据映射文件和持久化类 来 校验表
             create 每次当hibernate启动的时候，都会根据持久化类和映射文件来创建表
            create-drop 每次当hibernate 启动的时候都会根据持久化类和映射文件
            来创建表和删除表
            update   检查，如果映射文件不一致，则更新表结构,如果没有表则创建表
            //如果把  Person.hdm/xml  ，中的 column 修改，则表结构会新添加一列
            造成结果是表中产生两个主键
        -->
        <property name="hbm2ddl.auto">update</property>
        <!--//加载映射文件-->
        <!--显示ＳＱＬ语句-->
        <property name="show_sql">true</property>
        <mapping
                resource="com/sanmao/hibernate/crud/domain/Person.hbm.xml" />
    </session-factory>
</hibernate-configuration>`这里写代码片`

package com.sanmao.hibernate.crud.domain;

import java.io.Serializable;

/**
 * Created by root on 16-9-18.
 */
public class Person implements Serializable {
//实现序列化能够用二进制在网络传输,所以分布式要实现中的类要实现序列化
    private Long pid;
    private String name;
    private String sex;

    public Long getPid() {
        return pid;
    }

    public void setPid(Long pid) {
        this.pid = pid;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    @Override
    public String toString() {
        return "Person{" +
                "pid=" + pid +
                ", name='" + name + '\'' +
                ", sex='" + sex + '\'' +
                '}';
    }
}

持久化类的映射文件

<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "src/dtd/hibernate-mapping-3.0.dtd">

<hibernate-mapping>
<!--class 元素代表持久化类-->
    <!--name属性为类的全名-->
    <!--table 表名，默认值是类名-->
    <!--catalog 数据库的名字-->
    <class name="com.sanmao.hibernate.crud.domain.Person">
        <!--id为主键元素-->
        <!--name 标识符属性-->
        <!--length 数据库中pid 的长度-->
         <!--column    pid 属性对应的字段-->
        <id name="pid" length="5" column="pid" type="java.lang.Long">
            <!--主键的产生器-->
            <!--需要什么样的方式产生主键-->
            <generator class="increment"></generator>
            <!--<generator class="assigned"></generator>-->
        </id>
        <!--代表一般的属性-->
        <property name="name" length="20"></property>
        <property name="sex" length="20"></property>
    </class>
</hibernate-mapping>

创建表

package com.sanmao.hibernate.createtable;

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

/**
 * Created by root on 16-9-18.
 */
public class CreateTableTest {
    @Test
    public  void  testCreateTable(){
//        加载了hibernate的文件
        Configuration configuration=new Configuration();
//        要求的配置文件的路径
//        1.必须是classpath的根目录
//        2.文件的名称必须是hibernate.cfg.xml
 //       加载方式一
        configuration.configure();
//       方法二，指定要加载的文件
//        configuration.configure(""); //参数为hibernate配置文件的路径及名称
        //        <!--一个sessionFactory代表一个数据库描述-->
        SessionFactory sessionFactory=configuration.buildSessionFactory();
    }
}

增　删　　改　查

package com.sanmao.hibernate.crud.test;

import com.sanmao.hibernate.crud.domain.Person;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.junit.Test;

import java.util.List;

/**
 * 完成crud的操作
 */
public class CRUDTest {
    /**
     * 存储操作*/
    @Test
    public  void  testSave(){
        /*
        * 创建sessionFactory
        *     1.sessionFactory是单例的
        *     2. hibernate的配置文件的信息
        *   ，映射文件的信息，持久化类的信息全部在sessionFactory中
        *   3.sessionFactory封装的信息都是公共的数据
        *      4.sessionFactory 本身是线程安全的，
        * */
        Configuration configuration=new Configuration();
        configuration.configure();//加载了配置文件
        SessionFactory sessionFactory=configuration.buildSessionFactory();
        //跟HTTP  中的Session 没有一点关系，就是Hibernate内部自己的Session
        //保存操作是由session来完成的
        //openSession 方法相当于利用session打开了一个数据库链接
        Session session=sessionFactory.openSession();
        //开启一个事务
        //hibernate 的事务默认是关闭的，必须手动开启，可以保证数据的安全性
        Transaction transaction=session.beginTransaction();
        Person person=new Person();
        person.setName("三毛2");
        person.setSex("男");
        session.save(person);
        transaction.commit();
        //相当于关闭了一个连接
        session.close();
    }
    /**
     * 查询操作*/
    @Test
    public void testQueryAllPerson(){
        Configuration configuration=new Configuration();
        configuration.configure();
        SessionFactory sessionFactory=configuration.buildSessionFactory();
        Session session=sessionFactory.openSession();
        /**
         * HQL :  hibernate  query  language
         * */
        //返回所有persons
        List<Person> persons=session.createQuery("from Person ").list();
        for (Person p: persons) {
            System.out.println(p);
        }
        session.close();
    }
    /**
     * 通过主键获取对象*/
    @Test
    public  void getPersonById(){
        Configuration configuration=new Configuration();
        configuration.configure();
        SessionFactory sessionFactory=configuration.buildSessionFactory();
        Session session=sessionFactory.openSession();
        /**
         * 第一个参数为持久化类的class形式
         * 第二个参数就是主键，类型必须和持久化类中的主键保持一致
         * */
        //在持久化类中主键类型为ＬＯＮＧ　所以，要将１　转换为ＬＯＮＧ类型
//        Person person=(Person) session.get(Person.class,1);
        Person person=(Person) session.get(Person.class,1L);
        System.out.println(person);
        session.close();
    }
    /**
     * 更新对象*/
    @Test
    public void testUpdatePerson(){
        Configuration configuration=new Configuration();
        configuration.configure();
        SessionFactory sessionFactory=configuration.buildSessionFactory();
        Session session=sessionFactory.openSession();
        //开启事务
        Transaction transaction=session.beginTransaction();
        Person person=(Person) session.get(Person.class,1L);
        person.setName("yongchao");
        //应该是根据主键定位
        session.update(person);
        transaction.commit();
        session.close();
    }
    /**
     * 删除操作*/
    @Test
    public void testDeletePerson(){
        Configuration configuration=new Configuration();
        configuration.configure();
        SessionFactory sessionFactory=configuration.buildSessionFactory();
        Session session=sessionFactory.openSession();
        //开启事务
        Transaction transaction=session.beginTransaction();
        Person person=(Person) session.get(Person.class,1L);
        session.delete(person);
        transaction.commit();
        session.close();
    }
}