Hibernate菜鸟入门，从零开始建立一个测试项目

最新推荐文章于 2019-08-22 18:42:02 发布
最新推荐文章于 2019-08-22 18:42:02 发布
阅读量732 收藏 2
点赞数
分类专栏： 实训练习项目 hibernate 文章标签： hibernate
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40180411/article/details/83351636
版权

Hibernate官方手册：http://docs.jboss.org/hibernate/orm/current/quickstart/html_single/#hibernate-gsg-tutorial-basic-test

踩坑心得：官网页面一定要看，英语一定要会，看不懂就慢慢看，真的很有用

为什么要用Hibernate？

java语言是面向对象的，而使用数据库Mysql等关系型数据库时，使用java语言操作关系型数据库是不一致的，使用JDBC操作数据库时非常繁琐，怎么解决呢，当然是通过映射，而Hibernate就很好的解决了这个问题。

Hibernate是一个开放源代码的对象关系映射框架，通过对JDBC进行了轻量级的对象封装，使Java程序员能随心所欲的使用面向对象的编程思维来操作数据库

Hibernate的工作原理：

一、

Hibernate准备：（我使用的开发环境环境是）

1.准备数据库环境：MYSQL5.5

2.准备开发工具：Spring-tool-suite-3.9.4.RELEASE
3.准备数据库的驱动程序:：jdbc
4.准备Hibernate包:这里我们使用maven

下载地址:http://maven.apache.org/

安装教程：http://maven.apache.org/install.html

其实安装非常简单：下载完毕解压后就可以了，如果想要测试一下，可以将解压后的文件夹的bin目录配置到环境变量path中，然后在dos命令行测试：

  • 输入： mvn -v

 

5.在sts中集成maven，addapache-maven-3.5.4

 

 

 创建项目：

配置pom.xml文件

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>com.xintoucloud</groupId>
  <artifactId>hibernate_test</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <packaging>jar</packaging>

  <name>hibernate_test</name>
  <url>http://maven.apache.org</url>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  </properties>

  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.8.1</version>
      <scope>test</scope>
    </dependency>

	<dependency>
	   <groupId>org.hibernate</groupId>
	   <artifactId>hibernate-core</artifactId>
	   <version>5.3.7.Final</version>
	</dependency>

	<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
			<version>5.1.47</version>
		</dependency>
  </dependencies>
  <build>
    	<plugins>
	      <plugin>
	        <groupId>org.apache.maven.plugins</groupId>
	        <artifactId>maven-compiler-plugin</artifactId>
	        <version>3.8.0</version>
	        <configuration>
	          <source>1.8</source>
	          <target>1.8</target>
	        </configuration>
	      </plugin>
  	  </plugins>
    </build>
</project>

如果需要修改版本，只需要修改配置文件中的版本号即可，非常方便

创建实体类:

package com.xintoucloud.entity;

public class User {
	private int uid;
	private String uname;
	private String upass;
	private String email;
	private int state;
	
	public int getUid() {
		return uid;
	}
	public void setUid(int uid) {
		this.uid = uid;
	}
	public String getUname() {
		return uname;
	}
	public void setUname(String uname) {
		this.uname = uname;
	}
	public String getUpass() {
		return upass;
	}
	public void setUpass(String upass) {
		this.upass = upass;
	}
	public String getEmail() {
		return email;
	}
	public void setEmail(String email) {
		this.email = email;
	}
	public int getState() {
		return state;
	}
	public void setState(int state) {
		this.state = state;
	}
	
}

创建映射文件:

<?xml version="1.0"?>

<!--
  ~ Hibernate, Relational Persistence for Idiomatic Java
  ~
  ~ License: GNU Lesser General Public License (LGPL), version 2.1 or later.
  ~ See the lgpl.txt file in the root directory or <http://www.gnu.org/licenses/lgpl-2.1.html>.
  -->
<!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.xintoucloud.entity">

    <class name="User" table="user">
        <id name="uid" column="uid">
            <generator class="native"/>
        </id>
        <property name="uname"  column="uname"/>
        <property name="upass"  column="upass"/>
        <property name="email"  column="email"/>
        <property name="state"  column="state"/>
    </class>

</hibernate-mapping>

创建测试文件

package com.xintoucloud.hibernate_test;


