Java高级工程师面试全攻略：从Spring生态到微服务架构

Java高级工程师面试全攻略：从Spring生态到微服务架构

在当今竞争激烈的互联网行业，Java工程师面试已经不再局限于基础语法和简单框架使用。特别是在一线大厂，面试官更关注候选人对技术深度、系统设计能力以及复杂业务场景的应对能力。本文将以一场真实的高级Java工程师面试为背景，通过面试官与资深程序员cc的对话，深入探讨包括Spring生态、微服务架构、分布式系统、性能优化等在内的核心技术要点，帮助读者系统性地准备面试。

第一轮：Spring生态与核心框架深度考察

周先生：cc你好，欢迎来到我们公司面试。我是技术面试官周先生。我们先从基础开始，聊聊Spring框架。Spring 5.0引入了函数式编程的支持，你能说说WebFlux是如何实现响应式编程的吗？在什么业务场景下你会优先选择WebFlux而不是传统的Spring MVC？

cc：好的，周先生。WebFlux是Spring 5.0引入的响应式编程框架，它基于Reactor项目实现。与传统的Spring MVC不同，WebFlux采用非阻塞、异步的编程模型，能够更好地处理高并发场景。

WebFlux的核心组件包括：

1. HandlerFunction：处理请求并返回响应
2. RouterFunction：定义路由规则
3. WebClient：非阻塞的HTTP客户端

下面是一个简单的WebFlux示例：

@RestController
public class UserController {
    
    @Autowired
    private UserService userService;
    
    // 传统Spring MVC方式
    @GetMapping("/users/{id}")
    public User getUserById(@PathVariable Long id) {
        return userService.findById(id);
    }
    
    // WebFlux响应式方式
    @GetMapping("/reactive/users/{id}")
    public Mono<User> getUserByIdReactive(@PathVariable Long id) {
        return userService.findByIdReactive(id);
    }
}

@Service
public class UserService {
    
    // 传统阻塞式实现
    public User findById(Long id) {
        // 模拟数据库查询
        return userRepository.findById(id);
    }
    
    // 响应式实现
    public Mono<User> findByIdReactive(Long id) {
        // 使用Reactive Repository或异步调用
        return reactiveUserRepository.findById(id);
    }
}

在以下场景中我会优先选择WebFlux：

1. 高并发、I/O密集型应用，如API网关、实时数据处理
2. 需要与响应式数据源（如MongoDB、Cassandra）交互
3. 需要实现背压控制的流式数据处理
4. 微服务间通信需要更好的资源利用率

周先生：很好！接下来，Spring Boot 3已经全面迁移到Jakarta EE 9，包名从javax.变更为jakarta.。你能举例说明这种迁移对现有项目的影响，以及如何平滑升级？

cc：Spring Boot 3的重大变化之一就是迁移到Jakarta EE 9，这主要是因为Java EE已经转移到Eclipse基金会并更名为Jakarta EE。这个变化对现有项目的影响主要包括：

1. 包名变更：所有javax.*包重命名为jakarta.*包
2. 依赖兼容性：第三方库需要更新以支持新的包名
3. 配置文件调整：部分配置可能需要修改

平滑升级步骤：

<!-- pom.xml中Spring Boot 2.x升级到3.x -->
<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>3.1.0</version>
    <relativePath/>
</parent>

<dependencies>
    <!-- 旧版本 -->
    <!-- <dependency>
        <groupId>javax.servlet</groupId>
        <artifactId>javax.servlet-api</artifactId>
        <scope>provided</scope>
    </dependency> -->
    
    <!-- 新版本 -->
    <dependency>
        <groupId>jakarta.servlet</groupId>
        <artifactId>jakarta.servlet-api</artifactId>
        <scope>provided</scope>
    </dependency>
</dependencies>

代码层面的变更示例：

// 旧版本Spring Boot 2.x
// import javax.servlet.Filter;
// import javax.servlet.FilterChain;
// import javax.servlet.FilterConfig;
// import javax.servlet.ServletException;
// import javax.servlet.ServletRequest;
// import javax.servlet.ServletResponse;

// 新版本Spring Boot 3.x
import jakarta.servlet.Filter;
import jakarta.servlet.FilterChain;
import jakarta.servlet.FilterConfig;
import jakarta.servlet.ServletException;
import jakarta.servlet.ServletRequest;
import jakarta.servlet.ServletResponse;

@Component
public class CustomFilter implements Filter {
    
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, 
                         FilterChain chain) throws IOException, ServletException {
        // 过滤逻辑
        chain.doFilter(request, response);
    }
}

升级建议：

1. 先评估第三方依赖的兼容性
2. 使用工具如OpenRewrite自动完成包名替换
3. 逐步迁移和测试
4. 更新配置文件和注解引用

周先生：非常专业！最后一个问题，Spring Security 6在授权模型上有了重大变化，从WebSecurityConfigurerAdapter转向了基于组件的配置方式。你能演示一下如何实现一个基于JWT的认证授权系统吗？

cc：Spring Security 6确实移除了WebSecurityConfigurerAdapter，改用更加灵活的组件化配置方式。下面我演示如何实现一个基于JWT的认证授权系统：

@Configuration
@EnableWebSecurity
@EnableMethodSecurity
public class SecurityConfig {

    @Autowired
    private JwtAuthenticationEntryPoint jwtAuthenticationEntryPoint;

    @Autowired
    private JwtRequestFilter jwtRequestFilter;

    @Bean
    public AuthenticationManager authenticationManager(
            AuthenticationConfiguration config) throws Exception {
        return config.getAuthenticationManager();
    }

    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        http.csrf().disable()
            .authorizeHttpRequests(authz -> authz
                .requestMatchers("/authenticate", "/register").permitAll()
                .requestMatchers("/admin/**").hasRole("ADMIN")
                .requestMatchers("/user/**").hasAnyRole("USER", "ADMIN")
                .anyRequest().authenticated()
            )
            .exceptionHandling()
            .authenticationEntryPoint(jwtAuthenticationEntryPoint)
            .and()
            .sessionManagement()
            .sessionCreationPolicy(SessionCreationPolicy.STATELESS);

        http.addFilterBefore(jwtRequestFilter, UsernamePasswordAuthenticationFilter.class);

        return http.build();
    }
}

@Component
public class JwtUtil {
    
    private String SECRET_KEY = "mySecretKey";
    
    public String extractUsername(String token) {
        return extractClaim(token, Claims::getSubject);
    }
    
    public Date extractExpiration(String token) {
        return extractClaim(token, Claims::getExpiration);
    }
    
    public <T> T extractClaim(String token, Function<Claims, T> claimsResolver) {
        final Claims claims = extractAllClaims(token);
        return claimsResolver.apply(claims);
    }
    
