Hibernate的CRUD以及junit测试

1:第一步创建动态工程引包，省略。

2:第二步，创建数据库和数据表，省略。

3:第三步，创建实体类，如User.java,源码如下所示：

　　对于实体类，一般实现构造方法，而构造方法一般实现三个：

　　　　一个无参构造方法；

　　　　一个有参的构造方法；

　　　　一个不带id的构造方法；

  1.  package com.bie.po;
  2.  /**
  3.  * @author BieHongLi
  4.  * @version 创建时间：2017年3月8日 下午5:17:23
  5.  *
  6.  */
  7.  public class User {
  8.  
  9.      private int id;
  10.      private String name;
  11.      private String password;
  12.      private String email;
  13.      private String phone;
  14.      public int getId() {
  15.          return id;
  16.      }
  17.      public void setId(int id) {
  18.          this.id = id;
  19.      }
  20.      public String getName() {
  21.          return name;
  22.      }
  23.      public void setName(String name) {
  24.          this.name = name;
  25.      }
  26.      public String getEmail() {
  27.          return email;
  28.      }
  29.      public void setEmail(String email) {
  30.          this.email = email;
  31.      }
  32.      public String getPhone() {
  33.          return phone;
  34.      }
  35.      public void setPhone(String phone) {
  36.          this.phone = phone;
  37.      }
  38.      public String getPassword() {
  39.          return password;
  40.      }
  41.      public void setPassword(String password) {
  42.          this.password = password;
  43.      }
  44.      @Override
  45.      public String toString() {
  46.          return "User [id=" + id + ", name=" + name + ", password=" + password + ", email=" + email + ", phone=" + phone
  47.                  + "]";
  48.      }
  49.      public User(String name, String password, String email, String phone) {
  50.          super();
  51.          this.name = name;
  52.          this.password = password;
  53.          this.email = email;
  54.          this.phone = phone;
  55.      }
  56.      public User(int id, String name, String password, String email, String phone) {
  57.          super();
  58.          this.id = id;
  59.          this.name = name;
  60.          this.password = password;
  61.          this.email = email;
  62.          this.phone = phone;
  63.      }
  64.      public User() {
  65.          super();
  66.      }
  67.  
  68.  }

4：配置数据表和实体类之间的映射，起名如实体类.hbm.xml,源码如下所示：

  1.  <?xml version="1.0"?>
  2.  <!DOCTYPE hibernate-mapping PUBLIC
  3.      "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
  4.      "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
  5.  
  6.  <hibernate-mapping package="com.bie.po">
  7.      <!-- 操作条件：
  8.          1：对象与表
  9.          2：属性与字段的对应
  10.          3：类型的对应,类型默认采用属性的类型，type不写的话
  11.       -->
  12.      <class name="User" table="user">
  13.          <!-- 主键，映射 -->
  14.          <id name="id" column="id">
  15.              <generator class="native"></generator>
  16.          </id>
  17.  
  18.          <!-- 非主键，映射 -->
  19.          <property name="name" column="name"></property>
  20.          <property name="password" column="password"></property>
  21.          <property name="email" column="email"></property>
  22.          <property name="phone" column="phone"></property>
  23.  
  24.      </class>
  25.  
  26.  </hibernate-mapping>

5：完成实体类和数据表之间的配置，就开始配置数据库连接和加载映射，hibernate,cfg.xml

  1.  <!DOCTYPE hibernate-configuration PUBLIC
  2.      "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
  3.      "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
  4.  
  5.  <hibernate-configuration>
  6.      <session-factory>
  7.          <!--
  8.              1:数据连接配置
  9.              2:加载所有的映射（*.hbm.xml）
  10.           -->
  11.  
  12.           <!-- 1:数据连接配置 -->
  13.           <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
  14.           <property name="hibernate.connection.url">jdbc:mysql:///test</property>
  15.           <property name="hibernate.connection.username">root</property>
  16.           <property name="hibernate.connection.password">123456</property>
  17.           <!-- mysql数据库的方言 -->
  18.           <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
  19.  
  20.           <property name="hibernate.show_sql">true</property>
  21.  
  22.           <!-- 2:加载所有的映射（*.hbm.xml） -->
  23.           <mapping resource="com/bie/po/User.hbm.xml"/>
  24.  
  25.      </session-factory>
  26.  </hibernate-configuration>

