Saturday, March 9, 2024

what are different types of design patterns used in microservices

When designing microservices, there are several architectural patterns that can be used to achieve various goals such as scalability, fault tolerance, maintainability, and ease of deployment. Here are some common patterns used in microservices architecture:

1. Single Service Instance Pattern

Each microservice instance runs as a single instance. This is the simplest form of microservices architecture, where each service is deployed independently.

2. Service Instance per Container Pattern

Each microservice runs in its own container. Containers provide lightweight, isolated runtime environments for applications, allowing them to run consistently across different environments.

3. Service Instance per Virtual Machine Pattern

Each microservice runs in its own virtual machine (VM). This pattern provides a higher level of isolation compared to containers but comes with the overhead of managing VMs.

4. Shared Database Pattern

Multiple microservices share a common database. While this can simplify some aspects of development, it can also lead to tight coupling between services and make it difficult to evolve the system over time.

5. Database per Service Pattern

Each microservice has its own database. This pattern promotes loose coupling between services but requires careful coordination when data needs to be shared between services.

6. API Gateway Pattern

An API Gateway acts as a single entry point for clients to interact with multiple microservices. It can handle routing, authentication, and other cross-cutting concerns.

7. Aggregator Pattern

Aggregates data from multiple microservices into a single response for the client. This can reduce the number of client-server round trips and improve performance.

8. Saga Pattern

Manages distributed transactions across multiple microservices. A saga is a sequence of local transactions where each local transaction updates the database and publishes a message or event to trigger the next transaction.

9. Event Sourcing Pattern

Each microservice persists events as a log of changes to the system's state. This enables replaying events to rebuild state, auditing, and decoupling between services.

10. CQRS (Command Query Responsibility Segregation) Pattern

Separates read and write operations for a microservice. This pattern can improve scalability by allowing separate optimization for read and write operations.

11. Bulkhead Pattern

Isolates components of a system into separate pools to prevent failures in one component from affecting others. This helps improve fault tolerance and resilience.

12. Circuit Breaker Pattern

Monitors for failures and prevents cascading failures by temporarily blocking requests to a failing service. This pattern helps improve system stability.

13. Sidecar Pattern

Attaches a helper service, known as a "sidecar," to a microservice to provide additional functionality such as monitoring, logging, or security.

14. Strangler Pattern

Gradually replaces a monolithic application with microservices by "strangling" parts of the monolith with new microservices over time.

15. Choreography vs. Orchestration

In microservices, you often need to decide between choreography (decentralized coordination through events) and orchestration (centralized coordination through a service). This decision impacts how services communicate and coordinate their actions.

These patterns can be used individually or in combination to design a microservices architecture that meets the specific requirements of your application. It's essential to consider factors such as scalability, maintainability, fault tolerance, and team expertise when choosing the appropriate patterns for your system.


Wednesday, December 27, 2023

Getting started with Generative AI prompt engineer Step By Step Guide

 Generative AI prompt engineering involves crafting effective prompts to elicit desired responses from generative models.

Whether you're working with any models, the key is to provide clear and specific instructions. Here's a step-by-step guide to get started:

  1. Understand the Model's Capabilities:

    • Familiarize yourself with the capabilities and limitations of the generative model you're using. Understand the types of tasks it can perform and the formats it accepts.
  2. Define Your Goal:

    • Clearly define the goal of your prompt. Are you looking for creative writing, programming code, problem-solving, or something else? The specificity of your goal will guide your prompt creation.
  3. Start with a Clear Instruction:

    • Begin your prompt with a clear and concise instruction. Be specific about the type of output you're expecting. For example, if you want a creative story, you might start with "Write a short story about..."
  4. Provide Context or Constraints:

    • If necessary, provide additional context or constraints to guide the model. This can include setting, characters, tone, or any specific requirements. Constraints help to narrow down the output and make it more relevant to your needs.
  5. Experiment with Temperature and Max Tokens:

    • Generative models often come with parameters like "temperature" and "max tokens." Temperature controls the randomness of the output, and max tokens limit the length of the response. Experiment with these parameters to fine-tune the model's behavior.
  6. Iterate and Refine:

    • Don't be afraid to iterate and refine your prompts. Experiment with different instructions, wording, and structures to achieve the desired output. Analyze the model's responses and adjust your prompts accordingly.
  7. Use System and User Messages:

    • For interactive conversations with the model, you can use both system and user messages. System messages set the behavior of the assistant, while user messages simulate the user's input. This can be useful for multi-turn interactions.
  8. Handle Ambiguity:

    • If your prompt is ambiguous, the model might produce unexpected or undesired results. Clarify your instructions to reduce ambiguity and improve the likelihood of getting the desired output.
  9. Consider Prompt Engineering Libraries:

    • Some platforms provide prompt engineering libraries that simplify the process of crafting effective prompts. For example, OpenAI's Playground or other third-party libraries may offer useful tools and examples.
  10. Stay Ethical:

    • Be mindful of ethical considerations when generating content. Avoid prompts that may lead to harmful or inappropriate outputs. Review and filter the generated content to ensure it aligns with ethical guidelines.

Prompt engineering often involves a trial-and-error process. As you experiment and become familiar with the model's behavior, you'll improve your ability to craft effective prompts for generative AI.

