Zugriff auf Daten mit Indizes (API Index)

Für einen effizienteren Datenzugriff können Sie mit Indexierung arbeiten.

Informationen zu diesem Vorgang

Die Klasse HashIndex ist die integrierte Index-Plug-in-Implementierung, die beide integrierten Anwendungsindexschnittstellen, MapIndex und MapRangeIndex, unterstützen kann. Sie können auch eigene Indizes erstellen. Sie können HashIndex als statischen oder dynamischen Index in der BackingMap hinzufügen, ein MapIndex- oder MapRangeIndex-Index-Proxy-Objekt abrufen und das Index-Proxy-Objekt zum Suchen zwischengespeicherter Objekte verwenden.

Wenn Sie durch die Schlüssel in einer lokalen Map iterieren möchten, können Sie den Standardindex verwenden. Dieser Index erfordert keine Konfiguration, aber er muss für das Shard über einen Agenten oder eine ObjectGrid-Instanz, die mit der Methode ShardEvents.shardActivated(ObjectGrid shard) abgerufen wird, verwendet werden.

Anmerkung: Wenn das Indexobjekt in einer verteilten Umgebung von einem Client-ObjectGrid abgerufen wird, hat es den Typ "Clientindexobjekt", und alle Indexoperationen werden in einem fernen Server-ObjectGrid ausgeführt. Wenn die Map partitioniert ist, werden die Indexoperationen in jeder Partition über Fernzugriff aufgeführt. Die Ergebnisse für alle Partitionen werden zusammengeführt, bevor die Ergebnisse an die Anwendung zurückgegeben werden. Die Leistung richtet sich nach der Anzahl der Partitionen und der Größe des von jeder einzelnen Partition zurückgegebenen Ergebnisses. Die Leistung kann schwach sein, wenn beide Faktoren hoch sind.

