03_IOC和AOP-CSDN博客

本文链接：https://blog.csdn.net/qq_36341729/article/details/148095305

文章目录

- - 一、IOC（控制反转）
  - 二、AOP（面向切面编程）

IOC（控制反转）和AOP（面向切面编程）是现代软件开发中的重要概念，特别是在使用Spring框架等主流框架时，这两种技术被广泛应用。下面是对IOC和AOP的详细解析以及相应的代码示例。

一、IOC（控制反转）

概念：
- IOC是一种设计原则，通过将对象的创建和依赖关系的管理交给外部容器来降低代码的耦合度。
- IOC的核心思想是将控制权从应用程序代码转移到框架或容器，从而实现松耦合和更易于测试的代码。
核心组件：
- 依赖注入（DI）：是实现IOC的一种方式，通过注入依赖对象来实现控制反转。DI有三种常见的方式：构造器注入、setter注入和接口注入。
- IOC容器：负责管理对象的生命周期和依赖关系的容器。Spring框架提供了强大的IOC容器，支持Bean的定义、创建和注入。
优势：
- 对象创建与管理：IOC容器负责创建和管理应用程序中的对象，简化了对象的创建过程。
- 依赖关系管理：通过DI来管理对象之间的依赖关系，减少代码耦合。
- 配置管理：通过外部配置文件来管理应用程序的配置，提高灵活性和可维护性。
- 单元测试：通过DI来模拟依赖对象，便于单元测试的编写。
代码示例：

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

// 实现Service接口
@Service
public class UserServiceImpl implements UserService {
    @Autowired
    private UserRepository userRepository;

    @Override
    public void createUser(String username) {
        userRepository.save(new User(username));
    }
}

// 定义Repository接口
public interface UserRepository {
    void save(User user);
}

// 实现Repository接口
@Repository
public class UserRepositoryImpl implements UserRepository {
    @Override
    public void save(User user) {
        // 保存用户信息的逻辑
    }
}

// 定义Controller类
@RestController
@RequestMapping("/users")
public class UserController {
    @Autowired
    private UserService userService;

    @PostMapping
    public ResponseEntity<Void> createUser(@RequestBody String username) {
        userService.createUser(username);
        return ResponseEntity.ok().build();
    }
}

在这个例子中，UserController、UserService和UserRepository都通过@Autowired注解实现了依赖注入，由Spring的IOC容器来管理它们的依赖关系。

二、AOP（面向切面编程）

‌**切面（Aspect）**‌：
- 封装横切关注点的模块化单元。切面定义了在何时、何地、以何种方式“切入”到业务代码中。
- 每个切面都可以包含多个切点和通知，以决定切面在应用中的行为方式。
‌**连接点（Join Point）**‌：
- 程序执行的某个特定点，比如方法的调用、异常的抛出、字段的访问等。
- 在AOP中，切点是潜在的切入位置，表示横切关注点可以在何处插入到应用代码中。
‌**通知（Advice）**‌：
- 定义了切面在切点上的具体行为。通知是AOP的执行部分，表示在匹配的切点上执行的代码逻辑。有如下五种：
- ‌**前置通知（Before Advice）**‌：在方法执行之前执行的通知。
- ‌**后置通知（After Advice）**‌：在方法执行之后执行的通知，不管方法是否发生异常。
- ‌**返回通知（After Returning Advice）**‌：在方法正常返回后执行的通知。
- ‌**异常通知（After Throwing Advice）**‌：在方法抛出异常时执行的通知。
- ‌**环绕通知（Around Advice）**‌：在方法执行的前后都执行的通知，允许在方法调用之前和之后都添加自定义逻辑。这种通知最为灵活，可以完全控制目标方法的执行流程。
‌**切入点（Pointcut）**‌：
- 匹配连接点的条件，通知仅会在切入点方法执行时被应用。
‌**目标对象（Target）**‌：
- 应用AOP切面的对象，即包含业务逻辑的实际对象。AOP通过对目标对象的增强来实现切面功能。
‌**代理（Proxy）**‌：
- AOP在目标对象上的“包装”，负责实现对目标对象的增强。
- ‌JDK动态代理‌：基于接口创建的代理，适用于目标对象实现接口的情况。
- ‌CGLIB代理‌：基于子类的代理，适用于目标对象没有实现接口的情况。
‌**织入（Weaving）**‌：
- 将切面逻辑与目标对象结合的过程，也就是将切面应用到目标对象上，使得增强的代码在目标对象的方法中生效。
- ‌编译时织入‌：在编译时将切面织入到目标代码中，生成增强后的字节码。
- ‌类加载时织入‌：在类加载到JVM时，通过字节码操作将切面织入到目标类中。
- ‌运行时织入‌：在程序运行期间，通过动态代理或其他方式将切面织入到目标对象中。这是Spring AOP的主要方式。
优势：
- 日志记录：在方法调用前后记录日志，便于调试和监控。
- 事务管理：在方法执行前后管理事务，确保数据一致性。
- 安全检查：在方法执行前进行权限验证，确保安全性。
- 性能监控：在方法执行前后记录执行时间，进行性能分析。
- 异常处理：统一处理方法执行过程中抛出的异常，提升代码健壮性。
代码示例：

AOP（面向切面编程）在Java中常用于日志记录、事务管理等方面。下面是一个使用Spring AOP进行日志记录的简单示例代码。

引入依赖

首先，确保你的项目中引入了Spring AOP相关的依赖。如果你使用的是Maven，可以在pom.xml中添加以下依赖：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
</dependency>

定义一个服务类

接下来，定义一个简单的服务类，该类将包含一些业务方法，我们将对这些方法进行日志记录。

package com.example.demo.service;

import org.springframework.stereotype.Service;

@Service
public class MyService {

    public void doSomething() {
        System.out.println("Doing something...");
    }

    public String sayHello(String name) {
        return "Hello, " + name;
    }
}

创建一个切面类

然后，创建一个切面类，该类将包含日志记录的逻辑。

package com.example.demo.aspect;

import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;

@Aspect
@Component
public class LoggingAspect {

    private static final Logger logger = LoggerFactory.getLogger(LoggingAspect.class);

    // 定义一个切入点，匹配MyService中的所有方法
    @Pointcut("execution(* com.example.demo.service.MyService.*(..))")
    public void myServiceMethods() {}

    // 在方法执行之前记录日志
    @Before("myServiceMethods()")
    public void logBefore() {
        logger.info("Method is about to be executed");
    }

    // 在方法成功执行之后记录日志（返回结果）
    @AfterReturning(pointcut = "myServiceMethods()", returning = "result")
    public void logAfterReturning(Object result) {
        logger.info("Method executed successfully, result: {}", result);
    }
}

配置Spring Boot应用程序

确保你的Spring Boot应用程序已经正确配置了组件扫描，以便能够扫描到上面定义的切面类和服务类。

package com.example.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class DemoApplication {

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

测试日志记录

最后，你可以创建一个简单的控制器或测试类来调用MyService的方法，并观察日志输出。

package com.example.demo;

import com.example.demo.service.MyService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;

@Component
public class MyCommandLineRunner implements CommandLineRunner {

    @Autowired
    private MyService myService;

    @Override
    public void run(String... args) throws Exception {
        myService.doSomething();
        String hello = myService.sayHello("World");
        System.out.println(hello); // This will also be printed to the console, but the log is more interesting
    }
}