hibernate学习之五

映射的关系
pojo类
   Persion
   private Long id;
   private String name;
   private Card card;
   Card类
   1:1-----(一对一的关联关系)
   两种（映射文件的配置）：
   主键映射------约束：card主键id参照persion的主键id
       主
<one-to-one name=" class=""/>
       从
       <key>
           <penerator class="foreign">//主键的生成的机制是与主方的主键一致
     <param name="property">persion</param>
  </generator>   
</key>
   <one-to-one name="persion" class="persion" constrained="true"/>
   //constrained="true"这个属性的含义：加这个属性是从表的id是参照主表的id
   //如果不配置这个属性，是从表的id之没有约束的，这样的话如果修改表中的id的时候会容易出错
   //当我们生成的从表的主键，是依赖于主表中的id。
   外键映射------约束：外键p_id:card主键的p_id参照persion主键的id。
   主
      <one-to-one name="" class="" property-ref="true"/>
      //property-ref="true"加这个属性是为了主表让自己的主键去匹配从表的外键。
   从
   <many-to-one class="" column="" unique="true"/>
   //1:1的比例在开发的过程中出现的比例比较少。
   1:m-----（一对多的关联关系）
   -------------------------------------------------------------------
   维护关系：------建议一般是通过从方来维护主方。
    
   主方维护从从方：------在<set cascade="save-update"></key>//cascade="save-update"设置级联
   //主表的数据的保存，从表的数据级联保存。
   //因为默认的inverse是一个false，双向维护关联关系。如果是双向的维护会有一次重复的更新。
   //inverse="true"是一个单向的维护的关系,单向的维护的关系，一般都要设置级联，不然会容易
   //报错（瞬时态的原因---表中找不到数据）。


   从方维护主方：-------在<many-to-one cascade="save-update"/>//cascade="save-update"设置级联。
   从表的保存，级联保存主表的数据。
   --------------------------------------------------------------------
   pojo
   Customer:
      private Long id;
      private String name;
      private Set<Order> orders=new HashSet<Order>();
   Order:
       private Long id;
       private Double total;
       priavte Customer customer;


      映射文件：----约束：外键c_id:c_id参照customer中的主键id。
      customer.hbm.xml:
       <set name="orders">
           <key column="外键"></key>//通过外键来找所有的订单（Order）
  <one-to-many class="Order'/>
       </set>
      order.hbm.xml：
      <many-to-one name="" class="" column="外键"/>//通过外键来找所有的Customer
      //主表中的外键与从表中的外键是一样的。
  
   hbm2ddl :update-----在配置文件中设置这个属性值。
一对多的关系中：------在<set></set>标签里面设置cescade(级联属性)属性和lazy(是否懒加载)属性
m:n-----（多对多的关联关系）----
（多对多的关系在一般的情况下是可以转换成两个一对多的关系的。）---在这里的体现：-----
  学生表对桥表的一对多的关系，课程表对桥表单的一对多的关系。
pojo类：
    Student：
    private Long id;
    private String name;
    private Integer age;
    Cource：
    private Long id;
    private String name;
    priavte Integer credit;//学分
    private Set<Student> students =new HashSet<Student>();

映射关系：
    student.hbm.xml:
    <set name="courses" table="">//这里把table给写上的话只建一个桥表
       <key column="s_id"></key>//就是当前表中的主键与桥表中的外键相对应。
       <many-to-many class="" column="s_id"/>//column设置课程表查学生表，那就是通过两个键的结合
    </set>
   course.hbm.xml:
   <set name="students" table="">
       <key column="c_id"></key>//就是当前表中的主键与桥表中的外键相对应。
       <many-to-many class="" column="c_id"/>//column设置学生表查课程表，那就是通过两个键的结合
    </set>