6：提取工具类HibernateUtils.java,简化开发：

  1.  package com.bie.utils;
  2.  
  3.  import org.hibernate.Session;
  4.  import org.hibernate.SessionFactory;
  5.  import org.hibernate.cfg.Configuration;
  6.  
  7.  /**
  8.  * @author BieHongLi
  9.  * @version 创建时间：2017年3月10日 下午1:47:55
  10.  * 创建工具类
  11.  */
  12.  public class HibernateUtils {
  13.  
  14.      private static SessionFactory sf;
  15.      static{
  16.          //加载主配置文件，并且创建session的工厂
  17.          sf=new Configuration().configure().buildSessionFactory();
  18.      }
  19.  
  20.      //创建session对象
  21.      public static Session getSession(){
  22.          return sf.openSession();
  23.      }
  24.  }

7：最后完成Dao层的替换，由之前使用的基本的Connection创建连接替换成为session创建连接；

　　首先创建接口再实现接口；

　　注意：

　　　　　更新的时候，索引是从0开始的，不是从1开始的，切记；

  1.  package com.bie.dao;
  2.  
  3.  import java.util.List;
  4.  
  5.  import com.bie.po.User;
  6.  
  7.  /**
  8.  * @author BieHongLi
  9.  * @version 创建时间：2017年3月10日 下午1:35:14
  10.  *
  11.  */
  12.  public interface UserDao {
  13.  
  14.      /***
  15.       * 用户信息保存的方法
  16.       * @param user
  17.       */
  18.      public void insertUser(User user);
  19.  
  20.      /***
  21.       * 用户信息更改的方法
  22.       * @param user
  23.       */
  24.      public void updateUser(User user);
  25.  
  26.      /***
  27.       * 根据用户的编号用户信息查询的方法
  28.       * @param id
  29.       * @return
  30.       */
  31.      public User selectUserId(int id);
  32.  
  33.      /**
  34.       * 用户查询所有的信息
  35.       * @return
  36.       */
  37.      public List<User> selectAll();
  38.  
  39.      /***
  40.       *
  41.       * @param name
  42.       * @return
  43.       */
  44.      public List<User> selectAll(String name);
  45.  
  46.      /***
  47.       * 分页查询的方法
  48.       * @param index
  49.       * @param count
  50.       * @return
  51.       */
  52.      public List<User> selectPage(int index,int count);
  53.  
  54.      /***
  55.       * 删除的方法
  56.       * @param id
  57.       */
  58.      public void deleteUser(int id);
  59.  }
  1.  package com.bie.dao.impl;
  2.  
  3.  import java.util.List;
  4.  
  5.  import org.hibernate.Query;
  6.  import org.hibernate.Session;
  7.  import org.hibernate.Transaction;
  8.  
  9.  import com.bie.dao.UserDao;
  10.  import com.bie.po.User;
  11.  import com.bie.utils.HibernateUtils;
  12.  
  13.  /**
  14.  * @author BieHongLi
  15.  * @version 创建时间：2017年3月10日 下午1:35:27
  16.  *
  17.  */
  18.  public class UserDaoImpl implements UserDao{
  19.  
  20.      @Override
  21.      public void insertUser(User user) {
  22.          Session session=null;
  23.          Transaction tx=null;
  24.          try {
  25.              //获取session
  26.              session=HibernateUtils.getSession();
  27.              //开启事务
  28.              tx=session.beginTransaction();
  29.              //插入即保存
  30.              session.save(user);
  31.          } catch (Exception e) {
  32.              throw new RuntimeException(e);
  33.          }finally{
  34.              //提交事务
  35.              tx.commit();
  36.              //关闭session
  37.              session.close();
  38.          }
  39.  
  40.      }
  41.  
  42.      @Override
  43.      public void updateUser(User user) {
  44.          Session session=null;
  45.          Transaction tx=null;
  46.          try {
  47.              session=HibernateUtils.getSession();
  48.              tx=session.beginTransaction();
  49.              session.update(user);
  50.          } catch (Exception e) {
  51.              throw new RuntimeException(e);
  52.          }finally{
  53.              //提交事务
  54.              tx.commit();
  55.              //关闭事务
  56.              session.close();
  57.          }
  58.  
  59.      }
  60.  
  61.      @Override
  62.      public User selectUserId(int id) {
  63.          //获取session
  64.          Session session=null;
  65.          //事务
  66.          Transaction tx=null;
  67.          try {
  68.              //获取session
  69.              session=HibernateUtils.getSession();
  70.              //开启事务
  71.              tx=session.beginTransaction();
  72.  
  73.              return (User)session.get(User.class, id);
  74.          } catch (Exception e) {
  75.              throw new RuntimeException(e);
  76.          }finally{
  77.              //提交事务
  78.              tx.commit();
  79.              //关闭session
  80.              session.close();
  81.          }
  82.      }
  83.  
  84.      @Override
  85.      public List<User> selectAll() {
  86.          //session
  87.          Session session=null;
  88.          //事务
  89.          Transaction tx=null;
  90.          try {
  91.              //获取session
  92.              session=HibernateUtils.getSession();
  93.              //开启事务
  94.              tx=session.beginTransaction();
  95.              //HQL语句
  96.              Query q=session.createQuery("from User");
  97.  
  98.              List<User> list=q.list();
  99.              return list;
  100.          } catch (Exception e) {
  101.              throw new RuntimeException(e);
  102.          }finally{
  103.              //提交事务
  104.              tx.commit();
  105.              //关闭session
  106.              session.close();
  107.          }
  108.      }
  109.  
  110.      @Override
  111.      public List<User> selectAll(String name) {
  112.          //session
  113.          Session session=null;
  114.          //事务
  115.          Transaction tx=null;
  116.          try {
  117.              //获取session
  118.              session=HibernateUtils.getSession();
  119.              //开启事务
  120.              tx=session.beginTransaction();
  121.              //HQL语句
  122.              Query q = session.createQuery("from User user where user.name=? ");
  123.              //注意：参数索引从0开始
  124.              q.setString(0, name);
  125.  
  126.              return q.list();
  127.          } catch (Exception e) {
  128.              throw new RuntimeException();
  129.          }finally{
  130.              //提交事务
  131.              tx.commit();
  132.              //关闭session
  133.              session.close();
  134.          }
  135.      }
  136.  
  137.      @Override
  138.      public List<User> selectPage(int index, int count) {
  139.          //session
  140.          Session session=null;
  141.          //事务
  142.          Transaction tx=null;
  143.          try {
  144.              //获取session
  145.              session=HibernateUtils.getSession();
  146.              //开启事务
  147.              tx=session.beginTransaction();
  148.              //HQL查询
  149.              Query q = session.createQuery("from User ");
  150.              //设置分页参数
  151.              q.setFirstResult(index);//查询起始行
  152.              q.setMaxResults(count);//查询返回的行数
  153.  
  154.              return q.list();
  155.          } catch (Exception e) {
  156.              throw new RuntimeException();
  157.          }finally{
  158.              //提交事务
  159.              tx.commit();
  160.              //关闭session
  161.              session.close();
  162.          }
  163.      }
  164.  
  165.      @Override
  166.      public void deleteUser(int id) {
  167.          Session session=null;
  168.          Transaction tx=null;
  169.          try {
  170.              session=HibernateUtils.getSession();
  171.              tx=session.beginTransaction();
  172.              //先根据id查询出用户的信息再删除
  173.              Object obj=session.get(User.class, id);
  174.              if(obj!=null){
  175.                  session.delete(obj);
  176.              }
  177.          } catch (Exception e) {
  178.              throw new RuntimeException();
  179.          }finally{
  180.              //提交事务
  181.              tx.commit();
  182.              //关闭session
  183.              session.close();
  184.          }
  185.      }
  186.  
  187.  }

8：最后一步，完成测试。源码如下所示：

  1.  package com.bie.test;
  2.  
  3.  import java.util.List;
  4.  
  5.  import org.junit.Test;
  6.  
  7.  import com.bie.dao.UserDao;
  8.  import com.bie.dao.impl.UserDaoImpl;
  9.  import com.bie.po.User;
  10.  
  11.  /**
  12.  * @author BieHongLi
  13.  * @version 创建时间：2017年3月10日 下午2:34:48
  14.  *
  15.  */
  16.  public class UserCRUD {
  17.  
  18.      private UserDao dao=new UserDaoImpl();
  19.  
  20.      @Test
  21.      public void insertUser(){
  22.          dao.insertUser(new User("曹操","111","111111","111111@163.com"));
  23.  
  24.      }
  25.  
  26.      @Test
  27.      public void updateUser(){
  28.          User user=new User();
  29.          user.setId(1);
  30.          user.setName("刘备222");
  31.  
  32.          dao.updateUser(user);
  33.      }
  34.  
  35.      @Test
  36.      public void deleteUser(){
  37.          dao.deleteUser(30);
  38.      }
  39.  
  40.      @Test
  41.      public void selectUserId(){
  42.          //根据用户的编号进行查询
  43.          User user=dao.selectUserId(1);
  44.          System.out.println(user);
  45.      }
  46.  
  47.      @Test
  48.      public void selectUser(){
  49.          //查询用户的所有信息
  50.          List<User> list = dao.selectAll();
  51.          System.out.println(list);
  52.      }
  53.  
  54.      @Test
  55.      public void selectUserName(){
  56.          //根据用户姓名查询信息
  57.          List<User> list=dao.selectAll("李四");
  58.          System.out.println(list);
  59.      }
  60.  
  61.      @Test
  62.      public void selectPage(){
  63.          //分页查询,第一个参数是起始行，第二个参数是每页的个数
  64.          List<User> list=dao.selectPage(0, 5);
  65.          System.out.println(list);
  66.      }
  67.  }

运行效果如下所示：

路在远方，人丑就该多码Coding！！！

Hibernate的CRUD以及junit测试的更多相关文章

  1. hibernate之CRUD操作

    CRUD是指在做计算处理时的增加(Create).读取(Retrieve)(重新得到数据).更新(Update)和删除(Delete)几个单词的首字母简写. 下面列举实例来讲解这几个操作: 实体类: ...

  2. java框架篇---hibernate之CRUD操作

    CRUD是指在做计算处理时的增加(Create).读取(Retrieve)(重新得到数据).更新(Update)和删除(Delete)几个单词的首字母简写. 下面列举实例来讲解这几个操作: 实体类: ...

  3. ssh架构之hibernate(一)简单使用hibernate完成CRUD

    1.Hibernate简介   Hibernate是一个开放源代码的对象关系映射(ORM)框架,它对JDBC进行了非常轻量级的对象封装,它将POJO与数据库表建立映射关系,是一个全自动的orm框架,h ...

  4. Hibernate之CRUD实践

    Hibernate作为一个高度封装的持久层框架,曾经是非常牛逼的,现在虽然应用不是特别广,比如我前公司主要是做OA的,应用的框架就是Spring+SpringMVC+Hibernate. Hibern ...

  5. JUnit测试工具在项目中的用法

    0:33 2013/6/26 三大框架整合时为什么要对项目进行junit测试: |__目的是测试配置文件对不对,能跑通就可以进行开发了 具体测试步骤: |__1.对hibernate进行测试 配置hi ...

  6. junit测试时，出现java.lang.IllegalStateException: Failed to load ApplicationContext

    课程设计要求进行junit测试,我是在已经做好的ssh项目上做的测试,测试类代码如下 package com.zhang.web.services; import static org.junit.A ...

  7. Spring4.2.3+Hibernate4.3.11整合( IntelliJ maven项目)(使用Annotation注解)（Junit测试类）

    1. 在IntelliJ中新建maven项目 给出一个建好的示例 2. 在pom.xml中配置依赖 包括: spring-context spring-orm hibernate-core mysql ...

  8. java之hibernate之crud

    这篇文章主要讲解: 1>.对Hibernate使用的一些简单封装: · 2>.在单元测试中,使用Hibernate的封装的工具进行增删改查的测试 1.目录结构展示 2.代码展示 2.0 配 ...

  9. （2）.mybatis单元测试（junit测试）

    一.Junit使用步骤:1.创建测试目录,(src.测试目录是test)2.在测试目录test中创建与src中相同的包名3.为需要测试的类创建测试类,例如:UsersMapper,测试类是UsersM ...

随机推荐

  1. 循环内的switch中break和continue使用区别

    首先看下break和continue的使用方法. break语句在循环和switch语句中使用,用于终止最近的封闭代码块,如果在嵌套循环中,则只终止最近的循环. continue语句在循环中使用,不能 ...

  2. mysql学习笔记-- 多表查询之外键、表连接、子查询、索引

    本章主要内容: 一.外键 二.表连接 三.子查询 四.索引 一.外键: 1.什么是外键 2.外键语法 3.外键的条件 4.添加外键 5.删除外键 1.什么是外键: 主键:是唯一标识一条记录,不能有重复 ...

  3. 【转】LR分析法

    转自:http://guanjy0129.blog.163.com/blog/static/1115494452010614113333509/ LR分析法的归约过程是规范推导的逆过程,所以LR分析过 ...

  4. 在O(n) 时间复杂度，O(1)空间复杂度内反转单链表

    在LeetCode中看到判断回文的程序:https://leetcode.com/problems/palindrome-linked-list/ 里面用单链表来存储数据,先反转前半部分的单链表,然后 ...

  5. JS简史

    一.产生背景 1)在JavaScript问世之前,必须把表单数据发送到服务器端才能确定用户是否没有填写某个必填域,是否输入了无效的值: 2)为完成简单的表单验证而频繁地与服务器交换数据只会加重用户的负 ...

  6. （一）求 int 型数据在内存中存储时 1 的个数

    题目:求 int 型数据在内存中存储时 1 的个数 描述:输入一个 int 型数据,计算出该 int 型数据在内存中存储时 1 的个数 运行时间限制: 10 sec 内存限制:128 MByte 输入 ...

  7. Python 升级致yum 问题，pip 异常

    升级 Python 导致 yum 和 pip 异常: 一些storm 和 自定义项目 需要升级python版本:Linux 系统默认是2.6 版本 ,所以需要根据业务进行升级操作:Python 官方下 ...

  8. 洛谷 P2257 YY的GCD

    洛谷 P2257 YY的GCD \(solution:\) 这道题完全跟[POI2007]ZAP-Queries (莫比乌斯反演+整除分块) 用的一个套路. 我们可以列出答案就是要我们求: \(ans ...

  9. IP分片丢失重传 - Sacrifice的日志 - 网易博客

        尽管IP分片看起来是是透明的,但有一点让人不想使用它:即使只丢失一片数据也要重传整个数据报.为什么会发生这种情况呢?     因为IP层本身没有超时重传的机制--由更高层来负责超时和重传(TC ...

  10. eMMC基础技术6：eMMC data读写

    1. 前言 data可以经data线从host发往device,也可以从device发往host 数据线以是1线(DATA0),4线(DATA0~DATA3),8线(DATA0~DATA7) 对每条数 ...