DEV Community: Tharindu Dulshan Fernando

Resolving Deadlocks in Transactions in Spring Boot

Tharindu Dulshan Fernando — Mon, 05 May 2025 05:17:16 +0000

In transactional systems, deadlocks are a common concurrency issue, particularly when several threads or processes seek for the same resources. Deadlocks can cause major problems with application speed and consistency in Spring Boot applications that use relational databases and @Transactional annotations.

In this blog post, we will cover:

What a deadlock is
How it occurs in Spring Boot transactional systems
Real code examples
How to detect and handle deadlocks
Best practices to prevent them

What is a Deadlock?

A deadlock occurs when two or more transactions block each other by holding a lock and waiting for the other’s lock to be released.

Example:

Transaction A locks Row 1 and needs Row 2
Transaction B locks Row 2 and needs Row 1
Neither can proceed, resulting in a deadlock

Relational databases (like MySQL, PostgreSQL) will detect the deadlock and typically abort one of the transactions, throwing an exception.

Deadlock in Spring Boot Example

Let’s consider a simple scenario using Spring Data JPA and @Transactional.

Model :

@Entity
public class Account {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;
    private String email;

    private BigDecimal balance;

    // getters and setters
}

Repository :

public interface AccountRepository extends JpaRepository<Account, Long> {}

Service with Transaction :

@Service
public class AccountService {

    @Autowired
    private AccountRepository accountRepository;

    //this method will cause deadlocks if two threads access the transfer method at the same time.
    //If both threads fetch and lock their first account row and then,
    //attempt to access the other, a deadlock is likely.
    @Transactional
    public void transfer(Long fromId, Long toId, BigDecimal amount) {
        Account from = accountRepository.findById(fromId).orElseThrow();
        Account to = accountRepository.findById(toId).orElseThrow();

        from.setBalance(from.getBalance().subtract(amount));
        to.setBalance(to.getBalance().add(amount));

        accountRepository.save(from);
        accountRepository.save(to);
    }

Thread A: transfers from Account 1 to 2
Thread B: transfers from Account 2 to 1

How to Detect Deadlocks

1. Database Logs

Databases like MySQL and PostgreSQL will log deadlocks. For example, in MySQL, you can run:

SHOW ENGINE INNODB STATUS;

2. Application Logs

Spring will typically throw a DeadlockLoserDataAccessException or a database-specific exception. Make sure your logs include stack traces.

How to Handle and Prevent Deadlocks

1. Consistent Lock Ordering

Always access resources in the same order. In the above example, always load accounts in order of ID:

    @Transactional
    public void transfer(Long fromId, Long toId, BigDecimal amount) {
        List<Account> accounts = accountRepository.findAllById(List.of(fromId, toId));
        Account from = fromId < toId ? accounts.get(0) : accounts.get(1);
        Account to = fromId < toId ? accounts.get(1) : accounts.get(0);

        accountRepository.save(from);
        accountRepository.save(to);
    }

2. Retry Logic on Deadlocks

Use Spring’s @Transactional with retry logic using @Retryable from Spring Retry:

    @Retryable(
            value = {TransientDataAccessException.class},
            maxAttempts = 3,
            backoff = @Backoff(delay = 200))
    @Transactional
    public void transfer2(Long fromId, Long toId, BigDecimal amount) {
        Account from = accountRepository.findById(fromId).orElseThrow();
        Account to = accountRepository.findById(toId).orElseThrow();

        from.setBalance(from.getBalance().subtract(amount));
        to.setBalance(to.getBalance().add(amount));

        accountRepository.save(from);
        accountRepository.save(to);
    }

Don’t forget to enable Spring Retry:

@EnableRetry
@SpringBootApplication
public class DeadlockexampleApplication {

 public static void main(String[] args) {
  SpringApplication.run(DeadlockexampleApplication.class, args);
 }

}

value and include are deprecated in latest versions so you can Define retry behavior via a RetryPolicy bean.

@Configuration
@EnableRetry
public class RetryConfig {

    @Bean
    public RetryPolicy retryPolicy() {
        SimpleRetryPolicy policy = new SimpleRetryPolicy();
        policy.setMaxAttempts(3);
        policy.setRetryableExceptions(Map.of(
            TransientDataAccessException.class, true
        ));
        return policy;
    }

    @Bean
    public RetryTemplate retryTemplate(RetryPolicy retryPolicy) {
        RetryTemplate template = new RetryTemplate();
        template.setRetryPolicy(retryPolicy);
        return template;
    }
}

3. Locking Strategies

Repository:

@Repository
public interface AccountRepository extends JpaRepository<Account, Long> {
    @Lock(LockModeType.PESSIMISTIC_WRITE)
    @Query("SELECT a FROM Account a WHERE a.id = :id")
    Account findByIdForUpdate(@Param("id") Long id);

}

Service:

    @Transactional
    public void transfer(Long fromId, Long toId, BigDecimal amount) {
        Account from = accountRepository.findByIdForUpdate(fromId);
        Account to = accountRepository.findByIdForUpdate(toId);

        from.setBalance(from.getBalance().subtract(amount));
        to.setBalance(to.getBalance().add(amount));

        accountRepository.save(from);
        accountRepository.save(to);
    }

Important Notes:

Pessimistic locking tells the database to acquire a row-level write lock as soon as the row is read — no other transaction can read/write it until the current one commits or rolls back.
This works well to prevent deadlocks, but can cause blocking and contention under high load. So use it carefully.
Always make sure you’re using it inside a @Transactional method — otherwise, the lock will be released immediately after the method exits.

4. Keep Transactions Short

Avoid long-running transactions. Don’t perform unnecessary logic inside a transaction block.

Conclusion

Deadlocks are inevitable in highly concurrent systems, but with careful design, detection, and retries, you can manage them effectively in Spring Boot. Stick to consistent access patterns, use proper locking, and ensure your application is resilient to deadlocks through retries and monitoring.

References

https://www.baeldung.com/spring-retry

https://www.baeldung.com/java-deadlock-livelock

https://www.baeldung.com/transaction-configuration-with-jpa-and-spring

GitHub : https://github.com/tharindu1998/resolve-deadlock-example

Boosting Performance: Essential Memory Optimization Techniques for Spring Boot Applications

Tharindu Dulshan Fernando — Wed, 30 Apr 2025 10:05:52 +0000

Optimizing memory usage is critical for ensuring your Spring Boot applications perform efficiently, especially under heavy workloads. Proper Memory management will help to reduce latency, minimize crashes, and improve overall application scalability. In this article, we’ll explore five core techniques to optimize memory usage in Spring Boot applications.

1. Tune JVM Settings

The Java Virtual Machine (JVM) plays a significant role in managing memory. Fine-tuning its configuration can yield considerable improvements in performance:

Heap Size Management

Configure the initial (-Xms) and maximum (-Xmx) heap sizes to match your application’s needs.
Avoid leaving the heap size at its default value, as this can cause unexpected behavior under heavy load.

Garbage Collection (GC) Tuning

Use the G1 Garbage Collector (G1GC) for most Spring Boot applications, as it provides predictable pause times.
Adjust GC parameters, such as -XX:InitiatingHeapOccupancyPercent and -XX:MaxGCPauseMillis, for optimized performance.

Enable Class Data Sharing (CDS)

Reduce memory consumption for frequently loaded classes by enabling Class Data Sharing with -Xshare:on.

2.Optimize Spring Boot Configurations

Spring Boot provides various features that, if not optimized, can consume unnecessary memory. Here are some ways to streamline configurations:

Profile-Specific Configurations

Use application-{profile}.yml or application-{profile}.properties to load only environment-specific configurations.
Ensure unused configurations are not included in the runtime environment.

Disable Unused Auto-Configurations

Use the spring.autoconfigure.exclude property to prevent unnecessary auto-configurations from being loaded.
For example:

spring:
  autoconfigure:
    exclude:
-org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration

Manage Actuator Endpoints

Actuator endpoints provide valuable insights but can consume resources if all are enabled.
Only enable required endpoints using:

management:
  endpoints:
    enabled-by-default: false
  endpoint:
    health:
      enabled: true

3. Streamline Dependencies

Unused or excessive dependencies can unnecessarily bloat the memory footprint of your application. Follow these practices:

Exclude Unnecessary Dependencies

Review your pom.xml or build.gradle for unused dependencies.
Remove redundant libraries and ensure only essential dependencies are included.

Properly Scope Test Libraries

Use the test scope for test dependencies to ensure they are excluded from production builds:

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

4. Optimize Bean Initialization

Spring Boot uses dependency injection to manage beans, which can sometimes lead to excessive memory consumption. Optimize this process as follows:

Enable Lazy Initialization

Load beans only when they are required by enabling lazy initialization:

spring:
  main:
    lazy-initialization: true

Use Prototype Scope for Non-Singleton Beans

For beans that are not frequently reused, use @scope("prototype") to avoid keeping them in memory unnecessarily:

@Bean
@Scope("prototype")
public MyPrototypeBean myPrototypeBean() {
    return new MyPrototypeBean();
}

5. Monitor and Analyze Memory Usage

Regular monitoring and analysis of your application’s memory usage can help identify and fix bottlenecks:

Leverage Spring Boot Actuator Metrics

Use Actuator’s metrics to monitor memory usage in real time.
Integrate with monitoring tools like Prometheus and Grafana for visualization.

Profile with Tools

Use tools like VisualVM, JProfiler, or YourKit to profile your application and identify memory leaks or inefficient memory usage.

Conclusion

By implementing these five core techniques, you can ensure your Spring Boot application is both efficient and scalable. Regularly profile your application and adapt these strategies as your application’s requirements evolve. DYOR for other stratergies and optimize your applications.

References

https://www.baeldung.com/spring-boot-lazy-initialization

https://docs.spring.io/spring-boot/reference/actuator/metrics.html

https://docs.spring.io/spring-framework/reference/core/beans/factory-scopes.html

Top five Common mistakes Developers make when using Java Streams and How to Avoid Them

Tharindu Dulshan Fernando — Sun, 24 Nov 2024 11:10:12 +0000

Java Streams provide a powerful way to process data in a functional style, allowing developers to write concise and readable code. However, misusing Streams can lead to inefficient, buggy, or unmaintainable code. In this blog, we’ll explore developers' top five common mistakes when working with Java Streams and how to avoid them.

1. Modifying the Source During Stream Processing

One common mistake is changing a collection while using a stream to process it. Streams are meant to handle data without making changes to the original collection. If you modify the collection during processing, it can cause errors like a ConcurrentModificationException.

List<Integer> list = new ArrayList<>(List.of(1, 2, 3));
list.stream().forEach(x -> list.add(x + 1)); // Runtime exception

Problem :

Streams are not thread-safe, and modifying the underlying collection during processing disrupts its consistency.

How to avoid and solve:

If you need to transform the data, collect the results into a new collection instead of modifying the original one.

List<Integer> transformedList = list.stream()
    .map(x -> x + 1)
    .collect(Collectors.toList());

2. Assuming Streams Can Be Reused

Streams are single-use objects. Once consumed by a terminal operation (e.g., forEach(), collect()), they cannot be reused. Attempting to reuse a stream will throw an IllegalStateException.

Stream<String> stream = List.of("a", "b", "c").stream();
stream.forEach(System.out::println); // Works
stream.forEach(System.out::println); // Throws IllegalStateException

Problem:

This mistake often occurs when developers try to perform multiple operations on the same stream without realizing it has already been consumed.

How to avoid and solve:

If you need to process the data multiple times, create a new stream for each operation.

List<String> list = List.of("a", "b", "c");
list.stream().forEach(System.out::println);
list.stream().forEach(System.out::println); // Create a new stream

3. Improper Handling of Parallel Streams

Parallel streams can help speed up processing, but if not used carefully, they can cause problems. For example, using them on small datasets or shared resources can lead to errors or slow things down instead of improving performance.

List<Integer> list = List.of(1, 2, 3);
list.parallelStream().forEach(System.out::println); // Non-deterministic output

Problem:

For small datasets, the overhead of parallelization often outweighs the performance gains.
Accessing shared mutable resources in parallel streams can lead to race conditions.

How to avoid and solve:

Use parallel streams only for large datasets where they provide a clear performance boost, and make sure to handle shared resources safely to avoid errors.

list.stream().forEach(System.out::println); // Sequential stream

4. Avoid Side Effects in Stream Operations

Streams are meant to follow a functional programming style. Adding side effects, like printing or changing external variables, in operations like map() or filter() goes against this approach and makes the code harder to maintain.

list.stream()
    .map(x -> {
        System.out.println(x); // Side effect
        return x * 2;
    })
    .collect(Collectors.toList());

Problem:

Side effects can make the stream pipeline harder to understand and debug. They can also cause unexpected behaviour when using parallel streams.

How to avoid and solve:

If you need to debug or inspect values, use peek(). Avoid modifying external state in stream operations.

list.stream()
    .peek(System.out::println) // Use peek for debugging
    .map(x -> x * 2)
    .collect(Collectors.toList());

5. Improper Collecting with Collectors.toMap

When using Collectors.toMap to collect data into a map, developers sometimes forget to handle key collisions. If two elements have the same key, the code will throw an IllegalStateException unless collisions are properly managed.

Map<Integer, String> map = List.of("apple", "bat", "ant").stream()
    .collect(Collectors.toMap(String::length, Function.identity())); // Key collision issue

Problem:

If two elements produce the same key, the collector does not know how to merge them, leading to an exception.

How to avoid and solve:

Provide a merge function to handle key collisions.

Map<Integer, String> map = List.of("apple", "bat", "ant").stream()
    .collect(Collectors.toMap(
        String::length,
        Function.identity(),
        (existing, replacement) -> existing // Resolve collision
    ));

Conclusion

Java Streams are a powerful tool for processing data, but using them incorrectly can cause inefficiency and errors. By being aware of these common mistakes and knowing how to avoid them, you can write clean, efficient, and maintainable code that makes the most of streams.

References :

https://www.baeldung.com/java-8-streams

https://www.digitalocean.com/community/tutorials/java-8-stream

https://docs.oracle.com/javase/8/docs/api/?java/util/stream/Stream.html

Optimizing Spring Boot Applications with Redis Caching

Tharindu Dulshan Fernando — Tue, 24 Sep 2024 13:07:27 +0000

In my previous blog, I explained what is Caching and different methods of caching used In Springboot Applications. So as promised here is an in-depth blog about Redis Caching.

What is Redis?

Redis (Remote Dictionary Server) is an open-source, in-memory key-value data store that supports a variety of data structures like strings, lists, sets, hashes, and more. It’s highly performant due to its in-memory architecture, which makes it an excellent choice for caching and session management in modern applications.

Pros of Using Redis for Caching.

Redis offers several benefits when used as a caching solution:

In-memory storage: It stores data in RAM, enabling lightning-fast read and write operations.
Data persistence: Redis allows data persistence through snapshots or appending to logs.
Advanced data structures: Beyond key-value pairs, Redis supports lists, sets, sorted sets, and more, making it a versatile tool.
High availability: Redis can be configured in a distributed, highly available setup with clustering and replication.
TTL support: You can set Time-to-Live (TTL) on cached data, ensuring stale data is evicted automatically.

Let’s Set Up Redis in Spring Boot

Let’s go step-by-step on how to set up and configure Redis caching in a Spring Boot application.

1. Add Dependencies

To get started, add the following dependencies in your pom.xml (for Maven) or build.gradle (for Gradle) file:

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

2. Install Redis

You can install Redis on your machine, or if you’re working in a cloud environment, you can use managed services like AWS ElastiCache or Redis Enterprise Cloud.

For local development, you can install Redis using the following command:

sudo apt-get install redis-server

Start Redis using:

redis-server

You can confirm that Redis is running by typing:

redis-cli ping
It should return PONG if Redis is running correctly.

3. Configure Redis in Spring Boot

Spring Boot makes it easy to configure Redis. All you need to do is provide Redis connection details in the application.properties or application.yml file.

# application.properties
spring.redis.host=localhost
spring.redis.port=6379
spring.cache.type=redis

spring:
  redis:
    host: localhost
    port: 6379
  cache:
    type: redis

If your Redis instance requires authentication, add the password field:

spring.redis.password=yourpassword

4. Enable Caching in Spring Boot

Next, you need to enable caching in your Spring Boot application. This can be done by adding the @EnableCaching annotation in your main application class.

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

5. Implement Caching

To apply caching to a method, simply use the @Cacheable annotation. Let’s say you have a service class that fetches user data:

@Service
public class UserService {

