software Programming

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

noreply@blogger.com (A143MK PROGRAMMING) — Sun, 27 Sep 2026 09:12:12 +0000

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.

noreply@blogger.com (A143MK PROGRAMMING) — Fri, 18 Sep 2026 05:42:07 +0000

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?

noreply@blogger.com (A143MK PROGRAMMING) — Sun, 11 Jan 2026 16:35:00 +0000

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

noreply@blogger.com (A143MK PROGRAMMING) — Sat, 13 Dec 2025 13:58:00 +0000

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

noreply@blogger.com (A143MK PROGRAMMING) — Tue, 25 Nov 2025 16:54:01 +0000

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

noreply@blogger.com (A143MK PROGRAMMING) — Sat, 24 May 2025 10:46:00 +0000

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.

noreply@blogger.com (A143MK PROGRAMMING) — Thu, 27 Mar 2025 11:27:00 +0000

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.

Configuration SSL Certificate in Tomcat server

noreply@blogger.com (A143MK PROGRAMMING) — Fri, 07 Mar 2025 12:07:00 +0000

To, configure SSL in the server.xml file for Apache Tomcat, follow these steps.
Steps:

1. Generate or Obtain an SSL Certificate with Other Files.

Required Files:

2. Locate the server.xml file.
The server.xml file is typically located in the conf directory inside your Tomcat installation.
Path example:/path/to/tomcat/conf/server.xml

3. Edit server.xml
Open the server.xml file in a text editor and find the section for the HTTPS connector. By default, it may be commented out. You need to configure this section to enable SSL. Here’s an example of how to configure SSL for Tomcat:

4. Configure Redirect from HTTP to HTTPS (Optional) To force all HTTP traffic to be redirected to HTTPS, you can add a redirect connector for HTTP (typically port 80). For example, below the HTTP connector section in the server.xml file:

This will redirect traffic from HTTP (port 8080) to HTTPS (port 8443).
5. Restart Tomcat After making these changes, restart your Tomcat server for the changes to take effect. ..../bin/shutdown.sh
..../bin/startup.sh
6. Verify SSL Configuration
Open a browser and navigate to https://

:8443.
Check for a secure connection (padlock symbol) in the browser's address bar.

Additional Notes:

You can use port 443 (standard HTTPS port) instead of 8443, but you may need root privileges to bind to port 443, or use a reverse proxy to map it.
If you're running Tomcat behind a reverse proxy (like Apache HTTPD), you may need to adjust the connector settings accordingly. Let me know if you need further clarification or help!

Introduction of Angular and AngularJS

noreply@blogger.com (A143MK PROGRAMMING) — Sat, 04 Jan 2025 09:24:00 +0000

Here’s a list of common Angular and AngularJS along with detailed examples to help you prepare.
Angular: Angular is a platform and framework for building single-page client applications using HTML, CSS, and JavaScript/TypeScript. It is a complete rewrite of AngularJS, developed by Google. Angular uses TypeScript, which is a superset of JavaScript, offering strong typing, interfaces, and decorators.

Key features of Angular:
Two-way data binding
Directives for extending HTML capabilities
Dependency injection
Routing and navigation
Components-based architecture

Difference between AngularJS and Angular:
AngularJS is the original version of Angular, and Angular (2 and above) is a complete rewrite.
Key differences:
Architecture: Angular uses a component-based architecture, whereas AngularJS uses a directive-based architecture.
Language: Angular uses TypeScript, while AngularJS uses JavaScript.
Performance: Angular has better performance because of the use of a new change detection mechanism (in Angular 2+).
Dependency Injection (DI): Angular's DI is more powerful and more flexible than AngularJS.
Angular Components:
In Angular, a component is a building block of the application. It controls a portion of the user interface (UI), with each component consisting of:

HTML template (view)
CSS styles (view styles)
TypeScript class (logic and data)

Example:

In this example, HelloComponent is an Angular component with a template displaying a message.
Data binding in Angular? Explain the types of data binding. Data binding in Angular is the mechanism to synchronize the data between the component and the view. Angular supports several types of data binding:
Interpolation: Binding data from the component to the view.

Property Binding: Bind an element property to a component property.

Event Binding: Bind an event (e.g., click) to a method in the component.

<button (click)="onClick()">Click Me</button>

Two-Way Data Binding: Combines property and event binding.

Dependency Injection (DI) in Angular?
Dependency Injection (DI) is a design pattern used in Angular to achieve Inversion of Control (IoC). It allows services or objects to be injected into components or other services rather than being created manually inside the component.
Example:

In this example, the DataService is injected into DataComponent via DI, and its method getData() is used in the component.
Angular Routing:
Angular Routing allows you to define routes and navigate between different views or pages in a single-page application (SPA). The routing module helps handle navigation and deep linking.
Example: Define routes in app-routing.module.ts:
Use the router-outlet in app.component.html:

<router-outlet></router-outlet>

Navigating using the routerLink directive:

<a routerLink="/about">About</a>

Service in Angular:
A service is a class in Angular used to handle logic that can be shared across multiple components. Services are commonly used for business logic, data fetching, and state management. Services are injected into components or other services using Angular’s Dependency Injection system.
Example:

In the component, the service is injected:

Directives in Angular:
Directives are special markers in the DOM that allow Angular to modify the DOM structure. There are three types of directives in Angular:
Component Directives: These are the most common type of directives and include templates and logic (e.g., @Component).
Structural Directives: These modify the structure of the DOM (e.g., *ngIf, *ngFor).
Attribute Directives: These change the appearance or behavior of an element (e.g., ngClass, ngStyle).
Example: *ngIf: Conditionally display an element.

<div *ngIf="isVisible">This content is visible.</div>

Observables in Angular:
Observables are a core part of Angular’s reactive programming. They represent a stream of asynchronous events. Angular uses RxJS (Reactive Extensions for JavaScript) for handling asynchronous operations like HTTP requests, user input, or timer events.
Example:

