DEV Community: Yegor Voronianskii

Spring Boot & JOOQ | Getting started

Yegor Voronianskii — Wed, 03 Jan 2024 11:37:31 +0000

This article will show how to use jOOQ in your spring boot projects.

Why do we need jOOQ?
There is a lot of pain using JPA and Hibernate. That is why we have something jOOQ.

First, we need to create a database schema. In this article, we will develop a simple CRUD (create, read, update, and delete) application to manage goods.

The first step is to design our database. The application will contain only one table — goods. The table looks like below.

This code of ERD above, I have created within Mermaid.

erDiagram
    GOODS {
        id uuid pk "ID"
        name string "The name of good"
        price numeric "The price of good"
        total_count int "The total count of good"
        sold_count int "The sold count of good"
        deleted bool "The flag indicated that good was deleted"
    }

The next step is to create a Spring Boot Maven Project, but you can choose Gradle; it is up to you.

Let’s create a migration to the init schema of our database. I will use YAML syntax, but with Liquibase, you can choose between plain SQL, JSON, and YAML.

databaseChangeLog:
  - changeSet:
      id: init-schema
      author: Egor Voronianskii
      changes:
        - createTable:
            tableName: GOODS
            columns:
              - column:
                  name: id
                  type: UUID
                  constraints:
                    primaryKey: true
                    nullable: false
              - column:
                  name: name
                  type: VARCHAR(255)
                  constraints:
                    nullable: false
              - column:
                  name: price
                  type: numeric
              - column:
                  name: total_count
                  type: integer
              - column:
                  name: sold_count
                  type: integer
              - column:
                  name: deleted
                  type: boolean

I have the following structure in the project.

I have the following structure in the project. There are two folders — one for data definition language and the second for data management language.

Inside the changelog.yml, I specified where the migrations folder is located.

databaseChangeLog:
  - includeAll:
      path: db/migrations/ddl

Let’s configure our application to use the right changelog.

spring:
  datasource:
    url: jdbc:postgresql://localhost:5432/goods_db
    username: postgres
    password: 55555
  liquibase:
    change-log: classpath:db/changelog.yml

Before starting the app, ensure you have created a database.

The next step is to add a jOOQ plugin to generate code from the database. Here is my updated build section of pom.xml.

    <build>
        <plugins>
            <plugin>
                <groupId>org.jooq</groupId>
                <artifactId>jooq-codegen-maven</artifactId>
                <dependencies>
                    <dependency>
                        <groupId>org.postgresql</groupId>
                        <artifactId>postgresql</artifactId>
                        <version>42.6.0</version>
                    </dependency>
                </dependencies>
                <configuration>
                    <jdbc>
                        <driver>org.postgresql.Driver</driver>
                        <url>jdbc:postgresql://localhost:5432/goods_db</url>
                        <user>postgres</user>
                        <password>55555</password>
                    </jdbc>
                    <generator>
                        <name>org.jooq.codegen.JavaGenerator</name>
                        <database>
                            <excludes>databasechangelog|databasechangeloglock</excludes>
                        </database>
                    </generator>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <excludes>
                        <exclude>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok</artifactId>
                        </exclude>
                    </excludes>
                </configuration>
            </plugin>
        </plugins>
    </build>

As you may see, I must configure the database connection again and exclude tables Liquibase creates.

Now, run the plugin; you can do it from the terminal or the IDE.

After successfully running the plugin, you should see the generated classes in the target folder.

At the start of the article, I forgot to add the Spring Boot Web starter; let’s add it to pom.xml.

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

We must create a data transfer object before moving to the write service and controller layer. You may agree or disagree with me. However, having a different object unrelated to the database entity is better.

package io.vrnsky.jooqdemo.dto;

import java.math.BigDecimal;
import java.util.UUID;

public record Goods(
        UUID id,
        String name,
        BigDecimal price,
        Integer totalCount,
        Integer soldCount,
        boolean deleted
) {
}

The next step is to implement the service layer of our app.

package io.vrnsky.jooqdemo.service;

import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.jooq.DSLContext;
import org.jooq.generated.public_.tables.Goods;
import org.springframework.stereotype.Service;
import org.springframework.util.Assert;

import java.util.UUID;

@Slf4j
@Service
@RequiredArgsConstructor
public class GoodsService {

    private final DSLContext dslContext;

    public io.vrnsky.jooqdemo.dto.Goods create(io.vrnsky.jooqdemo.dto.Goods goods) {
        var id = UUID.randomUUID();
        var result = dslContext.insertInto(Goods.GOODS)
                .values(id, goods.name(), goods.price(), goods.totalCount(), goods.soldCount(), goods.deleted())
                .execute();
        log.info("Inserted with result: {}", result);
        return getById(id);
    }

    public io.vrnsky.jooqdemo.dto.Goods update(io.vrnsky.jooqdemo.dto.Goods goods) {
        var updated = dslContext.update(Goods.GOODS)
                .set(Goods.GOODS.ID, goods.id())
                .set(Goods.GOODS.NAME, goods.name())
                .set(Goods.GOODS.PRICE, goods.price())
                .set(Goods.GOODS.SOLD_COUNT, goods.soldCount())
                .set(Goods.GOODS.TOTAL_COUNT, goods.totalCount())
                .set(Goods.GOODS.DELETED, goods.deleted())
                .execute();
        log.info("Successfully updated {} rows", updated);
        return this.getById(goods.id());
    }

    public io.vrnsky.jooqdemo.dto.Goods getById(UUID id) {
        final var fetchedRecord = dslContext.select(
                        Goods.GOODS.ID, Goods.GOODS.NAME, Goods.GOODS.PRICE,
                        Goods.GOODS.SOLD_COUNT, Goods.GOODS.TOTAL_COUNT, Goods.GOODS.DELETED
                )
                .from(Goods.GOODS)
                .where(Goods.GOODS.ID.eq(id))
                .fetchOne();
        Assert.notNull(fetchedRecord, "Record with id = " + id + " is not exists");
        return new io.vrnsky.jooqdemo.dto.Goods(
                fetchedRecord.get(Goods.GOODS.ID),
                fetchedRecord.get(Goods.GOODS.NAME),
                fetchedRecord.get(Goods.GOODS.PRICE),
                fetchedRecord.get(Goods.GOODS.SOLD_COUNT),
                fetchedRecord.get(Goods.GOODS.TOTAL_COUNT),
                fetchedRecord.get(Goods.GOODS.DELETED)
        );
    }

    public void delete(UUID id) {
        dslContext.update(Goods.GOODS).
                set(Goods.GOODS.DELETED, true)
                .where(Goods.GOODS.ID.eq(id))
                .execute();

        log.info("Successfully deleted the good with id = [" + id + "]");
    }
}

It is time to create a controller layer to test our application.

package io.vrnsky.jooqdemo;

import io.vrnsky.jooqdemo.dto.Goods;
import io.vrnsky.jooqdemo.service.GoodsService;
import lombok.RequiredArgsConstructor;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;

import java.util.UUID;

@RestController
@RequiredArgsConstructor
public class GoodsController {

    private final GoodsService goodsService;

    @PostMapping("/create")
    public Goods create(@RequestBody Goods goods) {
        goodsService.create(goods);
    }

    @GetMapping("/{id}")
    public Goods getById(@PathVariable UUID id) {
        goodsService.getById(id);
    }

    @PutMapping("/update")
    public Goods update(@RequestBody Goods goods) {
        goodsService.update(goods);
    }

    @DeleteMapping("/delete/{id}")
    public void delete(@PathVariable UUID id) {
        goodsService.delete(id);
    }

}

I will add Spring Doc dependencies and document controller methods to make the testing process more accessible. This type of testing is manual and the better approach to writing unit tests.

   <dependency>
      <groupId>org.springdoc</groupId>
      <artifactId>springdoc-openapi-starter-webmvc-ui</artifactId>
      <version>2.3.0</version>
   </dependency>

Here is the updated version of the controller class.

package io.vrnsky.jooqdemo;

import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.tags.Tag;
import io.vrnsky.jooqdemo.dto.Goods;
import io.vrnsky.jooqdemo.service.GoodsService;
import lombok.RequiredArgsConstructor;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;

import java.util.UUID;

@RestController
@RequiredArgsConstructor
@Tag(name = "GoodsController", description = "Operations with goods")
public class GoodsController {

    private final GoodsService goodsService;

    @Operation(summary = "Creation of goods")
    @PostMapping("/create")
    public Goods create(@RequestBody Goods goods) {
        return goodsService.create(goods);
    }

    @Operation(summary = "Get goods by id")
    @GetMapping("/{id}")
    public Goods getById(@PathVariable UUID id) {
        return goodsService.getById(id);
    }

    @Operation(summary = "Update goods")
    @PutMapping("/update")
    public Goods update(@RequestBody Goods goods) {
        return goodsService.update(goods);
    }

    @Operation(summary = "Delete by id")
    @DeleteMapping("/delete/{id}")
    public void delete(@PathVariable UUID id) {
        goodsService.delete(id);
    }

}

Now, we can run the application and try to perform CRUD operations.

Conclusion

It is my first time using a jOOQ; I cannot say that I’m going to use it at this moment at my job. My experience with jOOQ is relatively tiny. In my honest opinion, jOOQ would be a better approach if the application business logic requires very complex SQL queries. Meanwhile, the Spring JPA and Hibernate simplify the work with the database. So, choose carefully the tool that you would like to use. Compare the pros and cons of each tool before starting to use it.

One more thing: You may raise an opinion that Goods is terrible naming, and I agree with you, but at the moment, I have been struggling to choose a domain field for this article.

Please feel free to give any comments if you have any. Share your experience with jOOQ in the comments.

References

JUnit 5 | How to write more tests with less code

Yegor Voronianskii — Sun, 31 Dec 2023 09:57:54 +0000

Introduction

In this article, I will show and explain how you can write more tests with relatively small changes in your code.

Recently, one of my colleagues wrote a massive test with repetitive code. The difference between test cases was only data that was submitted to the service. I will use JUnit 5 in this article, but feel free to check the library docs you use for writing tests.

Problem

Let’s imagine the following situation: we have a service that accepts the following data and returns the following response.

{
  "operationType": "+",
  "operands": [
    1,
    2,
    3,
    4,
    5
  ]
}

{
  "result": 15
}

Of course, we can write many tests to cover each aspect, but there is a better solution. Let me introduce to you TestFactory from JUnit 5. You may argue that artificial cases use a test factory, and I agree with you, but the article is designed to give you an idea of how you can achieve more tests without writing more code.

Let’s implement our data transfer object first.

package io.vrnsky.testfactorydemo.dto;

import java.util.List;

public record Request(
        String operationType,
        List<Integer> operands
) {
}

package io.vrnsky.testfactorydemo.dto;

public record Response(
        Integer result
) {
}

The next step is to implement service and controller layers.

package io.vrnsky.testfactorydemo.service;

import io.vrnsky.testfactorydemo.dto.Request;
import io.vrnsky.testfactorydemo.dto.Response;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class CalculationService {

    public Response calculate(Request request) {
        return switch (request.operationType()) {
            case "+" -> new Response(sum(request.operands()));
            case "*" -> new Response(multiply(request.operands()));
            default -> throw new IllegalArgumentException("Invalid operation: " + request.operationType());
        };
    }

    private int sum(List<Integer> operands) {
        if (operands == null || operands.isEmpty()) {
            return 0;
        }
        return operands.stream().mapToInt(i -> i).sum();
    }

    private int multiply(List<Integer> operands) {
        if (operands == null || operands.isEmpty()) {
            return 0;
        }
        int result = 1;
        for (Integer operand : operands) {
            result *= operand;
        }
        return result;
    }

}

package io.vrnsky.testfactorydemo.controller;

import io.vrnsky.testfactorydemo.dto.Request;
import io.vrnsky.testfactorydemo.dto.Response;
import io.vrnsky.testfactorydemo.service.CalculationService;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class CalculateController {

    private final CalculationService calculationService;

    public CalculateController(CalculationService calculationService) {
        this.calculationService = calculationService;
    }

    @PostMapping("/calculate")
    public Response calculate(@RequestBody Request request) {
        return calculationService.calculate(request);
    }
}

The controller is not required; we can test only the service layer. I have implemented a controller to test manually that the application is working. Manual testing is a bad thing because it cannot be automated.

curl -X POST "http://localhost:8080/calculate" -H "Content-type:application/json" -d '{"operationType": "+", "operands": [1, 2, 3]}' 
{"result":6}%

curl -X POST "http://localhost:8080/calculate" -H "Content-type:application/json" -d '{"operationType": "+", "operands": []}'        
{"result":0}

Okay, now it is what you have been waiting for — let’s write a unit test with TestFactory. But before implementing, let’s create two folders inside the test resource directory.

In the files, I have a request and response as follows.

{"operationType": "+", "operands": [1, 2, 3]}

{"result":6}

The next step is to implement a test factory within the unit test.

package io.vrnsky.testfactorydemo.service;

import com.fasterxml.jackson.databind.ObjectMapper;
import io.vrnsky.testfactorydemo.dto.Request;
import io.vrnsky.testfactorydemo.dto.Response;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.DynamicTest;
import org.junit.jupiter.api.TestFactory;

import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.Collections;
import java.util.List;
import java.util.stream.Stream;

class CalculationServiceTest {

    private static final ObjectMapper OBJECT_MAPPER = new ObjectMapper();
    private static final CalculationService CALCULATION_SERVICE = new CalculationService();

    @TestFactory
    Stream<DynamicTest> testCalculateService() {
        int counter = 0;
        List<Stream<DynamicTest>> test = Collections.singletonList(generateTest("(+)", counter++, "request/1.json", "response/1.json"));
        return test
                .stream()
                .flatMap(stream -> stream);
    }

    private Stream<DynamicTest> generateTest(String tag, int counter, String requestPath, String responsePath) {
        return Stream.of(createTest(tag, counter, requestPath, responsePath));
    }

    private DynamicTest createTest(String tag, int counter, String requestPath, String responsePath) {
        return DynamicTest.dynamicTest(tag + " | Calculation test case #" + counter, () -> {
            var request = this.getRequest(requestPath);
            var expected = this.getResponse(responsePath);
            var actual = CALCULATION_SERVICE.calculate(request);
            Assertions.assertEquals(expected.result(), actual.result());
        });
    }

