Menu
The review-first prompt is selected by default. You can switch to a direct command or download a local copy.
Read SKILL.md and any companion files shown by SkillsMP before deciding whether to install.
Install with Codex or Claude Copy this prompt, paste it into Codex, Claude, or another assistant, and let it review the skill page and install it for you.
A direct command skips the review prompt. Inspect the source before running it.
npx skills add https://github.com/microwind/ai-skills --skill spring-bootThe command stays on one line. Scroll horizontally to inspect it before copying.
Prefer a local copy? Download the files currently available to SkillsMP.
Showing SKILL.md
Based on SOC occupation classification
| name | Spring Boot应用开发 |
| description | 当开发Spring Boot应用时，分析自动配置，优化依赖管理，解决启动问题。验证微服务架构，设计企业级应用，和最佳实践。 |
| license | MIT |
Spring Boot是Java企业级应用开发的领先框架。不当的Spring Boot配置会导致启动缓慢、内存泄漏和性能问题。在开发Spring Boot应用前需要仔细分析架构需求。
核心原则: 好的Spring Boot应用应该快速启动、配置简单、易于部署、生产就绪。坏的Spring Boot应用会导致配置复杂、性能瓶颈和维护困难。
始终:
触发短语:
问题:
应用启动缓慢，内存占用高
错误示例:
- 不必要的自动配置
- 类路径扫描过多
- Bean初始化耗时
- 配置加载缓慢
解决方案:
1. 禁用不必要的自动配置
2. 优化组件扫描范围
3. 延迟加载非关键Bean
4. 使用条件化配置
问题:
版本冲突，类加载异常
错误示例:
- 传递依赖版本不匹配
- 多版本jar包冲突
- 缺失必要依赖
- 依赖范围配置错误
解决方案:
1. 使用dependencyManagement管理版本
2. 排除冲突依赖
3. 明确指定依赖版本
4. 分析依赖树结构
问题:
配置分散，环境切换困难
错误示例:
- 硬编码配置值
- 配置文件混乱
- 环境配置缺失
- 敏感信息暴露
解决方案:
1. 使用外部化配置
2. 分环境配置文件
3. 配置中心集成
4. 敏感信息加密
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.core.env.ConfigurableEnvironment;
import org.springframework.core.type.classreading.MetadataReader;
import org.springframework.core.type.classreading.MetadataReaderFactory;
import org.springframework.core.type.filter.TypeFilter;
import org.springframework.util.ClassUtils;
import org.springframework.util.ReflectionUtils;
import java.io.File;
import java.io.IOException;
import java.lang.reflect.Method;
import java.net.URL;
import java.net.URLClassLoader;
import java.util.*;
import java.util.jar.JarEntry;
import java.util.jar.JarFile;
import java.util.stream.Collectors;
public class SpringBootAnalyzer {
private final String applicationPath;
private AnalysisResult result;
public SpringBootAnalyzer(String applicationPath) {
this.applicationPath = applicationPath;
this.result = new AnalysisResult();
}
public AnalysisResult analyzeApplication() {
try {
// 分析应用结构
analyzeApplicationStructure();
// 分析依赖配置
analyzeDependencies();
// 分析自动配置
analyzeAutoConfiguration();
analyzePerformanceConfiguration();
analyzeSecurityConfiguration();
generateReport();
} (Exception e) {
result.addError( + e.getMessage());
result;
}
}
{
(applicationPath);
(!appDir.exists()) {
result.addIssue(, , + applicationPath);
;
}
checkStandardStructure(appDir);
findMainApplicationClass(appDir);
analyzeConfigurationFiles(appDir);
}
{
String[] requiredDirs = {, , };
(String dir : requiredDirs) {
(appDir, dir);
(!requiredDir.exists()) {
result.addIssue(, , + dir);
}
}
(appDir, );
(appDir, );
(!pomFile.exists() && !buildGradleFile.exists()) {
result.addIssue(, , );
}
}
{
(appDir, );
(!javaDir.exists()) {
;
}
List<String> mainClasses = findMainClasses(javaDir);
(mainClasses.isEmpty()) {
result.addIssue(, , );
} (mainClasses.size() > ) {
result.addIssue(, , + mainClasses);
} {
result.setMainApplicationClass(mainClasses.get());
validateMainApplicationClass(mainClasses.get());
}
}
List<String> {
List<String> mainClasses = <>();
findMainClassesRecursive(javaDir, , mainClasses);
mainClasses;
}
{
File[] files = dir.listFiles();
(files == ) ;
(File file : files) {
(file.isDirectory()) {
findMainClassesRecursive(file, packageName + file.getName() + , mainClasses);
} (file.getName().endsWith()) {
packageName + file.getName().replace(, );
(hasMainMethod(file)) {
mainClasses.add(className);
}
}
}
}
{
{
(java.io.Files.readAllBytes(javaFile.toPath()));
content.contains() &&
content.contains();
} (IOException e) {
;
}
}
{
{
Class<?> clazz = Class.forName(className);
clazz.getAnnotation(SpringBootApplication.class);
(annotation == ) {
result.addIssue(, , );
}
clazz.getPackage().getName();
(basePackage.equals() || basePackage.isEmpty()) {
result.addIssue(, , );
}
} (ClassNotFoundException e) {
result.addIssue(, , + className);
}
}
{
(appDir, );
(!resourcesDir.exists()) {
;
}
(resourcesDir, );
(resourcesDir, );
(!propertiesFile.exists() && !yamlFile.exists()) {
result.addIssue(, , );
} {
analyzeMainConfiguration(propertiesFile.exists() ? propertiesFile : yamlFile);
}
analyzeEnvironmentConfigurations(resourcesDir);
}
{
{
(java.io.Files.readAllBytes(configFile.toPath()));
(!content.contains()) {
result.addIssue(, , );
}
(!content.contains()) {
result.addIssue(, , );
}
(!content.contains()) {
result.addIssue(, , );
}
(!content.contains()) {
result.addIssue(, , );
}
} (IOException e) {
result.addIssue(, , + e.getMessage());
}
}
{
String[] environments = {, , };
(String env : environments) {
(resourcesDir, + env + );
(resourcesDir, + env + );
(!devConfig.exists() && !devYaml.exists()) {
result.addIssue(, , + env + );
}
}
}
{
(applicationPath, );
(applicationPath, );
(pomFile.exists()) {
analyzeMavenDependencies(pomFile);
} (buildGradleFile.exists()) {
analyzeGradleDependencies(buildGradleFile);
}
}
{
{
(java.io.Files.readAllBytes(pomFile.toPath()));
(!content.contains()) {
result.addIssue(, , );
}
String[] requiredStarters = {
,
,
};
(String starter : requiredStarters) {
(!content.contains(starter)) {
result.addIssue(, , + starter);
}
}
(!content.contains()) {
result.addIssue(, , );
}
} (IOException e) {
result.addIssue(, , + e.getMessage());
}
}
{
{
(java.io.Files.readAllBytes(buildGradleFile.toPath()));
(!content.contains()) {
result.addIssue(, , );
}
String[] requiredStarters = {
,
,
};
(String starter : requiredStarters) {
(!content.contains(starter)) {
result.addIssue(, , + starter);
}
}
} (IOException e) {
result.addIssue(, , + e.getMessage());
}
}
{
result.addInfo(, );
checkAutoConfigurationOptimizations();
}
{
result.addIssue(, , );
result.addIssue(, , );
}
{
(applicationPath, );
(!resourcesDir.exists()) {
;
}
(resourcesDir, );
(!configFile.exists()) {
configFile = (resourcesDir, );
}
(configFile.exists()) {
analyzePerformanceSettings(configFile);
}
}
{
{
(java.io.Files.readAllBytes(configFile.toPath()));
(!content.contains() && !content.contains()) {
result.addIssue(, , );
}
(!content.contains()) {
result.addIssue(, , );
}
(!content.contains()) {
result.addIssue(, , );
}
} (IOException e) {
result.addIssue(, , + e.getMessage());
}
}
{
(applicationPath, );
(!resourcesDir.exists()) {
;
}
(applicationPath, );
(applicationPath, );
;
(pomFile.exists()) {
{
(java.io.Files.readAllBytes(pomFile.toPath()));
hasSecurity = content.contains();
} (IOException e) {
}
} (buildGradleFile.exists()) {
{
(java.io.Files.readAllBytes(buildGradleFile.toPath()));
hasSecurity = content.contains();
} (IOException e) {
}
}
(!hasSecurity) {
result.addIssue(, , );
}
}
AnalysisResult {
result.calculateSummary();
result.generateRecommendations();
result.calculateHealthScore();
result;
}
{
List<Issue> issues = <>();
List<String> infos = <>();
List<String> errors = <>();
String mainApplicationClass;
Summary summary;
List<Recommendation> recommendations = <>();
healthScore;
{
issues.add( (severity, type, message));
}
{
infos.add(category + + message);
}
{
errors.add(error);
}
{
.mainApplicationClass = mainApplicationClass;
}
{
summary = ();
summary.totalIssues = issues.size();
summary.criticalIssues = () issues.stream().filter(i -> i.severity.equals()).count();
summary.highIssues = () issues.stream().filter(i -> i.severity.equals()).count();
summary.mediumIssues = () issues.stream().filter(i -> i.severity.equals()).count();
summary.lowIssues = () issues.stream().filter(i -> i.severity.equals()).count();
}
{
Map<String, Long> issueTypes = issues.stream()
.collect(Collectors.groupingBy(i -> i.type, Collectors.counting()));
(Map.Entry<String, Long> entry : issueTypes.entrySet()) {
recommendations.add( (
getPriorityByType(entry.getKey()),
entry.getKey(),
+ entry.getValue() + + entry.getKey() + ,
getSuggestionByType(entry.getKey())
));
}
}
String {
(type) {
:
:
;
:
:
;
:
;
}
}
String {
(type) {
:
;
:
;
:
;
:
;
:
;
:
;
}
}
{
;
score -= summary.criticalIssues * ;
score -= summary.highIssues * ;
score -= summary.mediumIssues * ;
score -= summary.lowIssues * ;
healthScore = Math.max(, score);
}
List<Issue> { issues; }
List<String> { infos; }
List<String> { errors; }
String { mainApplicationClass; }
Summary { summary; }
List<Recommendation> { recommendations; }
{ healthScore; }
}
{
String severity;
String type;
String message;
{
.severity = severity;
.type = type;
.message = message;
}
}
{
totalIssues;
criticalIssues;
highIssues;
mediumIssues;
lowIssues;
}
{
String priority;
String type;
String message;
String suggestion;
{
.priority = priority;
.type = type;
.message = message;
.suggestion = suggestion;
}
}
}
{
String applicationPath;
{
.applicationPath = applicationPath;
}
OptimizationResult {
();
optimizeDependencies(result);
optimizeConfiguration(result);
optimizeStartupPerformance(result);
optimizeProductionConfiguration(result);
result;
}
{
(applicationPath, );
(pomFile.exists()) {
{
(java.io.Files.readAllBytes(pomFile.toPath()));
(!content.contains()) {
result.addOptimization(, , );
}
(!content.contains()) {
result.addOptimization(, , );
}
} (IOException e) {
result.addError( + e.getMessage());
}
}
}
{
(applicationPath, );
(!resourcesDir.exists()) {
;
}
(resourcesDir, );
(!configFile.exists()) {
configFile = (resourcesDir, );
}
(configFile.exists()) {
{
(java.io.Files.readAllBytes(configFile.toPath()));
(!content.contains()) {
result.addOptimization(, , );
}
(!content.contains()) {
result.addOptimization(, , );
}
} (IOException e) {
result.addError( + e.getMessage());
}
}
}
{
result.addOptimization(, , );
result.addOptimization(, , );
result.addOptimization(, , );
}
{
result.addOptimization(, , );
result.addOptimization(, , );
result.addOptimization(, , );
}
{
List<Optimization> optimizations = <>();
List<String> errors = <>();
{
optimizations.add( (type, message, suggestion));
}
{
errors.add(error);
}
Map<String, Object> {
Map<String, Object> improvements = <>();
;
;
;
(Optimization opt : optimizations) {
(opt.type) {
:
:
performanceGain += ;
;
:
maintainabilityGain += ;
;
:
securityGain += ;
;
}
}
improvements.put(, performanceGain);
improvements.put(, securityGain);
improvements.put(, maintainabilityGain);
improvements;
}
List<Optimization> { optimizations; }
List<String> { errors; }
}
{
String type;
String message;
String suggestion;
{
.type = type;
.message = message;
.suggestion = suggestion;
}
}
}
{
{
();
SpringBootAnalyzer. analyzer.analyzeApplication();
System.out.println();
System.out.println( + result.getHealthScore());
System.out.println( + result.getMainApplicationClass());
System.out.println( + result.getSummary().totalIssues);
System.out.println();
(SpringBootAnalyzer.Recommendation rec : result.getRecommendations()) {
System.out.println( + rec.message + + rec.suggestion);
}
();
SpringBootOptimizer. optimizer.optimizeApplication();
System.out.println();
(SpringBootOptimizer.Optimization opt : optimization.getOptimizations()) {
System.out.println( + opt.message + + opt.suggestion);
}
System.out.println();
Map<String, Object> improvements = optimization.estimateImprovements();
improvements.forEach((key, value) ->
System.out.println(key + + value + ));
}
}
import org.springframework.boot.actuate.health.Health;
import org.springframework.boot.actuate.health.HealthIndicator;
import org.springframework.boot.actuate.metrics.MetricsEndpoint;
import org.springframework.stereotype.Component;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import javax.management.MBeanServer;
import java.lang.management.ManagementFactory;
import java.lang.management.MemoryMXBean;
import java.lang.management.ThreadMXBean;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicLong;
@Component
public class SpringBootPerformanceMonitor implements HealthIndicator {
private final Map<String, RequestMetrics> requestMetrics = new ConcurrentHashMap<>();
private final AtomicLong totalRequests = new AtomicLong(0);
private final long startTime = System.currentTimeMillis();
@Autowired(required = false)
private MetricsEndpoint metricsEndpoint;
public void {
method + + path;
requestMetrics.compute(key, (k, metrics) -> {
(metrics == ) {
metrics = ();
}
metrics.addRequest(duration, statusCode);
metrics;
});
totalRequests.incrementAndGet();
}
Health {
Map<String, Object> details = <>();
ManagementFactory.getMemoryMXBean();
details.put(, memoryBean.getHeapMemoryUsage().getUsed());
details.put(, memoryBean.getHeapMemoryUsage().getMax());
ManagementFactory.getThreadMXBean();
details.put(, threadBean.getThreadCount());
details.put(, System.currentTimeMillis() - startTime);
details.put(, totalRequests.get());
details.put(, requestMetrics.size());
requestMetrics.values().stream()
.mapToDouble(RequestMetrics::getAverageResponseTime)
.average()
.orElse();
details.put(, avgResponseTime);
requestMetrics.values().stream()
.mapToLong(RequestMetrics::getErrorCount)
.sum();
totalRequests.get() > ?
() totalErrorRequests / totalRequests.get() * : ;
details.put(, errorRate);
(errorRate > || avgResponseTime > ) {
Health.down()
.withDetails(details)
.withDetail(, )
.build();
}
(errorRate > || avgResponseTime > ) {
Health.unknown()
.withDetails(details)
.withDetail(, )
.build();
}
Health.up()
.withDetails(details)
.build();
}
{
SpringBootPerformanceMonitor monitor;
Map<String, Object> {
Map<String, Object> metrics = <>();
ManagementFactory.getMemoryMXBean();
metrics.put(, Map.of(
, memoryBean.getHeapMemoryUsage().getUsed(),
, memoryBean.getHeapMemoryUsage().getMax(),
, () memoryBean.getHeapMemoryUsage().getUsed() /
memoryBean.getHeapMemoryUsage().getMax() *
));
ManagementFactory.getThreadMXBean();
metrics.put(, Map.of(
, threadBean.getThreadCount(),
, threadBean.getPeakThreadCount()
));
ManagementFactory.getPlatformMBeanServer();
{
mBeanServer.getAttribute(
ManagementFactory.getOperatingSystemMXBean().getObjectName(),
);
metrics.put(, cpuUsage);
} (Exception e) {
metrics.put(, );
}
metrics.put(, Map.of(
, System.currentTimeMillis() - monitor.startTime,
, monitor.totalRequests.get(),
, monitor.calculateErrorRate(),
, monitor.calculateAverageResponseTime()
));
metrics.put(, monitor.getTopRoutes());
metrics;
}
Map<String, Object> {
Map<String, Object> metrics = <>();
(Map.Entry<String, RequestMetrics> entry : monitor.requestMetrics.entrySet()) {
entry.getValue();
metrics.put(entry.getKey(), Map.of(
, rm.getRequestCount(),
, rm.getAverageResponseTime(),
, rm.getMaxResponseTime(),
, rm.getMinResponseTime(),
, rm.getErrorCount(),
, rm.getErrorRate()
));
}
metrics;
}
}
{
requestMetrics.values().stream()
.mapToLong(RequestMetrics::getErrorCount)
.sum();
totalRequests.get() > ?
() totalErrorRequests / totalRequests.get() * : ;
}
{
requestMetrics.values().stream()
.mapToDouble(RequestMetrics::getAverageResponseTime)
.average()
.orElse();
}
Map<String, Object> {
requestMetrics.entrySet().stream()
.sorted((e1, e2) -> Long.compare(e2.getValue().getRequestCount(), e1.getValue().getRequestCount()))
.limit(limit)
.collect(HashMap::,
(map, entry) -> map.put(entry.getKey(), Map.of(
, entry.getValue().getRequestCount(),
, entry.getValue().getAverageResponseTime(),
, entry.getValue().getErrorRate()
)),
HashMap::putAll);
}
{
;
;
Long.MAX_VALUE;
;
;
{
requestCount++;
totalResponseTime += responseTime;
(responseTime < minResponseTime) {
minResponseTime = responseTime;
}
(responseTime > maxResponseTime) {
maxResponseTime = responseTime;
}
(statusCode >= ) {
errorCount++;
}
}
{
requestCount > ? () totalResponseTime / requestCount : ;
}
{
requestCount > ? () errorCount / requestCount * : ;
}
{ requestCount; }
{ minResponseTime == Long.MAX_VALUE ? : minResponseTime; }
{ maxResponseTime; }
{ errorCount; }
}
}