1. 为什么需要手写SpringBoot核心？
SpringBoot作为Java生态中最流行的应用框架，其核心价值在于简化配置和快速启动。但很多开发者只是停留在"会用"的层面，对背后的运行机制一知半解。去年我在团队内部做技术评审时，发现80%的同事无法说清楚@SpringBootApplication注解背后的完整启动链路。
手写简化版SpringBoot核心的过程，就像解剖一台精密的钟表。通过300行左右的代码实现，我们可以清晰地看到：
- 注解扫描如何触发
- 自动配置如何加载
- 内嵌容器如何启动
这三个核心环节的衔接关系。这种深度理解能帮助我们在遇到： - 启动时Bean加载顺序问题
- 自动配置失效
- 组件扫描冲突
等实际开发难题时，快速定位问题根源。
2. 最小化SpringBoot核心架构设计
2.1 核心组件划分
我们实现的微型SpringBoot需要包含以下模块：
java复制// 主启动类（模拟@SpringBootApplication）
public class MiniSpringApplication {
public static void run(Class<?> primarySource, String... args) {
// 初始化容器
AnnotationConfigApplicationContext context =
new AnnotationConfigApplicationContext();
// 组件扫描
ComponentScanner.scan(context, primarySource);
// 自动配置加载
AutoConfigurator.configure(context);
// 启动内嵌Tomcat
EmbeddedTomcat.start(context);
}
}
2.2 注解体系设计
需要实现的关键注解：
java复制@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface MiniSpringBootApplication {
String[] scanBasePackages() default {};
}
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface MiniController {
String value() default "";
}
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface MiniGetMapping {
String path();
}
注意：实际SpringBoot使用组合注解（@SpringBootApplication=@Configuration+@EnableAutoConfiguration+@ComponentScan），我们这里简化处理
3. 实现组件扫描机制
3.1 包扫描核心逻辑
java复制public class ComponentScanner {
public static void scan(ApplicationContext context, Class<?> primarySource) {
// 获取扫描路径（默认主类所在包）
String basePackage = primarySource.getPackage().getName();
// 使用ASM读取class文件字节码
ClassPathScanningCandidateComponentProvider scanner =
new ClassPathScanningCandidateComponentProvider(false);
scanner.addIncludeFilter(new AnnotationTypeFilter(MiniController.class));
// 遍历类并注册Bean定义
for (BeanDefinition candidate : scanner.findCandidateComponents(basePackage)) {
context.registerBeanDefinition(
candidate.getBeanClassName(),
candidate
);
}
}
}
3.2 控制器方法映射
扫描到@MiniController类后，需要解析方法级别的注解：
java复制public class RequestMappingHandler {
private final Map<String, Method> handlerMethods = new HashMap<>();
public void parseHandlerMethods(Class<?> controllerClass) {
for (Method method : controllerClass.getDeclaredMethods()) {
MiniGetMapping mapping = method.getAnnotation(MiniGetMapping.class);
if (mapping != null) {
String path = mapping.path();
handlerMethods.put(path, method);
}
}
}
public Object invokeHandler(String path, Object... args) {
Method method = handlerMethods.get(path);
return method.invoke(/* controller实例 */, args);
}
}
4. 模拟自动配置实现
4.1 条件装配逻辑
SpringBoot的@Conditional系列注解是其灵魂所在，我们实现简化版：
java复制public class AutoConfigurator {
private static final List<Class<?>> CONFIG_CLASSES = Arrays.asList(
DataSourceAutoConfig.class,
WebMvcAutoConfig.class
);
public static void configure(ApplicationContext context) {
for (Class<?> configClass : CONFIG_CLASSES) {
if (shouldConfigure(configClass)) {
context.registerBean(configClass);
}
}
}
private static boolean shouldConfigure(Class<?> configClass) {
ConditionalOnClass cond = configClass.getAnnotation(ConditionalOnClass.class);
if (cond != null) {
try {
Class.forName(cond.value());
return true;
} catch (ClassNotFoundException e) {
return false;
}
}
return true;
}
}
4.2 自动配置类示例
java复制@ConditionalOnClass("javax.servlet.Servlet")
public class WebMvcAutoConfig {
@Bean
public ViewResolver viewResolver() {
InternalResourceViewResolver resolver = new InternalResourceViewResolver();
resolver.setPrefix("/WEB-INF/views/");
resolver.setSuffix(".jsp");
return resolver;
}
}
5. 内嵌Tomcat集成
5.1 最小化Servlet容器
java复制public class EmbeddedTomcat {
public static void start(ApplicationContext context) throws Exception {
Tomcat tomcat = new Tomcat();
tomcat.setPort(8080);
Context ctx = tomcat.addContext("", null);
Tomcat.addServlet(ctx, "dispatcher", new DispatcherServlet(context));
ctx.addServletMappingDecoded("/*", "dispatcher");
tomcat.start();
tomcat.getServer().await();
}
}
5.2 请求分发实现
java复制public class DispatcherServlet extends HttpServlet {
private final ApplicationContext context;
protected void doGet(HttpServletRequest req, HttpServletResponse resp) {
String path = req.getRequestURI();
RequestMappingHandler handler = context.getBean(RequestMappingHandler.class);
try {
Object result = handler.invokeHandler(path);
resp.getWriter().write(result.toString());
} catch (Exception e) {
resp.setStatus(500);
}
}
}
6. 实际应用与问题排查
6.1 典型启动问题调试
当遇到No qualifying bean异常时，可以通过以下步骤排查：
- 检查组件扫描路径是否包含目标类所在包
- 确认类上是否有
@MiniController等注解 - 查看自动配置条件是否满足（如依赖是否存在）
6.2 性能优化实践
在扫描阶段可以做的优化：
java复制// 使用并行流加速类扫描
scanner.findCandidateComponents(basePackage)
.parallelStream()
.forEach(candidate -> {
context.registerBeanDefinition(
candidate.getBeanClassName(),
candidate
);
});
7. 扩展思考：如何支持更多SpringBoot特性
基于这个最小化实现，可以逐步添加：
- 配置文件解析（application.properties）
- 更复杂的条件装配（@ConditionalOnProperty）
- AOP代理支持
- 启动Actuator端点
我在实际扩展时发现，最难处理的是循环依赖问题。一个实用的技巧是使用三级缓存：
java复制// 简化的依赖解决流程
public Object getBean(String name) {
Object bean = singletonCache.get(name);
if (bean == null) {
bean = createBean(name);
earlySingletonCache.put(name, bean); // 二级缓存
populateDependencies(bean);
singletonCache.put(name, bean); // 一级缓存
}
return bean;
}
这个手写实现虽然只有300行左右，但已经勾勒出了SpringBoot最核心的启动链路。建议读者可以在此基础上，逐步添加自己感兴趣的特性模块，这种渐进式的学习方法比直接阅读庞大源码更有效。