DEV Community: Hùng Trần

Rest API: How to Prevent Duplicate Requests Effectively

Hùng Trần — Tue, 01 Oct 2024 14:49:13 +0000

The solution to prevent duplicate requests that I want to talk about here is that when a user manipulates an API feed or any data source, in reality, they only manipulate once, but for any reason, such as intentionally by the user or maybe by a hacker, to cause system data errors.

To prevent this from happening, we need to build a deduplication solution. In the scope of this article, I will implement deduplication based on Redis and Spring Boot 3.

The idea of doing it in sequence would be like this:

Get some data fields in the Request Body that the user sends, the purpose is to create a Redis key. Which field to use depends on the business needs, as well as the system architecture that is responding to consider the choice.
Build the key in some optional format, then hash it again with MD5 (using MD5 here is optional, depending on your needs). If you use it, consider using Fast MD5 for faster speed.
Every time the user calls the API, the Redis key will be checked. If it exists, a duplicate data error will be returned. If not, the logic will continue to be processed.
When inserting a key into Redis, an Expired Time must be configured. In the framework of the article, I set it to about 40 seconds for an easy demo.

That’s the idea, but the actual implementation will require a few more techniques, which I will mention later. Let’s build the project and test it first.

Project structure

In this project, I using Spring Boot 3.3.4, Java 17, Spring AOP

Here is the detailed code implementation of each part

package com.cafeincode.demo.aop;
import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface PreventDuplicateValidator {

    String[] includeFieldKeys() default {};

    String[] optionalValues() default {};

    long expireTime() default 10_000L;

}

PreventDuplicateValidator I declare it as an annotation, here there are three data fields:

includeFieldKeys: to declare the list of fields that are needed to generate the key based on the fields in the Request Body.

optionalValues: a list of values that need to be attached to the key. I implemented this field for the purpose of flexibility in preventing duplication. You can add any data as you like.

expireTime: is the key expiration time value, the default is 10 seconds.

package com.cafeincode.demo.aop;
import com.cafeincode.demo.enums.ErrorCode;
import com.cafeincode.demo.exception.DuplicationException;
import com.cafeincode.demo.exception.HandleGlobalException;
import com.cafeincode.demo.utils.Utils;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.Arrays;
import java.util.Collections;
import java.util.Map;
import java.util.Objects;
import java.util.stream.Collectors;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.data.redis.connection.RedisStringCommands;
import org.springframework.data.redis.core.RedisCallback;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.types.Expiration;
import org.springframework.stereotype.Component;

/**
 * author: hungtv27
 * email: hungtvk12@gmail.com
 * blog: cafeincode.com
 */

@Aspect
@Component
@RequiredArgsConstructor
@Slf4jj
public class PreventDuplicateValidatorAspect {

    private final RedisTemplate redisTemplate;
    private final ObjectMapper objectMapper;

    @Around(value = "@annotation(preventDuplicateValidator)", argNames = "pjp, preventDuplicateValidator")
    public Object aroundAdvice(ProceedingJoinPoint pjp, PreventDuplicateValidator preventDuplicateValidator)
        throws Throwable {

        var includeKeys = preventDuplicateValidator.includeFieldKeys();
        var optionalValues = preventDuplicateValidator.optionalValues();
        var expiredTime = preventDuplicateValidator.expireTime();

        if (includeKeys == null || includeKeys.length == 0) {
            log.warn("[PreventDuplicateRequestAspect] ignore because includeKeys not found in annotation");
            return pjp.proceed();
        }

        //extract request body in request body
        var requestBody = Utils.extractRequestBody(pjp);
        if (requestBody == null) {
            log.warn(
                "[PreventDuplicateRequestAspect] ignore because request body object find not found in method arguments");
            return pjp.proceed();
        }

        //parse request body to map<String, Object>
        var requestBodyMap = convertJsonToMap(requestBody);

        //build key redis from: includeKeys, optionalValues, requestBodyMap
        var keyRedis = buildKeyRedisByIncludeKeys(includeKeys, optionalValues, requestBodyMap);

        //hash keyRedis to keyRedisMD5: this is Optional, should be using Fast MD5 hash to replace
        var keyRedisMD5 = Utils.hashMD5(keyRedis);

        log.info(String.format("[PreventDuplicateRequestAspect] rawKey: [%s] and generated keyRedisMD5: [%s]", keyRedis,
            keyRedisMD5));

        //handle logic check duplicate request by key in Redis
        deduplicateRequestByRedisKey(keyRedisMD5, expiredTime);

        return pjp.proceed();
    }

    private String buildKeyRedisByIncludeKeys(String[] includeKeys, String[] optionalValues, Map<String, Object> requestBodyMap) {

        var keyWithIncludeKey = Arrays.stream(includeKeys)
            .map(requestBodyMap::get)
            .filter(Objects::nonNull)
            .map(Object::toString)
            .collect(Collectors.joining(":"));

        if (optionalValues.length > 0) {
            return keyWithIncludeKey + ":" + String.join(":", optionalValues);
        }
        return keyWithIncludeKey;
    }

    public void deduplicateRequestByRedisKey(String key, long expiredTime) {
        var firstSet = (Boolean) redisTemplate.execute((RedisCallback<Boolean>) connection ->
            connection.set(key.getBytes(), key.getBytes(), Expiration.milliseconds(expiredTime),
                RedisStringCommands.SetOption.SET_IF_ABSENT));

        if (firstSet != null && firstSet) {
            log.info(String.format("[PreventDuplicateRequestAspect] key: %s has set successfully !!!", key));
            return;
        }
        log.warn(String.format("[PreventDuplicateRequestAspect] key: %s has already existed !!!", key));
        throw new DuplicationException(ErrorCode.ERROR_DUPLICATE.getCode(), ErrorCode.ERROR_DUPLICATE.getMessage());
    }

    public Map<String, Object> convertJsonToMap(Object jsonObject) {
        if (jsonObject == null) {
            return Collections.emptyMap();
        }
        try {
            return objectMapper.convertValue(jsonObject, new TypeReference<>() {
            });
        } catch (Exception ignored) {
            return Collections.emptyMap();
        }
    }

}

Here PreventDuplicateValidatorAspect is advice, implementing logic for annotation PreventDuplicateValidator, I use Around Advice for flexibility

The logic implementation in the above code is described in the order of steps below:

First, we will need to extract the request body from the API.
Parse request body into Map format.
Build raw keys from defined data fields.
Build MD5 key
Check duplicate requests by key
If the key already exists in Redis, then throw an exception.
If the key does not exist in Redis, insert the key into Redis, add the expired time parameter, and then continue the logic of the main function through pjp.proceed()

package com.cafeincode.demo.config;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.RedisStandaloneConfiguration;
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;

@Configuration
public class BeanConfig {

    @Value("${redis.host}")
    private String redisHost;

    @Value("${redis.port}")
    private int redisPort;

    @Bean(name = "objectMapper")
    @Primary
    public ObjectMapper objectMapper() {
        ObjectMapper mapper = new ObjectMapper();
        mapper.registerModule(new JavaTimeModule());
        return mapper;
    }

    @Bean
    public RedisConnectionFactory redisConnectionFactory() {
        var config = new RedisStandaloneConfiguration(redisHost, redisPort);
        return new LettuceConnectionFactory(config);
    }

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

}

BeanConfigI added bean configuration for ObjectMapper and Redis connection bean

package com.cafeincode.demo.dto;
import java.io.Serializable;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.SuperBuilder;

@Data
@AllArgsConstructor
@NoArgsConstructor
@SuperBuilder
public class BaseResponse<T> implements Serializable {

    public static final String OK_CODE = "200";
    public static final String OK_MESSAGE = "Successfully";
    private String code;
    private String message;
    private T data;

    public static <T> BaseResponse<T> ofSucceeded(T data) {
        BaseResponse<T> response = new BaseResponse<>();
        response.code = OK_CODE;
        response.message = OK_MESSAGE;
        response.data = data;
        return response;
    }
}

BaseResponse is the response class that returns results via API. Large companies as well as standard systems define fields: code , message , and data in this class (maybe with different names, but not very important).

We can add other fields depending on usage needs, such as metadata , request_id , etc.

package com.cafeincode.demo.dto;
import java.time.Instant;
import lombok.Data;

@Data
public class ProductDto {

