Spring Boot监控与运维详解

原创 已于 2025-10-14 08:32:51 修改 · 834 阅读 · 6 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#spring boot #运维 #后端

于 2025-10-14 08:32:12 首次发布

1. 监控与运维概述

监控与运维是确保Spring Boot应用稳定运行的关键环节。通过完善的监控体系，可以实时了解应用状态、性能指标和异常情况，为运维决策提供数据支持。

1.1 监控体系

  • 应用监控：应用性能、响应时间、吞吐量
  • 系统监控：CPU、内存、磁盘、网络
  • 业务监控：业务指标、用户行为、交易量
  • 日志监控：错误日志、访问日志、审计日志

1.2 监控工具

  • Spring Boot Actuator：内置监控端点
  • Micrometer：指标收集框架
  • Prometheus：指标存储和查询
  • Grafana：可视化监控面板
  • ELK Stack：日志分析平台

1.3 核心依赖

<dependencies>
    <!-- Spring Boot Actuator -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-actuator</artifactId>
    </dependency>
    
    <!-- Micrometer Prometheus -->
    <dependency>
        <groupId>io.micrometer</groupId>
        <artifactId>micrometer-registry-prometheus</artifactId>
    </dependency>
    
    <!-- Spring Boot Admin Client -->
    <dependency>
        <groupId>de.codecentric</groupId>
        <artifactId>spring-boot-admin-starter-client</artifactId>
    </dependency>
    
    <!-- Logback -->
    <dependency>
        <groupId>net.logstash.logback</groupId>
        <artifactId>logstash-logback-encoder</artifactId>
    </dependency>
</dependencies>

2. Spring Boot Actuator

2.1 基础配置

# application.yml
management:
  endpoints:
    web:
      exposure:
        include: "*"
      base-path: /actuator
  endpoint:
    health:
      show-details: always
      show-components: always
    info:
      enabled: true
  health:
    defaults:
      enabled: true
    diskspace:
      enabled: true
      threshold: 100MB
  metrics:
    export:
      prometheus:
        enabled: true
    distribution:
      percentiles-histogram:
        http.server.requests: true
      percentiles:
        http.server.requests: 0.5, 0.95, 0.99

2.2 健康检查

package com.example.demo.health;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.actuate.health.Health;
import org.springframework.boot.actuate.health.HealthIndicator;
import org.springframework.stereotype.Component;
import com.example.demo.repository.UserRepository;

@Component
public class DatabaseHealthIndicator implements HealthIndicator {
    
    @Autowired
    private UserRepository userRepository;
    
    @Override
    public Health health() {
        try {
            long userCount = userRepository.count();
            return Health.up()
                    .withDetail("database", "Available")
                    .withDetail("userCount", userCount)
                    .build();
        } catch (Exception e) {
            return Health.down()
                    .withDetail("database", "Unavailable")
                    .withDetail("error", e.getMessage())
                    .build();
        }
    }
}

2.3 自定义指标

package com.example.demo.metrics;

import io.micrometer.core.instrument.Counter;
import io.micrometer.core.instrument.MeterRegistry;
import io.micrometer.core.instrument.Timer;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.util.concurrent.atomic.AtomicLong;

@Component
public class CustomMetrics {
    
    private final Counter userCreatedCounter;
    private final Timer userProcessingTimer;
    private final AtomicLong activeUsers;
    
    @Autowired
    public CustomMetrics(MeterRegistry meterRegistry) {
        this.userCreatedCounter = Counter.builder("user.created")
                .description("Number of users created")
                .register(meterRegistry);
        
        this.userProcessingTimer = Timer.builder("user.processing.time")
                .description("Time taken to process user operations")
                .register(meterRegistry);
        
        this.activeUsers = meterRegistry.gauge("user.active", new AtomicLong(0));
    }
    
    public void incrementUserCreated() {
        userCreatedCounter.increment();
    }
    