    private Claims extractAllClaims(String token) {
        return Jwts.parser().setSigningKey(SECRET_KEY).parseClaimsJws(token).getBody();
    }
    
    private Boolean isTokenExpired(String token) {
        return extractExpiration(token).before(new Date());
    }
    
    public String generateToken(UserDetails userDetails) {
        Map<String, Object> claims = new HashMap<>();
        return createToken(claims, userDetails.getUsername());
    }
    
    private String createToken(Map<String, Object> claims, String subject) {
        return Jwts.builder()
                .setClaims(claims)
                .setSubject(subject)
                .setIssuedAt(new Date(System.currentTimeMillis()))
                .setExpiration(new Date(System.currentTimeMillis() + 1000 * 60 * 60 * 10))
                .signWith(SignatureAlgorithm.HS512, SECRET_KEY)
                .compact();
    }
    
    public Boolean validateToken(String token, UserDetails userDetails) {
        final String username = extractUsername(token);
        return (username.equals(userDetails.getUsername()) && !isTokenExpired(token));
    }
}

@Component
public class JwtRequestFilter extends OncePerRequestFilter {
    
    @Autowired
    private UserDetailsService userDetailsService;
    
    @Autowired
    private JwtUtil jwtUtil;
    
    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, 
                                    FilterChain chain) throws ServletException, IOException {
        final String authorizationHeader = request.getHeader("Authorization");
        
        String username = null;
        String jwt = null;
        
        if (authorizationHeader != null && authorizationHeader.startsWith("Bearer ")) {
            jwt = authorizationHeader.substring(7);
            try {
                username = jwtUtil.extractUsername(jwt);
            } catch (Exception e) {
                logger.error("JWT解析异常", e);
            }
        }
        
        if (username != null && SecurityContextHolder.getContext().getAuthentication() == null) {
            UserDetails userDetails = this.userDetailsService.loadUserByUsername(username);
            
            if (jwtUtil.validateToken(jwt, userDetails)) {
                UsernamePasswordAuthenticationToken authToken = 
                    new UsernamePasswordAuthenticationToken(
                        userDetails, null, userDetails.getAuthorities());
                authToken.setDetails(new WebAuthenticationDetailsSource().buildDetails(request));
                SecurityContextHolder.getContext().setAuthentication(authToken);
            }
        }
        chain.doFilter(request, response);
    }
}

这种方式相比旧的WebSecurityConfigurerAdapter更加灵活，可以针对不同的安全需求创建多个SecurityFilterChain。

周先生：太棒了！你对Spring生态的理解非常深入，代码示例也很完整。我们进入下一轮技术考察。

第二轮：分布式系统与微服务架构实战

周先生：在微服务架构中，服务间通信和服务治理是关键问题。Spring Cloud提供了完整的解决方案。你能谈谈如何使用Spring Cloud Gateway实现API网关，以及如何与服务注册发现机制集成吗？

cc：Spring Cloud Gateway是Spring官方推出的API网关解决方案，基于Spring WebFlux构建，具有高性能和非阻塞特性。下面我来展示如何实现一个完整的API网关：

# application.yml
server:
  port: 8080

spring:
  application:
    name: api-gateway
  
  cloud:
    gateway:
      routes:
        - id: user-service
          uri: lb://user-service
          predicates:
            - Path=/api/users/**
          filters:
            - StripPrefix=2
            
        - id: order-service
          uri: lb://order-service
          predicates:
            - Path=/api/orders/**
          filters:
            - StripPrefix=2
            - name: Hystrix
              args:
                name: order-service-fallback
                fallbackUri: forward:/fallback
                
      default-filters:
        - name: GlobalFilter
          args:
            message: "Global filter applied"
            
  # 服务注册与发现配置
  cloud:
    nacos:
      discovery:
        server-addr: localhost:8848

# 熔断降级配置
hystrix:
  command:
    order-service-fallback:
      execution:
        isolation:
          thread:
            timeoutInMilliseconds: 5000

@Component
public class AuthenticationFilter implements GlobalFilter, Ordered {
    
    private static final Logger logger = LoggerFactory.getLogger(AuthenticationFilter.class);
    
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        ServerHttpRequest request = exchange.getRequest();
        
        // 简单的认证检查
        if (this.isAuthorizationRequired(request)) {
            String token = request.getHeaders().getFirst("Authorization");
            if (token == null || !isValidToken(token)) {
                logger.warn("无效的认证令牌");
                ServerHttpResponse response = exchange.getResponse();
                response.setStatusCode(HttpStatus.UNAUTHORIZED);
                String errorResponse = "{\"error\":\"Unauthorized\"}";
                DataBuffer buffer = response.bufferFactory().wrap(errorResponse.getBytes());
                response.getHeaders().add("Content-Type", "application/json;charset=UTF-8");
                return response.writeWith(Mono.just(buffer));
            }
        }
        
        return chain.filter(exchange);
    }
    
    private boolean isAuthorizationRequired(ServerHttpRequest request) {
        String path = request.getPath().value();
        return path.startsWith("/api/users") || path.startsWith("/api/orders");
    }
    
    private boolean isValidToken(String token) {
        // 实际应用中应该验证JWT或其他认证机制
        return token != null && token.startsWith("Bearer ");
    }
    
    @Override
    public int getOrder() {
        return -100; // 在其他过滤器之前执行
    }
}

@RestController
public class FallbackController {
    
    @RequestMapping("/fallback")
    public ResponseEntity<String> fallback() {
        return ResponseEntity.status(HttpStatus.SERVICE_UNAVAILABLE)
                .body("{\"error\":\"Service temporarily unavailable, please try again later\"}");
    }
}

这种配置实现了：

1. 基于路径的路由转发
2. 服务发现集成（通过lb://前缀）
3. 请求路径重写
4. 熔断降级机制
5. 全局过滤器和路由特定过滤器

周先生：非常不错！现在微服务架构中，分布式事务是一个难点。你能介绍几种分布式事务的解决方案，并说明在什么场景下使用哪种方案吗？

cc：分布式事务确实是微服务架构中的一个核心挑战。目前主流的解决方案有以下几种：

1. 两阶段提交（2PC）

// 使用Seata实现AT模式分布式事务
@GlobalTransactional
public void createOrder(OrderDTO orderDTO) {
    // 1. 创建订单
    Order order = orderService.createOrder(orderDTO);
    
    // 2. 扣减库存
    inventoryService.decreaseStock(orderDTO.getProductId(), orderDTO.getQuantity());
    
    // 3. 扣减账户余额
    accountService.decreaseBalance(orderDTO.getUserId(), orderDTO.getAmount());
}

2. TCC模式（Try-Confirm-Cancel）

public interface TransferService {
    /**
     * Try阶段：检查并冻结资金
     */
    @TwoPhaseBusinessAction(name = "transfer", commitMethod = "confirm", rollbackMethod = "cancel")
    public boolean prepare(BusinessActionContext actionContext, 
                          @BusinessActionContextParameter(paramName = "fromUserId") String fromUserId,
                          @BusinessActionContextParameter(paramName = "toUserId") String toUserId,
                          @BusinessActionContextParameter(paramName = "amount") double amount);
    
    /**
     * Confirm阶段：确认转账
     */
    public boolean confirm(BusinessActionContext actionContext);
    
    /**
     * Cancel阶段：取消转账
     */
    public boolean cancel(BusinessActionContext actionContext);
}

