实现Hibernate关联映射（富贵）

最新推荐文章于 2022-02-12 19:40:27 发布
最新推荐文章于 2022-02-12 19:40:27 发布
阅读量149 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44608611/article/details/102894400
版权

实现Hibernate关联映射

  1. 学生与身份证是一对一关联
  • IdCard.java
package com.ydy.entity;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.OneToOne;
import javax.persistence.Table;

import org.hibernate.annotations.GenericGenerator;
import org.hibernate.annotations.Parameter;

@Entity
@Table(name="card")
public class IdCard {
	@Id
	@GeneratedValue(generator="aa")
	@GenericGenerator(name="aa",strategy="foreign",
	parameters={@Parameter(name="property",value="person")})
		      
	private Integer id;
	private String cardNo;
	@OneToOne(mappedBy="card")
	private Student student;
	
	public Integer getId() {
		return id;
	}
	public void setId(Integer id) {
		this.id = id;
	}
	public String getCardNo() {
		return cardNo;
	}
	public void setCardNo(String cardNo) {
		this.cardNo = cardNo;
	}
	public Student getStudent() {
		return student;
	}
	public void setStudent(Student student) {
		this.student = student;
	}
	@Override
	public String toString() {
		return "IdCard [id=" + id + ", cardNo=" + cardNo + ", student=" + student + "]";
	}


}
  • Student.java
package com.ydy.entity;

import javax.persistence.CascadeType;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.OneToOne;
import javax.persistence.PrimaryKeyJoinColumn;
import javax.persistence.Table;

import com.ydy.entity.IdCard;

@Entity
@Table(name="student")
public class Student {
	@Id
	@GeneratedValue(strategy=GenerationType.IDENTITY)
	private Integer id;
	private String name;
	@OneToOne(cascade=CascadeType.ALL)
	@PrimaryKeyJoinColumn(name="id")
	private IdCard card;
	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;
	}
	public IdCard getCard() {
		return card;
	}
	public void setCard(IdCard card) {
		this.card = card;
	}
	@Override
	public String toString() {
		return "Student [id=" + id + ", name=" + name + ", card=" + card + "]";
	}


}
  • IdCard.hbm.xml
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<hibernate-mapping package="com.ydy.entity">
	<class name="IdCard" table="card" >
		<id name="id" column="id" >
			<generator class="foreign">
				<param name="property">student</param>
				
			</generator>
		</id>
		
	
		<property name="cardNo" column="cardNo" />
        <one-to-one name="student"  class="Student"  constrained="true"/>
		
	 
	</class>
</hibernate-mapping>
  • Student.hbm.xml
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<hibernate-mapping package="com.ydy.entity">
	<class name="Student" table="student_card" >
		<id name="id" column="id" >
			<generator class="native">
				
			</generator>
		</id>
		
	
		<property name="name" column="name" />
		<one-to-one name="card" cascade="all"></one-to-one>
      
		
	 
	</class>
</hibernate-mapping>
  • TestYdy.java
package com.ydy.ui;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;

import com.ydy.entity.IdCard;
import com.ydy.entity.Student;
import com.ydy.util.HibernateUtil;

public class TestYdy {
	/**
	 * 12.12 测试类(主键关联)--->主要测试程序功能实现情况
	 * 注意：<顺序>
	 * constrained="true"--->添加时先添加主表后添加从表，删除时反之。
	 */
	public TestYdy() {
		
	}

	public static void main(String[] args) {
//		  save();
		 update();
		// delete();
		
	}

	/*
	 * 
	 * 实现添加功能
	 */

	public static void save() {
		
		Configuration cfg=new Configuration().configure();
		SessionFactory factory=cfg.buildSessionFactory();
		Session session=factory.openSession();
		Transaction tran=session.beginTransaction();
		
		Student s=new Student();
		s.setName("张三");
		
		IdCard card=new IdCard();
		card.setCardNo("0001");
		
		card.setStudent(s);
		s.setCard(card);
		session.save(s);
		session.save(card);
		tran.commit();//提交
		session.close();
		factory.close();
		
		
	}

	/*
	 *   
	 * 实现删除功能
	 */
	 