    public void recordUserProcessingTime(Runnable operation) {
        userProcessingTimer.record(operation);
    }
    
    public void setActiveUsers(long count) {
        activeUsers.set(count);
    }
}

3. 日志监控

3.1 日志配置

<!-- logback-spring.xml -->
<configuration>
    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
        <encoder class="net.logstash.logback.encoder.LoggingEventCompositeJsonEncoder">
            <providers>
                <timestamp/>
                <logLevel/>
                <loggerName/>
                <message/>
                <mdc/>
                <stackTrace/>
            </providers>
        </encoder>
    </appender>
    
    <appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <file>logs/application.log</file>
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <fileNamePattern>logs/application.%d{yyyy-MM-dd}.%i.log</fileNamePattern>
            <maxFileSize>100MB</maxFileSize>
            <maxHistory>30</maxHistory>
            <totalSizeCap>3GB</totalSizeCap>
        </rollingPolicy>
        <encoder class="net.logstash.logback.encoder.LoggingEventCompositeJsonEncoder">
            <providers>
                <timestamp/>
                <logLevel/>
                <loggerName/>
                <message/>
                <mdc/>
                <stackTrace/>
            </providers>
        </encoder>
    </appender>
    
    <root level="INFO">
        <appender-ref ref="STDOUT"/>
        <appender-ref ref="FILE"/>
    </root>
</configuration>

3.2 结构化日志

package com.example.demo.service;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.slf4j.MDC;
import org.springframework.stereotype.Service;
import java.util.UUID;

@Service
public class LoggingService {
    
    private static final Logger logger = LoggerFactory.getLogger(LoggingService.class);
    
    public void processUser(String username) {
        String traceId = UUID.randomUUID().toString();
        MDC.put("traceId", traceId);
        MDC.put("username", username);
        
        try {
            logger.info("开始处理用户: {}", username);
            
            // 模拟业务处理
            Thread.sleep(1000);
            
            logger.info("用户处理完成: {}", username);
        } catch (Exception e) {
            logger.error("用户处理失败: {}", username, e);
        } finally {
            MDC.clear();
        }
    }
}

4. 性能监控

4.1 性能指标收集

package com.example.demo.metrics;

import io.micrometer.core.instrument.MeterRegistry;
import io.micrometer.core.instrument.Timer;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.util.concurrent.atomic.AtomicLong;

@Component
public class PerformanceMetrics {
    
    private final Timer requestTimer;
    private final AtomicLong activeConnections;
    private final AtomicLong totalRequests;
    
    @Autowired
    public PerformanceMetrics(MeterRegistry meterRegistry) {
        this.requestTimer = Timer.builder("http.server.requests")
                .description("HTTP request processing time")
                .register(meterRegistry);
        
        this.activeConnections = meterRegistry.gauge("http.active.connections", new AtomicLong(0));
        this.totalRequests = meterRegistry.gauge("http.total.requests", new AtomicLong(0));
    }
    
    public void recordRequestTime(Runnable operation) {
        requestTimer.record(operation);
    }
    
    public void incrementActiveConnections() {
        activeConnections.incrementAndGet();
    }
    
    public void decrementActiveConnections() {
        activeConnections.decrementAndGet();
    }
    
    public void incrementTotalRequests() {
        totalRequests.incrementAndGet();
    }
}

4.2 性能监控拦截器

package com.example.demo.interceptor;

import com.example.demo.metrics.PerformanceMetrics;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.web.servlet.HandlerInterceptor;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

@Component
public class PerformanceInterceptor implements HandlerInterceptor {
    
    @Autowired
    private PerformanceMetrics performanceMetrics;
    
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
        performanceMetrics.incrementActiveConnections();
        performanceMetrics.incrementTotalRequests();
        return true;
    }
    
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) {
        performanceMetrics.decrementActiveConnections();
    }
}

5. 业务监控

5.1 业务指标收集

package com.example.demo.metrics;