    private String productId;
    private String productName;
    private String productDescription;
    private String transactionId;
    private Instant requestTime;
    private String requestId;

}

package com.cafeincode.demo.enums;
import lombok.AllArgsConstructor;
import lombok.Getter;

@AllArgsConstructor
@Getter
public enum ErrorCode {

    ERROR_DUPLICATE("CF_275", "Duplicated data, please try again later");

    private final String code;
    private final String message;
}

package com.cafeincode.demo.exception;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Getter;
import lombok.Setter;
import org.springframework.http.HttpStatus;

@Getter
@Setter
@AllArgsConstructor
@Builder
public class DuplicationException extends RuntimeException {

    private String code;
    private String message;
    private HttpStatus httpStatus;

    public DuplicationException(String code, String message) {
        this.code = code;
        this.message = message;
        httpStatus = HttpStatus.BAD_REQUEST;
    }

}

package com.cafeincode.demo.exception;
import java.util.HashMap;
import java.util.Map;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.servlet.mvc.method.annotation.ResponseEntityExceptionHandler;

@ControllerAdvice
public class HandleGlobalException extends ResponseEntityExceptionHandler {

    @ExceptionHandler(DuplicationException.class)
    private ResponseEntity<?> handleError(Exception ex) {

        //TODO: you should custom more here

        Map<String, String> body = new HashMap<>();
        body.put("code", ((DuplicationException) ex).getCode());
        body.put("message", ex.getMessage());
        return new ResponseEntity<>(body, HttpStatus.BAD_REQUEST);
    }
}

In this class HandleGlobalException, I will handle DuplicationException, the firing in the processing logic from PreventDuplicateValidatorAspect.

package com.cafeincode.demo.service;
import com.cafeincode.demo.dto.ProductDto;

public interface IProductService {

    ProductDto createProduct(ProductDto dto);

}

package com.cafeincode.demo.service;
import com.cafeincode.demo.dto.ProductDto;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;

@Component
@Slf4j
@RequiredArgsConstructor
public class ProductService implements IProductService {

    @Override
    public ProductDto createProduct(ProductDto dto) {
        //TODO: more logic here
        return null;
    }

}

You can add more logic if needed; I just need to return null to serve the demo purpose.

package com.cafeincode.demo.utils;
import jakarta.xml.bind.DatatypeConverter;
import java.lang.annotation.Annotation;
import java.lang.reflect.Method;
import java.security.MessageDigest;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.web.bind.annotation.RequestBody;

@Slf4j
public class Utils {

    private Utils() {
    }

    public static Object extractRequestBody(ProceedingJoinPoint pjp) {
        try {
            for (int i = 0; i < pjp.getArgs().length; i++) {
                Object arg = pjp.getArgs()[i];
                if (arg != null && isAnnotatedWithRequestBody(pjp, i)) {
                    return arg;
                }
            }
        } catch (Exception ex) {
            log.error("", ex);
        }
        return null;
    }

    private static boolean isAnnotatedWithRequestBody(ProceedingJoinPoint pjp, int paramIndex) {
        var method = getMethod(pjp);
        var parameterAnnotations = method.getParameterAnnotations();
        for (Annotation annotation : parameterAnnotations[paramIndex]) {
            if (RequestBody.class.isAssignableFrom(annotation.annotationType())) {
                return true;
            }
        }
        return false;
    }

    private static Method getMethod(ProceedingJoinPoint pjp) {
        MethodSignature methodSignature = (MethodSignature) pjp.getSignature();
        return methodSignature.getMethod();
    }

    public static String hashMD5(String source) {
        String res = null;
        try {
            var messageDigest = MessageDigest.getInstance("MD5");
            var mdBytes = messageDigest.digest(source.getBytes());
            res = DatatypeConverter.printHexBinary(mdBytes);
        } catch (Exception e) {
            log.error("", e);
        }
        return res;
    }
}

The class Utils includes logic functions to extract the request body from ProceedingJoinPoint and the MD5 hash function

redis:
  host: localhost
  port: 6379
spring:
  application:
    name: product-service
server:
  port: 8888

configure application-local.yml

version: "3.2"
services:
  redis:
    container_name: demo-service-redis
    image: redis:6.2.5
    ports:
      - '6379:6379'

package com.cafeincode.demo.controller;
import com.cafeincode.demo.aop.PreventDuplicateValidator;
import com.cafeincode.demo.dto.BaseResponse;
import com.cafeincode.demo.dto.ProductDto;
import com.cafeincode.demo.service.ProductService;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@Slf4j
@RequestMapping("/products")
@RequiredArgsConstructor
public class ProductController {

    private final ProductService productService;

    @PostMapping
    @PreventDuplicateValidator(
        includeFieldKeys = {"productId", "transactionId"},
        optionalValues = {"CAFEINCODE"},
        expireTime = 40_000L)
    public BaseResponse<?> createProduct(@RequestBody ProductDto request) {
        return BaseResponse.ofSucceeded(productService.createProduct(request));
    }

}

In this main controller section, I declare to use annotation with the parameter values above: PreventDuplicateValidator

includeFieldKeys : markup will take two fields productIdand transactionId in the request body as input to generate key
optionalValues : option value, I declare here CAFEINCODE
expireTime : data lifetime in Redis cache, I set it to 40 seconds.

Okay, now let’s run the project and test it:

For MacOS and Windows, you need to turn on Docker Desktop first, then run the command docker-compose up -din Terminal.

For Ubuntu machines, you need to install Docker first, then run the above command.

I use a Macbook, and it’s already turned on, so I just need to turn it on to use

redis docker

check connection Redis

Check if the connection to Redis is ok, launch the application

config profile local, jdk

start application spring boot

You open Postman to test, I leave the request body below for you to easily copy and practice.

{
    "productId": "hungtv27-test-001",
    "productName": "CAFEINCODE",
    "productDescription": "Threat identify buy war manage little friend south really chair",
    "transactionId": "cd076846-ff28-4307-8524-3eb6e1809838",
    "requestTime": 1696069378367,
    "requestId": "{{$randomUUID}}"
}

Click Sendand follow the results

response when first call

validate success, init key to redis

Check the console log and see the message with the MD5 key: 6C518A2B1666005572EDFC8240A130F2does not exist in Redis, so it will be initialized successfully for the first time and set the expiration time to 40 seconds. Now I will check the data in Redis.

MD5 key in Redis

The key 6C518A2B1666005572EDFC8240A130F2has been successfully initialized in Redis. Now we will continue to call the API one more time to check the result. The expectation is to return an errorCF_275

response when call second

View the console log to see if the key 6C518A2B1666005572EDFC8240A130F2 already exists in Redis, so it will return error CF_275 to the client.

So we have completed the implementation of duplicate prevention based on Redis and Spring AOP. In this article, there are some conclusions that you need to consider as follows:

Select appropriate parameter fields in the Request Body to be used as an input source to create a key; you should ignore time-type fields such as createTime or updateTime.
Set the expiration time value to suit the project's business needs.
Consider whether to hash MD5 or not. If you want to optimize performance, you can remove or choose to use Fast MD5 (I do not use it in this article).

Finally, after implementing the complete logic, all we need to do is declare annotation on the controllers that we need to use. Setting the data fields is very flexible, so we rarely need to modify anything further.

Thanks, before you go:

👏 If you have any better solutions, please comment below, we will discuss and learn from each other.

👏 Please clap for the story and follow the author, 👉👉👉 hungtv27

👏 Please share your questions or insights in the comments section below.

Originally published at https://cafeincode.com on October 1, 2024.

Stop using if-else statements in Java

Hùng Trần — Tue, 20 Aug 2024 08:59:28 +0000

The tale goes that there is an ancient legacy system, my colleague coded thousands of lines from top to bottom, and each block added several if then java sections to route circumstances, so I feel like I’m trapped in an unfamiliar fairyland.

In this post, I will show you how to optimize the use of if-else, restrict code with too many branching conditions, and make your Java code much easier to read and understand.

Code snippets with too many if-else statements

Before delving into the details of optimization, let’s use a sample demo Java code with multiple if else conditions, and then optimize it in various ways:

public class ShippingCostCalculator {
    public double calculateShippingCost(String shippingType, double weight) {
        if (shippingType.equals("STANDARD")) {
            return weight * 5.0;
        } else if (shippingType.equals("EXPRESS")) {
            return weight * 10.0;
        } else if (shippingType.equals("SAME_DAY")) {
            return weight * 20.0;
        } else if (shippingType.equals("INTERNATIONAL")) {
            return weight * 50.0;
        } else if (shippingType.equals("OVERNIGHT")) {
            return weight * 30.0;
        }
        return 0;
    }
}

As you can see, the code above calculates shipping charges based on the shipping type

Optimize using Enum

Now, we will use Enumto replace the statements if-else

public enum ShippingType {
    STANDARD {
        @Override
        public double getCost(double weight) {
            return weight * 5.0;
        }
    },
    EXPRESS {
        @Override
        public double getCost(double weight) {
            return weight * 10.0;
        }
    },
    SAME_DAY {
        @Override
        public double getCost(double weight) {
            return weight * 20.0;
        }
    },
    INTERNATIONAL {
        @Override
        public double getCost(double weight) {
            return weight * 50.0;
        }
    },
    OVERNIGHT {
        @Override
        public double getCost(double weight) {
            return weight * 30.0;
        }
    };

    public abstract double getCost(double weight);
}

public class ShippingCostCalculator {

    public double calculateShippingCost(ShippingType shippingType, double weight) {
        return shippingType.getCost(weight);
    }
}

public class MainCost {
    public static void main(String[] args) {
        var calculator = new ShippingCostCalculator();
        var cost = calculator.calculateShippingCost(ShippingType.EXPRESS, 2.5);
        System.out.println("Shipping cost: " + cost);
    }
}

As you can see, the difficult if-else statement has been simplified into two short, straightforward lines of code. Run the main function to see the results.

Advantage :

Extensibility: Add new shipping types and values. Enumerate and define a handling method for it.
Maintainable and understandable code: The reasoning for each method of transport is isolated and easy to comprehend.

However , utilizing Enum has certain clear downsides that you should consider:

Extensibility : Add new shipping types and values. Enumerate and define a handling method for it.
Difficult to add new parameters : When more parameters are needed, Enum is not well-suited, and the code becomes cumbersome.
Inheritance restrictions : Enum cannot inherit from other classes, which reduces their potential to reuse logic.

Using Enum for optimization is generally suitable in simple case conditions with few parameters.

Optimization with Factory Pattern

Still the messy code above, we will optimize it in the following way:

Create an Interface ShippingCostStrategy

public interface ShippingCostStrategy {
    double calculate(double weight);
}

Next, we will create specific classes for each type of delivery, implementing the interface above.

public class StandardShipping implements ShippingCostStrategy {
    @Override
    public double calculate(double weight) {
        return weight * 5.0;
    }
}

public class ExpressShipping implements ShippingCostStrategy {
    @Override
    public double calculate(double weight) {
        return weight * 10.0;
    }
}

public class SameDayShipping implements ShippingCostStrategy {
    @Override
    public double calculate(double weight) {
        return weight * 20.0;
    }
}

public class InternationalShipping implements ShippingCostStrategy {
    @Override
    public double calculate(double weight) {
        return weight * 50.0;
    }
}

public class OvernightShipping implements ShippingCostStrategy {
    @Override
    public double calculate(double weight) {
        return weight * 30.0;
    }
}

Now, we will create a Factory class to handle routing to Strategies based on shipping type

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

public class ShippingCostFactory {
    private static final Map<String, ShippingCostStrategy> strategies = new HashMap<>();

    static {
        strategies.put("STANDARD", new StandardShipping());
        strategies.put("EXPRESS", new ExpressShipping());
        strategies.put("SAME_DAY", new SameDayShipping());
        strategies.put("INTERNATIONAL", new InternationalShipping());
        strategies.put("OVERNIGHT", new OvernightShipping());
    }

    public static ShippingCostStrategy getStrategy(String shippingType) {
        ShippingCostStrategy strategy = strategies.get(shippingType);
        if (strategy == null) {
            throw new IllegalArgumentException("Invalid shipping type: " + shippingType);
        }
        return strategy;
    }
}

Now just call it and use it

public class ShippingCostCalculator {
    public double calculateShippingCost(String shippingType, double weight) {
        ShippingCostStrategy strategy = ShippingCostFactory.getStrategy(shippingType);
        return strategy.calculate(weight);
    }
}

Beat 90% of Candidates: Software Engineer's Fast-Track Coding Interview Guide

Advantages of Factory Pattern:

Easy extensibility : Add new delivery kinds by simply developing additional classes and updating the Factory without changing the core code. Logical separation : Charging logic is segregated, and simple to manage and maintain. Flexibility : The factory might return multiple solutions depending on other factors, increasing flexibility.

Optimization using Strategy Pattern

Before we get into detail, please keep in mind that the implementation will be similar to Factory, but the purpose of use will be slightly different

public interface ShippingCostStrategy {
    double calculate(double weight);
}

public class StandardShipping implements ShippingCostStrategy {
    @Override
    public double calculate(double weight) {
        return weight * 5.0;
    }
}

public class ExpressShipping implements ShippingCostStrategy {
    @Override
    public double calculate(double weight) {
        return weight * 10.0;
    }
}

public class SameDayShipping implements ShippingCostStrategy {
    @Override
    public double calculate(double weight) {
        return weight * 20.0;
    }
}

public class InternationalShipping implements ShippingCostStrategy {
    @Override
    public double calculate(double weight) {
        return weight * 50.0;
    }
}

public class OvernightShipping implements ShippingCostStrategy {
    @Override
    public double calculate(double weight) {
        return weight * 30.0;
    }
}

Now we will create ShippingContext to manage strategies

public class ShippingCostContext {
    private ShippingCostStrategy strategy;

    public void setStrategy(ShippingCostStrategy strategy) {
        this.strategy = strategy;
    }

    public double calculateShippingCost(double weight) {
        return strategy.calculate(weight);
    }
}

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

public class ShippingCostCalculator {

    private static final Map<String, ShippingCostStrategy> strategies = new HashMap<>();

    static {
        strategies.put("STANDARD", new StandardShipping());
        strategies.put("EXPRESS", new ExpressShipping());
        strategies.put("SAME_DAY", new SameDayShipping());
        strategies.put("INTERNATIONAL", new InternationalShipping());
        strategies.put("OVERNIGHT", new OvernightShipping());
    }

    private final ShippingCostContext context = new ShippingCostContext();

    public double calculateShippingCost(String shippingType, double weight) {
        ShippingCostStrategy strategy = strategies.get(shippingType);
        if (strategy == null) {
            throw new IllegalArgumentException("Invalid shipping type: " + shippingType);
        }
        context.setStrategy(strategy);
        return context.calculateShippingCost(weight);
    }
}

Now, add it inside the Main Class to use.

public class MainCost {

    public static void main(String[] args) 
        ShippingCostCalculator calculator = new ShippingCostCalculator();

        double weight = 10.0;

        String shippingType1 = "STANDARD";
        double cost1 = calculator.calculateShippingCost(shippingType1, weight);
        System.out.println("Shipping cost for " + shippingType1 + ": " + cost1);

        String shippingType2 = "EXPRESS";
        double cost2 = calculator.calculateShippingCost(shippingType2, weight);
        System.out.println("Shipping cost for " + shippingType2 + ": " + cost2);

        String shippingType3 = "SAME_DAY";
        double cost3 = calculator.calculateShippingCost(shippingType3, weight);
        System.out.println("Shipping cost for " + shippingType3 + ": " + cost3);

        String shippingType4 = "INTERNATIONAL";
        double cost4 = calculator.calculateShippingCost(shippingType4, weight);
        System.out.println("Shipping cost for " + shippingType4 + ": " + cost4);

        String shippingType5 = "OVERNIGHT";
        double cost5 = calculator.calculateShippingCost(shippingType5, weight);
        System.out.println("Shipping cost for " + shippingType5 + ": " + cost5);
    }

}

In the previous two cases, the Strategy Pattern manages how shipping costs are computed, and the Factory Pattern decides which strategy to utilize based on the delivery type.

Optimize using Stream API and Map

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

public class ShippingCostCalculator {

    private static final Map<String, Double> shippingCosts = new HashMap<>();

    static {
        shippingCosts.put("STANDARD", 5.0);
        shippingCosts.put("EXPRESS", 10.0);
        shippingCosts.put("SAME_DAY", 20.0);
        shippingCosts.put("INTERNATIONAL", 50.0);
        shippingCosts.put("OVERNIGHT", 30.0);
    }

