DEV Community: priyankanandula

Implementing Library Inventory Project Using Apache Kafka & SpringBoot Part 1

priyankanandula — Sat, 29 Jan 2022 13:56:54 +0000

Signed in as @priyankanandula

Hey, you! Are you a programmer❓

If yes, this blog is for you 😃

This blog series is intended to demonstrate how to code Kafka producers and consumers.

Library will be the application that we will create. The Library Inventory Application, to be more specific.

Let's see the flow of our application👇 ...

We have a librarian and library inventory

When a new book arrives at the library, the librarian scans it before placing it on the shelf.

Simplistic view of application architecture

Librarian scans can be categorized as events. For that purpose, we are going to have a Kafka topic library events.
As the librarian scans the new books, which are treated as events get publishes into a library events topic.
We have two microservices here...
- Library event producer : When a librarian scans a book, the library event producer exposes an API that is called as soon as the book is scanned. From there, the record is passed on to the next layer, which is the *Kafka producer*, and then it is published into the *Kafka topic*.
- Library event Consumer :
  
  - The library event consumer is the second application, and it is constantly pulling new records from the topic.
  
  - The consumer will read these events and begin processing as soon as new records on the topic are available. .
  
  - The processing logic in this case is to read the message and scan the library into the in-memory database.

4.This is the end of the library scan event..

In this first part, we'll develop Kafka Producer only, which will send book details to Kafka Topic.

NOTE

Please see my previous blog for instructions on how to install Kafka and Zookeeper.You must have this.

Because I'll be using Gradle in this blog series, it's helpful if you have some basic knowledge of it.

You will also learn,how to write Integration testing and Unit testing in this entire series

Let's get started with the implementation.

Project Structure

Implementation Steps

1.Adding Dependencies and required properties in build.gradle file :

After creating new gradle project, add the following properties in
build.gradle file...

plugins {
    id 'org.springframework.boot' version '2.2.2.RELEASE'
    id 'io.spring.dependency-management' version '1.0.8.RELEASE'
    id 'java'
}

group = 'com.learnkafka'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = '8'

configurations {
    compileOnly {
        extendsFrom annotationProcessor
    }
}

repositories {
    mavenCentral()
}

dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-web'
    implementation 'org.springframework.kafka:spring-kafka'
    compileOnly 'org.projectlombok:lombok'
    annotationProcessor 'org.projectlombok:lombok'
    testImplementation('org.springframework.boot:spring-boot-starter-test') {
        exclude group: 'org.junit.vintage', module: 'junit-vintage-engine'
    }
    testImplementation 'org.springframework.kafka:spring-kafka-test'
}



sourceSets{
    test {
        java.srcDirs = ['src/test/java/unit', 'src/test/java/intg']
    }
}

test {
    useJUnitPlatform()
}

2. Create application.yml file inside resources folder as below :

spring:
  profiles:
    active: local
---
spring:
  profiles: local
  kafka:
    template:
      default-topic: library-events
    producer:
      bootstrap-servers: localhost:9092
      key-serializer: org.apache.kafka.common.serialization.IntegerSerializer
      value-serializer: org.apache.kafka.common.serialization.StringSerializer
    admin:
      properties:
        bootstrap.servers: localhost:9092
---
spring:
  profiles: dev
  kafka:
    producer:
      bootstrap-servers: dev:9092
      key-serializer: org.apache.kafka.common.serialization.IntegerSerializer
      value-serializer: org.apache.kafka.common.serialization.StringSerializer

---
spring:
  profiles: prod
  kafka:
    producer:
      bootstrap-servers: prod:9092
      key-serializer: org.apache.kafka.common.serialization.IntegerSerializer
      value-serializer: org.apache.kafka.common.serialization.StringSerializer

3.Give Gradle build again :

After adding the above files give Gradle build again.

NOTE: It will automatically creates two new intg & unit folders inside test/java folder.

4. Creating packages inside src/main/java folder :

Create the following packages in java folder

Here com.kafka is root package remaining are sub packages in this root.

5. Create Application class inside root package :

Here I am giving springboot application class name as LibraryInventoryApplication.java.

package com.kafka;

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

@SpringBootApplication
public class LibraryInventoryApplication {

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

}

6. Create configuration class inside config package :

Create the following class inside config package.I am using class name as AutoCreateConfig.

We are creating this class to create a topic in Kafka by code.

package com.kafka.config;

import org.apache.kafka.clients.admin.NewTopic;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Profile;
import org.springframework.kafka.config.TopicBuilder;

@Configuration
@Profile("local")
public class AutoCreateConfig {

    @Bean
    public NewTopic libraryEvents(){
        return TopicBuilder.name("library-events")
                .partitions(3)
                .replicas(1)
                .build();
    }

}

This will create library-events topic in Kafka whenever we run the application.

7. Create Models classes inside domain package :

Let's create POJO classes for Libraryevent and Book.

Create the following three classes inside domain package.

Book.java

package com.kafka.domain;


import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;

@AllArgsConstructor
@NoArgsConstructor
@Data
@Builder
public class Book {

    private Integer bookId;
    private String bookName;
    private String bookAuthor;
}

LibraryEvent.java

package com.kafka.domain;


import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;

@AllArgsConstructor
@NoArgsConstructor
@Data
@Builder
public class LibraryEvent {

    private Integer libraryEventId;
    private LibraryEventType libraryEventType;
    private Book book;

}

LibraryEventType.class

package com.kafka.domain;

public enum LibraryEventType {
    NEW,
    UPDATE
}

8. Create KafkaProducer class inside producer package :

Here I gave the class name as LibraryEventProducer.You can use any name.

