第19章_Spring框架

授课语音

理解Spring的控制反转、依赖注入和面向切面编程

Spring框架是Java开发中的核心框架之一，它通过控制反转（IoC）和依赖注入（DI）等机制大大简化了Java应用的开发。除了这些，Spring还提供了强大的面向切面编程（AOP）支持，这使得应用程序的开发更加模块化和灵活。

本课件将深入讲解Spring的核心功能，包括控制反转、依赖注入和面向切面编程，并通过代码示例帮助大家理解这些概念和技术。

1. 控制反转（IoC）与依赖注入（DI）

1.1 控制反转（IoC）概念

控制反转（Inversion of Control, IoC）是指对象的创建和管理不再由程序员直接控制，而是交由Spring容器来管理。IoC的核心思想是将控制权从程序中反转出来，交给容器，使得对象之间的依赖关系不再由应用程序代码明确管理。

1.2 依赖注入（DI）概念

依赖注入（Dependency Injection, DI）是IoC的一种实现方式，它通过将对象的依赖（即其他对象）注入到目标对象中，而不是让目标对象自己去创建依赖对象。Spring框架通过DI机制自动将对象的依赖关系注入到类的字段、构造方法或setter方法中。

1.2.1 DI的三种方式

构造器注入：通过构造器传递依赖对象。
Setter注入：通过setter方法注入依赖对象。
字段注入：通过字段直接注入依赖对象。

1.3 代码示例：控制反转与依赖注入

// 1. 定义一个Service接口
public interface UserService {
    void createUser();
}

// 2. 实现UserService接口
public class UserServiceImpl implements UserService {
    @Override
    public void createUser() {
        System.out.println("创建用户");
    }
}

// 3. 创建Controller类，并依赖UserService
public class UserController {
    private UserService userService;

    // 通过构造器注入依赖
    public UserController(UserService userService) {
        this.userService = userService;
    }

    public void createUser() {
        userService.createUser();
    }
}

// 4. Spring配置类
@Configuration
@ComponentScan(basePackages = "com.example")
public class AppConfig {
    // 定义一个bean
    @Bean
    public UserService userService() {
        return new UserServiceImpl();
    }

    @Bean
    public UserController userController() {
        return new UserController(userService());
    }
}

// 5. 启动类
public class Main {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
        UserController userController = context.getBean(UserController.class);
        userController.createUser();  // 输出：创建用户
        context.close();
    }
}

解释：

在Spring中，控制反转通过 @Configuration 和 @Bean 注解管理对象的创建和依赖关系。
依赖注入通过构造方法注入，将 UserService 自动注入到 UserController 类中。

2. 面向切面编程（AOP）

2.1 AOP的概念

面向切面编程（Aspect-Oriented Programming, AOP）是一种编程范式，它通过横切关注点（如日志记录、性能监控、事务管理等）将其与主业务逻辑解耦。AOP允许你将这些横切逻辑抽离成一个独立的模块（切面），在适当的时机进行织入。

2.2 AOP的基本概念

切面（Aspect）：定义横切逻辑的类，可以包含前置、后置、环绕等通知。
连接点（JoinPoint）：程序执行的某个点，如方法调用时。
通知（Advice）：横切逻辑，可以在方法执行前后进行操作。
切点（Pointcut）：定义在哪些连接点上应用通知。
织入（Weaving）：将通知与连接点结合的过程。

2.3 代码示例：使用AOP进行日志记录

2.3.1 定义切面类

@Aspect
@Component
public class LoggingAspect {

    // 前置通知：方法执行前执行
    @Before("execution(* com.example.service.UserService.createUser(..))")
    public void logBefore(JoinPoint joinPoint) {
        System.out.println("方法 " + joinPoint.getSignature().getName() + " 执行前");
    }

    // 后置通知：方法执行后执行
    @After("execution(* com.example.service.UserService.createUser(..))")
    public void logAfter(JoinPoint joinPoint) {
        System.out.println("方法 " + joinPoint.getSignature().getName() + " 执行后");
    }

    // 环绕通知：方法执行前后都能执行
    @Around("execution(* com.example.service.UserService.createUser(..))")
    public Object logAround(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("方法 " + joinPoint.getSignature().getName() + " 执行前");
        Object result = joinPoint.proceed();  // 执行目标方法
        System.out.println("方法 " + joinPoint.getSignature().getName() + " 执行后");
        return result;
    }
}

2.3.2 Service类

@Service
public class UserService {

    public void createUser() {
        System.out.println("正在创建用户...");
    }
}

2.3.3 Spring配置类

@Configuration
@ComponentScan(basePackages = "com.example")
@EnableAspectJAutoProxy  // 开启AOP支持
public class AppConfig {
    // 其他bean配置
}

2.3.4 运行输出

方法 createUser 执行前
正在创建用户...
方法 createUser 执行后