【劔"Tsurugi" Tips集】⼤量のトランザクションを捌く場合はセッションプールの作成を検討する【プログラミングTips】

import com.tsurugidb.iceaxe.TsurugiConnector;
import com.tsurugidb.iceaxe.session.TsurugiSession;
import jakarta.annotation.PreDestroy;
import org.springframework.stereotype.Component;

import java.io.IOException;
import java.util.Deque;
import java.util.concurrent.ConcurrentLinkedDeque;

@Component
public class TsurugiSessionPool {

  // 1, 2
  private final Deque<SessionCache> sessionCacheDeque = new
ConcurrentLinkedDeque<>();

  private final TsurugiConnector connector;

  public TsurugiSessionPool(TsurugiConnector connector) {
       this.connector = connector;
  }

  // 3
  public SessionCache getSessionCache() throws IOException {
       while (true) {
          var sessionCache = sessionCacheDeque.pollFirst();
          // 4
          if (sessionCache == null) {
              var session = connector.createSession();
              return new SessionCache(this, session);
          }
          var session = sessionCache.getSession();
          // 5
          if (session.isClosed() || !session.isAlive()) {
              // 保持しているセッションが無効な場合は取り直す
              continue;
          }
          return sessionCache;
       }
  }

  // 6
  void releaseSessionCache(SessionCache sessionCache) {
      var session = sessionCache.getSession();
      if (session.isClosed() || !session.isAlive()) {
          // 接続が無効な場合は戻さずに破棄
          return;
      }
      sessionCacheDeque.addFirst(sessionCache);
  }

  // 7
  @PreDestroy
  public void destroy() {
      for (SessionCache sessionCache : sessionCacheDeque) {
          try {
              sessionCache.getSession().close();
          } catch (IOException | InterruptedException ignore) {
               // 終了時処理なので例外が発⽣しても無視する
          }
      }
      sessionCacheDeque.clear();
  }
}

import com.tsurugidb.iceaxe.session.TsurugiSession;

import java.io.Closeable;
import java.io.IOException;

public class SessionCache implements Closeable { // 1

    private final TsurugiSessionPool ownerPool;

    private final TsurugiSession session;

    public SessionCache(TsurugiSessionPool ownerPool, TsurugiSession session) {
        this.ownerPool = ownerPool;
        this.session = session;
    }

    // 2
    public TsurugiSession getSession() {
        return session;
    }

    @Override
    public void close() throws IOException {
        ownerPool.releaseSessionCache(this);
    }
}

@Service
public class ExampleService {

    private final TsurugiSessionPool sessionPool;

    private final ExampleRepository repository;

    // 1
    public ExampleService(TsurugiSessionPool sessionPool, ExampleRepository
repository) {
        this.sessionPool = sessionPool;
        this.repository = repository;
   }

    public ExampleResponse doSomeLogic(ExampleInput input) {
        // 2
        try (SessionCache sessionCache = sessionPool.getSessionCache()) {
           // 3
           var tm = sessionCache.getSession().createTransactionManager(
                   TgTmSetting.ofAlways(TgTxOption.ofOCC(), 2);
           return tm.execute(transaction -> {
               // 1トランザクションにまとめるべき処理を実装して結果を返す
           });
        } catch (IOException | InterruptedException e) {
            throw new RuntimeException(e);
        }
    }
}