3. 最大努力通知型

@Component
public class ReliableMessageService {
    
    @Autowired
    private MessageRepository messageRepository;
    
    @Autowired
    private MessageSender messageSender;
    
    // 业务操作与消息发送在同一个事务中
    @Transactional
    public void sendMessageWithBusiness(String messageContent) {
        // 1. 执行业务操作
        doBusiness();
        
        // 2. 插入消息记录（状态为待发送）
        Message message = new Message();
        message.setContent(messageContent);
        message.setStatus(MessageStatus.PENDING);
        message.setCreateTime(new Date());
        messageRepository.save(message);
    }
    
    // 定时任务发送消息
    @Scheduled(fixedDelay = 5000)
    public void sendPendingMessages() {
        List<Message> pendingMessages = messageRepository.findByStatus(MessageStatus.PENDING);
        for (Message message : pendingMessages) {
            try {
                messageSender.send(message.getContent());
                message.setStatus(MessageStatus.SENT);
                messageRepository.save(message);
            } catch (Exception e) {
                // 记录失败次数，超过阈值则标记为失败
                message.setFailedCount(message.getFailedCount() + 1);
                if (message.getFailedCount() > 3) {
                    message.setStatus(MessageStatus.FAILED);
                }
                messageRepository.save(message);
            }
        }
    }
}

4. Saga模式

@Component
public class OrderSagaService {
    
    // Saga编排模式
    public void processOrderSaga(OrderDTO orderDTO) {
        SagaInstance sagaInstance = sagaManager.createSaga(OrderSaga.class);
        
        try {
            // 步骤1：创建订单
            CreateOrderResult orderResult = orderService.createOrder(orderDTO);
            sagaInstance.addCompensation(() -> orderService.cancelOrder(orderResult.getOrderId()));
            
            // 步骤2：支付订单
            PaymentResult paymentResult = paymentService.processPayment(orderResult.getOrderId(), orderDTO.getAmount());
            sagaInstance.addCompensation(() -> paymentService.refund(paymentResult.getPaymentId()));
            
            // 步骤3：通知库存系统
            inventoryService.reserveItems(orderDTO.getItems());
            sagaInstance.addCompensation(() -> inventoryService.releaseItems(orderDTO.getItems()));
            
            // 所有步骤成功，提交Saga
            sagaInstance.commit();
        } catch (Exception e) {
            // 任何步骤失败，执行补偿操作
            sagaInstance.rollback();
            throw e;
        }
    }
}

各种方案的适用场景：

1. 2PC（Seata AT模式）：适合对一致性要求极高的场景，如金融交易系统
2. TCC模式：适合对性能要求高，可以接受一定开发复杂度的场景
3. 最大努力通知型：适合对一致性要求不高，可以接受最终一致性的场景，如通知类业务
4. Saga模式：适合业务流程长，涉及多个服务的场景，如订单处理流程

周先生：讲解得非常清楚！最后一个关于微服务的问题：在微服务架构中，如何实现服务间的通信安全和流量控制？

cc：在微服务架构中，服务间通信安全和流量控制是保障系统稳定性和安全性的关键。我从以下几个方面来说明：

服务间通信安全

// 1. 使用Spring Cloud Security实现服务间认证
@Configuration
@EnableWebSecurity
public class ResourceServerConfig {
    
    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        http.oauth2ResourceServer(oauth2 -> oauth2
            .jwt(jwt -> jwt
                .decoder(jwtDecoder())
            )
        );
        http.authorizeHttpRequests(authz -> authz
            .requestMatchers("/actuator/**").permitAll()
            .anyRequest().authenticated()
        );
        return http.build();
    }
    
    @Bean
    public JwtDecoder jwtDecoder() {
        // 配置JWT解码器，验证服务间调用的令牌
        return NimbusJwtDecoder.withJwkSetUri("http://auth-server/.well-known/jwks.json").build();
    }
}

// 2. 服务间调用时添加认证头
@Service
public class OrderServiceClient {
    
    @Autowired
    private WebClient.Builder webClientBuilder;
    
    public Order getOrder(Long orderId) {
        String token = generateServiceToken(); // 生成服务间调用令牌
        
        return webClientBuilder.build()
            .get()
            .uri("http://order-service/orders/{orderId}", orderId)
            .header("Authorization", "Bearer " + token)
            .retrieve()
            .bodyToMono(Order.class)
            .block();
    }
    
    private String generateServiceToken() {
        // 生成JWT令牌用于服务间认证
        Instant now = Instant.now();
        JwtClaimsSet claims = JwtClaimsSet.builder()
            .issuer("user-service")
            .issuedAt(now)
            .expiresAt(now.plusSeconds(300))
            .subject("service-to-service")
            .build();
        
        return jwtEncoder.encode(JwtEncoderParameters.from(claims)).getTokenValue();
    }
}

流量控制实现

// 1. 使用Resilience4j实现限流
@Component
public class RateLimiterService {
    
    private final RateLimiter rateLimiter;
    
    public RateLimiterService() {
        // 配置限流器：每秒允许10个请求
        RateLimiterConfig config = RateLimiterConfig.custom()
            .limitRefreshPeriod(Duration.ofSeconds(1))
            .limitForPeriod(10)
            .timeoutDuration(Duration.ofMillis(500))
            .build();
        
        this.rateLimiter = RateLimiter.of("user-service", config);
    }
    
    public User getUserWithRateLimit(Long userId) {
        // 应用限流
        Supplier<User> restrictedSupplier = RateLimiter
            .decorateSupplier(rateLimiter, () -> fetchUser(userId));
        
        return Try.ofSupplier(restrictedSupplier)
            .getOrElseThrow(throwable -> new RuntimeException("请求过于频繁，请稍后再试"));
    }
    
    private User fetchUser(Long userId) {
        // 实际的用户查询逻辑
        return userRepository.findById(userId);
    }
}

// 2. 使用Sentinel实现更精细的流量控制
@RestController
public class ProductController {
    
    @Autowired
    private ProductService productService;
    
