DEV Community: bryam vega

Streams in Java: Mastering or abuse?

bryam vega — Wed, 22 Jan 2025 22:24:54 +0000

It looked elegant, concise, and modern. But when we revisited the code six months later, nobody understood what it did. Was it mastery? Or just over-engineered cleverness?

Java Streams have become a hallmark of modern Java development. Introduced in Java 8, they offer a functional approach to working with collections, enabling developers to write concise and expressive code. But as with any tool, their effectiveness depends on how and when they are used.

What is a Stream?

The Streams were introduced in Java 8, and although Java is currently in versions higher than 21, this version marked an inflection point in the way Java is used nowadays. Within it is the API Stream that nowadays is too much used by Java programmers.

Streams provide a functional and declarative way of processing data. They allow to manipulate data collections efficiently, using operations such as map, filter, reduce, among others. For example:

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

// whitout streams
List<Integer> evenNumbers = new ArrayList<>();
for (Integer number : numbers) {
    if (number % 2 == 0) {
        evenNumbers.add(number);
    }
}


// with streams
List<Integer> evenNumbers = numbers.stream()
                                   .filter(number -> number % 2 == 0)
                                   .collect(Collectors.toList());

This approach is modern because:

It reduces boilerplate code.
It promotes functional programming.
It allows parallel operations easily with parallelStream().

But in my experience, the excessive use of streams ends up complicating the understanding of the code, so simplicity does not always mean clarity, and that is where the problems arise.

The senior-junior dilemma: elegant but incomprehensible vs. simple but robust

When trying to explain the importance of Streams, most of the time I've come across images like this:

And I ask myself... 🤔 why is Senior level using Stream to solve this problem?

Let’s break it down.

The "junior" approach: A straightforward loop, simple and clear. It works, it’s easy to read, and any developer—junior or senior—can understand it without much effort.
The "senior" approach: Using Streams to achieve the same result but with more compact, declarative code. At first glance, it might seem more sophisticated or "modern."

But here’s the catch: Does using Streams in this scenario actually add value? Or does it introduce unnecessary complexity, just to showcase a tool?

Let's go with another much more crazy example that I saw and it made my head hurt 😵‍💫😵‍💫.

Imagine that you are watching programming videos and suddenly a guy appears and presents you with the following code.

public class CodeVerification {

  private static final String NUMBERS = "12345";
  private static final Integer LENGTH_CODE = 10;

  private final Random random;

  public CodeVerification(Random random) {
    this.random = random;
  }

  public String generateCode(){
    var builder = new StringBuilder();

    for (int i = 0; i < LENGTH_CODE; i++) {
      var index = random.nextInt(NUMBERS.length());
      builder.append(NUMBERS.charAt(index));
    }

    return builder.toString();
  }
}

Now, this developer asks you to refactor the generateCode() method. He presents the following solution:

public String generateCode(){
    return IntStream.range(0, LENGTH_CODE)
        .mapToObj(i -> random.nextInt(NUMBERS.length()))
        .map(NUMBERS::charAt)
        .collect(StringBuilder::new, StringBuilder::append,
            StringBuilder::append)
        .toString();
}

Do you see it now? 🧐🧐 You do realize what I mean right!!!!

Both codes work exactly the same, but what happens?? We go from a perfectly understandable, readable and maintainable code to a code that is difficult to understand and that does not add value or improve the performance of the code. Also, the code is not refactored, that's a topic we can talk about in another post.

So, with that, I come to the conclusion that a Senior is not someone who knows how to use Streams perfectly and applies them everywhere with the justification of "refactoring" the code. Being a Senior is understanding that refactoring doesn’t always mean making the code more "modern" or "functional," but rather making it clearer, more efficient, and easier to maintain.

A Senior knows when to use a simple for loop because it’s the most straightforward and effective solution, and when to choose Streams when they truly add clarity or performance benefits. The key is understanding the problem, not the tool. If the traditional solution is simpler and keeps the code readable, there’s no need to complicate it with Streams just to follow a trend.

The real value of a Senior lies in their ability to make pragmatic decisions, based on the project's context and the team's needs, rather than just showing off skills with a tool. A Senior understands that sometimes less is more.

