# softwarer-summer

**Repository Path**: shendeyidi/softwarer-summer

## Basic Information

- **Project Name**: softwarer-summer
- **Description**: No description available
- **Primary Language**: Java
- **License**: MIT
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2026-02-07
- **Last Updated**: 2026-02-08

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

# Softwarer Summer

Softwarer Summer 是一个轻量级的 Java 项目，提供了包扫描和组件管理功能。

## 项目结构

```
softwarer-summer/
├── softwarer-summer-core/       # 核心模块，包含包扫描功能
├── softwarer-summer-test/       # 测试模块，包含单元测试
├── .gitignore                   # Git 忽略文件配置
├── pom.xml                      # 父项目 POM 文件
└── README.md                    # 项目说明文档
```

## 核心功能

### 1. 包扫描

`PackageScanner` 类提供了扫描指定包及其子包下所有类的功能，支持：

- 扫描文件系统中的类
- 扫描 JAR 文件中的类
- 递归检查类是否被指定注解标注（包括直接标注和通过上级注解标注）
- 从 `Component` 注解中读取 `name` 值，并传递给 `PotatoDefinition` 对象

### 2. 组件管理

- `Component` 注解：用于标注需要被管理的组件类
- `PotatoDefinition` 类：组件定义类，用于封装被标注的组件信息，支持：
  - 从 `Component` 注解中读取 `name` 值
  - 如果类有默认构造方法，则自动创建实例
  - 提供 `getPotato` 泛型方法，用于将实例转换为指定类型
- `PotatoContainer` 类：单例模式的容器类，用于存储和管理 `PotatoDefinition` 对象
- `Summer` 类：单例模式的核心类，提供 `setup` 方法来扫描包并将结果添加到容器中

## 快速开始

### 环境要求

- JDK 21+
- Maven 3.6+

### 构建项目

```bash
# 编译项目
mvn clean compile

# 运行测试
mvn test

# 打包项目
mvn clean package
```

### 使用示例

#### 1. 创建一个被 `Component` 注解标注的类

```java
import org.softwarer.summer.annotation.Component;

@Component(name = "exampleComponent")
public class ExampleComponent {
    public void doSomething() {
        System.out.println("Hello, Softwarer Summer!");
    }
}

// 或者使用间接注解
@Component(name = "service")
public @interface Service {
}

@Service
public class UserService {
    public void sayHello() {
        System.out.println("Hello from UserService!");
    }
}
```

#### 2. 使用 `Summer` 类初始化并获取组件

```java
import org.softwarer.summer.core.Summer;
import org.softwarer.summer.potato.PotatoContainer;

public class Main {
    public static void main(String[] args) {
        // 获取 Summer 单例实例并设置扫描包
        Summer summer = Summer.getInstance();
        summer.setup("com.example");
        
        // 获取 PotatoContainer 单例实例
        PotatoContainer container = PotatoContainer.getInstance();
        
        // 通过 name 获取组件
        ExampleComponent exampleComponent = container.getPotato("exampleComponent", ExampleComponent.class);
        if (exampleComponent != null) {
            exampleComponent.doSomething(); // 输出：Hello, Softwarer Summer!
        }
        
        // 通过类型获取组件（如果只有一个该类型的组件）
        UserService userService = container.getPotato(UserService.class);
        if (userService != null) {
            userService.sayHello(); // 输出：Hello from UserService!
        }
    }
}
```

#### 3. 直接使用 `PackageScanner` 扫描组件

```java
import org.softwarer.summer.core.PackageScanner;
import org.softwarer.summer.potato.PotatoDefinition;

import java.util.List;

public class Main {
    public static void main(String[] args) {
        PackageScanner scanner = new PackageScanner();
        
        // 扫描指定包及其子包
        String packageName = "com.example";
        List<PotatoDefinition> definitions = scanner.scanPackage(packageName);
        
        // 打印扫描结果
        System.out.println("Found " + definitions.size() + " components:");
        for (PotatoDefinition definition : definitions) {
            System.out.println("- " + definition.getName() + ": " + definition.getClazz().getName());
        }
    }
}
```

## 模块说明

### softwarer-summer-core

核心模块，包含以下主要类：

- `PackageScanner`：包扫描工具类，用于扫描指定包及其子包下的所有类
- `Component`：组件注解，用于标注需要被管理的组件类
- `PotatoDefinition`：组件定义类，用于封装被标注的组件信息，支持自动创建实例
- `PotatoContainer`：单例模式的容器类，用于存储和管理 `PotatoDefinition` 对象
- `Summer`：单例模式的核心类，提供 `setup` 方法来扫描包并将结果添加到容器中

### softwarer-summer-test

测试模块，包含单元测试：

- `PackageScannerTest`：测试 `PackageScanner` 类的功能

## 贡献

欢迎提交 Issue 和 Pull Request 来改进这个项目！

## 许可证

本项目采用 MIT 许可证。