Vorgehensweise

  1. Wenn Sie andere Indizes als den lokalen Index verwenden möchten, fügen Sie der BackingMap Index-Plug-ins hinzu.
    • XML-Konfiguration:
      <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>

      In diesem XML-Konfigurationsbeispiel wird die integrierte Klasse HashIndex als Index-Plug-in verwendet. Die Klasse HashIndex unterstützt Eigenschaften, die die Benutzer konfigurieren können, wie z. B. Name, RangeIndex und AttributeName aus dem vorherigen Beispiel.

      • Die Eigenschaft Name ist als CODE konfiguriert, einer Zeichenfolge, die dieses Index-Plug-in identifiziert. Der Wert der Eigenschaft "Name" muss innerhalb des Geltungsbereichs der BackingMap eindeutig sein und kann verwendet werden, um das Indexobjekt nach Namen von der ObjectMap-Instanz für die BackingMap abzurufen.
      • Die Eigenschaft RangeIndex ist mit true konfiguriert, d. h., die Anwendung kann das abgerufene Indexobjekt in die Schnittstelle MapRangeIndex umsetzen. Wird die Eigenschaft "RangeIndex" mit dem Wert false konfiguriert, kann die Anwendung das abgerufene Indexobjekt nur in die Schnittstelle MapIndex umsetzen. MapRangeIndex unterstützt Funktionen, mit denen Sie Daten über Bereichsfunktionen, wie z. B. größer als und/oder kleiner als, suchen können, wohingegen die Schnittstelle "MapIndex" nur Vergleichsfunktionen unterstützt. Wenn der Index von einer Abfrage verwendet wird, muss die Eigenschaft RangeIndex für Einzelattributindizes mit true konfiguriert werden. Für einen Beziehungsindex oder einen zusammengesetzten Index muss die Eigenschaft "RangeIndex" mit false konfiguriert werden.
      • Die Eigenschaft AttributeName ist mit employeeCode konfiguriert, d. h., das Attribut employeeCode des zwischengespeicherten Objekts wird verwendet, um einen Einzelattributindex zu erstellen. Wenn eine Anwendung zwischengespeicherte Objekte mit mehreren Attributen suchen muss, kann die Eigenschaft AttributeName auf eine durch Kommas begrenzte Liste mit Attributen gesetzt werden. Dies ergibt dann einen zusammengesetzten Index.
    • Programmgesteuerte Konfiguration:

      Die Schnittstelle "BackingMap"" hat zwei Methoden, die Sie verwenden können, um statische Index-Plug-ins hinzuzufügen: addMapIndexplugin und setMapIndexplugins. Weitere Informationen finden Sie in API "BackingMap". Im folgenden Beispiel wird dieselbe Konfiguration wie im XML-Konfigurationsbeispiel erstellt:

      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");
      
          // Integrierte Klasse "HashIndex" als Index-Plug-in-Klasse verwenden
          HashIndex mapIndexplugin = new HashIndex();
          mapIndexplugin.setName("CODE");
          mapIndexplugin.setAttributeName("EmployeeCode");
          mapIndexplugin.setRangeIndex(true);
          personBackingMap.addMapIndexplugin(mapIndexplugin);
  2. Zugriff auf Map-Schlüssel und -Werte mit Indizes.
    • Lokaler Indes:
      Wenn Sie durch die Schlüssel und Werte in einer lokalen Map iterieren möchten, können Sie den Standardindex verwenden. Der Standardindex arbeitet unter Verwendung eines Agenten oder der mit der Methode ShardEvents.shardActivated(ObjectGrid shard) abgerufenen ObjectGrid-Instanz mit einem Shard. Sehen Sie sich das folgende Beispiel an:
      MapIndex keyIndex = (MapIndex)
      objMap.getIndex(MapIndexPlugin.SYSTEM_KEY_INDEX_NAME);
      Iterator keyIterator = keyIndex.findAll();
    • Statische Indizes:

      Nachdem Sie einer BackingMap-Konfiguration ein statisches Index-Plug-in hinzugefügt und die übergeordnete ObjectGrid-Instanz initialisiert haben, können Anwendungen das Indexobjekt nach Namen von der ObjectMap-Instanz für die BackingMap abrufen. Setzen Sie das Indexobjekt in die Anwendungsindexschnittstelle um. Operationen, die von der Anwendungsindexschnittstelle unterstützt werden, können jetzt ausgeführt werden.

      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();
    • Dynamische Indizes:

      Sie können dynamische Indizes jederzeit über das Programm in einer BackingMap erstellen und entfernen. Ein dynamischer Index unterscheidet sich insofern von einem statischen Index, dass der dynamische Index auch nach der Initialisierung der übergeordneten ObjectGrid-Instanz erstellt werden kann. Anders als die statische Indexierung ist die dynamische Indexierung ein asynchroner Prozess, der im Status "Bereit" sein muss, damit Sie in verwenden können. Diese Methode verwendet denselben Ansatz für das Abrufen und Verwenden der dynamischen Indizes wie für statische Indizes. Sie können einen dynamischen Index entfernen, wenn er nicht mehr benötigt wird. Die Schnittstelle BackingMap hat Methoden zum Erstellen und Entfernen dynamischer Indizes.

      Weitere Einzelheiten zu den Methoden createDynamicIndex und removeDynamicIndex finden Sie in API BackingMap.

      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();
      
              // Index nach der Initialisierung des ObjectGrids ohne DynamicIndexCallback erstellen
              bm.createDynamicIndex("CODE", true, "employeeCode", null);
      
              try  {    
                  // Wenn DynamicIndexCallback nicht verwendet wird, warten, bis der Index bereit ist.
                  // Die Wartezeit richtet sich nach der aktuellen Größe der Map.
                  Thread.sleep(3000);
              } catch (Throwable t) {
                  // ...
              }
      
              // Wenn der Index bereit ist, können Anwendungen versuchen, eine Instanz der
              // Anwendungsindexschnittstelle abzurufen.
              // Anwendungen müssen einen Weg finden, um sicherzustellen, dass der Index
              // zur Verwendung bereit ist, wenn die Schnittstelle "DynamicIndexCallback"
              // nicht verwendet wird.
              // Das folgende Beispiel demonstriert eine Methode, mit der auf
              // die Bereitschaft des Index gewartet wird.
              // Berücksichtigen Sie die Größe der Map bei der Berechnung der Gesamtwartezeit.
      
              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) {
                      // Impliziert, dass der Index nicht bereit ist...
                      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.");
              }
      
              // Verwenden Sie den Index für Abfragen.
              // Die unterstützen Operationen finden Sie in den Beschreibungen der
              // Schnittstellen "MapIndex" und "MapRangeIndex".
              // Das Objektattribut, nach dem der Index erstellt wird, ist EmployeeCode.
              // Nehmen Sie an, dass das Attribut "EmployeeCode" den Datentyp "Integer" hat.
              // Der Parameter, der an Indexoperationen übergeben wird, hat diesen Datentyp.
      
              Iterator iter = codeIndex.findLessEqual(new Integer(15));
      
              // Entfernen Sie den dynamischen Index, wenn er nicht mehr benötigt wird.
      
              bm.removeDynamicIndex("CODE");	// Close the session (optional in Version 7.1.1 and later) for improved performance
      	session.close();

Nächste Schritte

Sie können die Schnittstelle DynamicIndexCallback verwenden, um Benachrichtigungen über Indexierungsereignisse zu erhalten. Weitere Informationen finden Sie unter Schnittstelle DynamicIndexCallback.