HibernateManytoMany

public class HibernateManytoMany {

    //演示维护第三张表
@Test
public void testTable2() {
SessionFactory sessionFactory = null;
Session session = null;
Transaction tx = null;
try {
//得到sessionFactory
sessionFactory = HibernateUtils.getSessionFactory();
//得到session
session = sessionFactory.openSession();
//开启事务
tx = session.beginTransaction(); // 让某个用户没有有某个角色
User user = session.get(User.class, 2);
Role role = session.get(Role.class, 3); //2 从用户里面把角色去掉
user.getSetRole().remove(role); //提交事务
tx.commit(); } catch (Exception e) {
tx.rollback();
} finally {
session.close();
//sessionFactory不需要关闭
sessionFactory.close();
}
} //演示维护第三张表
@Test
public void testTable1() {
SessionFactory sessionFactory = null;
Session session = null;
Transaction tx = null;
try {
//得到sessionFactory
sessionFactory = HibernateUtils.getSessionFactory();
//得到session
session = sessionFactory.openSession();
//开启事务
tx = session.beginTransaction(); // 让某个用户有某个角色
//让lucy有经纪人角色
//1 查询lucy和经纪人
User lucy = session.get(User.class, 2);
Role role = session.get(Role.class, 5); //2 把角色放到用户的set集合里面
lucy.getSetRole().add(role); //提交事务
tx.commit(); } catch (Exception e) {
tx.rollback();
} finally {
session.close();
//sessionFactory不需要关闭
sessionFactory.close();
}
} //演示多对多修级联保存
@Test
public void testDelete() {
SessionFactory sessionFactory = null;
Session session = null;
Transaction tx = null;
try {
//得到sessionFactory
sessionFactory = HibernateUtils.getSessionFactory();
//得到session
session = sessionFactory.openSession();
//开启事务
tx = session.beginTransaction(); User user = session.get(User.class, 4);
session.delete(user);
//提交事务
tx.commit(); } catch (Exception e) {
tx.rollback();
} finally {
session.close();
//sessionFactory不需要关闭
sessionFactory.close();
}
} //演示多对多修级联保存
@Test
public void testSave() {
SessionFactory sessionFactory = null;
Session session = null;
Transaction tx = null;
try {
//得到sessionFactory
sessionFactory = HibernateUtils.getSessionFactory();
//得到session
session = sessionFactory.openSession();
//开启事务
tx = session.beginTransaction(); //添加两个用户,为每个用户添加两个角色
//1 创建对象
User user1 = new User();
user1.setUser_name("lucy");
user1.setUser_password("123"); User user2 = new User();
user2.setUser_name("mary");
user2.setUser_password("456"); Role r1 = new Role();
r1.setRole_name("总经理");
r1.setRole_memo("总经理"); Role r2 = new Role();
r2.setRole_name("秘书");
r2.setRole_memo("秘书"); Role r3 = new Role();
r3.setRole_name("保安");
r3.setRole_memo("保安"); //2 建立关系,把角色放到用户里面
// user1 -- r1/r2
user1.getSetRole().add(r1);
user1.getSetRole().add(r2); // user2 -- r2/r3
user2.getSetRole().add(r2);
user2.getSetRole().add(r3); //3 保存用户
session.save(user1);
session.save(user2); //提交事务
tx.commit(); } catch (Exception e) {
tx.rollback();
} finally {
session.close();
//sessionFactory不需要关闭
sessionFactory.close();
}
}
}

User

public class User {
private Integer user_id;//用户id
private String user_name;//用户名称
private String user_password;//用户密码 public Set<Role> getSetRole() {
return setRole;
} public void setSetRole(Set<Role> setRole) {
this.setRole = setRole;
} private Set<Role> setRole = new HashSet<>(); public Integer getUser_id() {
return user_id;
} public void setUser_id(Integer user_id) {
this.user_id = user_id;
} public String getUser_name() {
return user_name;
} public void setUser_name(String user_name) {
this.user_name = user_name;
} public String getUser_password() {
return user_password;
} public void setUser_password(String user_password) {
this.user_password = user_password;
}
}

