DEV Community: Elattar Saad

Spring streaming response made easy

Elattar Saad — Wed, 10 Sep 2025 19:34:52 +0000

In certain scenarios, we need to retrieve large volumes of data, yet we often experience delays before the first pieces of the response are displayed. Fortunately, this is a well-known problem, and an effective solution exists.

TechStack

This project is built using:

Java 24.
Spring boot 3.5.5 with WebFlux.
Postgres (or any DB you want)

Use case

Simply, we need 1 million products (json objects) in the GET endpoint.

this is a simple SQL script to create and fill the products table:

-- Create table
CREATE TABLE IF NOT EXISTS products (
    id SERIAL PRIMARY KEY,
    name VARCHAR(255) NOT NULL,
    price NUMERIC(10,2) NOT NULL
);

-- Insert 100,000 products
INSERT INTO products (name, price)
SELECT
    'Product ' || i,
    ROUND((RANDOM() * 1000)::numeric, 2)
FROM generate_series(1, 1000000) AS s(i);

Next the entity and JPA repository:

@Entity
@Table(name = "products")
public class Product {
    @Id
    private Long id;
    private String name;
    private Double price;

    public Product() {
    }

    public Product(Long id, String name, Double price) {
        this.id = id;
        this.name = name;
        this.price = price;
    }

    public Long getId() {
        return id;
    }

    public String getName() {
        return name;
    }

    public Double getPrice() {
        return price;
    }

    @Override
    public String toString() {
        return "Product[" +
                "id=" + id + ", " +
                "name=" + name + ", " +
                "price=" + price + ']';
    }
}

import org.springframework.data.jpa.repository.JpaRepository;

public interface ProductRepository extends JpaRepository<Product, Long> {
}

Any database can be used here, I'm just used to postgres due to my daily work.

Traditional endpoints

Nothing fancy for our traditional endpoint, a simple find all GET:

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

    private final ProductRepository productRepository;

    public ProductController(ProductRepository productRepository) {
        this.productRepository = productRepository;
    }

    @GetMapping
    public List<Product> getAll(){
       return productRepository.findAll();
    }
}

While using this endpoint, the client needs to wait before exploiting the first returned product, or even worse, the response size is too big to be handled properly:

Streaming Response to the rescue

Using StreamingResponseBody, we can stream our products one by one and save some time :)

@GetMapping("/stream")
    public StreamingResponseBody getAllStreamed(HttpServletResponse response){
       response.setContentType("text/event-stream");
       return outputStream -> {
           productRepository.findAll()
                    .forEach(product -> {
                        try {
                            String json = new ObjectMapper().writeValueAsString(product) + "\n";
                            outputStream.write(json.getBytes());
                            outputStream.flush();
                        } catch (JsonProcessingException e) {
                            log.error("Error parsing product to json", e);
                        } catch (IOException e) {
                            log.error("Error writing object to stream", e);
                        }
                    });
    };
}

On another level

You may already noticed that we loop over the products and write one by one to the output stream, this can be improved even more by streaming data end-2-end from the data source to the client; For that purpose solutions like Spring Webflux and JPA streams exist.
(The resources are just below :D)

Resources

Streaming with JPA `Stream<T>`

The best way to use Spring Data JPA Stream methods

Server-Sent Events (SSE) / Reactive

Read this article and more on my website: https://www.saadelattar.me/article/spring-response-streams

Blossoming Intelligence: How to Run Spring AI Locally with Ollama

Elattar Saad — Sat, 11 May 2024 15:21:58 +0000

Nobody can dispute that AI is here to stay. Among many of its benefits, developers are using its capability to boost their productivity.
It is also planned to become accessible for a fee as a SaaS or any other service once it has gained the necessary trust from enterprises.
Still, We can run pre-trained models locally and incorporate them into our current app.

In this short article, we'll look at how easy it is to create a chat bot backend powered by Spring and Olama using the llama 3 model.

TechStack

This project is built using:

Java 21.
Spring boot 3.2.5 with WebFlux.
Spring AI 3.2.5.
Ollama 0.1.36.

Ollama Setup

To install Ollama locally, you simply need to head to https://ollama.com/download and install it using the proper executable to your OS.

You check is installed by running the following command:



ollama --version

You can directly pull a model from Ollama Models) and run it using the ollama cli, in my case I used the llama3 model:



ollama pull llama3 # Should take a while.
ollama run llama3

Let's test it out with a simple prompt:

To exist, use the command:



/bye

Talking Spring

The Spring will have the following properties:



spring.ai.ollama.base-url=http://localhost:11434
spring.ai.ollama.chat.model=llama3

Then is our chat package, will have a chat config bean to handle:



package io.daasrattale.generalknowledge.chat;

import org.springframework.ai.chat.ChatClient;
import org.springframework.ai.ollama.OllamaChatClient;
import org.springframework.ai.ollama.api.OllamaApi;
import org.springframework.ai.ollama.api.OllamaOptions;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class ChatConfig {


    @Bean
    public ChatClient chatClient() {
        return new OllamaChatClient(new OllamaApi())
                .withDefaultOptions(OllamaOptions.create()
                        .withTemperature(0.9f));
    }
}

FYI, Model temperature is a parameter that controls how random a language model's output is.
A temperature is set to 0.9 to make the model more random and willing to take more risks on the answers.

The last step is to create a simple Chat rest controller:



package io.daasrattale.generalknowledge.chat;

import org.springframework.ai.ollama.OllamaChatClient;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import reactor.core.publisher.Mono;

@RestController
@RequestMapping("/v1/chat")
public class ChatController {


    private final OllamaChatClient chatClient;

    public ChatController(OllamaChatClient chatClient) {
        this.chatClient = chatClient;
    }

    @GetMapping
    public Mono<ResponseEntity<String>> generate(@RequestParam(defaultValue = "Tell me to add a proper prompt in a funny way") String prompt) {
        return Mono.just(
                ResponseEntity.ok(chatClient.call(prompt))
        );
    }


}

Let's try and call a GET /v1/chat with an empty prompt:

What about a simple general knowledge question:

Of course, let's ask for some code:

The api url provided is not OK, still the rest of the code works.

Finally

Using models locally with such ease and simplicity can be considered as a true added value, still, the used models must be heavily inspected.

You can find the source code on this Github Repository make sure to star it if you find it useful :))

Resources

https://spring.io/projects/spring-ai

https://docs.spring.io/spring-ai/reference/api/clients/ollama-chat.html

React 19: The long-expected features

Elattar Saad — Wed, 17 Apr 2024 03:52:32 +0000

React 19 introduces a number of new features that will undoubtedly make the life of react developers simpler. While the release is not yet stable, you can test out the new features using the canary version.



npm i react@canary react-dom@canary

React Forget

The react compiler (called "React Forget") in version 19 is nothing short of game-changing. Whiles some solutions included their own compilers to maximize developer efficiency, React initially solely operated in the browser.

Once a compiler is in place, React developers can concentrate on creating business features rather than worrying about things like momoization.
Yes, you heard that righ the momoization hooks (useMemo and useCallback) and memo API will no longer be needed since
the compiler will be handling that automatically and more efficiently without compromising the application performance nor the code base quality.

The React compiler is already been deployed in Instagram web app Production. You can see it in action in this ReactAdvanced Conf talk by Joe Savona and Mofei Zhang.

Actions

React 19 introduces the ability to run actions on either the server or the client using the directives "use client"
or "use server". Previously, Server Actions were used to transport data from the client to the server.
As a result, we now refer to them as "actions".

If you're acquainted with NextJs, the directives will come as no surprise.

To manage async actions, React provides a useFormStatus and useFormState hooks to handle the pending status and state to prevent multiple submissions of a form for instance.

Hooks

React 19 came with a set of new hooks that will either replace existing hooks or support the new of its features.

useFormStatus



import { useFormStatus } from "react-dom";
import action from './actions';

function Submit() {
  const {pending} = useFormStatus(); // will return {pending, data, method, action}
  return <button disabled={pending}>Submit</button>
}

export default function App() {
  return (
    <form action={action}>
      <Submit />
    </form>
  );
}

useFormState

The actions can also return values, in that case we need use the useFormState hook.



import { useFormState } from "react-dom";

async function increment(previousState, formData) {
  return previousState + 1;
}

function StatefulForm({}) {
  const [state, formAction] = useFormState(increment, 0);
  return (
    <form>
      {state}
      <button formAction={formAction}>Increment</button>
    </form>
  )
}

