Learning JSP and Servlets for Java Web Development

#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 🚀

Day 28 — #100DaysOfJava ☕ Today a user typed something in a browser. My Java code received it, processed it, and sent a response back. That is client-server communication. And I built it from scratch. --- What I built today. A simple login form in HTML. User types username and password. Clicks submit. A Java Servlet receives that data on the server, reads it, and sends a response back to the browser. No framework. No Spring. No magic. Just raw Java talking directly to an HTTP request. --- How it actually works — and why every Spring Boot developer should understand this. The browser submits a form with method="post" to action="./firstServlet". The server sees that URL and maps it to my Servlet — because of this one annotation: @WebServlet("/firstServlet") That annotation replaced an entire XML configuration file. One line. Done. The Servlet extends HttpServlet and overrides two methods: doGet() — handles GET requests. When someone just visits the URL. doPost() — handles POST requests. When someone submits a form. Inside doPost(): String username = request.getParameter("username"); String password = request.getParameter("password"); PrintWriter writer = response.getWriter(); writer.print("Hello " + username); request.getParameter() reads the form field by its name attribute. PrintWriter writes the response back to the browser. That is the complete cycle. Request in. Process. Response out. --- What this taught me that no tutorial explains clearly. Every HTTP request has a method — GET or POST. GET is for fetching data. POST is for sending data. This is not just a Servlet concept. This is how the entire web works. Every form submission, every API call, every button click in a web app — underneath it is either a GET or a POST going to a server somewhere. Understanding this at the Servlet level means REST APIs, Spring Boot controllers, and API design all make immediate sense. @WebServlet maps a URL to a Java class. In Spring Boot, @RequestMapping and @GetMapping do the exact same thing — just with more features. Same concept. Different syntax. --- What Spring Boot does that raw Servlets do not. With raw Servlets — I write doGet() and doPost() manually. I configure the server. I handle everything. With Spring Boot — @RestController and @GetMapping handle all of this automatically. The Servlet container is embedded. Configuration is automatic. But here is the thing — Spring Boot is doing Servlet work underneath. It IS a Servlet application. Understanding the foundation means I will never be confused by what Spring Boot is doing for me. --- One thing I noticed in my own code today. I printed the password directly in the response: writer.print("I know your password " + password) Day 1 ... .......Day 28 To any developer reading this — what was the moment HTTP requests finally clicked for you? Drop it below. 👇 #Java #Servlets #HttpServlet #BackendDevelopment #WebDevelopment #100DaysOfJava #JavaDeveloper #LearningInPublic

🔥 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

Bridging the Gap: How Angular and Java Work Together In modern full-stack development, the combination of Angular (the robust frontend framework) and Java (the powerhouse backend language, usually via Spring Boot) is a gold standard for enterprise applications. But how do these two distinct worlds actually talk to each other? Here is a breakdown of the interaction: 1. The Communication Bridge: RESTful APIs Since Angular runs in the browser (client-side) and Java runs on a server (server-side), they don't share a direct memory space. Instead, they communicate over HTTP using REST (Representational State Transfer). The Java Side: Using Spring Boot, you create controllers annotated with @RestController. These expose "endpoints" (URLs) that perform CRUD operations. The Angular Side: Angular uses its built-in HttpClient module to send requests (GET, POST, PUT, DELETE) to those Java endpoints. 2. The Language of Exchange: JSON Even though Java uses Objects and Angular uses TypeScript classes, they speak a common language: JSON (JavaScript Object Notation). Java converts (serializes) its objects into JSON strings using libraries like Jackson. Angular receives these strings and parses them back into TypeScript objects to display on the UI. 3. Handling Asynchrony: Observables & RxJS Network requests take time. Angular uses RxJS Observables to handle this. When Angular calls a Java API, it doesn't "freeze" the screen. It "subscribes" to a stream. Once the Java backend finishes processing—whether it's a complex database query or a heavy calculation—it sends the data back, and Angular automatically updates the view. 4. Securing the Connection: JWT & CORS CORS (Cross-Origin Resource Sharing): By default, browsers block requests to a different domain. You must configure your Java backend to "trust" the Angular origin. Authentication: Typically, a JSON Web Token (JWT) is issued by the Java server after login. Angular stores this token and sends it in the header of every subsequent request to prove the user's identity. The Workflow at a Glance User Action: A user clicks "Save" in the Angular UI. Request: Angular’s DataService sends a POST request with a JSON payload to https://lnkd.in/eksUuZb2. Processing: The Java/Spring Boot controller receives the request, validates the data, and saves it to a database (like PostgreSQL or MongoDB). Response: Java sends back a 201 Created status and the saved object as JSON. UI Update: Angular receives the success response and shows a "Saved Successfully" toast notification. Why this duo? Angular provides a structured, scalable frontend, while Java offers the security, multi-threading, and performance needed for heavy-duty backend logic. Together, they create a seamless, high-performance user experience. #Angular #Java #SpringBoot #FullStack #WebDevelopment #CodingLife