    public double calculateShippingCost(String shippingType, double weight) {
        return shippingCosts.entrySet().stream()
            .filter(entry -> entry.getKey().equalsIgnoreCase(shippingType))
            .map(Map.Entry::getValue)
            .findFirst()
            .orElse(0.0)
            * weight; 
    }

    public static void main(String[] args) {
        ShippingCostCalculator calculator = new ShippingCostCalculator();

        double weight = 10.0;

        String shippingType1 = "STANDARD";
        double cost1 = calculator.calculateShippingCost(shippingType1, weight);
        System.out.println("Shipping cost for " + shippingType1 + ": " + cost1);

        String shippingType2 = "EXPRESS";
        double cost2 = calculator.calculateShippingCost(shippingType2, weight);
        System.out.println("Shipping cost for " + shippingType2 + ": " + cost2);

        String shippingType3 = "SAME_DAY";
        double cost3 = calculator.calculateShippingCost(shippingType3, weight);
        System.out.println("Shipping cost for " + shippingType3 + ": " + cost3);

        String shippingType4 = "INTERNATIONAL";
        double cost4 = calculator.calculateShippingCost(shippingType4, weight);
        System.out.println("Shipping cost for " + shippingType4 + ": " + cost4);

        String shippingType5 = "OVERNIGHT";
        double cost5 = calculator.calculateShippingCost(shippingType5, weight);
        System.out.println("Shipping cost for " + shippingType5 + ": " + cost5);

        String invalidType = "INVALID";
        double invalidCost = calculator.calculateShippingCost(invalidType, weight);
        System.out.println("Shipping cost for " + invalidType + ": " + invalidCost);
    }
}

This strategy is also quite convenient; while the expansion is not as good as Factory and Strategy, it is still a viable option for simple scenarios.

Thanks, before you go:

👏 Please clap for the story and follow the author 👉

Please share your questions or insights in the comments section below.

Originally published at https://cafeincode.com on August 20, 2024.

Best practices for using Java Stream

Hùng Trần — Wed, 17 Apr 2024 15:58:56 +0000

When working with Java, understanding and knowing how to use streams to optimize work performance is necessary. Today I will show you how to use some of the functions that Java streams provide, helping Your code become more visible and elegant.

First, let’s go through the popular functions that Java Stream provides.

filter removes elements that do not satisfy the predicate filter condition, or in other words, retains elements that satisfy the filter condition

import java.util.Arrays;
import java.util.stream.Collectors;

public class CafeincodeExample {

    public static void main(String[] args) {
        var domains = Arrays.asList("cafeincode", "medium", "google");
        var filtered = domains.stream()
                .filter(item -> item.startsWith("c"))
                .peek(item -> System.out.println("Result: " + item))
                .collect(Collectors.toList());
    }
}

Result: cafeincode

map is responsible for mapping each element in the stream to another data type through the function you specify and creating a new stream, like in the example below, I use the available toUpperCase function

import java.util.Arrays;
import java.util.stream.Collectors;

public class CafeincodeExample {

    public static void main(String[] args) {
        var input = Arrays.asList("cafeincode", "medium", "google");
        var mapped = input.stream()
                .map(String::toUpperCase)
                .collect(Collectors.toList());
        System.out.println("Result: " + mapped);
    }
}

Result: [CAFEINCODE, MEDIUM, GOOGLE]

flatMap is used to process the elements of a stream and help transform them into a new stream or a list of elements, i.e. it will combine child streams into a parent stream.

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class CafeincodeExample {

    public static void main(String[] args) {
        var nestedNumbers = Arrays.asList(
                Arrays.asList(1, 2),
                Arrays.asList(3, 4),
                Arrays.asList(5, 6)
        );
        var flattenedNumbers = nestedNumbers.stream()
                .flatMap(List::stream)
                .collect(Collectors.toList());
        System.out.println("Result: " + flattenedNumbers);
    }
}

Result: [1, 2, 3, 4, 5, 6]

distinct is used to remove duplicate elements from a stream and it will return a new stream containing only unique elements

import java.util.Arrays;
import java.util.stream.Collectors;

public class CafeincodeExample {

    public static void main(String[] args) {
        var numbers = Arrays.asList(1, 2, 2, 3, 3, 4, 5, 5);
        var distinctNumbers = numbers.stream()
                .distinct()
                .collect(Collectors.toList());
        System.out.println("Result: " + distinctNumbers);
    }
}

Result: [1, 2, 3, 4, 5]

sorted is used to sort the elements of a stream in a certain order and will return a new stream containing the sorted elements

import java.util.Arrays;
import java.util.stream.Collectors;

public class CafeincodeExample {

    public static void main(String[] args) {
        var numbers = Arrays.asList(3, 1, 4, 1, 5, 9, 2, 6, 5);
        var sortedNumbers = numbers.stream()
                .sorted()
                .collect(Collectors.toList());
        System.out.println("Result: " + sortedNumbers);
    }
}

Result: [1, 1, 2, 3, 4, 5, 5, 6, 9]

peek is often used to perform debugging or logging operations on elements during stream processing without changing the content of the stream.

import java.util.stream.IntStream;

public class CafeincodeExample {

    public static void main(String[] args) {
        IntStream.range(1, 6)
                .peek(element -> System.out.println("Processing element: " + element))
                .map(CafeincodeExample::mapping)
                .forEach(System.out::println);
    }

    private static Integer mapping(Integer input) {
        return input * input;
    }
}

Processing element: 1
1
Processing element: 2
4
Processing element: 3
9
Processing element: 4
16
Processing element: 5
25

limit is used to limit the number of elements in a stream, it will return a new stream containing the number of elements limited to a certain value.

import java.util.stream.IntStream;

public class CafeincodeExample {

    public static void main(String[] args) {
        IntStream.range(1, 100)
                .limit(5)
                .forEach(System.out::println);
    }
}

1
2
3
4
5

skip is used to skip a certain number of elements in a stream and return a new stream starting from the position that was skipped

import java.util.stream.IntStream;

public class CafeincodeExample {

    public static void main(String[] args) {
        IntStream.range(1, 11)
                .skip(5)
                .forEach(System.out::println);
    }
}

6
7
8
9
10

In this example, IntStream.range(1, 11)create a Stream containing the numbers 1 to 10.

skip(5)used to skip the first 5 elements of the stream
forEach(System.out::println)used to print out the remaining elements of the stream, starting from the 6th element to the last element

toArray is used to convert a stream into an array, this method returns an array containing the elements of the stream in order.

import java.util.stream.IntStream;

public class CafeincodeExample {

    public static void main(String[] args) {
        int[] numbers = IntStream.range(1, 6)
                .toArray();

        for (int number : numbers) {
            System.out.println("Result: " + number);
        }
    }
}

Result: 1
Result: 2
Result: 3
Result: 4
Result: 5

reduce is used to perform a transformation on the elements of the stream to calculate a final value

import java.util.Arrays;

public class CafeincodeExample {

    public static void main(String[] args) {
        Integer[] integers = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
        var result = Arrays.stream(integers).reduce(0, Integer::sum);
        System.out.println("Result: " + result);
    }
}

Result: 55

collect is used to collect the elements of a stream into a specific data structure, such as a List, Set or Map

import java.util.stream.Collectors;
import java.util.stream.Stream;

public class CafeincodeExample {

    public static void main(String[] args) {
        Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5);
        var list = stream.collect(Collectors.toList());
        System.out.println("Result: " + list);
    }
}

Result: [1, 2, 3, 4, 5]

count is used to count the number of elements in a stream, this method returns an integer value that is the number of elements in the stream

import java.util.stream.Stream;

public class CafeincodeExample {

    public static void main(String[] args) {

        var stream = Stream.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 11);
        var count = stream.count();
        System.out.println("Result: " + count);
    }
}

Result: 10

anyMatch is used to check whether at least one element in the stream satisfies the condition

import java.util.stream.Stream;

public class CafeincodeExample {

    public static void main(String[] args) {
        var stream = Stream.of("apple", "banana", "orange", "grape", "kiwi");
không
        var anyMatch = stream.anyMatch(str -> str.startsWith("a"));

        if (anyMatch) {
            System.out.println("There are elements starting with the letter 'a' in Stream");
        } else {
            System.out.println("There are no elements starting with the letter 'a' in Stream");
        }
    }
}

