# Core Concepts and Dependency Injection

## Understanding the core concepts of Spring Boot

* Spring Boot builds upon the core concepts of the Spring Framework, including dependency injection, inversion of control (IoC), and aspect-oriented programming (AOP).
* It simplifies the configuration and setup of these concepts, allowing developers to focus more on business logic and less on infrastructure.

## Dependency injection and inversion of control (IoC) in Spring Boot:

* Dependency injection is a design pattern where the dependencies of an object are injected from the outside, rather than being created within the object itself.
* Inversion of control (IoC) is a principle where the control of object creation and lifecycle management is inverted to a container or framework.
* Spring Boot uses IoC and dependency injection to manage the creation, configuration, and wiring of objects within the application.

## Configuring beans using annotations and Java-based configuration:

* Spring Boot provides annotations that can be used to configure beans, such as `@Component`, `@Service`, `@Repository`, and `@Controller`.
* These annotations help Spring Boot automatically detect and create the necessary beans based on the classpath scanning.
* Java-based configuration allows you to define beans using Java code instead of XML configuration files, using annotations like `@Configuration`, `@Bean`, and `@Autowired`.

## Working with different bean scopes and lifecycle events:

* Spring Boot supports different bean scopes, such as singleton, prototype, request, session, and more.
* The default scope is singleton, where only one instance of the bean is created and shared across the application.
* You can specify the scope of a bean using annotations like `@Scope` or through configuration.
* Spring Boot provides lifecycle hooks, such as `@PostConstruct` and `@PreDestroy`, to execute initialization and cleanup tasks for beans.

**Example of configuring beans using annotations:**

```java
@Component // Marks the class as a Spring-managed component
public class MyService {
    // Class implementation...
}
```

**Example of configuring beans using Java-based configuration:**

```java
@Configuration // Indicates that this class contains bean configurations
public class AppConfig {
    @Bean // Defines a bean with the specified name and type
    public MyService myService() {
        return new MyService();
    }
}
```

**Example of using bean scopes and lifecycle events:**

```java
@Component
@Scope("prototype") // Defines the scope of the bean as prototype
public class MyPrototypeBean {
    @PostConstruct // Executed after the bean is constructed
    public void init() {
        // Initialization logic...
    }

    @PreDestroy // Executed before the bean is destroyed
    public void cleanup() {
        // Cleanup logic...
    }
}
```

Understanding and effectively using these core concepts of Spring Boot is crucial for developing robust and maintainable applications.