Know more about the useFormStatus and useFormState hooks.

useOptimistic

The useOptimistic hook can be used to provide the user with a temporary ui based on what they already submitted,
for instance showing the newly sent message while the data is processed on the server.



import { useOptimistic, useState, useRef } from "react";
import { deliverMessage } from "./actions.js";

function Thread({ messages, sendMessage }) {
  const formRef = useRef();
  async function formAction(formData) {
    addOptimisticMessage(formData.get("message")); // we get the input of the user; used to build the temp ui.
    formRef.current.reset(); // reset the form.
    await sendMessage(formData); // sending the data to the server asynchronosly.
  }
  const [optimisticMessages, addOptimisticMessage] = useOptimistic(
    messages,
    (state, newMessage) => [
      ...state,
      {
        text: newMessage,
        sending: true
      }
    ]
  );

  return (
    <>
      {optimisticMessages.map((message, index) => ( // getting the newly sent messages, mapping them into dom elements (optimistic UI).
        <div key={index}>
          {message.text}
          {!!message.sending && <small> (Sending...)</small>}
        </div>
      ))}
      <form action={formAction} ref={formRef}> {/* Just a simple form with action and ref*/}
        <input type="text" name="message" placeholder="Hello!" />
        <button type="submit">Send</button>
      </form>
    </>
  );
}

// Putting the Thread component in action by providing a state.
export default function App() {
  const [messages, setMessages] = useState([
    { text: "Hello there!", sending: false, key: 1 }
  ]);
  async function sendMessage(formData) {
    const sentMessage = await deliverMessage(formData.get("message"));
    setMessages((messages) => [...messages, { text: sentMessage }]);
  }
  return <Thread messages={messages} sendMessage={sendMessage} />;
}

Know more about the useOptimistic hook.

useCallback and useMemo

As previously stated the momoization will be handled by the React Compiler, therefor the useMemo,
useCallback hooks and memo API won't make it to the version 19 of React.

use

The use hook is here to clean more the react code base, it will replace two widly used hooks (thank God): useEffect and useContext.

One of the famous use cases for the useEffect hook is data fetching, for this example we fetch the user details and return a UserProfile:




  // Using useEffect hook to fetch data.
  export const UserProfile = () => {
    const [userDetails, setUserDetails] = useState(null);

    useEffect(()=>{
      getUserDetails() // async function
        .then(data => {
          setUserDetails(data);
        })
        .catch(error => console.log(error))
    },[])

    if (!userDetails) return <p>Loading...</p>

    return (
      <p>{userDetails.name}</p>
    )

  }

  // Using use hook to fetch data.
  export const UserDetails = () => {  // another component for simplicity
    const userDetails = use(getUserDetails());
    return (
       <p>{userDetails.name}</p>
    )
  }

  export const UserProfile = () => {
    return (
      <Suspense fallback={<p>Loading...</p>}>
      <p>{userDetails.name}</p>
      </Suspense>
    )
  }

The use hook will also be replacing the useContext hook:



// Using useContext hook to consume the theme context.

const theme = useContext(ThemeContext);

// Using use hook to consume the theme context

const theme = use(ThemeContext);

ForwardRef

No more forwardRef! We can simply pass the ref down like any other prop without the use of forwardRef.



// Before

export const ProfilePicture = forwardRef(

  (props, ref) => ( // src and alt are props

    <img ref={ref} {...props}/>

  )

)

// On v19

export const ProfilePicture = (ref, ...props) => {

  <img ref={ref} {...props}/>

}

SEO

React will enable the usage of the <title>, <meta>, and <link> tags anywhere in the App, improving SEO performance.
Previously, libraries like as react-helmet were used for this.

Summary

In my perspective, React v19 will deliver a lot of relevant and required enhancements, allowing developers to focus more on important features that matter!

Resources

https://react.dev/blog/2024/02/15/react-labs-what-we-have-been-working-on-february-2024#react-compiler
https://react.dev/blog/2023/03/22/react-labs-what-we-have-been-working-on-march-2023#react-optimizing-compiler
https://www.youtube.com/watch?v=qOQClO3g8-Y
https://react.dev/reference/react/

Just a simple Songs API using Spring Reactive with Functional Endpoints, Docker and MongoDB

Elattar Saad — Thu, 29 Feb 2024 00:55:13 +0000

Blocking is a feature of classic servlet-based web frameworks like Spring MVC. Introduced in Spring 5, Spring WebFlux is a reactive framework that operates on servers like Netty and is completely non-blocking.

Two programming paradigms are supported by Spring WebFlux. Annotations (Aspect Oriented Programming) and WebFlux.fn (Functional Programming).

"Spring WebFlux includes WebFlux.fn, a lightweight functional programming model in which functions are used to route and handle requests and contracts are designed for immutability. It is an alternative to the annotation-based programming model but otherwise runs on the same Reactive Core foundation." Spring | Functional Endpoints

Project Description

As the title describe, this is a simple Songs API build using Spring, Docker and MongoDB, the endpoints are Functional Endpoints and will have the traditional ControllerAdvice as Exception handler.

Project Dependencies

Java Version 21
Spring Boot version 3.3.0-SNAPSHOT with Spring Reactive Starter.
Spring Docker Support.
Lombok (Optional).

Talking XML these are the project dependencies:



<dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-mongodb-reactive</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-webflux</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-docker-compose</artifactId>
            <scope>runtime</scope>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>io.projectreactor</groupId>
            <artifactId>reactor-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

Coding time!

First, let's setup the docker compose file /compose.yaml of the project (it should generated by spring via the docker support starter).



services:
  mongodb:
    image: 'mongo:7.0.5'
    environment:
      - 'MONGO_INITDB_DATABASE=songsDB'
      - 'MONGO_INITDB_ROOT_PASSWORD=passw0rd'
      - 'MONGO_INITDB_ROOT_USERNAME=root'
    ports:
      - '27017'

With that set, let's create the Song class:




import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Getter;
import lombok.Setter;
import org.springframework.data.annotation.Id;
import org.springframework.data.mongodb.core.mapping.Document;

import java.util.UUID;

@Document
@Getter
@Setter
@AllArgsConstructor
@Builder
public class Song {
    @Id
    private UUID id;
    private String title;
    private String artist;
}

The SongRepository interface will be referring to the Song class in its DB ops:



import org.springframework.data.repository.reactive.ReactiveCrudRepository;
import org.springframework.stereotype.Repository;
import reactor.core.publisher.Flux;

import java.util.UUID;

@Repository
public interface SongRepository extends ReactiveCrudRepository<Song, UUID> {

    Flux<Song> findAllByArtist(final String artist);

}

Song Functional Endpoint and Handler

Now, it's time for the Song Router, it will be responsible for router the incoming requests for the /songs ressource:



import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.reactive.function.server.RouterFunction;
import org.springframework.web.reactive.function.server.ServerResponse;

import static org.springframework.web.reactive.function.server.RouterFunctions.route;

@Configuration
public class SongRouterConfig {

    private final SongHandler handler;

    public SongRouterConfig(SongHandler handler) {
        this.handler = handler;
    }

    @Bean
    public RouterFunction<ServerResponse> router() {
        return route().path("/songs", builder -> builder
                .GET("/artist", handler::findAllByArtist)
                .GET(handler::findAll) // Get endpoints' order is important
                .POST("/new", handler::create)
                .DELETE("/{id}", handler::delete)
        ).build();
    }
}

As you noticed the request are redirected to the SongHandler for a certain logic to be performed.

Note: If you having trouble understanding the syntax, make sure to know more about Java functional interfaces, lambda and method references.

The SongsHandler will act as Service as well, will perform a business logic and communicate with the SongRepository for operations with the database.



import io.daasrattale.webfluxmongofunctionalendpoints.song.exceptions.InvalidParamException;
import io.daasrattale.webfluxmongofunctionalendpoints.song.exceptions.InvalidUUIDException;
import org.springframework.http.HttpStatus;
import org.springframework.stereotype.Service;
import org.springframework.web.reactive.function.server.ServerRequest;
import org.springframework.web.reactive.function.server.ServerResponse;
import reactor.core.publisher.Mono;

import java.util.Optional;
import java.util.UUID;

@Service
public class SongHandler {

    private final SongRepository repository;

    public SongHandler(SongRepository repository) {
        this.repository = repository;
    }

    public Mono<ServerResponse> findAll(final ServerRequest request) {
        return ServerResponse
                .ok()
                .body(repository.findAll(), Song.class);
    }

