Menü
Standardmäßig ist der Prompt ausgewählt, der zuerst die Quelle prüft. Sie können zu einem direkten Befehl wechseln oder eine lokale Kopie herunterladen.
Lesen Sie SKILL.md und alle von SkillsMP angezeigten Begleitdateien, bevor Sie sich für eine Installation entscheiden.
Mit Codex oder Claude installieren Kopieren Sie diesen Prompt, fügen Sie ihn in Codex, Claude oder einen anderen Assistant ein und lassen Sie die Skill-Seite prüfen und installieren.
Ein direkter Befehl überspringt den Prüf-Prompt. Prüfen Sie die Quelle, bevor Sie ihn ausführen.
npx skills add https://github.com/microwind/ai-skills --skill spring-bootDer Befehl bleibt in einer Zeile. Scrollen Sie horizontal, um ihn vor dem Kopieren vollständig zu prüfen.
Sie bevorzugen eine lokale Kopie? Laden Sie die Dateien herunter, die SkillsMP derzeit vorliegen.
Basierend auf der SOC-Berufsklassifikation
SKILL.md wird angezeigt
| 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; }
}
}