	public static void delete() {
		Session session = null;
		Transaction tran = null;
		try {
			session = HibernateUtil.openSession();
			tran = session.beginTransaction();
			// ---------------------------------

			// 查找Person对象
			Student s = session.load(Student.class, 5);
			System.out.println(s.getCard().getCardNo());
			session.delete(s);
			

			// ---------------------------------
			tran.commit();
		} catch (Exception e) {
			e.printStackTrace();
			tran.rollback();
		} finally {
			if (null != session) {
				session.close();
			}
		}
	}

	 
	/*
	 * 实现修改功能
	 */
	 

	public static void update() {
		Session session = null;
		Transaction tran = null;
		try {
			session = HibernateUtil.openSession();
			tran = session.beginTransaction();
			// ---------------------------------

			// 查找Person对象
			Student s = session.load(Student.class, 1);
			s.setName("李四");//级联更新，在修改name的同时修改idcard；
			IdCard card=s.getCard();
			card.setCardNo("0002");
			s.setCard(card);
			session.update(s);
			// ---------------------------------
			tran.commit();
		} catch (Exception e) {
			e.printStackTrace();
			tran.rollback();
		} finally {
			if (null != session) {
				session.close();
			}
		}
	}


}
  • HibernateUtil.java
package com.ydy.util;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.boot.MetadataSources;
import org.hibernate.boot.registry.StandardServiceRegistry;
import org.hibernate.boot.registry.StandardServiceRegistryBuilder;

/**  
 * @Title:  HibernateUtil.java   
 * @Package com.ydy.util   
 * @Description:    描述   
 * @author: 太平洋醋王     
 * @date:   2019年11月4日 下午12:17:21   
 */

/**
 * 初始化Hibernate过程
 * Configuration、SessionFactory、Session对象
 */
public class HibernateUtil {
	public HibernateUtil() {
		// TODO Auto-generated constructor stub
	}
	
	   // SessionFactory实例（会话工厂）
    private static SessionFactory sessionFactory = null;
    //Configuration configuration = new Configuration();  
    
    /**
     * 静态初始化 Hibernate 
     */
    static {
        // 1 创建 StandardServiceRegistry 实例（标准注册服务）
        // 1.1 创建 StandardServiceRegistryBuilder 实例（标准注册服务生成器）
        // 1.2 从 hibernate.cfg.xml 配置文件中读取配置信息
        // 1.3 构建 StandardServiceRegistry实例（标准注册服务）
    	
        StandardServiceRegistry registry = new StandardServiceRegistryBuilder().configure().build();

        try {
            // 2 创建 SessionFactory 实例（会话工厂）
            // 2.1 根据标准注册服务创建一个  MetadataSources 实例（元数据资源集）
            // 2.2 构建元数据
            // 2.3 生成应用一般唯一的 SessionFactory 实例（会话工厂）
            sessionFactory = new MetadataSources(registry).buildMetadata().buildSessionFactory();
        } catch (Exception e) {
            // 2.4 创建失败手动释放 StandardServiceRegistry 实例
            StandardServiceRegistryBuilder.destroy(registry);
            e.printStackTrace();
        }
    }

    /**
     * 打开一个 Session 会话
     * @return Session
     */
    public static Session openSession() {
        return sessionFactory.openSession();
    }


}
  • Hibernate.cfg.xml
<?xml version="1.0" encoding="UTF-8"?>
<!--表明解析本XML文件的DTD文档位置，DTD是Document Type Definition 的缩写,即文档类型的定义,
 XML解析器使用DTD文档来检查XML文件的合法性。hibernate.sourceforge.net/hibernate-configuration-3.0dtd可以在Hibernate3.1.3软件包中的src\org\hibernate目录中找到此文件-->     
