Introduction

SSH (Secure Shell) is a popular, secure protocol for remote access to servers and other network devices. When you launch an EC2 instance, you can connect to it using SSH to manage the server, install and update software, configure settings, and perform other administrative tasks.

• Prerequisites
• Connecting over Unix-based systems
• Connecting over Windows

Prerequisites

Before you can connect to an EC2 instance over SSH, you need the following:

• Running EC2 instance and accessible over the network.
• The EC2 instance’s IP address or public DNS.
• The appropriate security group configured to allow SSH access (port 22) from your IP address or network.
• The private key file (.pem) corresponding to the key pair used when launching the instance.

Remember to keep your private key file secure and not share it with anyone. It is the key to accessing your EC2 instance.

If you encounter any issues while connecting, double-check that your instance is running, that the security group allows SSH access from your IP address, or that you are using the correct private key file.

Connecting over Unix-based systems

To connect to your EC2 instance via SSH at Unix-based systems like Linux, macOS, or others, follow these steps:

Locate the private key file

Find the private key file (.pem) you downloaded when you created the EC2 instance.

Make sure you have the correct permissions to use the private key file. On Linux or macOS, you can set the permissions using the command:

chmod 400 /path/to/your/private-key.pem

Connect to the EC2 instance using SSH

Open a terminal or command prompt and use the `ssh` command to connect to your EC2 instance:

ssh -i /path/to/your/private-key.pem ec2-user@<public-dns-or-ip>

• Replace /path/to/your/private-key.pem with the real path to your private key file.
• Replace <public-dns-or-ip> with the public DNS or IP address of your EC2 instance.
• If you’re using a different username than ec2-user (e.g., for Ubuntu instances, it’s usually ubuntu), modify the command accordingly.

Here’s an example of the SSH command:

 ssh -i ~/Downloads/my-key-pair.pem ec2-user@ec2-1-25-67-980.us-west-2.compute.amazonaws.com

Accept the server’s host key

If it’s your first time connecting to the instance, the server may prompt you to accept its host key. Type yes and press Enter to continue.

Connection to EC2 instance

Success! You should now have successfully connected to your EC2 instance via SSH.

Connecting over Windows

If you’re using Windows and don’t have the ssh command available, you can use an SSH client like PuTTY:

• First, convert your private key file (.pem) to a format compatible with PuTTY (.ppk) using PuTTYgen. If you do not know how, just check the section below.
• Open PuTTY and enter the public IPv4 DNS or IP address of your EC2 instance in the “Host Name (or IP address)” field. Keep “Connection type” as “SSH”.
• From the “Connection” category in left tree navigation, select “SSH -> Auth” and click on “Credentials”.
• For “Private key file for authentication” click on “Browse” and select the private key file (.ppk).
• Click on “Open” to initiate the SSH connection. At “Putty Security Alert”, click “Yes” to accept the server’s host key.

Generating a .ppk file from a .pem file

To convert your private key file (.pem) to a .ppk file for use with PuTTY, follow these steps:

• Open PuTTY Key Generator (PuTTYgen) and click on “Load” to select your private key file (.pem).
• Click on “Save private key” to convert the key to PuTTY’s .ppk format and save it to a location of your choice.
• You can now connect the converted .ppk file with PuTTY to your EC2 instance.

Conclusion

This article has shown how to connect to an Amazon EC2 instance over SSH. Following the steps outlined above, you can securely access your EC2 instance and manage it remotely using SSH.

Be sure to store your private key file securely and avoid sharing it with others, as it serves as the gateway to accessing your Amazon EC2 instance.

If you face any connection issues, verify that your instance is operational, that your security group permits SSH access from your IP address, and that you employ the correct private key file.

Did you find connecting to your EC2 instance over SSH easy? Do you have tips or another way to connect to an EC2 instance? Let us know in the comments below. We’d love to hear your ideas and experiences.

Thanks for reading!

Like this article? Please share it with your friends and help us grow. Happy coding! 😊

Introduction

Recently, I was solving a straightforward issue. The technical documentation about the input format was straightforward. A particular column in the CSV document represented numbers in double format. However, users were allowed to interact with CSV files and make manual edits. This lead to a situation where the user or the processing program changes the number to a standardized format or even to an incorrect one. In most cases, users change the dot to a comma.

Thus, if possible, I needed to devise a simple way to fix the incorrect input and cast the string to double.

Implementation

I have created a simple util class with a single static method to fix the incorrect string format.

The method implementation catches and solves the following cases:

• The method throws an exception if the input string is null or empty.
• The method throws an exception if the input string contains more than one separator or a mix of different separators.
• The method throws an exception if the input string is not a number.
• Otherwise, the process replaces the comma with a dot and parses the string to double.

Casting can still fail and throw NumberFormatException if the input string is not a number. parseStringToDouble() method will not handle the failure, and it will be up to the caller to catch the exception and manage it. Feel free to adjust the method according to your needs.

Here is a simple algorithm for how to cast string to double:

public static class StringUtil {
  
  private static final String DOT = ".";
  private static final String COMMA = ",";
  private static final String EMPTY = "";
  
  /**
   * Parses a string to a double.
   *
   * @param numberStr
   * @return the parsed double
   * @throws IllegalArgumentException if the input string is null or empty, or if the number is ambiguous
   */
  public static Double parseStringToDouble(final String numberStr) {
      if (numberStr == null || numberStr.isEmpty()) {
          throw new IllegalArgumentException("Input string is null or empty");
      }

      val numberStrWithReplacedCommas = numberStr.replace(COMMA, DOT);

      int dotCount = numberStr.length() - numberStr.replace(DOT, EMPTY).length();
      int commaCount = numberStr.length() - numberStrWithReplacedCommas.length();

      if (dotCount + commaCount > 1) {
          throw new IllegalArgumentException("There is more than one separator, or a mix of them, the number is ambiguous");
      }

      return Double.parseDouble(numberStrWithReplacedCommas);
  }

}

Feel free to use this simple algorithm in your projects and extend it according to your will. You may not need to throw an exception if the input string is null or empty or if the number is ambiguous. You may want to catch NumberFormatException from parseDouble method and return 0.0 in such case. You could return empty Optional. It is up to you.

Tests

I also wrote a few tests to verify that the algorithm works correctly. Please check it and adjust it according to your will. Here are the tests:

import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;

import lombok.val;

class StringUtilTest {

    @Test
    public void testParseValidStringWithDot() {
        val result = StringUtil.parseStringToDouble("123.45");
        Assertions.assertEquals(123.45, result, 0.000);
    }

    @Test
    public void testParseValidStringWithComma() {
        val result = StringUtil.parseStringToDouble("123,45");
        Assertions.assertEquals(123.45, result, 0.000);
    }

    @Test
    public void testParseStringWithMultipleSeparatorsShouldThrowException() {
        Assertions.assertThrows(IllegalArgumentException.class,
            () -> StringUtil.parseStringToDouble("123,45.67"));
    }

    @Test
    public void testParseStringWithInvalidCharactersShouldThrowException() {
        Assertions.assertThrows(IllegalArgumentException.class,
            () -> StringUtil.parseStringToDouble("123..45"));
    }

    @Test
    public void testParseStringWithOtherInvalidCharactersShouldThrowException() {
        Assertions.assertThrows(IllegalArgumentException.class,
            () -> StringUtil.parseStringToDouble("123,,45"));
    }

