What is the Spring Core module and what advantages does it provide?

Spring Core is a fundamental module of the Spring framework that provides basic functionality for building applications. It includes IoC (Inversion of Control) and AOP (Aspect-Oriented Programming) components.

Advantages:

• Dependency Injection (DI): Allows managing object dependencies, reducing component coupling and simplifying testing.
• IoC Container: Manages the lifecycle of objects (beans), their creation, configuration, and wiring.
• Aspect-Oriented Programming (AOP): Enables separation of cross-cutting concerns (logging, security) into separate aspects, increasing modularity.
• Abstractions: Provides common abstractions for working with resources, events, and messages.
• Simplifies testing: Easily replace real dependencies with mocks or stubs in test scenarios.

Example of IoC using annotations:

// Service interface
public interface MyService {
    void doSomething();
}

// Service implementation
@Component
public class MyServiceImpl implements MyService {
    @Override
    public void doSomething() {
        System.out.println("MyService implementation doing something.");
    }
}

// Component using the service
@Component
public class MyComponent {
    private final MyService myService;

    // @Autowired injects MyService
    @Autowired
    public MyComponent(MyService myService) {
        this.myService = myService;
    }

    public void performAction() {
        myService.doSomething();
    }
}

// Spring configuration (alternative to XML)
@Configuration
@ComponentScan(basePackages = "com.example.package") // Component scanning
public class AppConfig {
}

// Application entry point
public class MainApp {
    public static void main(String[] args) {
        // Create Spring context
        try (AnnotationConfigApplicationContext context =
             new AnnotationConfigApplicationContext(AppConfig.class)) {

            // Get component from context
            MyComponent component = context.getBean(MyComponent.class);

            // Perform action
            component.performAction();
        }
    }
}

This example demonstrates how Spring Core manages the lifecycle of MyServiceImpl and injects it into MyComponent using @Autowired, illustrating the Inversion of Control principle and dependency injection.