Building a Simple Login Form with Java Servlets and HTTP Requests

Java 𝗖𝗼𝗿𝗲 𝗝𝗮𝘃𝗮 → How do you sort a Map? → Implement a Singleton class. → Difference between Comparable and Comparator. → What are the new features introduced in Java 7 and 8? Key features of Java 8, 11, and 17. → What is try-with-resources? → What is a multi-catch block in Java? → Difference between Runnable and Callable. → Types of exceptions in Java and the exception hierarchy. → What are the different design patterns in Java? → Explain OOP principles. → Internals of ConcurrentHashMap. → How does Java Garbage Collection work? 𝗗𝗦𝗔/𝗖𝗼𝗱𝗶𝗻𝗴 → How to identify duplicate strings in a list? → Write a program to check if a string is a palindrome. → Combination Sum II (recursion-based problem). → Given an array, remove odd numbers, multiply remaining elements by a constant, and return the sum using Java Streams. → Find the missing number in a consecutive array. → Move all zeroes to the end of an array. → Check whether two strings are anagrams. → Find the longest common prefix among strings. → Longest Increasing Subsequence (LIS). → Best time to buy and sell stock (maximize profit). → Dijkstra’s Algorithm. → Coin Change problem (minimum coins). → Reverse-add palindrome problem. 𝗗𝗮𝘁𝗮𝗯𝗮𝘀𝗲 (𝗦𝗤𝗟) → How to retrieve the number of tables and their columns in a SQL database? → What is the purpose of database indexing? → How to detect duplicate records in SQL? → How would you design a schema for a ride-sharing application? 𝗪𝗲𝗯/𝗙𝗿𝗮𝗺𝗲𝘄𝗼𝗿𝗸𝘀 → Difference between REST and SOAP. → What is Spring Framework? → Why is Spring used? → Difference between Spring and Spring Boot. → How does dependency injection (autowiring) work in Spring? → What is Spring Security? → What is a RESTful API? → Difference between HTTP and HTTPS. 𝗦𝘆𝘀𝘁𝗲𝗺 𝗗𝗲𝘀𝗶𝗴𝗻 → Explain the architecture of a recent project you worked on. → Design a fraud detection system for transactions. → Database design for a ride-sharing platform. → Design a data warehouse for an e-commerce platform. → Design a news aggregation system. 𝗦𝗲𝗿𝘃𝗲𝗿/𝗦𝘆𝘀𝘁𝗲𝗺 → How to identify root causes of server crashes? → How to monitor server memory usage? → How to debug high CPU or memory utilization in JVM? → How to capture heap dumps and thread dumps? 𝗞𝗲𝗲𝗽𝗶𝗻𝗴 𝘁𝗵𝗶𝘀 𝗶𝗻 𝗺𝗶𝗻𝗱, 𝗜 𝘄𝗲𝗻𝘁 𝗱𝗲𝗲𝗽 𝗮𝗻𝗱 𝗱𝗼𝗰𝘂𝗺𝗲𝗻𝘁𝗲𝗱 𝗲𝘃𝗲𝗿𝘆𝘁𝗵𝗶𝗻𝗴 𝗶𝗻𝘁𝗼 𝗮 𝗝𝗮𝘃𝗮 𝗕𝗮𝗰𝗸𝗲𝗻𝗱 𝗗𝗲𝘃𝗲𝗹𝗼𝗽𝗲𝗿 𝗚𝘂𝗶𝗱𝗲. #java #backend

