Hibernate
框架是用来提高开发效率的，它封装一些功能可以直接使用即可。所以框架可以理解是一个半成品的项目。
Hibernate则是用来操作数据库的框架，在操作数据库的过程中可以用面向对象的方式来完成，而不需要书写SQL语句。
Hibernate属于ORM性质的框架，其中ORM是指使用配置或其他手段将对象信息与数据库的表进行对应。
hibernate属于四级，是完全面向对象的形式操作数据库的。
mybatis属于二级。
dbUtils属于一级。
Hibernate使用
Hibernate框架搭建
- 建表语句
创建数据库和表的建表语句如下：
create database hibernate_demo;
create table `cst_customer` (
`cust_id` bigint(32) not null auto_increment comment '客户编号(主键)',
`cust_name` varchar(32) not null comment '客户名称(公司名称)',
`cust_source` varchar(32) default null comment '客户信息来源',
`cust_industry` varchar(32) default null comment '客户所属行业',
`cust_level` varchar(32) default null comment '客户级别',
`cust_linkman` varchar(64) default null comment '联系人',
`cust_phone` varchar(64) default null comment '固定电话',
`cust_mobile` varchar(16) default null comment '移动电话',
primary key (`cust_id`)
) engine=innodb auto_increment=1 default charset=utf8;
- 数据库配置
创建完数据库之后，需要编写数据库的一些配置信息，名称默认为：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>
<!-- 数据库驱动 -->
<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
<!-- 数据库url -->
<property name="hibernate.connection.url">jdbc:mysql://localhost:3306/hibernate_demo?useUnicode=true&characterEncoding=utf-8</property>
<!-- 数据库连接用户名 -->
<property name="hibernate.connection.username">root</property>
<!-- 数据库连接密码 -->
<property name="hibernate.connection.password">123456</property>
<!-- 数据库方言
不同的数据库中,sql语法略有区别. 指定方言可以让hibernate框架在生成sql语句时.针对数据库的方言生成.
sql99标准: DDL 定义语言 库表的增删改查
DCL 控制语言 事务 权限
DML 操纵语言 增删改查
注意: MYSQL在选择方言时,请选择最短的方言.
-->
<property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
<!-- #hibernate.show_sql true
#hibernate.format_sql true-->
<!-- 将hibernate生成的sql语句打印到控制台 -->
<property name="hibernate.show_sql">true</property>
<!-- 将hibernate生成的sql语句格式化(语法缩进) -->
<property name="hibernate.format_sql">true</property>
<!--
## auto schema export 自动导出表结构. 自动建表
#hibernate.hbm2ddl.auto create 自动建表.每次框架运行都会创建新的表.以前表将会被覆盖,表数据会丢失.(开发环境中测试使用)
#hibernate.hbm2ddl.auto create-drop 自动建表.每次框架运行结束都会将所有表删除.(开发环境中测试使用)
#hibernate.hbm2ddl.auto update(推荐使用) 自动生成表.如果已经存在不会再生成.如果表有变动.自动更新表(不会删除任何数据).
#hibernate.hbm2ddl.auto validate 校验.不自动生成表.每次启动会校验数据库中表是否正确.校验失败. -->
<property name="hibernate.hbm2ddl.auto">update</property>
<!-- 引入orm元数据路径书写: 填写src下的路径-->
<mapping resource="com/legend/hibernate/domain/Customer.hbm.xml"/>
</session-factory>
</hibernate-configuration>
注意一：所有的配置信息都必须在<mapping>标签之前配置，否则会出错。
注意二：在使用过程中如果出现java.sql.SQLException: Incorrect string value:xxx错误的话是因为这里没有& 加上即可。
jdbc:mysql://localhost:3306/hibernate_demo?useUnicode=true&amp;characterEncoding=utf-8
注意三：由于Hibernate默认的建表方式不是utf8，想要设置Hibernate默认建表方式可以重写方言来实现：
public class MYSQLDialectUTF8 extends MySQLDialect {
@Override
public String getTableTypeString() {
return " ENGINE=InnoDB DEFAULT CHARSET=utf8";
}
}
然后在连接数据库的时候带上编码，以及方言使用我们重写的类使用如下方式：
<!-- 数据库url -->
<property name="hibernate.connection.url">jdbc:mysql://localhost:3306/hibernate_demo?useUnicode=true&characterEncoding=utf-8</property>
<!-- 数据库方言-->
<property name="hibernate.dialect">com.legend.hibernate.charset.MYSQLDialectUTF8</property>
这样数据库就默认支持utf8了，如果有必要还需要修改MYSQL的默认编码方式，在MYSQL安装目录找到my.ini，将编码全部改成utf8即可。
- 映射实体配置
创建和数据库表映射的实体类：Customer.java
public class Customer {
private Long cust_id;
private String cust_name;
private String cust_source;
private String cust_industry;
private String cust_level;
private String cust_linkman;
private String cust_phone;
private String cust_mobile;
...Get & Set...
}
在实体类的同包下创建它的数据映射配置类Customer.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">
<!-- 配置表与实体对象的关系 -->
<!-- package属性:填写一个包名.在元素内部凡是需要书写完整类名的属性,可以直接写简答类名了. -->
<hibernate-mapping package="com.legend.hibernate.domain" >
<!--
class元素: 配置实体与表的对应关系的
name: 完整类名
table:数据库表名
-->
<class name="Customer" table="cst_customer">
<!-- id元素:配置主键映射的属性
name: 填写主键对应属性名
column(可选): 填写表中的主键列名.默认值:列名会默认使用属性名
type(可选):填写列(属性)的类型.hibernate会自动检测实体的属性类型.
每个类型有三种填法: java类型|hibernate类型|数据库类型
not-null(可选):配置该属性(列)是否不能为空. 默认值:false
length(可选):配置数据库中列的长度. 默认值:使用数据库类型的最大长度
-->
<id name="cust_id">
<!-- generator:主键生成策略：主键生成策略，就是每条记录录入时，主键的生成规则
identity：主键自增，有数据库维护主键值，录入不需要指定主键。
sequence：Oracle中的主键生成策略。
increment（了解）：主键自增，有hibernate来维护。每次插入前会先查询表中id最大值，然后+1作为新主键。
hilo（了解）：高低位算法，主键自增，由hibernate来维护。（开发不适用）
native（方便）：hilo + seqence + identity自动三选一。
uuid：产生随机字符串作为主键，主键类型必须为String类型。
assigend：自然主键生成策略。hibernate不会管理主键值，由开发人员操作。
-->
<generator class="native"></generator>
</id>
<!-- property元素:除id之外的普通属性映射
name: 填写属性名
column(可选): 填写列名
type(可选):填写列(属性)的类型.hibernate会自动检测实体的属性类型.
每个类型有三种填法: java类型|hibernate类型|数据库类型
not-null(可选):配置该属性(列)是否不能为空. 默认值:false
length(可选):配置数据库中列的长度. 默认值:使用数据库类型的最大长度
-->
<property name="cust_name" column="cust_name">
<!-- <column name="cust_name" sql-type="varchar" ></column> -->
</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>
</class>
</hibernate-mapping>
到这里，Hibernate框架基本上已经搭建完毕。然后我们来测试一下Hibernate是否能正常连接：
@Test
public void test01(){
Configuration conf = new Configuration().configure();
SessionFactory sessionFactory = conf.buildSessionFactory();
Session session = sessionFactory.openSession();
Transaction tx = session.beginTransaction();
//----------------------------------------------
Customer c = new Customer();
c.setCust_name("完美时空");
session.save(c);
//----------------------------------------------
tx.commit();
session.close();
sessionFactory.close();
}
hibernate API详解
-
Configuration类
Configuration是hibernate的入口，负责管理Hibernate的配置信息，这些配置信息都是从配置文件hibernate.cfg.xml或者Hibernate.properties读取的，
当然也可以自定义文件名称，只要在实例化Configuration的时候指定具体的路径就可以了
//1 创建,调用空参构造
Configuration conf = new Configuration();
//2 读取指定主配置文件 => 空参加载方法,加载src下的hibernate.cfg.xml文件
conf.configure();
//3 读取指定orm元数据(扩展),如果主配置中已经引入映射配置.不需要手动加载
//conf.addResource(resourceName);
//conf.addClass(persistentClass);
-
SessionFactory类
SessionFactory用于创建操作数据库核心对象session对象的工厂。
//4 根据配置信息,创建 SessionFactory对象
SessionFactory sf = conf.buildSessionFactory();
//5 获得session
//打开一个新的session对象
sf.openSession();
//获得一个与线程绑定的session对象(明天讲解)
sf.getCurrentSession();
需要注意的是：
1.sessionfactory 负责保存和使用所有配置信息。消耗内存资源非常大。
2.sessionFactory属于线程安全的对象设计。
结论: 保证在web项目中,只创建一个sessionFactory。
-
Session
Session对象表示hibernate和数据库之间的连接会话，类似于JDBC的Connection对象，可以对数据库进行增删改查。它是Hibernate操作数据库的核心对象。
Session session = sf.openSession();
//4 session获得操作事务的Transaction对象
//获得操作事务的tx对象
//Transaction tx = session.getTransaction();
//开启事务并获得操作事务的tx对象(建议使用)
Transaction tx2 = session.beginTransaction();
//----------------------------------------------
// 操作数据库代码
//----------------------------------------------
tx2.commit();//提交事务
tx2.rollback();//回滚事务
session.close();//释放资源
sf.close();//释放资源
Hibernate增删改查
- 增加数据
@Test
public void insert() {
Configuration configuration = new Configuration().configure();
SessionFactory sessionFactory = configuration.buildSessionFactory();
Session session = sessionFactory.openSession();
// 开启事务
Transaction transaction = session.beginTransaction();
// 增加数据
Customer customer = new Customer();
customer.setCust_name("人生得意须纵欢");
session.save(customer);
transaction.commit();
session.close();
sessionFactory.close();
}
- 查询数据
@Test
public void query() {
Configuration configuration = new Configuration().configure();
SessionFactory sessionFactory = configuration.buildSessionFactory();
Session session = sessionFactory.openSession();
// 开启事务
Transaction transaction = session.beginTransaction();
// 查询数据
Customer customer = session.get(Customer.class, 1l);
System.out.println(customer.getCust_name());
transaction.commit();
session.close();
sessionFactory.close();
}
注意：由于id是long类型的数据，所以查询id为1的时候，参数需要填写1l。
- 修改数据
@Test
public void update() {
Configuration configuration = new Configuration().configure();
SessionFactory sessionFactory = configuration.buildSessionFactory();
Session session = sessionFactory.openSession();
// 开启事务
Transaction transaction = session.beginTransaction();
// 修改数据 -> 拿到对象 -> 修改数据 -> 更新数据
Customer customer = session.get(Customer.class, 1l);
customer.setCust_name("莫使金樽空对月");
session.update(customer);
transaction.commit();
session.close();
sessionFactory.close();
}
注意：根据面向对象的思想来说，首先要拿到对象，然后对对象的内容进行修改，然后再存回数据库。
- 删除数据
@Test
public void delete() {
Configuration configuration = new Configuration().configure();
SessionFactory sessionFactory = configuration.buildSessionFactory();
Session session = sessionFactory.openSession();
// 开启事务
Transaction transaction = session.beginTransaction();
// 删除数据 -> 拿到对象 -> 删除数据
Customer customer = session.get(Customer.class, 1l);
session.delete(customer);
transaction.commit();
session.close();
sessionFactory.close();
}
注意：根据面向对象的思想来说，首先要拿到对象，然后再删除对象。
-
Hibernate封装
我们知道，由于SessionFactory是一个耗费资源的对象，而且一个Web应用一般只对应一个SessionFactory，所以在使用的时候需要对其进行封装。
public class HibernateUtils {
private static SessionFactory mSessionFactory;
static{
//1 创建,调用空参构造
Configuration conf = new Configuration().configure();
//2 根据配置信息,创建 SessionFactory对象
mSessionFactory = conf.buildSessionFactory();
}
//获得session => 获得全新session
public static Session openSession(){
//3 获得session
Session session = mSessionFactory.openSession();
return session;
}
//获得session => 获得与线程绑定的session
public static Session getCurrentSession(){
//3 获得session
Session session = mSessionFactory.getCurrentSession();
return session;
}
}
-
解决中文乱码监听器
这个监听器是针对整个Web应用的数据库乱码处理的，是通用的类。
/**
* 通用编码解决方案
*/
public class GenericEncodingFilter implements Filter {
@Override
public void destroy() {
}
@Override
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
// 转型为与协议相关对象
HttpServletRequest httpServletRequest = (HttpServletRequest) request;
// 对request包装增强
HttpServletRequest myrequest = new MyRequest(httpServletRequest);
chain.doFilter(myrequest, response);
}
@Override
public void init(FilterConfig filterConfig) throws ServletException {
}
}
// 自定义request对象
class MyRequest extends HttpServletRequestWrapper {
private HttpServletRequest request;
private boolean hasEncode;
public MyRequest(HttpServletRequest request) {
super(request);// super必须写
this.request = request;
}
// 对需要增强方法 进行覆盖
@Override
public Map getParameterMap() {
// 先获得请求方式
String method = request.getMethod();
if (method.equalsIgnoreCase("post")) {
// post请求
try {
// 处理post乱码
request.setCharacterEncoding("utf-8");
return request.getParameterMap();
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
}
} else if (method.equalsIgnoreCase("get")) {
// get请求
Map<String, String[]> parameterMap = request.getParameterMap();
if (!hasEncode) { // 确保get手动编码逻辑只运行一次
for (String parameterName : parameterMap.keySet()) {
String[] values = parameterMap.get(parameterName);
if (values != null) {
for (int i = 0; i < values.length; i++) {
try {
// 处理get乱码
values[i] = new String(values[i].getBytes("ISO-8859-1"), "utf-8");
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
}
}
}
}
hasEncode = true;
}
return parameterMap;
}
return super.getParameterMap();
}
@Override
public String getParameter(String name) {
Map<String, String[]> parameterMap = getParameterMap();
String[] values = parameterMap.get(name);
if (values == null) {
return null;
}
return values[0]; // 取回参数的第一个值
}
@Override
public String[] getParameterValues(String name) {
Map<String, String[]> parameterMap = getParameterMap();
String[] values = parameterMap.get(name);
return values;
}
}
然后在web.xml配置该监听器：
<!-- 通用乱码过滤器 -->
<filter>
<filter-name>GenericEncodingFilter</filter-name>
<filter-class>com.legend.hibernate.filter.GenericEncodingFilter</filter-class>
</filter>
<filter-mapping>
<filter-name>GenericEncodingFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
Hibernate主键规则
Hibernate的主键生成规则需要在ORM的映射配置文件中进行修改，具体可以参考下面代码：
<id name="cust_id">
<!-- generator:主键生成策略：主键生成策略，就是每条记录录入时，主键的生成规则
identity：主键自增，有数据库维护主键值，录入不需要指定主键。
sequence：Oracle中的主键生成策略。
increment（了解）：主键自增，有hibernate来维护。每次插入前会先查询表中id最大值，然后+1作为新主键。
hilo（了解）：高低位算法，主键自增，由hibernate来维护。（开发不适用）
native（方便）：hilo + seqence + identity自动三选一。
uuid：产生随机字符串作为主键，主键类型必须为String类型。
assigend：自然主键生成策略。hibernate不会管理主键值，由开发人员操作。
-->
<generator class="native"></generator>
一般推荐使用native的规则，因为这种在Mysql、Oracle数据库中都是通用的。
ibernate对象状态
Hibernate中的对象包含三种状态，分为是：瞬时状态、持久化状态、游离或托管状态。
代码如下所示：
/**
* 对象的三种状态
* save方法：其实不能理解为保存，应该是将瞬时状态转换为持久化状态。
* 主键自增：执行save方法时，因为对象转换为持久化状态，必须生成ID值，需要执行insert语句生成。
*/
@Test
public void test1() {
Session session = HibernateUtils.openSession();
Transaction transaction = session.beginTransaction();
// 没有ID，没有与session关联 => 瞬时状态
Customer customer = new Customer();
customer.setCust_name("联想");
// 有id和有关联 => 持久化状态
session.save(customer);
transaction.commit();
// 有id但没关联 => 游离或托管状态
session.close();
}
注意：凡是经过session操作的对象都是持久化状态的对象。
ibernate进阶
一级缓存
缓存是提高效率的一种手段，Hibernate中的缓存技术也是用来提高数据库的一种手段。
Session缓存技术 ：提高查询的效率。
缓存快照：减少不必要的修改语句发送。
事务操作
- 事务特性
| 特性 | 说明 |
|---|---|
| 原子性(atomicity) | 指的是事务最小不可分割的单位,事务中的操作要么都发生，要么都不发生。 |
| 一致性(consistency) | 指的是事务前后数据保持完整，不会出现不统一的情况。 |
| 隔离性(isolation) | 操作事务的时候，不同的事务之间相互隔离，不能被干扰到。 |
| 持久性(durability) | 事务一旦提交，那么数据都真的持久化保存到设备中去了，不能再回滚或任何的更改。 |
-
事务的隔离级别
事务的隔离级别主要是用于处理数据库并发时的一种手段。
| 名称 | 说明 |
|---|---|
| TRANSACTION_READ_COMMITTED | 指示不可以发生脏读的常量；不可重复和虚读可以发生。 |
| TRANSACTION_READ_UNCOMMITTED | 指示可以发生脏读、不可重复读和虚读的常量。 |
| TRANSACTION_REPEATABLE_READ | 指示不可以发生脏读和不可重复读的常量；虚读可以发生。 |
| TRANSACTION_SERIALIZABLE | 指示不可以发生脏读、不可重复读和虚读的常量。 |
Hibernate中支持数据库的事务操作，Mysql的默认隔离级别是4，我们可以在hibernate中对其进行配置：
<!-- 指定hibernate操作数据库时的隔离级别
#hibernate.connection.isolation 1|2|4|8
0001 1 读未提交
0010 2 读已提交
0100 4 可重复读
1000 8 串行化
-->
<property name="hibernate.connection.isolation">4</property>
我们平时在操作JDBC时，每次去获取Connection都只能得到一个，并不能满足高并发的情况。因为Connection是线程不安全的。
每次获得connection都需要浪费cpu资源和内存资源，是很浪费资源的。所以诞生了数据库连接池。数据库连接池的Connection都是从ThreadLocal中去
获取的，如果ThreadLocal中存在则用，保证多个dao的操作都是同一个Connection对象，以保证事务。
那么在项目中如何管理事务呢？
1、在业务开始之前打开事务，在业务执行过后提交事务，出现异常则回滚事务。
public void save(Customer customer) {
Session session = HibernateUtils.getCurrentSession();
// 打开事务
Transaction transaction = session.beginTransaction();
CustomerDao dao = new CustomerDao();
try {
dao.save(customer);
}catch (Exception e) {
e.printStackTrace();
transaction.rollback();
}
// 关闭事务
transaction.commit();
}
2、在dao层操作数据库需要用到session对象，我们要确保dao层和service层使用同一个session对象。
<!--指定session与当前线程绑定，解决session不一致的问题-->
<property name="hibernate.current_session_context_class">thread</property>
此时，我们就可以通过SessionFactory的getCurrentSession()来获取Session对象，而且每次获取的都是同一个：
@Test
public void testSession() {
Session session1 = HibernateUtils.getCurrentSession();
Session session2 = HibernateUtils.getCurrentSession();
System.out.println(session1 == session2);
Session session3 = HibernateUtils.openSession();
Session session4 = HibernateUtils.openSession();
System.out.println(session3 == session4);
}
输出结果：
true
false
结论：由此可以证明getCurrentSession()每次获取都是同一个Session对象，而openSession()方法获取的不是同一个对象。
3、通过getCurrentSession()方法获得的Session对象在事务提交后，Session会自动关闭，如果手动关闭则会异常。
单表查询
Hibernate中有三种查询方式：原生SQL查询（复杂业务）、HQL查询、Ceiteria查询。
- 原生SQL查询
1、基本查询操作
在企业开发中，复杂的业务操作都还是使用原生SQL的方式进行操作。
@Test
public void queryBySQL() {
Session session = HibernateUtils.openSession();
Transaction transaction = session.beginTransaction();
// 执行查询操作
String sql = "select * from cst_customer";
SQLQuery query = session.createSQLQuery(sql);
List<Object[]> list = query.list();
// query.uniqueResult();
for (Object[] objs : list) {
System.out.println(Arrays.toString(objs));
}
transaction.commit();
session.close();
}
需要注意调用list()方法的返回值的泛型是Object[]数组，封装所查询到的数据表的所有内容。
如果想将数据结果集封装到指定的对象中的话，则需要进行指定。
@Test
public void query() {
Session session = HibernateUtils.openSession();
Transaction transaction = session.beginTransaction();
// 执行查询操作
String sql = "select * from cust_customer";
SQLQuery query = session.createSQLQuery(sql);
// 指定将结果集封装到哪个对象中
query.addEntity(Customer.class);
List<Customer> list = query.list();
System.out.println(list.get(0).getCust_name());
transaction.commit();
session.close();
}
2、条件查询操作
需要注意，这里跟Mysql保持一致，位置都是从0开始的。
@Test
public void queryByWhere() {
Session session = HibernateUtils.openSession();
Transaction transaction = session.beginTransaction();
// 执行查询操作
String sql = "select * from cust_customer where cust_id = ?";
SQLQuery query = session.createSQLQuery(sql);
// 指定占位符的参数
query.setParameter(0, 1l);
// 指定将结果集封装到哪个对象中
query.addEntity(Customer.class);
List<Customer> list = query.list();
System.out.println(list.get(0).getCust_name());
transaction.commit();
session.close();
}
3、分页查询操作
@Test
public void queryByage() {
Session session = HibernateUtils.openSession();
Transaction transaction = session.beginTransaction();
// 执行查询操作
String sql = "select * from cust_customer limit ?,?";
SQLQuery query = session.createSQLQuery(sql);
// 指定占位符的参数
query.setParameter(0, 0);
query.setParameter(1, 1);
// 指定将结果集封装到哪个对象中
query.addEntity(Customer.class);
List<Customer> list = query.list();
System.out.println(list.get(0).getCust_name());
transaction.commit();
session.close();
}
-
HQL查询
HQL（Hibernate Query Language）查询是Hibernate独有的面向对象的查询语言。在多表查询，但是表不复杂的情况下使用。
1、基本查询操作
@Test
public void queryByHQL() {
Session session = HibernateUtils.getCurrentSession();
Transaction transaction = session.beginTransaction();
// 1> 书写HQL语句
//String hql = "from com.legend.hibernate.domain.Customer"; // 类名重复时使用
String hql = "from Customer";
// 2> 根据HQL语句创建查询对象
Query query = session.createQuery(hql);
// 3> 根据查询对象获得查询结果
List<Customer> list = query.list();// 多条结果使用，返回list类型数据。
//query.uniqueResult(); // 接收唯一的结果。
System.out.println(list.size());
transaction.commit();
}
2、条件查询操作
在HQL语句中是不可能出现任何数据库相关的内容，只会出现对象名和属性名，所以条件查询跟的条件是属性名称。
@Test
public void queryHQLBy() {
Session session = HibernateUtils.getCurrentSession();
Transaction transaction = session.beginTransaction();
// 1> 书写HQL语句，条件是属性名
String hql = "from Customer where cust_id = 1l";
// 2> 根据HQL语句创建查询对象
Query query = session.createQuery(hql);
// 3> 根据查询对象获得查询结果
Customer customer = (Customer) query.uniqueResult();
System.out.println(customer.getCust_name());
transaction.commit();
}
如果条件想根据占位符的方式进行输入可以采用如下写法：
@Test
public void queryHQLBy1() {
Session session = HibernateUtils.getCurrentSession();
Transaction transaction = session.beginTransaction();
// 1> 书写HQL语句，条件是属性名
String hql = "from Customer where cust_id = ?";
// 2> 根据HQL语句创建查询对象
Query query = session.createQuery(hql);
// 3> 根据占位符传入参数
//query.setLong(0, 1l);
query.setParameter(0, 1l);
// 4> 根据查询对象获得查询结果
Customer customer = (Customer) query.uniqueResult();
System.out.println(customer.getCust_name());
transaction.commit();
}
在HQL中还有一种命名占位符的方式，它的写法如下：
@Test
public void queryHQLBy2() {
Session session = HibernateUtils.getCurrentSession();
Transaction transaction = session.beginTransaction();
// 1> 书写HQL语句，条件是属性名
String hql = "from Customer where cust_id = :xxx";
// 2> 根据HQL语句创建查询对象
Query query = session.createQuery(hql);
// 3> 根据占位符传入参数
query.setParameter("xxx", 1l);
// 4> 根据查询对象获得查询结果
Customer customer = (Customer) query.uniqueResult();
System.out.println(customer.getCust_name());
transaction.commit();
}
3、分页查询操作
在HQL中使用分页查询，可以使用如下方式：
@Test
public void queryHQLByPage() {
Session session = HibernateUtils.getCurrentSession();
Transaction transaction = session.beginTransaction();
// 1> 书写HQL语句，条件是属性名
String hql = "from Customer";
// 2> 根据HQL语句创建查询对象
Query query = session.createQuery(hql);
// 3> 设置分页信息
query.setFirstResult(0);
query.setMaxResults(1);
// 4> 根据查询对象获得查询结果
List<Customer> list = query.list();
System.out.println(list.get(0).getCust_name());
transaction.commit();
}
4、聚合函数查询
@Test
public void query() {
Session session = HibernateUtils.openSession();
Transaction transaction = session.beginTransaction();
// 执行数据库操作
String hql1 = "select count(*) from com.legend.hibernate.domain.Customer";
String hql2 = "select sum(cust_id) from com.legend.hibernate.domain.Customer";
String hql3 = "select avg(cust_id) from com.legend.hibernate.domain.Customer";
String hql4 = "select max(cust_id) from com.legend.hibernate.domain.Customer";
String hql5 = "select min(cust_id) from com.legend.hibernate.domain.Customer";
Query query = session.createQuery(hql5);
Number number = (Number) query.uniqueResult();
System.out.println(number);
// 提交事务
transaction.commit();
session.close();
}
其中Number对象是Long、Integer....的父类，所以可以接收全部类型。
5、投影查询
所谓投影查询，其实就是查询对象的某一个属性。
@Test
public void query() {
Session session = HibernateUtils.openSession();
Transaction transaction = session.beginTransaction();
// 查询单个属性
String hql = "select cust_name from com.legend.hibernate.domain.Customer";
Query query = session.createQuery(hql);
List list = query.list();
System.out.println(list);
// 查询多个属性
String hql1 = "select cust_name,cust_id from com.legend.hibernate.domain.Customer";
Query query1 = session.createQuery(hql1);
List<Object[]> list1 = query1.list();
System.out.println(list1);
// 查询多个属性封装到Customer，构造函数必须存在，且顺序一致。
String hql2 = "select new Customer(cust_id,cust_name) from com.legend.hibernate.domain.Customer";
Query query2 = session.createQuery(hql2);
List<Customer> list2 = query2.list();
System.out.println(list2);
transaction.commit();
session.close();
}
-
Criteria查询
Criteria查询也是Hibernate自创的查询方式，它是没有数据库语句的面向对象查询方式。主要用于单表查询。
1、基本查询操作
@Test
public void query() {
Session session = HibernateUtils.openSession();
Transaction transaction = session.beginTransaction();
// 执行查询操作
Criteria criteria = session.createCriteria(Customer.class);
// Customer customer = (Customer) criteria.uniqueResult();
List<Customer> list = criteria.list();
System.out.println(list.size());
transaction.commit();
session.close();
}
2、条件查询操作
使用Criteria进行条件语句查询时，有如下方法：
| 数据库符号 | 方法名 |
|---|---|
| > | Restrictions.eq(String propertyName, Object value) |
| >= | Restrictions.ge(String propertyName, Object value) |
| < | Restrictions.lt(String propertyName, Object value) |
| <= | Restrictions.le(String propertyName, Object value) |
| == | Restrictions.eq(String propertyName, Object value) |
| != | Restrictions.ne(String propertyName, Object value) |
| in | Restrictions.in(String propertyName, Object[] values) |
| between and | Restrictions.between(String propertyName, Object lo, Object hi) |
| like | Restrictions.like(String propertyName, Object value) |
| is not null | Restrictions.isNotNull(String propertyName) |
| is null | Restrictions.isNull(String propertyName) |
| or | Restrictions.or(Criterion lhs, Criterion rhs) |
| and | Restrictions.and(Criterion lhs, Criterion rhs) |
范例：
@Test
public void query1() {
Session session = HibernateUtils.openSession();
Transaction transaction = session.beginTransaction();
// 执行查询操作
Criteria criteria = session.createCriteria(Customer.class);
// 添加查询参数
criteria.add(Restrictions.eq("cust_id", 1l));
Customer customer = (Customer) criteria.uniqueResult();
System.out.println(customer.getCust_name());
transaction.commit();
session.close();
}
3、分页查询操作
@Test
public void queryByPage() {
Session session = HibernateUtils.openSession();
Transaction transaction = session.beginTransaction();
// 执行分页查询操作
Criteria criteria = session.createCriteria(Customer.class);
// 添加分页信息
criteria.setFirstResult(0);
criteria.setMaxResults(1);
// 执行查询操作
List<Customer> list = criteria.list();
System.out.println(list.get(0).getCust_name());
transaction.commit();
session.close();
}
4、查询总记录
如果想通过聚合函数查询总行数，可以使用下面的方法：
@Test
public void queryByCount() {
Session session = HibernateUtils.openSession();
Transaction transaction = session.beginTransaction();
// 执行分页查询操作
Criteria criteria = session.createCriteria(Customer.class);
// 设置查询聚合函数 => 总行数
criteria.setProjection(Projections.rowCount());
// 执行查询操作
Long count = (Long) criteria.uniqueResult();
System.out.println(count);
transaction.commit();
session.close();
}
多表查询
- 原生SQL查询
交叉连接-笛卡尔积(避免)
select * from A,B
内连接
|-隐式内连接
select * from A,B where b.aid = a.id
|-显式内连接
select * from A inner join B on b.aid = a.id
外连接
|- 左外
select * from A left [outer] join B on b.aid = a.id
|- 右外
select * from A right [outer] join B on b.aid = a.id
多表查询待补充。
多表映射
假设我们有两个实体Customer（顾客）和LinkMan（联系人），那么他们的正常关系是一个顾客对应多个联系人。
一对多和多对一
我们知道一个客户对应多个联系人，在实体中设计的话则需要在客户实体中设计集合来包含多个联系人，用来表示一对多的关系；然后在联系人实体中设计
单个客户的对象来表明多对一的关系。那么我们的实体设计如下：
Customer.java
public class Customer {
private Long cust_id;
private String cust_name;
private String cust_source;
private String cust_industry;
private String cust_level;
private String cust_linkman;
private String cust_phone;
private String cust_mobile;
// 表明一对多的关系
private Set<LinkMan> linkMens = new HashSet<>();
...省略get和set方法...
}
LinkMan.java
public class LinkMan {
private Long lkm_id;
private Character lkm_gender;
private String lkm_name;
private String lkm_phone;
private String lkm_email;
private String lkm_qq;
private String lkm_mobile;
private String lkm_memo;
private String lkm_position;
// 表达多对一的关系
private Customer customer;
...省略get和set方法...
}
Customer这个属性就代表了客户表和联系人表之间的cid了。这样就表示出客户和联系人之间一对多和多对一的关系。
其中Customer和LinkMan对应如下两张表，下面的建表命令：
-- Customer
create table `cst_customer` (
`cust_id` bigint(32) not null auto_increment comment '客户编号(主键)',
`cust_name` varchar(32) not null comment '客户名称(公司名称)',
`cust_user_id` bigint(32) default null comment '负责人id',
`cust_create_id` bigint(32) default null comment '创建人id',
`cust_source` varchar(32) default null comment '客户信息来源',
`cust_industry` varchar(32) default null comment '客户所属行业',
`cust_level` varchar(32) default null comment '客户级别',
`cust_linkman` varchar(64) default null comment '联系人',
`cust_phone` varchar(64) default null comment '固定电话',
`cust_mobile` varchar(16) default null comment '移动电话',
primary key (`cust_id`)
) engine=innodb auto_increment=1 default charset=utf8;
-- LinkMan
create table `cst_linkman` (
`lkm_id` bigint(32) not null auto_increment comment '联系人编号(主键)',
`lkm_name` varchar(16) default null comment '联系人姓名',
`lkm_cust_id` bigint(32) not null comment '客户id',
`lkm_gender` char(1) default null comment '联系人性别',
`lkm_phone` varchar(16) default null comment '联系人办公电话',
`lkm_mobile` varchar(16) default null comment '联系人手机',
`lkm_email` varchar(64) default null comment '联系人邮箱',
`lkm_qq` varchar(16) default null comment '联系人qq',
`lkm_position` varchar(16) default null comment '联系人职位',
`lkm_memo` varchar(512) default null comment '联系人备注',
primary key (`lkm_id`),
key `fk_cst_linkman_lkm_cust_id` (`lkm_cust_id`),
constraint `fk_cst_linkman_lkm_cust_id` foreign key (`lkm_cust_id`) references `cst_customer` (`cust_id`) on delete no action on update no action
) engine=innodb auto_increment=3 default charset=utf8;
-
ORM映射
当我们创建完实体类后，就需要做实体类的ORM映射来和数据库表建立关联了，我们分别创建两张ORM映射配置
Customer.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.legend.hibernate.domain" >
<class name="Customer" table="cst_customer">
<id name="cust_id">
<generator class="native"></generator>
</id>
<property name="cust_name">
</property>
<property name="cust_source"></property>
<property name="cust_industry" ></property>
<property name="cust_level"></property>
<property name="cust_linkman"></property>
<property name="cust_phone"></property>
<property name="cust_mobile"></property>
<!--集合，一对多关系，在配置文件中配置
name属性：集合属性名
column属性：外键列名
class属性：与我关联的对象完整类名
-->
<set name="linkMens">
<key column="lkm_cust_id"></key>
<one-to-many class="LinkMan"/>
</set>
</class>
</hibernate-mapping>
LinkMan.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.legend.hibernate.domain" >
<class name="LinkMan" table="cst_linkman">
<id name="lkm_id">
<generator class="native"></generator>
</id>
<property name="lkm_gender"></property>
<property name="lkm_name"></property>
<property name="lkm_phone"></property>
<property name="lkm_email"></property>
<property name="lkm_qq"></property>
<property name="lkm_mobile"></property>
<property name="lkm_memo"></property>
<property name="lkm_position"></property>
<!--多对一的关系
name属性：集合属性名
column属性：外键列名
class属性：与我关联的对象完整类名
-->
<many-to-one name="customer" column="lkm_cust_id" class="Customer"></many-to-one>
</class>
</hibernate-mapping>
在创建实体关系时<key>标签的column必须保持和<many-to-one>标签中的column保持完全一致。
在配置完实体关系后，千万要记得在Hibernater的配置文件中增加实体的ORM元数据配置。
<!-- 引入orm元数据路径书写: 填写src下的路径-->
<mapping resource="com/legend/hibernate/domain/Customer.hbm.xml"/>
<mapping resource="com/legend/hibernate/domain/LinkMan.hbm.xml"/>
范例：测试多表ORM元数据配置是否成功
@Test
public void test() {
Session session = HibernateUtils.openSession();
Transaction transaction = session.beginTransaction();
Customer customer = new Customer();
customer.setCust_name("百度公司");
LinkMan linkMan1 = new LinkMan();
linkMan1.setLkm_name("张总");
LinkMan linkMan2 = new LinkMan();
linkMan2.setLkm_name("刘总");
// 表达一对多关系
customer.getLinkMens().add(linkMan1);
customer.getLinkMens().add(linkMan2);
// 表达多对一的关系
linkMan1.setCustomer(customer);
linkMan2.setCustomer(customer);
session.save(customer);
session.save(linkMan1);
session.save(linkMan2);
transaction.commit();
session.close();
}
注意：由于Hibernate在创建数据库表的时候默认会用lartin编码，会导致我们无法插入数据，可以手动以UTF8的方式建表。
-
级联操作
在上方的代码操作中，每次添加客户都需要创建多个联系人，如果我们想在保存客户的时候同时保存联系人信息，则可以使用级联操作。
<!--集合，一对多关系，在配置文件中配置
name属性：集合属性名
column属性：外键列名
class属性：与我关联的对象完整类名
级联操作：cascade
save-update：级联保存更新
delete：级联删除
all：save-update and delete
-->
<set name="linkMens" cascade="save-update">
<key column="lkm_cust_id"></key>
<one-to-many class="LinkMan"/>
</set>
设置为cascade为save-update后，我们的操作数据库的代码可以修改为：
@Test
public void test1() {
Session session = HibernateUtils.openSession();
Transaction transaction = session.beginTransaction();
Customer customer = new Customer();
customer.setCust_name("百度公司");
LinkMan linkMan1 = new LinkMan();
linkMan1.setLkm_name("张总");
LinkMan linkMan2 = new LinkMan();
linkMan2.setLkm_name("刘总");
// 表达一对多关系
customer.getLinkMens().add(linkMan1);
customer.getLinkMens().add(linkMan2);
// 表达多对一的关系
linkMan1.setCustomer(customer);
linkMan2.setCustomer(customer);
session.save(customer);
//session.save(linkMan1);
//session.save(linkMan2);
transaction.commit();
session.close();
}
这样我们在保存客户的时候会自动将联系人一起保存，下面我们测试下删除，将cascade设置为delete：
<set name="linkMens" cascade="delete">
<key column="lkm_cust_id"></key>
<one-to-many class="LinkMan"/>
</set>
这样我们在操作时，删除客户的同时会自动删除客户下的联系人信息。
@Test
public void delete() {
Session session = HibernateUtils.openSession();
Transaction transaction = session.beginTransaction();
// 联动删除操作
Customer customer = session.get(Customer.class, 4l);
session.delete(customer);
transaction.commit();
session.close();
}
如果我们将cascade配置为all的话，那么它同时具备级联保存和级联删除两种操作，save-update and delte。
注意：级联操作不但可以正向操作，还可以方向操作，不但可以在客户中设置来联动联系人，也可以在联系人设置来联动客户。
-
关系维护
我们在正常操作客户和联系的时候，在保存时，两方都会维护自己的关系和外键关系，所以关系被维护两次，那么多余的关系维护就冗余了。
Hibernate:
insert
into
cst_customer
(cust_name, cust_source, cust_industry, cust_level, cust_linkman, cust_phone, cust_mobile)
values
(?, ?, ?, ?, ?, ?, ?)
Hibernate:
insert
into
cst_linkman
(lkm_gender, lkm_name, lkm_phone, lkm_email, lkm_qq, lkm_mobile, lkm_memo, lkm_position, lkm_cust_id)
values
(?, ?, ?, ?, ?, ?, ?, ?, ?)
Hibernate:
update
cst_linkman
set
lkm_cust_id=?
where
lkm_id=?
从输出语句可以看出一共有三条语句，其中第三条是冗余的语句。我们可以在hibernater中通过inverse属性来维护客户的关系，避免冗余的维护。
<!--inverse属性：配置关系是否维护
true：Customer不维护关系。
false（默认）：Customer维护关系。
-->
<set name="linkMens" cascade="delete" inverse="true">
<key column="lkm_cust_id"></key>
<one-to-many class="LinkMan"/>
</set>
配置inverse属性为true后，此时控制台只输出两条语句，则避免了冗余的语句，优化性能。
Hibernate:
insert
into
cst_customer
(cust_name, cust_source, cust_industry, cust_level, cust_linkman, cust_phone, cust_mobile)
values
(?, ?, ?, ?, ?, ?, ?)
Hibernate:
insert
into
cst_linkman
(lkm_gender, lkm_name, lkm_phone, lkm_email, lkm_qq, lkm_mobile, lkm_memo, lkm_position, lkm_cust_id)
values
(?, ?, ?, ?, ?, ?, ?, ?, ?)
注意：在多的一方不能放弃维护关系（外键存在），必须有一方来维护关系，reverse属性只是将双方都维护的方式转换为只需要多的一方来维护。
如果客户在放弃维护联系人关系，我们在操作数据库的时候可以省略客户对联系人维护的代码：
@Test
public void test() {
Session session = HibernateUtils.openSession();
Transaction transaction = session.beginTransaction();
Customer customer = new Customer();
customer.setCust_name("百度公司");
LinkMan linkMan1 = new LinkMan();
linkMan1.setLkm_name("张总");
LinkMan linkMan2 = new LinkMan();
linkMan2.setLkm_name("刘总");
// 表达一对多关系，如果客户放弃维护联系人的关系，这两行代码可以省略。
//customer.getLinkMens().add(linkMan1);
//customer.getLinkMens().add(linkMan2);
// 表达多对一的关系
linkMan1.setCustomer(customer);
linkMan2.setCustomer(customer);
session.save(customer);
session.save(linkMan1);
session.save(linkMan2);
transaction.commit();
session.close();
}
如果客户放弃维护联系人关系的时候，是无法删除客户的，需要先删除联系人，然后再删除客户。也可以开启casecade="delete"属性来联动删除。
多对多关系
我们知道在多对多关系和一对多关系有很大不同，一对多和多对一可以通过外键的形式来处理关系，而多对多只能通过中间表的方式来处理关系。
而且中间表必须两列，而且都是外键，分别引用两张表的主键。
在多对多的实体关系关系中，我们可以在双方都使用集合来表达可以拥有多个对方。那么我实体设计如下：
User.java
public class User {
private Long user_id;
private String user_code;
private String user_name;
private String user_password;
private Character user_state;
// 表达和Role的关系
private Set<Role> roles = new HashSet<>();
...省略get和set方法...
}
Role.java
public class Role {
private Long role_id;
private String role_name;
private String role_memo;
// 表达和User的关系
private Set<User> users = new HashSet<>();
...省略get和set方法...
}
这样就表达了两个实体之间，多对多的关系了，互相持有多个对方。
其中User和Role对应如下两张表，下面的建表语句：
// User
create table `sys_user` (
`user_id` bigint(32) not null auto_increment comment '用户id',
`user_code` varchar(32) not null comment '用户账号',
`user_name` varchar(64) not null comment '用户名称',
`user_password` varchar(32) not null comment '用户密码',
`user_state` char(1) not null comment '1:正常,0:暂停',
primary key (`user_id`)
) engine=innodb auto_increment=9 default charset=utf8;
// Role
create table `sys_role` (
`role_id` bigint(32) not null auto_increment,
`role_name` varchar(32) not null comment '角色名称',
`role_memo` varchar(128) default null comment '备注',
primary key (`role_id`)
) engine=innodb auto_increment=6 default charset=utf8;
除此之外，因为多对多的关系需要一张虚拟的表来进行关系映射，所以虚拟表的建表语句如下：
create table `sys_user_role` (
`role_id` bigint(32) not null comment '角色id',
`user_id` bigint(32) not null comment '用户id',
primary key (`role_id`,`user_id`),
key `fk_user_role_user_id` (`user_id`),
constraint `fk_user_role_role_id` foreign key (`role_id`) references `sys_role` (`role_id`) on delete no action on update no action,
constraint `fk_user_role_user_id` foreign key (`user_id`) references `sys_user` (`user_id`) on delete no action on update no action
) engine=innodb default charset=utf8;
-
ORM映射
当我们创建完实体类后，就需要做实体类的ORM映射来和数据库表建立关联了，我们分别创建两张ORM映射配置
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">
<!-- 配置表与实体对象的关系 -->
<!-- package属性:填写一个包名.在元素内部凡是需要书写完整类名的属性,可以直接写简答类名了. -->
<hibernate-mapping package="com.legend.hibernate.domain" >
<class name="User" table="sys_user">
<id name="user_id">
<!-- generator:主键生成策略，每条记录录入时，主键的生成规则-->
<generator class="native"></generator>
</id>
<property name="user_code"></property>
<property name="user_name"></property>
<property name="user_password" ></property>
<property name="user_state"></property>
<!--多对多关系表达 name：集合属性名；table：配置中间表名-->
<set name="roles" table="sys_user_role">
<!--column属性表示外键，别人引用我的外键。-->
<key column="user_id"></key>
<!--class：我与哪个类是多对多关系；column：我引用别人的外键-->
<many-to-many class="Role" column="role_id"></many-to-many>
</set>
</class>
</hibernate-mapping>
Role.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">
<!-- 配置表与实体对象的关系 -->
<!-- package属性:填写一个包名.在元素内部凡是需要书写完整类名的属性,可以直接写简答类名了. -->
<hibernate-mapping package="com.legend.hibernate.domain" >
<class name="Role" table="sys_role">
<id name="role_id">
<!-- generator:主键生成策略，每条记录录入时，主键的生成规则-->
<generator class="native"></generator>
</id>
<property name="role_name"></property>
<property name="role_memo"></property>
<!--多对多关系表达 name：集合属性名；table：配置中间表名-->
<set name="users" table="sys_user_role">
<!--column属性表示外键，别人引用我的外键。-->
<key column="role_id"></key>
<!--class：我与哪个类是多对多关系；column：我引用别人的外键-->
<many-to-many class="User" column="user_id"></many-to-many>
</set>
</class>
</hibernate-mapping>
在配置完实体关系后，千万要记得在Hibernater的配置文件中增加实体的ORM元数据配置。
<mapping resource="com/legend/hibernate/domain/User.hbm.xml"/>
<mapping resource="com/legend/hibernate/domain/Role.hbm.xml"/>
范例：测试多表设计的实体是否正常
@Test
public void test() {
Session session = HibernateUtils.openSession();
Transaction transaction = session.beginTransaction();
// 1> 创建两个User
User user1 = new User();
user1.setUser_name("孙悟空");
User user2 = new User();
user2.setUser_name("猪八戒");
// 2> 创建两个Role
Role role1 = new Role();
role1.setRole_name("看家护院");
Role role2 = new Role();
role2.setRole_name("化斋打水");
// 3> 用户表达关系
user1.getRoles().add(role1);
user1.getRoles().add(role2);
user2.getRoles().add(role1);
user2.getRoles().add(role2);
// 4> 角色表述关系
role1.getUsers().add(user1);
role1.getUsers().add(user2);
role2.getUsers().add(user1);
role2.getUsers().add(user2);
// 5> 调用save方法保存
session.save(user1);
session.save(user2);
session.save(role1);
session.save(role2);
transaction.commit();
session.close();
}
上方是非常标准的插入方式，运行发现出现错误：
这是因为Hibernate对双方的第三张关系表进行两次维护，两次维护导致虚拟关系表中的外键冲突。二种解决方案：
1、第一种方式就是只保存某个表的操作
// 4> 角色表述关系，去掉如下代码
role1.getUsers().add(user1);
role1.getUsers().add(user2);
role2.getUsers().add(user1);
role2.getUsers().add(user2);
2、第二种就是在某一个ORM文件中设置inverse为true来放弃外键维护。
<!--多对多关系表达 name：集合属性名；table：配置中间表名-->
<set name="users" table="sys_user_role" inverse="true">
<!--column属性表示外键，别人引用我的外键。-->
<key column="role_id"></key>
<!--class：我与哪个类是多对多关系；column：我引用别人的外键-->
<many-to-many class="User" column="user_id"></many-to-many>
</set>
注意：在开发过程中，如果遇到多对多的关系，一定要让某一方放弃外键的维护，放弃的规则是根据业务来判断哪一方放弃。
假设有员工和职位两张表，因为职位是需要员工去支配的，所以员工则需要维护外键，而职位则需要放弃维护外键。
- 多对多关系操作
1、为用户新增一个角色
// 为用户新增一个角色
@Test
public void insert() {
Session session = HibernateUtils.openSession();
Transaction transaction = session.beginTransaction();
// 1> 获得需要新增角色的用户
User user = session.get(User.class, 1l);
// 2> 创建新的角色
Role role = new Role();
role.setRole_name("端茶倒水");
// 3> 将角色添加到用户中
user.getRoles().add(role);
// 4> 将角色转换为持久化
session.save(user);
transaction.commit();
session.close();
}
除此之外，也可以使用级联的方式来新增角色，在User.hbm.xml中配置级联方式：
<!--多对多关系表达 name：集合属性名；table：配置中间表名-->
<set name="roles" table="sys_user_role" cascade="save-update">
<!--column属性表示外键，别人引用我的外键。-->
<key column="user_id"></key>
<!--class：我与哪个类是多对多关系；column：我引用别人的外键-->
<many-to-many class="Role" column="role_id"></many-to-many>
</set>
然后代码中注释掉session.save()方法，然后运行也可以成功保存。
// 为用户新增一个角色
@Test
public void insert() {
Session session = HibernateUtils.openSession();
Transaction transaction = session.beginTransaction();
// 1> 获得需要新增角色的用户
User user = session.get(User.class, 1l);
// 2> 创建新的角色
Role role = new Role();
role.setRole_name("端茶倒水");
// 3> 将角色添加到用户中
user.getRoles().add(role);
transaction.commit();
session.close();
}
注意：在开发中不用级联的方式，即使用也只用save-update属性，因为delete属性在多对多的情况下非常危险。