LibraryEventProducer.java

package com.kafka.producer;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.kafka.domain.LibraryEvent;
import lombok.extern.slf4j.Slf4j;
import org.apache.kafka.clients.producer.ProducerRecord;
import org.apache.kafka.common.header.Header;
import org.apache.kafka.common.header.internals.RecordHeader;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.kafka.support.SendResult;
import org.springframework.stereotype.Component;
import org.springframework.util.concurrent.ListenableFuture;
import org.springframework.util.concurrent.ListenableFutureCallback;

import java.util.Arrays;
import java.util.List;

@Component
@Slf4j
public class LibraryEventProducer {

    @Autowired
    KafkaTemplate<Integer,String> kafkaTemplate;

    String topic = "library-events";
    @Autowired
    ObjectMapper objectMapper;



    public void sendLibraryEvent(LibraryEvent libraryEvent) throws JsonProcessingException {

        Integer key = libraryEvent.getLibraryEventId();
        String value = objectMapper.writeValueAsString(libraryEvent);

        ProducerRecord<Integer,String> producerRecord = buildProducerRecord(key, value, topic);

        ListenableFuture<SendResult<Integer,String>> listenableFuture =  kafkaTemplate.send(producerRecord);

        listenableFuture.addCallback(new ListenableFutureCallback<SendResult<Integer, String>>() {
            @Override
            public void onFailure(Throwable ex) {
                handleFailure(key, value, ex);
            }

            @Override
            public void onSuccess(SendResult<Integer, String> result) {
                handleSuccess(key, value, result);

            }
        });
    }


    private ProducerRecord<Integer, String> buildProducerRecord(Integer key, String value, String topic) {


        List<Header> recordHeaders = Arrays.asList(new RecordHeader("event-source", "scanner".getBytes()));

        return new ProducerRecord<>(topic, null, key, value, recordHeaders);
    }




    private void handleFailure(Integer key, String value, Throwable ex) {
        log.error("Error Sending the Message and the exception is {}", ex.getMessage());
        try {
            throw ex;
        } catch (Throwable throwable) {
            log.error("Error in OnFailure: {}", throwable.getMessage());
        }


    }

    private void handleSuccess(Integer key, String value, SendResult<Integer, String> result) {
        log.info("Message Sent SuccessFully for the key : {} and the value is {} , partition is {}", key, value, result.getRecordMetadata().partition());
    }
}

KafkaTemplate:Kafkatemplate class is provided by the spring framework.By using this class only we can perform Kafka operations like sending data to topics and retrieving the data from topic.

ObjectMapper:Here objectmapper will convert our library event java object to JSON and then to String.(POJO-JSON-String)

ProducerRecord: A key/value pair to be sent to Kafka.This consists of a topic name to which the record is being sent, an optional partition number, and an optional key and value.

9. Create Controller class inside Controller package :

Here I am creating a rest controller class for sending Book data.

LibraryEventsController.java

package com.kafka.controller;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.kafka.domain.LibraryEvent;
import com.kafka.domain.LibraryEventType;
import com.kafka.producer.LibraryEventProducer;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;

import java.util.concurrent.ExecutionException;

@RestController
@Slf4j
public class LibraryEventsController {
    @Autowired
    LibraryEventProducer libraryEventProducer;

    @PostMapping("/v1/libraryevent")
    public ResponseEntity<LibraryEvent> postLibraryEvent(@RequestBody LibraryEvent libraryEvent) throws JsonProcessingException, ExecutionException, InterruptedException {

        //invoke kafka producer
        libraryEvent.setLibraryEventType(LibraryEventType.NEW);

        libraryEventProducer.sendLibraryEvent(libraryEvent);
        return ResponseEntity.status(HttpStatus.CREATED).body(libraryEvent);
    }
}

10. Create test class inside srs/test/java package :

NOTE: Package should be same as in src/java

LibraryEventsControllerIntegrationTest.java

package com.kafka.controller;


import com.kafka.domain.Book;
import com.kafka.domain.LibraryEvent;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.web.client.TestRestTemplate;
import org.springframework.http.*;

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

@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
public class LibraryEventsControllerIntegrationTest {

    @Autowired
    TestRestTemplate restTemplate;


    @Test
    void postLibraryEvent() {
        //given
        Book book = Book.builder()
                .bookId(127)
                .bookAuthor("Priyanka")
                .bookName("Kafka using Spring Boot part2")
                .build();

        LibraryEvent libraryEvent = LibraryEvent.builder()
                .libraryEventId(null)
                .book(book)
                .build();
        HttpHeaders headers = new HttpHeaders();
        headers.set("content-type", MediaType.APPLICATION_JSON.toString());
        HttpEntity<LibraryEvent> request = new HttpEntity<>(libraryEvent,headers);

        //when
        ResponseEntity<LibraryEvent> responseEntity = restTemplate.exchange("/v1/libraryevent", HttpMethod.POST,request, LibraryEvent.class);

        //then
        assertEquals(HttpStatus.CREATED,responseEntity.getStatusCode());
    }
}

11. Starting up the Zookeeper & Kafka Serves:

For installing softwares please refer this blog - link

1. First we must start the zookeeper Instance by using the below command.

NOTE: Please make sure you're in the kafka folder in CMD before proceeding.

zookeeper-server-start.bat config\zookeeper.properties

If you can see these logs, it signifies that the Zookeeper instance was running successfully in Port No - 2181.

2.Start up the kafka server using the below command.

kafka-server-start config\server.properties

If you can see these logs, it signifies that the Kafka instance was running successfully in Port No - 9092.

kafka id started with id zero and might have noticed some logs ran in the zookeeper instance so thats a signal that broker registered itself with the zookeeper.