import java.util.List;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.boot.MetadataSources;
import org.hibernate.boot.registry.StandardServiceRegistry;
import org.hibernate.boot.registry.StandardServiceRegistryBuilder;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import com.xintoucloud.entity.User;

public class HibernateTest {
	public SessionFactory sessionFactory;
	@Before
	public void setUp() throws Exception {
		//1.读取配置文件，创建SessionFactory
		final StandardServiceRegistry registry = new StandardServiceRegistryBuilder()
				.configure()
				.build();
		try {
			//SessionFactory（创建Session）：线程安全，重量级对象，一个数据库只需要创建一个
			
			sessionFactory = new MetadataSources( registry ).buildMetadata().buildSessionFactory();
		}
		catch (Exception e) {
			e.printStackTrace();
			// The registry would be destroyed by the SessionFactory, but we had trouble building the SessionFactory
			// so destroy it manually.
			StandardServiceRegistryBuilder.destroy( registry );
		}
	}
	@After
	public void tearDown() throws Exception {
		if ( sessionFactory != null ) {
			sessionFactory.close();
		}
	}
	@Test
	public void testSave() {
		//Session(执行数据库操作，和HttpSession没有任何关系)：线程不安全的，轻量级对象，每个操作就应该使用不同的Session，用来后立即关闭
		//2.打开Session
		Session session = sessionFactory.openSession();
		//3.开启事务
		session.beginTransaction();
		
		User user = new User();
		user.setEmail("user@qq.com");
		user.setState(1);
		user.setUname("jhq");
		user.setUpass("123456");
		//4.执行保存
		session.save(user);
		//5.提交事务
		session.getTransaction().commit();
		//6.关闭Session
		session.close();
		
	}
	@Test
	public void testGet() {
		//Session(执行数据库操作，和HttpSession没有任何关系)：线程不安全的，轻量级对象，每个操作就应该使用不同的Session，用来后立即关闭
		//2.打开Session
		Session session = sessionFactory.openSession();
		//3.开启事务
		session.beginTransaction();
		//4.执行查询
		User user=session.get(User.class,13);
		System.out.println("uname:"+user.getUname());
		//5.提交事务
		session.getTransaction().commit();
		//6.关闭Session
		session.close();
		
	}
	@Test
	public void testLoad() {
		//Session(执行数据库操作，和HttpSession没有任何关系)：线程不安全的，轻量级对象，每个操作就应该使用不同的Session，用来后立即关闭
		//2.打开Session
		Session session = sessionFactory.openSession();
		//3.开启事务
		session.beginTransaction();
		//load支持lazy(懒加载)：执行完load不会立即查询数据库2.查询一条不存在的记录出现ObjectNotFoundException
		User user = session.load(User.class, 13);
		System.out.println(user.getUname()+","+user.getEmail()+","+user.getState());
		//5.提交事务
		session.getTransaction().commit();
		//6.关闭Session
		session.close();
		
	}
	
	@Test
	public void testList() {
		//Session(执行数据库操作，和HttpSession没有任何关系)：线程不安全的，轻量级对象，每个操作就应该使用不同的Session，用来后立即关闭
		//2.打开Session
		Session session = sessionFactory.openSession();
		//3.开启事务
		session.beginTransaction();
		//4.执行查询
		List<User> users=session.createQuery("from User").list();
		for (User user2 : users) {
			System.out.println("uname:"+user2.getUname());
		}
		//5.提交事务
		session.getTransaction().commit();
		//6.关闭Session
		session.close();
		
	}
	@Test
	public void testDelete() {
		//Session(执行数据库操作，和HttpSession没有任何关系)：线程不安全的，轻量级对象，每个操作就应该使用不同的Session，用来后立即关闭
		//2.打开Session
		Session session = sessionFactory.openSession();
		//3.开启事务
		session.beginTransaction();
		//4.执行查询
		User user=session.get(User.class,12);
		session.delete(user);
		//5.提交事务
		session.getTransaction().commit();
		//6.关闭Session
		session.close();
		
	}
	@Test
	public void testUpdate() {
		//Session(执行数据库操作，和HttpSession没有任何关系)：线程不安全的，轻量级对象，每个操作就应该使用不同的Session，用来后立即关闭
		//2.打开Session
		Session session = sessionFactory.openSession();
		//3.开启事务
		session.beginTransaction();
		//4.执行查询
		User user=session.get(User.class,13);
		user.setUname("修改后");
		user.setEmail("123456@163.com");
		session.update(user);
		//5.提交事务
		session.getTransaction().commit();
		//6.关闭Session
		session.close();
		
	}
	@Test
	public void testListPage() {
		//Session(执行数据库操作，和HttpSession没有任何关系)：线程不安全的，轻量级对象，每个操作就应该使用不同的Session，用来后立即关闭
				//2.打开Session
				Session session = sessionFactory.openSession();
				//3.开启事务
				session.beginTransaction();
				//4.执行查询
				List<User> users=session.createQuery("from User").setFirstResult(0).setMaxResults(5).list();
				for (User user2 : users) {
					System.out.println("uname:"+user2.getUname()+",email"+user2.getEmail());
				}
				//5.提交事务
				session.getTransaction().commit();
				//6.关闭Session
				session.close();
				
			}
}