With the above example, does this mean that we should not use Streams? 😢😢😢 Absolutely NOT, here I show you a way to use streams to solve the same problem, keeping code readability, however this does not mean that it is more optimal.

public String generateCode(){
    IntStream randomIndexes = random.ints(LENGTH_CODE, 0, NUMBERS.length());

    Stream<Character> characters = randomIndexes.mapToObj(NUMBERS::charAt);

    String code = characters.map(String::valueOf)
        .collect(Collectors.joining());

    return code 
}

This is more readable, right? This is simply because we separate the stream into steps, one of the best practices of Streams is to ❌ NOT CONCATENATE SEVERAL STEPS IN A SINGLE STEP.

Best practices: How to use Streams without abuse

Here are some tips that I have acquired throughout my experience in working with streams

Prioritize Readability Over Conciseness:If a Stream is difficult to understand at first glance, it probably needs refactoring.
Avoid Excessive Nesting of Operations: Break complex operations into intermediate steps with descriptive names
Don’t Use Streams When a Simple Loop Is Enough: For simple tasks like modifying a single element or performing basic calculations, Streams may be unnecessary
Use Parallel Streams with Caution: While parallel Streams (parallelStream()) can improve performance, incorrect use may lead to concurrency issues or performance degradation.
Add Comments Where Necessary: If you use a complex operation in a Stream, document its purpose so others can understand it quickly.

Conclusion

Streams are a powerful feature in modern Java, but their true value lies in knowing when and how to use them effectively. There is no "seniority" in using or not using Streams—it’s just a different way of programming. A Senior developer understands that it’s not about the tool, but about choosing the right solution for the problem. Whether that means using Streams, loops, or any other approach, the key is writing code that is clean, maintainable, and easy to understand.

The goal should always be clean, maintainable, and understandable code, remember: clarity always comes first.

Streams can be incredibly powerful when used correctly, but overusing them can lead to unnecessary complexity and remember: less is often more.

Happy coding!! ❤️

Implementing Feature Flags with Spring: A Step-by-Step Guide for Feature Deployment

bryam vega — Tue, 21 Jan 2025 18:27:16 +0000

Introduction

Feature flags, also known as feature toggles, are a software development technique that allows teams to enable or disable features dynamically. By decoupling feature deployment from code releases, they provide enhanced control over the application’s behavior and mitigate risks associated with new feature rollouts.

Benefits of Feature Flags:

Controlled Rollouts: Gradually introduce new features to a subset of users.
A/B Testing: Compare variations of a feature to improve user experience.
Quick Rollbacks: Disable malfunctioning features without a full redeployment.
Continuous Deployment: Safely deploy code even if certain features are not yet complete.

How to work Feature-flags

Feature flags operate by introducing conditional logic into your application code. Here’s a step-by-step breakdown of how they work:

Step 1: Define a Feature Flag

Decide on a meaningful name for your feature flag (e.g., new-feature).
Identify the scope of the flag: whether it will be applied globally, for specific users, or for particular environments.

Step 2: Add Conditional Logic

Modify your application code to check the status of the feature flag before executing a feature. This is a simple representation about how could be works a feature flag and could be the most simple way to implement. For example:

if (featureFlagService.isEnabled("new-feature")) {
    // New feature logic
} else {
    // Fallback logic
}

Step 3: Store and Manage the Flag

Use one of the following methods to store feature flags:

Configuration Files: Use application properties or YAML files.
Remote Service: Utilize a feature flag management tool like Unleash. (For me this is the best way)
Database: Store flags in a database for runtime updates.

Step 4: Control Flag States

Dynamically update the feature flag state (enabled or disabled) using the chosen storage method or management tool.

Step 5: Evaluate Flags at Runtime

The application checks the flag’s state dynamically during execution and activates or deactivates features accordingly.

Step 6: Monitor Usage

Use analytics tools or dashboards provided by feature flag services to track the flag’s impact on users and application performance.

How to implement Feature-Flags with Spring Boot and Unleash

This time, we are going to put into practice the use of Feature-Flags using the Spring Boot framework and using the Unleash platform as our flags handler. Quickly, what we are going to do is the following:

Create a service in Spring Boot: This service is going to be a simple API that demonstrates the deployment of feature flags, it is going to have the unleash SDK installed to be able to work with it.
We are going to create 2 beans that are going to be our features or different functionalities.
Finally we are going to raise an unleash server to configure our flags to enable and disable the functionality to be tested in our Spring service.

Prerequisites

Gradle
Git
Docker
IDE of java (IntelliJ, Eclipse …)

Unleash Configuration

In order to configure Unleash, we will download the following repository using the following command:

$ git clone https://github.com/Unleash/unleash.git

After that, we access the folder of the downloaded repository and execute the following command to be able to run our unleash server.

$ cd unleash
$ docker compose up -d

Once up, we access through the address http://localhost:4242 where the credentials are the following:

Username: admin
Password: unleash4all

With this we will be able to access the following platform, and we have the unleash server up and ready for use:

Create Feature-Flag

To create a flag, we are going to access the default project that is in our unleash server, since we are working with the free version and we cannot create new projects.

Create new feature flag

Once in the default project, select the new feature flag option. Once this option is selected, we proceed to create our own feature flag. Something interesting as you can see in the image, is that in case we do not want to use the unleash sdk, we can communicate through API requests to the unleash server. In this case our feature flag is going to be called featureFlagExample.

With our feature flag created we will see the following screen, which contains information about our flag as well as the different strategies we can configure to deploy the features to our end users (that will be another post)

To activate our feature flag, we will simply activate the development option. These environments will allow us to configure our flags depending on the environment we are in, in this case only development.

Create Project API Key

To be able to communicate with our unleash server and its APIs, it is necessary to create a token that allows us to access its endpoints in order to use our configured flags.

To do this, we go to Project Settings and in this section we have the option New API token, which will allow us to generate our authentication token to consume our flags.

We configure it as shown in the image below, if we notice, on the right side of the image, we are presented with how to create an api token through the API unleash, which is also another option.

This in turn gives us a token created, which we will have to copy anywhere on our computer, since we will only be able to see it that time.

With this, we are now ready to proceed to create our Spring Boot project and configure our feature flag with unleash in our project.

Spring Boot Project (product discount)

A company’s service developed with Spring exposes a REST endpoint that allows consulting the list of available products. The company wants that during discount seasons, the list of products automatically shows the prices with the discount applied, without the end customer having to perform additional calculations. Outside these seasons, the prices should be displayed unchanged.

The project we are going to take as an example is this one: github repo

To download the repository we use the following command:

$ https://github.com/bvegaM/spring-unleash-feature-flag.git
$ cd spring-unleash-feature-flag

We open it in the IDE of preference or the one you prefer, in my case, I will use IntellIJ Idea.

Structure of project

The structure of this project is based on a layered architecture which has the following package tree:

├── HELP.md
├── build.gradle
├── settings.gradle
└── src
    ├── main
    │   ├── java
    │   │   └── ec
    │   │       └── com
    │   │           └── vega
    │   │               └── spring_unleash
    │   │                   ├── SpringUnleashFeatureFlagApplication.java
    │   │                   ├── config
    │   │                   │   └── SpringUnleashFeatureFlagConfiguration.java
    │   │                   ├── controller
    │   │                   │   └── ProductController.java
    │   │                   ├── domain
    │   │                   │   └── Product.java
    │   │                   ├── repository
    │   │                   │   ├── ProductRepository.java
    │   │                   │   └── impl
    │   │                   │       └── ProductRepositoryImpl.java
    │   │                   ├── service
    │   │                   │   ├── ProductService.java
    │   │                   │   └── impl
    │   │                   │       ├── ProductServiceImpl.java
    │   │                   │       └── ProductServiceWithDiscountImpl.java
    │   │                   └── utils
    │   │                       └── Constant.java
    │   └── resources
    │       ├── application.yaml
    │       ├── static
    │       └── templates

The following project has the following classes and interfaces:

SpringUnleashFeatureFlagApplication: Main class of the Spring Boot application. Contains the main method that starts the application. It sets up the Spring context and runs the application.
SpringUnleashFeatureFlagConfiguration: Class that contains a bean method to initialize a list of products, which can be injected into the repository as a temporary database.

@Configuration
public class SpringUnleashFeatureFlagConfiguration {

