双向多对多非注解方式

需求：一个学生可以对应多个老师，一个老师可以对应多个学生

具体实现

1. 建模

Teacher类

package com.model;

import java.io.Serializable;

import java.util.HashSet;

import java.util.Set;

public class Teacher implements Serializable{

privateint tid;

privateString tname;

private Set<Stud> st=new HashSet<Stud>();

publicint getTid() {

returntid;

}

publicvoid setTid(int tid) {

this.tid= tid;

}

publicString getTname() {

returntname;

}

publicvoid setTname(String tname) {

this.tname= tname;

}

publicSet<Stud> getSt() {

returnst;

}

publicvoid setSt(Set<Stud> st) {

this.st= st;

}

Stud类

package com.model;

import java.io.Serializable;

import java.util.HashSet;

import java.util.Set;

public class Stud implements Serializable {

privateint id;

privateString sname;

privateint age;

privateString sex;

privateString address;

private Groupp group;

private Set<Teacher> teacher=new HashSet<Teacher>();

publicGroupp getGroup() {

returngroup;

}

publicvoid setGroup(Groupp group) {

this.group= group;

}

publicint getAge() {

returnage;

}

publicvoid setAge(int age) {

this.age= age;

}

publicString getSex() {

returnsex;

}

publicvoid setSex(String sex) {

this.sex= sex;

}

publicString getAddress() {

returnaddress;

}

publicvoid setAddress(String address) {

this.address= address;

}

publicint getId() {

returnid;

}

publicvoid setId(int id) {

this.id= id;

}

publicString getSname() {

returnsname;

}

publicvoid setSname(String sname) {

this.sname= sname;

}

publicSet<Teacher> getTeacher() {

returnteacher;

}

publicvoid setTeacher(Set<Teacher> teacher) {

this.teacher= teacher;

}

2.实体映射关系

Stud.hbm.xml文件

<?xml version="1.0"encoding="UTF-8"?>

<!DOCTYPE hibernate-mappingPUBLIC "-//Hibernate/HibernateMapping DTD 3.0//EN"

"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<hibernate-mapping>

</id>

<!—set的属性是stud类中teacher类的属性，key是stud类中的主键列名-->

<many-to-many class="com.model.Teacher"/>

</set>

</class>

</hibernate-mapping>

teacher.hbm.xml文件

<?xml version="1.0"encoding="UTF-8"?>

<!DOCTYPE hibernate-mappingPUBLIC "-//Hibernate/HibernateMapping DTD 3.0//EN"

"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<hibernate-mapping>

</id>

<many-to-many class="com.model.Stud"/>

</set>

</class>

</hibernate-mapping>

3.配置hibernate的配置文件

<?xml version="1.0"encoding="UTF-8"?>

<!DOCTYPE hibernate-configuration PUBLIC

"-//Hibernate/HibernateConfiguration DTD 3.0//EN"

"http://hibernate.sourceforge.net/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://127.0.0.1:3306/hiber?useUnicode=true&characterEncoding=UTF-8</property>

<property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>

<property name="hbm2ddl.auto">update</property>

</session-factory>

</hibernate-configuration>

4.测试类

package com.Test;

import org.hibernate.Session;

import org.hibernate.Transaction;

import com.db.util.HiberDBUtil;

import com.model.Groupp;

import com.model.Stud;

import com.model.Teacher;

public class TestSive {

publicstatic void main(String[] args) {

Session session=HiberDBUtil.getSession();

Teachertea1=new Teacher();

tea1.setTname("TA");

Teachertea2=new Teacher();

tea2.setTname("wo");

Studstud1=new Stud();

stud1.setAge(21);

stud1.setAddress("guangzhou");

stud1.setSex("女");

stud1.setSname("student1");

Studstud2=new Stud();

stud2.setAge(20);

stud2.setAddress("guangzhou");

stud2.setSex("男");

stud2.setSname("student2");

//建立关系

tea1.getSt().add(stud1);

tea1.getSt().add(stud2);

tea2.getSt().add(stud2);

stud1.getTeacher().add(tea1);

stud1.getTeacher().add(tea2);

stud2.getTeacher().add(tea2);

Transactiontr = session.beginTransaction();

try {

session.save(tea1);

session.save(tea2);

session.save(stud1);

session.save(stud2);

tr.commit();

} catch (Exception e) {

tr.rollback();

}finally{

HiberDBUtil.closeSession();

}

双向一对多非注解方式

需求：一个学生对应一个组，一个组对应多个学生

具体实现

1. 建模model

Stud类

packagecom.model;

importjava.io.Serializable;

importjava.util.HashSet;

importjava.util.Set;

publicclass Stud implements Serializable {

private int id;

private String sname;

private int age;

private String sex;

private String address;

private Groupp group;

public Groupp getGroup() {

return group;

}

public void setGroup(Groupp group) {

this.group = group;

}

public int getAge() {

return age;

}

public void setAge(int age) {

this.age = age;

}

public String getSex() {

return sex;

}

public void setSex(String sex) {

this.sex = sex;

}

public String getAddress() {

return address;

}

public void setAddress(String address) {

this.address = address;

}

public int getId() {

return id;

}

public void setId(int id) {

this.id = id;

}

public String getSname() {

return sname;

}

public void setSname(String sname) {

this.sname = sname;

}

Group类

package com.model;

import java.io.Serializable;

import java.util.HashSet;

import java.util.Set;

public class Groupp implements Serializable {

privateint groupId;

privateString groupName;

private Set<Stud>students=new HashSet<Stud>();

publicint getGroupId() {

returngroupId;

}

publicvoid setGroupId(int groupId) {

this.groupId= groupId;

}

publicString getGroupName() {

returngroupName;

}

publicvoid setGroupName(String groupName) {

this.groupName= groupName;

}

publicSet<Stud> getStudents() {

returnstudents;

}

publicvoid setStudents(Set<Stud> students) {

this.students= students;

}

配置实体映射关系

Stud.hbm.xml文件

<?xml version="1.0"encoding="UTF-8"?>

<!DOCTYPE hibernate-mappingPUBLIC "-//Hibernate/HibernateMapping DTD 3.0//EN"

"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<hibernate-mapping>

</id>

<!—many-to-one 的name属性是Stud类中的Group的属性，列值是Group类中的主键列名-->

<many-to-one name="group"column="groupId"></many-to-one>

</class>

</hibernate-mapping>

Group.hbm.xml文件

<?xml version="1.0"encoding="UTF-8"?>

<!DOCTYPE hibernate-mappingPUBLIC "-//Hibernate/HibernateMapping DTD 3.0//EN"

"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<hibernate-mapping>

</id>

<!—set的name属性是Group类中Student类的属性，key值是Group的主键的列名-->

<one-to-many class="com.model.Stud"/>

</set>

</class>

</hibernate-mapping>

2. 配置hibernate的文件

<?xml version="1.0"encoding="UTF-8"?>

<!DOCTYPE hibernate-configurationPUBLIC

"-//Hibernate/HibernateConfiguration DTD 3.0//EN"

"http://hibernate.sourceforge.net/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://127.0.0.1:3306/hiber?useUnicode=true&characterEncoding=UTF-8</property>

<property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>

<property name="hbm2ddl.auto">update</property>

</session-factory>

</hibernate-configuration>

测试类

package com.Test;

import org.hibernate.Session;

import org.hibernate.Transaction;

import com.db.util.HiberDBUtil;

import com.model.Groupp;

import com.model.Stud;

public class TestFive {

publicstatic void main(String[] args) {

Sessionsession=HiberDBUtil.getSession();

Grouppgroup=new Groupp();

group.setGroupName("mm");

Studstud1=new Stud();

stud1.setAge(21);

stud1.setAddress("guangzhou");

stud1.setSex("女");

stud1.setSname("haha");

Studstud2=new Stud();

stud2.setAge(20);

stud2.setAddress("guangzhou");

stud2.setSex("男");

stud2.setSname("kaka");

group.getStudents().add(stud1);

group.getStudents().add(stud2);

Transactiontr = session.beginTransaction();

try {

session.save(group);

tr.commit();

} catch (Exception e) {

tr.rollback();

}finally{

HiberDBUtil.closeSession();

}

hibernate之配置文件

双向多对多非注解方式

需求：一个学生可以对应多个老师，一个老师可以对应多个学生

具体实现

1. 建模

2.实体映射关系

3.配置hibernate的配置文件

4.测试类

双向一对多非注解方式

需求：一个学生对应一个组，一个组对应多个学生

具体实现

1. 建模model

配置实体映射关系

2. 配置hibernate的文件

测试类

猜你喜欢

hibernate之配置文件

双向多对多非注解方式

需求： 一个学生可以对应多个老师，一个老师可以对应多个学生

具体实现

1. 建模

2.实体映射关系

3.配置hibernate的配置文件

4.测试类

双向一对多非注解方式

需求：一个学生对应一个组，一个组对应多个学生

具体实现

1. 建模model

配置实体映射关系

2. 配置hibernate的文件

测试类

猜你喜欢

需求：一个学生可以对应多个老师，一个老师可以对应多个学生