    @GetMapping("/products/{id}")
    @SentinelResource(value = "getProduct", 
                     blockHandler = "handleException", 
                     fallback = "fallbackMethod")
    public Product getProduct(@PathVariable Long id) {
        return productService.findById(id);
    }
    
    // 限流处理方法
    public Product handleException(Long id, BlockException ex) {
        // 记录限流日志
        log.warn("访问过于频繁，触发限流: {}", ex.getMessage());
        return Product.builder()
            .id(id)
            .name("服务繁忙，请稍后再试")
            .build();
    }
    
    // 降级处理方法
    public Product fallbackMethod(Long id) {
        return Product.builder()
            .id(id)
            .name("服务暂时不可用")
            .build();
    }
}

# sentinel配置
spring:
  cloud:
    sentinel:
      transport:
        dashboard: localhost:8080
        port: 8719
      datasource:
        ds1:
          nacos:
            server-addr: localhost:8848
            dataId: ${spring.application.name}-sentinel
            groupId: DEFAULT_GROUP
            rule-type: flow

# resilience4j配置
resilience4j:
  ratelimiter:
    instances:
      user-service:
        limit-for-period: 10
        limit-refresh-period: 1s
        timeout-duration: 0
        register-health-indicator: true
        event-consumer-buffer-size: 100

通过这些方式，我们可以确保微服务间通信的安全性和稳定性，防止系统因突发流量而崩溃。

周先生：非常精彩！你对微服务架构的理解和实践经验都很扎实。我们进入下一轮。

第三轮：数据库与缓存优化实战

周先生：在高并发系统中，数据库和缓存的优化至关重要。你能谈谈在Spring Boot应用中如何优化数据库访问性能，以及如何设计合理的缓存策略吗？

cc：数据库和缓存优化确实是高并发系统的关键。我从以下几个方面来说明：

数据库访问优化

// 1. 使用连接池优化数据库连接
@Configuration
public class DataSourceConfig {
    
    @Bean
    @ConfigurationProperties("spring.datasource.hikari")
    public HikariDataSource dataSource() {
        return DataSourceBuilder.create().type(HikariDataSource.class).build();
    }
}

// application.yml
spring:
  datasource:
    hikari:
      maximum-pool-size: 20
      minimum-idle: 5
      connection-timeout: 30000
      idle-timeout: 600000
      max-lifetime: 1800000
      connection-test-query: SELECT 1

// 2. 使用JPA优化查询
@Entity
@Table(name = "orders")
@NamedEntityGraph(
    name = "Order.withItems",
    attributeNodes = @NamedAttributeNode("items")
)
public class Order {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    @OneToMany(mappedBy = "order", fetch = FetchType.LAZY)
    private List<OrderItem> items = new ArrayList<>();
    
    // 使用@Formula优化计算字段
    @Formula("(SELECT SUM(oi.quantity * oi.price) FROM order_items oi WHERE oi.order_id = id)")
    private BigDecimal totalAmount;
}

@Repository
public interface OrderRepository extends JpaRepository<Order, Long> {
    
    // 使用@EntityGraph避免N+1查询
    @EntityGraph("Order.withItems")
    Optional<Order> findWithItemsById(Long id);
    
    // 使用@Query优化复杂查询
    @Query("SELECT o FROM Order o JOIN FETCH o.items WHERE o.userId = :userId")
    List<Order> findOrdersWithItemsByUserId(@Param("userId") Long userId);
    
    // 使用原生SQL优化特定查询
    @Query(value = "SELECT * FROM orders WHERE user_id = :userId AND status = 'ACTIVE' ORDER BY create_time DESC LIMIT 10", nativeQuery = true)
    List<Order> findRecentActiveOrders(@Param("userId") Long userId);
}

// 3. 使用读写分离优化数据库性能
@Configuration
public class DataSourceConfig {
    
    @Bean
    @Primary
    @ConfigurationProperties("spring.datasource.master")
    public DataSource masterDataSource() {
        return DataSourceBuilder.create().build();
    }
    
    @Bean
    @ConfigurationProperties("spring.datasource.slave")
    public DataSource slaveDataSource() {
        return DataSourceBuilder.create().build();
    }
    
    @Bean
    public AbstractRoutingDataSource routingDataSource() {
        Map<Object, Object> targetDataSources = new HashMap<>();
        targetDataSources.put("master", masterDataSource());
        targetDataSources.put("slave", slaveDataSource());
        
        AbstractRoutingDataSource routingDataSource = new AbstractRoutingDataSource() {
            @Override
            protected Object determineCurrentLookupKey() {
                return DataSourceContextHolder.getDataSourceType();
            }
        };
        
        routingDataSource.setTargetDataSources(targetDataSources);
        routingDataSource.setDefaultTargetDataSource(masterDataSource());
        return routingDataSource;
    }
}

// 自定义注解实现读写分离
@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface DataSource {
    String value();
}

@Aspect
@Component
public class DataSourceAspect {
    
    @Around("@annotation(dataSource)")
    public Object around(ProceedingJoinPoint point, DataSource dataSource) throws Throwable {
        DataSourceContextHolder.setDataSourceType(dataSource.value());
        try {
            return point.proceed();
        } finally {
            DataSourceContextHolder.clearDataSourceType();
        }
    }
}

@Service
public class OrderService {
    
    @DataSource("master")
    @Transactional
    public Order createOrder(OrderDTO orderDTO) {
        // 写操作使用主库
        return orderRepository.save(convertToOrder(orderDTO));
    }
    
    @DataSource("slave")
    public List<Order> getUserOrders(Long userId) {
        // 读操作使用从库
        return orderRepository.findByUserId(userId);
    }
}

缓存策略设计

// 1. 多级缓存设计
@Service
public class ProductService {
    
    @Autowired
    private ProductRepository productRepository;
    
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    
    // 本地缓存 - Caffeine
    private final Cache<String, Product> localCache = Caffeine.newBuilder()
        .maximumSize(1000)
        .expireAfterWrite(10, TimeUnit.MINUTES)
        .recordStats()
        .build();
    
    public Product getProduct(Long productId) {
        // 一级缓存：本地缓存
        Product product = localCache.getIfPresent(productId.toString());
        if (product != null) {
            return product;
        }
        
        // 二级缓存：Redis缓存
        String cacheKey = "product:" + productId;
        product = (Product) redisTemplate.opsForValue().get(cacheKey);
        if (product != null) {
            localCache.put(productId.toString(), product);
            return product;
        }
        
        // 三级缓存：数据库
        product = productRepository.findById(productId).orElse(null);
        if (product != null) {
            redisTemplate.opsForValue().set(cacheKey, product, 30, TimeUnit.MINUTES);
            localCache.put(productId.toString(), product);
        }
        
        return product;
    }
    