    @Cacheable(value = "userCache", key = "#userId")
    public User getUserById(Long userId) {
        // Simulate a database call
        return userRepository.findById(userId).orElseThrow(() -> new UserNotFoundException());
    }
}

@Cacheable: Caches the method's return value using the given cache name (userCache in this case).
key: Specifies the key under which the value will be stored. By default, all method arguments are considered part of the key.

When the getUserById method is called, it will first check the cache. The data is cached and returned if it is present; if not, it retrieves the data from the database and saves it in the cache.

6. Cache Eviction and Updating

You should update or invalidate the cache whenever the underlying data changes. Spring provides the @CachePut and @CacheEvict annotations for this purpose.

@CachePut: Updates the values in the cache with a new value.
@CacheEvict: eliminates a record from the cache.

Here’s an example:

@Service
public class UserService {

    @CacheEvict(value = "userCache", key = "#userId")
    public void deleteUserById(Long userId) {
        userRepository.deleteById(userId);
    }

    @CachePut(value = "userCache", key = "#user.id")
    public User updateUser(User user) {
        return userRepository.save(user);
    }
}

In deleteUserById, the cache entry for the given userId is removed.
In updateUser, the cache entry is updated with the new user data.

7. Customizing Cache Expiration

Redis lets you specify the time-to-live (TTL) for entries that are cached. You can set the TTL in your cache manager using Spring Boot.

@Configuration
public class RedisCacheConfig {

    @Bean
    public RedisCacheConfiguration cacheConfiguration() {
        return RedisCacheConfiguration.defaultCacheConfig()
                .entryTtl(Duration.ofMinutes(10)) // Set TTL to 10 minutes
                .disableCachingNullValues();
    }
}

Cache values will be automatically deleted after ten minutes thanks to this configuration.

8. Monitoring Redis

In addition to integrating Redis with external tools like Redis-cli or Prometheus, Redis has its own suite of monitoring tools, such as redis-cli. Monitoring makes it easier to monitor response times, memory usage, and cache hit/miss ratios.

Conclusion

The performance and scalability of your Spring Boot application can be greatly enhanced by integrating Redis caching. It gives end users faster response times and lessens the strain on your backend services.

References

https://collaborationbetterstheworld.com/insights/redis-cache-in-spring-boot-applications/

https://www.baeldung.com/spring-boot-redis-cache/

https://docs.spring.io/spring-data/redis/reference/redis/redis-cache.html

Spring Boot Caching: A Comprehensive Guide to Improve Application Performance

Tharindu Dulshan Fernando — Tue, 17 Sep 2024 08:12:50 +0000

Caching is a crucial method for increasing application performance since it stores frequently requested data in a temporary manner. Caching speeds up response times, lessens backend strain, and enhances user experience by cutting down on the number of costly activities like database searches and API requests.

1. Spring Boot Cache Annotations

Spring Boot provides a set of annotations to simplify caching:

@Cacheable: Caches the result of a method based on its parameters.
@CachePut: Updates the cache with the method’s result.
@CacheEvict: Removes data from the cache.
@Caching: Allows combining multiple caching annotations using a single method.

2. Enabling Caching in Spring Boot

To enable caching in your Spring Boot application, add the @EnableCaching annotation to one of your configuration classes. This annotation triggers a post-processor that inspects each Spring bean for caching annotations.

import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Configuration;

@Configuration
@EnableCaching
public class CacheConfig {
}

3. Using In-Memory Caching

By default, Spring Boot uses a simple in-memory cache with ConcurrentHashMap. Let's create a sample caching mechanism for a product service:

Step 1: Create a Product Model

public class Product {
    private Long id;
    private String name;

    // Include getters , setters and the constructer here
}

Step 2: Implement a Service with Caching

Here’s how to use @Cacheable to cache method results:

import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;

@Service
public class ProductService {

    @Cacheable(value = "products", key = "#id")
    public Product getProductById(Long id) {
        // Simulate a slow database query
        try {
            Thread.sleep(3000); // Simulates a delay
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return new Product(id, "Sample Product");
    }
}

In this example, the getProductById method is annotated with @Cacheable. The first time the method is called with a specific id, the result is stored in the cache. Subsequent calls with the same id retrieve the result from the cache instead of executing the method again.

4. Using External Cache Providers (e.g., Redis, EhCache)

It’s often better to use external cache providers like Redis, EhCache, or Hazelcast for distributed caching for production applications. Let’s see how to use Redis as a cache provider.

Step 1: Add Redis Dependencies

Add the following dependency to your pom.xml file:

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

Step 2: Configure Redis

Add Redis configuration to your application.properties file:

spring.data.redis.host=localhost
spring.data.redis.port=6379

Step 3: Create a Redis Cache Manager

Configure the Redis cache manager in a configuration class:

import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;

@Configuration
@EnableCaching
public class RedisCacheConfig {