12. Running the test class :

Now we will run the test class to see whether the controller send the data to kafka topic or not.

Here finally, if you see in logs it was showing successfully sent message.

Before we create consumer in code,you can check it out in CMD whether it was produced to library-events topic or not using below command in CMD.

kafka-console-consumer.bat --bootstrap-server localhost:9092 --topic library-events --from-beginning

OUTPUT

That's it guys!Hope you learned something new....

Git Repo for Project: https://github.com/priyankanandula/LibraryInventory

In my next blog we will create consumer in code.

Happy Coding......

This is priyanka nandula signing off...

Basic CLI Implementation of Producer & Consumer using - Apache Kafka Broker & Zookeeper

priyankanandula — Sun, 27 Jun 2021 07:07:02 +0000

Signed in as @priyankanandula

What's up, programmers ❓ Nothing is ever too late to learn 😎

In today's blog, we'll look at how to use Apache Kafka Broker and Zookeeper to send and consume messages using Producer and Consumer.

Isn't it fascinating ❓

Let's start with a brief overview of Kafka before moving on to implementation.

Apache Kafka:

Apache Kafka is a publish-subscribe based durable messaging system. A messaging system sends messages between processes, applications, and servers.

These are four main parts in a Kafka system:

Broker: - Handles all requests from clients (produce, consume, and metadata) and keeps data replicated within the cluster. There can be one or more brokers in a cluster.
Zookeeper: - Keeps the state of the cluster (brokers, topics, users).
Producer: - Sends records to a broker.
Consumer: - Consumes batches of records from the broker.

In this blog, I will not delve further into the theoretical aspects. So, let's get started with the implementation 👇

Implementation steps :

NOTE : Java 8 or higher must be installed on your computer.

Download and Install Apache Kafka(Windows).
Set up the kafka environment path variable.
Inside the Kafka folder, creating a data folder.
Modify the properties file's configuration parameters.
Getting the Zookeeper and Kafka instances running.
Creating a kafka topic.
Instantiate a Console Producer.
Instantiate a Console Consumer.

1. Download and Install Apache Kafka(Windows):