User.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>
<class name="k.manytomany.User" table="t_user">
<id name="user_id" column="user_id">
<generator class="native"></generator>
</id>
<property name="user_name" column="user_name"></property>
<property name="user_password" column="user_password"></property>
<set name="setRole" table="user_role" cascade="save-update,delete">
<key column="userid"></key>
<many-to-many class="k.manytomany.Role" column="roleid"></many-to-many>
</set>
</class>
</hibernate-mapping>

Role

public class Role {
private Integer role_id;//角色id
private String role_name;//角色名称
private String role_memo;//角色描述
private Set<User> setUser = new HashSet<>(); public Set<User> getSetUser() {
return setUser;
} public void setSetUser(Set<User> setUser) {
this.setUser = setUser;
} public Integer getRole_id() {
return role_id;
} public void setRole_id(Integer role_id) {
this.role_id = role_id;
} public String getRole_name() {
return role_name;
} public void setRole_name(String role_name) {
this.role_name = role_name;
} public String getRole_memo() {
return role_memo;
} public void setRole_memo(String role_memo) {
this.role_memo = role_memo;
}
}

Role.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>
<class name="k.manytomany.Role" table="t_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>
<set name="setUser" table="user_role" >
<key column="roleid"></key>
<many-to-many class="k.manytomany.User" column="userid"></many-to-many>
</set>
</class>
</hibernate-mapping>

HibernateUtils

public class HibernateUtils {

    static Configuration cfg = null;
static SessionFactory sessionFactory = null;
//静态代码块实现
static {
//加载核心配置文件
cfg = new Configuration();
cfg.configure();
sessionFactory = cfg.buildSessionFactory();
} //提供返回与本地线程帮的session的方法
public static Session getSessionobject() {
return sessionFactory.getCurrentSession();
} //提供方法返回sessionFactory
public static SessionFactory getSessionFactory() {
return sessionFactory;
} public static void main(String[] args) { }
}

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>
<property name="hibernate.connection.url">jdbc:mysql:///hibernate_day01</property>
<property name="hibernate.connection.useUnicode">true</property>
<property name="hibernate.connection.characterEncoding">UTF-8</property>
<property name="hibernate.connection.username">root</property>
<property name="hibernate.connection.password">root3306</property> <!-- 第二部分: 配置hibernate信息 可选的-->
<!-- 输出底层sql语句 -->
<property name="hibernate.show_sql">true</property>
<!-- 输出底层sql语句格式 -->
<property name="hibernate.format_sql">true</property>
<!-- hibernate帮创建表,需要配置之后
update: 如果已经有表,更新,如果没有,创建
-->
<property name="hibernate.hbm2ddl.auto">update</property>
<!-- 配置数据库方言
在mysql里面实现分页 关键字 limit,只能使用mysql里面
在oracle数据库,实现分页rownum
让hibernate框架识别不同数据库的自己特有的语句
-->
<property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property> <!-- 第三部分: 把映射文件放到核心配置文件中 必须的-->
<!--<mapping resource="k/entity/User.hbm.xml"/>-->
<mapping resource="k/manytomany/User.xml"/>
<mapping resource="k/manytomany/Role.xml"/>
</session-factory>
</hibernate-configuration>