Test(测试类):
public class Test {
public static void main(String[] args) {
Session session=HibernateSessionFactory.getSession();
Transaction tran=session.beginTransaction();
//学生报名:
//Student stu=new Student(null, "fu", 21);//瞬态，在内存中的状态。
//session.save(stu);//从瞬态变为持久态。
//课程的录入：
/*Course course1=(Course) session.load(Course.class, 1L);
course1.setCredit(2);
Course course2=(Course) session.load(Course.class, 2L);
Course course3=(Course) session.load(Course.class, 3L);
Course course4=new Course(null, "SSH",4);*/
//session.save(course1);
/*
* 以后在save中的对象不能是持久态的对象。例如：这里的
* Course course1=(Course) session.load(Course.class, 1L)；
* 中的course1，就是一个持久态的对象.(它本来在数据表中就已经存在了)
* 所以再保存的时候会报一个持久态的保存的错误。
* 除非再保存之前先做一个更新的操作，这样的保存就不会报持久态的错误了
* 因为更新的操作----持久态变成瞬时态。
* 持久态：数据库里面有的数据，你是从数据库里面查出来的，它就是一个持久态的数据。
*/
//session.save(course2);
//session.save(course3);
//session.save(course4);

//学生选课：先登录，后选课。
String hql="from Student where name=?";
//登录
Student student=(Student) session.createQuery(hql)
.setString(0, "fu").uniqueResult();
/*//查询课程，选课
String hql2="from Course where name=?";
Course course=(Course) session.createQuery(hql2).setString(0, "C++").uniqueResult();

student.getCourses().add(course);//这里通过那个维护那个都是可以的。//拿出所有的Course在添加。
//student.getCourses()如果setCourses()将会覆盖前面的数据。
*/
//张三选的所有的课查询：-------写一条sql语句查询张三选的所有的课。
/*
* select stu.name,'选了',cou.name from tbl_student stu,
* tbl_course cou,tbl_student_course sc
*  where stu.id=sc.s_id and cou.id=sc.c_id and stu.name='fu';
*  
*/
//查询选课：---查询姓名为fu的学生选的所有的课的hibernate下的查询。
        Set<Course> courses=student.getCourses();
for(Course course:courses){
System.out.println(course.toString());
}
tran.commit();
}
}

桥表----tb1_stu_cou:
c_id:参照课程表中的id
s_id:参照学生表中的id
m:n的关系-----多对多的关系---也可以转换成两个一对多的关系。
例子：
pojo类：
student：
    private Long id;
    private String name;
    private Integer age;
    private Set<StuCou> stuCous=new HashSet<StuCou>();
course：
    private Long id;
    private String name;
    private Integer credit;//学分
    private Set<StuCou> stuCous=new HashSet<StuCou>();
stucou：
    private Long id;
    private String content;
    private Double score;
    private Student student;
    private Course course;


映射关系：-----
  student.hbm.xml
  <hibernate-mapping package="com.fjx.double_one2many">
<class name="Student" table="tbl_student">
<id name="id" column="id">
<generator class="increment" />
</id>
<property name="name" />
<property name="age" />
<!-- 关联映射 -->
<set name="stuCous">
 <key column="s_id"></key>
 <one-to-many class="StuCou"/>
</set>
</class>
</hibernate-mapping>


  course.hbm.xml
    <hibernate-mapping package="com.fjx.double_one2many">
<class name="Course" table="tbl_course">
<id name="id" column="id">
<generator class="increment" />
</id>
<property name="name" />
<property name="credit" />
<!-- 关联映射 -->
<set name="stuCous">
 <key column="c_id"></key>
 <one-to-many class="StuCou"/>
</set>
</class>
</hibernate-mapping>


  stuCou.hbm.xml
  <hibernate-mapping package="com.fjx.double_one2many">
<class name="StuCou" table="tbl_stuCou">
<id name="id" column="id">
<generator class="increment" />
</id>
<property name="content" />
<property name="score" />
<!-- 关联映射 -->
<many-to-one name="student" class="Student" column="s_id"></many-to-one>
<many-to-one name="course" class="Course" column="c_id"></many-to-one>
</class>
</hibernate-mapping>


Test(测试类):
public class Test {
/*
*这种关系推荐使用
*/
public static void main(String[] args) {
Session session = HibernateSessionFactory.getSession();
Transaction tran = session.beginTransaction();
// 学生报名
// Student stu1=new Student(null, "fu", 21);
// Student stu2=new Student(null, "ji", 20);
// session.save(stu1);
// session.save(stu2);


/*
* //添加课程 Course cou1=new Course(null, "JAVA", 2); Course cou2=new
* Course(null, "Android", 3); Course cou3=new Course(null, "C++", 4);
* 
* session.save(cou1); session.save(cou2); session.save(cou3);
*/



// 学生选课：先登录，后选课。
String hql = "from Student where name=?";
// 登录
Student student = (Student) session.createQuery(hql).setString(0, "fu").uniqueResult();
// 查询课程，选课
String hql2 = "from Course where name=?";
Course course = (Course) session.createQuery(hql2).setString(0, "JAVA").uniqueResult();
/*
* 选课的同时就给出了成绩。
* 该方式不推荐，应该限选课，后面再给成绩的。
 
StuCou sc=new StuCou(null, "不错", 80.0);
sc.setCourse(course);
sc.setStudent(student);
session.save(sc);*/
StuCou sc=new StuCou();//空参，后面给出成绩后再设，并更新，推荐使用。
sc.setCourse(course);
sc.setStudent(student);
session.save(sc);
/*
//查询选课，这里查询fu选的所有的课
String hql = "from Student where name=?";
Student student = (Student) session.createQuery(hql).setString(0, "fu").uniqueResult();
Set<StuCou> scs=student.getStuCous();
for(StuCou sc:scs){
System.out.println(sc.getCourse());
}
*/
tran.commit();
}
}


inherit//继承映射