DEV Community: Thompson Olufemi

[Boost]

Thompson Olufemi — Fri, 20 Mar 2026 15:01:42 +0000

[Boost]

Thompson Olufemi ・ Mar 16

#cli #terminal #devops #software

[Boost]

Thompson Olufemi — Mon, 16 Mar 2026 05:15:05 +0000

cmdlib: Save, Search and Run Terminal Commands with Descriptions (Better Than CTRL+R)

Thompson Olufemi ・ Mar 16

#cli #terminal #devops #software

cmdlib: Save, Search and Run Terminal Commands with Descriptions (Better Than CTRL+R)

Thompson Olufemi — Mon, 16 Mar 2026 05:11:25 +0000

If you use the terminal a lot, you probably run into this problem.

You ran a useful command some time ago. Maybe last week or last month. Now you need it again but you cannot remember the exact command.

So you press CTRL+R and start searching through your shell history.

Sometimes you find it quickly. Many times you don't. Or you remember what the command does but you do not remember the exact text of the command.

This happens to me all the time.

For example I might remember something like

"that command that deletes docker images"

"that command that finds large files in a folder"

But when I search with CTRL+R it does not help because I do not remember the exact command text.

So I built a small tool for myself called cmdlib.

cmdlib is a very simple idea.

It lets you save commands with a description and later search using that description.

For example you can write a command like :

docker image prune -a

And then add a meaninful description :

delete unused docker image

Later when you forget the command you can just search :

delete docker

and cmdlib will show it.

You can then press Enter and run it directly.

So it works like a personal command library for your terminal.

You can save commands you use often. You can add a small description so you remember what they do. Then you can search them anytime.

Some things you can do with cmdlib :

Save useful commands with descriptions
Search commands using normal words
Run the command directly from the search results
Delete commands you no longer need
Browse your shell history and save commands from there

The workflow is very simple.

Install it by running the following command in your terminal.

npm install -g cmdlib

Then After installing,

restart your terminal
or run source ~/.bashrc if using bash shell
or run source ~/.zshrcif using zsh shell

Then type cmdlib in your terminal to start using it.

Once you run it, it opens a small interactive search interface in your terminal where you can search, save, and run commands easily.

It is a small tool, but it has been very useful for me because I no longer forget commands that took time to figure out.

If you want to try it, you can install it from npm.

npm install -g cmdlib

You can also checkout the README on the GitHub page for instructions on how to use it:

https://github.com/olufemithompson/cmdlib

If you find it useful, please consider giving the repo a star on GitHub. It helps others discover the project.

If you try it and have suggestions or ideas for improvements, I would love to hear them. Contributions and feedback are always welcome.

Building Resilient Distributed Systems with Springboot

Thompson Olufemi — Thu, 02 Jan 2025 11:36:42 +0000

When building distributed systems, many teams concentrate on making individual services strong and reliable. While that's important, the real challenge lies in how these services interact, especially when the system is under heavy stress.

A resilient system isn't just about tough services - it's about ensuring all parts of the system work together smoothly when things go wrong.

Now, if you're a Spring Boot developer like me, you're in luck.

In this article, I'll not only break down four essential strategies for building resilient systems, but I'll also provide sample code snippets, showing you how to implement them with Spring Boot libraries and tools.

Let's get started.

1. Prioritize Performance with Caching

When your application is flooded with requests, where does it break first? Often, it’s the database or an external API. Caching is the go-to solution to ease this bottleneck by storing frequently accessed data closer to your application.

Why Caching Matters

Speed: A cache retrieves data faster than a database or an API call. Faster responses mean happier users.
Reliability: Even if your database or API is temporarily unavailable, a cache can keep things running smoothly.
Scalability: Reducing database hits means your system can handle more traffic without crumbling under pressure.

Common Use Cases for Caching

Static Data: Product catalogs, user preferences, or site configurations that don’t change frequently.
Computed Data: Expensive calculations, like recommendation engines or data aggregations.
Session Management: Tracking user sessions or authentication tokens.

Implementing Caching in Spring Boot

Step 1: Add Caching Dependencies

For basic caching, include this in your pom.xml:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-cache</artifactId>
</dependency>

If you want distributed caching with Redis:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

Step 2: Enable Caching

Enable caching in your application by adding @EnableCaching:

@SpringBootApplication
@EnableCaching
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

Step 3: Define Cacheable Methods

Use @Cacheable to specify which methods should cache their results:

@Service
public class WeatherService {

    @Cacheable("weather")
    public String getWeather(String location) {
        // Simulate slow external API call
        slowApiCall();
        return "Sunny in " + location;
    }

    private void slowApiCall() {
        //api call code
    }
}

