對象A需要對象B → 對象A自己創(chuàng)建對象B（new B()）

對象A需要對象B → 對象A聲明需要B → Spring容器創(chuàng)建B并注入給A

/**
 * 傳統(tǒng)方式：UserService 直接創(chuàng)建 UserDao
 * 缺點：
 * 1. 高耦合：UserService 直接依賴 UserDao 的具體實現(xiàn)
 * 2. 難以測試：無法輕易替換 UserDao 的實現(xiàn)
 * 3. 不靈活：如果要換一個 UserDao 實現(xiàn),需要修改 UserService 代碼
 */
public class UserService {
    // 直接在類內部創(chuàng)建依賴對象
    private UserDao userDao = new UserDaoImpl();
    public void addUser(String username) {
        // 使用 userDao 進行數(shù)據(jù)庫操作
        userDao.save(username);
    }
}
// UserDao 接口
interface UserDao {
    void save(String username);
}
// UserDao 的具體實現(xiàn)
class UserDaoImpl implements UserDao {
    @Override
    public void save(String username) {
        System.out.println("保存用戶：" + username);
    }
}

/**
 * IOC方式：UserService 不再自己創(chuàng)建 UserDao,而是通過依賴注入獲得
 * 優(yōu)點：
 * 1. 低耦合：UserService 只依賴 UserDao 接口,不關心具體實現(xiàn)
 * 2. 易于測試：可以輕松注入模擬對象（Mock）進行單元測試
 * 3. 靈活性高：可以通過配置切換不同的 UserDao 實現(xiàn),無需修改代碼
 */
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 的實現(xiàn)類
import org.springframework.stereotype.Repository;
@Repository  // 告訴Spring這是一個數(shù)據(jù)訪問層組件,需要被Spring管理
class UserDaoImpl implements UserDao {
    @Override
    public void save(String username) {
        System.out.println("保存用戶到數(shù)據(jù)庫：" + username);
    }
}

┌─────────────────────────────────────────────────────┐
│                   Spring IOC容器                      │
│                                                       │
│  1. 讀取配置（XML/注解）                               │
│         ↓                                             │
│  2. 解析Bean定義信息                                   │
│         ↓                                             │
│  3. 使用反射創(chuàng)建Bean實例                               │
│         ↓                                             │
│  4. 進行依賴注入（屬性賦值）                           │
│         ↓                                             │
│  5. 初始化Bean（調用初始化方法）                       │
│         ↓                                             │
│  6. 將Bean放入容器（可供使用）                         │
│         ↓                                             │
│  7. 容器關閉時銷毀Bean                                 │
└─────────────────────────────────────────────────────┘

                原始對象（Target）
                      ↓
            Spring AOP 檢測到需要增強
                      ↓
            創(chuàng)建代理對象（Proxy）
                      ↓
     ┌─────────────────────────────────┐
     │         代理對象                 │
     │  ┌──────────────────────────┐   │
     │  │  前置通知（Before）       │   │
     │  └──────────────────────────┘   │
     │              ↓                   │
     │  ┌──────────────────────────┐   │
     │  │  調用原始方法             │   │
     │  └──────────────────────────┘   │
     │              ↓                   │
     │  ┌──────────────────────────┐   │
     │  │  后置通知（After）        │   │
     │  └──────────────────────────┘   │
     └─────────────────────────────────┘

/**
 * 構造器注入示例
 * 優(yōu)點：
 * 1. 依賴關系明確,必須在對象創(chuàng)建時提供
 * 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會自動傳入這兩個參數(shù)
        this.userService = userService;
        this.productService = productService;
        System.out.println("OrderService通過構造器注入創(chuàng)建");
    }
    /**
     * 創(chuàng)建訂單的業(yè)務方法
     */
    public void createOrder(String username, String productName) {
        // 使用注入的依賴
        userService.addUser(username);
        System.out.println("訂單創(chuàng)建成功：用戶=" + username + ", 商品=" + productName);
    }
}

/**
 * Setter注入示例
 * 優(yōu)點：
 * 1. 靈活性高,可以在對象創(chuàng)建后修改依賴
 * 2. 可以注入可選依賴
 * 
 * 缺點：
 * 1. 可能造成對象處于不完整狀態(tài)
 * 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 郵件發(fā)送器
     */
    @Autowired
    public void setMailSender(MailSender mailSender) {
        this.mailSender = mailSender;
        System.out.println("通過Setter方法注入MailSender");
    }
    /**
     * 發(fā)送郵件
     */
    public void sendEmail(String to, String content) {
        if (mailSender != null) {
            mailSender.send(to, content);
        } else {
            System.out.println("MailSender未注入,無法發(fā)送郵件");
        }
    }
}

