Acessando Dados com Índices (API de Índice)

Use indexação para acesso a dados mais eficiente.

Sobre Esta Tarefa

A classe HashIndex é a implementação de plug-in de índice integrada que pode suportar ambas as interfaces integradas de índice a seguir: MapIndex e MapRangeIndex. Também é possível criar seus próprios índices. É possível incluir HashIndex como um índice estático ou dinâmico no mapa de apoio, obter um objeto proxy do índice MapIndex ou MapRangeIndex e usar o objeto proxy do índice para localizar objetos em cache.

Se desejar iterar por meio das chaves em um mapa local, o índice padrão poderá ser usado. Este índice não requer nenhuma configuração, porém ele deve ser usado com relação ao shard, usando um agente ou uma instância do ObjectGrid recuperados a partir do método ShardEvents.shardActivated(shard do ObjectGrid).

Nota: Em um ambiente distribuído, se o objeto do índice for obtido de um cliente do ObjectGrid, o índice possuirá um objeto de índice do tipo cliente e todas as operações de índice executadas em um ObjectGrid do servidor remoto. Se o mapa for particionado, as operações de índice executarão em cada partição remotamente. Os resultados de cada partição são mesclados antes de retornar os resultados para o aplicativo. O desempenho é determinado pelo número de partições e pelo tamanho do resultado retornado por cada partição. Um desempenho insuficiente poderá ocorrer se ambos os fatores forem altos.