<!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration DTD 3.0//EN" "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
 <!--Hibernate配置文件的根元素,其他文件要包含在其中-->
 <hibernate-configuration>
 <!--SessionFactory是Hibernate中的一个类，这个类主要负责保存Hibernate的配置信息，以及对session的操作-->   
 <session-factory>
    <!--hibernate.dialect 只是Hibernate使用的数据库方言,就是要用Hibernate连接那种类型的数据库服务器。-->
  <property name="hibernate.dialect">org.hibernate.dialect.MySQL5InnoDBDialect</property>
   <!--配置数据库的驱动程序，Hibernate在连接数据库时，需要用到数据库的驱动程序-->     
  <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
   <!--设置数据库的连接url:jdbc:mysql://localhost：3306/dbname,其中localhost表示mysql服务器名称，此处为本机，    dbname是数据库名-->      
  <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/hibernate?useUnicode=true&amp;characterEncoding=UTF-8&amp;useSSL=false&amp;serverTimezone=UTC</property>
  <!-- 连接数据库时数据的传输字符集编码方式 -->
  <property name="hibernate.connection.characterEncoding">UTF-8</property>
  <!--连接数据库时的用户名-->    
  <property name="hibernate.connection.username">root</property>
   <!--连接数据库时的密码-->     
  <property name="hibernate.connection.password">123456</property>
         
  <!--是否在后台显示Hibernate用到的SQL语句，开发时设置为true，便于差错，
          程序运行时可以在Eclipse的控制台显示Hibernate的执行Sql语句。项目部署后可以设置为false，提高运行效率-->    
  <property name="hibernate.show_sql">true</property>
  <!-- 格式化输出的Sql语句 -->
  <property name="hibernate.format_sql">true</property>
  <property name="hibernate.hbm2ddl.auto">update</property>  
   <!--指定映射文件，可映射多个映射文件--> 
   <!-- <mapping class="com.lll.entity.IdCard"/>
   <mapping class="com.lll.entity.Student"/> -->
   
  <mapping resource="com/lll/entity/IdCard.hbm.xml"/>
  <mapping resource="com/lll/entity/Student.hbm.xml"/>
</session-factory>
</hibernate-configuration>
  1. 学生与角色是一对多关联
  • Role.java
package com.ydd.entity;

import java.util.HashSet;
import java.util.Set;

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

import org.hibernate.annotations.Cascade;

@Entity
@Table(name="role")
public class Role {
	
	private Integer id;//代理主键
	private String name;
	private Set<Student> students=new HashSet<Student>();//对应的员工的对象
	public Role(){
		
	}
	
	public Role(Integer id, String name) {
		
		this.id = id;
		this.name = name;
	}
	@Id
	@GeneratedValue(strategy=GenerationType.IDENTITY)
	public Integer getId() {
		return id;
	}
	public void setId(Integer id) {
		this.id = id;
	}
	@Column(name="name")
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	@OneToMany(targetEntity=Student.class,mappedBy="role",cascade=CascadeType.ALL)
	
	public Set<Student> getStudents() {
		return students;
	}
	public void setStudents(Set<Student> students) {
		this.students = students;
	}
	@Override
	public String toString() {
		return "Role [id=" + id + ", name=" + name + "]";
	}
	

}
  • Student.java
package com.ydd.entity;

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

import org.hibernate.annotations.Cascade;
import org.hibernate.annotations.Fetch;
import org.hibernate.annotations.Proxy;
//@Proxy(lazy=false)
@Entity
@Table(name="student")
public class Student {
	
	private Integer id;
	private String name;
	private String telephone;
	private Role role;
	public Student(){
		
	}
	public Student(String name, String telephone) {
		super();
		this.name = name;
		this.telephone = telephone;
	}
	@Id
	@GeneratedValue(strategy=GenerationType.IDENTITY)
	public Integer getId() {
		return id;
	}
	public void setId(Integer id) {
		this.id = id;
	}
	@Column(name="name")
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	@Column(name="telephone")
	public String getTelephone() {
		return telephone;
	}
	public void setTelephone(String telephone) {
		this.telephone = telephone;
	}

	@ManyToOne
	@JoinColumn(name="rid")
	public Role getRole() {
		return role;
	}
	public void setRole(Role role) {
		this.role = role;
	}
	@Override
	public String toString() {
		return "Student [id=" + id + ", name=" + name + ", telephone=" + telephone 
				+ "]";
	}
	

}
  • Role.hbm.xml
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<hibernate-mapping package="com.ydd.entity">
	<class name="Role" table="role"  >
		<id name="id" column="id" >
			<generator class="identity">
				
			</generator>
		</id>
		<property name="name" column="name" >
		<!-- <column name="" sql-type=""></column> -->
		</property>
		<!--  inverse="true" lazy="true" outer-join="true" fetch="subselect" -->
		<set name="students" cascade="all" inverse="true">
		<!--inverse属性是谁维护外键（关联关系），是否放弃维护权，false：当前方维护外键，true：由对方维护外键，inverse="true"意思是让多方维护外键  -->
			<key  column="rid"></key>
			<one-to-many class="Student"/>
	    </set>
      
		
	 
	</class>
