集合映射详解

最新推荐文章于 2023-07-28 16:27:16 发布

番薯(Koali)

最新推荐文章于 2023-07-28 16:27:16 发布

阅读量5k

点赞数 1

CC 4.0 BY-SA版权

分类专栏： Hibernate 文章标签： hibernate 集合映射

本文链接：https://blog.youkuaiyun.com/Shirley_John_Thomas/article/details/52505415

Hibernate 专栏收录该内容

33 篇文章

订阅专栏

一、集合映射

1.1 集合小介

集合映射也是基本的映射，但在开发过程中不会经常用到，所以不需要深刻了解，只需要理解基本的使用方法即可，等在开发过程中遇到了这种问题时能够查询到解决方法就可以了。对应集合映射它其实是指将java中的集合映射到对应的表中，是一种集合对象的映射，在java中有四种类型的集合，分别是Set、Map、List还有普通的数组，它们之间有很大的区别：

Set，不可以有重复的对象，对象是无序的；

List，可以与重复的对象，对象之间有顺序；

Map，它是键值成对出现的；

数组，可以重复，对象之间有顺序。

它们之间的区别决定了在开发时使用哪种集合，通常在开发时会使用Set，它内部的对象是无需的，并可以使用迭代器获取内部对象。这几种集合想要映射到相应的关系模型的话就必须使用Hibernate提供的映射标签，<set>、<list>、<map>、<array>。

1.2 映射小介

继续讨论集合映射的关系模型，集合映射是指一个对象对应着另一个对象集合，在保存时Hibernate会把数据集合保存到相应的表中，并按照自己分配的id把数据保存到数据表中，如果单独为集合分配了新表，那么会将id分配给集合表的id，那么对应的关系表如下图：

1.3 类文件

集合映射是如何通过代码实现的，接下来具体分析。这里把所有的集合封存到一个类中，这个类我们称之为CollectionMapping.java，那么它对应的内部代码如下：

 
 package com.hibernate;  
  
import java.util.List;  
import java.util.Map;  
import java.util.Set;  
  
@SuppressWarnings("rawtypes")  
public class CollectionMapping {  
      
    //id  
    private int id;  
    public int getId() {  
        return id;  
    }  
    public void setId(int id) {  
        this.id = id;  
    }  
      
    //名字  
    private String name;  
    public String getName() {  
        return name;  
    }  
    public void setName(String name) {  
        this.name = name;  
    }  
      
    //Set集合  
    private Set setValues;  
    public Set getSetValues() {  
        return setValues;  
    }  
    public void setSetValues(Set setValues) {  
        this.setValues = setValues;  
    }  
      
    //List集合  
    private List listValues;  
    public List getListValues() {  
        return listValues;  
    }  
    public void setListValues(List listValues) {  
        this.listValues = listValues;  
    }  
      
    //数组集合  
    private String[] arrayValues;  
    public String[] getArrayValues() {  
        return arrayValues;  
    }  
    public void setArrayValues(String[] arrayValues) {  
        this.arrayValues = arrayValues;  
    }  
      
    //Map集合  
    private Map mapValues;  
    public Map getMapValues() {  
        return mapValues;  
    }  
    public void setMapValues(Map mapValues) {  
        this.mapValues = mapValues;  
    }  
}  
 

该类中封装了几种常用的集合，想要转化为关系模型，就必须来看下文的映射。

1.4 集合映射

集合的映射其实相当的简单，只需要添加对应的集合标签，Hibernate分别提供了集合标签<set>、<map>、<list>、<array>，通过使用集中标签来将集合映射为对应的关系表，另外通过添加<key>标签来实现表外键的关联，其它的属性通过使用<element>来添加。