    @CacheEvict(value = "products", key = "#product.id")
    public Product updateProduct(Product product) {
        Product updatedProduct = productRepository.save(product);
        // 清除各级缓存
        localCache.invalidate(product.getId().toString());
        redisTemplate.delete("product:" + product.getId());
        return updatedProduct;
    }
}

// 2. 缓存预热和更新策略
@Component
public class CacheWarmUpService {
    
    @Autowired
    private ProductRepository productRepository;
    
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    
    @EventListener(ApplicationReadyEvent.class)
    public void warmUpCache() {
        // 应用启动时预热热点数据
        List<Product> hotProducts = productRepository.findHotProducts();
        for (Product product : hotProducts) {
            String cacheKey = "product:" + product.getId();
            redisTemplate.opsForValue().set(cacheKey, product, 60, TimeUnit.MINUTES);
        }
    }
    
    // 定时更新缓存
    @Scheduled(fixedRate = 300000) // 每5分钟执行一次
    public void refreshCache() {
        // 更新热点数据缓存
        updateHotProductsCache();
    }
    
    private void updateHotProductsCache() {
        List<Product> hotProducts = productRepository.findHotProducts();
        for (Product product : hotProducts) {
            String cacheKey = "product:" + product.getId();
            redisTemplate.opsForValue().set(cacheKey, product, 60, TimeUnit.MINUTES);
        }
    }
}

这些优化策略可以显著提升系统的性能和响应速度，特别是在高并发场景下。

周先生：很棒！接下来，请谈谈如何在Spring Boot中集成和优化Redis，以及如何处理缓存穿透、击穿和雪崩问题？

cc：Redis在现代应用中扮演着重要角色，正确集成和优化Redis对系统性能至关重要。让我详细说明：

Redis集成与优化

// 1. Redis配置优化
@Configuration
@EnableCaching
public class RedisConfig {
    
    @Bean
    public LettuceConnectionFactory redisConnectionFactory() {
        RedisStandaloneConfiguration config = new RedisStandaloneConfiguration();
        config.setHostName("localhost");
        config.setPort(6379);
        config.setDatabase(0);
        
        LettuceClientConfiguration clientConfig = LettuceClientConfiguration.builder()
            .commandTimeout(Duration.ofSeconds(2))
            .shutdownTimeout(Duration.ZERO)
            .build();
            
        return new LettuceConnectionFactory(config, clientConfig);
    }
    
    @Bean
    public RedisTemplate<String, Object> redisTemplate() {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(redisConnectionFactory());
        template.setKeySerializer(new StringRedisSerializer());
        template.setHashKeySerializer(new StringRedisSerializer());
        template.setValueSerializer(new GenericJackson2JsonRedisSerializer());
        template.setHashValueSerializer(new GenericJackson2JsonRedisSerializer());
        template.afterPropertiesSet();
        return template;
    }
    
    // 自定义缓存管理器
    @Bean
    public CacheManager cacheManager() {
        RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
            .entryTtl(Duration.ofHours(1))
            .serializeKeysWith(RedisSerializationContext.SerializationPair
                .fromSerializer(new StringRedisSerializer()))
            .serializeValuesWith(RedisSerializationContext.SerializationPair
                .fromSerializer(new GenericJackson2JsonRedisSerializer()))
            .disableCachingNullValues();
            
        return RedisCacheManager.builder(redisConnectionFactory())
            .cacheDefaults(config)
            .build();
    }
}

// 2. 处理缓存穿透、击穿和雪崩问题
@Service
public class CacheService {
    
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    
    @Autowired
    private ProductRepository productRepository;
    
    private final Cache<String, Product> localCache = Caffeine.newBuilder()
        .maximumSize(1000)
        .expireAfterWrite(5, TimeUnit.MINUTES)
        .build();
    
    // 解决缓存穿透问题 - 布隆过滤器
    private final BloomFilter<String> bloomFilter = BloomFilter.create(
        Funnels.stringFunnel(Charset.defaultCharset()), 1000000, 0.01);
    
    @PostConstruct
    public void initBloomFilter() {
        // 初始化布隆过滤器，加载所有有效key
        List<Long> productIds = productRepository.findAllProductIds();
        for (Long id : productIds) {
            bloomFilter.put("product:" + id);
        }
    }
    
    public Product getProductSafe(Long productId) {
        String key = "product:" + productId;
        
        // 1. 布隆过滤器快速判断key是否存在
        if (!bloomFilter.mightContain(key)) {
            return null; // 快速返回，避免查询数据库
        }
        
        // 2. 查询本地缓存
        Product product = localCache.getIfPresent(productId.toString());
        if (product != null) {
            return product;
        }
        
        // 3. 查询Redis缓存
        product = (Product) redisTemplate.opsForValue().get(key);
        if (product != null) {
            localCache.put(productId.toString(), product);
            return product;
        }
        
        // 4. 分布式锁防止缓存击穿
        String lockKey = "lock:" + key;
        String lockValue = UUID.randomUUID().toString();
        
        try {
            // 尝试获取分布式锁
            Boolean lockAcquired = redisTemplate.opsForValue()
                .setIfAbsent(lockKey, lockValue, Duration.ofSeconds(10));
                
            if (Boolean.TRUE.equals(lockAcquired)) {
                // 获取锁成功，查询数据库
                product = productRepository.findById(productId).orElse(null);
                
                if (product != null) {
                    // 回种缓存
                    redisTemplate.opsForValue().set(key, product, Duration.ofMinutes(30));
                    localCache.put(productId.toString(), product);
                } else {
                    // 缓存空值防止穿透
                    redisTemplate.opsForValue().set(key, "", Duration.ofMinutes(5));
                }
            } else {
                // 获取锁失败，短暂等待后重试
                Thread.sleep(100);
                return getProductSafe(productId);
            }
        } catch (Exception e) {
            // 异常处理
            log.error("获取商品信息失败", e);
        } finally {
            // 释放分布式锁
            String script = "if redis.call('get', KEYS[1]) == ARGV[1] then " +
                           "return redis.call('del', KEYS[1]) else return 0 end";
            redisTemplate.execute(new DefaultRedisScript<>(script, Long.class),
                Collections.singletonList(lockKey), lockValue);
        }
        
        return product;
    }
}

// 3. 缓存雪崩解决方案 - 随机过期时间
@Service
public class CacheWithRandomExpireService {
    
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    
    public void setWithRandomExpire(String key, Object value) {
        // 设置随机过期时间，避免同时过期
        int randomExpire = 1800 + new Random().nextInt(1800); // 30-60分钟
        redisTemplate.opsForValue().set(key, value, Duration.ofSeconds(randomExpire));
    }
    
