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. codeforces 1204C Anna, Svyatoslav and Maps(floyd+dp)

    题目链接:http://codeforces.com/problemset/problem/1204/C 给定一组序列,P1,P2,P3...Pm,这是一组合法路径的序列,即任意的Pi和Pi+1之间有 ...

  2. Mysql SQL CAST()函数

    (1).CAST()函数的参数是一个表达式,它包括用AS关键字分隔的源值和目标数据类型.以下例子用于将文本字符串'12'转换为整型: SELECT CAST('12' AS int) (2).返回值是 ...

  3. VS2015打开失败

    在使用VS2015过程中之前能打开的.Net项目,结果突然就不能使用了.我就不能理解了,后来找了一个方法,抱着试试的心态结果就成功了. 解决办法 第一步: 开始-->所有程序-->Micr ...

  4. jsoup学习待续

    1.Jsoup简介 Jsoup是一个java html解析器.它是一个用于解析HTML文档的java库.Jsoup提供api来从URL或HTML文件中提取和操作数据.它使用DOM,CSS和类似 Jqu ...

  5. AcWing 847. 图中点的层次

    队列 #include <cstdio> #include <cstring> #include <iostream> #include <algorithm ...

  6. C9300升级-TFTP

    1.操作命令:CAT9300(config)#ip tftp blocksize 8192CAT9300(config)#install add file tftp://10.1.100.37/cat ...

  7. queue的使用-Hdu 1702

    ACboy needs your help again! Time Limit: 1000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K ( ...

  8. Spring5 of WebClient(转载)

    前言 Spring5带来了新的响应式web开发框架WebFlux,同时,也引入了新的HttpClient框架WebClient.WebClient是Spring5中引入的执行 HTTP 请求的非阻塞. ...

  9. mac停靠栏动画

    MAC停靠栏 <!DOCTYPE html> <html> <head> <meta charset="utf-8"> <ti ...

  10. 总结fiddler抓https包

    把fiddler工具>选项>https>勾选所有,点击actions,导出的证书导入到浏览器(打开右上角浏览器设置>选项>高级>证书>查看证书>证书机构 ...