Hibernate从入门到精通（4）- 单向 一对多 多对一

最新推荐文章于 2023-04-05 17:31:32 发布
最新推荐文章于 2023-04-05 17:31:32 发布
阅读量1k 收藏 2
点赞数 2
文章标签： Annotation Hibernate 一对多 多对一
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011499992/article/details/49507131
版权

Hibernate单向操作

下面使用学生-班级进行测试：

一对多（班级-学生）

班级影响学生，学生不影响班级。

映射

hibernate.cfg.xml: 

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
		"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
		"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
    <session-factory>
        <property name="hibernate.connection.driver_class">oracle.jdbc.driver.OracleDriver</property>
        <property name="hibernate.connection.password">xukai</property>
        <property name="hibernate.connection.url">jdbc:oracle:thin:@10.25.116.164:1521:orcl</property>
        <property name="hibernate.connection.username">xukai</property>
        <property name="hibernate.dialect">org.hibernate.dialect.Oracle10gDialect</property>
    
    	<!-- <property name="hibernate.hbm2ddl.auto">create</property> -->
    	<property name="hibernate.show_sql">true</property>
    	<property name="hibernate.format_sql">true</property>

	<mapping resource="com/edu/entity/Student.hbm.xml"/>
	<mapping resource="com/edu/entity/ClassInfo.hbm.xml"/>
    </session-factory>
</hibernate-configuration>
 ClassInfo和Student实体类： 
package com.edu.entity;

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

public class ClassInfo implements Serializable{
	
	private static final long serialVersionUID = 1L;

	private Integer claId;
	
	private String claName;

	//班级下面的学生
	private Set<Student> stus = new HashSet<>();

	//getter.setter
}



package com.edu.entity;

import java.io.Serializable;

public class Student implements Serializable {

	private static final long serialVersionUID = 1L;

	private Integer stuId;
	
	private String stuName;	<pre name="code" class="java" style="font-size: 13.3333339691162px;"><span style="white-space:pre">	</span>//getter.setter
} 
 
  

    ClassInfo.hbm.xml: 
  
 
  
 
   
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<!-- Generated 2015-10-29 20:52:31 by Hibernate Tools 3.4.0.CR1 -->
<hibernate-mapping>
    <class name="com.edu.entity.ClassInfo" table="CLASSINFO">
        <id name="claId" type="java.lang.Integer">
            <column name="CLA_ID" />
            <generator class="assigned" />
        </id>
        <property name="claName" type="java.lang.String">
            <column name="CLA_NAME" />
        </property>
        <set name="stus" table="STUDENT" inverse="false" lazy="false" 
        	cascade="save-update">
        	<key>
        		<!-- STUDENT表中的外键列名 -->
        		<column name="CLA_ID"></column>
        	</key>
        	<one-to-many class="com.edu.entity.Student"/>
        </set>
    </class>
</hibernate-mapping>


 
   Student.hbm.xml: 
   
 
  
 
  
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<!-- Generated 2015-10-29 20:52:31 by Hibernate Tools 3.4.0.CR1 -->
<hibernate-mapping>
    <class name="com.edu.entity.Student" table="STUDENT">
        <id name="stuId" type="java.lang.Integer">
            <column name="STU_ID" />
            <generator class="assigned" />
        </id>
        <property name="stuName" type="java.lang.String">
            <column name="STU_NAME" />
        </property>
    </class>
</hibernate-mapping>
 
  
 
 
 测试：执行完毕说明，配置没有问题。 

 


  HibernateUtil: 

 

 
 
package com.edu.util;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.boot.registry.StandardServiceRegistryBuilder;
import org.hibernate.cfg.Configuration;
import org.hibernate.service.ServiceRegistry;

public class HibernateUtils {

	private static SessionFactory sessionFactory;
	
	static{
		Configuration config = new Configuration().configure();
		ServiceRegistry serviceRegistry = new StandardServiceRegistryBuilder()
				.applySettings(config.getProperties()).build();
		sessionFactory = config.buildSessionFactory(serviceRegistry);
		System.out.println("资源加载成功!");
	}
	
	public static Session getSession(){
		return sessionFactory.openSession();
	}
	
	public static void closeSession(Session session){
		if(session != null && session.isOpen()){
			session.close();
		}
	}
	
}

使用JUnit进行测试： 

 

 
 
package com.edu.util;

