DEV Community: TheCodeAlchemist

Introducing Archify: From Architecture Idea to Spring Boot Code

TheCodeAlchemist — Sat, 07 Mar 2026 14:26:19 +0000

https://archify-brown.vercel.app/

Every backend developer has experienced this moment.

You start a new project. You already know the architecture in your head. Maybe it is a simple REST service with a database. Maybe two services communicating with each other. But before you can work on real logic, you spend time doing the same setup again.

Create the project.
Add dependencies.
Create entities.
Create repositories.
Create services.
Create controllers.
Wire everything together.

None of this is hard. But it is repetitive.
That is why I started building Archify.

Archify is a tool that turns an architecture idea into a ready to run Spring Boot project.
Instead of manually creating boilerplate, you define the architecture and Archify generates the code.

The Problem

Modern backend development is heavily architecture driven. When starting a project we already know the basic structure.
For example:

A REST service
A PostgreSQL database
A few entities
CRUD APIs Maybe multiple services communicating with each other But tools today only solve part of the problem.

Spring Initializr helps you create a basic project skeleton. It adds dependencies and basic configuration. But it does not generate actual application structure like entities, repositories, or controllers.
Other tools often require complex configuration or opinionated frameworks.

What developers often want is something simpler.

Define architecture.
Generate working code.

The Idea Behind Archify

Archify takes a different approach.
Instead of starting from a project template, you start from an architecture recipe.

For example:

REST service with PostgreSQL.
Or two services communicating via REST.
Once the recipe is selected, you define the domain model. Example:

User
  name: String
  email: String

Archify then generates a complete Spring Boot service with:

Entity
Repository
Service layer
REST controller
Database configuration
Maven build setup

The generated project can be started immediately.

./mvnw spring-boot:run

Architecture as YAML

One feature I wanted to support early was a simple way to share architectures.
Instead of describing architecture in text, Archify lets you export it as YAML.

Example:

recipe: rest-postgres

serviceName: user-service

entities:
  - name: User
    fields:
      - name: name
        type: String
      - name: email
        type: String

This YAML becomes a shareable architecture blueprint.
You can send it to a teammate.
Store it in documentation.
Use it in examples.
Anyone can paste the YAML into Archify and generate the same project.

Visual Architecture Preview

Another goal was to make architecture visible.
When selecting a recipe, Archify shows a simple diagram representing the architecture. For example a service connected to a database or two services communicating with each other.
The preview updates as the configuration changes. This helps developers understand what they are generating before any code is created.

Current Scope

Archify is currently focused on common backend patterns such as:

REST service with H2
REST service with PostgreSQL
Two services communicating through REST The goal is not to cover every possible architecture but to make common setups quick and easy.

Why I Built It

The idea came from repeated friction when starting new backend services.
Even experienced developers spend time creating the same scaffolding again and again. That time could be better spent building real features.

Archify tries to remove that friction.

Describe the architecture.
Generate the service.
Start building.

What’s Next

The next steps for Archify include:

More architecture recipes
Sharing architecture blueprints
Better visualization of service interactions The long term vision is to make architecture definition the starting point of backend development.

Try It

Archify is open source and available on GitHub.
If you build Spring Boot services regularly, I would love your feedback.
The project is still early, but the goal is simple.
Make it easier to turn architecture ideas into working backend code.

Java to LLMs: Exploring the LLMs Fundamentals

TheCodeAlchemist — Tue, 25 Feb 2025 14:05:59 +0000

AI/ML - YouTube

youtube.com

As a long-time Java developer, I’ve always enjoyed the world of programming. Recently, I found myself increasingly curious about LLMs. It has really become impossible to ignore advances in AI space.

Here I’m sharing my personal journey as I started exploring Large Language Models (LLMs).

If you’re a developer like me, confused with buzz words but eager to understand how modern language models work without diving into heavy hands-on coding right away, this might resonate with you.

Part 1: Diving into AI, ML, and Data Fundamentals

I started by revisiting some core concepts.

What is AI?
Coming from a Java background, I was used to writing explicit instructions in code. AI, however, is about creating systems that learn from data rather than following hard-coded rules.
Machine Learning & Deep Learning
ML intrigued me because it’s all about algorithms that improve over time. I learned that while traditional programming relies on clear logic, ML uses statistical methods to find patterns. Deep Learning took it a step further by mimicking the human brain with neural networks.
Understanding NLP
Natural Language Processing (NLP) was a particularly interesting area. NLP enables machines to understand and generate human language, a huge leap from the type-safe code I’m used to in Java.
Models and Data
I learned that an ML model is essentially a function that transforms input into output by learning from data. A key takeaway was the difference between labeled and unlabeled data. While labeled data comes with predefined answers (like data for classification tasks), unlabeled data is used for self-supervised learning. This concept was a refreshing contrast to the deterministic behavior of traditional Java programs.

Part 2: Tokens, Embeddings, and Transformers

Once I had the fundamentals in place, I began exploring the inner workings of language models — a natural progression given my newfound interest in NLP.

Tokens and Embeddings
I discovered that before any text can be processed by a machine, it must be broken down into small units called tokens. Think of it as parsing a sentence in Java — each token is like a word or subword, a manageable piece of data. These tokens are then transformed into embeddings, which are numerical representations in a high-dimensional space. In simpler terms, embeddings capture the essence or meaning of a word, allowing the model to understand relationships between words — much like how data structures in Java can represent complex relationships in code.
Transformers and Attention
The next major breakthrough was understanding transformers. Unlike older models that processed text sequentially, transformers look at an entire sentence at once, using something called the attention mechanism. This allows the model to weigh the importance of each word relative to others, ensuring context is preserved.
A High-Level Look at Consuming LLMs via APIs
Finally, I learned that you don’t always need to build these models from scratch. Many companies now offer powerful LLMs through APIs. As a developer, this means you can integrate cutting-edge AI capabilities into your projects without dealing with the heavy lifting of training and maintaining the models yourself. It’s a bit like using a trusted Java library — someone else has done the hard work, and you just plug it into your application.