    public Mono<ServerResponse> findAllByArtist(final ServerRequest request) {
        return Mono.just(request.queryParam("artist"))
                .switchIfEmpty(Mono.error(new InvalidParamException("artist")))
                .map(Optional::get)
                .map(repository::findAllByArtist)
                .flatMap(songFlux -> ServerResponse
                        .ok()
                        .body(songFlux, Song.class));
    }

    public Mono<ServerResponse> create(final ServerRequest request) {
        return request.bodyToMono(Song.class)
                .switchIfEmpty(Mono.error(new RuntimeException("Song body not found"))) // you can use that or create a custom exception (recommended)
                .doOnNext(song -> song.setId(UUID.randomUUID()))
                .flatMap(song -> ServerResponse
                        .status(HttpStatus.CREATED)
                        .body(repository.save(song), Song.class)
                );
    }

    public Mono<ServerResponse> delete(final ServerRequest request) {
        return Mono.just(request.pathVariable("id"))
                .map(UUID::fromString)
                .doOnError(throwable -> {
                    throw new InvalidUUIDException(throwable);
                })
                .flatMap(songId -> ServerResponse
                        .ok()
                        .body(repository.deleteById(songId), Void.class)
                );
    }
}

Note: The SongHandler can be annotated with @Component, since it performs a business logic I see it better have the @Service annotation instead.

Exception Handling

As previously states, will be using the same old ControllerAdvice as Exception handler with two custom Exceptions as the following:

Custom Exceptions



import lombok.Getter;

@Getter
public class InvalidParamException extends RuntimeException {

    private final String paramName;

    public InvalidParamException(final String paramName) {
        this.paramName = paramName;
    }
}



import lombok.Getter;

@Getter
public class InvalidUUIDException extends RuntimeException {

    private final Throwable cause;

    public InvalidUUIDException(final Throwable cause) {
        this.cause = cause;
    }
}

Custom Exception Handler



import io.daasrattale.webfluxmongofunctionalendpoints.song.exceptions.InvalidUUIDException;
import lombok.extern.slf4j.Slf4j;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;

import java.util.Map;

@ControllerAdvice
@Slf4j
public class SongExceptionHandler {


    @ExceptionHandler(InvalidUUIDException.class)
    public ResponseEntity<Map<String, ?>> handle(final InvalidUUIDException exception) {
        return ResponseEntity
                .badRequest()
                .body(
                        Map.of(
                                "status", 400,
                                "message", "Invalid UUID",
                                "details", exception.getCause().getMessage()
                        )
                );
    }

    @ExceptionHandler(Exception.class)
    public ResponseEntity<Map<String, ?>> handle(final Exception exception) {
        log.error("Unhandled Error, message: {}", exception.getMessage());
        return ResponseEntity
                .internalServerError()
                .body(
                        Map.of(
                                "status", 500,
                                "message", "Unknown Error",
                                "details", exception.getMessage()
                        )
                );
    }
}

With all that been set, let's make use of our endpoint using Postman:

Creating a new Song

Getting songs by artist:

Getting all songs:

Deleting a song:

Sorry not a big fan of Madonna tbh :|

Checking the result of the delete op:

Finally,

With that said, our functional songs endpoint will be good to go for further improvements and new features.
This is simple, in real industrial projects, I can assure you things get complicated with more layers, for "getting started" purposes I avoided the use of advanced concepts such as validation, DTO, etc.

You can find the full source here

Also find more content on my personal personal website.

Spring cloud: introduction to service discovery using netflix eureka

Elattar Saad — Fri, 11 Feb 2022 23:16:18 +0000

Micro-services are all good until they come with their distributed challenges which normally we don't face in monolithic based applications. Just like this one!

Understanding the problem

In order to fully get the main purpose of the solution let us first understand the underlying problem.

As the diagram above shows, we have to micro-services communicating via a certain network:

Micro-service I with the IP address 10.10.10.10, and port 8080
Micro-service II with the IP address 20.20.20.20, and port 8090

All working peacefully until the second micro-service changed its address and port for some reason.

As result the micro-service I cannot communicate with micro-service II since it doesn't have the new address and port (30.30.30.30:5000).
To resolve this we need to provide manually the micro-service I with the micro-service II's new address and port. What if we can do that automatically?

The answer is YES, and that's exactly what Netflix Eureka does.

Eureka under the hood

The first thing MS2 will do is to register to the naming registry server (Eureka server) providing mainly its IP, port and status (UP or DOWN). [A]

Before MS1 makes the call to MS2 [D], it will fetch the MS2 coordinates from the naming registry [B] which will allow the communication to happen even if MS2 changes its location a million times as long as its registers to the Eureka server. The server will respond with the required data. [C]

You should also understand that by fetching the naming registry or registering to it, the micro-service becomes its client (Eureka client).

Let's talk code

For this tutorial I'll be using:

Spring Boot 2.6.2



<parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.6.2</version>
        <relativePath/> <!-- lookup parent from repository -->
</parent>

Java 8 && Spring cloud 2021.0.0



<properties>
        <java.version>1.8</java.version>
        <spring-cloud.version>2021.0.0</spring-cloud.version>
</properties>

and of course the dependency management for the spring cloud modules



<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>

Eureka server configuration

The Eureka server require the Spring Cloud starter netflix eureka server dependency



<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
</dependency>

Then, we need a set of properties as the following



# Setting a name for out app
spring:
  application:
    name: registry-server

# Simply telling Eureka server to NOT fetch or register to any server since it's not a client.
eureka:
  client:
    register-with-eureka: false
    fetch-registry: false

Finally, we need to declare our app as a registry service using the @EnableEurekaServer annotation:



@SpringBootApplication
@EnableEurekaServer
public class RegistryEurekaServerApplication {

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

}

You can find a user interface generated by Eureka, for our case is on localhost:8099

Eureka client configuration

The Eureka client require the Spring Cloud starter netflix eureka client dependency



<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>

Also for this one, we need a set of properties:



# Setting a name for out app
spring:
  application:
    name: registry-eureka-client

eureka:
  client:
    # To register to the eureka server
    registerWithEureka: true

    # To fetch the registry from the eureka server
    fetchRegistry: true

    # The location of the eureka server
    serviceUrl:
      defaultZone: http://localhost:8099/eureka/

  instance:
    # The instance hostname
    hostname: localhost

    # The instance unique id
    instanceId: ${eureka.instance.hostname}:${spring.application.name}

    # A bench of health information end-points provided by eureka
    statusPageUrl: http://${eureka.hostname}/
    healthCheckUrl: http://${eureka.hostname}/actuator/health
    secureHealthCheckUrl: http://${eureka.hostname}/actuator/health

Finally, we need to declare our app as a discovery client (Eureka client) using the @EnableDiscoveryClient annotation:



@SpringBootApplication
@EnableDiscoveryClient
public class RegistryEurekaClientApplication {

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

Once, we start our client app, we will notice that it successfully registered to the running eureka server.

And on the UI dashboard, you can see this:

This may seem incomplete, actually it is, since we're not fetching the eureka server for registered service instances and exploit them. That's the main purpose of the next article when we will be doing so using a reverse proxy called Netflix Zuul.

More articles Here.

Spring internal micro-service driven communication

Elattar Saad — Sat, 01 Jan 2022 20:04:18 +0000

During the solution architecture phase, especially when we're talking micro-services, we need a sort of internal exchange
of data, they're many tools to do so, such as Spring rest template and web client, but I'm using the one I find the simplest of them all:
Yes, OpenFeign!

Installing OpenFeign

First, we add the OpenFeign dependency (inside the pom.xml file), so it will be imported by Maven (our dependency manager).



<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-openfeign</artifactId>
    <version>3.1.0</version>
</dependency>

<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>

As you already noticed, we are using a tool which belongs to the spring cloud project, as result, we need to set the Spring cloud version we're using.
In side the properties tag, we'll add both, java and spring cloud versions:



<properties>
    <java.version>1.8</java.version>
    <spring-cloud.version>2021.0.0</spring-cloud.version>
</properties>

Please note that I'm using Spring boot version 2.6.1

Also note that I'll be using the movies project from the previous articles

After having all the needed dependencies, we still have to declare our app is using OpenFeign in a certain package.
We decorate our main class with the @EnableFeignClients with the target package which will have the feign clients.



@SpringBootApplication
@EnableFeignClients("io.xrio.movies.controller.client")
public class MoviesApplication {
  ...
}

OpenFeign client implementation

In the the implementation, I will be sending a simple get request to the jsonplaceholder API (acting as the second micro-service) to get a list of posts using OpenFeign:

In order to make use the Json/POJO auto-conversion which Spring Boot offers, we'll be using a DTO to manipulate the received/sent data (posts).

Inside the controller > dto package, we create the PostDTO.java file:



@Data
public class PostDTO {