  @Bean
  public List<Product> initProducts(){
    final List<Product> products = new ArrayList<>();
    products.add(new Product("Product 1", "Description 1", 10, new BigDecimal(50)));
    products.add(new Product("Product 2", "Description 2", 30, new BigDecimal(40)));
    products.add(new Product("Product 3", "Description 3", 5, new BigDecimal(30)));
    return products;
  }
}

ProductController: Class that exposes REST endpoints for the product service, specifically for retrieving all products.
Product: Product class that contains the attributes of the object and also includes a method to calculate the discount for the product.

@Getter
@Setter
@AllArgsConstructor
@NoArgsConstructor
public class Product {

  private String name;
  private String description;
  private Integer quantity;
  private BigDecimal price;

  public Product(Product product) {
    this.name = product.getName();
    this.description = product.getDescription();
    this.quantity = product.getQuantity();
    this.price = product.getPrice();
  }

  public void applyDiscount(BigDecimal discount) {
    BigDecimal discountValue = price.multiply(discount);
    price = price.subtract(discountValue);
  }
}

ProductRepository: Repository interface that simulates database transactions and contains a single method.
ProductRepositoryImpl: Class that implements the ProductRepository interface and uses the bean created in SpringUnleashFeatureFlagConfiguration to retrieve the list of products.
ProductService: Interface that defines the method to retrieve all products. This interface is critical because it sets up the feature flag to determine which implementation to use when the flag is active.
ProductServiceImpl: Class that implements the ProductService interface and returns the products.
ProductServiceWithDiscountImpl: Class that implements the ProductService interface and returns the products with a discount applied.
Constant: Class that contains constant variables.

Install Unleash library

In our downloaded project we go to the build.gradle file and we will notice that in the dependencies section we will have the unleash library installed.

dependencies {
 implementation 'org.springframework.boot:spring-boot-starter-web'
 compileOnly 'org.projectlombok:lombok'
 annotationProcessor 'org.projectlombok:lombok'
 testImplementation 'org.springframework.boot:spring-boot-starter-test'
 testRuntimeOnly 'org.junit.platform:junit-platform-launcher'

 //unleash library
 implementation 'io.getunleash:springboot-unleash-starter:1.1.0'
}

Setting communication service with Unleash server

Once our unleash dependency is installed, we are going to proceed to configure the communication with the Unleash server. To do this we go to the application.yaml and we will see the following configuration.

io:
  getunleash:
    app-name: spring-demo-flag # app name example for unleash (could be any name)
    instance-id: demo-flag-x # instance of service
    environment: development # enviroment Unleash server deploy (in this case is development)
    api-url: http://localhost:4242/api # Unleash server URI
    api-token: <your_token> # token or api key you created in the previous section

Interface to getProducts

This ProductService interface has a method called getProducts() which is decorated with a Toggle (a mechanism for handling feature flags). Below is the explanation of the code:

public interface ProductService {

  @Toggle(name = "featureFlagExample", alterBean = "productServiceWithDiscountImpl")
  List<Product> getProducts();

}

The method getProducts() is a method that returns a list of products (List<Product>). It is a critical method in the product service because it allows retrieving all the products. However, the implementation of how the products are retrieved is linked to the state of the feature flag controlled by the Toggle.

The @Toggle annotation is used to control the behavior of the method based on the activation or deactivation of a feature flag. The feature flag allows changing the functionality of the system without needing to change the code.

**name = "featureFlagExample"**: This is the name of the feature flag being used. The value featureFlagExample refers to a flag that is configured in Unleash. If this flag is active, the getProducts() method will execute different logic, in this case, the implementation of ProductServiceWithDiscountImpl.
**alterBean = "productServiceWithDiscountImpl"**: Here, it specifies that when the feature flag (featureFlagExample) is active, the implementation to be used for the product service is ProductServiceWithDiscountImpl. This means that, instead of using the default implementation (ProductServiceImpl), the system will use a version that likely includes logic for applying discounts to the products.

Implement differents solutions

We implement the ProductService interface in two classes, these are: ProductServiceImpl and ProductServiceWithDiscountImpl.

// ProductServiceImpl.java
@Service("productServiceImpl")
@RequiredArgsConstructor
public class ProductServiceImpl implements ProductService {

