a143mk-Software Programming

How to create an AI and RAG chatbot using Spring AI and a Web HTML page.

Retrieval-Augmented Generation (RAG)
First, you need to select an LLM (Large Language Model) that Spring AI will use to communicate: Instead of relying solely on an LLM's pre-trained knowledge, RAG fetches relevant context from your own data sources (like databases, PDFs, or internal documentation) at runtime and passes that information along with the user prompt to the LLM.
Step 1: Core Concepts of RAG

Ingestion & Embedding (Offline / Pre-processing): Raw documents (PDF, TXT, HTML) are read and split into smaller text chunks. An Embedding Model converts these text chunks into numerical vectors. The vectors and text chunks are stored in a Vector Store (e.g., PgVector, ChromaDB, Pinecone, Redis).
Retrieval (Runtime): When a user submits a query, Spring AI converts the query into a vector and searches the Vector Store for the most semantically relevant document chunks.
Augmentation & Generation: Spring AI automatically combines the user query and the retrieved documents into an augmented prompt. The augmented prompt is sent to the LLM, which uses the provided context to generate an accurate, hallucination-free answer.

Key RAG Components in Spring AI:
Spring AI simplifies RAG integration through familiar Spring abstractions: DocumentReader & TextSplitter: Interfaces to ingest documents (e.g., using Apache Tika) and break them into processable chunks.
VectorStore: A unified Java abstraction for vector databases (supports pgvector, Redis, Pinecone, Qdrant, Milvus, ChromaDB, etc.).
Advisor API (QuestionAnswerAdvisor): A high-level abstraction that automatically intercepts ChatClient prompts, queries the VectorStore, appends retrieved documents to the prompt context, and passes it to the LLM.
RetrievalAugmentationAdvisor: A modular API for advanced RAG patterns, enabling features like multi-query expansion, document re-ranking, and dynamic metadata filtering.
Step 2: Implementing Basic RAG with Spring AI
In this step, we configure the Spring Boot AI application using Spring Initializr (https://start.spring.io/); we have previously covered how to perform this configuration. Here, we will explain the coding process step-by-step.

Step 2.1: Check the dependencies in the `pom.xml` file and ensure they match your project setup.

<?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>4.1.1</version>
		<relativePath/> 
	</parent>
	<groupId>a143mk.AI</groupId>
	<artifactId>aiChatclient</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<name/>
	<description/>
	<url/>
	<licenses>
		<license/>
	</licenses>
	<developers>
		<developer/>
	</developers>
	<scm>
		<connection/>
		<developerConnection/>
		<tag/>
		<url/>
	</scm>
	<properties>
		<java.version>17</java.version>
		<spring-ai.version>2.0.1</spring-ai.version>
	</properties>
	<dependencies>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-webmvc</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.ai</groupId>
			<artifactId>spring-ai-starter-model-ollama</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.ai</groupId>
			<artifactId>spring-ai-vector-store</artifactId>
		</dependency>

<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-webmvc-test</artifactId>
			<scope>test</scope>
		</dependency>
	</dependencies>
	<dependencyManagement>
		<dependencies>
			<dependency>
				<groupId>org.springframework.ai</groupId>
				<artifactId>spring-ai-bom</artifactId>
				<version>${spring-ai.version}</version>
				<type>pom</type>
				<scope>import</scope>
			</dependency>
		</dependencies>
	</dependencyManagement>

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

</project>

Step 2.2: We create a REST controller named `RAGController.java`. Here, we will see how to implement the LLM packages and classes, and we will also use `@CrossOrigin` to facilitate the design of the web UI.

package a143mk.AI.aiChatclient;
import a143mk.AI.Modal.QueryRequest;
import jakarta.annotation.PostConstruct;
import org.springframework.ai.chat.client.ChatClient;
import org.springframework.ai.chat.messages.Message;
import org.springframework.ai.chat.messages.UserMessage;
import org.springframework.ai.chat.prompt.Prompt;
import org.springframework.ai.chat.prompt.SystemPromptTemplate;
import org.springframework.ai.document.Document;
import org.springframework.ai.embedding.EmbeddingModel;
import org.springframework.ai.reader.TextReader;
import org.springframework.ai.transformer.splitter.TokenTextSplitter;
import org.springframework.ai.vectorstore.SearchRequest;
import org.springframework.ai.vectorstore.SimpleVectorStore;
import org.springframework.ai.vectorstore.VectorStore;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.Resource;
import org.springframework.http.MediaType;
import org.springframework.web.bind.annotation.CrossOrigin;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;

import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.stream.Collectors;

@RestController
@CrossOrigin(origins = "*")
public class RAGController {

private final ChatClient chatClient;
    private final EmbeddingModel embeddingModel;
    private final Map<String, String> responseCache = new ConcurrentHashMap<>();
    private VectorStore vectorStore;

@Value("${file.path:classpath:data/data.text}")
    private Resource fileResource;

private String template;

public RAGController(ChatClient.Builder chatClientBuilder, EmbeddingModel embeddingModel) {
        this.chatClient = chatClientBuilder.build();
        this.embeddingModel = embeddingModel;
    }

@PostConstruct
    public void init() {
        this.vectorStore = SimpleVectorStore.builder(this.embeddingModel).build();

Resource resource = (fileResource != null && fileResource.exists())
                ? fileResource
                : new ClassPathResource("data/data.text");

if (resource.exists()) {
            try {
                TextReader textReader = new TextReader(resource);
                TokenTextSplitter tokenTextSplitter = new TokenTextSplitter();
                List<Document> documents = tokenTextSplitter.apply(textReader.get());
                if (documents != null && !documents.isEmpty()) {
                    this.vectorStore.accept(documents);
                }
            } catch (Exception e) {
                throw new IllegalStateException("Failed to load the RAG knowledge base from data.text", e);
            }
        }

this.template = "You are an internal local AI assistant. Use the provided context to answer the user's question. " +
                "If the answer is not in the context, say that the information is not available in the local knowledge base.\n\n" +
                "Context:\n{document}";
    }

@PostMapping(value = "/rag", consumes = MediaType.APPLICATION_JSON_VALUE, produces = MediaType.TEXT_PLAIN_VALUE)
    public String rag(@RequestBody QueryRequest queryRequest) {
        String question = queryRequest == null ? null : (queryRequest.getQuestion() != null ? queryRequest.getQuestion() : queryRequest.getQuery());

if (question == null || question.isBlank()) {
            throw new IllegalArgumentException("Request must contain a non-empty 'question' or 'query'.");
        }

String cacheKey = question.trim().toLowerCase();
        String cachedResponse = responseCache.get(cacheKey);
        if (cachedResponse != null) {
            return cachedResponse;
        }

String retrievedDoc = readRelevantContext(question);

SystemPromptTemplate systemPromptTemplate = new SystemPromptTemplate(template);
        Message systemMessage = systemPromptTemplate.createMessage(Map.of("document", retrievedDoc));

Message userMessage = new UserMessage(question);
        Prompt prompt = new Prompt(List.of(systemMessage, userMessage));

String response = chatClient.prompt(prompt)
                .call()
                .content();

responseCache.put(cacheKey, response);
        return response;
    }

private String readRelevantContext(String question) {
        if (vectorStore == null) {
            return readRawKnowledgeBase();
        }

try {
            List<Document> similarDocuments = vectorStore.similaritySearch(
                    SearchRequest.builder().query(question).topK(3).build());

if (similarDocuments == null || similarDocuments.isEmpty()) {
                return readRawKnowledgeBase();
            }

String retrievedDoc = similarDocuments.stream()
                    .map(Document::getText)
                    .filter(text -> text != null && !text.isBlank())
                    .collect(Collectors.joining("\n\n"));

return retrievedDoc.isBlank() ? readRawKnowledgeBase() : retrievedDoc;
        } catch (Exception e) {
            return readRawKnowledgeBase();
        }
    }

private String readRawKnowledgeBase() {
        try {
            Resource resource = (fileResource != null && fileResource.exists()) ? fileResource : new ClassPathResource("data/data.text");
            if (!resource.exists()) {
                return "No local context file was found.";
            }

return new String(resource.getInputStream().readAllBytes(), StandardCharsets.UTF_8);
        } catch (IOException e) {
            return "The local knowledge base could not be loaded.";
        }
    }
}

Step 2.3: We will configure the LLM model settings within the `application.properties` file.

spring.application.name=aiChatclient
server.port=8082

# Use the local Ollama instance for both the LLM and embeddings.
spring.ai.ollama.base-url=http://localhost:11434
spring.ai.ollama.chat.options.model=codellama:latest
spring.ai.ollama.chat.options.num-predict=256
spring.ai.ollama.chat.options.temperature=0.2
spring.ai.ollama.embedding.options.model=mxbai-embed-large:latest
spring.ai.ollama.embedding.enabled=true

# Local knowledge base file used by the RAG controller.
file.path=classpath:data/data.text

Step 2.4: We implement RAG by taking raw documents (PDF, TXT, HTML) processed into `data.text` format and breaking them down into smaller text chunks.

Details:

Name: Manoj kumar Vishwakarms

address: 123 Main Street, City, Country

phone: +910000000000

email: manoj@example.com

job: Software Engineer

skills: Java, Spring Boot, SQL, JavaScript

//Something else can also be written in this RAG data file.

Step 3: Finally, we create the web page (`indexAIRAGCHAT.html`) and integrate the REST controller with the web UI.

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">

<script src="https://code.jquery.com/jquery-3.7.1.min.js"></script>

.chat-container {
            max-width: 700px;
            margin: auto;
            background: white;
            padding: 25px;
            border-radius: 10px;
            box-shadow: 0 2px 10px rgba(0,0,0,0.1);
        }

#chatInput {
            width: 70%;
            padding: 10px;
            font-size: 16px;
        }
		 #chatInputRAG {
            width: 70%;
            padding: 10px;
            font-size: 16px;
        }