    // 多级缓存过期策略
    public void setMultiLevelCache(String key, Object value) {
        // L1缓存 - 本地缓存，较短时间
        // L2缓存 - Redis缓存，较长时间
        
        int localExpire = 300 + new Random().nextInt(300); // 5-10分钟
        int redisExpire = 3600 + new Random().nextInt(3600); // 1-2小时
        
        // 本地缓存使用Caffeine
        localCache.put(key, value);
        
        // Redis缓存
        redisTemplate.opsForValue().set(key, value, Duration.ofSeconds(redisExpire));
    }
}

// 4. 缓存预热和更新机制
@Component
public class CacheWarmUpScheduler {
    
    @Autowired
    private ProductService productService;
    
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    
    // 应用启动时预热缓存
    @EventListener(ApplicationReadyEvent.class)
    public void warmUpCacheOnStartup() {
        warmUpHotProducts();
    }
    
    // 定时预热热点数据
    @Scheduled(cron = "0 0 2 * * ?") // 每天凌晨2点执行
    public void warmUpHotProducts() {
        List<Product> hotProducts = productService.getHotProducts();
        for (Product product : hotProducts) {
            String key = "product:" + product.getId();
            redisTemplate.opsForValue().set(key, product, Duration.ofHours(24));
        }
    }
    
    // 缓存更新监听
    @EventListener
    public void handleProductUpdateEvent(ProductUpdateEvent event) {
        // 商品更新时同步更新缓存
        String key = "product:" + event.getProductId();
        redisTemplate.delete(key);
        localCache.invalidate(event.getProductId().toString());
    }
}

通过这些策略，我们可以有效解决缓存穿透、击穿和雪崩问题，提升系统的稳定性和性能。

周先生：非常棒的解决方案！最后一个数据库相关的问题：在大数据量场景下，如何设计分库分表策略，以及如何在Spring Boot中实现？

cc：分库分表是处理大数据量场景的核心技术。让我详细介绍如何设计和实现：

分库分表策略设计

// 1. 自定义分片算法
public class OrderShardingAlgorithm implements PreciseShardingAlgorithm<Long> {
    
    @Override
    public String doSharding(Collection<String> availableTargetNames, 
                            PreciseShardingValue<Long> shardingValue) {
        Long orderId = shardingValue.getValue();
        // 按订单ID取模分片
        int suffix = (int) (orderId % availableTargetNames.size());
        
        for (String tableName : availableTargetNames) {
            if (tableName.endsWith("_" + suffix)) {
                return tableName;
            }
        }
        
        throw new IllegalArgumentException("未找到匹配的分片表");
    }
}

public class UserDatabaseShardingAlgorithm implements PreciseShardingAlgorithm<Long> {
    
    @Override
    public String doSharding(Collection<String> availableTargetNames,
                            PreciseShardingValue<Long> shardingValue) {
        Long userId = shardingValue.getValue();
        // 按用户ID分库
        int dbIndex = (int) ((userId / 10000) % availableTargetNames.size());
        
        for (String dbName : availableTargetNames) {
            if (dbName.endsWith("_" + dbIndex)) {
                return dbName;
            }
        }
        
        throw new IllegalArgumentException("未找到匹配的分片库");
    }
}

# 2. ShardingSphere配置
spring:
  shardingsphere:
    datasource:
      names: ds0,ds1
      ds0:
        type: com.zaxxer.hikari.HikariDataSource
        driver-class-name: com.mysql.cj.jdbc.Driver
        jdbc-url: jdbc:mysql://localhost:3306/order_db_0
        username: root
        password: password
      ds1:
        type: com.zaxxer.hikari.HikariDataSource
        driver-class-name: com.mysql.cj.jdbc.Driver
        jdbc-url: jdbc:mysql://localhost:3306/order_db_1
        username: root
        password: password
    
    rules:
      sharding:
        tables:
          t_order:
            actual-data-nodes: ds$->{0..1}.t_order_$->{0..3}
            table-strategy:
              standard:
                sharding-column: order_id
                sharding-algorithm-name: order-inline
            database-strategy:
              standard:
                sharding-column: user_id
                sharding-algorithm-name: user-db-inline
          t_order_item:
            actual-data-nodes: ds$->{0..1}.t_order_item_$->{0..3}
            table-strategy:
              standard:
                sharding-column: order_id
                sharding-algorithm-name: order-item-inline
        
        sharding-algorithms:
          order-inline:
            type: INLINE
            props:
              algorithm-expression: t_order_$->{order_id % 4}
          user-db-inline:
            type: INLINE
            props:
              algorithm-expression: ds$->{user_id / 10000 % 2}
          order-item-inline:
            type: INLINE
            props:
              algorithm-expression: t_order_item_$->{order_id % 4}
    
    props:
      sql-show: true

// 3. 在Spring Boot中使用分库分表
@Repository
public class OrderShardingRepository {
    
    @Autowired
    private JdbcTemplate jdbcTemplate;
    
    // 插入订单 - 自动路由到正确的分片
    public void insertOrder(Order order) {
        String sql = "INSERT INTO t_order (order_id, user_id, amount, status) VALUES (?, ?, ?, ?)";
        jdbcTemplate.update(sql, order.getOrderId(), order.getUserId(), 
                           order.getAmount(), order.getStatus().name());
    }
    
    // 查询订单 - 自动路由到正确的分片
    public Order getOrderById(Long orderId, Long userId) {
        String sql = "SELECT * FROM t_order WHERE order_id = ? AND user_id = ?";
        return jdbcTemplate.queryForObject(sql, new Object[]{orderId, userId}, 
                                          new BeanPropertyRowMapper<>(Order.class));
    }
    
    // 范围查询 - 需要广播到所有分片
    public List<Order> getOrdersByUserId(Long userId, LocalDateTime startTime, LocalDateTime endTime) {
        String sql = "SELECT * FROM t_order WHERE user_id = ? AND create_time BETWEEN ? AND ?";
        return jdbcTemplate.query(sql, new Object[]{userId, startTime, endTime}, 
                                 new BeanPropertyRowMapper<>(Order.class));
    }
}

// 4. 分布式ID生成器
@Component
public class SnowflakeIdGenerator {
    
    private final long workerId;
    private final long datacenterId;
    private long sequence = 0L;
    private long lastTimestamp = -1L;
    
    public SnowflakeIdGenerator(@Value("${snowflake.worker-id:1}") long workerId,
                               @Value("${snowflake.datacenter-id:1}") long datacenterId) {
        this.workerId = workerId;
        this.datacenterId = datacenterId;
    }
    
    public synchronized long nextId() {
        long timestamp = System.currentTimeMillis();
        
        if (timestamp < lastTimestamp) {
            throw new RuntimeException("时钟回拨异常");
        }
        
        if (lastTimestamp == timestamp) {
            sequence = (sequence + 1) & 0xFFF;
            if (sequence == 0) {
                timestamp = waitNextMillis(timestamp);
            }
        } else {
            sequence = 0L;
        }
        
        lastTimestamp = timestamp;
        
        return ((timestamp - 1288834974657L) << 22) |
               (datacenterId << 17) |
               (workerId << 12) |
               sequence;
    }
    