【Hibernate 多对多】的更多相关文章

  1. hibernate多对多关联映射

    关联是类(类的实例)之间的关系,表示有意义和值得关注的连接. 本系列将介绍Hibernate中主要的几种关联映射 Hibernate一对一主键单向关联Hibernate一对一主键双向关联Hiberna ...

  2. hibernate多对一双向关联

    关联是类(类的实例)之间的关系,表示有意义和值得关注的连接. 本系列将介绍Hibernate中主要的几种关联映射 Hibernate一对一主键单向关联Hibernate一对一主键双向关联Hiberna ...

  3. hibernate多对一单向关联

    关联是类(类的实例)之间的关系,表示有意义和值得关注的连接. 本系列将介绍Hibernate中主要的几种关联映射 Hibernate一对一主键单向关联Hibernate一对一主键双向关联Hiberna ...

  4. Hibernate多对多关系映射(建表)

    下边讲述Hibernate多对多关系映射. 多对多关系的表的结构为: 两个实体表,还包含一个关系表,关系表为复合主键,如果要使用Hibernate多对多关系映射,则关系表必须只包含两个字段,如果生成了 ...

  5. atitit.atitit.hb many2one relate hibernate 多对一关联配置..

    atitit.atitit.hb many2one relate hibernate 多对一关联配置.. 1. 多对一单向 @ManyToOne 1 1. 其中@JoinColumn 注解 2 2.  ...

  6. hibernate 多对多

    HibernateHibernate多对多关联映射通常别拆分成两个多对一关联映射1. 下面的HostBean.UserBean.UserHostBean,UserHostBean是两个表之间的关联表, ...

  7. hibernate多对一单向外键

    hibernate多对一单向外键: 描述:

  8. Hibernate多对一ManytoOne

    ------------------------Hibernate多对一ManytoOne 要点: ManytoOne配置在多端 可以配置级联操作 @ManyToOne(cascade=Cascade ...

  9. hibernate 多对多一个对象出现多条记录问题

    hibernate 多对多时,当须要依据它关联的对象查找的时候,会出现一个对象有多条记录的问题 用 left join fetch 抓取查询的时候还是会出现这问题,是由于主表在关联表中有多条记录 用 ...

  10. Hibernate多对多操作

    ---------------------siwuxie095 Hibernate 多对多操作 以用户和角色为例 (一)多对多映射配置 第一步:创建两个实体类,用户和角色 第二步:让两个实体类之间互相 ...

随机推荐

  1. linux下删除空行的几种方法

    在查看linux下的配置文件时,为了便于一目了然的查看,经常会删除空行和#头的行.而linux在删除空行的方法很多,grep.sed.awk.tr等工具都能实现.现总结如下: 1.grep grep ...

  2. docker里面安装sqlserver2017

    首先要注意,docker一般不做数据持久化容器.如果非要安装可以参考微软官方教程: https://docs.microsoft.com/zh-cn/sql/linux/quickstart-inst ...

  3. XSS 2

    通过第一题之后继续进行第二题 我们会发现这个体会将内容放到<textarea></textarea>中然后我们刚才那段代码就失效了 因为这个代码可以将我们输入的内容转换成超文本 ...

  4. kill pkill

    首先说一下kill命令,它是通过pid(进程ID)来杀死进程,要得到某个进程的pid,我们可以使用ps(process status)命令,默认情况下,kill命令发送给进程的终止信号是15,但是有些 ...

  5. 多对多三种创建方式、forms组件、cookies与session

    多对多三种创建方式.forms组件.cookies与session 一.多对多三种创建方式 1.全自动 # 优势:不需要你手动创建第三张表 # 不足:由于第三张表不是你手动创建的,也就意味着第三张表字 ...

  6. Go_defer

    package main import "fmt" func main() { //外围函数 /* defer的词义:"延迟","推迟" 在 ...

  7. ftrace使用

    前段时间遇到个问题,有个后继音频数据处理线程调度不及时导致音频输出延迟,音视频不同步. 因此从系统上入手,采用ftrace进行debug,来看有哪些线程会去抢占音频数据处理线程. ftrace 提供了 ...

  8. 【ES6新增语法详述】

    目录 1. 变量的定义 let const 2. 模版字符串 3. 数据解构 4. 函数扩展 设置默认值 箭头函数 5. 类的定义 class 6. 对象的单体模式 "@ ES6新增了关于变 ...

  9. php 基础 字符型转换整形

    示例: 可以得出规律:以有效数字开头的,取有效数字.以非有效数字开头的都转换为0:

  10. 6_9 天平(UVa839)<二叉树的DFS>

    前一个ubiquous通信小工具,移动只是一个由弦和电线组成的结构五彩缤纷的东西.这种移动通常被发现悬挂在小婴儿的摇篮.图说明了一个简单的移动.它只是一个电线,悬挂的一个字符串,每一个对象的对象.它可 ...