</hibernate-mapping>
  • Student,hbm.xml

<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<hibernate-mapping package="com.ydd.entity">
	<class name="Student" table="student" >
		<id name="id" column="id" >
			<generator class="identity">
				
			</generator>
		</id>
		
	
		<property name="name" column="name" />
        <property name="telephone" column="telephone"></property>
        <many-to-one name="role" column="rid" class="Role" outer-join="false" fetch="join"></many-to-one>
		<!-- many-to-one不提供inverse属性，默认是false；不能设置 -->
	 
	</class>
</hibernate-mapping>

  • TestYdd.java

  • HibernateUtil.java

package com.ydd.util;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.boot.MetadataSources;
import org.hibernate.boot.registry.StandardServiceRegistry;
import org.hibernate.boot.registry.StandardServiceRegistryBuilder;

/**
 * 初始化Hibernate过程
 * Configuration、SessionFactory、Session对象
 */
public class HibernateUtil {
	public HibernateUtil() {
		// TODO Auto-generated constructor stub
	}
	
	   // SessionFactory实例（会话工厂）
    private static SessionFactory sessionFactory = null;
    //Configuration configuration = new Configuration();  
    
    /**
     * 静态初始化 Hibernate 
     */
    static {
        // 1 创建 StandardServiceRegistry 实例（标准注册服务）
        // 1.1 创建 StandardServiceRegistryBuilder 实例（标准注册服务生成器）
        // 1.2 从 hibernate.cfg.xml 配置文件中读取配置信息
        // 1.3 构建 StandardServiceRegistry实例（标准注册服务）
    	
        StandardServiceRegistry registry = new StandardServiceRegistryBuilder().configure().build();

        try {
            // 2 创建 SessionFactory 实例（会话工厂）
            // 2.1 根据标准注册服务创建一个  MetadataSources 实例（元数据资源集）
            // 2.2 构建元数据
            // 2.3 生成应用一般唯一的 SessionFactory 实例（会话工厂）
            sessionFactory = new MetadataSources(registry).buildMetadata().buildSessionFactory();
        } catch (Exception e) {
            // 2.4 创建失败手动释放 StandardServiceRegistry 实例
            StandardServiceRegistryBuilder.destroy(registry);
            e.printStackTrace();
        }
    }

    /**
     * 打开一个 Session 会话
     * @return Session
     */
    public static Session openSession() {
        return sessionFactory.openSession();
    }


}
  • Hibernate.cfg.xml
<?xml version="1.0" encoding="UTF-8"?>
<!--表明解析本XML文件的DTD文档位置，DTD是Document Type Definition 的缩写,即文档类型的定义,
 XML解析器使用DTD文档来检查XML文件的合法性。hibernate.sourceforge.net/hibernate-configuration-3.0dtd可以在Hibernate3.1.3软件包中的src\org\hibernate目录中找到此文件-->     
<!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration DTD 3.0//EN" "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
 <!--Hibernate配置文件的根元素,其他文件要包含在其中-->
 <hibernate-configuration>
 <!--SessionFactory是Hibernate中的一个类，这个类主要负责保存Hibernate的配置信息，以及对session的操作-->   
 <session-factory>
    <!--hibernate.dialect 只是Hibernate使用的数据库方言,就是要用Hibernate连接那种类型的数据库服务器。-->
  <property name="hibernate.dialect">org.hibernate.dialect.MySQL5InnoDBDialect</property>
   <!--配置数据库的驱动程序，Hibernate在连接数据库时，需要用到数据库的驱动程序-->     
  <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
   <!--设置数据库的连接url:jdbc:mysql://localhost：3306/dbname,其中localhost表示mysql服务器名称，此处为本机，    dbname是数据库名-->      
  <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/hibernate?useUnicode=true&amp;characterEncoding=UTF-8&amp;useSSL=false&amp;serverTimezone=UTC</property>
  <!-- 连接数据库时数据的传输字符集编码方式 -->
  <property name="hibernate.connection.characterEncoding">UTF-8</property>
  <!--连接数据库时的用户名-->    
  <property name="hibernate.connection.username">root</property>
   <!--连接数据库时的密码-->     
  <property name="hibernate.connection.password">123456</property>
         
  <!--是否在后台显示Hibernate用到的SQL语句，开发时设置为true，便于差错，
          程序运行时可以在Eclipse的控制台显示Hibernate的执行Sql语句。项目部署后可以设置为false，提高运行效率-->    
  <property name="hibernate.show_sql">true</property>
  <!-- 格式化输出的Sql语句 -->
  <property name="hibernate.format_sql">true</property>
  <property name="hibernate.hbm2ddl.auto">update</property>  
   <!--指定映射文件，可映射多个映射文件-->  
  <!-- <mapping class="com.ydd.entity.Role"/>
  <mapping class="com.ydd.entity.Student"/> -->
  <mapping resource="com/ydd/entity/Role.hbm.xml"/>
  <mapping resource="com/ydd/entity/Student.hbm.xml"/>
 