import io.micrometer.core.instrument.Counter;
import io.micrometer.core.instrument.MeterRegistry;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.util.concurrent.atomic.AtomicLong;

@Component
public class BusinessMetrics {
    
    private final Counter userLoginCounter;
    private final Counter userLogoutCounter;
    private final Counter orderCreatedCounter;
    private final AtomicLong onlineUsers;
    
    @Autowired
    public BusinessMetrics(MeterRegistry meterRegistry) {
        this.userLoginCounter = Counter.builder("business.user.login")
                .description("Number of user logins")
                .register(meterRegistry);
        
        this.userLogoutCounter = Counter.builder("business.user.logout")
                .description("Number of user logouts")
                .register(meterRegistry);
        
        this.orderCreatedCounter = Counter.builder("business.order.created")
                .description("Number of orders created")
                .register(meterRegistry);
        
        this.onlineUsers = meterRegistry.gauge("business.online.users", new AtomicLong(0));
    }
    
    public void recordUserLogin() {
        userLoginCounter.increment();
        onlineUsers.incrementAndGet();
    }
    
    public void recordUserLogout() {
        userLogoutCounter.increment();
        onlineUsers.decrementAndGet();
    }
    
    public void recordOrderCreated() {
        orderCreatedCounter.increment();
    }
}

5.2 业务监控服务

package com.example.demo.service;

import com.example.demo.metrics.BusinessMetrics;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class BusinessMonitorService {
    
    @Autowired
    private BusinessMetrics businessMetrics;
    
    public void recordUserLogin(String username) {
        businessMetrics.recordUserLogin();
        // 记录用户登录日志
    }
    
    public void recordUserLogout(String username) {
        businessMetrics.recordUserLogout();
        // 记录用户登出日志
    }
    
    public void recordOrderCreated(Long orderId) {
        businessMetrics.recordOrderCreated();
        // 记录订单创建日志
    }
}

6. 告警系统

6.1 告警配置

# application.yml
management:
  endpoints:
    web:
      exposure:
        include: health,metrics,alerts
  endpoint:
    alerts:
      enabled: true
  health:
    defaults:
      enabled: true
    diskspace:
      threshold: 100MB
    db:
      enabled: true

6.2 告警处理器

package com.example.demo.alert;

import org.springframework.boot.actuate.health.Health;
import org.springframework.boot.actuate.health.HealthIndicator;
import org.springframework.stereotype.Component;
import java.util.concurrent.atomic.AtomicLong;

@Component
public class AlertHealthIndicator implements HealthIndicator {
    
    private final AtomicLong errorCount = new AtomicLong(0);
    private final AtomicLong warningCount = new AtomicLong(0);
    
    @Override
    public Health health() {
        long errors = errorCount.get();
        long warnings = warningCount.get();
        
        if (errors > 10) {
            return Health.down()
                    .withDetail("errors", errors)
                    .withDetail("warnings", warnings)
                    .withDetail("status", "CRITICAL")
                    .build();
        } else if (warnings > 5) {
            return Health.up()
                    .withDetail("errors", errors)
                    .withDetail("warnings", warnings)
                    .withDetail("status", "WARNING")
                    .build();
        } else {
            return Health.up()
                    .withDetail("errors", errors)
                    .withDetail("warnings", warnings)
                    .withDetail("status", "HEALTHY")
                    .build();
        }
    }
    
    public void incrementError() {
        errorCount.incrementAndGet();
    }
    
    public void incrementWarning() {
        warningCount.incrementAndGet();
    }
}

7. 监控面板

7.1 Grafana配置