/**
 * 字段注入示例
 * 優(yōu)點：
 * 1. 代碼最簡潔
 * 2. 使用方便
 * 
 * 缺點：
 * 1. 難以進行單元測試（無法輕松注入Mock對象）
 * 2. 違反了依賴注入的原則（依賴關系不明確）
 * 3. 無法聲明為final
 * 4. IDE會給出警告
 * 
 * 適用場景：快速開發(fā)、原型項目（生產環(huán)境不推薦）
 */
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通知類型完整示例
 * 演示五種通知類型的執(zhí)行時機和用法
 */
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）
     * 在目標方法執(zhí)行之前執(zhí)行
     * 
     * 使用場景：參數(shù)驗證、權限檢查、日志記錄
     * 
     * @param joinPoint 連接點,包含方法信息
     */
    @Before("execution(* com.example.service.*.*(..))")
    public void beforeAdvice(JoinPoint joinPoint) {
        // 獲取方法名
        String methodName = joinPoint.getSignature().getName();
        // 獲取參數(shù)
        Object[] args = joinPoint.getArgs();
        System.out.println("=== 前置通知 ===");
        System.out.println("即將執(zhí)行方法：" + methodName);
        System.out.println("方法參數(shù)：" + java.util.Arrays.toString(args));
    }
    /**
     * 2. 后置通知（After Returning Advice）
     * 在目標方法正常返回后執(zhí)行（不包括異常情況）
     * 
     * 使用場景：記錄返回值、數(shù)據(jù)處理、緩存更新
     * 
     * @param joinPoint 連接點
     * @param result 方法返回值
     */
    @AfterReturning(
        pointcut = "execution(* com.example.service.*.*(..))",
        returning = "result"  // 指定返回值參數(shù)名
    )
    public void afterReturningAdvice(JoinPoint joinPoint, Object result) {
        String methodName = joinPoint.getSignature().getName();
        System.out.println("=== 后置通知 ===");
        System.out.println("方法執(zhí)行成功：" + methodName);
        System.out.println("返回值：" + result);
    }
    /**
     * 3. 異常通知（After Throwing Advice）
     * 在目標方法拋出異常后執(zhí)行
     * 
     * 使用場景：異常日志記錄、異常轉換、告警通知
     * 
     * @param joinPoint 連接點
     * @param exception 拋出的異常
     */
    @AfterThrowing(
        pointcut = "execution(* com.example.service.*.*(..))",
        throwing = "exception"  // 指定異常參數(shù)名
    )
    public void afterThrowingAdvice(JoinPoint joinPoint, Exception exception) {
        String methodName = joinPoint.getSignature().getName();
        System.out.println("=== 異常通知 ===");
        System.out.println("方法執(zhí)行異常：" + methodName);
        System.out.println("異常信息：" + exception.getMessage());
    }
    /**
     * 4. 最終通知（After Advice）
     * 在目標方法執(zhí)行之后執(zhí)行（無論是否拋出異常）
     * 類似于finally塊
     * 
     * 使用場景：資源釋放、清理工作
     * 
     * @param joinPoint 連接點
     */
    @After("execution(* com.example.service.*.*(..))")
    public void afterAdvice(JoinPoint joinPoint) {
        String methodName = joinPoint.getSignature().getName();
        System.out.println("=== 最終通知 ===");
        System.out.println("方法執(zhí)行完畢：" + methodName);
    }
    /**
     * 5. 環(huán)繞通知（Around Advice）
     * 包圍目標方法,可以控制方法的執(zhí)行
     * 最強大的通知類型
     * 
     * 使用場景：性能統(tǒng)計、事務管理、緩存處理
     * 
     * @param proceedingJoinPoint 可執(zhí)行的連接點
     * @return 方法返回值
     * @throws Throwable 方法可能拋出的異常
     */
    @Around("execution(* com.example.service.*.*(..))")
    public Object aroundAdvice(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        String methodName = proceedingJoinPoint.getSignature().getName();
        System.out.println("=== 環(huán)繞通知開始 ===");
        System.out.println("準備執(zhí)行方法：" + methodName);
        // 記錄開始時間
        long startTime = System.currentTimeMillis();
        Object result = null;
        try {
            // 執(zhí)行目標方法（這是關鍵?。?
            result = proceedingJoinPoint.proceed();
            // 目標方法執(zhí)行成功
            System.out.println("方法執(zhí)行成功,返回值：" + result);
        } catch (Throwable throwable) {
            // 目標方法執(zhí)行失敗
            System.out.println("方法執(zhí)行失?。? + throwable.getMessage());
            throw throwable;  // 重新拋出異常
        } finally {
            // 計算執(zhí)行時間
            long endTime = System.currentTimeMillis();
            long executionTime = endTime - startTime;
            System.out.println("方法執(zhí)行耗時：" + executionTime + "ms");
            System.out.println("=== 環(huán)繞通知結束 ===");
        }
        // 返回結果（可以修改返回值）
        return result;
    }
}

正常執(zhí)行流程：
@Around 開始
    ↓
@Before
    ↓
目標方法執(zhí)行
    ↓
@AfterReturning
    ↓
@After
    ↓
@Around 結束
異常執(zhí)行流程：
@Around 開始
    ↓
@Before
    ↓
目標方法執(zhí)行（拋出異常）
    ↓
@AfterThrowing
    ↓
@After
    ↓
@Around 異常處理

        業(yè)務邏輯層