    @Test
    public void testParseNonNumericStringShouldThrowException() {
        Assertions.assertThrows(NumberFormatException.class,
            () -> StringUtil.parseStringToDouble("not a number"));
    }

    @Test
    public void testParseEmptyStringShouldThrowException() {
        Assertions.assertThrows(IllegalArgumentException.class,
            () -> StringUtil.parseStringToDouble(""));
    }

    @Test
    public void testParseNullShouldThrowException() {
        Assertions.assertThrows(IllegalArgumentException.class,
            () -> StringUtil.parseStringToDouble(null));
    }

}

Conclusion

In simple algorithms, we have seen how to handle multiple cases of incorrect string input and how to cast string to double.

But in the end, it is up to you how to handle the cases when the input string is null or empty or if the number is ambiguous. You can throw a custom exception, return 0.0, empty Optional, or do something else.

Did you find an algorithm for casting strings to double easily? Do you have your trick or know another way how to change arbitrary string to double? Let us know in the comments below the article. We would like to hear your ideas and stories.

Introduction

In this article we will continue and spin from the previous article about generating OpenAPI with Spring Boot for multipart endpoint and uploading files through it. We strongly recommend reading the last article if you want to import more than one file. But in this article, we will focus only on the optional import of a single file.

But instead of multiple files, we will try to upload only one file and one serialized object, for example, the information about the new user.

We will also show how to handle the deserialization of the incoming object from the string at the Spring Boot backend and how to control proper deconstruction if some fields are optional or not mandatory.

OpenAPI User import definition YAML

So we start where we end the last time. Let’s generate the Spring Boot endpoint through the OpenAPI schema, which will be able to receive objects and, optionally, a file through multipart form data.

openapi: 3.0.2
info:
  title: User management module
  description: User management
  version: '0.1'
  contact:
  email: optional@email.com
servers:
  - url: https://localhost:8080/api/user-management

paths:
  /users/import:
    post:
      summary: Create new Users with optional attachment
      tags:
        - users
      operationId: createUserWithOptionalFile
      requestBody:
        content:
          multipart/form-data:
            schema:
              type: object
              properties:
                createUser:
                  description: Wrapper containing information for new user creation
                  type: object
                  properties:
                    username:
                      description: Users username
                      type: string
                    age:
                      description: Users password
                      type: number
                    creationTimestamp:
                      description: Time when the user will be defined as created in the system
                      type: string
                      format: date-time
                      example: "2024-02-29T12:30:00.000Z"
                    email:
                      description: Email of the user
                      type: string
                    addressId:
                      description: ID of the users address
                      type: string
                    accessRights:
                      description: List of access rights for the user
                      type: array
                      items:
                        type: object
                        properties:
                          accessRightId:
                            description: ID of the access right
                            type: string
                          note:
                            description: Note for the access right
                            type: string
                  required:
                    - username
                    - email
                    - accessRights
                optionalFile:
                  description: Optional file attachment
                  type: string
                  format: binary
              required:
              - createUser
      responses:
        '200':
          description: Successful operation
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/CreateUserResponse'
        '400':
          description: Bad Request

As you can see, we have defined the endpoint /users/import, which will be able to receive the object createUser and optionally also a single file. The createUser object is defined in the schema and is required, while the file is optional. CreateUser object also has various definitions of fields, although unimportant and displayed only for current examples.

You can refer to the object schema to make the YAML file more readable and concise. The object’s schema can be defined in self-standing section dedicated to components.

openapi: 3.0.2
info:
  title: User management module
  description: User management
  version: '0.1'
  contact:
  email: optional@email.com
servers:
  - url: https://localhost:8080/api/user-management

paths:
  /users/import:
    post:
      summary: Create new Users with optional attachment
      tags:
        - users
      operationId: createUserWithOptionalFile
      requestBody:
        content:
          multipart/form-data:
            schema:
              type: object
              properties:
                createUser:
                  $ref: '#/components/schemas/CreateUser'
                optionalFile:
                  description: Optional file attachment
                  type: string
                  format: binary
              required:
              - createUser
      responses:
        '200':
          description: Successful operation
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/CreateUserResponse'
        '400':
          description: Bad Request

components:
  schemas:
    CreateUser:
      description: Wrapper containing information for new user creation
      type: object
      properties:
        username:
          description: Users username
          type: string
        age:
          description: Users password
          type: number
        creationTimestamp:
          description: Time when the user will be defined as created in the system
          type: string
          format: date-time
          example: "2024-02-29T12:30:00.000Z"
        email:
          description: Email of the user
          type: string
        addressId:
          description: ID of the users address
          type: string
        accessRights:
          description: List of access rights for the user
          type: array
          items:
            type: object
            properties:
              accessRightId:
                description: ID of the access right
                type: string
              note:
                description: Note for the access right
                type: string
      required:
        - username
        - email
        - accessRights

Enforcing and casting mandatory properties of multipart request

Multipart file can accept only the Strings or Files (better visible in testing with Postman section). So any string input – Java’s serialized object, or JSON, is at the end nothing more than just a string of bytes.

The problem will arise during the deserialization of autogenerated code. It does not matter if you declare the object cast as required. With proper mapping, the input will be taken as a String and not as the type you want to use from the method signature.

Mapper and validator factory beans can solve the issue and handle the input.

First, register one new bean for object Validation. Optionally, you can register the ObjectMapper with JavaTimeModule to handle the date-time format, as we will use the date-time string in ISO format (“YYYY-MM-DDTHH:MM:SS.mmmZ”). The Validator is created through LocalValidatorFactoryBean.

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.validation.beanvalidation.LocalValidatorFactoryBean;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;

import jakarta.validation.Validator;
import lombok.val;

@Configuration
public class AppConfig {

  //@Bean
  //public ObjectMapper objectMapper() {
  //  val objectMapper = new ObjectMapper();
  //  objectMapper.registerModule(new JavaTimeModule());
  //  return objectMapper;
  //}

  @Bean
  public Validator validator() {
    return new LocalValidatorFactoryBean();
  }

}

The code was written for Java 21 dependencies with Lombok.

To enforce the proper conversion, you must create a new Spring component to convert the incoming string to the object. The component will be able to handle the deserialization and validation of the object.

import java.util.Set;

import org.springframework.core.convert.converter.Converter;
import org.springframework.stereotype.Component;

import com.fasterxml.jackson.databind.ObjectMapper;

import jakarta.validation.ConstraintViolation;
import jakarta.validation.ConstraintViolationException;
import jakarta.validation.Validator;
import lombok.val;

@Component
public class StringToCreateUserDtoConverter implements Converter<String, CreateUserDto> {

  private final Validator validator;
  private final ObjectMapper objectMapper;

  public StringToCreateUserDtoConverter(final Validator validator, final ObjectMapper objectMapper) {
    this.validator = validator;
    this.objectMapper = objectMapper;
  }

  @Override
  public CreateUserDto convert(final String source) {
    CreateUserDto createUserDto;
    try {
        createUserDto = objectMapper.readValue(source, CreateUserDto.class);
    } catch (JsonProcessingException e) {
        throw new CreateUserDeserializationException("Input mapping and processing error: " + e.getMessage());
    }
    val violations = validator.validate(createUserDto);
    if (!violations.isEmpty()) {
        throw new ConstraintViolationException(violations);
    }
    return createUserDto;
  }

}