    private long waitNextMillis(long lastTimestamp) {
        long timestamp = System.currentTimeMillis();
        while (timestamp <= lastTimestamp) {
            timestamp = System.currentTimeMillis();
        }
        return timestamp;
    }
}

@Service
public class OrderService {
    
    @Autowired
    private OrderShardingRepository orderRepository;
    
    @Autowired
    private SnowflakeIdGenerator idGenerator;
    
    @Transactional
    public Order createOrder(OrderDTO orderDTO) {
        // 生成全局唯一ID
        Long orderId = idGenerator.nextId();
        
        Order order = new Order();
        order.setOrderId(orderId);
        order.setUserId(orderDTO.getUserId());
        order.setAmount(orderDTO.getAmount());
        order.setStatus(OrderStatus.PENDING);
        order.setCreateTime(LocalDateTime.now());
        
        // 插入订单 - 自动路由到正确的分片
        orderRepository.insertOrder(order);
        
        return order;
    }
}

这种分库分表策略可以有效解决大数据量场景下的性能问题，通过合理的分片算法和ID生成策略，保证数据的均匀分布和全局唯一性。

周先生：太精彩了！你的技术深度和实践经验都非常出色。我们进入最后一轮。

第四轮：系统性能优化与监控

周先生：在生产环境中，系统性能监控和调优是保障服务质量的关键。你能谈谈如何在Spring Boot应用中集成Micrometer进行监控，以及如何进行JVM调优吗？

cc：系统监控和性能调优是保障生产环境稳定运行的重要环节。让我详细说明Micrometer集成和JVM调优：

Micrometer监控集成

// 1. Micrometer基础配置
@Configuration
public class MetricsConfig {
    
    @Bean
    public MeterRegistryCustomizer<MeterRegistry> metricsCommonTags() {
        return registry -> registry.config()
            .commonTags("application", "ecommerce-service")
            .commonTags("environment", System.getenv("SPRING_PROFILES_ACTIVE"))
            .commonTags("version", "1.0.0");
    }
    
    // 自定义指标
    @Bean
    public TimedAspect timedAspect(MeterRegistry registry) {
        return new TimedAspect(registry);
    }
}

@RestController
public class OrderController {
    
    @Autowired
    private OrderService orderService;
    
    private final MeterRegistry meterRegistry;
    private final Counter orderCreateCounter;
    private final Timer orderProcessTimer;
    
    public OrderController(MeterRegistry meterRegistry) {
        this.meterRegistry = meterRegistry;
        this.orderCreateCounter = Counter.builder("order.created")
            .description("订单创建数量")
            .register(meterRegistry);
        this.orderProcessTimer = Timer.builder("order.process.time")
            .description("订单处理耗时")
            .register(meterRegistry);
    }
    
    @PostMapping("/orders")
    @Timed(name = "order.create", description = "创建订单耗时")
    public ResponseEntity<Order> createOrder(@RequestBody OrderDTO orderDTO) {
        orderCreateCounter.increment();
        
        Timer.Sample sample = Timer.start(meterRegistry);
        try {
            Order order = orderService.createOrder(orderDTO);
            return ResponseEntity.ok(order);
        } finally {
            sample.stop(orderProcessTimer);
        }
    }
}

// 2. 自定义业务指标
@Component
public class BusinessMetricsService {
    
    private final MeterRegistry meterRegistry;
    private final Counter userLoginCounter;
    private final Gauge activeUserGauge;
    private final DistributionSummary orderAmountSummary;
    
    private final AtomicLong activeUserCount = new AtomicLong(0);
    
    public BusinessMetricsService(MeterRegistry meterRegistry) {
        this.meterRegistry = meterRegistry;
        this.userLoginCounter = Counter.builder("user.login")
            .description("用户登录次数")
            .tag("type", "success")
            .register(meterRegistry);
            
        this.activeUserGauge = Gauge.builder("user.active")
            .description("活跃用户数")
            .register(meterRegistry, activeUserCount, AtomicLong::get);
            
        this.orderAmountSummary = DistributionSummary.builder("order.amount")
            .description("订单金额分布")
            .publishPercentiles(0.5, 0.95, 0.99)
            .register(meterRegistry);
    }
    
    public void recordUserLogin() {
        userLoginCounter.increment();
        activeUserCount.incrementAndGet();
    }
    
    public void recordOrderAmount(BigDecimal amount) {
        orderAmountSummary.record(amount.doubleValue());
    }
    
    @EventListener
    public void handleUserLogoutEvent(UserLogoutEvent event) {
        activeUserCount.decrementAndGet();
    }
}

# 3. Prometheus集成配置
management:
  endpoints:
    web:
      exposure:
        include: health,info,metrics,prometheus
  metrics:
    export:
      prometheus:
        enabled: true
    tags:
      application: ${spring.application.name}
  endpoint:
    prometheus:
      enabled: true

# application.yml
spring:
  application:
    name: ecommerce-service

# prometheus.yml配置示例
# scrape_configs:
#   - job_name: 'spring-boot-app'
#     static_configs:
#       - targets: ['localhost:8080']

// 4. 健康检查和自定义监控
@Component
public class CustomHealthIndicator implements HealthIndicator {
    
    @Autowired
    private DatabaseService databaseService;
    
    @Autowired
    private CacheService cacheService;
    
    @Override
    public Health health() {
        // 检查数据库连接
        boolean dbStatus = databaseService.isConnectionValid();
        // 检查缓存服务
        boolean cacheStatus = cacheService.isAvailable();
        // 检查外部服务依赖
        boolean externalServiceStatus = checkExternalService();
        
        if (dbStatus && cacheStatus && externalServiceStatus) {
            return Health.up()
                .withDetail("database", "Available")
                .withDetail("cache", "Available")
                .withDetail("externalService", "Available")
                .build();
        } else {
            return Health.down()
                .withDetail("database", dbStatus ? "Available" : "Unavailable")
                .withDetail("cache", cacheStatus ? "Available" : "Unavailable")
                .withDetail("externalService", externalServiceStatus ? "Available" : "Unavailable")
                .build();
        }
    }
    
    private boolean checkExternalService() {
        // 实现外部服务健康检查逻辑
        return true;
    }
}

JVM调优实践