    private Request getRequest(String path) {
        try {
            byte[] content = Files.readAllBytes(Paths.get(CalculationServiceTest.class.getClassLoader().getResource(path).getPath()));
            return OBJECT_MAPPER.readValue(new String(content, StandardCharsets.UTF_8), Request.class);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    private Response getResponse(String path) {
        try {
            byte[] content = Files.readAllBytes(Paths.get(CalculationServiceTest.class.getClassLoader().getResource(path).getPath()));
            return OBJECT_MAPPER.readValue(new String(content, StandardCharsets.UTF_8), Response.class);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }


}

Let me explain what is going on inside this class.

First, we have a public method annotated with TestFactory annotation, which the testing framework will run. The other parts of the helper method achieve the following things:

Read requests from the test resource folder
Read the expected response from the test resource folder
Creation of dynamic test

For now, I have created files for only one unit test. You can add your own if you would like.
I have added two more files to test other inputs.

The article’s title tells you that you can write less code and achieve more test coverage. It is true, but you still need to change something. You need to add a new request-response pair.

Here is an updated version of the method annotated by the TestFactory annotation.

    @TestFactory
    Stream<DynamicTest> testCalculateService() {
        int counter = 0;
        List<Stream<DynamicTest>> test = Arrays.asList(
                generateTest("(+)", counter++, "request/1.json", "response/1.json"),
                generateTest("(+)", counter++, "request/2.json", "response/2.json"),
                generateTest("(+)", counter++, "request/3.json", "response/3.json")
        );
        return test
                .stream()
                .flatMap(stream -> stream);
    }

Now, you can run your tests and will see something similar.

The code could be better. There is always a place to improve something. For example, one thing you do is to read all files in the directory instead of hard-coding it. By doing this, you can achieve a minimal change in code only by adding files.

Conclusion

You may disagree with my point of view, but less code means fewer bugs in the code. Sometimes, using TestFactory is not a good choice, but it is a good choice when you have something to test, and the logic of the service is complex. The other reason behind choosing TestFactory is a lot of parameters that impact the results of something. Recently, I faced a request with a lot of parameters. The response is hard depending on the request data, so I have stuck with the test factory choice.

References

JUnit 5 docs

Spring Cloud Functions, Kafka | How to interact asynchronous

Yegor Voronianskii — Sun, 24 Dec 2023 10:10:51 +0000

Introduction

This article will show how to use the Spring Cloud Functions projects. The Spring Cloud Functions is the best approach to implementing a straightforward business logic.
Nowadays, the usage of message brokers such as Kafka has increased.
I will implement a simple system in this article, as shown below.

Implementation

I will start with a simple example of a cloud function, which is the same as a rest endpoint in the classical spring boot web application. You can create a project from your favorite IDE or from Spring Initliazr.

<?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>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>3.2.1</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>io.vrnsky</groupId>
    <artifactId>cloud-function-push</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>cloud-function-push</name>
    <description>cloud-function-push</description>
    <properties>
        <java.version>17</java.version>
        <spring-cloud.version>2023.0.0</spring-cloud.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-function-context</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-function-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>${spring-cloud.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

Your pom.xml file or build.gradle should like this.

The first step is to describe events related to service. I will stick with the following definition of an event.

package io.vrnsky.cloudfunctionpush.domain;

import java.util.List;

public record PullRequestAccepted(
        String author,
        List<String> reviewers,

        boolean havePassedAllChecks
) {
}

The first step is to describe events related to service. I will stick with the following definition of an event.
The second step is to create a configuration class within the bean function creation inside it.

package io.vrnsky.cloudfunctionpush.config;

import io.vrnsky.cloudfunctionpush.domain.PullRequestAccepted;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.function.Function;


@Configuration
public class FunctionConfig {

    @Bean
    public Function<PullRequestAccepted, String> pullRequestAccepted() {
        return value -> """
                Pull request from %s has been reviewed by %s. Have passed all checks: %b
                """
                .formatted(value.author(), value.reviewers().size(), value.havePassedAllChecks());
    }
}

It’s time to start our cloud function push service and check that it works correctly.

curl http://localhost:8080/pullRequestAccepted -H "Content-type:application/json" -d '{"author":"Yegor Voronianskii","reviewers":[],"havePassedAllChecks":true}'
Pull request from Yegor Voronianskii has been reviewed by 0. Have passed all checks: true

To achieve that, we must add the following dependencies to pom.xml or build.gradle

        <dependency>
            <groupId>org.apache.kafka</groupId>
            <artifactId>kafka-streams</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-stream</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-stream-binder-kafka</artifactId>
        </dependency>

Before starting the service, it is required to start Kafka and Zookeeper. Here is a docker-compose file to start both.

version: "3"
services:
  zookeeper:
    image: confluentinc/cp-zookeeper:latest
    environment:
      ZOOKEEPER_CLIENT_PORT: 2181
    ports:
      - "22181:2181"

  kafka:
    image: confluentinc/cp-kafka:latest
    depends_on:
      - zookeeper
    environment:
      KAFKA_ZOOKEEPER_CONNECT: zookeeper:2181
      KAFKA_ADVERTISED_LISTENERS: PLAINTEXT://localhost:9092,EXTERNAL://localhost:29092
      KAFKA_LISTENERS: PLAINTEXT://:9092,EXTERNAL://:29092
      KAFKA_LISTENER_SECURITY_PROTOCOL_MAP: PLAINTEXT:PLAINTEXT,EXTERNAL:PLAINTEXT
      KAFKA_INTER_BROKER_LISTENER_NAME: PLAINTEXT
      KAFKA_OFFSETS_TOPIC_REPLICATION_FACTOR: 1
    ports:
      - "9092:9092"
      - "29092:29092"

You can start Kafka and Zookeeper by following the command:

docker compose up

The next step it to configure our application and add some code. Here, you can see the updated version of the FunctionConfig class, where an instance of the stream bridge is injected. You can use Lombok for brevity. It is up to you.

package io.vrnsky.cloudfunctionpush.config;

import io.vrnsky.cloudfunctionpush.domain.PullRequestAccepted;
import org.springframework.cloud.stream.function.StreamBridge;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.function.Function;


@Configuration
public class FunctionConfig {

    private final StreamBridge streamBridge;

    public FunctionConfig(StreamBridge streamBridge) {
        this.streamBridge = streamBridge;
    }

    @Bean
    public Function<PullRequestAccepted, String> pullRequestAccepted() {
        return value -> {
            streamBridge.send("pullRequestAccepted-out-0", value);
            return "Message have been sent";
        };
    }
}

Below is the updated application configuration, where I specify the broker URL and other required settings.

spring:
  kafka:
    bootstrap-servers:
      - http://localhost:29092
  cloud:
    stream:
      kafka:
        binder:
          brokers:
            - http://localhost:29092
      output-bindings: pullRequestAccepted-out-0

logging:
  level:
    org.springframework.cloud.stream: TRACE

Now, we can check that the message has been sent to the broker.

curl http://localhost:8080/pullRequestAccepted -H "Content-type:application/json" -d '{"author":"Yegor Voronianskii","reviewers":[],"havePassedAllChecks":true}'
Message have been sent

In the cloud function push service, you should see something like this.

--- [nio-8080-exec-1] o.s.c.s.binder.DefaultBinderFactory      : Retrieving cached binder: kafka
--- [nio-8080-exec-1] o.s.c.s.m.DirectWithAttributesChannel    : preSend on channel 'bean 'pullRequestAccepted-out-0'', message: GenericMessage [payload=byte[73], headers={id=7c176f51-1a1a-63d9-b0ed-20cc1ce71fc8, contentType=application/json, target-protocol=kafka, timestamp=1703409370932}]
--- [nio-8080-exec-1] tractMessageChannelBinder$SendingHandler : org.springframework.cloud.stream.binder.AbstractMessageChannelBinder$SendingHandler@7d99be9b received message: GenericMessage [payload=byte[73], headers={id=7c176f51-1a1a-63d9-b0ed-20cc1ce71fc8, contentType=application/json, target-protocol=kafka, timestamp=1703409370932}]
--- [nio-8080-exec-1] nder$ProducerConfigurationMessageHandler : org.springframework.cloud.stream.binder.kafka.KafkaMessageChannelBinder$ProducerConfigurationMessageHandler@d36ee78 received message: GenericMessage [payload=byte[73], headers={id=d9ab9d27-fdf6-53a7-9db6-ae98e6130272, contentType=application/json, target-protocol=kafka, timestamp=1703409370933}]
--- [nio-8080-exec-1] nder$ProducerConfigurationMessageHandler : handler 'org.springframework.cloud.stream.binder.kafka.KafkaMessageChannelBinder$ProducerConfigurationMessageHandler@d36ee78' produced no reply for request Message: GenericMessage [payload=byte[73], headers={id=d9ab9d27-fdf6-53a7-9db6-ae98e6130272, contentType=application/json, target-protocol=kafka, timestamp=1703409370933}]
--- [nio-8080-exec-1] o.s.c.s.m.DirectWithAttributesChannel    : postSend (sent=true) on channel 'bean 'pullRequestAccepted-out-0'', message: GenericMessage [payload=byte[73], headers={id=7c176f51-1a1a-63d9-b0ed-20cc1ce71fc8, contentType=application/json, target-protocol=kafka, timestamp=1703409370932}]

The next step is implementing Spring Cloud Function to consume events from the message broker. The creation project’s steps are similar to those of the cloud push service. To configure our cloud pull service, we should have an application.properties or application.yml file with the following settings.

spring:
  kafka:
    bootstrap-servers:
      - http://localhost:29092
  cloud:
    function:
      definition: pullRequestAccepted
    stream:
      kafka:
        binder:
          brokers:
            - http://localhost:29092
      input-bindings: pullRequestAccepted-in-0
      bindings:
        pullRequestAccepted-in-0:
          destination: pullRequestAccepted-out-0
          group: myGroup
logging:
  level:
    org.springframework.cloud.stream: TRACE
server:
  port: 9090

To handle incoming messages, we have to define the consumer of this message. I stick with a simple solution that prints the message into standard output.

package com.example.cloudfunctionpull.config;

import com.example.cloudfunctionpull.domain.PullRequestAccepted;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.messaging.Message;

import java.util.function.Consumer;

@Configuration
public class FunctionsConfig {

    @Bean
    public Consumer<Message<PullRequestAccepted>> pullRequestAccepted() {
        return message -> {
            PullRequestAccepted payload = message.getPayload();
            System.out.println("Received message: " + payload);
        };
    }

    @Bean
    public Consumer<Message<?>> myErrorHandler() {
        return errorMessage -> {
            System.out.println("Handling error message " + errorMessage);
        };
    }
}

After a successful start of consuming the service, we can again push the message to the message broker and check that the message was consumed to pull the service.

kafka_consumer=org.springframework.kafka.core.DefaultKafkaConsumerFactory$ExtendedKafkaConsumer@1721c358, deliveryAttempt=1, kafka_timestampType=CREATE_TIME, kafka_receivedPartitionId=0, contentType=application/json, kafka_receivedTopic=pullRequestAccepted-out-0, kafka_receivedTimestamp=1703411981591, kafka_groupId=myGroup, target-protocol=kafka}]

Received message: PullRequestAccepted[author=Yegor Voronianskii, reviewers=[], havePassedAllChecks=true]

Conclusion

In my honest opinion, the Spring Cloud Function is a great tool for small, short-lived microservices. The Spring Cloud Stream is an excellent tool for building event-driven microservices architecture. But there are pros; of course, this project’s complexity can bring a lot of pain in terms of maintenance and understanding new paradigms.

References

Spring Boot Mutation testing with JUnit 5, Testcontainiers, and PIT

Yegor Voronianskii — Sat, 23 Dec 2023 10:58:44 +0000

What is mutation testing?

Mutation testing is a type of testing that validates new and existing tests. More formal definition from Wikipedia:

Mutation testing (or mutation analysis or program mutation) is used to design new software tests and evaluate the quality of existing software tests.

Why do we need mutation testing?

The problem that solves mutation testing is checking the validity of the existing and new tests. I often have met invalid unit tests that have covered only the happy path and no other paths.

When does it make sense for mutation testing?

So, if overall coverage is below 80%, you can skip mutation testing. You can return to mutation testing once you reach a threshold of 80% coverage.

How is mutation testing working?

The mutation testing itself is a form of white box testing. More or less mutation testing, trying to mutate or change your code and check that unit tests will fail.

The process of changing your code is called mutation. The mutation can be killed or survived during the test phase. The killed mutation is a good sign, notifying us that the unit tests caught the mutation and failed the unit test; on the other hand, if the mutation survived, that is a bad sign that the unit test did not die with code changes.

Implementation of mutation

First, we should add the following dependency on TestContainer for PostgreSQL.

In your pom.xml add following dependency.

  <dependency>
   <groupId>org.testcontainers</groupId>
   <artifactId>postgresql</artifactId>
   <scope>test</scope>
  </dependency>

The next step is to add a basic class test, which will be responsible for creating a PostgreSQL test container.

package io.vrnsky.mutationdemo;

import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.annotation.DirtiesContext;
import org.springframework.test.context.DynamicPropertyRegistry;
import org.springframework.test.context.DynamicPropertySource;
import org.testcontainers.containers.PostgreSQLContainer;
import org.testcontainers.junit.jupiter.Container;
import org.testcontainers.junit.jupiter.Testcontainers;

@Testcontainers
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
@DirtiesContext
public class DatabaseIntegrationTest {

    @Container
    public static PostgreSQLContainer<?> postgreSQLContainer = new PostgreSQLContainer<>()
            .withPassword("inmemory")
            .withUsername("inmemory");

    @DynamicPropertySource
    static void postgresqlProperties(DynamicPropertyRegistry registry) {
        registry.add("spring.datasource.url", postgreSQLContainer::getJdbcUrl);
        registry.add("spring.datasource.password", postgreSQLContainer::getPassword);
        registry.add("spring.datasource.username", postgreSQLContainer::getUsername);
        registry.add("spring.datasource.platform", () -> PostgreSQLContainer.NAME);
    }
}

Let’s implement some basic functionality — the basic CRUD application.
The project will be to manage the book entity.

package io.vrnsky.mutationdemo.entity;

import jakarta.persistence.Column;
import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.Id;
import jakarta.persistence.Table;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.time.LocalDate;
import java.util.UUID;

@Data
@Table(name = "BOOK")
@Entity
@AllArgsConstructor
@NoArgsConstructor
public class Book {

    @Id
    @GeneratedValue
    @Column(name = "ID")
    private UUID id;

    @Column(name = "AUTHOR")
    private String author;

    @Column(name = "ISBN")
    private String isbn;

    @Column(name = "PUBLISHED_DATE")
    private LocalDate publishedDate;

    @Column(name = "DELETED")
    private boolean deleted;
}

To manage an entity, you need to create an interface that extends the JPA Repository interface.

package io.vrnsky.mutationdemo.repository;

import io.vrnsky.mutationdemo.entity.Book;
import org.springframework.data.jpa.repository.JpaRepository;

import java.util.UUID;

public interface BookRepository extends JpaRepository<Book, UUID> {
}

According to the most used structure of spring boot services, we need two more layers — service and controller. Let’s implement that

package io.vrnsky.mutationdemo.service;

import io.vrnsky.mutationdemo.entity.Book;
import io.vrnsky.mutationdemo.repository.BookRepository;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;

import java.util.UUID;

@Slf4j
@Service
@RequiredArgsConstructor
public class BookService {

    private final BookRepository bookRepository;

    public Book create(Book book) {
        return bookRepository.save(book);
    }

    public Book getById(UUID bookId) {
        var book = bookRepository.findById(bookId);
        if (book.isEmpty()) {
            throw new RuntimeException();
        }
        return book.get();
    }

    public Book update(Book book) {
        var existingBook = bookRepository.findById(book.getId());
        if (existingBook.isEmpty()) {
            throw new RuntimeException();
        }
        return bookRepository.save(book);
    }

    public void delete(UUID bookId) {
        var existingBook = bookRepository.findById(bookId);
        if (existingBook.isEmpty()) {
            throw new RuntimeException();
        }

        existingBook.get().setDeleted(true);
        bookRepository.save(existingBook.get());
    }
}

As you can see, for now, we are using RuntimeException. It is a terrible practice. Sonar Qube also agrees with me. We will fix it later with custom runtime exceptions and controller advice.

BookController.java

package io.vrnsky.mutationdemo.controller;

import io.vrnsky.mutationdemo.entity.Book;
import io.vrnsky.mutationdemo.service.BookService;
import lombok.RequiredArgsConstructor;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;

import java.util.UUID;

@RestController
@RequiredArgsConstructor
public class BookController {

    private final BookService bookService;

    @PostMapping("/book")
    public Book create(@RequestBody Book book) {
        return bookService.create(book);
    }

    @GetMapping("/book/{bookId}")
    public Book getById(@PathVariable UUID bookId) {
        return bookService.getById(bookId);
    }

    @PutMapping("/book/{bookId}")
    public Book update(@RequestBody Book book) {
        return bookService.update(book);
    }

    @DeleteMapping("/{bookId}")
    public void delete(@PathVariable UUID bookId) {
        bookService.delete(bookId);
    }
}

There is one more thing that we also need to improve, which is added documentation to our controllers. We will do it later, and I will use SpringDoc for that.

package io.vrnsky.mutationdemo.controller;

import io.vrnsky.mutationdemo.entity.Book;
import io.vrnsky.mutationdemo.service.BookService;
import lombok.RequiredArgsConstructor;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;

import java.util.UUID;

@RestController
@RequiredArgsConstructor
public class BookController {

    private final BookService bookService;

    @PostMapping("/book")
    public Book create(@RequestBody Book book) {
        return bookService.create(book);
    }

    @GetMapping("/book/{bookId}")
    public Book getById(@PathVariable UUID bookId) {
        return bookService.getById(bookId);
    }

    @PutMapping("/book/{bookId}")
    public Book update(@RequestBody Book book) {
        return bookService.update(book);
    }

    @DeleteMapping("/{bookId}")
    public void delete(@PathVariable UUID bookId) {
        bookService.delete(bookId);
    }
}

It’s time to move on to write the unit test.

package io.vrnsky.mutationdemo.service;

import io.vrnsky.mutationdemo.DatabaseIntegrationTest;
import io.vrnsky.mutationdemo.entity.Book;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Tag;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;

import java.time.LocalDate;
import java.util.UUID;

class BookServiceTest extends DatabaseIntegrationTest {

    @Autowired
    private BookService bookService;

    @Test
    @DisplayName("Test case: Creation of book")
    @Tag("Positive")
    void testThatCreationOfBookWorksCorrectly() {
        var book = new Book(null, "John Doe", "123", LocalDate.now(), false);
        var createdBook = bookService.create(book);
        Assertions.assertNotNull(createdBook.getId());
        Assertions.assertEquals(createdBook.getAuthor(), book.getAuthor());
        Assertions.assertEquals(createdBook.getIsbn(), book.getIsbn());
        Assertions.assertEquals(createdBook.getPublishedDate(), book.getPublishedDate());
        Assertions.assertFalse(createdBook.isDeleted());
    }

    @Test
    @DisplayName("Test case: Update book")
    @Tag("positive")
    void testThatUpdateOfBookWorksCorrectly() {
        var book = new Book(null, "John Doe", "123", LocalDate.now(), false);
        var createdBook = bookService.create(book);
        createdBook.setDeleted(true);
        var updatedBook = bookService.update(createdBook);
        Assertions.assertTrue(updatedBook.isDeleted());
    }

    @Test
    @DisplayName("Test case: Get book by id")
    @Tag("Positive")
    void testThatGetBookByIdWorksCorrectly() {
        var book = new Book(null, "John Doe", "123", LocalDate.now(), false);
        var createdBook = bookService.create(book);
        var existingBook = bookService.getById(createdBook.getId());
        Assertions.assertNotNull(existingBook);
    }

    @Test
    @DisplayName("Test case: Delete book")
    @Tag("Positive")
    void testThatDeleteBookWorksCorrectly() {
        var book = new Book(null, "John Doe", "123", LocalDate.now(), false);
        var createdBook = bookService.create(book);
        bookService.delete(createdBook.getId());
        var deletedBook = bookService.getById(createdBook.getId());
        Assertions.assertTrue(deletedBook.isDeleted());
    }

    @Test
    @DisplayName("Test case: Update not existing book")
    @Tag("Negative")
    void testThatUpdateOfNotExistingBookThrowsException() {
        var book = new Book(null, "John Doe", "123", LocalDate.now(), false);
        Assertions.assertThrows(RuntimeException.class, () -> bookService.update(book));
    }

    @Test
    @DisplayName("Test case: Get by id not existing book")
    @Tag("Negative")
    void testThatGetByIdOfNotExistingBookThrowException() {
        var book = new Book(null, "John Doe", "123", LocalDate.now(), false);
        Assertions.assertThrows(RuntimeException.class, () -> bookService.update(book));
    }

    @Test
    @DisplayName("Test case: Deleting not existing book")
    void testThatDeletionOfNotExistingBookThrowsException() {
        Assertions.assertThrows(RuntimeException.class, () -> bookService.delete(UUID.randomUUID()));
    }
}

Now, let’s move to the controller layer.

package io.vrnsky.mutationdemo.controller;

import com.fasterxml.jackson.databind.ObjectMapper;
import io.vrnsky.mutationdemo.DatabaseIntegrationTest;
import io.vrnsky.mutationdemo.entity.Book;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Tag;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
import org.springframework.http.MediaType;
import org.springframework.test.web.servlet.MockMvc;

import java.time.LocalDate;

import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.delete;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.put;
import static org.springframework.test.web.servlet.result.MockMvcResultHandlers.print;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;

@AutoConfigureMockMvc
class BookControllerTest extends DatabaseIntegrationTest {

    @Autowired
    private MockMvc mockMvc;

    @Autowired
    private ObjectMapper objectMapper;

    @Test
    @DisplayName("Test case: Creating a book")
    @Tag("Positive")
    void testThatCreateBookCorrectlyCreateBook() throws Exception {
        var book = new Book(null, "John Doe", "123", LocalDate.now(), false);
        mockMvc.perform(post("/book")
                .content(objectMapper.writeValueAsString(book))
                .contentType(MediaType.APPLICATION_JSON))
                .andExpect(status().isOk())
                .andExpect(jsonPath("$.id").isNotEmpty())
                .andDo(print());
    }

    @Test
    @DisplayName("Test case: Updating existing book")
    @Tag("Positive")
    void testThatUpdatingExistingBookWorksCorrectly() throws Exception {
        var book = new Book(null, "John Doe", "123", LocalDate.now(), false);
        var mvcResponse = mockMvc.perform(post("/book")
                        .content(objectMapper.writeValueAsString(book))
                        .contentType(MediaType.APPLICATION_JSON))
                .andExpect(status().isOk())
                .andExpect(jsonPath("$.id").isNotEmpty())
                .andReturn();

        var createdBook = objectMapper.readValue(mvcResponse.getResponse().getContentAsString(), Book.class);
        createdBook.setAuthor("Yegor");
        mockMvc.perform(put("/book/" + createdBook.getId())
                .content(objectMapper.writeValueAsString(createdBook))
                .contentType(MediaType.APPLICATION_JSON))
                .andExpect(status().isOk())
                .andExpect(jsonPath("$.author").value("Yegor"));
    }

    @Test
    @DisplayName("Test case: Get existing book by id")
    @Tag("Positive")
    void testThatGetExistingBookByIdWorksCorrectly() throws Exception {
        var book = new Book(null, "John Doe", "123", LocalDate.now(), false);
        var mvcResponse = mockMvc.perform(post("/book")
                        .content(objectMapper.writeValueAsString(book))
                        .contentType(MediaType.APPLICATION_JSON))
                .andExpect(status().isOk())
                .andExpect(jsonPath("$.id").isNotEmpty())
                .andReturn();

        var createdBook = objectMapper.readValue(mvcResponse.getResponse().getContentAsString(), Book.class);
        createdBook.setAuthor("Yegor");
        mockMvc.perform(get("/book/" + createdBook.getId())
                        .content(objectMapper.writeValueAsString(createdBook))
                        .contentType(MediaType.APPLICATION_JSON))
                .andExpect(status().isOk())
                .andExpect(jsonPath("$.id").value(createdBook.getId().toString()))
                .andExpect(jsonPath("$.author").value("John Doe"));
    }

    @Test
    @DisplayName("Test case: Deletion of existing book works correctly")
    @Tag("Positive")
    void testThatDeletionOfWorkBookWorksCorrectly() throws Exception {
        var book = new Book(null, "John Doe", "123", LocalDate.now(), false);
        var mvcResponse = mockMvc.perform(post("/book")
                        .content(objectMapper.writeValueAsString(book))
                        .contentType(MediaType.APPLICATION_JSON))
                .andExpect(status().isOk())
                .andExpect(jsonPath("$.id").isNotEmpty())
                .andReturn();

        var createdBook = objectMapper.readValue(mvcResponse.getResponse().getContentAsString(), Book.class);
        createdBook.setAuthor("Yegor");
        mockMvc.perform(delete("/" + createdBook.getId())
                        .content(objectMapper.writeValueAsString(createdBook))
                        .contentType(MediaType.APPLICATION_JSON))
                .andExpect(status().isOk());

        mockMvc.perform(get("/book/" + createdBook.getId())
                        .content(objectMapper.writeValueAsString(createdBook))
                        .contentType(MediaType.APPLICATION_JSON))
                .andExpect(status().isOk())
                .andExpect(jsonPath("$.id").value(createdBook.getId().toString()))
                .andExpect(jsonPath("$.deleted").value(true));
    }
}

The next step is to add the Pit plugin to perform mutation testing. By default, the plugin will try to mutate all code, so be precise about what you want to test.

   <plugin>
    <groupId>org.pitest</groupId>
    <artifactId>pitest-maven</artifactId>
    <version>1.15.3</version>
    <dependencies>
     <dependency>
      <groupId>org.pitest</groupId>
      <artifactId>pitest-junit5-plugin</artifactId>
      <version>1.2.1</version>
     </dependency>
    </dependencies>
    <configuration>
     <timeoutConstant>15000</timeoutConstant>
     <verbose>true</verbose>
     <targetClasses>
      <param>io.vrnsky.mutationdemo.service.*</param>
      <param>io.vrnsky.mutationdemo.controller.*</param>
     </targetClasses>
     <targetTests>
      <param>io.vrnsky.mutationdemo.service.*</param>
      <param>io.vrnsky.mutationdemo.controler.*</param>
     </targetTests>
     <features>
      <feature>+auto_threads</feature>
     </features>
    </configuration>
   </plugin>

There is one more thing: Pitest is running in single-thread mode until you explicitly configure the auto threads feature.. As you can see, I have set verbose to true. It helps get more detailed information on what is going on.

Now, we can run mutation testing by following the command.

mvn org.pitest:pitest-maven:1.15.3:mutationCoverage

After completion, we can go to the target/pit-report folder and check the detailed report about mutation testing.

References

Wikipedia
Spring Boot Initializr
TestContainers
JUnit 5
100 Java Mistakes and how to avoid them, Tagir Valeev

Spring Cloud Config, Spring Cloud Bus & Kafka | How to set up automatic updates of your configuration

Yegor Voronianskii — Sat, 23 Dec 2023 10:56:55 +0000

In this article, I will show you how to achieve automatic updates with Spring Cloud Bus and Kafka

The Spring Cloud Bus, according to documentation:

Spring Cloud Bus links nodes of a distributed system with a lightweight message broker. This can then broadcast state changes (e.g., configuration changes) or other management instructions. AMQP and Kafka broker implementations are included in the project. Alternatively, any Spring Cloud Stream binder on the classpath will work out of the box as a transport.

I will start from common practice nowadays without a message broker.

First, we need to create a repository with your app’s configuration. There is no rocket science to create a new repository. After that, we can edit with web IDE, clone, add, commit, and push the app’s configuration to the remote repository.

Example of configuration in repository

echo:
  message:
    text: 'Hello, world!'

The second part is to create a cloud config server and set up the correct configuration for this server. We must set up a remote repository and credentials to make the configuration accessible.

Before developing a service that will be consuming configuration, we need to add an annotation that enables the config server and provides configuration.

package io.vrnsky.cloudconfigservice;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.config.server.EnableConfigServer;

@SpringBootApplication
@EnableConfigServer
public class CloudConfigServiceApplication {

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

}

server:
  port: 8888
spring:
  cloud:
    config:
      enabled: true
      server:
        git:
          uri: https://github.com/vrnsky/medium-config
          username: vrnsky
          password: your_github_personal_access_token here
          try-master-branch: false
          clone-on-start: true
          search-paths:
            - medium-service
logging:
  level:
    org.springframework.cloud: DEBUG

After a successful start, we can check if the configuration is available.

GitCredentialsProviderFactory : Constructing UsernamePasswordCredentialsProvider for URI https://github.com/vrnsky/medium-config

curl "http://localhost:8888/medium-service/main"
{"name":"medium-service","profiles":["main"],"label":null,"version":"f3c546784ab421046174a4119f2ca250184e740b","state":null,"propertySources":[{"name":"https://github.com/vrnsky/medium-config/medium-service/application.yml","source":{"echo.message.text":"Hello, world!"}}]}%

Now, let’s configure our service to interact with the cloud-config server. I will configure the application to use the config server application running on my machine.

spring:
  application:
    name: medium-service
  cloud:
    config:
      enabled: true
      uri: http://localhost:8888

The next part is to create configuration properties of the medium service.

package io.vrnsky.mediumservice.config;

import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Configuration;

@Data
@Configuration
@ConfigurationProperties(prefix = "echo.message")
public class MediumServiceConfig {

    private String text;
}

Now, let’s create a controller that will return the message value from the configuration.

package io.vrnsky.mediumservice.controller;

import io.vrnsky.mediumservice.config.MediumServiceConfig;
import lombok.RequiredArgsConstructor;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequiredArgsConstructor
public class MediumController {

    private final MediumServiceConfig config;

    @GetMapping("/sayHello")
    public String getMessage() {
        return config.getText();
    }
}

Let’s check if the property has been read from the cloud config server.

curl http://localhost:8080/sayHello
Hello, world!

After successfully managing to run both the service and cloud config server, we are ready to move with adding Spring Cloud Bus integration.

First, we need to bootstrap with docker-compose Kafka and Zookeeper.

version: "3"
services:
  zookeeper:
    image: confluentinc/cp-zookeeper:latest
    environment:
      ZOOKEEPER_CLIENT_PORT: 2181
    ports:
      - "22181:2181"

  kafka:
    image: confluentinc/cp-kafka:latest
    depends_on:
      - zookeeper
    environment:
      KAFKA_ZOOKEEPER_CONNECT: zookeeper:2181
      KAFKA_ADVERTISED_LISTENERS: PLAINTEXT://localhost:9092,EXTERNAL://localhost:29092
      KAFKA_LISTENERS: PLAINTEXT://:9092,EXTERNAL://:29092
      KAFKA_LISTENER_SECURITY_PROTOCOL_MAP: PLAINTEXT:PLAINTEXT,EXTERNAL:PLAINTEXT
      KAFKA_INTER_BROKER_LISTENER_NAME: PLAINTEXT
      KAFKA_OFFSETS_TOPIC_REPLICATION_FACTOR: 1
    ports:
      - "9092:9092"
      - "29092:29092"

Start Kafka and Zookeeper with the following command:

docker compose up

The next thing we will add is to configure our Cloud Config Server and our service to push and consume events from the message broker.

In your cloud config server, pom.xml add the following dependencies:

        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-config-monitor</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-stream-kafka</artifactId>
        </dependency>

The next step is to add properties in application.yml inside the resources folder of the config server.

spring:
  kafka:
    bootstrap-servers:
      - http://localhost:29092
  cloud:
    bus:
      enabled: true

Now, try to run the cloud config server and check if it succeeded in connecting with the message broker. You will see similar log messages if the connection has been established successfully.

.7c65c8b8-caaa-45e1-b5bb-2f9c8eb3b137-2, groupId=anonymous.7c65c8b8-caaa-45e1-b5bb-2f9c8eb3b137] Adding newly assigned partitions: springCloudBus-0
2023-12-21T13:31:23.119+08:00  INFO 7578 --- [container-0-C-1] o.a.k.c.c.internals.ConsumerCoordinator  : [Consumer clientId=consumer-anonymous.7c65c8b8-caaa-45e1-b5bb-2f9c8eb3b137-2, groupId=anonymous.7c65c8b8-caaa-45e1-b5bb-2f9c8eb3b137] Found no committed offset for partition springCloudBus-0
2023-12-21T13:31:23.123+08:00  INFO 7578 --- [container-0-C-1] o.a.k.c.c.internals.ConsumerCoordinator  : [Consumer clientId=consumer-anonymous.7c65c8b8-caaa-45e1-b5bb-2f9c8eb3b137-2, groupId=anonymous.7c65c8b8-caaa-45e1-b5bb-2f9c8eb3b137] Found no committed offset for partition springCloudBus-0
2023-12-21T13:31:23.133+08:00  INFO 7578 --- [container-0-C-1] o.a.k.c.c.internals.SubscriptionState    : [Consumer clientId=consumer-anonymous.7c65c8b8-caaa-45e1-b5bb-2f9c8eb3b137-2, groupId=anonymous.7c65c8b8-caaa-45e1-b5bb-2f9c8eb3b137] Resetting offset for partition springCloudBus-0 to position FetchPosition{offset=3, offsetEpoch=Optional.empty, currentLeader=LeaderAndEpoch{leader=Optional[localhost:29092 (id: 1001 rack: null)], epoch=

Now, move on to the service side; in the pom.xml of service, add the following dependency:

 <dependency>
   <groupId>org.springframework.cloud</groupId>
   <artifactId>spring-cloud-starter-bus-kafka</artifactId>
 </dependency>

The next step is configuring the service to listen to messages from the message broker.

spring:
  config:
    import: optional:configserver:http://localhost:8888
  application:
    name: medium-service
  cloud:
    config:
      enabled: true
      uri: http://localhost:8888
    stream:
      kafka:
        binder:
          brokers:
            - http://localhost:29092
    bus:
      trace:
        enabled: true
      refresh:
        enabled: true
      env:
        enabled: true

Now, we can start our config server and server. Please ensure that Kafka and Zookeeper have been created before bootstrapping the cloud config server and service.

The automatic updates use webhooks from version control system platforms such as GitHub and GitLab. In this article, for correct working, the services should be deployed somewhere, like Cloud Platform Providers, but to keep things simple, we will do it on a local machine.
You can create a webhook inside the repository’s settings section and get an idea of what information can be obtained from the webhook payload. I have used https://webhook.site to get webhooks from the medium-config repository.

Let’s change our property in a repository and manually trigger the configuration update.

echo:
  message:
    text: 'Hello, Medium'

You may see https://webhook.site, which has successfully caught the webhook. Copy the payload of the webhook we are going to use for the update configuration.

It’s time to trigger the update by following the command:

 curl -X POST 'http://localhost:8888/monitor?path=medium-service" -d '{webhook_payload}'

You should see something similar in the logs of the cloud-config server. The logs tell us the message has been sent to the broker.

 o.s.c.s.m.DirectWithAttributesChannel    : postSend (sent=true) on channel 'bean 'springCloudBusInput'', message: GenericMessage [payload=byte[370], headers={kafka_offset=5, scst_nativeHeadersPresent=true, kafka_consumer=org.springframework.kafka.core

In logs of service, you should see the following logs:

2023-12-21T13:47:55.412+08:00  INFO 4389 --- [medium-service] [container-0-C-1] o.s.c.c.c.ConfigServerConfigDataLoader   : Located environment: name=medium-service, profiles=[default], label=null, version=a4ea5778de48d08b36e6a8ee310cf2e76ebde68f, state=null
2023-12-21T13:47:55.438+08:00  INFO 4389 --- [medium-service] [container-0-C-1] o.s.cloud.bus.event.RefreshListener      : Keys refreshed [config.client.version, echo.message.text]

To check that the configuration was updated, we can again curl the sayHello method of the medium service.

curl http://localhost:8080/sayHello

Hello, Medium

References

Write Spring MVC Logger for log request and response

Yegor Voronianskii — Mon, 18 Jan 2021 04:56:09 +0000

Hello! In this article, I will explain how to write a logger for logging requests and responses. It would seem that there is nothing complicated about this, but if you look at the documentation, you can see the following

Which tells us that we can read data only once and by calling either the getReader method or the getInputStream method. In order to get around this limitation, two special classes were invented ContentCachingRequetWrapper.java and ContentCachingResponseWrapper.java, which are just needed so that we can log the request data. In order to polish the data about requests and responses, we will implement a filter that will extend the OncePerRequestFilter.java class Let's call this our movie LoggingFilter and start writing it. First, let's declare an instance of our logger

private static final Logger logger = LoggerFactory.getLogger(LoggingFilter.class);

Next, we declare all the MIME types that we want to log

private static final List<MediaType> VISIBLE_TYPES = Arrays.asList(
      MediaType.valueOf("text/*"),
      MediaType.APPLICATION_FORM_URLENCODED,
      MediaType.APPLICATION_JSON,
      MediaType.APPLICATION_XML,
      MediaType.valueOf("application/*+json"),
      MediaType.valueOf("application/*+xml"),
      MediaType.MULTIPART_FORM_DATA
);

Then we override the methods from the parent class

@Override
protected void doFilterInternal(HttpServletRequest httpServletRequest,
                                HttpServletResponse httpServletResponse,
                                FilterChain filterChain) 
                                throws ServletException, IOException {
  if (isAsyncDispatch(httpServletRequest)) {
      filterChain.doFilter(httpServletRequest, httpServletResponse);
  } else {
     doFilterWrapped(wrapRequest(httpServletRequest),
                     wrapResponse(httpServletResponse,
                     filterChain);
 }

In this case, we check whether the call is asynchronous, and in this case we do not try to polish it, if the call is synchronous, then we try to wrap the logging Implementing the doFilterWrapped method

protected void doFilterWrapped(ContentCachingRequestWrapper contentCachingRequestWrapper, ContentCachingResponseWrapper contentCachingResponseWrapper, FilterChain filterChain) throws IOException, ServletException {
        try {
            beforeRequest(contentCachingRequestWrapper);
            filterChain.doFilter(contentCachingRequestWrapper, contentCachingResponseWrapper);
        } finally {
            afterRequest(contentCachingRequestWrapper, contentCachingResponseWrapper);
            contentCachingResponseWrapper.copyBodyToResponse();
        }
    }

In this method, we already receive a cached request and response and perform processing and post-processing of the request, and also copy the response data Let's write the request processing code

protected void beforeRequest(ContentCachingRequestWrapper request) {
    if (logger.isInfoEnabled()) {
        logRequestHeader(request, request.getRemoteAddr() + "|>");
    }
}

We check the logging level and if it is equal to the INFO level, then we also log the request headers

Let's write a post-processing method

protected void afterRequest(ContentCachingRequestWrapper request, ContentCachingResponseWrapper response) {
        if (logger.isInfoEnabled()) {
            logRequestBody(request, request.getRemoteAddr() + "|>");
            logResponse(response, request.getRemoteAddr() + "|>");
        }
    }

In this case, we also check that the logging level is set to INFO before polishing the request and response. And finally, the most interesting thing, we write logging of headers, as well as requests and responses

private static void logRequestHeader(ContentCachingRequestWrapper request, String prefix) {
        String queryString = request.getQueryString();
        if (queryString == null) {
            logger.info("{} {} {}", prefix, request.getMethod(), request.getRequestURI());
        } else {
            logger.info("{} {} {}?{}", prefix, request.getMethod(), request.getRequestURI(), queryString);
        }
        Collections.list(request.getHeaderNames()).forEach(headerName ->
                Collections.list(request.getHeaders(headerName)).forEach(headerValue -> logger.info("{} {} {}", prefix, headerName, headerValue)));
        logger.info("{}", prefix);
    }

In the logRequestHeader method, the following happens - from the request we get a string, check whether it is null and if null, then we code the HTTP method and the URL to which such a request came, otherwise the HTTP method is also logged, the URL to which the request came, and also all request headers Next, we need to write the code to log the request body

private static void logRequestBody(ContentCachingRequestWrapper request, String prefix) {
    byte[] content = request.getContentAsByteArray();
    if (content.length > 0) {
        logContent(content, request.getContentType(), request.getCharacterEncoding(), prefix);
    }
}

We receive data from the request as an array of bytes, and in the event that the size of the array is greater than zero, we pass the data to the logContent method, which we will write a little later.

Now is the time to write the code for logging responses from the application.

private static void logResponse(ContentCachingResponseWrapper response, String prefix) {
    int status = response.getStatus();
    logger.info("{} {} {}", prefix, status, HttpStatus.valueOf(status).getReasonPhrase());
    response.getHeaderNames().forEach(header -> response.getHeaders(header).forEach(headerValue -> logger.info("{} {} {}", prefix, header, headerValue)));
    logger.info("{}", prefix);
    byte[] content = response.getContentAsByteArray();
    if (content.length > 0) {
        logContent(content, response.getContentType(), response.getCharacterEncoding(), prefix);
    }
}

Let's figure out what exactly is happening here - with the first line we get the HTTP response code of our application and then log data about it. Next, we go through the response headers and log them in the same way. Further, the logic is quite similar to what we have seen before - we receive data from the response as an array of bytes and then pass it to the logContent method, which will look like this:

private static void logContent(byte[] content, String contentType, String contentEncoding, String prefix) {
        MediaType mediaType = MediaType.valueOf(contentType);
        boolean visible = VISIBLE_TYPES.stream().anyMatch(visibleType -> visibleType.includes(mediaType));
        if (visible) {
            try {
                String contentString = new String(content, contentEncoding);
                Stream.of(contentString.split("\r\n|\r\n")).forEach(line -> logger.info("{} {}", prefix, line));
            } catch (UnsupportedEncodingException e) {
                logger.info("{}, [{} bytes content]", prefix, content.length);
            }
        } else {
            logger.info("{}, [{} bytes content]", prefix, content.length);
        }
    }

What's going on here? First, we check if the type of the transmitted data is supported for doping, if not, then we simply display the size of the data array. If yes, then we get create a line from the data with the specified encoding in the request, and separate each line using carriage return and newline characters. If the encoding is not supported, then, as in the case of an unsupported data type, we simply log the size of the data that we received in the request or response

And the final touch in our code is the two methods that are actually needed to wrap our HttpServletRequest and HttpServletResponse in ContentCachingRequestWrapper and ContentCachingResponseWrapper

private static ContentCachingRequestWrapper wrapRequest(HttpServletRequest httpServletRequest) {
        if (httpServletRequest instanceof ContentCachingRequestWrapper) {
            return (ContentCachingRequestWrapper) httpServletRequest;
        } else {
            return new ContentCachingRequestWrapper(httpServletRequest);
        }
    }

    private static ContentCachingResponseWrapper wrapResponse(HttpServletResponse httpServletResponse) {
        if (httpServletResponse instanceof ContentCachingResponseWrapper) {
            return (ContentCachingResponseWrapper) httpServletResponse;
        } else {
            return new ContentCachingResponseWrapper(httpServletResponse);
        }
    }

Next, you need to register our filter in the deployment descriptor

<filter>
    <filter-name>Filter</filter-name>
    <filter-class>ru.skillfactory.filter.LoggingFilter</filter-class>
</filter>

<filter-mapping>
    <filter-name>Filter</filter-name>
    <url-pattern>*</url-pattern>
</filter-mapping>

Finally, make sure our filter is working properly

2021-01-18 12:25:24 DEBUG RequestResponseBodyMethodProcessor:91 - Read "application/json;charset=ISO-8859-1" to [StudentData(firstName=John, lastName=Doe, grade=5)]
2021-01-18 12:25:24 DEBUG RequestResponseBodyMethodProcessor:265 - Using 'text/plain', given [*/*] and supported [text/plain, */*, application/json, application/*+json]
2021-01-18 12:25:24 DEBUG RequestResponseBodyMethodProcessor:91 - Writing ["You are great with your grade 5"]
2021-01-18 12:25:24 DEBUG DispatcherServlet:1131 - Completed 200 OK
2021-01-18 12:25:24 INFO  LoggingFilter:104 - 0:0:0:0:0:0:0:1|> {
    "firstName": "John",
    "lastName": "Doe",
    "grade": 5
}
2021-01-18 12:25:24 INFO  LoggingFilter:89 - 0:0:0:0:0:0:0:1|> 200 OK
2021-01-18 12:25:24 INFO  LoggingFilter:91 - 0:0:0:0:0:0:0:1|>
2021-01-18 12:25:24 INFO  LoggingFilter:104 - 0:0:0:0:0:0:0:1|> You are great with your grade 5

Full code of LoggingFilter.java

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.web.filter.OncePerRequestFilter;
import org.springframework.web.util.ContentCachingRequestWrapper;
import org.springframework.web.util.ContentCachingResponseWrapper;

import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.stream.Stream;

public class LoggingFilter extends OncePerRequestFilter {

    private static final Logger logger = LoggerFactory.getLogger(LoggingFilter.class);
    private static final List<MediaType> VISIBLE_TYPES = Arrays.asList(
            MediaType.valueOf("text/*"),
            MediaType.APPLICATION_FORM_URLENCODED,
            MediaType.APPLICATION_JSON,
            MediaType.APPLICATION_XML,
            MediaType.valueOf("application/*+json"),
            MediaType.valueOf("application/*+xml"),
            MediaType.MULTIPART_FORM_DATA
    );

    @Override
    protected void doFilterInternal(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, FilterChain filterChain) throws ServletException, IOException {
        if (isAsyncDispatch(httpServletRequest)) {
            filterChain.doFilter(httpServletRequest, httpServletResponse);
        } else {
            doFilterWrapped(wrapRequest(httpServletRequest), wrapResponse(httpServletResponse), filterChain);
        }
    }

    protected void doFilterWrapped(ContentCachingRequestWrapper contentCachingRequestWrapper, ContentCachingResponseWrapper contentCachingResponseWrapper, FilterChain filterChain) throws IOException, ServletException {
        try {
            beforeRequest(contentCachingRequestWrapper);
            filterChain.doFilter(contentCachingRequestWrapper, contentCachingResponseWrapper);
        } finally {
            afterRequest(contentCachingRequestWrapper, contentCachingResponseWrapper);
            contentCachingResponseWrapper.copyBodyToResponse();
        }
    }

    protected void beforeRequest(ContentCachingRequestWrapper request) {
        if (logger.isInfoEnabled()) {
            logRequestHeader(request, request.getRemoteAddr() + "|>");
        }
    }

    protected void afterRequest(ContentCachingRequestWrapper request, ContentCachingResponseWrapper response) {
        if (logger.isInfoEnabled()) {
            logRequestBody(request, request.getRemoteAddr() + "|>");
            logResponse(response, request.getRemoteAddr() + "|>");
        }
    }

    private static void logRequestHeader(ContentCachingRequestWrapper request, String prefix) {
        String queryString = request.getQueryString();
        if (queryString == null) {
            logger.info("{} {} {}", prefix, request.getMethod(), request.getRequestURI());
        } else {
            logger.info("{} {} {}?{}", prefix, request.getMethod(), request.getRequestURI(), queryString);
        }
        Collections.list(request.getHeaderNames()).forEach(headerName ->
                Collections.list(request.getHeaders(headerName)).forEach(headerValue -> logger.info("{} {} {}", prefix, headerName, headerValue)));
        logger.info("{}", prefix);
    }

    private static void logRequestBody(ContentCachingRequestWrapper request, String prefix) {
        byte[] content = request.getContentAsByteArray();
        if (content.length > 0) {
            logContent(content, request.getContentType(), request.getCharacterEncoding(), prefix);
        }
    }

    private static void logResponse(ContentCachingResponseWrapper response, String prefix) {
        int status = response.getStatus();
        logger.info("{} {} {}", prefix, status, HttpStatus.valueOf(status).getReasonPhrase());
        response.getHeaderNames().forEach(header -> response.getHeaders(header).forEach(headerValue -> logger.info("{} {} {}", prefix, header, headerValue)));
        logger.info("{}", prefix);
        byte[] content = response.getContentAsByteArray();
        if (content.length > 0) {
            logContent(content, response.getContentType(), response.getCharacterEncoding(), prefix);
        }
    }

    private static void logContent(byte[] content, String contentType, String contentEncoding, String prefix) {
        MediaType mediaType = MediaType.valueOf(contentType);
        boolean visible = VISIBLE_TYPES.stream().anyMatch(visibleType -> visibleType.includes(mediaType));
        if (visible) {
            try {
                String contentString = new String(content, contentEncoding);
                Stream.of(contentString.split("\r\n|\r\n")).forEach(line -> logger.info("{} {}", prefix, line));
            } catch (UnsupportedEncodingException e) {
                logger.info("{}, [{} bytes content]", prefix, content.length);
            }
        } else {
            logger.info("{}, [{} bytes content]", prefix, content.length);
        }
    }

    private static ContentCachingRequestWrapper wrapRequest(HttpServletRequest httpServletRequest) {
        if (httpServletRequest instanceof ContentCachingRequestWrapper) {
            return (ContentCachingRequestWrapper) httpServletRequest;
        } else {
            return new ContentCachingRequestWrapper(httpServletRequest);
        }
    }

    private static ContentCachingResponseWrapper wrapResponse(HttpServletResponse httpServletResponse) {
        if (httpServletResponse instanceof ContentCachingResponseWrapper) {
            return (ContentCachingResponseWrapper) httpServletResponse;
        } else {
            return new ContentCachingResponseWrapper(httpServletResponse);
        }
    }
}

If you liked the article, then subscribe and share with your friends!
Thanks for attention

Write Simple Spring Boot for get currency rate

Yegor Voronianskii — Tue, 08 Dec 2020 00:42:03 +0000

Within the framework of this article, we will develop an application for receiving exchange rates from the central bank of Russia. The main technologies we will be using will be Java, Spring Boot, Docker, Vue

Let's start by choosing the required method in the API of the central bank, which is allowed to get the current rates
Next, let's add WSDL processing to the application so that we don't have to do it by hand
We use Spring WebServices so that our application can skillfully request data from the API
Add Swagger to the application
Add some Vue frontend
Connect Docker The first thing we need is, of course, to create an application - this can be done using the Spring Initializr or through IntelliJ IDEA.

The API method we'll be using from the central bank is called GetCursOnDateXML. Below you can see its description.

In order not to describe the structure of requests and responses from the API ourselves, we will use plugins that will help turn WSDL into POJO. Listing pom.xml
Let's check that the plugin really works and the classes we need are created - screen.

<plugin> 
  <groupId>org.codehaus.mojo</groupId>
  <artifactId>jaxws-maven-plugin</artifactId>
  <version>2.6</version>
  <executions>
    <execution>
      <id>generatewsdl</id>
      <goals>
        <goal>wsimport</goal>
     </goals>
     <configuration>
        <vmArgs>
          <vmArg>-Djavax.xml.accessExternalSchema=all</vmArg>
          <vmArg>-Djavax.xml.accessExternalDTD=all</vmArg>
        </vmArgs> <wsdlDirectory>${basedir}/src/main/resources/</wsdlDirectory>  
    <args>
       <arg>-b</arg>
       <arg>https://www.w3.org/2001/XMLSchema.xsd</arg> 
    </args>
 <wsdlFiles> <wsdlFile>${basedir}/src/main/resources/dailyinfo.wsdl</wsdlFile>     </wsdlFiles> 
        </configuration> 
      </execution> 
  </executions>
</plugin>

Now let's add a web service that will be responsible for executing the request and response. Listing of creating a web service.

@Service
public class CBRService extends WebServiceTemplate {

     @Value("${cbr.url}")
     private String cbrApiUrl;     


     public List<ValuteCursOnDate> getCurrenciesFromCbr() throws DatatypeConfigurationException {
        final GetCursOnDateXML getCursOnDateXML = new GetCursOnDateXML();
        GregorianCalendar cal = new GregorianCalendar(); 
        cal.setTime(new Date());
        XMLGregorianCalendar xmlGregCal =  DatatypeFactory.newInstance().newXMLGregorianCalendar(cal);
        getCursOnDateXML.setOnDate(xmlGregCal);
        GetCursOnDateXmlResponse response = (GetCursOnDateXmlResponse) marshalSendAndReceive(cbrApiUrl, getCursOnDateXML);
        if (response == null) {   
          throw new IllegalStateException("Could not get response from CBR Service");        
        }
        final List<ValuteCursOnDate> courses = response.getGetCursOnDateXmlResult().getValuteData();
        courses.forEach(course -> course.setName(course.getName().trim()));
        return courses;    
}
    public ValuteCursOnDate getCurrencyFromCbr(String currencyCode) throws DatatypeConfigurationException {
        return getCurrenciesFromCbr()
             .stream()
             .filter(currency -> currencyCode.equals(currency.getChCode()))
             .findFirst().orElseThrow(() -> new RuntimeException("Could not find currency"));    
   }
}

Great, the MVP of the application is almost complete. Now let's add REST controllers so that we can send the received data from the third-party API outside. We will have one controller and two entry points - receiving all currencies, and receiving a specific currency at the moment.

@RestController
@RequestMapping(value = "/api")
@RequiredArgsConstructor
public class CurrencyController {
     private final CurrencyService currencyService;
     private final CBRService cbrService;

     @PostMapping(value = "/getCurrencyFromCbr")
     public List<ValuteCursOnDate> crbCurrencies() throws DatatypeConfigurationException {
        return cbrService.getCurrenciesFromCbr();
    }     
     @PostMapping(value = "/getCurrencyFromCbr/{currency}")     public ValuteCursOnDate crbOn(@PathVariable String currency) throws DatatypeConfigurationException {
        return cbrService.getCurrencyFromCbr(currency);
    }
}

Let's add Swagger to our application so that all consumers of our API know the contracts for interacting with the system.In order to add Swagger, you need to add one dependency and write the configuration code. Let's check that Swagger actually works. However, we need a complete UI. To do this, let's add another dependency and make sure that everything worked correctly.

<dependency>
  <groupId>io.springfox</groupId>
  <artifactId>springfox-swagger2</artifactId> 
  <version>2.6.1</version>
  <scope>compile</scope> 
</dependency> 
<dependency> 
 <groupId>io.springfox</groupId> 
 <artifactId>springfox-swagger-ui</artifactId> 
 <version>2.6.1</version> 
 <scope>compile</scope>        
</dependency>

We have an API, but at the moment we can display currencies only in JSON form. Let's add a little frontend in Vue.

<template>
  <div class="container">
    <div class="row">
      <div class="col-2">
      </div>
      <div class="col-8">
        <h1>Currency Rate</h1>
        <span>на {{ today }}</span>
        <table class="table">
          <thead class="table-striped table-bordered">
            <tr>
              <th scope="col">Name</th>
              <th scope="col">Nominal</th>
              <th scope="col">Rate</th>
              <th scope="col">Digital code</th>
              <th scope="col">Alphabet code</th>
            </tr>
          </thead>
          <tbody>
            <tr v-for="currency in currencies" :key="currency.name">
              <td scope="row">{{ currency.name }}</td>
              <td scope="row">{{ currency.nominal }}</td>
              <td scope="row">{{ currency.course }}</td>
              <td scope="row">{{ currency.code }}</td>
              <td scope="row">{{ currency.chCode }}</td>
            </tr>
          </tbody>
        </table>
      </div>
      <div class="col"></div>
    </div>
  </div>
</template>

<script>
import 'bootstrap/dist/css/bootstrap.css'
import 'bootstrap-vue/dist/bootstrap-vue.css'
import CurrencyService from '@/service/CurrencyService'
export default {
  data() {
    return {
      currencies: [],
      today: new Date()
    }
  },
  created() {
    CurrencyService.getCurrencies()
      .then(response => {
        this.currencies = response.data
      })
      .catch(error => {
        console.log(error.response)
      })
  }
}
</script>

Now, we should add service instance for interact with our backend.

import axios from 'axios'

const apiClient = axios.create({
  baseURL: 'http://localhost:9091',
  withCredentials: false,
  headers: {
    Accept: 'application/json',
    'Content-Type': 'application/json'
  }
})

export default {
  getCurrencies() {
    return apiClient.post('/api/getCurrencyFromCbr')
  }
}

We'll also add Docker for our convenience. Our Dockerfile will look like this

FROM adoptopenjdk/openjdk11:latestARG JAR_FILE=/backend/target/*.jar
COPY ${JAR_FILE} /backend/currency-rate-vue-0.0.1-SNAPSHOT.jar
ENTRYPOINT ["java","-jar","/backend/currency-rate-vue-0.0.1-SNAPSHOT.jar

And last, but not least let's write unit test - for check that our app works correctly

import com.fasterxml.jackson.databind.ObjectMapper;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.http.MediaType;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.MvcResult;
import ru.rbs.currency_vue.dto.CurrencyCreationResponse;
import ru.rbs.currency_vue.model.Currency;
import ru.rbs.currency_vue.model.CurrencyCode;

import java.math.BigDecimal;
import java.time.LocalDateTime;

import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post;
import static org.springframework.test.web.servlet.result.MockMvcResultHandlers.print;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;

@SpringBootTest
@AutoConfigureMockMvc
class CurrencyControllerTest {

    @Autowired
    private MockMvc mockMvc;

    @Autowired
    private ObjectMapper objectMapper;

    @Test
    public void testWhenWeAskAboutAllCurrenciesShouldCheckThatAllArePresent() throws Exception {
        mockMvc.perform(post("/api/getCurrencyFromCbr"))
                .andExpect(status().isOk())
                .andDo(print());
    }

    @Test
    public void testWhenWeAskAboutCurrencyShouldCheckThatIsPresent() throws Exception {
        mockMvc.perform(post("/api/getCurrencyFromCbr/USD"))
                .andExpect(status().isOk())
                .andExpect(jsonPath("$.name").value("Доллар США"))
                .andExpect(jsonPath("$.nominal").value(1))
                .andExpect(jsonPath("$.course").exists())
                .andExpect(jsonPath("$.code").value("840"))
                .andExpect(jsonPath("$.chCode").value("USD"))
                .andDo(print());
    }

}

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import ru.rbs.currency_vue.dto.ValuteCursOnDate;

import java.util.List;

import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNull;

@SpringBootTest
class CBRServiceTest {

    @Autowired
    private CBRService cbrService;

    @Test
    public void testWhenWeTryToGetAllCurrenciesCollectionsShouldBeNotEmpty() throws Exception {
        List<ValuteCursOnDate> cursOnDateList = cbrService.getCurrenciesFromCbr();
        assertFalse(cursOnDateList.isEmpty());
    }

    @Test
    public void testWhenWeTryToGetOnlyOneCurrenciesShouldCheckThatWeCanGetIt() throws Exception {
        ValuteCursOnDate rubCursOnDate = cbrService.getCurrencyFromCbr("USD");
        assertNull(rubCursOnDate);
    }
}

That's all for me, I hope you liked the article Write comments and subscribe

Software Architecture #3. Final

Yegor Voronianskii — Thu, 03 Dec 2020 05:01:35 +0000

Software architecture design is one of the software architecture life-cycle activities. As in any software project life cycle, this activity is concerned with the translation of requirements into a design into an implementation. Specifically, the architect need to worry about the following issues:

Architectural requirements. Among all requirements, a few will have a particular importance with respect to the software architecture. These architecturally significant requirements include not only most important functionality of the system and the constraints that need to be taken into account, but also - and most importantly quality attributes such as high performance, high availability, ease of evolution, and iron-clad security. These requirements, along with a clear design purpose and other architectural concerns that may never be written down or may be invisible to external stakeholders and components over another.
Architectural design. Design is translation, from the world of need(requirements) to the world of solutions, in terms of structures composed of code, framework, and components. A good design is one that satisfies the drivers.
Architectural documentation. Some level of preliminary documentation (or sketches) of the structures should be created as part of architectural design. This activity, however, refers to the creation of a more format document from these sketches. If the project is small and has a precedent, then architecture documentation may be minimal. In contrast, if the project is large, if distributed teams are collaborating, or if significant technical challenges exist, then architectural documentation will repay the effort invested in this activity. While documentation is often avoided and derided by programmers, it is a standard, non-negotiable deliverable in almost every other engineering discipline. If your system is big enough and if it is mission critical, it should be documented. In other engineering disciplines, a "blueprint" - some of sort of documented design - is an absolutely essential step in moving toward implementation and the commitment of resources
Architectural evaluation. As with documentation, if your project is non-trivial, then you owe it to yourself and to your stakeholders to evaluate it - that is, to ensure that the decisions made are appropriate to address the critical requirements. Would you deliver code without testing? Of course, not. Similarly, why would you commit enormous resources to fleshing out an architecture if you had not first "tested" the design? You might want to do this when first creating the system or when putting it through a major refactoring. Typically evaluation is done informally and internally, but for try important projects it is advisable to have formal evaluation done by an external team
Architectural implementation/conformance checking. Finally, you need to implement the architecture that you have created. As an architect, you may need to tweak the design as the system grows and requirements evolve. This is normal. In addition to this tweaking, your major responsibility during implementation is to ensure conformance of the code to the design. If developers are not faithfully implementing the architecture, the may be undermining the qualities that you have designed in. Again, consider what is done in other fields of engineering. When a concrete foundation for a new building is poured, the building that rests on top of that foundation is not constructed until the foundation has first been tested, typically vi a core sample, to ensure that it is wrong enough, dense enough, sufficiently impermeable to water and gases, and so forth. Without conformance checking, we have no way of ensuring the quality of what is being subsequently constructed.

The role of architect

An archives is much more that "just" a designer". This role may be played one or more individuals, has a long list of duties, skills and knowledge that must be satisfied if it to be successful. These prerequisites include the following:

Leadership: mentoring, team-building, establishing a vision, coach
Communication: both technical and nontechnical, encouraging collaboration
Negotiation: dealing with internal and external stakeholders and there conflicting needs and expectations
Technical skills: life-cycle skills, expertise with technologies, continuous learning, coding
Project skills: budgeting, personnel, schedule management, risk management
Analytical skill: architectural analysis, general analysis mindset for project management and measurement

Why is architectural design so important? There is a very high cost to a project of not making certain decisions, or not making them early enough. Without doing some architectural thinking and some early design work, you cannot confidently predict project cost, schedule, and quality. Without architecture, the benefits that the system is supposed to bring will be far harder to realise. If you do not make some key architectural decisions early and put if you allow architecture to degrade, you will be unable to maintain spring velocity, because you cannot easily respond to change requests. Such decisions may include:

Selection of tools
Structuring development environment
Supporting releases
DevOps

Architectural concerns

Architectural concerns encompass additional aspects that need to be considered as part of architectural design but that are not expressed as rational requirements. There are several different types of concerns.

General concerns. These are "broad" issues that one deals with in creating the architecture, such as establishing on overall system structure, the allocation of functionality to modules, the allocation of modules to team, organization of code base, startup and shutdown, and supporting delivery, deployment and updates.
Specific concerns. These are more detailed system-internal issues such as exception management, dependency management, configuration, logging, authentication, authorisation, caching and so forth that are common across large numbers of applications. Some specific concerns are addressed in reference architectures, but other will be unique to your system. Specific concerns also result from previous design decisions. For example, you may need to address session management if you previously decided to use a reference architecture for the development of web applications.
Internal requirements. These requirement are usually not specified explicitly in traditional requirement documents, such as customers usually seldom express them. Internal requirements may address aspects that facilitate development, deployment, operation, or maintenance of the system. They are sometimes called "derived requirements"
Issues. These result from analysis activities, such as design review, so they may not be present initially. For instance, an architectural evaluation may uncover a risk that requires some changes to be performed in current design.

Some of the decisions surrounding architectural concerns might be trivial or obvious. For example, your deployment structure might be a single processor for an embedded system, or a single cell phone for an app. Your reference architecture might be constrained by company policy. Your authentication and authorisation policies might be dictated by your enterprise architecture and realised in a shared framework. In other cases, however, the decisions required to satisfy particular concerns may be less obvious - for example, in exception management or input validation or structuring code base.
From their past experience, wise architects are usually aware of the concerns that are associated with a particular type of system and the need to make design decisions to address them. Inexperienced architects are usually less aware of such concerns; because these concerns tend to be tacit rather than explicit, the may not consider them as part of the design process, which often results in problem later or.
Architectural concerns frequently result in the introduction of new quality attribute scenarios. The concerns of "supporting logging", for example, is too vague and need to be made more specific.

The selection of externally developed components, which is a key aspect of the design process, can be a challenge task because of their extensive number. Here are few criteria you should cosied when selection externally developed components:

Problem that it addresses. Is is something specific, such as framework for object oriented to relation mapping or something more generic, such as platform.
Cost. What is the cost of the license, and if it is free, what is cost of support and education?
Type of license. Does it have a license that is compatible with the project goals?
Support. Is it well supported? Is there extensive documentation about the technology? Is there an extensive usr or developer community that you can turn for advice?
Learning curve. How hard is to learn this technology. Have others in your organization already mastered it? Are these courses available?
Maturity. Is it a technology that has just papered on the market, which may be exciting but still relatively unstable or unsupported?
Popularity. Is it a relatively widespread technology? Are these positive testimonial or adoption by mature organisations? Will it be easy to hire people who have deep knowledge of it? Is there an active developer community or user group?
Compatibility and ease of integration. Is it compatible with other technologies used in the project? Can it be integrated easily in project? Support for critical quality attributes. Does it limit attributes such as performance? Is it secure and robust?
Size. Will the use of the technology have negative impact of the size of the application under development

In their paper "A General Model of Software Architecture Design Derived from Five Industrial Approaches", Holfmeister and her colleagues compared five industrial software architecture design methods and extracted from their commonalities a generic software architecture design approach.
The derived general model consist of three main activities that are present in all five models reviewed:

Architectural analysis. In this activity, requirements (called concerns) and system context are used as inputs to determine set of architecturally significant requirements(ASR).
Architectural synthesis. This activity is described as being the core of architecture design. It proposes architecture solution to a set of ASRs, moving from the problem to the solution space. The results of this activity are candidate architectural solutions, which are partial or complete architecture designs an include information about the rationale.
Architectural evaluation. This activity ensures that the architectural decisions are the right ones. Candidate architectural solutions are measured agains ASRs. Several evaluations of different architectural solutions are expected, but the eventual result its the validated architecture.

Analysis is the process of breaking a complex entity into its constituent parts as a means of understanding it . The opposite of analysis is synthesis. Analysis and design are therefore inerwined actives. During the design process, the activity of analysis can refer to several aspects

Studying the inputs to the design process to understand the problem whose solution you are about to design.
Studying the alternative design concepts that you identified to solve a design problem so as to select the most appropriate one. In this situations, analysis forces you to provide concrete evidence for you choices.
Ensuring the decisions made during the design process (or an iteration) are appropriate.

Java Multithreading. Basics

Yegor Voronianskii — Mon, 30 Nov 2020 02:26:10 +0000

Why do you need multithreading

In the distant past, computers did not have operating systems. They only executed one program from start to finish, and that program had direct access to all of the computer's resources. Not only was it difficult to write a program that would run on bare metal, but running only one program at a time proved to be an inefficient waste of computer resources.

With the advent of operating systems, it became possible to run several programs at once. Programs were launched in a process - that is, an isolated, independent environment for which the operating system allocated resources such as memory, file descriptors.

The need to develop operating systems with multithreading support was due to the following factors:

Utilization of resources. Programs sometimes have to wait for some kind of third-party operation, such as input and output, and while we waited there was no opportunity to do some useful work.
Equity in resource allocation. Many users and programs can have the same rights to computer resources. It is preferable to share all resources between them.
Convenience. It is often easier and simpler to write several programs, each of which performs a different task and then coordinate them, than to write one program that does all the tasks.

Simple thread safe counter

public class Sequence {
   private int value;

   public synchronized int getNext() {
       return value++;
   }
}

This counter is thread safe because the getNext () method contains the synchronized keyword, which is used to ensure thread safety.

That is, in this case, each thread that will call this method will receive the actual value. If any thread has not yet executed this method, another thread will be queued and wait for the first thread to complete.

If many threads have access to variables that can change state, then your program is broken. There are three methods to fix this.

Restrict access to such variables
Make states immutable
Use sync to access state variables

Atomicity

public class Counter {
    private int long value;

    public int getNext() {
         return value++;
    }
}

Race condition

Imagine meeting your friend at Starbucks near the university at 12 noon. But when you arrived, it turned out that there are two Starbucks and you are not sure which meeting will take place. At 12:10 you didn't see your friend at Starbucks A, so you decided to go to Starbucks B to check if your friend was there, but as it turned out, he was not there. There are the following outcomes

Your friend is late and is not at any of the Starbucks
Your friend came to Starbucks A when you left to Starbucks B
Your friend was at Starbucks B and was looking for you, but he didn't find him and went to Starbucks A

Let's imagine the worst situation. At 12:15 pm, you visited both Starbucks. What will you do?

Will you go back to Starbucks A? How many times are you going to go back there?

Until the consistency protocol is developed, you both can spend all day walking between Starbucks.

This variant of the race condition can also be called - check then action. You check for some condition, for example file X does not exist, and then perform an action based on the fact that the condition file X does not exist is true. But immediately after your check, the X file may appear, which leads to unexpected problems

The most famous example of validation and then action is lazy initialization. The goal of lazy initialization is to create an object only when you really need it and another goal is to ensure that the object is initialized only once

public class LazyInitRace {
    private ExpensiveObject instance = null;

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

if (!vector.contains(element)) {
    vector.add(element);
}

Do you think this code is thread safe?

Answer: No. This attempt to put an item into a collection if there is no such item has a race condition, even if both add & contains methods are atomic. Methods with the synchronized keyword in their signature can do individual operations atomically, but additional synchronization is needed when both such methods are combined in some complex action. Do not overuse the synchronized keyword, as over-synchronization can lead to performance problems.

Volatile variables

The Java language also provides weaker synchronization — volatile variables that update predictably for other threads. It is not recommended to use this synchronization mechanism, since the code obeying such a synchronization mechanism is fragile and difficult to understand at what moment locks are used.

This type of variable is convenient, but it has certain limitations. Basically, variables marked volatile are used as completion flags, interrupt flags, or status flags. But it is important to understand that volatile does not guarantee that the increment will execute correctly (since the increment consists of three operations)

Use volatile only in the following cases

To describe variables that do not depend on their current value
This variable does not participate in invariants with other state variables
When accessing a variable, locking is not required for any other reason

Deadlock

Under deadlock, we mean the following situation: One thread is waiting for the lock taken by another thread to become available, while the first thread is waiting for the lock taken by the second thread to become available

public class TestDeadlockExample1 {  
  public static void main(String[] args) {  
    final String resource1 = "dev.to";  
    final String resource2 = "dev.architecture";  
    // t1 tries to lock resource1 then resource2  
    Thread t1 = new Thread() {  
      public void run() {  
          synchronized (resource1) {  
           System.out.println("Thread 1: locked resource 1");  

           try { Thread.sleep(150);} catch (Exception e) {}  

           synchronized (resource2) {  
            System.out.println("Thread 1: locked resource 2");  
           }  
         }  
      }  
    };  

    // t2 tries to lock resource2 then resource1  
    Thread t2 = new Thread() {  
      public void run() {  
        synchronized (resource2) {  
          System.out.println("Thread 2: locked resource 2");  

          try { Thread.sleep(150);} catch (Exception e) {}  

          synchronized (resource1) {  
            System.out.println("Thread 2: locked resource 1");  
          }  
        }  
      }  
    };  


    t1.start();  
    t2.start();  
  }  
}

Starvation

Fasting describes a situation where a thread cannot regularly access shared resources and cannot make progress. This occurs when shared resources become unavailable for extended periods due to greedy threads. For example, suppose an object provides a synchronized method that often takes a long time to return. If one thread calls this method frequently, other threads that also require frequent synchronized access to the same object will often block.

Livelock

A thread often acts in response to the action of another thread. If the action of another thread is also a response to the action of another thread, then a live block may occur. As with the deadlock, blocked threads cannot move on. However, the threads are not blocked - they are simply too busy answering each other to resume work. This is comparable to two people trying to pass each other in the corridor: Andrey moves to the left to let Gregory pass, and Grigory moves to the right to let Andrey pass. Seeing that they are still blocking each other, Andrei moves to the right, and Gregory - to the left.

Thread Synchronization and its Application

Synchronization of threads is necessary in order to avoid the problems described above. There is a synchronized mechanism that allows threads to be synchronized

Every object in Java has an Intrinsic Lock (monitor). When a synchronized method is called from a thread, it needs to get this monitor. The monitor will be released after the thread finishes executing the method. This way we can synchronize the block of instructions working with the object by forcing the threads to get the monitor before executing the block of instructions. Remember that the monitor can only be held by one thread at a time, so other threads wishing to receive it will be suspended until the current thread exits. Only then can a specific waiting thread get the monitor and continue execution.

Stop writing code in main method

Yegor Voronianskii — Sat, 28 Nov 2020 07:19:50 +0000

Greetings to everyone who reads this post! Due to my work, I often run into novice programmers and look at their code. Sometimes it is beautiful, sometimes not, but I understand that a person learns, and the further he masters the best practices and technologies, the better his code becomes. But I would still like to pay some attention to such a simple task that almost all novice programmers face - writing a calculator

Here's what novice programmers write:

import java.util.Scanner;

public class Calculator {
    public static void main(String[] args) {
        int sum = 0;
        int number1 = 0, number2 = 0;
        boolean correct = true;
        char operation1;
        Scanner sc = new Scanner(System.in);
        System.out.println("Enter first number:");
        while (!sc.hasNextInt()) {
            System.out.println("Sorry, it is not a digit. Try again, please");
            sc.next();
        }
        number1 = sc.nextInt();
        System.out.println("Thanks! You entered number: " + number1);
        System.out.println("Enter a number:");
        while (!sc.hasNextInt()) {
            System.out.println("It is not a digit. Try again");
            sc.next();
        }
            number2 = sc.nextInt();
        System.out.println("Thanks! It is a digit " + number2);
        do {
            correct = true;
            System.out.println("What would you like to do? + - / *");
            operation1 = sc.next().charAt(0);
            switch (operation1) {
                case '+':
                    sum = number1 + number2;
                    System.out.println("Sum of this two equals to " + sum);
                    break;
                case '-':
                    sum = number1 - number2;
                    System.out.println("The difference between equals to: " + sum);
                    break;
                case '/':
                    if (number2 != 0) {
                        sum = number1 / number2;
                        System.out.println("Divied equals to: " + sum);
                    } else {
                        System.out.println("Divided by zero is not allowed.");
                        correct = false;
                    }
                    break;
                case '*':
                    sum = number1 * number2;
                    System.out.println("Multiplication of this two: " + sum);
                    break;
                default:
                    System.out.println("Unknow operation");
                    correct = false;
                    break;
            }
            } while (correct != true);
        }
    }

What problems do you see in this code? I see the following problems

Everything is written in the main method, and certainly represents more than 10 lines
There are no tests for this code, that is, there is no confidence that it will work correctly
Structural programming style - the switch statement encourages this
Using the Scanner, but it can be forgiven because it has convenient methods for getting numbers right away.

How would you fix this code? I would fix the given code as follows

Would create an Operation interface for all operations on numbers

public interface Operation {
    int execute(int a, int b);
}

And accordingly I would implement this interface in the following classes

public class Addition implements Operation {

    @Override
    public int execute(int a, int b) {
        return a + b;
    }
}

public class Deduction implements Operation {
    @Override
    public int execute(int a, int b) {
        return a - b;
    }
}

public class Division implements Operation {
    @Override
    public int execute(int a, int b) {
        return a / b;
    }
}

public class Multiplication implements Operation {
    @Override
    public int execute(int a, int b) {
        return a * b;
    }
}

I would do the same with input and output methods, but before we start writing them, let's add a very useful library - Apache Commons

<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-lang3</artifactId>
    <version>3.11</version>
</dependency>

The interface for the operation with input-output of information will look like this

public interface IO {

    int getNumber(String message, String errorMessage);

    Operation getOperation(String message);

    void printResult(String result);
}

And this is how its implementation will look like

public class ConsoleIO implements IO {

    private final BufferedReader bufferedReader;
    private final List<String> allowedOperation;
    private Map<String, Operation> operationMap;

    public ConsoleIO(final List<String> allowedOperation) {
        this.bufferedReader = new BufferedReader(new InputStreamReader(System.in));
        this.allowedOperation = allowedOperation;
        fullFillServiceMap();
    }

    @Override
    public int getNumber(String message, String errorMessage) {
        if (StringUtils.isNotBlank(message)) {
            System.out.println(message);
        }
        boolean validNumber = false;
        int numberResult = 0;
        while (!validNumber) {
            try {
                String line = bufferedReader.readLine();
                if (StringUtils.isNumeric(line)) {
                    numberResult = Integer.parseInt(line);
                    validNumber = true;
                }
            } catch (IOException e) {
                System.out.println(errorMessage);
                throw new RuntimeException(e);
            }
        }

        return numberResult;
    }

    @Override
    public Operation getOperation(String operationKey) {
        if (this.allowedOperation == null || this.allowedOperation.isEmpty()) {
            throw new IllegalStateException("Не заданы разрешенные операции");
        }
        boolean validOperation = false;
        while (!validOperation) {
            if (this.allowedOperation.contains(operationKey)) {
                validOperation = true;
            }
        }
        return operationMap.get(operationKey);
    }

    @Override
    public void printResult(String result) {
        System.out.println(result);
    }

    private void fullFillServiceMap() {
        this.operationMap = new HashMap<>();
        this.operationMap.put("+", new Addition());
        this.operationMap.put("-", new Deduction());
        this.operationMap.put("*", new Multiplication());
        this.operationMap.put("/", new Division());
    }
}

The only thing left is to write the calculator itself, that is, the operation handler

public class Calculator {

    private IO io;
    private Map<Integer, String> idOperationKeys;

    public Calculator(IO io) {
        this.io = io;
        fillMap();
    }

    public void launch() {
        boolean working = true;
        while (working) {
            int number = io.getNumber("1.Addition\n2.Substraction\n3.Multiplication\n4.Divison\n5.Exit", "Not valid number");
            if (number == 5) {
                working = false;
            } else {
              int result = 0;
                try {
                    result = io.getOperation(idOperationKeys.get(number))
                            .execute(
                                    io.getNumber("Enter first number", "Not valid number"),
                                    io.getNumber("Enter second number", "Not valid number")
                            );
                    io.printResult("The result of you operation equals to " + result);
                } catch (RuntimeException runtimeException) {
                    io.printResult(runtimeException.getMessage());
                }
            }
        }
    }

    private void fillMap() {
        idOperationKeys = new HashMap<>();
        idOperationKeys.put(1, "+");
        idOperationKeys.put(2, "-");
        idOperationKeys.put(3, "*");
        idOperationKeys.put(4, "/");
    }

}

Well, in order for our program to finally work, we will edit the main method

public class App {

    public static void main(String[] args) {
        new Calculator(
                new ConsoleIO(
                        Arrays.asList("+", "-", "*", "/")
                )
        ).launch();
    }
}

My implementation does not claim to be the best solution, however I see several advantages in it:

This code is easier to write tests
The code is open to add new functionality
No dependencies on any implementation - we use abstraction for input and output of information

That's all for me, thanks for your attention!

If you liked the article, share with your friends and like

Subscribe and leave your comments

Software Architecture #2

Yegor Voronianskii — Mon, 23 Nov 2020 05:38:48 +0000

My previous blogpost start from the house picture - as analogy about architecture. But I found some problems with this analogy:

There is no software construction industry in the same degree that there is for buildings. The building industry has substantial substructure, reflection numerous specialisations, skill sets, training paths, corporate organisations, standards bodies, and regulations. While the software industry has some structure, including that seen in offshore development practices, it is much less differentiated than the building industry
The disciple off architecture does not have anything akin to the issue of deployment in software: Software is built in one place, but deployed for use in many places, often with specialisation and localisation. Manufactured building, otherwise known as trailers, are somewhat similar, but still there is no corresponding notion to dynamic distributed, mobile architectures, as there is with software
Software is a machine; building are not (notwithstanding Le Corbusier's declaration that, "A house is machine for living in"). The dynamic character of software - the observation that led to Edsger Dijkstra's famous "goto statement considers harmful" paper (Dijkstra 1968), provides a profoundly difficult challenge to designers, for which there is not counterpart in building design

Fundamental understanding

There are three fundamental understandings of architecture, the recognition of which helps situate architecture with respect to rest of software engineering:

Every application has an architecture
Every application has at least one architect
Architecture is not a phase of development

All applications do have architectures because they all result from key design decision.
The architect is the person, or in most cases, group who makes the principal decisions about applications, who establishes and (it is hoped) maintains the foundational design.
Architecture refers to the conceptual essence of an application, the principal decision regarding its design, the key abstractions that characterise the application.

Requirements

Consideration of architecture rightly and properly begins at the outset of any software development activity. Notions of structure, design, and solution are quite appropriate during the requirements analysis activity.
In waterfall model, indeed in most process models, the initial phase of activities is focused on developing the requirement for an application - the statement of what the application is supposed to do.

Existing design and architecture provide the vocabulary for talking about what might be
Understanding of what works now, and how it works, affects our wants and perceived needs, typically in very solution-focused terms
The insights from experiences with existing system helps imagine what might work and enable to assess, at an early stage, how long we must be willing to wait for it, and how much we will need to pay for it

Design

Designing is, by definition, the activity that creates a system's software architecture -its set of principal design decisions.

The traditional design phase is not exclusively "the place or the with" when a system's architecture is developed - for that happens over the course of development - but it is a time when particular emphasis is placed on architectural concerns.
Since principal design decisions are made throughout development, designing must be seen as an spect of many other development activities
Architectural decisions are of many different kinds, requiring a rich repertoire of design techniques

The architect must deal, for example, with:

Stakeholder issues, such as choices concerning the use of proprietary, commercial off-the-shelf or open-source components, with their attendant and varying licensing obligation
Over arching style and structure
Types of connector for composing subelements
Package and primary class structure(this, is low-level style and structure when working in an object-oriented development context)
Distributed and decentralised system concerns
Deployment issues
Security and other nonfunctional properties
Post-implementation issues (means for supporting upgrade and adoption)

Design techniques

Object-oriented design

Object-oriented design (OOD) is usually tight in the context of object-oriented programming, that is, reduction of an algorithm to machine-executable form. The essence of OOD is the identification of so-called objects, which are encapsulations of state with function for accessing and manipulation that state. Numerous variations are found in different object-oriented programming languages regarding the way object are specified, related to one another, created destroyed, and so on.

OOD views all application as consisting, solely, of one software species (namely, "object"), regardless of purpose. Forcing all concepts and entities int a single mold can obfuscate important differences. The REST style, for instance, maintains distinct notions of "user agent", "origin-server", and "cache". Apart from using programming language types to try characterise these distinct elements, OOD does not offer any helpful modelling mechanism.
OOD provides only one kind of encapsulation (the object), one notion of interface, one type of explicit connector (procedure call), no real notion of structure (objects are constantly created and destroyed), and no notion of required interfaces. This implies that all richness of a given solution approach has to be mapped down or transformed to this level of single choice. Some architectures such as pipe-and-filter-may not be at all effective after such transformation
OOD is so closely related to programming language concerns and choices that it tends to have the forest obscured by the Rees. For instance, the vagaries of type inheritance may obscure identification of principal objects critical to the design. Similarly, it is so bound with programming language issues that the language may start dictating what the important decisions are.

Domain-Specific Software Architectures

This approach known as domain specific software architecture, is appropriate when prior experience and prior architectures are able to strongly influence new projects. The key notion is that if a developer or company has worked within particular application domain for many years, it is likely that a best approach or best general solution for application within that domain will have been identified. Future application in that domain can leverage this knowledge, whit those application having their fundamental architecture determined by the architecture of the past generation applications. The technical essence of the domain-specific software engineering approach is to capture and characterise the best solutions and the best practices from past projects within domain in such a way that production of new applications can focus more or less exclusively on the points of novel variation.
To effectively follow the DSSA approach, good technical support is required: The architecture of the previous generation of application must be capture and refined for reuse; the points of allowable variation must be identified and isolated, the interfaces between the points of variation and the core architecture must be made explicit, the dependencies between multiple points of variation must be identified, and so on.

Implementation and implementation strategies

The task of the implementation activity is to create machine-executable source code that is faithful to the architecture and that fully develops all outstanding details of the applications. This is true whether speaking from the perspective of classical forward engineering or from the software architecture-centric view of software engineering.
First, the implementation activity may add to or modify the architecture - if key design decisions are made while working with the source code, they are part of the architecture as much as any principal decision made much earlier in the process. Second, there is no presumption that architecture is completed before implementation begins.
The source code:

Must not utilise major new computation elements that have no corresponding elements in the architecture
Must not contain new connection between elements of the architecture (for example, such as might be motivated by efficiency concerns) that are not found in the architecture

The implementation does have an architecture: It is latent, as opposed to what is documented.
Failure to recognize this distinction:

Robs one of the ability to reason about the implemented application's architecture in the future.
Misleads all stakeholders regarding what they believe they have as opposed to what they really have
Makes any development or evolution strategy that is based on documented but inaccurate architecture doomed to failure

Analysis and testing

Analysis and testing are activities undertaken to asses the qualities of an artifact. One of the virtues of conduction analysis before code exists is cost savings: The earlier an error is detected and corrected, the lower the aggregate cost.
First, the structural architecture of an application can be examined for consistency, correctness, and exhibition of desired nonfunctional properties. If the architecture upon which the implementation is (later) based is of high quality, the prospects for a high-quality implementation are significantly raised
Second, the architectural model may be examined for consistency with requirements. Regardless of whether the requirements were developed in the classical way (that is, before any development solution notions).
Third, the architectural model may be used in determining and supporting analysis and testing strategies applied to the source code
Fourth, there architectural model can be compared to a model derived from the source code of an application. This is a form checking your answer.

Evolution and maintenance

Software evolution and software maintenance - the terms are synonymous - refer to all manner of activities that chronologically follow the release of an application. There range from bug fixes to major additions of new functionality to creation of specialised version of the application for specific markets or platforms.
The typical software engineering approach to maintenance is largely ad hoc. In a best-practices situation, each type of change cause the software process to return to whatever point. Thus, if new functionality is requested, the requires returning the requirements analysis phase and then moving forward sequence from there.

The design process

The typical assumption of software design is that the process can proceed in general manned of architectural design or engineering design, which can be summarised (Jones 1970) as consisting of the following four stages

Feasibility stage: Identifying a set of feasible concepts
Preliminary design stage: Selection and development of the best concept
Detailed design stage: Development of engineering description of the concept
Planning stage: Evaluation and altering the concept to suit the requirements of production, distribution, consumption and product retirement

Software Architecture

Yegor Voronianskii — Sun, 22 Nov 2020 08:00:34 +0000

Introduction
In this article, I will try to explain what architecture and clean architecture is, and architecture's role in projects.

Examples of web architecture application

Let's consider an example of a service with one architectural level (Single Tier)

In an application with one architectural level, the user interface, business logic, that is, the backend part of the application and the database are on the same server

An example of an application with one architectural level are applications such as MS Office, GIMP

Benefits of using a single-layer architecture

Very little or no delay in the interaction of components due to the fact that the components are located on the same server
Although it largely depends on the machine's power and software hardware requirements, to measure the real performance of a single-tier application
In addition, the user's data remains on his machine and does not need to be transferred over the network. This ensures data security at the highest level. Client data cannot be intercepted, since data exchange will occur within the same server

Disadvantages of this architecture

The impossibility of changing the code or functions after delivery to the production server. For example, in the 90s, if the game was shipped with an erroneous code, the studios could do nothing
Code in peer-to-peer applications is also vulnerable to rework and reversal. Business security is minimal, because in the case of reverse engineering, an attacker or competitor can gain access to your codebase, which can lead to financial losses. Example - your application works with finances, attackers have exposed part of your system's code and can now bypass some of your checks and thus use your application for fraud

Two-tier architecture

A two-tier application includes a client and a server. The client will contain the user interface and business logic on the same machine. And the server will be a backend application deployed on another computer.

There are times when you need to use a two-tier architecture, such as to-do list applications.

Three-tier architecture

Three-tier architecture is quite popular and often used. Most simple websites like blogs, news sites use this architecture

Let's consider an example of a simple blog - the client interface will be written using HTML, JavaScript, CSS and the backend application will be launched on a server, for example Apache, and the backend part will use the PostgreSQL database as storage

N-tier architecture

This term is used to describe an architecture that uses more than three components. Examples of these components

Cache - an example of this technology JCache, Caffeine. This technology is used for the following things - 1. Reduce the response time from the application without requesting any data in the database, 2. Also save some responses from third-party systems, since this can take a very long time
Message broker - examples are Apache Kafka, RabbitMQ. This tool is necessary to save any messages, a message can mean some kind of request to a third-party system, for example, in Kafka you can store messages that will have to be sent to the tax system or the fiscal data operator
Load balancer - examples are Nginx, Ribbon, Eureka. This tool is required to distribute the load on the application. Imagine the following situation - you have a distributed application, which means there are several instances or nodes, and in order to optimize the speed for the end user, all requests go through the balancer, which chooses a less loaded instance / node
Search services - to search for information in huge amounts of data
Components responsible for processing data arrays
Components using heterogeneous technologies, commonly known as web services

All modern social applications - Instagram, Facebook and scalable services like Uber, Airbnb, as well as games with a huge number of players like Pokemon Go, for example, use an N-tier architecture

Clean architecture

The center of your application is not the database. An architecture is also not one or more frameworks that you can use. The center of your app is the use cases for your app. The center of the application is the functionality for which the business gets paid, that is, what problem / what value does your application bring to the business - this place is the center of the application

Clean architecture is a set of practices, techniques, design patterns that enable you to create an extensible and reliable application. Designed to prevent the following problems that may arise:

Decisions are made very quickly - hasty decisions can lead to problems when the application is on the production server
Difficult to make changes
Stuck on a certain framework - one day an organization / person may decide that he / she does not have the strength to support this framework. Accordingly, you should not be strongly tied to the framework
Focusing only on technical aspects - it is important to understand that when developing, you should focus not only on technical aspects, but also on what business value the development of new functionality will bring
It's hard to find the right places in the project
Business logic is scattered throughout the code - if some requirements change, the programmer will have to find all the places in the code and change the functionality in each place. If the business logic is isolated in one place, then the programmer only needs to change the code in one place
Lack of tests
Infrequent updates Clean architecture also provides the following benefits when used
Effective testing strategy
Code for using frameworks is isolated
Database independence
All business logic is contained in the application use cases
Hard to do wrong
The application is always ready for output to the production environment

Let's analyze these figures in more detail:

The core of the application is:

Entities representing the domain area or subject area. Subject area for payment gateway application - Internet finance
At this level is the code that is applicable to the entire object as a whole (for example, checking the format of the hostname)
Java Plain Objects: no frameworks or annotations required

Core:

Represents the business actions of your application - this is what your application can do.
Pure business logic, Java code without using any frameworks, but using utilitarian libraries such as Apache Commons
Defines the interfaces for the data that are needed to apply the logic. One or more data providers implement the interface, but in case of use it is not known where the data is coming from
At this level, business exceptions are thrown - exceptions that are directly related to the application domain

Data providers (dataproviders):

Receiving and storing data from multiple sources of information (database, network devices, file system, etc.)

Application entrypoints:

This application layer describes the way to interact with the application and usually includes a delivery mechanism (for example, REST API, scheduled tasks, GUI, other systems)
Launching a use case and converting the result into a format that matches the delivery mechanism

Configuration

Connects all components together
Dependency Injection is isolated here
Contain "dirty details" - such as Main class, web server configuration, database configuration, etc.

Architectural Application Templates

An architectural pattern is a repetitive and generic solution to a problem arising from an application architecture problem within a given context.

Let's take a look at 10 popular architectural patterns

Multilevel
Client - server
Leading - slave
Channels and filters
Mediator template
Peer-to-peer template
Event bus
Model - View - Controller
Board
Interpreter

Multilevel

It is used to structure programs that can be decomposed into groups of certain subtasks located at certain levels of abstraction. Each layer provides services for the next higher layer.

Most often, there are 4 layers in common information systems:

Presentation layer (also known as user interface layer)
Application layer (also known as service layer)
Business logic layer (also known as domain layer)
Data access layer (also known as data storage layer)

Usage

Common desktop applications.
Web applications e-commerce.

Client - Server

This template consists of two parts: server and many clients . The server component provides services to the client components. Clients request services from the server, and it, in turn, provides these very services to clients. Moreover, the server continues to "eavesdrop" on client requests.

Usage

Online applications (email, document sharing, banking).

Master - Slave

This pattern also involves two participants - master and slaves. The Leader distributes tasks to identical Followers and calculates the final result based on the results received from its "Subordinates".

Usage

In database replication. There, the main database is considered an authoritative source, and the subordinate databases are synchronized with it.
Peripheral devices connected to the bus in the computer (master and slave devices).

Channels and Filters

This pattern is suitable for systems that generate and process data streams. Each processing step takes place inside a filter component. Data for processing is transmitted via channels. These channels can be used to buffer or synchronize data.

Usage

· Compilers. Sequential filters perform lexical, parsing, semantic analysis, and code generation.

· Workflows in bioinformatics.

Mediator template

This pattern is needed to structure distributed systems with disconnected components. These components can communicate with each other through a remote service call. The mediator component is responsible for coordinating the interaction of components.

The server hosts its capabilities (services and characteristics) with an intermediary (broker). The client requests a service from the broker. The broker then redirects the client to the appropriate service from its registry.

Usage

· Message brokers by type Apache ActiveMQ, Apache Kafka, RabbitMQ and JBoss Messaging.

Peer-to-peer template

There are separate components in this template, the so-called peers. Peers can act as a client requesting services from other peers (peers), and a server providing services to other peers. A peer can be a client or a server, or all at once, and can dynamically change its role over time.

Usage

· File sharing networks (Gnutella and G2)

· Multimedia Protocols (P2PTV and PDTP)

· Proprietary multimedia applications (like the same Spotify).

Event Bus

This template mainly interacts with events and has 4 main components: event source, event listener, channel and event bus. Sources place messages for specific channels on the event bus. Listeners subscribe to specific channels. Listeners are notified of the appearance of messages posted on channels from their subscription.

Usage

Android development

Notification services

Model - View - Controller

This pattern is also known as the MVC pattern. It divides interactive applications into 3 parts:

model - contains key data and functionality;
view - shows information to the user (more than one view can be specified);
controller - deals with the processing of data from the user.

This is done in order to differentiate the internal presentation of information from the way it is presented and received from the user. This design isolates components and allows for efficient code reuse.

Usage

· Architecture of WWW-applications written in the main programming languages.

· Web frameworks (for example, Django and Rails)

Board

This pattern is suitable for problems for which there are no clear deterministic solutions. The Board template has 3 main components:

· board is a structured global memory containing objects from the space of possible solutions;

· source of knowledge - specialized modules with their own presentation;

· control components - selects, configures and executes modules.

All components have access to the board. Components can produce new data objects that are added to the board. Components look for specific kinds of data on the board. One way to search is to match patterns against an existing source of knowledge.

Usage

· speech recognition;

· Identification and tracking of vehicles;

· Determination of protein structures;

· Interpretation of signals Sonar.

Interpreter

It is suitable for developing a component that must interpret programs written in a special programming language. Basically, it describes how to evaluate strings (in other words: "sentences" or "expressions") written in some particular programming language. The point is to assign a class to each character in the language.

Usage

· Languages of queries to the database (SQL);

· Languages that are used to describe data transfer protocols.

Comparison of architectural patterns

Below are the pros and cons of each of the architectural patterns.

Layered Template

Pros:

One low layer can be used by different layers of a higher rank.
Layers make standardization easier because we clearly define the levels.
Changes are made within one layer, while the other layers remain unchanged.

Cons:

Not universal.
In some situations it is possible to skip some layers.

Client / Server Template

Pros:

A set of services that clients can request is suitable for modeling.

Cons:

Requests are usually executed in separate threads on the server.
Interaction between processes increases resource consumption, because different clients have different views.

Master-Follower Template

Pros:

Accuracy, because service execution is delegated to different slaves with different implementations.

Cons:

All slaves are isolated, they have no general condition.
The waiting period in the master-slave communication is a significant disadvantage. For example, in real time systems.
Suitable only for those problems whose solution can be decomposed into parts.

Template "Channels and Filters"

Pros:

They can implement parallel processes, when input and output consist of streams, and filters begin calculations after receiving data.
Simple addition of filters. The system can be easily expanded.
Filters are suitable for reuse. They can build different pipelines, creating all kinds of combinations of the existing set of filters.

Cons:

The efficiency is reduced by the slowest filtration processes. When moving from one filter to another, data transformation is performed, which leads to increased resource consumption.

Mediator Template

Pros:

It is possible to dynamically change, add, delete and move objects. This pattern makes the distribution process transparent to the developer.

Cons:

Need to standardize service descriptions.

Peer-to-Peer Template

Pros:

Supports decentralized computing. Extremely resilient to failures at any node.
High scalability in terms of resource and computing power.

Cons:

There is no guarantee of the quality of services; nodes cooperate spontaneously.
It is difficult to guarantee security.
Performance depends on the number of nodes.

Event Bus Template

Pros:

Easily add new subscribers, publishers and connections. Works well for highly distributed applications.

Cons:

Problem with scalability, because all messages go through one event bus.

Model-View-Controller Template

Pros:

Facilitates the creation of different representations of the same model; they can be enabled or disabled at run time.

Cons:

The complexity of the algorithm increases. Can lead to many unnecessary adjustments to user actions.

Board Template

Pros:

Easy adding of new applications.
You can easily expand the data space structures.

Cons:

Editing data structures is really difficult because such changes affect all applications.
Synchronization and access control may be required.

Template "Interpreter"

Pros:

Highly dynamic behavior possible.
An excellent solution for end users in terms of programming convenience.

Cons:

Performance problems as an interpreted language is slower than a compiled one.