Hibernate(4)简单的HelloWorld

一个HelloWorld的案例

public class HelloWorld {

    @Test
    public void test() {
        //1.创建SessionFactory对象
        SessionFactory sessionFactory = null;
        //1.1.创建Configuration对象，对应Hibernate的基本配置信息和对象映射信息
        Configuration configuration = new Configuration().configure();

        //Hibernate4.0之前这样创建SessionFactory对象
        //sessionFactory = configuration.buildSessionFactory();

        //Hibernate4.0之后这样创建sessionFactory对象

        //1.2.创建ServiceRegistry对象，Hibernate4.X新添加的对象，Hibernate任何配置和服务都要在该对象中注册后才有效
        ServiceRegistry serviceRegistry = new ServiceRegistryBuilder().
                        applySettings(configuration.getProperties()).
                        buildServiceRegistry();

        //1.3.获取SessionFactory对象，并在serviceRegistry对象中注册
        sessionFactory = configuration.buildSessionFactory(serviceRegistry);

        //2.创建一个Session对象
        Session session = sessionFactory.openSession();

        //3.开启事务
        Transaction transaction = session.beginTransaction();

        Users user= new Users("lili", "123", "丽丽", "河南省", "12883924987", "163@qq.com", new Date());

        //4.执行保存操作
        session.save(user);

        //5.提交事务
        transaction.commit();

        //6.关闭session
        session.close();

        //.关闭sessionFactory
        sessionFactory.close();
    }

}

实体类

package com.test.withXml.entity;

import java.io.Serializable;
import java.sql.Blob;
import java.util.Date;


public class Users implements Serializable {

    private static final long serialVersionUID = 1L;
    private Integer id;
    private String loginName;
    private String loginPwd;
    private String name;
    private String address;
    private String phone;
    private String mail;
    //日期格式
    private Date date;
    //派生的属性
    private String Desc;
    //大文本属性
    private String content;
    //二进制文件
    private Blob image;

    public String getContent() {
        return content;
    }
    public void setContent(String content) {
        this.content = content;
    }
    public Blob getImage() {
        return image;
    }
    public void setImage(Blob image) {
        this.image = image;
    }
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getLoginName() {
        return loginName;
    }
    public void setLoginName(String loginName) {
        this.loginName = loginName;
    }
    public String getLoginPwd() {
        return loginPwd;
    }
    public void setLoginPwd(String loginPwd) {
        this.loginPwd = loginPwd;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getAddress() {
        return address;
    }
    public void setAddress(String address) {
        this.address = address;
    }
    public String getPhone() {
        return phone;
    }
    public void setPhone(String phone) {
        this.phone = phone;
    }
    public String getMail() {
        return mail;
    }
    public void setMail(String mail) {
        this.mail = mail;
    }
    public String getDesc() {
        return Desc;
    }
    public void setDesc(String desc) {
        Desc = desc;
    }
    public Date getDate() {
        return date;
    }
    public void setDate(Date date) {
        this.date = date;
    }
    //1.
    public Users(String loginName, String loginPwd, String name,
            String address, String phone, String mail, Date date) {
        super();
        this.loginName = loginName;
        this.loginPwd = loginPwd;
        this.name = name;
        this.address = address;
        this.phone = phone;
        this.mail = mail;
        this.date = date;
    }
    //2.
    public Users() {
    }
    @Override
    public String toString() {
        return "Users [loginName=" + loginName + ", loginPwd=" + loginPwd
                + ", name=" + name + ", address=" + address + ", phone="
                + phone + ", mail=" + mail + ", date=" + date + "]";
    }



}

映射文件User.hbm.xml

<!-- 映射文件 -->

<hibernate-mapping>
    <!-- class节点中的name属性对应实体类的名字，table属性对应数据表的名字，catalog对应数据库的名字 -->
    <class name="com.test.withXml.entity.Users" table="users" 
        catalog="hibernate_xml" dynamic-update="true">
        <!-- class节点下必须有一个<id>节点，用于定义实体类的标识属性（对应数据表中的主键），
            id节点的name属性对应实体类的属性，type对应该属性的Java类型
         -->
        <id name="id" type="java.lang.Integer" unsaved-value="100">
            <!-- column用于指定数据库表的列名 -->
            <column name="Id"></column>
            <!-- generator用于指定主键的生成器策略 ，使用native表示让底层数据库主键自增的方式生成，使用这种方式
            产生的ID会在执行Session的save()方法的时候，先执行SQL语句，在提交事务的意外情况。
            hilo表示使用Hibernate高低算法生成ID，使用该算法时，要在数据库中建立一张额外的表，
            默认表名为hibernate_unique_key,默认字段为integer类型，名称是next_hi，并设置初始值-->
            <generator class="native"></generator>
        </id>
        <!-- properties节点与id类似，用于映射普通属性 -->
        <property name="loginName" type="java.lang.String">
            <column name="LoginName" length="50"></column>
        </property>
        <property name="loginPwd" type="java.lang.String">
            <column name="LoginPwd" length="16"></column>
        </property>
        <property name="name" type="java.lang.String">
            <column name="Name" length="16"></column>
        </property>
        <property name="address" type="java.lang.String">
            <column name="Address" length="16"></column>
        </property>
        <property name="phone" type="java.lang.String">
            <column name="Phone" length="16"></column>
        </property>
        <property name="mail" type="java.lang.String">
            <column name="Mail" length="20"></column>
        </property>

