Hibernate的基础入门--笔记(一)

1、三层架构是什么？
　　web层 表现层
　　MVC是表现层的一个设计模型。
　　service层 业务层
　　dao层 持久层
　　明确：
　　　　Hibernate它是一个持久层（DAO层）框架

2、操作数据库的方式

　　JDBC:痛苦

//保存一个学生
    Student s = new Student();
    String sql = "insert into student(name,gender)values(?,?)";
    Connection conn = getConnection();
    PreparedStatement pstm = conn.prepareStatement(sql);
    pstm.setString(1,s.getName());
    pstm.setString(2,s.getGender());
    pstm.executeUpdate();
//查询学生信息
    String sql = "select * from student";
    Connection conn = getConnection();
    PreparedStatement pstm = conn.prepareStatement(sql);
    ResultSet rs = pstm.executeQuery();
    List<Student> students = new ArrayList<Student>();
    while(rs.next()){
        Student s = new Student();
        int id = rs.getInt("id");
        s.setId(id);
        s.setName(rs.getString("name"));
        s.setGender(rs.getString("gender"));
        students.add(s);
    }

DBUtils:麻烦

//保存一个学生
    Student s = new Student();
    QueryRunner qr = new QueryRunner(dataSource);
    String sql = "insert into student(name,gender)values(?,?)";
    qr.update(sql,s.getName(),s.getGender());
//查询学生
    QueryRunner qr = new QueryRunner(dataSource);
    String sql = "select * from student";
    List list = qr.query(sql,new BeanListHandler<Student>(Student.class));

table:
  create table student(
    s_id int primary key auto_increment,
    s_name varchar(200),
    s_gender varchar(10)
  );
Class
   public class Student implements Serializable{
    private int id;
    private String name;
    private String gender;

    //getter and setter
   }

3、你想怎么操作数据库？
　　想：
　　　　session.save(s);==========>存到数据库表里 解析XML文件，生成SQL语句，发送到数据库。数据库只认识SQL。
　　　　session.get(id);==========>从数据库表中查询
　　　　query.list();
4、建立表和实体类之间的对应关系
　　如何建立？
　　　　通过配置文件
　　你会的配置文件
　　　　xml
　　　　properties
　　选择XML
　　　　因为它可以描述层级关系
　　配置文件的内容：
　　　　实体类和表的对应关系
　　　　实体类中属性和表中字段的对应关系
5、ORM
　　Object Relational Mapping
　　对象 　 关系　　　  映射
　　它就是通过配置文件建立起来实体和表之间的对应关系，从而可以操作实体就直接操作了数据库表
6、Hibernate
　　它是一个开源的，轻量级企业级ORM框架。
　　解决的是持久层的完整操作。

7、搭建hibernate的开发环境
　　使用的示例：
　　　　CRM：客户关系管理系统
　　Hibernate的开发包：
　　　　documentation
　　　　jar包
　　　　project
　　步骤：
　　　　a、导入必备的13个jar包
　　　　required：9个
　　　　log4j相关：3个
　　　　数据库驱动：1个
　　b、创建映射配置文件
　　　　在实体类所在的包下创建一个xml文件
　　　　命名规则：实体类名称.hbm.xml

　　　　示例:

/**
 * 客户的实体类
 *
 */
public class Customer implements Serializable {

    private Long custId;
    private String custName;
    private String custSource;
    private String custIndustry;
    private String custLevel;
    private String custAddress;
    private String custPhone;
    
    
    public Long getCustId() {
        return custId;
    }
    public void setCustId(Long custId) {
        this.custId = custId;
    }
    public String getCustName() {
        return custName;
    }
    public void setCustName(String custName) {
        this.custName = custName;
    }
    public String getCustSource() {
        return custSource;
    }
    public void setCustSource(String custSource) {
        this.custSource = custSource;
    }
    public String getCustIndustry() {
        return custIndustry;
    }
    public void setCustIndustry(String custIndustry) {
        this.custIndustry = custIndustry;
    }
    public String getCustLevel() {
        return custLevel;
    }
    public void setCustLevel(String custLevel) {
        this.custLevel = custLevel;
    }
    public String getCustAddress() {
        return custAddress;
    }
    public void setCustAddress(String custAddress) {
        this.custAddress = custAddress;
    }
    public String getCustPhone() {
        return custPhone;
    }
    public void setCustPhone(String custPhone) {
        this.custPhone = custPhone;
    }
    @Override
    public String toString() {
        return "Customer [custId=" + custId + ", custName=" + custName + ", custSource=" + custSource
                + ", custIndustry=" + custIndustry + ", custLevel=" + custLevel + ", custAddress=" + custAddress
                + ", custPhone=" + custPhone + "]";
    }

}