There are elements starting with the letter 'a' in Stream

allMatch is used to check whether all elements in the stream satisfy the given condition

import java.util.stream.Stream;

public class CafeincodeExample {

    public static void main(String[] args) {
        var stream = Stream.of(2, 4, 6, 8, 10);
        var allMatch = stream.allMatch(number -> number % 2 == 0);

        if (allMatch) {
            System.out.println("Result: All numbers in the Stream are divisible by 2");
        } else {
            System.out.println("Result: There is at least one number in the Stream that is not divisible by 2");
        }
    }
}

Result: All numbers in the Stream are divisible by 2

noneMatch it still returns a boolean value, however, this function will check that all elements in the stream must not satisfy a condition.

import java.util.stream.Stream;

public class CafeincodeExample {

    public static void main(String[] args) {
        var stream = Stream.of(2, 4, 6, 8, 10);
        var noneMatch = stream.noneMatch(number -> number % 5 == 0);

        if (noneMatch) {
            System.out.println("Result: There are no numbers in the Stream that are divisible by 5");
        } else {
            System.out.println("Result: There is at least one number in the Stream that is divisible by 5");
        }
    }
}

Result: There is at least one number in the Stream that is divisible by 5

findFirst returns the first element in the stream

import java.util.Optional;
import java.util.stream.Stream;

public class CafeincodeExample {

    public static void main(String[] args) {
        var stream = Stream.of("apple", "banana", "cherry", "avocado", "blueberry");
        Optional<String> firstElement = stream.findFirst();
        if (firstElement.isPresent()) {
            System.out.println("Result: First element: " + firstElement.get());
        } else {
            System.out.println("Result: Stream is empty.");
        }
    }
}

Result: First element: apple

findAny returns any element in the stream

import java.util.Optional;
import java.util.stream.Stream;

public class CafeincodeExample {

    public static void main(String[] args) {
        var stream = Stream.of("apple", "banana", "cherry", "avocado", "blueberry");
        Optional<String> anyElement = stream.findAny();
        if (anyElement.isPresent()) {
            System.out.println("Result: Any element: " + anyElement.get());
        } else {
            System.out.println("Result: Stream is empty.");
        }
    }
}

Result: Any element: apple

min returns the smallest word in the stream

import java.util.Optional;
import java.util.stream.Stream;

public class CafeincodeExample {

    public static void main(String[] args) {
        var stream = Stream.of(5, 2, 8, 1, 3);

        Optional<Integer> minElement = stream.min(Integer::compareTo);

        if (minElement.isPresent()) {
            System.out.println("Minimum element: " + minElement.get());
        } else {
            System.out.println("Stream is empty.");
        }
    }
}

Minimum element: 1

max returns the largest element in the stream

import java.util.Optional;
import java.util.stream.Stream;

public class CafeincodeExample {

    public static void main(String[] args) {
        var stream = Stream.of(5, 2, 8, 1, 3);

        Optional<Integer> maxElement = stream.max(Integer::compareTo);

        if (maxElement.isPresent()) {
            System.out.println("Maximum element: " + maxElement.get());
        } else {
            System.out.println("Stream is empty.");
        }
    }
}

Maximum element: 8

groupingBy is used to group elements in the stream according to a certain condition

import java.util.stream.Collectors;
import java.util.stream.Stream;

public class CafeincodeExample {

    public static void main(String[] args) {
        var stream = Stream.of("apple", "banana", "cherry", "avocado", "blueberry");
        var groupedByLength = stream.collect(Collectors.groupingBy(String::length));
        System.out.println("Result: " + groupedByLength);
    }
}

Result: {5=[apple], 6=[banana, cherry], 7=[avocado], 9=[blueberry]}

partitioningBy is used to divide the stream elements into two groups based on a provided condition, the return result is a Map with two keys: true and false

Elements that satisfy the condition will be assigned to the key true and elements that do not satisfy the condition will be assigned to the key false

import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class CafeincodeExample {
    public static void main(String[] args) {
        Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        Map<Boolean, List<Integer>> partitioned = stream.collect(Collectors.partitioningBy(i -> i % 2 == 0));
        System.out.println("Even numbers: " + partitioned.get(true));
        System.out.println("Odd numbers: " + partitioned.get(false));
    }
}

Even numbers: [2, 4, 6, 8, 10] 
Odd numbers: [1, 3, 5, 7, 9]

joining is used to combine stream elements into one string, you can provide a separating string between elements or leave it as default

import java.util.Arrays;
import java.util.stream.Collectors;

public class CafeincodeExample {
    public static void main(String[] args) {
        var data = Arrays.asList("apple", "banana", "cherry");
        String result = data.stream().collect(Collectors.joining(", "));
        System.out.println("Result: " + result);
    }
}

Result: apple, banana, cherry

Iterating is often used when it is necessary to create a sequence of values generated according to a certain rule

import java.util.stream.Stream;

public class CafeincodeExample {
    public static void main(String[] args) {
        Stream<Integer> evenNumbers = Stream.iterate(2, n -> n + 2).limit(5);
        evenNumbers.forEach(System.out::println);
    }
}

2
4
6
8
10

of is used to create a stream from the elements provided as arguments

import java.util.stream.Stream;

public class CafeincodeExample {
    public static void main(String[] args) {
        Stream<String> stream = Stream.of("apple", "banana", "cherry");
        stream.forEach(System.out::println);
    }
}

apple 
banana 
cherry

concat is used to concatenate two streams together, creating a new stream containing all the elements of the two original streams

import java.util.stream.Stream;

public class CafeincodeExample {
    public static void main(String[] args) {
        Stream<String> stream1 = Stream.of("apple", "banana");
        Stream<String> stream2 = Stream.of("cherry", "grape");
        Stream<String> concatenatedStream = Stream.concat(stream1, stream2);
        concatenatedStream.forEach(System.out::println);
    }
}

apple
banana
cherry
grape

unordered is used to specify that the stream will not follow the originally defined order.

This means that elements in the stream can appear in any order after performing transformations or collecting on the stream

import java.util.stream.Stream;

public class CafeincodeExample {
    public static void main(String[] args) {
        Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5);

        Stream<Integer> unorderedStream = stream.unordered();


        unorderedStream.forEach(System.out::println);
    }
}

1
2
3
4
5

range is used to create a stream containing consecutive integers, starting at a value A and ending at a value B-1

import java.util.stream.IntStream;

public class CafeincodeExample {
    public static void main(String[] args) {
        IntStream rangeStream = IntStream.range(1, 6);

        rangeStream.forEach(System.out::println);
    }
}

1
2
3
4
5

rangeClosed is used to create a stream with integers in the range A to B

import java.util.stream.IntStream;

public class CafeincodeExample {
    public static void main(String[] args) {
        IntStream rangeClosedStream = IntStream.rangeClosed(1, 5);
        rangeClosedStream.forEach(System.out::println);
    }
}

1
2
3
4
5

generate is used to generate a stream by generating elements based on a provided supplier, which independently generates elements each time it is called

import java.util.stream.Stream;

public class CafeincodeExample {
    public static void main(String[] args) {
        Stream<String> stream = Stream.generate(() -> "Cafeincode").limit(3);
        stream.forEach(System.out::println);
    }
}

Cafeincode
Cafeincode
Cafeincode

takeWhile is used to retrieve elements from a stream until a condition is no longer satisfied.

import java.util.stream.Stream;

public class CafeincodeExample {
    public static void main(String[] args) {
        Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        Stream<Integer> takenStream = stream.takeWhile(n -> n <= 7);
        takenStream.forEach(System.out::println);
    }
}

1
2
3
4
5
6
7

In contrast to takeWhile, dropWhile is used to remove elements from a stream until a condition is no longer satisfied, the remainder of the stream will be elements that do not satisfy the condition

import java.util.stream.Stream;

public class CafeincodeExample {
    public static void main(String[] args) {
        Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        Stream<Integer> droppedStream = stream.dropWhile(n -> n <= 6);
        droppedStream.forEach(System.out::println);
    }
}

7
8
9
10

boxed is used to convert the elements of a stream from primitive types to boxed types, which is useful when you want to work with streams of objects instead of primitive types

import java.util.stream.IntStream;
import java.util.stream.Stream;

