JavaXp.com | Java Experts Blog | Java Examples | API | Errors | Exceptions

Java Performance Optimization for High-Volume Search Applications

2025-10-15T03:07:00.002+05:30

Imagine a search box that must sweep billions of records across more than fifty data sources and still answer in under three seconds while thousands of people are clicking at once. That is the everyday reality for public unclaimed property lookups. Latency here is not a vanity metric. Ten seconds feels like forever, and thirty seconds often means a user gives up and never finds the money that could cover rent, tuition, or medical bills. Java can handle this scale, but large datasets, legacy endpoints, and network drag can slow even well-written code. The question is blunt: how do you deliver Google-like speed on top of upstream systems that were never designed for it? Below is a practical playbook drawn from turning a single-state search that took more than thirty seconds into a fifty-state sweep that lands under three seconds, with lessons you can reuse in any high-volume Java search.

Java performance in a cup: profile, optimize, repeat.

Understanding the Performance Bottlenecks

Database Query Time

This is commonly the most significant slice. The usual culprits are missing or weak indexes, joins that force full scans, overgrown subqueries, and servers that are starved for CPU, memory, or I O. Shape access paths to exploit indexes, and verify with execution plans rather than hunches.

Network Latency

Parallel calls help, but round-trip calls to external databases, slow links into legacy data centers, API rate limits that serialize requests, repeat DNS lookups, and SSL or TLS setup costs all add up. Minimize handshakes, coalesce requests, and reuse connections aggressively.

Data Processing Time

Large XML or JSON payloads must be parsed, validated, transformed, deduped, fuzzy-matched for names, and ranked. Streaming parsers, compact payloads, and careful algorithm choices trim this section.

Application Overhead

Heavy object churn, the wrong collections for the job, noisy logging, synchronous waits, and needless copying waste CPU. Favor allocation light patterns and keep the hot path small.

Measurement is Critical

You cannot optimize what you cannot see. Use profilers like VisualVM, JProfiler, or YourKit, plus APM, to find real hotspots under realistic load. Optimize only what measurements justify.

Common Misconceptions

Developers often assume the database is always at fault. Optimization without measurement can make things worse. Tricks that worked for thousands of rows rarely scale to billions.

Database Optimization Strategies

Indexing Strategy

Indexes move the needle the most. Build composite indexes that mirror user queries, for example, last name, first name, and state. Use covering indexes so the engine reads the needed columns straight from the index. Do not over-index because extra indexes slow writes and bloat storage.

Query Optimization

Reshape queries so the planner can choose indexes. Replace broad ORs with UNION where it improves index use. Remove joins by selectively denormalizing hot read paths. Avoid SELECT* and fetch only needed columns. Cap transferred rows with LIMIT or TOP for first page delivery. Use engine hints only when profiling proves a gain.

Connection Pooling

Creating connections is expensive. Use a fast pool such as HikariCP and size it deliberately. A helpful first guess is pool size equals core count times two plus effective spindle count, then refine using production metrics.

Read Replicas

Split reads from writes. Direct search traffic to read replicas and keep the primary focused on writes. Read heavy systems see immediate throughput gains with minimal code changes.

Batch Processing

When scanning many jurisdictions, batch lookups are used. One request carrying ten searches can replace ten separate round-trip searches and cut network overhead dramatically.

Database Caching

Enable query result caching where appropriate and tune it using actual hit rates. Popular names repeat, so cached answers land instantly and reduce load.

Application Level Optimization

Concurrency

Never query fifty states one by one. Use CompletableFuture or virtual threads in Java 21 to issue calls in parallel and then compose results. Total time approaches the slowest upstream, not the sum of all.

Caching Layers

Adopt a three-tier model. L1 is an in-process cache with Caffeine for microsecond access on hot keys. L2 is a distributed cache with Redis, so instances share hits. L3 is an edge cache or CDN for static payloads and precomputed common results. Choose TTLs based on the upstream refresh cadence. For many public datasets, a daily or weekly refresh is adequate.

Pagination and Lazy Loading

Return the first page immediately and stream further pages. Perceived speed rises even if total work stays the same.

Object Reuse

Pool expensive objects. You already have pool connections and threads. Extend that mindset to parsers, mappers, and buffers to cut allocation churn and GC pressure.

Garbage Collection Tuning

Favor low-latency collectors like G1GC or ZGC for interactive search. Tune heap size and GC threads guided by profiling under realistic load. The goal is brief, predictable pauses.

Implementing these tactics at scale changed outcomes. Platforms like Claim Notify issue parallel queries across more than fifty state data sources, serve millions of lookups from layered caches, and hold response times under three seconds even across billions of records. This demonstrates that Java can feel consumer-grade while wrangling messy, massive datasets.

Asynchronous Processing

Move expensive enrichment to background workers via Kafka or RabbitMQ. Deliver fast first page results and notify users when deep scans complete.

Resource Hygiene