CollectionMapping.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">  
<hibernate-mapping>  
    <class name="com.hibernate.CollectionMapping" table="t_collection_mapping">  
        <id name="id">  
            <generator class="native"/>  
        </id>  
        <property name="name"/>  
          
        <set name="setValues" table="t_set_values">  
            <key column="set_id"></key>  
            <element type="string" column="set_value"></element>  
        </set>  
        <list name="listValues" table="t_list_values">  
            <key column="list_id"/>  
            <list-index column="list_index"/>  
            <element type="string" column="list_value"/>  
        </list>  
        <map name="mapValues" table="t_map_values">  
            <key column="map_id"/>  
            <map-key type="string" column="map_key"/>  
            <element type="string" column="map_value"/>  
        </map>  
        <array name="arrayValues" table="t_array_value">  
            <key column="array_id"/>            
            <index column="array_index" type="integer"></index>  
            <element type="string" column="array_value"/>  
        </array>  
    </class>  
</hibernate-mapping>  

需要注意的是list标签和array标签，这两种集合内的对象是有顺序的，所以在添加映射标签时需要使用list-index或者index标签来标明对象的顺序，而且在添加子标签时一定要按照顺序添加，也就是说先添加<key>标签，后添加<list-index>标签，最后添加<element>标签，否则的话会出现如下错误：

The content of element type "list" must match "(meta*,subselect?,cache?,synchronize*,comment?,key,(index|list-index),(element|one-to-many|many-to-many|composite-element|many-to-any),loader?,sql-insert?,sql-update?,sql-delete?,sql-delete-all?,filter*)".

1.5 关系模型

将配置好的对象模型转化为相应的关系模型，生成的SQL语句如下：

 
  
 
 
alter table t_array_value drop foreign key FK2E0DD0C067676B68  
alter table t_list_values drop foreign key FKE01EC98BF4FCB03  
alter table t_map_values drop foreign key FKD169BA107402B585  
alter table t_set_values drop foreign key FK7BB8D04A7E79F8BF  
drop table if exists t_array_value  
drop table if exists t_collection_mapping  
drop table if exists t_list_values  
drop table if exists t_map_values  
drop table if exists t_set_values  
create table t_array_value (array_id integer not null, array_value varchar(255), array_index integer not null, primary key (array_id, array_index))  
create table t_collection_mapping (id integer not null auto_increment, name varchar(255), primary key (id))  
create table t_list_values (list_id integer not null, list_value varchar(255), list_index integer not null, primary key (list_id, list_index))  
create table t_map_values (map_id integer not null, map_value varchar(255), map_key varchar(255) not null, primary key (map_id, map_key))  
create table t_set_values (set_id integer not null, set_value varchar(255))  
alter table t_array_value add index FK2E0DD0C067676B68 (array_id), add constraint FK2E0DD0C067676B68 foreign key (array_id) references t_collection_mapping (id)  
alter table t_list_values add index FKE01EC98BF4FCB03 (list_id), add constraint FKE01EC98BF4FCB03 foreign key (list_id) references t_collection_mapping (id)  
alter table t_map_values add index FKD169BA107402B585 (map_id), add constraint FKD169BA107402B585 foreign key (map_id) references t_collection_mapping (id)  
alter table t_set_values add index FK7BB8D04A7E79F8BF (set_id), add constraint FK7BB8D04A7E79F8BF foreign key (set_id) references t_collection_mapping (id)  

生成的对应的数据库视图如下：

二、数据操作

2.1 数据写入

写入数据操作，将数据写入时需要注意创建数据对象，其中的List、Set、Map需要创建数据对象，将数据对象写入到数据库中，因为它们三者都是对象接口，所以需要创建一个对象，将对象写入到数据库中，具体代码如下：

 
  
 
 
@SuppressWarnings({ "unchecked", "rawtypes" })  
public void testsave(){  
      
    Session session=null;  
    try{  
        session=HibernateUtils.getSession();  
        session.beginTransaction();  
          
        CollectionMapping cm=new CollectionMapping();  
        cm.setName("zhangsan");  
          
        Set set=new HashSet();  
        set.add("a");  
        set.add("b");  
        cm.setSetValues(set);  
          
        List list=new ArrayList();  
        list.add("list1");  
        list.add("list2");  
        cm.setListValues(list);  
          
        String[] str=new String[]{"array1","array2"};  
        cm.setArrayValues(str);  
          
        Map map=new HashMap();  
        map.put("k1","v1");  
        map.put("k2", "v2");  
        cm.setMapValues(map);  
          
        session.save(cm);  
        session.getTransaction().commit();  
    }catch(Exception e){  
        e.printStackTrace();  
        session.getTransaction().rollback();  
    }finally{  
        HibernateUtils.closeSession(session);  
    }  
}  

