Java基础学习之hibernate初体验

最新推荐文章于 2021-10-28 10:11:38 发布

vlin_fanpeng

最新推荐文章于 2021-10-28 10:11:38 发布

阅读量297

点赞数

分类专栏： it菜鸟升级

本文链接：https://blog.csdn.net/vlin_fan/article/details/80931998

版权

it菜鸟升级专栏收录该内容

30 篇文章 0 订阅

订阅专栏

Hibernate 简介 :

简介:

Hibernate 是由 Gavin King 于 2001 年创建的开放源代码的对象关系框架。它强大且高效的构建具有关系对象持久性和查询服务的 Java 应用程序。

Hibernate 将 Java 类映射到数据库表中，从 Java 数据类型中映射到 SQL 数据类型中，并把开发人员从 95% 的公共数据持续性编程工作中解放出来。

Hibernate 是传统 Java 对象和数据库服务器之间的桥梁，用来处理基于 O/R 映射机制和模式的那些对象。

Hibernate 优势

Hibernate 使用 XML 文件来处理映射 Java 类别到数据库表格中，并且不用编写任何代码。
为在数据库中直接储存和检索 Java 对象提供简单的 APIs。
如果在数据库中或任何其它表格中出现变化，那么仅需要改变 XML 文件属性。
抽象不熟悉的 SQL 类型，并为我们提供工作中所熟悉的 Java 对象。
Hibernate 不需要应用程序服务器来操作。
操控你数据库中对象复杂的关联。
最小化与访问数据库的智能提取策略。
提供简单的数据询问。

支持的数据库

Hibernate 支持几乎所有的主要 RDBMS。以下是一些由 Hibernate 所支持的数据库引擎。

HSQL Database Engine
DB2/NT
MySQL
PostgreSQL
FrontBase
Oracle
Microsoft SQL Server Database
Sybase SQL Server
Informix Dynamic Server

Hibernate 架构

配置对象

配置对象是你在任何 Hibernate 应用程序中创造的第一个 Hibernate 对象，并且经常只在应用程序初始化期间创造。它代表了 Hibernate 所需一个配置或属性文件。配置对象提供了两种基础组件。

数据库连接：由 Hibernate 支持的一个或多个配置文件处理。这些文件是 hibernate.properties 和 hibernate.cfg.xml。
类映射设置：这个组件创造了 Java 类和数据库表格之间的联系

SessionFactory 对象

配置对象被用于创造一个 SessionFactory 对象，使用提供的配置文件为应用程序依次配置 Hibernate，并允许实例化一个会话对象。SessionFactory 是一个线程安全对象并由应用程序所有的线程所使用。

SessionFactory 是一个重量级对象所以通常它都是在应用程序启动时创造然后留存为以后使用。每个数据库需要一个 SessionFactory 对象使用一个单独的配置文件。所以如果你使用多种数据库那么你要创造多种 SessionFactory 对象。

Session 对象

一个会话被用于与数据库的物理连接。Session 对象是轻量级的，并被设计为每次实例化都需要与数据库的交互。持久对象通过 Session 对象保存和检索。

Session 对象不应该长时间保持开启状态因为它们通常情况下并非线程安全，并且它们应该按照所需创造和销毁。

Transaction 对象

一个事务代表了与数据库工作的一个单元并且大部分 RDBMS 支持事务功能。在 Hibernate 中事务由底层事务管理器和事务（来自 JDBC 或者 JTA）处理。

这是一个选择性对象，Hibernate 应用程序可能不选择使用这个接口，而是在自己应用程序代码中管理事务。

Query 对象

Query 对象使用 SQL 或者 Hibernate 查询语言（HQL）字符串在数据库中来检索数据并创造对象。一个查询的实例被用于连结查询参数，限制由查询返回的结果数量，并最终执行查询。

Criteria 对象

Criteria 对象被用于创造和执行面向规则查询的对象来检索对象。

Hibernate 配置 MySQL 数据库

1.导入框架(共12个包)

require 文件夹下的所有包(10个)

jpa-metamodel-generator 文件夹下的包