Friday, December 8, 2023

API rate limiting strategies for Spring Boot applications


API Rate Limiting

 Rate limiting is a strategy to limit access to APIs. 

 It restricts the number of API calls that a client can make within a certain time frame. 

 This helps defend the API against overuse, both unintentional and malicious.

API rate limiting is crucial for maintaining the performance, stability, and security of Spring Boot applications. Here are several rate limiting strategies you can employ:

1. Fixed Window Counter:

In this strategy, you set a fixed window of time (e.g., 1 minute), and you allow a fixed number of requests within that window. If a client exceeds the limit, further requests are rejected until the window resets. This approach is simple but can be prone to bursts of traffic.

2. Sliding Window Counter:

A sliding window counter tracks the number of requests within a moving window of time. This allows for a more fine-grained rate limiting mechanism that considers recent activity. You can implement this using a data structure like a sliding window or a queue to track request timestamps.

3. Token Bucket Algorithm:

The token bucket algorithm issues tokens at a fixed rate. Each token represents permission to make one request. Clients consume tokens for each request, and requests are only allowed if there are available tokens. Google's Guava library provides a RateLimiter class that implements this algorithm.

4. Leaky Bucket Algorithm:

Similar to the token bucket, the leaky bucket algorithm releases tokens at a constant rate. However, in the leaky bucket, the bucket has a leak, allowing it to empty at a constant rate. Requests are processed as long as there are tokens available. This strategy can help smooth out bursts of traffic.

5. Distributed Rate Limiting with Redis or Memcached:

If your Spring Boot application is distributed, you can use a distributed caching system like Redis or Memcached to store and share rate limiting information among different instances of your application.

6. Spring Cloud Gateway Rate Limiting:

If you're using Spring Cloud Gateway, it provides built-in support for rate limiting. You can configure rate limiting policies based on various criteria such as the number of requests per second, per user, or per IP address.

7. User-based Rate Limiting:

Instead of limiting based on the number of requests, you can implement rate limiting on a per-user basis. This is useful for scenarios where different users may have different rate limits based on their subscription level or user type.

8. Adaptive Rate Limiting:

Implement adaptive rate limiting that dynamically adjusts rate limits based on factors such as server load, response times, or the health of the application. This approach can help handle variations in traffic.

9.Response Code-based Rate Limiting:

Consider rate limiting based on response codes. For example, if a client is generating a high rate of error responses, you might want to impose stricter rate limits on that client.

10. API Key-based Rate Limiting:

Tie rate limits to API keys, allowing you to set different limits for different clients or users. This approach is common in scenarios where you have third-party developers using your API.

Thursday, June 15, 2023

How to install Kong Gateway using Docker

