如何实现一个Mini Spring Boot

Spring Boot 是一个强大的框架，简化了 Spring 应用程序的开发。但是，它的核心思想和实现其实并不复杂。接下来，我们将从零开始，逐步实现一个简化版的 “Mini Spring Boot”。

1. 核心思想

Spring Boot 的核心功能包括：

• 自动配置：根据依赖和环境，自动配置应用程序。
• 嵌入式服务器：内置 Tomcat 或其他服务器，简化部署。
• 注解驱动：通过注解，如 @Component、@Controller 等，进行自动化的依赖注入和组件扫描。

我们将逐步实现这些功能。

2. 项目结构

为了保持简洁，我们设计的项目结构如下：

mini-springboot/
 ├── src/
 │   ├── main/
 │   │   └── MiniSpringBootApplication.java
 ├── lib/
 └── pom.xml

其中，MiniSpringBootApplication 是启动类。

3. 组件扫描与依赖注入

Spring 的依赖注入是通过组件扫描来实现的。我们可以使用 Java 的 ClassLoader 加载特定包下的类，并检查是否包含自定义注解 @Component，从而进行实例化和注入。

自定义注解

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface Component {
}

我们定义了一个简单的 @Component 注解，用于标记需要注入的类。

扫描与实例化

为了模拟 Spring 的自动扫描机制，我们使用 ClassLoader 加载指定包下的所有类，判断是否有 @Component 注解：

public class ComponentScanner {

    public static void scan(String basePackage) throws Exception {
        String path = basePackage.replace('.', '/');
        URL resource = Thread.currentThread().getContextClassLoader().getResource(path);
        if (resource == null) throw new IllegalArgumentException("Package not found: " + basePackage);

        File dir = new File(resource.toURI());
        for (File file : dir.listFiles()) {
            String className = basePackage + "." + file.getName().replace(".class", "");
            Class<?> clazz = Class.forName(className);
            if (clazz.isAnnotationPresent(Component.class)) {
                System.out.println("Found component: " + className);
                // **实例化并保存到容器中**
                Object instance = clazz.getDeclaredConstructor().newInstance();
                BeanFactory.addBean(clazz, instance);
            }
        }
    }
}

简单的 Bean 容器

我们可以通过一个简单的 BeanFactory 类来保存这些实例：

public class BeanFactory {
    private static Map<Class<?>, Object> beans = new HashMap<>();

    public static void addBean(Class<?> clazz, Object instance) {
        beans.put(clazz, instance);
    }

    public static Object getBean(Class<?> clazz) {
        return beans.get(clazz);
    }
}

通过这种方式，我们可以实现一个基本的依赖注入。

4. 模拟 Controller

Spring Boot 的 @Controller 允许我们处理 HTTP 请求。在这里，我们模拟一个简单的 Controller，通过反射调用方法。

@Controller 和 @RequestMapping 注解

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface Controller {
}

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface RequestMapping {
    String value();
}

这些注解用于标记控制器和其处理的方法。

模拟 HTTP 请求处理

public class DispatcherServlet {

    public void handleRequest(String path) {
        for (Class<?> controller : BeanFactory.getBeansWithAnnotation(Controller.class)) {
            for (Method method : controller.getDeclaredMethods()) {
                if (method.isAnnotationPresent(RequestMapping.class)) {
                    String mappedPath = method.getAnnotation(RequestMapping.class).value();
                    if (mappedPath.equals(path)) {
                        try {
                            method.invoke(BeanFactory.getBean(controller));
                        } catch (Exception e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        }
    }
}

这个类用于根据请求路径找到对应的控制器，并调用相应的方法。

示例控制器

@Controller
public class HelloController {

    @RequestMapping("/hello")
    public void hello() {
        System.out.println("Hello, Mini Spring Boot!");
    }
}

5. 启动类

最后，我们实现一个简单的启动类来启动组件扫描，并启动我们的“服务器”：

public class MiniSpringBootApplication {

    public static void main(String[] args) throws Exception {
        // **扫描组件**
        ComponentScanner.scan("com.example");

        // **模拟处理请求**
        DispatcherServlet servlet = new DispatcherServlet();
        servlet.handleRequest("/hello");
    }
}

运行时，它将扫描指定包下的类，找到 HelloController 并处理 /hello 请求。

6. 结论

通过以上步骤，我们实现了一个非常简化版的 Spring Boot。它包含了组件扫描、依赖注入和控制器等核心功能。尽管与真实的 Spring Boot 相比，功能非常有限，但这展示了其核心原理。希望这篇文章帮助你更好地理解 Spring Boot 的工作机制。

下一步可以尝试加入更多的功能，例如更多的注解支持、更复杂的依赖注入机制，或者集成嵌入式服务器来处理真正的 HTTP 请求。