    @Bean
    public CacheManager cacheManager(RedisConnectionFactory redisConnectionFactory) {
        return RedisCacheManager.builder(redisConnectionFactory).build();
    }

    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(redisConnectionFactory);
        return template;
    }
}

This configuration sets up Redis as the cache provider for your Spring Boot application.

“I will explain Redis caching in depth in a seperate blog”

5. Conditional Caching with @Cacheable

You can use the condition and unless attributes of @Cacheable to control caching behaviour conditionally.

In the below example, caching occurs only if the id is greater than 10.

@Cacheable(value = "products", key = "#id", condition = "#id > 10")
public Product getProductById(Long id) {
    // Method logic
}

6. Updating and Removing Caches with @CachePut and @CacheEvict

Updating the Cache with @CachePut

@CachePut allows you to update the cache when the method is called:

@CachePut(value = "products", key = "#product.id")
public Product updateProduct(Product product) {
    // Update product logic
    return product;
}

Removing Cache Entries with @CacheEvict

@CacheEvict is used to remove entries from the cache. This is useful when you want to invalidate a cache after certain operations (e.g., deleting a product).

@CacheEvict(value = "products", key = "#id")
public void deleteProduct(Long id) {
    // Delete product logic
}

You can also clear the entire cache using allEntries = true:

@CacheEvict(value = "products", allEntries = true)
public void clearCache() {
    // Logic to clear cache
}

7. Additional Configuration and Best Practices

Cache Expiration: If using an external cache provider, configure cache expiration to avoid stale data. For example, in Redis, you can set TTL (Time-To-Live) for cache entries.
Logging: Enable cache logging for monitoring cache hits and misses.
Avoid Over-Caching: Cache only data that is frequently accessed and expensive to retrieve.
Use Unique Cache Names: Use unique names for caches in multi-module projects to avoid cache collisions.

** Conclusion**

You can significantly enhance the user experience while lowering backend load by following best practices and carefully planning your caching strategy. You can optimize application performance with a flexible toolkit thanks to Spring Boot’s caching capabilities.

Github: https://github.com/tharindu1998/spring-boot-caching-example

References

https://docs.spring.io/spring-boot/reference/io/caching.html

https://www.baeldung.com/spring-cache-tutorial

https://www.javatpoint.com/spring-boot-caching

Creating the Perfect Code: Understanding Creational Patterns

Tharindu Dulshan Fernando — Tue, 06 Aug 2024 15:43:02 +0000

This is a start for a series of blogs about Design Patterns. In this blog, we will discuss the first type of design pattern, Creational Patterns. Here the types which fall under creational patterns will be discussed with some real-world examples. I will be using Java as my language of selection.

What are Design Patterns?

Design patterns play a crucial role in software development, providing proven solutions to common problems and promoting best practices. They are like pre-made blueprints that you can customize to solve a recurring design problem in your code.

Exploring Creational Design Patterns in Java

In object-oriented programming, creational design patterns play a significant role since they make it possible for object instantiation to be separated from their utilization thereby increasing the flexibility and scalability of object creation. This blog post will focus on five main types of creational design patterns: Factory Method, Abstract Factory, Builder, Prototype and Singleton. To show how each one works, we will use real-world examples in Java.

1. Factory Method

The Factory Method pattern defines an interface for creating an object but allows subclasses to alter the type of objects that will be created. This pattern supports loose coupling in Java to stop the need to bind application-specific classes into the code.

Real-life Scenario: Consider a logistics company that transports goods using various vehicles such as trucks and ships. The type of vehicle depends on the transport mode required.

// Product Interface
interface Transport {
    void deliver();
}

// Concrete Products
class Truck implements Transport {
    @Override
    public void deliver() {
        System.out.println("Deliver by land in a truck.");
    }
}

class Ship implements Transport {
    @Override
    public void deliver() {
        System.out.println("Deliver by sea in a ship.");
    }
}

// Creator
abstract class Logistics {
    public abstract Transport createTransport();

    public void planDelivery() {
        Transport transport = createTransport();
        transport.deliver();
    }
}

// Concrete Creators
class RoadLogistics extends Logistics {
    @Override
    public Transport createTransport() {
        return new Truck();
    }
}

class SeaLogistics extends Logistics {
    @Override
    public Transport createTransport() {
        return new Ship();
    }
}

// let's call the main class
public class Main {
    public static void main(String[] args) {
        Logistics logistics = new RoadLogistics();
        logistics.planDelivery();

        logistics = new SeaLogistics();
        logistics.planDelivery();
    }
}

2. Abstract Factory

The Abstract Factory pattern provides an interface for creating families of related or dependent objects without specifying their concrete classes. It is useful when the system needs to be independent of how its objects are created.

Real-life Scenario: Imagine a furniture store that sells different types of furniture sets, such as Victorian and Modern. Each set includes products like chairs and sofas.

// Abstract Products
interface Chair {
    void sitOn();
}

interface Sofa {
    void lieOn();
}

// Concrete Products
class VictorianChair implements Chair {
    @Override
    public void sitOn() {
        System.out.println("Sitting on a Victorian chair.");
    }
}

class ModernChair implements Chair {
    @Override
    public void sitOn() {
        System.out.println("Sitting on a Modern chair.");
    }
}

class VictorianSofa implements Sofa {
    @Override
    public void lieOn() {
        System.out.println("Lying on a Victorian sofa.");
    }
}

class ModernSofa implements Sofa {
    @Override
    public void lieOn() {
        System.out.println("Lying on a Modern sofa.");
    }
}

// Abstract Factory
interface FurnitureFactory {
    Chair createChair();
    Sofa createSofa();
}

// Concrete Factories
class VictorianFurnitureFactory implements FurnitureFactory {
    @Override
    public Chair createChair() {
        return new VictorianChair();
    }

    @Override
    public Sofa createSofa() {
        return new VictorianSofa();
    }
}

class ModernFurnitureFactory implements FurnitureFactory {
    @Override
    public Chair createChair() {
        return new ModernChair();
    }

    @Override
    public Sofa createSofa() {
        return new ModernSofa();
    }
}

// Client code
public class Main {
    private static void createFurniture(FurnitureFactory factory) {
        Chair chair = factory.createChair();
        Sofa sofa = factory.createSofa();
        chair.sitOn();
        sofa.lieOn();
    }

    public static void main(String[] args) {
        FurnitureFactory victorianFactory = new VictorianFurnitureFactory();
        createFurniture(victorianFactory);

        FurnitureFactory modernFactory = new ModernFurnitureFactory();
        createFurniture(modernFactory);
    }
}

3. Builder

The Builder pattern separates the construction of a complex object from its representation, allowing the same construction process to create different representations. It is particularly useful for creating objects with many optional attributes.

Real-life Scenario: Consider an online pizza ordering system where customers can customize their pizzas with various toppings, sizes, and crust types.

// Product
class Pizza {
    private String dough = "";
    private String sauce = "";
    private String topping = "";

    public void setDough(String dough) { this.dough = dough; }
    public void setSauce(String sauce) { this.sauce = sauce; }
    public void setTopping(String topping) { this.topping = topping; }

    @Override
    public String toString() {
        return "Pizza [dough=" + dough + ", sauce=" + sauce + ", topping=" + topping + "]";
    }
}

// Builder Interface
interface PizzaBuilder {
    void buildDough();
    void buildSauce();
    void buildTopping();
    Pizza getPizza();
}

// Concrete Builders
class HawaiianPizzaBuilder implements PizzaBuilder {
    private Pizza pizza;

    public HawaiianPizzaBuilder() {
        this.pizza = new Pizza();
    }

    @Override
    public void buildDough() { pizza.setDough("cross"); }
    @Override
    public void buildSauce() { pizza.setSauce("mild"); }
    @Override
    public void buildTopping() { pizza.setTopping("ham+pineapple"); }
    @Override
    public Pizza getPizza() { return this.pizza; }
}

class SpicyPizzaBuilder implements PizzaBuilder {
    private Pizza pizza;

    public SpicyPizzaBuilder() {
        this.pizza = new Pizza();
    }

    @Override
    public void buildDough() { pizza.setDough("pan baked"); }
    @Override
    public void buildSauce() { pizza.setSauce("hot"); }
    @Override
    public void buildTopping() { pizza.setTopping("pepperoni+salami"); }
    @Override
    public Pizza getPizza() { return this.pizza; }
}

// Director
class Waiter {
    private PizzaBuilder pizzaBuilder;