Just for the record, I will also add here the custom exception you can throw and catch in the custom exception handler:

import java.io.Serial;

import lombok.Getter;

@Getter
public class CreateUserDeserializationException extends RuntimeException {

  @Serial
  private static final long serialVersionUID = 1659771269447893294L;

  public CreateUserDeserializationException(String msg) {
    super(msg);
  }

}

Unit tests

I recommend writing the unit tests for the converter. It is a good practice to test the conversion and validation of the object. As we rely heavily upon Spring magic, a lot can unintentionally influence the component’s behaviour without us discovering it.

The code below is just an example of the unit tests with the usage of SpringBootTest and LocalTestcontainers which ties to get close to real-world use scenarios. We highly recommend to accommodate tests to your environment and needs.

import org.testcontainers.containers.PostgreSQLContainer;

public class LocalTestcontainers {

    public static void startPostgres(){
        PostgreSQLContainer postgre = new PostgreSQLContainer<>("postgres:16.0")
            .withDatabaseName("INSERT_DATABASE_NAME")
            .withUsername("INSERT_DATABASE_USERNAME")
            .withPassword("INSERT_DATABASE_PASSWORD");
        postgre.start();

        System.setProperty("spring.datasource.url", postgre.getJdbcUrl());
        System.setProperty("spring.datasource.username", postgre.getUsername());
        System.setProperty("spring.datasource.password", postgre.getPassword());
    }

}

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;

import java.math.BigDecimal;
import java.time.Instant;
import java.time.format.DateTimeFormatter;
import java.util.UUID;

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.testcontainers.junit.jupiter.Testcontainers;

import com.codepills.usermanagementmodule.api.exception.CreateUserDeserializationException;
import com.codepills.usermanagementmodule.utils.LocalTestcontainers;

import jakarta.validation.ConstraintViolationException;
import lombok.val;

@SpringBootTest
@Testcontainers
class StringToCreateUserDtoConverterTest {

    static {
        LocalTestcontainers.startPostgres();
    }

    @Autowired
    private StringToCreateUserDtoConverter stringToCreateUserDtoConverter;

    @Test
    void testConvertValidInputString() {
        // Arrange
        val username = "JohnDoe";
        val age = 25;
        val formatter = DateTimeFormatter.ISO_INSTANT;
        val now4CreationTime = Instant.now();
        val email = "john.doe@noemail.com";
        val addressId = UUID.randomUUID();
        val accessRightId1 = UUID.randomUUID();
        val accessRightId2 = UUID.randomUUID();

        val stringBuilder = new StringBuilder();
        stringBuilder.append("{");
        stringBuilder.append("\"username\" : \"").append(username).append("\",");
        stringBuilder.append("\"age\" : ").append(age).append(",");
        stringBuilder.append("\"creationTimestamp\" : \"").append(formatter.format(now4CreationTime)).append("\",");
        stringBuilder.append("\"email\" : \"").append(email).append("\",");
        stringBuilder.append("\"addressId\" : \"").append(addressId).append("\",");
        stringBuilder.append("\"accessRights\" : [");
        stringBuilder.append("{");
        stringBuilder.append("\"accessRightId\" : \"").append(accessRightId1).append("\",");
        stringBuilder.append("}, {");
        stringBuilder.append("\"accessRightId\" : \"").append(accessRightId2).append("\"");
        stringBuilder.append("}]}");
        val validInput = stringBuilder.toString();

        // Act
        val createUserDto = stringToCreatUserDtoConverter.convert(validInput);

        // Assert
        assertNotNull(createUserDto);
        assertEquals(username, createUserDto.getUsername());
        assertEquals(age, createUserDto.getAge());
        assertEquals(now4CreationTime, createUserDto.getCreationTimestamp());
        assertEquals(email, createUserDto.getEmail());
        assertEquals(addressId.toString(), createUserDto.getAddressId());
        assertEquals(2, createUserDto.getAccessRights().size());
        assertEquals(accessRightId1.toString(), createUserDto.getAccessRights().get(0).getAccessRightId());
        assertEquals(accessRightId2.toString(), createUserDto.getAccessRights().get(1).getAccessRightId());
    }

    @Test
    void testConvertInvalidInputString() {
        // Arrange
        val invalidInput = "invalid input string";
        // Act & Assert
        try {
            stringToCreateUserDtoConverter.convert(invalidInput);
        } catch (CreateUserDeserializationException ex) {
            assertEquals("Input mapping and processing error: Unrecognized token 'invalid': was expecting (JSON String, Number, Array, "
                             + "Object or token 'null', 'true' or 'false')\n at [Source: (String)\"invalid input string\"; line: 1, "
                             + "column: 8]", ex.getMessage());
        }
    }

    @Test
    void testConvertInputWithValidationErrors() {
        // Arrange
        val username = "JohnDoe";
        val age = 25;
        val formatter = DateTimeFormatter.ISO_INSTANT;
        val now4CreationTime = Instant.now();
        val email = "john.doe@noemail.com";
        val addressId = UUID.randomUUID();
        val accessRightId1 = UUID.randomUUID();
        val accessRightId2 = UUID.randomUUID();

        val stringBuilder = new StringBuilder();
        stringBuilder.append("{");
        stringBuilder.append("\"username\" : \"").append(username).append("\",");
        stringBuilder.append("\"age\" : ").append(age).append(",");
        stringBuilder.append("\"creationTimestamp\" : \"").append(formatter.format(now4CreationTime)).append("\",");
        stringBuilder.append("\"email\" : \"").append(email).append("\",");
        // Missing addressId
        stringBuilder.append("\"addressId\" : null,");
        stringBuilder.append("\"accessRights\" : [");
        stringBuilder.append("{");
        stringBuilder.append("\"accessRightId\" : \"").append(accessRightId1).append("\",");
        stringBuilder.append("}, {");
        stringBuilder.append("\"accessRightId\" : \"").append(accessRightId2).append("\"");
        stringBuilder.append("}]}");
        val validInput = stringBuilder.toString();

        // Act & Assert
        try {
            stringToCreateUserDtoConverter.convert(inputWithValidationErrors);
        } catch (ConstraintViolationException ex) {
            assertEquals(1, ex.getConstraintViolations().size());
        }
    }

}

User Management Controller

Now, all we need to do is create a controller to implement the OpenAPI schema.

Here is an example of the controller:

@Logger
@RestController
@RequiredArgsConstructor
public class UserManagementController implements UserManagementApi {

  @Override
  public ResponseEntity<Void>> createUserWithOptionalFile(
        @RequestPart(name = "createUser") final CreateUserDto createUserDto,
        @RequestPart(name = "optionalFile", required = false) MultipartFile optionalFile
     ) {
    if (optionalFile == null || optionalFile.isEmpty()) {
        log.info("No optionalFile uploaded.");
    } else {
        log.info("PDF optionalFile {} uploaded but not saved.", optionalFile.getOriginalFilename());
    }

    // You can work with createUserDto here

    return ResponseEntity.ok().build();
  }

}

I will leave the implementation of createUserWithOptionalFile() method up to you as it is not the main focus of this article.

Again, notice the optionalFile and createUser keywords in the method arguments. It is the same as the keyword as defined in the OpenAPI schema.

