A Day Rooted in Community

The Java Developers’ Conference has always been about people. JDC 2025 showed us that this is still true.

From early morning, the venue was buzzing. Developers were meeting friends and welcoming new people. We saw everyone there: students starting out, professionals, and seniors sharing their knowledge.

Throughout the day, the sessions covered the real challenges we face in software today. We explored what’s new in Modern Java (from version 21 to 25) and how to build resilient systems that don’t crash under pressure. Speakers shared lessons on DevOps and platform engineering, and showed us how to handle legacy code without fear. We even looked at the future of AI and context engineering, while others reminded us of the power of core Java without heavy frameworks. The questions you asked and the discussions in the hallways showed how much everyone wants to learn.

Gratitude to Those Who Made It Possible

An event like JDC 2025 is never the effort of a single individual or a small group.

We are sincerely thankful to our speakers, who prepared and delivered thoughtful sessions with clarity and passion. Their willingness to share knowledge and experience continues to be one of the strongest pillars of the Java community.

Our volunteers played a vital role in ensuring the conference ran smoothly. From managing registrations to coordinating sessions and handling on-ground logistics, their dedication and teamwork were evident throughout the day.

We are also grateful to our sponsor, DSi, for supporting the conference. Their contribution helped us bring this edition of JDC to life and allowed us to take a step forward in the scale and ambition of the event.

Looking Ahead

JDC is more than just a one-day event. It is part of a journey to help the Java community in Bangladesh learn and grow.

JDC 2025 showed us that this community is ready for more. We hope this energy continues. We want to see more of you getting involved not just as attendees, but as speakers, volunteers, and organizers.

Thank You

Finally, a heartfelt thanks to everyone who came to JDC 2025. Your presence and trust are what make this event matter.

We appreciate your support and can’t wait to see you at future JUGBD events.

Regards,

Tanvir Anjum Rifat
Organizer

We are beyond thrilled to share some exciting news—Java User Group Bangladesh has been nominated for the Java in Education Community Award at the 22nd Annual Java Community Process (JCP) Awards! This recognition is a testament to our collective efforts in making Java education more accessible and impactful for aspiring developers in Bangladesh.

At its core, the Java in Education initiative is about empowerment—providing students and educators with the tools, resources, and support needed to build a strong foundation in Java programming. It’s about more than just learning a language; it’s about opening doors to opportunities in software development, innovation, and global collaboration.

This nomination isn’t just for us—it belongs to every student who wrote their first System.out.println(“Hello, World!”);, every mentor who guided a newcomer through the nuances of Java, and every community member who contributed to workshops, coding sessions, and knowledge-sharing events.

We are honored to be part of this global movement in advancing Java education and will continue our mission to inspire, teach, and uplift the next generation of developers in Bangladesh. Let’s keep building, learning, and growing—together!

Registration Opens Soon!
Stay tuned for updates on our official website: jdc.jugbd.org

️ Interested in Speaking?
We’re now accepting session proposals! Share your expertise and ideas by submitting your talk here:
sessionize.com/java-developers-conference-2024

A Special Thanks to SELISE
We sincerely thank SELISE for their generous sponsorship, setting the stage for an exceptional event that promises to inspire and unite the Java community.

Let’s come together to learn, share, and celebrate the power of Java! Stay tuned for more details—this is an event you won’t want to miss!

#JDC2024 #Java #JUGBD

Fast forward a few years, and now I work on projects involving multiple developers, a product owner, a scrum master, an operations team, an infrastructure team, and, of course, millions of users. Importantly, the production environment is mostly inaccessible to us developers. Additionally, customers cannot directly communicate with developers, as that would drive us crazy.

The operations team served as a bridge between these two realms. Their primary task was to investigate issues by examining the system, application logs, and the database if necessary. If they couldn’t find a solution or had insights for improvement, they would then approach developers with the relevant data.

Working in this environment, I began to appreciate the importance of logs. Logs help us trace back through the events in the life of an application or a transaction. With proper analysis, they help derive patterns and even forecast anomalies.

However, I still didn’t know much about distributed tracing (I still know very little). I used to include different identifiers like phone numbers, user IDs, etc., so that our ops team could properly investigate issues for a customer.

But this approach had its problems too. The same customer might have engaged in various interactions with the system, generating multiple streams of logs with their identifier. So pinpointing the exact logs for the issue was still cumbersome. And don’t even start with me about what a nightmare it was when multiple applications were involved. I used to manually add UUIDs in the payloads between service calls and log them.

Eventually, it became evident that my current approach was inadequate. Some of my applications served as middlewares between other applications maintained by different teams. Why would they tolerate my inconvenience?

Then, I discovered Sleuth. It was amazing; adding just one dependency and configuring logging would enable application-wide tracing. Even with multiple microservices in play, there was no need for additional measures to propagate the trace ID among services.