I’m excited about where this exploration will lead next, especially as I start experimenting with more hands-on approaches and practical applications.

Stay tuned for more updates!

If you’re curious about these topics or have insights from your own experiences, I’d love to hear from you.

Happy coding and exploring!

Spring Security For Beginners — Part 2

TheCodeAlchemist — Mon, 30 Sep 2024 11:52:05 +0000

How to secure a Spring Boot REST API with HTTP Basic Authentication

TL;DR

HTTP Basic is one of the simplest authentication mechanisms available. It’s also likely the first one people learn and try when getting started with Spring Security. This method is easier to understand because most of us are already familiar with username/password-based authentication.

In this article, we will explore how to implement it.

Where do we start and what do we need?

In projects like this, we need at least two key components:

A User Store
An Authentication Mechanism, i.e., a way to compare and validate user credentials with what we already have in our system.

Let’s break down the different components we’ll need and how we plan to implement them:

User Store
A user store is essentially an entity where we store user information, such as credentials. This could be an RDBMS, NoSQL database, or any third-party solution. In our case, we’ll use our own MySQL database, which will have a Users table.
UserService and UserController
The UserController will have a registerUser endpoint, which users will call to register themselves.

UserController will call UserService.
UserService will interact with UserRepository (a simple Spring Data repository) to insert new users or fetch existing user details from the MySQL database.

3. PasswordEncoder
UserService will use a PasswordEncoder bean to encode passwords before creating a new user, ensuring that passwords are stored in a hashed form rather than as plain text in the database.

This encoder will also be used by Spring Security during authentication, where the framework will match the incoming raw password with the hashed password stored in the database.

4. UserDetailsService
Since we can have various types of user stores, how does Spring know where to find and load a user? The UserDetailsService interface defines a contract for this purpose. If Spring finds an implementation of this service, it will be used to load the user during the authentication flow.

5. UserDetails
Each product or project may represent users differently. To maintain consistency, Spring Security requires an instance of UserDetails, which represents the principal (the user being authenticated).

6. SecurityFilterChain
This is a bean that we’ll define to configure the security settings in our project.

7. A Private Endpoint
We’ll implement a simple controller that will serve as a private endpoint, accessible only to authenticated users.

High Level Flow

Here’s the high-level flow of our demo app:

The user accesses the public registration endpoint to register.
The user provides a username, password, and email in the POST request.
Since this is a public endpoint, Spring Security will not authenticate the request and will pass it on to the UserController.
UserController calls UserService.
UserService maps the incoming request to a JPA entity, uses the PasswordEncoder to hash the password, and then calls UserRepository.
UserRepository.save(..) stores the user in the database.
The user then accesses a private endpoint by passing their username and password through Postman or any other tool.
The user sets the authentication type to Basic Auth.
Spring Security looks for an implementation of UserDetailsService and calls its loadUserByUsername() method.
The UserDetailsService implementation fetches the user from the database and creates an instance of UserDetails, representing the authenticated user.
Spring Security automatically compares the raw password (entered by the user) with the hashed password (retrieved from the database).
If the passwords match, the user is authenticated, and a 200 OK response is returned.
If they do not match, a 401 Unauthorized error is returned to the client.

Implemetation

Now that we understand the building blocks, the implementation will be easy to follow. You can find it here — https://github.com/therealdumbprogrammer/spring-security-httpbasic-auth/tree/master

Conclusion

For more details, please check out the YouTube tutorial linked above.
If you enjoyed the content, don’t forget to like and share!

Happy coding!

Spring Security For Beginners — Part 1

TheCodeAlchemist — Tue, 10 Sep 2024 14:53:48 +0000

TL;DR

If you’re like me— struggling with Spring Security — how to start or where to start then this is the right place for you.

I’ve been learning and experimenting with Spring Security and I will be sharing my learnings in a step-by-step manner with all of you who are in the same boat.

In this post, we’ll start with the first step i.e. the Spring Security architecture on a high level.

I’ll walk you through the architecture of Spring Security, breaking down its core components like the Security Filter Chain, AuthenticationManager, ProviderManager, and more. This will give you a strong conceptual foundation to understand how Spring Security works under the hood.

Filters

Filters are an essential part of any Java-based web application.

In a typical web app, filters handle tasks such as logging, authentication, encoding, and more. The request moves through each filter in sequence, and on the way back, it goes through them again(but in reverse order).

The role of any filter is to intercept the incoming request, optionally do some operation, pass it to the next filter in the chain.

Spring Security

Let’s break down the architecture and understand the key components.

1. Security Filter Chain

At the core of Spring Security lies its SecurityFilterChain. This is a specialized filter chain(has a series of security related filters) that handles all the security logic in your application.

When a request hits your application, it enters the SecurityFilterChain and passes through a series of filters designed to handle various security aspects like:

Authentication
Authorization
Session management
Exception handling

Here’s how it works:

Inbound Requests: When a request is received, it passes through multiple filters that perform tasks such as checking if the user is authenticated, authorizing access to resources, and managing sessions.
Security Filters: Some of the key filters include UsernamePasswordAuthenticationFilter (handles authentication via username and password), BasicAuthenticationFilter (for HTTP Basic authentication), and ExceptionTranslationFilter (handles security-related exceptions).
Outbound Responses: Once the request is processed and a response is generated, it travels back through the filters, ensuring that the response is secure before it reaches the client.

2. AuthenticationManager and ProviderManager

Once a request reaches the Security Filter Chain, it is passed to the AuthenticationManager. The AuthenticationManager is responsible for managing the authentication process, but it doesn’t directly authenticate the user. Instead, it delegates that task to ProviderManager.

