DEV Community: Hunor Vadasz-Perhat

📌spring-note-006: Bean Definition Inheritance

Hunor Vadasz-Perhat — Wed, 19 Feb 2025 14:28:01 +0000

(Reference: Spring Docs - Bean Definition Inheritance)

🔹 What is Bean Definition Inheritance?

💡 Spring allows one bean to inherit properties from another bean.

💡 Useful for reusing common configurations across multiple beans.

💡 Implemented via XML (parent attribute) or Java-based configuration (@Bean inheritance).

📌 How to Implement Bean Definition Inheritance

1️⃣ XML-Based Bean Inheritance (Legacy)

✔ In traditional XML configuration, you can define a parent bean with common properties and let child beans inherit them.

📌 Example (XML Configuration - Not Recommended for Modern Apps)

<bean id="baseShip" abstract="true">
    <property name="captain" value="Blackbeard"/>
    <property name="crewSize" value="100"/>
</bean>

<bean id="pirateShip" parent="baseShip">
    <property name="shipName" value="The Black Pearl"/>
</bean>

<bean id="navyShip" parent="baseShip">
    <property name="shipName" value="The Royal Fortune"/>
</bean>

🔥 Both pirateShip and navyShip inherit properties from baseShip!

2️⃣ Java-Based Bean Inheritance

✔ Modern Spring applications use Java-based configuration instead of XML.

✔ Use inheritance in Java classes to achieve the same effect.

📌 Example: Abstract Parent Bean

public abstract class BaseShip {
    protected String captain = "Blackbeard";
    protected int crewSize = 100;

    public String getCaptain() {
        return captain;
    }

    public int getCrewSize() {
        return crewSize;
    }
}

📌 Child Beans Inheriting Properties

import org.springframework.stereotype.Component;

@Component
public class PirateShip extends BaseShip {
    private String shipName = "The Black Pearl";

    public String getShipName() {
        return shipName;
    }
}

@Component
public class NavyShip extends BaseShip {
    private String shipName = "The Royal Fortune";

    public String getShipName() {
        return shipName;
    }
}

🔥 Both PirateShip and NavyShip automatically inherit captain & crew size from BaseShip!

3️⃣ Using `@Bean` Methods for Inheritance

✔ You can also define beans using @Configuration and have them inherit properties.

📌 Example: Java Config with @Bean Inheritance

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class ShipConfig {

    @Bean
    public BaseShip baseShip() {
        return new BaseShip();
    }

    @Bean
    public PirateShip pirateShip() {
        PirateShip ship = new PirateShip();
        ship.captain = baseShip().getCaptain();
        ship.crewSize = baseShip().getCrewSize();
        return ship;
    }

    @Bean
    public NavyShip navyShip() {
        NavyShip ship = new NavyShip();
        ship.captain = baseShip().getCaptain();
        ship.crewSize = baseShip().getCrewSize();
        return ship;
    }
}

🔥 This approach ensures that all ships share common properties while allowing modifications!

📌 Hands-On Project: Testing Bean Inheritance

💡 Let’s modify our Spring Boot app to test bean inheritance!

Step 1: Create Parent and Child Beans

📌 BaseShip.java

public abstract class BaseShip {
    protected String captain = "Blackbeard";
    protected int crewSize = 100;

    public String getCaptain() {
        return captain;
    }

    public int getCrewSize() {
        return crewSize;
    }
}

📌 PirateShip.java

import org.springframework.stereotype.Component;

@Component
public class PirateShip extends BaseShip {
    private String shipName = "The Black Pearl";

    public String getShipName() {
        return shipName;
    }
}

📌 NavyShip.java

import org.springframework.stereotype.Component;

@Component
public class NavyShip extends BaseShip {
    private String shipName = "The Royal Fortune";

    public String getShipName() {
        return shipName;
    }
}

Step 2: Create a REST Controller to Test Inheritance

📌 ShipController.java

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/ships")
public class ShipController {
    private final PirateShip pirateShip;
    private final NavyShip navyShip;

    public ShipController(PirateShip pirateShip, NavyShip navyShip) {
        this.pirateShip = pirateShip;
        this.navyShip = navyShip;
    }

    @GetMapping("/pirate")
    public String getPirateShip() {
        return "🏴‍☠️ Pirate Ship: " + pirateShip.getShipName() + 
               ", Captain: " + pirateShip.getCaptain() + 
               ", Crew: " + pirateShip.getCrewSize();
    }

    @GetMapping("/navy")
    public String getNavyShip() {
        return "⚓ Navy Ship: " + navyShip.getShipName() + 
               ", Captain: " + navyShip.getCaptain() + 
               ", Crew: " + navyShip.getCrewSize();
    }
}

Step 3: Run the Application & Test

💡 Run the app using:

mvn spring-boot:run

./mvnw spring-boot:run

📌 Test Bean Inheritance in Browser:
1️⃣ Check the Pirate Ship:

http://localhost:8080/ships/pirate

Response:

 🏴‍☠️ Pirate Ship: The Black Pearl, Captain: Blackbeard, Crew: 100

2️⃣ Check the Navy Ship:

http://localhost:8080/ships/navy

Response:

 ⚓ Navy Ship: The Royal Fortune, Captain: Blackbeard, Crew: 100

🔥 Boom! You just witnessed Bean Definition Inheritance in action!

📌 Summary of Step 6

✅ Bean Definition Inheritance allows reusing common bean configurations.

✅ Implemented via XML (parent attribute) or Java-based configuration (@Bean).

✅ Java-based inheritance is preferred for modern Spring Boot applications.

✅ Best practice: Use abstract base classes for shared properties & behavior.

📌 Topics Covered in This Section
📜 Bean Definition Inheritance (✔️ Covered)

XML-based inheritance (parent attribute) – for legacy projects.
Java-based inheritance (extending base class) – recommended modern approach.
Using @bean configuration for inheritance.

🛠️ Spring Boot & Bean Inheritance (✔️ Covered)

Best practices for using inheritance in real-world applications.
How to share properties across multiple bean definitions.
Differences between XML-based and Java-based configurations.

🔥 Key Takeaways You Need to Remember:
✅ Bean Definition Inheritance allows reusing properties in multiple beans.
✅ XML-based inheritance (parent) is for legacy projects; modern apps use Java-based.
✅ Best practice: Use abstract base classes to share logic across beans.
✅ Use @bean methods for more flexibility when defining bean inheritance.

📌 spring-note-005: Customizing the Nature of a Bean

Hunor Vadasz-Perhat — Tue, 11 Feb 2025 10:50:05 +0000

(Reference: Spring Docs - Customizing Beans)

🔹 Why Customize Beans?

💡 Spring allows us to modify how beans behave using annotations and configurations.

💡 Customization gives us control over bean instantiation, dependency resolution, and initialization.

📌 Key Customization Features

🔥 Spring provides several ways to customize beans:

1️⃣ Lazy vs. Eager Initialization (@Lazy)

2️⃣ Defining Primary Beans (@Primary)

3️⃣ Using Qualifiers for Specific Bean Selection (@Qualifier)

4️⃣ Conditional Beans (@Conditional)

1️⃣ Lazy vs. Eager Initialization (`@Lazy`)

🔥 By default, Singleton Beans are created at startup.

🔥 With @Lazy, Spring delays bean creation until it is actually needed.

📌 Example:

import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Component;

@Component
@Lazy
public class Kraken {
    public Kraken() {
        System.out.println("🦑 Kraken is awakening lazily...");
    }
}

Test with a REST Controller:

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/lazy")
public class LazyController {
    private final Kraken kraken;

    public LazyController(Kraken kraken) {
        this.kraken = kraken;
    }

    @GetMapping
    public String awakenKraken() {
        return "⚓ Kraken is now awake!";
    }
}

💡 Bean is NOT created at startup! It is only created when /lazy endpoint is called.

2️⃣ Defining Primary Beans (`@Primary`)

🔥 If multiple beans of the same type exist, Spring needs to know which one to use by default.

🔥 @Primary marks a bean as the default choice unless explicitly overridden.

📌 Example:

import org.springframework.context.annotation.Primary;
import org.springframework.stereotype.Component;

@Component
@Primary
public class MainCaptain implements Captain {
    @Override
    public String command() {
        return "🏴‍☠️ Main Captain: Full speed ahead!";
    }
}

@Component
public class BackupCaptain implements Captain {
    @Override
    public String command() {
        return "⚓ Backup Captain: Ready if needed!";
    }
}

💡 When injecting Captain, MainCaptain is used by default.

3️⃣ Using Qualifiers for Specific Bean Selection (`@Qualifier`)

🔥 When multiple beans exist, we can use @Qualifier to specify which one to inject.

📌 Example:

import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Component;

@Component
public class Ship {
    private final Captain captain;

    public Ship(@Qualifier("backupCaptain") Captain captain) {
        this.captain = captain;
    }

    public String sail() {
        return captain.command();
    }
}

💡 Now BackupCaptain is explicitly used instead of MainCaptain.

4️⃣ Conditional Beans (`@Conditional`)

🔥 @Conditional allows us to register beans based on runtime conditions.

🔥 Useful for feature toggles, environment-based configurations, or platform-specific beans.

📌 Example: Load a bean only if a certain property is set.

import org.springframework.context.annotation.Conditional;
import org.springframework.stereotype.Component;

@Component
@Conditional(StormyWeatherCondition.class)
public class StormySail {
    public StormySail() {
        System.out.println("⛈️ Storm detected! Adjusting sails...");
    }
}

📌 Custom Condition Class:

import org.springframework.context.annotation.Condition;
import org.springframework.context.annotation.ConditionContext;
import org.springframework.core.type.AnnotatedTypeMetadata;

public class StormyWeatherCondition implements Condition {
    @Override
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        return "stormy".equals(context.getEnvironment().getProperty("weather.mode"));
    }
}

💡 If weather.mode=stormy is set in application.properties, StormySail bean will be loaded.

📌 Hands-On Project: Testing Bean Customization

💡 Let’s modify our Spring Boot app to test these customizations!

Step 1: Create a Spring Boot Project

1️⃣ Go to Spring Initializr

2️⃣ Select:

Spring Boot Version: Latest stable
Dependencies: Spring Web
Packaging: Jar 3️⃣ Click Generate and extract the zip file.

Step 2: Define Beans with Custom Behavior

📌 Lazy Bean:

@Component
@Lazy
public class Kraken {
    public Kraken() {
        System.out.println("🦑 Kraken is awakening lazily...");
    }
}

📌 Primary & Alternative Beans:

@Component
@Primary
public class MainCaptain implements Captain {
    @Override
    public String command() {
        return "🏴‍☠️ Main Captain: Full speed ahead!";
    }
}

@Component
public class BackupCaptain implements Captain {
    @Override
    public String command() {
        return "⚓ Backup Captain: Ready if needed!";
    }
}

📌 Conditional Bean:

@Component
@Conditional(StormyWeatherCondition.class)
public class StormySail {
    public StormySail() {
        System.out.println("⛈️ Storm detected! Adjusting sails...");
    }
}

Step 3: Create a REST Controller to Test Beans

📌 Lazy Bean Activation:

@RestController
@RequestMapping("/lazy")
public class LazyController {
    private final Kraken kraken;

    public LazyController(Kraken kraken) {
        this.kraken = kraken;
    }

    @GetMapping
    public String awakenKraken() {
        return "⚓ Kraken is now awake!";
    }
}

📌 Check which Captain is Injected:

@RestController
@RequestMapping("/captain")
public class CaptainController {
    private final Captain captain;

    public CaptainController(Captain captain) {
        this.captain = captain;
    }

    @GetMapping
    public String getCaptain() {
        return captain.command();
    }
}

Step 4: Run the Application & Test

💡 Run the app using:

mvn spring-boot:run

./mvnw spring-boot:run

📌 Test Lazy Initialization:

Open browser and visit: http://localhost:8080/lazy
You should see: "⚓ Kraken is now awake!"
And in logs: "🦑 Kraken is awakening lazily..."

📌 Test Default vs. Qualified Bean Injection:

Open browser and visit: http://localhost:8080/captain
If @Primary is used → "🏴‍☠️ Main Captain: Full speed ahead!"
If @Qualifier("backupCaptain") is used → "⚓ Backup Captain: Ready if needed!"

📌 Summary

✅ @Lazy delays bean creation until needed.

✅ @Primary sets the default bean when multiple exist.

✅ @Qualifier allows precise bean selection.

✅ @Conditional loads beans based on runtime conditions.

📌 Topics Covered in This Section
📜 Customizing Beans in Spring (✔️ Covered)

Lazy vs. Eager Initialization (@lazy).
Setting Default Beans with @primary.
Overriding with @Qualifier when multiple beans exist.
Conditional Beans (@Conditional) for dynamic configurations.

🛠️ Spring Boot & Customization (✔️ Covered)

When to use lazy initialization for performance optimization.
How @primary works in multi-bean scenarios.
Using @Conditional to load beans based on environment properties.

🔥 Key Takeaways You Need to Remember:
✅ @lazy prevents beans from being created at startup.
✅ @primary sets the default bean when multiple exist.
✅ @Qualifier ensures the correct bean is injected.
✅ @Conditional allows runtime-based bean loading.

📌 spring-note-004: Understanding Spring Bean Scopes

Hunor Vadasz-Perhat — Tue, 11 Feb 2025 10:41:10 +0000

(Reference: Spring Docs - Bean Scopes)

🔹 What is a Bean Scope?

💡 Bean Scope determines how long a bean lives and how many instances exist in the application.

💡 Spring provides different scopes to manage beans depending on the use case.

📌 Types of Bean Scopes in Spring

🔥 Spring defines several bean scopes, divided into two categories:

Singleton & Prototype → Standard scopes (used in ANY Spring app).
Request, Session, Application, WebSocket → Web-specific scopes.

1️⃣ Singleton Scope (Default)

✅ Only ONE instance exists for the entire application context.

✅ Same instance is returned every time the bean is requested.

✅ Best for stateless, reusable components (e.g., Service classes).

📌 Example:

import org.springframework.stereotype.Component;

@Component
public class PirateCaptain {
    public PirateCaptain() {
        System.out.println("🏴‍☠️ Singleton Pirate Captain Created!");
    }
}

🔥 Spring ensures only ONE PirateCaptain instance exists!

2️⃣ Prototype Scope

✅ A NEW instance is created every time the bean is requested.

✅ Used for stateful objects that require separate instances.

✅ Good for expensive objects that should NOT be shared.

📌 Example:

import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;

@Component
@Scope("prototype")
public class TreasureMap {
    public TreasureMap() {
        System.out.println("🗺️ New Treasure Map Created!");
    }
}

🔥 Each time you getBean(TreasureMap.class), a new instance is returned!

3️⃣ Request Scope (For Web Applications)

✅ One instance per HTTP request (lives as long as the request).

✅ Useful for objects needed only during request processing.

📌 Example:

import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;

@Component
@Scope("request")
public class ShipLog {
    public ShipLog() {
        System.out.println("📜 New Ship Log Created for Request!");
    }
}

🔥 Every new HTTP request gets a new ShipLog instance!

4️⃣ Session Scope (For Web Applications)

✅ One instance per user session (persists across multiple requests).

✅ Useful for session-based user data.

📌 Example:

import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;

@Component
@Scope("session")
public class PirateSession {
    public PirateSession() {
        System.out.println("🏴‍☠️ New Pirate Session Created!");
    }
}

🔥 Every user gets their own PirateSession bean across multiple requests.

5️⃣ Application Scope (For Web Applications)

✅ One instance for the ENTIRE application (shared across all requests & users).

✅ Useful for storing global application data.

📌 Example:

import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;

@Component
@Scope("application")
public class GlobalPirateRules {
    public GlobalPirateRules() {
        System.out.println("📜 Global Pirate Rules Initialized!");
    }
}

🔥 The same instance is shared across all users and requests.

📌 Hands-On Project: Exploring Bean Scopes