# 1. JVM启动参数优化
#!/bin/bash
# JVM调优参数示例
JAVA_OPTS="-server \
-Xms2g \
-Xmx2g \
-XX:NewRatio=2 \
-XX:SurvivorRatio=8 \
-XX:+UseG1GC \
-XX:MaxGCPauseMillis=200 \
-XX:+UnlockExperimentalVMOptions \
-XX:+UseStringDeduplication \
-XX:+HeapDumpOnOutOfMemoryError \
-XX:HeapDumpPath=/opt/logs/heapdump.hprof \
-Xloggc:/opt/logs/gc.log \
-XX:+PrintGCDetails \
-XX:+PrintGCTimeStamps \
-XX:+PrintGCApplicationStoppedTime \
-Dcom.sun.management.jmxremote \
-Dcom.sun.management.jmxremote.port=9999 \
-Dcom.sun.management.jmxremote.authenticate=false \
-Dcom.sun.management.jmxremote.ssl=false"

java $JAVA_OPTS -jar ecommerce-service.jar

// 2. 内存使用优化
@Service
public class MemoryOptimizationService {
    
    // 使用对象池减少GC压力
    private final ObjectPool<StringBuilder> stringBuilderPool = 
        new GenericObjectPool<>(new StringBuilderFactory());
    
    public String processLargeData(List<String> data) {
        StringBuilder sb = null;
        try {
            sb = stringBuilderPool.borrowObject();
            for (String item : data) {
                sb.append(item).append(",");
            }
            return sb.toString();
        } catch (Exception e) {
            throw new RuntimeException("处理数据失败", e);
        } finally {
            if (sb != null) {
                sb.setLength(0); // 清空内容
                stringBuilderPool.returnObject(sb);
            }
        }
    }
    
    // 及时释放资源，避免内存泄漏
    public void processDataWithResourceManagement() {
        try (FileInputStream fis = new FileInputStream("data.txt");
             BufferedReader reader = new BufferedReader(new InputStreamReader(fis))) {
            
            String line;
            while ((line = reader.readLine()) != null) {
                // 处理数据
                processLine(line);
            }
        } catch (IOException e) {
            log.error("读取文件失败", e);
        }
    }
}

这些监控和调优措施可以帮助我们全面了解系统运行状态，及时发现和解决性能问题。

周先生：非常棒！最后一个问题：在容器化部署环境中，如何优化Spring Boot应用的资源使用和启动性能？

cc：在容器化环境中，应用的资源使用和启动性能优化尤为重要。让我详细介绍：

容器化环境优化

# 1. 优化Dockerfile
FROM openjdk:17-jdk-slim

# 创建非root用户
RUN groupadd -r appuser && useradd -r -g appuser appuser

# 复制应用文件
COPY target/ecommerce-service.jar app.jar

# 更改文件所有权
RUN chown appuser:appuser app.jar

# 切换到非root用户
USER appuser

# JVM优化参数
ENV JAVA_OPTS="-XX:+UseContainerSupport \
               -XX:MaxRAMPercentage=75.0 \
               -XX:+UseG1GC \
               -XX:+UseStringDeduplication \
               -Djava.security.egd=file:/dev/./urandom"

# 健康检查
HEALTHCHECK --interval=30s --timeout=3s --start-period=60s --retries=3 \
  CMD curl -f http://localhost:8080/actuator/health || exit 1

EXPOSE 8080

ENTRYPOINT ["sh", "-c", "java $JAVA_OPTS -jar app.jar"]

# 2. Kubernetes部署配置优化
apiVersion: apps/v1
kind: Deployment
metadata:
  name: ecommerce-service
spec:
  replicas: 3
  selector:
    matchLabels:
      app: ecommerce-service
  template:
    metadata:
      labels:
        app: ecommerce-service
    spec:
      containers:
      - name: ecommerce-service
        image: ecommerce-service:latest
        ports:
        - containerPort: 8080
        resources:
          requests:
            memory: "1Gi"
            cpu: "500m"
          limits:
            memory: "2Gi"
            cpu: "1000m"
        env:
        - name: SPRING_PROFILES_ACTIVE
          value: "prod"
        - name: JAVA_OPTS
          value: "-XX:+UseContainerSupport -XX:MaxRAMPercentage=75.0"
        readinessProbe:
          httpGet:
            path: /actuator/health/readiness
            port: 8080
          initialDelaySeconds: 30
          periodSeconds: 10
        livenessProbe:
          httpGet:
            path: /actuator/health/liveness
            port: 8080
          initialDelaySeconds: 60
          periodSeconds: 30
---
apiVersion: v1
kind: Service
metadata:
  name: ecommerce-service
spec:
  selector:
    app: ecommerce-service
  ports:
    - protocol: TCP
      port: 8080
      targetPort: 8080
  type: ClusterIP

// 3. 应用启动优化
@SpringBootApplication
public class EcommerceApplication {
    
    public static void main(String[] args) {
        // 启用延迟初始化，减少启动时间
        System.setProperty("spring.main.lazy-initialization", "true");
        
        SpringApplication app = new SpringApplication(EcommerceApplication.class);
        // 禁用不必要的自动配置
        app.setLazyInitialization(true);
        app.run(args);
    }
}

// 4. GraalVM原生镜像支持（Spring Boot 3.x）
@Configuration
@NativeHint(
    options = {
        "--enable-url-protocols=http,https",
        "--initialize-at-build-time=com.mysql.cj.jdbc.Driver"
    },
    types = {
        @TypeHint(types = {
            com.mysql.cj.jdbc.Driver.class,
            org.hibernate.dialect.MySQL8Dialect.class
        })
    }
)
public class NativeConfig {
    
}

# 5. 构建原生镜像
#!/bin/bash
# 使用GraalVM构建原生镜像
./mvnw -Pnative native:compile

# 构建原生镜像Dockerfile
cat > Dockerfile.native << 'EOF'
FROM gcr.io/distroless/cc-debian11
COPY target/ecommerce-service app
USER nonroot:nonroot
EXPOSE 8080
ENTRYPOINT ["/app"]
EOF

docker build -f Dockerfile.native -t ecommerce-service:native .

# 6. Helm Chart配置示例
# values.yaml
replicaCount: 3

image:
  repository: ecommerce-service
  tag: latest
  pullPolicy: IfNotPresent

resources:
  limits:
    cpu: 1000m
    memory: 2Gi
  requests:
    cpu: 500m
    memory: 1Gi

autoscaling:
  enabled: true
  minReplicas: 3
  maxReplicas: 10
  targetCPUUtilizationPercentage: 80

service:
  type: ClusterIP
  port: 8080

ingress:
  enabled: true
  hosts:
    - host: ecommerce.example.com
      paths:
        - path: /
          pathType: Prefix

通过这些优化措施，我们可以显著提升容器化环境中Spring Boot应用的性能和资源利用率。

周先生：太棒了！cc，你今天的表现非常出色，技术深度和广度都令人印象深刻。我们今天的面试就到这里，我们会尽快给你反馈。