运行测试文件:

总结：

1.先配置pom.xml文件，添加依赖关系

2.hibernate.apache.org,中找到hibernate的Gav坐标配置到pom.xml文件中，（依赖一）

3.maven.apache.org中找到plugins-compiler-compile using-source and -targetjavac options,配置到文件中

4.mvnrepository.com中搜索mysql，找到对应版本

5.我的是jdk1.8所以junit需要4.8.1，改完之后，更新maven项目

6.按照maven目录的结构创建必要的目录，src/main/resources

7.去官网上下载maven项目的tutorials（模板）就可以开始创建自己的项目了

一生所Ai
关注
专栏目录
Spring Boot入门(12)：从零开始！轻松掌握Spring Boot整合MyBatis-Plus的最佳实践！
**My Coding Family**
08-17 1万+
一文吃透SpringBoot整合mybatis-plus及实战演练，赶紧来学！
Hibernate入门详细教程
ycfxhsw的博客
06-03 1952
Hibernate入门 1、下载Hibernate Hibernate官网链接 本文以 hibernate-release-5.3.16.Final 为例 （1）下载好解压后如下图所示： （2）打开 lib （3）打开 required 2、编写第一个程序 （1）开发工具IDEA （2）创建项目Hibernate，导入 jar 包 导入上面 required 中的所有 jar 包 导入 Mysql 驱动包 mysql-connector-java-8.0.19.jar （说明：Mysql版本
hibernate测试项目
youngage的专栏
05-04 460
步骤如下： 　　1、创建数据库，创建相应的表； 　　2、点击图标，选择MyEclipse Datebase Explorer； 　　3、右击空白区域，选择new菜单，根据提示创建数据库连接，创建好后会显示所创建的连接名，如图mysqldb是创建的数据库连接； 　　4、选择需要添加hibernate映像文件的工程右击--->MyEcli
Hibernate 菜鸟教程 11 继承 Single Table策略
菜鸟教程
11-20 495
Single Table策略 通过 discriminator来区分是父类还是子类
Hibernate 之菜鸟入门
架构设计
05-04 200
HibernateHibernate是一个开放源代码的对象关系映射框架，它对JDBC进行了非常轻量级的对象封装，使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。 Hibernate可以应用在任何使用JDBC的场合，既可以在Java的客户端程序使用，也可以在Servlet/JSP的Web应用中使用，最具革命意义的是，Hibernate可以在应用EJB的J2EE架构中取代CMP，完成数据...
Hibernate 菜鸟教程 异常 集锦
weixin_34343308的博客
04-27 116
异常1.Error parsing JNDI name [foo] 异常信息摘要： org.hibernate.engine.jndi.JndiException: Error parsing JNDI name [foo] at org.hibernate.engine.jndi.internal.JndiServiceImpl.parseName(JndiServiceImpl....
菜鸟学习Hibernate——简单的增、删、改、查操作
weixin_30878361的博客
04-27 443
上篇博客利用Hibernate搭建起一个简单的例子，把数据库的映射显示了出来在上一篇的博客基础上这篇博客讲述如何利用Hinbernate框架实现简单的数据库操作。 1、加入junit.jar 2、新建一个工具类HibernateUtils.Java把一些对session的公共操作封装起来 import org.hibernate.Session; import or...
Hibernate入门第一讲——Hibernate框架的快速入门
热门推荐
李阿昀的博客
08-04 12万+
Hibernate框架介绍什么是Hibernate我们可以从度娘上摘抄这样有关Hibernate的介绍： Hibernate是一个开放源代码的对象关系映射框架，它对JDBC进行了非常轻量级的对象封装，它将POJO与数据库表建立映射关系，是一个全自动的orm框架，hibernate可以自动生成SQL语句，自动执行，使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。Hibernate可以
Struts2SpringHibernate整合,一个HelloWorld版的在线书店(项目源码+详尽注释+单元测试)
10-01
Struts2，Spring，Hibernate是Java Web开发中最为常见的3种...实体虽然有7个，真正的实现却很简单，这并不是一个完整的在线书店项目。 我的CSDN博客 http://blog.csdn.net/FansUnion 亲，有很多精彩技术文章等着你哦。
Hibernate 系列教程5-双向多对一
菜鸟教程
11-20 179
主要讲解inverse和cascade的用法 cascade定义的是关系两端对象到对象的级联关系； 而inverse定义的是关系和对象的级联关系（管理外键的值）。 inverse 属性默认是false的，就是说关系的两端都来维护关系。 在双向多对一里面配置到一方的集合属性上面，inverse=true，表示关系的维护(外键的值)由对方(多方)来管理 cascade all : 所有情...
Hibernate 菜鸟教程 9 自关联
菜鸟教程
11-20 721
自关联:本质还是原来双向一对多,原来要配置两个类，现在全部都配置在一个类里面
Hibernate 菜鸟教程 7 双向一对一
菜鸟教程
11-20 755
双向一对一 一对一主要用在 一个一方需要的信息比较少，比如注册的登录信息 另一个一方存储的信息比较多，比如注册之后用户填写的详细信息实现方式常用的主要有2种： java模型都是一样，其中一个映射文件有所不同
Hibernate 系列教程6-双向多对多
菜鸟教程
11-20 113
双向多对多inverse配置 如果关系两边都使用默认inverse=false配置，表示关系两边都可以管理中间表的数据 关系其中一边设置inverse=true配置，表示自己放弃管理中间表关系，由对方来管理 如果关系两边都使用默认inverse=true配置，表示关系两边都不管理中间表，是不能这样配置的 hibernate.cfg.xml &lt;mapping resource=...
Hibernate 菜鸟教程 4 单向多对一
菜鸟教程
11-19 733
单向多对一CRUD
idea2018.3.2创建Hibernate入门项目
兔的骄傲
08-22 246
具体步骤： 展示一下我的项目列表（其中常用jar包主要是为了导入连接数据库的dbutils，我为了方便一起导入） 1、新建Project（此处以创建web项目为例） 勾选Web Application + Hibernate 同时勾选 ”Create default hibernate configuration and main class” （当然也可以不勾选，在项目创建好后再手...
菜鸟笔记——Hibernate入门知识点及简单操作
weixin_42678675的博客
07-30 874
这些天开始研究Java的常用框架，首先先从Hibernate入手吧。到目前为止，个人感觉Hibernate是一个简化版的serlvet，他可以把原本需要我们自己写的增删查改等功能都封装好了直接通过实体类来调用便可以了，并且用起来也较方便。 参考链接：http://how2j.cn?p=48985 搭建一个简单的Hibernate来连接数据库吧 1、建立数据库 create databas...
Hibernate 菜鸟教程 2 创建maven工程
菜鸟教程
11-19 727
第1步：通过eclipse新建1个java maven项目。选择file–>new–>other–>MAVEN PROJECT选项第2步：New Maven project 选择模版：Artifact Id:maven-archetype-quickstart 包名groupId:com.jege.hibernate 工程/模块名称：Artifa
Hibernate 系列教程16-二级缓存
菜鸟教程
11-21 119
pom.xml &lt;dependency&gt; &lt;groupId&gt;org.hibernate&lt;/groupId&gt; &lt;artifactId&gt;hibernate-ehcache&lt;/artifactId&gt; &lt;version&gt;${hibernate.version}&lt;/version&gt; &
Hibernate入门教程：从零开始搭建项目
在深入学习Hibernate之前，首先需要理解它是一个开源的对象关系映射框架，用于简化Java应用与关系数据库之间的交互。以下是笔记中涉及的关键知识点： 1. **项目设置**：创建Java项目后，需要引入Hibernate的核心库...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值