Before Spring Boot 3, whenever I started a project, I always included Spring Cloud Sleuth to enable distributed tracing.

Then came Spring Boot 3, and Sleuth was migrated to Micrometer. In this article, we’ll explore how to achieve Sleuth-like functionality in Spring Boot 3 with Micrometer tracing.

Right now I have a controller and a service with some logs. If I hit the controller endpoint with postman, I get logs like this:

2024-02-23T23:28:18.043+06:00  INFO 14443 --- [rest-api] [nio-8080-exec-2] x.r.t.restapi.web.MessageController   : Received message: Message(header=some header, content=some content)
2024-02-23T23:28:18.046+06:00  INFO 14443 --- [rest-api] [nio-8080-exec-2] x.r.t.r.service.MessageServiceImpl    : Handling message Message(header=some header, content=some content)

It’s clearly discernible that there is no tracing. Now I will add the following dependency:

<dependency>
      <groupId>io.micrometer</groupId>
      <artifactId>micrometer-tracing-bridge-brave</artifactId>
      <scope>compile</scope>
</dependency>

Just hit the same endpoint once again, but still no luck or log!

A bit of internet searching revealed you also need to add actuator to make it work.

It contains an ObservationAutoConfiguration that provides an injectable instance of ObservationRegistry (if it doesn’t already exist), and configures ObservationHandlers for collecting metrics and traces. baeldung.com .

<dependency>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-starter-actuator</artifactId>
     <scope>compile</scope>
</dependency>

Hitting the same endpoint again produces logs like this:

2024-02-24T00:11:06.050+06:00  INFO 18463 --- [rest-api] [nio-8080-exec-1] [65d8dfb96a137925ba56091d26f33e80-ba56091d26f33e80] x.r.t.restapi.web.MessageController   : Received message: Message(header=some header, content=some content)
2024-02-24T00:11:06.053+06:00  INFO 18463 --- [rest-api] [nio-8080-exec-1] [65d8dfb96a137925ba56091d26f33e80-ba56091d26f33e80] x.r.t.r.service.MessageServiceImpl    : Handling message Message(header=some header, content=some content)

See? [65d8dfb96a137925ba56091d26f33e80-ba56091d26f33e80] this part here contains the trace id and span id.

Now let’s see If we can call another service and if traceId gets propagated there.

I have created another service rest-api-2 , which has the necessary controller, service as well as required dependencies.

Now we will use the shiny new rest-client to make an http call from rest-api to rest-api-2.

I have modified the MessageServiceImpl in rest-api to look like this:

@Service
@Slf4j
public class MessageServiceImpl implements MessageService {

 private final RestClient restClient;
 public MessageServiceImpl(@Value("${rest-api-2.url}") String restApi2Url) {
     this.restClient  = RestClient.builder().baseUrl(restApi2Url)
         .defaultHeader("Content-Type", MediaType.APPLICATION_JSON_VALUE).build();

 }

 @Override
 public void handleMessage(Message message) {
     log.info("Handling message {}", message);
     this.restClient.post().uri( "/process-message").body(message).retrieve();

 }

}

Here, In the constructor, I have declared an instance of rest client. Then, in the service I made the call to rest-api-2.

Log for rest-api:

2024-02-24T14:31:13.060+06:00  INFO 29880 --- [rest-api] [nio-8080-exec-5] [65d9a95114390c055da56f5c4e138be3-5da56f5c4e138be3] x.r.t.restapi.web.MessageController   : Received message: Message(header=some header, content=some content)
2024-02-24T14:31:13.061+06:00  INFO 29880 --- [rest-api] [nio-8080-exec-5] [65d9a95114390c055da56f5c4e138be3-5da56f5c4e138be3] x.r.t.r.service.MessageServiceImpl    : Handling message Message(header=some header, content=some content)

Log for rest-api-2:

2024-02-24T14:31:13.072+06:00  INFO 29563 --- [rest-api-2] [nio-8081-exec-7] [65d9a9513ed86cb5ea2477e08166b9d2-ea2477e08166b9d2] x.r.t.r.web.MessageProcessorController   : Received message for processing Message(header=some header, content=some content)
2024-02-24T14:31:13.072+06:00  INFO 29563 --- [rest-api-2] [nio-8081-exec-7] [65d9a9513ed86cb5ea2477e08166b9d2-ea2477e08166b9d2] x.r.t.r.s.MessageProcessorServiceImpl : Processing Message Message(header=some header, content=some content)

We can see that though rest-api-2 has traceId and spanId. But, these doesn’t match! Because it’s starting new trace context for each requests.

This means traceId from first application is not propagating to the second application.

Let’s verify this.