#sendBtn {
            padding: 10px 20px;
            font-size: 16px;
            cursor: pointer;
        }
		
		 #sendStrimRAG {
            padding: 10px 20px;
            font-size: 16px;
            cursor: pointer;
        }
		
		
		 #sendStrim {
            padding: 10px 20px;
            font-size: 16px;
            cursor: pointer;
        }

/*  #response-display {
            margin-top: 20px;
            padding: 15px;
            background: #eee;
            min-height: 100px;
            white-space: pre-wrap;
            border-radius: 5px;
        }*/
		
		/* Your original container */
#response-display {
    margin-top: 20px;
    padding: 15px;
    background: #eee;
    min-height: 100px;
    white-space: pre-wrap;
    border-radius: 5px;
    font-family: sans-serif; /* Clean font for regular text */
	
	
	max-height: 300px;         /* Adjust maximum height as needed */
    overflow-y: auto;          /* Show vertical scrollbar only when content overflows */
    overflow-x: auto;          /* Add horizontal scrolling if JSON/lines are long */
    word-break: break-word;    /* Prevent text/strings from breaking layout */
    
    /* Optional visual styles for better readability */
    padding: 12px;
    border: 1px solid #ccc;
    border-radius: 4px;
	
}

/* New styles for the code block container */
#response-display pre {
    background: #272822;       /* Dark background for code contrast */
    color: #f8f8f2;            /* Light text color */
    padding: 12px;
    margin: 10px 0;
    border-radius: 4px;
    overflow-x: auto;          /* Adds horizontal scrollbar if code is too long */
}

/* New styles for the actual code text */
#response-display pre code {
    font-family: 'Courier New', Courier, monospace; /* Monospace font */
    font-size: 14px;
    white-space: pre;          /* Keeps code indentation exactly as written */
}

.error {
            color: red;
        }
    </style>
</head>

<body>

<h2>AI Chatbot</h2>

<input   type="text"      id="chatInput"      value="hi"      placeholder="Enter your message"   >
	    <button id="sendBtn">Send Message ?</button>
  
	 
	 <br/>
	 <h2>AI RAG Chatbot</h2>
     <input   type="text"      id="chatInputRAG"      value="My name is "      placeholder="Enter your RAG Question?"   >
	
    <button id="sendStrimRAG">Send RAG ?</button>
  
  
  
  
    <h3>AI ChatBot & RAG Response:</h3>

<pre id="response-display">Waiting...</pre>

</div>

// Check jQuery
    console.log("jQuery version:", $.fn.jquery);