    public void setPizzaBuilder(PizzaBuilder pb) { pizzaBuilder = pb; }
    public Pizza getPizza() { return pizzaBuilder.getPizza(); }

    public void constructPizza() {
        pizzaBuilder.buildDough();
        pizzaBuilder.buildSauce();
        pizzaBuilder.buildTopping();
    }
}

// Client code
public class Main {
    public static void main(String[] args) {
        Waiter waiter = new Waiter();
        PizzaBuilder hawaiianPizzaBuilder = new HawaiianPizzaBuilder();
        PizzaBuilder spicyPizzaBuilder = new SpicyPizzaBuilder();

        waiter.setPizzaBuilder(hawaiianPizzaBuilder);
        waiter.constructPizza();
        Pizza pizza1 = waiter.getPizza();
        System.out.println("Pizza built: " + pizza1);

        waiter.setPizzaBuilder(spicyPizzaBuilder);
        waiter.constructPizza();
        Pizza pizza2 = waiter.getPizza();
        System.out.println("Pizza built: " + pizza2);
    }
}

4. Prototype

The Prototype pattern is used to create a new object by copying an existing object, known as the prototype. This pattern is useful when the cost of creating a new object is expensive.

Real-life Scenario: Think of a graphical editor where you can create, duplicate, and edit shapes.

import java.util.HashMap;
import java.util.Map;

// Prototype
abstract class Shape implements Cloneable {
    private String id;
    protected String type;

    abstract void draw();

    public String getType() { return type; }
    public String getId() { return id; }
    public void setId(String id) { this.id = id; }

    public Object clone() {
        Object clone = null;
        try {
            clone = super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return clone;
    }
}

// Concrete Prototypes
class Rectangle extends Shape {
    public Rectangle() { type = "Rectangle"; }
    @Override
    public void draw() { System.out.println("Drawing a Rectangle."); }
}

class Circle extends Shape {
    public Circle() { type = "Circle"; }
    @Override
    public void draw() { System.out.println("Drawing a Circle."); }
}

// Prototype Registry
class ShapeCache {
    private static Map<String, Shape> shapeMap = new HashMap<>();

    public static Shape getShape(String shapeId) {
        Shape cachedShape = shapeMap.get(shapeId);
        return (Shape) cachedShape.clone();
    }

    public static void loadCache() {
        Rectangle rectangle = new Rectangle();
        rectangle.setId("1");
        shapeMap.put(rectangle.getId(), rectangle);

        Circle circle = new Circle();
        circle.setId("2");
        shapeMap.put(circle.getId(), circle);
    }
}

// Client code
public class Main {
    public static void main(String[] args) {
        ShapeCache.loadCache();

        Shape clonedShape1 = ShapeCache.getShape("1");
        System.out.println("Shape: " + clonedShape1.getType());

        Shape clonedShape2 = ShapeCache.getShape("2");
        System.out.println("Shape: " + clonedShape2.getType());
    }
}

5. Singleton

The Singleton pattern ensures a class has only one instance and provides a global point of access to it. This pattern is commonly used for logging, caching, and thread pools.

Real-life Scenario: Imagine a printer spooler where only one instance should manage all print jobs.

class PrinterSpooler {
    private static PrinterSpooler instance;

    private PrinterSpooler() {
        // private constructor to prevent instantiation
    }

    public static PrinterSpooler getInstance() {
        if (instance == null) {
            instance = new PrinterSpooler();
        }
        return instance;
    }

    public void print(String document) {
        System.out.println("Printing document: " + document);
    }
}

// Client code
public class Main {
    public static void main(String[] args) {
        PrinterSpooler spooler1 = PrinterSpooler.getInstance();
        PrinterSpooler spooler2 = PrinterSpooler.getInstance();

        spooler1.print("Document 1");
        spooler2.print("Document 2");

        System.out.println("Are both spoolers the same instance? " + (spooler1 == spooler2));
    }
}

References

https://refactoring.guru/

https://www.javatpoint.com/design-patterns-in-java

https://www.digitalocean.com/community/tutorials/java-design-patterns-example-tutorial

5 helpful plugins for IntelliJ IDEA: Enhance your Spring Boot and Java development experience

Tharindu Dulshan Fernando — Thu, 11 Jul 2024 20:05:18 +0000

For any Spring Boot developer, two primary goals are maximum productivity and high-quality code. One of the most widely applied Integrated Development Environments today is IntelliJ IDEA. More than that, it provides a huge set of plugins that facilitate development processes. In this article, we shall discover 5 IntelliJ plugins every Spring Boot developer should consider in his toolbox.

1. SonarLint

SonarLint is a static code analysis tool for real-time feedback within the IDE on the quality of the code. This ensures high quality and best practices of code.

Key Features:

Instant Feedback: Highlights code issues as you type, providing instant feedback on potential bugs, vulnerabilities, and code smells.
Rule Customization: Allows customization of rules to fit your project's coding standards.
Integration with SonarQube: Offers seamless integration with SonarQube for comprehensive code analysis.

Link - https://plugins.jetbrains.com/plugin/7973-sonarlint

2. JRebel for IntelliJ

JRebel is a productivity tool that enables developers to instantly see the impact of code changes without restarting the application. The JRebel plugin for IntelliJ integrates this powerful feature into the IDE.

Key Features:

Hot Reloading: Reloads code changes on-the-fly, eliminating the need for application restarts.
Time-Saving: Significantly reduces development time by speeding up the feedback loop.
Support for Various Frameworks: Works seamlessly with Spring Boot and other Java frameworks.

Link - https://plugins.jetbrains.com/plugin/4441-jrebel-and-xrebel

3. SwaggerHub Plugin

The SwaggerHub plugin allows you to view and edit your OpenAPI definitions stored in SwaggerHub directly from within IntelliJ. You will be able to access the APIs and domains of your organization and sync the changes back into SwaggerHub.

Both SwaggerHub SaaS and On-Premise are supported.

Key Features:

API Documentation: Provides tools for generating and editing Swagger/OpenAPI documentation.
Code Generation: Generates client code for various programming languages from API definitions.
Visualization: Allows for the visualization of API endpoints and their details within the IDE.

Link - https://support.smartbear.com/swaggerhub/docs/en/integrations/swaggerhub-plugin-for-intellij-idea.html

4. Lombok Plugin

Lombok is a Java library that reduces boilerplate code. The plugin to IntelliJ IDEA, Lombok Plugin, integrates perfectly, and all the features of Lombok are at your disposal.

Key Features:

Annotations Support: Enables the use of Lombok annotations like @Getter, @setter, @builder, and more.
Code Generation: Automatically generates boilerplate code, such as getters, setters, constructors, and builders.

Link - https://plugins.jetbrains.com/plugin/6317-lombok

5. RestfulTool plugin

The RestfulTool plugin provides tools for developing and testing RESTful services, making it easier to work with APIs within IntelliJ IDEA.

Key Features:

Request Generation: Allows you to generate and test HTTP requests directly from the IDE.
cURL Command Generation: Generates cURL commands from HTTP requests, simplifying API testing.
Endpoint Management: Helps manage and organize RESTful endpoints.

Link - https://plugins.jetbrains.com/plugin/14280-restful-tool

Bonus Plugin

6. Json2Pojo Plugin

Allows the creation of easily Java POJOs from JSON with GSON annotations and accessors. Once installed, right-click the destination package and choose "New -> Generate POJOs from JSON", then fill in your root class name and source JSON text as appropriate.

The JSON to POJO plugin is one very useful tool in the estimation of JSON data to Java POJO classes.

Key Features:

Code Generation: Automatically generates Java classes from JSON, saving time and effort.
Customizable Output: Allows customization of the generated code to match your coding standards.

Conclusion

These plugins will smooth and increase the workflow, thus enabling the delivery of quality applications within a quicker time frame. Besides helping one save time, such tools are important in the maintenance of best practices and coding standards, thus making the overall development experience more pleasurable and productive.

Understanding @Transactional in Spring Boot

Tharindu Dulshan Fernando — Fri, 05 Jul 2024 08:04:26 +0000

Managing transactions in Spring Boot can be done using @Transactional annotation. In this blog post, we'll explore how to use @Transactional to ensure data consistency and simplify error handling in your spring boot applications.

1. Basic Usage

To use @Transactional, you typically place it on methods of a service class where you want the transactional behaviour.

import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
public class UserService{