{
  "dashboard": {
    "title": "Spring Boot Application Monitoring",
    "panels": [
      {
        "title": "HTTP Requests",
        "type": "graph",
        "targets": [
          {
            "expr": "rate(http_server_requests_seconds_count[5m])",
            "legendFormat": "Requests/sec"
          }
        ]
      },
      {
        "title": "Response Time",
        "type": "graph",
        "targets": [
          {
            "expr": "histogram_quantile(0.95, rate(http_server_requests_seconds_bucket[5m]))",
            "legendFormat": "95th percentile"
          }
        ]
      },
      {
        "title": "Active Users",
        "type": "singlestat",
        "targets": [
          {
            "expr": "business_online_users",
            "legendFormat": "Online Users"
          }
        ]
      }
    ]
  }
}

7.2 自定义监控端点

package com.example.demo.controller;

import com.example.demo.metrics.BusinessMetrics;
import com.example.demo.metrics.PerformanceMetrics;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.HashMap;
import java.util.Map;

@RestController
@RequestMapping("/api/monitoring")
public class MonitoringController {
    
    @Autowired
    private BusinessMetrics businessMetrics;
    
    @Autowired
    private PerformanceMetrics performanceMetrics;
    
    @GetMapping("/metrics")
    public Map<String, Object> getMetrics() {
        Map<String, Object> metrics = new HashMap<>();
        
        // 业务指标
        metrics.put("onlineUsers", businessMetrics.getOnlineUsers());
        metrics.put("totalLogins", businessMetrics.getTotalLogins());
        metrics.put("totalOrders", businessMetrics.getTotalOrders());
        
        // 性能指标
        metrics.put("activeConnections", performanceMetrics.getActiveConnections());
        metrics.put("totalRequests", performanceMetrics.getTotalRequests());
        metrics.put("averageResponseTime", performanceMetrics.getAverageResponseTime());
        
        return metrics;
    }
}

8. 运维工具

8.1 健康检查端点

package com.example.demo.health;

import org.springframework.boot.actuate.health.Health;
import org.springframework.boot.actuate.health.HealthIndicator;
import org.springframework.stereotype.Component;
import java.lang.management.ManagementFactory;
import java.lang.management.MemoryMXBean;
import java.lang.management.RuntimeMXBean;

@Component
public class SystemHealthIndicator implements HealthIndicator {
    
    @Override
    public Health health() {
        MemoryMXBean memoryBean = ManagementFactory.getMemoryMXBean();
        RuntimeMXBean runtimeBean = ManagementFactory.getRuntimeMXBean();
        
        long usedMemory = memoryBean.getHeapMemoryUsage().getUsed();
        long maxMemory = memoryBean.getHeapMemoryUsage().getMax();
        long uptime = runtimeBean.getUptime();
        
        double memoryUsage = (double) usedMemory / maxMemory;
        
        if (memoryUsage > 0.9) {
            return Health.down()
                    .withDetail("memoryUsage", String.format("%.2f%%", memoryUsage * 100))
                    .withDetail("uptime", uptime)
                    .withDetail("status", "CRITICAL")
                    .build();
        } else if (memoryUsage > 0.8) {
            return Health.up()
                    .withDetail("memoryUsage", String.format("%.2f%%", memoryUsage * 100))
                    .withDetail("uptime", uptime)
                    .withDetail("status", "WARNING")
                    .build();
        } else {
            return Health.up()
                    .withDetail("memoryUsage", String.format("%.2f%%", memoryUsage * 100))
                    .withDetail("uptime", uptime)
                    .withDetail("status", "HEALTHY")
                    .build();
        }
    }
}

8.2 运维脚本

#!/bin/bash
# health-check.sh

APP_URL="http://localhost:8080"
HEALTH_ENDPOINT="$APP_URL/actuator/health"
METRICS_ENDPOINT="$APP_URL/actuator/metrics"

echo "=== Spring Boot Application Health Check ==="
echo "Timestamp: $(date)"
echo ""

# 检查应用健康状态
echo "1. Application Health Status:"
curl -s "$HEALTH_ENDPOINT" | jq '.'
echo ""

# 检查关键指标
echo "2. Key Metrics:"
echo "HTTP Requests:"
curl -s "$METRICS_ENDPOINT/http.server.requests" | jq '.'
echo ""

