IDEA下的Hibernate入门demo

最新推荐文章于 2021-01-19 11:34:57 发布
最新推荐文章于 2021-01-19 11:34:57 发布
阅读量707 收藏 2
点赞数 1
分类专栏： 框架 文章标签： java hibernate idea
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44486072/article/details/90106174
版权

Hibernate简介

Hibernate是一个开放源代码的对象关系映射框架，它对JDBC进行了非常轻量级的对象封装，它将POJO与数据库表建立映射关系，是一个全自动的orm框架，hibernate可以自动生成SQL语句，自动执行，使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。 Hibernate可以应用在任何使用JDBC的场合，既可以在Java的客户端程序使用，也可以在Servlet/JSP的Web应用中使用，最具革命意义的是，Hibernate可以在应用EJB的JaveEE架构中取代CMP，完成数据持久化的重任。

入门案例

1，创建Maven工程，完整结构目录
在这里插入图片描述
2，pom.xml

	<dependencies>
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-core</artifactId>
            <version>5.4.2.Final</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.38</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
    </dependencies>

3，核心配置文件hibernate.cfg.xml

<?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>
    <session-factory>
        <!-- 配置关于数据库连接的四个项：driverClass  url username password -->
        <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
        <property name="hibernate.connection.url">jdbc:mysql:///mybatisdb</property>
        <property name="hibernate.connection.username">root</property>
        <property name="hibernate.connection.password">3416</property>

        <!-- 可以将向数据库发送的SQL语句显示出来 -->
        <property name="hibernate.show_sql">true</property>
        <!-- 格式化SQL语句 -->
        <property name="hibernate.format_sql">true</property>
        <!-- hibernate的方言 -->
        <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
        <!-- 配置hibernate的映射文件所在的位置 -->
        <mapping resource="com/demo/domain/User.hbm.xml"/>
    </session-factory>
</hibernate-configuration>

4，实体类com.demo.domain.User

package com.demo.domain;

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

public class User implements Serializable {
    private Integer id;
    private String username;
    private Date birthday;
    private String sex;
    private String address;
    
	//此处为get/set方法
	
    @Override
    public String toString() {
        return "User{" +
                "id='" + id + '\'' +
                ", username='" + username + '\'' +
                ", birthday=" + birthday +
                ", sex='" + sex + '\'' +
                ", address='" + address + '\'' +
                '}';
    }
}

5，映射文件com/demo/domain/User.hbm.xml

<?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 package="com.demo.domain">
    <!--
        name：即实体类的全名
        table：映射到数据库里面的那个表的名称
        catalog：数据库的名称
     -->
    <class name="User" table="tb_user" catalog="mybatisdb">
        <!-- class下必须要有一个id的子元素 -->
        <!-- id是用于描述主键的 -->
        <id name="id" column="id">
            <!-- 主键生成策略 -->
            <generator class="native"/>
        </id>
        <!--
            使用property来描述属性与字段的对应关系
            如果length忽略不写，且你的表是自动创建这种方案，那么length的默认长度是255
        -->
        <property name="username" column="username" length="20"/>
        <property name="birthday" column="birthday" length="20"/>
        <property name="sex" column="sex" length="2"/>
        <property name="address" column="address" length="50"/>
    </class>
</hibernate-mapping>

6，测试类HibernateTest

package com.demo.test;

import com.demo.domain.User;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import org.hibernate.query.Query;
import org.junit.Test;

import java.util.Date;
import java.util.List;

public class HibernateTest {

    // 保存一个User
    @Test
    public void saveUserTest() {
        // 创建一个User
        User c = new User();
        c.setUsername("叶子");
        c.setBirthday(new Date());
        c.setSex("女");
        c.setAddress("武汉");

        // 使用Hibernate的API来完成将User信息保存到mysql数据库中的操作
        Configuration config = new Configuration().configure(); // Hibernate框架加载hibernate.cfg.xml文件
        SessionFactory sessionFactory = config.buildSessionFactory();
        Session session = sessionFactory.openSession(); // 相当于得到一个Connection
        // 开启事务
        session.beginTransaction();
        // 操作
        session.save(c);
        // 事务提交
        session.getTransaction().commit();
        session.close();
        sessionFactory.close();
    }