    @Transactional
    public void createUser() {
        // enter your transactional code here
    }
}

2. Propagation and Isolation Levels

You can specify the propagation and isolation levels of a transaction to control how the transaction behaves:

Propagation: Defines how the transaction behaves when an existing transaction is already running.
Isolation: Defines the data visibility level of the transaction.

@Transactional(propagation = Propagation.REQUIRED, 
              isolation = Isolation.READ_COMMITTED)
public void createUser() {
    // enter your transactional code here
}

3. Rollback Rules

You can specify which exceptions should trigger a rollback:

@Transactional(rollbackFor = Exception.class)
public void createUser() {
    // your transactional code here
}

4. Read-Only Transactions

If your method only reads data and does not perform any write operations, you can mark it as read-only for performance optimizations:

@Transactional(readOnly = true)
public void getUser() {
    // your read-only code here
}

5. Transactional on Classes

You can also place @Transactional at the class level to apply it to all methods in the class:

@Service
@Transactional
public class UserService {

    public void getUser() {
        // transactional code
    }

    public void createUser() {
        // transactional code
    }
}

Example Service with Transactional Methods

import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
public class UserService {

    @Transactional
    public void saveUser() {
        // code to save data
    }

    @Transactional(readOnly = true)
    public void fetchUser() {
        // code to fetch data
    }

    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void newTransaction() {
        // code to execute in a new transaction
    }

    @Transactional(rollbackFor = {CustomException.class})
    public void performWithRollback() {
        // risky code that may throw CustomException
    }
}

Summary

Using @Transactional Spring Boot allows you to manage transactions declaratively, specifying exactly how you want transactions to behave in various scenarios. This helps ensure data consistency and simplifies error handling in your applications.

References

https://www.baeldung.com/spring-transactions-read-only

https://docs.spring.io/spring-framework/reference/data-access/transaction/declarative/annotations.html

https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/transaction/annotation/Transactional.html

Github: https://github.com/tharindu1998/transactional-blog

Understanding Lazy Initialization in Spring Boot

Tharindu Dulshan Fernando — Wed, 26 Jun 2024 09:38:11 +0000

In this blog, we'll explore the concept of lazy initialization in Spring Boot, how to use the "@ Lazy" annotation, and the benefits it can bring to your applications.

What is Lazy Initialization?

Lazy initialization is a design pattern which delays the creation of an object until it is really needed. In the context of Spring, it means that a bean is not instantiated and initialized until it is first requested. This can be particularly useful for improving the startup time of an application, especially if there are many beans or if some beans are resource-intensive to create.

The "@ Lazy" Annotation

Spring provides the "@ Lazy" annotation to enable lazy initialization. This annotation can be used in several ways:

1. Using @ Lazy on Bean Definitions

To use "@ Lazy" on a bean definition, simply annotate the bean method with "@ Lazy".

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Lazy;

@Configuration
public class AppConfig {

    @Bean
    @Lazy
    public TestBean testBean() {
        return new testBean();
    }
}

In this example, "testBean" will not be created until it is first requested.

2. Using @ Lazy on Configuration Classes

You can also apply "@ Lazy" at the class level to indicate that all beans within the configuration should be lazily initialized.

import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Lazy;
import org.springframework.context.annotation.Bean;

@Configuration
@Lazy
public class LazyConfig {

    @Bean
    public TestBean testBean() {
        return new TestBean();
    }

    @Bean
    public AnotherTestBean anotherTestBean() {
        return new AnotherTestBean();
    }
}

In this case, both "testBean" and "anotherTestBean" will be lazily initialized.

3. Using @lazy on Dependencies

You can use "@ Lazy" on a field or method parameter to lazily resolve the dependency.

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Component;

@Component
public class TestComponent {

    private final TestBean testBean;

    @Autowired
    public TestComponent(@Lazy TestBean testBean) {
        this.testBean = testBean;
    }

    // you can include other methods here
}

Here, "testBean" will only be created when it is first accessed in "TestComponent".

Benefits of Lazy Initialization

Improved Startup Time: By deferring the creation of beans until they are needed, the initial startup time of the application can be reduced.
Resource Management: Lazy initialization can help manage resources more efficiently by only instantiating beans that are actually used.
Avoiding Circular Dependencies: Lazy initialization can help break circular dependencies by delaying the creation of beans.

Conclusion

By using the "@ Lazy" annotation, you can control when beans are instantiated and initialized. However, it's important to use this feature carefully and be aware of its potential impact on application performance.

References

https://www.baeldung.com/spring-lazy-annotation

https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/context/annotation/Lazy.html

Github : https://github.com/tharindu1998/lazy-annotation

Creating a Secure NestJS Backend with JWT Authentication and Prisma

Tharindu Dulshan Fernando — Thu, 13 Jun 2024 15:09:51 +0000

In this tutorial, we will create a secure backend application using NestJS, Prisma, and JWT-based authentication. Our application will include CRUD operations for managing books, with endpoints protected by JWT authentication.

Prerequisites

Before we start, ensure you have the following installed on your machine:

Node.js and npm(Better to have a Lts version Installed)
Nest CLI: Install globally using npm install -g @nestjs/cli
PostgreSQL (or any other Prisma-supported database) running and accessible

Step 1: Create a New NestJS Project

First, create a new NestJS project using the Nest CLI:

nest new book-store
cd book-store

Step 2: Install Dependencies

Next, install the necessary dependencies for JWT authentication and Prisma:

npm install @nestjs/jwt @nestjs/passport passport passport-jwt @prisma/client prisma

Step 3: Initialize Prisma

If you are using the docker image of Postgresql add the below lines in the docker-compose.yml.

version: '3.8'
services:
  postgres:
    container_name: postgres_container
    image: postgres:13
    ports:
      - 5434:5432
    environment:
      POSTGRES_USER: postgres
      POSTGRES_PASSWORD: 123
      POSTGRES_DB: book-store
    volumes:
      - postgres_data:/var/lib/postgresql/data

Update your .env file with your database connection string.

DATABASE_URL="postgresql://postgres:123@localhost:5434/book-store?schema=public"

Initialize Prisma in your project and configure the database connection:

npx prisma init

Step 4: Configure Prisma Schema

Edit prisma/schema.prisma to include the User and Book models:

datasource db {
  provider = "postgresql"
  url      = env("DATABASE_URL")
}

generator client {
  provider = "prisma-client-js"
}

model User {
  id       Int     @id @default(autoincrement())
  createdAt DateTime @default(now())
  updatedAt DateTime @updatedAt
  email    String  @unique

  firstName String?
  lastName  String?

  password String
}

model Book {
  id       Int    @id @default(autoincrement())
  createdAt DateTime @default(now())
  updatedAt DateTime @updatedAt
  title       String
  description String?
  link        String
  userId   Int
}

Run the Prisma migration to apply the schema to the database:

npx prisma migrate dev --name init

Generate the Prisma client:

npx prisma generate

Step 5: Set Up Authentication

Generate the Auth module, controller, and service:

nest generate module auth
nest generate controller auth
nest generate service auth

Configure the Auth module:

import { Module } from '@nestjs/common';
import { JwtModule } from '@nestjs/jwt';
import { PassportModule } from '@nestjs/passport';
import { AuthService } from './auth.service';
import { AuthController } from './auth.controller';
import { JwtStrategy } from './jwt.strategy';
import { PrismaService } from '../prisma.service';

@Module({
  imports: [
    PassportModule,
    JwtModule.register({
      secret: process.env.JWT_SECRET || 'secretKey',
      signOptions: { expiresIn: '60m' },
    }),
  ],
  providers: [AuthService, JwtStrategy, PrismaService],
  controllers: [AuthController],
})
export class AuthModule {}

Configure the auth.service.ts

Implement the AuthService with registration and login functionality:

import { Injectable } from '@nestjs/common';
import { JwtService } from '@nestjs/jwt';
import { PrismaService } from '../prisma.service';
import * as bcrypt from 'bcrypt';

@Injectable()
export class AuthService {
  constructor(
    private jwtService: JwtService,
    private prisma: PrismaService
  ) {}