echo "JVM Memory:"
curl -s "$METRICS_ENDPOINT/jvm.memory.used" | jq '.'
echo ""

echo "Thread Count:"
curl -s "$METRICS_ENDPOINT/jvm.threads.live" | jq '.'
echo ""

# 检查日志
echo "3. Recent Logs:"
tail -n 20 logs/application.log
echo ""

echo "=== Health Check Complete ==="

9. 监控最佳实践

9.1 监控配置

# application.yml
management:
  endpoints:
    web:
      exposure:
        include: health,info,metrics,prometheus
      base-path: /actuator
  endpoint:
    health:
      show-details: when-authorized
      show-components: always
    info:
      enabled: true
  health:
    defaults:
      enabled: true
    diskspace:
      threshold: 100MB
    db:
      enabled: true
  metrics:
    export:
      prometheus:
        enabled: true
    distribution:
      percentiles-histogram:
        http.server.requests: true
      percentiles:
        http.server.requests: 0.5, 0.95, 0.99
  info:
    env:
      enabled: true
    java:
      enabled: true
    os:
      enabled: true

9.2 监控指标配置

package com.example.demo.config;

import io.micrometer.core.instrument.MeterRegistry;
import io.micrometer.core.instrument.config.MeterFilter;
import org.springframework.boot.actuate.autoconfigure.metrics.MeterRegistryCustomizer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class MonitoringConfig {
    
    @Bean
    public MeterRegistryCustomizer<MeterRegistry> metricsCommonTags() {
        return registry -> registry.config().commonTags("application", "spring-boot-app");
    }
    
    @Bean
    public MeterFilter meterFilter() {
        return MeterFilter.denyNameStartsWith("jvm.threads");
    }
}

10. 总结

Spring Boot监控与运维提供了完整的监控解决方案：

  1. Actuator监控：内置监控端点和健康检查
  2. 指标收集：Micrometer指标收集和Prometheus集成
  3. 日志监控：结构化日志和日志分析
  4. 性能监控：性能指标收集和分析
  5. 业务监控：业务指标和用户行为监控
  6. 告警系统：异常检测和告警通知
  7. 监控面板：Grafana可视化监控
  8. 运维工具：健康检查和运维脚本

通过完善的监控体系，可以确保Spring Boot应用的稳定运行和高效运维。