import org.hibernate.Session;
import org.hibernate.Transaction;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import com.edu.entity.ClassInfo;
import com.edu.entity.Student;

public class HibernateUtilsTest {

	private Session session = null;
	private Transaction tran = null;
	
	@Before
	public void initSession(){
		session = HibernateUtils.getSession();
		tran = session.beginTransaction();
	}
	
	@Test
	public void testGet(){
		ClassInfo classInfo = (ClassInfo) session.get(ClassInfo.class, 10);
		session.close();
		System.out.println(classInfo.toString());

	}
	
	@Test
	public void testSave(){
		Student stu1 = new Student();
		stu1.setStuId(1);
		stu1.setStuName("学生1");
		Student stu2 = new Student();
		stu2.setStuId(2);
		stu2.setStuName("学生2");
		
		ClassInfo classInfo = new ClassInfo();
		classInfo.setClaId(10);
		classInfo.setClaName("十班");
		classInfo.getStus().add(stu1);
		classInfo.getStus().add(stu2);
		session.save(classInfo);
	}
	
	@After
	public void colseSession(){
		if(tran!=null){
			tran.commit();
		}
		if(session!=null&&session.isOpen()){
			session.close();
		}
	}
	
}

 
 
 
 
注解（Annotation）
 
 

   hibernate.cfg.xml: 
 
 
 
 
  
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
		"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
		"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
    <session-factory>
        <property name="hibernate.connection.driver_class">oracle.jdbc.driver.OracleDriver</property>
        <property name="hibernate.connection.password">xukai</property>
        <property name="hibernate.connection.url">jdbc:oracle:thin:@10.25.116.164:1521:orcl</property>
        <property name="hibernate.connection.username">xukai</property>
        <property name="hibernate.dialect">org.hibernate.dialect.Oracle10gDialect</property>
    
    	<!-- <property name="hibernate.hbm2ddl.auto">create</property> -->
    	<property name="hibernate.show_sql">true</property>
    	<property name="hibernate.format_sql">true</property>
<span style="white-space:pre">	</span><!-- 使用注解为class -->
	<mapping class="com.edu.entity.ClassInfo"/>
	<mapping class="com.edu.entity.Student"/>
		
    </session-factory>
</hibernate-configuration>

Student 
  实体类: 
 
 
 
 
  
package com.edu.entity;

import java.io.Serializable;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.Table;

@Entity
@Table(name="student")
public class Student implements Serializable {

	private static final long serialVersionUID = 1L;

	@Id
	@Column(name="STU_ID")
	private Integer stuId;
	
	@Column(name="STU_NAME")
	private String stuName;

	//getter setter
}

ClassInfo 
  实体类: 
 
 
 
 
  
package com.edu.entity;

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

import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.OneToMany;
import javax.persistence.Table;

@Entity
@Table(name="CLASS_INFO")
public class ClassInfo implements Serializable{
	
	private static final long serialVersionUID = 1L;

	@Id
	@Column(name="CLA_ID")
	private Integer claId;
	
	@Column(name="CLA_NAME")
	private String claName;

	@OneToMany(targetEntity=Student.class,
			cascade=CascadeType.ALL)
	//外键
	@JoinColumn(name="CLA_ID")
	private Set<Student> stus = new HashSet<>();
	
	//getter setter
}

 
  
 测试： 
 
 
 
 
  
package com.edu.util;

import org.hibernate.Session;
import org.hibernate.Transaction;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import com.edu.entity.ClassInfo;
import com.edu.entity.Student;

public class HibernateUtilsTest {

	private Session session = null;
	private Transaction tran = null;
	
	@Before
	public void initSession(){
		session = HibernateUtils.getSession();
		tran = session.beginTransaction();
	}
	
	@Test
	public void testGet(){
		ClassInfo classInfo = (ClassInfo) session.get(ClassInfo.class, 10);
		System.out.println(classInfo.toString());
	}
	
	public void testSave(){
		Student stu1 = new Student();
		stu1.setStuId(1);
		stu1.setStuName("学生1");
		Student stu2 = new Student();
		stu2.setStuId(2);
		stu2.setStuName("学生2");
		
		ClassInfo classInfo = new ClassInfo();
		classInfo.setClaId(10);
		classInfo.setClaName("十班");
		classInfo.getStus().add(stu1);
		classInfo.getStus().add(stu2);
		session.save(classInfo);
	}
	
