java2025springboot面试题第二弹

1. 如何在Spring Boot中实现自定义的健康检查指标？

答案：
Spring Boot Actuator提供了健康检查功能，可以通过实现HealthIndicator接口来自定义健康检查指标。

@Component
public class CustomHealthIndicator implements HealthIndicator {

    @Override
    public Health health() {
        int errorCode = check(); // 模拟检查逻辑
        if (errorCode != 0) {
            return Health.down().withDetail("Error Code", errorCode).build();
        }
        return Health.up().build();
    }

    private int check() {
        // 模拟检查逻辑，返回错误码
        return new Random().nextInt(10);
    }
}

总结：
自定义HealthIndicator可以将应用的特定健康状态暴露给Actuator的/actuator/health端点，方便监控和运维。

2. 如何在Spring Boot中实现基于角色的访问控制（RBAC）？

答案：
可以通过Spring Security实现基于角色的访问控制。首先，配置Spring Security的认证和授权机制，然后使用@PreAuthorize或@Secured注解保护方法。

配置Spring Security：

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .authorizeRequests()
            .antMatchers("/admin/**").hasRole("ADMIN")
            .antMatchers("/user/**").hasAnyRole("USER", "ADMIN")
            .anyRequest().authenticated()
            .and()
            .formLogin()
            .and()
            .httpBasic();
    }

    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.inMemoryAuthentication()
            .withUser("user").password("{noop}password").roles("USER")
            .and()
            .withUser("admin").password("{noop}password").roles("ADMIN");
    }
}

保护方法：

@RestController
public class SecureController {

    @PreAuthorize("hasRole('ADMIN')")
    @GetMapping("/admin/data")
    public String adminData() {
        return "Admin Data";
    }

    @PreAuthorize("hasAnyRole('USER', 'ADMIN')")
    @GetMapping("/user/data")
    public String userData() {
        return "User Data";
    }
}

总结：
通过Spring Security的@PreAuthorize或@Secured注解，可以轻松实现基于角色的访问控制，确保只有授权用户才能访问特定资源。

3. 如何在Spring Boot中实现API限流？

答案：
可以通过集成如Guava RateLimiter或Spring Cloud Gateway的限流功能来实现API限流。

使用Guava RateLimiter：

@RestController
public class RateLimitedController {

    private final RateLimiter rateLimiter = RateLimiter.create(10); // 每秒最多10次请求

    @GetMapping("/data")
    public ResponseEntity<String> getData() {
        if (!rateLimiter.tryAcquire()) {
            return ResponseEntity.status(HttpStatus.TOO_MANY_REQUESTS).body("Rate limit exceeded");
        }
        return ResponseEntity.ok("Data");
    }
}

使用Spring Cloud Gateway限流：

spring:
  cloud:
    gateway:
      routes:
        - id: rate-limited-route
          uri: http://localhost:8081
          predicates:
            - Path=/data
          filters:
            - name: RequestRateLimiter
              args:
                redis-rate-limiter.replenishRate: 10
                redis-rate-limiter.burstCapacity: 20

总结：
API限流可以通过简单的工具（如Guava RateLimiter）或更复杂的框架（如Spring Cloud Gateway）实现，以防止服务过载和滥用。

4. 如何在Spring Boot中实现微服务之间的通信？

答案：
微服务之间的通信可以通过RESTful API、消息队列（如RabbitMQ、Kafka）或gRPC实现。

使用RestTemplate或WebClient进行HTTP通信：

@Service
public class UserServiceClient {

    private final RestTemplate restTemplate;

    public UserServiceClient(RestTemplate restTemplate) {
        this.restTemplate = restTemplate;
    }

    public User getUserById(String userId) {
        return restTemplate.getForObject("http://user-service/users/" + userId, User.class);
    }
}

使用RabbitMQ进行异步通信：

@Service
public class MessageProducer {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    public void sendMessage(String message) {
        rabbitTemplate.convertAndSend("exchange", "routingKey", message);
    }
}

总结：
微服务之间的通信方式取决于需求，同步通信适合实时性要求高的场景，而异步通信适合解耦和高并发场景。

5. 如何在Spring Boot中实现日志的集中管理？

答案：
可以通过集成ELK（Elasticsearch、Logstash、Kibana）或Spring Cloud Sleuth + Zipkin实现日志的集中管理和追踪。

使用Spring Boot与ELK集成：

1. 配置Logback：

   <appender name="ELK" class="net.logstash.logback.appender.LogstashTcpSocketAppender">
       <remoteHost>localhostremoteHost>
       <port>5000port>
   appender>
   <root level="INFO">
       <appender-ref ref="ELK"/>
   root>
   

2. 配置Logstash：

   input {
       tcp {
           port => 5000
           codec => json
       }
   }
   output {
       elasticsearch {
           hosts => ["localhost:9200"]
           index => "logs-%{+YYYY.MM.dd}"
       }
   }
   

3. 使用Kibana可视化日志。

使用Spring Cloud Sleuth + Zipkin进行分布式追踪：

spring:
  application:
    name: my-service
  sleuth:
    sampler:
      probability: 1.0  # 采样率
  zipkin:
    base-url: http://localhost:9411

总结：
通过ELK或Spring Cloud Sleuth + Zipkin，可以实现日志的集中管理和分布式追踪，方便监控和排查问题。