Close streams and sockets with try-with-resources. Track open file descriptors and database handles. Small leaks become production fires under real traffic.

Real World Performance Results

Before Optimization

A single state search took thirty to forty-five seconds. A full multi-state pass would have taken more than twenty-five minutes. Concurrency collapsed near a dozen users before timeouts. Database CPU pegged in the high eighties to mid-nineties. The JVM threw intermittent out-of-memory errors. There was no caching.

After Optimization

A single state search takes between half a second and one second. A comprehensive fifty-state search returns in two to three seconds. The system handles more than one thousand concurrent users without degradation. Database CPU averages in the twenties to forties. Memory is stable. Cache hit rate reaches seventy-five to eighty percent, which slashes query volume.

Performance Metrics That Matter

P50 latency sits near 1.2 seconds, P95 near 2.8, and P99 near 4.5. Throughput reaches roughly five hundred searches per second with an error rate under 0.1 percent. Infrastructure cost drops about sixty percent, helped by a seventy percent reduction in database queries due to caching.

Monitoring and Continuous Improvement

What to Track

Watch latency percentiles, slow query logs, cache hit and miss patterns, heap usage, GC pauses, thread counts, upstream API times, and timeout or error rates. Use APM tools, query analyzers, load testing with JMeter or Gatling, and alerts that trigger on percentile shifts rather than averages. Profile production traffic regularly, A/B test changes, and keep current with Java runtime improvements.

Performance as a Feature

Measure first and cut second. Databases deliver the biggest early wins through indexing, query shaping, pooling, replicas, and batching. Parallelism collapses wall time from the sum to the max. Caching multiplies speed and reduces cost. Continuous monitoring preserves the gains. Platforms like ClaimNotify show that disciplined, data-guided engineering lets Java deliver consumer-grade speed on top of complex public data. Start by baselining your system, fix the loudest bottleneck, and repeat. Share the tuning tactics and surprises you discover so the community can push the craft forward.

Best Java Libraries for XML Data Processing

2025-03-08T22:57:00.005+05:30

Source

Users continue to rely on XML (eXtensible Markup Language) for data exchange and storage across Java applications because it delivers adaptable structures for complex information representation. XML demonstrates wide industry application because of its platform-independent format that produces human-readable content.

However, the processing of XML data requires careful management due to its difficulties including efficient parsing of big files and database storage consistency with data integrity and fast data transformation.

Top Java Libraries for XML Processing

Source

The selection of a library depends on two factors: the level of task complexity and the set criteria for system performance.

The following list contains the main Java libraries that facilitate XML processing:

JAXB (Java Architecture for XML Binding)

The conversion of Java objects to XML and back to Java objects functions smoothly through this library. Programmers maintain control over Java classes through an automatic XML serializing feature of the library.

DOM & SAX Parsers

The two fundamental XML parser components are DOM (Document Object Model) and SAX (Simple API for XML) which process XML document structures swiftly. DOM treats the complete XML document as an in-memory tree structure that works best for files with a smaller size.

SAX executes as an event-driven XML parser that sequentially processes data so large XML files use less memory space.

StAX (Streaming API for XML)

The StAX API functions as a pull-parsing mechanism for achieving both efficiency and memory-friendly XML file handling. Through its stream-based XML processing model, StAX functions as an optimal solution when users have extensive XML information that needs efficient handling while minimizing memory usage.

dom4j & JDOM

The user-friendly XML data manipulation libraries dom4j and JDOM provide easy interfaces for XML data processing. Through simple API functions developers can handle XML documents with these libraries while they produce document formats which include XPath and XSLT.

These XML libraries simplify XML operation and provide developer-friendly access to standard Java XML APIs for those using an alternative to built-in XML solutions.

XStream

XStream serves users by focusing on XML to Java object conversions and their reverse operations. It makes XML serialization and deserialization of Java objects simple by removing the need for complicated configuration.

Using Java XML Libraries to Prepare Data for SQL Databases

Java libraries serve as fundamental tools to prepare XML data for SQL databases through their capabilities of handling XML content transformation and structure definition to make it usable by relational databases.

How Java Libraries Help Parse and Transform XML

The first step requires XML data parsing through JAXB DOM and SAX libraries to produce either structured Java objects or recognizable usable data formats. Developers can utilize these libraries to retrieve particular XML document elements and their attributes.

Parsed XML data moves through libraries StAX or dom4j to achieve a structure that functions according to the relational model of an SQL database.

Best Practices for Structuring XML for SQL Storage

Here are some key tips:

Flatten Complex XML Structures

A flat structure suits relational databases making it advisable to convert nested XML elements into simple row-column combinations. You should use XML elements as relational table counterparts through a process that employs foreign keys for hierarchical information processing.

Normalize Data

Normalization of database data maintains both consistency of information and protects against repetitive data entry. You should remove repetitive elements in XML data by distributing them across separate related tables to decrease redundant information while securing data consistency.

Use Appropriate Data Types