生成的SQL语句如下：

 
  
 
 
Hibernate: insert into t_collection_mapping (name) values (?)  
Hibernate: insert into t_set_values (set_id, set_value) values (?, ?)  
Hibernate: insert into t_set_values (set_id, set_value) values (?, ?)  
Hibernate: insert into t_list_values (list_id, list_index, list_value) values (?, ?, ?)  
Hibernate: insert into t_list_values (list_id, list_index, list_value) values (?, ?, ?)  
Hibernate: insert into t_map_values (map_id, map_key, map_value) values (?, ?, ?)  
Hibernate: insert into t_map_values (map_id, map_key, map_value) values (?, ?, ?)  
Hibernate: insert into t_array_value (array_id, array_index, array_value) values (?, ?, ?)  
Hibernate: insert into t_array_value (array_id, array_index, array_value) values (?, ?, ?)  

2.2 加载数据

加载数据的方法很简单，它会将表中的数据按照集合加载到对象中，然后只需要获取相应的对象集合即可。

 
  
 
 
public void testload(){  
    Session session=null;  
    try{  
        session=HibernateUtils.getSession();  
        session.beginTransaction();  
          
        CollectionMapping cm=(CollectionMapping)session.load(CollectionMapping.class, 1);  
          
        System.out.println("cm.name= "+cm.getName());  
        System.out.println("cm.list= "+cm.getListValues());  
        System.out.println("cm.map= "+cm.getMapValues());  
        System.out.println("cm.array= "+cm.getArrayValues());  
        System.out.println("cm.set= "+cm.getSetValues());  
          
        session.getTransaction().commit();  
    }catch(Exception e){  
        e.printStackTrace();  
        session.getTransaction().rollback();  
    }finally{  
        HibernateUtils.closeSession(session);  
    }  
}  

生成的结果：

 
  
 
 
Hibernate: select collection0_.id as id0_0_, collection0_.name as name0_0_ from t_collection_mapping collection0_ where collection0_.id=?  
Hibernate: select arrayvalue0_.array_id as array1_0_, arrayvalue0_.array_value as array2_0_, arrayvalue0_.array_index as array3_0_ from t_array_value arrayvalue0_ where arrayvalue0_.array_id=?  
cm.name= zhangsan  
Hibernate: select listvalues0_.list_id as list1_0_, listvalues0_.list_value as list2_0_, listvalues0_.list_index as list3_0_ from t_list_values listvalues0_ where listvalues0_.list_id=?  
cm.list= [list1, list2]  
Hibernate: select mapvalues0_.map_id as map1_0_, mapvalues0_.map_value as map2_0_, mapvalues0_.map_key as map3_0_ from t_map_values mapvalues0_ where mapvalues0_.map_id=?  
cm.map= {k1=v1, k2=v2}  
cm.array= [Ljava.lang.String;@758d8478  
Hibernate: select setvalues0_.set_id as set1_0_, setvalues0_.set_value as set2_0_ from t_set_values setvalues0_ where setvalues0_.set_id=?  
cm.set= [b, a]  

结语

集合映射在开发过程中不会经常用到，但是要做基本的了解，理解这种映射的实现方法，是通过相对应的集合标签来实现的模型转化，很简单。截止到该篇文章，Hibernate基本的映射已经讨论完成，这些映射是对象模型转化为关系模型中经常用到的，文章对映射的用法做了详细的讨论，它们之间的关系还没有做进一步的探讨，所以下篇文章将会对映射做基本的总结展望，对映射进行对比分类。