Go through the link --> [https://kafka.apache.org/downloads].
Click on the link in the image below.

Download the kafka_2.13-2.8.0.tgz file.

After you've downloaded the file, unzip it with a tool like 7-zip or winRAR.

2. Set up the kafka environment path variable :

Copy and paste the bin/windowd folder path into the System Environment variables.

3. Inside the Kafka folder, creating a data folder :

Create a new folder data inside the kafka_2.13-2.8.0 folder.

Inside data folder --> Create a two new folders as kafka & zookeeper

4. Modify the properties file's configuration parameters:

Inside config folder --> Open the zookeeper.properties file with notepad++ or any editor.

In that file change the value for dataDir property to the zookeeper folder path which we have create in earlier step and Save it.

Again inside config folder --> Open the server.properties file with notepad++ or any editor.

In that file change the value for dataDir property to the kafka folder path which we have create in earlier step and Save it.

Also add the following two properties in the same file.

listeners = PLAINTEXT://localhost:9092
auto.create.topics.enable=false

NOTE : Remember to use '/' forward slash for path otherwise it will not work.

C:/kafka_2.13-2.8.0/data/kafka

5. Getting the Zookeeper and Kafka instances running :

Start up the Zookeeper

NOTE : Please make sure you're in the kafka folder in CMD before proceeding.

To start the Zookeeper instance, use the command below.

zookeeper-server-start.bat config\zookeeper.properties

If you can see these logs, it signifies that the Zookeeper instance was running successfully in Port No - 2181.

Start up the Kafka

Now open the new command terminal.

To start the Kafka server, use the command below.

kafka-server-start config\server.properties

If you can see these logs, it signifies that the Kafka instance was running successfully in Port No - 9092.

kafka id started with id zero and might have noticed some logs ran in the zookeeper instance so thats a signal that broker registered itself with the zookeeper.

6. Creating a kafka topic :

The very first step is we are going to create the Kafka topic.

NOTE : Please make sure that both Zookeeper & Kafka instances are up and running in your local.

Open new `CMD terminal` and use the command below to create a Kafka Topic

kafka-topics.bat --create --topic test-topic -zookeeper localhost:2181 --replication-factor 1 --partitions 4

kafka-topics.bat is the command that we'll use. This is a batch file for just creating the topic, and then we'll pass the required arguments to that batch file.
-- create followed by that we provide the topic name and then will provide the zookeeper instance.
After that we have a new attribute called Replication factor as '1' because we just have have only one broker running in our machine.
After that we are passing the number of paritions.
Normally when you provide a _create topic command _,the command will be directed to the zookeeper,from the zookeeper it takes care of redirecting the request to the Kafka Broker.

once you see this message the topic got created successfully

Next steps we are going to do start Producing and Consuming messages 👇.

7.Instantiate a Console Producer :

Instantiate console producer without key.Open new `CMD terminal` and use the command below to create a Producer.

kafka-console-producer.bat --broker-list localhost:9092 --topic test-topic

we have batch file called kafka-console-producer, for that we need to provide a broker-list as a parameter and followed by that we are going to provide the topic name.

If you able to see '>' then start posting messages.

And now we have four messages successfully posted to the test topic and it is going to be consumed.

8. Instantiate a Console Consumer :

The next step we are going to instantiate a console consumer.

Open new `CMD terminal` and use the command below to create a Consumer.

kafka-console-consumer.bat --bootstrap-server localhost:9092 --topic test-topic --from-beginning

Here we provide the boostrap server in which our kafka broker is up and running after that we provide the topic and we are going to give the options from the beginning .
from the beginning - The meaning of this one is that I read all the messages from the beginning.

As you produce messages , these are consumed by the consumer , so we have producer and consumer successfully.

If we do not provide this from beginning ,what would happen?

Basically , it is not going to read the messages that are already there but as you post the new messages ,it's going to read that message.

Here I didn't provide the option to start from the beginning, so it simply read the most recently posted message, "This is a message produced by the producer."

NOTE : Sometimes you may get the messages in different order because of the message is getting posted to different partitions.

So if you want ordering , you have to make sure you're going to post to the same partition.

So for ordering you need to pass the same key , if you pass the same key , then the messages will be retrieved in the same order.

"We will discuss creating **Producer & consumer** with Key and also about Consumer Offsets in my next blog"

That's all for now, guys, I hope you learnt something new today 🤘 .

Have a great day....

This is priyanka nandula signing off...

Database Caching with Spring Boot and Hazelcast

priyankanandula — Thu, 17 Jun 2021 13:53:15 +0000

Signed in as @priyankanandula

After few days gap, I am back 😎

Good day 😃, guys! I come back with an important concept during the execution of database operations using ORM tools in Spring Boot.

In this blog, we'll talk about caching and how to implement it using Hazel Cast, one of the cache providers.

Final Project Structure

Let's get started 👇

Before we go into detail regarding caching, let's have a look at how `ORM` tools handle the given request.

when client access our application, our application, which uses ORM tools like hibernate to read the data from the database, will execute a select query internally on the database table to retrieve the data.
The data is then converted into an object, which is then passed to our application, which then sends it back to the client as required.
Every time a client requests data from our application or ORM tool, the select statement will be executed, and the process will repeat again.
Instead of repeatedly performing the same read operation, we employ caching or a cache.

Caching :

Caching stores data or objects in temporary locations. When a request comes in for the first time, this ORM tool or the caching framework will read the data, transform it to an object, and store it in a temporary location or on disc.

The next time a request comes in, these ORM frameworks will check to see if the data for that request is already in the cache. If it exists, no database select queries or database communication will be performed; simple take the object from cache, process it, and return it to the client.

Finally, we may increase our application's performance by using the Cache.

Let's get started with the implementation 👇

Follow the steps below to utilise Hazel Cast or any other cache provider.

Adding Dependencies
Create Cache Configuration
Enable and Use Caching
Caching in Action

1. Adding Dependencies :

Add the following dependencies in POM.xml file.

spring-boot-starter-cache
hazelcast-spring

POM.xml

<?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.0.6.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.priya.springweb</groupId>
    <artifactId>ProductRestAPI</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>ProductRestAPI</name>
    <description>Demo project for Spring BootRestAPI</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>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-cache</artifactId>
        </dependency>
<!-- https://mvnrepository.com/artifact/com.hazelcast/hazelcast-spring -->
<dependency>
    <groupId>com.hazelcast</groupId>
    <artifactId>hazelcast-spring</artifactId>

</dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </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>
            </plugin>
        </plugins>
    </build>

</project>

2. Create Cache Configuration :

Now we'll create the java configuration class that we'll need to create a Cache. This is where we'll give the Cache a name, size, and amount of objects that can be placed in it, among other things.

we can add `Hazelcast` configuration in one of the following manners:

Add hazelcast.yaml configuration OR
Add hazelcast.xml configuration OR
Define @bean with Hazelcast configuration in the source code

I am using the Java Based Configuration using @bean

package com.priya.springweb.cacheconfiguraions;



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

import com.hazelcast.config.Config;
import com.hazelcast.config.EvictionConfig;
import com.hazelcast.config.EvictionPolicy;
import com.hazelcast.config.MapConfig;
import com.hazelcast.config.MaxSizeConfig;


@Configuration
public class ProductCacheConfig {

    @Bean
    public Config cacheConfig() {
        return new Config()
                .setInstanceName("hazel-instance")
                .addMapConfig(new MapConfig()
                        .setName("product-cache")
                        .setTimeToLiveSeconds(5000)
                        .setMaxSizeConfig(new MaxSizeConfig(200,com.hazelcast.config.MaxSizeConfig.MaxSizePolicy.FREE_HEAP_SIZE))
                        .setEvictionPolicy(EvictionPolicy.LRU)
                        );
                }
}

addMapConfig : We set all the values for the Cache in this MapConfig, such as name, size, time, and so on.It holds all the information for the Cache.
setName : The name of the cache should be specified. choose whatever name you want.
setTimeToLiveSeconds : This is the period of time the object will live in the Cache before being evicted.
setMaxSizeConfig : The Cache's MaxSizeConfig option has two values: one is the maximum number of objects the Cache can hold, and the other is the maximum amount of space the Cache can maintain.
setEvictionPolicy : We'll also need to give cache eviction information, such as when the cache should be cleaned, because the cache size will grow with time, and if we don't clear it, our application will crash.

We can employ a variety of cache policies, like as

1 Least Recently Used(LRU)

2 Least Frequently Used(LFU)

3 Random : Randomly pick the element from Cache and removed it.

4 NONE : It will do nothing.

3. Enable and Use Caching :

I'm using the Rest APIs that we created in my previous blog.

This should be referred to [https://dev.to/priyanka_nandula/create-rest-crud-api-with-springboot-springdata-jpa-3m6b]

package com.priya.springweb;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cache.annotation.EnableCaching;


@SpringBootApplication
@EnableCaching
public class ProductRestApiApplication {

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

}

@EnableCaching that will enable the caching for our application

package com.priya.springweb.entities;

import java.io.Serializable;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
public class Product implements Serializable{

    /**
     * 
     */
    private static final long serialVersionUID = 1L;
    @Id
    @GeneratedValue(strategy=GenerationType.IDENTITY)
    private int id;
    private String name;
    private String description;
    private int price;
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getDescription() {
        return description;
    }
    public void setDescription(String description) {
        this.description = description;
    }
    public int getPrice() {
        return price;
    }
    public void setPrice(int price) {
        this.price = price;
    }

}

Our Model class Should implements the Serializable interface because hazel cast or any other Cache providers like EH Cache will serialize our projects or Model Entities to a file system or in memory as required to a database.

package com.priya.springweb.controllers;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

import com.priya.springweb.entities.Product;
import com.priya.springweb.repos.ProductRepository;

@RestController
public class ProductController {

    @Autowired
    private ProductRepository repository;

    @RequestMapping(value="/products",method=RequestMethod.GET)
    public List<Product> getProducts(){

        return repository.findAll();
    }

    @RequestMapping(value="/products/{id}",method=RequestMethod.GET)
    @Cacheable(value="product-cache",key="#id")
    public Product getProductById(@PathVariable("id") int id) {

        return repository.findById(id).get();

    }

    @RequestMapping(value="/products/",method=RequestMethod.POST)
    public Product createProduct(@RequestBody Product product) {

        return repository.save(product);
    }


    @RequestMapping(value="/products/",method=RequestMethod.PUT)
    public Product updateProduct(@RequestBody Product product) {

        return repository.save(product);
    }

    @RequestMapping(value="/products/{id}",method=RequestMethod.DELETE)
    @CacheEvict(value="product-cache",key="#id")
    public void  deleteProduct(@PathVariable("id") int id) {

    repository.deleteById(id);

    }
}

We will be using Caching on the get a single product method.
Cacheable : we will also use @Cachable on the rest controllers or service classes. Here value is the Cache name we provided in the configuration class and Key is unique Key to store in Cache.
CacheEvict : cache evict information that is when should cache be cleaned.

After you made all these Changes Run the Application -->Run on Spring Boot App

4. Caching in Action :

To check the working of Caching we will execute the GET MEthod.

NOTE: Please remember the following few points.

Make sure MySQL Server is running.

Make sure you are running the SpringBoot project in embedded Tomcat Server

I'm using `RestTemplate` inside the JUnit Class to consume the Restful Services we created in the Controller Class.

Using the RestTemplate given by the spring web module, we can now consume restful web services or create a restful client.

Spring web enables us to both design and consume restful web services.

Rest Template is a class that performs various HTTP Methods(GET/PUT/POST/DELETE..).

The returned json is automatically deserialized into the Product class when using a spring or rest template.

Application.Properties File :

spring.datasource.url=jdbc:mysql://localhost:3306/myproducts
spring.datasource.username=root
spring.datasource.password=root

server.servlet.context-path=/productapi

productresapi.services.url=http://localhost:8080/productapi/products/

spring.cache.cache-names=product-cache
spring.cache.type=hazelcast
spring.jpa.show-sql=true

package com.priya.springweb;

import static org.junit.Assert.assertEquals;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
import org.springframework.web.client.RestTemplate;

import com.priya.springweb.entities.Product;


@RunWith(SpringRunner.class)
@SpringBootTest()
public class ProductRestApiApplicationTests {

    @Value("${productresapi.services.url}")
    private String baseURL;

    @Test
    public void textGetProduct() {
        RestTemplate template=new RestTemplate();
        Product product=template.getForObject(baseURL+"2", Product.class);
        System.out.println("name :"+product.getName());
        assertEquals("Mac Book Pro", product.getName());



    }

}

Available methods are:

getForObject(url, classType) – retrieve a representation by doing a GET on the URL. The response (if any) is unmarshalled to given class type and returned.

getForEntity(url, responseType) – retrieve a representation as ResponseEntity by doing a GET on the URL.

exchange(requestEntity, responseType) – execute the specified RequestEntity and return the response as ResponseEntity.

execute(url, httpMethod, requestCallback, responseExtractor) – execute the httpMethod to the given URI template, preparing the request with the RequestCallback, and reading the response with a ResponseExtractor.

"In my upcoming blogs, I'll go over RestTemplate in greater detail.."

Now Run this `JUnit Test` Case:

Test Runs Successfully. Now go through the logs Console.

As you can see, when we sent the Request for the first time, it executed the Select Query to get the data from the database.

Run the JUnit Test Case Again :

I've now cleared the console logs and rerunning the Test Case.

Now Hibernate did not execute the select query because the object was already cached.

NOTE : Instead of using RestTemplate within the Code, you can also use Postmansuiteand then check the logs Console.

RestTemplate can be used anywhere in the application, such as in the RestController or Service classes.

Here's a link to the code's GIT repository.[https://github.com/priyankanandula/SpringBoot/tree/feature/HazelCast_Cache/ProductRestAPI]

That's it, guys, that's how we use Hazel Cast to implement caching. I hope you found it interesting.

This is priyanka nandula signing off...

What are Fail Fast Iterators in Java Collections?

priyankanandula — Sat, 12 Jun 2021 17:31:26 +0000

Signed in as @priyankanandula

Hello, Developers hope you guys are doing great 😃.Today I came up with an interesting and important concept in Java Collections, as well as in interviews. I hope you enjoy it.

Do you know what was the issue with using the for-loop to iterate the Collection objects ❓

Let me explain this to you in such case 👇.

Let's take a look at the following code

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

public class IteratorDemo {


    private static void arrayListDemo() {
        List<Integer> list=new ArrayList<>();
        list.add(5);
        list.add(6);
        list.add(7);
        list.add(9);
        for(int element:list) {

            System.out.println("element : "+element);

            if(element==6) {

                list.remove(Integer.valueOf(7));
            }
        }

    }

    public static void main(String[] args) {
        arrayListDemo();

    }

}

OUTPUT :

element : 5
element : 6
Exception in thread "main" java.util.ConcurrentModificationException
    at java.util.ArrayList$Itr.checkForComodification(Unknown Source)
    at java.util.ArrayList$Itr.next(Unknown Source)
    at IteratorDemo.arrayListDemo(IteratorDemo.java:14)
    at IteratorDemo.main(IteratorDemo.java:27)

It was printed up to element 6, after which the element in the following index is 7, and we have put a condition to remove that element from the list if it is 7 and here it was thrown
java.util.ConcurrentModificationException

NOTE : However, we can do replacement operations such as set method, and this exception will never be thrown.

Root Cause :

Internally, for-each statement, it invokes the iterator function for the given object and iterates over the elements using the instance obtained by the iterator.

The iterator, which is internally written, generates the concurrent modification exception.

The iterator does not allow us to make any concurrent structural changes (removing/adding) to the underlying ArrayList.

Such Iterators which gives a concurrent modification exception are called fail-fast Iterator.

Solution :

The solution here is to use Iterator interface and to access an instance of iterator we need to invoke the iterator method which is declared in the Iterable interface.

Collection interface already extends the Iterable interface and collection implementations like ArrayList, HashSet.. implements the Iterator method.

public interface Collection
extends Iterable{..}

Collection interface is saying that its elements can be iterated by extending the Iterable.

The `java.lang.Iterable` interface provides the following methods:

iterator() : We can iterate the elements of Java Iterable by obtaining the Iterator from it using the iterator() method.
forEach(Consumer<? super T> action) : Performs the given action for each element of the Iterable until all elements have been processed or the action throws an exception.
spliterator() : The Spliterator interface, can be used for traversing and partitioning sequences. It's a base utility for Streams, especially parallel ones.

The `java.util.Iterator` interface provides the following methods:

boolean hasNext() - Returns true if the iteration has more elements.
E next() - Returns the next element in the iteration.
void remove() - Removes from the underlying collection the last element returned by the iterator (optional operation).
forEachRemaining(Consumer<? super E>action) - Performs the given action on each of the element until and unless all the elements have been processed or unless an exception is thrown by the action.

Now, using the Iterator interface, we'll rewrite the code to remove the element.

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


public class IteratorDemo {


    private static List<Integer> arrayListDemo() {
        List<Integer> list=new ArrayList<>();
        list.add(5);
        list.add(6);
        list.add(7);
        list.add(9);


        return list;
    }

    private static void iteratorDemo(List<Integer> list1) {
        System.out.println("\nInside iteratorDemo ... ");

        Iterator<Integer> iterator = list1.iterator();
        while (iterator.hasNext()) {
            int element = iterator.next();
            System.out.println("element: " + element);

            if (element == 9) {
                iterator.remove();

            }
        }
        System.out.println("List After removing the element " + list1);


    }

    public static void main(String[] args) {
        List<Integer> list1 = arrayListDemo();
        iteratorDemo(list1);
    }
}

OUTPUT :


Inside iteratorDemo ... 
element: 5
element: 6
element: 7
element: 9
List After removing the element [5, 6, 7]

Yo 🤘 ! It doesn't throw any exceptions anymore.

NOTE : The invocation of remove method must be preceded by the invocation of next() method otherwise it will throw an exception.Because the remove method will removes the element that was returned by the next() method.

For Example : Sample Code

while (iterator.hasNext()) {
            int element = iterator.next();
            System.out.println("element: " + element);

            if (element == 9) {
                iterator.remove();
                iterator.remove();
            }
        }

OUTPUT

Inside iteratorDemo ... 
element: 5
element: 6
element: 7
element: 9
Exception in thread "main" java.lang.IllegalStateException
    at java.util.ArrayList$Itr.remove(Unknown Source)
    at IteratorDemo.iteratorDemo(IteratorDemo.java:30)
    at IteratorDemo.main(IteratorDemo.java:40)

It will throw an exception at the second remove method because it has to be preceded by next() method only.

Generally the use case of this scenario like removing during the iteration could be that you may have retrieved a list of elements form the database and now you want to remove some of them which meets certain criteria.

That's it for today, guys. I hope you learned something new.

This is priyanka nandula signing off...

Create REST CRUD API With SpringBoot & SpringData-JPA.

priyankanandula — Thu, 10 Jun 2021 18:22:53 +0000

Signed in as @priyankanandula

Hurrah 😃 , finally I started writing technical blogs to share my practical implementation knowledge in programming.
This is the My First Blog come let's start 😍.

Hope you guys will definitely gain some knowledge after completion of reading this blog.

No delay let's start this 👇

In this blog, you will learn how to develop RESTful web services APIs for CRUD operations on a MySQL database. The CRUD operations include Create, Retrieve, Update and Delete.

Technologies & Tools Required.

Java Development Kit (JDK 1.8 or newer)
MySQL Database server (including MySQL Workbench and MySQL Command Line Client to manage database)
STS(Spring Tool Suite)--4.10.0.RELEASE for creating SpringBoot projects
Postman (to test RESTful APIs)

NOTE: You can use your favorite IDE like Eclipse, IntelliJ...

Implementation Steps :

Creating SpringBoot Maven Project in STS.
Creating Database in Mysql in CommandLine
Creating a Table in Database using MySQL WorkBench UI.
Creating an Entity Class in Project
Creating a JPA Repository to perform CRUD Operations for Entity Class
Configure Data Source Properties
Creating a RestController Class for GET , POST, PUT ,UPDATE & DELETE HTTP Methods
Run our SpringBoot Application in Embedded Tomcat Server
Test our Restful services using Postman

We will create Final Project Structure as below

1. Creating SpringBoot Maven Project in STS :

After open STS you can go through File ->New -> Spring Starter Project

Provide the details as below:

1.Name - any name as your wish (in this blog I gave as ProductRestAPI)

2.Type - Maven

3.Group, Artifact & Package - you can give any values as your wish.

Here I have used...
Group - com.priya.springweb
Artifact - ProductRestAPI
Package - com.priya.springweb

Click Next and then select the following dependencies that are required and then click finish.

1.The artifact spring-boot-starter-web is for Spring Web MVC, RESTful web services, and embedded Tomcat server.

2.The artifact spring-boot-starter-data-JPA is for Spring Data JPA and Hibernate.

The artifact MySQL-connector-java is for the JDBC driver for MySQL.

After click finish, the project gets created as below.

Maven POM File:

<?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.0</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.priya.springweb</groupId>
    <artifactId>ProductRestAPI</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>ProductRestAPI</name>
    <description>Demo project for Spring BootRestAPI</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>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </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>
            </plugin>
        </plugins>
    </build>

</project>

2.Creating Database in Mysql in CommandLine

Open MySQL Commandlind Client and log in with the password you have given at the time of installation.

I have used root user.

Create a database with any name in this I have used myproducts.

3.Creating a Table in Database using MySQL WorkBench

Execute the following SQL script in WorkBench.

use myproducts;

create table product(
id int NOT NULL AUTO_INCREMENT PRIMARY KEY,
name varchar(20),
description varchar(100),
price int
);

4.Creating an Entity Class in Project

Create a package like com.priya.springweb.entities and then create the Product class to map with the product table in the database as follows:

package com.priya.springweb.entities;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
public class Product {

    @Id
    @GeneratedValue(strategy=GenerationType.IDENTITY)
    private int id;
    private String name;
    private String description;
    private int price;
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getDescription() {
        return description;
    }
    public void setDescription(String description) {
        this.description = description;
    }
    public int getPrice() {
        return price;
    }
    public void setPrice(int price) {
        this.price = price;
    }

}

We have used @GeneratedValue(strategy=GenerationType.IDENTITY) because in the Database table we mentioned the id column as Auto_Increment to get these auto-generated values from a database.

NOTE: This is a simple domain model class, with class name and field names are identical to table name and column names in the database – so we can use the minimum number of JPA annotations.

5.Creating a JPA Repository to perform CRUD Operations for Entity Class

To take advantages of Spring Data JPA, create the ProductRepository interface as below:

package com.priya.springweb.repos;

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

import com.priya.springweb.entities.Product;

public interface ProductRepository extends JpaRepository<Product, Integer> {

}

NOTE : Here JpaRepository arguments represents

6.Configure Data Source Properties

In main/resources/application. properties file we need to specify database-connection information as follows.

spring.datasource.url=jdbc:mysql://localhost:3306/myproducts
spring.datasource.username=root
spring.datasource.password=root

server.servlet.context-path=/productapi

Remember to update url, username and password according to your MySQL database server.

NOTE:Here the context path is the name of the URL at which we access the application. The default context path is empty.you can provide any name here.

7.7.Creating a RestController Class for GET , POST, PUT ,UPDATE & DELETE HTTP Methods

Here, we come to the part that actually exposes RESTful APIs for CRUD operations – a Spring controller following REST style. Create the ProductController class with some initial code as below:

package com.priya.springweb.controllers;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

import com.priya.springweb.entities.Product;
import com.priya.springweb.repos.ProductRepository;

@RestController
public class ProductController {

    @Autowired
    private ProductRepository repository;

    @RequestMapping(value="/products",method=RequestMethod.GET)
    public List<Product> getProducts(){

        return repository.findAll();
    }

    @RequestMapping(value="/products/{id}",method=RequestMethod.GET)
    public Product getProductById(@PathVariable("id") int id) {

        return repository.findById(id).get();

    }

    @RequestMapping(value="/products/",method=RequestMethod.POST)
    public Product createProduct(@RequestBody Product product) {

        return repository.save(product);
    }


    @RequestMapping(value="/products/",method=RequestMethod.PUT)
    public Product updateProduct(@RequestBody Product product) {

        return repository.save(product);

    }

    @RequestMapping(value="/products/{id}",method=RequestMethod.DELETE)
    public void  deleteProduct(@PathVariable("id") int id) {

    repository.deleteById(id);

    }
}

 **@RestController** - The _@RestController_ annotation is used to define the RESTful web services. It serves JSON, XML and custom response

@RequestMapping - The @RequestMapping annotation is used to define the Request URI to access the REST Endpoints. We can define Request method to consume and produce object. The default request method is GET.

@PathVariable - The @PathVariable annotation is used to define the custom or dynamic request URI. The Path variable in request URI is defined as curly braces {}

@RequestBody - The @RequestBody annotation is used to define the request body content type.

NOTE:You must use @ResponseBody for Update and Create operations.

8. Run the SpringBoot Application in Embedded Tomcat Server

Right Click on your project and then select run as Spring boot app.

9. Testing our Restful services in Postman

1. Create Product Details - `POST METHOD`

URL : http://localhost:8080/productapi/products/

NOTE : Here in body JSON no need to pass id as it as already automatically generated by Database.

Must Select data type as JSON .

Yo 🤘! Data inserted successfully. Great Job.

2.Get Product Details - `GET METHOD`

URL - http://localhost:8080/productapi/products

Response :

[
    {
        "id": 1,
        "name": "IPhone",
        "description": "Its Awesome Product",
        "price": 1000
    },
    {
        "id": 2,
        "name": "Mac Book Pro",
        "description": "Its Amazing Product",
        "price": 3000
    },
    {
        "id": 6,
        "name": "Ipad Airpods",
        "description": "It is Good  Product",
        "price": 10000
    },
    {
        "id": 7,
        "name": "Ipad Mini",
        "description": "It is Good  Product",
        "price": 7000
    }
]

NOTE : No need to pass any body for GET.

3. Get Product Details by ID - `GET METHOD`

URL - http://localhost:8080/productapi/products/7

Give any id of product that exists in Database Product table.

4.Update Product Details - `PUT METHOD`

URL - http://localhost:8080/productapi/products/

{
    "id": 7,
    "name": "Ipad Mini",
    "description": "It is Good  Product",
    "price": 10000
}

Here I am updating the price to 10000 earlier we have given 7000.

NOTE : You must mention all the fields for PUT Method based upon the Id it wil lupdate the details in database table

5. 5.Delete Product Details by Id - `DELETE METHOD`

URL - http://localhost:8080/productapi/products/7

It deleted the Product successfully .

Thats it guys,WOW 😀 Good Job .We have completed creating REST API CRUD in Spring Boot.

Refer GIT Repository Details :

[Link] https://github.com/priyankanandula/SpringBoot-REST-API-CRUD

In next blog I will explain how to Consume these REST APIS using RestTemplate inside the code.

Have a Good Day, this is priyanka nandula signing off...

DEV Community: priyankanandula

Implementing Library Inventory Project Using Apache Kafka & SpringBoot Part 1

We have a librarian and library inventory

Simplistic view of application architecture

We have two microservices here...

Let's get started with the implementation.

Project Structure

Implementation Steps

1.Adding Dependencies and required properties in build.gradle file :

2. Create application.yml file inside resources folder as below :

3.Give Gradle build again :

4. Creating packages inside src/main/java folder :

Here com.kafka is root package remaining are sub packages in this root.

5. Create Application class inside root package :

6. Create configuration class inside config package :

7. Create Models classes inside domain package :

Book.java

LibraryEvent.java

LibraryEventType.class

8. Create KafkaProducer class inside producer package :

LibraryEventProducer.java

9. Create Controller class inside Controller package :

LibraryEventsController.java

10. Create test class inside srs/test/java package :

LibraryEventsControllerIntegrationTest.java

11. Starting up the Zookeeper & Kafka Serves:

1. First we must start the zookeeper Instance by using the below command.

2.Start up the kafka server using the below command.

12. Running the test class :

Basic CLI Implementation of Producer & Consumer using - Apache Kafka Broker & Zookeeper

Apache Kafka:

These are four main parts in a Kafka system:

Implementation steps :

1. Download and Install Apache Kafka(Windows):

2. Set up the kafka environment path variable :

3. Inside the Kafka folder, creating a data folder :

4. Modify the properties file's configuration parameters:

Also add the following two properties in the same file.

5. Getting the Zookeeper and Kafka instances running :

Start up the Zookeeper

Start up the Kafka

6. Creating a kafka topic :

Open new CMD terminal and use the command below to create a Kafka Topic

7.Instantiate a Console Producer :

Instantiate console producer without key.Open new CMD terminal and use the command below to create a Producer.

8. Instantiate a Console Consumer :

Open new CMD terminal and use the command below to create a Consumer.

If we do not provide this from beginning ,what would happen?

Database Caching with Spring Boot and Hazelcast

Final Project Structure

Before we go into detail regarding caching, let's have a look at how ORM tools handle the given request.

Caching :

Follow the steps below to utilise Hazel Cast or any other cache provider.

1. Adding Dependencies :

POM.xml

2. Create Cache Configuration :

we can add Hazelcast configuration in one of the following manners:

We can employ a variety of cache policies, like as

3. Enable and Use Caching :

4. Caching in Action :

I'm using RestTemplate inside the JUnit Class to consume the Restful Services we created in the Controller Class.

Application.Properties File :

Available methods are:

Now Run this JUnit Test Case:

As you can see, when we sent the Request for the first time, it executed the Select Query to get the data from the database.

Run the JUnit Test Case Again :

What are Fail Fast Iterators in Java Collections?

Let me explain this to you in such case 👇.

OUTPUT :

Root Cause :

Solution :

The `java.lang.Iterable` interface provides the following methods:

The `java.util.Iterator` interface provides the following methods:

OUTPUT :

For Example : Sample Code

OUTPUT

Create REST CRUD API With SpringBoot & SpringData-JPA.

Technologies & Tools Required.

Implementation Steps :

1. Creating SpringBoot Maven Project in STS :

Open new `CMD terminal` and use the command below to create a Kafka Topic

Instantiate console producer without key.Open new `CMD terminal` and use the command below to create a Producer.

Open new `CMD terminal` and use the command below to create a Consumer.

Before we go into detail regarding caching, let's have a look at how `ORM` tools handle the given request.

we can add `Hazelcast` configuration in one of the following manners:

I'm using `RestTemplate` inside the JUnit Class to consume the Restful Services we created in the Controller Class.

Now Run this `JUnit Test` Case:

1. Create Product Details - `POST METHOD`

2.Get Product Details - `GET METHOD`

3. Get Product Details by ID - `GET METHOD`

4.Update Product Details - `PUT METHOD`

5. 5.Delete Product Details by Id - `DELETE METHOD`