The ProviderManager is a collection of AuthenticationProviders, each responsible for authenticating users through different methods. For instance, one provider might handle username-password authentication, while another could handle OAuth tokens.

Here’s how the authentication flow works:

ProviderManager checks each provider to see if it can handle the current authentication method.
Once the right provider is found, it processes the request and determines if the user is authenticated.
If authentication is successful, the user is granted access; if not, an error is thrown.

3. UserDetailsService and PasswordEncoder

These two components are usually used with username/password based authentication mechanism but good to cover here.

UserDetailsService: This defines an interface contract which has a key method to find/load a user by username otherwise Spring Security has no idea how to load a user and from where. We provide an implementation of this method in our application through which the service loads user details (such as username, password, and roles) from a data source, usually a database which is used for user/client authentication.
PasswordEncoder: Spring Security never stores plain-text passwords. Instead, it uses a PasswordEncoder to hash passwords when they are saved and to validate them during login attempts.

4.SecurityContextHolder and Authentication

Once authentication is successful, the user’s details are stored in the SecurityContextHolder. This is a global object that holds security-related information for the current session(following the ThreadLocal model), specifically the Authentication object.

The Authentication object contains:

Principal: This usually represents the authenticated user.
Credentials: Typically, this holds sensitive data like the password. Once authentication is complete, the credentials are cleared.
Authorities: These are the roles or permissions granted to the user, used for authorization purposes.

By storing this information in the SecurityContextHolder, Spring Security ensures that the user’s identity and roles are available throughout the application, allowing it to make authorization decisions as needed.

Summary

Here’s a high-level summary of how a request is processed in a Spring Security-enabled application:

Request hits the SecurityFilterChain: Filters handle various security tasks.
AuthenticationManager delegates to ProviderManager: Authentication providers are consulted to authenticate the user.
UserDetailsService and PasswordEncoder(optional): These are used to retrieve user information and verify credentials.
SecurityContextHolder stores authentication details: The user’s authentication state is stored and available for future security checks.

This architecture ensures that all aspects of security — authentication, authorization, session management — are handled efficiently and in a modular way. You can add or customize filters, implement different authentication providers, and modify how user details are managed, all without breaking the security flow.

Conclusion

Spring Security’s architecture is powerful yet flexible, allowing you to secure web applications with ease. By understanding the core components like the SecurityFilterChain, AuthenticationManager, and ProviderManager, you’ll be better equipped to configure and customize your security needs.

In future posts, I’ll dive deeper into these individual components, showing how they can be customized and extended to fit different application requirements.

Until then, keep experimenting, and don’t forget — security is not optional, it’s essential!

Happy coding!

Making Spring Transactions Transparent with Detailed Logging

TheCodeAlchemist — Wed, 05 Jun 2024 14:42:39 +0000

TL;DR

While working on my latest video on Transactions, I found a very useful logging configuration. By enable/configuring these log levels, you can gain valuable insights into your application’s transaction flow.

This makes Spring Boot to display detailed information related to Spring/JPA Transactions wherein you can see Transactions being created, joined, committed, and rolled back.

Configuring log levels

Here’s a quick look at how you can set up detailed logging in your Spring Boot application:

Add these configurations to your application.yml file

Note — for application.properties just change the format of keys and corresponding values.

spring:
  datasource:
    username: root
    password: mysql@123!
    url: jdbc:mysql://localhost:3306/hibdemo
  jpa:
    show-sql: true
    hibernate:
      ddl-auto: create
logging:
  level:
    org.springframework.orm.jpa.JpaTransactionManager: debug

Notice the last section where we’re setting the logging level.

This setting will provide detailed logs that include when transactions are created, committed, and rolled back. This makes it easier to follow the flow and understand what’s happening under the hood.

Here’s how it would look like when you run the application:

If you’re interested in a more in-depth explanation, including practical examples and best practices, check out my detailed YouTube video on Spring Transactions. In the video, I cover everything you need to know about managing transactions in Spring Boot, from basic concepts to advanced settings.

I hope this post helps you get a better grasp of Spring transactions and logging. If you have any questions or need further clarification, feel free to leave a comment below or reach out on social media.

Happy coding!

Java on Azure Part 1 — Developing a CRUD application with Spring Boot & Azure MySQL

TheCodeAlchemist — Tue, 14 Nov 2023 16:08:02 +0000

TL;DR

A) How do we develop a Spring Boot Application?

Developing a simple CRUD application is quite easy, isn’t it!

We start with Spring Initializer, include required dependencies e.g. Spring JDBC, Spring Data, or Spring JPA. And then we use Crud or Jpa Repositories to implement CRUD operations.

In trivial cases, we don’t need to write any code at all as Spring Data repositories can generate required code at runtime.

If you need a refresher, refer this playlist on Spring Data project https://www.youtube.com/playlist?list=PLpxcSt9FGVVGq9vFTFdFVhz9-OEsqvPaj

B) Okay, what about the database?

Given
Suppose, we have a relational database which is running on our local system. We’re familiar with different ways of running a database:

Download the executable and start the database server
Run the database in a container e.g. a docker container
Use a managed service e.g. a database running on cloud

While the top 2 are generally used to run databases on local, the last one is a purely managed service which means the database is not running on our local system.

Then
We provide the database details to our Spring boot application via application.properties or application.yml

C) So, the important thing is…

We need the database details where it’s running and that can be a connection string or details like host, port, database name, a URL.

D) What does it have to do with Azure MySQL?

Before that, let’s quickly cover what is Azure MySQL?

Azure MySQL
Azure MySQL is an Azure offering for MySQL database. It is fully managed by Azure.

Which means it belongs to the category of 3rd option in Section B above.

Here, the difference is that the database is running on Azure cloud instead of our local system.

So, a Spring Boot application can easily connect to this MySQL instance same as any other MySQL as long as we provide/configure a correct connection string that can locate the running database server.