$('#sendBtn').on('click', function () {

// Get value from input
        var userInput = $('#chatInput').val().trim();

// Validate input
        if (!userInput) {
            $('#response-display').text("Please enter a message.");
            return;
        }

// API URL
        var targetUrl =
            "http://localhost:8082/chat/Message?q="+ encodeURIComponent(userInput);

console.log("Calling API:", targetUrl);

// Show loading
        $('#response-display').text("Sending To LLM ...");

// POST request
        $.post(targetUrl).done(function (entityResponse) {

// console.log("API Response:", entityResponse);

// $('#response-display').text(JSON.stringify(entityResponse, null, 2));
			    $('#response-display').text(entityResponse);

})

.fail(function (xhr, status, error) {

console.error("Request failed:", status, error);
                console.error("HTTP Status:", xhr.status);
                console.error("Response:", xhr.responseText);

$('#response-display')
                    .addClass("error")
                    .text(
                        "Request failed" +
                        "HTTP Status: " + xhr.status + "\n" +
                        "Error: " + error
                    );
            });
    });
	 // Allow Enter key to send
    $('#chatInput').on('keypress', function (event) {

if (event.which === 13) {
            $('#sendBtn').click();
        }

});
	
	
	
	
    $('#sendStrim').on('click', function () {

// Get value from input
        var userInput = $('#chatInput').val().trim();

// Validate input
        if (!userInput) {
            $('#response-display')
                .text("Please enter a message.");
            return;
        }

// API URL
        var targetUrl =
            "http://localhost:8082/chat/Message/stream?q="
            + encodeURIComponent(userInput);

// console.log("Calling API:", targetUrl);

// Show loading
        $('#response-display').text("Sending...");

// POST request
        $.post(targetUrl).done(function (entityResponse) {

// console.log("API Response:", entityResponse);

$('#response-display').text(
                    JSON.stringify(entityResponse, null, 2)
                );

})

.fail(function (xhr, status, error) {

console.error("Request failed:", status, error);
                console.error("HTTP Status:", xhr.status);
                console.error("Response:", xhr.responseText);

$('#response-display')
                    .addClass("error")
                    .text(
                        "Request failed" +
                        "HTTP Status: " + xhr.status + "\n" +
                        "Error: " + error
                    );
            });
    });

// Allow Enter key to send
    $('#chatInput').on('keypress', function (event) {

if (event.which === 13) {
            $('#sendStrim').click();
        }

});	
	/*RAg Coltrolling*/
$('#sendStrimRAG').on('click', function () {

// Get value from input
    var userInputRGA = $('#chatInputRAG').val().trim();
    // Validate input
    if (!userInputRGA) {
        $('#response-display').text("Please enter RAG a message.");
        return;
    }
    // API URL (removed query string)
    var targetUrl = "http://localhost:8082/rag";
	    // Show loading
    $('#response-display').text("Sending to RAG...");
	
	var settings = {
  "url": targetUrl,
  "method": "POST",
  "timeout": 0,
  "headers": {
    "Content-Type": "application/json"
  },
  "data": JSON.stringify({
    "question": userInputRGA
  }),
};

$.ajax(settings)
  .done(function (response) {
   // console.log("Success:", response);
	  $('#response-display').text(response);
  })
  .fail(function (xhr, status, error) {
    console.error("Request Failed!");
    console.error("HTTP Status Code:", xhr.status);
    console.error("Status Text:", status);
    console.error("Error Description:", error);
    console.error("Server Response:", xhr.responseText);
  });

});

</script>

</body>
</html>

Output:

How to create an AI chatbot using Spring AI and a Web HTML page.

AI-CHATBOT , Spring Boot , SpringAI 1 comment :

Spring AI is an open-source application framework designed to easily integrate Artificial Intelligence (AI) features into Spring Boot applications. It functions as a standard middleware layer; rather than training or building AI models from scratch, it enables developers to seamlessly connect their enterprise code with existing AI models. Below, we outline the step-by-step process for configuring and developing a chatbot.
First, you need to select an LLM (Large Language Model) that Spring AI will use to communicate:

Step 1:We will use the standalone Ollama LLM model. To do this, install Ollama on your system (download via https://ollama.com/download/windows) and then download a free model from https://ollama.com/search.
CMD:

1. widows CMD:

irm https://ollama.com/install.ps1 | iex

2. mocOS CMD:

curl -fsSL https://ollama.com/install.sh | sh

3. Linux CMD:

curl -fsSL https://ollama.com/install.sh | sh

Check Ollama Run using URL: http://localhost:11434/
Step 2:
In this step, we configure the Spring Boot AI application using Spring Initializr (https://start.spring.io/); we have previously covered how to perform this configuration. Here, we will explain the coding process step-by-step.

Step 2.1: Check the dependencies in the `pom.xml` file and ensure they match your project setup.

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

</project>

Step 2.2:

We create a REST controller named `ChatClientController.java`. Here, we will see how to implement the LLM packages and classes, and we will also use `@CrossOrigin` to facilitate the design of the web UI.

package a143mk.AI.aiChatclient;
import org.springframework.ai.chat.client.ChatClient;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import reactor.core.publisher.Flux;
import org.springframework.web.bind.annotation.CrossOrigin;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/chat")
@CrossOrigin(origins = "*")
public class ChatClientControler {
    private final ChatClient chatClient;

public ChatClientControler(ChatClient.Builder chatClientBuilder) {
        this.chatClient = chatClientBuilder.build();
    }

@PostMapping("/Message")
    public ResponseEntity<String> chat(@RequestParam(value="q") String message) {
        String response = this.chatClient.prompt(message).call().content();
        return ResponseEntity.ok(response);
    }

@PostMapping(value = "/Message/stream", produces = MediaType.TEXT_EVENT_STREAM_VALUE)
    public Flux<String> streamChat(@RequestParam(value = "q") String message) {
        return this.chatClient.prompt(message)
                .stream()
                .content();
    }
}

Step 2.3: We will configure the LLM model settings within the `application.properties` file.

spring.application.name=aiChatclient

server.port=8081

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

spring.ai.ollama.chat.options.model=codellama:latest

spring.ai.ollama.chat.options.num-predict=256

spring.ai.ollama.chat.options.temperature=0.2

Step 3: Finally, we create the web page (`indexAI_CHAT.html`) and integrate the REST controller with the web UI.

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">

<title>AI ChatBot</title>

<script src="https://code.jquery.com/jquery-3.7.1.min.js"></script>

#chatInput {
            width: 70%;
            padding: 10px;
            font-size: 16px;
        }

#sendBtn {
            padding: 10px 20px;
            font-size: 16px;
            cursor: pointer;
        }
		
		 #sendStrim {
            padding: 10px 20px;
            font-size: 16px;
            cursor: pointer;
        }

.error {
            color: red;
        }
    </style>
</head>

<body>

<h2>AI Chatbot</h2>

<button id="sendBtn">Send Message</button>
    <h3>Response:</h3>

<pre id="response-display">Waiting...</pre>
<em id="chat-container">Power by <a href="https://a143mk.blogspot.com/">a143mk</a></em>
</div>

// Check jQuery
    console.log("jQuery version:", $.fn.jquery);

