Java技术生态全景图：从JVM到微服务的完整技术栈深度解析

// 典型的生产环境JVM参数配置
-Xms4g -Xmx4g                    // 堆内存4G，初始=最大避免动态扩容
-XX:+UseG1GC                     // 使用G1垃圾回收器
-XX:MaxGCPauseMillis=200         // 最大GC停顿200ms
-XX:+HeapDumpOnOutOfMemoryError  // OOM时自动dump堆快照
-XX:HeapDumpPath=/tmp/heapdump.hprof
-XX:+PrintGCDetails              // 打印GC详细日志

// ❌ 错误：使用Executors工具类（可能OOM）
ExecutorService executor = Executors.newFixedThreadPool(10);

// ✅ 正确：手动创建线程池，明确参数
ThreadPoolExecutor executor = new ThreadPoolExecutor(
    10,                       // 核心线程数
    20,                       // 最大线程数
    60L, TimeUnit.SECONDS,    // 空闲线程存活时间
    new LinkedBlockingQueue<>(1000),  // 任务队列
    new ThreadFactoryBuilder()
        .setNameFormat("order-pool-%d")
        .build(),
    new ThreadPoolExecutor.CallerRunsPolicy()  // 拒绝策略
);

// Spring Boot自动配置三大核心注解
@SpringBootApplication
  ├── @SpringBootConfiguration   // 配置类
  ├── @EnableAutoConfiguration   // 自动配置
  │     └── @Import(AutoConfigurationImportSelector.class)
  │           └── 读取 META-INF/spring.factories
  └── @ComponentScan             // 组件扫描

// 自定义Starter的AutoConfiguration示例
@Configuration
@ConditionalOnClass(RedisTemplate.class)  // 条件装配
@EnableConfigurationProperties(RedisProperties.class)
public class RedisAutoConfiguration {
    @Bean
    @ConditionalOnMissingBean
    public RedisTemplate<String, Object> redisTemplate() {
        // ...配置代码
    }
}

-- ✅ 正确：联合索引遵循最左前缀原则
CREATE INDEX idx_user_age_city ON user(age, city);

-- 以下查询可以使用索引
SELECT * FROM user WHERE age = 25 AND city = '北京';  -- 全匹配
SELECT * FROM user WHERE age = 25;                    -- 最左匹配

-- 以下查询无法使用索引
SELECT * FROM user WHERE city = '北京';               -- 跳过age

-- ✅ 正确：覆盖索引减少回表
CREATE INDEX idx_user_name_age ON user(name, age);
SELECT name, age FROM user WHERE name = '张三';       -- 索引覆盖

-- ❌ 错误：索引失效场景
SELECT * FROM user WHERE age + 1 = 26;                -- 索引列运算
SELECT * FROM user WHERE name LIKE '%张三%';          -- 前导模糊
SELECT * FROM user WHERE type != 1;                   -- !=操作符

// 基于Redisson实现分布式锁
@Autowired
private RedissonClient redissonClient;

public void deductStock(String productId) {
    String lockKey = "product:lock:" + productId;
    RLock lock = redissonClient.getLock(lockKey);

    try {
        // 尝试加锁，最多等待10秒，锁30秒自动释放
        boolean isLocked = lock.tryLock(10, 30, TimeUnit.SECONDS);
        if (isLocked) {
            // 业务逻辑：扣减库存
            int stock = getStock(productId);
            if (stock > 0) {
                updateStock(productId, stock - 1);
            }
        }
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
    } finally {
        // 释放锁（只能释放自己持有的锁）
        if (lock.isHeldByCurrentThread()) {
            lock.unlock();
        }
    }
}

// 商品搜索：支持分词、高亮、聚合
GET /products/_search
{
  "query": {
    "bool": {
      "must": [
        { "match": { "title": "华为手机" } }
      ],
      "filter": [
        { "range": { "price": { "gte": 2000, "lte": 5000 } } },
        { "term": { "brand": "华为" } }
      ]
    }
  },
  "highlight": {
    "fields": { "title": {} }
  },
  "aggs": {
    "price_ranges": {
      "range": {
        "field": "price",
        "ranges": [
          { "to": 2000 },
          { "from": 2000, "to": 5000 },
          { "from": 5000 }
        ]
      }
    }
  },
  "sort": [
    { "sales": "desc" },
    { "_score": "desc" }
  ]
}

// 1. 生产者确认（Publisher Confirms）
rabbitTemplate.setConfirmCallback((correlationData, ack, cause) -> {
    if (ack) {
        log.info("消息发送成功");
    } else {
        log.error("消息发送失败：{}", cause);
        // 重试或记录到数据库
    }
});