🚀 The Full Anatomy of JSP: Directives, Scopes, and Scripting ✔️If you're building Java Web apps, understanding how JSP (JavaServer Pages) handles data is a game-changer. It’s not just about tags it’s about understanding the "Big Three" elements that make your page dynamic. 🛠️ 1. JSP Directives (The Configuration) Directives are the "Setup" instructions for the JSP engine. 🔹<%@ page ... %>: Imports classes and sets page properties (like session="true"). 🔹<%@ include ... %>: Merges other files (Headers/Footers) during translation. 🔹<%@ taglib ... %>: Enables powerful tag libraries like JSTL. 📝 2. Scripting Elements (The Logic) This is where the magic happens. Many developers confuse these: 🔹Declarations <%! ... %>: Use this to define variables and methods. 🔹Scriptlets <% ... %>: The "Engine Room." Write your Java logic here (if-else, for-loops). 🔹Expressions <%= ... %>: Use this purely to display (print) data to the user. 🌐 3. The 4 Scopes (The Memory) 🔹Page: Lives only for the current page. 🔹Request: Lasts for one full request/response cycle. 🔹Session: Stays with the user while they browse. 🔹Application: Shared by every single user on the server. 💻 The "Ultimate Cheat Sheet" Code <%@ page language="java" contentType="text/html; charset=UTF-8" import="java.util.Date" %> <html> <body> <%! int hitCount = 0; %> <% hitCount++; // Incrementing our declared variable String timeOfDay = ""; int hour = new java.util.GregorianCalendar().get(java.util.Calendar.HOUR_OF_DAY) if(hour < 12) timeOfDay = "Morning"; else timeOfDay = "Evening"; request.setAttribute("greeting", "Good " + timeOfDay); %> <h1><%= request.getAttribute("greeting") %>, Developer!</h1> <p>This page has been viewed <b><%= hitCount %></b> times.</p> <hr> <p>Server Time: <%= new Date() %></p> </body> </html> 💡 Summary for your feed: 🔹Directives = Setup 🔹Declarations = Definition 🔹Scriptlets = Logic 🔹Expressions = Output 🔹Scopes = Lifetime ✔️Mastering these ensures your backend remains organized and your web pages stay fast. ❓Which of these four was the hardest for you to grasp when you started? Let's discuss! 👇 #Java #JSP #BackendDevelopment #Coding #SoftwareEngineering #WebApps #JavaDeveloper