Testing with Postman

Nothing blocks our development anymore, and we can start testing the endpoint with Postman. The endpoint will be able to receive the serialized object in the form of string and also the file. However, attaching the file to the request is, of course, optional.

As it might need to be stressed more, the most important thing is using the exact keywords defined in the OpenAPI schema. In our case, for importing object, it will be createUser and for optional file, it will be optionalFile.

Let’s run the SpringBoot app at localhost.

Backend should be running at localhost. And if added the necessary logic for file processing into the controller, we should be able to upload serialized objects in JSON format and optional file through the /users/import endpoint.

When using Postman, you also need to define the type of multipart key. It is either the String or File. For files, use File, and for the object, use String. Do not forget that in the previous article we discuss the implementation of sending multiple files through multipart request.

All you need to do is to define your endpoint POST request in Postman. Select POST request, add the URL, and in the body tab, select form-data and add the keywords createUser set as String and optionalFile as File .

The most important part is to really define serialized object as String and not File.

Here is an example of createUser as String:

{
	"username" : "johndoe",
	"age" : "25",
	"creationTimestamp" : "2024-02-29T12:30:00.000Z",
	"email" : "john.doe@noemail.com",
	"addressId" : "f8935f28-8d7b-40a4-96d7-a3288976617e",
	"accessRights" : [
		{
      "accessRightId" : "712d5a0a-11b5-4a44-9e92-6e67d16be2aa"
    }
	]
}

Conclusion

This article has shown how to create a Spring Boot endpoint to receive objects and, optionally, file through multipart form data. We have also demonstrated how to handle the deserialization of the incoming object from the string at the Spring Boot backend and how to control proper deconstruction if some fields are optional or not mandatory.

Is it applicable to auto-generating infrastructure code through OpenAPI with Spring Boot for multipart endpoint and uploading files? Let us know in the comments below. Do you have your trick or see another way how to enforce and deserialize multipart object? Let us know in the comments below the article. We would like to hear your ideas and stories.

Introduction

Let’s imagine we want to build some simple user management app separated frontend with which we will communicate through REST.

Also, let’s add some limitations and requirements for our user management project. We will need to use the OpenAPI schema to generate the code infrastructure, as it can help us speed up interface development between the frontend and backend. We will focus on the implementation of code infrastructure on the backend side.

We generally want to receive and process multiple user files through multipart form data in Spring Boot.

Maven OpenAPI plugin

First, we must define a plugin in the pom.xml file to generate the code infrastructure from the OpenAPI schema.

Here is an example of the pom.xml file with the plugin definition:

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <parent>
    <groupId>com.codepills.openapi</groupId>
    <artifactId>spring-boot-parent</artifactId>
    <version>1.1.0</version>
  </parent>

  <groupId>com.codepills.openapi</groupId>
  <artifactId>user-management-module</artifactId>
  <version>1.0.0-SNAPSHOT</version>
  <name>user-management-module</name>
  <description>User management module</description>

  <properties>
    <java.version>21</java.version>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
    <version.swagger.codegen>3.0.50</version.swagger.codegen>
    <open.api.file>${project.basedir}/src/main/api-specification/OpenApi-UserManagement.yaml</open.api.file>
    <open.api.base>com.codepills.openapi.usermanagementmodule</open.api.base>
    <generated-sources-path>${project.build.directory}/generated-sources</generated-sources-path>
    <generated-sources-java-path>main/java</generated-sources-java-path>
  </properties>

  <dependencies>...</dependencies>

  <build>
    <finalName>${project.name}</finalName>
    <plugins>
      <plugin>
        <groupId>io.swagger.codegen.v3</groupId>
        <artifactId>swagger-codegen-maven-plugin</artifactId>
        <version>${version.swagger.codegen}</version>
        <executions>
          <execution>
            <id>generate-the-stuff</id>
            <phase>generate-sources</phase>
            <goals>
              <goal>generate</goal>
            </goals>
          </execution>
        </executions>
        <configuration>
          <inputSpec>${open.api.file}</inputSpec>
          <language>spring</language>
          <modelNameSuffix>Dto</modelNameSuffix>
          <configOptions>
            <sourceFolder>${generated-sources-java-path}</sourceFolder>
            <basePackage>${open.api.base}</basePackage>
            <modelPackage>${open.api.base}.api.model</modelPackage>
            <apiPackage>${open.api.base}.api</apiPackage>
            <interfaceOnly>true</interfaceOnly>
            <useBeanValidation>true</useBeanValidation>
            <library>spring-boot3</library>
            <dateLibrary>custom</dateLibrary>
            <jakarta>true</jakarta>
          </configOptions>
          <typeMappings>
            <typeMapping>DateTime=Instant</typeMapping>
            <typeMapping>multipartFile=org.springframework.web.multipart.MultipartFile</typeMapping>
          </typeMappings>
          <importMappings>
            <importMapping>Instant=java.time.Instant</importMapping>
          </importMappings>
          <output>${generated-sources-path}</output>
        </configuration>
      </plugin>
    </plugins>
  </build>

  <repositories>...</repositories>

</project>

As you can see, we have defined the SpringBoot module, and in it, the OpenAPI file is located at /src/main/API-specification/OpenApi-UserManagement.yaml. The OpenApi-UserManagement.yaml file will also be responsible for defining generated code infrastructure.

OpenAPI User management definition YAML

Let’s create the OpenApi-UserManagement.yaml file at /src/main/api-specification/ relative to the location of pom.xml

openapi: 3.0.2
info:
  title: User management module
  description: User management
  version: '0.1'
  contact:
  email: optional@email.com
servers:
  - url: https://localhost:8080/api/user-management

paths:
  /users/import:
    post:
      summary: Import User files
      tags:
        - UserManagement
      operationId: importFiles
      requestBody:
        content:
          multipart/form-data:
            schema:
              properties:
                userFiles:
                  type: array
                  items:
                    type: multipartFile
      responses:
        '200':
          description: Successful operation
          content:
            application/json:
              schema:
                type: object
                additionalProperties:
                  type: array
                  items:
                    type: string
        '400':
          description: Bad Request

As you can see, we have defined a simple endpoint for importing user files. The endpoint is defined as a POST request with a summary, tags, operationId, requestBody and responses.

It is essential to define the keywords for user files well. I picked up the userFiles, but you can use whatever you like. For example – simply files. The keyword will be used for the protocol to tie the files during transmission.

User Management Controller

Now, all we need to do is create a controller to implement the OpenAPI schema. User management schema name will be generated based on the tags in the OpenAPI schema.

Here is an example of the controller:

@RestController
@RequiredArgsConstructor
public class UserManagementController implements UserManagementApi {

  @Override
  public ResponseEntity<Map<<tring, List userFiles) {
    // ... your logic here ...
  }

}

I will leave the implementation up to you as it is not the main focus of this article.

Again, notice the userFiles keyword in the method argument. It is the same as the keyword as defined in the OpenAPI schema.

Testing with Postman

Let’s run the app; the last thing will be testing the endpoint with Postman.

As it might not be stressed enough so far, the most important thing is to use the same keyword as defined in the OpenAPI schema. In our case, it is userFiles.

And now, if the backend is running at localhost, and we added the necessary logic for file processing into the controller, we should be able to upload multiple files through the endpoint.