MySQL 的驱动包

2.创建Hibernate 的主配置文件 etc

默认放到src下文件名为 hibernate.cfg.xml

<!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 >
	<!-- hibernate 的数据库配置 -->
		<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
		<property name="hibernate.connection.url">jdbc:mysql://localhost:3306/hibernate01</property>
		<property name="hibernate.connection.username">root</property>
		<property name="hibernate.connection.password">123456</property>
		<!-- 加载MySQL的方言包 limit.. -->
		<property name="hibernate.dialect">org.hibernate.dialect.MySQL5InnoDBDialect</property>
		<!-- 开启打印SQL语句 -->
		<property name="hibernate.show_sql">true</property>
		<!-- 开启格式化SQL语句 -->
		<property name="hibernate.format_sql">true</property>
		<!-- 自动更新表结构  没有表会帮你创建出来-->
		<property name="hibernate.hbm2ddl.auto">update</property>
		<!-- 映射数据库表对应的实体类映射文件的路径
		路径从包名开始 / 反斜杠相隔
		 -->
		 <!--
		 	设置数据库的隔离级别 
		 	(etc/hibernate.properties)
		 	默认的隔离级别 4  (1|2|4|8)
		 	hibernate.connection.isolation 4 
		 	1.脏读
		 	2.不可重复读
		 	3.幻读
		 	隔离级别
		 	读未提交  READ UNCOMMITED    1 2 3  ....1
		 	读已提交  READ COMMITED       2 3   ....2
		 	可重复读  REPEATABLE READ        3  ....4
		 	串行化    SERIALIZABLE      都能避免 ....8
		 	隔离级别使用一个字节来存储的
		 	0001
		 	0010
		 	0100
		 	1000
		  -->
		 <property name="hibernate.connection.isolation">4</property>
		<mapping resource="com/lanou3g/User.hbm.xml"/>
		
	</session-factory>
</hibernate-configuration>

3.创建实体类 (User)

建议数据库的字段名和对象的属性名相同

Hibernate 的完整概念是提取 Java 类属性中的值，并且将它们保存到数据库表单中。映射文件能够帮助 Hibernate 确定如何从该类中提取值，并将它们映射在表格和相关域中

在 Hibernate 中，其对象或实例将会被存储在数据库表单中的 Java 类被称为持久化类

所有将被持久化的 Java 类都需要一个默认的构造函数。
为了使对象能够在 Hibernate 和数据库中容易识别，所有类都需要包含一个 ID。此属性映射到数据库表的主键列。
所有将被持久化的属性都应该声明为 private，并具有由 JavaBean 风格定义的 getXXX 和 setXXX 方法。
Hibernate 的一个重要特征为代理，它取决于该持久化类是处于非 final 的，还是处于一个所有方法都声明为 public 的接口。
所有的类是不可扩展或按 EJB 要求实现的一些特殊的类和接口。

package com.lanou3g;
/*
 * 建议数据库的字段名和对象的属性名 相同
 */
public class User {
	private int id;
	private String username;
	private String password;
	public User() {
		super();
		// TODO Auto-generated constructor stub
	}
	public User(int id, String username, String password) {
		super();
		this.id = id;
		this.username = username;
		this.password = password;
	}
	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;
	}
	@Override
	public String toString() {
		return "User [id=" + id + ", username=" + username + ", password=" + password + "]";
	}
	

}

4.创建与实体类对应的映射文件

命名规范: 实体类名.hbm.xml

作用: 配置实体类与数据库表的映射关系

映射文件是一个以 <hibernate-mapping> 为根元素的 XML 文件，里面包含所有<class>标签。
<class> 标签是用来定义从一个 Java 类到数据库表的特定映射。Java 的类名使用 name 属性来表示，数据库表明用 table 属性来表示。
<meta> 标签是一个可选元素，可以被用来修饰类。
<id> 标签将类中独一无二的 ID 属性与数据库表中的主键关联起来。id 元素中的 name 属性引用类的性质，column 属性引用数据库表的列。type属性保存 Hibernate 映射的类型，这个类型会将从 Java 转换成 SQL 数据类型。
在 id 元素中的 <generator> 标签用来自动生成主键值。设置 generator 标签中的 class 属性可以设置 native 使 Hibernate 可以使用 identity, sequence 或 hilo 算法根据底层数据库的情况来创建主键。
<property> 标签用来将 Java 类的属性与数据库表的列匹配。标签中 name 属性引用的是类的性质，column 属性引用的是数据库表的列。type属性保存 Hibernate 映射的类型，这个类型会将从 Java 转换成 SQL 数据类型。

