hibernate注解简单应用-优快云博客

本文链接：https://blog.youkuaiyun.com/qfnu_cjt_wl/article/details/26397345

本文介绍了一个使用Hibernate框架实现的学生、教师、课程及身份证信息的多表关联映射案例，详细展示了多对多、一对多及一对一关系的具体实现方式。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

hiberante.cfg.xml 配置文件

<!DOCTYPE hibernate-configuration PUBLIC
	"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
	"http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">

<hibernate-configuration>
	<session-factory>
		<property name="hibernate.connection.driver_class">oracle.jdbc.driver.OracleDriver</property>  
        <property name="hibernate.connection.url">jdbc:oracle:thin:@localhost:1521:orcl</property>  
        <property name="hibernate.connection.username">scott</property>  
        <property name="hibernate.connection.password">orcl</property>  
        <property name="hibernate.dialect">org.hibernate.dialect.Oracle10gDialect</property>  
        <property name="hibernate.show_sql">true</property> 
        <property name="hibernate.hbm2ddl.auto">update</property>  
        <property name="hibernate.jdbc.batch_size">20</property>
	<property name="hibernate.cache.use_second_level_cache">false</property>
	<property name="hibernate.temp.use_jdbc_metadata_defaults">false</property>
       
        
       <!--  <mapping resource="cn/edu/qfnu/pojos/User.hbm.xml"/>
        <mapping resource="cn/edu/qfnu/pojos/District.hbm.xml"/>
        <mapping resource="cn/edu/qfnu/pojos/Street.hbm.xml"/> -->
        
        <mapping class="cn.edu.qfnu.pojos.Student"/><!-- 注意这里是class，不是resource -->
        <mapping class="cn.edu.qfnu.pojos.Teacher"/>
        <mapping class="cn.edu.qfnu.pojos.Course"/>
        <mapping class="cn.edu.qfnu.pojos.IDCard"/>
		
	</session-factory>
</hibernate-configuration>

hibernateUtils工具类

package cn.edu.qfnu.utils;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import org.hibernate.service.ServiceRegistry;
import org.hibernate.service.ServiceRegistryBuilder;

public class HibernateUtils {
	private static String CONFIG_FILE_LOCATION = "/hibernate.cfg.xml";
	private static final ThreadLocal<Session> threadLocal = 
						new ThreadLocal<Session>();
	private static Configuration configuration = new Configuration();
	private static SessionFactory sessionFactory;
	private static ServiceRegistry serviceRegistry;
	private static String configFile = CONFIG_FILE_LOCATION;
	
	/*静态代码块创建SessionFactory*/  
	static{
		try {

			configuration.configure();
			/*hibernate4.2.4废弃了直接使用buuldSessionFactory()的方法，使用了ServiceRigistry对象*/  
			serviceRegistry = new ServiceRegistryBuilder()
					.applySettings(configuration.getProperties())
					.buildServiceRegistry();
			sessionFactory = configuration
					.buildSessionFactory(serviceRegistry);

		} catch (Exception e) {
			System.err.println("%%%% Error Creating SessionFactory1%%%%");
			e.printStackTrace();
		}	
	}
	
	private HibernateUtils(){
		
	}
	
	/**
	 * 返回ThreadLocal中的session实例  
	 */
	public static Session getSession(){
		Session session = (Session)threadLocal.get();
		if(session==null || !session.isOpen()){
			if(sessionFactory == null){
				rebuildSessionFactory();
			}
			session = (sessionFactory!=null)? sessionFactory.openSession() : null;
			threadLocal.set(session);
		}
		return session;
	}
	
	/*返回Hibernate的SessionFactory*/
	public static void rebuildSessionFactory() {
		try {

			configuration.configure(configFile);
			serviceRegistry = new ServiceRegistryBuilder()
					.applySettings(configuration.getProperties())
					.buildServiceRegistry();
			sessionFactory = configuration
					.buildSessionFactory(serviceRegistry);
		} catch (Exception e) {
			System.err.println("%%%%Error Creating SessionFactoty2 %%%%");
		}
	}
	
	/*关闭Session实例并且把ThreadLocal中的副本清除*/
	public static void closeSession(){
		Session session = (Session) threadLocal.get();
		threadLocal.set(null);
		if(session!=null){
			session.close();
		}
	}
	
	/*返回SessionFactory*/
	public static SessionFactory getSessionFactory(){
		return sessionFactory;
	}

	public static Configuration getConfiguration() {
		return configuration;
	}

	public static void setConfigFile(String configFile) {
		HibernateUtils.configFile = configFile;
	}
	
	
}

创建的类有：student，teacher，course，idcard。

student 和 course 是多对多的关系，student 和 teacher 是多对一的关系， teacher 和 course 是多对多的关系， student 和 idcard 一对一关系。

student类

package cn.edu.qfnu.pojos;

import java.io.Serializable;
import java.util.HashSet;
import java.util.Set;

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

@Entity
@Table(name="students")
public class Student implements Serializable{
	private Integer id;
	private String name;
	private Teacher teacher;//假设一个学生只面对一位老师many-to-one
	private IDCard idcard;//一个学生对应一个省份证号，one-to-one
	private Set<Course> courses = new HashSet<Course>();//一个学生可以学多门课，一门课对应多个学生，many-to-many
	