I have stopped the rest-api-2 application, and started listening to the port it was running with a tool called netcat:

Now If it hit the endpoint , I get the following:

We can see, though there supposed to be some header containing traceId, it’s not there. We need to make sure the proper headers with trace context are present in the request.

This is not that tough. We need to use the default restClient builder that spring boot auto-configured for use. Which has necessary knowledge for propagating traceId. We can do this like this:

public MessageServiceImpl(@Value("${rest-api-2.url}") String restApi2Url, RestClient.Builder restClientBuilder) {
     this.restClient  = restClientBuilder.baseUrl(restApi2Url)
         .defaultHeader("Content-Type", MediaType.APPLICATION_JSON_VALUE).build();

 }

We received the default RestClient.Builder through the constructor in the service where we want it to use. Rest of the code is simple. Now if we initiate a request we can see something like this:

Now we have a header called traceparent, and it seems to have the traceId from the log. Now we will stop the netcat and start the rest-api-2 application.

Log from first application:

Log from second application:

And bingo!

We can see the trace id between two applications matches. Though spanId doesn’t match, which is expected.

I think this is a good time to refactor the service. Instead of declaring the rest-client here, we will declare it as a reusable bean in a config class.

Rest client config class looks like this:

@Configuration
public class RestClientConfig {
 @Bean("restApi2Client")
 RestClient restApi2Client(@Value("${rest-api-2.url}") String restApi2Url, RestClient.Builder restClientBuilder) {
     return restClientBuilder.baseUrl(restApi2Url)
         .defaultHeader("Content-Type", MediaType.APPLICATION_JSON_VALUE).build();
 }

}

And refactored MessageServiceImpl class:

@Service
@Slf4j
public class MessageServiceImpl implements MessageService {

 private final RestClient restClient;

 public MessageServiceImpl(@Qualifier("restApi2Client") RestClient restClient) {
     this.restClient = restClient;
 }


 @Override
 public void handleMessage(Message message) {
     log.info("Handling message {}", message);
     this.restClient.post().uri( "/process-message").body(message).retrieve();

 }

}

Cleaner right ?

This is just a basic demo. I plan to write more on how to leverage micrometer for other observability use cases.

Here is the repo for all the codes.

Happy coding!

New software developers often feel a bit put off by the idea of working with old code. It might not seem very interesting compared to creating something brand new. But this view misses the chances to learn and grow that come with understanding and updating old code. This article looks at the good things that can come from working with existing systems.

The Challenge and Chance to Learn

When starting in software development, many people want to make something new. It’s a normal feeling, but it’s good to know there’s much to gain from working with existing code. It might seem like a limitation, but being able to understand old code is a skill that many people need.

Why Look at More Code Than You Make?

In the real world, programmers often read more code than they create. Getting good at understanding old code can help you stand out. Just like a new writer learns from reading books by great authors, understanding old code enables you to become a better programmer. Looking at code, getting what it does, and fixing it up can turn you into an expert.

Developing the Virtue of Code Reading

In programming, reading code isn’t just a job to do; it’s a skill that needs practice. The article “Read Code Like a Ninja” tells us that we often read code more than we write it. This isn’t just something we do without thinking; it’s more like studying a complex subject. By learning how our minds work and finding ways to read code that fits with that, we can get better at it without wasting time. There are tools and practices to make reading code easier, and just like any skill, the more we do it, the better we get. This way of looking at old code makes it more than just a tedious task. It’s a chance to grow and get better at something that’s at the heart of what programmers do.

Here is a must-read article on this subject that would help you learn to acquire code reading skills: 7 Ways to Improve Your Code Reading Skill.

Fixing and Finding Problems in Code

Learning how to fix up code and find issues is a crucial skill. It’s about more than just stopping code from worsening; it’s about improving it over time. Books like “Refactoring” by Martin Fowler can help you learn these skills. They show you how to keep code working well.

Learning Through Side Projects

Along with working on old code, trying outside projects and looking into new technology helps you learn different skills. This way, you’re not just stuck with old code but are also trying out new things. These projects keep you up to date with what’s new in the field.

Conclusion

Being a software developer isn’t just about working on the latest projects. As software grows and gets older, it turns into what’s called “legacy code.” But that’s where your expertise can shine. Rather than shying away from this aspect of the profession, embracing it can lead to a rewarding and fulfilling career. Remember, knowing all parts of software development and constantly learning is critical to doing well in this field. With an open mind and the right help, even tough old code can be a chance to grow and succeed.

Here are some resources that might help you:

• Martin Fowler – Refactoring https://www.goodreads.com/book/show/35135772-refactoring
• Joshua Kerievsky – Refactoring to Patterns: https://www.goodreads.com/book/show/85041.Refactoring_to_Patterns
• Refactoring Catalog: https://refactoring.com/catalog
• Refactoring to Patterns earlier paper: http://www.tarrani.net/RefactoringToPatterns.pdf
• Christian Clausen – Five Lines of Code: https://www.goodreads.com/book/show/55892270-five-lines-of-code
• Chris Birchall – Re-Engineering Legacy Software: https://www.goodreads.com/book/show/24850349-re-engineering-legacy-software
• A refactoring example in 50 easy steps: https://www.lagerweij.com/2011/05/28/code-cleaning-a-refactoring-example-in-50-easy-steps/

Our brain tries to save energy and doesn’t want to learn things that it doesn’t think are important. The trick is to convince your brain that coding is important. The best way to do this is to set a time for learning each day. Even if it’s just 25 minutes, make sure you do it every day for the next few months. Soon, your brain will realize that this is something you do a lot, and it’ll start to make it easier for you to learn.

Here’s what you can do to start learning:

1. Finish the Course: Learn a little bit every day. Don’t just watch the lessons from YouTube or Udemy, but also type out the code yourself. This helps you learn better.

2. Read a Coding Book: Read a whole book about coding and do the coding exercises in it. This will give you more practice.

Once you’ve done these two things, you can start doing your own projects. This could be a small task or a big project, whatever you like. The idea is to think of something you want to make and then try to code it. If you get stuck, don’t worry. You can always look up ideas on Google, StackOverflow, or GitHub.

GitHub is a really good place to learn from. There are thousands of coding projects on there that you can look at. Try reading some of the code on GitHub. You might not understand everything at first, but that’s okay. The more you do it, the more you’ll learn.

Just like a writer needs to read lots of books to become great, a coder needs to read lots of code. That’s why reading code on GitHub is so important.

This might seem like a lot to take in, but don’t worry. If you have any questions, just ask. The more specific your questions are, the better help you can get.

Remember, learning to code takes time and practice, but if you stick with it, you’ll get there. Keep trying, keep asking questions, and keep coding!

On a rainy day, when the pitter-patter of raindrops orchestrates a symphony against the windowpane, I find solace in the realm of coding. I have embarked on countless coding journeys, each accompanied by its own set of challenges and triumphs. Just like the rain that occasionally dances unpredictably, coding too can have its share of unpredictable moments, where hiccups arise, and we must seek remedies to navigate through them.

In the vast landscape of software development, Spring Boot emerges as a beacon of hope, bringing forth a refreshing breeze of simplicity and efficiency. Like the gentle arrival of spring, it offers a renewed sense of enthusiasm, making the development process more enjoyable and manageable. Spring Boot empowers us to focus on crafting remarkable applications, while it handles the tedious and repetitive configuration tasks behind the scenes.

Now, let’s delve into a fascinating aspect of Spring Boot that has proven to be a valuable ally in building resilient and scalable systems — SQS, or Simple Queue Service. SQS, offered by Amazon Web Services (AWS), is a fully managed message queuing service that allows applications to communicate asynchronously by decoupling the sender and receiver. It acts as a reliable intermediary, ensuring messages are safely delivered between components, even when there are fluctuations in demand or potential failures in the system.

Working with spring boot and SQS is not new for me. Few years ago I worked on a spring boot project where I used SQS. Recently, I got the chance to start a green field project. Having witnessed the proven merits of SQS in the past, I eagerly chose to incorporate it into this new endeavor. However, to my surprise, I found myself stumbling upon unforeseen challenges that I couldn’t recall encountering before. Perhaps in my previous project, I joined the team when it had reached a certain level of maturity, and the configurations were already in place, skillfully handled by another team member. This time, however, my expectation of smooth sailing with minimal configuration for basic use cases was met with unexpected roadblocks.

In this write-up I’ll share the challenges I’ve faced and what I did to overcome those challenges.

At first I created a new spring boot project with spring initializer. I’m using spring boot version 2.7.7. As now I have bootstrapped the project now need an SQS instance to test our development. I don’t want to spin up a real sqs instance. To save some bucks, rather I prefer to deploy a local sqs with docker. Here is the docker compose:

version: "3"

services:
  sqs:
    image: roribio16/alpine-sqs
    ports:
      - '9334:9324'
      - '9335:9325'
    volumes:
      - my-datavolume:/sqs-data
volumes:
  my-datavolume:

Just for this demo I picked this roribio16/alpine-sqs image. It is lightweight, and also has an UI. Whereas localstack is a bit heavy.

Now a docker compose up should bring us an sqs up and running.

So here is the Idea. I’ll have a dto Task like this:

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Task {
   private String id;
   private String name;
   private String description;
}

And a controller like this:

@PostMapping("/task")
public void createTask(@RequestBody Task task){
   log.info("Received task {}", task.toString());
   queueService.publishTask(task);
}