<?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.lanou3g">
  <!-- 配置表与实体类的关系
    		name: 实体类全类名
    		table :表名
    		package :填包名: 填上后 地下在写全类名
    		可以省略包名
     -->
 	<class name="User" table="user">
 	<!-- 
 	    id:表示主键
 	    注意:没有主键 不能使用hibernate
 		name:表示类中的属性名(成员变量名)
 		column:表示这个成员变量所代表的表中的字段名
 	 -->
 		<id name="id" column="id">
 			<!-- 主键的生成策略   主键自增策略 -->
 			<generator class="native"></generator>
 		</id>
 		<!-- 
 		   property:表示除主键以外的的属性
 		 -->
 		<property name="username" column="username"></property>
 		<property name="password" column="password"></property>
 	</class>
 </hibernate-mapping>

5.从主配置文件中配置映射文件的路径

Hibernate 查询语言

public void fun1() {
		System.out.println("fun1");
		//读取主配置文件
		//创建读取文件的对象 默认读取SRC下的hibernate.cfg.xml文件
		Configuration configuration = new Configuration().configure();
		//创建session 工厂(管理一堆session)
		//相当于数据库连接池
		SessionFactory sessionFactory = configuration.buildSessionFactory();
		// 从sessionfactory 获取session对象
		//获取一个全新的session对象
		Session session = sessionFactory.openSession();
		// 通过 session 操作数据库
		Transaction transaction = session.beginTransaction();  //开启事务
		//向数据库中插入一条记录;()
		
		User user = new User();
		user.setUsername("wanglong");
		user.setPassword("123");
		
		//将对象保存入到数据库中
		session.save(user);
		//提交事务
		transaction.commit();
		//关闭资源
		session.close();
		sessionFactory.close();
		
	}

2.根据id查询 get 方法

public void fun2() {
		//session.get(查询对象的.class,id);
		Configuration configuration = new Configuration().configure();
		SessionFactory sessionFactory = configuration.buildSessionFactory();
		Session session = sessionFactory.openSession();
		Transaction transaction = session.beginTransaction();
		
		User user = session.get(User.class, 1);
		
		transaction.commit();
		session.close();
		sessionFactory.close();
		System.out.println(user);
	}

3.load与get 的区别

