Domain‐Driven Design - ganmath/learners GitHub Wiki

Domain-Driven Design (DDD) is a methodology and set of priorities for developing software that aligns complex needs with the underlying software implementation. In the context of Spring Boot, implementing DDD involves organizing your application into a domain layer, which includes entities, value objects, repositories, and services that reflect the business domain.

Here’s a simple example to illustrate how you might structure a Spring Boot application using DDD principles. This example will involve a basic domain of "Book Management" in a library system.

1. Define the Domain Model

First, you define the core domain model, which includes entities and value objects. Here, Book is an entity with a unique identifier.

package com.example.library.domain.model;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
public class Book {
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Long id;
    private String title;
    private String author;
    private String isbn;

    public Book() {
    }

    public Book(String title, String author, String isbn) {
        this.title = title;
        this.author = author;
        this.isbn = isbn;
    }

    // Getters and setters
}

2. Define Repositories

Repositories handle the data access logic. Here’s an example of a repository interface for the Book entity.

package com.example.library.domain.repository;

import com.example.library.domain.model.Book;
import org.springframework.data.repository.CrudRepository;

public interface BookRepository extends CrudRepository<Book, Long> {
}

3. Define Services

Services encapsulate business logic. They use repositories to retrieve and store domain objects.

package com.example.library.domain.service;

import com.example.library.domain.model.Book;
import com.example.library.domain.repository.BookRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class BookService {

    private final BookRepository bookRepository;

    @Autowired
    public BookService(BookRepository bookRepository) {
        this.bookRepository = bookRepository;
    }

    public Book saveBook(Book book) {
        return bookRepository.save(book);
    }

    public Iterable<Book> findAllBooks() {
        return bookRepository.findAll();
    }
}

4. Use Cases or Application Services

In DDD, application services handle specific business cases. Here’s a simple controller that might act as an application service.

package com.example.library.application;

import com.example.library.domain.model.Book;
import com.example.library.domain.service.BookService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/books")
public class BookController {

    private final BookService bookService;

    @Autowired
    public BookController(BookService bookService) {
        this.bookService = bookService;
    }

    @PostMapping("/")
    public Book addBook(@RequestBody Book book) {
        return bookService.saveBook(book);
    }

    @GetMapping("/")
    public Iterable<Book> getBooks() {
        return bookService.findAllBooks();
    }
}

Summary

This example demonstrates how to apply DDD concepts in a Spring Boot application by dividing the architecture into layers of domain models, repositories, services, and application services. The focus is on isolating the core business logic from infrastructure concerns and ensuring the software structure closely mirrors the business domain.