网上选课系统-Hibernate-注解实现 实体 关系映射

申明：以下内容仅个人观点，可能存在不足之处，多多指教！

在编写代码 之前需要分析 各个实体间的关系，最好能画出E-R图，分析如下：

该系统 包含 以下实体（仅包含最基本属性）：

• Admin（管理员）
  

       id (主键)  采用自增的方式。

       accont （账号）

       password （密码）

• Course（课程）
  

       id (主键/课程号)  并没有采用自增的方式，而是采用自定义方式，将 主键 与 课程号 合二为一。

       name（课程名）

       presentation（介绍）

       credit（学分）

• Teacher（教师）
  

       id (主键/教师工号)    并没有采用自增的方式，而是采用自定义方式，将 主键 与 教师工号 合二为一。  

       name (姓名)

• CourseTeacher（开课表）
  

       id (主键)  采用自增的方式。

       time (上课时间)

       address (上课地点)

• GradeClass（班级）
  

       id (主键)  采用自增的方式。

       name (名称) 

       num (班级人数) 

• Major（专业）
  

       id (主键/专业号)    并没有采用自增的方式，而是采用自定义方式，将 主键 与 专业号 合二为一。  

       name （专业名称）

• Student（学生）
  

       id (主键/学号)    并没有采用自增的方式，而是采用自定义方式，将 主键 与 学号 合二为一。  

       name （姓名）

       age（年龄）

       sex（性别）

• StudentCourse（选课表）

       id (主键)  采用自增方式。

       grade (分数)

实体 间 关系分析：

• Course——CourseTeacher——Teacher

       一门课程（Course）可以被多个教师（Teacher）讲授，同时一名教师（Teacher）可以讲授多门课程（Course），所以 二者关系为多对多，于是我们设计一张中间表 CourseTeacher（开课表），Course与CourseTeacher构成一对多的关系，Teacher与CourseTeacher构成一对多的关系，变向实现教师（Teacher）与开课表（CourseTeacher）多对多的关系。

• GradeClass——Student
  

      一个班级（GradeClass）里面包含多个学生（Student），但一个学生只能存在于一个班级，所以二者关系为一对多。

• Major——Student

      一个学生（Student）只能选择一个专业（Major），但一个专业可以被多个学生选择，所以二者关系为一对多。

• Student——StudentCourse——CourseTeacher
  

      一个学生（Course）可以选择多门课程（Course），一门课程可以被多名学生选择，构成了多对多的关系，但并非直接选择课程，而是通过开课表定向的选择课程，可以理解为学生（Course）与开课表（CourseTeacher）构成了多对多的关系，于是我们设计一张中间表 StudentCourse（选课表），Student与StudentCourse构成一对多的关系，Course与StudentCourse构成一对多的关系，变向实现学生（Course）与开课表（CourseTeacher）多对多的关系。

• Admin

      这里先不对Admin(管理员)进行关联关系处理，他只承担管理的作用！

关系 汇总：

•             Course — CourseTeacher   —>  一对多  
  
•            Teacher — CourseTeacher   —>  一对多  
  
•     GradeClass   — Student              —>  一对多  
  
•                Major— Student              —>  一对多  
  
•            Student — StudentCourse   —>  一对多  
  
• CourseTeacher — StudentCourse   —>  一对多  
  

画出E-R图( 用PowerDesigner16.5 创建)：

具体代码实现：

MasterId_Increment 类 （对主键自增进行了封装）：

package cn.yznu.CourseSelectionSystem.ServiceAction;

import javax.persistence.Column;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.MappedSuperclass;

@MappedSuperclass 
public class MasterId_Increment {
  @Id 
  @GeneratedValue(strategy = GenerationType.IDENTITY)
  @Column(unique = true, nullable = true)
  private Integer id;

  public Integer getId() {
    return id;
  }

  public void setId(Integer id) {
    this.id = id;
  }

  public MasterId_Increment(Integer id) {
    super();
    this.id = id;
  }

  public MasterId_Increment() {
    super();
  }

}

MasterId 类 （对 自定义主键 进行了封装）：

package cn.yznu.CourseSelectionSystem.ServiceAction;

import javax.persistence.Id;
import javax.persistence.MappedSuperclass;

@MappedSuperclass 
public class MasterId {
@Id 
private String id;

public String getId() {
  return id;
}

public void setId(String id) {
  this.id = id;
}

public MasterId(String id) {
  super();
  this.id = id;
}

public MasterId() {
  super();
}

}

Admin 类：

package cn.yznu.CourseSelectionSystem.entity;

import javax.persistence.Entity;
import javax.persistence.Table;

import cn.yznu.CourseSelectionSystem.ServiceAction.MasterId_Increment;