public class CafeincodeExample {
    public static void main(String[] args) {
        IntStream intStream = IntStream.of(1, 2, 3, 4, 5, 6, 7, 8);
        Stream<Integer> boxedStream = intStream.boxed();
        boxedStream.forEach(System.out::println);
    }
}

1
2
3
4
5
6
7
8

parallel used to convert a stream into a stream that can be processed in parallel.

When a stream is processed in parallel, elements of the stream can be processed on multiple threads simultaneously, increasing application performance on systems with multiple processors.

However, in reality, using parallel in some cases does not really bring much significant performance, you can learn more about this part yourself.

import java.util.stream.Stream;

public class CafeincodeExample {
    public static void main(String[] args) {
        Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5);
        Stream<Integer> parallelStream = stream.parallel();
        parallelStream.forEach(System.out::println);
    }
}

3
5
4
2
1

sequential used to convert a stream from parallel processing to sequential processing.

When a stream is processed sequentially, the stream’s elements are processed in order from start to finish on a single stream.

import java.util.stream.Stream;

public class CafeincodeExample {
    public static void main(String[] args) {
        Stream<Integer> parallelStream = Stream.of(1, 2, 3, 4, 5).parallel();
        Stream<Integer> sequentialStream = parallelStream.sequential();
        sequentialStream.forEach(System.out::println);
    }
}

1
2
3
4
5

Best practice in using Java streams

Using streams properly makes your code more elegant, easier to see, and neater than the traditional coding style.

However, it must be said again and again, that too much of anything is not necessarily good. Overusing streams or confusing writing methods will also give you a real headache every time you debug.

So below are some best practices that I think should be applied to both make good use of it and avoid unnecessary abuse.

When using a stream where multiple methods are continuously applied, put each function on a different line, it will be extremely useful when debugging.
Use the methods I listed above map(), filter(), reduce(), collect(),... appropriately to perform operations on the stream
Check for null during map and filter operations
Avoid overusing parallel in the coding process, in many cases it does not achieve as much performance value as you think. If possible, just use the default sequential only.
Name variables when used appropriately. Do not use variable names with the default letters a, b, and c because it will be difficult to understand when reading.
Using Optional makes sense in cases where findFirst or findAny are used
In reality, there will be many methods you need to re-implement rather than using the default, for example, sorted
Use Peek to debug properly
In the case of converting List to Map , you need to be careful to pay attention to duplicate keys
Java streams use lazy evaluation (discussed in another article), which means elements are only calculated when necessary. You can use this to increase performance by avoiding unnecessary calculations.

Thanks, before you go:

👏 Please clap for the story and follow the author 👉

Please share your questions or insights in the comments section below.

Let’s connect on LinkedIn

Originally published at https://cafeincode.com on April 17, 2024.

Take advantage of scripts in Postman to save your time

Hùng Trần — Sun, 24 Mar 2024 05:48:36 +0000

effectively utilizing Postman scripts

In my work process, using Postman script to test API terminals is almost indispensable in my work process. In this article, I will share a few good ways to optimize my time. you guys when testing the API.

Use scripts to create virtual data

When testing the API, you will need fake data sets to use as input data, perhaps passing in the request body, request param, or path variable, but you don’t want to have to change it manually. automatically randomize the value.

In Postman, there are already random functions that help you automatically create fake value sets. All we need to do is take them out to use, you can see below.

{
    "name": "{{$randomFullName}}",
    "gender": "MALE",
    "first_name": "{{$randomWord}}",
    "last_middle_name": "{{$randomWord}}",
    "identify_number": "{{$randomBankAccount}}",
    "permanent_address": "{{$randomStreetAddress}}",
    "self_description": "{{$randomWords}}",
    "bank_account_holder": "{{$randomBankAccountName}}",
    "bank_account_number": "{{$randomBankAccount}}",
    "bank_code": "{{$randomBankAccount}}",
    "bank_name": "{{$randomBankAccountName}}",
    "tax_code": "{{$randomBankAccount}}"
}

using random method in the Postman tool

Or instead of using Postman’s built-in random functions, you can write your own function and create your own variables to use for your needs.

Random phone number

const prefixes = ['03', '05', '07', '08', '09']; 
const randomPrefix = prefixes[Math.floor(Math.random() * prefixes.length)]; 
let phoneNumber = randomPrefix + Math.random().toString().slice(2, 10); 
pm.environment.set("randomPhoneNumber", phoneNumber); 
console.log("Random phone number:", phoneNumber);

random phone number script

Random full name

const lastNames = ["Nguyễn", "Trần", "Lê", "Phạm", "Hoàng", "Huỳnh", "Phan", "Vũ", "Võ", "Đặng", "Bùi", "Đỗ", "Hồ", "Ngô", "Dương", "Lý", "Đào", "Đoàn", "Đinh", "Lương"]; 
const firstNames = ["An", "Bình", "Châu", "Duy", "Giang", "Hải", "Hà", "Hạnh", "Hiếu", "Hoàng", "Huy", "Khoa", "Lan", "Linh", "Long", "Minh", "Nam", "Nga", "Nhi", "Như", "Phong", "Phương", "Quân", "Quốc", "Sơn", "Thảo", "Thành", "Thu", "Thủy", "Tiến", "Trang", "Trung", "Tùng", "Tú", "Tuấn", "Uyên", "Vân", "Việt", "Xuân", "Yến"]; 
function generateRandomFullName() { 
  const randomLastNameIndex = Math.floor(Math.random() * lastNames.length); 
  const randomFirstNameIndex = Math.floor(Math.random() * firstNames.length); 
  const fullName = lastNames[randomLastNameIndex] + " " + firstNames[randomFirstNameIndex];
 return fullName; 
} 
const randomFullName = generateRandomFullName(); 
pm.environment.set("randomFullName", randomFullName); 
console.log("Random full name:", randomFullName);

random full name script

Random email

const domains = ["gmail.com", "yahoo.com", "hotmail.com", "outlook.com", "icloud.com", "aol.com", "protonmail.com", "mail.com", "zoho.com", "yandex.com"]; 
function generateRandomEmail() { 
  const randomUsername = Math.random().toString(36).substring(7); 
  const randomDomain = domains[Math.floor(Math.random() * domains.length)]; 
  const email = randomUsername + "@" + randomDomain; 
  return email; 
} 
const randomEmail = generateRandomEmail(); 
console.log("Random email:", randomEmail); 
pm.environment.set("randomEmail", randomEmail);

random email script

Random gender

function generateRandomGender() { 
  const genders = ["MALE", "FEMALE", "OTHER"]; 
  const randomIndex = Math.floor(Math.random() * genders.length); 
  const randomGender = genders[randomIndex]; 
  return randomGender; 
} 
const randomGender = generateRandomGender(); 
pm.environment.set("randomGender", randomGender); 
console.log("Random gender:", randomGender);

random gender script

You can reuse the above scripts or optimize them according to your actual needs.

Write a script to get data from the response and transmit it to other APIs

Now after getting the results from the API, you want to throw some values from response API A to the request body or request param of API B, C, D, E, or something else to call again, but you don’t want to. Copying manually by hand it is very tiring.

The most effective way is to write functions to extract data from the response, then pass the extracted value results into parameter variables, and then use these parameter variables on the APIs that need to be called.

Some use cases you can often use are:

Get access token from login API

The example below is the resulting JSON string after making a call to the login API:

{
    "access_token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMzjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyLCJleHAiOjE1MTYyMzkwMjIsInJvbGUiOiJ1c2VyIn0.DeOXN2oxXntRklB5A9IMop0EXo-qYpBJE7Je9y06X5o",
    "token_type": "Bearer",
    "expires_in": 3600,
    "refresh_token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyLCJlreHAiOjE1MTYyMzkwMjIsInJvbGUiOiJ1c2VyIn0.S8EoXZBk7oG3K9TThlTMyhYO2XvE7YlzzI6xgJgrXhg",
    "scope": "read write",
    "user_id": "1234567890"
}

Now you will need to write a function to get that access_token value and put it into another API to call

Go to the Tests tab in Postman to write the script below

console.log('Request:'+ pm.request.body.toString()) 
var jsonData = pm.response.json(); 
var accessToken = jsonData.access_token; 
pm.environment.set("accessToken", accessToken); 
console.log('Token:'+ accessToken)