<?xml version="1.0" encoding="UTF-8"?>
<!-- 导入约束(dtd约束) 
在hibernate的核心jar包中：hibernate-mapping-3.0.dtd中
明确：
    此配置文件中只包含：实体类和表的对应关系，已经实体类中属性和表中字段的对应关系
-->
<!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.XXX.domain"><!-- hibernate-mapping中的package属性：用于导入包。之后再出现类是此包中的都可以省略 -->
    <!-- class标签：
            作用：用于建立实体类和表的对应关系
            属性：
              name:实体类的名称。如果在根标签上没有导包，此处需要写全限定类名
              table:指定数据库表的名称
    -->
    <class name="Customer" table="cst_customer">
        <!-- id标签：
                作用：用于映射主键字段
                属性：
                  name：指定的是实体类中属性的名称。找的是get/set方法后面的部分，首字母转小写。
                  column：指定的是数据库表的列名
        -->
        <id name="custId" column="cust_id">
            <!-- genrator标签：
                    作用：配置主键生成策略。
                    属性：
                      class：指定策略的取值
                      取值之一：
                          native：使用本地数据库自动增长的能力
            -->
            <generator class="native"></generator>
        </id>
        <!-- property标签：
                作用：映射其他字段
                属性：
                  name：用于指定实体类中属性的名称.找的也是get/set方法后面的部分,首字母转小写。
                  column：用于指定表中列的名称
        -->
        <property name="custName" column="cust_name"></property>
        <property name="custIndustry" column="cust_industry"></property>
        <property name="custSource" column="cust_source"></property>
        <property name="custLevel" column="cust_level"></property>
        <property name="custAddress" column="cust_address"></property>
        <property name="custPhone" column="cust_phone"></property>
    </class>
</hibernate-mapping>

　　c、编写主配置文件
　　　　在类的根路径下创建一个xml文件
　　　　命名规则：hibernate.cfg.xml

<?xml version="1.0" encoding="UTF-8"?>
<!-- 导入dtd约束：
约束位置：hibernate-configuration-3.0.dtd中
-->
<!DOCTYPE hibernate-configuration PUBLIC
    "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
    <!-- 配置session工厂 
            SessionFactory：生产Session
            Session是干嘛的：
                它就是hibernate中操作数据库的核心对象了。
        创建Session工厂必备的3组信息
            1、连接数据库的信息
            2、hibernate相关的配置
            3、指定映射文件所在位置
    -->
    <session-factory>
        <!-- 1、连接数据库的信息 -->
        <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
        <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/hibernate</property>
        <property name="hibernate.connection.username">root</property>
        <property name="hibernate.connection.password">1234</property>
        <!-- 2、hibernate的基本配置 -->
        <!-- 数据库的方言 -->
        <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
        <!-- 是否显示sql语句在控制台 -->
        <property name="hibernate.show_sql">true</property>
        <!-- 是否格式化sql语句 -->
        <property name="hibernate.format_sql">true</property>
        <!-- 生成DDL语句的策略 
            SQL结构化查询语言：一共有6个部分
            DDL：数据定义语言 Date Definition Language
            DML：数据操作语言 Data Manipulation Language
            DQL：数据查询语言 Data Query Language
            DCL：数据控制语言  Data Control Language 
            CCL：指针控制语言  Cursor Control Language
            TPL：事务处理语言  Transaction Processing Language
            
            
            取值update的含义：
                检查表结构和映射配置文件的变化，如果不一致，更新表结构
        -->
        <property name="hibernate.hbm2ddl.auto">update</property>
        <!-- 3、映射文件的位置 -->    
        <mapping resource="com/XXX/domain/Customer.hbm.xml"/>    
    </session-factory>
</hibernate-configuration>

8、入门案例
　　需求：保存一个客户到数据库中

/**
 * 入门案例：
 *     保存客户
 * @author zhy
 *
 */
public class HibernateDemo1 {
    
