Hirbernate学习笔记(1)入门体验及对象持久化

为什么80%的码农都做不了架构师？>>>

网站四层

四层体系结构
 表示层：提供用户界面的显示和与用户进行交互
 业务逻辑层：进行软件的核心业务的处理
 持久化层：用户进行对象的持久化操作
 数据层：用户保存持久化数据
 
 SSH：struts属于表示层   hibernate属于持久化层   spring
 
持久化数据的几种方案：
 1.通过会话bean和实体bean来实现数据的持久化
 2.通过DAO(Date Access Object(数据访问对象))和JDBC来实现数据的持久化
 3.通过DAO和ORM(Object Relation Mapping:对象关系映射)来实现数据的持久化
 
 三者的比较：
  内存消耗方面：1>3>2
  性能方面：2>3>1
  开发效率：1=3>2
  

---

Hibernate的优点和缺点：
 1、不需要编写的SQL语句(不需要编辑JDBC)，只需要操作相应的对象就可以了，就能够存储、更新、删除、加载对象，可以提高生产效；
 2、因为使用Hibernate只需要操作对象就可以了，所以我们的开发更对象化了；
 3、使用Hibernate，移植性好(只要使用Hibernate标准开发，更换数据库时，只需要配置相应的配置文件就可以了，不需要做其它任务的操作)；
 4、Hibernate实现了透明持久化：当保存一个对象时，这个对象不需要继承Hibernate中的任何类、实现任何接口，
  只是个纯粹的单纯对象—称为POJO对象(最纯粹的对象—这个对象没有继承第三方框架的任何类和实现它的任何接口)
 5、Hibernate是一个没有侵入性的框架，没有侵入性的框架我们一般称为轻量级框架
 
Java应用中使用Hibernate的步骤：
 导包
 创建Hibernate的配置文件
 创建持久化类
 创建对象-关系映射
 通过HibernateAPI编写访问数据库的代码

---

 Hibernate配置

    1.配置hibernate.cfg.xml文件

<h<!DOCTYPE hibernate-configuration PUBLIC
 "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
 "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
 <session-factory>
  <!-- Database connection settings -->
  <!-- 方言用来确定连接的数据库   SQL dialect -->
  <property name="hibernate.dialect">org.hibernate.dialect.Oracle10gDialect</property>
        <property name="hibernate.connection.driver_class">oracle.jdbc.driver.OracleDriver</property>
        <property name="hibernate.connection.url">jdbc:oracle:thin:@localhost:1521:orcl</property>
        <property name="hibernate.connection.username">scott</property>
        <property name="hibernate.connection.password">a</property>
        
        <!-- 使用Hibernate的自动上下文管理Enable Hibernate's automatic session context management  -->
        <!-- <property name="current_session_context_class">thread</property> -->
        <!-- 是否发送sql到控制界面显示 Echo all executed SQL to stdout  -->
        <property name="show_sql">true</property>
        <!-- 自动持久化Drop and re-create the database schema on startup-->
        <property name="hbm2ddl.auto">create</property>
  
  <!-- 实体类的映射文件 -->
        <mapping resource="com/yc/bean/UserInfo.hbm.xml"/>
        
        <!-- JDBC connection pool (use the built-in) -->
        <!-- <property name="connection.pool_size">1</property> -->
        <!-- Disable the second-level cache  -->
        <!-- <property name="cache.provider_class">org.hibernate.cache.NoCacheProvider</property> -->
  
 </session-factory>
</hibernate-configuration>

    2.创建实体类

package com.yc.bean;
public class UserInfo {
     private int uid;
     private String uname;
    
     @Override
     public String toString() {
          return "UserInfo [uid=" + uid + ", uname=" + uname + "]";
     }
     public UserInfo() {
          super();
     }
     public UserInfo(int uid, String uname) {
          super();
          this.uid = uid;
          this.uname = uname;
     }
     public int getUid() {
          return uid;
     }
     public void setUid(int uid) {
          this.uid = uid;
     }
     public String getUname() {
          return uname;
     }
     public void setUname(String uname) {
          this.uname = uname;
     }
}

 3.创建实体类对应的UersInfo.hbm.xml文件

    注意该文件 默认和对应的UserInfo类文件放在一个包下

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<!--
    This mapping demonstrates the use of composite ids with the
    key-many-to-one feature.  Essentially a composite id where part
    of the composition is a foreign-key to another entity.
    Here, specifically, we map the key-many-to-one as a lazy
    association.
-->
<hibernate-mapping>
 <!-- name="类的路径"  table:该类对应的数据库中的表名 -->
    <class name="com.yc.bean.UserInfo" table="userInfo">
     <!-- 主键生成策略 
      如果不指定列名，则默认与属性同名
     -->
        <id name="uid" column="usid">
         <!-- 主键生成策略 native:自动根据数据类型生成 -->
            <generator class="native" />
        </id>
        
        <property name="uname" column="uname" length="40" />
    </class>
</hibernate-mapping>

 4.测试类

package com.yc.test;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.hibernate.service.ServiceRegistry;
import org.hibernate.service.ServiceRegistryBuilder;
import com.yc.bean.UserInfo;
@SuppressWarnings("deprecation")
public class Test1 {
 public static void main(String[] args) {
  //读取并解析 配置文件
  Configuration cfg=new Configuration().configure();
  
  //获取注册服务
  ServiceRegistry serviceRegistry=new ServiceRegistryBuilder().applySettings(cfg.getProperties()).build();
  
  
  SessionFactory sessionFactory=cfg.buildSessionFactory(serviceRegistry);
  
  //通过会话工厂获取会话
  Session session=sessionFactory.openSession();
  
  //打开事务
  Transaction transaction=session.beginTransaction();
  
  UserInfo us=new UserInfo();
  
  us.setUname("张三");
  
  
  try {
   session.save(us);
   transaction.commit();
  } catch (Exception e) {
   e.printStackTrace();
   transaction.rollback();
  }finally{
   session.close();
  }
 }
}

 SessionFactory
 一个SessionFactory实例对应一个数据存储源，应用从SessionFactory中获得session实例。
 SessionFactory有以下特点：
  它是线程安全的，这意味着它的同一个实例可以被应用的多个线程共享。
  它是重量级的，这意味着不能随意创建或销毁它的实例。如果应用只访问一个数据库，只需要在应用初始化时创建一个SessionFactory实例。
   如果应用同时访问多个数据库，则需要为每一个数据库创建一个SessionFactory实例。

Session

 Session：Session接口是Hibernate应用使用最广泛的接口
 Session也被称为持久化管理器，它提供了和Session有以下持久化相关的操作，如：添加、修改、删除和查询等。
 Session接口提供了操作数据库的各种方法，如：
      save() 把Java对象保存到数据库中
      update() 更新数据库中的Java对象
      delete() 把Java对象从数据库中删除
      saveOrUpdate()如果传入的对象对于临时状态，则执行save() 操作，如果传入的对象处于游离态则执行update()，如果处于持久化状态则直接返回，不做任何操作
      get()|load() 从数据库中加载Java对象
      contains()  判断一个实体对象是否与当前的Session对象相关联，也就是处于持久化状态。
      evict()  用于移除一个实体对象与Session之间的关联，也就是将一个实体由持久化态变为游离态

 

 

 

 

 

转载于:https://my.oschina.net/yedianxiaoxinxin/blog/299398