DEV Community: javatute673

Monolithic vs Microservice

javatute673 — Sat, 23 Dec 2023 08:06:39 +0000

Monolithic vs. Microservices

Today, let's dive into a topic that stirs up quite the debate in the software development world: Monolithic vs. Microservices Architecture. Think of it as deciding between a one-stop mega mall or a street full of specialized boutiques. Intriguing, right?

Monolithic: The All-in-One Giant

Imagine building a house. A monolithic architecture is like constructing a single, massive structure where every room (or component) is interconnected. It's the traditional way of software development, where everything is under one roof - your database, client-side logic, server-side logic, you name it.

Pros:

Simplicity: Starting off, it's like having everything in one big room. Easy to navigate, right?
Straightforward Deployment: It's like moving into a house that’s ready to go.

Cons:

Scaling Challenges: As your application grows, so does the complexity. Ever tried finding a specific tool in a cluttered garage? Yep, it's like that.
Tougher Updates: Changing one part can affect the whole. It's like renovating your kitchen but accidentally knocking out the power in your bedroom.

Microservices: The Specialized Boutiques

Now, envision a street lined with specialized boutiques, each offering something unique. Microservices break down the software into smaller, independent services. Each service runs its own process and communicates through lightweight mechanisms, often an HTTP resource API.

Pros:

Scalability: You can scale individual components without touching others. It’s like upgrading just the boutique you want.
Flexibility in Technology: Each service can use a tech stack that best fits its purpose. It's like each boutique choosing its own decor and style.

Cons:

Complex Communication: These services need to talk to each other, and sometimes, the conversation gets complicated.
Deployment Complexity: It's like managing multiple shops at once, each with its own opening hours and maintenance needs.

Which One to Choose?

It really depends on your project's size, team, and scalability needs. If you're just starting out or have a small, closely-knit team, a monolithic approach might be your best bet. But if you're looking at handling large-scale applications, especially in the cloud, microservices offer flexibility and scalability that's hard to beat.

Wrapping Up

Choosing between monolithic and microservices is like choosing between a Swiss Army knife and a tool belt. Each has its place, and the right choice depends on the task at hand. The key is understanding your needs and striking a balance between simplicity and flexibility.

Got any experiences or thoughts to share on this topic? Drop them in the comments below – let's keep the conversation going!

See a depth tutorial.

How to Configure a Standard and FIFO SQS Queue in AWS

javatute673 — Mon, 18 Dec 2023 16:26:48 +0000

In this post we will see How to Configure a Standard and FIFO SQS Queue in AWS. Configuring Amazon Simple Queue Service (SQS) involves setting up either a standard queue or a FIFO (First-In-First-Out) queue, depending on your application's requirements. Here's a step-by-step guide for configuring both types of queues:

Configuring a Standard SQS Queue

Standard queues offer maximum throughput, best-effort ordering, and at-least-once delivery.

Sign in to AWS Management Console and open the Amazon SQS console at https://console.aws.amazon.com/sqs/.
Create a New Queue:
- Click on “Create Queue”.
- Select “Standard Queue”.
- Enter the Queue Name.
Configure Queue Settings (Optional):
- Set parameters such as Delay Seconds, Maximum Message Size, Message Retention Period, etc., according to your needs.
- For a standard queue, ordering is not guaranteed, and each message is delivered at least once.
Create Queue:
- Click the “Create Queue” button at the bottom of the page. Your standard queue is now set up and ready to use.

Configuring a FIFO SQS Queue

FIFO queues ensure the order in which messages are sent and received is strictly preserved and a message is delivered once and remains available until a consumer processes and deletes it.

Sign in to AWS Management Console and open the Amazon SQS console at https://console.aws.amazon.com/sqs/.
Create a New Queue:
- Click on “Create Queue”.
- Select “FIFO Queue”.
- Enter the Queue Name. Note that FIFO queue names must end with the .fifo suffix.
Configure Queue Settings:
- Set parameters such as Message Deduplication ID, Message Group ID, Maximum Message Size, Message Retention Period, etc.
- FIFO queues also offer features like Content-Based Deduplication.
Create Queue:
- Click the “Create Queue” button at the bottom of the page. Your FIFO queue is now set up and ready to use.

Additional Configuration

Access Policies: Configure access policies to control which users or services can send messages to or receive messages from the queue.
Dead-Letter Queues: Optionally, configure a Dead-Letter Queue (DLQ) to collect messages that can't be processed successfully.
Monitoring: Set up CloudWatch monitoring to track metrics like the number of messages sent, delivered, delayed, etc.

Conclusion

Use Standard Queues when you require high throughput and at-least-once delivery without the necessity of message ordering.
Use FIFO Queues when the order of operations and events is critical, or where duplicates cannot be tolerated.