Wanted to share a few learnings from a recent backend upgrade we did. ⚙️ We moved one of our services to a newer Java, Spring, and Hibernate stack, and one thing became very clear: Big upgrades usually don’t fail at the compiler boundary. They fail at the assumption boundary. For us, the real work was not just the JDK upgrade. It was aligning everything around it: persistence mappings date/time behavior JSON serialization One of the earliest signals came from date/time handling. Before moving to java.time, we saw that some flows still using legacy java.sql.* types were not behaving correctly after the upgrade. In multiple cases, timestamp values were ending up in the database as 00:00:00.000 instead of carrying the expected time component. That created major issues across dev env because downstream flows were now reading and acting on incomplete or incorrect timestamps. That was the point where it became clear: this was not just a framework upgrade problem. It was a type-system and consistency problem. So we moved legacy JDBC-era date/time handling toward java.time, especially LocalDateTime. Java 21 does not suddenly reject java.sql.Date or java.sql.Timestamp, but modern frameworks definitely favor java.time. And with Hibernate 6.6.x, that path is much cleaner and more predictable. Why that mattered: older java.sql.* types were still “working” in parts of the system, but they became a poor fit across the full stack, especially once we looked at: ORM mappings Redis serialization integration flows consistency of behavior across layers The second issue was quieter, but just as important. 🧩 Once LocalDateTime entered one of our Redis-backed JSON flows, serialization started failing with: InvalidDefinitionException: Java 8 date/time type `java.time.LocalDateTime` not supported by default The root cause was a custom ObjectMapper. The fix: OBJECT_MAPPER.registerModule(new JavaTimeModule()); OBJECT_MAPPER.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS); Why this mattered: JavaTimeModule teaches Jackson how to handle java.time types disabling WRITE_DATES_AS_TIMESTAMPS makes unannotated date/time fields serialize as readable strings by default instead of timestamp/array-style output In short: the upgrade exposed hidden consistency gaps. The API layer may be fine, but caches, async flows, and internal serializers can still be operating under very different assumptions. A few takeaways from this upgrade 👇 JDK upgrades are often the easy part date/time migration deserves first-class attention Hibernate 6.6.x is far happier when your model uses java.time custom ObjectMappers are hidden compatibility surfaces consistency across DB, API, cache, and integrations matters more than “it compiles” #Java21 #SpringBoot #Hibernate #BackendEngineering #SoftwareArchitecture #TechLearning

🔥 ClassLoader Hierarchy and Why It Matters More Than You Think In Java, a Class Is Not Just Its Name a class is uniquely identified by (ClassLoader + Fully Qualified Class Name). That means aame .class file loaded by 2 ClassLoaders = 2 different types 1️⃣ The ClassLoader Hierarchy (Under the Hood) Bootstrap ClassLoader (native, part of JVM)     ↓ Platform ClassLoader (JDK modules)     ↓ Application ClassLoader (your classpath)     ↓ Custom ClassLoaders (frameworks, plugins) Who loads what? Bootstrap → java.lang, java.util (core classes) Platform → JDK internal modules Application → Your app classes Custom loaders: Spring Boot App servers (Tomcat) Plugin systems 2️⃣ Parent Delegation Model (Critical Concept) When JVM needs a class: 1️⃣ Ask parent ClassLoader 2️⃣ Parent tries to load 3️⃣ If not found → child loads This ensures: No duplicate core classes Consistent class definitions Security boundaries 3️⃣ Why You Can’t Override java.lang.String Even if you write: package java.lang; public class String {} It won’t work because for security guarantee -> Bootstrap ClassLoader already loaded the real String -> Your version is ignored. 4️⃣ What Happens Internally During Class Loading When a class is loaded: Step 1 -> Loading Bytecode read into memory Step 2 -> Linking Verification (bytecode safety) Preparation (allocate static fields) Resolution (symbolic → direct references) Step 3 -> Initialization Static variables assigned Static blocks executed Only after this → class is usable. 5️⃣ Real Production Bug: “A Cannot Be Cast to A” ClassCastException: com.User cannot be cast to com.User This happens when same class loaded by different ClassLoaders Example: App server loads User Plugin loads User 👉 Same name 👉 Same code 👉 Different ClassLoaders JVM treats them as different types 6️⃣ Why Frameworks Use Custom ClassLoaders 🔹 Isolation -> Different apps/modules don’t interfere 🔹 Hot Reloading -> Reload classes without restarting JVM 🔹 Plugin Systems -> Load/unload modules dynamically Used in: Spring Boot DevTools Tomcat OSGi 7️⃣ Memory Leaks (Advanced but Important) ClassLoaders can cause leaks If: -> A ClassLoader is referenced -> Its classes cannot be garbage collected 👉 Entire module stays in memory Common in: -> App servers -> ThreadLocal misuse -> Static references 💡In Java, two classes are equal only if their ClassLoader is equal. #Java #JVM #ClassLoader #JavaInternals #BackendEngineering #SoftwareEngineering #SystemDesign #Performance #LearnInPublic