  private final ProductRepository productRepository;

  @Override
  public List<Product> getProducts() {
    return productRepository.getProducts();
  }
}


// ProductServiceWithDiscountImpl.java
@Service("productServiceWithDiscountImpl")
@RequiredArgsConstructor
public class ProductServiceWithDiscountImpl implements ProductService {

  private final ProductRepository productRepository;

  @Override
  public List<Product> getProducts() {
    List<Product> productsWithDiscount = productRepository.getProducts().stream().map(Product::new)
        .toList();
    productsWithDiscount.forEach(product -> product.applyDiscount(Constant.DISCOUNT));
    return productsWithDiscount;
  }

}

ProductServiceImpl: In this class, the only thing we do is return the products as they are stored.
ProductServiceWithDiscountImpl: In this class, the products are retrieved, and after that, the discount for each product is calculated and added to the new price.

Controller to get Products

Finally, let’s check the ProductController controller that has the endpoint to get all the products. The code is as follows:

@RestController
@RequestMapping("/products")
public class ProductController {
  private final ProductService productService;

  public ProductController(@Qualifier("productServiceImpl") ProductService productService) {
    this.productService = productService;
  }

  @GetMapping()
  public ResponseEntity<List<Product>> getProducts(){
    return ResponseEntity.ok().body(productService.getProducts());
  }
}

As we can see, the @Qualifier annotation is present in the constructor of our ProductController.
The @Qualifier annotation is used to specify which bean implementation should be injected into the ProductController constructor when there are multiple possible implementations of the ProductService interface. In this case, we have two implementations, so we want to use ProductServiceImpl by default.

With everything reviewed so far, we just need to run our code, and we should be able to execute it via http://localhost:8080.

Testing

With this, we are going to perform the tests to validate that our service is working with our Flag feature implementation. The products that are tested with are those created in the class bean **SpringUnleashFeatureFlagConfiguration**.

Testing with flag enabled

In this case we go to our unleash server and activate our flag (by default it is already activated). To activate our feature flag, we only activate the development option which is the environment where the flag must be activated.

Once our feature-flag has been activated, we proceed to run a test in postman to validate the operation:

As we can see, the price parameter is shown with the discount already applied, making the first test case correct. Now, let’s test with the inactive flag

Testing with flag disabled

To deactivate the flag, as we did in the previous test, we just deactivate the development option of our flag in our unleash server.

Once our feature-flag has been deactivate, we proceed to run a test in postman to validate the operation:

As we can see, the prices in the price parameter are the original prices without applying the discount.

With that, we can say that our feature-flag implementation is working correctly!!! 🚀

Conclusion

Feature flags are an invaluable tool for controlling the deployment of new features in a flexible and dynamic manner. They allow teams to enable or disable specific functionality without the need for code redeployments, offering improved control over the application’s behavior.

In this case, we demonstrated how to implement feature flags with Spring Boot and Unleash. By integrating Unleash to manage feature flags, we can conditionally enable or disable certain features like applying discounts to products based on the status of a feature flag. This provides the ability to control the deployment of features progressively, perform A/B testing, and quickly rollback faulty features without affecting the entire application.

In the end, the successful implementation of the feature flag system ensures that we can safely deploy new features, test them with specific user groups, and roll back if needed, all while minimizing risk and disruption.

Happy coding!! ❤️

Design Patterns Serie — Structural Chapter: Proxy Pattern

bryam vega — Mon, 20 Jan 2025 19:51:17 +0000

Introduction

Design patterns are solutions to common problems encountered in software development. The objective of these design patterns could be equated with the phrase “not reinventing the wheel” because its purpose is that, to provide solutions to problems that usually appear very frequently.

However, design patterns are not an absolute solution, I could say that it is a guide on how to solve a problem equal or similar to the moment the pattern was created, from then on, it is up to the developer to adapt the pattern to the business needs.

Design patterns are now divided into three sections: Creative, Structural and Behavioral. Each of them with its defined characteristics and structure.

In this article, we are going to learn about one of the most popular software design patterns within the structural patterns section and that is the Proxy Pattern.

What is Proxy Pattern?