The conversion of XML-extracted data must identify matching SQL data types between VARCHAR, INTEGER, and DATE. XStream included in Java libraries enables developers to achieve type conversion which ensures optimized SQL table storage.

Handle Large XML Files in Chunks

The processing and storage of big XML documents should be done in smaller less cumbersome data increments. StAX libraries enable the streaming of XML data through their parsing functions while also promoting efficient memory utilization to enhance scalability.

Once XML is processed using these Java libraries, the next step is storing it in a relational database. Here’s a detailed guide on how to insert XML data into SQL tables effectively.

Conclusion

Java provides developers with multiple strong libraries that enable effective XML data handling including JAXB, DOM, SAX, StAX and dom4j, JDOM and XStream. These tools help developers improve the flow of XML data to the database while providing efficient storage capabilities.

Upgrading to Java 21 and Spring Boot 3: A Comprehensive Guide

2025-03-01T18:56:00.000+05:30

The transition from Java 17 to Java 21, paired with an upgrade to Spring Boot 3, is a transformative step for modern application development. This blog post shares the detailed insights, challenges, and solutions from upgrading various services and Lambda functions to these latest versions. We’ll explore the evolution of dependencies, dive into troubleshooting steps, discuss resolutions for common issues, and provide actionable takeaways to help you succeed in your own upgrade journey.

Overview of the Upgrade

The upgrade process entailed moving applications from Java 17 to Java 21 and aligning them with Spring Boot 3. This wasn’t a simple plug-and-play operation—it required careful updates to dependencies, adjustments to configurations, and tweaks to codebases to ensure everything worked harmoniously with the new versions. The process touched multiple components, including core services and AWS Lambda functions, each requiring its own set of changes.

Dependency Evolution

The upgrade unfolded in stages, with dependencies evolving iteratively as issues surfaced and were resolved. Here’s how the key components changed over time:

Java: Initially running on version 17, the leap to Java 21 introduced a "Major version 65" issue, signaling bytecode incompatibility with older tools. This necessitated updates to other dependencies to align with Java 21’s requirements.

Gradle: Starting at version 7.2, we upgraded to 8.1 early in the process to leverage its improved features and compatibility with Java 21. However, this shift triggered initial compile errors, which we addressed as part of broader dependency updates.

Spring Boot: We began with version 2.7.3 but quickly encountered limitations. An intermediate step to 2.7.18 resolved some issues, but JUnit and acceptance test failures persisted. The final move to Spring Boot 3.3.3 was essential to fully support Java 21 and handle the significant shift from javax to jakarta namespaces.

AWS SDK v1: Version 1.12.139 was in use initially, but it proved incompatible with Java 21. We phased it out entirely, relying instead on AWS SDK v2.

AWS SDK v2: Starting at 2.17.162, this remained stable throughout the upgrade, though we later validated its compatibility with the final configuration.

LocalStack: We started with version 1.17.1 for local testing. As issues emerged with Spring Boot 3, we upgraded to 1.20.1 and eventually aligned the LocalStack Docker image to version 3.0.0 for better test reliability.

LocalStack Docker: The initial version, 0.14.0, was outdated for our needs. Upgrading to 3.0.0 ensured compatibility with the updated LocalStack and Spring Boot 3.

Lombok Plugin: Version 6.4.3 caused compile errors with Java 21. Upgrading to 8.10 resolved these issues and ensured smooth integration with the new Java version.

AWS Spring: We began with version 2.4.4, which worked with Spring Boot 2.x. The move to Spring Boot 3 required an update to version 3.1.1 to maintain AWS integration.

Spring Cloud AWS Messaging: Also at 2.4.4 initially, this dependency was ultimately removed as we streamlined our AWS interactions with SDK v2.

Each step in this evolution addressed specific pain points—whether it was compilation failures, test issues, or runtime errors—bringing us closer to a fully functional Java 21 and Spring Boot 3 setup.

Known Issues and Solutions

Throughout the upgrade, several issues emerged that required targeted solutions. Here’s a detailed look at what we encountered and how we resolved them:

1. PortUnreachableException Spamming Logs

Issue: After the Spring Boot upgrade, logs became inundated with errors like:

java.net.PortUnreachableException: recvAddress(..) failed: Connection refused

Cause: This stemmed from a StatsD configuration mismatch introduced by Spring Boot’s updated metrics handling.

Solution: We updated the configuration key from management.metrics.export.statsd.enabled to management.statsd.metrics.export.enabled and explicitly enabled it in the application’s YAML file:

management:

statsd:

metrics:

export:

enabled: true

This adjustment silenced the log spam and restored proper metrics behavior.

2. Container Privileged Mode

Issue: Running containers in privileged mode clashed with Docker’s user namespaces, causing failures during testing.

Solution: We disabled Testcontainers’ Ryuk resource reaper by setting an environment variable:

TESTCONTAINERS_RYUK_DISABLED=true

This workaround allowed our tests to run smoothly without requiring privileged mode adjustments.