// 2. 消息持久化
@Bean
public Queue orderQueue() {
    return QueueBuilder.durable("order.queue")  // 队列持久化
            .build();
}

// 发送持久化消息
rabbitTemplate.convertAndSend(exchange, routingKey, message, msg -> {
    msg.getMessageProperties().setDeliveryMode(MessageDeliveryMode.PERSISTENT);
    return msg;
});

// 3. 消费者手动确认
@RabbitListener(queues = "order.queue", ackMode = "MANUAL")
public void handleOrder(Message message, Channel channel) throws IOException {
    try {
        // 业务处理
        processOrder(message);

        // 手动ACK
        channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
    } catch (Exception e) {
        // 业务失败，重新入队或拒绝
        channel.basicNack(message.getMessageProperties().getDeliveryTag(), false, true);
    }
}

// application.yml配置
spring:
  cloud:
    nacos:
      discovery:
        server-addr: 127.0.0.1:8848
        namespace: prod
        group: DEFAULT_GROUP

// 服务提供者
@RestController
@RequestMapping("/order")
public class OrderController {
    @GetMapping("/{id}")
    public Order getOrder(@PathVariable Long id) {
        return orderService.getById(id);
    }
}

// 服务消费者：OpenFeign声明式调用
@FeignClient(name = "order-service", fallback = OrderServiceFallback.class)
public interface OrderServiceClient {
    @GetMapping("/order/{id}")
    Order getOrder(@PathVariable Long id);
}

// 定义流控规则
@PostConstruct
public void initFlowRules() {
    List<FlowRule> rules = new ArrayList<>();
    FlowRule rule = new FlowRule();
    rule.setResource("orderService");
    rule.setGrade(RuleConstant.FLOW_GRADE_QPS);
    rule.setCount(100);  // QPS阈值100
    rules.add(rule);
    FlowRuleManager.loadRules(rules);
}

// 使用@SentinelResource注解
@Service
public class OrderService {
    @SentinelResource(
        value = "createOrder",
        blockHandler = "handleBlock",   // 限流处理
        fallback = "handleFallback"     // 异常降级
    )
    public Order createOrder(OrderDTO dto) {
        // 业务逻辑
        return order;
    }

    // 限流处理方法
    public Order handleBlock(OrderDTO dto, BlockException ex) {
        return new Order("系统繁忙，请稍后再试");
    }

    // 降级处理方法
    public Order handleFallback(OrderDTO dto, Throwable ex) {
        return new Order("服务异常，已降级处理");
    }
}

# 1. 查看JVM参数
java -XX:+PrintFlagsFinal -version | grep -i gc

# 2. 查看堆内存使用
jmap -heap <pid>

# 3. dump堆快照
jmap -dump:live,format=b,file=heapdump.hprof <pid>

# 4. 查看GC日志
jstat -gcutil <pid> 1000  # 每1秒打印一次

# 5. 线程分析
jstack <pid> > thread.txt

# 6. 在线诊断工具
# Arthas：阿里开源的Java诊断工具
java -jar arthas-boot.jar

-- ❌ 慢SQL：全表扫描
SELECT * FROM order WHERE DATE(create_time) = '2025-10-21';

-- ✅ 优化：避免函数导致索引失效
SELECT * FROM order
WHERE create_time >= '2025-10-21 00:00:00'
  AND create_time < '2025-10-22 00:00:00';

-- ❌ 慢SQL：子查询
SELECT * FROM order WHERE user_id IN (
    SELECT id FROM user WHERE city = '北京'
);

-- ✅ 优化：JOIN替代子查询
SELECT o.* FROM order o
INNER JOIN user u ON o.user_id = u.id
WHERE u.city = '北京';

// 方案1：Cache Aside（旁路缓存）
public Order getOrder(Long id) {
    // 1. 先查缓存
    Order order = redisTemplate.opsForValue().get("order:" + id);
    if (order != null) {
        return order;
    }

    // 2. 缓存未命中，查数据库
    order = orderMapper.selectById(id);

    // 3. 写入缓存
    if (order != null) {
        redisTemplate.opsForValue().set("order:" + id, order, 300, TimeUnit.SECONDS);
    }
    return order;
}

// 更新数据：先更新数据库，再删除缓存
@Transactional
public void updateOrder(Order order) {
    // 1. 更新数据库
    orderMapper.updateById(order);

    // 2. 删除缓存（延迟双删）
    redisTemplate.delete("order:" + order.getId());

    // 3. 延迟500ms再删一次（防止脏数据）
    CompletableFuture.runAsync(() -> {
        try {
            Thread.sleep(500);
            redisTemplate.delete("order:" + order.getId());
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    });
}