Remember that SQS is a managed service, so much of the heavy lifting is done by AWS, allowing you to focus more on how your application interacts with the queue rather than on the underlying infrastructure and maintenance.

How to use @Lazy annotation in case of Circular Dependency

javatute673 — Mon, 18 Dec 2023 15:45:42 +0000

Using the @Lazy annotation in Spring is a common technique to resolve circular dependencies. Circular dependencies occur when two beans are dependent on each other, leading to a situation where neither bean can be instantiated without the other already existing.

To understand how @Lazy helps, let's first look at what a circular dependency might look like and then how to resolve it with @Lazy.

Circular Dependency Example

Suppose you have two classes, ClassA and ClassB, and they depend on each other.

@Component
public class ClassA {
    private final ClassB classB;

    @Autowired
    public ClassA(ClassB classB) {
        this.classB = classB;
    }
}

@Component
public class ClassB {
    private final ClassA classA;

    @Autowired
    public ClassB(ClassA classA) {
        this.classA = classA;
    }
}

In this scenario, Spring cannot instantiate ClassA without first instantiating ClassB and vice versa, leading to a circular dependency problem.

Resolving with `@Lazy`

You can resolve this by using the @Lazy annotation. @Lazy defers the initialization of a bean until it is actually needed. This can break the circular dependency as one of the beans will not be fully initialized (i.e., its dependencies won't be injected) until it's first used.

@Component
public class ClassA {
    private final ClassB classB;

    @Autowired
    public ClassA(@Lazy ClassB classB) {
        this.classB = classB;
    }
}

@Component
public class ClassB {
    private final ClassA classA;

    @Autowired
    public ClassB(ClassA classA) {
        this.classA = classA;
    }
}

In this modified example, ClassA's dependency on ClassB is marked as @Lazy. When Spring creates an instance of ClassA, it injects a lazy proxy for ClassB instead of an actual instance of ClassB. The actual ClassB instance is not created until a method on the ClassB proxy is called. This delay breaks the circular dependency chain and allows Spring to successfully create both beans.

Things to Note

Design Smell: Circular dependencies often indicate a potential flaw in the design of your application. It's generally a good idea to revisit your design and consider refactoring to eliminate circular dependencies altogether.
Proxy Behavior: With @Lazy, Spring creates a proxy to inject as the dependency. This means that the actual bean will be created when the proxy is first accessed. Be aware of this lazy behavior as it might have implications for your application logic.
Alternative Solutions: Other than using @Lazy, you can also resolve circular dependencies by using setter injection or method injection, which allows one of the beans to be constructed without needing the other to be fully initialized.

Using @Lazy is a quick workaround for circular dependencies, but it's important to consider whether a redesign of the application's components and their relationships might be a more sustainable solution.

How does String compareTo() method work in Java

javatute673 — Sun, 10 Dec 2023 05:47:32 +0000

https://javatute.com/core-java/how-does-string-compareto-method-work-in-java/

CollectionUtils isEqualCollection() Example in Java

javatute673 — Sun, 10 Dec 2023 05:35:57 +0000

https://javatute.com/collection/collectionutils-isequalcollection-example-in-java/

CollectionUtils intersection() Example in Java

javatute673 — Sun, 10 Dec 2023 05:30:26 +0000

https://javatute.com/collection/collectionutils-intersection-example-in-java/

CollectionUtils union() Example in Java

javatute673 — Sun, 10 Dec 2023 05:23:57 +0000

https://javatute.com/collection/collectionutils-union-example-in-java/

What is Hibernate

javatute673 — Sun, 10 Dec 2023 05:18:23 +0000

https://javatute.com/hibernate/what-is-hibernate/

Java.lang.IllegalStateException Ambiguous mapping Cannot map Controller method

javatute673 — Sun, 10 Dec 2023 05:11:18 +0000

https://javatute.com/spring-boot/java-lang-illegalstateexception-ambiguous-mapping-cannot-map-controller-method/

How to upload CSV file to oracle database using Spring Batch

javatute673 — Sat, 09 Dec 2023 01:58:55 +0000

https://javatute.com/spring-batch/how-to-upload-csv-file-to-oracle-database-using-spring-batch/

How to write nested loop using Java 8 Stream

javatute673 — Wed, 06 Dec 2023 17:38:47 +0000

Consider we have two lists List and List. The List of Subject is defined in Student class.

or consider we have below code that we want to convert into Java 8.

List<String> list = new ArrayList();
for(int i = 0; i < 10; i++) {
    for(int j = 0; j < 10; j++) {
        if(dataMap[i][j] == 1)
            list.add(new Data(i,j));
    }
}

We want to convert above code into Java 8.

https://javatute.com/core-java/how-to-filter-data-from-nested-list-using-stream-java-8/

Different between ls and pwd command

javatute673 — Wed, 06 Dec 2023 15:53:05 +0000

https://javatute.com/linux/different-between-ls-and-pwd-command/