Step 4: Configure Cache Settings

For Redis, add this to application.properties:

spring.cache.type=redis
spring.redis.host=localhost
spring.redis.port=6379

2. Graceful Recovery with Circuit Breakers

Failures are inevitable in distributed systems. The trick is to isolate those failures and prevent them from dragging down the rest of the system. This is where circuit breakers shine.

What is a Circuit Breaker?

A circuit breaker monitors your service calls. If too many failures occur, it trips, temporarily stopping further calls. This prevents overloading a struggling service and allows it time to recover.

When to Use Circuit Breakers

When calling external APIs or microservices that are prone to latency or failures.
To protect critical parts of your system from cascading failures.

Using Circuit Breakers with Resilience4j in Spring Boot

Step 1: Add Dependencies

Add Resilience4j to your project:

<dependency>
    <groupId>io.github.resilience4j</groupId>
    <artifactId>resilience4j-spring-boot2</artifactId>
    <version>1.7.1</version>
</dependency>

Step 2: Configure Circuit Breakers

Define your circuit breaker settings in application.properties:

resilience4j.circuitbreaker.instances.myService.failure-rate-threshold=50
resilience4j.circuitbreaker.instances.myService.sliding-window-size=10
resilience4j.circuitbreaker.instances.myService.wait-duration-in-open-state=10000

Step 3: Wrap Calls with Circuit Breakers

Use @CircuitBreaker to wrap risky service calls:

@RestController
public class ApiController {

    @CircuitBreaker(name = "myService", fallbackMethod = "fallbackResponse")
    @GetMapping("/data")
    public String fetchData() {
        // Simulating an external API call
        return webClient.get()
                .uri("http://external-service.com/api")
                .retrieve()
                .bodyToMono(String.class)
                .block();
    }

    public String fallbackResponse(Throwable t) {
        return "Service is unavailable, please try again later.";
    }
}

3. Prevent Overload with Throttling

Imagine your app gets flooded with requests—maybe because you went viral, or someone’s intentionally hitting your endpoints nonstop. Without some kind of control, your servers could get overwhelmed, leading to crashes or performance issues.

That’s where throttling comes in. It limits how often users (or systems) can access your app, helping you protect your backend and keep things running smoothly.

What’s Throttling?

Throttling is like placing a speed limit on a highway. It ensures no one can send too many requests at once, giving your app breathing room to handle other users.

When Should You Use Throttling?

When your app serves a public API or has user-facing endpoints that could get spammed.
To prevent abuse from automated bots or malicious users.
To handle traffic surges gracefully, especially during sales or promotions.

How to Implement Throttling in Spring Boot

Option 1: Use Spring Web Filters for Simple Throttling

For basic throttling, you can use a filter to track request counts and delay or block users who exceed the limit.

@Component  
public class ThrottleFilter implements Filter {  

    private final Map<String, Integer> requestCounts = new ConcurrentHashMap<>();  
    private final int MAX_REQUESTS_PER_MINUTE = 100;  

    @Override  
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {  
        HttpServletRequest httpRequest = (HttpServletRequest) request;  
        String clientIP = httpRequest.getRemoteAddr();  

        requestCounts.merge(clientIP, 1, Integer::sum);  

        if (requestCounts.get(clientIP) > MAX_REQUESTS_PER_MINUTE) {  
            ((HttpServletResponse) response).setStatus(HttpServletResponse.SC_TOO_MANY_REQUESTS);  
            response.getWriter().write("Too many requests. Please try again later.");  
            return;  
        }  

        chain.doFilter(request, response);  
    }  

    @Scheduled(fixedRate = 60000)  
    public void resetCounts() {  
        requestCounts.clear();  
    }  
}

This example tracks requests per client IP and blocks further requests if they exceed a set limit within a minute.

Option 2: Use a Library Like Bucket4j for Advanced Throttling

For more control, such as rate-limiting based on API keys or user roles, use Bucket4j.

Add Dependency
Include the Bucket4j library:

<dependency>  
    <groupId>com.github.vladimir-bukhtoyarov</groupId>  
    <artifactId>bucket4j-core</artifactId>  
    <version>8.0.0</version>  
</dependency>

Set Up Throttling Logic
Here’s an example of rate-limiting requests:

@RestController  
@RequestMapping("/api")  
public class RateLimitController {  

    private final Map<String, Bucket> buckets = new ConcurrentHashMap<>();  

    @GetMapping("/data")  
    public ResponseEntity<String> getData(HttpServletRequest request) {  
        String clientIP = request.getRemoteAddr();  
        Bucket bucket = buckets.computeIfAbsent(clientIP, k -> createNewBucket());  

        if (bucket.tryConsume(1)) {  
            return ResponseEntity.ok("Here's your data!");  
        } else {  
            return ResponseEntity.status(HttpStatus.TOO_MANY_REQUESTS).body("Rate limit exceeded. Try again later.");  
        }  
    }  

