hibernate简单实现连接数据库，并实现数据的操作

1：创建实体类

 package com.yinfu.entity;

 public class User {

     private int id;
     private String username;
     private String password;
     private String address;
     public int getId() {
         return id;
     }
     public void setId(int id) {
         this.id = id;
     }
     public String getUsername() {
         return username;
     }
     public void setUsername(String username) {
         this.username = username;
     }
     public String getPassword() {
         return password;
     }
     public void setPassword(String password) {
         this.password = password;
     }
     public String getAddress() {
         return address;
     }
     public void setAddress(String address) {
         this.address = address;
     }

 }

User.Java

2：创建实体类与数据库表对应的配置文件：

 <?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE hibernate-mapping PUBLIC
     "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
     "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
 <hibernate-mapping>
 <!--
     配置类和表的对应
     class标签
     name属性：实体类全类名
     table属性：数据库表名称,用hibernate不需要自己创建表，他可以根据配置文件自动生成数据库表
  -->
  <class name="com.yinfu.entity.User" table="t_user">
      <!--
          配置实体类ID与表中的ID进行对应
          hibernate要求实体类属性有一个唯一值
          hibernate要求表有作为唯一值得字段
       -->
       <!--id标签
            name属性：实体类中的id名称
            column属性：表字段中的id名称
        -->
        <id name="id" column="id">
            <!-- 设置数据库表的增长策略
                native:生成表id值就是主键自增长
             -->
            <generator class="native"></generator>
        </id>
        <!-- 配置其他属性和表的字段的对应
                name属性：实体类中的属性名
                column属性：表中的字段名
         -->
        <property name="username" column="username"></property>
        <property name="password" column="password"></property>
        <property name="address" column="address"></property>
  </class>
 </hibernate-mapping>

User.hbm.xml

3：hibernate核心配置文件（1.数据库信息，2.hibernate信息，3.实体类与数据库映射的配置文件注入信息）

此配置文件文件名和位置是固定的：文件名：hibernate.cfg.xml 位置：要放在src文件夹下

 <?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE hibernate-configuration PUBLIC
     "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
     "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
 <hibernate-configuration>
 <!-- 此配置文件的文件名和位置是固定的的
     文件名：hibernate.cfg.xml
     位置：要写在src文件中
  -->
     <session-factory>
         <!-- 第一部分：配置数据库信息 -->
         <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
         <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/test</property>
         <property name="hibernate.connection.username">root</property>
         <property name="hibernate.connection.password">song12345</property>

         <!-- 第二部分：配置hibernate信息（可有可无） -->
         <!-- 输出底层的SQL语句 -->
         <property name="hibernate.show_sql">true</property>
         <!-- 对底曾语句进行格式化 -->
         <property name="hibernate.format_sql">true</property>
         <!-- hibernate帮创建表，需要配置
             update：如果有表就更新，没有表就创建
          -->
         <property name="hibernate.hbm2ddl.auto">update</property>
         <!-- 配置数据库的方言
             识别不同数据库中的特有的语句和关键字
             比如：分页查询
                     MySQL关键字是limit
                     oracle中的使用的是top-n分析中的rownum
         -->
         <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
         <!-- 指定线程管理方式，与本地线程进行绑定，实现单线程操作 -->
         <property name="hibernate.current_session_context_class">thread</property>

         <!-- 第三部分：把映射文件放到核心配置文件中 -->
         <mapping resource="com/yinfu/entity/User.hbm.xml"/>

     </session-factory>

 </hibernate-configuration>

hibernate.cfg.xml