In this example, the HttpClient service returns an Observable, and subscribe() is used to handle the response asynchronously.
Pipes in Angular:
Pipes are used to transform data in the template before it is displayed. Angular provides several built-in pipes like DatePipe, UpperCasePipe, LowerCasePipe, and CurrencyPipe. You can also create custom pipes.
Example:

In this example, birthday will be transformed into a formatted date using the DatePipe.
You can also create custom pipes:

In the template:

These are some of the key Angular and AngularJS, along with practical examples. Practicing these concepts and writing code will help you to be more prepared for your Development!

How To Use Predicate In Java 8

noreply@blogger.com (A143MK PROGRAMMING) — Thu, 19 Dec 2024 05:18:00 +0000

In Java 8,
The Predicate is a functional interface that represents a single argument function that returns a boolean value. It is widely used in functional programming, especially when working with streams, as it allows you to define conditions that can be tested.
The Predicate Interface: Let’s look at an example of how to use the @FunctionalInterface annotation in a Spring Boot application:

The Predicate interface contains a method called test(T t) that evaluates a condition and returns a boolean. It also contains some useful default methods like:

and(Predicate other): Combines two predicates with a logical AND.
or(Predicate other): Combines two predicates with a logical OR.
negate(): Negates the result of the predicate.

Example 1: Simple Predicate In the following example, a Predicate is used to test whether a number is greater than 10

Example 2: Combining Predicates with and(), or(), and negate() You can combine multiple predicates to create more complex conditions using and(), or(), and negate().

import java.util.function.Predicate;
    public class CombinedPredicateExample {
    public static void main(String[] args) {
        // Predicate to check if a number is greater than 10
        Predicate<Integer> isGreaterThanTen = (n) -> n > 10;

// Predicate to check if a number is Mehuln
        Predicate<Integer> isMehuln = (n) -> n % 2 == 0;

// Combining predicates using 'and()' (number > 10 and Mehuln)
        Predicate<Integer> isGreaterThanTenAndMehuln = isGreaterThanTen.and(isMehuln);

// Combining predicates using 'or()' (number > 10 or Mehuln)
        Predicate<Integer> isGreaterThanTenOrMehuln = isGreaterThanTen.or(isMehuln);

// Negating the 'isGreaterThanTen' predicate
        Predicate<Integer> isNotGreaterThanTen = isGreaterThanTen.negate();

// Test the combined predicates
        System.out.println(isGreaterThanTenAndMehuln.test(12));  // output true (12 > 10 and 12 is Mehuln)
        System.out.println(isGreaterThanTenOrMehuln.test(8));   //output true (8 is Mehuln)
        System.out.println(isNotGreaterThanTen.test(8));      //output true (8 is not greater than 10)
    }
}

Example 3: Using Predicate with Collections and Streams The Predicate interface is often used with the Streams API to filter collections based on certain conditions.

Example 4: Predicate with isEqual Static Method Java 8 introduces a static method isEqual in the Predicate interface, which is used to create a predicate that checks if two objects are equal.

Example 5: Using Predicate with a List of Objects You can use predicates to filter lists of custom objects. Hare's an example where we filter a list of Person objects based on age.

import java.util.Arrays;
import java.util.List;
import java.util.function.Predicate;
import java.util.stream.Collectors;
class Person {
    String name;
    int age;

Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

@Override
    public String toString() {
        return name + " (" + age + ")";
    }
}

public class PersonPredicateExample {
    public static void main(String[] args) {
        List<Person> people = Arrays.asList(
            new Person("John", 25),
            new Person("Manoj", 32),
            new Person("Bob", 17),
            new Person("Mehul", 6)
        );

// Predicate to check if a person is over 18 years old
        Predicate<Person> isAdult = person -> person.age > 18;

// Using the predicate with streams to filter the list
        List<Person> adults = people.stream()
                                    .filter(isAdult)  // Applying the Predicate
                                    .collect(Collectors.toList());

System.out.println(adults); // output Prints: [John (25), Manoj (32), Mehul (6)]
    }
}

Summary of Predicate Methods:

test(T t): Evaluates the predicate on the given argument and returns true or false.

and(Predicate other): Combines this predicate with another one using logical AND.

or(Predicate other): Combines this predicate with another one using logical OR.

negate(): Reverses the result of the predicate (logical NOT).

isEqual(Object targetRef): Creates a predicate that checks if an object is equal to the given target.

* Common Use Cases:

Filtering collections with Stream.filter(). Validating input, such as checking if a string matches a pattern or if a number falls within a range. Using complex conditional logic in combination with other predicates.
Predicates are a powerful tool in functional programming and are heavily used in Java 8's Streams API to make code more readable and expressive.

Spring Framework `@ExceptionHandler`

noreply@blogger.com (A143MK PROGRAMMING) — Wed, 11 Dec 2024 12:30:00 +0000

In Spring Framework, the `@ExceptionHandler` annotation is used to handle exceptions that occur during the execution of a controller method. This allows you to handle specific exceptions in a centralized manner without cluttering your code with `try-catch` blocks. You can define exception handler methods in your controller or in a global exception handler class.

Example of using @ExceptionHandler:

Let’s look at an example of how to use the `@ExceptionHandler` annotation in a Spring Boot application:
Create a custom exception class First, let's define a custom exception that we will handle in the controller.

Create a Controller that throws the exception In this step, we’ll create a simple controller that throws a `ResourceNotFoundException` when an endpoint is accessed.

Handle the exception using `@ExceptionHandler` Now, let’s handle the `ResourceNotFoundException` using the `@ExceptionHandler` annotation in the same controller.

For Explanation :

@RestControllerAdvice: This is a specialized version of @ControllerAdvice that is used for global exception handling in @RestController methods. It allows you to handle exceptions across all controllers.
@ExceptionHandler(ResourceNotFoundException.class): This annotation tells Spring that whenever a `ResourceNotFoundException` is thrown, the `handleResourceNotFoundException` method should handle it.
ResponseEntity: The method returns a ResponseEntity with a custom message and HTTP status code (404 in this case).

