src/org/objectweb/cjdbc/controller/recoverylog/JDBCLoggerThread.java

説明を見る。

package org.objectweb.cjdbc.controller.recoverylog;

import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.util.ArrayList;

import org.objectweb.cjdbc.common.i18n.Translate;
import org.objectweb.cjdbc.common.log.Trace;

public class JDBCLoggerThread extends Thread
{
  private boolean           killed = false; // Control thread death
  private ArrayList         logQueue;
  private PreparedStatement pstmt;
  private Trace             logger;

  private class LogObject
  {
    private long    tid;
    private String  query;
    private String  login;
    private long    id;
    private boolean escapeProcessing;

    public LogObject(long id, String login, String query, long tid,
        boolean escapeProcessing)
    {
      this.id = id;
      this.login = login;
      this.query = query;
      this.tid = tid;
      this.escapeProcessing = escapeProcessing;
    }

    public long getId()
    {
      return id;
    }

    public String getLogin()
    {
      return login;
    }

    public String getQuery()
    {
      return query;
    }

    public long getTid()
    {
      return tid;
    }

    public boolean getEscapeProcessing()
    {
      return escapeProcessing;
    }
  }

  public JDBCLoggerThread(PreparedStatement pstmt, Trace logger)
  {
    super("JDBCLoggerThread");
    this.pstmt = pstmt;
    this.logger = logger;
    logQueue = new ArrayList();
  }

  public synchronized void log(long id, String login, String query, long tid,
      boolean escapeProcessing)
  {
    logQueue.add(new LogObject(id, login, query, tid, escapeProcessing));
    notify();
  }

  public synchronized void rollbackTransactions()
  {
    if (logQueue.isEmpty())
    {
      logger.debug(Translate
          .get("recovery.jdbc.loggerthread.rollback.no.transaction"));
      return;
    }
    // Find all begun transactions
    LogObject log;
    for (int i = 0; i < logQueue.size(); i++)
    {
      log = (LogObject) logQueue.get(i);
      if (log.getQuery().equalsIgnoreCase("begin"))
      {
        // Found beginning of transaction, let's roll it back
        rollbackTransaction(log.getTid());
      }
    }
  }

  public synchronized void rollbackTransaction(long tid)
  {
    logger.debug(Translate.get("recovery.jdbc.loggerthread.rollback", tid));
    LogObject logEntry;
    for (int i = 0; i < logQueue.size(); i++)
    {
      logEntry = (LogObject) logQueue.get(i);
      if (logEntry.getTid() == tid)
        logQueue.remove(i);
    }
  }

  public synchronized boolean getLogQueueIsEmpty()
  {
    if (logQueue.isEmpty())
    {
      // Notifies the Recovery log that the queue is empty.
      notify();
      return true;
    }
    else
    {
      return false;
    }
  }

  public void run()
  {
    LogObject params;

    while (!killed)
    {
      synchronized (this)
      {
        while (getLogQueueIsEmpty())
        {
          try
          {
            wait();
          }
          catch (InterruptedException e)
          {
            logger.warn(Translate.get("recovery.jdbc.loggerthread.awaken"), e);
          }
        }
        params = (LogObject) logQueue.remove(0);
        try
        {
          pstmt.setLong(1, params.getId());
          pstmt.setString(2, params.getLogin());
          pstmt.setString(3, params.getQuery());
          pstmt.setLong(4, params.getTid());
          try
          {
            pstmt.setEscapeProcessing(params.getEscapeProcessing());
          }
          catch (Exception ignore)
          {
          }
          pstmt.executeUpdate();
          if (logger.isDebugEnabled())
            logger.debug(Translate.get("recovery.jdbc.loggerthread.log.debug",
                new String[]{String.valueOf(params.getId()), params.getLogin(),
                    params.getQuery(), String.valueOf(params.getTid()),
                    String.valueOf(params.getEscapeProcessing())}));
          else if (logger.isInfoEnabled())
            logger.info(Translate.get("recovery.jdbc.loggerthread.log.info",
                params.getId()));
        }
        catch (SQLException e)
        {
          logger.error(
              Translate.get("recovery.jdbc.loggerthread.log.failed",
                  new String[]{params.getQuery(),
                      String.valueOf(params.getTid())}), e);
        }
      }
    }
  }

}

---