Spring IOC 和 AOP 从入门到精通

对象A需要对象B → 对象A自己创建对象B（new B()）

对象A需要对象B → 对象A声明需要B → Spring容器创建B并注入给A

/**
 * 传统方式：UserService 直接创建 UserDao
 * 缺点：
 * 1. 高耦合：UserService 直接依赖 UserDao 的具体实现
 * 2. 难以测试：无法轻易替换 UserDao 的实现
 * 3. 不灵活：如果要换一个 UserDao 实现,需要修改 UserService 代码
 */
public class UserService {
    // 直接在类内部创建依赖对象
    private UserDao userDao = new UserDaoImpl();
    public void addUser(String username) {
        // 使用 userDao 进行数据库操作
        userDao.save(username);
    }
}
// UserDao 接口
interface UserDao {
    void save(String username);
}
// UserDao 的具体实现
class UserDaoImpl implements UserDao {
    @Override
    public void save(String username) {
        System.out.println("保存用户：" + username);
    }
}

/**
 * IOC方式：UserService 不再自己创建 UserDao,而是通过依赖注入获得
 * 优点：
 * 1. 低耦合：UserService 只依赖 UserDao 接口,不关心具体实现
 * 2. 易于测试：可以轻松注入模拟对象（Mock）进行单元测试
 * 3. 灵活性高：可以通过配置切换不同的 UserDao 实现,无需修改代码
 */
import org.springframework.stereotype.Service;
import org.springframework.beans.factory.annotation.Autowired;
@Service  // 告诉Spring这是一个服务类,需要被Spring管理
public class UserService {
    // 使用@Autowired注解,让Spring自动注入UserDao的实例
    // Spring会在容器中查找UserDao类型的Bean,并自动赋值给这个变量
    @Autowired
    private UserDao userDao;
    public void addUser(String username) {
        // 使用注入的 userDao 对象
        userDao.save(username);
    }
}
// UserDao 接口定义
interface UserDao {
    void save(String username);
}
// UserDao 的实现类
import org.springframework.stereotype.Repository;
@Repository  // 告诉Spring这是一个数据访问层组件,需要被Spring管理
class UserDaoImpl implements UserDao {
    @Override
    public void save(String username) {
        System.out.println("保存用户到数据库：" + username);
    }
}

┌─────────────────────────────────────────────────────┐
│                   Spring IOC容器                      │
│                                                       │
│  1. 读取配置（XML/注解）                               │
│         ↓                                             │
│  2. 解析Bean定义信息                                   │
│         ↓                                             │
│  3. 使用反射创建Bean实例                               │
│         ↓                                             │
│  4. 进行依赖注入（属性赋值）                           │
│         ↓                                             │
│  5. 初始化Bean（调用初始化方法）                       │
│         ↓                                             │
│  6. 将Bean放入容器（可供使用）                         │
│         ↓                                             │
│  7. 容器关闭时销毁Bean                                 │
└─────────────────────────────────────────────────────┘

                原始对象（Target）
                      ↓
            Spring AOP 检测到需要增强
                      ↓
            创建代理对象（Proxy）
                      ↓
     ┌─────────────────────────────────┐
     │         代理对象                 │
     │  ┌──────────────────────────┐   │
     │  │  前置通知（Before）       │   │
     │  └──────────────────────────┘   │
     │              ↓                   │
     │  ┌──────────────────────────┐   │
     │  │  调用原始方法             │   │
     │  └──────────────────────────┘   │
     │              ↓                   │
     │  ┌──────────────────────────┐   │
     │  │  后置通知（After）        │   │
     │  └──────────────────────────┘   │
     └─────────────────────────────────┘

/**
 * 构造器注入示例
 * 优点：
 * 1. 依赖关系明确,必须在对象创建时提供
 * 2. 注入的对象可以声明为final,保证不可变性
 * 3. 便于编写单元测试
 * 
 * 适用场景：强制依赖、不可变对象
 */
import org.springframework.stereotype.Service;
import org.springframework.beans.factory.annotation.Autowired;
@Service
public class OrderService {
    // 使用final确保依赖不可变
    private final UserService userService;
    private final ProductService productService;
    /**
     * 构造器注入
     * @Autowired 可以省略（Spring 4.3+,只有一个构造器时）
     * 
     * @param userService 用户服务
     * @param productService 商品服务
     */
    @Autowired
    public OrderService(UserService userService, ProductService productService) {
        // Spring会自动传入这两个参数
        this.userService = userService;
        this.productService = productService;
        System.out.println("OrderService通过构造器注入创建");
    }
    /**
     * 创建订单的业务方法
     */
    public void createOrder(String username, String productName) {
        // 使用注入的依赖
        userService.addUser(username);
        System.out.println("订单创建成功：用户=" + username + ", 商品=" + productName);
    }
}