E) Steps

Create/setup an Azure MySQL instance
Use Spring Initializer to setup a new code base
Add required azure dependencies and starters
Get the connection string of Azure database
Provide the datasource details(url, username, password) in application.properties file
Run the main class

Happy learning!

Cloud Native with Spring Cloud: A Beginner’s Guide

TheCodeAlchemist — Sat, 04 Nov 2023 05:46:31 +0000

Cloud Native with Spring Cloud: A Beginner’s Guide

TL;DR

Cloud Native

Cloud native is a modern approach to building, deploying, and managing applications that leverage the full power and benefits of cloud computing.

Emphasizes: Containerization, microservices, CI/CD pipelines.

Characteristics: Highly scalable, resilient, adaptable.

Utilizes: Cloud services for auto-scaling, resource optimization.

Fosters: Agility, rapid delivery, user experience enhancement.

Design goal: Thrive in the cloud’s flexibility and scalability.

How to develop Cloud Native apps?

There are different ways to build cloud native apps. It depends on the programming language and its ecosystem like supported frameworks and patterns.

The important point to understand here is that cloud native is an approach of building, deploying, and managing applications.

You follow a set of best practices and patterns to build such apps, implementation doesn’t matter much.

Cloud native apps with Spring and Java

That’s the subject of this guide — how to build cloud native Java apps?

Spring is by far the most popular framework used to build modern Java applications.

The good this about Spring ecosystem is that it’s modular — there are different projects to support different aspects of Java development and different problems.

Spring Cloud is one such Project that itself is a home of many different projects.

If you visit the Spring documentation, you can see a long list of Spring Cloud sub-projects to support various aspects of cloud native apps.

What is Spring Cloud?

Spring Cloud is a toolkit and set of frameworks that makes it simpler to build, deploy, and manage cloud-native applications.

It builds upon the widely used Spring Framework, providing a solid foundation for creating enterprise-grade applications.

Spring Cloud offers patterns and best practices for designing and implementing microservices architecture.

How to use Spring Cloud?

The same way we use any other Spring project — add a particular dependency to your POM and that’s it! Spring boot is smart enough to auto configure that project accordingly and then we can use provided abstractions to implement logic.

In the following section, we will see few core projects that I think everyone should know about.

Key Projects in Spring Cloud

1. Spring Cloud Config

Imagine having multiple instances of your application running in the cloud. Spring Cloud Config helps you manage configuration settings for these instances in a centralized and externalized manner.

It allows you to store configurations in a Git repository or other external sources.

This means you can alter configurations without needing to redeploy your application, enhancing flexibility and dynamism.

Use Case: Efficiently handling environment-specific configurations (e.g., development, staging, production) in a distributed application.

2. Spring Cloud Netflix

This project encompasses a suite of libraries that assist in implementing patterns commonly used in microservices architectures.

It includes tools like Eureka for service registration and discovery.

Use Case: Ensuring that your services can locate and communicate with one another in a dynamic and scalable environment.

3. Spring Cloud Stream

Microservices often need to communicate with each other through messaging systems. Spring Cloud Stream offers a straightforward and consistent approach to constructing message-driven microservices.

It supports various message brokers like RabbitMQ and Kafka, allowing you to focus on business logic instead of dealing with low-level messaging intricacies.

Use Case: Constructing event-driven applications where services need to respond to events and messages in real-time.

4. Spring Cloud Security

Security is a paramount concern for any application, particularly in a distributed microservices environment.

Spring Cloud Security equips you with tools and libraries to handle authentication and authorization in a microservices architecture.

It integrates seamlessly with Spring Security, streamlining the process of securing your services.

Use Case: Implementing security measures to safeguard your microservices and thwart unauthorized access.

5. Spring Cloud Gateway

Spring Cloud Gateway is a powerful tool for building API gateways in a microservices architecture.

It provides a flexible and efficient way to route and filter HTTP requests to different services. With features like load balancing, rate limiting, and path-based routing, it helps optimize the flow of traffic between services.

Additionally, it integrates seamlessly with Spring Cloud projects, making it a crucial component for managing and securing communication within a microservices ecosystem.

Use Case: Directing and controlling traffic to various services, ensuring efficient and secure communication in a microservices architecture.

6. Spring Cloud OpenFeign

Spring Cloud OpenFeign simplifies the process of making HTTP requests to other microservices in a microservices architecture.

It allows developers to define interfaces with annotated methods, which are automatically implemented and wired to make HTTP requests.

This eliminates the need for manual HTTP client code, making communication between services more straightforward and efficient.

Use Case: Streamlining communication between microservices, reducing boilerplate code for making HTTP requests.

Additional Projects:

- Spring Cloud Secure Vault

Secure Vault provides a secure and centralized way to manage sensitive information such as passwords, API keys, and other credentials in your applications.

It ensures that sensitive data is protected and easily accessible only to authorized services.

Use Case: Safeguarding critical credentials and sensitive information in a cloud-native application.

- Spring Cloud Function

Spring Cloud Function simplifies the process of developing serverless functions using Spring.

It allows you to write business logic as functions and deploy them to various serverless platforms like AWS Lambda, Azure Functions, and more.

Use Case: Creating and deploying serverless functions in a cloud environment, reducing operational overhead.

- Spring Cloud Circuit Breaker

Circuit breakers are essential for building resilient microservices. Spring Cloud Circuit Breaker provides a set of abstractions and implementations for handling faults and failures in distributed systems. It helps prevent cascading failures and provides fallback mechanisms.

Use Case: Ensuring that your application gracefully handles failures and maintains stability, even when components are experiencing issues.

A sample design

Here’s a simple and basic design to help you understand different components and how we can implement them using Spring Cloud.

Conclusion

Spring Cloud is a powerful toolkit that simplifies the process of building and deploying cloud-native applications.

