1. Mapeamento de coleção
1. Introdução da coleção
O mapeamento de coleções também é um mapeamento básico, mas não será usado com frequência durante o processo de desenvolvimento; portanto, não há necessidade de ter um entendimento profundo. Você só precisa entender os métodos básicos de uso. Basta poder consultar a solução quando encontrar esse problema durante o processo de desenvolvimento. Mapeamento de conjunto correspondente, de fato, refere -se ao mapeamento do conjunto em Java para a tabela correspondente. É um mapeamento de objetos de coleção. Existem quatro tipos de conjuntos em Java, como definido, mapa, listagem e matrizes comuns. Existem grandes diferenças entre eles:
(1) Definido, não deve haver objetos duplicados, os objetos são desordenados;
(2) a lista pode ser encomendada com objetos repetidos;
(3) mapa, aparece em pares de valores -chave;
(4) As matrizes podem ser repetidas e há uma ordem entre objetos.
A diferença entre eles determina qual coleção é usada durante o desenvolvimento. Geralmente, o conjunto é usado durante o desenvolvimento. Os objetos dentro dele são desnecessários e os objetos internos podem ser obtidos usando um iterador. Se esses conjuntos desejarem mapear para o modelo relacional correspondente, você deverá usar as tags de mapeamento fornecidas pelo Hibernate, <Set>, <list>, <pap> e <Array>.
2. Introdução ao mapeamento
Continue discutindo o modelo de relacionamento do mapeamento de conjuntos. O mapeamento do conjunto refere -se a um objeto correspondente a outra coleção de objetos. Ao salvar, o Hibernate salvará o conjunto de dados na tabela correspondente e salvará os dados na tabela de dados de acordo com o ID que aloca. Se uma nova tabela for atribuída ao conjunto separadamente, o ID será atribuído ao ID da tabela de set e a tabela de relacionamento correspondente será a seguinte:
3. Arquivos de classe
Como o mapeamento do conjunto é implementado através do código e o analisamos em detalhes a seguir. Aqui, selaremos todas as coleções em uma classe. Chamamos essa classe coletaMapping.java, então seu código interno correspondente é o seguinte:
pacote com.hibernate; importar java.util.list; importar java.util.map; importar java.util.set; @Suppresswarnings ("RawTypes") CLASS PUBLIC Coleção de coleta {// id private int id; public int getId () {return id; } public void setId (int id) {this.id = id; } // Nome do nome da string privada; public String getName () {Return Name; } public void setName (nome da string) {this.name = name; } // Defina a coleção Set SetValues Private Set; public set getSetValues () {return set setValues; } public void setSetSetValues (set setValues) {this.setValues = setSalues; } // Lista de listas de listas de listas privadas ListValues; list public getListValues () {return listValues; } public void setListValues (listValues) {this.ListValues = listValues; } // Coleção de matriz Private String [] ArrayValues; public String [] getArrayValues () {return ArrayValues; } public void SetArrayValues (String [] ArrayValues) {this.arrayValues = ArrayValues; } // coleta de mapa mapa privado mapvalues; mapa público getMapValues () {return mapValues; } public void setMapValues (map mapValues) {this.mapValues = mapValues; }}Esta classe encapsula vários conjuntos comumente usados. Se você deseja convertê -los em um modelo relacional, deve olhar para o mapeamento abaixo.
4. Mapeamento de coleção
O mapeamento de uma coleção é realmente bastante simples. Você só precisa adicionar as tags de coleção correspondentes. O Hibernate fornece as tags de coleção <Set>, <PAP>, <TIST> e <Array> respectivamente. A coleção é mapeada para a tabela de relacionamento correspondente usando a tag centralizada. Além disso, a associação de chaves estrangeiras é alcançada adicionando a tag <Key> e outros atributos são adicionados usando <lement>.
ColeçãoMapping.hbm.xml
<? xml versão = "1.0"?> <! Doctype Hibernate-mapping public "-// Hibernate/hibernate mapeamento dtd 3.0 // pt" "http://hibernate.sourceforge.net/hibernate" "Dtdddd.meatrcepforge.net/BERNATEM-MAPPAPP) tabela = "t_collection_mapping"> <id name = "id"> <gerator // id> <propriedade name = "name"/> <set name = "setValues" table = "t_set_values"> <key column = "set_id"> </key> <lement type = "string" = "setValVe_value"> </"se elemento" </set "> </key> <lement) =" string "=" setvalue_value "> </" <key column = "list_id"/> <list-index column = "list_index"/> <elemento tipo = "string" column = "list_value"/> </list> <name = "mapValues" table = "t_map_values"> <Key column = "map_id_id/> <pyKey type =" String "" column = "map_value"/> </map> <array name = "ArrayValues" table = "t_array_value"> <key column = "array_id"/> <index column = "array_index" type = "integer"> </index> <elemento "" ""/"/" Array_value "/">
Deve -se notar que a tag da lista e a tag de matriz. Os objetos nesses dois conjuntos estão em ordem. Portanto, ao adicionar tags de mapeamento, você precisa usar tags de índice ou índice de lista para indicar a ordem dos objetos. Além disso, ao adicionar sub-marcas, você deve adicioná-las em ordem. Ou seja, primeiro adicione a tag <Key> e adicione a tag <List-Index> e, finalmente, adicione a tag <lement>, caso contrário, o seguinte erro será exibido:
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*)".
5. Modelo relacional
O modelo de objeto configurado é convertido no modelo relacional correspondente, e a instrução SQL gerada é a seguinte:
ALTER TABELA T_ARRAY_VALUE CHAVE ESTRAGENS FK2E0DD0C067676B68 ALTER TABELA T_LIST_VALUES CHAVE CHAVE ESTRAGENS FK01EC98BF4FCB03 ALTER TABELA T_MAP_VALUES DROP CHAT FKD169BA107402B585 ALTER TABLE T_STELUES 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)) Crie Tabela T_Collection_Mapping (ID inteiro não NULL Auto_increment, nome varchar (255), chave primária (id)) Criar tabela t_list_value varchar (255), list_index integro não nulo, chave primária (list_id, list_index)), tabela t_Map_Mav_VALUES map_key varchar (255) não nula, chave primária (map_id, map_key)) criar tabela t_set_values (set_id inteiro não nulo, set_value varchar (255)) alterar tabela t_array_value add fk2e0dd0c0c0c0c0c0c0c0c0c0c0c0c060606060s60d60cd06d06d060s Índice FK2E0D0C0C0C0S (Array_id) Referências T_Collection_Mapping (ID) ALTER TABELA T_LIST_VALUES ADICIONAR INDICE FKE01EC98BF4FCB03 (LIST_ID), Adicione restrições FKE01EC98BF4FCB03 Chave estrangeira (list_id) Teus t_collection_mapping (id) alter thak (map_id), adicione restrição FKD169BA107402B585 Chave estranha (MAP_ID) REFERÊNCIAS T_COLLECTION_MAPPAP (ID) ALTER TABELA T_SET_VALUES ADICIONAR FK7BBB8D04A7E79F8BF (SET_ID), Adicionar restrição FK7BBBBBBS04A7E7E79F8BF (Set_id), restrição FK7BBBBBBS04E7E7E77 (eu ia)
A exibição de banco de dados correspondente gerada é a seguinte:
2. Operação de dados
1. Escrita de dados
Ao escrever operações de dados, você precisa prestar atenção à criação de objetos de dados ao escrever dados. Liste, definir e mapa precisam criar objetos de dados e gravar objetos de dados no banco de dados. Como os três são interfaces de objeto, você precisa criar um objeto e escrever o objeto no banco de dados. O código específico é o seguinte:
@Suppresswarnings ({"desmarcado", "RawTypes"}) public void testSave () {sessão session = null; tente {session = hibernateUtils.getSession (); session.BegIntransaction (); Coleção CM = new CollectionMapping (); cm.setName ("Zhangsan"); SET SET = new HashSet (); set.add ("A"); set.add ("b"); cm.setSetValues (set); Lista da lista = new ArrayList (); list.add ("list1"); list.add ("list2"); CM.SetListValues (lista); String [] str = new String [] {"Array1", "Array2"}; cm.setArrayValues (STR); Mapa mapa = new hashmap (); map.put ("k1", "v1"); map.put ("k2", "v2"); cm.setMapValues (mapa); session.Save (CM); session.gettransaction (). Commit (); } catch (Exceção e) {e.printStackTrace (); session.gettransaction (). rollback (); } finalmente {hibernateutils.closhessession (sessão); }}A instrução SQL gerada é a seguinte:
Hibernate: inserir em t_collection_mapping (nome) valores (?) Hibernate: insert in t_set_values (set_id, set_value) ?,?) Hibernate: inserir em t_list_values (list_id, list_index, list_value) valores (?,?,?) Hibernate: insert in t_list_values (list_id, list_index, list_value) valores (?,?,?) Hibernate: insert_list_list_list_list_values (listue) (?,?,?) Hibernate: insert_list_list_list_list_list_list_values (? Hibernato: inserir em t_map_values (map_id, map_key, map_value) valores (?,?) Hibernate: inserir em t_map_values (map_id, map_key, map_value) (? Hibernate: Insira em T_ARRAY_VALUE (Array_id, Array_index, Array_value) valores (?,?)
2. Dados de carregamento
O método de carregar dados é muito simples. Ele carregará os dados na tabela no objeto de acordo com o conjunto e, em seguida, você só precisa obter a coleção de objetos correspondente.
public void testLoad () {sessão session = null; tente {session = hibernateUtils.getSession (); session.BegIntransaction (); Coleção CM = (Coleção) 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 (Exceção e) {e.printStackTrace (); session.gettransaction (). rollback (); } finalmente {hibernateutils.closhessession (sessão); }}O resultado gerado:
Hibernate: selecione colecionamento0_.id como id0_0_, collection0_.name como name0_0_ de t_collection_mapping collection0_ where collection0_.id =? Hibernate: selecione ArrayValue0_.Array_Id como Array1_0_, ArrayValue0_.Array_Value como Array2_0_, ArrayValue0_.array_index como Array3_0_ de T_ARRAY_VALUE ArrayValue0_ Where ArrayValue0_.Array_id =? cm.name = zhangsan hibernate: selecione listValues0_.list_id como list1_0_, listValues0_.list_value como list2_0_, listValues0_.list_index como list3_0_ de t_list_values listValues0_ onde listValues_.list_id =? cm.List = [List1, List2] Hibernate: Selecione MapValues0_.map_id como map1_0_, mapValues0_.map_value como map2_0_, mapValues0_.map_key como map3_0_ de t_map_values mapvalues where mapValues_.map_id =? cm.map = {k1 = v1, k2 = v2} cm.array = [ljava.lang.string;@758d8478 hibernate: selecione setValues0_.set_id como set1_0_, setValues0_.set_value como set2_0_ de t_SetLues Setvalues Setvalues cm.set = [b, a] 3. Resumo
O hibernato pode persistir em instâncias das seguintes coleções Java, incluindo java.util.map, java.util.set, java.util.sortedmap, java.util.sortedset, java.util.list e matrizes de entidades ou valores persistentes (usando tipos de coleta de conjuntos). Propriedades do tipo java.util.Collection ou java.util.list também podem ser persistidas usando a semântica "bolsa". As coleções usadas para persistência não podem manter a semântica anexada a quaisquer classes que implementem essas interfaces, exceto a interface de coleta (por exemplo: Ordem iterativa trazida pelo LinkedHashSet). Todas as coleções persistentes realmente funcionam diretamente de acordo com a semântica de Hashmap, Hashset, Treemap, Treeset e Arraylist. Para colocá -lo mais profundamente, para uma propriedade que contém uma coleção, o tipo Java deve ser definido como uma interface (ou seja, mapa, conjunto ou list, etc.), e não deve ser hashmap, TreeSet ou ArrayList. O motivo dessa limitação é que, quando você não sabe, o Hibernate substitui secretamente seu mapa, definir e listar instâncias por sua própria implementação de mapa, conjunto ou listar. (Portanto, no seu programa, use o operador == com cautela.) (Nota: Por desempenho e outros motivos, quase todas as interfaces de coleção Java são implementadas no Hibernate (para implementar alguns recursos de carregamento preguiçoso).) Todas as classes de coleta ordenadas (mapas, listas, matrizes) têm uma chave primária composta de < -key> e <ipend>. Nesse caso, a atualização da classe de coleta é muito eficiente - a chave primária foi indexada de maneira eficaz; portanto, quando o Hibernate tenta atualizar ou excluir uma linha, os dados dessa linha podem ser encontrados rapidamente. A chave primária de um conjunto (conjuntos) consiste em <Key> e outros campos de elementos. Isso é ineficiente para alguns tipos de elementos, especialmente elementos combinados ou texto grande ou campos binários grandes; O banco de dados pode não conseguir indexar efetivamente as chaves primárias complexas. Por outro lado, para associações um para muitos e muitos, especialmente identificadores sintéticos, os conjuntos podem obter o mesmo desempenho eficiente. (Parte 1: se você deseja que o SchemaExport crie uma chave primária para o seu <Set>, você deve declarar todos os campos como não-null = "true".) O mapa <dbag> define a chave proxy, para que sempre possa ser atualizada com eficiência. De fato, <dbag> tem o melhor desempenho. A bolsa é a pior. Como a bolsa permite valores duplicados de elementos e não possui campos de índice, é impossível definir chaves primárias. O hibernato não pode determinar linhas duplicadas. Quando essa coleção for alterada, o Hibernate removerá primeiro completamente toda a coleção (através de uma única exclusão) e depois recrie toda a coleção. Portanto, a bolsa é muito ineficiente.