hibernate 双向多对多注解

最新推荐文章于 2019-03-16 08:38:01 发布

下雨天_____

最新推荐文章于 2019-03-16 08:38:01 发布

阅读量459

点赞数

分类专栏： java hibernate hibernate学习文章标签： hibernate 注解

本文链接：https://blog.csdn.net/loveyaqin1990/article/details/41249759

版权

java 同时被 3 个专栏收录

115 篇文章 0 订阅

订阅专栏

hibernate

11 篇文章 0 订阅

订阅专栏

hibernate学习

11 篇文章 1 订阅

订阅专栏

其实它的和一对多差不多，但是按照网上写法出现了一个问题，使得双向的关系变成了单向的。

Person类

[java]view plaincopy 
   
 package cn.lzg;  
   
 import java.util.ArrayList;  
 import java.util.List;  
   
 import javax.persistence.Column;  
 import javax.persistence.Entity;  
 import javax.persistence.FetchType;  
 import javax.persistence.GeneratedValue;  
 import javax.persistence.GenerationType;  
 import javax.persistence.Id;  
 import javax.persistence.JoinColumn;  
 import javax.persistence.JoinTable;  
 import javax.persistence.ManyToMany;  
 import javax.persistence.SequenceGenerator;  
 import javax.persistence.Table;  
   
 @Entity  
 @Table(name = "person_lzg")  
 public class Person {  
   
     @Id  
     @SequenceGenerator(name = "person_lzg", sequenceName = "p_seq", allocationSize = 1)  
     @GeneratedValue(generator = "person_lzg", strategy = GenerationType.SEQUENCE)  
     private Long p_id;  
   
     @Column(name = "name")  
     private String name;  
   
     @ManyToMany(targetEntity = cn.lzg.Book.class, fetch = FetchType.LAZY)  
     @JoinTable(name = "lzgp_lzgb", joinColumns = { @JoinColumn(name = "p_id") }, inverseJoinColumns = { @JoinColumn(name = "b_id") })  
     // name中间表的名字,第一个自己的主键，第二个关联的主键  
     private List<Book> books = new ArrayList<Book>();  
   
     public Long getP_id() {  
         return p_id;  
     }  
   
     public void setP_id(Long p_id) {  
         this.p_id = p_id;  
     }  
   
     public String getName() {  
         return name;  
     }  
   
     public void setName(String name) {  
         this.name = name;  
     }  
   
     public List<Book> getBooks() {  
         return books;  
     }  
   
     public void setBooks(List<Book> books) {  
         this.books = books;  
     }  
   
 }  

Book类

[java]view plaincopy 
   
 package cn.lzg;  
   
 import java.util.ArrayList;  
 import java.util.List;  
   
 import javax.persistence.Column;  
 import javax.persistence.Entity;  
 import javax.persistence.FetchType;  
 import javax.persistence.GeneratedValue;  
 import javax.persistence.GenerationType;  
 import javax.persistence.Id;  
 import javax.persistence.JoinColumn;  
 import javax.persistence.JoinTable;  
 import javax.persistence.ManyToMany;  
 import javax.persistence.SequenceGenerator;  
 import javax.persistence.Table;  
   
 @Entity  
 @Table(name = "book_lzg")  
 public class Book {  
     @Id  
     @SequenceGenerator(name = "book_lzg", sequenceName = "b_seq", allocationSize = 1)  
     @GeneratedValue(generator = "book_lzg", strategy = GenerationType.SEQUENCE)  
     private Long b_id;  
   
     @Column(name = "name")  
     private String name;  
   
     @ManyToMany(targetEntity = cn.lzg.Person.class, fetch = FetchType.LAZY)  
     <span style="color:#FF0000;">// 如果在上面使用mappedBy后,就成单向的了.也就是mappedBy出现的位置所在的类,这个类是被维护端,它只能被别人级联,不能去保存别人.  
     // 这个问题搞了好久才发现，开始一直是单向的.</span>  
     @JoinTable(name = "lzgp_lzgb", joinColumns = { @JoinColumn(name = "b_id") }, inverseJoinColumns = { @JoinColumn(name = "p_id") })  
     private List<Person> persons = new ArrayList<Person>();  
   
     public Long getB_id() {  
         return b_id;  
     }  
   
     public void setB_id(Long b_id) {  
         this.b_id = b_id;  
     }  
   
     public String getName() {  
         return name;  
     }  
   
     public void setName(String name) {  
         this.name = name;  
     }  
   
     public List<Person> getPersons() {  
         return persons;  
     }  
   
     public void setPersons(List<Person> persons) {  
         this.persons = persons;  
     }  
   
 }  

注意

[java]view plaincopy 
   
 <span style="color:#FF0000;">如果在上面ManyToMany注解中使用mappedBy,就成单向的了.因为mappedBy出现的位置所在的类,这个类是被维护端,它只能被别人级联,不能去保存别人  
   
 <span style="color:#330033;">测试类  
 </span></span><pre name="code" class="java">package cn.lzg;  
   
 import java.util.ArrayList;  
 import java.util.Date;  
 import java.util.List;  
   
 import org.hibernate.Session;  
 import org.hibernate.SessionFactory;  
 import org.hibernate.Transaction;  
 import org.hibernate.cfg.Configuration;  
 import org.hibernate.service.ServiceRegistry;  
 import org.hibernate.service.ServiceRegistryBuilder;  
 import org.junit.Test;  
   
 public class TestHibernate {  
     private static Configuration configuration = null;  
     private static SessionFactory sessionFactory = null;  
     private static ServiceRegistry serviceRegistry = null;  
     private static Session session = null;  
   
     static {  
         /** 
          * hibernate 4 貌失要这样获得sessionFactory 以前的configuration.buildSessionFactory();方法 过时了 
          */  
         configuration = new Configuration().configure();  
   
         serviceRegistry = new ServiceRegistryBuilder().applySettings(configuration.getProperties())  
                 .buildServiceRegistry();  
   
         sessionFactory = configuration.buildSessionFactory(serviceRegistry);  
         session = sessionFactory.openSession();  
     }  
   
   
   
     @Test  
     // 测试manytomany  
     public void testM2M() {  
         Person p1 = new Person();  
         p1.setName("张三");  
         Person p2 = new Person();  
         p2.setName("李四");  
         Person p3 = new Person();  
         p3.setName("王五");  
         List<Person> persons = new ArrayList<Person>();  
         persons.add(p1);  
         persons.add(p2);  
         persons.add(p3);  
   
         Book b1 = new Book();  
         b1.setName("书本1");  
         Book b2 = new Book();  
         b2.setName("书本2");  
         Book b3 = new Book();  
         b3.setName("书本3");  
         List<Book> books = new ArrayList<Book>();  
         books.add(b1);  
         books.add(b2);  
         books.add(b3);  
   
         p1.setBooks(books);  
         b3.setPersons(persons);  
   
         Transaction tx = session.beginTransaction();  
         session.save(p1);  
         session.save(p2);  
         session.save(p3);  
         session.save(b1);  
         session.save(b2);  
         session.save(b3);  
         tx.commit();  
         session.close();  
     }  
 }  

结果生成了中间表

[java]view plaincopy 
   
 lzgp_lzgb 里面的关系p1 有三本书， p1,p2,p3都有b3  

下雨天_____

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录

hibernate 双向多对多 注解

hibernate 双向多对多注解