    // 根据id查询一个User对象
    @Test
    public void findUserByIdTest() {
        Configuration config = new Configuration().configure(); // Hibernate框架加载hibernate.cfg.xml文件
        SessionFactory sessionFactory = config.buildSessionFactory();
        Session session = sessionFactory.openSession(); // 相当于得到一个Connection
        // 开启事务
        session.beginTransaction();

        // 根据业务来编写代码
         User c = session.get(User.class, "62");
//        User c = session.load(User.class, "62");

        System.out.println(c.getUsername());
        // 事务提交
        session.getTransaction().commit();
        session.close();
        sessionFactory.close();
    }

    // 修改操作
    @Test
    public void updateUserTest() {
        Configuration config = new Configuration().configure(); // Hibernate框架加载hibernate.cfg.xml文件
        SessionFactory sessionFactory = config.buildSessionFactory();
        Session session = sessionFactory.openSession(); // 相当于得到一个Connection
        // 开启事务
        session.beginTransaction();

        // 根据业务来编写代码
        User c = session.get(User.class, "62");
        c.setUsername("郑敏");
        session.update(c); // 修改操作

        // 事务提交
        session.getTransaction().commit();
        session.close();
        sessionFactory.close();
    }

    // 删除操作---根据id进行删除
    @Test
    public void deleteUserTest() {
        Configuration config = new Configuration().configure(); // Hibernate框架加载hibernate.cfg.xml文件
        SessionFactory sessionFactory = config.buildSessionFactory();
        Session session = sessionFactory.openSession(); // 相当于得到一个Connection
        // 开启事务
        session.beginTransaction();

        // 根据业务来编写代码
        User c = session.get(User.class, "62");
        session.delete(c); // 删除操作

        // 事务提交
        session.getTransaction().commit();
        session.close();
        sessionFactory.close();
    }

    // 查询所有User
    @Test
    public void findAllUserTest() {
        Configuration config = new Configuration().configure(); // Hibernate框架加载hibernate.cfg.xml文件
        SessionFactory sessionFactory = config.buildSessionFactory();
        Session session = sessionFactory.openSession(); // 相当于得到一个Connection
        // 开启事务
        session.beginTransaction();
        // 根据业务来编写代码
        Query query = session.createQuery("from User"); // HQL语句，它类似于SQL语句
        List<User> list = query.list();
        for (User user : list) {
            System.out.println(user);
        }
        // 事务提交
        session.getTransaction().commit();
        session.close();
        sessionFactory.close();
    }

}

7，提取公共类HibernateUtils

package com.demo.utils;

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

public class HibernateUtils {

    // SessionFactory全局只需要有一个就可以了，因为它的创建和销毁需要消耗大量的资源，初始化信息会比较多，并且它是线程安全的，可以在多线程的环境下使用它
    private static SessionFactory sessionFactory;

    static {
        // 初始化SessionFactory方式一：
        /*
        Configuration cfg = new Configuration(); // 代表配置文件的一个对象
        cfg.configure(); // 读取默认的配置文件(hibernate.cfg.xml)
        // cfg.configure("hibernate.cfg.xml"); // 读取指定位置的配置文件
        sessionFactory = cfg.buildSessionFactory();
        */

        // 初始化SessionFactory方式二：
        sessionFactory = new Configuration() //
                .configure() //
                .buildSessionFactory(); // 方法链
    }

    /**
     * 获取全局唯一的SessionFactory
     *
     * @return
     */
    public static SessionFactory getSessionFactory() {
        return sessionFactory;
    }

    /**
     * 从全局唯一的SessionFactory中打开一个Session
     *
     * @return
     */
    public static Session openSession() {
        return sessionFactory.openSession();
    }

}

8，封装结果类QueryResult

package com.demo.entity;

import java.util.List;

public class QueryResult {

    private int count; // 总记录数
    private List list; // 一页的数据