To install Kong Gateway, you can follow these steps: 

 Step 1: Choose the installation method: 
     Kong Gateway offers different installation methods depending on your operating system and

    You can choose from Docker, package managers (e.g., Homebrew, Yum, Apt), or manual installation.

     For simplicity, let's go with the Docker installation method.

 Step 2: Install Docker: If you don't have Docker installed, visit the Docker website
              ( and follow the instructions to install Docker for your specific
               operating system. 

 Step 3: Pull the Kong Gateway Docker image: 
             Open a terminal or command prompt. Run the following command to pull the Kong Gateway
              Docker image from Docker Hub:
docker pull kong/kong-gateway

Step 4: Run Kong Gateway container: Once the image is pulled, run the following command to start a
             Kong Gateway
docker run -d --name kong-gateway \
  -e "KONG_DATABASE=off" \
  -e "KONG_PROXY_ACCESS_LOG=/dev/stdout" \
  -e "KONG_ADMIN_ACCESS_LOG=/dev/stdout" \
  -e "KONG_PROXY_ERROR_LOG=/dev/stderr" \
  -e "KONG_ADMIN_ERROR_LOG=/dev/stderr" \
  -p 8000:8000 \
  -p 8001:8001 \

This command starts a Kong Gateway container named "kong-gateway" with the necessary environment variables and port mappings. 

 The -p option maps the container's ports to the host machine, allowing access to Kong Gateway's admin API (port 8001) and proxy API (port 8000). 

 The -e options set various environment variables like the database type (KONG_DATABASE=off disables the database), log configurations, and listen addresses.

 Step 5: Verify Kong Gateway installation: After running the container, wait for a few moments to allow
              Kong Gateway to initialize. 

You can check the logs of the container using the following command:
docker logs kong-gateway

Look for any error messages or indications that Kong Gateway has started successfully. 

 Step 6: Access Kong Gateway admin API: 

 Once Kong Gateway is running, you can access its admin API to configure and manage your Kong Gateway instance. 

Open a web browser and go to http://localhost:8001. You should see the Kong Gateway admin API homepage if everything is working correctly.

 Congratulations! You have successfully installed Kong Gateway using Docker. 

You can now proceed with configuring Kong Gateway and integrating it with your applications as needed

Monday, May 1, 2023

How to Implement Image classification using TensorFlow maven and Java

Here is an example of using TensorFlow with Java and Maven to perform image classification: 

 1.Create a new Maven project in your favorite IDE. 

 2. Add the TensorFlow Java dependency to your project by adding the following to your pom.xml file:


3. Create a new class, for example, and add the following code:
import java.awt.image.BufferedImage;
import javax.imageio.ImageIO;
import org.tensorflow.DataType;
import org.tensorflow.Graph;
import org.tensorflow.Session;
import org.tensorflow.Tensor;
import org.tensorflow.TensorFlow;

public class ImageClassifier {
    private static byte[] loadImage(String path) throws IOException {
        BufferedImage img = File(path));
        int height = img.getHeight();
        int width = img.getWidth();
        int channels = 3;
        byte[] data = new byte[height * width * channels];
        int pixel = 0;
        for (int i = 0; i < height; i++) {
            for (int j = 0; j < width; j++) {
                int rgb = img.getRGB(j, i);
                data[pixel++] = (byte) ((rgb >> 16) & 0xFF);
                data[pixel++] = (byte) ((rgb >> 8) & 0xFF);
                data[pixel++] = (byte) (rgb & 0xFF);
        return data;

    public static void main(String[] args) throws Exception {
        // Load the TensorFlow library
        try (Graph g = new Graph()) {
           byte[] graphBytes = TensorFlowModelLoader.load("path/to/model.pb");

            // Create a new session to run the graph
            try (Session s = new Session(g)) {
                // Load the image data
                String imagePath = "path/to/image.jpg";
                byte[] imageBytes = loadImage(imagePath);

                // Create a tensor from the image data
                Tensor inputTensor = Tensor.create(new long[]
                                   {1, imageBytes.length}, ByteBuffer.wrap(imageBytes));

                // Run the graph on the input tensor
                Tensor outputTensor = s.runner()
                        .feed("input", inputTensor)

                // Print the predicted label
                DataType outputDataType = outputTensor.dataType();
                long[] outputShape = outputTensor.shape();
                Object[] output = new Object[outputTensor.numElements()];
                System.out.println("Prediction: " + output[0]);
4. Replace the path/to/model.pb and path/to/image.jpg with the actual paths to your model and image files. 

 5. Run the ImageClassifier class, and it should print out the predicted label for the input image.

Thursday, April 13, 2023

How to create key cloak authentication server and spring boot

To create a Keycloak authentication server, you need to follow these steps: 

 1. Download and Install Keycloak: You can download Keycloak from the official website     

 Follow the installation instructions provided in the documentation. 

 2. Configure Keycloak: Once installed, you need to configure Keycloak by creating a new realm. 
     A realm is a container for all the users, roles, and groups in your application.

    To create a new realm, log in to the Keycloak admin console using the default credentials
      (admin/admin), then follow these steps:

      Click on the "Add Realm" button and provide a name for your realm. 

      Configure your realm settings, including themes, email settings, and login settings. 

      Create users and groups within your realm and assign roles to them. 

 3. Set Up Your Spring Boot Application: You can use the Keycloak Spring Boot Starter dependency to
      add Keycloak authentication to your Spring Boot application.

      Add the following dependency to your Maven or Gradle build file:


4. Configure Your Spring Boot Application: You need to configure your Spring Boot application to
     connect to the Keycloak server. 

     You can do this by adding the following properties to your or application.yml file:

   Replace <keycloak-server-url>, <keycloak-realm>, <keycloak-client-id>, 
    and <keycloak-client-secret> with the appropriate values for your Keycloak instance.

 5.  Secure Your Spring Boot Application: You can secure your Spring Boot application by adding the
      Keycloak configuration to your Spring Security configuration. 

      You can do this by creating a new class that extends KeycloakWebSecurityConfigurerAdapter and
      override the configure method. 

Here's an example:
@ComponentScan(basePackageClasses = KeycloakSecurityComponents.class)
public class SecurityConfig extends KeycloakWebSecurityConfigurerAdapter {

    public void configureGlobal(AuthenticationManagerBuilder auth) throws Exception {

    public KeycloakSpringBootConfigResolver keycloakConfigResolver() {
        return new KeycloakSpringBootConfigResolver();

    protected void configure(HttpSecurity http) throws Exception {
          .antMatchers("/user/**").hasAnyRole("user", "admin")
    This configuration class enables Keycloak authentication and authorization for specific URLs in the

 6. Test Your Application: You can test your application by running it and accessing the protected URLs.
     When a user tries to access a protected resource, they will be redirected to the Keycloak login page.
      Once they successfully authenticate, they will be redirected back to the original resource. 

That's it! we have created a Keycloak authentication server and secured your Spring Boot application with it.

Wednesday, April 12, 2023

How to build video conference using spring boot

To build a video conference application using Spring Boot, you can follow these steps: 

 1. Choose a video conferencing API: There are several video conferencing APIs available such as Twilio, Agora, Zoom, Jitsi, etc. Choose an API that best fits your requirements. 

 2. Set up a Spring Boot project: Create a new Spring Boot project using your preferred IDE or by using Spring Initializr. 

 3. Add the video conferencing API dependencies: Add the necessary dependencies for the chosen API in your project's pom.xml file.

 4. Configure the video conferencing API: Configure the video conferencing API with the required credentials and other settings in your Spring Boot application's configuration file.

 5. Implement the video conferencing features: Use the API's SDK to implement the video conferencing features such as creating a conference room, joining a room, leaving a room, etc. 

 6. Integrate the video conferencing features with your application: Add the necessary controllers and views to your Spring Boot application to integrate the video conferencing features with your application. 

 7. Test the application: Test the application thoroughly to ensure that the video conferencing features are working as expected. 

 Here's a sample code for a video conference application using Spring Boot and the Twilio Video API:
 1. Add the Twilio Video API dependency to your pom.xml file:



2. Add the required Twilio credentials and settings to your Spring Boot application's file
3. Implement a controller for creating and joining a video conference room:
public class VideoConferenceController {

    private TwilioConfig twilioConfig;

    public ResponseEntity createRoom() throws Exception {
        RoomCreator roomCreator = Room.creator()
        Room room = roomCreator.create();
        RoomResponse response = new RoomResponse();
        return ResponseEntity.ok(response);

    public ResponseEntity 
                        getRoomToken(@PathVariable("roomId") String roomId) {
        String accessToken = createAccessToken(roomId);
        return ResponseEntity.ok(accessToken);

    private String createAccessToken(String roomId) {
        VideoGrant grant = new VideoGrant();
        AccessToken token = new AccessToken.Builder(
        return token.toJwt();

4.Define a configuration class for the Twilio settings:
@ConfigurationProperties(prefix = "twilio")
public class TwilioConfig {

    private String accountSid;
    private String authToken;
    private String apiKey;
    private String apiSecret;
    private String statusCallback;
    private int maxParticipants;


5.Configure the Twilio settings in your Spring Boot application's application.yml file:
  account-sid: your_account_sid
  auth-token: your_auth_token
  api-key: your_api_key
  api-secret: your_api_secret
  status-callback: http://localhost:8080/callback
  max-participants: 4
6. Run your Spring Boot application and test the video conference feature by creating and joining a room using the API endpoints.

Tuesday, March 14, 2023

Oracle Cloud Infrastructure- Object storage example

This post will explain, how we can create bucket and configure notification and rules and object storage like create/update object. Login into OCI using login credentials . if you don't have a account please create the same using this link Once you create account and successful login, Now we need to create a bucket. search for bucket and create a bucket
After creating bucket now we can create a topic
Now we can create notification, after uploading file , we should get email
Create a Rule to process this
Once we create all then , once we upload file in object storage , then we should get email like below
This shows we can send email, but we can configure with different ways like queues. Here we will get the details in mail . But if we want complete object details, then we can use java code to retrieve the object details by calling the API which required namespace details ,bucket name and object name.
import java.nio.file.Paths;
import java.util.List;


public class LogFileRetriever {
    public static void main(String[] args) {
        String namespaceName = "mynamespace";
        String bucketName = "mybucket";
        String objectName = "mylogfile.txt";

        // Create a new Object Storage client
        ObjectStorage objectStorageClient = ObjectStorageClient.builder()

        GetObjectRequest request = GetObjectRequest.builder()

        GetObjectResponse response = objectStorageClient.getObject(request);

        // Get the InputStream from the response
        InputStream logFileInputStream = response.getInputStream();

        // Write the InputStream to a local file
        OutputStream logFileOutputStream = 
            new FileOutputStream(Paths.get("logfile.txt").toFile());
        byte[] buffer = new byte[1024];
        int bytesRead;
        while ((bytesRead = != -1) {
            logFileOutputStream.write(buffer, 0, bytesRead);

Monday, March 14, 2022

How to call REST API Using Spring Webflux WebClient set proxy with authorization while calling the external site and Generate base 64 authentication header spring boot

This post will explain us, how can we call REST API using Webclient. How to set Proxy username and password to call the external site. Step 1: Add folllowing dependency in your pom.xml
Step 2:
import lombok.extern.slf4j.XSlf4j;
import org.springframework.http.HttpHeaders;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.http.client.reactive.ClientHttpConnector;
import org.springframework.http.client.reactive.ReactorClientHttpConnector;
import org.springframework.web.reactive.function.client.WebClient;
import reactor.netty.http.client.HttpClient;
import reactor.netty.transport.ProxyProvider;

import java.util.Base64;
import java.util.function.Consumer;
import java.util.function.Function;
 public static void main(String[] args) {
  try {
  //Generate HttP client to set proxy details
  HttpClient httpClient = HttpClient.create()
            .proxy(proxy-> proxy.type(ProxyProvider.Proxy.HTTP)
            .password(new Function() {
                        public String apply(String s) {
                            return "test@12!";
  ClientHttpConnector clientHttpConnector = 
           new ReactorClientHttpConnector(httpClient);
  WebClient webClient = WebClient.builder().build();
  String plainCredentials = "username" + ":" + "password";
  String base64Credentials = new String(Base64.getEncoder()
  String authorizationHeader = "Basic " + base64Credentials;
  //input json
  String json = "{\n" +
                    "  \"user\": \"siva\"\n" +
            //set http headers
  Consumer httpHeaders = new Consumer() {
     public void accept(HttpHeaders httpHeaders) {
       httpHeaders.add("Authorization", authorizationHeader);
       httpHeaders.add("Content-Type", "application/json");
       httpHeaders.add("Proxy-Authorization", authorizationHeader);
   //post call to external URL and get ResponseEntity as response like body 
   //and http status code etc..
    ResponseEntity result = webClient.mutate()
                    .uri(new URI("https://localhost:8080/test/details"))
        catch(Exception ex){
Hope this post will help some one, while working on the REST API calls

Thursday, March 11, 2021

How to mock ResultSet , NamedParameterJdbcTemplate , RowMapper

package com.siva.springboot.javaguruonline.repository;

import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.List;

import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.invocation.InvocationOnMock;
import org.mockito.stubbing.Answer;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate;
import org.springframework.test.context.junit4.SpringRunner;

import com.siva.springboot.javaguruonline.model.EmployeeDetails;
 * @author Siva
//@SpringBootTest(classes = SpringbootJpaSwaggerSonarqubeApplication.class)
public class EmployeeDaoImplTest {
	public EmployeeDaoImpl employeeDao;
	private NamedParameterJdbcTemplate namedParameterJdbcTemplate;
	public void testGetAllEmployeeDetails(){
		List list = new ArrayList();
		EmployeeDetails employeeDetails = new EmployeeDetails();
	    .thenAnswer(new Answer>() {
	public List answer(InvocationOnMock invocation) 
                                          throws Throwable {
	            // Fetch the method arguments
	          Object[] args = invocation.getArguments();

	            // Fetch the row mapper instance from the arguments
	          RowMapper rm = (RowMapper) args[1];

	          // Create a mock result set and setup an expectation on it
	          ResultSet rs = Mockito.mock(ResultSet.class);
	            // Invoke the row mapper
	          EmployeeDetails actual = rm.mapRow(rs, 0);
	            // Assert the result of the row mapper execution
	          Assert.assertEquals(employeeDetails.getEmpName(), actual.getEmpName());

	            // Return your created list for the template#query call
	            return list;


Thursday, August 27, 2020

Getting started with Chatbot using java and response in text to speech -- Java simple chatbot and text to speech

This will explain you about , how we can write simple chatbot using java and read the bot response into speech 

 Step 1: Download sample program-ab from the below archive folder Program-ab 

 Step 2: Unzip the downloaded folder. 

 Step 3: Create java maven project using any IDE or console application

 Step 4: Copy Ab.jar (Which is there in the unzipped folder lib in step 2) add to the classpath 

 Step 5: Copy bots folder (which is available in the unzipped folder) it has all the aiml files, which bot act upon our request and give the response

 Step 6: Now we need to give bot response in speech

 Step 7: Download freetss from the given link FREETTS 

 Step 8: Unzip the downloaded folder and go to \freetts-1.2.2-bin\freetts-1.2\lib folder 

 Step 9: Run the jsapi.exe file- It will generate multiple jars

 Step 10: copy that jars and place it in the classpath of the java project 

 Step 11: Once above steps completed then, we can write simple java program as follows
package com.siva;

import java.util.Locale;
import java.util.Scanner;

import javax.speech.Central;
import javax.speech.synthesis.Synthesizer;
import javax.speech.synthesis.SynthesizerModeDesc;

import org.alicebot.ab.AB;
import org.alicebot.ab.Bot;
import org.alicebot.ab.Chat;
import org.alicebot.ab.MagicBooleans;
import org.alicebot.ab.utils.IOUtils;

public class TestChatbot {

    private static final boolean TRACE_MODE = false;
    static String botName = "super";
    public static void main(String[] args) {
        try {
            String aimlResourcesPath = getResourcesPath();
            MagicBooleans.trace_mode = TRACE_MODE;
            Bot bot = new Bot("super", aimlResourcesPath);
            Chat chatSession = new Chat(bot);
	        Scanner sc=new Scanner(;

	        String request = "Hai";

	        request = IOUtils.readInputTextLine();
	        String response = chatSession.multisentenceRespond(request); 
	            // Set property as Kevin Dictionary 
	                    + ".cmu_us_kal.KevinVoiceDirectory"); 
	            // Register Engine 
	                + ".jsapi.FreeTTSEngineCentral"); 
	            // Create a Synthesizer 
	            Synthesizer synthesizer 
	                = Central.createSynthesizer( 
	                    new SynthesizerModeDesc(Locale.US)); 
	            // Allocate synthesizer 
	            // Resume Synthesizer 
	            // Speaks the given text 
	            // until the queue is empty. 
	            		response, null); 

        } catch (Exception e) {
    private static String getResourcesPath() {
        File currDir = new File(".");
        String path = currDir.getAbsolutePath();
        path = path.substring(0, path.length() - 2);
        String resourcesPath = path + File.separator + "src" 
        + File.separator + "main" + File.separator + "resources";
        return resourcesPath;

Step 12: Once code completed , then run the java program , type the input like Hai, hello and date, there are so many QA mentioned in imal files. and we can also write our own aiml file, for reference, you can verify under boats/aiml folder 

Step 13: output will print in console and it will read the boat response.. 

 Step 14: Out put will be like below image. 

 Thanks for viewing this post.

Friday, July 24, 2020

Angular with Spring boot Getting started with Angular and Spring boot

This post will explain , how we can integrate spring boot rest api in angular js

Step 1 : We need to install angular js

Follow the steps to mention in the angular web site Angular set up

Basic commands used in angular application
npm install -g @angular/cli

Create a new angular js application

ng new employee-crud-client

Once application created then, now we need to create components, services, model classes to integrate with spring boot

Step 2: to create component - Go to src/app folder in command prompt

ng g c employee-list

We can write our entire crud operations logic inside employee-list component or we can create different components for different operations.

Once we create component , there were 4 files created

1. employee-list.component.ts - logic related to how to form request and after getting the response from service- spring boot api, how to massage and send it to ui
2. employee-list.component.html - plain html with angular script to display/action with response or user input
3. employee-list.component.spec
4. employee-list.component.css

Step 3: Once the above files created and now we need to configure these with angular components

1. app.module.ts - will have the components, which we created
2. app-routing.module.ts- will have the path details, to which path has to call the which component
3. app.component.html - will have the router-outlet, which internally call the routing-module and which will call the app.modules.ts

Step 4: This is important step, service to be created, which calls the spring boot api

ng g s employee

employee.service file will be created

this service consists of the logic , how we can call the rest api methods, This is called from the employee-list.component.ts

Step 5: We will create model class, it should be same like our pojo class in java

ng g class employee

Step 6: Once all the steps completed, then now we need to run the angular client.

ng serve
ng serve --open If there is no errors, then page directly will open in browser http://localhost:4200

Step 7 : For spring boot api application, see my previous employee crud operations with spring boot post.

Step 8: This way we can integrate our spring boot application with angular.

Thanks for viewing this post, if you have any difficulty while integration, please comment the same.

Convert Date to Number and Number to Date in Oracle

How we can convert date to number in oracle

select to_number(to_char(add_months(sysdate,-0),'yyyymm')) from dual;

How we can convert number to date

select to_char(to_date(202007,'yyyymm'),'dd-mon-yyyy') from dual;

Sunday, March 22, 2020

Spring Boot with Swagger UI , JPA , MYSQL , Mockito, Integration Test and Sonar Qube

This post will expain you about
1. How we will integrate spring boot and swagger api
2. Spring boot with JPA and MySQL (Crud Repository and NamedJdbcTemplate)
3 Spring mockMvc test for controller
4. Integration test for Service and DAO classes
5. Usage of Mockito
6. Sonarqube Code coverage

Step 1 : create a maven project called - springboot-jpa-swagger-mysql-sonarqube in eclipse
Step 2 : provide groupId,artifactId,version,jar,name and description
Step 3: Replace below pom.xml into your local system
pom.xml will have dependencies related to spring boot,swagger,jdbc,mysql,mockito,sonarqube



 Demo project for Spring Boot PJA MySQL AND Sonarqube








Step 4: Now create a Springboot application, which is the starting point to run the Application.

Step 5: create under resources folder, add the db related details
## Spring DATASOURCE (DataSourceAutoConfiguration & DataSourceProperties)
spring.datasource.url = jdbc:mysql://localhost:3306/employee
spring.datasource.username = root
spring.datasource.password = root

## Hibernate Properties
# The SQL dialect makes Hibernate generate better SQL for the chosen database = org.hibernate.dialect.MySQL5InnoDBDialect

# Hibernate ddl auto (create, create-drop, validate, update)
spring.jpa.hibernate.ddl-auto = update

logging.level.root = DEBUG


Step 5: Create a SwaggerConfig class, which will have the details , what is controller package and other details
Learn more about Swagger API swagger-ui

package com.siva.springboot.javaguruonline.config;

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

import springfox.documentation.service.ApiInfo;
import springfox.documentation.service.Contact;
import springfox.documentation.spi.DocumentationType;
import springfox.documentation.spring.web.plugins.Docket;
import springfox.documentation.swagger2.annotations.EnableSwagger2;

public class Swagger2Config {
 public Docket api() {
  return new Docket(DocumentationType.SWAGGER_2).select()

 private ApiInfo apiEndPointsInfo() {

  return new ApiInfoBuilder().title("Spring Boot REST API")
    .description("Employee Management REST API")
    .contact(new Contact("Siva Raju", "", ""))
    .license("Apache 2.0")

Step 6 : This project is related to employee management system - like Employee CRUD operations

Step 7 : Write Model class called Employee and EmployeeDetails

package com.siva.springboot.javaguruonline.model;


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

import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.EqualsAndHashCode;
import lombok.ToString;

@Table(name = "employee")
@ApiModel(description="All details about the Employee. ")
public class Employee implements Serializable{

 private static final long serialVersionUID = 7407317371057056536L;

 @ApiModelProperty(notes = "The database generated employee ID")
 private int id;

 @ApiModelProperty(notes = "The employee name")
 private String name;

 @ApiModelProperty(notes = "The employee age")
 private int age;

 public Employee() {


 public Employee(String name, int age) { = name;
  this.age = age;

 @GeneratedValue(strategy = GenerationType.AUTO)
 @Column(name = "emp_id", nullable = false)
 public int getId() {
  return id;

 public void setId(int id) { = id;

 @Column(name = "emp_name", nullable = false)
 public String getName() {
  return name;

 public void setName(String name) { = name;
 @Column(name = "email_age", nullable = false)
 public int getAge() {
  return age;

 public void setAge(int age) {
  this.age = age;


package com.siva.springboot.javaguruonline.model;

import lombok.EqualsAndHashCode;
import lombok.ToString;

public class EmployeeDetails {
 private int empId;
 public int getEmpId() {
  return empId;
 public void setEmpId(int empId) {
  this.empId = empId;
 public String getEmpName() {
  return empName;
 public void setEmpName(String empName) {
  this.empName = empName;
 private String empName;


Step 8: Step 8: service/serviceimpl and repository classes

In the repository class, It is extending the JpaRepository, which will get all the default methods related to that Model Object.
In the DAO class, NamedParameterJdbcTemplate , to work with native query and how to map using rowmapper

package com.siva.springboot.javaguruonline.repository;

import java.util.List;

import com.siva.springboot.javaguruonline.model.EmployeeDetails;

public interface EmployeeDao {
 public List getEmployeeDetails();


package com.siva.springboot.javaguruonline.repository;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate;
import org.springframework.stereotype.Repository;

import com.siva.springboot.javaguruonline.mapper.EmployeeDetailsMapper;
import com.siva.springboot.javaguruonline.model.EmployeeDetails;

public class EmployeeDaoImpl implements EmployeeDao{
 String sqlQuery="select emp_id,emp_name from employee";
 private NamedParameterJdbcTemplate namedParameterJdbcTemplate;

 public List getEmployeeDetails() {
  return namedParameterJdbcTemplate.query(sqlQuery, new EmployeeDetailsMapper());


package com.siva.springboot.javaguruonline.mapper;

import java.sql.ResultSet;
import java.sql.SQLException;

import org.springframework.jdbc.core.RowMapper;

import com.siva.springboot.javaguruonline.model.EmployeeDetails;

public class EmployeeDetailsMapper implements RowMapper {
 public EmployeeDetails mapRow(ResultSet resultset, int count) throws SQLException {
  EmployeeDetails employeeDetails = new EmployeeDetails();
  return employeeDetails;


package com.siva.springboot.javaguruonline.repository;

import org.springframework.stereotype.Repository;

import com.siva.springboot.javaguruonline.model.Employee;

public interface EmployeeRepository extends JpaRepository{


Step 9: Write Controller class, which will have the all the crud operations
package com.siva.springboot.javaguruonline.controller;

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

import javax.validation.Valid;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import com.siva.springboot.javaguruonline.exception.ResourceNotFoundException;
import com.siva.springboot.javaguruonline.model.Employee;
import com.siva.springboot.javaguruonline.model.EmployeeDetails;
import com.siva.springboot.javaguruonline.repository.EmployeeDao;
import com.siva.springboot.javaguruonline.repository.EmployeeRepository;

import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
import io.swagger.annotations.ApiResponse;
import io.swagger.annotations.ApiResponses;

@Api(value="Employee Management System")
public class EmployeeController {
 private static final String EMPLOYEE_NOT_FOUND_FOR_THIS_ID = "Employee not found for this id :: ";

 private EmployeeRepository employeeRepository;
 private EmployeeDao employeeDao;

 @ApiOperation(value = "View a list of available employees", response = List.class)
 @ApiResponses(value = { @ApiResponse(code = 200, message = "Successfully retrieved list"),
   @ApiResponse(code = 401, message = "You are not authorized to view the resource"),
   @ApiResponse(code = 403, message = "Accessing the resource you were trying to reach is forbidden"),
   @ApiResponse(code = 404, message = "The resource you were trying to reach is not found") })
 public List getAllEmployees() {
  return employeeRepository.findAll();
 @ApiOperation(value = "View a list of available employee details", response = List.class)
 @ApiResponses(value = { @ApiResponse(code = 200, message = "Successfully retrieved list"),
   @ApiResponse(code = 401, message = "You are not authorized to view the resource"),
   @ApiResponse(code = 403, message = "Accessing the resource you were trying to reach is forbidden"),
   @ApiResponse(code = 404, message = "The resource you were trying to reach is not found") })
 public List getAllEmployeeDetails() {
  return employeeDao.getEmployeeDetails();

 @ApiOperation(value = "Get an employee by Id")
 public ResponseEntity getEmployeeById(
   @ApiParam(value = "Employee id from which employee object will retrieve", required = true)
   @PathVariable(value = "id") Long employeeId)
   throws ResourceNotFoundException {
  Employee employee = employeeRepository.findById(employeeId)
    .orElseThrow(() -> new ResourceNotFoundException(EMPLOYEE_NOT_FOUND_FOR_THIS_ID + employeeId));
  return ResponseEntity.ok().body(employee);

 @ApiOperation(value = "Add an employee")
 public Employee createEmployee(
   @ApiParam(value = "Employee object store in database table", required = true)
   @Valid @RequestBody Employee employee) {

 @ApiOperation(value = "Update an employee")
 public ResponseEntity updateEmployee(
   @ApiParam(value = "Employee Id to update employee object", required = true)
   @PathVariable(value = "id") Long employeeId,
   @ApiParam(value = "Update employee object", required = true)
   @Valid @RequestBody Employee employeeDetails) throws ResourceNotFoundException {
  Employee employee = employeeRepository.findById(employeeId)
    .orElseThrow(() -> new ResourceNotFoundException(EMPLOYEE_NOT_FOUND_FOR_THIS_ID + employeeId));

  final Employee updatedEmployee =;
  return ResponseEntity.ok(updatedEmployee);

 @ApiOperation(value = "Delete an employee")
 public Map deleteEmployee(
   @ApiParam(value = "Employee Id from which employee object will delete from database table", required = true)
   @PathVariable(value = "id") Long employeeId)
   throws ResourceNotFoundException {
  Employee employee = employeeRepository.findById(employeeId)
    .orElseThrow(() -> new ResourceNotFoundException(EMPLOYEE_NOT_FOUND_FOR_THIS_ID + employeeId));

  Map response = new HashMap<>();
  response.put("deleted", Boolean.TRUE);
  return response;

Step 10: Once above code has been completed, then you can run the application by right clicking on the Springboot application.
Step 11. Once the application executed successfully, then we need to test this application

One way is either Using- SOAP UI, Postman - these needs to be installed on our machine, else we can't test the rest service.
To test the REST API, we already configured Swagger UI. So just go to your web browser, then click, http://localhost:8080/swagger-ui.html - it will display all the operations, which is availabe in controller class.

Now you can test those API's by giving request parameters

Step 12: Once done, we need to write Junit test cases for the all the classes

package com.siva.springboot.javaguruonline;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

public class SpringbootJpaSwaggerSonarqubeApplicationTest {

 public void contextLoads() {


Controller class test

package com.siva.springboot.javaguruonline.controller;

import static org.hamcrest.Matchers.hasSize;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.content;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;

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

import javax.annotation.meta.When;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.http.MediaType;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.test.web.servlet.MockMvc;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.siva.springboot.javaguruonline.SpringbootJpaSwaggerSonarqubeApplication;
import com.siva.springboot.javaguruonline.model.Employee;
import com.siva.springboot.javaguruonline.model.EmployeeDetails;
import com.siva.springboot.javaguruonline.repository.EmployeeDaoImpl;
import com.siva.springboot.javaguruonline.repository.EmployeeRepository;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;

@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT,classes=SpringbootJpaSwaggerSonarqubeApplication.class)
public class EmployeeControllerTest {
 private MockMvc mockMvc;
 private EmployeeRepository employeeRepository;
 private EmployeeDaoImpl employeeDao;
 public void testGetAllEmployees() throws Exception{
  List employeeList  = employeeRepository.findAll();
  ObjectMapper mapper = new ObjectMapper();
  String jsonString = mapper.writeValueAsString(employeeList);
  FileWriter file = new FileWriter(new File("employee.json"));
  .andExpect(jsonPath("$", hasSize(4)));

 public void testGetAllEmployeeDetails()  throws Exception {
  EmployeeDetails employee = new EmployeeDetails();
  List employeeList = new ArrayList();
  .andExpect(jsonPath("$", hasSize(4)));


DaoImpl Test

package com.siva.springboot.javaguruonline.repository;

import java.util.List;

import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

import com.siva.springboot.javaguruonline.SpringbootJpaSwaggerSonarqubeApplication;
import com.siva.springboot.javaguruonline.model.EmployeeDetails;
import com.siva.springboot.javaguruonline.repository.EmployeeDao;
@SpringBootTest(classes = SpringbootJpaSwaggerSonarqubeApplication.class)
public class EmployeeDaoImplTest {
 public EmployeeDao employeeDao;
 public void testGetAllEmployeeDetails(){
  List employeeDetails = employeeDao.getEmployeeDetails();


Repository Test

package com.siva.springboot.javaguruonline.repository;

import java.util.List;

import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

import com.siva.springboot.javaguruonline.SpringbootJpaSwaggerSonarqubeApplication;
import com.siva.springboot.javaguruonline.model.Employee;
import com.siva.springboot.javaguruonline.repository.EmployeeRepository;

@SpringBootTest(classes = SpringbootJpaSwaggerSonarqubeApplication.class)
public class EmployeeRepositoryTest {
 EmployeeRepository employeeRepository;
 public void getEmployeeDetails(){
  List employeeList = employeeRepository.findAll();
  Assert.assertNotNull("EmployeeListNotEmpty", employeeList);;


Step 13: We need to check the code coverage tool called Sonarqube, required dependencies added in pom.xml

Step 14: Download Sonarqube from SonarQube - and look for Historical Downloads, then download , which ever the version you want to work on.

Step 15 : Unzip that file and go to bin folder- StartSonar.bat file

Step 16 : Once Sonar is up, then go to browser and try http://localhost:9000 , login with username -admin and password- admin

Step 17: Once Sonarqube is up and running, we need to run the code through either sonar scanner or maven

Before Scanning the code, we need to create properties file called - place the inside of the your project
and need to mention src code path , test path, java version.. etc

# must be unique in a given SonarQube instance
# this is the name displayed in the SonarQube UI

# Path is relative to the file. Replace "\" by "/" on Windows.
# Since SonarQube 4.2, this property is optional if sonar.modules is set. 
# If not set, SonarQube starts looking for source code from the directory containing 
# the file.
# Encoding of the source code. Default is default system encoding

# Generate sonar issues report in html and console

# Display Jacoco report into SonarQube dashboard
# Comma-separated paths to directories with tests (optional)
# This name depends on the configuration in pom.xml. In this example we have ${}/coverage-reports/jacoco-ut.exec entry in our pom.xml

Step 18 : Use the below command to run the code coverage- make sure before running the sonar, sonarqube should up and running
Go to your project location in the command prompt.
/>mvn clean install sonar:sonar


Contact Form


Email *

Message *