What is Spring Framework

// Without Spring — UserService manually creates its dependencies:
public class UserService {
    private UserRepository repository = new UserRepositoryImpl(); // tight coupling
    private EmailService emailService = new EmailServiceImpl();   // hard to test

    public void registerUser(User user) {
        repository.save(user);
        emailService.sendWelcome(user.getEmail());
    }
}

// With Spring — dependencies are injected (Dependency Injection):
@Service
public class UserService {
    private final UserRepository repository;
    private final EmailService emailService;

    // Constructor injection — Spring provides both dependencies:
    public UserService(UserRepository repository, EmailService emailService) {
        this.repository = repository;
        this.emailService = emailService;
    }

    public void registerUser(User user) {
        repository.save(user);
        emailService.sendWelcome(user.getEmail());
    }
}
// UserService doesn't know or care which implementation it gets.
// In production: real DB and real email service.
// In tests: mock implementations injected instead.

// 1. Constructor Injection (RECOMMENDED):
@Service
public class OrderService {
    private final OrderRepository repository;
    private final PaymentService paymentService;

    // Spring auto-detects single constructor — @Autowired optional in modern Spring:
    public OrderService(OrderRepository repository, PaymentService paymentService) {
        this.repository = repository;
        this.paymentService = paymentService;
    }
}
// Benefits: fields can be final, NullPointerException impossible,
//           testable without Spring context (just call new OrderService(mock, mock))

// 2. Setter Injection (for optional dependencies):
@Service
public class NotificationService {
    private EmailClient emailClient;

    @Autowired(required = false)
    public void setEmailClient(EmailClient emailClient) {
        this.emailClient = emailClient;
    }
}

// 3. Field Injection (convenient but avoid in production code):
@Service
public class ProductService {
    @Autowired
    private ProductRepository repository;  // can't be final, hard to test
}

// Without AOP — logging duplicated in every service method:
public class OrderService {
    public Order createOrder(OrderRequest request) {
        log.info("createOrder called with: {}", request);  // duplicated
        long start = System.currentTimeMillis();
        Order order = processOrder(request);
        log.info("createOrder took {}ms", System.currentTimeMillis() - start); // duplicated
        return order;
    }
}

// With AOP — logging defined once, applied everywhere:
@Aspect
@Component
public class LoggingAspect {

    // Applies to ALL methods in ANY class in the service package:
    @Around("execution(* com.example.service.*.*(..))")
    public Object logExecution(ProceedingJoinPoint joinPoint) throws Throwable {
        String method = joinPoint.getSignature().getName();
        log.info("Calling: {}", method);
        long start = System.currentTimeMillis();

        Object result = joinPoint.proceed();   // call the actual method

        log.info("{} took {}ms", method, System.currentTimeMillis() - start);
        return result;
    }
}
// OrderService.createOrder() now has logging applied automatically.
// Zero changes to OrderService. Zero code duplication.

@Component
public class DatabaseConnectionPool {

    private DataSource dataSource;

    // Called by Spring after all dependencies are injected:
    @PostConstruct
    public void initialize() {
        // Safe to use dependencies here — all injected before this is called
        this.dataSource = createDataSource();
        System.out.println("Connection pool initialized with " + poolSize + " connections");
    }

    // Called by Spring just before the bean is destroyed:
    @PreDestroy
    public void shutdown() {
        // Clean up resources — close connections, flush buffers, etc.
        dataSource.close();
        System.out.println("Connection pool shut down");
    }
}

// Bean scopes — how many instances Spring creates:
@Component
@Scope("singleton")   // DEFAULT — one shared instance per container
public class AppConfig { }

@Component
@Scope("prototype")   // new instance every time it's requested
public class RequestProcessor { }

@Component
@Scope("request")     // one per HTTP request (web applications only)
public class RequestContext { }

@Component
@Scope("session")     // one per HTTP session (web applications only)
public class UserSession { }