    /**
     * 步骤分析：
     *  1、加载主配置文件
     *  2、根据主配置文件构建SessionFactory
     *  3、使用工厂生产一个新的Session对象
     *  4、开启事务
     *  5、执行保存操作
     *  6、提交事务
     *  7、释放资源
     */
    @Test
    public void testAdd(){
        Customer c = new Customer();
        c.setCustName("中关村");
        c.setCustIndustry("xxx");
        c.setCustSource("网络");
        c.setCustLevel("VIP客户");
        c.setCustAddress("北京");
        c.setCustPhone("010-98234832");
        
        //1.加载主配置文件
        Configuration cfg = new Configuration();
        cfg.configure();
        //2.根据主配置文件构建SessionFactory
        SessionFactory factory = cfg.buildSessionFactory();
        //3.使用工厂生产一个新的Session
        Session session = factory.openSession();//注意：openSession()永远都是一个新的
        //4.使用session获取事务对象,开启事务
        Transaction tx = session.beginTransaction();
        //5.执行保存操作
        session.save(c);//=========>解析xml，生产sql语句，发送给数据库，执行保存。
        //6.提交事务
        tx.commit();
        //7.释放资源
        session.close();
        factory.close();
    }
}

9、常用对象详解

    /**
     * Configuration:                                　　**使用
     *         作用：就是用于加载主配置文件的。
     *         常用方法：
     *             默认构造函数：它只能加载类的根路径下，名称为hibernate.properties的配置文件。不能加载xml
     *             configure()：它用于加载类的根路径下，名称为hibernate.cfg.xml的配置文件。
     *             buildSessionFactory()：根据配置文件，构建SessionFactory
     *             addResource(String url);指定映射文件的位置
     *             addClass(Class clazz);指定实体类的字节码
     * 
     * SessionFactory                                   ****重要
     *         作用：就是用于创建Session的
     *         常用方法：
     *             openSession()：每次都是生成一个新的Session
     *         细节：
     *             它维护了很多信息：
     *                 连接数据库的信息
     *                 hibernate的基本配置
     *                 映射文件的位置，以及映射文件中的配置
     *                 一些预定义的SQL语句（这些语句都是通用的） 比如：全字段保存，根据id的全字段更新，根据id的全字段查询，根据id的删除等等。
     *                 hibernate的二级缓存（了解）
     *            特性：
     *                它是一个线程安全的对象，所有由该工厂生产的Session都共享工厂中维护的数据。
     *        SessionFactory的使用原则：
     *            由于它维护了很多信息，所以创建和销毁会消耗很多资源，所以不应该反复的创建和销毁。
     *            原则就是：一个应用应该只有一个SessionFactory。在应用加载时创建，应用卸载时销毁。
     *    
     * Session                                    非常重要
     *         作用：就是用于跟数据库交互。包含了增删改查以及获取事务对象。
     *         常用方法：
     *             save(Object entity);  ：保存一个实体到数据库
     *             update(Object entity);：更新一个实体
     *             delete(Object entity);：删除一个实体
     *             get(Class clazz,Serializable id);：根据id查询一个实体。参数的含义：Class表示要查询的实体类字节码。Serializable就是查询的条件。
     *             beginTransaction();：开启事务，并返回事务对象
     *             createQuery(String hql);：获取一个查询对象，用于查询所有。
     *                     HQL：hibernate  query language
     *                     含义：hibernate的查询语句。和SQL的区别：把数据表名称用实体类名称替换，把数据库表中的列用实体类中的属性替换，所写的SQL语句就是HQL。
     *         细节：
     *             由于SessionFactory已经维护了很多数据，所以Session就维护较少的内容。
     *             它是一个轻量级对象。并且：它不是线程安全的！！！！！！！
     *             它维护了hibernate的一级缓存（关于一级缓存的问题都是明天的内容）。
     *             它的反复创建销毁不会消耗太多资源。
     *         使用原则：
     *             每个线程都只有一个Session对象。
     * 
     * Transaction                        了解
     *         作用：就是用于控制事务的
     *         常用方法:
     *             commit()：提交事务
     *             rollback()：回滚事务
     */

10、抽取Hibernate工具类
　　HibernateUtil.java
　　明确：
　　　　hibernate把所有可以预见的异常都转成了运行时异常

/**
 * hibernate的工具类
 *
 */
public class HibernateUtil {
    
    private static SessionFactory factory;    
    //使用静态代码块
    //hibernate把所有可以预见的异常都转成了运行时异常
    static{
        try {
            //读取配置文件
            Configuration cfg = new Configuration();
            cfg.configure();
            factory = cfg.buildSessionFactory();
        } catch (Exception e) {
            throw new ExceptionInInitializerError("初始化Session工厂失败！");
        }
    }
    
    /**
     * 获取一个新的Session
     * @return
     */
    public static Session openSession(){
        return factory.openSession();
    }
    
}