	@After
	public void colseSession(){
		if(tran!=null){
			tran.commit();
		}
		if(session!=null&&session.isOpen()){
			session.close();
		}
	}
	
}

 
  
 
  
多对一（学生-班级）
 
  学生影响班级，班级不影响学生。 
 
 
 
 
  
映射
 
  

    hibernate.cfg.xml: 
  
 
  
 
   
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
		"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
		"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
    <session-factory>
        <property name="hibernate.connection.driver_class">oracle.jdbc.driver.OracleDriver</property>
        <property name="hibernate.connection.password">xukai</property>
        <property name="hibernate.connection.url">jdbc:oracle:thin:@10.25.116.164:1521:orcl</property>
        <property name="hibernate.connection.username">xukai</property>
        <property name="hibernate.dialect">org.hibernate.dialect.Oracle10gDialect</property>
    
    	<property name="hibernate.hbm2ddl.auto">create</property>
    	<property name="hibernate.show_sql">true</property>
    	<property name="hibernate.format_sql">true</property>

		<mapping resource="com/edu/entity/Student.hbm.xml"/>
		<mapping resource="com/edu/entity/ClassInfo.hbm.xml"/>
    </session-factory>
</hibernate-configuration>

Student 
   实体类: 
  
 
  
 
   
package com.edu.entity;

import java.io.Serializable;

public class Student implements Serializable {

	private static final long serialVersionUID = 1L;

	private Integer stuId;
	
	private String stuName;
	
	private ClassInfo classInfo;//关联班级

<span style="white-space:pre">	</span>//getter setter
}

ClassInfo 
   实体类: 
  
 
  
 
   
package com.edu.entity;

import java.io.Serializable;

public class ClassInfo implements Serializable{

	private static final long serialVersionUID = 1L;

	private Integer claId;
	
	private String claName;

<span style="white-space:pre">	</span>//getter setter
}

 
   

     Student.hbm.xml: 
   
 
   
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<!-- Generated 2015-10-29 21:19:46 by Hibernate Tools 3.4.0.CR1 -->
<hibernate-mapping>
    <class name="com.edu.entity.Student" table="STUDENT">
        <id name="stuId" type="java.lang.Integer">
            <column name="STUID" />
            <generator class="assigned" />
        </id>
        <property name="stuName" type="java.lang.String">
            <column name="STUNAME" />
        </property>
        <many-to-one name="classInfo" class="com.edu.entity.ClassInfo" fetch="join"
			cascade="save-update">
			<!-- STUDENT表中的外键列名 -->
            <column name="CLA_ID" />
        </many-to-one>
    </class>
</hibernate-mapping>

ClassInfo.hbm.xml: 
  
 
  
 
   
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<!-- Generated 2015-10-29 21:19:46 by Hibernate Tools 3.4.0.CR1 -->
<hibernate-mapping>
    <class name="com.edu.entity.ClassInfo" table="CLASSINFO">
        <id name="claId" type="java.lang.Integer">
            <column name="CLAID" />
            <generator class="assigned" />
        </id>
        <property name="claName" type="java.lang.String">
            <column name="CLANAME" />
        </property>
    </class>
</hibernate-mapping>

测试： 
  
 
  
 
   
package com.edu.util;

import org.hibernate.Session;
import org.hibernate.Transaction;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import com.edu.entity.ClassInfo;
import com.edu.entity.Student;

public class HibernateUtilsTest {

	private Session session = null;
	private Transaction tran = null;
	
	@Before
	public void initSession(){
		session = HibernateUtils.getSession();
		tran = session.beginTransaction();
	}
	
	@Test
	public void testSave(){
		ClassInfo classInfo = new ClassInfo();
		classInfo.setClaId(10);
		classInfo.setClaName("十班");
		Student stu1 = new Student();
		stu1.setStuId(1);
		stu1.setStuName("学生1");
		stu1.setClassInfo(classInfo);
		Student stu2 = new Student();
		stu2.setStuId(2);
		stu2.setStuName("学生2");
		stu2.setClassInfo(classInfo);
		session.save(stu1);
		session.save(stu2);
	}
	
	@After
	public void colseSession(){
		if(tran!=null){
			tran.commit();
		}
		if(session!=null&&session.isOpen()){
			session.close();
		}
	}
	
}

 
   