Now the access_token value from the login API has been passed into the variable accessToken, you just need to take it out and use it.

using variable accessToken

Get an array of a list of data

Just imagine, if you need to test 7 or 8 APIs continuously, each API needs data from the previous API. At that time, having to manually change each input data is a real torture.

Here, after successfully calling the first API, I get an array of values. Now the need is to get a list of results by field code, then pass this array of results into the second API, and you can implement it. declared as follows

Let’s say the JSON string below is the result of calling the API

{
    "data": [
        {
            "id": 1,
            "code": "org001",
            "name": "Organization A",
            "status": "ACTIVE"
        },
        {
            "id": 2,
            "code": "org002",
            "name": "Organization B",
            "status": "ACTIVE"
        },
        {
            "id": 3,
            "code": "org003",
            "name": "Organization C",
            "status": "INACTIVE"
        }
    ]
}

You can also go to the tab Teststo write js script as below:

let responseData = pm.response.json().data; 
if (Array.isArray(responseData)) { 
  let codes = []; 
  responseData.forEach(item => { 
    if (item && item.hasOwnProperty("code")) { 
      codes.push(item.code); 
      } 
    }); 
  pm.globals.set("envSegments", JSON.stringify(codes)); 
  console.log("Size envSegments: "+codes.length); 
  console.log("envSegments: " + JSON.stringify(codes)); 
} else { 
console.log("Trường data không phải là một mảng"); 
}

script get list codes

And now in the API you need to use, you can take it out and use it similar to the above parts. Below is a sample request body snippet that I use. Please do not share the full request body but just stop at the part using variables. Okay, guys.

using variable envSegments

Originally published at https://cafeincode.com on March 24, 2024.

Three threads execute sequentially, what implementations are there?

Hùng Trần — Thu, 04 May 2023 10:53:14 +0000

Today we will look a little bit at Java, for example, an interview question you are asked is as follows: the request requires three threads to execute sequentially, and what implementations are there to achieve it?

The problem will be that we have three streams: Stream 1, Stream 2, and Stream 3, the requirement is that stream 1 will be processed first, then stream 2, and finally stream 3. We will have a few ways like after:

Use the Join method

import java.util.Objects;

public class ThreadMain {

    public static void main(String[] args) {
        var t1 = new Thread(new Work(null));
        var t2 = new Thread(new Work(t1));
        var t3 = new Thread(new Work(t2));
        t1.start();
        t2.start();
        t3.start();
    }

    static class Work implements Runnable {
        private Thread beforeThread;

        public Work(Thread beforeThread) {
            this.beforeThread = beforeThread;
        }

        @Override
        public void run() {
            if (Objects.nonNull(beforeThread)) {
                try {
                    beforeThread.join();
                    System.out.println("Thread start : " + Thread.currentThread().getName());
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            } else {
                System.out.println("Thread start : " + Thread.currentThread().getName());
            }
        }
    }
}

Reading the above code, you can understand some of the logic, passing parameters into the initialization function of streams 1, 2, and 3. At this time, it stream 1will be processed first, stream 2join stream 1will be processed further, and join stream 3with stream 2will be processed last.

Start the application and see the results:

Use CountDown Latch

import java.util.concurrent.CountDownLatch;

public class CountDownLatchMain {

    public static void main(String[] args) {
        var countDownLatchOne = new CountDownLatch(0);
        var countDownLatchTwo = new CountDownLatch(1);
        var countDownLatchThree = new CountDownLatch(1);

        var t1 = new Thread(new Work(countDownLatchOne, countDownLatchTwo));
        var t2 = new Thread(new Work(countDownLatchTwo, countDownLatchThree));
        var t3 = new Thread(new Work(countDownLatchThree, countDownLatchThree));

        t1.start();
        t2.start();
        t3.start();

    }

    static class Work implements Runnable {
        CountDownLatch cOne;
        CountDownLatch cTwo;

        public Work(CountDownLatch cOne, CountDownLatch cTwo) {
            this.cOne = cOne;
            this.cTwo = cTwo;
        }

