https://github.com/creator79/spring-boot-learning
https://github.com/creator79/spring-boot-learning
Last synced: 4 months ago
JSON representation
- Host: GitHub
- URL: https://github.com/creator79/spring-boot-learning
- Owner: creator79
- Created: 2025-06-08T10:06:17.000Z (about 1 year ago)
- Default Branch: main
- Last Pushed: 2025-06-08T11:45:30.000Z (about 1 year ago)
- Last Synced: 2025-06-08T12:31:13.624Z (about 1 year ago)
- Size: 15.6 KB
- Stars: 0
- Watchers: 0
- Forks: 0
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
Awesome Lists containing this project
README
# 🌱 Spring Boot Learning Adventure
## *A Fun Guide to Building Amazing Web Apps!*
---
## 🎯 What You'll Learn
By the end of this adventure, you'll be able to:
- 🏗️ Build cool web applications
- 🚀 Create REST APIs that talk to other apps
- 💾 Store data like a pro
- 🎪 Handle errors gracefully
- 🎨 Make your code super organized
---
## 🌟 Chapter 1: Meet Spring Boot!
### 🤔 What is Spring Boot?
Imagine you want to build a LEGO castle 🏰. Without Spring Boot, you'd have to find each tiny piece one by one - that's boring and takes FOREVER!
Spring Boot is like getting a **magic LEGO kit** that already has most pieces sorted and ready. You just focus on building your awesome castle! 🎉
### 🎪 Why is Spring Boot So Cool?
- **🎯 Auto-Magic Setup**: It sets up everything automatically (like having a robot helper!)
- **🏠 Built-in Server**: Your app gets its own house to live in (Tomcat server)
- **📦 Starter Packs**: Pre-made toolkits for different jobs
- **🚀 Super Fast**: Build APIs in minutes, not hours!
### 🎬 Your First Spring Boot App
```java
@SpringBootApplication // 🎪 This is like the "main tent" of your circus!
public class MyAwesomeApp {
public static void main(String[] args) {
SpringApplication.run(MyAwesomeApp.class, args);
System.out.println("🎉 My app is alive and running!");
}
}
```
---
## 🏭 Chapter 2: The Magic Factory (IoC & Dependency Injection)
### 🤖 What is IoC (Inversion of Control)?
Think of Spring as a **super smart robot factory manager** 🤖. Instead of you creating every toy by hand, you tell the robot manager: *"Hey, I need a car!"* and **POOF** - the robot makes it and hands it to you!
### 🎁 Dependency Injection Explained
Imagine you're making a sandwich 🥪:
- **Old way**: You go buy bread, get butter, slice tomatoes, etc.
- **Spring way**: You say "I want a sandwich" and someone brings you all ingredients ready to use!
```java
@Component // 🏷️ "Hey Spring, please manage this for me!"
public class CookieService {
public String bakeCookie() {
return "🍪 Fresh chocolate chip cookie ready!";
}
}
@RestController // 🎭 "I'm the face that talks to the outside world!"
public class CookieController {
private final CookieService cookieService;
// 🎁 Constructor Injection - Spring gives us the service automatically!
public CookieController(CookieService cookieService) {
this.cookieService = cookieService;
}
@GetMapping("/cookie") // 🌐 When someone visits /cookie
public String getCookie() {
return cookieService.bakeCookie();
}
}
```
---
## 🏷️ Chapter 3: The Magical Stickers (Annotations)
Think of annotations as **magical stickers** you put on your code to give it superpowers! ✨
### 🎪 **Core Circus Performers**
| Sticker | Superpower | Example |
|---------|------------|---------|
| `@SpringBootApplication` | 🎪 **Ring Master** - Controls the whole show | Main class |
| `@Component` | 🎯 **Basic Performer** - Spring manages this | Any helper class |
| `@Service` | 🧠 **Brain Worker** - Handles business logic | Calculate prices |
| `@Repository` | 💾 **Data Keeper** - Talks to database | Save/get data |
| `@RestController` | 🎭 **Public Face** - Talks to outside world | API endpoints |
### 🌐 **Web Magic Stickers**
```java
@RestController // 🎭 "I handle web requests!"
@RequestMapping("/pets") // 🏠 "My home address is /pets"
public class PetController {
@GetMapping // 📋 "I handle GET requests"
public String getAllPets() {
return "🐶🐱🐹 Here are all pets!";
}
@PostMapping // ➕ "I create new things"
public String addPet(@RequestBody PetDTO pet) { // 📦 "Give me the data from request"
return "✅ Added new pet: " + pet.getName();
}
@PutMapping("/{id}") // ✏️ "I update existing things"
public String updatePet(@PathVariable Long id) { // 🔍 "Grab the ID from URL"
return "✏️ Updated pet with ID: " + id;
}
@DeleteMapping("/{id}") // 🗑️ "I remove things"
public String deletePet(@PathVariable Long id) {
return "🗑️ Deleted pet with ID: " + id;
}
}
```
### 💾 **Database Magic Stickers**
```java
@Entity // 🏷️ "I represent a table in database"
@Table(name = "super_heroes") // 🏠 "My table name is super_heroes"
public class SuperHero {
@Id // 🔑 "I'm the unique key"
@GeneratedValue(strategy = GenerationType.IDENTITY) // 🔢 "Auto-number me"
private Long id;
@Column(name = "hero_name", nullable = false) // 📝 "I'm a required column"
private String name;
@Column(length = 1000) // 📏 "I can hold up to 1000 characters"
private String superPower;
// 🎁 Getters and Setters (Spring needs these!)
}
```
### 🔧 **Validation Magic Stickers**
```java
public class UserDTO {
@NotBlank(message = "🚫 Name cannot be empty!") // ✅ "Must have a name"
private String name;
@Email(message = "📧 Please enter a valid email!") // ✅ "Must be email format"
private String email;
@Min(value = 18, message = "🔞 Must be at least 18 years old!") // ✅ "Age check"
private Integer age;
@Size(min = 8, message = "🔐 Password must be at least 8 characters!") // ✅ "Password strength"
private String password;
}
```
### 🔧 **More Industrial-Strength Annotations**
```java
// 🏗️ Configuration & Properties
@Configuration // 🎛️ "I configure beans and settings"
@ConfigurationProperties(prefix = "app.config") // ⚙️ "Load properties from application.yml"
public class AppConfig {
private String name;
private String version;
// getters/setters
}
// 💉 Advanced Dependency Injection
@Autowired // 🎯 "Auto-inject dependency"
@Qualifier("primaryUserService") // 🏷️ "Use this specific bean when multiple exist"
@Primary // ⭐ "I'm the default choice when multiple beans of same type exist"
@Lazy // 😴 "Create me only when needed, not at startup"
// 🔄 Lifecycle & Events
@PostConstruct // 🎬 "Run me after object is created"
@PreDestroy // 🏁 "Run me before object is destroyed"
@EventListener // 👂 "I listen to application events"
// 🌐 Advanced Web Annotations
@CrossOrigin(origins = "http://localhost:3000") // 🌍 "Allow requests from React app"
@RequestHeader("Authorization") // 📋 "Get header value from request"
@CookieValue("sessionId") // 🍪 "Get cookie value"
@SessionAttribute("user") // 👤 "Get data from HTTP session"
// 📊 JPA Advanced Annotations
@CreationTimestamp // 📅 "Auto-set creation time"
@UpdateTimestamp // ⏰ "Auto-update modification time"
@Version // 🔄 "Handle optimistic locking"
@Transactional(rollbackFor = Exception.class) // 🔄 "Database transaction management"
@Modifying // ✏️ "This query modifies data"
@Query("SELECT u FROM User u WHERE u.active = true") // 🔍 "Custom JPQL query"
// 🧪 Testing Annotations
@SpringBootTest // 🧪 "Full integration test"
@WebMvcTest(UserController.class) // 🎭 "Test only web layer"
@DataJpaTest // 💾 "Test only JPA repositories"
@MockBean // 🎭 "Create mock bean for testing"
@TestPropertySource(locations = "classpath:test.properties") // 📋 "Test-specific properties"
// 🔐 Security Annotations
@PreAuthorize("hasRole('ADMIN')") // 🛡️ "Check permission before method execution"
@PostAuthorize("returnObject.owner == authentication.name") // 🔒 "Check permission after method execution"
@Secured("ROLE_USER") // 🔐 "Simple role-based access"
// 📋 Scheduling & Async
@Scheduled(fixedRate = 5000) // ⏰ "Run every 5 seconds"
@Async // 🚀 "Run asynchronously"
@EnableScheduling // ⏱️ "Enable scheduled tasks in application"
// 🎯 Conditional Annotations
@ConditionalOnProperty(name = "feature.enabled", havingValue = "true") // 🎛️ "Create bean only if property is true"
@ConditionalOnMissingBean // ❓ "Create only if no other bean of this type exists"
@Profile("development") // 🎯 "Active only in development profile"
```
---
## 🏗️ Chapter 4: The Three Amigos (DTO vs POJO vs Entity)
### 🎭 Meet the Characters
```java
// 🏷️ ENTITY - "I live in the database!"
@Entity
@Table(name = "students")
public class Student {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
@Column(nullable = false)
private String fullName;
@Column(unique = true)
private String email;
private Integer age;
private String phoneNumber;
// 🎁 Constructors, getters, setters
}
// 📦 DTO - "I carry data between layers!"
public class StudentDTO {
private String fullName;
private String email;
private Integer age;
// 🎁 Only the data we want to show/receive
}
// 🎯 POJO - "I'm just a simple Java object!"
public class StudentInfo {
private String name;
private String grade;
// 🎁 Simple object, no special annotations
}
```
---
## 🎪 Chapter 5: Build Your First API Circus!
### 🎯 Project: "Pet Store Management System"
Let's build a fun pet store where we can:
- ➕ Add new pets
- 👀 See all pets
- ✏️ Update pet info
- 🗑️ Remove pets
```java
// 📦 Pet Data Transfer Object
public class PetDTO {
@NotBlank(message = "🐾 Pet needs a name!")
private String name;
@NotBlank(message = "🏷️ What type of pet is this?")
private String type; // dog, cat, bird, etc.
@Min(value = 0, message = "🎂 Age cannot be negative!")
private Integer age;
private String color;
// 🎁 Getters and setters
public String getName() { return name; }
public void setName(String name) { this.name = name; }
// ... other getters and setters
}
// 🏷️ Pet Entity (Database Table)
@Entity
@Table(name = "pets")
public class Pet {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
@Column(nullable = false)
private String name;
@Column(nullable = false)
private String type;
private Integer age;
private String color;
@CreationTimestamp // 📅 Automatically sets when created
private LocalDateTime createdAt;
// 🎁 Constructors, getters, setters
}
// 💾 Pet Repository (Database Worker)
@Repository
public interface PetRepository extends JpaRepository {
// 🔍 Find pets by type
List findByType(String type);
// 🔍 Find pets by name containing
List findByNameContainingIgnoreCase(String name);
// 🔍 Find pets younger than age
List findByAgeLessThan(Integer age);
}
// 🧠 Pet Service (Business Logic)
@Service
public class PetService {
private final PetRepository petRepository;
public PetService(PetRepository petRepository) {
this.petRepository = petRepository;
}
public Pet addPet(PetDTO petDTO) {
Pet pet = new Pet();
pet.setName(petDTO.getName());
pet.setType(petDTO.getType());
pet.setAge(petDTO.getAge());
pet.setColor(petDTO.getColor());
return petRepository.save(pet);
}
public List getAllPets() {
return petRepository.findAll();
}
public Pet updatePet(Long id, PetDTO petDTO) {
Pet pet = petRepository.findById(id)
.orElseThrow(() -> new RuntimeException("🚫 Pet not found!"));
pet.setName(petDTO.getName());
pet.setType(petDTO.getType());
pet.setAge(petDTO.getAge());
pet.setColor(petDTO.getColor());
return petRepository.save(pet);
}
public void deletePet(Long id) {
if (!petRepository.existsById(id)) {
throw new RuntimeException("🚫 Pet not found!");
}
petRepository.deleteById(id);
}
}
// 🎭 Pet Controller (Public Face)
@RestController
@RequestMapping("/api/pets")
@Validated
public class PetController {
private final PetService petService;
public PetController(PetService petService) {
this.petService = petService;
}
@PostMapping
public ResponseEntity addPet(@Valid @RequestBody PetDTO petDTO) {
Pet savedPet = petService.addPet(petDTO);
return ResponseEntity.status(HttpStatus.CREATED)
.body("🎉 Successfully added " + savedPet.getName() + " to our pet store!");
}
@GetMapping
public ResponseEntity> getAllPets() {
List pets = petService.getAllPets();
return ResponseEntity.ok(pets);
}
@PutMapping("/{id}")
public ResponseEntity updatePet(@PathVariable Long id, @Valid @RequestBody PetDTO petDTO) {
Pet updatedPet = petService.updatePet(id, petDTO);
return ResponseEntity.ok("✅ Updated " + updatedPet.getName() + " successfully!");
}
@DeleteMapping("/{id}")
public ResponseEntity deletePet(@PathVariable Long id) {
petService.deletePet(id);
return ResponseEntity.ok("🗑️ Pet removed from store!");
}
}
```
---
## 🎪 Chapter 6: The Status Magic Show (ResponseEntity)
### 🎭 Why Use ResponseEntity?
Think of `ResponseEntity` as a **magical envelope** 📮 that can carry:
- 📄 Your message (body)
- 🏷️ Status codes (200 OK, 404 Not Found, 500 Error)
- 📎 Extra info (headers)
```java
@RestController
@RequestMapping("/api/magic")
public class MagicController {
// ✅ Success Response
@GetMapping("/success")
public ResponseEntity successMagic() {
return ResponseEntity.ok("🎉 Magic spell worked perfectly!");
}
// ➕ Created Response
@PostMapping("/create")
public ResponseEntity createMagic(@RequestBody String spell) {
return ResponseEntity.status(HttpStatus.CREATED)
.header("Magic-Level", "Expert")
.body("✨ New spell created: " + spell);
}
// 🚫 Not Found Response
@GetMapping("/missing")
public ResponseEntity missingMagic() {
return ResponseEntity.status(HttpStatus.NOT_FOUND)
.body("🔍 Oops! This magic spell doesn't exist!");
}
// 🛡️ Custom Response with Headers
@GetMapping("/protected")
public ResponseEntity protectedMagic() {
return ResponseEntity.ok()
.header("Access-Control-Allow-Origin", "*")
.header("Magic-Protection", "High")
.body("🛡️ Protected magic accessed successfully!");
}
}
```
---
## 🚨 Chapter 7: The Error Superhero (Global Exception Handling)
### 🦸♂️ Meet @ControllerAdvice - The Error Superhero!
When things go wrong in your app, `@ControllerAdvice` swoops in like a superhero to save the day! 🦸♂️
```java
// 🚨 Custom Exception Classes
public class PetNotFoundException extends RuntimeException {
public PetNotFoundException(String message) {
super(message);
}
}
public class InvalidPetDataException extends RuntimeException {
public InvalidPetDataException(String message) {
super(message);
}
}
// 🦸♂️ Global Exception Handler
@ControllerAdvice
public class GlobalExceptionHandler {
// 🔍 Handle "Not Found" errors
@ExceptionHandler(PetNotFoundException.class)
public ResponseEntity handlePetNotFound(PetNotFoundException ex) {
ErrorResponse error = new ErrorResponse(
"PET_NOT_FOUND",
"🔍 " + ex.getMessage(),
LocalDateTime.now()
);
return ResponseEntity.status(HttpStatus.NOT_FOUND).body(error);
}
// ❌ Handle validation errors
@ExceptionHandler(MethodArgumentNotValidException.class)
public ResponseEntity handleValidationErrors(MethodArgumentNotValidException ex) {
String errorMessage = ex.getBindingResult()
.getFieldErrors()
.stream()
.map(FieldError::getDefaultMessage)
.collect(Collectors.joining(", "));
ErrorResponse error = new ErrorResponse(
"VALIDATION_ERROR",
"❌ " + errorMessage,
LocalDateTime.now()
);
return ResponseEntity.status(HttpStatus.BAD_REQUEST).body(error);
}
// 💥 Handle general errors
@ExceptionHandler(Exception.class)
public ResponseEntity handleGeneralError(Exception ex) {
ErrorResponse error = new ErrorResponse(
"INTERNAL_ERROR",
"💥 Oops! Something went wrong: " + ex.getMessage(),
LocalDateTime.now()
);
return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(error);
}
}
// 📋 Error Response Class
public class ErrorResponse {
private String errorCode;
private String message;
private LocalDateTime timestamp;
public ErrorResponse(String errorCode, String message, LocalDateTime timestamp) {
this.errorCode = errorCode;
this.message = message;
this.timestamp = timestamp;
}
// 🎁 Getters and setters
}
```
---
## 🌐 Chapter 8: The Complete REST API Universe
### 🎯 **Understanding HTTP Methods - The 6 Superpowers**
Think of HTTP methods as different **superpowers** for talking to your API! 🦸♂️
| Method | Superpower | Purpose | Example |
|--------|------------|---------|---------|
| **GET** | 👀 **Reader** | Get data, never changes anything | Get user profile |
| **POST** | ➕ **Creator** | Create new resources | Add new user |
| **PUT** | 🔄 **Replacer** | Replace entire resource | Update complete user profile |
| **PATCH** | ✏️ **Editor** | Update part of resource | Change just user email |
| **DELETE** | 🗑️ **Destroyer** | Remove resources | Delete user account |
| **TRACE** | 🔍 **Detective** | Debug requests (rarely used) | Check request path |
### 🎪 **HTTP Status Codes - The Response Theater**
```java
@RestController
@RequestMapping("/api/demo")
public class StatusCodeController {
// ✅ 2xx - Success Family
@GetMapping("/success")
public ResponseEntity success() {
return ResponseEntity.ok("✅ 200 OK - Everything is perfect!");
}
@PostMapping("/created")
public ResponseEntity created() {
return ResponseEntity.status(HttpStatus.CREATED) // 201
.body("🎉 201 CREATED - New resource born!");
}
@PutMapping("/accepted")
public ResponseEntity accepted() {
return ResponseEntity.status(HttpStatus.ACCEPTED) // 202
.body("👍 202 ACCEPTED - Request received, processing...");
}
@DeleteMapping("/no-content")
public ResponseEntity noContent() {
return ResponseEntity.noContent().build(); // 204 - Success but no content to return
}
// ❌ 4xx - Client Error Family (Your fault!)
@GetMapping("/bad-request")
public ResponseEntity badRequest() {
return ResponseEntity.badRequest() // 400
.body("😵 400 BAD REQUEST - You sent wrong data!");
}
@GetMapping("/unauthorized")
public ResponseEntity unauthorized() {
return ResponseEntity.status(HttpStatus.UNAUTHORIZED) // 401
.body("🚫 401 UNAUTHORIZED - Who are you?");
}
@GetMapping("/forbidden")
public ResponseEntity forbidden() {
return ResponseEntity.status(HttpStatus.FORBIDDEN) // 403
.body("🛡️ 403 FORBIDDEN - You can't access this!");
}
@GetMapping("/not-found")
public ResponseEntity notFound() {
return ResponseEntity.notFound().build(); // 404 - Resource doesn't exist
}
// 💥 5xx - Server Error Family (Our fault!)
@GetMapping("/server-error")
public ResponseEntity serverError() {
return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR) // 500
.body("💥 500 INTERNAL SERVER ERROR - We messed up!");
}
}
```
### 🤔 **The Great HTTP Method Debate - Can We Mix & Match?**
#### 🎭 **Can we use POST for GET operations?**
```java
// 🚫 DON'T DO THIS - But technically works
@PostMapping("/get-users-wrong") // ❌ Wrong approach
public List getUsersWrong(@RequestBody SearchCriteria criteria) {
return userService.searchUsers(criteria);
}
// ✅ CORRECT APPROACH
@GetMapping("/users") // ✅ Right approach
public List getUsers(@RequestParam String name, @RequestParam Integer age) {
return userService.searchUsers(name, age);
}
// 🤷♂️ WHEN POST for READ is acceptable
@PostMapping("/users/search") // ✅ Complex search with lots of parameters
public List searchUsers(@RequestBody ComplexSearchCriteria criteria) {
// When search criteria is too complex for URL parameters
return userService.complexSearch(criteria);
}
```
**🔍 Limitations of using POST for GET:**
- 🚫 **Not cacheable** - Browsers/proxies won't cache POST requests
- 🚫 **Not bookmarkable** - Can't save the URL and get same result later
- 🚫 **SEO unfriendly** - Search engines don't index POST endpoints
- 🚫 **Breaks REST principles** - Confuses other developers
- 🚫 **Not idempotent** - Multiple calls might have different effects
#### 🔄 **Can we use PUT for POST operations?**
```java
// 🚫 DON'T DO THIS
@PutMapping("/users") // ❌ Creating with PUT at collection level
public User createUserWrong(@RequestBody User user) {
return userService.createUser(user); // Creates new user
}
// ✅ CORRECT USAGE
@PostMapping("/users") // ✅ Create new user
public User createUser(@RequestBody User user) {
return userService.createUser(user);
}
@PutMapping("/users/{id}") // ✅ Replace entire user
public User updateUser(@PathVariable Long id, @RequestBody User user) {
return userService.replaceUser(id, user);
}
// 🤷♂️ WHEN PUT for creation is acceptable
@PutMapping("/users/{id}") // ✅ Upsert pattern
public User upsertUser(@PathVariable Long id, @RequestBody User user) {
// If exists, replace it. If not, create it.
return userService.upsertUser(id, user);
}
```
**🔍 Limitations of using PUT for creation:**
- 🚫 **Client must know ID** - PUT expects client to provide resource identifier
- 🚫 **Not safe for auto-generated IDs** - Databases usually generate IDs
- 🚫 **Idempotency issues** - Multiple PUT calls should have same effect
- 🚫 **Semantic confusion** - PUT means "replace", not "create"
### 🎯 **Industry Best Practices & Anti-Patterns**
```java
// 🏭 REAL INDUSTRY SCENARIOS
// ❌ ANTI-PATTERN: Using GET for actions that change data
@GetMapping("/users/{id}/delete") // 🚫 NEVER DO THIS!
public String dangerousDelete(@PathVariable Long id) {
userService.deleteUser(id); // Changes data with GET!
return "deleted";
}
// ❌ ANTI-PATTERN: Using POST for everything
@PostMapping("/get-user") // 🚫 Wrong
@PostMapping("/update-user") // 🚫 Wrong
@PostMapping("/delete-user") // 🚫 Wrong
// ✅ CORRECT PATTERNS
@GetMapping("/users/{id}") // ✅ Get user
@PostMapping("/users") // ✅ Create user
@PutMapping("/users/{id}") // ✅ Replace user
@PatchMapping("/users/{id}") // ✅ Update user partially
@DeleteMapping("/users/{id}") // ✅ Delete user
// 🎯 ADVANCED REAL-WORLD PATTERNS
@PostMapping("/users/{id}/activate") // ✅ Action endpoints
@PostMapping("/users/bulk-import") // ✅ Bulk operations
@PostMapping("/auth/login") // ✅ Authentication
@PostMapping("/password/reset") // ✅ Complex operations
```
## 🏗️ Chapter 9: The Complete MVC Architecture Kingdom
### 🏰 Understanding the Kingdom Structure with DTO/POJO Flow
Think of your Spring Boot app as a **magical kingdom** 🏰 with different workers and their data carriers:
```
🌍 Outside World (JSON)
↓
📦 DTO (Data Transfer Object) - "I carry data between layers"
↓
🎭 CONTROLLER (Gatekeeper) - "I receive requests and DTOs"
↓
🔄 DTO → Entity Conversion (Mapper)
↓
🧠 SERVICE (Royal Advisor) - "I work with Entities and business logic"
↓
🏷️ ENTITY (Database Model) - "I represent database table"
↓
💾 REPOSITORY (Royal Librarian) - "I talk to database"
↓
🏛️ DATABASE (Royal Treasury)
↑
🔄 Entity → DTO Conversion (for response)
↑
📦 Response DTO - "I carry response data back"
↑
🌍 Outside World (JSON Response)
```
### 🎪 **Complete MVC Flow with Data Transformation**
```java
// 📦 1. REQUEST DTO - What client sends
public class CreateUserRequestDTO {
@NotBlank(message = "Name is required")
private String fullName;
@Email(message = "Invalid email format")
private String email;
@Min(value = 18, message = "Must be 18+")
private Integer age;
private String department;
// getters/setters
}
// 📦 2. RESPONSE DTO - What we send back
public class UserResponseDTO {
private Long id;
private String fullName;
private String email;
private Integer age;
private String department;
private LocalDateTime createdAt;
private String status;
// getters/setters - NO sensitive data like passwords!
}
// 🏷️ 3. ENTITY - Database representation
@Entity
@Table(name = "users")
public class User {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
@Column(nullable = false)
private String fullName;
@Column(unique = true, nullable = false)
private String email;
private Integer age;
private String department;
private String encryptedPassword; // 🔐 Sensitive data stays in entity
@CreationTimestamp
private LocalDateTime createdAt;
@UpdateTimestamp
private LocalDateTime updatedAt;
@Enumerated(EnumType.STRING)
private UserStatus status;
// getters/setters
}
// 🎭 4. CONTROLLER - The Traffic Manager
@RestController
@RequestMapping("/api/users")
@Validated
public class UserController {
private final UserService userService;
private final UserMapper userMapper; // 🔄 Handles DTO ↔ Entity conversion
public UserController(UserService userService, UserMapper userMapper) {
this.userService = userService;
this.userMapper = userMapper;
}
@PostMapping
public ResponseEntity createUser(@Valid @RequestBody CreateUserRequestDTO requestDTO) {
// 🔄 Step 1: Convert DTO to Entity
User userEntity = userMapper.toEntity(requestDTO);
// 🧠 Step 2: Pass Entity to Service
User savedUser = userService.createUser(userEntity);
// 🔄 Step 3: Convert Entity back to Response DTO
UserResponseDTO responseDTO = userMapper.toResponseDTO(savedUser);
return ResponseEntity.status(HttpStatus.CREATED).body(responseDTO);
}
@GetMapping("/{id}")
public ResponseEntity getUser(@PathVariable Long id) {
User user = userService.findById(id);
UserResponseDTO responseDTO = userMapper.toResponseDTO(user);
return ResponseEntity.ok(responseDTO);
}
@GetMapping
public ResponseEntity> getAllUsers() {
List users = userService.findAllUsers();
List responseDTOs = userMapper.toResponseDTOList(users);
return ResponseEntity.ok(responseDTOs);
}
}
// 🔄 5. MAPPER - The Translator
@Component
public class UserMapper {
public User toEntity(CreateUserRequestDTO dto) {
User user = new User();
user.setFullName(dto.getFullName());
user.setEmail(dto.getEmail());
user.setAge(dto.getAge());
user.setDepartment(dto.getDepartment());
user.setStatus(UserStatus.ACTIVE);
// 🔐 Handle password encryption here if needed
return user;
}
public UserResponseDTO toResponseDTO(User entity) {
UserResponseDTO dto = new UserResponseDTO();
dto.setId(entity.getId());
dto.setFullName(entity.getFullName());
dto.setEmail(entity.getEmail());
dto.setAge(entity.getAge());
dto.setDepartment(entity.getDepartment());
dto.setCreatedAt(entity.getCreatedAt());
dto.setStatus(entity.getStatus().toString());
// 🔐 Never expose password or sensitive data!
return dto;
}
public List toResponseDTOList(List entities) {
return entities.stream()
.map(this::toResponseDTO)
.collect(Collectors.toList());
}
}
// 🧠 6. SERVICE - Business Logic Handler
@Service
@Transactional
public class UserService {
private final UserRepository userRepository;
private final PasswordEncoder passwordEncoder;
public UserService(UserRepository userRepository, PasswordEncoder passwordEncoder) {
this.userRepository = userRepository;
this.passwordEncoder = passwordEncoder;
}
public User createUser(User user) {
// 🧠 Business Logic 1: Check if email exists
if (userRepository.existsByEmail(user.getEmail())) {
throw new UserAlreadyExistsException("Email already registered");
}
// 🧠 Business Logic 2: Encrypt password if provided
if (user.getEncryptedPassword() != null) {
user.setEncryptedPassword(passwordEncoder.encode(user.getEncryptedPassword()));
}
// 🧠 Business Logic 3: Auto-assign department if empty
if (user.getDepartment() == null) {
user.setDepartment("General");
}
// 💾 Save to database
return userRepository.save(user);
}
public User findById(Long id) {
return userRepository.findById(id)
.orElseThrow(() -> new UserNotFoundException("User not found with ID: " + id));
}
public List findAllUsers() {
return userRepository.findAll();
}
}
// 💾 7. REPOSITORY - Database Communication
@Repository
public interface UserRepository extends JpaRepository {
boolean existsByEmail(String email);
List findByDepartment(String department);
List findByStatus(UserStatus status);
@Query("SELECT u FROM User u WHERE u.age BETWEEN :minAge AND :maxAge")
List findByAgeRange(@Param("minAge") Integer minAge, @Param("maxAge") Integer maxAge);
}
```
### 🎯 **Why This Architecture is POWERFUL**
1. **🛡️ Security**: Sensitive data (passwords) never leaves the Entity layer
2. **🔄 Flexibility**: Different DTOs for different operations (Create vs Update vs Response)
3. **📝 Validation**: Request DTOs validate input at the boundary
4. **🧹 Clean Code**: Each layer has single responsibility
5. **🔧 Maintainability**: Easy to modify without affecting other layers
6. **📊 Performance**: Response DTOs only send needed data
7. **🎯 Testability**: Each layer can be tested independently
### 🎪 The Flow in Action
```java
// 🌐 1. Client sends request to Controller
@RestController
@RequestMapping("/api/students")
public class StudentController {
private final StudentService studentService;
public StudentController(StudentService studentService) {
this.studentService = studentService;
}
// 🎭 Controller receives request and passes to Service
@PostMapping
public ResponseEntity addStudent(@RequestBody StudentDTO studentDTO) {
Student savedStudent = studentService.createStudent(studentDTO);
return ResponseEntity.status(HttpStatus.CREATED)
.body("🎓 Student " + savedStudent.getName() + " enrolled successfully!");
}
}
// 🧠 2. Service handles business logic
@Service
public class StudentService {
private final StudentRepository studentRepository;
public StudentService(StudentRepository studentRepository) {
this.studentRepository = studentRepository;
}
public Student createStudent(StudentDTO studentDTO) {
// 🧠 Business logic: Check if email already exists
if (studentRepository.existsByEmail(studentDTO.getEmail())) {
throw new RuntimeException("📧 Student with this email already exists!");
}
// 🔄 Convert DTO to Entity
Student student = new Student();
student.setName(studentDTO.getName());
student.setEmail(studentDTO.getEmail());
student.setAge(studentDTO.getAge());
// 💾 Pass to Repository to save
return studentRepository.save(student);
}
}
// 💾 3. Repository talks to Database
@Repository
public interface StudentRepository extends JpaRepository {
boolean existsByEmail(String email);
List findByAgeGreaterThan(Integer age);
@Query("SELECT s FROM Student s WHERE s.name LIKE %:name%")
List findStudentsByNameContaining(@Param("name") String name);
}
```
### 🚀 **Advanced REST Patterns Used in Industry**
```java
// 🎯 BULK OPERATIONS
@PostMapping("/users/bulk")
public ResponseEntity bulkCreateUsers(@RequestBody List users) {
BulkOperationResult result = userService.bulkCreate(users);
return ResponseEntity.ok(result);
}
// 🔍 COMPLEX SEARCH WITH POST (when GET isn't enough)
@PostMapping("/users/search") // ✅ Acceptable when search is complex
public ResponseEntity> searchUsers(@RequestBody UserSearchCriteria criteria) {
// When you need complex search with multiple filters, sorting, pagination
return ResponseEntity.ok(userService.complexSearch(criteria));
}
// 🎯 ACTION-BASED ENDPOINTS
@PostMapping("/users/{id}/activate") // ✅ User actions
@PostMapping("/users/{id}/deactivate")
@PostMapping("/orders/{id}/cancel")
@PostMapping("/products/{id}/publish")
// 🔄 BATCH UPDATES
@PatchMapping("/users/batch")
public ResponseEntity batchUpdateUsers(@RequestBody BatchUpdateRequest request) {
userService.batchUpdate(request);
return ResponseEntity.ok("Updated " + request.getUserIds().size() + " users");
}
// 📊 AGGREGATION ENDPOINTS
@GetMapping("/users/statistics")
public ResponseEntity getUserStatistics() {
return ResponseEntity.ok(userService.getStatistics());
}
// 🗂️ NESTED RESOURCE OPERATIONS
@GetMapping("/users/{userId}/orders") // Get user's orders
@PostMapping("/users/{userId}/orders") // Create order for user
@GetMapping("/categories/{catId}/products") // Get products in category
```
### 🎭 **HTTP Method Characteristics Comparison**
| Aspect | GET | POST | PUT | PATCH | DELETE |
|--------|-----|------|-----|-------|--------|
| **Safe** | ✅ Yes | ❌ No | ❌ No | ❌ No | ❌ No |
| **Idempotent** | ✅ Yes | ❌ No | ✅ Yes | ❌ No | ✅ Yes |
| **Cacheable** | ✅ Yes | ❌ No | ❌ No | ❌ No | ❌ No |
| **Request Body** | ❌ No | ✅ Yes | ✅ Yes | ✅ Yes | ❌ Optional |
| **Response Body** | ✅ Yes | ✅ Yes | ✅ Yes | ✅ Yes | ❌ Optional |
**🔍 Definitions:**
- **Safe**: Doesn't change server state
- **Idempotent**: Multiple identical requests have same effect as single request
- **Cacheable**: Response can be stored and reused
---
## 🎨 Chapter 10: Creating Your Own Magic Stickers (Custom Annotations)
### ✨ Advanced Magic - Making Your Own Annotations
```java
// 📝 Create Custom Annotation
@Target(ElementType.METHOD) // 🎯 Can be used on methods
@Retention(RetentionPolicy.RUNTIME) // 🕐 Available at runtime
public @interface LogExecutionTime {
String value() default "Method executed";
}
// 🎪 Aspect to Handle the Annotation
@Aspect
@Component
public class LoggingAspect {
@Around("@annotation(logExecutionTime)")
public Object logExecutionTime(ProceedingJoinPoint joinPoint, LogExecutionTime logExecutionTime) throws Throwable {
long startTime = System.currentTimeMillis();
Object result = joinPoint.proceed();
long executionTime = System.currentTimeMillis() - startTime;
System.out.println("⏱️ " + logExecutionTime.value() + " took " + executionTime + "ms");
return result;
}
}
// 🎯 Using Your Custom Annotation
@Service
public class PetService {
@LogExecutionTime("Finding all pets")
public List getAllPets() {
// Your method logic
return petRepository.findAll();
}
}
```
---
## 📁 Chapter 11: File Magic Tricks
### 📄 Working with Files in Spring Boot
```java
@RestController
@RequestMapping("/api/files")
public class FileController {
// 📤 Upload File
@PostMapping("/upload")
public ResponseEntity uploadFile(@RequestParam("file") MultipartFile file) {
try {
String fileName = file.getOriginalFilename();
Path path = Paths.get("uploads/" + fileName);
Files.createDirectories(path.getParent());
Files.write(path, file.getBytes());
return ResponseEntity.ok("📁 File uploaded successfully: " + fileName);
} catch (IOException e) {
return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
.body("💥 Failed to upload file: " + e.getMessage());
}
}
// 📥 Download File
@GetMapping("/download/{filename}")
public ResponseEntity downloadFile(@PathVariable String filename) {
try {
Path path = Paths.get("uploads/" + filename);
Resource resource = new UrlResource(path.toUri());
if (resource.exists()) {
return ResponseEntity.ok()
.header(HttpHeaders.CONTENT_DISPOSITION, "attachment; filename=\"" + filename + "\"")
.body(resource);
} else {
return ResponseEntity.notFound().build();
}
} catch (Exception e) {
return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
}
}
// 📝 Save Data to File
@PostMapping("/save-pets")
public ResponseEntity savePetsToFile(@RequestBody List pets) {
try {
StringBuilder content = new StringBuilder();
content.append("🐾 Pet Store Report\n");
content.append("==================\n\n");
for (Pet pet : pets) {
content.append("Name: ").append(pet.getName()).append("\n");
content.append("Type: ").append(pet.getType()).append("\n");
content.append("Age: ").append(pet.getAge()).append("\n");
content.append("Color: ").append(pet.getColor()).append("\n");
content.append("-------------------\n");
}
Path path = Paths.get("reports/pets-report.txt");
Files.createDirectories(path.getParent());
Files.write(path, content.toString().getBytes());
return ResponseEntity.ok("📊 Pet report saved successfully!");
} catch (IOException e) {
return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
.body("💥 Failed to save report: " + e.getMessage());
}
}
}
```
---
## 🎯 Grand Finale Project: "SuperHero Academy Management System"
### 🦸♂️ Let's Build Something AMAZING!
Combine everything you've learned to create a SuperHero Academy where you can:
- 🦸♂️ Register new superheroes
- 🏫 Assign them to classes
- 📊 Generate reports
- 📁 Export data to files
```java
// 🦸♂️ SuperHero Entity
@Entity
@Table(name = "super_heroes")
public class SuperHero {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
@Column(nullable = false)
private String heroName;
@Column(nullable = false)
private String realName;
private String superPower;
private String weakness;
private Integer powerLevel;
@Enumerated(EnumType.STRING)
private HeroClass heroClass;
@CreationTimestamp
private LocalDateTime joinedDate;
// 🎁 Getters and setters
}
// 🏷️ Hero Classes Enum
public enum HeroClass {
BEGINNER("👶 Rookie Heroes"),
INTERMEDIATE("🎯 Skilled Heroes"),
ADVANCED("🌟 Elite Heroes"),
LEGENDARY("👑 Legendary Heroes");
private String description;
HeroClass(String description) {
this.description = description;
}
public String getDescription() { return description; }
}
// 📦 SuperHero DTO
public class SuperHeroDTO {
@NotBlank(message = "🦸♂️ Hero needs a hero name!")
private String heroName;
@NotBlank(message = "👤 Hero needs a real name!")
private String realName;
@NotBlank(message = "⚡ What's their superpower?")
private String superPower;
private String weakness;
@Min(value = 1, message = "💪 Power level must be at least 1!")
@Max(value = 100, message = "💪 Power level can't exceed 100!")
private Integer powerLevel;
@NotNull(message = "🏫 Please assign a hero class!")
private HeroClass heroClass;
// 🎁 Getters and setters
}
```
---
## 🛠️ Tools You'll Need for Your Adventure
### 📋 Essential Tools
- ☕ **Java 17+** - Your coding language
- 🌱 **Spring Boot** - Start at [start.spring.io](https://start.spring.io)
- 💻 **IDE**: IntelliJ IDEA Community (Free) or VS Code
- 🧪 **Postman** - Test your APIs like a pro
- 🐘 **PostgreSQL** or **MySQL** - Your database
### 📚 Learning Resources
- 🌱 [Spring Boot Official Docs](https://spring.io/projects/spring-boot)
- 🎥 YouTube tutorials on Spring Boot
- 📖 Practice coding every day!
---
## 🎊 Congratulations, Hero!
You've completed your Spring Boot adventure! 🎉
You now know how to:
- ✅ Build REST APIs like a boss
- ✅ Handle data with databases
- ✅ ManageErrors gracefully
- ✅ Create beautiful, organized code
- ✅ Work with files
- ✅ Use powerful annotations
### 🚀 What's Next?
- 🔐 Learn Spring Security (for authentication)
- 🐳 Try Docker (containerization)
- ☁️ Deploy to cloud (AWS, Azure, GCP)
- 📊 Add monitoring and logging
- 🧪 Write comprehensive tests
Remember: **Practice makes perfect!** 💪 Keep building projects and you'll become a Spring Boot superhero! 🦸♂️
---
*Made with ❤️ for aspiring developers. Happy coding! 🚀*