To understand what the proxy pattern is, it is first important to understand the problem behind this pattern.

Imagine that as developers, we are told that in order to consume some services to obtain some User data, we must first consume a service to obtain a JWT (Json Web Token).

Problem

Currently we do not know the use of the proxy pattern, so we imagine that every time we need to consume the service to get the user’s data we will have to call the service to get the JWT that returns a JWT with a expiration time. With this we are doing the following scenario.

Our QA tells us that the service to get the customer data is taking longer than usual. So, we analyze our service and we see that the service that calls the user data is working correctly, however, the service that provides the JWT is taking too long because we are requesting a token every time we call the service. So the concept of token expiration is not working.

Therefore, they are asking you to fix this problem and you don’t know what to do.

Solution

Luckily, you found this article that talks about how to fix this problem using the proxy pattern

Reviewing in more detail, the proxy pattern consists of creating a control layer called Proxy whose main function is to act as an intermediary between the client and the real object to be accessed, managing or regulating this access in various ways.

This pattern is commonly used to control the creation of resource-intensive objects, protect them from unauthorized access, or add additional functionality during interaction with the actual objects.

With this idea, the initial problem using a proxy pattern looks as follows:

Now that we see it through a higher level diagram, we see how this proxy pattern works through a class diagram to see how to implement it.

As we can see in the class diagram, the proxy pattern is composed of the following classes:

Subject (JWTService): This is the common interface that both the proxy and the real subject will implement. It defines the operations that the client can perform. In this case we can see that request JWT will be the common method that both classes will implement.
Real Subject (JWTServiceImpl): This is the class that implements the JWTService interface and provides the real functionality of the service. This object performs the real operations related to JWT tokens, such as generating a token.
Proxy (JWTServiceProxy): This is the object that controls access to the real object (JWTServiceImpl). The proxy can perform additional tasks such as security handling, logging, or cache handling before or after invoking calls to the real object. In this case it handles the lifecycle of the JWT class that returns the JWTServiceImpl . If we notice JWT class contains a method called validateJWT that allows to validate that our JWT is still functional and not to call it every time.

I know that the class diagram may seem a bit weird and confusing to understand, but believe me, when we put this into code, everything will be more understandable!

Implement Proxy Pattern for JWT generation

The code of this implementation is hosted in this repository in case you want to clone it and try it yourself: Proxy Pattern Repo

Based on our created class diagram, we are going to implement it in code and this way you will see that you will understand the proxy pattern in a faster way.

The JWT object

A JWT class that contains the data necessary for a Json Web Token to work. It is presented as follows.

public record JWT(String token, long expirationTime, long creationTime) {
    public boolean validateJWT(){
        long currentTimeInSeconds = System.currentTimeMillis() / 1000;
        return currentTimeInSeconds < this.creationTime() + this.expirationTime();
    }
}

Since Java 16, the records known as records are born, which allow the attributes that contain a class to be immutable by default, keeping the same characteristics of a normal class, such as creating methods such as validateJWT(). This method will be important because it will be used by our proxy method to validate the token lifecycle.

The subject

The subject is represented by the JWTService interface. This interface defines a single requestJWT() method that, when implemented, should be responsible for requesting and returning a JWT (JSON Web Token) object.

public interface JWTService {

    JWT requestJWT();
}

This interface will be implemented by the Real Subject and the proxy, since both require the common operation requestJWT().

The Real Subject

The JWTServiceImpl class serves as the RealSubject within the Proxy pattern, where its primary responsibility is the generation of JSON Web Tokens (JWT).

public class JWTServiceImpl implements JWTService {
    @Override
    public JWT requestJWT() {
        return new JWT(generateToken(), 5,
                System.currentTimeMillis() / 1000);
    }

    private String generateToken(){
        String header = UUID.randomUUID().toString();

        String payload = UUID.randomUUID().toString();

        String signature = UUID.randomUUID().toString();

        return header + "." + payload +
                "." + signature;
    }
}

For this case, we simulate the creation of a JWT using the generateToken() method, by generating UUID for the header, payload and signature, just as an example, in real life, this must be obtained through a security service or a platform such as keycloak or auth0.