	@Id
	@SequenceGenerator(name="studentseq", sequenceName="STUDENT_SEQ",allocationSize=1)
	@GeneratedValue(strategy = GenerationType.SEQUENCE,generator="studentseq")
	public Integer getId() {
		return id;
	}
	public void setId(Integer id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	
	@ManyToOne(fetch=FetchType.LAZY)
	@JoinColumn(name="teacher_id")
	public Teacher getTeacher() {
		return teacher;
	}
	public void setTeacher(Teacher teacher) {
		this.teacher = teacher;
	}
	
	@ManyToMany(mappedBy="students",cascade=CascadeType.ALL)
	public Set<Course> getCourses() {
		return courses;
	}
	public void setCourses(Set<Course> courses) {
		this.courses = courses;
	}
	
	@OneToOne(cascade=CascadeType.ALL)
	@JoinColumn(name="card_id")
	public IDCard getIdcard() {
		return idcard;
	}
	public void setIdcard(IDCard idcard) {
		this.idcard = idcard;
	}
}

teacher类：

package cn.edu.qfnu.pojos;

import java.io.Serializable;
import java.util.HashSet;
import java.util.Set;

import javax.persistence.CascadeType;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.ManyToMany;
import javax.persistence.OneToMany;
import javax.persistence.SequenceGenerator;
import javax.persistence.Table;

@Entity
@Table(name="teachers")
public class Teacher implements Serializable{
	private Integer id;
	private String name;
	private Set<Student> students = new HashSet<Student>();
	private Set<Course> courses = new HashSet<Course>();
	
	@Id
	@SequenceGenerator(name="teacherseq", sequenceName="TEACHER_SEQ", allocationSize=1)
	@GeneratedValue(strategy=GenerationType.SEQUENCE, generator="teacherseq")
	public Integer getId() {
		return id;
	}
	public void setId(Integer id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	
	@OneToMany(mappedBy="teacher",cascade=CascadeType.ALL)
	public Set<Student> getStudents() {
		return students;
	}
	public void setStudents(Set<Student> students) {
		this.students = students;
	}
	
	@ManyToMany(mappedBy="teachers")
	public Set<Course> getCourses() {
		return courses;
	}
	public void setCourses(Set<Course> courses) {
		this.courses = courses;
	}
	
	
}

course类：

package cn.edu.qfnu.pojos;

import java.io.Serializable;
import java.util.HashSet;
import java.util.Set;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.JoinTable;
import javax.persistence.ManyToMany;
import javax.persistence.SequenceGenerator;
import javax.persistence.Table;

@Entity
@Table(name = "courses")
public class Course implements Serializable{
	private Integer id;
	private String name;
	private Set<Student> students = new HashSet<Student>();// 一门课程有多名学生
	private Set<Teacher> teachers = new HashSet<Teacher>();// 一门课程有多位老师教授

	@Id
	@SequenceGenerator(name = "courseseq", sequenceName = "COURSE_SEQ", allocationSize=1)
	@GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "courseseq")
	public Integer getId() {
		return id;
	}

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

	public String getName() {
		return name;
	}

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

	@ManyToMany
	@JoinTable(name = "student_course", 
			joinColumns = { @JoinColumn(name = "course_id") }, 
			inverseJoinColumns = { @JoinColumn(name = "student_id") })
	public Set<Student> getStudents() {
		return students;
	}

	public void setStudents(Set<Student> students) {
		this.students = students;
	}
	
	@ManyToMany
	@JoinTable(name="course_teacher", 
			joinColumns={@JoinColumn(name="course_id")},
			inverseJoinColumns={@JoinColumn(name="teacher_id")})
	public Set<Teacher> getTeachers() {
		return teachers;
	}

	public void setTeachers(Set<Teacher> teachers) {
		this.teachers = teachers;
	}

}

idcard类：

package cn.edu.qfnu.pojos;

import java.io.Serializable;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.OneToOne;
import javax.persistence.SequenceGenerator;

@Entity
public class IDCard implements Serializable{
	private Integer id;
	private String cardNum;
	private Student student;
	
	@Id
	@SequenceGenerator(name="idcardseq", sequenceName="IDCARDSEQ", allocationSize=1)
	@GeneratedValue(strategy=GenerationType.SEQUENCE, generator="idcardseq")
	public Integer getId() {
		return id;
	}
	public void setId(Integer id) {
		this.id = id;
	}
	public String getCardNum() {
		return cardNum;
	}
	public void setCardNum(String cardNum) {
		this.cardNum = cardNum;
	}
	
	@OneToOne(mappedBy="idcard")
	public Student getStudent() {
		return student;
	}
	public void setStudent(Student student) {
		this.student = student;
	}
	
}

小技巧:通过hibernate来进行插入操作的时候，不管是一对多、一对一还是多对多，都只需要记住一点，在哪个实体类声明了外键，就由哪个类来维护关系，在保存数据时，总是先保存的是没有维护关联关系的那一方的数据，后保存维护了关联关系的那一方的数据;