    public QueryResult(int count, List list) {
        this.count = count;
        this.list = list;
    }

    //此处省略get/set方法

    @Override
    public String toString() {
        return "QueryResult{" +
                "count=" + count +
                ", list=" + list +
                '}';
    }
}

9，dao层UserDao

package com.demo.dao;

import com.demo.domain.User;
import com.demo.entity.QueryResult;
import com.demo.utils.HibernateUtils;
import org.hibernate.Session;
import org.hibernate.Transaction;

import java.util.List;

public class UserDao {

    /*
     * 保存
     */
    public void save(User user) {
        Session session = HibernateUtils.openSession();
        try {
            Transaction tx = session.beginTransaction(); // 开启事务
            session.save(user);
            tx.commit(); // 提交事务
        } catch (RuntimeException e) {
            session.getTransaction().rollback(); // 回滚事务
            throw e;
        } finally {
            session.close(); // 关闭session
        }
    }

    /*
     * 更新
     */
    public void update(User user) {
        Session session = HibernateUtils.openSession();
        Transaction tx = null;
        try {
            tx = session.beginTransaction();

            session.update(user);// 操作

            tx.commit();
        } catch (RuntimeException e) {
            tx.rollback();
            throw e;
        } finally {
            session.close();
        }
    }

    /*
     * 删除
     */
    public void delete(int id) {
        Session session = HibernateUtils.openSession();
        Transaction tx = null;
        try {
            tx = session.beginTransaction();

            Object user = session.get(User.class, id); // 要先获取到这个对象
            session.delete(user); // 删除的是实体对象

            tx.commit();
        } catch (RuntimeException e) {
            tx.rollback();
            throw e;
        } finally {
            session.close();
        }
    }

    /*
     * 根据id查询一个User数据
     */
    public User getById(int id) {
        Session session = HibernateUtils.openSession();
        Transaction tx = null;
        try {
            tx = session.beginTransaction();
            User user = (User) session.get(User.class, id);// 操作
            tx.commit();
            return user;
        } catch (RuntimeException e) {
            tx.rollback();
            throw e;
        } finally {
            session.close();
        }
    }

    /*
     * 查询所有
     */
    public List<User> findAll() {
        Session session = HibernateUtils.openSession();
        Transaction tx = null;
        try {
            tx = session.beginTransaction();

            // 方式一：使用HQL语句
            List<User> list = session.createQuery("FROM User").list(); // 使用HQL查询

            tx.commit();
            return list;
        } catch (RuntimeException e) {
            tx.rollback();
            throw e;
        } finally {
            session.close();
        }
    }

    /**
     * 分页的查询数据列表
     * @param firstResult 从结果列表中的哪个索引开始取数据
     * @param maxResults 最多取多少条数据
     * @return 一页的数据列表
     */
    @SuppressWarnings("unchecked")
    public QueryResult findAll(int firstResult, int maxResults) {
        Session session = HibernateUtils.openSession();
        Transaction tx = null;
        try {
            tx = session.beginTransaction();
            // 查询一页的数据列表
            // 方式一：
            // Query query = session.createQuery("FROM User");
            // query.setFirstResult(firstResult);
            // query.setMaxResults(maxResults);
            // List<User> list = query.list(); // 使用HQL查询

            // 方式二：方法链
            List<User> list = session.createQuery( //
                    "FROM User") //
                    .setFirstResult(firstResult) //
                    .setMaxResults(maxResults) //
                    .list();

            // 查询总记录数
            // session.createQuery("SELECT COUNT(*) FROM User").list().get(0);
            // Long count = (Long) session.createQuery("SELECT COUNT(*) FROM User").uniqueResult();
            Long count = (Long) session.createQuery( //
                    "SELECT COUNT(*) FROM User") //
                    .uniqueResult();
            tx.commit();

            // 返回结果
            return new QueryResult(count.intValue(), list);
        } catch (RuntimeException e) {
            tx.rollback();
            throw e;
        } finally {
            session.close();
        }
    }

}

