ObjectTransformer-Plug-in

Mit dem ObjectTransformer-Plug-in können Sie Objekte im Cache serialisieren, entserialisieren und kopieren, um eine höhere Leistung zu erzielen.

Veraltetes Feature Die Schnittstelle "ObjectTransformer" wurde durch die DataSerializer-Plug-ins ersetzt, die Sie verwenden können, um beliebige Daten effizient in WebSphere eXtreme Scale zu speichern, damit vorhandene Produkt-APIs effizient mit Ihren Daten interagieren können.

Wenn Sie Leistungsprobleme in Bezug auf die Prozessorbelegung lesen, fügen Sie jeder Map ein ObjectTransformer-Plug-in hinzu. Wenn Sie kein ObjectTransformer-Plug-in bereitstellen, werden bis zu 60-70 % der gesamten Prozessorzeit mit der Serialisierung und das Kopieren von Einträgen verbracht.

Zweck

Wenn Sie das ObjectTransformer-Plug-in verwenden, können Ihre Anwendung angepasste Methoden für die folgenden Operationen bereitstellen:
  • Serialisierung und Entserialisierung des Schlüssels für einen Eintrag,
  • Serialisierung und Entserialisierung des Werts für einen Eintrag,
  • Kopieren eines Schlüssels oder eines Werts für einen Eintrag.

Wenn kein ObjectTransformer-Plug-in bereitgestellt wird, müssen Sie in der Lage sein, die Schlüssel und Werte zu serialisieren, weil das ObjectGrid eine Serialisierungs- und Entserialisierungsfolge verwendet, um die Objekte zu kopieren. Diese Methode ist kostenintensiv, und deshalb sollten Sie ein ObjectTransformer-Plug-in verwenden, wenn die Leistung kritisch ist. Der Kopiervorgang findet statt, wenn eine Anwendung ein Objekt in einer Transaktion zu ersten Mal sucht. Sie können diesen Kopiervorgang vermeiden, indem Sie den Kopiermodus der Map auf NO_COPY setzen. Mit der Kopiermoduseinstellung COPY_ON_READ können Sie die Anzahl der Kopiervorgänge reduzieren. Optimieren Sie die Kopieroperation, wenn diese von der Anwendung benötigt wird, indem Sie eine angepasste Kopiermethode in diesem Plug-in bereitstellen. Ein solches Plug-in kann den Kopieraufwand von 65−70 % auf 2/3 % der gesamten Prozessorzeit reduzieren.

Die Standardimplementierungen der Methoden "copyKey" und "copyValue" versuchen zuerst, die Methode "clone" zu verwenden, sofern diese verfügbar ist. Wenn keine Implementierung der Methode "clone" bereitgestellt wird, wird standardmäßig mit Serialisierung gearbeitet.

Die Objektserialisierung wird auch direkt verwendet, wenn eXtreme Scale im verteilten Modus ausgeführt wird. LogSequence verwendet das ObjectTransformer-Plug-in für die Serialisierung von Schlüsseln und Werten, bevor die Änderungen an die Peers im ObjectGrid übertragen werden. Sie müssen sorgfältig vorgehen, wenn Sie eine angepasste Serialisierungsmethode als Ersatz für die integrierte JDK-Serialisierung bereitstellen. Die Versionssteuerung von Objekten ist eine komplexes Thema, und es können Probleme mit der Versionskompatibilität auftreten, wenn Sie nicht sicherstellen, dass Ihre angepassten Methoden für die Versionssteuerung konzipiert sind.

Die folgende Liste enthält Details zur Serialisierung von Schlüsseln und Werten durch eXtreme Scale:
  • Wenn ein angepasstes ObjectTransformer-Plug-in geschrieben und integriert wird, ruft eXtreme Scale Methoden in der Schnittstelle "ObjectTransformer" auf, um Schlüssel und Werte zu serialisieren und Kopien von Objektschlüsseln und -werten abzurufen.
  • Wenn kein angepasstes ObjectTransformer-Plug-in verwendet wird, führt eXtreme Scale die Serialisierung und Entserialisierung von Werten nach dem Standardverfahren durch. Wenn das Standard-Plug-in verwendet wird, wird jedes Objekt als extern bereitstellbares (Externalizable) oder als serialisierbares (Serializable) Objekt implementiert.
    • Wenn das Objekt die Schnittstelle "Externalizable" unterstützt, wird die Methode "writeExternal" aufgerufen. Objekte, die als extern bereitstellbare Objekte implementiert werden, tragen zu einer besseren Leistung bei.
    • Wenn das Objekt die Schnittstelle "Externalizable" nicht unterstützt und die Schnittstelle "Serializable" implementiert, wird das Objekt mit der Methode "ObjectOutputStream" gespeichert.