Running the Application When you run this Spring Boot application and access the /resource/{id} endpoint with an invalid ID (e.g., `/resource/0` or `/resource/-1`), it will return a response like:
HTTP Status: 404 Not Found Body: Resource with ID 0 not found!
Example Output:

- When accessing `/resource/1`, it will return "Resource found with ID 1".
- When accessing `/resource/0`, it will return a 404 response with the message "Resource with ID 0 not found!".

Advantages of using @ExceptionHandler:
Centralized exception handling. - Cleaner code with no need for `try-catch` blocks in each controller method.

Ability to return custom error responses with HTTP status codes. You can handle multiple exceptions in a similar way by adding more `@ExceptionHandler` methods in the same class, or even define exception handling globally for all controllers using `@ControllerAdvice` instead of `@RestControllerAdvice`.

Handling Exceptions in an API when Integrating with an API Gateway.

noreply@blogger.com (A143MK PROGRAMMING) — Thu, 19 Sep 2024 01:25:00 +0000

Handling exceptions in an API when integrating with an API Gateway is crucial for maintaining robust, secure, and user-friendly services. The API Gateway often acts as a middleman between your clients and your backend services, so it needs to handle errors effectively to ensure that meaningful and actionable responses are provided to clients. Here's a structured approach to handling exceptions from your API to the API Gateway:
Design Consistent Error Responses:
Ensure that your backend APIs provide consistent and meaningful error responses. This helps the API Gateway understand and relay errors appropriately.

Example Error Response Structure:

json