    private Long id;
    private Long userId;
    private String title;
    private String body;

}

Note that the structure of the DTO is defined by the response of the jsonplaceholder API.

Next, we create our post client (feign client), which is going to be like the following:



@FeignClient(name = "jsonplaceholder", url = "https://jsonplaceholder.typicode.com/posts")
public interface PostClient {

    @GetMapping
    List<PostDTO> getPosts();

}

@FeignClient will declare this interface as a feign client in order to be implemented according to our needs.

The name attribute mainly useless in this case since we're not addressing the api with a name, but using its url instead. The name is used when a naming registry is integrated (a future article is on the way).

And just like magic, that's all for our client!

Now we need to call our client and return the response to our user. We'll create a PostController which does just that:



@RestController
@RequestMapping("post")
@AllArgsConstructor
public class PostController {

    final PostClient postClient;

    @GetMapping
    public List<PostDTO> getPosts(){
        return postClient.getPosts();
    }


}

Finally, that's what you will get when invoking this PostController method:

More articles Here.

Spring Boot optional request params

Elattar Saad — Sun, 05 Dec 2021 16:05:18 +0000

Sometimes the job description forces us into a scenario where the request param (or query params) are not always needed or required. The obvious way to get the job done is to check simply if the param is null or not. Let's try this and another smarter way using Optionals which come with Java since its version 8.

Method 1: Using required attribute

As simple as the following, we'll set the required attribute to false and check if there's a value in the associated variable:



@GetMapping("/params")
public String getWithParam(@RequestParam(required = false) String name){
    if(name == null){
        return "Hello Anonymous";
    }
    return "Hello "+name;
}

Method 2: Using Java 8 Optionals

This time we'll be doing the same using Optionals:



@GetMapping("/params")
public String getWithParam(@RequestParam Optional<String> name){
    if(name.isPresent()){
        return "Hello "+name.get();
    }
    return "Hello Anonymous";
}

Or even in an advanced way:



@GetMapping("/params")
public String getWithParam(@RequestParam Optional<String> name){
    return  "Hello "+ name.orElse("Anonymous");
}

More articles Here.

Spring Boot validation and bean manipulation

Elattar Saad — Tue, 21 Sep 2021 12:33:16 +0000

Secure applications follow several security measures during their dev and prod phases, the app entry points are one of the most important parts to secure due to the risk of data injection that may occur. Spring proposes its way of data validation which improves controlling these particular points.

As you've already guessed, this article is about more than just data validation; it's also about bean or custom data structure manipulation, which are two important applicative security features that every developer should be aware of.

Enough introductions, for now, let's start with a global blueprint of what we need to achieve, you need to know that both mechanisms resolve two security vulnerabilities:

Injection attacks
Database schema exposure

Sounds bad right? Well, the solution is actually simpler than you think. First, let's understand both problems before jumping to the solutions.

Injection attacks

An injection attack is when malicious code is injected into the network and retrieves all of the data from the database and sends it to the attacker.
As you concluded the attack uses the open door of your app to gain all the stored data, and it can disguise, the attack, in many types such as XSS, SQL, XPath, Template, code, CRLF, LDAP, OS command injections, and more.
If you're using ORM operations you're not totally safe, but you're one step ahead. The more defenses you raise the better.

Database schema exposure

Mainly when this occurs, it doesn't come with a great benefit for the attackers, but it still delivers a piece of valuable information, which is the way you constructed your schemas, data types, and relations, in some scenarios it becomes critical.

Data validation

During this tutorial, we will be based on our last Movies API.

First, let's add the Spring boot validation dependency to our pom.xml file.



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

Second, we'll enhance our movie model with some validation rules.



// other imports
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.validation.constraints.Max;
import javax.validation.constraints.Min;
import javax.validation.constraints.NotBlank;
import javax.validation.constraints.NotNull;

@Data
@Entity
public class Movie {

    @Id
    @GeneratedValue(strategy = GenerationType.SEQUENCE)
    @NotNull(message = "Id must not be null")
    private Long id;

    @NotBlank(message = "Name must not be blank")
    private String name;

    @NotBlank(message = "Type must not be blank")
    private String type;

    @Min(value = 1, message = "Movies are mainly more than a minute")
    @Max(value = 300, message = "Movies are less than 5 hours")
    private Long duration;

    @NotNull(message = "Release year must not be null")
    private Long releaseYear;

}

Third, we alter our controller end points' signatures so they can validate incoming request bodies and throw Exception instead of custom exceptions.



...

import javax.validation.Valid;

@RestController
@RequestMapping("movie")
@Data
public class MovieController {

    ...

    @PostMapping("/")
    public ResponseEntity<?> save(@Valid @RequestBody Movie movie) throws Exception {
        if (movie == null)
            return ResponseEntity.badRequest().body("The provided movie is not valid");
        return ResponseEntity.status(HttpStatus.CREATED).body(movieService.save(movie));
    }

    @PutMapping("/")
    public ResponseEntity<?> update(@Valid @RequestBody Movie movie) throws Exception {
        if (movie == null)
            return ResponseEntity.badRequest().body("The provided movie is not valid");
        return ResponseEntity.ok().body(movieService.update(movie));
    }

    ...

}

The @valid makes sure that the incoming body is valid, otherwise a MethodArgumentNotValidException will be thrown

Obviously, we removed the custom-made exception and replaced it with the Exception class so the controller won't suppress the exception in the controller layer and let the default exception handler interfere, which will cause a 500 server internal error. Instead, it will be handled by the exception handler we’re about to make.



package io.xrio.movies.controller.advice;

import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.validation.FieldError;
import org.springframework.web.bind.MethodArgumentNotValidException;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseStatus;

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

@ControllerAdvice
public class ValidationExceptionHandler {

    @ExceptionHandler(MethodArgumentNotValidException.class)
    public ResponseEntity<?> handleValidationExceptions(MethodArgumentNotValidException exception) {
        Map<String, String> errors = new HashMap<>();
        exception.getBindingResult().getAllErrors().forEach((error) -> {
            String fieldName = ((FieldError) error).getField();
            String errorMessage = error.getDefaultMessage();
            errors.put(fieldName, errorMessage);
        });
        return ResponseEntity.badRequest().body(errors);
    }
}

Just like our previous Movie exception handler, this ControllerAdvice based handler will target the MethodArgumentNotValidException type exceptions and resolve them by retrieving the validation violation, wrap it in a response entity and send it back to the user with 400 bad request response code.

NOTE: Returning the validation violations to the user is a huge blender, it's like telling a house robber why they failed to rob your own house.

To counter this, we'll print them on the logs, which are by the way are accessible only to the prod env admins. Our Exception will be like this:



import lombok.extern.slf4j.Slf4j;

...

@ControllerAdvice
@Slf4j
public class ValidationExceptionHandler {

    @ExceptionHandler(MethodArgumentNotValidException.class)
    public ResponseEntity<?> handleValidationExceptions(MethodArgumentNotValidException exception) {
        exception.getBindingResult().getAllErrors().forEach((error) -> {
            String fieldName = ((FieldError) error).getField();
            String errorMessage = error.getDefaultMessage();
            log.error(fieldName + ": " + errorMessage);
        });
        return ResponseEntity.badRequest().body("Sorry, that movie you sent sucks :)");
    }
}

Sending the same request will result this:

And only prod env admins can see this:

The @Slf4j is a short way using Lombok to call the logger.

Data validation not only is a layer to counter injection attacks, but it helps keep your data nice and clean.

Since we still exposing our model in our end-points, it's time to change that!

Data manipulation

Introduction to the DTOs

The data transfer objects, also known as Value Objects (VOs), will be the ones carrying data between two processes, in our case, it will be their structure that will be exposed instead of the model's.

Our MovieDTO will be like the following:



import lombok.Data;

import javax.validation.constraints.Max;
import javax.validation.constraints.Min;
import javax.validation.constraints.NotBlank;
import javax.validation.constraints.NotNull;

@Data
public class MovieDTO {