Schnittstelle "ObjectTransformer" verwenden

Ein ObjectTransformer-Objekt muss die Schnittstelle "ObjectTransformer" implementieren und die folgenden allgemeinen Konventionen für ObjectGrid-Plug-ins einhalten.

Es gibt zwei Ansätze (programmgesteuerte Konfiguration und XML-Konfiguration), mit denen ein ObjectTransformer-Objekt im folgt der BackingMap-Konfiguration hinzugefügt werden kann.

ObjectTransformer-Objekt programmgesteuert integrieren

Das folgende Code-Snippet erstellt das angepasste ObjectTransformer-Objekt und fügt es einer BackingMap hinzu:
ObjectGridManager objectGridManager = ObjectGridManagerFactory.getObjectGridManager();
ObjectGrid myGrid = objectGridManager.createObjectGrid("myGrid", false);
BackingMap backingMap = myGrid.getMap("myMap");
MyObjectTransformer myObjectTransformer = new MyObjectTransformer();
backingMap.setObjectTransformer(myObjectTransformer);

ObjectTransformer durch XML-Konfiguration integrieren

Angenommen, der Klassenname der ObjectTransformer-Implementierung ist "com.company.org.MyObjectTransformer". Diese Klasse implementiert die Schnittstelle "ObjectTransformer". Eine ObjectTransformer-Implementierung kann mit der folgenden XML konfiguriert werden:
<?xml version="1.0" encoding="UTF-8"?>
<objectGridConfig xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://ibm.com/ws/objectgrid/config ../objectGrid.xsd"
    xmlns="http://ibm.com/ws/objectgrid/config">
    <objectGrids>
        <objectGrid name="myGrid">
	    <backingMap name="myMap" pluginCollectionRef="myMap" />
        </objectGrid>
    </objectGrids>

    <backingMapPluginCollections>
	<backingMapPluginCollection id="myMap">
	     <bean id="ObjectTransformer" className="com.company.org.MyObjectTransformer" />
	</backingMapPluginCollection>
    </backingMapPluginCollections>
</objectGridConfig>

Einsatzszenarien für ObjectTransformer

Sie können das ObjectTransformer-Plug-in in den folgenden Situationen verwenden:
  • Nicht serialierbares Objekt
  • Serialisierbares Objekt, aber Serialisierungsleistung muss verbessert werden
  • Schlüssel- oder Wertkopie
Im folgenden Beispiel wird ObjectGrid verwendet, um die Klasse "Stock" zu speichern:
/**
* Stock-Objekt für ObjectGrid-Demonstration
*
*
*/
public class Stock implements Cloneable {
    String ticket;
    double price;
    String company;
    String description;
    int serialNumber;
    long lastTransactionTime;
    /**
    * @return Gibt die Beschreibung zurück.
    */
    public String getDescription() {
        return description;
    }
    /**
    * @param description Die festzulegende Beschreibung.
    */
    public void setDescription(String description) {
        this.description = description;
    }
    /**
    * @return Gibt den lastTransactionTime-Wert zurück.
    */
    public long getLastTransactionTime() {
        return lastTransactionTime;
    }
    /**
    * @param lastTransactionTime Der festzulegende lastTransactionTime-Wert.
    */
    public void setLastTransactionTime(long lastTransactionTime) {
        this.lastTransactionTime = lastTransactionTime;
    }
    /**
    * @return Gibt den Preis zurück.
    */
    public double getPrice() {
        return price;
    }
    /**
    * @param price Der festzulegende Preis.
    */
    public void setPrice(double price) {
        this.price = price;
    }
    /**
    * @return Gibt den serialNumber-Wert zurück.
    */
    public int getSerialNumber() {
        return serialNumber;
    }
    /**
    * @param serialNumber Der festzulegende serialNumber-Wert.
    */
    public void setSerialNumber(int serialNumber) {
        this.serialNumber = serialNumber;
    }
    /**
    * @return Gibt das Ticket zurück.
    */
    public String getTicket() {
        return ticket;
    }
    /**
    * @param ticket Das festzulegende Ticket.
    */
    public void setTicket(String ticket) {
        this.ticket = ticket;
    }
    /**
    * @return Gibt die Firma zurück.
    */
    public String getCompany() {
        return company;
    }
    /**
    * @param company Die festzulegende Firma.
    */
    public void setCompany(String company) {
        this.company = company;
    }
    //clone
    public Object clone() throws CloneNotSupportedException
    {
        return super.clone();
    }
}