💡 Let’s create a simple Spring Boot app to experiment with different bean scopes!

Step 1: Create a Spring Boot Project

1️⃣ Go to Spring Initializr

2️⃣ Select:

Spring Boot Version: Latest stable
Dependencies: Spring Web
Packaging: Jar 3️⃣ Click Generate and extract the zip file.

Step 2: Create Beans with Different Scopes

📌 Create a Singleton Bean:

import org.springframework.stereotype.Component;

@Component
public class SingletonPirate {
    public SingletonPirate() {
        System.out.println("🏴‍☠️ Singleton Pirate Created!");
    }
}

📌 Create a Prototype Bean:

import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;

@Component
@Scope("prototype")
public class PrototypeTreasure {
    public PrototypeTreasure() {
        System.out.println("💎 New Prototype Treasure Created!");
    }
}

Step 3: Inject and Test Scopes in a REST Controller

📌 Create a ScopeController to observe bean behavior:

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/scopes")
public class ScopeController {

    private final SingletonPirate singletonPirate;
    private final PrototypeTreasure prototypeTreasure;

    public ScopeController(SingletonPirate singletonPirate, PrototypeTreasure prototypeTreasure) {
        this.singletonPirate = singletonPirate;
        this.prototypeTreasure = prototypeTreasure;
    }

    @GetMapping("/singleton")
    public String getSingleton() {
        return "🏴‍☠️ Singleton Pirate Hash: " + singletonPirate.hashCode();
    }

    @GetMapping("/prototype")
    public String getPrototype() {
        return "💎 Prototype Treasure Hash: " + prototypeTreasure.hashCode();
    }
}

Step 4: Run the Application & Test

💡 Run the app using:

mvn spring-boot:run

./mvnw spring-boot:run

📌 Open browser & test the endpoints:
1️⃣ Call Singleton Endpoint:

http://localhost:8080/scopes/singleton

Response:

 🏴‍☠️ Singleton Pirate Hash: 12345678

Same value every time!

2️⃣ Call Prototype Endpoint Multiple Times:

http://localhost:8080/scopes/prototype

Response:

 💎 Prototype Treasure Hash: 87654321

Different value each time!

🔥 Boom! You just witnessed Spring Bean Scopes in action!

📌 Summary of Step 4

✅ Singleton (Default): One instance per application.

✅ Prototype: A new instance every time.

✅ Request: One instance per HTTP request (Web apps only).

✅ Session: One instance per user session (Web apps only).

✅ Application: One instance for the entire app (Web apps only).

📌 Topics Covered in This Section
📜 Spring Bean Scopes (✔️ Covered)

Singleton (Default scope, one instance per container).
Prototype (New instance every time).
Request Scope (New instance per HTTP request).
Session Scope (New instance per user session).
Application Scope (Shared instance for the entire application).

🛠️ Spring Boot & Scopes (✔️ Covered)

Using @scope annotation.
How singleton vs. prototype works in dependency injection.
Scope behavior in REST APIs.

🔥 Key Takeaways You Need to Remember:
✅ Singleton is the default scope.
✅ Prototype creates a new bean instance every time.
✅ Web scopes (Request, Session, Application) require Spring Web.
✅ Use @scope("prototype") carefully when injecting into Singleton beans (can cause issues).

📌 spring-note-003: Spring Bean Lifecycle

Hunor Vadasz-Perhat — Tue, 11 Feb 2025 09:58:34 +0000

🔹 What is the Spring Bean Lifecycle?

💡 Spring Beans go through multiple phases: creation, initialization, usage, and destruction.

💡 Spring provides hooks to customize these phases (e.g., @PostConstruct, @PreDestroy).

📌 Phases of the Spring Bean Lifecycle

🔥 Step by Step Breakdown:

1️⃣ Bean Instantiation → Spring creates the bean instance.

2️⃣ Populate Properties (Dependency Injection) → Spring injects dependencies.

