Implementierung eines robusten Wiederholungsmechanismus für GridDB -Transaktionen mit detailliertem Protokollieren in Ja ⇐ Java

[Anonymous]

Ich entwickle eine auf GridDB-basierte Anwendung in Java. Gelegentlich scheitern Transaktionen aufgrund von Zeitüberschreitungen oder transienten Fehlern. com.toshiba.mwcloud.gs.*;
import org.apache.logging.log4j.logmanager; LogManager.getLogger (transactionRetryExample.class); < /p>
public static void main(String[] args) {
GridStore store = null;
try {
// Connect to GridDB
Properties props = new Properties();
props.setProperty("host", "127.0.0.1");
props.setProperty("port", "31999");
props.setProperty("clusterName", "myCluster");
props.setProperty("username", "admin");
props.setProperty("password", "admin_pass");

store = GridStoreFactory.getInstance().getStore(props);
logger.info("Connected to GridDB.");
} catch (GSException e) {
logger.error("Connection failed:", e);
return;
}

String containerName = "TransactionTest";
final int maxRetries = 3;
int attempt = 0;
boolean success = false;

while (attempt < maxRetries && !success) {
attempt++;
try {
store.beginTransaction();
Container container = store.getContainer(containerName);
Object[] row = {"sampleKey", "sampleValue"};
container.put(row);
store.commitTransaction();

logger.info("Transaction committed on attempt " + attempt);
success = true;
} catch (GSException e) {
logger.warn("Transaction failed on attempt " + attempt + ": " + e.getMessage());
try {
store.abortTransaction();
} catch (GSException abortEx) {
logger.error("Failed to abort transaction: ", abortEx);
}

try {
Thread.sleep(1000);
} catch (InterruptedException ie) {
logger.error("Sleep interrupted:", ie);
}
}
}

if (!success) {
logger.error("Transaction failed after " + maxRetries + " attempts.");
}
}
< /code>
} `< /p>
Ich habe eine Wiederholungsschleife mit bis zu 3 Versuchen implementiert. Zeitüberschreitungen für Netzwerk. Ich bin mir jedoch nicht sicher, welche Ausnahmen wirklich transient und sicher wiederholen können, gegenüber welchen auf einen nicht wiederbezogenen Fehler hinweisen. /> Was sind in einer Umgebung mit mehreren Threads empfohlen, um doppelte Operationen bei der Wiederholung von Transaktionen zu vermeiden (z. B. Idempotenzstrategien, einzigartige Schlüssel)? Die Best -Practices von Protokollieren) werden nicht vollständig beschrieben. Ich würde mich freuen, Erkenntnisse oder Muster, die andere erfolgreich verwendet haben.