3. Gradle Job Dependency

Issue: A task responsible for running the application failed because it implicitly relied on the output of a jar task without declaring a dependency. The error message highlighted this misconfiguration:

Task uses this output of another task without declaring an explicit or implicit dependency.

Solution: We modified the build.gradle file to explicitly declare the dependency:

afterEvaluate {

tasks.named('forkedSpringBootRun') {

dependsOn ':jar'

}

This ensured tasks executed in the correct order, resolving the build failure.

4. Missing AWSCredentials

Issue: After removing AWS SDK v1, we encountered a NoClassDefFoundError: com/amazonaws/auth/AWSCredentials error, indicating a lingering dependency mismatch.

Solution: We updated the LocalStack Docker image to localstack/localstack:3.0.0 and refreshed the Testcontainers dependencies in build.gradle:

testImplementation 'org.testcontainers:localstack'

testImplementation 'org.testcontainers:testcontainers'

This aligned our local testing environment with the updated AWS SDK v2 setup.

5. Acceptance Test Failures

Issue: Acceptance tests failed due to a missing AmazonSQSAsync bean, disrupting validation of AWS SQS interactions.

Solution: We added the spring.cloud.aws.sqs.endpoint property to the configuration and updated the Docker entry point to support Java 21. This restored the bean’s availability and fixed the tests.

public LocalStackContainer create() {

try (LocalStackContainer localstack =

new LocalStackContainer(DockerImageName.parse(IMAGE_NAME))

.withExposedPorts(EXPOSED_PORT)

.withServices(DYNAMODB, SNS, SQS)

.withCopyToContainer(forClasspathResource(INIT_LOCALSTACK_SH, 0775),"/etc/localstack/init/ready.d/init-localstack.sh")

.waitingFor(

Wait.forLogMessage(LOG_MARKER, 1).withStartupTimeout(Duration.ofMinutes(1)))) {

return localstack;

}

Conclusion

Upgrading to Java 21 and Spring Boot 3 is a complex but rewarding endeavor. By navigating challenges like log spam from PortUnreachableException, Gradle task misconfigurations, and AWS SDK transitions, you can modernize your applications for improved performance and maintainability. This guide offers a detailed roadmap to help you avoid common pitfalls and achieve a successful upgrade.

Simplifying Docker Deployment with PM2

2024-03-19T02:55:00.004+05:30

As you know, PM2 is a daemon process manager that allows you to keep applications online. Many times, you may be running your service inside a Docker image. The service can be written in any language, such as Node.js, Java, etc. Below is the shell script that can be used to deploy your service. It can be added and used in your CI/CD pipeline.

AWS - Get quicksight embed url using JavaScript SDK V3

2023-12-31T21:00:00.007+05:30

In the realm of data-driven solutions, AWS QuickSight offers a robust platform for crafting dynamic and insightful dashboards. Embedding these dashboards directly into your applications adds a layer of accessibility and convenience. This guide walks you through the process of obtaining a secure QuickSight embed URL using JavaScript SDK V3, suitable for both Node.js backend and Lambda functions. Before proceeding, ensure your QuickSight dashboard is created and shared with the intended audience.

Prerequisites:

Make sure you've completed the following preliminary steps:

Dashboard Setup:

Create your QuickSight dashboard and Share the dashboard with all users in your AWS account.

Open the published dashboard and choose Share at upper right. Then choose Share dashboard.

Domain Whitelisting:

Whitelist the domain where you plan to embed the QuickSight dashboard

Step 1: IAM Role Creation with Required Policies

To interact with QuickSight, set up an IAM role with specific permissions. Include the following policies in your IAM role: quicksight:RegisterUser and quicksight:GetDashboardEmbedUrl.

Step 2: Assuming IAM Role Using AWS SDK

Assume the IAM role you created using the AWS SDK.

Step 3: Register a User in QuickSight

Before obtaining the embed URL, register a user in QuickSight. Note that this is a one-time process; subsequent calls will result in an error.

This will create a QuickSight user, as shown below:

Step 4: Retrieve Secure QuickSight Dashboard Embed URL

Fetch the secure QuickSight dashboard embed URL using the following code snippet:

Complete Lambda Function Code:

Here is the complete Node Lambda function code, seamlessly integrating all the steps discussed above:

Make sure to add following npm package @aws-sdk/client-sts and @aws-sdk/client-quicksight

Docker - err: exec: "docker-credential-desktop": executable file not found in $PATH, out: ``

2023-06-02T20:39:00.001+05:30

Introduction:

Docker has revolutionized the way we package, distribute, and deploy applications. However, like any other technology, it is not immune to errors and issues. One such error that I encountered recently while working with Docker on my Mac was the "error getting credentials - executable file not found" error. In this blog post, I will share my experience with this error and provide a solution that worked for me.

The Error:

When attempting to build a Docker image or perform a Docker login, I encountered the following error message:

openjdk:17: error getting credentials - err: exec: "docker-credential-desktop": executable file not found in $PATH, out: ``

Error saving credentials: error storing credentials - err: exec: "docker-credential-desktop": executable file not found in $PATH, out: ``

Diagnosis:

The error message suggests that the Docker daemon was unable to locate the "docker-credential-desktop" executable file in the $PATH environment variable. This executable is responsible for retrieving Docker credentials and authentication.

Solution:

After researching the issue, I discovered that the problem was specific to Docker on macOS. The Docker Desktop application on macOS uses a credential helper called "docker-credential-desktop" to handle authentication with Docker registries. To resolve the error, I followed these steps:

1. Open Finder and navigate to the following path: `/Users/[USERNAME]/.docker/`.

2. Look for the file named `config.json` in the `.docker` directory.

3. Delete the `config.json` file.

4. Retry the Docker command that was previously failing (e.g., `docker build`, `docker login`, etc.).

Explanation:

By deleting the `config.json` file, we essentially reset the Docker configuration and remove any potential misconfigurations or conflicts. Docker Desktop will recreate the necessary files and configurations automatically when you run Docker commands again.

Conclusion:

If you encounter the "error getting credentials - executable file not found" error while working with Docker on your macOS machine, deleting the `config.json` file located at `/Users/[USERNAME]/.docker/` can help resolve the issue. Remember to retry the Docker command after deleting the file to confirm that the error is resolved.

Docker is a powerful tool, but occasional errors and challenges are inevitable. Hopefully, this blog post has provided you with a solution to the specific error discussed here, allowing you to continue working with Docker seamlessly. Happy Dockerizing!

React simple rich text editor using draft-js

2023-04-19T20:01:00.004+05:30

This React Simple Rich Text Editor is created using the Draft.js library and includes button controls made with react-icons. It allows users to toggle between different inline styles like block, italic, and underline, as well as block types such as header-one, unordered-list-item, and ordered-list-item. The controls buttons are selected on text click, making it easy for users to format their text.

The component requires two packages to be installed

yarn add draft-js react-icons

Caused by: java.lang.UnsupportedOperationException: PermittedSubclasses requires ASM9

2023-02-23T19:09:00.004+05:30

After attempting to upgrade Spring Boot from version 2.7.3 to version 3.0.2, I encountered this error. I spent a few hours searching on Google to try to figure out the cause of the error. Eventually, I realized that the error was related to the version of Gradle that I was using. At the time, I had been using Gradle version 7.3.3. However, once I updated to Gradle version 8.0.1, the error was successfully resolved.

I also updated distributionUrl in gradle-wrapper.properties as shown below

distributionUrl=https\://services.gradle.org/distributions/gradle-8.0.1-bin.zip

Note - After above changes i removed .idea folder and restarted my intellij

Java thread synchronization

2023-02-03T06:19:00.006+05:30

Do you know what is thread synchronization Java? Have you ever thought about how to use synchronized in Java? let us gain some knowledge about thread synchronization Java & try to find out the answer to what is thread synchronization in Java.

But before we start writing about thread synchronization Java & try to find out how to use synchronized in Java. Let us first try to understand the policy of synchronization from one daily life example.

Assume one daily life scenario.

Suppose in your school, there is one toilet for the gents. Now, at the same time, you & your friend need to access the toilet. In both cases, the matter is an urgent one. So, you are not ready to let him go. Neither of your friends is ready to let you go. As a result, there is a mess in front of the toilet.

So, what you will do in such a case? Or what your friend will do at that time?

So, you called the teacher to solve the situation that arise there. Your teacher will draw a solution & allow anyone to go to the toilet first. And as a teacher is a respected person both of you are ready with the solution. In this case, the teacher helps to solve the conflict.

The same thing happens in thread synchronization Java. When two different parts of the program try to access the same resources then this trouble arises. We will try to know more about it when we discuss what is thread synchronization in Java.

What Is Thread Synchronization in Java:

Java is an important programming language. Java is used in the corporate world as it helps to solve real-life problems very easily. Java is used for game development purposes. These along with an operation some more processes are going on. For implementing that situation, Java programming language used the thread concept. Thread is a special concept of the Java programming language. It helps to execute more operations a t same time.

Synchronization means collaborating two or more processes at the same time. The thread synchronization Java is quite like this. Now, sometimes when two or more processes are using the same resource then there will be a problem. This problem arises when we use thread in Java. Two or more parts of the code want to use the same resources. Then there is a mess at that point.

The main goal of thread synchronization in Java is to remove the problems related to resources. If two or more parts want to use the same resource, then one by one they will execute that. This means one part will use that resource, then it will be removed. After that, another part is going to use the resource & will be removed. This is a very problematic situation. To come out of this situation, we used the 'synchronized' keyword.

Synchronize is like the teacher at your school. It helps to remove the conflicts between two or more parts for using the same recourses. We will find out more about this when we implement the thread synchronized Java. Similarly, when you are stuck at Java coding you can use Java Assignment Help Services from codingzap.

Why Should We Use Thread Synchronization Java:

Now, after knowing about thread synchronization Java, we need to know why we should use it. This is a very important topic. Often, we find out that, the threads that are implemented in the program are not executing the same we want. In those cases, we need to use this method. As there is a problem related to the synchronization.

If we don't use synchronization, then there will be an issue related to the memory space. Also, the flow of the output of the program will not be similar as desired. There will be a thread interface problem if we don't use synchronization at the correct time. When we implement thread synchronization Java, it will be easy to understand.

How To Use Synchronized in Java:

Now, it is time to implement Thread Synchronization Java. Here, first, we need to declare one function that is synchronized. This means, there will be no issue with the synchronization. We have written a for loop there. This will be executed by the threads. Now, we have declared two threads. Using the concept of the thread, we are accessing the synchronized function. In one thread, we are trying to provide the value of 2. And in another thread, we are trying to provide the value of 10.

Now, in the main driver function, we will create an object of the synchronized class. Now using that object, we are trying to make a new object of the thread class. Hence, we have implemented two objects for the threads. Now using the start() function of the thread, we will execute that.

Example:

Let us try to find out the output of the above code. This will help to understand thread synchronization Java.

Output:

Conclusion:

As we saw, thread synchronization Java is a very important topic.

We need to remember what thread synchronization in Java is. Also, we need to understand how to use synchronized in Java.

It is advisable to clear the basis of the Java Programming Language. Also, we need to clear the multithreading in Java programming language. Then the topic is understandable.

Sponsor by: https://codingzap.com/

Java - Progress bar in console

2022-07-09T18:51:00.002+05:30

Output -

Docker - Springboot and mysql image example

2022-04-05T22:06:00.006+05:30

A simple docker example using springboot and database as mysql/mariadb

Create springboot image

Get the completed springboot source code on github for hello-docker image

1. Create docker image

cd hello-docker

docker build --tag hello-docker .

2. Tag the image

docker tag hello-docker madan712/hello-docker:v1.0

Run individual container(s) in a docker network

Since springboot application need to connect to database, both the containers should be present in same docker network.

1. Created docker network

docker network create mynetwork

2. Run database image in docker network

docker run -d --name mysqldb -p 3306:3306 -e MYSQL_ROOT_PASSWORD=pass123 -e MYSQL_DATABASE=mydb --network mynetwork mysql

3. Run springboot application

docker run -d --name hello-docker -p 8080:8080 -e SPRING_DATASOURCE_URL="jdbc:mysql://mysqldb:3306/mydb?useSSL=false" -e SPRING_DATASOURCE_USERNAME=root -e SPRING_DATASOURCE_PASSWORD=pass123 --network mynetwork madan712/hello-docker:v1.0

Run multi-container docker application using docker compose

docker-compose.yaml

Compose command

docker-compose up -d

Please find complete github code - hello-docker

React native swipe gestures handler example

2022-02-09T21:33:00.005+05:30

This is a simple 2048 game demonstrates how to use gestures handler in react native

It is hosted in play store, feel free to install and see the demo

It is using npm react-native-swipe-gestures package to detect swipe. this component can be used handling swipe gestures in up, down, left and right direction.

Here is the complete github code link

https://github.com/madan712/2048

Code snippet

React native draggable and swipeable list

2022-01-30T02:12:00.004+05:30

This is a simple todo app demonstrates how to create a draggable and swipeable list in react native

An open source todo app hosted in google play store. Feel free to download and play with it.

It is using npm react-native-draggable-flatlist and react-native-swipeable-item package

Here is the complete github code link

https://github.com/madan712/simple-todo-app

Code snippet

Why Higher Learning Institution Prefer to Teach Java Than Python

2021-12-24T00:22:00.002+05:30

Python and Java are two of the most widely used programming languages. Due to its computability, Java is typically more efficient than Python. Python's syntax is simpler and more succinct than Java's since it is interpreted. Using less code than Java, it can do the same thing. However, large number of students, programmers, professors in most reputable universities spend much time training java.

Much of Java's efficiency is due to its Just-In-Time (JIT) compiler and its ability to handle concurrency. The JIT compiler is a component of the Java Runtime Environment. Compiling byte-codes into native machine code "just in time" to execute Java applications enhances their performance. The Java Virtual Machine (JVM) directly calls the built code. Compiling does not use a lot of resources since the code does not have to be parsed. This could theoretically make a Java program as quick as a native application.

Another reason making java most popular among students looking for programmingassignment help online is due to its user friendliness especially when doing the coding part. Bugs, errors, and all other issues affecting the code are clearly indicated in the runtime, not like in python. Programmer errors in Python are not discovered until the code is executed. This might lead to operational failures and a longer turnaround time, which is not ideal. Object mutation is impossible in Java, although it is feasible in Python. This leads to the creation of secure software. Fixing bugs is an hectic task, that may make programmers and students look for programming help online and bestwebsites offering programming assignment help.

Python may be more flexible and user-friendly than Java, but Java is still the best "formal" language out there. It is statically typed, has all of the OO implementation bells and whistles, and tends to function in a manner that rewards proper program design. That makes it a great choice for teaching at the college and university levels. Computer Science students find it difficult to spend much time in the laptop while avoiding some best moments as a college student. However, with good programmingassignment service, such as ThePandaPapers, students may now get professional help with all sort of programming tasks, may it be java, sql, or python. They have programming assignment experts

Java JSON Web Tokens example

2021-09-26T00:00:00.007+05:30

What is JSON Web Token?

JSON Web Token (JWT) is an open standard (RFC 7519) that defines a compact and self-contained way for securely transmitting information between parties as a JSON object. For more details, click here.

In this example, User object is encrypted to jwt also validating it and decrypting token to user object again. For complete github source code, click here.

JwtTokenService.java

Client side load balancing using Eureka and Ribbon

2020-06-13T17:11:00.000+05:30

Traditional server side load balancer has some drawbacks. It requires an additional hop from client to load balancer and then load balancer to service. Also there is a burden to run and manage load balancer itself. Client side load balancer is the solution to overcome these problems. In this architecture there is an addition inbuilt load balancer component that resides inside client.

In this example we will see how client side load balancer works with eureka discovery server.

1. When service (discovery client) boots up it registers itself with discovery server. Multiple instances register itself with discovery server. Here spring.application.name is use to identify a particular service

2. Client application will also resister itself to discovery client to find instance for load banacer

3. Now load balancer within client can find the service with the help of service name

Please find complete codes from github repository -

Discovery server code -

https://github.com/madan712/discovery-server

Ribbon service code -

https://github.com/madan712/ribbon-service

Ribbon client code -

https://github.com/madan712/ribbon-client

How to run this example -

Step 1 - Start eureka discovery server, which will run on port 8761

http://localhost:8761/

Step 2 - Start 2 instances of ribbon service on port 4444, 5555. You can do that by passing server.port argument to start the services as shown below

--server.port=2222

Verify 2 service are running in eureka

http://localhost:8761/

Step 3 - Run Ribbon client which will run on default 8080 port

RestTemplate bean is created using @LoadBalanced annotation

Ribbon service is discovered using service name

Output -

On subsequent request u can see response from different instance

Server side load balancing using Eureka and Zuul

2020-06-07T01:22:00.002+05:30

Routing is an important part of a microservice architecture. In real time cloud application, service instances are added/removed dynamically based on requirement and availability in such scenario its very important to manage traffic load. In the following example you will see how to use Zuul API Gateway to enable sever side load balancing of your RESTful Web Services.

Request flow -

1. When service boots up it registers itself with discovery server. Multiple instances register itself with discovery server. Here spring.application.name is use to identify a particular service

2. Zuul gateway also registers itself with discovery server. Remember Zuul gateway is also a discovery client

3. When client sends request to zuul gateway for a particular service, Zuul gateway queries discovery server to fetch available healthy instance of the service and then accordingly send request to that service.

Please check previous example on Discovery Server.

Discovery code -

https://github.com/madan712/discovery-server

Zuul Server

pom.xml

application.properties

ZuulServerApplication.java

Zuul Service

pom.xml

application.properties

ServiceApplication.java

Controller.java

Here is complete source code in Github

https://github.com/madan712/zuul-server

https://github.com/madan712/zuul-service

Output -
1. Our discovery server is running on port 8761
http://localhost:8761/

2. Start Zuul server, by default it will run on port 8080

3. Starting 2 instances on zuul service on port 1111, 2222
Note - you may need to pass server.port argument to start the services as shown below
--server.port=2222

Now hit zuul url
http://localhost:8080/zuul-service

On subsequent request u can see response from different instance

Spring cloud service discovery example

2020-06-03T18:04:00.003+05:30

Real time cloud application consist of a large number of micro services communicating with each other. Service instances are added/removed dynamically based on requirement and availability. Service discovery is the process of one service dynamically discovering the network location (IP address and port) of another service without hard coding their location.

Steps involved in service discovery

1. Service registers location - when service boots up it registers itself with discovery server

2. Client looks for service location - When client needs to hit a particular service first it goes to discovery server for its location

3. Discovery server sends back location - Discovery server sends the active location of the particular service

4. Client request service at location - This is a normal request to the service

5. Service sends response - Service responds to client accordingly

Example -

Started eureka server on default port 8761 and Started 2 instances of Application service on 8081 and 8082

Discovery Server

pom.xml
application.properties
DiscoveryServerApplication.java

Application Service

pom.xml
application.properties
ServiceApplication.java
Controller.java

Client

pom.xml
application.properties
DiscoveryClientApplication.java
Controller.java

Here is complete source code in Github

https://github.com/madan712/discovery-server

https://github.com/madan712/discovery-application-service

https://github.com/madan712/discovery-client

Spring boot ActiveMQ example

2020-05-31T15:47:00.000+05:30

ActiveMQ Setup

Download the latest version of ActiveMQ from below link

https://activemq.apache.org/components/classic/download/

Extract the zip file, go to bin folder and start activemq server using activemq.bat

In my case it is
apache-activemq-5.15.11/bin/win32/activemq.bat

Verify ActiveMQ server is UP and running

http://localhost:8161/

Note - You can change the default port 8161 by updating below file
apache-activemq-5.15.11/conf/jetty.xml

Go to admin page

http://localhost:8161/admin/

Login with default credentials

Username - admin
Password - admin

Note - You can change default credentials by updating below file
apache-activemq-5.15.11/conf/jetty-realm.properties

Here is how our data will flow

Please see the self explanatory code below, in our example server will push a message (Object) to queue ever 2 seconds and client will read the message.

Server

pom.xml
TestJmsServerApplication.java
application.properties
Client

pom.xml
TestJmsClientApplication.java
Receiver.java
application.properties

Download full source code from github

https://github.com/madan712/jms-server.git

https://github.com/madan712/jms-client.git

React with Redux authorization workflow example (react-router-dom v6)

2019-07-28T22:39:00.003+05:30

This a simple React example which demonstrates how to restrict access to routes to authenticated users.

Complete source code can be found in GitHub -
https://github.com/madan712/auth-workflow

Below packages are used in this example -

React router - React Router is used to manage navigation in react application
Redux - Redux is used to manage state of react applications
react-router-dom v6 - React routing library
react-bootstrap - React-Bootstrap is a complete re-implementation of the Bootstrap components using React
react-redux-toastr - Used to show alert messages
Webpack - Webpack is used to create prod ready build which can be used to deployed in production
Babel - Babel is used to convert ECMAScript 2015+ code into a backwards compatible version of JavaScript in current and older browsers or environments

About the example - We have a landing page i.e public page which can be viewed by anyone. As this is a public page, user need not required to go through any sort of authorization

Our private page is a restricted page. If user clicks on private page link, user is taken to login page where user is asked to enter user name and password

If user is a valid user i.e authorized user then only user can see the private page

Steps to run the example -

>git clone https://github.com/madan712/auth-workflow.git

>cd auth-workflow

auth-workflow>npm install

auth-workflow>npm start

Spring Boot + Jasypt example to encrypt database password in property file

2019-06-29T21:32:00.001+05:30

In this example we will see how to encrypted database password in property file (application.properties or application.yml). We will use Jasypt library for this purpose.

Jasypt (Java Simplified Encryption) is a java library which allows the developer to add basic encryption capabilities to his/her projects with minimum effort, and without the need of having deep knowledge on how cryptography works.

To know more about Jasypt, click here. Go to Jasypt website and download the latest version of jasypt client. I am using jasypt-1.9.2-dist.zip. Once downloaded extract the zip file and go to folder /jasypt-1.9.2/bin and execute the below command. Here input is your password or any other text that you want to encrypt and password is the secret key used by Jasypt to encode and decode the input.

encrypt.bat input="dummy_password" password="SECRET_KEY"

To know about encrypting from the command line using Jasypt CLI Tools. click here.

Add below maven dependency in your pom.xml file

<dependency>
<groupId>com.github.ulisesbocchio</groupId>
<artifactId>jasypt-spring-boot-starter</artifactId>
<version>2.1.1</version>
</dependency>

application.yml
Note - the encrypted password in parenthesis with keyword ENC

There are various options by which you can feed the SECRET_KEY to your application

- From java code you can set system property jasypt.encryptor.password as shown below. You can do this in a separate secure JAR file.

System.setProperty("jasypt.encryptor.password", "SECRET_KEY");

- From command line you can pass system properties

$ Java -Djasypt.encryptor.password=SECRET_KEY Application

My Sql + Spring Boot JPA - One to many, many to one example

2019-06-29T17:32:00.003+05:30

This is a simple spring boot JPA (hibernate) example. It will demonstrate how one to many, many to one mapping can be done

Below are the tables created in MySQL

create table department

(

department_id int not null auto_increment,primary key (department_id),

department_name varchar(50) not null

);

create table employee

(

employee_id int not null auto_increment, primary key (employee_id),

employee_name varchar(50) not null,

department_id int not null, foreign key (department_id) references department(department_id)

);

pom.xml

application.yml

Employee.java

Department.java

EmployeeRepository.java

DepartmentRepository.java

Application.java

Java - Export database table to CSV file

2019-06-28T02:12:00.001+05:30

This is a sample springboot application with bare minimum code to export database tables to CSV file

pom.xml

application.yml

Application.java

Python - Export database table to csv file

2019-06-28T01:42:00.000+05:30

Java - Export database tables to an excel file

2019-06-28T00:51:00.000+05:30

This is a sample springboot application with bare minimum code to export database tables to an excel file

pom.xml

application.yml

Application.java