    @NotNull(message = "Id must not be null")
    private Long id;

    @NotBlank(message = "Name must not be blank")
    private String name;
    @NotBlank(message = "Type must not be blank")
    private String type;
    @Min(value = 1, message = "Movies are mainly more than a minute")
    @Max(value = 300, message = "Movies are less than 5 hours")
    private Long duration;
    @NotNull(message = "Release year must not be null")
    private Long releaseYear;

}

Since the DTOs are the ones to be exposed, we added some validation rules.

Okay, we have the DTOs exposed, but how are we going to persist data using DTOs?

The answer is that DTOs only exist in the controller layer, in other words, we can't use them on the service and repository layers.

Also means our need for a conversion mechanism, yes, we need a MovieConverter.

Let's start with the integration of the ModelMapper dependency which will help convert models and DTO in both ways:



<dependency>
    <groupId>org.modelmapper</groupId>
    <artifactId>modelmapper</artifactId>
    <version>2.3.5</version>
</dependency>

Then, we add its basic configuration so it will treated as Spring Bean:




import org.modelmapper.ModelMapper;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class ModelMapperConfig {

    @Bean
    public ModelMapper modelMapper() {
        return new ModelMapper();
    }
}

I don't like repeating myself (DRY priciple) that's why I always put redundant behavior into generic classes, the AbstractConverter will do that for us:




import java.util.ArrayList;
import java.util.List;

public abstract class AbstractConverter <DM, DTO> {

    public abstract DM convertToDM(DTO dto);

    public abstract DTO convertToDTO(DM dm);

    public List<DM> convertToDMs(List<DTO> dtos) {
        List<DM> dms = new ArrayList<>();
        for (DTO dto : dtos) dms.add(convertToDM(dto));
        return dms;
    }

    public List<DTO> convertToDTOs(List<DM> dms) {
        List<DTO> dtos = new ArrayList<>();
        for (DM dm : dms) dtos.add(convertToDTO(dm));
        return dtos;
    }

}

Our MovieConverter will inherit from the AbstractConverter with the movie model and DTO as class params.



import io.xrio.movies.dto.MovieDTO;
import io.xrio.movies.model.Movie;
import org.modelmapper.ModelMapper;
import org.modelmapper.config.Configuration;
import org.springframework.stereotype.Component;

@Component
public class MovieConverter extends AbstractConverter<Movie, MovieDTO> {

    private final ModelMapper modelMapper;

    public MovieConverter(ModelMapper modelMapper) {
        modelMapper.getConfiguration()
                .setFieldMatchingEnabled(true)
                .setFieldAccessLevel(Configuration.AccessLevel.PRIVATE);
        this.modelMapper = modelMapper;
    }

    @Override
    public Movie convertToDM(MovieDTO movieDTO) {
        return modelMapper.map(movieDTO, Movie.class);
    }

    @Override
    public MovieDTO convertToDTO(Movie movie) {
        return modelMapper.map(movie, MovieDTO.class);
    }
}

I decorated the MovieConverter with the @Component annotation so it can be injected into the MovieController later.

The model mapper will be configured in the MovieConverter constructors with a simple configuration, and with the model and DTO having the same fields, the mapping will be possible for now.

Before testing our converter, we need to inject it into the controller, then alter the endpoints so they can handle the DTOs now instead.



package io.xrio.movies.controller;

import io.xrio.movies.converter.MovieConverter;
import io.xrio.movies.dto.MovieDTO;
import io.xrio.movies.service.MovieService;
import lombok.Data;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

import javax.validation.Valid;
import java.util.List;

@RestController
@RequestMapping("movie")
@Data
public class MovieController {

    final MovieService movieService;
    final MovieConverter movieConverter;

    @PostMapping("/")
    public ResponseEntity<?> save(@Valid @RequestBody MovieDTO movieDTO) throws Exception {
        if (movieDTO == null)
            return ResponseEntity.badRequest().body("The provided movie is not valid");
        return ResponseEntity
                .status(HttpStatus.CREATED)
                .body(movieConverter.convertToDTO(movieService.save(movieConverter.convertToDM(movieDTO))));
    }

    @PutMapping("/")
    public ResponseEntity<?> update(@Valid @RequestBody MovieDTO movieDTO) throws Exception {
        if (movieDTO == null)
            return ResponseEntity.badRequest().body("The provided movie is not valid");
        return ResponseEntity
                .ok()
                .body(movieConverter.convertToDTO(movieService.update(movieConverter.convertToDM(movieDTO))));
    }

    @DeleteMapping("/{id}")
    public ResponseEntity<?> delete(@PathVariable Long id) throws Exception {
        if (id == null)
            return ResponseEntity.badRequest().body("The provided movie's id is not valid");
        return ResponseEntity.ok().body("Movie [" + movieService.delete(id) + "] deleted successfully.");
    }

    @GetMapping("/")
    public ResponseEntity<List<MovieDTO>> findAll() {
        return ResponseEntity.ok().body(movieConverter.convertToDTOs(movieService.findAll()));
    }

}

Then we test it!

Great! But it looks the same as before with more code!

True, so let's play the same game with different rules, the movie model for us now will be different than the DTO in order to protect our API against the database schema exposure:

Some of the movie model fields will be put in an info class that will be embedded in the movie, that way we will change the structure and keep things simple for you.

NOTE: I removed the model validation because it's no longer used or needed.




import lombok.Data;

import javax.persistence.*;
import javax.validation.Valid;
import javax.validation.constraints.NotNull;

@Data
@Entity
public class Movie {

    @Id
    @GeneratedValue(strategy = GenerationType.SEQUENCE)
    private Long id;

    @Embedded
    private Info info;

}



import javax.persistence.Embeddable;

@Embeddable
public class Info {

    private String name;
    private String type;
    private Long duration;
    private Long releaseYear;

}

We need also to alter our DTO's fields' names so we don't need to add an advanced configuration for the model mapper.




import lombok.Data;

import javax.validation.constraints.Max;
import javax.validation.constraints.Min;
import javax.validation.constraints.NotBlank;
import javax.validation.constraints.NotNull;

@Data
public class MovieDTO {

    @NotNull(message = "Id must not be null")
    private Long id;

    @NotBlank(message = "Name must not be blank")
    private String infoName;
    @NotBlank(message = "Type must not be blank")
    private String infoType;
    @Min(value = 1, message = "Movies are mainly more than a minute")
    @Max(value = 300, message = "Movies are less than 5 hours")
    private Long infoDuration;
    @NotNull(message = "Release year must not be null")
    private Long infoReleaseYear;

}

And finally testing it.

Finnally

Data validation and data manipulation can be a greatly valued asset to your API dev and prod, not only enhancing security but also gives you the power to keep your data in shape and to adapt to the users’ requirements without changing your own.

Find the source code Here.

More articles Here.

Getting started with Spring Boot: Creating a simple movies list API.

Elattar Saad — Tue, 21 Sep 2021 12:15:47 +0000

Spring boot is widely considered an entry to the Spring ecosystem, simple yet effective and powerful! Spring boot makes it possible to create Spring-based stand-alone, quality production apps with minimum needed configuration specifications. Let's keep it simple, just like the movies list API we're about to create!

Before we start

Your project structure matters, Spring boot gives you all the freedom to structure your project the way you see fit, you may want to use that wisely.

There's not a particular structure you need to follow, I'll be introducing mine on this project but that doesn't mean you have to follow it the way it is, as I said you're free!

Most tech companies, including mine, use guiding dev rules to keep the code clean and pretty, the rules are there to help you, don't go rogue.

Phase 0 : Introduction to the global architecture

Before we get busy with the layers specifications, let's have a bird's-eye view :

Phase I : Model definition

Models are the data structure which you're project is dealing with (example: you're building a user management system, the user is your model among others).

Usually, the software architect will be there to provide you with the needed resources to build your Spring boot models, those resources mainly are UML class diagrams. Here's ours :

NOTE: I decided for this model layer to be as simple as possible, to not give a wall to climb instead of a first step. In real-life projects, things get ugly and much more complicated.

Phase II : Service definition

After the model layer, now it's time to blueprint our services' structure, in other words, we need to define what service our API is going to mainly provide.

The services usually are fully invocated by the controller layer which means they usually have the same structure, but not all the time.

This one also will be provided by the software architect, and it comes as a detailed list with descriptions, a set of UML sequence diagrams, or both.

We need our API to be able to provide us with a list of saved movies, save, update and delete a movie.

