description = 'micro-dbcp'

dependencies {

compile group: 'org.apache.commons', name: 'commons-dbcp2', version:'2.1'

compile project(':micro-core')

compile project(':micro-jdbc')

testCompile project(':micro-client')

testCompile project(':micro-grizzly')

testCompile project(':micro-jersey')

testCompile group: 'org.hsqldb', name:'hsqldb', version:'2.0.0'

}

modifyPom {

project {

name 'Microserver dbcp'

description 'Opinionated rest microservices'

url 'https://github.com/aol/micro-server'

inceptionYear '2015'

groupId 'com.aol.microservices'

artifactId 'micro-dbcp'

version "$version"

scm {

url 'scm:git@github.com:aol/micro-server.git'

connection 'scm:git@github.com:aol/micro-server.git'

developerConnection 'scm:git@github.com:aol/micro-server.git'

}

licenses {

license {

name 'The Apache Software License, Version 2.0'

url 'http://www.apache.org/licenses/LICENSE-2.0.txt'

distribution 'repo'

}

}

developers {

developer {

id 'johnmcclean-aol'

name 'John McClean'

email 'john.mcclean@teamaol.com'

}

developer {

id 'kewangie'

name 'Ke Wang'

email 'ke.wang@teamaol.com'

}

developer {

id 'earlzero'

name 'Nikita Sapozhnikov'

email 'nikita.sapozhnikov@teamaol.com'

}

}

}

}

extraArchive {

sources = true

tests = true

javadoc = true

}

nexus {

sign = true

repositoryUrl = 'https://oss.sonatype.org/service/local/staging/deploy/maven2'

snapshotRepositoryUrl = 'https://oss.sonatype.org/content/repositories/snapshots'

}