┌─────────────────────────┐
│                         │
│  UserService            │ ← 日志、事務、權限
│  OrderService           │ ← 日志、事務、權限
│  ProductService         │ ← 日志、事務、權限
│  PaymentService         │ ← 日志、事務、權限
│                         │
└─────────────────────────┘
橫切關注點：
- 日志記錄
- 事務管理
- 權限檢查
- 性能監(jiān)控

/**
 * 沒有AOP的代碼：每個方法都要寫重復的橫切邏輯
 * 問題：
 * 1. 代碼重復
 * 2. 業(yè)務邏輯和橫切邏輯混在一起
 * 3. 難以維護
 * 4. 修改橫切邏輯需要改動所有方法
 */
public class UserServiceWithoutAOP {
    public void addUser(String username) {
        // ===== 橫切邏輯開始 =====
        // 1. 日志記錄
        System.out.println("[日志] 開始執(zhí)行addUser方法,參數(shù)：" + username);
        long startTime = System.currentTimeMillis();
        try {
            // 2. 權限檢查
            if (!checkPermission()) {
                System.out.println("[權限] 無權限執(zhí)行此操作");
                return;
            }
            // 3. 事務開啟
            beginTransaction();
            // ===== 業(yè)務邏輯開始 =====
            System.out.println("執(zhí)行添加用戶的業(yè)務邏輯：" + username);
            // 實際的業(yè)務代碼...
            // ===== 業(yè)務邏輯結束 =====
            // 4. 事務提交
            commitTransaction();
        } catch (Exception e) {
            // 5. 事務回滾
            rollbackTransaction();
            System.out.println("[異常] 方法執(zhí)行失?。? + e.getMessage());
        } finally {
            // 6. 性能統(tǒng)計
            long endTime = System.currentTimeMillis();
            System.out.println("[性能] 方法執(zhí)行耗時：" + (endTime - startTime) + "ms");
        }
        // ===== 橫切邏輯結束 =====
    }
    public void deleteUser(String username) {
        // 同樣的橫切邏輯又要寫一遍...
        System.out.println("[日志] 開始執(zhí)行deleteUser方法,參數(shù)：" + username);
        // ... 重復代碼 ...
    }
    // 輔助方法
    private boolean checkPermission() { return true; }
    private void beginTransaction() { }
    private void commitTransaction() { }
    private void rollbackTransaction() { }
}

/**
 * 使用AOP的代碼：業(yè)務邏輯和橫切邏輯完全分離
 * 優(yōu)點：
 * 1. 代碼簡潔,只關注業(yè)務邏輯
 * 2. 橫切邏輯集中管理
 * 3. 易于維護和擴展
 * 4. 修改橫切邏輯只需修改切面類
 */
import org.springframework.stereotype.Service;
@Service
public class UserServiceWithAOP {
    /**
     * 添加用戶
     * 注意：這個方法只包含業(yè)務邏輯
     * 日志、權限、事務等橫切邏輯由AOP切面自動處理
     */
    public void addUser(String username) {
        // 純粹的業(yè)務邏輯,簡潔明了
        System.out.println("執(zhí)行添加用戶的業(yè)務邏輯：" + username);
    }
    /**
     * 刪除用戶
     */
    public void deleteUser(String username) {
        // 純粹的業(yè)務邏輯
        System.out.println("執(zhí)行刪除用戶的業(yè)務邏輯：" + 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. 創(chuàng)建對象
        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();
    }
    /**
     * 演示創(chuàng)建對象
     */
    private static void demonstrateCreateInstance() throws Exception {
        System.out.println("=== 2. 創(chuàng)建對象 ===");
        Class<?> clazz = User.class;
        // 方式1：使用無參構造器創(chuàng)建對象
        System.out.println("方式1：使用無參構造器");
        User user1 = (User) clazz.getDeclaredConstructor().newInstance();
        // 方式2：使用有參構造器創(chuàng)建對象
        System.out.println("\n方式2：使用有參構造器");
        Constructor<?> constructor = clazz.getConstructor(String.class, int.class);
        User user2 = (User) constructor.newInstance("張三", 25);
        System.out.println("創(chuàng)建的對象：" + 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動態(tài)代理：目標類實現(xiàn)接口
public interface UserService {
    void addUser(String username);
}
@Service
public class UserServiceImpl implements UserService {
    @Override
    public void addUser(String username) {
        System.out.println("添加用戶：" + username);
    }
}
// CGLIB代理：目標類沒有實現(xiàn)接口
@Service
public class ProductService {
    public void addProduct(String productName) {
        System.out.println("添加商品：" + productName);
    }
}

@Around 開始 → @Before → 目標方法 → @AfterReturning → @After → @Around 結束

execution(修飾符? 返回類型 包名.類名.方法名(參數(shù)) 異常?)

// 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參數(shù)的方法
execution(* com.example.service.*Service.*(String))
// 7. 匹配第一個參數(shù)為String的方法
execution(* com.example.service.*Service.*(String,..))

// 優(yōu)化前：每次都獲取Method對象
for (int i = 0; i < 10000; i++) {
    Method method = clazz.getMethod("sayHello");
    method.invoke(user);
}
// 優(yōu)化后：緩存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");