By leveraging its key projects, including Spring Cloud Config, Netflix, Sleuth and Zipkin, Stream, and Security, along with additional tools like Secure Vault, Function, and Circuit Breaker, you can tackle common challenges in microservices development.

With Spring Cloud, you’ll be well-equipped to create robust, scalable, and secure applications in the cloud.

Remember, this is just the tip of the iceberg. As you delve deeper into Spring Cloud, you’ll uncover even more features and projects that can further enhance your microservices architecture.

If you found this information helpful, be sure to follow for more insightful content on cloud-native development. Subscribe to stay updated with the latest tips and tricks in the world of technology.

Happy coding!

Role of Service Discovery in Microservices

TheCodeAlchemist — Tue, 26 Sep 2023 14:53:12 +0000

TL;DR

Mastering Service Discovery for Seamless Microservices Integration - YouTube

Different ways to implement Service Discovery:1) Using Spring Cloud Netflix EurekaEureka Server - https://youtu.be/wTjnFzs8rBcEureka Client - https://youtu.b...

youtube.com

In Microservices architecture, we have different services instead of a monolithic application/service. On top of that, each service would have multiple instances.

We used to have one application but now we have several applications.

So, what’s the problem here?

As people say — all kind of things will go wrong as soon as you go from one instance to multiple instances.

Your application would have an address i.e. where to find it, how to connect to it. So, for instance, an IP and a port. Let’s say your application’s address is — http://someip/abc and it internally uses port 8081.

When there’s a single application — you and the clients(client apps) know where it’s running.

A client app can use this IP and Port information to talk to your application.

Consider we add another instance of the same application. Now, we can’t run the new instance with the same port on the same host due to port conflicts, there are other ways to solve this problem.

Also, now we have to keep this information somewhere that this application has two instances and what are the addresses of these instances.

What if the instance goes down?

If an instance goes down, we need to remove it and add a new one. But, we also need to update the information(wherever we kept earlier) i.e. remove the crashed instance’s metadata and add the details of newly created instance.

What if we scale up and down?

What if we scale up to 100 instances and down to 1 when not required? How to keep the metadata updated for all created and destroyed instances?

How does the client know which instance to call?

How do we redirect the client calls in load balanced way? How does the client find the correct address of an instance to call the application?

You got it right, this is not going to be an easy task in a Microservices architecture!

Let’s see how a Service Discovery solution can solve these problems..

Service Discovery

Service discovery is the process of automatically detecting devices and services on a computer network. This reduces the need for manual configuration by users and administrators. — Wikipedia

This is generally a two step process:

Registration— In this step, services(or their instances) register themselves with the Service Discovery when they’re coming up.
Discovery— Once the discovery service has the metadata about registered services, clients or other services can query the discovery service to find the required information about other services

Problems addressed by Service Discovery

Registering and de-registering Services — As discussed above, services can register themselves with the discovery service. In the same way, a particular instance of a Service can be deregistered as well in case of a crash or server failure.

Monitoring — Discovery service can monitor registered service so it knows what’s the status of different services and their instances. This information is useful in scaling and load balancing scenarios.

Locating Services — With the help of discovery service, clients(could be different services) can locate other services without knowing explicit host, port, or IP.

Different Service Discovery Solutions

There are different ways to implement a service discovery solution, to name a few:

Netflix Eureka

Spring Cloud Eureka Server | Microservices | Developer's Guide - YouTube

GitHub Repository - https://github.com/therealdumbprogrammer/spring-cloud-netflix-eureka-serverIn this video, we're going to be exploring the Spring Cloud Eu...

youtube.com

Spring Cloud Netflix Eureka Client | Microservices | Developer's Guide - YouTube

GitHub Repository - https://github.com/therealdumbprogrammer/spring-cloud-netflix-eureka-clientToday we're going to take a look at how to master the Netflix ...

youtube.com

2. Consul

Spring Cloud Consul Service Discovery | Microservices - YouTube

GitHub Repository - https://github.com/therealdumbprogrammer/spring-cloud-consul-discovery-clientIn this video, we'll be taking a look at the Spring Cloud Co...

youtube.com

3. Zookeeper

Service Discovery using Spring Cloud Zookeeper | Microservices | Developer's Guide - YouTube

GitHub Repository - https://github.com/therealdumbprogrammer/spring-zookeeper-discovery-clientIn this video, we're going to show you how to use Spring Cloud ...

youtube.com

4. Kubernetes supported discovery service

Happy Learning!!

Building a REST API using Spring Boot | Step-by-Step Plan

TheCodeAlchemist — Wed, 30 Aug 2023 14:08:40 +0000

Hey Guys, I’m back again with another step-by-step plan.

If you are interested in or planning to learn Spring Data, please check out my previous article

Mastering Spring Data — A Step-by-Step Plan with free course Links

TheCodeAlchemist ・ Aug 12 '23

#java #spring #springboot #programming

TL;DR

If you’re in hurry, jump right on to the playlist:

APIs are everywhere!

APIs are everywhere. Everything is moving towards X-as-a-Service.

So, either you own an API or you’re consuming an API.

While there are a few solutions available e.g. GraphQL, gRPC, REST is still one of the most popular solutions available.

And, extend this to Java — again, there are different ways to develop an API but Spring Boot is the most widely used framework to develop an API.

If you’re a beginner or just want to brush-up the basics then you’re at the right place.
In this article, we will cover the basic knowledge of Spring Boot API. By the end of this article, you’ll be able to write your own API.

There is too much to learn and explore in Microservices area. Building an API is probably the first step.

To start, this is the bare minimum that we need:

A Spring Boot Project
How to handle and process the request?
How to read and consume parameters or data from the incoming request?
How to return a good Response?
How to handle the exceptions and errors?

Step-1 [@RestController]

To start, we need to step a Spring Boot Project and we need to add right set of dependencies.