When using Postman, you also need to define the type of multipart key. It is either the String or File. For files, use File, and for the object, use String. The following article will discuss the implementation and use of mixed input.

Otherwise, all you need to do is to define your endpoint POST request as everything else. Select POST request, add the URL, and in the body tab, select form-data and add the keyword and the file.

Add multiple files with the same key “userFiles” and send the request.

Conclusion

This article has shown how to implement autogenerate of code from OpenAPI schema, how to define the schema for multiple file uploads and how to implement the endpoint at the Spring Boot backend. All you need to do is run your application and use the same keyword defined in the OpenAPI schema for the file upload.

Did you find autogenerate OpenAPI implementation and sending files through multipart requests easy? Do you have your trick or know another way to send effectively multipart requests with files? Let us know in the comments below the article. We would like to hear your ideas and stories.

We will use the following simple code to print a code into the terminal or command prompt for demonstration purposes.

public class MyJavaApp {

    public static void main(String[] args) {
        System.out.println("Hello World!");
    }

}

Compile and run Java code in a few steps

You must follow only a few basic steps to compile and run Java code.

1. As a precondition, ensuring the installation of Java Development Kit (JDK) on your system and the accessibility of the javac and java commands from the terminal or command prompt is important.
2. First, you have to have a Java source code in Java files. Open a text editor and write your Java code. Save the file with a .java file extension.
3. Then you are ready to compile the Java source file. Open a terminal or command prompt and navigate to the directory where your Java source file is placed. Utilize the javac command for compiling the Java source file into bytecode. For example:

   javac MyJavaApp.java

   You will generate a bytecode file named MyJavaApp.java if there are no compilation errors.

4. When you have successfully compiled the Java source file into a bytecode file, you can execute the bytecode using the java command. However, select the class which contains valid public static void main(String args[]) Java method in order for JVM to have an access point to your code.

   Here is an example of running MyJavaApp:

   java MyJavaApp

   And here is the output:

   

   java MyJavaApp will run your Java program, and if everything is correct, you should see the output in the console.

Compiling and running nested classes

So far, we have seen compile and run only a single class. However, running a multi-class project is no different from compiling and running a single class. Here is an example of a multi-class project we will use next.

public class MyJavaApp {

    public static void main(String[] args) {
        InsertedClass.printToWorld();
    }

}

public class InsertedClass {

    public static void printToWorld() {
        System.out.println("Hello World from other class!");
    }

}

For sure, the same as in a single class, you need to pick a class for compiling the class which contains the public static void main(String args[]). That is the only way the compiler can reach and compile all classes in your project.

And again, same as in the single class, you need to run the multi-class project with the java command on the file, which contains public static void main(String args[]) method.

Conclusion

This article has shown how to compile and run Java code on the Windows platform.

Did you find compiling and running your Java code easy? Do you have your trick or know another way how to compile and run Java code from the terminal or command prompt? Let us know in the comments below the article. We would like to hear your ideas and stories.

Let’s take a while and simulate such a conversation so you can be prepared for your next Java concurrency interview.

The whole ping-pong between interviewer and candidate is to test the candidate’s ability and knowledge of Java concurrency and way of handling access to shared variables.

Two threads with the same primitive int as argument

So, the narrative of the conversation goes like this:

Create two Java Threads. Each Thread takes the same single primitive int as an argument to its constructor. Let the first thread increment primitive int to 100 million. Let the second Thread increment the same shared variable to 20 million. How will look the output of both threads at the end of the incrementation?

So as you might guess already, this example will go in the way of figuring out if incrementing primitive int will be concurrent safe. What is meant by that, it incrementing the primitive int in one Thread will not influence the shared variable in the other Thread and vice versa.

Should both threads print 20 million, 100 million or one print count of 20 million and the second 100 million?

public class Main {
    public static void main(String[] args) {
        int sharedInt = 0;
        TOne tOne = new TOne(sharedInt);
        TTwo tTwo = new TTwo(sharedInt);
        tOne.start();
        tTwo.start();
    }
}

class TOne extends Thread {
    private int sharedInt;

    public TOne(int sharedInt) {
        this.sharedInt = sharedInt;
    }

    public void run() {
        for (int i = 0; i < 100_000_000; i++) {
            this.sharedInt += 1;
        }
        System.out.println("tOne: The shared primitive int is: " + this.sharedInt);
    }
}

class TTwo extends Thread {
    private int sharedInt;

    public TTwo(int sharedInt) {
        this.sharedInt = sharedInt;
    }

    public void run() {
        for (int i = 0; i < 20_000_000; i++) {
            this.sharedInt += 1;
        }
        System.out.println("tTwo: The shared primitive int is: " + this.sharedInt);
    }
}

Let's put the code to the file name Main.java, compile it and run it. As you can see, the tTwo execute immediately as it increments much lower than tOne. Both threads show the results as expected, although tTwo finished before tOne, which does not look correct.

tTwo: The shared primitive int is: 20000000
tOne: The shared primitive int is: 100000000

Would there be a way for tTwo to wait for tOne? What will be the output? We still do not know if they share the variable sharedInt of primitive int, if to tTwo takes a shorter time to execute as to tOne.

One Thread waits for another one to finish

We need to adjust our code slightly. We need to use Thread class join() method.

The whole premise of calling join() method upon calling Thread is for calling Thread to stop and go to a waiting state. Calling Thread will remain to wait until the referenced Thread upon which the join() method was called terminates. This way we block tTwo before executing.

public class Main {
    public static void main(String[] args) throws InterruptedException {
        int sharedInt = 0;
        TOne tOne = new TOne(sharedInt);
        TTwo tTwo = new TTwo(sharedInt);
        tOne.start();
        tOne.join();
        tTwo.start();
    }
}

class TOne extends Thread {
    private int sharedInt;

    public TOne(int sharedInt) {
        this.sharedInt = sharedInt;
    }

    public void run() {
        for (int i = 0; i < 100_000_000; i++) {
            this.sharedInt += 1;
        }
        System.out.println("tOne: The shared primitive int is: " + this.sharedInt);
    }
}

class TTwo extends Thread {
    private int sharedInt;

    public TTwo(int sharedInt) {
        this.sharedInt = sharedInt;
    }

    public void run() {
        for (int i = 0; i < 20_000_000; i++) {
            this.sharedInt += 1;
        }
        System.out.println("tTwo: The shared primitive int is: " + this.sharedInt);
    }
}

Let's compile and run the code above:

tOne: The shared primitive int is: 100000000
tTwo: The shared primitive int is: 20000000

When we run the code, we conclude that even though the variable is shared, it is isolated in the threads. The reason is that each Java Thread on its creation allocates and creates resources. And primitive types make their copies; they do not pass as a reference on the new threads. However, will this rule apply to object-type variables?

Two threads with the same Integer variable as argument

But what if we will use Object variable instead primitive int type? Will it be the same? Will the instance of the object also be isolated?

public class Main {
    public static void main(String[] args) throws InterruptedException {
        Integer sharedInt = 0;
        TOne tOne = new TOne(sharedInt);
        TTwo tTwo = new TTwo(sharedInt);
        tOne.start();
        tTwo.start();
    }
}

class TOne extends Thread {
    private Integer sharedInt;

