Hikari API

Giriş

Hikari'yi tek başına kütüphane olarak ta kullanmak mümkün. MySQL ip uçları burada. 

Loglama

Hikari SLF4J kullanıyor. 

- SLF+J kullanımı ile ilgili örnekler burada

- Adaptörler ile ilgili genel açıklama SLF4J sayfasında burada

- Eğer kendi adaptörümüzü yazmak istersek bir örnek burada. 

- Eğer hiç bir adaptör tanımlı değilse şu çıktıyı alırız

SLF4J: Failed to load class "org.slf4j.impl.StaticLoggerBinder".

SLF4J: Defaulting to no-operation (NOP) logger implementation

SLF4J: See http://www.slf4j.org/codes.html#StaticLoggerBinder for further details.

Açıklaması şöyle

If no logging dependency is provided on the classpath, it will default to a no-operation implementation and nothing gets logged.

Hikari Uyarı Mesajları

Eğer şöyle bir hata alıyorsak, 

 Executed rollback on connection ... due to dirty commit state on close().

1. connection.rollback() yapmayı unutmuşuzdur.

2. Ya da şöyle yapmışızdır. setAutoCommit(false); getMetaData() çağrısından sonra yapılmalı

// See https://github.com/brettwooldridge/HikariCP/issues/866
connection.setAutoCommit(false);
boolean supportsBatch = connection.getMetaData().supportsBatchUpdates();

Maven

Java 8 için şöyle yaparız

<dependency>
  <groupId>com.zaxxer</groupId>
  <artifactId>HikariCP</artifactId>
  <version>4.0.3</version>
</dependency>

Java 11+ için şöyle yaparız

<dependency>
  <groupId>com.zaxxer</groupId>
  <artifactId>HikariCP</artifactId>
  <version>5.0.1</version>
</dependency>

Gradle

Java 8-11 için şöyle yaparız

implementation 'com.zaxxer:HikariCP:3.4.5'

Java 17 için şöyle yaparız

implementation 'com.zaxxer:HikariCP:5.01'

Örnek - En Basit Kullanım

Gradle ile şöyle yaparız

implementation 'com.zaxxer:HikariCP:5.01'
implementation 'mysql:mysql-connector-java:8.0.27'

Ayarları okumak için şöyle yaparız

public HikariConfig getHikariConfig() {
  HikariConfig hikariConfig = new HikariConfig();

  String jdbCUrl = getJdbcUrl();
  hikariConfig.setJdbcUrl(jdbCUrl);

  Optional<String> userName = getUserName();
  userName.ifPresent(hikariConfig::setUsername);

  Optional<String> password = getPassword();
  password.ifPresent(hikariConfig::setPassword);

  Optional<Integer> maxPoolSize = getMaxPoolSize();
  maxPoolSize.ifPresent(hikariConfig::setMaximumPoolSize);

  hikariConfig.addDataSourceProperty("cachePrepStmts", "true");
  hikariConfig.addDataSourceProperty("prepStmtCacheSize", "250");
  hikariConfig.addDataSourceProperty("prepStmtCacheSqlLimit", "2048");

  return hikariConfig;
}

Daha sonra şöyle yaparız. Artık bundan sonra elimizde bir DataSource vardır.

HikariConfig hikariConfig = getHikariConfig();

HikariDataSource hikariDataSource = new HikariDataSource(hikariConfig);

HikariConfig Sınıfı

HikariConfig Sınıfı yazısına taşıdım

HikariPool Sınıfı

HikariPool Sınıfı yazısına taşıdım

Örnek - Custom Logger

Şöyle yaptım

public class MyLogger extends MarkerIgnoringBase {
  private final String name;
  public SLF4JUnifiedLogger(String name) {
    this.name = name;
  }
  private void formatAndLog(int level, String format, Object arg1, Object arg2) {
    FormattingTuple tp = MessageFormatter.format(format, arg1, arg2);
    log(level, tp.getMessage(), tp.getThrowable());
  }
  private void formatAndLog(int level, String format, Object... arguments) {
    FormattingTuple tp = MessageFormatter.arrayFormat(format, arguments);
    log(level, tp.getMessage(), tp.getThrowable());
  }
  private void log(int level, String message, Throwable throwable) {
    String levelStr = renderLevel(level);

    StringBuilder stringBuilder = new StringBuilder(32);
    stringBuilder.append(levelStr);
    stringBuilder.append(' ');
    // Append the message
    stringBuilder.append(message);
    if (throwable != null) {
      PrintWriter printWriter = ...
      throwable.printStackTrace(printWriter);
      stringBuilder.append(stringWriter);
    }
    ...
  }
 
  @Override
  public void trace(String msg) {
    log(LOG_LEVEL_TRACE, msg, null);
  }
  ...
}

renderLevel şöyle

protected String renderLevel(int level) {
  switch (level) {
    case LOG_LEVEL_TRACE:
      return "TRACE";
    case LOG_LEVEL_DEBUG:
      return ("DEBUG");
    case LOG_LEVEL_INFO:
      return "INFO";
    case LOG_LEVEL_WARN:
      return "WARN";
    case LOG_LEVEL_ERROR:
      return "ERROR";
    }
    throw new IllegalStateException("Unrecognized level [" + level + "]");
  }

Factory şöyle

public class MyLoggerFactory implements ILoggerFactory {

  final ConcurrentMap<String, MyLogger> loggerMap;

  public MyLoggerFactory() {
    loggerMap = new ConcurrentHashMap<>();
  }

  public void setTracer(ITracer tracer) {
    this.tracer = tracer;
    loggerMap.forEach((k, v) -> v.setTracer(tracer));
  }

  @Override
  public Logger getLogger(String name) {
    return loggerMap.computeIfAbsent(name, k -> {
      MyLogger myLogger = new MyLogger(name);
      myLogger.setTracer(tracer);
      return myLogger;
    });
  }
}

StaticLoggerBinder şöyle

public class StaticLoggerBinder implements LoggerFactoryBinder  {

  private static final StaticLoggerBinder SINGLETON = new StaticLoggerBinder();

  public static final StaticLoggerBinder getSingleton() {
    return SINGLETON;
  }
  
  //Declare the version of the SLF4J API this implementation is compiled against.
  //The value of this field is modified with each major release.
  public static String REQUESTED_API_VERSION = "1.6.99"; // !final
  
  private static final String loggerFactoryClassStr = MyLoggerFactory.class.getName();
  
  private final MyLoggerFactory loggerFactory;
  
  private StaticLoggerBinder() {
    loggerFactory = new MyLoggerFactory();
  }
  
  public void setTracer(ITracer tracer) {
    loggerFactory.setTracer(tracer);
  }
  
  @Override
  public ILoggerFactory getLoggerFactory() {
    return loggerFactory;
  }
  
  @Override
  public String getLoggerFactoryClassStr() {
    return loggerFactoryClassStr;
  }
}