Once we have the project, the next thing is how to handle and process the request?

Well, we create a Controller. What’s a Controller?

Controller is a Java class which is annotated with @RestController annotation. This annotation tells Spring that this class is capable of handling the incoming requests.

Having a RestController is not enough. It will intercept the request but what to do after that?

To process the request, we need a method in the controller class. And, to invoke that method, we need another annotation to bind it with the incoming request’s HTTP method type. For instance, if this is an HTTP Get request, then we need to annotate the method with @GetMapping.

Step-2 [@RequestMapping]

You must have seen the URLs in API calls. How does an API translate and map these URLs to the Controllers we created in Step-1?

There’s another annotation — @RequestMapping. With this annotation, we define URL patterns for Controllers and method which will decide which controller and method to invoke in order to process a request.

Step-3 [@RequestParam & @PathVariable]

Now, we need to make it dynamic. We need to be able to consume data/parameters from the incoming requests.

There are different ways to pass the data in a request, request parameter and path variable being the most common ones.

Learn here how to use @RequestParam and @PathVariable annotations.

Step-4 [@PostMapping & @RequestBody]

Now, we’re making some progress. Our API is getting some shape now.

Let’s see how to create the resources and how to process HTTP Post requests.

We use @PostMapping to do this.

Step-5 [@ResponseEntity]

It’s not a mandatory but a good-to-know thing.

@ResponseEntity gives us the flexibility to have more control over the response we’re returning.

Here’s a quick demo on the same.

Step-6 [@ControllerAdvice & @ExceptionHandler]

All good? No? What we should we do then?

Yea, what should we do when it’s not all good? How to handle errors and exceptions gracefully?

We not only want to handle the abnormal situations but we want to report them in a clean meaningful way so that client can make a sense out of it and decide what to do accordingly.

@ControllerAdvice and @ExceptionHandler annotations provide a way to handle the exceptions and return an error response in a clean and consistent way.

You’re mostly ready!

Not kidding, you ARE!

These are the building blocks. If you’re comfortable with these concepts and annotations, believe me, you’re ready to develop a REST API of your own using Spring Boot.

There are other things like Security, discovery, HATEOAS that we have not covered but this is not an exhaustive guide.

Once you feel comfortable, the last step is to develop a demo API.

Need any help? Watch this video which covers a Demo API with MySQL DB connectivity using Spring Data JPA.

Happy Learning!

Mastering Spring Data — A Step-by-Step Plan with free course Links

TheCodeAlchemist — Sat, 12 Aug 2023 12:29:23 +0000

TL;DR

If you’re unsure where to start, start from here:

spring-data - YouTube

All about Java and database connectivity

youtube.com

Data is everywhere. Almost every application or system we design and develop has something to do with data.

It’s either generating new data sets OR ingesting data from some other system OR processing and transforming data so that some other application can do something based on what it consumes.

In a nutshell — it’s all about the data.

On top of that, there are variety of data stores e.g. RDBMS, NoSQL, Caches, Distributed Caches, Time-series DBs and the list goes on….

Data management is so critical that it’s an essential skill for developers.

It’s important that we know how to write data to a database and read from the database.

And, it’s not a simple thing — consider available options like JDBC, JPA, Hibernate, Spring JDBC, Spring Data JPA, and so on. It can become messy and very confusing, especially for beginners.

So, in this step-by-step guide, we will see how you can start from the basics and master database connectivity in Java.

Step-0 Learn JDBC Concepts

JDBC is a pretty low level API but it’s still the first thing you should familiarize yourself with. Since we don’t generally write raw JDBC code nowadays so you can avoid going into the deep from a beginner’s perspective. You can simply focus on the basics. Complete this free Oracle JDBC lesson to understand the building blocks of database connectivity in Java.
Lesson: JDBC Basics

Time to fly! Moving on to Spring Framework

Once you’re comfortable with JDBC, the next step is to pick Spring Framework.

As of today, at the time of writing this article, you can’t succeed in your developer career if you don’t have hands-on experience on Spring Framework and related Spring projects.

And, this is mostly true as majority of enterprise applications are built on top of Spring stack.

If you simply visit the Spring homepage and explore Spring Data section, you’d see a long list of supported connectors and APIs.

Even if you can’t cover everything from the above list, couple of child projects which you should absolutely explore are:

Spring JDBC
Spring Data JPA
Spring Data for Cassandra

Step-1 Spring Data JDBC

If you completed Step-0, you’d really appreciate Spring Data JDBC.

Spring Data JDBC is a wrapper around JDBC which simplifies JDBC connectivity. Spring JDBC is a perfect choice if your project is really simple and doesn’t really need complex ORM features.

You can start from here:

Then, move on to Spring Boot and learn how Spring Boot can further simplify Spring JDBC in a project.

Step-2 Spring Data JPA

Spring JDBC is all good but it really falls short when a project needs ORM features and has complex entity models and entity relationships.

Spring Data JPA uses Hibernate under the hood and simplifies entity mappings, data access with Repositories, pagination, filtering, etc.

Start from here:

Learn how to read data from the database using Data JPA.

Next, understand how to implement Pagination and Sorting using Spring Data JPA.

And, lastly how to perform search operation without writing much code using Spring code generation and Data repositories.

If you cover this much, you’d be pretty comfortable with JPA and can explore more features on your own e.g. native queries, caching, fetch plans, etc.

Step-3 Spring Data Redis

Spring Data Redis is not needed for typical CRUD based applications. It has nothing to do with RDBMS data stores.

The main use-case of Redis is to use it as a high performance distributed cache.

Learning Spring Data Redis would expand your horizon as a developer as you learn more about capabilities of Spring Data and it easily integrates with similar NoSQL technologies and frameworks.

Even if you’re not working on Redis or similar solutions, I would still recommend to learn a little bit about Spring and Redis integration.