Day 24 — #100DaysOfJava ☕ Today I learned **JSP** — JavaServer Pages. And this is where Java meets the browser. For 23 days I have been writing backend code — logic, databases, architecture. Today I saw how Java actually sends something to a user's screen. --- Q.What is JSP? JSP = HTML + Java code running on the server. You write HTML like normal. But inside that HTML, you can embed Java code using special tags. The server runs that Java, produces the output, and sends pure HTML back to the browser. The user never sees Java. They just see the result. --- How it actually works — the flow every developer should know: Step 1 — Browser sends a request to the server. Step 2 — Server takes your JSP file and converts it into a Servlet automatically. Step 3 — That Servlet compiles and runs. Step 4 — Output is plain HTML sent back to the browser. You write JSP. Java handles the rest. --- Three things you write inside JSP: Scriptlet — for writing Java logic. <% int sum = 10 + 20; %> Expression — for printing a value directly into the page. <%= sum %> Directive — for page-level settings like importing classes. <%@ page import="java.util.*" %> --- JSP also gives you built-in objects for free — no setup needed: request — get data the user sent response — send data back to the user session — remember the user across multiple pages out — write output to the page These are available in every JSP file automatically. That is one of the reasons JSP was so popular for building web apps quickly. --- JSP vs Servlet — the honest difference: Servlet is pure Java. You write Java code that generates HTML. Powerful but messy — imagine writing out.println for every single HTML tag. Hard to maintain. JSP is HTML first. Java is embedded inside. Much easier to design pages. Better separation between UI and logic. In modern Java development — neither JSP nor raw Servlet is used for production apps. Spring Boot with REST APIs and a frontend framework has replaced them. But understanding JSP and Servlets is what makes Spring MVC make complete sense. You cannot understand the solution without understanding the problem it solved. --- What clicked today — every web framework in Java is built on top of Servlets underneath. Spring MVC, Spring Boot — all of it. When a request comes in, a Servlet is handling it. JSP taught me that foundation. Day 1 ..... ....... Day 24 To any Java developer reading this — did you learn JSP and Servlets before Spring Boot? Do you think beginners should still learn them? Drop your opinion below. 👇 #Java #JSP #Servlets #JavaWebDevelopment #BackendDevelopment #100DaysOfJava #JavaDeveloper #LearningInPublic #100DaysOfCode #SpringBoot #WebDevelopment #OpenToWork #HiringJavaDeveloper

static in Java, Not Just a Keyword, It’s a Production Decision Learnings from fixing production Bugs..... Most developers learn static early… But very few understand how dangerous or powerful it becomes in real backend systems. Let’s break it down 👇 ⚡ What static really means When you mark something static, you’re saying: 👉 “This belongs to the class, not to individual objects” 👉 “This will be shared across all requests, threads, and users” In backend systems, that’s a big deal. Where static actually helps in production ✅ 1. Constants (Best Use Case) public static final String STATUS_ACTIVE = "ACTIVE"; ✔ No duplication ✔ Memory efficient ✔ Thread-safe ✅ 2. Utility Classes public class DateUtils { public static String format(Date date) { ... } } ✔ Stateless ✔ Reusable across services ✔ No object creation overhead ✅ 3. Caching (Careful Usage) public static Map<String, Config> cache = new HashMap<>(); ✔ Fast access ✔ Avoids repeated DB calls ⚠ But NOT thread-safe unless handled properly! Where static breaks production systems ❌ 1. Shared Mutable State (Biggest Mistake) public static int loginAttempts = 0; Imagine: 1000 users logging in simultaneously All threads updating the same variable 🔥 Result: Race conditions Wrong data Security issues ❌ 2. Memory Leaks Static objects live till JVM dies public static List<User> users = new ArrayList<>(); If this keeps growing → 💥 OutOfMemoryError ❌ 3. Breaking Framework Lifecycles Frameworks like Spring Boot, Hibernate manage objects (Beans) for you. If you use static: 👉 You go outside the container 👉 Lose dependency injection 👉 Lose lifecycle control ❌ 4. Testing Becomes Hard Static methods: Cannot be easily mocked Lead to tightly coupled code ⚖️ Golden Rules ✔ Use static for: Constants Stateless utilities ❌ Avoid static for: Business logic User/session data Mutable shared state 🧩 Real Production Insight Servlets are singleton by design. If you combine that with static state: 👉 You’re now sharing data across: All users All sessions All threads That’s how subtle production bugs are born. 🧠 Final Thought static is not about syntax… It’s about understanding memory, concurrency, and system design. Use it right → ⚡ High performance Use it wrong → 💣 Production incident If you’re building backend systems, mastering this one concept will save you from some of the hardest bugs you’ll ever debug. #Java #BackendEngineering #SystemDesign #Concurrency #SpringBoot