    public TOne(Integer sharedInt) {
        this.sharedInt = sharedInt;
    }

    public void run() {
        for (int i = 0; i < 100_000_000; i++) {
            this.sharedInt += 1;
        }
        System.out.println("tOne: The shared object Integer is: " + this.sharedInt);
    }
}

class TTwo extends Thread {
    private Integer sharedInt;

    public TTwo(Integer sharedInt) {
        this.sharedInt = sharedInt;
    }

    public void run() {
        for (int i = 0; i < 20_000_000; i++) {
            this.sharedInt += 1;
        }
        System.out.println("tTwo: The shared object Integer is: " + this.sharedInt);
    }
}

The output of the code above is surprisingly correct:

tTwo: The shared object Integer is: 20000000
tOne: The shared object Integer is: 100000000

Both threads are doing relatively well. However, with a close inspection under the hood, we find out something fishy is happening. If we look better at the assigned references to sharedInt, both threads have assigned the same reference before the thread executions. However, after the run, the sharedInt in tOne had assigned a different reference. Thus, while the output is correct, each Thread's referenced object changes. Therefore, each Thread on every iteration assigns a new object to sharedInt. Consequently, at the end of execution, the different object is printed.

Rather than using the object variable of Integer class, let's make a wrapping class around the count so the passed object variable will not change. What will change will be its internal state. Here is a code with Wrapper class:

public class Main {
    public static void main(String[] args) throws InterruptedException {
        Wrapper wrapper = new Wrapper(0);
        TOne tOne = new TOne(wrapper);
        TTwo tTwo = new TTwo(wrapper);
        tOne.start();
        tTwo.start();
    }
}

class TOne extends Thread {
    private Wrapper wrapper;

    public TOne(Wrapper wrapper) {
        this.wrapper = wrapper;
    }

    public void run() {
        synchronize {
            for (int i = 0; i < 100_000_000; i++) {
                this.wrapper.increment();
            }
            System.out.println("tOne: Count is " + this.wrapper.printCount());
        }
    }
}

class TTwo extends Thread {
    private Wrapper wrapper;

    public TTwo(Wrapper wrapper) {
        this.wrapper = wrapper;
    }

    public void run() {
        synchronize {
            for (int i = 0; i < 20_000_000; i++) {
                this.wrapper.increment();
            }
            System.out.println("tTwo: Count is " + this.wrapper.printCount());
        }
    }
}

class Wrapper {
    private Integer count;

    public Wrapper(Integer count) {
        this.count = count;
    }

    public void increment() {
        this.count++;
    }

    public Integer printCount() {
        return this.count;
    }
}

Result is shocking! More and more you try, you will get slightly different numbers every time. The result is not 20 million, nor 100, or 120. Why?! As you can see, there is clearly a problem with synchronization and keeping the isolated internal state of the wrapper from one Thread to another.

tTwo: Count is 22095354
tOne: Count is 104408141

The whole concurrency is about keeping the data isolated from one Thread to another. We ended the interview section as the conversation showed several vital elements of your concurrency knowledge. You successfully demonstrated mastery of the difference between passing reference for primitive and object variables, ways for synchronizing threads and how to show and estimate concurrent output.

The interview might continue, and the interviewer might challenge you to fix the issues. So formalize the problem with the current solution and figure out how to fix the current situation and isolate the internal state of the wrapper.

Passing object and isolating its internal state

How can we isolate the internal state? How to secure the synchronization of internal variables?

The question is now, thus, how we can fix the current situation. There are several mechanisms in Java to keep the inner state concurrent. It would be worth telling about each of them in a separate article. But you might start discussing each Java concurrency mechanism with the interviewer, how it can fix the code, and what the output will be.

Let's show one way to fix the issue, which will be through the use of Locks.

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Main {
    public static void main(String[] args) throws InterruptedException {
        Wrapper wrapper = new Wrapper(0);
        TOne tOne = new TOne(wrapper);
        TTwo tTwo = new TTwo(wrapper);
        tOne.start();
        tTwo.start();
        // tOne.join();
        // tTwo.join();
        System.out.println("Final count: " + wrapper.printCount());
    }
}

class TOne extends Thread {
    private Wrapper wrapper;

    public TOne(Wrapper wrapper) {
        this.wrapper = wrapper;
    }

    public void run() {
        this.wrapper.getLock();
        try {
            for (int i = 0; i < 100_000_000; i++) {
                this.wrapper.increment();
            }
        } finally {
            this.wrapper.unlock();
        }
        System.out.println("tOne: Count is " + this.wrapper.printCount());
    }
}

class TTwo extends Thread {
    private Wrapper wrapper;

    public TTwo(Wrapper wrapper) {
        this.wrapper = wrapper;
    }

    public void run() {
        this.wrapper.getLock();
        try {
            for (int i = 0; i < 20_000_000; i++) {
                this.wrapper.increment();
            }
        } finally {
            this.wrapper.unlock();
        }
        System.out.println("tTwo: Count is " + this.wrapper.printCount());
    }
}

class Wrapper {
    private Integer count;
    private Lock lock;

    public Wrapper(Integer count) {
        this.count = count;
        this.lock = new ReentrantLock();
    }

    public void getLock() {
        lock.lock();
    }

    public void unlock() {
        lock.unlock();
    }

    public void increment() {
        this.count++;
    }

    public Integer printCount() {
        return this.count;
    }
}

If you choose not to use join() methods for both threads, the main Java thread will execute first and will leave the two other threads running in parallel. The output will be like this:

Final count: 0
tOne: Count is 100000000
tTwo: Count is 120000000

However, if you decide to use join() method, the output will be as follows:

tOne: Count is 100000000
tTwo: Count is 120000000
Final count: 120000000

Conclusion

As said before, the whole concept of concurrency is about keeping the data isolated from one Thread to another. You can use this conversation to prepare for an interview for your understanding of concurrent mechanisms. But the successful demonstration of concepts demonstrated your knowledge of the difference between passing reference for primitive variables and object variables, ways for synchronizing threads and how to show and estimate concurrent output.

Don't come only with answers to the interviewers' questions. Try to come also with solutions to problems and pitfalls of concurrency.

And for interviewers, there are several alternatives of how the interview conversation might go between you and the candidate. Suppose this conversation about concurrency inspires you. In that case, you might challenge the candidate to come up with different solutions, can for example, obey using a wrapper and instead focus on handling the situation with volatile or synchronization keyword.

What is NumberFormatException

The NumberFormatException is an unchecked Java exception which happens when there is incorrect string input converted to a numeric value. When the input is wrong, NumberFormatException is thrown to inform the user that the conversion requires a correct input and the transformation did not happen. For example, the NumberFormatException is thrown when a numerical string is parsed to an integer, but the string contains also space.

As the NumberFormatException is an unchecked exception, it does not need to be declared in the throws clause of a method or constructor. However, when in doubt of input correctness, it should be handled in code using a try-catch block.

NumberFormatException Example

Let’s take a look at the simple example of NumberFormatException being thrown:

public class NumberFormatExceptionExample {
    public static void main(String args[]) {
        int orderNumber = Integer.parseInt("Order 66");
        System.out.println(orderNumber);
    }
}

The above code will throw NumberFormatException. While pure input of string “66” is a valid input, a string with non-numerical characters like “Order 66” is unsuitable for creating a number.