        @Override
        public void run() {
            try {
                cOne.await();
                System.out.println("Thread using countdown latch start : " + Thread.currentThread().getName());
                cTwo.countDown();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

Ok, now start the application and see the results, then go into detail about its execution:

In the function main(), three objects CountDownLatchare created with initial values of 0, 1, and 1.

countDownLatchOneused to mark all threads as ready to start
countDownLatchTwoused to start t2after t1having finished
countDownLatchThreeused to start t3after t2having finished

Three objects are created with three corresponding Threadobjects passed in. WorkThen, three threads are started by calling the start().

In class Work, the implementation is shown as follows:

Class Workis an implementation class Runnablewhose purpose is to perform some work executed in a separate thread.
The class Workhas two input parameters, which are two objects of the class CountDownLatch, cOneand cTwo.
run()In the class method Work, before starting to execute work, the thread will call the await()above method cOne, waiting until cOnethe countdown value is reduced to 0.
The thread will then print a message to confirm that it has started doing its work. This is the marker for t1completing your work.
Finally, the thread will call the countDown()above method cTwoto decrement the countdown value of cTwoto 0. Decreasing the countdown value of cTwowill mark the t2start of execution.
The same process will continue for t2and t3in the correct order of entry. That is, t2it will wait until cTwothe countdown value is reduced to 0 by calling the await()above method cTwo, then print a confirmation message and finally reduce the countdown value to 0 by calling the above cThreemethod.countDown()cThree
Similarly, t3it will wait until cThreethe countdown value is reduced to zero by calling the await()above method cThree, printing a confirmation message, and finally ending its execution.

Use ExecutorService

We can implement a single thread group using ExecutorService but only use a single thread because if we deploy multiple thread groups, the order of T1, T2, and T3 will not be guaranteed.

import java.util.concurrent.Executors;

public class ExecutorServiceMain {
    public static void main(String[] args) {
        Thread t1 = new Thread(() -> System.out.println("Thread Start : " + Thread.currentThread().getName() + " 1"));

        Thread t2 = new Thread(() -> System.out.println("Thread Start : " + Thread.currentThread().getName() + " 2"));

        Thread t3 = new Thread(() -> System.out.println("Thread Start : " + Thread.currentThread().getName() + " 3"));

        var executor = Executors.newSingleThreadExecutor();
        executor.submit(t1);
        executor.submit(t2);
        executor.submit(t3);
        executor.shutdown();
    }
}

Above are a few ways to solve the problem of processing the order of streams. Good luck with your studies.

Thanks, before you go:

👏 Please clap for the story and follow the author 👉

Please share your questions or insights in the comments section below.

Let’s connect on LinkedIn

Originally published at https://cafeincode.com on May 4, 2023.

Kĩ năng quản lý căng thẳng cho Developer

Hùng Trần — Sun, 02 Apr 2023 03:45:43 +0000

Khi là một Developer, bạn sẽ phải đối mặt với nhiều áp lực trong công việc, từ những deadline của dự án đến những vấn đề phức tạp trong mã nguồn. Điều này có thể khiến bạn cảm thấy căng thẳng và ảnh hưởng đến tinh thần, sức khỏe của mình.

Vì vậy, việc quản lý căng thẳng là một kỹ năng cần thiết để giúp bạn duy trì sức khỏe tinh thần và hoàn thành công việc của mình một cách hiệu quả.

Thời gian rất lâu trước đây mình cũng đã từng bị stress, căng thẳng tột độ cũng như trào ngược dạ dày cấp độ nặng, mà không chỉ là do công việc mà còn do ti tỉ thứ khác kết hợp lại dẫn đến.

Trong bài viết hôm nay mình sẽ hướng dẫn các bạn một số tips có thể quản lý căng thẳng, giúp các bạn có một tâm trạng thoải mái hơn và đối diện được với những vấn đề trong công việc, cuộc sống.

Tập trung vào giải pháp

Tập trung vào giải pháp là một cách tiếp cận tích cực và hiệu quả để xử lý vấn đề. Thay vì tập trung vào những khó khăn và trở ngại, tập trung vào tìm ra giải pháp và cách thức để giải quyết vấn đề có thể giúp bạn giải quyết nhanh chóng và hiệu quả hơn.

Tuy nhiên, việc tập trung vào giải pháp không có nghĩa là bạn không cần phải nhìn vào vấn đề. Điều quan trọng là bạn phải hiểu rõ và đánh giá chính xác tình hình để có thể đưa ra những giải pháp phù hợp. Bạn cần tìm hiểu và xác định nguyên nhân của vấn đề, đặt mục tiêu và lên kế hoạch để đạt được mục tiêu đó. Sau đó, hãy tập trung vào thực hiện giải pháp và theo dõi kết quả.

Nhìn nhận tích cực và tập trung vào giải pháp có thể giúp bạn giải quyết vấn đề một cách nhanh chóng và hiệu quả hơn, đồng thời giúp cải thiện tinh thần và nâng cao năng lượng.

Tìm kiếm hỗ trợ khi gặp khó khăn

Nếu bạn gặp phải căng thẳng nghiêm trọng khi gặp phải việc khó hoặc không thể tự giải quyết được vấn đề, hãy nghĩ đến việc tìm kiếm sự giúp đỡ từ những đồng nghiệp nhiều kinh nghiệm hơn, để xem những góc nhìn mới từ họ như thế nào, từ đó có phương án để xử lý vấn đề cho bản thân.

Hơn nữa việc tìm kiếm sự giúp đỡ từ người khác nó không đánh giá bạn là một người kém hiểu biết, mà ngược lại việc bạn tìm sự giúp đỡ từ đúng người nó còn chứng tỏ bạn là một người rất biết cách xử lý công việc, tối ưu hóa thời gian cá nhân.

Biết cách đặt giới hạn

Phần này sẽ gồm hai ý:

Thứ nhấthãy học cách từ chối các yêu cầu không cần thiết hoặc nếu nhận lời thì thêm nó vào danh sách công việc của bạn và để làm sau, như kiểu nắm thông tin và đưa vào một danh sách công việc rồi dành thời gian xử lý sau nếu nó thực sự không gấp.

Thứ haiđó là hãy giảm kì vọng của bản thân xuống, đồng thời nâng mức độ chấp nhận của bản thân lên (Một quan điểm của chủ nghĩa khắc kỉ giúp bản thân hạnh phúc hơn, mình sẽ nói ở một bài nào đó sau).

Như kiểu các bạn kì vọng trong một ngày cần phải hoàn thành 10 công việc trong to-do list, nhưng đến cuối ngày nhìn lại chỉ hoàn thành được 7, 8 thôi chẳng hạn thì hãy chấp nhận nó và lấy đó làm mức tạm chấp nhận và cải thiện dần, nếu không các bạn sẽ rất dễ bị dính vào toxic-productivity.

Toxic Productivity: ChatGPT said

Sắp xếp công việc hợp lý

Đặt mục tiêu và lên kế hoạch để hoàn thành công việc một cách hợp lý và đều đặn. Bạn có thể sử dụng các công cụ quản lý thời gian như Asana hoặc Trello để giúp bạn tổ chức công việc của mình và đảm bảo rằng bạn hoàn thành công việc đúng hạn.

Như cá nhân mình thì mình dùng Asana để quản lý công việc cá nhân, cũng như quản lý dự án ngoài, còn những dự án ở công ty thì dùng Jira.

Mình lên kế hoạch công việc cho bản thân đều đặn theo tuần, theo ngày, và sau mỗi quý thì sẽ tổng hợp lại những thứ đã đạt được và so sánh với mục tiêu của bản thân từ đầu năm, sau đó điều chỉnh những quý tiếp theo cho phù hợp.

Lời khuyên cá nhân là các bạn nên tập trung xử lý công việc vào đầu ngày, lúc đó chúng ta có thể giải quyết được rất nhiều thứ.

Duy trì việc tập thể dục

Tập thể dục là một cách tuyệt vời để giảm stress và cải thiện sức khỏe tinh thần của bạn. Hãy dành thời gian để tập thể dục mỗi ngày và bạn sẽ cảm thấy ngày hôm đó cực kì nhiều năng lượng.

Mình thấy nhiều người rất lạ, công việc bận thì họ ở lại công ty OT muộn (không nói đến những trường hợp golive hoặc xử lý gấp nên ở lại muộn vì nó có tính thời điểm) và đều lấy lý do là chưa giải quyết xong công việc và không dành được thời gian để thể dục thể thao.

Mỗi tuần mình đều duy trì việc đi bộ buổi sáng hoặc đi bơi vào buổi tối, dù công việc bận bịu thế nào thì cũng luôn dành cho bản thân chút thời gian duy trì thể dục, mỗi ngày vận động một chút thì cơ thể sẽ cảm thấy thoải mái hơn và giảm căng thẳng rất tốt, hôm nào bận quá hoặc có việc riêng thì đành chịu.

Bảng theo dõi tháng 01/2023

Như tháng 1 thì cái tháng này là tháng có Tết nên mình chủ yếu đi bộ buổi sáng hoặc buổi chiều.

Bảng theo dõi tháng 02/2023

Sang tháng 2 thì có thêm đi bơi nhiều hơn.

Bảng theo dõi tháng 03/2023

Sang tháng 3 thì mình vẫn duy trì đi bộ/bơi, có nhiều hôm không hoàn thành được do là về quá muộn hoặc trời mưa nên Failed.

Bảng theo dõi tháng 04/2023

Tháng 4 bắt đầu hè về nên mình duy trì với tần suất cao hơn, các tháng tiếp theo mình sẽ update liên tục trong post này luôn.

Quản lý cảm xúc cá nhân

Học cách quản lý cảm xúc của mình là một kỹ năng quan trọng trong việc quản lý căng thẳng. Hãy tìm hiểu cách quản lý cảm xúc của mình và biết cách kiểm soát chúng để không bị tác động tiêu cực, lắng nghe người khác nhiều hơn và đưa ra phản hồi một cách hợp lý.

Hãy học cách lắng nghe tích cực từ bài trước của mình để có thêm những góc nhìn mới và có thể hiểu người khác hơn.

Học cách thở dài sinh lý

Khi chúng ta cảm thấy căng thẳng thì nhịp tim thường rơi vào trạng thái đập điên loạn và cường độ cao, lúc này có một cách giúp bạn có thể đưa nhịp tim trở về trạng thái ổn định ngay lập tức đó là Thở Dài Sinh Lý.

Thở dài sinh lý 2 lần hít vào 1 lần thở ra sâu (ChatGPT said)

Kĩ thuật này mình học được từ một bác Giáo Sư trong lĩnh vực thần kinh học của Mỹ, và khi áp dụng vào công việc hằng ngày thì mình thấy nó thực sự hiệu quả.

Có nhiều lần đồng nghiệp ngồi cạnh thấy mình thở dài thì đều hỏi tại sao lại thở dài, chán chường điều gì hay sao? và mình có giải thích đó là một cách điều hòa nhịp tim, tăng cường tập trung và giảm mệt mỏi chứ không phải là một trạng thái chán chường thông thường bằng thở dài.

Dành thời gian nghỉ ngơi, gặp gỡ bạn bè

Một trong những cách giảm căng thẳng cơ bản đó là social-network, hiểu một cách đơn giản đó là dành thời gian cho việc gặp gỡ bạn bè, người thân, những người mà chúng ta cảm thấy thực sự tin tưởng.

Đó là một cách rất hữu hiệu để tăng hormone serotonin trong cơ thể, giúp tâm trạng của bạn trở nên thoải mái và hạnh phúc hơn. Khi đang nghỉ ngơi thì hãy cố gắng gạt công việc sang một bên, tạm thời không cần nghĩ đến nó nữa sẽ khiến cơ thể rất thoải mái.

Học cách điều chỉnh quan điểm

Cố gắng nhìn nhận vấn đề một cách tích cực và tìm cách giải quyết nó. Mỗi người sẽ có một quan điểm cá nhân khác nhau, quan điểm tốt và tích cực thì chúng ta học hỏi, quan điểm sai trái thì nhìn nhận và loại trừ, nó sẽ giúp cá nhân bạn tạo ra một trải nghiệm tích cực trong công việc cũng như trong cuộc sống.

Với những kỹ năng quản lý căng thẳng này, bạn có thể duy trì sức khỏe tinh thần và hoàn thành công việc của mình một cách hiệu quả. Điều quan trọng là bạn phải luôn chú ý đến sức khỏe của mình và biết cách giải quyết căng thẳng để không bị tác động đến tâm trí và sức khỏe của mình. Chúc bạn thành công trong công việc và cuộc sống!