Additionally let’s take into account that our JWT will have a lifetime of 5 seconds and its creation time will be the current time in which we execute the service in seconds, as you can see in the requestJWT() method.

Finally we can notice that our RealSubject is only in charge of generating the JWT, it does absolutely nothing else, so at the beginning,** we did not realize that we had to validate the lifetime of the jwt*, so our **proxy pattern* will come in to solve our life.

The proxy

The proxy, in this case JWTServiceProxy, serves as an intermediary between the client and the actual service (JWTServiceImpl). Its role is to manage the JWT token request flow, implementing a caching strategy that improves operational efficiency and reduces the load on system resources.

Initialization: The proxy class initializes its concrete dependency on JWTServiceImpl within its constructor (composition). This ensures all token requests are routed through the proxy before reaching the actual service.
Token Caching: It maintains a cached instance of the JWT. Before processing a new request, it checks whether it already possesses a valid token. If the stored token is invalid or has expired, it proceeds to request a new token from the real service, JWTServiceImpl.

public class JWTServiceProxy implements JWTService {

    private final JWTService jwtService;
    private JWT jwt;

    public JWTServiceProxy() {
        this.jwtService = new JWTServiceImpl();
    }

    @Override
    public JWT requestJWT() {
        if (jwt == null || !jwt.validateJWT()) {
            jwt = jwtService.requestJWT();
        }
        return jwt;
    }
}

The requestJWT() method encapsulates the logic for validating and issuing tokens:

Token Validation: Checks if the current cached token is valid using jwt.validateJWT(). This step is crucial to ensure that the tokens are not only present but also secure and reliable.
Conditional Token Generation: If the token is null or invalid, the proxy requests a new token, which is done by calling the real service. This mechanism ensures that the system does not generate tokens unnecessarily, optimizing resource usage.

Test Proxy Pattern

Finally, since we have implemented our proxy pattern, the last thing we have left is to validate to see if this pattern really works. For it we instantiate the Subject initializing it with the proxy and not with the RealSubject.

public class Main {

    private static final Logger log = Logger.getLogger(Main.class.getName());

    public static void main(String[] args) throws InterruptedException {
        JWTService proxy = new JWTServiceProxy();

        JWT jwt = proxy.requestJWT();
        log.info("TOKEN: " + jwt.token());

        jwt = proxy.requestJWT();
        log.info("TOKEN TWO: " + jwt.token());

        Thread.sleep(5000);

        jwt = proxy.requestJWT();
        log.info("TOKEN THREE: " + jwt.token());

    }
}

If we notice, we can notice that we make 3 requests to get the JWT, however, before the last request we use Thread.sleep(5000) which guarantees that we are going to wait for the thread to sleep for about 5 seconds, which is the time configured in our JWT mock to expire.

Nov 27, 2024 9:16:21 PM org.bvega.Main main
INFO: TOKEN: 9b348add-fcca-4187-b7cd-f36e07e97e97.63a81aa0-6c75-4b7e-8178-6488c61a5181.5ae3bea6-9ba9-4727-b183-875baf8de9a8
Nov 27, 2024 9:16:21 PM org.bvega.Main main
INFO: TOKEN TWO: 9b348add-fcca-4187-b7cd-f36e07e97e97.63a81aa0-6c75-4b7e-8178-6488c61a5181.5ae3bea6-9ba9-4727-b183-875baf8de9a8
Nov 27, 2024 9:16:26 PM org.bvega.Main main
INFO: TOKEN THREE: f06eea26-15c7-408b-9a73-1804121cca1f.2f3360be-5cb5-4ac1-be32-d3af242cd998.19e68e66-6f03-493e-8b42-8542347cace7

And what a surprise!!! 😮, as you can see, the first 2 tokens are the same, but the third one is a new one since the life time of the initial token expired, this validates that our proxy pattern worked correctly, congratulations !!!! 😄

Conclusion

The Proxy pattern is a powerful tool in the software developer’s arsenal, offering significant advantages in terms of performance enhancement and security. However, its implementation should be approached with a clear understanding of the system’s architectural needs and operational challenges. Properly utilized, the Proxy pattern can lead to more maintainable, secure, and efficient software systems, making it a worthwhile consideration for projects requiring controlled access and optimized resource management.

Happy coding!! ❤️