Sie können eine angepasste ObjectTransformer-Klasse für die Klasse "Stock" schreiben:

/**
* Angepasste Implementierung des ObjectGrid-ObjectTransformer-Plug-ins für Stock-Objekt
*
*/
public class MyStockObjectTransformer implements ObjectTransformer {
/* (keine Javadoc)
* @see
* com.ibm.websphere.objectgrid.plugins.ObjectTransformer#serializeKey
* (java.lang.Object,
* java.io.ObjectOutputStream)
*/
public void serializeKey(Object key, ObjectOutputStream stream) throws IOException {
    String ticket= (String) key;
    stream.writeUTF(ticket);
}

/* (keine Javadoc)
* @see com.ibm.websphere.objectgrid.plugins.
ObjectTransformer#serializeValue(java.lang.Object,
java.io.ObjectOutputStream)
*/
public void serializeValue(Object value, ObjectOutputStream stream) throws IOException {
    Stock stock= (Stock) value;
    stream.writeUTF(stock.getTicket());
    stream.writeUTF(stock.getCompany());
    stream.writeUTF(stock.getDescription());
    stream.writeDouble(stock.getPrice());
    stream.writeLong(stock.getLastTransactionTime());
    stream.writeInt(stock.getSerialNumber());
}

/* (keine Javadoc)
* @see com.ibm.websphere.objectgrid.plugins.
ObjectTransformer#inflateKey(java.io.ObjectInputStream)
*/
public Object inflateKey(ObjectInputStream stream) throws IOException, ClassNotFoundException {
    String ticket=stream.readUTF();
    return ticket;
}

/* (keine Javadoc)
* @see com.ibm.websphere.objectgrid.plugins.
ObjectTransformer#inflateValue(java.io.ObjectInputStream)
*/

public Object inflateValue(ObjectInputStream stream) throws IOException,	ClassNotFoundException {
    Stock stock=new Stock();
    stock.setTicket(stream.readUTF());
    stock.setCompany(stream.readUTF());
    stock.setDescription(stream.readUTF());
    stock.setPrice(stream.readDouble());
    stock.setLastTransactionTime(stream.readLong());
    stock.setSerialNumber(stream.readInt());
    return stock;
}

/* (keine Javadoc)
* @see com.ibm.websphere.objectgrid.plugins.
ObjectTransformer#copyValue(java.lang.Object)
*/
public Object copyValue(Object value) {
    Stock stock = (Stock) value;
    try {
        return stock.clone();
    }
    catch (CloneNotSupportedException e)
    {
        // Ausnahmenachricht anzeigen    }
}

/* (keine Javadoc)
* @see com.ibm.websphere.objectgrid.plugins.
ObjectTransformer#copyKey(java.lang.Object)
*/
public Object copyKey(Object key) {
    String ticket=(String) key;
    String ticketCopy= new String (ticket);
    return ticketCopy;
}
}
Integrieren Sie anschließend diese angepasste Klasse "MyStockObjectTransformer" in die BackingMap:
ObjectGridManager ogf=ObjectGridManagerFactory.getObjectGridManager();
ObjectGrid og = ogf.getObjectGrid("NYSE");
BackingMap bm = og.defineMap("NYSEStocks");
MyStockObjectTransformer ot = new MyStockObjectTransformer();
bm.setObjectTransformer(ot);