注解（Annotation）
 hibernate.cfg.xml: 
  
 
  
 
   
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
		"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
		"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
    <session-factory>
        <property name="hibernate.connection.driver_class">oracle.jdbc.driver.OracleDriver</property>
        <property name="hibernate.connection.password">xukai</property>
        <property name="hibernate.connection.url">jdbc:oracle:thin:@10.25.116.164:1521:orcl</property>
        <property name="hibernate.connection.username">xukai</property>
        <property name="hibernate.dialect">org.hibernate.dialect.Oracle10gDialect</property>
    
    	<property name="hibernate.hbm2ddl.auto">create</property>
    	<property name="hibernate.show_sql">true</property>
    	<property name="hibernate.format_sql">true</property>

		<mapping class="com.edu.entity.Student"/>
		<mapping class="com.edu.entity.ClassInfo"/>
    </session-factory>
</hibernate-configuration>

Student:实体类： 
  
 
  
 
   
package com.edu.entity;

import java.io.Serializable;

import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.Table;

@Entity
@Table(name="STUDENT")
public class Student implements Serializable {

	private static final long serialVersionUID = 1L;

	@Id
	@Column(name="STU_ID")
	private Integer stuId;
	
	@Column(name="STU_NAME")
	private String stuName;
	
	@ManyToOne(targetEntity=ClassInfo.class,cascade=CascadeType.ALL)
	@JoinColumn(name="CLA_ID")
	private ClassInfo classInfo;

	//getter setter
}

ClassInfo 
   实体类： 
   
package com.edu.entity;

import java.io.Serializable;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.Table;

@Entity
@Table(name="CLASS_INFO")
public class ClassInfo implements Serializable{

	private static final long serialVersionUID = 1L;

	@Id
	@Column(name="CLA_ID")
	private Integer claId;
	
	@Column(name="CLA_NAME")
	private String claName;

<span style="white-space:pre">	</span>//getter setter
}

测试类： 
  
 
  
 
   
package com.edu.util;

import org.hibernate.Session;
import org.hibernate.Transaction;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import com.edu.entity.ClassInfo;
import com.edu.entity.Student;

public class HibernateUtilsTest {

	private Session session = null;
	private Transaction tran = null;
	
	@Before
	public void initSession(){
		session = HibernateUtils.getSession();
		tran = session.beginTransaction();
	}
	
	@Test
	public void testSave(){
		ClassInfo classInfo = new ClassInfo();
		classInfo.setClaId(10);
		classInfo.setClaName("十班");
		Student stu1 = new Student();
		stu1.setStuId(1);
		stu1.setStuName("学生1");
		stu1.setClassInfo(classInfo);
		Student stu2 = new Student();
		stu2.setStuId(2);
		stu2.setStuName("学生2");
		stu2.setClassInfo(classInfo);
		session.save(stu1);
		session.save(stu2);
	}
	
	@After
	public void colseSession(){
		if(tran!=null){
			tran.commit();
		}
		if(session!=null&&session.isOpen()){
			session.close();
		}
	}
	
}

 
   
 
   总结：单向一对多在one的一方进行操作，多对一在many的一方进行操作。 
  
 
  
 
   
 
  
 
  
 
   
 
  
 
  
 
   
 
  
 
  
 
   
 
   
 
   
 
   
 
   
 
  
 
  
 
   
 
   
 
  
 
  
 
 
 
 
 


                

        

        

    




    

      

        

            

              
                
                  x_k
                
              
            

            

                关注
              
            

        

        

          
    
            
  • 
              
                
                
                
                
                    2
                
              
              
    点赞
    
            
    • 
            
  • 
              
                
                
                
              
              
    踩
    
            
    • 
            
  • 
              
                
                
                
                
                    2
                
              
              
    
                
    
                  
                    收藏
                  
                
    
              
    
              
    
                
    
                  觉得还不错?
                  
                    一键收藏
                  
                 
                
    
              
    
            
    • 
          
  • 
            
    
              
              
            
    
              
              
              
                    0
              
            
            
    评论
    
          
    • 
          
  • 
          
    • 
          
  • 
            
              
            
              
    
            
              
                
            
    
          
    • 
        

      

      

            

                专栏目录
          










                



	

		

			

				
					
JSP开发之hibernate之单向多对一关联的实例

				
			

			

				

					01-08
				

			

		

		

			
				
JSP开发之hibernate之单向多对一关联的实例 一对多的基础上来测试单向多对一的关联  hibernate多对一的关联关系定义：  和单向一对多不同的是：一对多是在意的一方的一方定义set集合，在映射文件中        ：单向多...

			
		

	



                

              
                



	

		

			

				
					
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一对多，多对多操作

				
			

			

				

					SkyFire1121的博客
				

				

					03-06
					
					298
					
				

			

		

		

			
				
