How to use

onDemand

method

in

org.skife.jdbi.v2.DBI

@Override
public Iterable<Map.Entry<String, String>> fetch(final Iterable<String> keys)
{
 QueryKeys queryKeys = dbi.onDemand(QueryKeys.class);
 return queryKeys.findNamesForIds(Lists.newArrayList(keys), table, keyColumn, valueColumn);
}

 @Override
 protected void run(Bootstrap<WhisperServerConfiguration> bootstrap,
           Namespace namespace,
           WhisperServerConfiguration config)
   throws Exception
 {
  DataSourceFactory messageDbConfig = config.getMessageStoreConfiguration();
  DBI               messageDbi      = new DBI(messageDbConfig.getUrl(), messageDbConfig.getUser(), messageDbConfig.getPassword());

  messageDbi.registerArgumentFactory(new OptionalArgumentFactory(messageDbConfig.getDriverClass()));
  messageDbi.registerContainerFactory(new ImmutableListContainerFactory());
  messageDbi.registerContainerFactory(new ImmutableSetContainerFactory());
  messageDbi.registerContainerFactory(new OptionalContainerFactory());

  Messages messages  = messageDbi.onDemand(Messages.class);
  long     timestamp = System.currentTimeMillis() - TimeUnit.DAYS.toMillis(90);

  logger.info("Trimming old messages: " + timestamp + "...");
  messages.removeOld(timestamp);

  Thread.sleep(3000);
  System.exit(0);
 }
}

dbi.registerContainerFactory(new OptionalContainerFactory());
Accounts accounts  = dbi.onDemand(Accounts.class);
long     yesterday = TimeUnit.MILLISECONDS.toDays(System.currentTimeMillis()) - 1;
long     monthAgo  = yesterday - 30;

messageDbi.registerContainerFactory(new OptionalContainerFactory());
Accounts        accounts        = dbi.onDemand(Accounts.class       );
Keys            keys            = dbi.onDemand(Keys.class           );
PendingAccounts pendingAccounts = dbi.onDemand(PendingAccounts.class);
Messages        messages        = messageDbi.onDemand(Messages.class);

dbi.registerContainerFactory(new OptionalContainerFactory());
Accounts            accounts        = dbi.onDemand(Accounts.class);
ReplicatedJedisPool cacheClient     = new RedisClientFactory(configuration.getCacheConfiguration().getUrl(), configuration.getCacheConfiguration().getReplicaUrls()).getRedisClientPool();
ReplicatedJedisPool redisClient     = new RedisClientFactory(configuration.getDirectoryConfiguration().getRedisConfiguration().getUrl(), configuration.getDirectoryConfiguration().getRedisConfiguration().getReplicaUrls()).getRedisClientPool();

@Override
public PostgresHistoryJDBI get() {
 return dbi.onDemand(PostgresHistoryJDBI.class);
}

@Override
public MySQLHistoryJDBI get() {
 return dbi.onDemand(MySQLHistoryJDBI.class);
}

dbi.registerContainerFactory(new OptionalContainerFactory());
Accounts            accounts        = dbi.onDemand(Accounts.class);
ReplicatedJedisPool cacheClient     = new RedisClientFactory(configuration.getCacheConfiguration().getUrl(), configuration.getCacheConfiguration().getReplicaUrls()).getRedisClientPool();
ReplicatedJedisPool redisClient     = new RedisClientFactory(configuration.getDirectoryConfiguration().getRedisConfiguration().getUrl(), configuration.getDirectoryConfiguration().getRedisConfiguration().getReplicaUrls()).getRedisClientPool();

DBI        abusedb    = dbiFactory.build(environment, config.getAbuseDatabaseConfiguration(), "abusedb");
Accounts         accounts         = database.onDemand(Accounts.class       );
PendingAccounts  pendingAccounts  = database.onDemand(PendingAccounts.class);
PendingDevices   pendingDevices   = database.onDemand(PendingDevices.class );
Keys             keys             = database.onDemand(Keys.class           );
Messages         messages         = messagedb.onDemand(Messages.class);
AbusiveHostRules abusiveHostRules = abusedb.onDemand(AbusiveHostRules.class);

  private AccessToken rotateToken()
  {
    if (tokens.isEmpty()) {
      tokens = dbi.onDemand(AccessTokenDao.class).allEnabledTokens();
    }
    return tokens.remove(0); // TODO: handle no tokens
  }
}

public GitHubClient buildForUser(Integer userId)
{
  AccessToken token = dbi.onDemand(AccessTokenDao.class).findByUserId(userId);
  return new GitHubClient(token.getToken());
}

@Test
public void testOnDemandDao() throws Exception
{
  DBI dbi = new DBI("jdbc:h2:mem:" + UUID.randomUUID());
  MyDAO dao = dbi.onDemand(MyDAO.class);
}

@BeforeClass(groups = "slow")
public void beforeClass() throws Exception {
  super.beforeClass();
  sqlDao = getDBI().onDemand(PersistentBusSqlDao.class);
}

@Test
public void testFinalizeDoesntConnect() throws Exception
{
  final UselessDao dao = dbi.onDemand(UselessDao.class);
  dao.finalize(); // Normally GC would do this, but just fake it
}

@Test
public void testSimpleTransactionsSucceed() throws Exception
{
  final SomethingDao dao = dbi.onDemand(SomethingDao.class);
  dao.insertInSingleTransaction(10, "Linda");
}

@Test
public void testNoErrorOnNoData() throws Exception
{
  Kabob bob = dbi.onDemand(Kabob.class);
  Something henning = bob.find(1);
  assertThat(henning, nullValue());
  List<Something> rs = bob.listAll();
  assertThat(rs.isEmpty(), equalTo(true));
  Iterator<Something> itty = bob.iterateAll();
  assertThat(itty.hasNext(), equalTo(false));
}

@Test
public void testRegisterMapperAnnotationWorks() throws Exception
{
  Kabob bob = dbi.onDemand(Kabob.class);
  bob.insert(1, "Henning");
  Something henning = bob.find(1);
  assertThat(henning, equalTo(new Something(1, "Henning")));
}

@Test
public void testWithSqlObjectSetReturnValue() throws Exception
{
  Dao dao = dbi.onDemand(Dao.class);
  dao.insert(new Something(1, "Coda"));
  dao.insert(new Something(2, "Brian"));
  Set<String> rs = dao.findAllAsSet();
  assertThat(rs, equalTo((Set<String>)ImmutableSet.of("Coda", "Brian")));
}

@Test
public void testTransactionPropagates() throws Exception
{
  Foo foo = dbi.onDemand(Foo.class);
  try {
    foo.insertAndFail(1, "Jeff");
    fail("should have raised an exception");
  }
  catch (Exception e){}
  Something n = foo.createBar().findById(1);
  assertThat(n, nullValue());
}

@Test
public void testOnDemandSpiffy() throws Exception
{
  Spiffy spiffy = dbi.onDemand(Spiffy.class);
  spiffy.insert(new Something(1, "Tim"));
  spiffy.insert(new Something(2, "Diego"));
  assertEquals("Diego", spiffy.findNameById(2));
}