DEV Community: karthikeyan

A Clean & Scalable Spring Boot Project Structure (Shared-Domain Architecture)

karthikeyan — Wed, 10 Dec 2025 12:18:27 +0000

🚀 A Clean & Scalable Spring Boot Project Structure (Shared-Domain Architecture)

Organizing a Spring Boot project isn’t just about style — it directly affects how maintainable, scalable, and team-friendly your application becomes.

The classic approach:

controller/
service/
repo/
model/

…works for tiny projects, but quickly becomes messy when the app grows.

A better way for real-world full-stack apps is a Shared-Domain + Feature Modules architecture.

Here’s the structure:

src/
├── config/
├── shared/
│   ├── util/
│   ├── exception/
│   ├── model/
│   └── repo/
├── modules/
│   ├── auth/
│   │   ├── controller/
│   │   ├── service/
│   │   ├── dto/
│   │   ├── mapper/
│   │   └── projection/
│   │
│   └── dashboard/
│       ├── controller/
│       ├── service/
│       ├── dto/
│       ├── mapper/
│       └── projection/

🧱 Folder Breakdown (Short & Useful)

`config/`

App-wide configurations (Security, Swagger, CORS, caching, bean configs).

`shared/`

Common domain layer — reusable across all features.

model/ → JPA entities
repo/ → shared repositories
exception/ → global exception handlers + custom exceptions
util/ → utilities used by multiple modules

`modules/`

Each feature has its own mini-architecture:

auth/
  controller/
  service/
  dto/
  mapper/
  projection/

This keeps features independent and clean.

🎯 Why Use This Architecture?

✔ Feature-based organization → easy to navigate

✔ Shared domain avoids duplication

✔ Scales cleanly as features grow

✔ Ideal for teams working on multiple modules

✔ Easy to convert modules into microservices later

📌 When This Works Best

Use this structure if:

You're building a medium or large Spring Boot app
Multiple devs will work on different features
You want a clean way to separate features
Some entities (User, Role, Company) need to be shared

🏁 Final Thoughts

This Shared-Domain Architecture strikes the perfect balance:

Not too complex
Not too basic
Perfect for modern full-stack development
Easy to extend, test, and migrate

If you’re starting a new Spring Boot project or refactoring an existing one, this structure will save you time and headaches as your application grows.

Create ReactJS Vite and Django Integration Project

karthikeyan — Wed, 03 Jan 2024 00:42:50 +0000

Create ReactJS Vite and Django project

Create ReactJS Vite project

frontend - name of the project

npm create vite@latest 
cd frontend
npm install
npm run dev

Create and Activate Virtual Environment

virtualenv env
cd env
source bin/activate
pip install django djangorestframework django-cors-headers serializer
cd ..

Create Django project

backend - name of the project

django-admin startproject backend
cd backend/

Run the Development Server

python3 manage.py migrate
python3 manage.py runserver
python3 manage.py createsuperuser

Create a App called post

python3 manage.py startapp post

Update Backend Settings

In backend/backend/settings.py:

INSTALLED_APPS = [
    # ...,
    'rest_framework',
    'corsheaders',
    'post',
    # ...,
]

CORS_ALLOWED_ORIGINS = [
    'http://localhost:5173',  # Adjust as per your frontend URL
]
MIDDLEWARE = [
    #...
    'corsheaders.middleware.CorsMiddleware',
    #...
]

Create Models

In backend/post/models.py:

from django.db import models

class Post(models.Model):
    title = models.CharField(max_length=200)
    body = models.TextField()

    def __str__(self):
        return f"Post: {self.title}"

Admin Configuration

In backend/post/admin.py:

from django.contrib import admin
from .models import Post

admin.site.register(Post)

Serializers

Create backend/post/api/serializers.py:

from rest_framework import serializers
from ..models import Post

class PostSerializer(serializers.ModelSerializer):
    class Meta:
        model = Post
        fields = ('id', 'title', 'body')

Views and URLs

Create backend/post/api/views.py:

from rest_framework.viewsets import ModelViewSet
from ..models import Post
from .serializers import PostSerializer