/**
 * Setter注入示例
 * 优点：
 * 1. 灵活性高,可以在对象创建后修改依赖
 * 2. 可以注入可选依赖
 * 
 * 缺点：
 * 1. 可能造成对象处于不完整状态
 * 2. 依赖关系不够明确
 * 
 * 适用场景：可选依赖、需要重新配置的依赖
 */
import org.springframework.stereotype.Service;
import org.springframework.beans.factory.annotation.Autowired;
@Service
public class EmailService {
    private MailSender mailSender;  // 非final,可以修改
    /**
     * Setter方法注入
     * Spring会自动调用这个方法,传入MailSender实例
     * 
     * @param mailSender 邮件发送器
     */
    @Autowired
    public void setMailSender(MailSender mailSender) {
        this.mailSender = mailSender;
        System.out.println("通过Setter方法注入MailSender");
    }
    /**
     * 发送邮件
     */
    public void sendEmail(String to, String content) {
        if (mailSender != null) {
            mailSender.send(to, content);
        } else {
            System.out.println("MailSender未注入,无法发送邮件");
        }
    }
}

/**
 * 字段注入示例
 * 优点：
 * 1. 代码最简洁
 * 2. 使用方便
 * 
 * 缺点：
 * 1. 难以进行单元测试（无法轻松注入Mock对象）
 * 2. 违反了依赖注入的原则（依赖关系不明确）
 * 3. 无法声明为final
 * 4. IDE会给出警告
 * 
 * 适用场景：快速开发、原型项目（生产环境不推荐）
 */
import org.springframework.stereotype.Service;
import org.springframework.beans.factory.annotation.Autowired;
@Service
public class PaymentService {
    // 直接在字段上注入,Spring通过反射设置值
    @Autowired
    private UserService userService;
    @Autowired
    private OrderService orderService;
    /**
     * 处理支付
     */
    public void processPayment(String username, double amount) {
        System.out.println("处理支付：用户=" + username + ", 金额=" + amount);
        // 使用注入的依赖
        userService.addUser(username);
    }
}

                    切面（Aspect）
                    ┌─────────────────────┐
                    │  @Aspect             │
                    │  LoggingAspect       │
                    │                      │
                    │  切点（Pointcut）     │
                    │  ↓                   │
                    │  execution(* com.example..*(..))  │
                    │                      │
                    │  通知（Advice）       │
                    │  ↓                   │
                    │  @Before             │
                    │  @After              │
                    │  @Around             │
                    └─────────────────────┘
                              ↓
                        织入（Weaving）
                              ↓
                    ┌─────────────────────┐
                    │  目标对象（Target）   │
                    │  UserService         │
                    └─────────────────────┘
                              ↓
                    ┌─────────────────────┐
                    │  代理对象（Proxy）    │
                    │  UserServiceProxy    │
                    └─────────────────────┘

/**
 * AOP通知类型完整示例
 * 演示五种通知类型的执行时机和用法
 */
import org.aspectj.lang.annotation.*;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.springframework.stereotype.Component;
/**
 * 日志切面：演示各种通知类型
 */