$('#sendBtn').on('click', function () {

// Get value from input
        var userInput = $('#chatInput').val().trim();

// Validate input
        if (!userInput) {
            $('#response-display').text("Please enter a message.");
            return;
        }

// API URL
        var targetUrl =
            "http://localhost:8081/chat/Message?q="+ encodeURIComponent(userInput);

console.log("Calling API:", targetUrl);

// Show loading
        $('#response-display').text("Sending...");

// POST request
        $.post(targetUrl).done(function (entityResponse) {

// console.log("API Response:", entityResponse);

$('#response-display').text(entityResponse);

})

.fail(function (xhr, status, error) {

console.error("Request failed:", status, error);
                console.error("HTTP Status:", xhr.status);
                console.error("Response:", xhr.responseText);

if (event.which === 13) {
            $('#sendBtn').click();
        }

});

</script>

</body>
</html>

Output:

Step-by-step development video:

How to receive a JWT-based access token from the client, verify the token, and push data using the client's URL?

java 8 , JSON , JWT Token , OAuth2 Security , Rest API 1 comment :

JWT OAuth2 Integration and JSON Payload Handling in Java: JWT (JSON Web Token) is a token format used in OAuth2.

A JWT is:

Stateless
Digitally signed
Self-contained

Integrating with client APIs using APIs and JSON-based payloads involves an end-to-end process that includes making API calls with JSON payloads and pushing master/other data to REST API endpoints.

Step 1: Obtain the authentication details/Requirements from the client as shown in the example below.

############_MK_TOKEN_CLIENT_SECRET_####################

TOKEN_URL=https://a143mk-uat.client.com/api/v1/client/authentication/generate_token CLIENT_ID=AA143Mkbolgs

CLIENT_SECRET=testa143mk

####Example of Configure URL #############

CUST_URL=https://a143mk-uat.client.com/api/master/push_customer

CUST_USER_PASS_AUTH=useradmin:password //if it is required or not

Step 2: Making an API call with an Json payload and pushing master data to the location.

A REST API Controller is responsible for handling HTTP requests (such as GET, POST, PUT, DELETE) from clients and routing them to the appropriate service methods. It acts as the entry point for external clients to interact with the backend application.
Purpose: The main role of the controller is to manage incoming HTTP requests, map them to specific methods (often called endpoints), and return appropriate responses to the client.
Responsibilities: Handle HTTP requests (e.g., GET, POST, PUT, DELETE). Map the incoming requests to service methods. Return HTTP responses, often in JSON or Json format. Perform basic request validation or authentication. Act as the "interface" between the client and the service layer. In a Spring Boot application, for example, the controller is typically annotated with @RestController and the request mappings are handled using annotations like @GetMapping, @PostMapping, etc.

Example "ClientApiController.java" of a REST Controller in Spring Boot with handlined Json Payload :

package a143mk.a143mkCustMasterMaster.SystemClientcontroller;
import java.net.URL;
import java.text.Format;
import java.text.SimpleDateFormat;
import java.util.Date;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;
import a143mk.a143mkCustMasterMaster.FromBean.APIResponseEntityBean;
import a143mk.a143mkCustMasterMaster.SystemClientServices.CustMastSysteCliService;
import org.apache.log4j.PropertyConfigurator;

@RestController
@RequestMapping("/CUST_T_API")
public class ClientApiController {
	private static final Logger logger = LoggerFactory.getLogger(CustomerMasterCoSysteCli.class);
	 @Autowired
	 private CustMastSysteCliService custMasteServ;
	
	 @RequestMapping(method = RequestMethod.POST, value="/cust") 
	 public ResponseEntity<APIResponseEntityBean> getCustMasterSysteCli() {
		 APIResponseEntityBean responseEntityBean = null;
		 Object retunResult=null;
		 try {
		 /*Log4je Config*/
	        ClassLoader loader = Thread.currentThread().getContextClassLoader();
			 URL url = loader.getResource("application.properties");
			 PropertyConfigurator.configure(url);
		     /* End Log4je Config*/
			 logger.info("Push A143mk Customer TO SysteCli  Method is getCustMasterSysteCli()"); 
			 retunResult=custMasteServ.CustMastSystemNameService();
		     responseEntityBean = new APIResponseEntityBean("SUCCESS", "Please check Log file For Success or not!", dtFormater.format(new Date()), retunResult);
		     
		 } catch (Exception e) {
		 // TODO: handle exception
		 responseEntityBean = new APIResponseEntityBean("ERROR", e.getMessage(),dtFormater.format(new Date()), retunResult);
		 logger.error(e.getMessage());
		 //e.printStackTrace();
		 }
		 return new ResponseEntity<APIResponseEntityBean>(responseEntityBean, HttpStatus.OK);

}	
}

The Service class is a part of the business logic layer of your application. It contains methods that implement the core functionality of the application (e.g., creating, reading, updating, deleting data). The service class is called by the controller to perform operations that are not directly related to the web request itself.

Purpose: The service layer acts as a mediator between the controller and the data layer (such as a repository or database). It focuses on business logic and operations.
Responsibilities: Perform the core business logic of the application. Interact with the database (via repositories or DAOs). Provide methods for the controller to use (i.e., encapsulate business operations). Handle any necessary validation or transformation before sending data back to the controller. In a Spring Boot application, service classes are typically annotated with @Service, and they are injected into the controller using @Autowired (or constructor injection).

Example "CustMastSystemNameService.java" of a Service Class in Spring Boot:

Method Internal Working ->geta143mkCustMasterFOrSYS() ->pusha143mkCustToSystemNameSystem().

package a143mk.a143mkCustMaster.SYSServices;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import a143mk.a143mkCustMaster.Entity.a143mkCustAddressMaster;
import a143mk.a143mkCustMaster.Entity.a143mkCustMaster;
import a143mk.a143mkCustMaster.Repository.a143mkCustAddressMasterRepository;
import a143mk.a143mkCustMaster.Repository.a143mkCustMasterRepository;
import a143mk.a143mkCustMaster.SYSConfig.SSLStopGetToken;
import org.springframework.http.*;
import org.springframework.web.client.RestTemplate;

@SuppressWarnings("serial")
@Service
public class CustMastSystemNameService implements Serializable {
	private static final Logger logger = LoggerFactory.getLogger(CustMastSystemNameService.class);
	@Autowired
	private a143mkCustMasterRepository customerMastRepositM1Table;
	@Autowired
	private a143mkCustAddressMasterRepository custAdderssMastRepoM2Table;
	
	public List<Map<String, Object>> geta143mkCustMasterFOrSYS() {
	    List<Map<String, Object>> pusha143mkCustSystemNameList = new ArrayList<>();
	    try {
	        logger.info("Start a143mkCust_push");
	        List<a143mkCustMaster> getMasterV = customerMastRepositM1Table.mdmCustDetailsSystemName();        
	        if (getMasterV != null) {
	            for (a143mkCustMaster getCust : getMasterV) {
	                // Use a Map instead of JSONObject
	                Map<String, Object> customerMap = new HashMap<>();
	                customerMap.put("name", getCust.geta143mkCustName());
	                customerMap.put("type", "Business");
	                customerMap.put("sub_type", "a143mkCust");
	                customerMap.put("phone", Optional.ofNullable(getCust.getPhoneNo()).map(String::trim).filter(p->p.length()>10).orElse("no"));
	                customerMap.put("email", Optional.ofNullable(getCust.getEmailId()).orElse("no"));
	                customerMap.put("code", Optional.ofNullable(getCust.getWhDepotStoreNo()).map(String::trim).filter(p->p.length()>5).orElse("no"));
	                customerMap.put("user_id", "AA143Mkbolgs"); //Pass the client_id value or pass the value according to your client.
	                pusha143mkCustSystemNameList.add(customerMap);
	                // Address logic
	                List<a143mkCustAddressMaster> cutoAddressSystemName = 
	                        custAdderssMastRepoM2Table.geta143mkCustAddressTableList(getCust.getLegacyCustNo());
	                
	                List<Map<String, Object>> pushAddressList = new ArrayList<>();
	                if (cutoAddressSystemName != null) {
	                    for (a143mkCustAddressMaster custAdde : cutoAddressSystemName) {
	                        Map<String, Object> address = new HashMap<>();
	                        address.put("address_1", custAdde.getAddress1());
				            address.put("address_2", Optional.ofNullable(custAdde.getAddress2()).orElse(""));
				            address.put("address_3", Optional.ofNullable(custAdde.getAddress3()).orElse(""));
				            address.put("city", Optional.ofNullable(custAdde.getCityName()).orElse("no"));
				            address.put("state", Optional.ofNullable(custAdde.getStateCode()).orElse(""));
				            address.put("pincode", Optional.ofNullable(custAdde.getPincode()).orElse("") );
				            address.put("state_code", custAdde.getStateCode());
				          
	                        pushAddressList.add(address);
	                    }
	                } 
	                // Add the address list to the customer map
	                customerMap.put("address_details", pushAddressList);
	              
	            }
	            ResponseEntity<String>  returnto=pusha143mkCustToSystemNameSystem(pusha143mkCustSystemNameList);
	            if(returnto!=null) {
	            	 logger.info("Success:" +returnto);
	            }else {
	            	logger.error("Error to Push customer to SystemName", returnto);
	            }
	        }
	        
	    } catch (Exception e) {
	        logger.error("Error in geta143mkCustMasterFOrSYS", e);
	    }
	    
	    return pusha143mkCustSystemNameList;
	}
	
	private  ResponseEntity<String>  pusha143mkCustToSystemNameSystem(List<Map<String, Object>> pusha143mkCustSystemNameList) {
	    RestTemplate restTemplate = new RestTemplate();

try {
	        // 1. Get token
	        String getTokenTms = new SSLStopGetToken().GetToken();
	        if (getTokenTms == null) {
	            throw new RuntimeException("Failed to get SystemName token");
	        }
             // 2. Set headers
	        HttpHeaders headers = new HttpHeaders();
	        headers.set("Authorization", "Bearer " + getTokenTms);
	   
	        // 3. Build the request entity
	        HttpEntity<List<Map<String, Object>>> request = new HttpEntity<>(pusha143mkCustSystemNameList, headers);

// 4. This is the Client Master API URL through which client master data can be sent. This is a test URL; you can modify it according to your client's requirements.
	        String url = "https://a143mk-uat.client.com/api/master/push_customer";
	        ResponseEntity<String> response = restTemplate.postForEntity(url, request, String.class);
	        // 5. Get response body
	       /* responseObject = response.getBody();
	        System.out.println("Response: " + responseObject);
	        logger.info("statuse for  in geta143mkCustMasterFOrSYS: ", responseObject);*/
	        return response;
	    } catch (Exception e) {
	        logger.error("Error pushing customer to SystemName", e);
	        return null;
	    }  
	}
}

Step 3: The authorization server issues an access token in JWT format The client sends this token in requests using Authorization: Bearer<Token>
The API validates the JWT by checking its signature, expiration, issuer, and audience See the example below for how to obtain an access token for the client: Use this for server-to-server authentication.

Method Internal Working ->geta143mkCustMasterFOrSYS() ->pusha143mkCustToSystemNameSystem().

package a143mk.MdmCustomerMaster.SYSConfig;
import javax.net.ssl.*;
import java.io.*;
import java.net.HttpURLConnection;
import java.net.URL;
import java.security.cert.X509Certificate;
import org.json.JSONObject;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
public class SSLStopGetToken {
	public String GetToken() {
		try {
            disableSSL(); 
			// Only disable the SSL certificate if it is absolutely necessary 
		   //when using this method; otherwise, do not.
		   
            String apiUrl = "https://a143mk-uat.client.com/api/v1/client/authentication/generate_token";
            URL url = new URL(apiUrl);
            HttpURLConnection conn = (HttpURLConnection) url.openConnection();
            conn.setRequestMethod("POST");
            conn.setRequestProperty("Content-Type", "application/json");
            conn.setRequestProperty("Accept", "application/json");
            conn.setDoOutput(true);
            String jsonInput = "{"
                    + "\"client_id\":\"AA143Mkbolgs\","
                    + "\"client_secret\":\"testa143mk\""
                    + "}";
	//The client_id and client_secret values are examples
   // please ask the client for these as they are confidential 
  //information and should be changed.
            try (OutputStream os = conn.getOutputStream()) {
                os.write(jsonInput.getBytes("UTF-8"));
            }
            BufferedReader br;
            if (conn.getResponseCode() >= 200 && conn.getResponseCode() < 300) {
                br = new BufferedReader(new InputStreamReader(conn.getInputStream()));
            } else {
                br = new BufferedReader(new InputStreamReader(conn.getErrorStream()));
            }
			
            StringBuilder response = new StringBuilder();
            String line;
            while ((line = br.readLine()) != null) {
                response.append(line);
            }
            ObjectMapper mapper = new ObjectMapper();
            JsonNode jsonNode = mapper.readTree(response.toString());
            System.out.println(jsonNode.get("access_token").asText());
            conn.disconnect();
            return jsonNode.get("access_token").asText();
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
		}
	    
		// SSL bypass (TESTING ONLY)
	    private static void disableSSL() throws Exception {
	        TrustManager[] trustAll = new TrustManager[]{
	            new X509TrustManager() {
	                public X509Certificate[] getAcceptedIssuers() { return null; }
	                public void checkClientTrusted(X509Certificate[] c, String a) {}
	                public void checkServerTrusted(X509Certificate[] c, String a) {}
	            }
	        };
	        SSLContext sc = SSLContext.getInstance("TLS");
	        sc.init(null, trustAll, new java.security.SecureRandom());
	        HttpsURLConnection.setDefaultSSLSocketFactory(sc.getSocketFactory());
	        HttpsURLConnection.setDefaultHostnameVerifier((h, s) -> true);
	    }
}

JWT-based access tokens are secure, stateless, and scalable, making them ideal for modern authentication and authorization systems.

API Integration and XML payload Handling

java , java 8 , Rest API , XML payload No comments :

API integration and XML payload handling in Java using HttpURLConnection and the Apache HttpClient library. To integrate with a client API using an API and XML-based payload, the entire process includes:

ClientURLConfig.properties: Used to store client credential details Making an API call with an JSON/XML payload and pushing data communication.
Data Communication from the two Client API using the JSON/XML payload API.

Step 1: ClientURLConfig.properties

####Example of Configure URL #############

CUST_URL=https://a143mk.com:443/a143mk1_test/MK/api/init_stage_interface/ CUST_USER_PASS_AUTH=useradmin:password

Step 2: Making an API call with an XML payload and pushing master data to the location.

A REST API Controller is responsible for handling HTTP requests (such as GET, POST, PUT, DELETE) from clients and routing them to the appropriate service methods. It acts as the entry point for external clients to interact with the backend application.
Purpose: The main role of the controller is to manage incoming HTTP requests, map them to specific methods (often called endpoints), and return appropriate responses to the client.
Responsibilities: Handle HTTP requests (e.g., GET, POST, PUT, DELETE). Map the incoming requests to service methods. Return HTTP responses, often in JSON or XML format. Perform basic request validation or authentication. Act as the "interface" between the client and the service layer. In a Spring Boot application, for example, the controller is typically annotated with @RestController and the request mappings are handled using annotations like @GetMapping, @PostMapping, etc.

Example of a REST Controller in Spring Boot with handlined XML Payload :

@RestController
@RequestMapping("/api/users")
public class UserController {
private static final Logger logger = LogManager.getLogger(UserController.class);
    @Autowired
    private UserService customerServiceImpl;

// controller class mathod 
  @PostMapping(value = "/pushCustomerToClient")
	    @ResponseBody
	    public ResponseEntity<APIResponseEntityBean> pushCustomerToClient() throws Exception {
	    	synchronized (this) {		
	    		 logger.info(" Running Block !");
	      APIResponseEntityBean responseEntityBean = null;
	      Object retunResult = null;
	      try {
	    	      retunResult = customerServiceImpl.getAllCustomerStores();;
	              responseEntityBean = new APIResponseEntityBean("SUCCESS", "Response Generated Successfully!", dtFormater.format(new Date()), retunResult);
	      } catch (Exception e) {
	           responseEntityBean = new APIResponseEntityBean("ERROR", e.getMessage(), dtFormater.format(new Date()), retunResult);
	           logger.error("Error In Method pushCustomerToClient of MasterAPIController.class :"		+ PrintStackTraceLogger.getStackTrace(e));
	          e.printStackTrace();
	      }
	      return new ResponseEntity<APIResponseEntityBean>(responseEntityBean, HttpStatus.OK);
	    }
	    }
}

Purpose: The service layer acts as a mediator between the controller and the data layer (such as a repository or database). It focuses on business logic and operations.
Responsibilities: Perform the core business logic of the application. Interact with the database (via repositories or DAOs). Provide methods for the controller to use (i.e., encapsulate business operations). Handle any necessary validation or transformation before sending data back to the controller. In a Spring Boot application, service classes are typically annotated with @Service, and they are injected into the controller using @Autowired (or constructor injection).

Example of a Service Class in Spring Boot:

Method Internal Working ->getAllCustomerStores()->buildCustomerXmlPayload()->pushCustomerXmlToa143mkClient().

@Service
public class UserService {

@Autowired
    private UserRepository customerRepo;
//Create controller request services and have the controller send back an XML payload
     @Override
	 @Transactional(readOnly = true, propagation = Propagation.SUPPORTS)
	public String getAllCustomerStores() throws Exception {
		List<MastBean> customerList = customerRepo.getCustomerDataFromDB(); //get Date for DataBase
		if(customerList!=null) {
			String xmlPayload = buildCustomerXmlPayload(customerList); //Get Master Details form Database
	        return pushCustomerXmlToa143mkClient(xmlPayload);
		}
	}

public String buildCustomerXmlPayload(List<MastBean> list) throws Exception{
		StringBuilder sb = new StringBuilder();
		sb.append("<?xml version=\"1.0\" encoding=\"utf-8\"?>\n");
		sb.append("<AmkfData>\n<Header>\n");
		sb.append("<DocumentVersion>1V</DocumentVersion>\n");
		sb.append("<OriginSystem>APPv3</OriginSystem>\n");
		sb.append("<ClientEnvCode>a143mk1</ClientEnvCode>\n");
		sb.append("<ParentCompanyCode>a143mk</ParentCompanyCode>\n");
		sb.append("<Entity>store</Entity>\n");
		sb.append("<TimeStamp>").append(java.time.LocalDateTime.now()).append("</TimeStamp>\n");
		sb.append("<MessageId>").append("str").append(System.currentTimeMillis()).append("</MessageId>\n");
		sb.append("</Header>\n<ListOfStores>\n");

for (MastBean customer : list) {
			sb.append("<store>\n");
			sb.append("<c_code>").append(nonNull(customer.getConceptCode())).append("</c_code>\n");
			sb.append("<code>").append(nonNull(customer.getCustomerNo()))).append("</code>\n");
			sb.append("<name>").append(nonNull(customer.getCustomerName())).append("</name>\n");
			// Customer address
			// Split as per character limits
			String address1 = substringSafe(customer.getAddress(), 0, 60);
			String locality = substringSafe(customer.getLocality(), 60, 190);
			sb.append("<address_1>").append(address1.replace("&",",")).append("</address_1>\n");
			sb.append("<locality>").append(locality).append("</locality>\n");
			sb.append("<city>").append(nonNull(customer.getCityName())).append("</city>\n");
			sb.append("<state>").append(customer.getStateCode()).append("</state>\n");
			sb.append("<zip>").append(nonNull(customer.getPinCode())).append("</zip>\n");
			sb.append("<country>INDIA</country>\n");
			sb.append("<email>").append(nonNull(customer.getEmailId())).append("</email>\n");
			sb.append("<contact></contact>\n");
			sb.append("<action_code>CREATE</action_code>\n");
			sb.append("<lang>es_IN</lang>\n");
			sb.append("<default_ship_via_code></default_ship_via_code>\n");
			sb.append("<a143mkClient_managed_flg></a143mkClient_managed_flg>\n");
			sb.append("</store>\n");
		}
		sb.append("</ListOfStores>\n</AmkfData>");
		System.out.println("Data payload \n" + sb);
		return sb.toString();
	}
	
	// create push "pushCustomerXmlToa143mkClient" Mathod. 
	public String pushCustomerXmlToa143mkClient(String xmlPayload) throws Exception{
		
		 InputStream input; 
    	 String CUST_URL ="";
    	 String CUST_USER_PASS_AUTH ="";
    	 Properties prop = new Properties();
		try {
			
			input = CustomerServiceImpl.class.getClassLoader().getResourceAsStream("a143mkClientURL.properties");
            prop.load(input);
			CUST_URL=prop.getProperty("CUST_URL");
			CUST_USER_PASS_AUTH=prop.getProperty("CUST_USER_PASS_AUTH");  
			String encodedAuth = Base64.getEncoder().encodeToString(CUST_USER_PASS_AUTH.getBytes(StandardCharsets.UTF_8));
			HttpPost post = new HttpPost(CUST_URL);
			post.setHeader("Authorization", "Basic " + encodedAuth);
			post.setHeader("Content-Type", "application/x-www-form-urlencoded");
			List<NameValuePair> params = new ArrayList<>();
			params.add(new BasicNameValuePair("xml_data", xmlPayload));
			try (CloseableHttpClient client = HttpClients.createDefault()) {
				post.setEntity(new UrlEncodedFormEntity(params, StandardCharsets.UTF_8));
				try (CloseableHttpResponse response = client.execute(post)) {
					System.out.println("API response: " + response.getStatusLine());
					String responseBody = EntityUtils.toString(response.getEntity(), StandardCharsets.UTF_8);
					System.out.println("Response Body: " + responseBody);
					return responseBody;
				}
			} catch (IOException e) {
				logger.error("IOException of pushCustomerXmlToa143mkClient() "+e.toString());
				throw new RuntimeException("Error while sending XML to a143mkClient", e);
			}

} catch (Exception e) {
			logger.error("Exception of pushCustomerXmlToa143mkClient() "+e.toString());
			return null;
		}
	}
	}

To test an API endpoint URL like https://a143mk.com/api/puchCustData/pushCustomerToClient using Postman, refer to the image. This will allow you to verify the API's functionality and inspect the response.

Cross-Origin Resource Sharing

Cross-Origin , java No comments :

CROSS is a system that allows client web applications (such as JavaScript code) loaded on one domain to interact with resources located on a different domain.
Origin: An "Origin" (or source) URL consists of three parts:

Protocol (scheme): Such as http or https.

Domain (host): Such as a143mk.blogspot.com or localhost.

Port (port number): Such as 8080 or 3000.

If any of these three parts are different in a request, it is called a Cross-Origin request.
Example:
If your frontend (endpoints.com) sends a request to a backend API (api.com), it is Cross-Origin and will be intercepted by the browser. CORS is a way to relax this security restriction in a controlled manner, allowing legitimate cross-origin communication.

Configuring CORS globally in Spring Boot is the preferred approach, as it saves you from having to apply the @CrossOrigin annotation to every controller or method and keeps the configuration centralized.
Example: This method defines global CORS settings

addMapping("/**"): This indicates that the CORS mapping will apply to all paths.
allowedOrigins: Defines the client origins that are allowed to access your API.
allowedMethods: The HTTP methods that are allowed.
allowedHeaders: Allows all headers sent by the client.
allowedCredentials: Set this to 'true' if the client is using cookies or HTTP authentication.
maxAge: The time (in seconds) to cache the results of a pre-flight request.

Implementing JWT Token for secure authentication

java 8 , JWT Token 1 comment :

Implementing JWT (JSON Web Token) in Java typically involves creating a secure authentication mechanism for your web applications. Below is a basic guide to implement JWT using Java, Spring MVC, and jjwt (a popular Java JWT library).

WorkFlow:

The lifecycle of a JSON Web Token (JWT) typically involves several stages, from creation to expiration and validation. JWTs are widely used for securely transmitting information between parties in the form of a signed and optionally encrypted token. Here’s an overview of the typical lifecycle: Token Creation
Authentication: When a user logs in, they typically provide credentials (e.g., username and password).
Server Validation: The server validates these credentials (e.g., checks the database for the user’s password).
JWT Creation: If the credentials are correct, the server generates a JWT. The token contains:
Header: Describes the signing algorithm (e.g., HS256, RS256) and token type (JWT).
Payload: Contains the claims. Claims are pieces of information (e.g., user ID, expiration time) that are encoded in the token.
Signature: The header and payload are signed with a secret key (HMAC) or a private key (RSA or ECDSA) to ensure integrity.

Download Jar file: jjwt-api-0.10.5.jar

To create a A143mk.JWTAPIConfig, we first need to define a package that will be handled in the configuration.
Create classes name in the A143mk.JWTAPIConfig package.

JwtRequestFilter
JwtUtil
SecurityConfig
AuthRequest

1. JwtRequestFilter

package a143mk.JWTAPIConfig;

import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;
import org.springframework.web.filter.OncePerRequestFilter;

import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.annotation.WebFilter;
import javax.servlet.http.HttpServletRequest;
import java.io.IOException;

@SuppressWarnings("unused")
@WebFilter(urlPatterns = "/api/*")
public class JwtRequestFilter extends OncePerRequestFilter {

private JwtUtil jwtUtil = new JwtUtil();

@Override
    protected void doFilterInternal(HttpServletRequest request, javax.servlet.http.HttpServletResponse response, FilterChain filterChain)
            throws ServletException, IOException {
        final String token = request.getHeader("Authorization");

if (token != null && token.startsWith("Bearer ")) {
            String username = jwtUtil.extractUsername(token.substring(7));
            if (username != null && jwtUtil.validateToken(token, username)) {
                // Set user authentication here
            }
        }
        filterChain.doFilter(request, response);
    }
}

2.JwtUtil

package a143mk.JWTAPIConfig;
import io.jsonwebtoken.Claims;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
import io.jsonwebtoken.security.Keys;
import java.security.Key;
import java.util.Date;
public class JwtUtil {
    private String secretKey = "a143mkJWT3API"; // use a more secure key in production!
	// private Key secretKey = Keys.secretKeyFor(SignatureAlgorithm.HS256);
    // Generate token
    public String generateToken(String username) {
        return Jwts.builder()
                .setSubject(username)
                .setIssuedAt(new Date())
                .setExpiration(new Date(System.currentTimeMillis() + 1000 * 60 * 60)) // Token expires in 1 hour
                .signWith(SignatureAlgorithm.HS256, secretKey)
                .compact();
    }
    // Extract username from token
    public String extractUsername(String token) {
        return extractClaims(token).getSubject();
    }
    // Extract claims (payload)
    private Claims extractClaims(String token) {
        return Jwts.parser()
                .setSigningKey(secretKey)
                .parseClaimsJws(token)
                .getBody();
    }
    // Validate token
    public boolean validateToken(String token, String username) {
        return (username.equals(extractUsername(token)) && !isTokenExpired(token));
    }
    // Check if token is expired
    private boolean isTokenExpired(String token) {
        return extractClaims(token).getExpiration().before(new Date());
    }
}

3. SecurityConfig
4. AuthRequest/PayloderBeanClass
Create a Controller class create a simple controller name is AuthController an endpoint is accessed.

package a143mk.JWTAPIController;

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.directwebremoting.export.Data;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;
import a143mk.JWTAPIConfig.AuthRequest;
import a143mk.JWTAPIConfig.JwtUtil;
import a143mk.service.InterTransferOutWardService;

@RestController
public class AuthController {
	private static final Logger logger = LogManager.getLogger(AuthController.class);
    private JwtUtil jwtUtil = new JwtUtil();
    @Autowired
	InterTransferOutWardService interOutward;
    @PostMapping("/api/authenticate")
     public String createToken(@RequestBody AuthRequest authRequest) {
    	String token=jwtUtil.generateToken(authRequest.getUsername());
    	logger.info("DATE_Time:"+new Data()+" Token Ganrate: "+token );
    	interOutward.tokenSave(token);
    	return jwtUtil.generateToken(authRequest.getUsername());
    }
}

Steps to Test JWT Token in Postman:
Obtain the JWT Token: First, you need to obtain the JWT token from your authentication endpoint. Typically, this is done by making a POST request to your login endpoint with the correct user credentials (username, password, etc.).

Example (login request):

Method: POST
URL: http://localhost:8080/A143mk/api/authenticate
Body (JSON):

{

"username": "A143mk@Manoj"

}

Result :

eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiJCQVRBQGRtc0Vjb20iLCJpYXQiOjE3NDc5MDc5MzYsImV4cCI6MTc0NzkxMTUzNn0.1eEK4gwwR3mr2bqcIoYYjxwpcTzUKOCtBMH-GBo6X_4

LDAP (Lightweight Directory Access Protocol) authentication in a Spring Boot.

LDAP , Spring Boot 3 comments :

LDAP
(Lightweight Directory Access Protocol) authentication in a Spring Boot application typically involves using Spring Security to configure LDAP authentication properly, ensuring that sensitive data like passwords is protected and communication with the LDAP server is secure.
Here’s a basic guide to securing LDAP authentication in a Spring Boot application:
Add Dependencies:In your pom.xml, add the following dependencies for Spring Security and LDAP:

LDAP Configuration: In your application.properties or application.yml, configure the LDAP server details:

# application.properties

spring.ldap.urls=ldap://localhost:389

spring.ldap.base=dc=example,dc=com

spring.ldap.username=uid=admin,ou=system

spring.ldap.password=password

spring.ldap.embedded.enabled=false

Spring Security Configuration :You can configure Spring Security to authenticate using LDAP by defining a SecurityConfig class.
Here is an example:

import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.ldap.authentication.LdapAuthenticationProvider;
import org.springframework.security.ldap.authentication.LdapAuthoritiesPopulator;
import org.springframework.security.ldap.authentication.LdapAuthenticationProviderConfigurer;
import org.springframework.security.ldap.core.LdapTemplate;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;
@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .authorizeRequests()
            .antMatchers("/login", "/error").permitAll()  // Allowing login and error pages
            .anyRequest().authenticated()  // Other requests require authentication
            .and()
            .formLogin()  // Enable form login
            .loginPage("/login")
            .permitAll()
            .and()
            .logout().permitAll();  // Allow logout
    }
    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        // LDAP Authentication configuration
        auth
            .ldapAuthentication()
            .userDnPatterns("uid={0},ou=users")
            .groupSearchBase("ou=groups")
            .contextSource()
            .url("ldap://localhost:389/dc=example,dc=com")
            .managerDn("cn=admin,dc=example,dc=com")
            .managerPassword("adminpassword")
            .and()
            .passwordCompare()
            .passwordEncoder(new org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder())
            .passwordAttribute("userPassword");
    }
}