class PostViewSet(ModelViewSet):
    queryset = Post.objects.all()
    serializer_class = PostSerializer

Create backend/post/api/urls.py:

from django.urls import path
from rest_framework.routers import DefaultRouter
from .views import PostViewSet

router = DefaultRouter()
router.register(r'post', PostViewSet)

urlpatterns = router.urls

Root URLs

In backend/backend/urls.py:

from django.contrib import admin
from django.urls import path, include

urlpatterns = [
    path('admin/', admin.site.urls),
    path('api/', include('post.api.urls')),
]

Run the Application

python3 manage.py makemigrations
python3 manage.py migrate
python3 manage.py runserver

create `.env` file in `/frontend/.env`

VITE_API_URL=http://127.0.0.1:8000/api/

write the bellow code

import { useState, useEffect } from 'react';
import './App.css';

function App() {
  const [data, setData] = useState([]);

  useEffect(() => {
    async function fetchData() {
      try {
        const response = await fetch(`${import.meta.env.VITE_API_URL}post/`);
        if (!response.ok) {
          throw new Error('Network response was not ok...');
        }
        const result = await response.json();
        console.log(result)
        setData(result);
      } catch (error) {
        console.error('Error fetching data:', error);
      }
    }

    fetchData(); 
  }, []); 
  return (
    <>
      <h1>Hello World!..</h1>
      {data.map((post) => (
        <div key={post.id}>
          <h2>{post.title}</h2>
          <p>{post.body}</p>
        </div>
      ))}
    </>
  );
}

export default App;

Run the Application

python3 manage.py makemigrations
python3 manage.py migrate
npm run dev
python3 manage.py runserver

Open your Browser

Access the application using http://localhost:5173/

Access the application django page using http://127.0.0.1:8000/api/

Access the application django Admin page using http://127.0.0.1:8000/admin/login/?next=/admin/

Install and Configure PostgreSQL With GoLang

karthikeyan — Thu, 21 Dec 2023 03:07:33 +0000

Install PostgreSQL: If you haven't already installed PostgreSQL, you can do so using the following command:



   sudo apt-get update
   sudo apt-get install git
   sudo apt-get install golang-go
   sudo apt-get install postgresql postgresql-contrib

Start PostgreSQL: Start the PostgreSQL service:



   sudo service postgresql start

Create a PostgreSQL User and Database: You'll need to create a PostgreSQL user and a database for your Go application. You can do this using the psql command-line utility:



   sudo -u postgres psql

Then, within the psql shell, create a new user and a database:



   CREATE USER myuser WITH PASSWORD 'mypassword';
   CREATE DATABASE mydb;
   GRANT ALL PRIVILEGES ON DATABASE mydb TO myuser;

Replace myuser and mypassword with your desired username and password, and mydb with your desired database name.

Locate the pg_hba.conf file. It's usually found in the PostgreSQL data directory, often in /etc/postgresql/{version}/main/pg_hba.conf.

Changing the pg_hba.conf line:



local   all             all                                     peer



local   all             all                                     all
local   testing         <Data_base>                                 md5



sudo service postgresql restart

** Switch to the PostgreSQL User**

You can switch to the PostgreSQL user and then use psql. The PostgreSQL user is typically named "postgres." Run the following command:



sudo -u postgres psql -d mydb

This command switches to the "postgres" system user and then runs psql to connect to the specified database. You will be prompted for the password of the "postgres" PostgreSQL user.

You can execute the SQL code to create the "list" table:



   CREATE TABLE list (
       id INT PRIMARY KEY,
       name VARCHAR (255)
   );
   INSERT INTO list VALUES (1, 'Sam');
   INSERT INTO list VALUES (2, 'Som');
   INSERT INTO list VALUES (3, 'Ram');
   INSERT INTO list VALUES (4, 'Bam');

This SQL code defines a table named "list" with two columns, "id" and "name." The "id" column is set as the primary key, and the "name" column is of type VARCHAR with a maximum length of 255 characters.

Exit the psql session by typing:

\q

This will return you to your regular command prompt.

Create a Go Module:

If you are starting a new project, you can create a Go module by navigating to your project directory and running:



   go mod init myproject

If you're working on an existing project, and it doesn't have a Go module yet, you can also initialize one in the project's root directory.

Install the PostgreSQL Driver for Go: You'll need a Go driver to connect to PostgreSQL. One popular option is pq. You can install it using go get:



   go get github.com/lib/pq

Write a Go Program (main.go): Here's a simple example of a Go program that connects to the PostgreSQL database and performs a basic query:



   package main

   import (
       "database/sql"
       "fmt"
       _ "github.com/lib/pq"
   )

   func main() {
       // Connect to the PostgreSQL database
       connStr := "user=myuser dbname=mydb password=mypassword sslmode=disable"
       db, err := sql.Open("postgres", connStr)
       if err != nil {
           panic(err)
       }
       defer db.Close()

       // Perform a sample query
       rows, err := db.Query("SELECT * FROM list")
       if err != nil {
           panic(err)
       }
       defer rows.Close()

       // Iterate through the results
       for rows.Next() {
           var id int
           var name string
           if err := rows.Scan(&id, &name); err != nil {
               panic(err)
           }
           fmt.Printf("ID: %d, Name: %s\n", id, name)
       }
   }

Replace myuser, mydb, and the query with your own credentials and SQL statement.

Run the Go Program: You can compile and run your Go program like this:



   go build -o main.go
   ./main

Fixing The permission denied for table list problem Here are the steps to grant the necessary permissions:

12.1. Connect to PostgreSQL: Connect to the PostgreSQL database with a superuser or a user who has the necessary privileges to grant permissions. You can use the psql command as you did before:



   sudo -u postgres psql -d mydb

Replace "mydb" with the name of your database.

12.2. Grant SELECT Permission: In the psql shell, grant the SELECT permission on the "list" table to your PostgreSQL user. Replace <username> with the actual username your Go application is using:



   GRANT SELECT ON TABLE list TO myuser;

This grants the SELECT permission on the "list" table to the specified user, allowing them to retrieve data from the table.

12.3. Exit psql: After granting the permissions, you can exit the psql shell:

\q

12.4. Rebuild and Run Your Go Application: After granting the necessary permissions, rebuild and run your Go application:



   go build -o main && ./main

Your application should now be able to access the "list" table without encountering the "permission denied" error.

Video Tutorial: https://www.youtube.com/watch?v=BTeSJ4VGU1o&t=350s&ab_channel=KKBUGHUNTER
GitHub: https://github.com/KKBUGHUNTER/GO_Postgresql_CRUD_Web_App/tree/main

Thank you...

Install and Configure PostgreSQL With GoLang

karthikeyan — Thu, 21 Dec 2023 03:07:26 +0000

Install PostgreSQL: If you haven't already installed PostgreSQL, you can do so using the following command:

   sudo apt-get update
   sudo apt-get install git
   sudo apt-get install golang-go
   sudo apt-get install postgresql postgresql-contrib

Start PostgreSQL: Start the PostgreSQL service:

   sudo service postgresql start

Create a PostgreSQL User and Database: You'll need to create a PostgreSQL user and a database for your Go application. You can do this using the psql command-line utility:

   sudo -u postgres psql

Then, within the psql shell, create a new user and a database:

   CREATE USER myuser WITH PASSWORD 'mypassword';
   CREATE DATABASE mydb;
   GRANT ALL PRIVILEGES ON DATABASE mydb TO myuser;

local   all             all                                     peer

local   all             all                                     all
local   testing         <Data_base>                                 md5

sudo service postgresql restart

** Switch to the PostgreSQL User**

You can switch to the PostgreSQL user and then use psql. The PostgreSQL user is typically named "postgres." Run the following command:

sudo -u postgres psql -d mydb

This command switches to the "postgres" system user and then runs psql to connect to the specified database. You will be prompted for the password of the "postgres" PostgreSQL user.