一、hibernate一对多1.1 一对多映射配置以客户和联系人为例：客户是一，联系人是多。第一步：创建两个实体类，客户和联系人第二步：让两个实体类之间互相表示。让客户实体类里面表示多个联系人。一个客户可以对应多个联系人，这里装载联系人，装载的容器用的是Set集合，而不是LinkedList，因为Set集合的特点是，值不能够重复。在联系人实体类里面表示所属客户。一个联系人只能属于一个客户。客户实体...

			
		

	





	

		

			

				
					
hibernate关联关系（一对多，多对多）

				
			

			

				

					m0_60375943的博客
				

				

					10-19
					
					523
					
				

			

		

		

			
				
一对多的关联配置

数据库：主表从表，通过外键关联

类：


class A{

B b；

}

class B{

}


实体类 包含了订单集合的属性



订单项来说 它一定属于某个订单



配置order.hbm.xml


<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC
  "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
...

			
		

	



		

			
		



	

		

			

				
					
Hibernate多表关联——（一对多关系）

				
			

			

				

					闲来垂钓碧溪上的博客
				

				

					04-05
					
					1809
					
				

			

		

		

			
				
hibernate是连接数据库使得更容易操作数据库数据的一个框架，在上期我们演示了单表建立查询。接触过数据库的都知道数据库表有三种关系，。而接下来我们在hibernate中建立关系，首先应该检查一下数据库是否打开，根据，接下来继续建立表的关系。

			
		

	





	

		

			

				
					
hibernate-一对多

				
			

			

				

					JJ_HH
				

				

					03-18
					
					166
					
				

			

		

		

			
				
单向一对多关系：多方维护，多方中加入一方主键，但是保存一方时，多方字段为空，若多方不为空，则不能保存，若对多方操作则会发出对一方的update语句。 
单向多对一关系：多方维护，多方加入一方主键 
载上来。即我们查询用户的时候，组也被查询出来了。而一对多的关系，  
是指在加载一的时候可以将多加载进来。即查询组的时候，用户也被查出来了。他们适用于不同的需求。 
双向一对多：一对多双向关联映射，我们...

			
		

	





	

		

			

				
					
Hibernate 系列教程 单向一对多

				
			

			

				

					11-30
				

			

		

		

			
				
Hibernate 系列教程 单向一对多

			
		

	





	

		

			

				
					
hibernate一对多关联映射学习小结

				
			

			

				

					08-29
				

			

		

		

			
				
主要介绍了hibernate一对多关联映射学习小结,需要的朋友可以参考下

			
		

	





	

		

			

				
					
hibernate多对一单向关联关系实现源码

				
			

			

				

					10-08
				

			

		

		

			
				
这里包含了hibernate多对一单向关联关系实现源码，希望对你有用。

			
		

	





	

		

			

				
					
hibernate之一对多

				
			

			

				

					weixin_43977846的博客
				

				

					07-15
					
					346
					
				

			

		

		

			
				
hibernate之一对多（以订单和订单项为例）
注意：切记把配置文件配置好，且不可出错，用工具类可检验
工具类：
package com.yj.three.util;

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

public...

			
		

	





	

		

			

				
					
Hibernate单向多对多

				
			

			

				

					Gaaidou的博客
				

				

					08-07
					
					2473
					
				

			

		

		

			
				
最近做一个OA系统，用到了Hibernate框架，我发现，权限和角色的关系是一种多对多的关系，一个权限可以分配给多个角色，一个角色拥有多个权限。
多对多关系有两种，一种是单向的，一种是多向的。对于这个问题，曾经让我很犯难。单纯在语言上理解，会比较复杂，而从代码上理解，可能就会明白了。
下面模拟为角色授权的过程：
1，Hibernate使用Annotation
2，使用Junit进行测试。

			
		

	





	

		

			

				
					
Hibernate关联关系配置(一对多、一对一和多对多)

				
			

			

				

					devlgdg1924的博客
				

				

					05-08
					
					184
					
				

			

		

		

			
				
第一种关联关系：一对多（多对一） 
“一对多”是最普遍的映射关系，简单来讲就如消费者与订单的关系。 
一对多：从消费者角的度来说一个消费者可以有多个订单，即为一对多。 
多对一：从订单的角度来说多个订单可以对应一个消费者，即为多对一。