    private Bucket createNewBucket() {  
        return Bucket4j.builder()  
                .addLimit(Bandwidth.simple(50, Duration.ofMinutes(1)))  
                .build();  
    }  
}

Here, each client can make 50 requests per minute. If they exceed the limit, they’ll get a 429 Too Many Requests response.

Option 3: Fine-Tune with Spring Cloud Gateway

If you’re using a gateway, Spring Cloud Gateway makes it easy to add rate-limiting globally.

Add Dependencies
Include these in your pom.xml:

<dependency>  
    <groupId>org.springframework.cloud</groupId>  
    <artifactId>spring-cloud-starter-gateway</artifactId>  
</dependency>  
<dependency>  
    <groupId>org.springframework.boot</groupId>  
    <artifactId>spring-boot-starter-data-redis</artifactId>  
</dependency>

Configure Rate-Limiting in application.yml
Set up Redis-based rate-limiting for API routes:

spring:  
  cloud:  
    gateway:  
      routes:  
        - id: data-service  
          uri: http://localhost:8080  
          predicates:  
            - Path=/api/data  
          filters:  
            - name: RequestRateLimiter  
              args:  
                redis-rate-limiter:  
                  replenishRate: 10  
                  burstCapacity: 20

By adding throttling, you not only protect your system from abuse but also ensure a smoother experience for all users, even during traffic spikes.

4. Use Retry Strategies: Because Nobody Likes a Nag

When dealing with temporary failures, retries can be a lifesaver, but overdoing them can overwhelm your system and make minor issues worse. It’s essential to implement retries thoughtfully to strike a balance between resilience and system stability.

Introducing Spring Retry

Spring Retry is a powerful library that simplifies implementing retry mechanisms in Java applications. It integrates seamlessly with Spring, providing declarative and programmatic approaches to handle retries effectively.

Spring Retry allows you to:

Retry operations based on specific exceptions.
Define policies like fixed intervals, exponential backoff, and more.
Customize maximum retry attempts and delays.

Adding the Dependency

To use Spring Retry in your project, add the following dependency to your pom.xml :

<dependency>
    <groupId>org.springframework.retry</groupId>
    <artifactId>spring-retry</artifactId>
    <version>1.3.4</version> <!-- Use the latest version -->
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
</dependency>

The spring-boot-starter-aop dependency is required for handling annotations like @Retryable.

Configuring Retry Logic

Spring Retry provides annotations like @Retryable to handle retries declaratively.

Enable Retry Support: Add the @EnableRetry annotation to your configuration class to enable retry functionality.

import org.springframework.context.annotation.Configuration;
import org.springframework.retry.annotation.EnableRetry;

@Configuration
@EnableRetry
public class RetryConfig {
}

Add Retry Logic to a Service: Use the @Retryable annotation to define retry policies.

import org.springframework.retry.annotation.Retryable;
import org.springframework.retry.annotation.Backoff;
import org.springframework.stereotype.Service;

@Service
public class ApiService {
    @Retryable(
        value = {RuntimeException.class},
        maxAttempts = 3,
        backoff = @Backoff(delay = 2000, multiplier = 2)
    )
    public String callExternalService() {
        System.out.println("Attempting to call external service...");
        throw new RuntimeException("Temporary failure");
    }
}

value: Specifies the exceptions to trigger a retry.
maxAttempts: Limits the number of retry attempts.
backoff: Configures the delay between retries (e.g., exponential backoff with a multiplier).

Fallback for Graceful Failure: Handle failures gracefully by defining a fallback method using @Recover.

import org.springframework.retry.annotation.Recover;
import org.springframework.stereotype.Service;

@Service
public class ApiService {
    // Retryable method as shown above

    @Recover
    public String recover(RuntimeException e) {
        System.out.println("Fallback executed due to: " + e.getMessage());
        return "Fallback response";
    }
}

The Bottom Line: Focus on Interactions

A truly resilient system isn't just about robust services; it’s about ensuring those services interact seamlessly and effectively.

By caching wisely, preventing cascading failures, designing fallbacks, and managing retries, you can create systems that effortlessly bounce back from issues.

Failures are inevitable, but what truly defines a resilient system is how gracefully it responds to those challenges.

Best of luck in building your resilient system, may it handle every hiccup like a pro!

Easily Set Up Multiple Spring Beans with Unique Configurations

Thompson Olufemi — Tue, 29 Oct 2024 07:30:53 +0000