@Aspect  // 标记这是一个切面类
@Component  // 将切面类注册为Spring Bean
public class LoggingAspect {
    /**
     * 1. 前置通知（Before Advice）
     * 在目标方法执行之前执行
     * 
     * 使用场景：参数验证、权限检查、日志记录
     * 
     * @param joinPoint 连接点,包含方法信息
     */
    @Before("execution(* com.example.service.*.*(..))")
    public void beforeAdvice(JoinPoint joinPoint) {
        // 获取方法名
        String methodName = joinPoint.getSignature().getName();
        // 获取参数
        Object[] args = joinPoint.getArgs();
        System.out.println("=== 前置通知 ===");
        System.out.println("即将执行方法：" + methodName);
        System.out.println("方法参数：" + java.util.Arrays.toString(args));
    }
    /**
     * 2. 后置通知（After Returning Advice）
     * 在目标方法正常返回后执行（不包括异常情况）
     * 
     * 使用场景：记录返回值、数据处理、缓存更新
     * 
     * @param joinPoint 连接点
     * @param result 方法返回值
     */
    @AfterReturning(
        pointcut = "execution(* com.example.service.*.*(..))",
        returning = "result"  // 指定返回值参数名
    )
    public void afterReturningAdvice(JoinPoint joinPoint, Object result) {
        String methodName = joinPoint.getSignature().getName();
        System.out.println("=== 后置通知 ===");
        System.out.println("方法执行成功：" + methodName);
        System.out.println("返回值：" + result);
    }
    /**
     * 3. 异常通知（After Throwing Advice）
     * 在目标方法抛出异常后执行
     * 
     * 使用场景：异常日志记录、异常转换、告警通知
     * 
     * @param joinPoint 连接点
     * @param exception 抛出的异常
     */
    @AfterThrowing(
        pointcut = "execution(* com.example.service.*.*(..))",
        throwing = "exception"  // 指定异常参数名
    )
    public void afterThrowingAdvice(JoinPoint joinPoint, Exception exception) {
        String methodName = joinPoint.getSignature().getName();
        System.out.println("=== 异常通知 ===");
        System.out.println("方法执行异常：" + methodName);
        System.out.println("异常信息：" + exception.getMessage());
    }
    /**
     * 4. 最终通知（After Advice）
     * 在目标方法执行之后执行（无论是否抛出异常）
     * 类似于finally块
     * 
     * 使用场景：资源释放、清理工作
     * 
     * @param joinPoint 连接点
     */
    @After("execution(* com.example.service.*.*(..))")
    public void afterAdvice(JoinPoint joinPoint) {
        String methodName = joinPoint.getSignature().getName();
        System.out.println("=== 最终通知 ===");
        System.out.println("方法执行完毕：" + methodName);
    }
    /**
     * 5. 环绕通知（Around Advice）
     * 包围目标方法,可以控制方法的执行
     * 最强大的通知类型
     * 
     * 使用场景：性能统计、事务管理、缓存处理
     * 
     * @param proceedingJoinPoint 可执行的连接点
     * @return 方法返回值
     * @throws Throwable 方法可能抛出的异常
     */
    @Around("execution(* com.example.service.*.*(..))")
    public Object aroundAdvice(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        String methodName = proceedingJoinPoint.getSignature().getName();
        System.out.println("=== 环绕通知开始 ===");
        System.out.println("准备执行方法：" + methodName);
        // 记录开始时间
        long startTime = System.currentTimeMillis();
        Object result = null;
        try {
            // 执行目标方法（这是关键！）
            result = proceedingJoinPoint.proceed();
            // 目标方法执行成功
            System.out.println("方法执行成功,返回值：" + result);
        } catch (Throwable throwable) {
            // 目标方法执行失败
            System.out.println("方法执行失败：" + throwable.getMessage());
            throw throwable;  // 重新抛出异常
        } finally {
            // 计算执行时间
            long endTime = System.currentTimeMillis();
            long executionTime = endTime - startTime;
            System.out.println("方法执行耗时：" + executionTime + "ms");
            System.out.println("=== 环绕通知结束 ===");
        }
        // 返回结果（可以修改返回值）
        return result;
    }
}

正常执行流程：
@Around 开始
    ↓
@Before
    ↓
目标方法执行
    ↓
@AfterReturning
    ↓
@After
    ↓
@Around 结束
异常执行流程：
@Around 开始
    ↓
@Before
    ↓
目标方法执行（抛出异常）
    ↓
@AfterThrowing
    ↓
@After
    ↓
@Around 异常处理

        业务逻辑层
┌─────────────────────────┐
│                         │
│  UserService            │ ← 日志、事务、权限
│  OrderService           │ ← 日志、事务、权限
│  ProductService         │ ← 日志、事务、权限
│  PaymentService         │ ← 日志、事务、权限
│                         │
└─────────────────────────┘
横切关注点：
- 日志记录
- 事务管理
- 权限检查
- 性能监控

/**
 * 没有AOP的代码：每个方法都要写重复的横切逻辑
 * 问题：
 * 1. 代码重复
 * 2. 业务逻辑和横切逻辑混在一起
 * 3. 难以维护
 * 4. 修改横切逻辑需要改动所有方法
 */
public class UserServiceWithoutAOP {
    public void addUser(String username) {
        // ===== 横切逻辑开始 =====
        // 1. 日志记录
        System.out.println("[日志] 开始执行addUser方法,参数：" + username);
        long startTime = System.currentTimeMillis();
        try {
            // 2. 权限检查
            if (!checkPermission()) {
                System.out.println("[权限] 无权限执行此操作");
                return;
            }
            // 3. 事务开启
            beginTransaction();
            // ===== 业务逻辑开始 =====
            System.out.println("执行添加用户的业务逻辑：" + username);
            // 实际的业务代码...
            // ===== 业务逻辑结束 =====
            // 4. 事务提交
            commitTransaction();
        } catch (Exception e) {
            // 5. 事务回滚
            rollbackTransaction();
            System.out.println("[异常] 方法执行失败：" + e.getMessage());
        } finally {
            // 6. 性能统计
            long endTime = System.currentTimeMillis();
            System.out.println("[性能] 方法执行耗时：" + (endTime - startTime) + "ms");
        }
        // ===== 横切逻辑结束 =====
    }
    public void deleteUser(String username) {
        // 同样的横切逻辑又要写一遍...
        System.out.println("[日志] 开始执行deleteUser方法,参数：" + username);
        // ... 重复代码 ...
    }
    // 辅助方法
    private boolean checkPermission() { return true; }
    private void beginTransaction() { }
    private void commitTransaction() { }
    private void rollbackTransaction() { }
}