Exception in thread "main" java.lang.NumberFormatException: For input string: "Order 66"
    at java.base/java.lang.NumberFormatException.forInputString(NumberFormatException.java:65)
	at java.base/java.lang.Integer.parseInt(Integer.java:652)
	at java.base/java.lang.Integer.parseInt(Integer.java:770)
    at NumberFormatExceptionExample.main(NumberFormatExceptionExample.java:6)

8 Different Ways How To Get NumberFormatException

There are various causes for throwing NumberFormatException, and the improper conversion of invalid input mainly causes them. Here is a list of different ways how to get NumberFormatException:

1. Input string is empty:

Integer.parseInt("");

2. Input string is null:

Integer.parseInt(null);

3. Input string with non-numeric data:

This case has several different options why it can happen.

a. Input string contains space character:

Integer.parseInt("66 66");

b. Input string contains non-numeric character:

Integer.parseInt("Sixty");

c. Numeric input with non-numeric character in input string

Integer.parseInt("Catch22");

4. Input string with inappropriate symbols in it:

Double.parseDouble("66,12345");

5. Input string with leading or tailing white space

Integer randomExample = new Integer("  12345  ");

Integer, Long, Short, Byte throw NumberFormatException; Double, Float does not.

6. Mismatch of data type between input string and the target data type

Integer.parseInt("12.34");

7. Input string exceeding the range of the target data type

Integer.parseInt("2147483648");

The example shown above is a case of NumberFormatException upon placing a numeric input string exceeding the range of the target data type, which is in our case Integer class object. The maximum range for Integer class object is from -2_147_483_648 to 2_147_483_647.

How to handle NumberFormatException

The NumberFormatException is an unchecked exception in Java. Therefore it can be handled as any other Java exception by wrapping critical code to try-catch block.

Look at the following example of catching NumberFormatException with a try-catch block:

public class NumberFormatExceptionExample {

    public static void main(String args[]) {
        String userInput = "Order 66";
        Optional<Integer> orderNumber = processOrder(userInput);
        if (orderNumber.isPresent()) {
            System.out.println("Execute order " + orderNumber.get());
        } else {
            System.out.println("Unrecognized order number. Please try again.");
        }
    }

    public static Optional<Integer> processOrder(String userInput) {
        try {
            int order = Integer.parseInt(userInput);
            return Optional.of(order);
        } catch (NumberFormatException ex) {
            System.out.println("Order exception: Invalid user input!");
        }
        return Optional.empty();
    }

}

Depending on the requirements of the application, take necessary action. For example, log the exception with an appropriate message or return an empty Optional object if you are using at least Java 8. Like in the example above, wrapping the code in try-catch blocks allows the program to continue execution after the code throws the exception.

Output:

Order exception: Invalid user input!
Unrecognized order number. Please try again.

Conclusion

This article led us to explain what NumberFormatException and how to handle it. It also showed over seven different ways how the NumberFormatException can occur and how we can defensively take care of it.

Do you know NumberFormatException? In what case did it throw to you? Do you have your trick, or do you see another way how to handle NumberFormatException? Let us know in the comments below the article. We would like to hear your ideas and stories.

Using Character class

First option is to select a character from string with help of charAt() method and the character position; and use Character class static method isDigit() to return boolean value.

String movie = "101 dalmatians";
System.out.println(movie);
boolean result = Character.isDigit(movie.charAt(0));
System.out.println("Is first letter number? Answer: " + result)

The output will be:

101 dalmatians
Is first letter number? true

If we want to check if several characters are numbers, we can place the isDigit() method call inside the loop.

String movie = "101 dalmatians";
for (int i = 0; i <= movie.length() - 1; i++) {
    System.out.println(movie.charAt(i) + " -> " + Character.isDigit(movie.charAt(i)));
}

The output of the above code will be:

1 -> true
0 -> true
1 -> true
  -> false
d -> false
a -> false
l -> false
m -> false
a -> false
t -> false
i -> false
a -> false
n -> false
s -> false

Using Unicode check

Using Character class static method isDigit() can be used on any Unicode character, not just 0-9 number range. You can use create number check at any Unicode character.

Here is an example of checking a number through a check of Unicode characters:

String movie = "101 dalmatians";
System.out.println(movie);
boolean char c = word.charAt(0);
boolean isDigit = (c >= '0' && c <= '9');
System.out.println(isDigit)

101 dalmatians
true

Using Regex

Alternative way to using Character class static method isDigit() is to use solution based on regex output. However, this will require string to be instance of String class as we can conduct regex pattern search only on String.

Let us show you first regex pattern for searching digit in substring of length 1 on the instance String class named word:

word.substring(0, 1).matches("\\d")

The alternative and equivalent version uses the regex search pattern with the search of digit range.

word.substring(0, 1).matches("[0-9]")

The regex solution should be discouraged as it is an over-engineered solution. While there might be a minor performance hit, we can argue it would not affect simple coding solutions. But be aware that regex brings complexity. A solution implementing regular expression should be used with caution and with a fair amount of tests.

Note: Regular expressions are very strong, but expensive tool. It is valid to use regular expressions for character check if, e.g. the first character is a digit. But performance-wise, it is also like shooting birds with cannon.

Using casting

The last way to check if the character in a string is a number is to use Java casting feature. We will cast string values into one of the numerical object classes. However, this is the worst way how to do it. If you find a code using casting, you should refactor it immediately.

public boolean isNumber(String word) {
    boolean isNumber = true;
    try {
        Integer.valueOf(word.substring(0,1));
    } catch (Exception e) {
        isNumber = false;
    }
    return isNumber;
}

There is a lot that can go wrong with the method above. If the entering argument word is an empty string, casting will throw NumberFormatException and catch it. If the first character is not a digit, e.g. letter or special symbol, casting will also throw NumberFormatException and catch it. But if the first character is a digit, it will return true.

You can place any numerical object class to the code such as Integer, Double, Float or Long. But please do not! Using casting with valueOf() method is wrong for two reason:

• In general, we want to avoid throwing Exceptions, checked or unchecked, as they slow the program and have tremendous performance hit.
• Second reason, we can see above at least 3 different ways which provide shorter, more effective and readable way for solving the same problem.

Conclusion

In the article, we have demonstrated four different ways to find out if the single character or characters from a string is a number or not. The solutions ranged from best to worst, from easiest to most cumbersome. Use as much as possible the first option which use Character class static method isDigit() for determining if the character is a string. Using isDigit() method is, without instantiation of any variables, the most effective and readable solution.

I hope you learned something new and had fun. Thanks for the reading. And if you have any tricks or know a better way how to find out if the character is a string, let us know in the comments below. We would like to hear your ideas.

Developer notes will be an irregular series of articles where I will briefly go through some of my notes to make notes for posterity. The notes themself can be pretty long, yet their length is not enough for writing a meaningful article.

Let’s take a look at a list of content:

• Oracle Error: Value Larger Than Specified Precision Allowed For This Column
• Switch on String with Enum Name in Java 8
• Lombok’s serialization error for Jackson
• Interpunct
• How To Do curl in Postman

Oracle Error: Value Larger Than Specified Precision Allowed For This Column

I was getting errors on inserting data into the Oracle database “ORA-01438: value larger than specified precision allowed for this column.”