So that I can POST tasks in this endpoint and this endpoint will call a method in queueService, that will have the necessary codes to publish the tasks to the sqs.

Later we will create a listener class that will receive the tasks from queue and do some heavy(!!) computation.. Nah, just some logs but should be able to convey the idea.

With spring-cloud-starter-aws-messaging we get QueueMessagingTemplate. It is an abstraction to easily publish/receive messages to queue. It also provides apis to configure various converters.

So, we are going to create a Bean of QueueMessagingTemplate. To construct functional QueuMessagingTemplate we will also need an instance of SqsClient. We will create both of them in a class named SQSConfig.

@Configuration
public class SqsConfig {
 private final int BATCH_SIZE = 10;
 private final String queueEndpoint;

 public SqsConfig(@Value("${queue.endpoint}") String queueEndpoint) {
     this.queueEndpoint = queueEndpoint;
 }

 @Bean
 @Primary
 public AmazonSQSAsync amazonSQSAsync(@Value("${spring.profiles.active}") String profile){
     if(profile.equals("dev")){
         return AmazonSQSAsyncClientBuilder
                 .standard()
                 .withEndpointConfiguration(new AwsClientBuilder.EndpointConfiguration(queueEndpoint,
                         Region.AP_SOUTHEAST_1.id()))
                 .build();
     }
     else{
         return AmazonSQSAsyncClientBuilder
                 .standard()
                 .withRegion(Region.AP_SOUTHEAST_1.id())
                 .build();
     }
 }

 @Bean
 public QueueMessagingTemplate queueMessagingTemplate(AmazonSQSAsync amazonSQSAsync) {
     return new QueueMessagingTemplate(amazonSQSAsync);

 }

As in my dev environment I have my own sqs running at http://127.0.0.1:9334 which is not the usual sqs endpoint that’s why I instantiated with AmazonSQSAsyncClientBuilder mentioning the endpoint for the dev profile.

Now it’s time to create an implementation of the QueueService. We will take queueMessagingTemplate in the constructor and use it’s convertAndSend method to publish a message to our queue.

@Slf4j
@Service
public class QueueServiceImpl implements QueueService {
 private final QueueMessagingTemplate queueMessagingTemplate;
 private final String taskQueue;

 public QueueServiceImpl(QueueMessagingTemplate queueMessagingTemplate,
                         @Value("${queue.task}") String taskQueue) {
     this.queueMessagingTemplate = queueMessagingTemplate;
     this.taskQueue = taskQueue;
 }

 @Override
 public void publishTask(Task task) {

     task.setId(UUID.randomUUID().toString());
     log.info("Publishing task to queue {}", task);

     queueMessagingTemplate.convertAndSend(taskQueue, task);
     
 }
}

Let’s restart the server and hope everything compiles. Then run the following curl:

curl --location 'http://localhost:8080/task' \
--header 'Content-Type: application/json' \
--data '{
 "name":"Task 1",
 "description": "save the world"
}'

Now if we go to http://localhost:9335/ in our browser and click on the tab of our queue we will be able to see the message.

Message will be there unless a consumer receives the message and deletes it.

(For brevity I skipped the part of creating the queue. You can use an utility script or aws cli to do this.)

First Hiccup: Time module

So far, so good. Now I will change the Dto. I want to add an Instant field called arrivedAt. I will populate the field just before publishing to the queue. I have now updated the dto and publishTask method.

@Override
public void publishTask(Task task) {

    task.setId(UUID.randomUUID().toString());
    task.setArrivedAt(Instant.now());
    log.info("Publishing task to queue {}", task);

    queueMessagingTemplate.convertAndSend(taskQueue, task);

}

After restarting the application if we hit the curl again then …boom!

From this error message, I could determine that somewhere it is using ObjectMapper. An old friend of all Java developers and we all know when we use Instant, we have to instantiate ObjectMapper a bit differently. Which is easy. But the question is, how do we configure QueueMessageTemplate to use this custom ObjectMapper.

With some googling and reading the documentation, I found that by default it’s using SimpleMessageConverter. Found the source code here , I’ll be adding my own message converter like this. But before that, I’ll create a bean for ObjectMapper:

@Configuration
public class ObjectMapperConfig {
 @Bean
 ObjectMapper getObjectMapper(){
     return new ObjectMapper().registerModule(new JavaTimeModule());
 }
}

Now I’ll write my own message converter and there I’ll use the object mapper to convert the payload into string before giving the Message object to sqs.

My message converter implements a MessageConveter interface that has two methods fromMessage and toMessage. Right now, I am only publishing message to sqs. So I will add my custom implementation in toMessage method, and for fromMessage I’ll just copy the implementation from SimpleMessageConverter.