Follow this 3 part step-by-step playlist:

Step-4 Spring Data for Apache Cassandra

Apache Cassandra is an extremely popular NoSQL database which is heavily used in high performant distributed solutions.

Spring Data for Apache Cassandra is a Spring Data project which focuses on Cassandra integration and how easily you can setup a Java project that uses a Cassandra cluster.

This is also a 3 part series which will take you through the world of NoSQL world.

Conclusion

If you covered this much, I’m pretty sure you’d feel ultra comfortable with any Spring based data project.

BUT…don’t just stop here. Keep exploring and don’t forget to subscribe so you don’t miss any future updates.

Happy learning!

Spring JDBC Quick Refresher

TheCodeAlchemist — Sat, 08 Jul 2023 07:14:10 +0000

Database connectivity is one of the most important aspects of any application. After all, we need a persistent system to store the data.

Storing the data is not enough, the application needs to perform other actions as well e.g. reading, deleting, and updating the data.

Setting up the database

The very first thing is to setup a database. To do that, we need to finalize a data store. There are many options available in the market and it depends on the use case.

RDBMS — MySQL, Postgress, etc.
NoSQL — Cassandra, Couchbase, etc.
Document DB — MongoDB
Graph DB — Neo4J
Cloud DBs — Azure Cosmos DB or similar offerings from AWS and GCP

After finalizing the database, next step would be to install and setup it.

On your local, you’d have to do it on your own.

For instance — here we install MySQL on a Windows machine.

Connecting to the database

To connect, an application needs to know few basic properties like:

DB URL or connection String — which tells where it can find the running database.
Database driver — Each database has a driver that acts as an intermediary layer between application and the real database.
Credentials — it could be username and password, an access token, or some kind of access key.

Database API

This is probably the most important aspect of DB connectivity. How exactly an application would talk to a database. We need a high level database API, compatible with the programming language, and the database.

JDBC

JDBC or Java Database Connectivity is the core API shipped with JDK which allows Java applications to talk to different databases without worrying about low level details of database connectivity.

In general, an application does following things in order to interact with database:

Load the database driver — happens automatically in newer versions.
Create/get a data source — a wrapper representing the underlying data store.
Establish the connection
Create the statement objects
Execute CRUD queries
Handle the ResultSet if/when query returns the results
Handle exceptions
Closing statement
Closing/releasing the connection

As you can see, it looks a bit complicated.

And that’s where Spring JDBC comes into the picture.

Spring JDBC

Spring JDBC is a part of overall Spring Data project. It is suitable for simple JDBC operations where an application doesn’t need ORM/JPA capabilities.

Spring JDBC simplifies the aforementioned JDBC steps. It leverages Spring Framework capabilities like IoC, loosely coupled components which allow a developer to focus on the business logic.

Spring JDBC handles the connection, statements, releasing them, and handling common runtime exceptions.

When would we use Spring JDBC?

There are quite a few options in Java space when it comes to the DB connectivity.

Using plain JDBC
Using native Hibernate
Using Spring JDBC
Using JPA with Hibernate as its implementation
Using Spring Data JPA which uses Hibernate as JPA implementation same as above point but simplifies everything same as other Spring projects.

Options 4 and 5 are best suited for applications which have complex entity models and need ORM features.

If your application doesn’t need these features but you still need a clean way to interact with database — choose Spring JDBC

Starting with Spring JDBC

Create a maven project
Add Spring JDBC dependency
Add Mysql(or your database specific) connector dependency
Create DataSource bean using DB properties like URL, driver-class, username, and password
Autowire DataSource where you need it e.g. in DAO classes.
In DAO class, initialize JdbcTemplate/NamedParamaterJdbcTemplate.
Use template methods to query database.

See this detailed video on how to work with Spring JDBC.

Spring JDBC with Spring Boot

Spring Boot further simplifies Spring JDBC.

When we use Spring Boot, we don’t need to create DataSource and JdbcTemplate/NamedParameterJdbcTemplate.

We just need to provide following details in application.properties and include corresponding starter poms in pom.xml:

spring.datasource.url
spring.datasource.username
spring.datasource.password

Spring boot will automatically create DataSource and JdbcTemplate bean.

In DAO classes, we simply need to autowire JdbcTemplate in order to use it.

You can find all the details in this video:

If you like the content, please share the content and subscribe my channel for similar content.

Happy learning!

Spring Framework for Everyone

TheCodeAlchemist — Sat, 24 Jun 2023 15:34:46 +0000

Below YouTube playlist is a great place to start.

What is Spring?

Spring is an open-source Java platform that enables to write maintainable and scalable Java applications.

What do we mean by ‘platform’?

Spring is a complete ecosystem for Java applications. It’s not a single project but a collection of various projects under the umbrella of Spring and each project focuses on a certain aspect of Java development.

Modern Java development is so dependent on Spring projects that it’s really difficult to think about a non-spring application.

Where can I find the information on Spring?

We can find everything about Spring here — https://spring.io/

What are Spring projects?

Each Spring project is a framework in itself which helps developers to develop a certain kind of Java application. For instance, if you want to develop a web application, there’s a Spring project for that.

Where can I find these projects?

You can find all the projects here https://spring.io/projects/

Another view of the same is https://spring.io/projects/spring-boot

What is Spring Framework?

While there are many projects, the core of everything is Spring core AKA Spring Framework which provides dependency injection features.

Dependency Injection(DI) & Inversion of Control(IoC)

In a Java project, we generally write classes, define their dependencies, and create objects where required. If class A wants to use class B then we do something like this:

public class A {
  public void something() {
    B = new B(); //creating the object manually using new keyword 
    B.dosomething();
  }
}

In a nutshell, the program as it executes, creates such objects and link those objects to do what it’s supposed to do.