</session-factory>
</hibernate-configuration>
  1. 学生与课程是多对多关联
  • Course.java
package com.ddd.entity;

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

@Entity
@Table(name="courses")
public class Course {
	private Integer id;
	private String name;
	private Set<Student> students=new HashSet<Student>();
	@Id
	@GeneratedValue(strategy=GenerationType.IDENTITY)
	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(mappedBy="courses")
	public Set<Student> getStudents() {
		return students;
	}
	public void setStudents(Set<Student> students) {
		this.students = students;
	}
	@Override
	public String toString() {
		return "Course [id=" + id + ", name=" + name + ", students=" + students + "]";
	}
	

}
  • Student.java
package com.ddd.entity;

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.Table;
@Entity
@Table(name="students")
public class Student {
	private Integer id;
	private String name;
	private Set<Course> courses=new HashSet<Course>();
	@Id
	@GeneratedValue(strategy=GenerationType.IDENTITY)
	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="students_course",joinColumns=@JoinColumn(name="sid")
	,inverseJoinColumns=@JoinColumn(name="cid"))
	public Set<Course> getCourses() {
		return courses;
	}
	public void setCourses(Set<Course> courses) {
		this.courses = courses;
	}
	@Override
	public String toString() {
		return "Student [id=" + id + ", name=" + name + ", courses=" + courses + "]";
	}
	

}

  • Course.hbm.xml

  • Student,hbm.xml


<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<hibernate-mapping package="com.ddd.entity">
	<class name="Student" table="m_student" >
		<id name="id" column="id" >
			<generator class="increment" />
		</id>
		<property name="name" column="name" />
		<set name="courses" table="m_student_course"  cascade="all">
			<key  column="sid"></key>
			<many-to-many class="Course" column="cid" ></many-to-many>
		</set>
	</class>
</hibernate-mapping>
  • TestDdd.java
package com.ddd.ui;

import java.util.Set;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;

import com.ddd.util.HibernateUtil;
import com.ddd.entity.Course;
import com.ddd.entity.Student;

public class TestDdd {
	/**
	 * 12.14 测试类--->主要测试程序功能实现情况
	 * 
	 */
	public TestDdd() {
		
	}

	public static void main(String[] args) {
		  save();
		 //update();
//		 delete();
		  //find();
		
	}
	public static void find() {
		Configuration cfg=new Configuration().configure();
		SessionFactory factory=cfg.buildSessionFactory();
		Session session=factory.openSession();
		Transaction tran=session.beginTransaction();
		
		Student student=session.get(Student.class, 1);
		System.out.println("当前用户是"+student.getName());
		Set<Course> courses=student.getCourses();
		for(Course course:courses){
			System.out.println(course.getName());
		}
		
		tran.commit();
		session.close();
		factory.close();
		
		
		
	}
	/*
	 * 
	 * 实现添加功能
	 */

	

	public static void save() {
		
		Configuration cfg=new Configuration().configure();
		SessionFactory factory=cfg.buildSessionFactory();
		Session session=factory.openSession();
		Transaction tran=session.beginTransaction();
		
		Student student1=new Student();
		student1.setName("小明");
		Student student2=new Student();
		student2.setName("小红");
		
		Course course1=new Course();
		course1.setName("JAVA");
		Course course2=new Course();
		course2.setName("C++");
		
		//建立关联
		student1.getCourses().add(course1);//由用户来维护关联，所以用户在前面
		student1.getCourses().add(course2);
//		role1.getStudent().add(student1);
//		role2.getStudent().add(student1);
		
		student2.getCourses().add(course1);
//		role1.getStudent().add(student2);
		
		session.save(student1);
		session.save(student2);
		session.save(course1);
		session.save(course1);
		tran.commit();
		session.close();
		factory.close();
		
		
	}

