Spring IOC 和 AOP

Spring的IOC（Inversion of Control）和AOP（Aspect-Oriented Programming）是两个核心概念，它们分别用于管理对象的生命周期和处理横切关注点。以下是它们的简单示例：

**IOC示例：**

假设你有一个类`Car`和一个类`Engine`，`Car`类依赖于`Engine`类，即`Car`需要一个`Engine`对象才能正常工作。在传统的编程方式下，你需要在`Car`类中直接创建`Engine`对象。但在Spring中，IOC容器会管理`Engine`对象的生命周期，你只需告诉Spring你需要一个`Engine`对象，Spring会负责为你创建和管理它。

// Car.java
public class Car {
    private Engine engine;

    public Car(Engine engine) {
        this.engine = engine;
    }

    public void start() {
        engine.start();
        System.out.println("Car is starting...");
    }
}

// Engine.java
public class Engine {
    public void start() {
        System.out.println("Engine is starting...");
    }
}

// Spring配置
@Configuration
@ComponentScan(basePackages = "com.example")
public class AppConfig {
    @Bean
    public Car car() {
        return new Car(engine());
    }

    @Bean
    public Engine engine() {
        return new Engine();
    }
}

// 主程序
public class Main {
    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
        Car car = context.getBean(Car.class);
        car.start();
    }
}

在这个示例中，`Car`类依赖于`Engine`，但Spring容器负责创建`Engine`对象并注入到`Car`中，实现了IOC。

**AOP示例：**

假设你有一个应用程序，你想在不同的地方记录方法的执行时间。在传统的方式下，你需要在每个方法中插入时间记录的代码。但在Spring中，你可以使用AOP来处理这个横切关注点，将时间记录逻辑抽象为一个切面。

@Aspect
@Component
public class MethodExecutionTimeAspect {
    @Around("execution(* com.example.service.*.*(..))")
    public Object measureExecutionTime(ProceedingJoinPoint joinPoint) throws Throwable {
        long startTime = System.currentTimeMillis();
        Object result = joinPoint.proceed();
        long endTime = System.currentTimeMillis();
        String methodName = joinPoint.getSignature().toShortString();
        System.out.println(methodName + " executed in " + (endTime - startTime) + " ms");
        return result;
    }
}

@Service
public class MyService {
    public void doSomething() {
        // Some business logic
    }
}

@Configuration
@EnableAspectJAutoProxy
@ComponentScan(basePackages = "com.example")
public class AppConfig {
}

public class Main {
    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
        MyService myService = context.getBean(MyService.class);
        myService.doSomething();
    }
}

在这个示例中，`MethodExecutionTimeAspect`是一个切面，它使用`@Around`注解来捕获被切点定义的方法的执行。在`MyService`的`doSomething`方法执行前后，切面记录了方法的执行时间。这是AOP的一个典型应用，用于处理横切关注点，如性能监控、日志、安全等。