Jimoshi_Hibernate 框架学习(一)--session的CRUD的基本操作、OID对象映射标示符和主键的生成的策略

Jimoshi成长经历：前面的笔记后面再慢慢整理-------方便自己

目录：了解什么是Hibernate、Hibernate框架学习、session的CRUD的基本操作、OID对象映射标示符和主键的生成的策略ss

Hibernate 框架学习（一）：
—、了解什么是Hibernate

    1、Hibernate是一个开放源代码的对象关系映射框架
    它对JDBC进行了非常轻量级的对象封装，它将POJO与数据库表建立映射关系，是一个全自动的orm框架，hibernate可以自动生成SQL语句，自动执行，使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库(对象关系映射）

    2、Hibernate框架中数据持久化机制
    在业务程序与数据库之间，Hibernate 框架使用Session会话，来完成数据的提交、更新、删除、查询等等。总之，数据持久化是解决程序与数据库之间交互访问的问题，使程序不直接访问数据库，而是直接访问Session会话，然后由Session会话与数据库“打交道”。只要确保，程序每次访问Session中的数据时，与数据库中的数据保持一致，就不会出现错误。

    我的注解：POJO是什么？ORM是什么？（后面自己去了解一下）

二、Hibernate框架学习

    1、JUNIT单元测试(步骤)

①配置使用Hibernate,添加Hibernate的jar包和数据库驱动（maven仓库中下载，添加到pom.xml中）
代码示例：
<dependency>
   <groupId>org.hibernate</groupId>
   <artifactId>hibernate-core</artifactId>
   <version>4.3.5.Final</version>
</dependency>
<dependency>
   <groupId>mysql</groupId>
   <artifactId>mysql-connector-java</artifactId>
   <version>5.1.18</version>
</dependency>

②配置xml文件(hibernate.cfg.xml)
代码示例：
<!DOCTYPE hibernate-configuration PUBLIC
          "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
          "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
   <session-factory>
<!-- 配置数据库连接 -->
   <!-- JDBC驱动程序 -->
   <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
   <!-- 连接数据库的URL mysql对应建立hibernate数据库-->
   <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/hibernate</property>
   <property name="Connection.useUnicode">true</property>
   <property name="connection.characterEncoding">utf8</property>
   <!-- 连接的登录名和密码-->
   <property name="hibernate.connection.username">root</property>
   <property name="hibernate.connection.password">123</property>
   <!-- 方言 -->
   <property name="dialect">org.hibernate.dialect.MySQLDialect</property>
   <!-- 控制台能够输出SQL语句 -->
   <property name="hibernate.show_sql">true</property>
   <!-- 帮你生成对应的表,或者是表的更新 -->
   <property name="hibernate.hbm2ddl.auto">update</property>
   </session-factory>    
</hibernate-configuration>

③建立对应实体Student类对象并且对实体进行XML文件(Student.hbm.xml)配置
代码示例：

 ③.1、Student实体类建立
 private int id;
 private String name;
（进行get，set）

 ③.2、Student.hbm.xml文件配置（官方推荐注解方式,先熟悉XML文件配置）
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<!-- 对哪个包下面的实体进行映射 -->
<hibernate-mapping package="com.zr.model">
<!-- table表名-->
    <class name="Student" table="t_student">
       <id name="id" column="sid">
          <!-- 主键策略的配置 -->
            <generator class="native"></generator>
       </id>
       <property name="name" column="sname"></property>
    </class>
</hibernate-mapping>

④将映射文件加入到session-factory配置(hibernate.cfg.xml)中
<mapping resource="com/zr/model/Student.hbm.xml" />

⑤最后创建com.zr.test包建立Test类使用Hibernate的一些接口将数据持久化然后进行测试
数据持久化步骤（1.读取配置文件 2.创建SessionFactory 3.创建session 4.在session当中做CRUD的操作）
代码示例：
public class Test {
    public static void main(String[] args) {
    //读取配置文件，创建sessionFactory工厂
    Configuration  config  = (Configuration) new Configuration().configure();
    //config.buildSessionFactory()可以使用,但不建议
    // 注册服务
    ServiceRegistry  sr =  new StandardServiceRegistryBuilder().applySettings(config.getProperties()).build();           
    //创建工厂
    SessionFactory  sf = config.buildSessionFactory(sr);
    //创建session
    Session  session  = sf.openSession();
    //在session 中做CRUD的操作  数据进行持久化
      //通过session 开启事务
      session.beginTransaction();
        //-----------------CRUD操作
        //测试数据是否添加到数据库表中
        Student s= new Student();
        s.setSname("Jimoshi");
        session.save(s);
        //-----------------CRUD操作
      //事务的提交
      session.getTransaction().commit();
      //关闭session
      session.close();
      //关闭工厂
      sf.close();
    }        
   }

 2、注解方式配置
①建立对应实体Teacher类对象
代码示例：
// 将一个类声明为一个实体bean(即一个持久化POJO类)
@Entity
//注解声明了该实体bean映射指定的表（table）
@Table(name="t_teacher")
public class Teacher {
  private  int tid;
  private  String tname;
// 注解声明了该实体bean的标识属性（对应表中的主键）注：对于属性的注解 一定是在get方法上面
@Id
//注解声明了主键的生成策略，s_native设置主键
@GeneratedValue(generator="s_native")
// strategy 指定生成的策略（JPA定义的）
@GenericGenerator(name="s_native",strategy="native")
public int getTid() {
    return tid;
}
public void setTid(int tid) {
    this.tid = tid;
}
//注解声明了属性到列的映射
@Column(name="t_name")
public String getTname() {
    return tname;
}
public void setTname(String tname) {
    this.tname = tname;
}
}
②将映射文件加入到session-factory配置(hibernate.cfg.xml)中
<mapping class="com.zr.model.Teacher"/>
③测试（在com.zr.test包下面的Test类的CRUD操作中添加测试）
代码示例：
//测试数据是否添加到对应数据库表中
代码示例：
 Teacher t = new Teacher();
 t.setTname("jimoshi");
 session.save(t);

三、session的CRUD的基本操作（JUNIT单元测试）
 
 1、对SessionFactory进行工具类封装（建立一个com.zr.util包在创建一个HibernateUtil工具类）
//通过该工具类生产出唯一一个SessionFactory（ 采用单例模式）
代码示例：
public class HibernateUtil {
  //定义了一个静态的属性,这个属性会在加载类的时候进行初始化.
  private static final SessionFactory sf = bulidSessionFactory();
  //调用了另一个私有的静态方法,这个静态方法加载了Hibernate的配置,然后用这个配置建立了一个SessionFactory
  private  HibernateUtil(){};
  private  static SessionFactory bulidSessionFactory(){
     //读取配置文件，创建sessioFactory工厂
     Configuration  config  = (Configuration) new Configuration().configure();
     //注册服务
     ServiceRegistry  sr =  new StandardServiceRegistryBuilder().applySettings(config.getProperties()).build();
     return  config.buildSessionFactory(sr);
     }
  public static SessionFactory getSf() {
     return sf;
    }
}

 2、使用JUNIT
①在pom.xml中引入JUNIT
代码示例：
<dependency>
   <groupId>junit</groupId>
   <artifactId>junit</artifactId>
   <version>4.11</version>
</dependency>

②创建一个com.zr.dao包建立对应StudentDao的学生类的实体操作并为Dao添加测试类
步骤：右键StudentDao --->new--->other--->JUnit Test Case--->Source folder 后面的Browse选中struts/src/main/java--->next--->选取测试类--->finish

③session 的CRUD操作
代码示例：
public class StudentDaoTest {
   //使用HibernateUtil
   private  SessionFactory  sf = HibernateUtil.getSf();
   private  Session  session;
   @Before
   public  void setSession(){
    // 通过开启事务
   session =  sf.openSession();
   session.beginTransaction();
    }
   @After
   public  void  closeSessionandSf(){
   //事务的提交
    session.getTransaction().commit();
   //关闭session
    session.close();
   //关闭工厂
    sf.close();
    }
    //增加，使用save方法
   @Test
   public void testAddStudent() {
     Student s = new Student();
     s.setSname("wwj");
     session.save(s);
}
    //删除，先通过ID来查询,在调用delete方法删除对象
   @Test
   public void testDeleteStudent() {
   Student  s  =  (Student) session.get(Student.class, Integer.valueOf(1));
   session.delete(s);
}
   //修改，先通过ID来查询,直接对对象进行赋值操作
   @Test
   public void testUpdateStudent() {
   Student  s  =  (Student) session.get(Student.class, Integer.valueOf(2));
   s.setSname("xyz");
}
   //查询，初次接触HQL（HQL面向对象语句思维方式）
   @Test
   public void testSelectStudents() {
   //String hql = from Student student where id=?
   String  hql  = "from Student";
   Query  query  =  session.createQuery(hql);
   List<Student> ss  =query.list();
   for (Student student : ss) {
     System.out.println(student.getSname());
    }
}
}

四、OID对象映射标示符和主键的生成的策略

 1、概念（session 缓存的概念，对象映射标示OID）
 
 2、测试对象映射标识符（StudentDao中的CRUD操作中添加）
 代码示例：
  @Test
  public void testOID(){
  Student s1 = (Student) session.get(Student.class, Integer.valueOf(3));
  Student s2 = (Student) session.get(Student.class, Integer.valueOf(4));
  Student s3 = (Student) session.get(Student.class, Integer.valueOf(3));
     System.out.println(s1==s2);
     System.out.println(s1==s3);    
    }
 3、主键生成的策略（xml文件配置的主键策略在Student.hbm.xml中配置，注解在Teacher类中配置，保证数据唯一实例）
 ①increment（通过Hibernate自身、自动以递增方式生成主键策略）
 ②identity（采用数据库提供的主键生成机制、orcale数据库不支持）
 ③sequence（采用数据库提供的主键生成机制、只支持oracle)
 ④hilo（算法实现的主键生成机制）
 ⑤native（根据数据库自动生成主键策略）