/**
 * 使用AOP的代码：业务逻辑和横切逻辑完全分离
 * 优点：
 * 1. 代码简洁,只关注业务逻辑
 * 2. 横切逻辑集中管理
 * 3. 易于维护和扩展
 * 4. 修改横切逻辑只需修改切面类
 */
import org.springframework.stereotype.Service;
@Service
public class UserServiceWithAOP {
    /**
     * 添加用户
     * 注意：这个方法只包含业务逻辑
     * 日志、权限、事务等横切逻辑由AOP切面自动处理
     */
    public void addUser(String username) {
        // 纯粹的业务逻辑,简洁明了
        System.out.println("执行添加用户的业务逻辑：" + username);
    }
    /**
     * 删除用户
     */
    public void deleteUser(String username) {
        // 纯粹的业务逻辑
        System.out.println("执行删除用户的业务逻辑：" + username);
    }
}

/**
 * 反射机制完整示例
 * 演示反射的各种用法
 */
import java.lang.reflect.*;
/**
 * 用户类（作为反射操作的目标）
 */
class User {
    // 私有字段
    private String username;
    private int age;
    // 无参构造器
    public User() {
        System.out.println("无参构造器被调用");
    }
    // 有参构造器
    public User(String username, int age) {
        this.username = username;
        this.age = age;
        System.out.println("有参构造器被调用：" + username + ", " + age);
    }
    // 公共方法
    public void sayHello() {
        System.out.println("Hello, I'm " + username);
    }
    // 私有方法
    private void secretMethod() {
        System.out.println("这是一个私有方法");
    }
    // Getter和Setter
    public String getUsername() { return username; }
    public void setUsername(String username) { this.username = username; }
    public int getAge() { return age; }
    public void setAge(int age) { this.age = age; }
    @Override
    public String toString() {
        return "User{username='" + username + "', age=" + age + "}";
    }
}
/**
 * 反射示例类
 */