	/*
	 *   
	 * 实现删除功能
	 */
	 

	public static void delete() {
		Session session = null;
		Transaction tran = null;
		try {
			session = HibernateUtil.openSession();
			tran = session.beginTransaction();
			// ---------------------------------

			// 查找Person对象
			Student  student = session.load(Student.class, 2);
			System.out.println(student.getName());
			session.delete(student);
			

			// ---------------------------------
			tran.commit();
		} catch (Exception e) {
			e.printStackTrace();
			tran.rollback();
		} finally {
			if (null != session) {
				session.close();
			}
		}
	}

	 
	/*
	 * 实现修改功能
	 */
	 

	public static void update() {
		Session session = null;
		Transaction tran = null;
		try {
			session = HibernateUtil.openSession();
			tran = session.beginTransaction();
			// ---------------------------------

			// 查找Person对象
			Student  student = session.load(Student.class, 5);
			student.setName("zhangsan");
			session.update(student);
			// ---------------------------------
			tran.commit();
		} catch (Exception e) {
			e.printStackTrace();
			tran.rollback();
		} finally {
			if (null != session) {
				session.close();
			}
		}
	}

}
  • HibernateUtil.java
package com.ddd.util;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.boot.MetadataSources;
import org.hibernate.boot.registry.StandardServiceRegistry;
import org.hibernate.boot.registry.StandardServiceRegistryBuilder;

/**
 * 初始化Hibernate过程
 * Configuration、SessionFactory、Session对象
 */
public class HibernateUtil {
	public HibernateUtil() {
		// TODO Auto-generated constructor stub
	}
	
	   // SessionFactory实例（会话工厂）
    private static SessionFactory sessionFactory = null;
    //Configuration configuration = new Configuration();  
    
    /**
     * 静态初始化 Hibernate 
     */
    static {
        // 1 创建 StandardServiceRegistry 实例（标准注册服务）
        // 1.1 创建 StandardServiceRegistryBuilder 实例（标准注册服务生成器）
        // 1.2 从 hibernate.cfg.xml 配置文件中读取配置信息
        // 1.3 构建 StandardServiceRegistry实例（标准注册服务）
    	
        StandardServiceRegistry registry = new StandardServiceRegistryBuilder().configure().build();

        try {
            // 2 创建 SessionFactory 实例（会话工厂）
            // 2.1 根据标准注册服务创建一个  MetadataSources 实例（元数据资源集）
            // 2.2 构建元数据
            // 2.3 生成应用一般唯一的 SessionFactory 实例（会话工厂）
            sessionFactory = new MetadataSources(registry).buildMetadata().buildSessionFactory();
        } catch (Exception e) {
            // 2.4 创建失败手动释放 StandardServiceRegistry 实例
            StandardServiceRegistryBuilder.destroy(registry);
            e.printStackTrace();
        }
    }

    /**
     * 打开一个 Session 会话
     * @return Session
     */
    public static Session openSession() {
        return sessionFactory.openSession();
    }


}
  • Hibernate.cfg.xml
<?xml version="1.0" encoding="UTF-8"?>
<!--表明解析本XML文件的DTD文档位置，DTD是Document Type Definition 的缩写,即文档类型的定义,
 XML解析器使用DTD文档来检查XML文件的合法性。hibernate.sourceforge.net/hibernate-configuration-3.0dtd可以在Hibernate3.1.3软件包中的src\org\hibernate目录中找到此文件-->     