public class MyMessageConverter implements MessageConverter {
 private final ObjectMapper objectMapper;

 public MyMessageConverter(ObjectMapper objectMapper) {
     this.objectMapper = objectMapper;
 }

 @Override
 public Object fromMessage(Message<?> message, Class<?> targetClass) {
     return null;
 }

 @Override
 public Message<?> toMessage(Object payload, MessageHeaders headers) {
     if (headers != null) {
         MessageHeaderAccessor accessor = MessageHeaderAccessor.getAccessor(headers, MessageHeaderAccessor.class);
         if (accessor != null && accessor.isMutable()) {
             return MessageBuilder.createMessage(getStringPayload(payload), accessor.getMessageHeaders());
         }
     }

     return MessageBuilder.withPayload(getStringPayload(payload)).copyHeaders(headers).build();
 }

 private String getStringPayload(Object payload){
     try {
         return objectMapper.writeValueAsString(payload);
     } catch (JsonProcessingException e) {
         throw new RuntimeException(e);
     }
 }
}

Here actually, toMessage is also a copy from SimpleMessageConverter, the deviation is in the converting of the payload to string inside MessageBuilder’s withPayload method.

Finally plug in MyMessageConverter with QueueMessagingTemplate:

@Bean
public QueueMessagingTemplate queueMessagingTemplate(AmazonSQSAsync amazonSQSAsync, MyMessageConverter myMessageConverter) {
   QueueMessagingTemplate queueMessagingTemplate = new QueueMessagingTemplate(amazonSQSAsync);
   queueMessagingTemplate.setMessageConverter(myMessageConverter);
   return queueMessagingTemplate;

}

Now if I restart the server and hit the cURL, the error should go away, and in the sqs’s web interface I should be able to see the published message with the new arrivedAt field:

Second Hiccup: Listener Not Receiving Object

So far we managed to publish the message from the controller to the queue. This is a good time to start listening to the queue for messages. So we add a service and annotate a method with @SqsListener:

@Service
@Slf4j
public class TaskProcessorImpl implements TaskProcessor {
 @Override
 @SqsListener(value = "dev-task.std",deletionPolicy = SqsMessageDeletionPolicy.ON_SUCCESS)
 public void process(String task) {
     log.info("Processing task {}", task);
 }
}

This is enough for receiving messages as string payload. If we restart the application we can see the logs like this:

2023-06-28 12:44:21.522  INFO 10804 --- [enerContainer-2] x.r.sqsdemo.service.TaskProcessorImpl : Processing task {"id":"2813920f-589e-44ff-a38a-aeb87fd2b021","name":"Task 1","description":"save the world","arrivedAt":1687934661.470700713}

That means we are able to receive messages. We can now parse the string to object and do whatever we want.

But, can we receive the object in the method annotated with SqsListener?

Probably we can, let’s change the type from String to Task.

@Service
@Slf4j
public class TaskProcessorImpl implements TaskProcessor {
 @Override
 @SqsListener(value = "dev-task.std",deletionPolicy = SqsMessageDeletionPolicy.ALWAYS)
 @MessageMapping
 public void process(Task task) {
     log.info("Processing task {}", task);
 }
}

Now, restart the application and try to publish the message, you’ll see the console is again flooded with errors.
Because, we need to let sqs know how it could convert the receiving strings to object. So we add a bean of QueueMessageHandlerFactory.

@Bean
public QueueMessageHandlerFactory queueMessageHandlerFactory(ObjectMapper objectMapper, 
  AmazonSQSAsync amazonSQSAsync) {
     MappingJackson2MessageConverter messageConverter = new MappingJackson2MessageConverter();
     messageConverter.setObjectMapper(objectMapper);
     messageConverter.setStrictContentTypeMatch(false);

     QueueMessageHandlerFactory factory = new QueueMessageHandlerFactory();
     factory.setAmazonSqs(amazonSQSAsync);

     List<HandlerMethodArgumentResolver> resolvers = List.of(
             new PayloadMethodArgumentResolver(messageConverter,null, false));
     factory.setArgumentResolvers(resolvers);

     return factory;
 }

Next we will also need to annotate the first parameter of the process method as @Payload.

Now, we can receive objects directly from the listener.

Third Hiccup: Sleuth traceId not propagating

This was kind of surprising for me. Because, over the last few years. I never had to handle the propagation of sleuth ids in logs. As we are using sqs with clients or libraries from the spring eco-system, I expected that it would work out of the box.

But it didn’t. To achieve this, I had to read traceId, spanId from current span and add them in the headers before publishing the queue.

And on the listener side I have to start a new span after reading those ids from the message’s header then injecting it into a new trace context.

At first, let’s work on passing the traceId and spanId in the messages we publishing.

In QueueServiceImpl we add the following method:

private Map<String, Object> headers() {
     return Map.of(
             "SleuthTraceId",tracer.currentSpan().context().traceId(),
             "SleuthSpanId", tracer.currentSpan().context().spanId());
 }

Then pass the headers with convertAndSend like this:

queueMessagingTemplate.convertAndSend(taskQueue, task, headers());

Now, we are also going to need to capture the headers in the listener so that we can use them.

This is not hard. Just need to add a new argument which is a Map<String, Object> and annotate the parameter with @Headers annotation.

@Override
@SqsListener(value = "dev-task.std",deletionPolicy = SqsMessageDeletionPolicy.ALWAYS)
@MessageMapping
public void process(@Payload Task task, @Headers Map<String, Object> headers) {
   log.info("Processing task {}", task);
}

If we restart the application, publish a new message and put a debug pointer in the body of process method and try to see what does headers is containing we’ll find something like this:

Did you have the question in your mind that is .class file contains nothing but hexadecimal code? but which code is used for which purpose? if then you are in the right place to go through!

let’s write code for subtract operation, and we will generate bytecode through compile.

public class AddToValue {
  public static void main(String[] args) {
    long maxLong = Long.MAX_VALUE;
    long secondMinimumPositiveLong = 1;
    long secondMaxLong = maxLong - secondMinimumPositiveLong;
    System.out.println(secondMaxLong);
  }
}

This high-level language hides the complexity of how JVM or theoperating system will read this code. Suppose we have declared the max long value, this is a simple instruction to us but how the value of maxLong variable is loaded to the CPU register is not our headache. we have to be relayed on the abstract layer.

although high-level code must be converted to instruction machine code-named as bytecode.

let’s compile this program.

javac AddToValue.java

we will get output like this

cafe babe 0000 0037 001f 0a00 0800 1107
0012 057f ffff ffff ffff ff09 0013 0014
0a00 1500 1607 0017 0700 1801 0006 3c69
6e69 743e 0100 0328 2956 0100 0443 6f64
6501 000f 4c69 6e65 4e75 6d62 6572 5461
626c 6501 0004 6d61 696e 0100 1628 5b4c
6a61 7661 2f6c 616e 672f 5374 7269 6e67
3b29 5601 000a 536f 7572 6365 4669 6c65
0100 0f41 6464 546f 5661 6c75 652e 6a61
7661 0c00 0900 0a01 000e 6a61 7661 2f6c
616e 672f 4c6f 6e67 0700 190c 001a 001b
0700 1c0c 001d 001e 0100 0a41 6464 546f
5661 6c75 6501 0010 6a61 7661 2f6c 616e
672f 4f62 6a65 6374 0100 106a 6176 612f
6c61 6e67 2f53 7973 7465 6d01 0003 6f75
7401 0015 4c6a 6176 612f 696f 2f50 7269
6e74 5374 7265 616d 3b01 0013 6a61 7661
2f69 6f2f 5072 696e 7453 7472 6561 6d01
0007 7072 696e 746c 6e01 0004 284a 2956
0021 0007 0008 0000 0000 0002 0001 0009
000a 0001 000b 0000 001d 0001 0001 0000
0005 2ab7 0001 b100 0000 0100 0c00 0000
0600 0100 0000 0100 0900 0d00 0e00 0100
0b00 0000 3c00 0400 0700 0000 1414 0003
400a 421f 2165 3705 b200 0516 05b6 0006
b100 0000 0100 0c00 0000 1600 0500 0000
0300 0400 0400 0600 0500 0b00 0600 1300
0700 0100 0f00 0000 0200 10

According to The Java Virtual Machine Instruction Set there are 256 possible bytecode instructions. generated bytecode contains instructions among them, we will find out which instruction is used for which bytecode down the line. this instructions set vary x86 to x64 another reason is that JVM tries to use a specific register for an instruction, if the processor does not have this register or is not compatible then used a stack for that operation.

let’s disassemble this class and we will print the instructions from the bytecode.

javap -c AddToValue.class

Compiled from "AddToValue.java"
public class AddToValue {
  public AddToValue();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: return

  public static void main(java.lang.String[]);
    Code:
       0: ldc2_w        #3                  // long 9223372036854775807l
       3: lstore_1
       4: lconst_1
       5: lstore_3
       6: lload_1
       7: lload_3
       8: lsub
       9: lstore        5
      11: getstatic     #5                  // Field java/lang/System.out:Ljava/io/PrintStream;
      14: lload         5
      16: invokevirtual #6                  // Method java/io/PrintStream.println:(J)V
      19: return
}

We will map bytecode with these printed instructions, first, we have to understand some term Permalink

opcode: opcode is operation code, also known as instruction machine code, that specifies the operation to be performed. ex:

operand stack: The operand stack is a 32-bit, used to store value and return once instructions are invoked.

mnemonic: Short description of the instruction ex: istore_1

theorem: the mnemonic form of opcode => mnemonic = opcode

now we will subtract operation instructions

long maxLong = Long.MAX_VALUE;
long secondMinimumPositiveLong = 1;
long secondMaxLong = maxLong - secondMinimumPositiveLong;

for these human-readable instructions, we got 8 opcode instructions

0: ldc2_w        #3                  // long 9223372036854775807l
3: lstore_1
4: lconst_1
5: lstore_3
6: lload_1
7: lload_3
8: lsub
9: lstore        5

opcode instructions corresponding hexadecimal value

this series of hexadecimal codes will exist within this .class file.

Operand Stack Preparation from these instructions:

In summary, we have seen how byte code holds the instruction need to be executed by JVM also mapping is made between Mnemonic and opcode in hexadecimal form.

ref:

1. List of Java bytecode instructions
2. The Java Virtual Machine Instruction Set
3. The Java Virtual Machine

Since you’ve finished learning Spring Core and MVC, and are focusing more on backend development, here are some ideas that involve backend logic and can also incorporate some frontend basic skills:

1. Restful Bookstore: Build a RESTful API for a bookstore using Spring Boot and Spring MVC. It should allow users to add, delete, update, and retrieve books. A book could have attributes like ISBN, title, author, and publication date.
2. Online Voting System: Create a secure system where users can register and vote for different candidates in various categories. This will help you understand how to handle secure user authentication and prevent vote tampering.
3. Fitness Tracker API: This could manage user profiles, track workouts or exercises, calculate calories burned, and provide health and fitness reports. This would help you learn about complex business logic and data handling.
4. Student Management System: This system would allow users to create, update, delete, and view students. Students can have fields like ID, name, course, and age. Implement different roles like students and admin, where admin has more rights.
5. E-Commerce Backend: Create a backend for an e-commerce platform. This should include product management, user management, shopping cart functionality, and order processing. You can use Spring Security for handling user authentication and authorization.
6. Blog Platform: Build a blogging platform where users can create an account, write blogs, read blogs by others, like, comment, and share. This will help you learn about handling complex relationships in databases.
7. Hotel Booking: Develop a backend system where users can view room availability, book a room, view their bookings, and cancel bookings. Implement features like different room types, date ranges for booking, and price calculation.
8. Task Tracker: A task tracker or a to-do list where users can add tasks, mark tasks as completed or incomplete, and delete tasks. This can be a good starting point to understand the basics of CRUD operations in Spring.
9. Social Media: Design a simple version of a social media backend. Users should be able to create posts, follow other users, and see a feed of posts from users they follow.
10. Online Quiz Application: A simple application where users can take quizzes on various topics and get their scores immediately. Admins can add, update, or delete questions.
11. Inventory Management System: Create a system that keeps track of product inventory for a small store. It should allow adding new products, updating product details, and adjusting stock levels.
12. Food Delivery App Backend: Users can see a list of restaurants in their area, view a restaurant’s menu, place an order, and check the status of their order.
13. Forum or Message Board: Users can create threads, post messages in different threads, and reply to other users’ messages.
14. Ride-Sharing App Backend: Simulate a basic ride-sharing app backend. Users can book a ride, see the details of their driver, and pay for the ride.
15. Event Management System: Design an API to create and manage events. Users should be able to create an event, specify its location, date and time, and other users should be able to RSVP, post comments, and rate the event. This can introduce you to concepts like handling date and time and complex business logic.
16. Appointment Scheduler: Design an API for an appointment booking system for a service-based business like a salon or clinic. Users should be able to book, cancel, and reschedule appointments. Employees should be able to view their schedule.
17. Survey System: Build a system where users can create surveys, share them, and collect responses. The system should allow for data aggregation and simple analytics of the responses.
18. Weather Application: Build an application that fetches weather data from an API like OpenWeatherMap and displays it to the user. Users can search for weather by city.
19. Recipe Application: A system where users can add, edit, and delete recipes. Other users can view these recipes, rate them, and comment on them.
20. Job Portal: A system where employers can post job vacancies and job seekers can apply. Include features like user registration, job posting, job applications, and job search.

All these projects involve handling HTTP requests, performing CRUD operations with a database, and implementing business logic – core backend development aspects. You can use Thymeleaf or JSP for a basic frontend, or you can integrate these backends with a simple frontend developed using HTML, CSS, and JavaScript.

Remember, it’s essential to grasp the basics and the underlying concepts, so don’t worry if you’re not able to implement complex features at first. Start small and gradually add more features as you learn. Good luck with your projects!

All credit goes to ChatGPT for coming up with ideas; I just picked a few I find appropriate for you.