Project Architecture and Layering

By now, you've built Java programs that talk to databases. But if you don’t organize your code… chaos awaits! In this chapter, we’ll go beyond the "everything-in-one-file" phase and introduce a structure that’s scalable, testable, and professional.

Why Code Organization Matters

Without structure:

x>Code becomes hard to navigate
x>Bugs are hard to trace
x>Features are hard to add
x>Developers waste time and hate their lives

A clean architecture means you can:

x>Separate responsibilities
x>Test smaller pieces
x>Make your app easier to scale

Layers in a Java App

A typical layered Java application looks like this:

Let’s break that down:

Controller Layer (a.k.a. Web Layer)

Handles HTTP requests and responses. Think of it as the front desk.

Service Layer

Contains business logic. It decides what should happen when a user does something.

Repository Layer (a.k.a. Data Access Layer)

Talks to the database using JPA or JDBC.

DTOs (Data Transfer Objects)

What Are They?

DTOs are simple objects used to carry data between layers (like from the client to your service, or from your service to the frontend). DTOs are not entities. They're stripped-down data carriers, often used for input/output.

Why Use DTOs?

x>Avoid exposing your internal database structure
x>Control what data is sent/received
x>Add custom fields for views
x>Separate validation logic

Example DTO

Use it in your controller:

Inside your service:

Bonus: Entity vs DTO vs ViewModel

Concern	Entity	DTO	ViewModel
Used For	Persistence (JPA)	Communication between layers	Frontend/response shaping
Contains	DB-mapped fields	Only needed fields	Only displayed fields
Knows DB rules	Yes	No	No

Example Refactor Challenge

You used to do this:

Now do this:

Define a BookDto

Move logic to a BookService

Map fields from DTO → Entity in the service layer

This separation of concerns sets you up for cleaner testing and better architecture.

What’s Next

Your code is now modular. But how do you wire everything together cleanly and flexibly? Next, we explore Spring’s magic behind object creation and dependency injection—the real engine behind modern Java backends. Let’s dive in.