        <!-- 映射派生属性，即对象中需要一个属性但是数据表中不需要再添加一个字段，使用派生属性即可 -->
        <property name="desc" formula="(SELECT concat(LoginName, ': ', LoginPwd) FROM users n WHERE n.id = id)"></property>

        <!-- 映射date（日期）、time（时间）、timestamp（时间戳），此时映射的是时间 -->
        <property name="date" type="date">
            <column name="Date" length="20"></column>
        </property>

        <!-- 映射大文本属性 -->
        <property name="content">
            <column name="Content" sql-type="mediumtext"></column>
        </property>
        <property name="image">
            <column name="Image" sql-type="mediumblob"></column>
        </property>

    </class>
</hibernate-mapping>

配置文件hibernate.cfg.xml

<!-- 配置文件 -->

<hibernate-configuration>
    <session-factory>
    <!-- 配置链接数据库的基本信息 -->
        <!-- 数据库连接的URL -->
        <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/hibernate_xml</property>
        <!-- 数据库驱动 -->
        <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
        <!-- 数据库用户名 -->
        <property name="hibernate.connection.username">root</property>
        <!-- 数据库密码 -->
        <property name="hibernate.connection.password">root</property>

    <!-- 配置Hibernate的基本信息 -->   
        <!-- 程序运行时是否在控制台输出执行的SQL语句 -->
        <property name="hibernate.show_sql">true</property>
        <!-- 是否对SQL进行格式化 -->
        <property name="format_sql">true</property>
        <!-- 配置Hibernate方言，即使用的不同的数据库类型，该方言支持事务 -->
        <property name="hibernate.dialect">org.hibernate.dialect.MySQL5Dialect</property>
        <!-- 数据库编码方式 -->
        <property name="Connection.characterEncoding">UTF-8</property>
        <!-- 
            指定生成表的策略 
            validate:加载hibernate时，验证创建数据库表结构，启动时验证现有schema与你配置的hibernate是否一致，如果不一致就抛出异常，并不做更新
            create:每次加载hibernate，重新创建数据库表结构，这就是导致数据库表数据丢失的原因。
            create-drop:加载hibernate时创建，退出是删除表结构
            update:加载hibernate自动更新数据库结构
         -->
        <property name="hbm2ddl.auto">update</property>
        <!-- 设置事务的隔离级别 -->
        <property name="hibernate.connection.isolation">2</property>
        <!-- 删除对象后，使其OID置位null -->
        <property name="hibernate.use_identifier_rollback">true</property>

    <!-- 配置C3P0数据源 -->  
        <!-- 数据库连接池的最大连接数 -->
        <property name="hibernate.c3p0.max_size">10</property>
        <!-- 数据库连接池的最小连接数 -->
        <property name="hibernate.c3p0.min_size">5</property>
        <!-- 当数据库连接池中的连接耗尽时, 同一时刻获取多少个数据库连接 -->
        <property name="hibernate.c3p0.acquire_increment">2</property>
        <!-- 表示连接池检测线程多长时间检测一次池内的所有链接对象是否超时 -->
        <property name="hibernate.c3p0.idle_test_period">2000</property>
        <!-- 数据库连接池中连接对象在多长时间没有使用过后，就应该被销毁 -->
        <property name="hibernate.c3p0.timeout">2000</property>
        <!-- 缓存 Statement 对象的数量 -->
        <property name="hibernate.c3p0.max_statements">10</property>
        <!-- 设定 JDBC 的 Statement 读取数据的时候每次从数据库中取出的记录条数 -->
        <property name="hibernate.jdbc.fetch_size">100</property>
        <!-- 设定对数据库进行批量删除，批量更新和批量插入的时候的批次大小 -->
        <property name="jdbc.batch_size">30</property>
    <!-- 配置映射文件时，这两种方法只能使用其中之一，同时使用会报错 -->
        <!--使用配置文件时： 加载映射文件，注意使用的是斜杠作为分割符，有文件的后缀名 -->
        <mapping resource="com/test/withXml/entity/User.hbm.xml"></mapping>

        <!-- 使用注解时：加载持久化类文件，注意使用的是圆点作为分割符，文件的后缀名 -->
        <!-- <mapping class="com.test.withAnnotation.entity.UsersAnno"/> -->
    </session-factory>
</hibernate-configuration>