Library Management System

@RestController
@RequestMapping("/library")
public class LibraryController {
}

// 1. Book Entity
import jakarta.persistence.*;

@Entity
class Book {

  @Id
  @GeneratedValue(strategy = GenerationType.IDENTITY)
  private Long id;

  private String title;
  private String author;
  private String isbn;
  private Integer availableCopies;
}


// 2. Member Entity
@Entity
class Member {

  @Id
  @GeneratedValue(strategy = GenerationType.IDENTITY)
  private Long id;

  private String name;
  private String email;
}


// 3. Issue Record Entity
@Entity
class IssueRecord {

  @Id
  @GeneratedValue(strategy = GenerationType.IDENTITY)
  private Long id;

  private Long bookId;
  private Long memberId;
  private String issueDate;
  private String returnDate;
  private String status; // ISSUED / RETURNED
}


// 4. Repository Layer
import org.springframework.data.jpa.repository.JpaRepository;

interface BookRepository extends JpaRepository<Book, Long> {}
interface MemberRepository extends JpaRepository<Member, Long> {}
interface IssueRepository extends JpaRepository<IssueRecord, Long> {}


// 5. Service Layer
import org.springframework.stereotype.Service;

@Service
class LibraryService {

  private final BookRepository bookRepo;
  private final MemberRepository memberRepo;
  private final IssueRepository issueRepo;

  public LibraryService(BookRepository bookRepo, MemberRepository memberRepo, IssueRepository issueRepo) {
    this.bookRepo = bookRepo;
    this.memberRepo = memberRepo;
    this.issueRepo = issueRepo;
  }

  public Book addBook(Book book) {
    return bookRepo.save(book);
  }

  public IssueRecord issueBook(IssueRecord record) {

    Book book = bookRepo.findById(record.getBookId()).orElseThrow();

    if (book.getAvailableCopies() <= 0) {
      throw new RuntimeException("Book not available");
    }

    book.setAvailableCopies(book.getAvailableCopies() - 1);
    bookRepo.save(book);

    record.setStatus("ISSUED");
    return issueRepo.save(record);
  }

  public IssueRecord returnBook(Long issueId) {

    IssueRecord record = issueRepo.findById(issueId).orElseThrow();

    Book book = bookRepo.findById(record.getBookId()).orElseThrow();
    book.setAvailableCopies(book.getAvailableCopies() + 1);

    bookRepo.save(book);

    record.setStatus("RETURNED");
    return issueRepo.save(record);
  }
}


// 6. Controller Layer
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/library")
class LibraryController {

  private final LibraryService service;

  public LibraryController(LibraryService service) {
    this.service = service;
  }

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

  @PostMapping("/issue")
  public IssueRecord issue(@RequestBody IssueRecord record) {
    return service.issueBook(record);
  }

  @PostMapping("/return/{id}")
  public IssueRecord returnBook(@PathVariable Long id) {
    return service.returnBook(id);
  }
}


// 7. application.properties
spring.datasource.url=jdbc:mysql://localhost:3306/library
spring.datasource.username=root
spring.datasource.password=root
spring.jpa.hibernate.ddl-auto=update


// Output:
// /library/books -> Add books
// /library/issue -> Issue book
// /library/return/{id} -> Return book

• 1 System to manage books and members.
• 2 Handles issuing and returning books.
• 3 Tracks availability of books.
• 4 Built using Spring Boot backend.

• 1 Book management
• 2 Member management
• 3 Issue/Return system
• 4 Inventory tracking

• 1 Member requests book
• 2 Book is issued
• 3 Book is returned
• 4 Inventory updated

• 1 Automates library operations
• 2 Reduces manual record keeping
• 3 Improves book tracking
• 4 Real-world CRUD system practice

• 1 Used in schools and universities.
• 2 Used in public libraries.
• 3 Used in digital library systems.
• 4 Used in educational institutions.
• 5 SaaS products use Library Management System using Spring Boot in services, dashboards, background jobs, and API workflows.
• 6 ERP and banking systems apply Library Management System using Spring Boot with validation, logging, review, and rollback plans.
• 7 E-commerce and healthcare platforms use Library Management System using Spring Boot carefully because reliability and data correctness matter.

• 1 A Java program first evaluates the surrounding context, then applies the Library Management System using Spring Boot rules to the current data.
• 2 The important mental model is input, transformation, result, and failure path.
• 3 In production, the same flow usually sits inside a larger layer such as a controller, service, repository, job, or UI component.

• 1 Choose the simplest implementation first, then measure real workloads.
• 2 Watch for repeated work inside loops, unnecessary allocations, and slow I/O in hot paths.
• 3 Prefer clear data structures and stable APIs before micro-optimizing syntax.

• 1 Treat external input as untrusted until it is validated.
• 2 Avoid hardcoded secrets and never print sensitive values in examples or logs.
• 3 Use established libraries for authentication, encryption, parsing, and database access.

• 1 Not handling multiple book issues per user.
• 2 No fine calculation system.
• 3 Missing due date validation.
• 4 Poor inventory tracking of books.
• 5 Skipping the small working example before adding framework code.
• 6 Ignoring null, empty, duplicate, and boundary inputs.
• 7 Mixing business logic, input handling, and output formatting in one place.
• 8 Using broad error handling that hides the real failure.
• 9 Forgetting to test the behavior after refactoring.
• 10 Adding clever code that future maintainers will struggle to read.

• 1 Implement fine calculation for late returns.
• 2 Use proper relational mapping.
• 3 Add search and filtering for books.
• 4 Use pagination for large catalogs.
• 5 Start with clear requirements and one minimal working example.
• 6 Use meaningful names that explain business intent.
• 7 Keep examples small enough to debug line by line.
• 8 Validate input at every trust boundary.
• 9 Handle errors explicitly and preserve useful context.
• 10 Prefer simple control flow over deeply nested logic.
• 11 Separate domain logic from I/O and framework code.
• 12 Write tests for normal, boundary, and failure cases.
• 13 Review security assumptions before production use.
• 14 Measure performance before optimizing.
• 15 Document non-obvious decisions close to the code or in project notes.
• 16 Use official documentation when behavior is version-specific.
• 17 Keep dependencies current and remove unused code.
• 18 Avoid hardcoded secrets, credentials, and environment-specific paths.
• 19 Log operational events without exposing sensitive data.
• 20 Design examples so learners can safely modify and rerun them.

• 1 Beginner: rewrite the example with different names and values.
• 2 Intermediate: add validation and handle one expected failure case.
• 3 Advanced: place Library Management System using Spring Boot inside a small service-style design with tests.

• 1 Build a small Java console feature that demonstrates Library Management System using Spring Boot.
• 2 Accept input, process it with the concept, print a clear result, and handle invalid input.
• 3 Add a README note explaining the design choice and two edge cases you tested.

• 1 If the program does not compile, check spelling, imports, braces, and file/class names first.
• 2 If output is unexpected, print intermediate values and verify each branch of the logic.
• 3 If the design feels complex, reduce it to the smallest working example and add pieces back one at a time.

• 1 Practice Library Management System using Spring Boot with a second example from a business domain such as inventory, payroll, banking, or e-commerce.
• 2 Review related Java topics that cover data flow, error handling, testing, and clean design.
• 3 Compare your solution with official documentation and simplify anything you cannot explain clearly.