<!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration DTD 3.0//EN" "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
 <!--Hibernate配置文件的根元素,其他文件要包含在其中-->
 <hibernate-configuration>
 <!--SessionFactory是Hibernate中的一个类，这个类主要负责保存Hibernate的配置信息，以及对session的操作-->   
 <session-factory>
    <!--hibernate.dialect 只是Hibernate使用的数据库方言,就是要用Hibernate连接那种类型的数据库服务器。-->
  <property name="hibernate.dialect">org.hibernate.dialect.MySQL5InnoDBDialect</property>
   <!--配置数据库的驱动程序，Hibernate在连接数据库时，需要用到数据库的驱动程序-->     
  <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
   <!--设置数据库的连接url:jdbc:mysql://localhost：3306/dbname,其中localhost表示mysql服务器名称，此处为本机，    dbname是数据库名-->      
  <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/hibernate?useUnicode=true&amp;characterEncoding=UTF-8&amp;useSSL=false&amp;serverTimezone=UTC</property>
  <!-- 连接数据库时数据的传输字符集编码方式 -->
  <property name="hibernate.connection.characterEncoding">UTF-8</property>
  <!--连接数据库时的用户名-->    
  <property name="hibernate.connection.username">root</property>
   <!--连接数据库时的密码-->     
  <property name="hibernate.connection.password">123456</property>
         
  <!--是否在后台显示Hibernate用到的SQL语句，开发时设置为true，便于差错，
          程序运行时可以在Eclipse的控制台显示Hibernate的执行Sql语句。项目部署后可以设置为false，提高运行效率-->    
  <property name="hibernate.show_sql">true</property>
  <!-- 格式化输出的Sql语句 -->
  <property name="hibernate.format_sql">true</property>
  <property name="hibernate.hbm2ddl.auto">update</property>  
   <!--指定映射文件，可映射多个映射文件--> 
  <!-- <mapping class="com.ydy.entity.Course"/>
  <mapping class="com.ydy.entity.Student"/> -->
  <mapping resource="com/ddd/entity/Course.hbm.xml"/>
  <mapping resource="com/ddd/entity/Student.hbm.xml"/>
