# java-ioc-aop

**Repository Path**: code-science-lab/java-ioc-aop

## Basic Information

- **Project Name**: java-ioc-aop
- **Description**: 使用Java Spring 实现简易的日志和缓存功能。
- **Primary Language**: Unknown
- **License**: Not specified
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2025-08-08
- **Last Updated**: 2025-08-08

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

# Spring IoC和AOP练习项目

这是一个用于学习Spring IoC（控制反转）和AOP（面向切面编程）的练习项目。

## 项目概述

本项目实现了一个简单的计算器服务，通过Spring框架演示了以下核心概念：

1. **IoC（控制反转）** - 依赖注入和容器管理
2. **AOP（面向切面编程）** - 自定义注解和切面
3. **自定义@Cache注解** - 实现方法结果缓存
4. **日志切面** - 自动记录方法执行信息

## 项目结构

```
src/main/java/com/example/
├── annotation/
│   └── Cache.java              # 自定义缓存注解
├── aspect/
│   ├── CacheAspect.java        # 缓存切面实现
│   └── LoggingAspect.java      # 日志切面实现
├── config/
│   └── AppConfig.java          # Spring配置类
├── service/
│   └── CalculatorService.java   # 计算器服务
└── Application.java             # 主程序入口

src/main/resources/
└── logback.xml                 # 日志配置文件
```

## 核心概念说明

### 1. IoC（控制反转）

IoC是Spring的核心概念，它将对象的创建和依赖关系的管理交给Spring容器处理。

**示例代码：**
```java
// 创建Spring容器
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);

// 从容器中获取Bean（依赖注入）
CalculatorService calculator = context.getBean(CalculatorService.class);
```

**关键注解：**
- `@Service` - 标记服务类
- `@Component` - 标记组件类
- `@Configuration` - 标记配置类
- `@ComponentScan` - 扫描组件

### 2. AOP（面向切面编程）

AOP允许将横切关注点（如日志、缓存、事务）从业务逻辑中分离出来。

**示例代码：**
```java
@Aspect
@Component
public class CacheAspect {
    
    @Pointcut("@annotation(com.example.annotation.Cache)")
    public void cachePointcut() {}
    
    @Around("cachePointcut()")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        // 缓存逻辑
    }
}
```

**关键注解：**
- `@Aspect` - 标记切面类
- `@Pointcut` - 定义切点
- `@Around` - 环绕通知
- `@EnableAspectJAutoProxy` - 启用AOP

### 3. 自定义@Cache注解

实现了简单的内存缓存功能，支持：
- 缓存过期时间设置
- 缓存键前缀
- 自动缓存管理

**使用示例：**
```java
@Cache(expire = 30, prefix = "add")
public double add(double a, double b) {
    // 方法实现
}
```

## 运行项目

### 环境要求
- Java 8+
- Maven 3.6+

### 编译和运行
```bash
# 编译项目
mvn compile

# 运行项目
mvn exec:java -Dexec.mainClass="com.example.Application"
```

或者直接运行：
```bash
java -cp target/classes com.example.Application
```

## 运行结果示例

运行程序后，你将看到类似以下的输出：

```
=== Spring IoC和AOP演示程序启动 ===
=== 开始演示计算器功能 ===

--- 演示加法运算 ---
开始执行方法: CalculatorService.add
参数: 10.0, 5.0
缓存未命中，执行方法: add
执行加法运算: 10.0 + 5.0
方法执行完成，耗时: 100ms，结果已缓存
10 + 5 = 15.0
开始执行方法: CalculatorService.add
参数: 10.0, 5.0
缓存命中: add:CalculatorService.add(10.0,5.0)
10 + 5 = 15.0 (应该从缓存获取)
```

## 学习要点

### IoC学习要点：
1. **依赖注入** - 对象不再自己创建依赖，而是由容器注入
2. **Bean管理** - Spring容器管理所有Bean的生命周期
3. **配置方式** - 通过注解或XML配置Bean

### AOP学习要点：
1. **切面（Aspect）** - 横切关注点的模块化
2. **切点（Pointcut）** - 定义在哪些地方应用切面
3. **通知（Advice）** - 切面在切点处要执行的代码
4. **连接点（Join Point）** - 程序执行过程中能够插入切面的点

### 自定义注解学习要点：
1. **注解定义** - 使用`@interface`定义注解
2. **元注解** - `@Target`、`@Retention`等
3. **注解处理** - 通过反射或AOP处理注解

## 扩展练习

1. **添加更多注解** - 实现`@Retry`、`@Timeout`等注解
2. **改进缓存** - 使用Redis或EhCache替代内存缓存
3. **添加事务** - 实现`@Transactional`注解
4. **性能监控** - 添加方法执行时间统计
5. **异常处理** - 实现统一的异常处理切面

## 常见问题

**Q: 为什么要使用IoC？**
A: IoC降低了代码的耦合度，提高了代码的可维护性和可测试性。

**Q: AOP解决了什么问题？**
A: AOP将横切关注点从业务逻辑中分离，避免了代码重复，提高了代码的模块化程度。

**Q: 如何选择合适的切点表达式？**
A: 根据业务需求选择合适的切点，常用的有方法签名、注解、包路径等。

## 参考资料

- [Spring Framework官方文档](https://spring.io/projects/spring-framework)
- [Spring AOP官方文档](https://docs.spring.io/spring-framework/docs/current/reference/html/core.html#aop)
- [AspectJ官方文档](https://www.eclipse.org/aspectj/)