Every Java developer has confidently used these three terms. JVM. JDK. JRE. Most of them have no idea what the difference actually is. (Don't worry. Neither did I when I started.) Let's go back to the promise Java made in 1995 -> "Write Once, Run Anywhere." Sounds magical. But HOW? How does the same code run on Windows, Mac, and Linux without changing a single line? The answer is the JVM -> Java Virtual Machine. When you write Java code, it doesn't become machine code directly. It first becomes something called Bytecode. Bytecode is like a middle language not human readable, not machine readable either. It's in between. Now here's the trick. Every operating system has its own JVM installed. And the JVM's only job is to take that Bytecode and translate it into instructions YOUR machine understands. Windows JVM speaks Windows. Mac JVM speaks Mac. Linux JVM speaks Linux. But your code? Your code never changes. That's the magic. That's "Write Once, Run Anywhere." Okay. So where do JDK and JRE fit in? Think of it like a kitchen. JVM -> the stove. It runs and executes things. JRE (Java Runtime Environment) -> the full kitchen. The stove + everything needed to actually cook. Libraries, tools, the works. If you just want to RUN a Java program, JRE is enough. JDK (Java Development Kit) -> the kitchen PLUS a recipe book, knife set, and a chef's manual. Everything in JRE plus the tools to actually WRITE and BUILD Java programs. Compilers. Debuggers. The full package. So -> -> User who just runs your app? They need JRE. -> You, the developer building it? You need JDK. -> Under all of it, quietly doing the real work? JVM. Here's why this matters more than you think. Ever seen this error? "Java is not recognised as an internal or external command" That's your machine saying I have no idea what Java is. You never gave me a JRE or JDK. Understanding JVM, JDK, and JRE isn't just theory. It saves you hours of debugging confusion. If you read this far... This is Post #2 of my Java series -> the story behind the code. Next up: How Java actually compiles and runs your code step by step, from the line you write to the output on your screen. Follow SHABANA FATHIMA so you don't miss it. JVM, JDK, JRE did this finally click for you, or were you already a pro? 👇 #Java #JavaSeries #JVM #JDK #JRE #SoftwareEngineering #Programming #LearnToCode #BackendDevelopment #TechHistory

🚀 3 Ways to Create Docker Images for Java Applications When working with Spring Boot / Java applications, there are three popular ways to create Docker images. Here’s a quick comparison with examples and pros/cons 👇 1️⃣ Using Dockerfile (Traditional Approach) Example Dockerfile: # Base image FROM eclipse-temurin:21-jdk-jammy LABEL maintainer="maintainer-name" # Copy project jar (replace with your jar name) COPY target/your-project-name.jar app.jar # Run application ENTRYPOINT ["java","-jar","/app.jar"] 👉 Replace your-project-name.jar with the JAR generated inside your target folder. Example: loan-service-0.0.1-SNAPSHOT.jar accounts-service-1.0.0.jar 2️⃣ Spring Boot Buildpacks (No Dockerfile Required):- Add inside pom.xml under spring-boot-maven-plugin: <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> <configuration> <image> <name>your-project-image-name</name> </image> </configuration> </plugin> Run: mvn spring-boot:build-image Run container:docker run -d -p servicePort:containerPort your-project-image-name ✅ Pros • No Dockerfile required • Easy to use • Automatically optimized layers ❌ Cons • Limited customization • Only for Spring Boot apps • Less control 3️⃣ Google Jib (Only for Java):- Add plugin in pom.xml: <plugin>   <groupId>com.google.cloud.tools</groupId>   <artifactId>jib-maven-plugin</artifactId>   <version>3.4.0</version>   <configuration>     <to>       <image>your-image-name</image>     </to>   </configuration> </plugin> Run: mvn compile jib:dockerBuild ✅ Pros • Very fast builds ⚡ • No Dockerfile required • No Docker daemon needed • Layered caching ❌ Cons • Only for Java • Less flexible than Dockerfile • Plugin configuration required 💡 Summary • Need full control → Dockerfile • Quick setup → Spring Boot Buildpacks • Fastest build → Google Jib Which one do you use? 🤔 #Docker #Java #SpringBoot #DevOps #Backend #Microservices #Maven #GoogleJib

Optional Misuse Patterns in Java: The Problem: A user lookup crashes in production with NoSuchElementException. The developer is confused — they used Optional, so it should be safe. But they called .get() directly without checking if the value is present. The Optional wrapper added zero safety. Root Cause: Optional was introduced in Java 8 to make absent values explicit and force callers to handle the empty case. But calling .get() on an empty Optional throws NoSuchElementException — just as calling a method on null throws NullPointe java User u = userRepo.findById(id).get(); That one line is no safer than a null dereference. Optional.get() on an empty Optional throws NoSuchElementException. Calling a method on null throws NullPointerException. Different exception, identical outcome. The Optional wrapper added zero protection. Optional was introduced to make absence explicit and force the caller to handle it. But calling .get() skips the entire contract. You have paid the ceremony tax with zero safety benefit. The other anti-pattern is isPresent() + get() — it works, but it is just a verbose null check. The same bug is still possible if someone removes the isPresent() guard later. Three correct patterns: java // 1 — fail with a meaningful exception (service layer default) .orElseThrow(() -> new UserNotFoundException(id)) // 2 — provide a safe default .orElse(User.anonymous()) // 3 — return Optional to caller, let them decide return userRepo.findById(id); Prevention Checklist: ->Never call Optional.get() without an explicit guard ->Prefer orElseThrow() at service layer — fail fast with meaningful exception ->Use orElseGet() instead of orElse() when the default is expensive to create ->Return Optional<T> from repo/service when absence is expected and valid ->Never use Optional as a method parameter or entity field — only as return type ->Enable IntelliJ inspection: "Optional.get() without isPresent()" Lesson: Optional.get() without a guard is just a different way to write a NPE. Optional forces you to think about the empty case — use its API to handle it. orElseThrow() for service layers. orElse() for defaults. Return Optional when absence is valid. Never call .get() directly. It is not a safe operation. #Java #DataStructures #DSA #SystemDesign #SpringBoot #BackendDevelopment #SoftwareEngineering #JavaDeveloper #Programming

🚀 Hey folks! I’m back with a Java concept — let’s decode Singleton in the simplest way possible 😄 🤔 What is Bill Pugh Singleton? (pronounced like “Bill Pew” 😄) Many of you know the Singleton pattern, but did you know there are multiple ways to implement it? 👉 Let’s quickly list them: 1️⃣ Eager Initialization 2️⃣ Lazy Initialization 3️⃣ Synchronized Singleton 4️⃣ Double-Checked Locking 5️⃣ Bill Pugh Singleton (Best Practice ⭐) 6️⃣ Enum Singleton (Most Secure) 🧠 Why Bill Pugh Singleton? It was popularized by Java expert Bill Pugh as a clean + efficient solution. 👉 It uses: Static inner class JVM class loading No locks, no volatile 🔥 Key Benefits ✔ Lazy loading (created only when needed) ✔ Thread-safe ✔ No synchronized overhead ✔ High performance ✔ Clean & simple ⚙️ How It Works (Internally) Step 1: Class Load Singleton s = Singleton.getInstance(); 👉 Only outer class loads ❗ Inner class NOT loaded yet Step 2: Method Call return Holder.INSTANCE; 👉 Now JVM triggers inner class loading Step 3: Inner Class Loads private static class Holder 👉 Loaded ONLY when accessed (Lazy 🔥) Step 4: Object Creation private static final Singleton INSTANCE = new Singleton(); 👉 Created once, safely 🔒 Why It’s Thread-Safe? JVM guarantees during class loading: ✔ Only ONE thread initializes ✔ Other threads WAIT ✔ Fully initialized object is shared 👉 Comes from Java Memory Model (JMM) ⚠️ Important Concept: Partial Construction What you THINK happens: Allocate memory Initialize object Assign reference What CAN happen (Reordering ❌): Allocate memory Assign reference ⚠️ Initialize object 💥 Real Problem Thread-1: instance = new Singleton(); Thread-2: System.out.println(instance.value); 👉 Output: Expected: 42   Actual:  0 ❌ 🚨 Object is visible BEFORE full initialization 👉 This is Partial Construction 🛠️ How volatile Fixes It (in DCL) private static volatile Singleton instance; ✔ Prevents reordering ✔ Ensures visibility ✔ Guarantees fully initialized object 🔥 Why Bill Pugh Avoids This? private static class Holder {   private static final Singleton INSTANCE = new Singleton(); } 👉 JVM ensures: No reordering No partial construction Happens-before guarantee 🧵 Internal Flow Thread-1 → creates instance Thread-2 → waits Thread-3 → waits 👉 All get SAME object 🏢 Simple Analogy Main Office = Singleton Storage Room = Holder 🚪 Room stays locked 👉 Opens only when needed 👉 Item created once 👉 Everyone uses same item ⚠️ Limitations ❌ Reflection can break it ❌ Serialization can break it 👉 Use Enum Singleton to fix these 🏁 Final Takeaway 👉 Bill Pugh = Lazy + Thread Safe + No Locks 🚀 💬 If this helped you understand Singleton better, drop a 👍 #Java #Multithreading #DesignPatterns #InterviewPrep #BackendDevelopment

#Day81 🚀 || AI Powered Java Full Stack Course 💻 Advanced Java | 🌐 Introduction to JSP, Scripting Elements & Scopes with Frontlines EduTech (FLM) Hello connections 👋😊 As part of my AI Powered Java Full Stack Course, today’s session introduced Java Server Pages (JSP) — a powerful server-side technology used to build dynamic and interactive web applications 💡🚀 Today marks 📅 Day 81 of my learning journey, where I explored how JSP simplifies web development by seamlessly combining HTML and Java code in a single file 🌐 🔹 🌐 Introduction to JSP JSP (Java Server Pages) enables developers to create dynamic web pages by embedding Java code directly into HTML 🧩 ✨ Key points: • Java code is executed on the server side • The processed result is sent to the browser as HTML • Helps in building dynamic and user-interactive applications 🔹 🎯 Purpose of JSP ✨ • Generates dynamic content efficiently • Simplifies UI development compared to Servlets • Reduces boilerplate code by integrating Java with HTML 🔹 🛠️ Creating a JSP File ✨ Steps: • Navigate to the webapp directory • Create a file with .jsp extension (e.g., index.jsp) 👉 Acts as the entry point for rendering web pages 🔹 🧩 JSP Scripting Elements JSP provides special elements to embed Java code within HTML 🔗 ✨ Types of scripting elements: • Scriptlet Tag → <% Java code %> 👉 Used for implementing business logic (loops, conditions) • Expression Tag → <%= expression %> 👉 Outputs data directly to the browser • Declaration Tag → <%! declaration %> 👉 Used to declare variables and methods at class level 🔹 🔄 JSP Scopes Scopes are used to store and share data across different components of a web application 📊 ✨ Types of scopes: • Request Scope 📥 👉 Stores data for a single request-response cycle 👉 Commonly used between Servlet and JSP (forwarding) • Session Scope 🔐 👉 Stores data across multiple requests for a single user session 👉 Data persists until session expires or browser is closed • Application Scope 🌍 👉 Stores data shared across the entire application 👉 Accessible by all users and components 🔹 ⚠️ Important Note ✨ • getAttribute() returns data as Object type • Requires typecasting while retrieving values 💡 Today’s Takeaway: JSP simplifies the development of dynamic web pages by bridging the gap between frontend (HTML) and backend (Java). Understanding scripting elements and scopes is crucial for managing data flow effectively in real-world web applications 💯🚀 🙏 Special thanks to Krishna Mantravadi, Upendra Gulipilli, and my trainer Fayaz S for their continuous guidance 💡 #Java #JSP #AdvancedJava #WebDevelopment #Servlets #JavaFullStack #BackendDevelopment #LearningJourney #AIPoweredJavaFullStack #FrontlinesEdutech #FLM 🚀