Spring Framework & Spring Boot: Complete Notes

Spring Framework
│
├── Core Container
│   ├── spring-core        → IoC and DI fundamentals
│   ├── spring-beans       → BeanFactory, bean definitions
│   ├── spring-context     → ApplicationContext, events
│   └── spring-expression  → SpEL (Spring Expression Language)
│
├── AOP & Instrumentation
│   ├── spring-aop         → Aspect-Oriented Programming
│   └── spring-aspects     → AspectJ integration
│
├── Data Access / Integration
│   ├── spring-jdbc        → JDBC template, exception handling
│   ├── spring-orm         → JPA, Hibernate integration
│   ├── spring-tx          → Transaction management
│   └── spring-messaging   → JMS, Kafka, RabbitMQ
│
├── Web Layer
│   ├── spring-web         → Core web support
│   ├── spring-webmvc      → Spring MVC (DispatcherServlet)
│   └── spring-webflux     → Reactive web (non-blocking)
│
└── Test
    └── spring-test        → MockMvc, @SpringBootTest, etc.

@Component
public class OrderService {
    private final PaymentService paymentService;

    @Autowired  // optional in modern Spring
    public OrderService(PaymentService paymentService) {
        this.paymentService = paymentService;
    }
}

@Component
public class OrderService {
    private PaymentService paymentService;

    @Autowired
    public void setPaymentService(PaymentService paymentService) {
        this.paymentService = paymentService;
    }
}

@Component
public class OrderService {
    @Autowired
    private PaymentService paymentService;
}

@Component
@Scope("prototype")
public class TaskProcessor { }

@Configuration
public class AppConfig {

    @Bean
    public PaymentService paymentService() {
        return new PaymentService();
    }
}

@Aspect
@Component
public class LoggingAspect {

    // Runs before method execution
    @Before("execution(* com.example.service.*.*(..))")
    public void logBefore(JoinPoint jp) {
        System.out.println("Before: " + jp.getSignature());
    }

    // Runs after method returns
    @AfterReturning("execution(* com.example.service.*.*(..))")
    public void logAfter() {
        System.out.println("Method completed.");
    }

    // Wraps the method
    @Around("execution(* com.example.service.*.*(..))")
    public Object logAround(ProceedingJoinPoint pjp) throws Throwable {
        System.out.println("Start");
        Object result = pjp.proceed();
        System.out.println("End");
        return result;
    }
}

my-spring-app/
├── src/
│   ├── main/
│   │   ├── java/com/example/myapp/
│   │   │   ├── MyAppApplication.java     ← Entry point
│   │   │   ├── controller/
│   │   │   │   └── UserController.java
│   │   │   ├── service/
│   │   │   │   └── UserService.java
│   │   │   ├── repository/
│   │   │   │   └── UserRepository.java
│   │   │   └── model/
│   │   │       └── User.java
│   │   └── resources/
│   │       ├── application.properties    ← Config file
│   │       └── static/                   ← Static assets
│   └── test/
│       └── java/com/example/myapp/
│           └── MyAppApplicationTests.java
└── pom.xml                               ← Maven dependencies

@SpringBootApplication   // = @Configuration + @EnableAutoConfiguration + @ComponentScan
public class MyAppApplication {
    public static void main(String[] args) {
        SpringApplication.run(MyAppApplication.class, args);
    }
}

@RestController
@RequestMapping("/api/users")
public class UserController {

    @Autowired
    private UserService userService;

    @GetMapping
    public List<User> getAllUsers() {
        return userService.findAll();
    }

    @GetMapping("/{id}")
    public User getUserById(@PathVariable Long id) {
        return userService.findById(id);
    }

    @PostMapping
    public User createUser(@RequestBody User user) {
        return userService.save(user);
    }

    @PutMapping("/{id}")
    public User updateUser(@PathVariable Long id, @RequestBody User user) {
        return userService.update(id, user);
    }

    @DeleteMapping("/{id}")
    public void deleteUser(@PathVariable Long id) {
        userService.delete(id);
    }
}

# Server
server.port=8080

# Database (H2 in-memory example)
spring.datasource.url=jdbc:h2:mem:testdb
spring.datasource.driver-class-name=org.h2.Driver
spring.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql=true

# App name
spring.application.name=my-spring-app

@Entity
@Table(name = "users")
public class User {

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

    private String name;
    private String email;

    // Getters and Setters
}

@Repository
public interface UserRepository extends JpaRepository<User, Long> {

    // Spring auto-generates: findAll(), findById(), save(), delete(), etc.

    // Custom query by method name:
    List<User> findByName(String name);

    // Custom JPQL query:
    @Query("SELECT u FROM User u WHERE u.email = :email")
    Optional<User> findByEmail(@Param("email") String email);
}

@Service
public class UserService {

    @Autowired
    private UserRepository userRepository;

    public List<User> findAll() {
        return userRepository.findAll();
    }

    public User findById(Long id) {
        return userRepository.findById(id)
                .orElseThrow(() -> new RuntimeException("User not found"));
    }

    public User save(User user) {
        return userRepository.save(user);
    }

    public void delete(Long id) {
        userRepository.deleteById(id);
    }
}

<dependencies>

    <!-- Web (REST API + Embedded Tomcat) -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>

    <!-- JPA + Hibernate -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>

    <!-- Security -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-security</artifactId>
    </dependency>

    <!-- Validation -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-validation</artifactId>
    </dependency>

    <!-- Actuator (Monitoring) -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-actuator</artifactId>
    </dependency>

    <!-- H2 In-memory DB (for testing) -->
    <dependency>
        <groupId>com.h2database</groupId>
        <artifactId>h2</artifactId>
        <scope>runtime</scope>
    </dependency>

    <!-- DevTools (hot reload) -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-devtools</artifactId>
        <scope>runtime</scope>
        <optional>true</optional>
    </dependency>

</dependencies>

@RestControllerAdvice
public class GlobalExceptionHandler {

    @ExceptionHandler(RuntimeException.class)
    public ResponseEntity<String> handleRuntimeException(RuntimeException ex) {
        return ResponseEntity.status(HttpStatus.NOT_FOUND).body(ex.getMessage());
    }

    @ExceptionHandler(Exception.class)
    public ResponseEntity<String> handleGenericException(Exception ex) {
        return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("Something went wrong");
    }
}

@Configuration
@EnableWebSecurity
public class SecurityConfig {

    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        http
            .authorizeHttpRequests(auth -> auth
                .requestMatchers("/api/public/**").permitAll()
                .anyRequest().authenticated()
            )
            .httpBasic(Customizer.withDefaults());
        return http.build();
    }
}

management.endpoints.web.exposure.include=*
management.endpoint.health.show-details=always

Phase 1 — Spring Core
  ✅ IoC & DI
  ✅ Bean lifecycle & scopes
  ✅ Annotations

Phase 2 — Spring Boot Basics
  ✅ Project setup (Spring Initializr)
  ✅ REST API creation
  ✅ application.properties config

Phase 3 — Data Layer
  → Spring Data JPA
  → Hibernate ORM
  → MySQL / PostgreSQL integration

Phase 4 — Security & Validation
  → Spring Security (JWT Auth)
  → Bean Validation (@Valid, @NotNull)

Phase 5 — Advanced Topics
  → Spring AOP
  → Spring Cache
  → Spring Async
  → Spring Actuator + Monitoring

Phase 6 — Microservices
  → Spring Cloud
  → Eureka (Service Discovery)
  → API Gateway
  → Feign Client
  → Config Server