In Java Spring Boot, AOP (Aspect-Oriented Programming), DI (Dependency Injection), and IOC (Inversion of Control) are essential concepts for building maintainable and scalable applications.

1. AOP (Aspect-Oriented Programming)

AOP separates cross-cutting concerns like logging, performance monitoring, and transaction management from business logic. In Spring Boot, AOP is implemented using aspects and advice.

@Aspect
@Component
class LoggingAspect {

    @Before("execution(* com.example.demo.service.*.*(..))")
    void logBefore(JoinPoint joinPoint) {
        System.out.println("Before method: " + joinPoint.getSignature().getName());
    }

    @AfterReturning(pointcut = "execution(* com.example.demo.service.*.*(..))", returning = "result")
    void logAfterReturning(JoinPoint joinPoint, Object result) {
        System.out.println("After returning from method: " + joinPoint.getSignature().getName() + ", result: " + result);
    }
}

In the example above, a LoggingAspect class is created with two advice methods: logBefore and logAfterReturning. The logBefore method is called before the target method executes, and the logAfterReturning method is called after the target method executes.

2. DI (Dependency Injection)

DI manages component dependencies through external injection of dependency objects. In Spring Boot, DI is managed by the container.

@Service
class UserService {

    private final UserRepository userRepository;

    @Autowired
    UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    public User getUserById(Long id) {
        return userRepository.findById(id).orElse(null);
    }
}

In the example above, the UserService class depends on the UserRepository class, which is injected via the constructor.

3. IOC (Inversion of Control)

IOC transfers application control from application code to a container or framework, allowing the container too manage object creation and dependency injection. In Spring Boot, the IOC container manages Bean lifecycle and dependency injection.

@SpringBootApplication
class DemoApplication {

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

In the example above, the DemoApplication class annotated with @SpringBootApplication is the entry point of the Spring Boot application. The Spring Boot framework automatically scans and manages this class and its dependent Beans.