一对多关系在hbm...

			
		

	





	

		

			

				
					
hibernate关联关系（多对多）

				
			

			

				

					qq_44271884的博客
				

				

					07-17
					
					141
					
				

			

		

		

			
				
数据库的多对多
1 数据库中不能直接映射多对多
处理：创建一个桥接表(中间表)，将一个多对多关系转换成两个一对多
注1：数据库多表联接查询 永远就是二个表的联接查询
注2：外连接：left(左)/right(右)/full(左右)
主从表：连接条件不成立时，主表记录永远保留，与null匹配
在hibernate中，你只管查询当前表对象即可，
hibernate会自动关联桥表以及关联表查询出关联对象...

			
		

	





	

		

			

				
					
Hibernate一对多，多对多操作

				
			

			

				

					Marvel__Dead 胡艺宝的博客
				

				

					03-16
					
					1万+
					
				

			

		

		

			
				
表与表之间的关系一对多：
分类和商品关系，一个分类里面有多个商品，一个商品只能属于一个分类。
客户和联系人是一对多关系：联系人在人际交流中担任着重要的角色，在销售过程中，我们通常不是在最开始就联系到有决策权的高管，而有可能是接电话的前台A、营销人员B、客服C、技术人员D等等。这些人都是我们与企业保持交流的联系人。他们对产品的支持态度决定了产品是否能够顺利推送到高管面前。通常销售人员在跟进一个客户时，

			
		

	





	

		

			

				
					
Hibernate的一对多操作

				
			

			

				

					cgk1996的博客
				

				

					09-24
					
					282
					
				

			

		

		

			
				
一对多映射配置（重点）




以客户和联系人为例：客户是一，联系人是多
 
第一步创建两个实体类，客户和联系人
 
第二步让两个实体类之间互相表示
（1）在客户实体类里面表示多个联系人
- 一个客户里面有多个联系人
 
（2）在联系人实体类里面表示所属客户
- 一个联系人只能属于一个客户
 
第三步配置映射关系
（1）一般一个实体类对应一个映射文件
（2）把映

			
		

	





	

		

			

				
					
Hibernate 一对多讲解

				
			

			

				

					qq_43059674的博客
				

				

					07-15
					
					272
					
				

			

		

		

			
				
前言
**什么是关联(association)**关联指的是类之间的引用关系。如果类A与类B关联，那么被引用的类B将被定义为类A的属性
	   class B{
		private String name;
	  }
	  public class A{
        private B b = new B;
        public A(){}
      }

着就是关联，在hibern...

			
		

	





	

		

			

				
					
hibernate一对多关系

				
			

			

				

					qq_44271884的博客
				

				

					07-15
					
					146
					
				

			

		

		

			
				
什么是关联(association)
1 关联指的是类之间的引用关系。如果类A与类B关联，那么被引用的类B将被定义为类A的属性.（订单项与订单）
关联的分类：
关联可以分为一对一、一对多/多对一、多对多关联
关联是有方向的
#关键点都在数据库中的外键上面,请好好理解下面这二句SQL和一对多及多对一的关系
#select * from Orders where cid=?   //这条SQL返回客户...

			
		

	





	

		

			

				
					
一对多关系[转] 

				
			

			

				

					Kevin的足跡
				

				

					02-12
					
					196
					
				

			

		

		

			
				
知识点：双向一对多关系，一是关系维护端（owner side），多是关系被维护端（inverse side）。在关系被维护端需要通过@JoinColumn建立外键列指向关系维护端的主键列。
 
 
publicclass Order implements Serializable {
    privateSet orderItems = new HashSet();
         ...

			
		

	





	

		

			

				
					
hibernate映射一对一 一对多 多对多

					
最新发布

				
			

			

				

					09-07
				

			

		

		

			
				
在Hibernate中，对于一对一、一对多和多对多的关系，我们可以通过以下方式进行映射。  一对一关系：在Hibernate中，可以通过主键关联和外键关联来实现一对一关系的映射。主键关联是指两个实体之间的关联通过主键来...

			
		

	



              



  
“相关推荐”对你有帮助么？

  

      
    
          
  • 
              
    
                  
                  
              
    
              
    非常没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    一般
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    有帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    非常有帮助
    
          
    • 
      

      

      

          
          提交
      

      

  




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值