Tired of Repetitive Spring Bean Registrations? You’re Not Alone!

Ever feel bogged down with repeated bean definitions in Spring Boot? You’re not alone! Managing multiple beans of the same class with different configurations can get tedious and cluttered. Let's say you need something like this:

@Bean
MyService beanA() {
    // Set Configuration for bean A
    Configuration a = new...
    a.setUrl(.....)
    return new MyService(a);
}

@Bean
MyService beanB() {
    // Set Configuration for bean A
    Configuration b = new...
    b.setUrl(.....)
    return new MyService(b);
}

This code isn't complex, but it quickly becomes repetitive, especially when dealing with several beans of the same type. Ideally, you'd have a way to register multiple instances with distinct settings without redundant code.

This differs from having unique beans for each implementation of an interface. Instead, we’re talking about setting up one class with variations. For example, think of an app that connects to multiple databases (e.g., customer, reporting, and backup). Each connection needs its own configuration, making it challenging to manage without clutter. You might end up writing something like this:

@Bean
DatabaseService primaryDatabaseService() {
    return new DatabaseService("db-url-primary");
}

@Bean
DatabaseService reportDatabaseService() {
    return new DatabaseService("db-url-report");
}

Having a simpler solution could significantly streamline your configuration and let you focus more on application logic. Enter MultiBeanConfig — a small library I built to help manage multiple configurations for the same Spring bean.

Introducing MultiBeanConfig

MultiBeanConfig simplifies the setup of multiple instances of a bean with separate configurations. With it, you can:

Reduce repetitive code
Centralize configuration management
Keep your codebase clean and organized

Core Features

Multiple Bean Setup: Define multiple instances of a single class.
Custom Configurations: Control settings per instance through your application properties.
Default Values: Automatically apply default values if specific configurations are missing.
Automatic Injection: Easily use @Autowired for dependency injection.

Step-by-Step Guide

1. Add MultiBeanConfig to Your Project

Include the dependency in your pom.xml:

<dependency>
    <groupId>io.github.olufemithompson</groupId>
    <artifactId>multibeanconfig</artifactId>
    <version>0.0.3</version>
</dependency>

2. Set Up the Bean Class

Mark your class with @MultiBean to make it eligible for multiple instances:

@MultiBean
public class DatabaseService {
    // Your service logic
}

3. Define Beans in Your Config File

Define unique versions in your properties or YAML file:

multibean:
  primary-database-service:
    class: DatabaseService
  report-database-service:
    class: DatabaseService

This registers primaryDatabaseService and reportDatabaseService beans with default configurations. MultiBeanConfig automatically translates names from kebab-case to camelCase.

Customizing Configurations Per Bean

To assign separate settings, add properties directly to each bean’s configuration. Here’s an example where each instance connects to a different database:

@MultiBean
public class DatabaseService {
   @Value("${database-config.connection-url}")
   private String connectionUrl;
}

Configure each instance in application.yml:

database-config:
  connection-url: 'jdbc:h2:default-url'

multibean:
  primary-database-service:
    class: DatabaseService
    database-config:
      connection-url: 'jdbc:mysql:primary-db-url'
  report-database-service:
    class: DatabaseService
    database-config:
      connection-url: 'jdbc:postgresql:report-db-url'

This setup gives each bean a unique connection URL. Shared settings can also be defined in a general section, making configurations efficient and reducing redundancy.

Alternative Ways to Inject Configurations

You don’t have to rely solely on @Value for injecting configurations. Spring’s @ConfigurationProperties allows encapsulating properties in a configuration class:

@ConfigurationProperties("database-config")
@Configuration
public class DatabaseConfig {
    private String connectionUrl;
    private int connectionTimeout;
    // Getters and Setters
}

Then, inject DatabaseConfig directly:

@MultiBean
public class DatabaseService {
   private final DatabaseConfig databaseConfig;
   public DatabaseService(DatabaseConfig databaseConfig) {
       this.databaseConfig = databaseConfig;
   }
}

Using the Configured Beans

With MultiBeanConfig , inject your uniquely configured beans as you would with any Spring dependency:

@Service
public class ApplicationService {
   private final DatabaseService primaryDatabaseService;
   private final DatabaseService reportDatabaseService;

   public ApplicationService(DatabaseService primaryDatabaseService, DatabaseService reportDatabaseService) {
       this.primaryDatabaseService = primaryDatabaseService;
       this.reportDatabaseService = reportDatabaseService;
   }
}

Final Thoughts

MultiBeanConfig streamlines bean management in Spring Boot applications, especially when handling feature flags, data sources, or distinct API connections. It reduces redundancy, keeps your code clean, and enhances maintainability. Give it a try, and let me know how it works for your projects!