Procedimento

  1. Se desejar usar índices diferente do índice local padrão, inclua plug-ins de índice no mapa de apoio.
    • Configuração XML:
      <backingMapPluginCollection id="person">
           <bean id="MapIndexplugin" 
      			className="com.ibm.websphere.objectgrid.plugins.index.HashIndex">
               <property name="Name" type="java.lang.String" value="CODE" description="index name" />
               <property name="RangeIndex" type="boolean" value="true" 
      						description="true for MapRangeIndex" />
               <property name="AttributeName" type="java.lang.String" value="employeeCode" description="attribute name" />
           </bean>
      </backingMapPluginCollection>

      Neste exemplo de configuração XML, a classe HashIndex integrada é usada como o plug-in de índice. A classe HashIndex suporta propriedades que os usuários podem configurar, como Name, RangeIndex e AttributeName no exemplo anterior.

      • A propriedade Name é configurada como CODE, uma sequência que identifica este plug-in de índice. O valor da propriedade Name deve ser único dentro do escopo do BackingMap, e pode ser usado para recuperar o objeto do índice pelo nome a partir da instância de ObjectMap para o BackingMap.
      • A propriedade RangeIndex é configurada como true, o que significa que o aplicativo pode efetuar cast do objeto do índice recuperado para a interface MapRangeIndex. Se a propriedade RangeIndex for configurada como false, o aplicativo poderá apenas efetuar cast do objeto do índice recuperado para a interface MapIndex. Um MapRangeIndex suporta funções para localizar dados usando funções de intervalo, como maior que, menor que, ou ambas, enquanto um MapIndex suporta apenas funções iguais. Se o índice for usado por consulta, a propriedade RangeIndex deverá ser configurada para true em índices de atributo único. Para um índice de relacionamento e um índice composto, a propriedade RangeIndex deve ser configurada para false.
      • A propriedade AttributeName é configurada como employeeCode, o que significa que o atributo employeeCode do objeto em cache é usado para construir um índice de atributo único. Se um aplicativo precisar procurar por objetos em cache com diversos atributos, a propriedade AttributeName poderá ser configurada para uma lista de atributos delimitados por vírgula, rendendo um índice composto.
    • Configuração programática:

      A interface BackingMap tem dois métodos que podem ser usados para incluir plug-ins de índice estático: addMapIndexplugin e setMapIndexplugins. Para obter mais informações, consulte API do BackingMap . O exemplo a seguir cria a mesma configuração que o exemplo de configuração XML :

      import com.ibm.websphere.objectgrid.ObjectGridManagerFactory;
      import com.ibm.websphere.objectgrid.ObjectGridManager;
      import com.ibm.websphere.objectgrid.ObjectGrid;
      import com.ibm.websphere.objectgrid.BackingMap;
      
          ObjectGridManager ogManager = ObjectGridManagerFactory.getObjectGridManager();
          ObjectGrid ivObjectGrid = ogManager.createObjectGrid( "grid" );
          BackingMap personBackingMap = ivObjectGrid.getMap("person");
      
          //utilize a classe HashIndex interna como a classe de plugin do índice.
          HashIndex mapIndexplugin = new HashIndex();
          mapIndexplugin.setName("CODE");
          mapIndexplugin.setAttributeName("EmployeeCode");
          mapIndexplugin.setRangeIndex(true);
          personBackingMap.addMapIndexplugin(mapIndexplugin);
  2. Acesse as chaves e valores de mapa com índices.
    • Índice de local:
      Para iterar por meio das chaves e valores em um mapa local, o índice padrão poderá ser usado. O índice padrão funciona apenas com relação ao shard, usando um agente ou usando a instância do ObjectGrid recuperados com o método ShardEvents.shardActivated(shard do ObjectGrid). Consulte o seguinte exemplo:
      MapIndex keyIndex = (MapIndex)
      objMap.getIndex(MapIndexPlugin.SYSTEM_KEY_INDEX_NAME);
      Iterator keyIterator = keyIndex.findAll();
    • Índices estáticos:

      Após um plug-in de índice estático ser incluído em uma configuração de BackingMap e a instância de ObjectGrid de abrangência ser inicializada, os aplicativos podem recuperar o objeto do índice por nome a partir da instância do ObjectMap para o BackingMap. Lance o objeto de índice para a interface de índice do aplicativo. As operações que a interface do índice do aplicativo suporta podem executar agora.

      Session session = ivObjectGrid.getSession();
      ObjectMap map = session.getMap("person");
      MapRangeIndex codeIndex = (MapRangeIndex) m.getIndex("CODE");
      Iterator iter = codeIndex.findLessEqual(new Integer(15));
      while (iter.hasNext()) {
      		Object key = iter.next();
      		Object value = map.get(key);
      }
      // Close the session (optional in Version 7.1.1 
      and later) for improved performance
      session.close();
    • Índices dinâmicos:

      É possível criar e remover índices dinâmicos a partir de uma instância do BackingMap programaticamente a qualquer momento. Um índice dinâmico se difere de um índice estático porque o índice dinâmico pode ser criado mesmo depois que a instância do ObjectGrid de abrangência tiver sido inicializada. Diferentemente da indexação estática, a indexação dinâmica é um processo assíncrono e precisa estar em estado de pronto antes de ser usada. Este método utiliza a mesma abordagem para recuperação e utilização de índices dinâmicos como índices estáticos. É possível remover um índice dinâmico se ele não for mais necessário. A interface BackingMap possui métodos para criar e remover índices dinâmicos.

      Consulte a API BackingMap para obter mais informações sobre os métodos createDynamicIndex e removeDynamicIndex.

      import com.ibm.websphere.objectgrid.ObjectGridManagerFactory;
      import com.ibm.websphere.objectgrid.ObjectGridManager;
      import com.ibm.websphere.objectgrid.ObjectGrid;
      import com.ibm.websphere.objectgrid.BackingMap;
      
              ObjectGridManager ogManager = ObjectGridManagerFactory.getObjectGridManager();
              ObjectGrid og = ogManager.createObjectGrid("grid");
              BackingMap bm = og.getMap("person");
              og.initialize();
      
              // create index after ObjectGrid initialization without DynamicIndexCallback.
              bm.createDynamicIndex("CODE", true, "employeeCode", null);
      
              try {
                  //Se não estiver utilizando DynamicIndexCallback, será necessário aguardar que o Índice esteja pronto.
                  //O tempo de espera depende do tamanho atual do mapa
                  Thread.sleep(3000);
              } catch (Throwable t) {
                  // ...
              }
      
              // When the index is ready, applications can try to get application index
              // interface instance.
              // Applications have to find a way to ensure that the index is ready to use,
              // if not using DynamicIndexCallback interface.
              // The following example demonstrates the way to wait for the index to be ready
              // Consider the size of the map in the total waiting time.
      
              Session session = og.getSession();
              ObjectMap m = session.getMap("person");
              MapRangeIndex codeIndex = null;
      
              int counter = 0;
              int maxCounter = 10;
              boolean ready = false;
              while(!ready && counter < maxCounter){
                  try {
                      counter++;
                      codeIndex = (MapRangeIndex) m.getIndex("CODE");
                      ready = true;
                  } catch (IndexNotReadyException e) {
                      // implies index is not ready, ...
                      System.out.println("Index is not ready. continue to wait.");
                      try {
                          Thread.sleep(3000);
                      } catch (Throwable tt) {
                          // ...
                      }
                  } catch (Throwable t) {
                      // unexpected exception
                      t.printStackTrace();
                  }
              }
      
              if(!ready){
                  System.out.println("Index is not ready.  Need to handle this situation.");
              }
      
              // Use the index to peform queries
              // Refer to the MapIndex or MapRangeIndex interface for supported operations.
              // The object attribute on which the index is created is the EmployeeCode.
              // Assume that the EmployeeCode attribute is Integer type: the
              // parameter that is passed into index operations has this data type.
      
              Iterator iter = codeIndex.findLessEqual(new Integer(15));
      
              // remove the dynamic index when no longer needed
      
              bm.removeDynamicIndex("CODE");
      	// Close the session (optional in Version 7.1.1 and 
      later) for improved performance
      session.close();

O que Fazer Depois

É possível usar a interface DynamicIndexCallback para obter notificações nos eventos de indexação. Consulte o Interface DynamicIndexCallback para obter informações adicionais.