/**
 * 管理员
 * 
 * @author ZhouKaiDong
 *
 */
@Entity
@Table
public class Admin extends MasterId_Increment {
	private String accont;//账号
	private String password;//密码

	public String getAccont() {
		return accont;
	}

	public void setAccont(String accont) {
		this.accont = accont;
	}

	public String getPassword() {
		return password;
	}

	public void setPassword(String password) {
		this.password = password;
	}

	public Admin() {
		super();
	}

}

Course 类：

package cn.yznu.CourseSelectionSystem.entity;

import java.util.Set;

import javax.persistence.Entity;
import javax.persistence.JoinColumn;
import javax.persistence.JoinTable;
import javax.persistence.ManyToMany;
import javax.persistence.OneToMany;
import javax.persistence.Table;

import cn.yznu.CourseSelectionSystem.ServiceAction.MasterId;
/**
 * 课程
 * @author ZhouKaiDong
 *
 */
@Entity
@Table
public class Course extends MasterId {

  private String name;// 课程名
  private String presentation;// 介绍
  private Integer credit;// 学分

  @OneToMany(targetEntity = CourseTeacher.class, mappedBy = "course")
  private Set<CourseTeacher> courseTeachers;

  public Set<CourseTeacher> getCourseTeachers() {
    return courseTeachers;
  }

  public void setCourseTeachers(Set<CourseTeacher> courseTeachers) {
    this.courseTeachers = courseTeachers;
  }

  public String getName() {
    return name;
  }

  public void setName(String name) {
    this.name = name;
  }

  public String getPresentation() {
    return presentation;
  }

  public void setPresentation(String presentation) {
    this.presentation = presentation;
  }

  public Integer getCredit() {
    return credit;
  }

  public void setCredit(Integer credit) {
    this.credit = credit;
  }


  public Course(String id) {
    super(id);
  }

  public Course(String id, String name) {
    super(id);
    this.name = name;
  }

  public Course() {
    super();
  }

  public Course(String id, String name, String presentation, Integer credit) {
    super(id);
    this.name = name;
    this.presentation = presentation;
    this.credit = credit;
  }

}

Teacher 类：

package cn.yznu.CourseSelectionSystem.entity;

import java.util.Set;

import javax.persistence.Entity;
import javax.persistence.ManyToMany;
import javax.persistence.OneToMany;
import javax.persistence.Table;

import cn.yznu.CourseSelectionSystem.ServiceAction.MasterId;
/**
 * 教师
 * @author ZhouKaiDong
 *
 */
@Entity
@Table
public class Teacher extends MasterId {
private String name;//教师名字

@OneToMany(targetEntity = CourseTeacher.class, mappedBy = "teacher")
private Set<CourseTeacher> courseTeachers;

public Set<CourseTeacher> getCourseTeachers() {
  return courseTeachers;
}

public void setCourseTeachers(Set<CourseTeacher> courseTeachers) {
  this.courseTeachers = courseTeachers;
}

public String getName() {
  return name;
}

public void setName(String name) {
  this.name = name;
}

public Teacher(String id) {
  super(id);
}

public Teacher(String id, String name) {
  super(id);
  this.name = name;
}

public Teacher() {
  super();
}

}

CourseTeacher 类：

package cn.yznu.CourseSelectionSystem.entity;

import java.util.Set;

import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.OneToMany;
import javax.persistence.Table;

import cn.yznu.CourseSelectionSystem.ServiceAction.MasterId_Increment;
/**
 * 开课表
 * @author ZhouKaiDong
 *
 */
@Entity
@Table
public class CourseTeacher extends MasterId_Increment {
  
  private String time;//上课时间
  private String address;//上课地点
  
  @ManyToOne(fetch = FetchType.LAZY)
  @JoinColumn(name = "teacher_id")
  private Teacher teacher;

  @ManyToOne(fetch = FetchType.LAZY)
  @JoinColumn(name = "course_id")
  private Course course;
  
  @OneToMany(targetEntity = StudentCourse.class, mappedBy = "courseTeacher")
  private Set<StudentCourse> studentCourses;

  public String getTime() {
    return time;
  }

  public void setTime(String time) {
    this.time = time;
  }

  public Teacher getTeacher() {
    return teacher;
  }

  public void setTeacher(Teacher teacher) {
    this.teacher = teacher;
  }

  public Course getCourse() {
    return course;
  }

  public void setCourse(Course course) {
    this.course = course;
  }

  public CourseTeacher(Integer id, String time) {
    super(id);
    this.time = time;
  }

  public CourseTeacher() {
    super();
  }

  public Set<StudentCourse> getStudentCourses() {
    return studentCourses;
  }