滚雪球学SpringCloud[9.3讲]：微服务监控与运维详解
**My Coding Family**
09-24 1173
在上期【9.3 微服务监控与运维】中，我们深入探讨了如何通过现代监控工具（如Prometheus、Grafana）对微服务系统进行实时监控与管理，确保服务的高可用性和稳定性。通过系统化的监控和自动化运维，开发团队能够快速响应问题，并进行及时处理，以保障系统在生产环境中的高效运行。然而，监控与运维是微服务生命周期的后期环节，在开发一个微服务系统之前，我们首先需要对项目进行需求分析、架构设计，并完成从0到1的核心功能开发与配置。
Spring Cloud 服务监控运维详解：构建高可用微服务体系
weixin_42593797的博客
06-22 817
本文深入解析了Spring Cloud微服务监控运维体系的核心技术。针对分布式系统的复杂性，提出了基于Prometheus+Grafana的指标监控、Zipkin/SkyWalking的链路追踪以及ELK/EFK日志聚合的完整解决方案。内容涵盖Micrometer指标收集、Prometheus配置部署、分布式链路追踪实现、日志聚合方案选型，以及告警规则和自动扩缩容配置，为构建高效的微服务监控运维体系提供了实践指导。
springboot的actuator
weixin_36098377的博客
01-25 3696
微服务的特点决定了功能模块的部署是分布式的，大部分功能模块都是运行在不同的机器上，彼此通过服务调用进行交互，前后台的业务流会经过很多个微服务的处理和传递，出现了异常如何快速定位是哪个环节出现了问题？在这种框架下，微服务的监控显得尤为重要。Spring Boot Actuator 模块提供了生产级别的监控功能，比如健康检查，审计，指标收集，HTTP 跟踪等，帮助我们监控和管理Spring Boot 应用。这个模块是一个采集应用内部信息暴露给外部的模块，上述的功能都可以通过HTTP 和 JMX 访问。
WhyNotWin11多语言支持终极指南：如何为全球用户构建国际化检测工具
最新发布
gitblog_00048的博客
12-11 264
WhyNotWin11作为一款专业的Windows 11兼容性检测工具，其强大的多语言支持功能让全球用户都能轻松使用。这款检测工具通过精心设计的国际化架构，实现了对50多种语言的完美支持，让技术门槛不再成为语言障碍。🚀 ## 🔥 多语言架构设计思路 WhyNotWin11采用**模块化多语言架构**，核心设计理念是**分离界面文本与程序逻辑**。所有语言文件都存放在 `Langs/` 目录
SpringBoot-运维实用篇
爪蛙毁一生的博客
02-25 625
​ 之前咱们做配置使用的配置文件都是application.yml，其实这个文件也是可以改名字的，这样方便维护。比如我2020年4月1日搞活动，走了一组配置，2020年5月1日活动取消，恢复原始配置，这个时候只需要重新更换一下配置文件就可以了。但是你总不能在原始配置文件上修改吧，不然搞完活动以后，活动的配置就留不下来了，不利于维护。方式一：使用临时属性设置配置文件名，注意仅仅是名称，不要带扩展名方式二：使用临时属性设置配置文件路径，这个是全路径名​ 也可以设置加载多个配置文件。
Spring Boot 监控端点 Actuator 入门
weixin_42073629的博客
06-15 2154
1. 概述 现在在阅读本文的胖友，估计绝大多数都是 Java 开发者。很多时候，我们只关心开发部分，但是应用在部署在生产环境下，我们还需要考虑应用的管理与监控。例如说，应用是否健康存活、应用的 JVM 监控信息、服务器的监控信息（CPU、内存、磁盘等等）。 如果我们为应用的管理与监控做相应的开发，是需要一定的成本的。幸运的是，在 Spring Boot 框架提供了一个非常重要的新组件spring-boot-actuator。其文档介绍如下： FROM《Spring Boot Actuator:...
【Springboot知识】Springboot监控工具SpringbootAdmin
wendao76的专栏
01-05 1501
概述一、主要构成二、功能特点三、集成配置四、安全性设置五、版本兼容性六、应用场景服务端部署与接入一、环境准备二、创建Spring Boot Admin服务端项目三、配置安全认证四、运行和访问五、客户端注册六、注意事项Spring Boot Admin是一个用于管理和监控Spring Boot应用程序的开源软件。
详解Spring Boot Admin监控服务上下线邮件通知
08-28
"Spring Boot Admin监控服务上下线邮件通知" Spring Boot Admin是一款功能强大且灵活的监控工具，能够实时监控微服务的状态，并提供邮件通知功能以便及时告警。下面是Spring Boot Admin监控服务上下线邮件通知的...
Spring Boot中的监控与运维：Actuator详解
Spring Boot Actuator是Spring Boot提供的一个功能强大的模块，用于监控和管理应用程序的运行状态。它提供了一组监控和管理端点，可以通过HTTP或JMX等方式访问。 Actuator可以帮助开发人员更好地了解应用程序的健康...
Eureka服务注册中心可视化监控和运维详解
weixin_42593797的博客
07-05 1277
摘要： Eureka作为微服务核心组件，其可视化监控与运维至关重要。本文介绍了Eureka Server自带界面、Spring Boot Actuator端点、Hystrix Dashboard及Turbine聚合监控等工具，实现服务状态、流量及健康指标的实时可视化。运维方面涵盖服务实例管理（注册/下线策略、自定义健康检查）、集群搭建与同步监控，并给出配置示例。通过结合监控工具与科学运维策略，可有效保障Eureka的高可用性与稳定性。
黑白盒 时序Prometheus详解 ； 含 全链路Spring Boot Actuator - google dapper论文 -ELK 日志易 吹牛篇
yuezhilangniao的博客
02-20 754
原文标题 ：号称中国的splunk-日志易公司怎么样？ https://exp.newsmth.net/topic/article/3c00ff380df9d7c7e07d96b056ccf315 日志易 融资1.4亿 2020最新篇：https://baijiahao.baidu.com/s?id=1667627432439028864&wfr=spider&for=pc ...
使用Spring Boot Actuator监控应用
u011851478的博客
02-13 2万+
Actuator是Spring Boot提供的对应用系统的自省和监控的集成功能，可以对应用系统进行配置查看、相关功能统计等。使用Actuator引入依赖即可 Maven： <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-actuator</artifa
springboot 运行状态监控Actuator
殇莫忆的博客
01-16 3996
springboot 的Actuator 提供了运行状态监控的功能，Actuator的监控数据可以通过REST、远程shell和JMX方式获得。 1、通过 REST 方式查看Actuator 的节点的方法。 下 pom 文件中引入Actuator 的依赖 &lt;dependency&gt; &lt;groupId&gt;org.springframework.boot&lt;...
Spring Boot Actuator 之监控架构实战使用
GitChat
07-03 1787
本 Chat 作为 Logging 的姊妹篇，来和大家一起整体认识一下 Spring Boot Actuator 及其在实际工作的使用。有整体到局部，有原理到实战，一起来学习一下 Actuator 的正确使用姿势。 通过此篇 Chat 我们可以了解到如下内容： Spring Boot Actuator 如何使用。 Actuator 中我们重点关注的是什么？如何自定义 Heath？ ...
spring boot actuator监控详细介绍一(超级详细)
热门推荐
weixin_43353498的博客
04-12 3万+
spring boot actuator介绍 Spring Boot包含许多其他功能，可帮助您在将应用程序推送到生产环境时监视和管理应用程序。 您可以选择使用HTTP端点或JMX来管理和监视应用程序。 审核，运行状况和指标收集也可以自动应用于您的应用程序。 总之Spring Boot Actuator就是一款可以帮助你监控系统数据的框架,其可以监控很多很多的系统数据,它有对应用系统...
Spring Boot整合ELK实现日志实时分析
m0_38105115的博客
08-01 1959
ELK的搭建我在上一篇博客中介绍过了，如果还不清楚的朋友请移步到上一篇博客 https://blog.csdn.net/m0_38105115/article/details/95591423 把Logstash的conf配置文件改成 input { tcp { host => "localhost" port => 9601 ...
SpringBoot 整合 elk
u011277123的博客
05-20 3146
javaspring思维导图2019-05-19 12:20:00 一、elk 简介 Elasticsearch是个开源分布式搜索引擎，它的特点有：分布式，零配置，自动发现，索引自动分片，索引副本机制，restful风格接口，多数据源，自动搜索负载等。 Logstash是一个完全开源的工具，他可以对你的日志进行收集、过滤，并将其存储供以后使用（如，搜索）。 Kibana 也是一个开源和免...
SpringBoot运维实用篇 - 使用linux部署项目（linux、jdk、mysql、SecureCRT、Navicat）技术运用
qq_39123467的博客
05-16 724
SpringBoot运维实用篇 - 工程打包后linux端运行（linux、jdk、mysql、SecureCRT、Navicat）技术运用
Spring Boot 示例项目启动与监控详解
结合描述、标签以及子文件结构来看，该项目不仅涵盖了 Spring Boot 的基本启动方式，还深入展示了其内置的监控功能、模板渲染机制、SSH 远程连接能力以及指标收集（Metrics）等高级特性。 首先，从项目的启动方式 `...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

程序员小凯

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值