Day 29 — #100DaysOfJava ☕ What happens when a browser requests a JSP page? Not "it shows HTML." What actually happens. Step by step. Inside the server. --- The JSP Life Cycle has 6 phases. Here is every one of them. Phase 1 — Translation your .jsp file is not Java yet. The server's JSP Container takes your file and converts it into a .java Servlet file. Every JSP tag becomes Java code. Every piece of HTML becomes an out.write() call. You never see this file unless you look inside the server's metadata folder. Phase 2 — Compilation That generated .java file is compiled into a .class bytecode file. Same as any Java program. This is why JSP is fast after the first request — the compilation already happened. Phase 3 — Loading and Instantiation The .class file is loaded onto the server and an object of that Servlet class is created. One object. Created once. Shared across all requests. Phase 4 — Initialization The jspInit() method runs once. This is where you set up resources that every request will share — database connections, configuration values. Runs one time only. Never again unless the server restarts. Phase 5 — Request Handling This is where your users actually get served. For every single request that comes in, _jspService() runs. This is the method that processes dynamic content, reads request parameters, and writes the HTML response. Every request. Every time. Phase 6 — Destroy When the server shuts down or the JSP is no longer needed, jspDestroy() runs. Cleanup happens here — close connections, release resources. Runs once. Then the object is gone. --- The three interview questions this answers: How many phases in JSP life cycle? — Six. Which method handles client requests? — _jspService(). Not doGet(). Not doPost(). The JSP Container calls _jspService() directly — it handles both GET and POST internally. What creates the initial JSP object? — The JSP Container. Not you. You never instantiate a JSP manually. The container controls the entire lifecycle. --- The thing that clicked today — JSP life cycle and Servlet life cycle are almost identical. Servlet: init() → service() → destroy() JSP: jspInit() → _jspService() → jspDestroy() JSP just has two extra steps at the beginning — Translation and Compilation — because your file starts as JSP and needs to become a Servlet first. After that, it IS a Servlet. Running the same lifecycle. The same container managing it. The same object serving every request. JSP is not a different technology from Servlets. It is Servlets with a friendlier way to write HTML. --- One thing most beginners miss — that .class file is cached. The first request to a JSP page is slow. Translation. Compilation. Loading. Instantiation. Initialization. All happening before a single user sees anything. Every request after that? Fast. The object is already loaded. _jspService() just runs. #Java #JSP #Servlets #JSPLifeCycle #BackendDevelopment #WebDevelopment #JavaDeveloper

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

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

📘 #Day115 of My Java Full Stack Journey Today I started learning JSP (JavaServer Pages), which is used to create dynamic web pages in Java web applications. ✨ 𝐖𝐡𝐚𝐭 𝐢𝐬 𝐉𝐒𝐏? JSP (JavaServer Pages) is a server-side technology used to create dynamic web content. ➜ It allows us to write HTML along with Java code inside a single file. ➜ JSP runs inside a Servlet container like Apache Tomcat. ➜ Before sending the response to the browser, JSP is automatically converted into a Servlet by the server. ✨ 𝐖𝐡𝐲 𝐉𝐒𝐏 𝐢𝐬 𝐍𝐞𝐞𝐝𝐞𝐝? While working with Servlets, generating HTML using Java code becomes difficult to manage. JSP solves this problem by separating presentation logic from business logic. JSP helps to: ➜ Write HTML easily ➜ Reduce Java code inside Servlets ➜ Improve readability of web pages ➜ Support faster development of UI ✨ 𝐉𝐒𝐏 𝐯𝐬 𝐒𝐞𝐫𝐯𝐥𝐞𝐭 𝑺𝒆𝒓𝒗𝒍𝒆𝒕: ▪ Used mainly for processing logic ▪ Writing HTML inside Java code is difficult 𝑱𝑺𝑷: ▪ Used mainly for designing UI pages ▪ Allows writing Java inside HTML easily ▪ Internally converted into Servlet ➜ So JSP is mainly used for the presentation layer, while Servlets handle processing logic. ✨ 𝐉𝐒𝐏 𝐄𝐥𝐞𝐦𝐞𝐧𝐭𝐬 JSP provides special elements to write Java code inside HTML. 1️⃣ Scriptlet: Scriptlet is used to write Java code inside JSP. 𝑬𝒙: <% out.println("Hello JSP"); %> 2️⃣ Expression: Expression is used to print output directly to the browser. 𝑬𝒙: <%= "Welcome to JSP" %> 3️⃣ Directive: Directive is used to provide instructions to the JSP container. 𝑬𝒙: <%@ page language="java" contentType="text/html" %> ✨ 𝐇𝐨𝐰 𝐉𝐒𝐏 𝐖𝐨𝐫𝐤𝐬? Browser → Request → JSP → Converted into Servlet → Response → Browser 📌 𝐊𝐞𝐲 𝐋𝐞𝐚𝐫𝐧𝐢𝐧𝐠𝐬 ▪ JSP is used to create dynamic web pages ▪ JSP runs inside Servlet container (Tomcat) ▪ JSP is internally converted into Servlet ▪ Scriptlet is used to write Java code ▪ Expression prints output directly to browser ▪ Directive provides instructions to JSP container Gurugubelli Vijaya Kumar | 10000 Coders #Java #JSP #JavaServerPages #JavaWebDevelopment #FullStackJourney #BackendDevelopment

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