Our end-points will be the following:

Save EP: This allows saving a movie by sending a JSON object using an HTTP/POST request.
Update EP: This allows updating a movie by sending a JSON object using an HTTP/PUT request.
Delete EP: This allows deleting a movie by sending its id using an HTTP/DELETE request.
Find all EP: This allows retrieving all the existing movies by sending an HTTP/GET request. (It's not recommended to open a find all end-point because it will slow down your application, instead set a limit, Example: 10 movies per request).

Why are we using multiple HTTP verbs?

If I were in your shoes right now, I'd be asking the same question. First, you can use it as you want with no restrictions, use an HTTP/POST request to retrieve movies, yes you can do that but, there's a reason why we don’t.

Dev rules and conventions are there to help you and keep things in order, otherwise, all we'll be building is chaos!

HTTP verbs are meant to describe the purpose of the request:

HTTP Verb	CRUD Op	Purpose	On success	On failure
POST	Create	Creates a resource	201	404 \| 409
GET	Read	Retrieves a resource	200	404
PUT	Update	Updates (replaces) a resource	200 \| 204	404 \| 405
PATCH	Update	Updates (modifies) a resource	200 \| 204	404 \| 405
DELETE	Delete	Deletes a resource	200	404 \| 405

Each request requires a response, in both success and error scenarios, HTTP response codes are there to define what type of response we are getting.

HTTP response code	Meaning
100 - 199	Informational responses
200 - 299	Successful responses
300 - 399	Redirection responses
400 - 499	Client error responses
500 - 599	Server error responses

Know more about HTTP response codes here

Phase III: Technical benchmarking

Now, we need to define the project technical requirements, what communication protocol we should use, what Database is suitable to store data, etc.

We will be using REST as our main communication protocol, H2/file database to store our data.
I chose those technologies for instructional purposes so that I could offer a simple yet working example, but in real-life projects, we select technologies only on the basis of their utility and ability to aid in the development of our API. That was the second factor that influenced my decision.

NOTE: The more technology experience you have, the more accurate your decisions will be.

Phase IV: Development

Github repository initialization

To make this code accessible for all of you, and insure its version, we'll be using git and GitHub, find all the code here : Github Repo

Spring Initializr

Spring provides us with an Initialization suite that helps us start our project quicker than usual.

After the init and downloading the basic version of our project, there're three important files you need to know about :

1. The application main class (aka. the backbone)

This class is the main class of the project and it represents its center.
NOTE: All packages should be under the main package of your application so they can be bootstrapped.

package io.xrio.movies;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class 
MoviesApplication {

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

}

2. The application properties file

This file is a way to put your configuration values which the app will use during the execution (example: URL to the database, server's port, etc.).
NOTE: You can add more properties files, I'll be covering that up in an upcoming article.
NOTE1: By default the file is empty.

spring.datasource.url=jdbc:h2:file:./data/moviesDB
spring.jpa.defer-datasource-initialization=true
spring.datasource.driverClassName=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=password
spring.jpa.hibernate.ddl-auto=update

3. The pom file

Since we are using Maven as our dependency manager (you can use Gradle instead) we have a pom.xml file containing all the data about our dependencies.

<?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>2.5.4</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>io.xrio</groupId>
    <artifactId>movies</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>movies</name>
    <description>Just a simple movies api</description>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>com.h2database</groupId>
            <artifactId>h2</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <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>

</project>

Building the model layer

The model layer is the direct implementation of our class diagrams as Java classes.

package io.xrio.movies.model;

import lombok.Data;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import java.util.Date;

@Data
@Entity
public class Movie {

    @Id
    @GeneratedValue(strategy = GenerationType.SEQUENCE)
    private Long id;
    private String name;
    private String type;
    private Long duration;
    private Long releaseYear;

}

The


 provides us with embedded constructors and accessors so we can reduce the written code. see more about the [Lombok project](https://projectlombok.org/).

The

 ```@Entity```

 is there to tell Spring Data that particular class should be represented as a table in our relational database. we call that process an ORM (Object Relational Mapping).

So that our id won’t be duplicated, we will use a sequence, we put the

 ```@GeneratedValue(strategy = GenerationType.SEQUENCE)```

 there.

### Building the repository facade
Simply, an interface that will inherit Spring Data JPA powers and handle the CRUD ORM operations on our behalf.

package io.xrio.movies.repository;

import io.xrio.movies.model.Movie;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

@Repository
public interface MoviesRepository extends JpaRepository {
}




@Repository ensures the dependency injection of the repository bean among other things, since the interface inherits from the generic JpaRepository, it will have all the already-set mechanisms of Spring Data JPA.

Spring Data is smart enough at the level it can handle a new operation only from the function signature. Example: You need to file a movie by its title? No problem, just add this function to your interface :

Movie findByName(String name);




### Building the custom exception

Before building our service layer, we need a couple of custom exceptions that will be thrown when things go south.

Basing on our service schema only two exceptions can be thrown when:
- Creating an already existing movie (MovieDuplicatedException class).

package io.xrio.movies.exception;

import lombok.Data;
import lombok.EqualsAndHashCode;

/**

@author : Elattar Saad
@version 1.0
@since 10/9/2021
*/
@EqualsAndHashCode(callSuper = true)
@data
@AllArgsConstructor
public class MovieDuplicatedException extends Exception{

/**
- The duplicated movie's id */ private Long mid;

}




- Updating a non-existing movie (MovieNotFoundException class).

package io.xrio.movies.exception;

import lombok.Data;
import lombok.EqualsAndHashCode;

@EqualsAndHashCode(callSuper = true)
@data
@AllArgsConstructor
public class MovieNotFoundException extends Exception{

/**
 * The nonexistent movie's id
 */
private Long mid;

}



***NOTE: There're mainly four ways to handle exception in Spring boot.***

***NOTE1: You can generalize custom exceptions so they can be used for more than one model.***

***NOTE2: You can handle your exceptions without custom-made exceptions and handlers.***


### Building the service layer
First, we will create a movie service interface that will bear the schema of our service, then implement it with the needed logic. This helps us to achieve the [purpose of the IoC](https://en.wikipedia.org/wiki/Inversion_of_control).

package io.xrio.movies.service;

import io.xrio.movies.exception.MovieDuplicatedException;
import io.xrio.movies.exception.MovieNotFoundException;
import io.xrio.movies.model.Movie;

import java.util.List;

public interface MovieService {

Movie save(Movie movie) throws MovieDuplicatedException;
Movie update(Movie movie) throws MovieNotFoundException;
Long delete(Long id) throws MovieNotFoundException;
List<Movie> findAll();

}

package io.xrio.movies.service.impl;

import io.xrio.movies.exception.MovieDuplicatedException;
import io.xrio.movies.exception.MovieNotFoundException;
import io.xrio.movies.model.Movie;
import io.xrio.movies.repository.MoviesRepository;
import io.xrio.movies.service.MoviesService;
import lombok.Data;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
@data
public class MovieServiceImpl implements MovieService {

final MovieRepository movieRepository;

@Override
public Movie save(Movie movie) throws MovieDuplicatedException {
    Movie movieFromDB = movieRepository.findById(movie.getId()).orElse(null);
    if (movieFromDB != null)
        throw new MovieDuplicatedException(movie.getId());
    return movieRepository.save(movie);
}

@Override
public Movie update(Movie movie) throws MovieNotFoundException {
    Movie movieFromDB = movieRepository.findById(movie.getId()).orElse(null);
    if (movieFromDB == null)
        throw new MovieNotFoundException(movie.getId());
    movie.setId(movieFromDB.getId());
    return movieRepository.save(movie);
}

@Override
public Long delete(Long id) throws MovieNotFoundException {
    Movie movieFromDB = movieRepository.findById(id).orElse(null);
    if (movieFromDB == null)
        throw new MovieNotFoundException(id);
    movieRepository.delete(movieFromDB);
    return id;
}

@Override
public List<Movie> findAll() {
    return movieRepository.findAll();
}

}




I combined the use of constructor dependency injection and Lombok’s

 ```@RequiredArgsConstructor```

 to reduce my code, without that it will look like this :

@Service
public class MovieServiceImpl implements MovieService {

final MovieRepository movieRepository;

public MovieServiceImpl(MovieRepository movieRepository) {
    this.movieRepository = movieRepository;
}

...
}




### Building the controller layer

After the service layer, time to build our controller to accept incoming requests.

As previously said, the controller layer directly calls the service layer, that's the reason behind the injection of a MovieService bean inside the movie controller.

package io.xrio.movies.controller;

import io.xrio.movies.exception.MovieDuplicatedException;
import io.xrio.movies.exception.MovieNotFoundException;
import io.xrio.movies.model.Movie;
import io.xrio.movies.service.MovieService;
import lombok.Data;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("movie")
@data
public class MovieController {

final MovieService movieService;

@PostMapping("/")
public ResponseEntity<?> save(@RequestBody Movie movie) throws MovieDuplicatedException {
    if (movie == null)
        return ResponseEntity.badRequest().body("The provided movie is not valid");
    return ResponseEntity.status(HttpStatus.CREATED).body(movieService.save(movie));
}

@PutMapping("/")
public ResponseEntity<?> update(@RequestBody Movie movie) throws MovieNotFoundException {
    if (movie == null)
        return ResponseEntity.badRequest().body("The provided movie is not valid");
    return ResponseEntity.ok().body(movieService.update(movie));
}

@DeleteMapping("/{id}")
public ResponseEntity<?> delete(@PathVariable Long id) throws MovieNotFoundException {
    if (id == null)
        return ResponseEntity.badRequest().body("The provided movie's id is not valid");
    return ResponseEntity.ok().body("Movie [" + movieService.delete(id) + "] deleted successfully.");
}

@GetMapping("/")
public ResponseEntity<?> findAll() {
    return ResponseEntity.ok().body(movieService.findAll());
}

}




One more last step and we're good to go. To handle the exception thrown from the service layer, we need to catch it in the controller layer.

Fortunately, Spring boot provides us with an Exception Handler that can resolve exceptions under the hood and without any code to the controller.

package io.xrio.movies.controller.advice;

import io.xrio.movies.exception.MovieDuplicatedException;
import io.xrio.movies.exception.MovieNotFoundException;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.servlet.mvc.method.annotation.ResponseEntityExceptionHandler;

@ControllerAdvice
public class MovieControllerExceptionHandler {

@ExceptionHandler(MovieNotFoundException.class)
private ResponseEntity<?> handleMovieNotFoundException(MovieNotFoundException exception){
    String responseMessage = "The provided movie ["+exception.getMid()+"] is nowhere to be found.";
    return ResponseEntity
            .status(HttpStatus.NOT_FOUND)
            .body(responseMessage);
}

@ExceptionHandler(MovieDuplicatedException.class)
private ResponseEntity<?> handleMovieDuplicatedException(MovieDuplicatedException exception){
    String responseMessage = "The provided movie ["+exception.getMid()+"] is already existing.";
    return ResponseEntity
            .status(HttpStatus.CONFLICT)
            .body(responseMessage);
}

}




All we need to do next is to test what we build via a rest client, for this reason, I'm using [Insomnia](https://insomnia.rest/) :

##### The post end-point

<p align="center">
  <img src="https://elattar.me/images/spring/movie-test-post.png">
</p>

##### The get end-point

<p align="center">
  <img src="https://elattar.me/images/spring/movie-test-get.png">
</p>

##### The put end-point

<p align="center">
  <img src="https://elattar.me/images/spring/movie-test-put.png">
</p>

##### The delete end-point

<p align="center">
  <img src="https://elattar.me/images/spring/movie-test-delete.png">
</p>

And finally, testing the error scenario for some end-points.

Let's try and save a movie with an existing id :
<p align="center">
  <img src="https://elattar.me/images/spring/movie-test-save-error.png">
</p>

Or delete a non-existing movie :
<p align="center">
  <img src="https://elattar.me/images/spring/movie-test-delete-error.png">
</p>

## Summary 

Spring Boot is a powerful apps making tool, takes away all the times consuming tasks and leaves you with the logical ones to handle.
Don't get fouled, building APIs is not that easy, and from what I saw, that's just the tip of the Iceberg!

Find the source code [Here](https://github.com/xrio/simple-spring-boot-movies). 

More articles [Here](https://elattar.me/).

Starting with Spring Framework? Here's what you need to know

Elattar Saad — Tue, 21 Sep 2021 12:04:36 +0000

Spring is a common term in the dev community, as a beginner, its wideness may overwhelm you on the first step you take towards it. I'm here to make it simpler.

The Spring Framework is a Java platform application framework and inversion of the control (IoC) container. Any Java program may utilize the framework's fundamental capabilities, however, there are extensions for creating web apps on top of the Java EE platform. Spring Framework - Wikipedia

Why using Spring?

Over the years Spring Framework has proven itself to be :

Everywhere: Developers all across the world rely on Spring's adaptable libraries. Every day, millions of end-users enjoy pleasant experiences from Spring, whether it's streaming TV, online shopping, or a variety of other creative solutions. All of the major tech companies, including Alibaba, Amazon, Google, Microsoft, and others, have contributed to Spring.
Flexible: Spring's extensible and extensive collection of extensions and third-party libraries enable developers to create nearly any application they can imagine. The Inversion of Control (IoC) and Dependency Injection (DI) capabilities of Spring Framework offers the foundation for a diverse collection of features and functionality. Spring offers the tools to let you develop secure, reactive, cloud-based microservices for the web or complicated streaming data flows for the enterprise.
Productive: Spring Boot revolutionizes the way you approach Java programming jobs, greatly simplifying your workflow. Spring Boot makes microservice development a breeze by combining essentials like an application environment and an auto-configured, embedded web server. You can move even quicker by combining Spring Boot with Spring Cloud's extensive collection of supporting libraries, servers, patterns, and templates to quickly deploy complete microservices-based architectures to the cloud.
Fast: By default, Spring provides quick startup, fast shutdown, and efficient execution. For even more efficiency, Spring projects are increasingly using the reactive (nonblocking) programming style. Spring's superpower is developer productivity. Spring Boot makes it easier for developers to create apps with considerably less effort than alternative paradigms. Embedded web servers, auto-configuration, and "fat jars" make it easy to get started, and innovations like Spring DevTools' LiveReload allow developers to iterate quicker than ever before. With the Spring Initializr at start.spring.io, you can even start a new Spring project in seconds.
Secure: Spring has a track record of promptly and properly dealing with security concerns. Spring committers collaborate with security experts to fix and test any identified flaws. Third-party dependencies are also constantly checked, and updates are released on a regular basis to make your data and apps as secure as possible. Spring Security also makes it easy to connect with industry-standard security schemes and offers trustworthy, secure-by-default solutions.
Supportive: Spring's community is vast, international, and varied, encompassing people of all ages and skills, from total beginners to seasoned veterans. You can discover the assistance and resources you need to advance to the next level, no matter where you are on your journey: quickstarts, guides & tutorials, videos, meetings, support, or even formal training and certification.

What can you do using Spring?

Microservices Spring | Microservices
Reactive systems Spring | Reactive
Cloud distributed structures Spring | Cloud
Web applications Spring | Web Apps
Serverless Applications and Function as a Service (FaaS) Spring | Serverless
Event-driven Systems Spring | Event Driven
Batches and automated tasks. Spring | Batch

What requirements I need to have before getting started with Spring.

Generally speaking, you need to have a good knowledge of Java core, a basic understanding of data structures, OOP, IoC, and dependency injection.
But, you also need to know the basics of the framework you intend to use inside the Spring ecosystem, for example, if you are using Spring Data JPA I believe you must know how JPA works in the first place.

Don't make the beginners' mistake, you don't have to know all about Spring before starting, it always comes piece by piece.

Where to start?

As previously said, Spring is a whole ecosystem, it is highly recommended to enter it via the Spring Boot door, to do so I suggest this official article: Spring | Spring Quickstart Guide

You can check my new article on Spring Boot here.

More resources

Learning sites

Spring learn: The official learning site and also my first direction when I need to look for something concerning Spring.
Baeldung: A powerful site that provides devs with a set of informative guides with practical examples following the best practices.
DZone: DZone provides the information, resources, and tactics that IT professionals require. construct the future Are you a non-member? DZone.com is a prominent provider of information resources for software professionals and one of the world's largest online communities.

Youtube Channels

If you prefer videos, there's a lot of YouTube channels which I'm sure you'll find useful :

Training & certification

In your advanced learning stages, you absolutely need to validate your knowledge, in other words, to certify your assets. Here's all you have to know : Spring | training

Lost in binaries? Here’s what I do!

Elattar Saad — Tue, 21 Sep 2021 12:02:54 +0000

We all had and will surely have moments of uncertainty and completely suffering under the weight of the logical/technical problem we must handle.
Okay, let’s start with this, YOU ARE NOT THE ONLY ONE WHO SUFFERS, WE ALL DO, the only difference is how often you get this, and how strong you become handling it over and over.

I still remember my second internship as a software developer, I was a part of the team charged with building the mobile app version using react native, guess what? I don’t even master vanilla javascript nor how to build a mobile application! And let’s say I was completely screwed 'cause I had only 45 days to deliver the final version of something I had no idea about.

What I’m saying here is not a new framework to master, but also a new design thinking to adapt, a new structure to set, and definitely a new solution to provide.

That’s one of the situations I love and appreciate, yes! you read that right, that’s a golden opportunity to upgrade your set of skills and open up to new technical points of view.
Now, Let’s start with what I did and let us just skip the self-doubt moments 😁.

1. Divide and conquer

What you need to know, is the problem you’re dealing with is a strong opponent to be handled at once and fully, and the best way to win the game is to turn it into a set of small problems that you will handle one by one.

In my case here, is to turn my big problem, being overwhelmed with all this new stuff into these tiny fries:

Getting into mobile development and think like a mobile developer.
Mastering JavaScript as fast as possible and go after the web version of React (ReactJS) so I can understand its mobile version (React native).
Checking out lot of open-sourced react projects so I’ll have an idea of how things are actually being done by professionals.
Last and not least, getting to know the dev environment requirements and setup mine properly.

If you feel like you need to, divide each one of these as well.

2. Go old school

It's a wonderful habit to go for a pen and paper when your brain can no longer visualize things properly.
Instead of having that badly-crafted net of thoughts in your mind, why just make them real in a couple of notes and diagrams.

Nevertheless, there're tools to help you get the job done:

For diagrams and drawings :

Draw.io : For designing your charts properly.

For notes :

I used to use One Note and it’s really amazing !

Since I switched to MacOs and iOS, I'm using Apple Note, it's simple and classy !

And something really helpful :

I got this idea while watching a med doctor performing an autopsy and recording a vocal report in the process.
You can use any voice record application to store your ideas, the best about this is that your feelings are stored too, so record them with passion and excitement!

3. Make use of your superpowers

You have those, but not all the time!

While relaxed, we intend to think very clearly, and our brains work just magically.
Yes, I’m talking about that shower time, bathroom time, or maybe that night walk time when your brain can make wonderful blueprints.

While having a similar problem, I intend to have showers, sometimes 3 per day, night walks alone, or you’ll find me just laying down on my bed, thinking deeply of what needs to be done.

Don’t waste that on drama or some uselessness!

4. It is what it is

Sometimes, in order to handle a problem, you first need to clear your mind. In other words, you need to forget about it temporarily and don't give a damn for the moment.

But remember you only do that to give yourself a break from that emotional pressure, so be careful, without your control, it can turn into a lifetime break!

5. Get some help

It may be a one-person job, still, you can have someone who’ll have your back.

Sometimes the job is confidential and should not be shared, but I’m not talking technically, I have friends who help me bear the pain, for that I’m grateful, emotional support is way more important than technical.

Make sure you surround yourself with worthy people!

Finally,

I’d like to say, having problems like these, doesn’t mean you’re dumb or stupid, doesn’t mean you made the wrong choice, it only means that you got yourself into a new situation, and you need to adapt to it.

Learn, adapt and overcome, remember?

What about your first IT internship?

Elattar Saad — Tue, 21 Sep 2021 12:00:17 +0000

Like everyone I’ve been amazed by what the digital world is made of, and what it can offer us as an added value to our daily life. Don’t get me wrong I’m still amazed even as a senior computer engineering student.
I’m a Moroccan youngster who always had a dream of becoming a computer scientist, my first most real step was joining the Higher School of Technology in Essaouira, yes, where the journey started.
I mainly address my talk to the newbies, computer engineering students and whoever wants to follow this path :

You spent some time as a fresh IT student, had some basics in mind, you even tried to experiment how it works in real projects, but what you still lacking here is the professional experience, trust me I know.

I still remember my first days, looking for internships, I’m not going to lie, it was a taught process, but it could be so much easier with some external help. Here I am giving you what I wish I’ve been told:

1.Know what you want

The step towards having a good internship is knowing what field you want, if you’re into web development, for example, you have to focus your energy on web development companies.
Knowing your true desires will guide your search process.

2.Know your target

Collect their information

After having an idea of what field to target, the next step will be looking for companies in the same field.
You can use whatever search tool you want:

Social media (I recommend LinkedIn)
Social contacts (a friend of a friend, your school’s professional network, etc.

But you still want to know what you must collect as valuable information, you need to:

Obviously, an active contact (an e-mail address or a phone number)
An idea about what this company do, its projects, its partners and for sure some names (its executive board, its HR manager, its director (or CEO/CTO), etc.)

Another thing, from personal experience, I advise you to apply for small companies’ internships, in these, you will be charged with more tasks so you can gain more experience.

These specifications will help you to establish a connection and will give an idea of what you’ll be asked during the interview (if required).

The interview

Sometimes the interview is not required, but you still have to be prepared for anything.

During the interview, you can be asked about every detail in your Curriculum Vitae including your technical/hard skills such as programming languages, technologies and frameworks you’re familiar with, etc., your soft skills such as teamwork, team management, public speaking, etc., professional experience if you have some and hobbies.

But here’s the good news, you have a trump card, which is the information you collected about this company, and which will show how interested and professional are you, especially if what they need is the same you can provide them within your CV.

3.Know what you have

For sure you need to know what you do best so you can use as an advantage:

The Curriculum Vitae

What you have here is literally who you are as a piece of paper, and while you apply your CV should be:

True: Never lie, or put something you don’t have.
Dynamic: you can’t use the same CV every time you apply (depends on the company needs and what position you’re applying for), and I said the moment your CV will get attention the company needs intersect with what skills you can offer.

The motivation letter

You got to know the importance of this document, and it has a huge effect on whatever decision the company will take.

The motivation letter is literally what your intentions are, the reason behind that pushes you to have this internship and mostly what qualifies you to have it and not somebody else.

Make sure you make your intentions clear.

The portfolio

Here’s the thing not required for your first internship, but it will give you a huge boost, it’s kind of here’s my work in real terms, and it better be deployed in a public environment.

Summary

The internship is your gate to the professional you, it’s the opportunity to improve your skills, work with others and mostly contribute to real projects that will make our daily life even easier.

DEV Community: Elattar Saad

Spring streaming response made easy

TechStack

Use case

Traditional endpoints

Streaming Response to the rescue

On another level

Resources

Streaming with JPA Stream<T>

Server-Sent Events (SSE) / Reactive

Blossoming Intelligence: How to Run Spring AI Locally with Ollama

TechStack

Ollama Setup

Talking Spring

Finally

Resources

React 19: The long-expected features

React Forget

Actions

Hooks

useFormStatus

useFormState

useOptimistic

useCallback and useMemo

use

ForwardRef

SEO

Summary

Resources

Just a simple Songs API using Spring Reactive with Functional Endpoints, Docker and MongoDB

Project Description

Project Dependencies

Coding time!

Song Functional Endpoint and Handler

Exception Handling

Custom Exceptions

Custom Exception Handler

Finally,

Spring cloud: introduction to service discovery using netflix eureka

Understanding the problem

Eureka under the hood

Let's talk code

Eureka server configuration

Eureka client configuration

Spring internal micro-service driven communication

Installing OpenFeign

OpenFeign client implementation

Spring Boot optional request params

Method 1: Using required attribute

Method 2: Using Java 8 Optionals

Spring Boot validation and bean manipulation

Injection attacks

Database schema exposure

Data validation

Data manipulation

Introduction to the DTOs

Finnally

Getting started with Spring Boot: Creating a simple movies list API.

Before we start

Phase 0 : Introduction to the global architecture

Phase I : Model definition

Phase II : Service definition

Why are we using multiple HTTP verbs?

Phase III: Technical benchmarking

Phase IV: Development

Github repository initialization

Spring Initializr

1. The application main class (aka. the backbone)

2. The application properties file

3. The pom file

Building the model layer

Starting with Spring Framework? Here's what you need to know

Why using Spring?

What can you do using Spring?

What requirements I need to have before getting started with Spring.

Where to start?

More resources

Learning sites

Youtube Channels

Training & certification

Streaming with JPA `Stream<T>`