You can execute the SQL code to create the "list" table:

   CREATE TABLE list (
       id INT PRIMARY KEY,
       name VARCHAR (255)
   );
   INSERT INTO list VALUES (1, 'Sam');
   INSERT INTO list VALUES (2, 'Som');
   INSERT INTO list VALUES (3, 'Ram');
   INSERT INTO list VALUES (4, 'Bam');

Exit the psql session by typing:

\q

This will return you to your regular command prompt.

Create a Go Module:

If you are starting a new project, you can create a Go module by navigating to your project directory and running:

   go mod init myproject

If you're working on an existing project, and it doesn't have a Go module yet, you can also initialize one in the project's root directory.

Install the PostgreSQL Driver for Go: You'll need a Go driver to connect to PostgreSQL. One popular option is pq. You can install it using go get:

   go get github.com/lib/pq

Write a Go Program (main.go): Here's a simple example of a Go program that connects to the PostgreSQL database and performs a basic query:

   package main

   import (
       "database/sql"
       "fmt"
       _ "github.com/lib/pq"
   )

   func main() {
       // Connect to the PostgreSQL database
       connStr := "user=myuser dbname=mydb password=mypassword sslmode=disable"
       db, err := sql.Open("postgres", connStr)
       if err != nil {
           panic(err)
       }
       defer db.Close()

       // Perform a sample query
       rows, err := db.Query("SELECT * FROM list")
       if err != nil {
           panic(err)
       }
       defer rows.Close()

       // Iterate through the results
       for rows.Next() {
           var id int
           var name string
           if err := rows.Scan(&id, &name); err != nil {
               panic(err)
           }
           fmt.Printf("ID: %d, Name: %s\n", id, name)
       }
   }

Replace myuser, mydb, and the query with your own credentials and SQL statement.

Run the Go Program: You can compile and run your Go program like this:

   go build -o main.go
   ./main

Fixing The permission denied for table list problem Here are the steps to grant the necessary permissions:

12.1. Connect to PostgreSQL: Connect to the PostgreSQL database with a superuser or a user who has the necessary privileges to grant permissions. You can use the psql command as you did before:

   sudo -u postgres psql -d mydb

Replace "mydb" with the name of your database.

   GRANT SELECT ON TABLE list TO myuser;

This grants the SELECT permission on the "list" table to the specified user, allowing them to retrieve data from the table.

12.3. Exit psql: After granting the permissions, you can exit the psql shell:

\q

12.4. Rebuild and Run Your Go Application: After granting the necessary permissions, rebuild and run your Go application:

   go build -o main && ./main

Your application should now be able to access the "list" table without encountering the "permission denied" error.

Video Tutorial: https://www.youtube.com/watch?v=BTeSJ4VGU1o&t=350s&ab_channel=KKBUGHUNTER

Thank you...

Java full-fledged Course in Tamil Introduction Video | Beginner to Expert in Java

karthikeyan — Wed, 13 Dec 2023 16:27:55 +0000

DEV Community: karthikeyan

A Clean & Scalable Spring Boot Project Structure (Shared-Domain Architecture)

🚀 A Clean & Scalable Spring Boot Project Structure (Shared-Domain Architecture)

🧱 Folder Breakdown (Short & Useful)

config/

shared/

modules/

🎯 Why Use This Architecture?

✔ Feature-based organization → easy to navigate

✔ Shared domain avoids duplication

✔ Scales cleanly as features grow

✔ Ideal for teams working on multiple modules

✔ Easy to convert modules into microservices later

📌 When This Works Best

🏁 Final Thoughts

Create ReactJS Vite and Django Integration Project

Create ReactJS Vite and Django project

Create ReactJS Vite project

Create and Activate Virtual Environment

Create Django project

Run the Development Server

Create a App called post

Update Backend Settings

Create Models

Admin Configuration

Serializers

Views and URLs

Root URLs

Run the Application

create .env file in /frontend/.env

write the bellow code

Run the Application

Open your Browser

Install and Configure PostgreSQL With GoLang

Thank you...

Install and Configure PostgreSQL With GoLang

Thank you...

Java full-fledged Course in Tamil Introduction Video | Beginner to Expert in Java

`config/`

`shared/`

`modules/`

create `.env` file in `/frontend/.env`