</session-factory>
</hibernate-configuration>
咸狗.
关注
hibernate关联映射实例
09-01
本文将深入探讨“hibernate关联映射实例”中的关键知识点，包括一对多、多对多和继承映射，这些都是Hibernate中至关重要的概念。 1. **一对多关联映射**： 在现实世界中，一个实体可能会与多个其他实体相关联，...
Hibernate关联映射.rar
01-14
本教程“Hibernate关联映射.rar”聚焦于Hibernate中的关联映射，特别是多对一和一对多的关系映射，非常适合初学者了解和实践。 首先，我们要理解什么是关联映射。在数据库中，表与表之间存在各种关系，如一对一、一...
Hibernate关联映射（非常详细）
youandme520的专栏
02-12 1691
在前面的学习中，我们所涉及的都是基于单表的操作，但在实际的开发过程中，基本上都是同时对多张表的操作，且这些表都存在一定的关联关系。 Hibernate 是一款基于 ORM 设计思想的框架，它将关系型数据库中的表与我们 Java 实体类进行映射，表中的记录对应实体类的对象，而表中的字段对应着实体类中的属性。Hibernate 进行增删改查等操作时，不再直接操作数据库表，而是对与之对应的实体类对象进行处理。那么，Hibernate 是如何处理多表关联问题的呢？本节我们针对此问题进行介绍。 关联映射 在关系型
Hibernate关联映射（一对多/多对多）
热门推荐
知飞翀的博客
11-22 1万+
3.  Hibernate关联映射 上接Hibernate持久化类：https://blog.csdn.net/biggerchong/article/details/84260707 目录 3.  Hibernate关联映射 3.1 数据库表之间的关系 3.1.1 一对多关系 3.1.2 多对多关系 3.1.3 一对一关系（实际开发中使用较少） 3.2 实战Hibernate...
Hibernate实体关联关系映射
皮一下很开心的猴头
08-03 2974
一、什么是Hibernate中的关联映射？ 　　简单来说Hibernate是ORM映射的持久层框架，全称是（Object Relational Mapping），即对象关系映射。 　　它将数据库中的表映射成对应的对象，以对象的形式展现，这样我们就可以通过映射的对象来对数据库中的数据进行间接的操作。 　　关联映射是将数据库中的表映射成与之相对应的对象，当你对这个对象进行操作的时候，Hibern...
Hibernate关联映射
gafeng123456的博客
05-25 7830
集合映射开发流程： 需求分析/数据库设计、项目设计/ 编码/测试/实施部署上线/验收需求: 用户购买， 填写地址！ // javabean设计 public class User { private int userId; private String userName; // 一个用户，对应的多个地址 private Set<String> addre
Hibernate关联关系映射(双向篇)
JavaSheng的专栏
05-12 6415
Hibernate关联关系可分为单向关联和双向关联两大类。单向关联可以分为一对一、一对多、多对一和多对多4种关联方式，而多向关联可以分为一对一、一对多和多对多3种关联方式。Hibernate连接管理类HibernateUtil.Javapublic class HibernateUtil { private static SessionFactory sessionFactory; p
hibernate关联映射注解及@JoinColumn的用法
JokerZhan的博客
12-15 2956
1、一对一单项外键（比如实体People和实体IDCard，一个人对应一个身份证号，反之） @OneToOne（cascade=CAscadeType.ALL）全级联关系 @JoinColumn（name="pid",unique=true）被控类的外键写到主控类中，且唯一 ps：保存时应该先保存外键对象，再保存主表对象，这是因为数据库相关约束的原因 2、一对一双向外键 主控方配置不变 被控方添...
Hibernate多表关联查询记录映射
小蜜蜂1010的博客
08-26 1466
通常情况下，单表的查询比较简单，在hibernate中可以将查询记录直接映射到具体的实体类，因为通常会通过JPA注解将数据表和实体类建立映射关系，在查询数据，保存数据时，可以直接操作java实体类，但是涉及到多表查询，查询的多条记录，如果也要和java的类建立关系映射，需要做一些处理。 hibernate查询支持多种，如使用基本实体类对象查询，HQL查询，QBC(Query By Criteria)以及原生sql语句查询 我个人在复杂查询时候还是喜欢用原生sql查询，因为HQL查询，操作的是实体类对象，
Hibernate集合映射、关联映射
guanhang89的专栏
09-17 1918
集合映射开发流程：需求分析/数据库设计、项目设计/ 编码/测试/实施部署上线/验收 需求:用户购买， 填写地址！ 数据库： 代码：// javabean设计 public class User { private int userId; private String userName; // 一个用户，对应的多个地址 private Set<String> add
Hibernate各种关联映射关系梳理
SteveJrong's Blog
09-02 2258
Hibernate各种关联映射关系梳理 多对一的单向关联关系 1.      了解表结构及其关系 采用两张表作为今天的样表：   2.      了解类结构和映射文件： 有两个类： Street类的映射文件： Street类的类结构：   District类的映射文件： District类的类结构： 梳理关系： Dist
Hibernate关联映射-数据对象三种关系
学亮编程手记
02-13 1696
Hibernate框架基于ORM设计思想，它将关系型数据库中的表与我们java中的类进行映射，一个对象就对应着表中的一条记录，而表中的字段对应着类中的属性。 数据库中表与表之间存在着三种关系，也就是系统设计中的三种实体关系。 一对一 原则有两种: 1. 唯一外键对应:在任意一方添加外键来描述对应关系 2. 主键对应：一方的主键作为另一方的主键 Cla...
Hibernate 关联映射
04-21
这可能是测试Hibernate关联映射的一个示例项目或者类。通常，这样的测试会包含各种关联映射的实例，如实体类的定义，配置文件或注解，以及测试用例，用于验证关联映射是否按预期工作。 **详细知识讲解：** 1. **一...
hibernate一对多关联映射学习小结
08-29
在Hibernate中，一对多关联映射可以通过在多的一端加入一个外键，指向一的一端来实现。 一对多关联映射的映射原理是通过在多的一端加入一个外键，指向一的一端来实现的。在加载多的一端时，可以将一的一端加载上来...
hibernate多对多关联映射
04-05
本文将深入探讨Hibernate如何实现多对多关联映射，并通过实际例子解析相关配置和操作。 一、多对多关联概述 在数据库设计中，多对多关联表示两个表之间的关系，如学生和课程的关系，一个学生可以选修多门课程，而...
毕业设计论文Nodejs+Vue宠物店管理系统.docx
10-16
毕业设计论文
（自适应手机版）响应式化工工业企业模板_网站整站打包下载.zip
10-16
（自适应手机版）响应式化工工业企业模板_网站整站打包下载.zip
金蝶与C#对接操作手册.doc
最新发布
10-16
金蝶EAS凭证引入 “webservice接口”说明
毕业设计论文Django+Vue应届生求职系统.docx
10-16
毕业设计论文
Hibernate关联映射详解：从基础到租房系统应用
本资源是一份名为"02-Hibernate 关联映射.pdf"的PDF电子书，主要讲解了Hibernate框架中的关联映射...通过这份资料，读者可以深入理解Hibernate关联映射在实际项目中的运用，提升数据库操作的灵活性和代码组织的清晰度。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值