{

"error": {

"code": "RESOURCE_NOT_FOUND",

"message": "The requested resource was not found.",

"details": "Resource ID: 12345"

}

Handle Exceptions in Backend Services: Implement proper exception handling in your backend services. Catch exceptions and convert them into meaningful error responses.

Java Example:

import org.springframework.http.HttpStatus;

import org.springframework.http.ResponseEntity;

import org.springframework.web.bind.annotation.ExceptionHandler;

import org.springframework.web.bind.annotation.RestControllerAdvice;

@RestControllerAdvice

public class GlobalExceptionHandler {

@ExceptionHandler(ResourceNotFoundException.class)

public ResponseEntity<ErrorResponse> handleResourceNotFound(ResourceNotFoundException ex) {

ErrorResponse errorResponse = new ErrorResponse("RESOURCE_NOT_FOUND", ex.getMessage());

return new ResponseEntity<>(errorResponse, HttpStatus.NOT_FOUND);

}

@ExceptionHandler(Exception.class)

public ResponseEntity<ErrorResponse> handleGeneralException(Exception ex) {

ErrorResponse errorResponse = new ErrorResponse("INTERNAL_SERVER_ERROR", "An unexpected error occurred.");

return new ResponseEntity<>(errorResponse, HttpStatus.INTERNAL_SERVER_ERROR);

}

// Define ErrorResponse class

public static class ErrorResponse {

private String code;

private String message;

// Constructor, getters, and setters

}

Configure API Gateway for Error Handling:
API Gateways like AWS API Gateway, Google Cloud Endpoints, or Azure API Management allow you to configure how errors are handled and transformed.

AWS API Gateway Example:

Create Custom Error Responses: Define custom error responses in the API Gateway settings. This includes mapping HTTP status codes from your backend to user-friendly messages or custom error codes.

Set Up Gateway Responses: Configure Gateway Responses to handle specific HTTP status codes (e.g., 500 Internal Server Error) and provide custom error messages or redirection.

Use Integration Responses: Map backend error responses to different HTTP status codes and customize the response format in the API Gateway
Logging and Monitoring:
Implement logging and monitoring to track and analyze errors. This helps in diagnosing issues and improving your API services.

Example Using AWS CloudWatch:

Enable Logging: Configure API Gateway to log request and response details.

Set Up Alarms: Create CloudWatch Alarms for specific error conditions (e.g., high 5xx error rates).
Testing and Validation: Thoroughly test your API error handling to ensure that errors are propagated and transformed correctly through the API Gateway.

Steps:

Unit Tests: Test backend error responses and exception handling.

Integration Tests: Test the full flow through the API Gateway to ensure errors are handled correctly and responses are as expected.
Summary:
Backend Services: Handle exceptions and return consistent error responses.

API Gateway Configuration: Map and customize error responses, configure Gateway Responses, and set up logging.

Logging and Monitoring: Track errors and performance using tools like AWS CloudWatch.

Testing:

Validate error handling through unit and integration tests. By following these steps, you ensure that your API Gateway can effectively manage and relay errors, providing a better experience for clients and aiding in the maintenance and debugging of your services.

How to improve the performance of Tomcat service configuration for slow networks.

noreply@blogger.com (A143MK PROGRAMMING) — Sun, 08 Sep 2024 14:49:00 +0000

Improving the performance of Tomcat services over a slow network involves addressing multiple aspects of both Tomcat configuration and network conditions. Here are some strategies to consider:
Optimize Tomcat Configuration:
Increase Thread Pool Size: Ensure that your Tomcat’s connector thread pool is appropriately sized. You can adjust the `maxThreads` attribute in your `server.xml` file to handle more simultaneous requests.

<Connector

port="8080"

protocol="HTTP/1.1"

maxThreads="200"

connectionTimeout="20000"

redirectPort="8443" />

Connection Timeout Settings: Tune the `connectionTimeout` attribute to be reasonable, considering network conditions. Setting it too high might lead to resource wastage on the server.
Disable Unnecessary Connectors:
Disable any unused connectors (e.g., AJP or HTTP/2) if they are not needed to reduce the overhead.
Enable Keep-Alive:
Keep-alive allows a single TCP connection to remain open for multiple requests, reducing the overhead of opening new connections for each request.

<Connector

port="8080"

protocol="HTTP/1.1"

connectionTimeout="20000"

redirectPort="8443"

keepAliveTimeout="60000"

maxKeepAliveRequests="100" />

Optimize Garbage Collection:
Configure Java’s garbage collection parameters to reduce the impact of GC pauses. Depending on your workload, you might use the G1GC collector or other JVM options suitable for your application.

-XX:+UseG1GC -XX:MaxGCPauseMillis=200

Optimize Application Code:
Reduce Latency: Ensure that your application code is optimized for performance. Slow database queries, inefficient algorithms, or heavy computation can exacerbate the effects of a slow network. Asynchronous Processing: Where possible, use asynchronous processing to free up Tomcat threads for other requests while waiting for I/O operations to complete.

Caching: Implement caching strategies (e.g., HTTP caching, application-level caching) to minimize the number of times the application needs to generate the same responses or fetch the same data.
Improve Network Performance:
Network Bandwidth: Ensure that your network has adequate bandwidth to handle the traffic. If possible, increase the bandwidth or use a Content Delivery Network (CDN) to reduce the load on your server.

Latency Reduction: Consider using tools or techniques to reduce latency, such as optimizing DNS resolution, using faster network routes, or deploying edge servers closer to end users.

Compression: Enable response compression to reduce the amount of data transmitted over the network. You can configure gzip compression in Tomcat:

<Connector

port="8080"

protocol="HTTP/1.1"

compression="on"

compressionMinSize="2048"

noCompressionUserAgents="gozilla, traviata" compressableMimeType="text/html,text/xml,text/plain,text/css,text/javascript,application/javascript" />

Monitor and Analyze Use Monitoring Tools: Implement monitoring and profiling tools to identify bottlenecks and performance issues. Tools like JVisualVM, JConsole, or commercial APM solutions can provide insights into how your application and Tomcat are performing.

Analyze Logs: Check Tomcat and application logs for any warnings or errors that could indicate performance issues. Look for patterns or recurring problems that could be addressed.

Regular Maintenance Keep Software Updated: Ensure that Tomcat, Java, and your application dependencies are up to date with the latest performance improvements and security patches.

Review Configuration: Periodically review and update your Tomcat and application configuration to ensure that they align with current performance and security best practices. By combining these strategies, you should be able to mitigate the effects of a slow network and improve the performance of Tomcat services.

How to fetch current location at the time of loading a web page using Javascript

noreply@blogger.com (A143MK PROGRAMMING) — Sat, 24 Aug 2024 15:58:00 +0000

To search for a location code (such as a City, state, postal code) using JavaScript, you generally need to perform a forward geocoding operation. This involves converting a location name or address into geographic coordinates and then retrieving additional details, including the City, State and postal code, from those coordinates. You can achieve this using various geocoding APIs.

<!DOCTYPE html>
<html>
<head>
    <title>Get City, state, postal code</title>
</head>
<body>
    <h1>Welcome to A143mk. <br/>Current Location City, state, postal code</h1>
    <p id="pinCode">Fetching...</p>

fetch(url)
                .then(response => response.json())
                .then(data => {
                    if (data && data.address && data.address.postcode) {
                        document.getElementById('pinCode').innerText = `HOUSE NO: ${data.address.house_number}, City: ${data.address.city},\n State: ${data.address.state},\n Pin Code: ${data.address.postcode}`;
                    } else {
                        document.getElementById('pinCode').innerText = 'Pin Code not found.';
                    }
						
                })
                .catch(error => {
                    console.error('Error:', error);
                    document.getElementById('pinCode').innerText = 'Error fetching pin code.';
                });
        }

if (navigator.geolocation) {
            navigator.geolocation.getCurrentPosition(position => {
                const lat = position.coords.latitude;
                const lon = position.coords.longitude;
                getPinCode(lat, lon);
            }, () => {
                document.getElementById('pinCode').innerText = 'Geolocation not supported or permission denied.';
            });
        } else {
            document.getElementById('pinCode').innerText = 'Geolocation not supported.';
        }
    </script>
</body>
</html>

output:

How to Implement Design Patterns in Spring Boots Application

noreply@blogger.com (A143MK PROGRAMMING) — Sat, 10 Aug 2024 11:12:00 +0000

In a Spring Boot web project, design patterns are essential to create a maintainable, scalable, and testable application. Below are some common design patterns and how you can implement them in a Spring Boot project:
Singleton PatternThe Singleton pattern ensures a class has only one instance and provides a global point of access to it. In Spring, beans are singleton by default.
For Example :

Factory Pattern
The Factory pattern is used to create objects without specifying the exact class of object that will be created.

For Example :
Usage in a Controller

Prototype Pattern
The Prototype pattern is used to create a new instance of a class by copying or cloning an existing instance.

For Example :

Adapter Pattern
The Adapter pattern allows incompatible interfaces to work together. In a Spring Boot project, it can be used to integrate third-party libraries.

For Example :Suppose you have an external logging service that doesn't fit directly into your logging system.
Usage:
Decorator Pattern
The Decorator pattern is used to add behavior to individual objects without affecting the behavior of other objects from the same class.
Example:

Observer Pattern
The Observer pattern allows an object to notify other objects when its state changes.
Example:

Usage in a Service:

Template Method Pattern
The Template Method pattern defines the skeleton of an al algorithm in a method, deferring some steps to subclasses.
Example:

Usage:

Conclusion: Design patterns are critical in developing well-structured, maintainable, and flexible Spring Boot applications. They help in decoupling components, reusing code, and making the application easier to understand and extend. By leveraging these patterns in your Spring Boot project, you can achieve better code organization and more effective application design.

@RestController and @Controller in Spring Framework

noreply@blogger.com (A143MK PROGRAMMING) — Mon, 05 Aug 2024 17:21:00 +0000

The primary difference between @RestController and @Controller in the Spring Framework lies in how they handle HTTP
@Controller :

@Controller is used to define a controller class that can handle HTTP requests and return views.
Typically used in web applications where the responses are HTML pages.
You need to use @ResponseBody on methods to indicate that the return value should be written directly to the HTTP response body.

@RestController:

@RestController is a specialized version of @Controller that combines @Controller and @ResponseBody.
Designed for RESTful web services where the responses are typically JSON or XML.
All methods in a class annotated with @RestController implicitly have @ResponseBody applied, so the return values are written directly to the HTTP response body.

Summary
Use @Controller when you need to return views (HTML pages).

Use @RestController when you need to create RESTful services and return data (like JSON or XML) directly in the response body.

Java 8 Introduced Key Features

noreply@blogger.com (A143MK PROGRAMMING) — Sun, 04 Aug 2024 08:56:00 +0000

Java 8 introduced several key features that significantly enhanced the language and its libraries. Here are the principal features:
Lambda Expressions:
Allow you to treat functionality as a method argument, or to create small function-like objects more concisely.

Syntax:

(parameters) -> expression or (parameters) -> { statements; }

Functional Interfaces:
An interface with just one abstract method, used as the type for lambda expressions and method references.

Example:

java.util.function.Predicate;

java.util.function.Function;

Stream API:
Introduces a new abstraction for working with sequences of elements and performing operations like filter, map, and reduce on them.

Example:

List myList = ...; myList.stream().filter(s -> s.startsWith("a")).forEach(System.out::println);

Default Methods:
Allow you to add new methods to interfaces without breaking the existing implementations.

Example:

interface MyInterface {

default void newMethod() {

............ // write Method body

} }

Optional:
A container object which may or may not contain a non-null value, to avoid `NullPointerException`.

Example:

Optional opt = Optional.of("value");

opt.ifPresent(System.out::println);

New Date and Time API:
A comprehensive new date and time library under `java.time` package, which is more flexible and easier to use than the old java.util.Date and java.util.Calendar classes.
Nashorn JavaScript Engine:
Replaces the old Rhino JavaScript engine, allowing for the embedding of JavaScript code within Java applications.
Method References:
Provide a way to refer to methods without invoking them, which can be used for constructing lambda expressions.

Example: ClassName::methodName.

These features aim to make Java code more expressive, readable, and efficient.

How to Mapping code logic using Stream API

noreply@blogger.com (A143MK PROGRAMMING) — Sun, 04 Aug 2024 08:31:00 +0000

Stream API in Java provides a powerful way to work with collections and other data sources. Mapping is one of the key operations available in the Stream API, used to transform elements of a stream. Here's a step-by-step guide on how to use the map function with the Stream API:
Import Required Classes :

First, make sure to import the necessary classes:

import java.util.Arrays;

import java.util.List;

import java.util.stream.Collectors;

import java.util.stream.Stream;

Create a Stream:
You can create a stream from various sources, like collections, arrays, or generator functions. For example, creating a stream from a list:

List names = Arrays.asList("a14mk", "manoj", "Jack");

Stream nameStream = names.stream();

Apply the map Function:
Use the map function to transform each element of the stream. For instance, to convert each name to uppercase:

Stream upperCaseNames = nameStream.map(String::toUpperCase);

Collect the Results:
Finally, you can collect the transformed stream back into a list or another collection:

List upperCaseNameList = upperCaseNames.collect(Collectors.toList());

Complete Example:
Here’s a complete example demonstrating how to use the map function with the Stream API:

Mapping with Complex Objects:
If you are working with a list of objects, you can use the map function to transform specific fields or create new objects. For example:

In this example, the map function is used to extract the names from a list of Person objects.

Inversion of Control (IoC) in Spring Frameworks

noreply@blogger.com (A143MK PROGRAMMING) — Sun, 04 Aug 2024 07:18:00 +0000

IoC stands for "Inversion of Control", a principle in software engineering where the control of objects or portions of a program is transferred to a framework or container. This concept is fundamental to achieving loose coupling in object-oriented design, which makes applications more modular, flexible, and easier to maintain.
Key Concepts of Inversion of Control :

Dependency Injection (DI)

The most common implementation of IoC.
Dependencies (objects that a class requires to function) are injected into the class rather than the class creating them itself.
Can be implemented in three main ways: constructor injection, setter injection, and interface injection.

Service Locator

An alternative to dependency injection.
A central registry (the service locator) provides dependencies upon request.
Can lead to less transparency in dependency management compared to DI.

How IoC Works:

Without IoC.

With IoC (Dependency Injection).

In the example above, with IoC, the `Car` class does not create the `Engine` instance itself. Instead, it receives it from an external source (typically an IoC container).
Benefits of IoC:

Decoupling: Reduces the dependency between components, making the system more modular. Testability: Easier to test components in isolation since dependencies can be easily mocked or stubbed. Flexibility: Easier to swap out implementations of dependencies without modifying the dependent class.

Maintainability: Simplifies code management and maintenance by following the single responsibility principle.

IoC Containers: IoC containers are frameworks that manage the creation and injection of dependencies. Some popular IoC containers are:
Spring (Java): Provides comprehensive support for dependency injection and IoC.

PicoContainer (Java): Lightweight and simple to use.

Unity (C#): A dependency injection container from Microsoft.

Autofac (C#): A popular IoC container for .NET applications.

Example in Spring Framework:

Spring Framework is a well-known example of an IoC container. Here’s how dependency injection is typically configured in a Spring application:

XML Configuration:

Java Configuration:

Annotation-Based Configuration:

In these examples, the Spring container manages the lifecycle and injection of the `Engine` dependency into the `Car` class. In summary, IoC is a design principle that helps to create flexible, maintainable, and testable software systems by inverting the control of dependency management. Dependency injection is the most common pattern used to implement IoC, and it is supported by various frameworks and containers across different programming languages.

How to Develop code logic using Stream API Workflow

noreply@blogger.com (A143MK PROGRAMMING) — Sat, 27 Apr 2024 12:34:00 +0000

Let's begin by defining the term stream as it applies to the stream API:
A stream operates on a data source, such as an array or a collection. A stream, itself, never provides storage on a data. It simply moves data, possibly filtering, sorting, or otherwise operating on that data is the process. as a genral rule, however a stream operation by itself does not modyfy the data source. For Example: sorting a stream does not change the order of the source. Rather, sorting a stream results in the creation of a new stream that produces the sroted result.
A Simple Stream Example : Let's work through an example that uses streams. The following program creates an ArrayList called myList that holds a collection of integers. Next, it obtains a stream that uses myList as a source.

package streamclasses;
import java.util.ArrayList;
import java.util.Optional;
import java.util.stream.Stream;

/**
 *
 * @author manoj.vishwakarma
 */
public class StreamClassDemo {
    public static void main(String[] args) {
        //Create a list of integer Values
        ArrayList<Integer> myList=new ArrayList<Integer>();
        myList.add(7);
        myList.add(18);
        myList.add(10);
        myList.add(5);
        myList.add(24);
        myList.add(17);
        myList.add(5);
        System.out.println("Original Lise:" +myList);
        //Obtain a stream to the array list.
        Stream<Integer> myStream=myList.stream();
        //Obtain the minimum and maximum value by using of min(), max(), isPresent(), and get()
        Optional<Integer> minValu=myStream.min(Integer::compare);
        if(minValu.isPresent()){
            System.out.println("Minimum Value:"+minValu.get());
        }
        // Must obtain a new stream because previous call to min() is a terminal opration that consumed the stream
        //Max value
         myStream=myList.stream();
         Optional<Integer> maxValu=myStream.max(Integer::compare);
        if(maxValu.isPresent()){
            System.out.println("Max Value:"+maxValu.get());
        }
        
        //Sort the stream by use of sorted()
         Stream<Integer> sortStream=myList.stream().sorted();
         //Display the sorted stream by use of forEacg().
         System.out.println("Sorted stream");
         sortStream.forEach((n)->System.out.println(n+""));
         
         //Dispaly only the odd values by use of filter()
        
          Stream<Integer> oddValue=myList.stream().sorted().filter((n)->(n%2)==1);
         //Display the sorted stream by use of forEacg().
         System.out.println("Odd Values");
         oddValue.forEach((n)->System.out.println(n+""));
         
         //Display only the odd value that are greater than 5. Notice That two filter operations are pipelined
       oddValue=myList.stream().sorted().filter((n)->(n%2)==1)
                                        .filter((n)->n>5);
         System.out.println("Odd Values grater  than 5:");
         oddValue.forEach((n)->System.out.println(n+""));              
    }  
}

OUTPUT:

How To Retrieve Data Using FLASHBACK Command In Oracle.

noreply@blogger.com (A143MK PROGRAMMING) — Sat, 27 Apr 2024 10:36:00 +0000

This command undoes changes made by Oracle Database to the data files that exist when you run the command. FLASHBACK can fix logical failures, but not physical failures
FLASHBACK DATABASE is usually much faster than a RESTORE operation followed by point-in-time recovery because no data files are restored. The time needed to perform FLASHBACK DATABASE depends on the number of changes made to the database since the desired flashback time. On the other hand, the time needed to do a traditional point-in-time recovery from restored backups depends on the size of the database.
For Example :

FLASHBACK TABLE TABLENAME to TIMESTAMP(SYSDATE-1);

Note: If Flashback is not working on SQL Tools/Oracle DataTable you can First run the command given below and then run the flashback command.

ALTER TABLE TABLENAME ENABLE ROW MOVEMENT;

Multiples DATABASE Connection and Data shifting Using Spring Boots API

noreply@blogger.com (A143MK PROGRAMMING) — Thu, 28 Dec 2023 04:08:00 +0000

Multiple DataBase Connection and Data shifting using Spring boot API configuration Example.

Step-by-step Write Java files.
1. application.properties File for Add multiple DataBase Connection.

2. DBConfigDBNAME.JAVA Files for multiple DataBase Connection.

3. Job Scheduler.java file for Auto shift programm.

4. Entity Beans, Repository, Services Implementations for Binding and shifting Data.

Create Spring Boot Java (Microservices)

Create Spring Boot Java (Microservices).

Project Name: DataShiftingConfigSpringBoots
Group: DataShifting-a143mk
Artifactid: DataShifting-a143mk
Description: DataBase Connection and Data shifting using Spring boot API.
Package: DataShiftinga143mk

Select the technologies and library(Maven Dependency ) to be.

spring-boot-configuration-processor
ojdbc8

while creating the project pom.xml file and some maven dependency, main class is automatically created when web add any dependency like.

pom.xml

<groupId>DataShiftinga143mk</groupId>
	<artifactId>DataShifting-a143mk</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<packaging>jar</packaging>
	<version>0.0.1-SNAPSHOT</version>
	<name>DataShiftingConfigSpringBoots</name>
	<description>DataBase Connection and Data shifting using Spring boot API</description>

<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>1.5.3.RELEASE</version>
		<relativePath/> 
	</parent>

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

<dependency>
               <groupId>com.oracle.database.jdbc</groupId>
               <artifactId>ojdbc8</artifactId>
               <version>12.2.0.1</version>
           </dependency>

<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-configuration-processor</artifactId>
			<optional>true</optional>
		</dependency>
	</dependencies>

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

<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-surefire-plugin</artifactId>
				
				<configuration>
					<useFile>false</useFile>
					<includes>
						<include>**/*Spec.java</include>
					</includes>
				</configuration>
			</plugin>
		</plugins>
	</build>

</project>

1. Configure application.properties

spring.jpa.database=default
spring.jpa.generate-ddl=true
server.port=9191

#  DB - "DATABASE1"
DATABASE1.datasource.driver-class-name=oracle.jdbc.OracleDriver
DATABASE1.datasource.url=jdbc:oracle:thin:@100.00.0.001:1521/serviceName(SID)
DATABASE1.datasource.username=db1UserName
DATABASE1.datasource.password=db1Password

#  DB - "DATABASE2"
DATABASE2.datasource.driver-class-name=oracle.jdbc.OracleDriver
DATABASE2.datasource.url=jdbc:oracle:thin:@100.00.1.002:1521/serviceName(SID)
DATABASE2.datasource.username=db2UserName
DATABASE2.datasource.password=db2Password

#  DB - "DATABASE3"
DATABASE3.datasource.driver-class-name=oracle.jdbc.OracleDriver
DATABASE3.datasource.url=jdbc:oracle:thin:@100.00.1.003:1521/serviceName(SID)
DATABASE3.datasource.username=db3UserName
DATABASE3.datasource.password=db3Password

#### LOGE FILE BLOCK#####
logging.level.org.springframework.web=INFO
logging.level.guru.springframework.controllers=DEBUG
logging.level.org.hibernate=ERROR
logging.file=logs/SHIPTING/masterShift.log
logging.level.org.hibernate.SQL=DEBUG
logging.level.org.hibernate.type.descriptor.sql.BasicBinder=TRACE

Create DataBase Configuration java Files :
DBConfigDATABASE1.java

package com.a143mk;

import javax.persistence.EntityManagerFactory;
import javax.sql.DataSource;

import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.autoconfigure.jdbc.DataSourceBuilder;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.orm.jpa.EntityManagerFactoryBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
import org.springframework.orm.jpa.JpaTransactionManager;
import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.annotation.EnableTransactionManagement;

@Configuration
@EnableTransactionManagement
@EnableJpaRepositories(entityManagerFactoryRef = "DATABASE1EntityManagerFactory",
    transactionManagerRef = "DATABASE1TransactionManager", basePackages = {"com.a143mk.DATABASE1.CustomerRepo"})
public class DATABASE1DbConfig {

@Bean(name = "DATABASE1DataSource")
  @ConfigurationProperties(prefix = "DATABASE1.datasource")
  public DataSource dataSource() {
    return DataSourceBuilder.create().build();
  }

@Bean(name = "DATABASE1EntityManagerFactory")
  public LocalContainerEntityManagerFactoryBean DATABASE1EntityManagerFactory(
      EntityManagerFactoryBuilder builder, @Qualifier("DATABASE1DataSource") DataSource dataSource) {
    return builder.dataSource(dataSource).packages("com.a143mk.DATABASE1.CustomerEntity").persistenceUnit("DATABASE1")
        .build();
  }

@Bean(name = "DATABASE1TransactionManager")
  public PlatformTransactionManager DATABASE1TransactionManager(
      @Qualifier("DATABASE1EntityManagerFactory") EntityManagerFactory DATABASE1EntityManagerFactory) {
    return new JpaTransactionManager(DATABASE1EntityManagerFactory);
  }

}

DBConfigDATABASE2.java

package com.a143mk;

import javax.persistence.EntityManagerFactory;
import javax.sql.DataSource;

@Configuration
@EnableTransactionManagement
@EnableJpaRepositories(entityManagerFactoryRef = "DATABASE2EntityManagerFactory",
    transactionManagerRef = "DATABASE2TransactionManager", basePackages = {"com.a143mk.DATABASE2.CustomerRepo"})
public class DATABASE2DbConfig {

@Bean(name = "DATABASE2DataSource")
  @ConfigurationProperties(prefix = "DATABASE2.datasource")
  public DataSource dataSource() {
    return DataSourceBuilder.create().build();
  }

@Bean(name = "DATABASE2EntityManagerFactory")
  public LocalContainerEntityManagerFactoryBean DATABASE2EntityManagerFactory(
      EntityManagerFactoryBuilder builder, @Qualifier("DATABASE2DataSource") DataSource dataSource) {
    return builder.dataSource(dataSource).packages("com.a143mk.DATABASE2.CustomerEntity").persistenceUnit("DATABASE2")
        .build();
  }

@Bean(name = "DATABASE2TransactionManager")
  public PlatformTransactionManager DATABASE2TransactionManager(
      @Qualifier("DATABASE2EntityManagerFactory") EntityManagerFactory DATABASE2EntityManagerFactory) {
    return new JpaTransactionManager(DATABASE2EntityManagerFactory);
  }

}

DBConfigDATABASE3.java

package com.a143mk;

import javax.persistence.EntityManagerFactory;
import javax.sql.DataSource;

@Configuration
@EnableTransactionManagement
@EnableJpaRepositories(entityManagerFactoryRef = "DATABASE3EntityManagerFactory",
    transactionManagerRef = "DATABASE3TransactionManager", basePackages = {"com.a143mk.DATABASE3.CustomerRepo"})
public class DATABASE3DbConfig {

@Bean(name = "DATABASE3DataSource")
  @ConfigurationProperties(prefix = "DATABASE3.datasource")
  public DataSource dataSource() {
    return DataSourceBuilder.create().build();
  }

@Bean(name = "DATABASE3EntityManagerFactory")
  public LocalContainerEntityManagerFactoryBean DATABASE3EntityManagerFactory(
      EntityManagerFactoryBuilder builder, @Qualifier("DATABASE3DataSource") DataSource dataSource) {
    return builder.dataSource(dataSource).packages("com.a143mk.DATABASE3.CustomerEntity").persistenceUnit("DATABASE3")
        .build();
  }

@Bean(name = "DATABASE3TransactionManager")
  public PlatformTransactionManager DATABASE3TransactionManager(
      @Qualifier("DATABASE3EntityManagerFactory") EntityManagerFactory DATABASE3EntityManagerFactory) {
    return new JpaTransactionManager(DATABASE3EntityManagerFactory);
  }

}

Create Scheduler ClassCreate Scheduler for Auto run Program and import some Packages Scheduler.java as below:

package com.a143mk.schedule;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.scheduling.annotation.Scheduled;
import com.a143mk.DATABASE3.ServiceImpl.MastCustomerDATABASE3ServiceImpl;
import com.a143mk.DATABASE2.ServiceImpl.MastCustomerDATABASE2ServiceImpl;
import com.a143mk.DATABASE1.CustomerServicesImpl.CustomerMasterDATABASE1SericesImpl;
@EnableScheduling
@Configuration
public class Scheduler {
	
	
	@Autowired
	private CustomerMasterDATABASE1SericesImpl custDATABASE1ServiceImpl;
	
	@Autowired
	private MastCustomerDATABASE3ServiceImpl DATABASE3CustomerServiImpl;
	
	@Autowired
	private  MastCustomerDATABASE2ServiceImpl  DATABASE2CustServeImple;

@Scheduled(cron = "0 */1 * ? * *")
	public void customerScheduletoDATABASE1() throws Exception {
		custDATABASE1ServiceImpl.customerinsertToDATABASE1();	
	}
	
	@Scheduled(cron = "0 */1 * ? * *")
	public void customerScheduletoDATABASE3() throws Exception {
	 DATABASE3CustomerServiImpl.customerinsertToDATABASE3();	
	}
	
	@Scheduled(cron = "0 */1 * ? * *")
	public void customerScheduletoDATABASE2() throws Exception {
	DATABASE2CustServeImple.customerinsertToDATABASE2();	
	}

}

Have you seen the previous post? You all know how to learn and create Entity Bean, Repository, Service Implementation in the project. If you don't know about it then go to the previous post and learn it.

How to add External Jar file in Pom.xml file

noreply@blogger.com (A143MK PROGRAMMING) — Sat, 07 Oct 2023 06:17:00 +0000

Add Externals Jar file in Pom.xml
There are many ways to configure external jar file but we are telling you an easy way, for this you should have whatever jar file you want to add, after that you know the .m2/repository folder.
Add dependencies in pom.xml and after saving the file, a folder is auto created inside the .m2/repository which is named after the groupId in dependency, such a groupId name is a143mkJar.
For Example : I have two Jar file one is EncryptDecryptA143mk-2.7.7.jar and Ldap-a143mkJar-2.7.7.jar

groupId is a143mkJar

artifactId is EncryptDecryptA143mk

version is 2.7.7

Add dependences in pom.xml:

Put the Jar file in maven repository Directory like this.

.m2/repository/a143mkJar/EncryptDecryptA143mk/2.7.7/EncryptDecryptA143mk-2.7.7.jar

.m2/repository/a143mkJar/Ldap-a143mkJar/2.7.7/Ldap-a143mkJar-2.7.7.jar

How to PACKAGE Spring Boot application to JAR and WAR

noreply@blogger.com (A143MK PROGRAMMING) — Tue, 19 Sep 2023 09:56:00 +0000

Maven is a popular build tool, that takes your project’s Java source code, compiles it, tests it and converts it into an executable Java program: either a .jar or a .war file.

Package Spring Boot application to JAR OR WAR file:
The default packaging type of a Spring Boot project is jar if the attribute is not present in the pom.xml file. It’s better to check your project’s pom.xml file to make sure that the packaging type is jar or War:

If you use an IDE such as Eclipse or Spring Tool Suite, right-click on the project, then select Run As > Maven Configuration Like:

CLEAN
BUILD
INSTALL
PACKAGE.................etc.

Simple LDAP sign-on Authentication Using Ldap-a143mkJar

noreply@blogger.com (A143MK PROGRAMMING) — Wed, 05 Jul 2023 12:19:00 +0000

LDAP sign-on is an authentication scheme that allows a user to log in with a single ID to any of several related, independent, software systems or web applications. In this post user will login through Outlook Mail. Ldap-a143mkJar.jar

Process of Ldap sign-On (LSO) Authentication:

Download the jar file and implement some methods / functions have been used, the names of the methods are as follows:

Call Class object LdapClient ldapClientClass=new LdapClient();

A143mkLdapConnection(ldapUrl, ldapDnConn, userEmailId, password);

There are some parameters in methods, which we initialize by creating configuration object like this.

String ldapUrl= "ldap://172.0.0.0:389/";

String lDapDnConn="dc=domainName,dc=com";

String userEmailId="EmailMail@mailDomen.com";

String password="mailPassword";

How to create a project/main class/other class to follow us.

while creating the controller/main class Ldapconn.java.

package ldapconn;
import ldap.a143mkjar.LdapClient;
import ldap.a143mkjar.LdapConnUser;
/**
 *
 * @author manoj.vishwakarma
 */
public class Ldapconn { 
     public static void main(String[] args) {
         //ldap-server configuration
        String ldapUrl= "ldap://172.0.0.0:389/";
        String lDapDnConn="dc=domainName,dc=com";
        String userEmailId="EmailMail@mailDomen.com";
        String password="mailPassword";
        
       LdapClient ldapClientClass=  new LdapClient();
       LdapConnUser get=ldapClientClass.A143mkLdapConnection(ldapUrl, lDapDnConn, userEmailId, password);
       if(get.getErrorLdapConn()==null){
          System.out.println(" DNParaMeter: "+get.getLdapDNParaMeter()+
                             "\n UserFirstName: "+get.getLdapUserFirstName()+
                             "\n UserSN: "+get.getLdapUserSN()+
                             "\n UserMailID: "+get.getLdapUserMailID()+
                              "\n accPassExpires: "+get.getAccPassExpires()+
                               "\n department: "+get.getDepartment()+
                                "\n description: "+get.getDescription()+
                                 "\n st: "+get.getSt()+
                                   "\n streetAddress: "+get.getStreetAddress());
          
  } else{
         System.out.println(get.getErrorLdapConn());
       }
     }
    
    
}

Output :