Enable Secure LDAP Connections:
If you are using LDAP over TLS/SSL (LDAPS), it’s critical to ensure that your LDAP communication is secured. Change the URL to:
spring.ldap.urls=ldaps://localhost:636
Ensure that your LDAP server supports LDAPS and that proper certificates are installed on the server. If you are using SSL, you can also import the certificate into your Java Keystore (JKS).
Secure Password Handling:In the above configuration, passwords are compared using passwordCompare(). It's recommended to use a hashed password encoder like BCryptPasswordEncoder, which is configured in the example to secure the passwords.
Customizing the Login Page:You can customize your login page if needed by creating a controller for the login and error handling views:

Role Mapping (Optional):If you want to map roles from LDAP groups or other attributes, you can use LdapAuthoritiesPopulator to fetch roles.

This will ensure the roles are properly populated from LDAP.
Test the Application:Start your Spring Boot application, and it should authenticate users against the LDAP server. Make sure you test with the proper credentials to confirm everything is working securely.

Summary of Key Points:

LDAP Configuration: Use spring.ldap properties to configure the LDAP server details.
Spring Security: Configure Spring Security to handle LDAP authentication with ldapAuthentication().
SSL/TLS: Ensure the LDAP communication is encrypted (use ldaps://).
Password Encoding: Use a secure password encoder like BCryptPasswordEncoder.
Role Mapping: Map roles from LDAP as needed using LdapAuthoritiesPopulator. This setup will help you integrate LDAP securely in your Spring Boot application.

Subscribe to: Posts ( Atom )

How to create an AI and RAG chatbot using Spring AI and a Web HTML page.

How to create an AI chatbot using Spring AI and a Web HTML page.

How to receive a JWT-based access token from the client, verify the token, and push data using the client's URL?

API Integration and XML payload Handling

Cross-Origin Resource Sharing

Implementing JWT Token for secure authentication

LDAP (Lightweight Directory Access Protocol) authentication in a Spring Boot.

Pageviews

LABELS

OUR TECH-PROJECTS

Development Accessories

DOWNLOAD ANY ONLINE VIDEOS

POPULAR POSTS