4：用Junit进行简单测试：

 package com.yinfu.test;

 import static org.junit.Assert.*;

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

 import com.yinfu.entity.User;
 import com.yinfu.utils.HibernateUtils;

 public class HibernateTest {

     @Test
     public void test() {
         //1.加载hibernate核心配置文件
         //只会到src下去寻找hibernate的核心配置文件
         Configuration cfg = new Configuration();
         cfg.configure();
         //2.创建sessionFactory对象
         //读取hibernate核心配置文件内容，根据configuration对象创建sessionFactory对象
         //在这过程中，根据映射关系，在相应数据库中把表创建
         SessionFactory sessionFactory = cfg.buildSessionFactory();
         //3.根据sessionFactory得到session对象
         //类似于jdbc中的connection链接
         Session session = sessionFactory.openSession();
         //4.开启事务
         Transaction tx = session.beginTransaction();
         //5.逻辑代码实现crud操作
         //session中有：增加：save方法   修改：update  删除：delete方法    根据ID查询：get方法
         User user = new User();
         user.setUsername("李四");
         user.setPassword("12345");
         user.setAddress("韩国");
         session.save(user);
         //6.提交事务
         tx.commit();
         //7.释放资源
         session.close();
         sessionFactory.close();

     }
 }

test

4.1，将创建SessionFactory对象的代码提出来，放到static静态代码块中，当此类加载的时候只创建一个对象，并重复使用此对象，能够进行优化

首先创建Utils工具类：

 package com.yinfu.utils;

 import org.hibernate.Session;
 import org.hibernate.SessionFactory;
 import org.hibernate.cfg.Configuration;

 //工具类
 public class HibernateUtils {

     private final static Configuration cfg;
     private final static SessionFactory sessionFactory;

     //用静态代码块来实现对象只在类加载的时候创建一次(静态代码块只执行一次)
     static{
         //创建configuration对象，
         cfg = new Configuration();
         cfg.configure();
         //根据Configuration对象创建sessionFactory对象
         sessionFactory = cfg.buildSessionFactory();
     }

     //返回与本地线程绑定的session
     public static Session getSession(){
         return sessionFactory.getCurrentSession();
     }

     //创建一个方法用于返回sessionFactory对象
     public static SessionFactory getSessionFactory(){
         return sessionFactory;
     }

 }

HibernateUtils

然后创建测试类：

 package com.yinfu.test;

 import static org.junit.Assert.*;

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

 import com.yinfu.entity.User;
 import com.yinfu.utils.HibernateUtils;

 public class HibernateTest {
     @Test
     public void testStatic() {
         //利用工具类得到与本地线程绑定的session
         Session session = HibernateUtils.getSession();
         //4.开启事务
         Transaction tx = session.beginTransaction();
         //5.逻辑代码
         //增加方法：
         //此user为瞬时态数据（user中没有id，与session无关）
         User user = new User();
         user.setUsername("赵六");
         user.setPassword("12345");
         user.setAddress("玛雅文明");
         session.save(user);

         //根据ID查询：
         //第一个参数：实体类的类对象。第二个参数：id值
         //此user为持久态数据（有id，与session有关）
 //        User user = session.get(User.class, 1);
 //        System.out.println(user);

         //修改方法:
 //        User user = session.get(User.class, 1);
 //        user.setUsername("张三");
 //        session.update(user);

         //删除方法：
         //第一种：
 //        User user = session.get(User.class, 1);
 //        session.delete(user);
         //第二种：
 //        User user = new User();
 //        user.setId(2);
 //        session.delete(user);

         //6.提交事务
         tx.commit();
         //7.释放资源
         session.close();

     }

 }

test

由于在工具类中将session与当前线程进行了绑定，执行结果正确了，但是会有一个异常，这个异常是由于当session与本地线程进行绑定之后，session会随着线程的结束而自动关闭，不在需要手动进行session关闭，当还有session.close()方法的时候回报此异常。

数据的三种状态：

1：瞬时态数据（没有ID，与session无关）：

User user = new User();
user.setUsername("赵六");
user.setPassword("12345");
user.setAddress("玛雅文明");

2：脱管状态：（有id，与session无关）

User user = new User();

user.setId(1);

3:持久态数据：（有id，与session有关）

User user = session.get(User.class, 1);