Spring uses DI to inject the dependencies where required instead of us creating objects manually using new keyword. Spring can use below two methods to inject the dependencies:

Constructor Injection
Setter Injection

When we use Spring, the control is inverted which means we tell Spring the dependencies of an object and it’s the job of Spring to create the objects and inject those dependencies appropriately which is why this principle is called Inversion of Control(IoC).

class A {
  private B b; //A is dependent on B

  //Spring will call this constructor to pass an object of B
  public A(B b) {
    this.b = b;
  }
}

How does Spring know what to do?

On its own, Spring has no idea about the project. We need to pass some information to the framework.

We provide the configuration metadata i.e. details about classes being managed, their dependencies(classes they’re dependent upon). Spring then reads that config, initialized it’s IoC container, and prepares the system.

How do I start?

You need to setup a Java project first with correct maven dependencies.

Once we have the project setup, we can start with Spring code.

As we know that we need to provide configuration metadata to IoC container. To do that, we will use @Configuration annotation.

This is a class-level annotation. We create a class, annotate it with @Configuration, then pass this class to IoC container.

At server startup, Spring will scan this class to read the metadata and to find more details about the classes that it needs to manage.

The classes that we want Spring to manage are called **beans. **You can say this is just another name for class. A spring bean means a Java class that spring knows about.

Watch this video where we use both the annotations.

@Bean alternatives

@Bean is not the only way to configure a Java class as a Spring bean. There are other ways to do that. Few annotations that can do the same thing are as follows:

@Component, @Service, @Repository in conjunction with @ComponentScan

These are explained in detail with hands-on here:

Bean Scopes

While being managed by Spring i.e. IoC container, each bean has a certain scope which essentially defines the scope of the object.

A bean can have different scopes such as:

Singleton
Prototype
Request
Session
Application

Singleton means that IoC container will create a single object of a bean so every time you ask Spring container for an object of say ClassA, it will the same object every time. This is similar to Gang of Four Singleton design pattern with a difference that this scope is guaranteed by the IoC container. You’re still free to create a new object using new keyword.

Just opposite is the Prototype scope, which means a new object every time.

Here we discuss all this in great detail:

Lazy and Eager initialization

It explains when a bean will be initialized and a new object of the bean is created by Spring container.

It will make more sense if you go through this video as you get to see the practical details:

@PostConstruct and @DependsOn

In continuation of lazy and eager initialization, we should also understand the lifecycle of a bean and how beans can be dependent on each other. It is actually important that we identify and setup beans accordingly as out of order initialization can crash an application.

Autowiring

Autowiring is the process by which Spring’s IoC container identifies the object dependencies and wire them together where needed.

For instance — If we configured that ClassA needs an object of ClassB that means ClassB is a dependency of ClassA so IoC container will create objects of ClassA and ClassB, and inject the object of ClassB in ClassA automatically.

@Autowired annotation simplifies the autowiring process which can be used on variable declaration, constructors, and setter methods.

Autowiring is explained here in great details with examples:

DEV Community: TheCodeAlchemist

Introducing Archify: From Architecture Idea to Spring Boot Code

The Problem

The Idea Behind Archify

Architecture as YAML

Visual Architecture Preview

Current Scope

Why I Built It

What’s Next

Try It

Java to LLMs: Exploring the LLMs Fundamentals

AI/ML - YouTube

Spring Security For Beginners — Part 2

TL;DR

Where do we start and what do we need?

High Level Flow

Implemetation

Conclusion

Spring Security For Beginners — Part 1

TL;DR

Filters

Spring Security

1. Security Filter Chain

2. AuthenticationManager and ProviderManager

3. UserDetailsService and PasswordEncoder

4.SecurityContextHolder and Authentication

Summary

Conclusion

Making Spring Transactions Transparent with Detailed Logging

Java on Azure Part 1 — Developing a CRUD application with Spring Boot & Azure MySQL

TL;DR

A) How do we develop a Spring Boot Application?

B) Okay, what about the database?

C) So, the important thing is…

D) What does it have to do with Azure MySQL?

E) Steps

Cloud Native with Spring Cloud: A Beginner’s Guide

Cloud Native with Spring Cloud: A Beginner’s Guide

TL;DR

Cloud Native

How to develop Cloud Native apps?

Cloud native apps with Spring and Java

What is Spring Cloud?

How to use Spring Cloud?

Key Projects in Spring Cloud

1. Spring Cloud Config

2. Spring Cloud Netflix

3. Spring Cloud Stream

4. Spring Cloud Security

5. Spring Cloud Gateway

6. Spring Cloud OpenFeign

Additional Projects:

- Spring Cloud Secure Vault

- Spring Cloud Function

- Spring Cloud Circuit Breaker

A sample design

Conclusion

Role of Service Discovery in Microservices

TL;DR

Mastering Service Discovery for Seamless Microservices Integration - YouTube

So, what’s the problem here?

Service Discovery

Problems addressed by Service Discovery

Different Service Discovery Solutions

Spring Cloud Eureka Server | Microservices | Developer's Guide - YouTube

Spring Cloud Netflix Eureka Client | Microservices | Developer's Guide - YouTube

Spring Cloud Consul Service Discovery | Microservices - YouTube

Service Discovery using Spring Cloud Zookeeper | Microservices | Developer's Guide - YouTube

Building a REST API using Spring Boot | Step-by-Step Plan

Mastering Spring Data — A Step-by-Step Plan with free course Links

TheCodeAlchemist ・ Aug 12 '23

TL;DR

APIs are everywhere!

Step-1 [@RestController]

Step-2 [@RequestMapping]

Step-3 [@RequestParam & @PathVariable]

Step-4 [@PostMapping & @RequestBody]

Step-5 [@ResponseEntity]

Step-6 [@ControllerAdvice & @ExceptionHandler]

You’re mostly ready!

spring-data - YouTube

All about Java and database connectivity

youtube.com