I found this very useful stack overflow:
https://stackoverflow.com/a/36552613/857994
It shows you how to start a spring-boot JAR from a different main class. It’s a quirky solution, but it worked great. Here’s a slightly more obvious/cleaner copy of the command (mostly for my own future reference):
java -cp presto-ws-3.2.2.jar -Dloader.main=com.company.PrestoQueryRunner org.springframework.boot.loader.PropertiesLauncher
Spring’s RestTemplate is an extremely convenient way to make REST calls to web services. But most people don’t realize initially that these calls have no timeout by default. This means no connection timeout and no data call timeout. So, potentially, your app can make a call that should take 1 second and could freeze up for a very long time if the back end is behaving badly.
There are a lot of ways of doing this, but the best one I’ve seen recently (from this stackoverflow post) is to create the RestTemplate in an @Configuration class and then inject it into your services. That way you know the RestTemplate you are using everywhere was configured properly with your desired timeouts.
Here is a full example.
package com.company.cloudops.config;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.web.client.RestTemplateBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.client.RestTemplate;
import java.time.Duration;
@Configuration
public class AppConfig {
@Value("${rest.template.timeout}") private int restTemplateTimeoutMs;
@Bean
public RestTemplate restTemplate(RestTemplateBuilder builder) {
return builder
.setConnectTimeout(Duration.ofMillis(restTemplateTimeoutMs))
.setReadTimeout(Duration.ofMillis(restTemplateTimeoutMs))
.build();
}
}
To use this RestTemplate in another Spring bean class, just pull it in with:
@Autowired private RestTemplate template;
I’ve been working on an odd API project where each user needs their own connection to various back-end databases/data-sources. This is a break from the norm because in general, you set up a connection pool of, say, 10 connections and everyone shares it and you’re golden.
If you have 500 users throughout the day though and each one gets some connections, that would be a disaster. So, in my case making sure the pool is of limited size and making sure the idle timeout works is pretty vital. So, I started playing around to see how I can verify old connections are really being removed.
I had started with an Apache BasicDataSource (old habits die hard). But then when I enabled debug I didn’t see connections being dropped, or info on them being logged at all for that matter. Before bothering with trace, I started reading about Hikari which is a connection pool I see spring using a lot… and it looked pretty awesome! See some good performance and usage info right here.
Anyway! I switched to Hikari quick which was easy since its already in Spring Boot 2.X (which I habitually use for everything these days).
Here’s my Spring config class/code. I have it set in properties to allow a minimum of 0 connections, to time out connections after 60 seconds, and to have a maximum of 4 connections. Connections are tested with “select 1” which is pretty safe on most databases.
@Configuration
public class Config {
//Configuration for our general audit data source.
private @Value("${audit.ds.url}") String auditDsUrl;
private @Value("${audit.ds.user}") String auditDsUser;
private @Value("${audit.ds.password}") String auditDsPassword;
@Bean
public DataSource auditDataSource() {
HikariConfig config = new HikariConfig();
config.setJdbcUrl(auditDsUrl);
config.setUsername(auditDsUser);
config.setPassword(auditDsPassword);
config.setMaximumPoolSize(4);
config.setMinimumIdle(0);
config.setIdleTimeout(60000);
config.setConnectionTestQuery("select 1");
config.setPoolName("Audit Pool");
config.setValidationTimeout(10000);
return new HikariDataSource(config);
}
@Bean
public NamedParameterJdbcTemplate auditJdbcTemplate() {
return new NamedParameterJdbcTemplate(auditDataSource());
}
}
After sending a query to my API, where it uses a basic JDBC template to execute the query, I see the logs do this (note that I removed the date/time/class/etc for brevity).
Audit Pool - Before cleanup stats (total=0, active=0, idle=0, waiting=0) Audit Pool - After cleanup stats (total=0, active=0, idle=0, waiting=0) Audit Pool - Before cleanup stats (total=1, active=0, idle=1, waiting=0) Audit Pool - After cleanup stats (total=1, active=0, idle=1, waiting=0) Audit Pool - Before cleanup stats (total=1, active=0, idle=1, waiting=0) Audit Pool - After cleanup stats (total=1, active=0, idle=1, waiting=0) Audit Pool - After cleanup stats (total=0, active=0, idle=0, waiting=0) Audit Pool - Closing connection PG...: (connection has passed idleTimeout)
So, we can see that it went from 0 connections total, to 1 connection total. The connection looks idle pretty quick because it was a short query that was done before the regular output log. Then after a minute, the connection gets closed and the total goes back to 0.
So, we’re correctly timing out idle connections using our settings. Also, we’re getting our pool name (Audit Pool) in the logs which is awesome too!
Coding Stream of Consciousness 