10，测试类UserDaoTest
安装JUnitGenerator V2.​0插件
点击UserDao按快捷键ctrl+shift+t创建测试类UserDaoTest

package com.demo.dao;

import com.demo.domain.User;
import com.demo.entity.QueryResult;
import org.junit.Test;

import java.util.Date;
import java.util.List;

public class UserDaoTest {

    private UserDao userDao = new UserDao();

    @Test
    public void save() {
        User user = new User();
        user.setUsername("HIBERNATE");
        user.setBirthday(new Date());
        user.setSex("妖");
        user.setAddress("BEIJING");
        userDao.save(user);
    }

    @Test
    public void update() {
        User byId = userDao.getById(63);
        byId.setSex("人");
        userDao.update(byId);
    }

    @Test
    public void delete() {
        userDao.delete(63);
    }

    @Test
    public void getById() {
        System.out.println(userDao.getById(63));
    }

    @Test
    public void findAll() {
        List<User> list = userDao.findAll();
        for (User user : list) {
            System.out.println(user);
        }
    }

    @Test
    public void findAll1() {
        QueryResult result = userDao.findAll(0, 5);
        System.out.println(result.getCount());
        for (Object o : result.getList()) {
            System.out.println(o);
        }
    }
}
MB.JJ20W
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
Hibernate的入门（Idea下使用Hibernate详细示例）
04-11
通过示例讲解从数据库到实体类，从实体类到数据库的映射关系，讲解包括：集合映射和继承映射。
IDEA入门创建Hibernate实例
03-22
该项目为通过IDEA使用Hibernate框架，详细制作过程见文章：https://blog.csdn.net/qq_37400312/article/details/105027562 数据库默认并不是本地数据库，所以运行的时候记得去hibernate.cfg.xml改为所用的数据库地址及账号密码
J2EE for Intellij Idea Hibernate开发实例
可可可可可是 的博客
07-14 573
Hibernate 的自动建表技术，本例简单，只为通过自动建表技术体现HIbernate的运行原理以及配置过程。一：新建一个Java web 应用 1.导入servlet的jar包和jsp-api的jar包。 2.将数据库连接器的jar包导入。 3.最后导入hibernate的jar包（可以通过idea自动下载）。官网下载 二：代码编写： 1》index.jsp<%-- Created
IDEA整合hibernate实例
qq_38415857的博客
09-17 421
IDEA自动配置hibernate 我的xml配置文件： <?xml version='1.0' encoding='utf-8'?> <!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration DTD//EN" "http://www.hibernat...
IDEA Hibernate入门配置
往復不息的博客
07-22 1025
首先新建一个项目，我是用的最新版5.3.2，下载jar包要等一会儿，然后取个自己的项目名，我这里就叫demo吧 我这里选择以maven方式来构建，在项目上右击，选择Add Framework Support 在之后的选择Maven 之后在项目的右下角弹出一个提示框，选择自动导入 然后在pom.xml文件下添加 <dependencies> &l...
HIbernate+Maven入门demo
05-15
**Hibernate+Maven入门demo详解** 在Java开发中，Hibernate是一个强大的对象关系映射（ORM）框架，它简化了数据库操作，使得开发者可以更专注于业务逻辑而不是底层的SQL语句。Maven则是一个项目管理工具，它管理...
hibernate-demo:尝试使用Hibernate
05-23
hibernate入门开发实践环境准备开发环境: Intellij IDEA本地mysql数据库创建Project新增项目，命名为 hibernate-demo创建目录结构 如下hibernate-demo/src/main/java/resources/test/java/resourcespom.xml依赖项...
springMVC+hibernate搭建的一个demo帮助新人
07-23
这个“springMVC+hibernate搭建的一个demo”旨在为初学者提供一个快速入门的实例，帮助他们理解和配置这些技术的集成环境。 SpringMVC是Spring框架的一部分，它提供了处理HTTP请求、管理控制器、数据绑定、视图解析...
SpringBoot入门级Demo带静态后台模版
08-28
**SpringBoot入门级Demo带静态后台模版** 这个入门级的Demo是基于SpringBoot框架构建的一个简单项目，它集成了Thymeleaf模板引擎、Spring Data JPA以及Bootstrap前端框架，旨在帮助初学者快速理解SpringBoot的核心...
JavaWeb_SSH框架入门，IntelliJ idea搭建Struts2的helloWorld
03-11
【JavaWeb_SSH框架入门，IntelliJ IDEA搭建Struts2的HelloWorld】是一个适合初学者的教程，主要讲解如何在IntelliJ IDEA这个强大的Java集成开发环境中搭建一个基于Struts2框架的简单Web应用。SSH框架是Struts2、...
用IDEA开发的spring mvc+hibernate 例子
02-11
用IDEA开发，完整的SpringMVC ＋Hibernate实例 把相关的包考到Lib目录下就行了
idea+maven+hibernate+springmvc+mysql 实现的增删改查小demo，适合新手
09-01
idea创建的maven项目，hibernate实现数据持久化，springmvc实现数据控制，适合新手学习，也可以用作初学idea的同学的参考。另附数据库。 idea创建的maven项目，hibernate实现数据持久化，springmvc实现数据控制，适合新手学习。另附数据库。
Spring+SpringMVC+Hibernate Demo
03-31
Spring+SpringMVC+Hibernate 模板，使用了IntelliJ IDEA，不过MyEclipse用起来问题不大，maven管理依赖。里面我写了三个具体的简单的跳转小例子，我跑过了是正常运行的。里面只有基本配置，没有各层的代码的，算是一个基本的Demo，每次新建项目的时候可以参考一下，希望能够帮助到大家~
Hibernate讲解(二)-Idea中手工创建Hibernate的开发环境及简单例子
weixin_33951761的博客
10-23 61
例子中用到的JAR可以到这里下载： http://u.115.com/file/f91639838Hibernate_Suit.zip 下载校验码：f91639838 IDEA新建工程，结构如图： Hibernate.cfg.xml是hibernate的配置文件里面主要放置了数据库连接属性，数据库驱动的指定，以及各个JAVA类的映射文件，如下事例： <?x...
使用Intellij IEDA创建hibernate
weixin_34007291的博客
03-13 108
2019独角兽企业重金招聘Python工程师标准>>> ...
IDEA插件MyBatis从dao层方法跳转到对应的xml
caihuawei123的博客
01-19 8857
idea 利用插件 实现从dao层方法进入xml文件中查看方法以及从xml跳转到dao层的方法 1.打开setting 2.点击插件，选择Free Mybatis plugin插件 ，然后点击install, 3.重新启动ide 4.dao层方法，重启后，一会就会出现箭头图标，点击箭头图标就会跳转到对应的xml的方法，反之从xml里的箭头图标跳转到dao层的方法 ...
Idea创建Hibernate bean类和.xml文件
weixin_30367169的博客
01-13 159
Idea通过表结构反向生成Hibernate实体类和映射文件 首先：之前通过Eclipse反向生成Hibernate的实体类，很傻瓜式，基本上不用配置。但是Idea通过表结构反向生成hibernate实体类和映射文件，如果单独生成一张表的实体Bean类，基本上不需要配置。但是针对关联的两张表，涉...
Intellij IDEA的Hibernate简单应用
weixin_33813128的博客
04-27 212
1、创建数据库及其表 create database demo; use demo; CREATE TABLE `user` ( `id` int(10) unsigned NOT NULL AUTO_INCREMENT, `username` varchar(50) DEFAULT NULL, `password` varchar(50) DEFAULT N...
Spring Data Jpa(2019_idea版),Hibernate增删改查操作
qq847196660的博客
07-30 649
1.创建项目工程，Maven导入相关坐标 <!-- junit --> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>4.12</versio...
idea创建hibernate项目
最新发布
08-03
要在IDEA中创建一个Hibernate项目，可以按照以下步骤进行操作： 1. 下载Hibernate开发包并解压缩。 2. 在IDEA中创建一个新的Java项目。 3. 在项目中添加Hibernate的相关依赖。可以通过在项目的pom.xml文件中添加...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值