The reason why I was getting an error was a too big number. When I looked over UI to database column definition, I saw something like this NUMBER(15,2).

Official Oracle documentation, as for Oracle database v21, depicts NUMBER datatype defined as NUMBER (precision,scale).

NUMBER datatype notation can be rather rewritten to NUMBER (size,precision)) where the first number depicts the total size of the digits in a number, and the second means the decimal point scale.

In other words, for example, for NUMBER(2,2), we can place the column number consisting of 2 digits, both of which will be decimals. i.e. 0.15, 0.45 etc. But if we would like to have a bigger number in the column, we need to upgrade the size of the column reserved for the whole number – NUMBER(5,2) will get us five digits, of which 2 are decimals. i.e 125.40, 18.00.

Switch on String with Enum Name in Java 8

Here is an example of how to use Enum values as strings in a switch case. You can only use the strings which are known at compile time. The compiler cannot determine the result of expression. However, in Java Enum case VALUE1, VALUE2 are static.

String name = ...
switch(CustomEnum.valueOf(name)) {
   case VALUE1:
        ...
        break;
   case VALUE2:
        ...
        break;
    ...
}

Lombok’s serialization error for Jackson

When I created a new aggregated DTO class on my REST output, I got the following error:

Type definition error: [simple type, class CUSTOM_DTO_CLASS_NAME]; nested exception is com.fasterxml.jackson.databind.exc.InvalidDefinitionException: No serializer found for class CUSTOM_DTO_CLASS_NAME and no properties discovered to create BeanSerializer (to avoid exception, disable SerializationFeature.FAIL_ON_EMPTY_BEANS) (through reference chain: CUSTOM_DTO_CLASS_NAME[\"aggregation-class-property\"]->java.util.ArrayList[0])

I am sure this error will be thrown quiet often as the solution on it is very simple. All I was missing on my Custom DTO class was Lombok’s @Getters annotation for serialization. So fix consisted on adding missing @Getters annotation on the top of my custom class for Lombok generating getter methods at compile time.

Interpunct

I was editing my resume this month and wanted to create a nice date range in positions I held in the past. I got this from my LinkedIn profile, where LinkedIn use dates in the form as Jan 2020 – Feb 2020 · 2 mos. But I could not figure out where to take the dot sign as it was an image. However, the character for such sign as little black dot · really exists and its name is Interpunct, or middle dot. So every time you would like to create a nice division of text with the help of ·, think about the Interpunct.

How To Do curl in Postman

Is there a way hot to make a curl command in Postman? What if we would like to import the curl command easily into Postman and make a Postman GUI request from it.
Is it even possible to easily translate all the curl command parameters into the Postman request?

Surely it is. Postman request are eventually nothing else than more fancy curl requests and Postman supports the curl import feature. Importing curl is very simple. Here is simple list of steps which will lead you to success:

1. Open Postman.
2. Go to navigation menu, click File and Import option
3. In Import window select the raw text tab.
4. Paste the raw text e.g. curl --location --request GET "https://www.google.com/", then click continue.
5. Check the name, format and import as.
6. If everything is correct, click Import button.

Following the steps will automatically import the curl command into the Postman on the new tab.

Introduction

I have been recently doing code review on other developer pull-request when I found the piece of code below:

private static final String DOCUMENT_VERSION = "document_version-";

public String getDocumentVersion(int version) {
    String documentVersion = "";
    if (version > 999) {
        throw new IllegalStateException("Version number " + version + " is too large.");
    } else if (version > 99) {
        documentVersion += version;
    } else if (version > 9) {
        documentVersion += "0" + version;
    } else {
        documentVersion += "00" + version;
    }

    return "DOCUMENT_VERSION_" + documentVersion;
}

As you can immediately see, the code is bad and can be surely rewritten to something more simple. Creating a string from a number can not be so declarative, right? There needs to be a simpler way how to do it. And surely it can. Like many other general-purpose programming languages, Java has multiple libraries and functions for processing text. String class itself has a static method format() which can be fully utilized on the text changes like this.

Java String format()

The Java String class format() method returns the formatted string. Let’s look little bit on parameters of format() method.

String.format() signature

There are two type of String format() method:

public static String format(String format, Object... args)

and

public static String format(Locale locale, String format, Object... args)  

Therefore, method parameters are described as:

• locale is specifies the locale to be applied on the format() method.
• format is format of the string.
• args represent arguments for the format string. It may be zero or more.

format() method returns new String. However, it is also good to be prepared for possibility of two unchecked exception:

• NullPointerException is thrown if format is null.
• IllegalFormatException is thrown if format is illegal or incompatible.

String.format() internal implementation

In reality, String.format() method allows usage of multiple Object arguments because internal implementation use nothing else than new instance of Formatter class.

public static String format(String format, Object... args) {
    return new Formatter().format(format, args).toString();
}

Usage of quiet Formatter class explains why we can take multiple arguments depending on the number of elements we want to format inside the string. Formatter class can use several different option of “%” character combination in order to define string formatting. In the table below are all options explained:

format() examples

Let us show you few tricks with format()

System.out.println(String.format("%d", 100)); // Integer
System.out.println(String.format("%s", "Anna Smith")); // String
System.out.println(String.format("%f", 42.42)); // Float
System.out.println(String.format("%x", 100)); // Hexadecimal
System.out.println(String.format("%c", 'a')); // Char
System.out.println("-----");
System.out.println(String.format("number with text: %d", 100)); // number with other text
System.out.println(String.format("%f", 42.12345)); // prints floating number
System.out.println(String.format("%10.10f", 42.12345)); // prints 10 digits for fractions padded with 0
System.out.println("-----");
System.out.println(String.format("|<-%10d->|", 222)); // Align right, padding with empty space
System.out.println(String.format("|<-%-10d->|", 555)); // Align left, padding with empty space
System.out.println(String.format("|<-% d->|", 777)); // Single space between % and conversion type is allowed
System.out.println(String.format("|<-%010d->|", 999)); // Filling space with zeros

100
Anna Smith
42.420000
64
a
-----
number with text: 100
42.123450
42.1234500000
-----
|<-       222->|
|<-555       ->|
|<- 777->|
|<-0000000999->|

Using format() to turn number into formatted string

To take for first exemplary code from code review, all what we needed to do in getDocumentVersion() method was to place custom format of string into the String class format method.

private static final String DOCUMENT_VERSION = "document_version-";

public String getDocumentVersion(int version) {
    return String.format(DOCUMENT_VERSION + "%03d", revisionNumber);
}

If we place number 1 into the method getDocumentVersion() we will get the same result as boilerplate code from code review:

Output

document_version-001

We can still quickly write some custom code to test our beliefs. But be thorough and do not forget edge cases as zero and negative numbers.

System.out.println(String.format("%03d", 999));
System.out.println(String.format("%03d", 99));
System.out.println(String.format("%03d", 9));
System.out.println(String.format("%03d", 0));
System.out.println(String.format("%03d", -9));

999
099
009
000
-09

As you can notice format() takes negative number into account its length with minus sign.

Note : If you have any crazy idea how to use format() method, let us know in comments below.

Conclusion

This article showed us how to turn a number into a string with a specific length where additional space is padded.

Did you find the String.format() method useful? Do you have your trick, or do you know another way how to turn a number into a string of specific length? Let us know in the comments below the article. We would like to hear your ideas and stories.