3️⃣ Bean Name is Set (BeanNameAware#setBeanName())

4️⃣ Bean Factory is Set (BeanFactoryAware#setBeanFactory())

5️⃣ ApplicationContext is Set (ApplicationContextAware#setApplicationContext())

6️⃣ Before Initialization Processing (BeanPostProcessor#postProcessBeforeInitialization())

7️⃣ Custom Initialization Methods:

InitializingBean#afterPropertiesSet()
@PostConstruct
init-method (if specified in XML or @Bean)

8️⃣ After Initialization Processing (BeanPostProcessor#postProcessAfterInitialization())

9️⃣ Bean is Ready for Use! 🚀

🔟 Before Destruction Processing (DestructionAwareBeanPostProcessor#postProcessBeforeDestruction())

1️⃣1️⃣ Custom Destruction Methods:

DisposableBean#destroy()
@PreDestroy
destroy-method (if specified in XML or @Bean)

1️⃣2️⃣ Bean is Removed (Garbage Collected).

🔥 This entire process is controlled by Spring’s ApplicationContext!

📌 Hands-On Project: Bean Lifecycle in Action

💡 Let’s create a small Spring Boot app to observe and control the Bean Lifecycle.

Step 1: Create a Spring Boot Project

1️⃣ Go to Spring Initializr

2️⃣ Select:

Spring Boot Version: Latest stable
Dependencies: Spring Web
Packaging: Jar 3️⃣ Click Generate and extract the zip file.

Step 2: Define a Bean with Lifecycle Hooks

📌 Create a Pirate Bean with Lifecycle Annotations:

package com.example.lifecycle;

import jakarta.annotation.PostConstruct;
import jakarta.annotation.PreDestroy;
import org.springframework.stereotype.Component;

@Component
public class Pirate {

    public Pirate() {
        System.out.println("⚓ Pirate Bean Instantiated!");
    }

    @PostConstruct
    public void prepareForSailing() {
        System.out.println("🏴‍☠️ @PostConstruct: Pirate is ready for adventure!");
    }

    @PreDestroy
    public void retireFromSailing() {
        System.out.println("☠️ @PreDestroy: Pirate is retiring...");
    }
}

💡 What happens here?
✅ Pirate() → Constructor is called (bean instantiation).

✅ @PostConstruct → Called after dependencies are injected but before the bean is used.

✅ @PreDestroy → Called before the bean is destroyed (removed from context).

Step 3: Add BeanPostProcessor to Track Lifecycle Events

📌 Create a PirateLifecycleLogger to observe Spring’s lifecycle hooks:

package com.example.lifecycle;

import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.stereotype.Component;

@Component
public class PirateLifecycleLogger implements BeanPostProcessor {

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) {
        System.out.println("⏳ Before Initialization: " + beanName);
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) {
        System.out.println("✅ After Initialization: " + beanName);
        return bean;
    }
}

💡 What happens here?
✅ postProcessBeforeInitialization() runs before @PostConstruct and afterPropertiesSet().

✅ postProcessAfterInitialization() runs after initialization but before usage.

Step 4: Create the Main Application Class

📌 Modify SpringBootApplication to trigger the lifecycle:

package com.example.lifecycle;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;

@SpringBootApplication
public class LifecycleApplication {
    public static void main(String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(LifecycleApplication.class, args);

        System.out.println("🛳️ Application is Running...");

        // Close context to trigger @PreDestroy
        context.close();
    }
}

💡 Why context.close()?

✅ It manually shuts down the Spring application, triggering @PreDestroy!

Step 5: Run the Application

💡 Run the app using:

mvn spring-boot:run

./mvnw spring-boot:run

👀 Expected Output:

⚓ Pirate Bean Instantiated!
⏳ Before Initialization: pirate
🏴‍☠️ @PostConstruct: Pirate is ready for adventure!
✅ After Initialization: pirate
🛳️ Application is Running...
☠️ @PreDestroy: Pirate is retiring...

🔥 Boom! You just witnessed the Spring Bean Lifecycle in action!

📌 Summary of Step 3

✅ Spring Beans have a lifecycle controlled by ApplicationContext.

✅ Spring calls lifecycle methods like @PostConstruct and @PreDestroy.

✅ BeanPostProcessor allows custom pre/post-initialization logic.

✅ context.close() manually triggers destruction lifecycle.

📌 Topics Covered in This Section
📜 Spring Bean Lifecycle (✔️ Covered)

How Beans are created & destroyed (Instantiation → Initialization → Destruction).
Lifecycle methods:
- @PostConstruct (Runs after properties are set).
- @PreDestroy (Runs before bean destruction).
BeanPostProcessor Hooks:
- postProcessBeforeInitialization()
- postProcessAfterInitialization()
Manually closing the ApplicationContext (context.close()).

🔥 Key Takeaways to Remember:
✅ Spring manages bean lifecycles automatically using ApplicationContext.
✅ @PostConstruct and @PreDestroy are commonly used for lifecycle management.
✅ BeanPostProcessor allows customization before/after initialization.
✅ Manually closing the ApplicationContext triggers @PreDestroy.

📌 spring-note-002: Understanding IoC (Inversion of Control) & DI (Dependency Injection)

Hunor Vadasz-Perhat — Tue, 11 Feb 2025 09:04:44 +0000

(Reference: Spring Docs - IoC Container)

🔹 What is IoC (Inversion of Control)?

💡 IoC is a design principle where the control of object creation and management is shifted from the developer to the framework (Spring).

🛠️ Before IoC: Traditional Object Creation (Manual Control)

public class PirateShip {
    private Captain captain;

    public PirateShip() {
        this.captain = new Captain(); // MANUAL CREATION
    }
}

❌ Problem: The class creates its own dependencies, leading to tight coupling (harder to test & maintain).

⚡ IoC in Action: Spring Controls Object Creation

With IoC, Spring is responsible for creating and injecting dependencies instead of the developer doing it manually.

@Component
public class Captain {
    public String getCommand() {
        return "Set sail, Matey! ☠️";
    }
}

@Component
public class PirateShip {
    private final Captain captain;

    @Autowired
    public PirateShip(Captain captain) {
        this.captain = captain;
    }

    public String sail() {
        return captain.getCommand();
    }
}

💡 Spring injects the Captain instance into PirateShip automatically.

🔹 What is Dependency Injection (DI)?

💡 Dependency Injection (DI) is how Spring implements IoC—it automatically provides the required dependencies to objects.

✅ No new keyword needed.

✅ Objects are loosely coupled (easier to test & modify).

✅ Easier configuration via annotations or XML.

📌 Types of Dependency Injection in Spring

(Reference: Spring Docs - Dependency Injection)

1️⃣ Constructor Injection (Recommended)

🚀 Inject dependencies via constructor (Best Practice).

@Component
public class PirateShip {
    private final Captain captain;

    @Autowired
    public PirateShip(Captain captain) { // Injecting dependency via constructor
        this.captain = captain;
    }
}

✅ Best for mandatory dependencies.

✅ Ensures immutability (final fields).

2️⃣ Setter Injection

🚀 Inject dependencies via setter methods.

@Component
public class PirateShip {
    private Captain captain;

    @Autowired
    public void setCaptain(Captain captain) { // Setter-based injection
        this.captain = captain;
    }
}

✅ Good for optional dependencies.

❌ Can lead to mutable objects (less safe).

3️⃣ Field Injection (NOT Recommended)

⚠️ Directly injecting fields using @Autowired.

@Component
public class PirateShip {
    @Autowired
    private Captain captain;
}

❌ Considered a bad practice because:

Harder to test (no way to pass a mock in tests).
Breaks immutability (makes class state changeable).

🔥 Best Practice: Use Constructor Injection whenever possible!

📌 Hands-On Project: IoC & DI in Action

Step 1: Create a Spring Boot Project

1️⃣ Go to Spring Initializr

2️⃣ Select:

Spring Boot Version: Latest stable
Dependencies: Spring Web
Packaging: Jar 3️⃣ Click Generate and extract the zip file.

Step 2: Define Components

📌 Create a Captain component:

package com.example.springdi;

import org.springframework.stereotype.Component;

@Component
public class Captain {
    public String giveOrder() {
        return "All hands on deck, Matey! ☠️";
    }
}

📌 Create a PirateShip component that depends on Captain:

package com.example.springdi;

import org.springframework.stereotype.Component;

@Component
public class PirateShip {
    private final Captain captain;

    public PirateShip(Captain captain) {
        this.captain = captain;
    }

    public String sail() {
        return captain.giveOrder();
    }
}

Step 3: Create a REST Controller

📌 Expose the PirateShip behavior via an API:

package com.example.springdi.controller;

import com.example.springdi.PirateShip;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/pirates")
public class PirateController {
    private final PirateShip pirateShip;

    public PirateController(PirateShip pirateShip) {
        this.pirateShip = pirateShip;
    }

    @GetMapping("/sail")
    public String sail() {
        return pirateShip.sail();
    }
}

Step 4: Run the Application

💡 Run the app using:

mvn spring-boot:run

./mvnw spring-boot:run

🌐 Visit: http://localhost:8080/pirates/sail

🎉 You should see:

All hands on deck, Matey! ☠️

📌 Summary

✅ IoC = Spring takes control of object creation and lifecycle.

✅ DI = Injecting dependencies instead of creating them manually.

✅ Constructor Injection is best practice!

✅ We built a real Spring Boot app demonstrating DI!

📌 Topics Covered in This Section
📜 IoC & Dependency Injection (✔️ Covered)

What is IoC? (Spring manages object creation, inversion of control).
What is DI? (Spring injects dependencies, reducing coupling).
Spring’s IoC container (ApplicationContext & BeanFactory).
Types of DI: Constructor, Setter, Field Injection (Pros/Cons).
Best Practices: Constructor Injection > Setter Injection > Field Injection.

🛠️ Spring Boot & IoC (✔️ Covered)

Auto-Configuration & @Component Scanning.
@Autowired behavior and limitations.
How IoC integrates into a Spring Boot project.

🔥 Key Takeaways You Need to Remember for the Exam:
✅ Spring’s IoC container creates, configures, and manages objects (beans).
✅ DI eliminates the need for new keyword by injecting dependencies.
✅ Spring Boot automatically registers components using @ComponentScan.
✅ @Autowired is used for injection but Constructor Injection is best practice.

📌 spring-note-001: Introduction to Spring Framework

Hunor Vadasz-Perhat — Tue, 11 Feb 2025 08:59:39 +0000

🔹 What is Spring Framework?

✅ Spring is a Java-based framework that simplifies application development.

✅ It provides comprehensive infrastructure support for enterprise applications.

✅ Spring allows developers to focus on business logic while handling common concerns like:

Dependency Injection (DI)
Transaction Management
Security
Web Development
Messaging & Event Handling

💡 Think of Spring as a Swiss Army knife 🛠️ for Java development!

🔹 Why Does Spring Exist? What Problem Does It Solve?

Before Spring, Java EE (Enterprise Edition) applications were complicated, rigid, and full of boilerplate code 😵.

🔥 Spring solves these problems by:

✅ Reducing Boilerplate Code → No need to manually manage transactions, security, or object creation.

✅ Providing an IoC (Inversion of Control) Container → Spring manages object lifecycles for you.

✅ Simplifying Web & Data Access → Spring Boot + Spring Data = Rapid development.

✅ Supporting Multiple Architectures → Works for monoliths, microservices, event-driven apps, etc.

✅ Being Modular → Use only the parts you need (DI, Web, Security, etc.).

💡 In short: Spring makes Java development EASIER, FASTER, and MORE FLEXIBLE.

🔹 Key Features of Spring

🚀 Spring Core → Provides IoC Container & Dependency Injection (DI)

🌐 Spring Web → Supports MVC & REST API development

💾 Spring Data → Simplifies JDBC, JPA, and NoSQL interactions

🔐 Spring Security → Handles authentication, authorization, and OAuth2

🛠️ Spring Boot → Makes Spring setup fast & automatic

📡 Spring Cloud → Supports microservices & distributed applications

🔥 Spring isn’t just a framework—it’s an ECOSYSTEM! 🏗️

📌 Hands-On Project: Small Spring Boot Starter

💡 Let’s create a simple Spring Boot app to experience Spring in action.

Step 1: Create a Spring Boot Project

1️⃣ Go to Spring Initializr

2️⃣ Select:

Spring Boot Version: Latest stable
Dependencies: Spring Web, Spring Boot Actuator
Packaging: Jar 3️⃣ Click Generate and extract the zip file.

Step 2: Create a Simple REST API

🚀 Modify the main application class:

package com.example.springintro;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class SpringIntroApplication {
    public static void main(String[] args) {
        SpringApplication.run(SpringIntroApplication.class, args);
    }
}

💡 Spring Boot automatically configures and runs the application. 🎉

Step 3: Add a REST Controller

📌 Create a simple API endpoint using Spring Web:

package com.example.springintro.controller;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/api")
public class HelloController {

    @GetMapping("/hello")
    public String sayHello() {
        return "Ahoy, Captain! Welcome to the Spring World! ⚓🔥";
    }
}

Step 4: Run the Application

💡 Run the app using:

mvn spring-boot:run

./mvnw spring-boot:run

🌐 Visit: http://localhost:8080/api/hello

🎉 You should see:

Ahoy, Captain! Welcome to the Spring World! ⚓🔥

📌 Summary

✅ Spring simplifies Java development by managing dependencies, security, and transactions.

✅ It follows a modular approach—you only use what you need.

✅ Spring Boot makes it even easier by handling configurations automatically.

✅ A simple REST API can be created in just a few lines of code!

📌 Topics Covered in This Section
📜 Spring Core Concepts (✔️ Covered)

Purpose of Spring, solving Java EE complexities.
Core modules: DI, Web, Data, Security, Boot, Cloud.

🛠️ Spring Boot Basics (✔️ Covered)

Spring Boot auto-configuration.
Creating a simple REST API with Spring Web.
Running a Spring Boot app (SpringApplication.run()).

💡 Key Takeaways to Remember:
✅ Spring provides infrastructure support for enterprise applications.
✅ Spring's core feature is IoC (Dependency Injection).
✅ Spring Boot simplifies application setup & config.
✅ Spring modules work independently—you use only what you need.

hibernate-014: Why Did Hibernate Introduce Unidirectional and Bidirectional Relationships?

Hunor Vadasz-Perhat — Mon, 10 Feb 2025 13:45:39 +0000

🚀 Why Did Hibernate Introduce Unidirectional and Bidirectional Relationships?

Hibernate introduced unidirectional and bidirectional relationships to give developers flexibility in how they model database relationships in Java, without always needing explicit database joins or additional queries.

📌 The Key Reasons Hibernate Introduced These Concepts

Concept	Why Was It Introduced?
Unidirectional Relationships (`@ManyToOne`, `@OneToMany`, `@OneToOne`)	✅ Simpler, aligns with database foreign keys, prevents unnecessary complexity.
Bidirectional Relationships (`@OneToMany + @ManyToOne`)	✅ Allows navigation in both directions, improves query flexibility.
Mapped Relationships (`mappedBy`)	✅ Helps define ownership, preventing unnecessary joins and redundant data storage.
Lazy vs. Eager Fetching	✅ Avoids performance problems by only loading what is necessary.

1️⃣ Hibernate Aligns with Relational Databases

In a relational database, foreign keys are always stored on the "many" side (e.g., customers.salesRepEmployeeNumber).
Hibernate allows us to model this naturally with @ManyToOne (child → parent).
But sometimes we also need to navigate from parent to child, so @OneToMany(mappedBy) was introduced.

2️⃣ Unidirectional vs. Bidirectional: The Trade-off

💡 Hibernate allows both unidirectional and bidirectional relationships to provide flexibility.

Feature	Unidirectional (`@ManyToOne`)	Bidirectional (`@OneToMany + @ManyToOne`)
Database-Friendly?	✅ Yes (Foreign Key is in the child table, natural)	⚠️ Yes, but can cause extra queries if misused
Hibernate Complexity	✅ Simple (follows normal FK logic)	⚠️ More complex (needs `mappedBy`)
Query Flexibility	❌ Only from child → parent (`customer.getSalesRep()`)	✅ Can fetch parent → child (`employee.getCustomers()`)
Performance	✅ Efficient for querying parents	⚠️ Can cause `N+1` query problems if not optimized
When to Use?	✅ When only one-way navigation is needed	✅ When you need to query in both directions

👉 Hibernate introduced unidirectional to keep things simple when bidirectionality is not needed.

👉 Hibernate introduced bidirectional for situations where both entities must be accessible from each other.

3️⃣ Hibernate Optimizes Object-Oriented Modeling

In a pure Java application, there are no foreign keys—only references between objects.

💡 Hibernate allows us to model database relationships in Java as natural object references.

Instead of writing manual SQL queries with joins, Hibernate automates relationships like:

Customer customer = entityManager.find(Customer.class, 1);
Employee salesRep = customer.getSalesRep();

Instead of writing:

SELECT * FROM employees e
JOIN customers c ON e.employeeNumber = c.salesRepEmployeeNumber
WHERE c.customerNumber = 1;

👉 Hibernate gives Java-like relationships on top of relational data storage.

4️⃣ Preventing Redundant Join Tables

Before Hibernate, manual join tables were often needed for relationships.

Hibernate introduced @JoinColumn to control where foreign keys are stored.

Without @JoinColumn on @OneToMany, Hibernate would create a join table (employee_customers).
With @JoinColumn, Hibernate simply stores the FK in the child table (customers.salesRepEmployeeNumber).

👉 Hibernate gives control over how relationships are stored in SQL, reducing unnecessary tables.

5️⃣ Preventing Infinite Recursion in JSON (Serialization)

One side effect of bidirectional relationships is infinite recursion in REST APIs.

Example:

{
    "employeeNumber": 1002,
    "customers": [
        {
            "customerNumber": 1,
            "salesRep": { "employeeNumber": 1002, "customers": [...] }
        }
    ]
}

💡 Hibernate introduced @JsonManagedReference and @JsonBackReference to fix this issue!

🎯 Final Answer: Why Did Hibernate Introduce These Concepts?

To align Java modeling with relational databases (Foreign keys, Parent-Child relationships).
To offer flexibility—some use cases require bidirectional navigation, others don’t.
To reduce extra join tables—Hibernate lets us control foreign key storage.
To optimize performance—lazy loading, avoiding unnecessary queries.
To simplify object-oriented relationships—Java developers can work with objects instead of raw SQL.

💡 Hibernate is about making object relationships feel "natural" while still being efficient in SQL.

hibernate-013: Can You Mix Unidirectional and Bidirectional @OneToMany & @ManyToOne?

Hunor Vadasz-Perhat — Mon, 10 Feb 2025 10:24:28 +0000

🚀 Can You Mix Unidirectional and Bidirectional `@OneToMany` & `@ManyToOne`?

✅ Yes, you can! You can choose:

@ManyToOne without @OneToMany → Unidirectional
@ManyToOne with @OneToMany(mappedBy) → Bidirectional

📌 Mixing Unidirectional & Bidirectional Approaches

Scenario	`@ManyToOne` Used?	`@OneToMany` Used?	Direction Type
✅ Best Practice	✅ Yes	✅ Yes (`mappedBy`)	Bidirectional
✅ Alternative	✅ Yes	❌ No	Unidirectional (`@ManyToOne` only)

1️⃣ Example: `@ManyToOne` Without `@OneToMany` (Unidirectional)

✅ Best for queries from Employee → Department but NOT the other way around.

@Entity
public class Employee {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;

    @ManyToOne
    @JoinColumn(name = "department_id") // ✅ Foreign key in Employee table
    private Department department;
}

@Entity
public class Department {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;
}

✅ Queries:

employee.getDepartment(); (Works ✅)
department.getEmployees(); (Not possible ❌ - No @OneToMany)

🚀 Use case: If you only need to retrieve an employee's department, but NOT employees from a department.

2️⃣ Example: `@ManyToOne` + `@OneToMany(mappedBy)` (Bidirectional)

✅ Best if you need queries in both directions.

@Entity
public class Employee {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;

    @ManyToOne
    @JoinColumn(name = "department_id") // ✅ Foreign key in Employee table
    private Department department;
}

@Entity
public class Department {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;

    @OneToMany(mappedBy = "department") // ✅ Refers to Employee.department
    private List<Employee> employees;
}

✅ Queries:

employee.getDepartment(); (Works ✅)
department.getEmployees(); (Works ✅)

🚀 Use case: If you need to retrieve both:

All employees in a department
An employee’s department

🎯 Final Recommendation

When to Use	Use `@ManyToOne` Only (Unidirectional)	Use `@ManyToOne` + `@OneToMany` (Bidirectional)
✅ Simple querying (best performance)	✅ Yes	❌ No
✅ Only querying child → parent	✅ Yes	❌ No
✅ Need parent → child queries	❌ No	✅ Yes
✅ Avoiding unnecessary complexity	✅ Yes	❌ No

✅ Best Practice:

Use @ManyToOne by itself (Unidirectional) if querying only from child → parent.
Use @ManyToOne + @OneToMany(mappedBy) (Bidirectional) if querying both ways.

hibernate-012: Which Direction to Use for Each Relationship Type in Hibernate?

Hunor Vadasz-Perhat — Mon, 10 Feb 2025 10:23:19 +0000

🚀 Which Direction to Use for Each Relationship Type in Hibernate?

Choosing unidirectional or bidirectional depends on:

✅ How you query data.
✅ Performance considerations.
✅ Database design (avoiding unnecessary tables).

📌 1️⃣ One-to-Many & Many-to-One

Relationship Type	Recommended Direction	Why?
One-to-Many (Unidirectional)	❌ Not recommended	Creates an unnecessary join table.
One-to-Many (Bidirectional)	✅ Recommended	Avoids a join table, allows querying in both directions.
Many-to-One (Unidirectional)	✅ Recommended	Simpler, efficient for querying child-to-parent.

✅ Best Practice:

Always use @ManyToOne with @JoinColumn (this is the owning side).
Use @OneToMany(mappedBy = "field") on the inverse side only if needed.

Example

@Entity
public class Employee {
    @ManyToOne
    @JoinColumn(name = "department_id") // ✅ Foreign key stored in Employee
    private Department department;
}

@Entity
public class Department {
    @OneToMany(mappedBy = "department") // ✅ Inverse side
    private List<Employee> employees;
}

🚀 Why?

✅ Using only @ManyToOne is efficient (no extra join table).

✅ Using bidirectional makes sense if you need to access employees from a department.

📌 2️⃣ One-to-One

Relationship Type	Recommended Direction	Why?
One-to-One (Unidirectional)	✅ Recommended	Simple, only one entity holds the foreign key.
One-to-One (Bidirectional)	✅ Use if needed	Needed if both entities must reference each other.

✅ Best Practice:

Use Unidirectional @OneToOne unless both sides must reference each other.
If using Bidirectional @OneToOne, ensure the inverse side has mappedBy.

Example

@Entity
public class User {
    @OneToOne
    @JoinColumn(name = "profile_id") // ✅ Foreign key in User
    private Profile profile;
}

@Entity
public class Profile {
    @OneToOne(mappedBy = "profile") // ✅ Inverse side
    private User user;
}

🚀 Why?

✅ Unidirectional is simple and avoids redundancy.

✅ Bidirectional is useful if you frequently query both ways.

📌 3️⃣ Many-to-Many

Relationship Type	Recommended Direction	Why?
Many-to-Many (Unidirectional)	✅ Okay for simple use cases	One side owns the join table, but the other cannot query back.
Many-to-Many (Bidirectional)	✅ Recommended	Both entities can query each other efficiently.

✅ Best Practice:

Use bidirectional @ManyToMany to allow querying both sides.
Place @JoinTable on the owning side, use mappedBy on the inverse side.

Example

@Entity
public class Student {
    @ManyToMany
    @JoinTable(
        name = "student_course",
        joinColumns = @JoinColumn(name = "student_id"),
        inverseJoinColumns = @JoinColumn(name = "course_id")
    )
    private List<Course> courses;
}

@Entity
public class Course {
    @ManyToMany(mappedBy = "courses") // ✅ Inverse side
    private List<Student> students;
}

🚀 Why?

✅ Unidirectional works, but bidirectional is better for querying both ways.

✅ Avoids duplicate join tables.

🎯 Final Recommendations

Relationship	Best Approach	Why?
One-to-Many & Many-to-One	✅ Use `@ManyToOne` + `@OneToMany(mappedBy)`	Efficient, avoids extra join tables.
One-to-One	✅ Use Unidirectional `@OneToOne`, bidirectional only if necessary	Simple and avoids redundancy.
Many-to-Many	✅ Use Bidirectional `@ManyToMany`	Allows querying both ways without duplicating join tables.

🚀 Best Practice: Keep it simple. Use bidirectional only if both sides need to query each other.

hibernate-011: Understanding Unidirectional vs. Bidirectional Relationships in Hibernate

Hunor Vadasz-Perhat — Mon, 10 Feb 2025 09:46:31 +0000

🚀 Which Direction to Use for Each Relationship Type in Hibernate?

Choosing unidirectional or bidirectional depends on:

✅ How you query data.
✅ Performance considerations.
✅ Database design (avoiding unnecessary tables).

📌 1️⃣ One-to-Many & Many-to-One

Relationship Type	Recommended Direction	Why?
One-to-Many (Unidirectional)	❌ Not recommended	Creates an unnecessary join table.
One-to-Many (Bidirectional)	✅ Recommended	Avoids a join table, allows querying in both directions.
Many-to-One (Unidirectional)	✅ Recommended	Simpler, efficient for querying child-to-parent.

✅ Best Practice:

Always use @ManyToOne with @JoinColumn (this is the owning side).
Use @OneToMany(mappedBy = "field") on the inverse side only if needed.

Example

@Entity
public class Employee {
    @ManyToOne
    @JoinColumn(name = "department_id") // ✅ Foreign key stored in Employee
    private Department department;
}

@Entity
public class Department {
    @OneToMany(mappedBy = "department") // ✅ Inverse side
    private List<Employee> employees;
}

🚀 Why?

✅ Using only @ManyToOne is efficient (no extra join table).

✅ Using bidirectional makes sense if you need to access employees from a department.

📌 2️⃣ One-to-One

Relationship Type	Recommended Direction	Why?
One-to-One (Unidirectional)	✅ Recommended	Simple, only one entity holds the foreign key.
One-to-One (Bidirectional)	✅ Use if needed	Needed if both entities must reference each other.

✅ Best Practice:

Use Unidirectional @OneToOne unless both sides must reference each other.
If using Bidirectional @OneToOne, ensure the inverse side has mappedBy.

Example

@Entity
public class User {
    @OneToOne
    @JoinColumn(name = "profile_id") // ✅ Foreign key in User
    private Profile profile;
}

@Entity
public class Profile {
    @OneToOne(mappedBy = "profile") // ✅ Inverse side
    private User user;
}

🚀 Why?

✅ Unidirectional is simple and avoids redundancy.

✅ Bidirectional is useful if you frequently query both ways.

📌 3️⃣ Many-to-Many

Relationship Type	Recommended Direction	Why?
Many-to-Many (Unidirectional)	✅ Okay for simple use cases	One side owns the join table, but the other cannot query back.
Many-to-Many (Bidirectional)	✅ Recommended	Both entities can query each other efficiently.

✅ Best Practice:

Use bidirectional @ManyToMany to allow querying both sides.
Place @JoinTable on the owning side, use mappedBy on the inverse side.

Example

@Entity
public class Student {
    @ManyToMany
    @JoinTable(
        name = "student_course",
        joinColumns = @JoinColumn(name = "student_id"),
        inverseJoinColumns = @JoinColumn(name = "course_id")
    )
    private List<Course> courses;
}

@Entity
public class Course {
    @ManyToMany(mappedBy = "courses") // ✅ Inverse side
    private List<Student> students;
}

🚀 Why?

✅ Unidirectional works, but bidirectional is better for querying both ways.

✅ Avoids duplicate join tables.

🎯 Final Recommendations

Relationship	Best Approach	Why?
One-to-Many & Many-to-One	✅ Use `@ManyToOne` + `@OneToMany(mappedBy)`	Efficient, avoids extra join tables.
One-to-One	✅ Use Unidirectional `@OneToOne`, bidirectional only if necessary	Simple and avoids redundancy.
Many-to-Many	✅ Use Bidirectional `@ManyToMany`	Allows querying both ways without duplicating join tables.

🚀 Best Practice: Keep it simple. Use bidirectional only if both sides need to query each other.

hibernate-010: Bidirectional One-to-Many & Many-to-One in Hibernate

Hunor Vadasz-Perhat — Mon, 10 Feb 2025 09:27:23 +0000

🚀 Bidirectional One-to-Many & Many-to-One in Hibernate

Now, let’s fully explore bidirectional One-to-Many and Many-to-One relationships with real examples, database schema, and queries.

📌 1️⃣ What is a Bidirectional One-to-Many & Many-to-One?

One parent entity has multiple child entities (One-to-Many).
Each child entity belongs to one parent entity (Many-to-One).
The "Many" side owns the foreign key, and the "One" side is mapped using mappedBy.

✅ Best Practice

The child (Many) owns the relationship (@ManyToOne with @JoinColumn).
The parent (One) just references it (@OneToMany(mappedBy = "field")).

📌 2️⃣ Example: Department ↔ Employee

One Department has many Employees (@OneToMany).
Each Employee belongs to one Department (@ManyToOne).

✅ Step 1: Define `@ManyToOne` (Owning Side - `Employee`)

@Entity
public class Employee {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;

    @ManyToOne
    @JoinColumn(name = "department_id") // ✅ Foreign key in Employee table
    private Department department;
}

✅ The department_id foreign key is stored in Employee.

✅ Step 2: Define `@OneToMany(mappedBy = "department")` (Inverse Side - `Department`)

@Entity
public class Department {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;

    @OneToMany(mappedBy = "department") // ✅ Refers to Employee.department
    private List<Employee> employees = new ArrayList<>();
}

✅ mappedBy = "department" tells Hibernate:

"The foreign key is already in Employee.department_id."
"Don’t create an extra join table."

📌 3️⃣ Database Schema (No Extra Join Table!)

CREATE TABLE department (
    id BIGINT AUTO_INCREMENT PRIMARY KEY,
    name VARCHAR(255)
);

CREATE TABLE employee (
    id BIGINT AUTO_INCREMENT PRIMARY KEY,
    name VARCHAR(255),
    department_id BIGINT, -- ✅ Foreign key column
    FOREIGN KEY (department_id) REFERENCES department(id)
);

✅ The foreign key is only in Employee.department_id, keeping the relationship correct.

📌 4️⃣ Saving Data in Hibernate

Department department = new Department();
department.setName("IT Department");

Employee emp1 = new Employee();
emp1.setName("Alice");
emp1.setDepartment(department); // ✅ Set reference in Employee

Employee emp2 = new Employee();
emp2.setName("Bob");
emp2.setDepartment(department);

department.getEmployees().add(emp1); // ✅ Set reference in Department
department.getEmployees().add(emp2);

entityManager.persist(department);
entityManager.persist(emp1);
entityManager.persist(emp2);

🚀 Now both Department and Employee are correctly linked!

📌 5️⃣ Querying Both Directions

✅ Get Employees from Department

Department dept = entityManager.find(Department.class, 1L);
List<Employee> employees = dept.getEmployees();
employees.forEach(emp -> System.out.println(emp.getName())); // ✅ Works!

✅ Get Department from Employee

Employee emp = entityManager.find(Employee.class, 10L);
System.out.println(emp.getDepartment().getName()); // ✅ Works!

✅ Both queries work because the relationship is bidirectional.

📌 6️⃣ Summary: One-to-Many & Many-to-One

Feature	One-to-Many (`Department`)	Many-to-One (`Employee`)
`@OneToMany(mappedBy = "department")`	✅ Yes	❌ No
`@ManyToOne` used?	❌ No	✅ Yes
`@JoinColumn(name = "fk_column")`	❌ No	✅ Yes
Foreign key location?	❌ Not in `Department`	✅ In `Employee.department_id`
Extra join table?	❌ No	❌ No
Reference back?	✅ Yes	✅ Yes

✅ Best Practice: Use bidirectional @OneToMany + @ManyToOne to avoid unnecessary join tables and keep data consistent.

Happy coding! 🚀

hibernate-009: Unidirectional vs bidirectional @ManyToMany in Hibernate

Hunor Vadasz-Perhat — Mon, 10 Feb 2025 09:20:53 +0000

🚀 Many-to-Many Relationship in Hibernate
In a Many-to-Many relationship:

An entity can have multiple related entities, and vice versa.
A join table is required to store the relationships.

We’ll go through both unidirectional and bidirectional mappings using Student and Course entities.

1️⃣ Unidirectional `@ManyToMany`

✅ In a unidirectional Many-to-Many:

Only one entity knows about the relationship.
The foreign key mapping is stored in a join table.

📌 Example: A `Student` can enroll in many `Courses`, but `Course` doesn’t reference `Student`.

@Entity
public class Student {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;

    @ManyToMany
    @JoinTable(
        name = "student_course", // ✅ Join table name
        joinColumns = @JoinColumn(name = "student_id"), // ✅ FK for Student
        inverseJoinColumns = @JoinColumn(name = "course_id") // ✅ FK for Course
    )
    private List<Course> courses = new ArrayList<>();
}

@Entity
public class Course {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String title;
}

✅ Only Student knows about Course, and Course has no reference back.

🔹 Generated SQL (Creates a Join Table)

CREATE TABLE student (
    id BIGINT AUTO_INCREMENT PRIMARY KEY,
    name VARCHAR(255)
);

CREATE TABLE course (
    id BIGINT AUTO_INCREMENT PRIMARY KEY,
    title VARCHAR(255)
);

CREATE TABLE student_course (
    student_id BIGINT NOT NULL,
    course_id BIGINT NOT NULL,
    PRIMARY KEY (student_id, course_id),
    FOREIGN KEY (student_id) REFERENCES student(id),
    FOREIGN KEY (course_id) REFERENCES course(id)
);

✅ The student_course table links students to courses.

📌 Saving Data

Course course1 = new Course();
course1.setTitle("Mathematics");

Course course2 = new Course();
course2.setTitle("Physics");

Student student = new Student();
student.setName("John Doe");
student.getCourses().add(course1);
student.getCourses().add(course2);

entityManager.persist(course1);
entityManager.persist(course2);
entityManager.persist(student);

🚀 The student is now enrolled in two courses!

📌 Querying Data

Student student = entityManager.find(Student.class, 1L);
List<Course> courses = student.getCourses();
courses.forEach(course -> System.out.println(course.getTitle())); // ✅ Works!

✅ You can query courses from a student, but not the other way around.

2️⃣ Bidirectional `@ManyToMany`

✅ In a bidirectional Many-to-Many:

Both entities reference each other.
One entity is the owning side (@JoinTable).
The other entity is the inverse side (mappedBy).

📌 Example: A `Student` can enroll in many `Courses`, and a `Course` can have many `Students`.

Owning Side (`Student`) - Uses `@JoinTable`

@Entity
public class Student {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;

    @ManyToMany
    @JoinTable(
        name = "student_course", // ✅ Join table
        joinColumns = @JoinColumn(name = "student_id"), // ✅ FK for Student
        inverseJoinColumns = @JoinColumn(name = "course_id") // ✅ FK for Course
    )
    private List<Course> courses = new ArrayList<>();
}

Inverse Side (`Course`) - Uses `mappedBy`

@Entity
public class Course {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String title;

    @ManyToMany(mappedBy = "courses") // ✅ References the field in Student
    private List<Student> students = new ArrayList<>();
}

✅ mappedBy = "courses" tells Hibernate:

"The join table is already defined in Student.courses."
"Don’t create another join table in Course."

🔹 Generated SQL (No Duplicate Join Table!)

CREATE TABLE student (
    id BIGINT AUTO_INCREMENT PRIMARY KEY,
    name VARCHAR(255)
);

CREATE TABLE course (
    id BIGINT AUTO_INCREMENT PRIMARY KEY,
    title VARCHAR(255)
);

CREATE TABLE student_course (
    student_id BIGINT NOT NULL,
    course_id BIGINT NOT NULL,
    PRIMARY KEY (student_id, course_id),
    FOREIGN KEY (student_id) REFERENCES student(id),
    FOREIGN KEY (course_id) REFERENCES course(id)
);

✅ The student_course table is correctly mapped without duplication.

📌 Saving Data (Same as Before)

Course course1 = new Course();
course1.setTitle("Mathematics");

Course course2 = new Course();
course2.setTitle("Physics");

Student student = new Student();
student.setName("John Doe");
student.getCourses().add(course1);
student.getCourses().add(course2);

course1.getStudents().add(student); // ✅ Add student to course
course2.getStudents().add(student);

entityManager.persist(course1);
entityManager.persist(course2);
entityManager.persist(student);

✅ Now, both Student and Course are correctly linked.

📌 Querying Both Directions

✅ Get Courses from Student

Student student = entityManager.find(Student.class, 1L);
List<Course> courses = student.getCourses();
courses.forEach(course -> System.out.println(course.getTitle())); // ✅ Works!

✅ Get Students from Course

Course course = entityManager.find(Course.class, 1L);
List<Student> students = course.getStudents();
students.forEach(student -> System.out.println(student.getName())); // ✅ Works!

✅ Unlike the unidirectional version, now you can access both Student → Course and Course → Student.

3️⃣ Summary: Unidirectional vs. Bidirectional `@ManyToMany`

Feature	Unidirectional (`@ManyToMany`)	Bidirectional (`@ManyToMany` + `mappedBy`)
`@ManyToMany` used?	✅ Yes	✅ Yes (Both Sides)
`@JoinTable` used?	✅ Yes (Owning Side)	✅ Yes (Only in Owning Side)
`mappedBy` used?	❌ No	✅ Yes (Inverse Side)
Extra join table?	✅ Yes	✅ Yes (But Correctly Shared)
Reference back?	❌ No	✅ Yes (Both Can Access Each Other)

✅ Best Practice: Use bidirectional @ManyToMany if you need to query both ways.

🚀 Unidirectional @ManyToMany is simpler if you only query in one direction.

🎯 Final Takeaways

Unidirectional @ManyToMany = Only one entity knows about the other (@JoinTable in the owning side).
Bidirectional @ManyToMany = Both entities reference each other (mappedBy used on the inverse side).
Use bidirectional when both sides need to access each other.
Always place the @JoinTable annotation on the owning side.

DEV Community: Hunor Vadasz-Perhat

📌spring-note-006: Bean Definition Inheritance

🔹 What is Bean Definition Inheritance?

📌 How to Implement Bean Definition Inheritance

1️⃣ XML-Based Bean Inheritance (Legacy)

2️⃣ Java-Based Bean Inheritance

3️⃣ Using @Bean Methods for Inheritance

📌 Hands-On Project: Testing Bean Inheritance

Step 1: Create Parent and Child Beans

Step 2: Create a REST Controller to Test Inheritance

Step 3: Run the Application & Test

📌 Summary of Step 6

📌 spring-note-005: Customizing the Nature of a Bean

🔹 Why Customize Beans?

📌 Key Customization Features

1️⃣ Lazy vs. Eager Initialization (@Lazy)

2️⃣ Defining Primary Beans (@Primary)

3️⃣ Using Qualifiers for Specific Bean Selection (@Qualifier)

4️⃣ Conditional Beans (@Conditional)

📌 Hands-On Project: Testing Bean Customization

Step 1: Create a Spring Boot Project

Step 2: Define Beans with Custom Behavior

Step 3: Create a REST Controller to Test Beans

Step 4: Run the Application & Test

📌 Summary

📌 spring-note-004: Understanding Spring Bean Scopes

🔹 What is a Bean Scope?

📌 Types of Bean Scopes in Spring

1️⃣ Singleton Scope (Default)

2️⃣ Prototype Scope

3️⃣ Request Scope (For Web Applications)

4️⃣ Session Scope (For Web Applications)

5️⃣ Application Scope (For Web Applications)

📌 Hands-On Project: Exploring Bean Scopes

Step 1: Create a Spring Boot Project

Step 2: Create Beans with Different Scopes

Step 3: Inject and Test Scopes in a REST Controller

Step 4: Run the Application & Test

📌 Summary of Step 4

📌 spring-note-003: Spring Bean Lifecycle

🔹 What is the Spring Bean Lifecycle?

📌 Phases of the Spring Bean Lifecycle

📌 Hands-On Project: Bean Lifecycle in Action

Step 1: Create a Spring Boot Project

Step 2: Define a Bean with Lifecycle Hooks

Step 3: Add BeanPostProcessor to Track Lifecycle Events

Step 4: Create the Main Application Class

Step 5: Run the Application

📌 Summary of Step 3

📌 spring-note-002: Understanding IoC (Inversion of Control) & DI (Dependency Injection)

🔹 What is IoC (Inversion of Control)?

🛠️ Before IoC: Traditional Object Creation (Manual Control)

⚡ IoC in Action: Spring Controls Object Creation

🔹 What is Dependency Injection (DI)?

📌 Types of Dependency Injection in Spring

1️⃣ Constructor Injection (Recommended)

2️⃣ Setter Injection

3️⃣ Field Injection (NOT Recommended)

📌 Hands-On Project: IoC & DI in Action

Step 1: Create a Spring Boot Project

Step 2: Define Components

Step 3: Create a REST Controller

Step 4: Run the Application

📌 Summary

📌 spring-note-001: Introduction to Spring Framework

🔹 What is Spring Framework?

🔹 Why Does Spring Exist? What Problem Does It Solve?

🔹 Key Features of Spring

📌 Hands-On Project: Small Spring Boot Starter

Step 1: Create a Spring Boot Project

Step 2: Create a Simple REST API

Step 3: Add a REST Controller

Step 4: Run the Application

📌 Summary

hibernate-014: Why Did Hibernate Introduce Unidirectional and Bidirectional Relationships?

🚀 Why Did Hibernate Introduce Unidirectional and Bidirectional Relationships?

📌 The Key Reasons Hibernate Introduced These Concepts

1️⃣ Hibernate Aligns with Relational Databases

2️⃣ Unidirectional vs. Bidirectional: The Trade-off

3️⃣ Hibernate Optimizes Object-Oriented Modeling

3️⃣ Using `@Bean` Methods for Inheritance

1️⃣ Lazy vs. Eager Initialization (`@Lazy`)

2️⃣ Defining Primary Beans (`@Primary`)

3️⃣ Using Qualifiers for Specific Bean Selection (`@Qualifier`)

4️⃣ Conditional Beans (`@Conditional`)

🚀 Can You Mix Unidirectional and Bidirectional `@OneToMany` & `@ManyToOne`?

1️⃣ Example: `@ManyToOne` Without `@OneToMany` (Unidirectional)

2️⃣ Example: `@ManyToOne` + `@OneToMany(mappedBy)` (Bidirectional)

✅ Step 1: Define `@ManyToOne` (Owning Side - `Employee`)

✅ Step 2: Define `@OneToMany(mappedBy = "department")` (Inverse Side - `Department`)

1️⃣ Unidirectional `@ManyToMany`

📌 Example: A `Student` can enroll in many `Courses`, but `Course` doesn’t reference `Student`.

2️⃣ Bidirectional `@ManyToMany`

📌 Example: A `Student` can enroll in many `Courses`, and a `Course` can have many `Students`.

Owning Side (`Student`) - Uses `@JoinTable`

Inverse Side (`Course`) - Uses `mappedBy`

3️⃣ Summary: Unidirectional vs. Bidirectional `@ManyToMany`