  public void setStudentCourses(Set<StudentCourse> studentCourses) {
    this.studentCourses = studentCourses;
  }

  public CourseTeacher( String time) {
    super();
    this.time = time;
  }





 

}

Student 类：

package cn.yznu.CourseSelectionSystem.entity;

import java.util.Set;

import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.OneToMany;
import javax.persistence.Table;

import org.hibernate.annotations.LazyCollection;
import org.hibernate.annotations.LazyCollectionOption;

import cn.yznu.CourseSelectionSystem.ServiceAction.MasterId;
/**
 * 学生
 * @author ZhouKaiDong
 *
 */
@Entity
@Table
public class Student extends MasterId {

  private String name;//姓名
  private Integer age;//年龄
  private String sex;//性别
  
  @ManyToOne(fetch = FetchType.LAZY)
  // ManyToOne指定了多对一的关系，fetch=FetchType.LAZY属性表示在多的那一方通过延迟加载的方式加载对象(默认不是延迟加载)
  @JoinColumn(name = "Major_Id")
  private Major major;//专业
  
  @ManyToOne(fetch = FetchType.LAZY)
  // ManyToOne指定了多对一的关系，fetch=FetchType.LAZY属性表示在多的那一方通过延迟加载的方式加载对象(默认不是延迟加载)
  @JoinColumn(name = "GradeClass_id")
  // 通过 JoinColumn 的name属性指定了外键的名称 (注意：如果我们不通过JoinColum来指定外键的名称，系统会给我们声明一个名称)
  private GradeClass gradeClass;
  
  @OneToMany(targetEntity = StudentCourse.class, mappedBy = "student")
  // OneToMany指定了一对多的关系，mappedBy="gradeClass"指定了由多的那一方来维护关联关系，mappedBy指的是多的一方对1的这一方的依赖的属性，(注意：如果没有指定由谁来维护关联关系，则系统会给我们创建一张中间表)
  @LazyCollection(LazyCollectionOption.EXTRA)
  // LazyCollection属性设置成EXTRA指定了当如果查询数据的个数时候，只会发出一条 count(*)的语句，提高性能
  private Set<StudentCourse> studentCourses;

  public String getName() {
    return name;
  }

  public void setName(String name) {
    this.name = name;
  }

  public Integer getAge() {
    return age;
  }

  public void setAge(Integer age) {
    this.age = age;
  }

  public String getSex() {
    return sex;
  }

  public void setSex(String sex) {
    this.sex = sex;
  }



  public GradeClass getGradeClass() {
    return gradeClass;
  }

  public void setGradeClass(GradeClass gradeClass) {
    this.gradeClass = gradeClass;
  }

  public Set<StudentCourse> getStudentCourses() {
    return studentCourses;
  }

  public void setStudentCourses(Set<StudentCourse> studentCourses) {
    this.studentCourses = studentCourses;
  }

  public Student(String name, Integer age, GradeClass gradeClass) {
    super();
    this.name = name;
    this.age = age;
    this.gradeClass = gradeClass;
  }

  public Student(String id) {
    super(id);
  }

  public Student(String id, String name, Integer age, GradeClass gradeClass) {
    super(id);
    this.name = name;
    this.age = age;
    this.gradeClass = gradeClass;
  }

  public Student(String id, String name, Integer age) {
    super(id);
    this.name = name;
    this.age = age;
  }

  public Student() {
    super();
  }

  public Student(String id, String name, Integer age, String sex, Major major,
      GradeClass gradeClass, Set<StudentCourse> studentCourses) {
    super(id);
    this.name = name;
    this.age = age;
    this.sex = sex;
    this.major = major;
    this.gradeClass = gradeClass;
    this.studentCourses = studentCourses;
  }

  public Student(String id, String name, Integer age, String sex, Major major) {
    super(id);
    this.name = name;
    this.age = age;
    this.sex = sex;
    this.major = major;
  }

  public Student(String id, String name, Integer age, String sex) {
    super(id);
    this.name = name;
    this.age = age;
    this.sex = sex;
  }

  public Major getMajor() {
    return major;
  }

  public void setMajor(Major major) {
    this.major = major;
  }



}

Major 类：

package cn.yznu.CourseSelectionSystem.entity;

import java.util.Set;

import javax.persistence.Entity;
import javax.persistence.OneToMany;
import javax.persistence.Table;

import org.hibernate.annotations.LazyCollection;
import org.hibernate.annotations.LazyCollectionOption;

import cn.yznu.CourseSelectionSystem.ServiceAction.MasterId;
/**
 * 专业
 * @author ZhouKaiDong
 *
 */
@Entity
@Table
public class Major extends MasterId {