　　编码模板

/**
 * 测试工具类
 * @author zhy
 *
 */
public class HibernateDemo3 {
    
    /**
     * 使用hibernate工具类
     */
    @Test
    public void testAdd(){
        Customer c = new Customer();
        c.setCustName("TBD");
        c.setCustIndustry("办公");
        c.setCustSource("网络");
        c.setCustLevel("VIP客户");
        c.setCustAddress("昌平区");
        c.setCustPhone("010-98234832");
        

        //1.使用工具类获取一个Session
        Session session = HibernateUtil.openSession();
        //2.使用session获取事务对象,开启事务
        Transaction tx = session.beginTransaction();
        //3.执行保存操作
        session.save(c);
        //4.提交事务
        tx.commit();
        //5.释放资源
        session.close();
    }
    
    
    /**
     * hibernate的编码模板
     */
    @Test
    public void testAdd2(){
        Customer c = new Customer();
        c.setCustName("TBD");
        c.setCustIndustry("办公");
        c.setCustSource("网络");
        c.setCustLevel("VIP客户");
        c.setCustAddress("昌平区");
        c.setCustPhone("010-98234832");
        
        Session session = null;
        Transaction tx = null;
        try{
            //1.使用工具类获取一个Session
            session = HibernateUtil.openSession();
            //2.使用session获取事务对象,开启事务
            tx = session.beginTransaction();
            //3.执行保存操作
            session.save(c);
            //4.提交事务
            tx.commit();
        }catch(Exception e){
            //5.回滚事务
            tx.rollback();
            e.printStackTrace();
        }finally{
            //6.释放资源
            session.close();
        }
    }
    
    
}

11、hibernate的CRUD操作
　　HibernateDemo4.java

/**
 * Hibernate的CRUD操作
 *
 */
public class HibernateDemo4 {
    
    /**
     * 保存
     */
    @Test
    public void testAdd(){
        Customer c = new Customer();
        c.setCustName("天安门");
        c.setCustIndustry("景点");
        c.setCustSource("网络");
        c.setCustLevel("VIP客户");
        c.setCustAddress("长安街");
        c.setCustPhone("010-98234832");
        

        //1.使用工具类获取一个Session
        Session session = HibernateUtil.openSession();
        //2.使用session获取事务对象,开启事务
        Transaction tx = session.beginTransaction();
        //3.执行保存操作
        session.save(c);
        //4.提交事务
        tx.commit();
        //5.释放资源
        session.close();
    }

    /**
     * 根据id查询一个实体
     */
    @Test
    public void testFindById(){
        //1.使用工具类获取一个Session
        Session session = HibernateUtil.openSession();
        //2.使用session获取事务对象,开启事务
        Transaction tx = session.beginTransaction();
        //3.执行根据id查询
        Customer c = session.get(Customer.class, 1L);
        System.out.println(c);
        //4.提交事务
        tx.commit();
        //5.释放资源
        session.close();
    }
    
    /**
     * 更新
     */
    @Test
    public void testUpdate(){
        //1.使用工具类获取一个Session
        Session session = HibernateUtil.openSession();
        //2.使用session获取事务对象,开启事务
        Transaction tx = session.beginTransaction();
        //3.执行根据id查询
        Customer c = session.get(Customer.class, 1L);
        c.setCustName("Java");
        session.update(c);
        //4.提交事务
        tx.commit();
        //5.释放资源
        session.close();
    }
    
    /**
     * 删除
     */
    @Test
    public void testDelete(){
        //1.使用工具类获取一个Session
        Session session = HibernateUtil.openSession();
        //2.使用session获取事务对象,开启事务
        Transaction tx = session.beginTransaction();
        //3.执行根据id查询
        Customer c = session.get(Customer.class, 1L);
        
        session.delete(c);
        //4.提交事务
        tx.commit();
        //5.释放资源
        session.close();
    }

    /**
     * 查询所有
     */
    @Test
    public void testFindAll(){
        //1.使用工具类获取一个Session
        Session session = HibernateUtil.openSession();
        //2.使用session获取事务对象,开启事务
        Transaction tx = session.beginTransaction();
        //3.获取Query对象
        Query query = session.createQuery("from Customer");//参数是一个HQL语句。hibernate query language
        List list = query.list();
        for(Object o : list){
            System.out.println(o);
        }
        //4.提交事务
        tx.commit();
        //5.释放资源
        session.close();
    }
}

 

持久层总图:

 

导入DTD: