Hibernate 实现增删改查案例

布满荆棘的人生 2022-06-07 12:17 347阅读 0赞

Hibernate 实现增删改查案例

本案例使用的hibernate版本为 hibernate-release-5.2.10.Final

为了测试，本案例在mysql数据库中创建了一个db数据库。

创建一个java项目：项目的结构如下：（lib文件夹用于存放jar包）

Center

lib目录下则是hibernate5需要的jar包（注需要将jar加载到项目中：选中jar包右键 —》BuildPath—》Add to Build Path）
Center 1
log4j.properties为日志配置文件（需要加载配置junit），此项目可以不需要日志，使用日志只是为了观察方便。
注：junit配置可以参考 http://blog.csdn.net/benxiaohai888/article/details/78231911

接下来是示例代码：

1、主配置文件 hibernate.cfg.xml

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <!DOCTYPE hibernate-configuration PUBLIC
  3.     "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
  4.     "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
  5. <hibernate-configuration>
  6.     <session-factory>
  7.         <!--配置一：数据库连接信息 -->
  8.         <!-- 数据库驱动 -->
  9.         <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
  10.         <!-- 数据库URL -->
  11.         <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/db?characterEncoding=utf8</property>
  12.         <!--数据库用户名， -->
  13.         <property name="hibernate.connection.username">root</property>
  14.         <!--数据库密码 -->
  15.         <property name="hibernate.connection.password"></property>
  17.         <!--配置二:数据库方言配置，配置数据库方言的作用是屏蔽数据库的差异，换句话说是使hibernate框架知道 要与哪种数据库取得联系 -->
  18.         <property name="hibernate.dialect">org.hibernate.dialect.MySQL5Dialect</property>
  20.         <!--配置三：其它配置 （这些配置可选） -->
  22.         <!-- 是否在控制台显示sql语句 -->
  23.         <property name="hibernate.show_sql">true</property>
  24.         <!--是否格式化删除sql语句 -->
  25.         <property name="hibernate.format_sql">true</property>
  26.         <!-- 自动生成数据表（数据表的生成方式） -->
  27.         <property name="hbm2ddl.auto">update</property>
  28.         <!-- 将session绑定到当前线程 -->
  29.         <property name="hibernate.current_session_context_class">thread</property>
  30.         <!-- 设置事务的隔离级别 -->
  31.         <property name="hibernate.connection.isolation">4</property>
  33.         <!-- 配置四：映射配置 -->
  34.         <mapping resource="cn/sz/entity/User.hbm.xml" />
  35.         <!-- 基于注解的配置方式 -->
  36.         <!-- <mapping class="cn.sz.entity.Dept" /> -->
  37.     </session-factory>
  38. </hibernate-configuration>

2、工具类（获取Session）HibernateUtil.java

  1. package cn.sz.utils;
  2. import org.hibernate.Session;
  3. import org.hibernate.SessionFactory;
  4. import org.hibernate.cfg.Configuration;
  5. public class HibernateUtil {
  6.     public static Session getSession() {
  7.         Session session = null;
  8.         // 创建一个读取主配置文件的对象
  9.         Configuration cfg = new Configuration();
  10.         // 读取主配置文件
  11.         // cfg.configure("hibernate.cfg.xml");如果读取的主配置文件时默认的名字则可以省略参数
  12.         cfg.configure();
  13.         // 创建SessionFactory
  14.         SessionFactory factory = cfg.buildSessionFactory();
  15.         // 我们在主配置中已经将session绑定到线程中，所以可以从线程中取出session
  16.         // 不从线程中取出session，则可以使用 factory.openSession(); 方式获得session
  17.         session = factory.getCurrentSession();
  18.         return session;
  19.     }
  20. }

3、定义方法接口 IUserDAO.java

  1. package cn.sz.dao;
  2. import java.util.List;
  3. import cn.sz.entity.Page;
  4. import cn.sz.entity.User;
  5. public interface IUserDAO {
  6.     // 添加用户方法
  7.     public void add(User user);
  9.     // 修改用户方法
  10.     public void update(User user);
  12.     // 删除用户方法
  13.     public void delete(int uid);
  15.     // 查询所有用户
  16.     public List<User> queryAllUsers();
  18.     // 根据id查询用户
  19.     public User queryUserById(int uid);
  21.     // 分页查看用户
  22.     public List<User> queryUserPage(Page page);
  24. }

4、接口的实现类 UserDAOImpl.java

  1. package cn.sz.dao;
  2. import java.util.List;
  3. import org.hibernate.Session;
  4. import org.hibernate.Transaction;
  5. import org.hibernate.query.Query;
  6. import cn.sz.entity.Page;
  7. import cn.sz.entity.User;
  8. import cn.sz.utils.HibernateUtil;
  9. public class UserDAOImpl implements IUserDAO {
  10.     @Override
  11.     public void add(User user) {
  12.         // 获取session
  13.         Session session = HibernateUtil.getSession();
  14.         Transaction tr = null;
  15.         try {
  16.             // 开启事务
  17.             tr = session.beginTransaction();
  18.             // 调用添加方法
  19.             session.save(user);
  20.             // 提交
  21.             tr.commit();
  22.         } catch (Exception e) {
  23.             // 异常则回滚
  24.             tr.rollback();
  25.             e.printStackTrace();
  26.         } finally {
  27.             // 关闭session
  28.             session.close();
  29.         }
  30.     }
  32.     @Override
  33.     public void update(User user) {
  34.         Session session = HibernateUtil.getSession();
  35.         Transaction tr = null;
  36.         try {
  37.             tr = session.beginTransaction();
  38.             // 调用修改方法
  39.             session.update(user);
  40.             tr.commit();
  41.         } catch (Exception e) {
  42.             tr.rollback();
  43.             e.printStackTrace();
  44.         } finally {
  45.             session.close();
  46.         }
  47.     }
  49.     @Override
  50.     public void delete(int uid) {
  51.         Session session = HibernateUtil.getSession();
  52.         Transaction tr = null;
  53.         try {
  54.             tr = session.beginTransaction();
  55.             // 先查询该用户信息
  56.             User user = session.get(User.class, uid);
  57.             // 然后调用删除方法
  58.             session.delete(user);
  59.             tr.commit();
  60.         } catch (Exception e) {
  61.             tr.rollback();
  62.             e.printStackTrace();
  63.         } finally {
  64.             session.close();
  65.         }
  66.     }
  68.     @Override
  69.     public List<User> queryAllUsers() {
  70.         Session session = HibernateUtil.getSession();
  71.         session.beginTransaction();
  72.         // HQL查询方式 这里 User 表示的User类
  73.         Query query = session.createQuery("from User");
  74.         // 查询到一个List集合
  75.         List<User> users = query.list();
  76.         session.getTransaction().commit();
  77.         session.close();
  78.         return users;
  79.     }
  81.     @Override
  82.     public User queryUserById(int uid) {
  83.         Session session = HibernateUtil.getSession();
  84.         session.beginTransaction();
  85.         // 调用查询方法
  86.         User user = session.get(User.class, uid);
  87.         session.getTransaction().commit();
  88.         session.close();
  89.         return user;
  90.     }
  92.     @Override
  93.     public List<User> queryUserPage(Page page) {
  94.         Session session = HibernateUtil.getSession();
  95.         session.beginTransaction();
  96.         // 计算得到从那个位置开始查询
  97.         int startRows = (page.getCurrentPage() - 1) * Page.PAGE_SIZE;
  98.         Query query = session.createQuery("from User");
  99.         // 设置开始查询的位置
  100.         query.setFirstResult(startRows);
  101.         // 设置每页查询几条数据
  102.         query.setMaxResults(Page.PAGE_SIZE);
  103.         // 查询结果为一个list集合
  104.         List<User> users = query.list();
  105.         session.getTransaction().commit();
  106.         session.close();
  107.         return users;
  108.     }
  110. }

5、用户实体类 User.java

  1. package cn.sz.entity;
  3. import java.io.Serializable;
  5. public class User implements Serializable {
  6.     private Integer uid;
  7.     private String uname;
  9.     public Integer getUid() {
  10.         return uid;
  11.     }
  13.     public void setUid(Integer uid) {
  14.         this.uid = uid;
  15.     }
  17.     public String getUname() {
  18.         return uname;
  19.     }
  21.     public void setUname(String uname) {
  22.         this.uname = uname;
  23.     }
  25. }

6、用户映射文件 User.hbm.xml

  1. <?xml version="1.0" encoding="UTF-8"?>
  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. <!-- package为实体类所在的包 -->
  6. <hibernate-mapping package="cn.sz.entity">
  7.     <!-- 实体类和哪个表对应 ;table用于配置实体类和表的对应；name用于配置哪个实体类和表对应 -->
  8.     <class table="user" name="User">
  9.         <!-- id用于配置主属性和主键字段对应；id的name用于配置属性名 ，column为对应字段名 -->
  10.         <id name="uid" column="userid">
  11.             <!-- 主键生成策略 -->
  12.             <generator class="native"></generator>
  13.         </id>
  14.         <!-- property用于配置普通属性和字段的对应 -->
  15.         <property name="uname" type="string" length="30"></property>
  16.     </class>
  17. </hibernate-mapping>

7、分页信息类 Page.java

  1. package cn.sz.entity;
  3. public class Page {
  4.     // 每页显示的条数
  5.     public static final int PAGE_SIZE = 2;
  6.     // 当前页码
  7.     private Integer currentPage;
  8.     // 总的记录数
  9.     private Integer counts;
  10.     // 总的页数
  11.     private Integer pageNums;
  12.     // 开始从那一条数据开始查询
  13.     private Integer startRows;
  15.     public Integer getCurrentPage() {
  16.         return currentPage;
  17.     }
  19.     public void setCurrentPage(Integer currentPage) {
  20.         this.currentPage = currentPage;
  21.     }
  23.     public Integer getCounts() {
  24.         return counts;
  25.     }
  27.     public void setCounts(Integer counts) {
  28.         this.counts = counts;
  29.     }
  31.     public Integer getPageNums() {
  32.         return pageNums;
  33.     }
  35.     public void setPageNums(Integer pageNums) {
  36.         this.pageNums = pageNums;
  37.     }
  39.     public Integer getStartRows() {
  40.         return startRows;
  41.     }
  43.     public void setStartRows(Integer startRows) {
  44.         this.startRows = startRows;
  45.     }
  47. }

8、测试类 UserTest.java

  1. package cn.sz.test;
  2. import java.util.List;
  3. import org.junit.Test;
  4. import cn.sz.dao.IUserDAO;
  5. import cn.sz.dao.UserDAOImpl;
  6. import cn.sz.entity.Page;
  7. import cn.sz.entity.User;
  8. public class UserTest {
  9.     @Test
  10.     // 测试添加用户方法
  11.     public void testSave() {
  12.         IUserDAO userDAOImpl = new UserDAOImpl();
  13.         User user = new User();
  14.         user.setUname("张三");
  15.         userDAOImpl.add(user);
  16.     }
  18.     @Test
  19.     // 测试修改用户方法
  20.     public void testUpdate() {
  21.         IUserDAO userDAOImpl = new UserDAOImpl();
  22.         // 将id为1的用户姓名改为李四
  23.         User user = new User();
  24.         user.setUid(1);
  25.         user.setUname("李四");
  26.         userDAOImpl.update(user);
  27.     }
  29.     @Test
  30.     // 测试删除用户方法
  31.     public void testDelete() {
  32.         IUserDAO userDAOImpl = new UserDAOImpl();
  33.         // 删除id为1的用户
  34.         userDAOImpl.delete(1);
  35.     }
  37.     @Test
  38.     // 测试查询所有用户方法
  39.     public void testQueryAllUsers() {
  40.         IUserDAO userDAOImpl = new UserDAOImpl();
  41.         List<User> users = userDAOImpl.queryAllUsers();
  42.         for (User user : users) {
  43.             System.out.println(user.getUid() + "," + user.getUname());
  44.         }
  45.     }
  47.     @Test
  48.     // 测试根据id查询用户方法
  49.     public void testQueryUserById() {
  50.         IUserDAO userDAOImpl = new UserDAOImpl();
  51.         User user = userDAOImpl.queryUserById(1);
  52.         System.out.println(user.getUid() + "," + user.getUname());
  53.     }
  55.     @Test
  56.     // 测试分页查看用户方法
  57.     public void testQueryUserPage() {
  58.         IUserDAO userDAOImpl = new UserDAOImpl();
  59.         Page page = new Page();
  60.         // 设置查询的是第一页
  61.         page.setCurrentPage(1);
  62.         List<User> users = userDAOImpl.queryUserPage(page);
  63.         for (User user : users) {
  64.             System.out.println(user.getUid() + "," + user.getUname());
  65.         }
  66.     }
  67. }

9、日志文件log4j.properties

  1. log4j.rootLogger=DEBUG,console,FILE
  2. log4j.appender.console=org.apache.log4j.ConsoleAppender
  3. log4j.appender.console.threshold=INFO
  4. log4j.appender.console.layout=org.apache.log4j.PatternLayout
  5. log4j.appender.console.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} [%5p] - %c -%F(%L) -%m%n
  6. log4j.appender.FILE=org.apache.log4j.RollingFileAppender
  7. log4j.appender.FILE.maxBackupIndex=100
  8. ##log4j.appender.FILE=org.apache.log4j.DailyRollingFileAppender 
  9. log4j.appender.FILE.Append=true
  10. log4j.appender.FILE.File=c:/error1.log
  11. log4j.appender.FILE.Threshold=INFO
  12. log4j.appender.FILE.layout=org.apache.log4j.PatternLayout
  13. log4j.appender.FILE.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} [%5p] - %c -%F(%L) -%m%n
  14. log4j.appender.FILE.MaxFileSize=1MB

下面是各个方法的运行截图：

添加用户方法 add(User user)
Center 2

修改用户方法 update(User user)
Center 3

为了后面的分页测试本人在数据库中多加了几条数据

Center 4

删除用户方法 delete(int uid) id为1 的数据已经被删除
Center 5

查询所有用户方法 queryAllUsers()
Center 6

根据id查询用户 方法queryUserById(int uid)
Center 7

分页查看用户方法 queryUserPage(Page page)

Center 8

发表评论

表情：
评论列表 （有 0 条评论，347人围观）

还没有评论，来说两句吧...

相关阅读