  async validateUser(email: string, pass: string): Promise<any> {
    const user = await this.prisma.user.findUnique({ where: { email } });
    if (user && await bcrypt.compare(pass, user.password)) {
      const { password, ...result } = user;
      return result;
    }
    return null;
  }

  async login(user: any) {
    const payload = { email: user.email, sub: user.id };
    return {
      access_token: this.jwtService.sign(payload),
    };
  }

  async register(email: string, pass: string) {
    const salt = await bcrypt.genSalt();
    const hashedPassword = await bcrypt.hash(pass, salt);

    const user = await this.prisma.user.create({
      data: {
        email,
        password: hashedPassword,
      },
    });

    const { password, ...result } = user;
    return result;
  }
}

Configure the auth.controller.ts

Create endpoints for login and registration in AuthController:

import { Controller, Post, Body } from '@nestjs/common';
import { AuthService } from './auth.service';

@Controller('auth')
export class AuthController {
  constructor(private authService: AuthService) {}

  @Post('login')
  async login(@Body() req) {
    return this.authService.login(req);
  }

  @Post('register')
  async register(@Body() req) {
    return this.authService.register(req.email, req.password);
  }
}

Configure the jwt.strategy.ts

import { Injectable } from '@nestjs/common';
import { PassportStrategy } from '@nestjs/passport';
import { ExtractJwt, Strategy } from 'passport-jwt';

@Injectable()
export class JwtStrategy extends PassportStrategy(Strategy) {
  constructor() {
    super({
      jwtFromRequest: ExtractJwt.fromAuthHeaderAsBearerToken(),
      ignoreExpiration: false,
      secretOrKey: process.env.JWT_SECRET || 'secretKey',
    });
  }

  async validate(payload: any) {
    return { userId: payload.sub, email: payload.email };
  }
}

Create the JWT authentication guard(jwt-auth.guard.ts):

import { Injectable } from '@nestjs/common';
import { AuthGuard } from '@nestjs/passport';

@Injectable()
export class JwtAuthGuard extends AuthGuard('jwt') {}

Step 6: Set Up Prisma Service

Create a Prisma service(prisma.service.ts) to handle database interactions:

import { Injectable, OnModuleInit, OnModuleDestroy } from '@nestjs/common';
import { PrismaClient } from '@prisma/client';

@Injectable()
export class PrismaService extends PrismaClient implements OnModuleInit, OnModuleDestroy {
  async onModuleInit() {
    await this.$connect();
  }

  async onModuleDestroy() {
    await this.$disconnect();
  }
}

Step 7: Create Books Module

Generate the Books module, controller, and service:

nest generate module books
nest generate controller books
nest generate service books

Configure the Books module(books.module.ts):

import { Module } from '@nestjs/common';
import { BooksService } from './books.service';
import { BooksController } from './books.controller';
import { PrismaService } from '../prisma.service';

@Module({
  providers: [BooksService, PrismaService],
  controllers: [BooksController]
})
export class BooksModule {}

Implement the BooksService(books.service.ts):

import { Injectable } from '@nestjs/common';
import { PrismaService } from '../prisma.service';
import { Book } from '@prisma/client';

@Injectable()
export class BooksService {
  constructor(private prisma: PrismaService) {}

  async create(data: Omit<Book, 'id'>): Promise<Book> {
    return this.prisma.book.create({ data });
  }

  async findAll(userId: number): Promise<Book[]> {
    return this.prisma.book.findMany({ where: { userId } });
  }

  async findOne(id: number, userId: number): Promise<Book> {
    return this.prisma.book.findFirst({ where: { id, userId } });
  }

  async update(id: number, data: Partial<Book>, userId: number): Promise<Book> {
    return this.prisma.book.updateMany({
      where: { id, userId },
      data,
    }).then((result) => result.count ? this.prisma.book.findUnique({ where: { id } }) : null);
  }

  async remove(id: number, userId: number): Promise<Book> {
    return this.prisma.book.deleteMany({
      where: { id, userId },
    }).then((result) => result.count ? this.prisma.book.findUnique({ where: { id } }) : null);
  }
}

Secure the BooksController with JWT authentication:

import { Controller, Get, Post, Body, Patch, Param, Delete, UseGuards, Request } from '@nestjs/common';
import { BooksService } from './books.service';
import { JwtAuthGuard } from '../auth/jwt-auth.guard';

@Controller('books')
@UseGuards(JwtAuthGuard)
export class BooksController {
  constructor(private readonly booksService: BooksService) {}

  @Post()
  create(@Body() createBookDto, @Request() req) {
    return this.booksService.create({ ...createBookDto, userId: req.user.userId });
  }

  @Get()
  findAll(@Request() req) {
    return this.booksService.findAll(req.user.userId);
  }

  @Get(':id')
  findOne(@Param('id') id: string, @Request() req) {
    return this.booksService.findOne(+id, req.user.userId);
  }

  @Patch(':id')
  update(@Param('id') id: string, @Body() updateBookDto, @Request() req) {
    return this.booksService.update(+id, updateBookDto, req.user.userId);
  }

  @Delete(':id')
  remove(@Param('id') id: string, @Request() req) {
    return this.booksService.remove(+id, req.user.userId);
  }
}

Step 8: Integrate Everything

Ensure all modules are correctly imported in the main app module:

import { Module } from '@nestjs/common';
import { AuthModule } from './auth/auth.module';
import { BooksModule } from './books/books.module';

@Module({
  imports: [AuthModule, BooksModule],
})
export class AppModule {}

Running the Application

npm run start:dev

Conclusion

In this tutorial, we created a NestJS application with Prisma for database interaction and JWT for securing the API endpoints. We covered setting up the Prisma schema, creating modules for authentication and books, and securing the endpoints using JWT guards. You now have a secure NestJS backend with JWT-based authentication and CRUD operations for books.

References

https://docs.nestjs.com/v5/

https://www.prisma.io/docs

https://jwt.io/introduction

Github : https://github.com/tharindu1998/book-store

Understanding Dependency Injection in Spring Boot

Tharindu Dulshan Fernando — Wed, 05 Jun 2024 11:35:31 +0000

In simple terms DI means that objects do not initiate their dependencies directly. Instead they recive them from an external source.

When class A uses some functionality of class B, then its said that class A has a dependency of class B.

What is DI in Spring Framework?

Dependency Injection (DI) is a fundamental concept in Spring Framework that makes it possible to develop loosely coupled and easily testable code. In this blog, we'll explore what dependency injection is, how it works in Spring Boot, and provide examples to illustrate its usage.

There are three main types of dependency injection:

Constructor Injection
Setter Injection
Field Injection

Constructor Injection

This is the most recommended way to acheive DI in Spring.It ensures that the dependency is not null and makes the class immutable.

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

@Service
public class TestService {