public class ReflectionDemo {
    public static void main(String[] args) throws Exception {
        System.out.println("=== 反射机制演示 ===\n");
        // 1. 获取Class对象的三种方式
        demonstrateGetClass();
        // 2. 创建对象
        demonstrateCreateInstance();
        // 3. 访问和修改字段
        demonstrateFieldAccess();
        // 4. 调用方法
        demonstrateMethodInvocation();
        // 5. 获取类信息
        demonstrateClassInfo();
    }
    /**
     * 演示获取Class对象的三种方式
     */
    private static void demonstrateGetClass() throws Exception {
        System.out.println("=== 1. 获取Class对象 ===");
        // 方式1：通过类名.class
        Class<?> clazz1 = User.class;
        System.out.println("方式1（类名.class）：" + clazz1.getName());
        // 方式2：通过对象.getClass()
        User user = new User();
        Class<?> clazz2 = user.getClass();
        System.out.println("方式2（对象.getClass()）：" + clazz2.getName());
        // 方式3：通过Class.forName()（最常用）
        Class<?> clazz3 = Class.forName("User");
        System.out.println("方式3（Class.forName()）：" + clazz3.getName());
        System.out.println();
    }
    /**
     * 演示创建对象
     */
    private static void demonstrateCreateInstance() throws Exception {
        System.out.println("=== 2. 创建对象 ===");
        Class<?> clazz = User.class;
        // 方式1：使用无参构造器创建对象
        System.out.println("方式1：使用无参构造器");
        User user1 = (User) clazz.getDeclaredConstructor().newInstance();
        // 方式2：使用有参构造器创建对象
        System.out.println("\n方式2：使用有参构造器");
        Constructor<?> constructor = clazz.getConstructor(String.class, int.class);
        User user2 = (User) constructor.newInstance("张三", 25);
        System.out.println("创建的对象：" + user2);
        System.out.println();
    }
    /**
     * 演示访问和修改字段
     */
    private static void demonstrateFieldAccess() throws Exception {
        System.out.println("=== 3. 访问和修改字段 ===");
        User user = new User("李四", 30);
        Class<?> clazz = user.getClass();
        // 获取私有字段
        Field usernameField = clazz.getDeclaredField("username");
        Field ageField = clazz.getDeclaredField("age");
        // 设置可访问（绕过private限制）
        usernameField.setAccessible(true);
        ageField.setAccessible(true);
        // 读取字段值
        System.out.println("原始username：" + usernameField.get(user));
        System.out.println("原始age：" + ageField.get(user));
        // 修改字段值
        usernameField.set(user, "王五");
        ageField.set(user, 35);
        System.out.println("修改后的对象：" + user);
        System.out.println();
    }
    /**
     * 演示调用方法
     */
    private static void demonstrateMethodInvocation() throws Exception {
        System.out.println("=== 4. 调用方法 ===");
        User user = new User("赵六", 28);
        Class<?> clazz = user.getClass();
        // 调用公共方法
        System.out.println("调用公共方法：");
        Method sayHelloMethod = clazz.getMethod("sayHello");
        sayHelloMethod.invoke(user);
        // 调用私有方法
        System.out.println("\n调用私有方法：");
        Method secretMethod = clazz.getDeclaredMethod("secretMethod");
        secretMethod.setAccessible(true);  // 绕过private限制
        secretMethod.invoke(user);
        System.out.println();
    }
    /**
     * 演示获取类信息
     */
    private static void demonstrateClassInfo() throws Exception {
        System.out.println("=== 5. 获取类信息 ===");
        Class<?> clazz = User.class;
        // 获取类名
        System.out.println("类名：" + clazz.getName());
        System.out.println("简单类名：" + clazz.getSimpleName());
        // 获取所有公共字段
        System.out.println("\n公共字段：");
        Field[] publicFields = clazz.getFields();
        for (Field field : publicFields) {
            System.out.println("  " + field.getName());
        }
        // 获取所有字段（包括私有）
        System.out.println("\n所有字段：");
        Field[] allFields = clazz.getDeclaredFields();
        for (Field field : allFields) {
            System.out.println("  " + Modifier.toString(field.getModifiers()) + 
                             " " + field.getType().getSimpleName() + 
                             " " + field.getName());
        }
        // 获取所有方法
        System.out.println("\n所有方法：");
        Method[] methods = clazz.getDeclaredMethods();
        for (Method method : methods) {
            System.out.println("  " + method.getName() + "()");
        }
        System.out.println();
    }
}

// @Autowired：按类型注入
@Autowired
private UserService userService;
// @Resource：按名称注入
@Resource(name = "userServiceImpl")
private UserService userService;

@Service
@Scope("prototype")  // 设置为原型作用域
public class UserService {
    // ...
}

// JDK动态代理：目标类实现接口
public interface UserService {
    void addUser(String username);
}
@Service
public class UserServiceImpl implements UserService {
    @Override
    public void addUser(String username) {
        System.out.println("添加用户：" + username);
    }
}
// CGLIB代理：目标类没有实现接口
@Service
public class ProductService {
    public void addProduct(String productName) {
        System.out.println("添加商品：" + productName);
    }
}

@Around 开始 → @Before → 目标方法 → @AfterReturning → @After → @Around 结束

execution(修饰符? 返回类型 包名.类名.方法名(参数) 异常?)

// 1. 匹配所有public方法
execution(public * *(..))
// 2. 匹配service包下所有类的所有方法
execution(* com.example.service.*.*(..))
// 3. 匹配service包及子包下所有类的所有方法
execution(* com.example.service..*.*(..))
// 4. 匹配UserService类的所有方法
execution(* com.example.service.UserService.*(..))
// 5. 匹配add开头的方法
execution(* com.example.service.*Service.add*(..))
// 6. 匹配只有一个String参数的方法
execution(* com.example.service.*Service.*(String))
// 7. 匹配第一个参数为String的方法
execution(* com.example.service.*Service.*(String,..))

// 优化前：每次都获取Method对象
for (int i = 0; i < 10000; i++) {
    Method method = clazz.getMethod("sayHello");
    method.invoke(user);
}
// 优化后：缓存Method对象
Method method = clazz.getMethod("sayHello");
method.setAccessible(true);  // 关闭安全检查
for (int i = 0; i < 10000; i++) {
    method.invoke(user);
}

// 方式1：通过类名.class（编译时确定）
Class<?> clazz1 = User.class;
// 方式2：通过对象.getClass()（运行时获取）
User user = new User();
Class<?> clazz2 = user.getClass();
// 方式3：通过Class.forName()（最灵活）
Class<?> clazz3 = Class.forName("com.example.User");