  private String name;
  @OneToMany(targetEntity = Student.class, mappedBy = "major")
  // mappedBy="major"指定了由多的那一方来维护关联关系，mappedBy指的是多的一方对1的这一方的依赖的属性，(注意：如果没有指定由谁来维护关联关系，则系统会给我们创建一张中间表)
  @LazyCollection(LazyCollectionOption.EXTRA)
  // LazyCollection属性设置成EXTRA，提高查询性能
  private Set<Student> students;



  public String getName() {
    return name;
  }

  public void setName(String name) {
    this.name = name;
  }

  public Set<Student> getStudents() {
    return students;
  }

  public void setStudents(Set<Student> students) {
    this.students = students;
  }



  public Major(String id, String name) {
    super(id);
    this.name = name;
  }

  public Major() {
    super();
  }

  public Major(String id) {
    super(id);
  }


}

GradeClass 类：

package cn.yznu.CourseSelectionSystem.entity;

import java.util.Set;

import javax.persistence.Entity;
import javax.persistence.OneToMany;
import javax.persistence.Table;

import org.hibernate.annotations.LazyCollection;
import org.hibernate.annotations.LazyCollectionOption;

import cn.yznu.CourseSelectionSystem.ServiceAction.MasterId;
/**
 * 班级
 * @author ZhouKaiDong
 *
 */
@Entity
@Table
public class GradeClass extends MasterId {

  private String name;//名称
  private Integer num;//最多人数
  @OneToMany(targetEntity = Student.class, mappedBy = "gradeClass")
  //mappedBy="gradeClass"指定了由多的那一方来维护关联关系，mappedBy指的是多的一方对1的这一方的依赖的属性，
  @LazyCollection(LazyCollectionOption.EXTRA)
  // LazyCollection属性设置成EXTRA，提高查询性能
  private Set<Student> students;

  public Set<Student> getStudents() {
    return students;
  }

  public void setStudents(Set<Student> students) {
    this.students = students;
  }

  public String getName() {
    return name;
  }

  public void setName(String name) {
    this.name = name;
  }

  public Integer getNum() {
    return num;
  }

  public void setNum(Integer num) {
    this.num = num;
  }

  public GradeClass(String id, String name, Set<Student> students) {
    super(id);
    this.name = name;
    this.students = students;
  }

  public GradeClass(String id) {
    super(id);
  }

  public GradeClass(String id, String name) {
    super(id);
    this.name = name;
  }

  public GradeClass() {
    super();
  }

  public GradeClass(String id, String name, Integer num, Set<Student> students) {
    super(id);
    this.name = name;
    this.num = num;
    this.students = students;
  }

  public GradeClass(String id, String name, Integer num) {
    super(id);
    this.name = name;
    this.num = num;
  }

}

StudentCourse 类：

package cn.yznu.CourseSelectionSystem.entity;

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.ManyToOne;
import javax.persistence.OneToOne;
import javax.persistence.Table;

import cn.yznu.CourseSelectionSystem.ServiceAction.MasterId;
import cn.yznu.CourseSelectionSystem.ServiceAction.MasterId_Increment;

/**
 * 选课表
 * @author ZhouKaiDong
 *
 */
@Entity
@Table
public class StudentCourse extends MasterId_Increment {
  
  private String grade;
 
  @ManyToOne(fetch = FetchType.LAZY)
  // ManyToOne指定了多对一的关系，fetch=FetchType.LAZY属性表示在多的那一方通过延迟加载的方式加载对象(默认不是延迟加载)
  @JoinColumn(name = "student_id")
  // 通过 JoinColumn 的name属性指定了外键的名称  (注意：如果我们不通过JoinColum来指定外键的名称，系统会给我们声明一个名称)
  private Student student;

  @ManyToOne(fetch = FetchType.LAZY)
  // ManyToOne指定了多对一的关系，fetch=FetchType.LAZY属性表示在多的那一方通过延迟加载的方式加载对象(默认不是延迟加载)
  @JoinColumn(name = "courseTeacher_id")
  // 通过 JoinColumn 的name属性指定了外键的名称  (注意：如果我们不通过JoinColum来指定外键的名称，系统会给我们声明一个名称)
  private CourseTeacher courseTeacher;

  public String getGrade() {
    return grade;
  }

  public void setGrade(String grade) {
    this.grade = grade;
  }

  public Student getStudent() {
    return student;
  }

  public void setStudent(Student student) {
    this.student = student;
  }
  public StudentCourse(String grade) {
    super();
    this.grade = grade;
  }

  public CourseTeacher getCourseTeacher() {
    return courseTeacher;
  }

  public void setCourseTeacher(CourseTeacher courseTeacher) {
    this.courseTeacher = courseTeacher;
  }

  public StudentCourse() {
    super();
  }


}