    private final TestRepository repository;

    @Autowired
    public TestService(TestRepository  repository) {
        this.repository = repository;
    }

    public void performService() {
        repository.doSomething();
    }
}

In the example above, TestService class declares a dependency on TestRepository. The dependency is injected via the constructor, which is annotated with @Autowired.

Setter Injection

Setter injection allows the dependency to be injected through a setter method. This method is less preferred than constructor injection because it allows the object to be in an incomplete state.

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

@Service
public class TestService {

    private TestRepository repository;

    @Autowired
    public void setTestRepository(TestRepository repository) {
        this.repository = repository;
    }

    public void performService() {
        repository.doSomething();
    }
}

In this example, TestService class has a setter method setTestRepository, which is used to inject the TestRepository dependency.

Field Injection

Field injection is the least preferred method because it makes the class less testable and harder to maintain. It involves annotating the dependency field directly with @Autowired.

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

@Service
public class TestService {

    @Autowired
    private TestRepository repository;

    public void performService() {
        repository.doSomething();
    }
}

Here, TestRepository is injected directly into the field of TestService using @Autowired.

Qualifiers

When there are multiple beans of the same type, you can use @Qualifier to specify which bean should be injected.

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Service;

@Service
public class TestService {

    private final TestRepository myRepository;

    @Autowired
    public TestService(@Qualifier("specificRepository")TestRepository repository) {
        this.repository = repository;
    }

    public void performService() {
        repository.doSomething();
    }
}

In this example, @Qualifier("specificRepository") specifies that a particular implementation of TestRepository should be injected.

Conclusion

Dependency Injection is a powerful pattern that helps to create loosely coupled, maintainable, and testable applications. Spring Boot leverages dependency injection to manage the lifecycle and configuration of application components, making development more straightforward and efficient. By understanding and applying constructor, setter, and field injection, as well as using qualifiers when necessary, you can create robust Spring Boot applications.

References

https://www.baeldung.com/spring-dependency-injection

https://www.baeldung.com/inversion-control-and-dependency-injection-in-spring

https://docs.spring.io/spring-framework/reference/core/beans/dependencies/factory-collaborators.html

Github : https://github.com/tharindu1998/SpringDependencyInjection

Step-by-Step Guide: Setting Up Elasticsearch and Kibana with Docker

Tharindu Dulshan Fernando — Fri, 31 May 2024 11:01:54 +0000

Setting up Elasticsearch and Kibana using Docker on a Mac is a straightforward process. Follow this step-by-step guide to integrate and visualize your developer metrics data.

Prerequisites: Ensure you have Docker installed on your Mac. You can download it from the Docker website.

Step 1: Create a docker-compose.yml File

Create a directory for your project and within that directory, create a docker-compose.yml file with the following content:

version: '7.16.3'
services:
  elasticsearch:
    image: docker.elastic.co/elasticsearch/elasticsearch:7.16.3
    container_name: elasticsearch
    environment:
      - discovery.type=single-node
      - ES_JAVA_OPTS=-Xms512m -Xmx512m
    ports:
      - "9200:9200"
    volumes:
      - esdata:/usr/share/elasticsearch/data

  kibana:
    image: docker.elastic.co/kibana/kibana:7.16.3
    container_name: kibana
    ports:
      - "5601:5601"
    depends_on:
      - elasticsearch

volumes:
  esdata:
    driver: local

This configuration sets up both Elasticsearch and Kibana, with Elasticsearch running on port 9200 and Kibana on port 5601.

Step 2: Start the Docker Containers

Open your terminal, navigate to the directory containing your docker-compose.yml file, and run:

docker-compose up -d

This command will start both Elasticsearch and Kibana in the background.

Step 3: Index the JSON Data into Elasticsearch

Consider this is only an example JSON just to explain the integration.

Save the following JSON data into a file named developer_metrics.json:

{
  "developer": "John Doe",
  "metrics": {
    "time_spent_coding": 120,
    "review_time": 35,
    "planned_overhead_time": 20,
    "untracked_time": 25,
    "effective_work": 15,
    "other_metrics": {
      "opened_pull_requests": 18,
      "merged_pull_requests": 15,
      "closed_pull_requests": 3,
      "created_feature_branches": 10,
      "lines_of_code": 2000,
      "inactive_days": 2
    }
  },
  "dates": {
    "start_date": "2024-05-01",
    "end_date": "2024-05-28"
  }
}

Use curl to index this data into Elasticsearch:

curl -X POST "localhost:9200/developer_metrics/_doc/1?pretty" -H 'Content-Type: application/json' -d @developer_metrics.json

Step 4: Create a Mapping for the Index

To ensure Elasticsearch correctly interprets our data fields, we need to define a mapping for our index.

Run the following curl command to create the mapping:

curl -X PUT "localhost:9200/developer_metrics?pretty" -H 'Content-Type: application/json' -d'
{
  "mappings": {
    "properties": {
      "developer": { "type": "keyword" },
      "metrics": {
        "properties": {
          "time_spent_coding": { "type": "integer" },
          "review_time": { "type": "integer" },
          "planned_overhead_time": { "type": "integer" },
          "untracked_time": { "type": "integer" },
          "effective_work": { "type": "integer" },
          "other_metrics": {
            "properties": {
              "opened_pull_requests": { "type": "integer" },
              "merged_pull_requests": { "type": "integer" },
              "closed_pull_requests": { "type": "integer" },
              "created_feature_branches": { "type": "integer" },
              "lines_of_code": { "type": "integer" },
              "inactive_days": { "type": "integer" }
            }
          }
        }
      },
      "dates": {
        "properties": {
          "start_date": { "type": "date" },
          "end_date": { "type": "date" }
        }
      }
    }
  }
}'

Step 5: Visualize the Data in Kibana

With our data indexed, it’s time to create visualizations in Kibana.

Creating an Index Pattern

Open Kibana in your browser by navigating to http://localhost:5601.
Navigate to Stack Management -> Index Patterns.
Click Create index pattern and specify developer_metrics as the index pattern.
Follow the prompts to complete the setup.

Creating Visualizations

Go to the Visualize Library.
Click Create visualization and choose a visualization type (e.g., bar chart, line chart).
Select the developer_metrics index pattern.
Configure your visualization by selecting fields like time_spent_coding, opened_pull_requests, etc.

Building a Dashboard

Navigate to Dashboard.
Click Create new dashboard.
Add your visualizations to the dashboard.

Conclusion

Using Docker to set up Elasticsearch and Kibana on a Mac simplifies the process and ensures a consistent environment. By following these steps, you can easily visualize and analyze developer metrics data, helping you make informed decisions and track performance effectively.

This setup can be customized and expanded to suit your specific needs. Start leveraging these powerful tools today to enhance your project’s efficiency and transparency.

References

https://www.elastic.co/guide/en/elasticsearch/reference/current/index.html

https://www.elastic.co/guide/en/kibana/current/introduction.html