Hibernate 多对多关联Demo

  1 package cn.test.test;
  2 
  3 import java.util.HashSet;
  4 import java.util.Set;
  5 
  6 import org.hibernate.Session;
  7 import org.hibernate.SessionFactory;
  8 import org.hibernate.Transaction;
  9 import org.hibernate.cfg.Configuration;
 10 import org.junit.Test;
 11 
 12 public class DoTest {
 13     private static SessionFactory sessionFactory;
 14     static{
 15         Configuration configuration=new Configuration();
 16         configuration.configure();
 17         sessionFactory=configuration.buildSessionFactory();
 18     }
 19     
 20     /**
 21      * 1、保存课程
 22      * 2、保存学生
 23      * 3、保存课程的时候同时保存学生
 24      * 4、保存课程的时候同时保存学生，并且建立课程和学生之间的关系
 25      * 5、已经存在一个课程，新建一个学生，并且建立该学生和该课程之间的关系
 26      * 6、已经存在一个学生，新建一个课程，并且建立该学生和该课程之间的关系
 27      * 7、已经存在一个学生，已经存在一个课程，解除该学生和原来课程之间的关系，建立该学生和新课程之间的关系
 28      * 8、已经存在一个学生，解除该学生和该学生的所有的课程之间的关系
 29      * 9、解除该课程和所有的学生之间的关系，再重新建立该课程和一些新的学员之间的关系
 30      * 10、解除该课程和所有的学生之间的关系
 31      * 11、删除课程
 32      *      *
 33      *          *  解除该班级和所有的学生之间的关系
 34      *          *  删除该班级
 35      *      *   
 36      *          删除班级的同时删除学生
 37      * 12、删除学生
 38      *      同删除班级
 39      *
 40      */
 41     
 42     
 43     //1、保存课程
 44     @Test
 45     public void testSaveCourse(){
 46         Session session =sessionFactory.openSession();
 47         Transaction transaction=session.beginTransaction();
 48         
 49         Course course=new Course();
 50         course.setCname("java基础");
 51         course.setCdesc("21天精通java基础");
 52         session.save(course);
 53         
 54         transaction.commit();
 55         session.close();
 56     }
 57     
 58     //2、保存学生
 59     @Test
 60     public void testSaveStudent(){
 61         Session session=sessionFactory.openSession();
 62         Transaction transaction=session.beginTransaction();
 63         
 64         Student student=new Student();
 65         student.setSname("张三");
 66         student.setSdesc("张四他哥，就是这么的霸气");
 67         session.save(student);
 68         
 69         transaction.commit();
 70         session.close();
 71     }
 72     
 73     //3、保存课程的时候同时保存学生
 74     @Test
 75     public void testSaveCourse_Student(){
 76         Session session =sessionFactory.openSession();
 77         Transaction transaction=session.beginTransaction();
 78         
 79         Course course=new Course();
 80         course.setCname("Net 基础");
 81         course.setCdesc("学习完java就要学习net");
 82         
 83         Student student=new Student();
 84         student.setSname("张大全");
 85         student.setSdesc("编程语言都要学会");
 86         Set<Student> set=  new HashSet<Student>();
 87         set.add(student);
 88         course.setStudents(set);
 89         
 90         session.save(course);
 91         
 92         transaction.commit();
 93         session.close();
 94     }
 95     
 96     //4、保存课程的时候同时保存学生，并且建立课程和学生之间的关系
 97     @Test
 98     public void testSaveStudent_Course(){
 99         Session session =sessionFactory.openSession();
100         Transaction transaction=session.beginTransaction();
101         
102         Course course=new Course();
103         course.setCname("Net2 基础");
104         course.setCdesc("学习完java就要学习net2");
105         Set<Course> set=new HashSet<Course>();
106         set.add(course);
107         
108         Student student=new Student();
109         student.setSname("张大全2");
110         student.setSdesc("编程语言都要学会2");
111         student.setCourses(set);
112         
113         session.save(student);
114         
115         transaction.commit();
116         session.close();
117     }
118     
119     //5、已经存在一个课程，新建一个学生，并且建立该学生和该课程之间的关系
120     @Test
121     public void testSaveCourse_R_Student(){
122         Session session=sessionFactory.openSession();
123         Transaction transaction= session.beginTransaction();
124         
125         Course course=(Course) session.get(Course.class, 1L);
126         
127         Student student=new Student();
128         student.setSname("fds");
129         student.setSdesc("1234567890-=");
130         
131         Set<Course> set =new HashSet<Course>();
132         set.add(course);
133         
134         
135         student.setCourses(set);
136         
137         session.save(student);
138         
139         transaction.commit();
140         session.close();
141     }
142     
143     //6、已经存在一个学生，新建一个课程，并且建立该学生和该课程之间的关系
144     @Test
145     public void testSaveStudent_R_Course(){
146         Session session=sessionFactory.openSession();
147         Transaction transaction=session.beginTransaction();
148         
149         Student student=(Student) session.get(Student.class,13L);
150         
151         Course course=new Course();
152         course.setCname("C++ 大学教材");
153         course.setCdesc("dsajkdsfnsdahfsdjkabdklsatgf");
154         
155         student.getCourses().add(course);
156         
157         session.save(student);
158         
159         transaction.commit();
160         session.close();
161     }
162     
163     //7、已经存在一个学生，已经存在一个课程，解除该学生和原来课程之间的关系，建立该学生和新课程之间的关系
164     @Test
165     public void testRelease_Rebuild(){
166         Session session=sessionFactory.openSession();
167         Transaction transaction=session.beginTransaction();
168         
169         Student student=(Student) session.get(Student.class, 13L);
170         Course course=(Course) session.get(Course.class, 2L);
171         
172         Set<Course> courses= student.getCourses();
173         for(Course c:courses){
174             if(c.getCid()==5){
175                 courses.remove(c);
176                 break;
177             }
178         }
179         
180         courses.add(course);
181         
182         transaction.commit();
183         session.close();
184     }
185     
186     //8、已经存在一个学生，已经存在多个课程，解除该学生和原来多个课程之间的关系，建立该学生和新的多个课程之间的关系
187     @Test
188     public void testRelaease_All(){
189         Session session=sessionFactory.openSession();
190         Transaction transaction=session.beginTransaction();
191         
192         Student student=(Student) session.get(Student.class, 13L);
193         Set<Course> courses=student.getCourses();
194         for(Course c:courses){
195             if(c.getCid()==1 || c.getCid()==2){
196                 courses.remove(c);
197                 break;///????不能同时删除两个，只能break，删除一个
198             }
199         }
200         
201         Course c4=(Course) session.get(Course.class, 4L);
202         Course c5=(Course) session.get(Course.class, 5L);
203         
204         courses.add(c4);
205         courses.add(c5);
206         
207         transaction.commit();
208         session.close();
209     }
210     //已经存在一个学生，解除该学生和该学生的所有的课程之间的关系
211     @Test
212     public void testR_All(){
213         Session session=sessionFactory.openSession();
214         Transaction transaction =session.beginTransaction();
215         
216         Student student=(Student) session.get(Student.class, 12L);
217         student.setCourses(null);
218         
219         transaction.commit();
220         session.close();
221     }
222     
223     //解除该课程和所有的学生之间的关系，再重新建立该课程和一些新的学员之间的关系
224     /*
225      * 说明：
226      *     *  必须由学生来维护关系
227      *     *  已经条件是课程
228      *         cid-->course-->set<student>-->遍历每一个student
229      *         -->从每一个student中得到所有的课程-->找到要移除的课程-->移除
230      * 
231      */
232     
233     @Test
234     public void testRemoveAll_Rebuild(){
235         Session session= sessionFactory.openSession();
236         Transaction transaction= session.beginTransaction();
237         
238         Course course=(Course) session.get(Course.class, 4L);//获取该课程        
239         Set<Student> students=course.getStudents();//获取该课程的学生
240         for(Student s:students){
241             Set<Course> courses=s.getCourses();//该学生所选取的所有课程
242             for(Course c:courses){
243                 if(c.getCid()==4){
244                     courses.remove(c);
245                     break;
246                 }
247             }
248         }
249         
250         Student s1=(Student) session.get(Student.class, 9L);
251         Student s2=(Student) session.get(Student.class, 10L);
252         s1.getCourses().add(course);
253         s2.getCourses().add(course);
254         
255         transaction.commit();
256         session.close();
257     }
258     
259     
260     
261 }