Hibernate_多对多双向映射关系

多对多双向映射关系，比如一个医生可以为多个病人看病，一个病人也可以找不同的医生看病。在数据库中只要找到这个医生就可以找到他所看过的病人信息，相反，如果找到病人的信息也可以反过来找到为其看过病的医生信息。

多对多映射关系通常要通过中间表来建立联系,中间表中保存的是医生表和病人表的外键信息。

Doctor.java:

public class Doctor {
    private String id;
    private String name;
    private String subject;
    private Set<Patient> patients = new HashSet<Patient>();

    public Doctor() {
    }

    public Doctor(String id, String name, String subject, Set<Patient> patients) {
        super();
        this.id = id;
        this.name = name;
        this.subject = subject;
        this.patients = patients;
    }

    //getter,setter……
}

Patient.java:

public class Patient {
    private String id;
    private String name;
    private String caseForPatient;
    private Set<Doctor> doctors = new HashSet<Doctor>();

    public Patient() {
    }

    public Patient(String id, String name, String caseForPatient,
            Set<Doctor> doctors) {
        this.id = id;
        this.name = name;
        this.caseForPatient = caseForPatient;
        this.doctors = doctors;
    }

    //getter,setter……
}

配置文件:

Doctor.hbm.xml:

<hibernate-mapping>
    <class name="com.sunflower.yuan.pojo.Doctor" table="doctor">
        <id name="id" type="string" column="id">
            <generator class="uuid"></generator>
        </id>

        <property name="name" type="string" column="name"></property>
        <property name="subject" type="string" column="subject"></property>

        <set name="patients" cascade="save-update" table="doctor_patient" inverse="true">
            <key column="doctor_id" not-null="true"></key>
            <many-to-many column="patient_id" class="com.sunflower.yuan.pojo.Patient"></many-to-many>
        </set>
        
    </class>
</hibernate-mapping>

Patient.hbm.xml:

<hibernate-mapping>
    <class name="com.sunflower.yuan.pojo.Patient" table="patient">
        <id name="id" type="string" column="id">
            <generator class="uuid"></generator>
        </id>

        <property name="name" type="string" column="name"></property>
        <property name="caseForPatient" type="string" column="caseFP"></property>

        <set name="doctors" cascade="save-update" table="doctor_patient" inverse="false">
            <key column="patient_id" not-null="true"></key>
            <many-to-many column="doctor_id" class="com.sunflower.yuan.pojo.Doctor"></many-to-many>
        </set>
        
    </class>
</hibernate-mapping>

Doctor.hbm.xml中的第１０行中inverse="true",Patient.hbm.xml中的第１０行inverse="false"，表明数据库的关系由Doctor来维护，如果都设为inverse="false"，那么会出现重复插入，系统报错。第１１行是中间表中对应于doctor表、patient表中的外键，用来联系两个表。

 

建表语句(SQL)：

alter table doctor_patient drop foreign key FK667B93E5BF142721
alter table doctor_patient drop foreign key FK667B93E5FB820CF3
drop table if exists doctor
drop table if exists doctor_patient
drop table if exists patient
create table doctor (id varchar(255) not null, name varchar(255), subject varchar(255), primary key (id))
create table doctor_patient (doctor_id varchar(255) not null, patient_id varchar(255) not null, primary key (patient_id, doctor_id))
create table patient (id varchar(255) not null, name varchar(255), caseFP varchar(255), primary key (id))
alter table doctor_patient add index FK667B93E5BF142721 (patient_id), add constraint FK667B93E5BF142721 foreign key (patient_id) references patient (id)
alter table doctor_patient add index FK667B93E5FB820CF3 (doctor_id), add constraint FK667B93E5FB820CF3 foreign key (doctor_id) references doctor (id)

 

测试：

Test.java:

public class Test {
    // 保存测试
    public void save() {
        Session session = HibernateUtil.getSession();
        Transaction ts = session.beginTransaction();

        try {
            Doctor doctor = new Doctor();
            doctor.setName("华佗");
            doctor.setSubject("骨科");

            Doctor doctor2 = new Doctor();
            doctor2.setName("扁鹊");
            doctor2.setSubject("外科");

            Patient patient = new Patient();
            patient.setName("曹操");
            patient.setCaseForPatient("头骨痛了三四年，剧烈");

            Patient patient2 = new Patient();
            patient2.setName("关羽");
            patient2.setCaseForPatient("肩膀中箭，有剧毒");

            doctor.getPatients().add(patient);
            doctor.getPatients().add(patient2);

            patient.getDoctors().add(doctor);
            patient2.getDoctors().add(doctor2);

            session.save(patient);
            session.save(patient2);

            ts.commit();
        }
        catch (Exception e) {
            e.printStackTrace();
            ts.rollback();
        }
        finally {
            HibernateUtil.closeSession(session);
        }
    }

    // 查询测试
    public void get() {
        Session session = HibernateUtil.getSession();
        Transaction ts = session.beginTransaction();

        try {
            Patient patient = (Patient) session.get(Patient.class,
                    "8a85f4eb395e288f01395e2890380002");
            System.out.println("Patient name:" + patient.getName());
            System.out.println("Patient's Doctor:"
                    + ((Doctor) patient.getDoctors().toArray()[0]).getName());
            ts.commit();
        }
        catch (Exception e) {
            e.printStackTrace();
            ts.rollback();
        }
        finally {
            HibernateUtil.closeSession(session);
        }
    }

    // HQL语句测试
    public void getHQL() {
        Session session = HibernateUtil.getSession();
        Transaction ts = session.beginTransaction();

        try {
            // Query query = session
            // .createQuery("select p.name,d.name from Patient as p,Doctor as d");
            // List list = query.list();
            // for (int i = 0; i < list.size(); i++) {
            // Object[] obj = (Object[]) list.get(i);
            // for (int j = 0; j < obj.length; j++) {
            // if (j + 1 == obj.length)
            // System.out.println(obj[j]);
            // else
            // System.out.print(obj[j] + ",");
            // }
            // }

            // Query query = session
            // .createQuery("select new list(p.name,d.name) from Patient as p,Doctor as d");
            // List list = query.list();
            // for (int i = 0; i < list.size(); i++) {
            // List list2 = (List) list.get(i);
            // for (int j = 0; j < list2.size(); j++) {
            // if (j + 1 == list2.size())
            // System.out.println(list2.get(j));
            // else
            // System.out.print(list2.get(j) + ",");
            // }
            // }

        }
        catch (Exception e) {
            e.printStackTrace();
            ts.rollback();
        }
        finally {
            HibernateUtil.closeSession(session);
        }
    }

    // 删除测试
    public void delete() {
        Session session = HibernateUtil.getSession();
        Transaction ts = session.beginTransaction();

        try {
            Patient patient = new Patient();
            patient.setId("8a85f4eb395e288f01395e2890380003");

            session.delete(patient);
            ts.commit();
        }
        catch (Exception e) {
            e.printStackTrace();
            ts.rollback();
        }
        finally {
            HibernateUtil.closeSession(session);
        }
    }

    public static void main(String[] args) {
        Test test = new Test();
        // test.save();
        // test.get();
        // test.delete();
        test.getHQL();
    }
}

第７２至８３行中，将两个不同表中的两个字段查询出来，这里的List list = query.list()返回的多行数据的集合，而每一行数据都是一个Object[]类型数据,参考文档说明如下：

所以要进行转换：Object[] obj = (Object[]) list.get(i);

HQL语句中也可以对查询出来的每行语句进行封装，例如第８５至８６行中Query query = session

.createQuery("select new list(p.name,d.name) from Patient as p,Doctor as d");将每行信息封装成List对象，也可以封装在自定义对象中，不过这个自定义对象要有包含所查询属性的构造函数，并且顺序一致。

 

详细的HQL语句，请查看HQL语句大全一文。