public void fun3() {
		Configuration configuration = new Configuration().configure();
		SessionFactory sessionFactory = configuration.buildSessionFactory();
		Session session = sessionFactory.openSession();
		Transaction transaction = session.beginTransaction();
		//---------------------------------------
		//使用load方法查询 按id
		//----------------------------------
		User user = session.load(User.class, 1);
		
		transaction.commit();
		session.close();
		sessionFactory.close();
		//找不到 session 对象 报错
		System.out.println(user);

load 方法与 get 方法的区别 get方法只要该方法执行就会产生SQL语句并查询数据库返回对象

load 方法懒加载方式进行查询 load 方法执行了不会立即查询数据库而是当你使用了该查询结果时

才会去查询数据库如果这时session 被释放了会报错;

4.根据id修改对象

public void fun4() {
		Configuration configuration = new Configuration().configure();
		SessionFactory sessionFactory = configuration.buildSessionFactory();
		Session session = sessionFactory.openSession();
		Transaction transaction = session.beginTransaction();
		//根据id查出这个对象
		User user = session.get(User.class, 1);
		user.setUsername("kuner");
		//修改对象 同步到数据库
		session.update(user);
		System.out.println(user);
		transaction.commit();
		session.close();
		sessionFactory.close(); 
	}

HQL语句操作数据库
Hibernate 查询语言（HQL）是一种面向对象的查询语言，类似于 SQL，但不是去对表和列进行操作，而是面向对象和它们的属性。 HQL 查询被 Hibernate 翻译为传统的 SQL 查询从而对数据库进行操作。

FROM 语句

如果你想要在存储中加载一个完整并持久的对象,你将使用 FROM 语句。以下是 FROM 语句的一些简单的语法：

String hql = "FROM Employee";
Query query = session.createQuery(hql);
List results = query.list();

如果你需要在 HQL 中完全限定类名，只需要指定包和类名，如下：

String hql = "FROM com.lanou3g.Employee";
Query query = session.createQuery(hql);
List results = query.list();

AS 语句

在 HQL 中 AS 语句能够用来给你的类分配别名，尤其是在长查询的情况下。例如，我们之前的例子，可以用如下方式展示：

String hql = "FROM Employee AS E";
Query query = session.createQuery(hql);
List results = query.list();

关键字 AS 是可选择的并且你也可以在类名后直接指定一个别名，如下：

String hql = "FROM Employee E";
Query query = session.createQuery(hql);
List results = query.list();

SELECT 语句

SELECT 语句比 from 语句提供了更多的对结果集的控制。如果你只想得到对象的几个属性而不是整个对象你需要使用 SELECT 语句。下面是一个 SELECT 语句的简单语法示例，这个例子是为了得到 Employee 对象的 first_name 字段：

String hql = "SELECT E.firstName FROM Employee E";
Query query = session.createQuery(hql);
List results = query.list();

值得注意的是 Employee.firstName 是 Employee 对象的属性，而不是一个 EMPLOYEE 表的字段

WHERE 语句

如果你想要精确地从数据库存储中返回特定对象，你需要使用 WHERE 语句。下面是 WHERE 语句的简单语法例子：

String hql = "FROM Employee E WHERE E.id = 10";
Query query = session.createQuery(hql);
List results = query.list();

ORDER BY 语句

为了给 HSQ 查询结果进行排序，你将需要使用 ORDER BY 语句。你能利用任意一个属性给你的结果进行排序，包括升序或降序排序。下面是一个使用 ORDER BY 语句的简单示例：

String hql = "FROM Employee E WHERE E.id > 10 ORDER BY E.salary DESC";
Query query = session.createQuery(hql);
List results = query.list();

如果你想要给多个属性进行排序，你只需要在 ORDER BY 语句后面添加你要进行排序的属性即可，并且用逗号进行分割：

String hql = "FROM Employee E WHERE E.id > 10 " +
             "ORDER BY E.firstName DESC, E.salary DESC ";
Query query = session.createQuery(hql);
List results = query.list();

GROUP BY 语句

这一语句允许 Hibernate 将信息从数据库中提取出来，并且基于某种属性的值将信息进行编组,通常而言,该语句会使用得到的结果来包含一个聚合值。下面是一个简单的使用 GROUP BY 语句的语法:

String hql = "SELECT SUM(E.salary), E.firtName FROM Employee E " +
             "GROUP BY E.firstName";
Query query = session.createQuery(hql);
List results = query.list();

使用命名参数

Hibernate 的 HQL 查询功能支持命名参数。这使得 HQL 查询功能既能接受来自用户的简单输入，又无需防御 SQL 注入攻击。下面是使用命名参数的简单的语法:

String hql = "FROM Employee E WHERE E.id = :employee_id";
Query query = session.createQuery(hql);
query.setParameter("employee_id",10);
List results = query.list();

注意使用?代替占位符时从0开始

UPDATE 语句

HQL Hibernate 3 较 HQL Hibernate 2，新增了批量更新功能和选择性删除工作的功能。查询接口包含一个 executeUpdate() 方法，可以执行 HQL 的 UPDATE 或 DELETE 语句。

UPDATE 语句能够更新一个或多个对象的一个或多个属性。下面是使用 UPDATE 语句的简单的语法:

String hql = "UPDATE Employee set salary = :salary "  + 
             "WHERE id = :employee_id";
Query query = session.createQuery(hql);
query.setParameter("salary", 1000);
query.setParameter("employee_id", 10);
int result = query.executeUpdate();
System.out.println("Rows affected: " + result);

DELETE 语句

DELETE 语句可以用来删除一个或多个对象。以下是使用 DELETE 语句的简单语法：

String hql = "DELETE FROM Employee "  + 
             "WHERE id = :employee_id";
Query query = session.createQuery(hql);
query.setParameter("employee_id", 10);
int result = query.executeUpdate();
System.out.println("Rows affected: " + result);

INSERT 语句

HQL 只有当记录从一个对象插入到另一个对象时才支持 INSERT INTO 语句。下面是使用 INSERT INTO 语句的简单的语法:

String hql = "INSERT INTO Employee(firstName, lastName, salary)"  + 
             "SELECT firstName, lastName, salary FROM old_employee";
Query query = session.createQuery(hql);
int result = query.executeUpdate();
System.out.println("Rows affected: " + result);

Hibernate 会话

hibernate 操作对象的三种状态

1.瞬时态 : 没有id 没有更session 产生关系

一种新的持久性实例，被 Hibernate 认为是瞬时的，它不与 Session 相关联，在数据库中没有与之关联的记录且无标识符值。

2.持久态 : 有id 有跟session产生关系 session调用了方法

可以将一个瞬时状态实例通过与一个 Session 关联的方式将其转化为持久状态实例。持久状态实例在数据库中没有与之关联的记录，有标识符值，并与一个 Session 关联。

3.游离态 : 有id 没跟session 产生关系

一旦关闭 Hibernate Session，持久状态实例将会成为脱管状态实例。

Hibernate 缓存

缓存是关于应用程序性能的优化，降低了应用程序对物理数据源访问的频次，从而提高应用程序的运行性能。

缓存对 Hibernate 来说也是重要的，它使用了如下解释的多级缓存方案：

public void fun3() {
		//使用get方法查询一个对象
		//当你调用get方法区数据库查询时 数据库给你返回的结果集
		//会被hibernate 封装成对象并且保存在缓存中一份
		//当你再次 get 方法查询时会先到缓存中查找有无该id的对象
		//有就返回缓存中的对象
		//没有就用SQL 去数据库中查询
		Session session = HibernateUtil.getopenSession();
		Transaction transaction = session.beginTransaction();
		User user1 = session.get(User.class, 1);
		User user2 = session.get(User.class, 1);
		User user3 = session.get(User.class, 1);
		User user4 = session.get(User.class, 1);
		User user5 = session.get(User.class, 1);
		System.out.println(user2==user5);
		
		transaction.commit();
		session.close();//游离态
	}

public void fun4() {
		//思考: 打印几条SQL语句 why?
		/*
		 * update 方法时
		 * hibernate 会被结果集保存到缓存中一份 快照中一份
		 * 最终同步到数据库时
		 * 会将缓存中的对象和快照中的对象进行对比
		 * 一样就不同步到数据库中
		 * 不一样才同步到数据库
		 */
		Session session = HibernateUtil.getopenSession();
		Transaction transaction = session.beginTransaction();
		User user = session.get(User.class, 1);
		user.setUsername("baoer");
		user.setUsername("haier");
		
		session.update(user);
		
		transaction.commit();
		session.close();//游离态
	}

Hibernate 多表查询

一对多

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.lanou3g">
    		<class name="Customer" table="cst_customer">
    			<id name="cust_id" column="cust_id">
    				<generator class="native"></generator>
    			</id>
    			<property name="cust_name" column="cust_name"></property>
    			<property name="cust_source" column="cust_source"></property>
    			<property name="cust_industry" column="cust_industry"></property>
    			<property name="cust_level" column="cust_level"></property>
    			<property name="cust_linkman" column="cust_linkman"></property>
    			<property name="cust_phone" column="cust_phone"></property>
    			<property name="cust_mobile" column="cust_mobile"></property>
    			
    			<!-- 级联操作
    				作用简化代码(量不大)
    				save-update  级联保存和更新
    				delete 级联删除
    				all   以上两个的功能都拥有
    			 -->
    			 <!-- inverse  反转
    			 		默认值时false 表示不放弃维护外键
    			 		作用:提高效率
    			 		一对多的表关系 .如果要放弃维护外键
    			 		只能是一的一方放弃维护
    			  -->
    			 
    		  <!-- 配置一对多关系
    		  	   name : 表示 实体类对象中的属性名
    		  	   column : 表示 本表中 与 从表联系的字段 (两张表的外键)
    		  	   class : 表示 与那个类(表) 一对多的联系
    		  	   注意: 两张表的外键名必须设置一致,否则会多创建出一个外键
    		   -->
    		  <set name="linkmans" cascade="delete" inverse="true" >
    		  	<key column="lkm_cust_id"></key>
    		  	<one-to-many class="Linkman"/>
    		  </set>
    		</class>
    </hibernate-mapping>

<?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.lanou3g">
  <!-- 配置表与实体类的关系
    		name: 实体类全类名
    		table :表名
    		package :填包名: 填上后 地下在写全类名
    		可以省略包名
     -->
 	<class name="User" table="user">
 	<!-- 
 	    id:表示主键
 	    注意:没有主键 不能使用hibernate
 		name:表示类中的属性名(成员变量名)
 		column:表示这个成员变量所代表的表中的字段名
 	 -->
 		<id name="id" column="id">
 			<!-- 主键的生成策略   主键自增策略 -->
 			<generator class="native"></generator>
 		</id>
 		<!-- 
 		   property:表示除主键以外的的属性
 		 -->
 		<property name="username" column="username"></property>
 		<property name="password" column="password"></property>
 	</class>
 </hibernate-mapping>

多对多

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.lanou3g">
    		<class name="Linkman" table="cst_linkman">
    			<id name="lkm_id" column="lkm_id">
    				<generator class="native"></generator>
    			</id>
    			<property name="lkm_name" column="lkm_name"></property>
    			<property name="lkm_gender" column="lkm_gender"></property>
    			<property name="lkm_phone" column="lkm_phone"></property>
    			<property name="lkm_mobile" column="lkm_mobile"></property>
    			<property name="lkm_email" column="lkm_email"></property>
    			<property name="lkm_qq" column="lkm_qq"></property>
    			<property name="lkm_position" column="lkm_position"></property>
    			<property name="lkm_memo" column="lkm_memo"></property>
    			<!-- 配置多对一的关系 
    				name : 表示多对一对象的属性名
    				class : 表示 多对一对象的类
    				column : 表示外键
    				注意 : 上面再配置properties 不要重复配置外键
    			-->
    			<many-to-one name="customer" class="Customer" column="lkm_cust_id"></many-to-one>
    			
    		</class>
    </hibernate-mapping>

<?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.lanou3g">
 
 	<class name="Role" table="sys_role">
 	
 		<id name="role_id" column="role_id">
 			<generator class="native"></generator>
 		</id>
 	
 		<property name="role_name" column="role_name"></property>
 		<property name="role_memo" column="role_memo"></property>
 		<!-- 配置多对多的表关系
 			name : 容器的名字
 			table : 表示中间表名字
 			key column : 中间表引用我的id
 			many-to-many class="对应哪个表的实体类类名" column="对应表的的外键(引用那个表的键)"
 		 -->
 		<set name="users" table="sys_user_role">
 			<key column="role_id"></key>
 			<many-to-many class="User" column="user_id"></many-to-many>
 		</set>
 	</class>
 </hibernate-mapping>

vlin_fanpeng

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java基础学习之hibernate初体验

Hibernate 简介 :简介:Hibernate 是由 Gavin King 于 2001 年创建的开放源代码的对象关系框架。它强大且高效的构建具有关系对象持久性和查询服务的 Java 应用程序。Hibernate 将 Java 类映射到数据库表中，从 Java 数据类型中映射到 SQL 数据类型中，并把开发人员从 95% 的公共数据持续性编程工作中解放出来。Hibernate 是传统 Jav...
复制链接

扫一扫