[micro-hikaricp example apps](https://github.com/aol/micro-server/tree/master/micro-jdbc/src/test/java/app)

Creates a DataSource Spring Bean with name "mainDataSource". This will be based on [DBCP2](https://commons.apache.org/proper/commons-dbcp/).

[](https://maven-badges.herokuapp.com/maven-central/com.aol.microservices/micro-jdbc)

Simply add to the classpath

Maven

<dependency>

<groupId>com.aol.microservices</groupId>

<artifactId>micro-dbcp</artifactId>

<version>x.yz</version>

</dependency>

Gradle

compile 'com.aol.microservices:micro-dbcp:x.yz'

A datasource can be configured by setting the following properties in application.properties, instance.properties or via the Microserver annotation

db.connection.driver: (e.g. (org.hsqldb.jdbcDriver)

db.connection.url: (e.g. jdbc:hsqldb:mem:aname)

db.connection.username: (e.g. admin)

db.connection.password: (e.g. password)

db.connection.dialect: (e.g. org.hibernate.dialect.HSQLDialect)

db.connection.hibernate.showsql: (e.g. true | false)

db.connection.ddl.auto: (e.g. create-drop)

dbcp.db.test.on.borrow: (e.g. true | false)

dbcp.db.validation.query: (e.g. SELECT 1)

dbcp.db.max.total: (e.g. -1)

dbcp.db.min.evictable.idle.time: (e.g. 1800000)

dbcp.db.time.between.eviction.runs: (e.g. 1800000)

dbcp.db.num.tests.per.eviction.run: (e.g. 3)

dbcp.db.test.while.idle: (e.g. true | false)

dbcp.db.test.on.return: (e.g. true | false)

The Microserver annotation can also be used to set some default properties, or they can be set in an application.properties or instance.properties file ([see wiki for more details](https://github.com/aol/micro-server/wiki/Defining-Properties)).

The important properties for us to set are the datasource properties

@Microserver(properties={"db.connection.driver","org.hsqldb.jdbcDriver",

"db.connection.url","jdbc:hsqldb:mem:aname",

"db.connection.username", "sa"})

public class MyMainClass {

}

package com.aol.micro.server.spring;

import java.util.Arrays;

import java.util.HashSet;

import java.util.Set;

import java.util.function.Function;

import javax.servlet.ServletContextListener;

import com.aol.micro.server.Plugin;

import com.aol.micro.server.servers.model.ServerData;

import com.aol.micro.server.spring.datasource.DBCPConfig;

import com.aol.micro.server.spring.datasource.DBCPDataSourceBuilder;

public class DBCPPlugin implements Plugin {

@Override

public Set<Class> springClasses() {

return new HashSet<>(Arrays.asList(DBCPConfig.class, DBCPDataSourceBuilder.class));

}

@Override

public Set<Function<ServerData, ServletContextListener>> servletContextListeners() {

return null;

}

@Override

public Set<Class> jaxRsResources() {

return null;

}

@Override

public Set<String> jaxRsPackages() {

return null;

}

}

package com.aol.micro.server.spring.datasource;

import lombok.Getter;

import lombok.experimental.Builder;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.beans.factory.annotation.Value;

import org.springframework.stereotype.Component;

@Component("dbcpEnv")

public class DBCPConfig {

private final boolean testOnBorrow;

private final String validationQuery;

private final int maxTotal;

private final long minEvictableIdleTime;

private final long timeBetweenEvictionRuns;

private final int numTestsPerEvictionRun;

private final boolean testWhileIdle;

private final boolean testOnReturn;

@Autowired

public DBCPConfig(@Value("${dbcp.db.test.on.borrow:true}") boolean testOnBorrow,

@Value("${dbcp.db.validation.query:SELECT 1}") String validationQuery, @Value("${dbcp.db.max.total:-1}") int maxTotal,

@Value("${dbcp.db.min.evictable.idle.time:1800000}") long minEvictableIdleTime,

@Value("${dbcp.db.time.between.eviction.runs:1800000}") long timeBetweenEvictionRuns,

@Value("${dbcp.db.num.tests.per.eviction.run:3}") int numTestsPerEvictionRun,

@Value("${dbcp.db.test.while.idle:true}") boolean testWhileIdle, @Value("${dbcp.db.test.on.return:true}") boolean testOnReturn) {

this.testOnBorrow = testOnBorrow;

this.validationQuery = validationQuery;

this.maxTotal = maxTotal;

this.minEvictableIdleTime = minEvictableIdleTime;

this.timeBetweenEvictionRuns = timeBetweenEvictionRuns;

this.numTestsPerEvictionRun = numTestsPerEvictionRun;

this.testWhileIdle = testWhileIdle;

this.testOnReturn = testOnReturn;

}

}

package com.aol.micro.server.spring.datasource;

import javax.annotation.Resource;

import javax.sql.DataSource;

import lombok.AllArgsConstructor;

import lombok.NoArgsConstructor;

import lombok.experimental.Builder;

import org.apache.commons.dbcp2.BasicDataSource;

import org.springframework.context.annotation.Bean;

import org.springframework.context.annotation.Configuration;

public class DBCPDataSourceBuilder {

@Resource(name = "mainEnv")

private JdbcConfig mainEnv;

@Resource(name = "dbcpEnv")

private DBCPConfig dbcpEnv;

@Bean(destroyMethod = "close", name = "mainDataSource")

public DataSource mainDataSource() {

return getDataSource();

}

private DataSource getDataSource() {

BasicDataSource ds = new BasicDataSource();

ds.setDriverClassName(mainEnv.getDriverClassName());

ds.setUrl(mainEnv.getUrl());

ds.setUsername(mainEnv.getUsername());

ds.setPassword(mainEnv.getPassword());

retrySetup(ds);

return ds;

}

private void retrySetup(BasicDataSource ds) {

if (!"org.hibernate.dialect.HSQLDialect".equals(mainEnv.getDialect())) {

ds.setTestOnBorrow(dbcpEnv.isTestOnBorrow());

ds.setValidationQuery(dbcpEnv.getValidationQuery());

ds.setMaxTotal(dbcpEnv.getMaxTotal());

ds.setMinEvictableIdleTimeMillis(dbcpEnv.getMinEvictableIdleTime());

ds.setTimeBetweenEvictionRunsMillis(dbcpEnv.getTimeBetweenEvictionRuns());

ds.setNumTestsPerEvictionRun(dbcpEnv.getNumTestsPerEvictionRun());

ds.setTestWhileIdle(dbcpEnv.isTestWhileIdle());

ds.setTestOnReturn(dbcpEnv.isTestOnReturn());

}

}

}

com.aol.micro.server.spring.DBCPPlugin

package app.pure.jdbc.com.aol.micro.server;

import lombok.AllArgsConstructor;

import lombok.Getter;

import lombok.NoArgsConstructor;

import lombok.Setter;

import lombok.experimental.Builder;

public class JdbcEntity implements java.io.Serializable {

private static final long serialVersionUID = 1L;

private Long id;

private String name;

private String value;

private int version;

}

package app.pure.jdbc.com.aol.micro.server;

import static org.hamcrest.CoreMatchers.is;

import static org.junit.Assert.assertThat;

import java.util.concurrent.ExecutionException;

import org.junit.After;

import org.junit.Before;

import org.junit.Test;

import com.aol.micro.server.MicroserverApp;

import com.aol.micro.server.config.Microserver;

import com.aol.micro.server.rest.client.nio.AsyncRestClient;

import com.aol.micro.server.testing.RestAgent;

@Microserver(properties = { "db.connection.driver", "org.hsqldb.jdbcDriver", "db.connection.url", "jdbc:hsqldb:mem:aname", "db.connection.username",

"sa", "db.connection.dialect", "org.hibernate.dialect.HSQLDialect" })

public class JdbcRunnerTest {

private final AsyncRestClient<JdbcEntity> listClient = new AsyncRestClient(1000, 1000).withResponse(JdbcEntity.class);

RestAgent rest = new RestAgent();

MicroserverApp server;

@Before

public void startServer() {

server = new MicroserverApp(() -> "jdbc-app");

server.start();

rest.get("http://localhost:8080/jdbc-app/persistence/gen");

}

@After

public void stopServer() {

server.stop();

}

@Test

public void runAppAndBasicTest() throws InterruptedException, ExecutionException {

assertThat(rest.get("http://localhost:8080/jdbc-app/persistence/create"), is("ok"));

assertThat(listClient.get("http://localhost:8080/jdbc-app/persistence/get").get(), is(JdbcEntity.class));

}

}