Java 面试微服务架构与云原生技术实操重点及常见问题解析 Java 面试

原创

啦啦啦191

修改于 2025-07-21 14:02:50

1830

文章被收录于专栏：Java开发Java开发

以下是结合最新技术的Java面试实操内容，包含技术方案说明和代码示例，帮助你应对BAT等大厂面试：

一、微服务架构与云原生技术

1. Spring Cloud Alibaba 实战

技术点：服务注册与发现(Nacos)、配置中心(Nacos)、负载均衡(Ribbon)、服务熔断(Sentinel)、网关(Spring Cloud Gateway)

应用场景：构建高可用、可扩展的分布式系统

实操步骤：

搭建Nacos服务注册中心

# 下载Nacos Server
wget https://github.com/alibaba/nacos/releases/download/2.2.0/nacos-server-2.2.0.zip
unzip nacos-server-2.2.0.zip
cd nacos/bin
# 启动Nacos (单机模式)
sh startup.sh -m standalone

创建微服务模块

// pom.xml 添加依赖
<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-gateway</artifactId>
</dependency>
<dependency>
    <groupId>com.alibaba.csp</groupId>
    <artifactId>sentinel-spring-cloud-gateway-adapter</artifactId>
</dependency>

// 启动类添加注解
@SpringBootApplication
@EnableDiscoveryClient
public class OrderServiceApplication {
    public static void main(String[] args) {
        SpringApplication.run(OrderServiceApplication.class, args);
    }
}

// application.yml 配置
spring:
  cloud:
    nacos:
      discovery:
        server-addr: localhost:8848  # Nacos服务地址
  application:
    name: order-service  # 服务名称

集成Sentinel实现服务熔断

// 添加Sentinel依赖
<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>
</dependency>

// 配置熔断规则
@Configuration
public class SentinelConfig {
    @PostConstruct
    public void initRules() {
        List<FlowRule> rules = new ArrayList<>();
        FlowRule rule = new FlowRule();
        rule.setResource("orderService");  // 资源名称
        rule.setGrade(RuleConstant.FLOW_GRADE_QPS);  // QPS限流
        rule.setCount(10);  // 阈值10次/秒
        rules.add(rule);
        FlowRuleManager.loadRules(rules);
    }
}

二、响应式编程与WebFlux

1. Reactor模式与Flux/Mono应用

技术点：非阻塞IO、背压机制、异步数据流处理

应用场景：高并发、低延迟的API服务

实操代码：

// 添加WebFlux依赖
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-webflux</artifactId>
</dependency>

// 创建响应式Controller
@RestController
@RequestMapping("/api/products")
public class ProductController {
    private final ProductService productService;

    public ProductController(ProductService productService) {
        this.productService = productService;
    }

    // 返回Flux流处理多个结果
    @GetMapping
    public Flux<Product> getAllProducts() {
        return productService.getAllProducts();
    }

    // 返回Mono处理单个结果
    @GetMapping("/{id}")
    public Mono<ResponseEntity<Product>> getProductById(@PathVariable String id) {
        return productService.getProductById(id)
            .map(product -> ResponseEntity.ok(product))
            .defaultIfEmpty(ResponseEntity.notFound().build());
    }
}

// 响应式Service实现
@Service
public class ProductServiceImpl implements ProductService {
    private final ReactiveMongoRepository<Product, String> repository;

    @Override
    public Flux<Product> getAllProducts() {
        return repository.findAll();
    }

    @Override
    public Mono<Product> getProductById(String id) {
        return repository.findById(id);
    }
}

三、容器化与Kubernetes

1. Docker镜像构建与发布

技术点：Dockerfile编写、多阶段构建、镜像优化

实操步骤：

# Dockerfile 示例 (多阶段构建)
# 构建阶段
FROM maven:3.8.4-openjdk-17 AS builder
WORKDIR /app
COPY pom.xml .
COPY src ./src
RUN mvn clean package -DskipTests

# 运行阶段
FROM openjdk:17-jdk-slim
WORKDIR /app
COPY --from=builder /app/target/my-app.jar .
EXPOSE 8080
CMD ["java", "-jar", "my-app.jar"]

# 构建镜像
docker build -t my-app:1.0.0 .

# 推送至Docker Hub
docker login
docker tag my-app:1.0.0 yourusername/my-app:1.0.0
docker push yourusername/my-app:1.0.0

2. Kubernetes部署微服务

技术点：Deployment、Service、Ingress

# deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: order-service
spec:
  replicas: 3
  selector:
    matchLabels:
      app: order-service
  template:
    metadata:
      labels:
        app: order-service
    spec:
      containers:
      - name: order-service
        image: yourusername/order-service:1.0.0
        ports:
        - containerPort: 8080
        env:
        - name: SPRING_PROFILES_ACTIVE
          value: prod

# service.yaml
apiVersion: v1
kind: Service
metadata:
  name: order-service
spec:
  type: ClusterIP
  selector:
    app: order-service
  ports:
    - protocol: TCP
      port: 80
      targetPort: 8080

四、函数式编程与Stream API

1. Java 8+ Stream实战

技术点：中间操作、终端操作、并行流

应用场景：数据处理、集合转换

代码示例：

public class StreamExample {
    public static void main(String[] args) {
        List<Product> products = Arrays.asList(
            new Product(1, "iPhone", 999.99, "Electronics"),
            new Product(2, "MacBook", 1999.99, "Electronics"),
            new Product(3, "Book", 29.99, "Books"),
            new Product(4, "Headphones", 199.99, "Electronics")
        );

        // 计算电子产品总价 (串行流)
        double totalElectronicsPrice = products.stream()
            .filter(p -> "Electronics".equals(p.getCategory()))
            .mapToDouble(Product::getPrice)
            .sum();

        // 查找价格最高的商品 (并行流)
        Optional<Product> mostExpensiveProduct = products.parallelStream()
            .max(Comparator.comparingDouble(Product::getPrice));

        // 分组统计各类商品数量
        Map<String, Long> categoryCount = products.stream()
            .collect(Collectors.groupingBy(Product::getCategory, Collectors.counting()));
    }
}

五、高性能缓存设计

1. Caffeine本地缓存与Redis分布式缓存结合

技术点：多级缓存、缓存失效策略、缓存穿透解决方案

// 添加依赖
<dependency>
    <groupId>com.github.ben-manes.caffeine</groupId>
    <artifactId>caffeine</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

// 缓存配置类
@Configuration
public class CacheConfig {
    @Bean
    public CacheManager cacheManager(RedisConnectionFactory redisConnectionFactory) {
        // 配置Caffeine一级缓存
        Caffeine<Object, Object> caffeineCache = Caffeine.newBuilder()
            .initialCapacity(100)
            .maximumSize(1000)
            .expireAfterWrite(10, TimeUnit.MINUTES);

        // 配置Redis二级缓存
        RedisCacheConfiguration redisCacheConfig = RedisCacheConfiguration.defaultCacheConfig()
            .entryTtl(Duration.ofHours(1))
            .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(new StringRedisSerializer()))
            .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(new GenericJackson2JsonRedisSerializer()));

        // 多级缓存管理器
        return new CaffeineRedisCacheManager(caffeineCache, redisCacheConfig, redisConnectionFactory);
    }
}

// 缓存使用示例
@Service
public class ProductServiceImpl implements ProductService {
    @Autowired
    private CacheManager cacheManager;

    @Override
    public Product getProductById(String id) {
        // 先查一级缓存
        Cache caffeineCache = cacheManager.getCache("caffeineCache");
        Product product = caffeineCache.get(id, Product.class);
        
        if (product == null) {
            // 查二级缓存
            Cache redisCache = cacheManager.getCache("redisCache");
            product = redisCache.get(id, Product.class);
            
            if (product == null) {
                // 查数据库
                product = productRepository.findById(id).orElse(null);
                if (product != null) {
                    redisCache.put(id, product);
                }
            }
            caffeineCache.put(id, product);
        }
        return product;
    }
}

六、高性能数据库设计

1. 分库分表ShardingSphere实战

技术点：水平分库分表、读写分离、分布式事务

# application.yml 配置
spring:
  shardingsphere:
    datasource:
      names: master,slave
      master:
        type: com.zaxxer.hikari.HikariDataSource
        driver-class-name: com.mysql.cj.jdbc.Driver
        jdbc-url: jdbc:mysql://localhost:3306/master_db
        username: root
        password: 123456
      slave:
        type: com.zaxxer.hikari.HikariDataSource
        driver-class-name: com.mysql.cj.jdbc.Driver
        jdbc-url: jdbc:mysql://localhost:3307/slave_db
        username: root
        password: 123456
    rules:
      # 读写分离配置
      readwrite-splitting:
        data-sources:
          rw-ds:
            write-data-source-name: master
            read-data-source-names: slave
      # 分表配置
      sharding:
        tables:
          order:
            actual-data-nodes: rw-ds.order_$->{0..1}
            table-strategy:
              standard:
                sharding-column: order_id
                sharding-algorithm-name: order-inline
        sharding-algorithms:
          order-inline:
            type: INLINE
            props:
              algorithm-expression: order_$->{order_id % 2}

七、分布式链路追踪

1. 集成Skywalking实现全链路监控

技术点：APM、服务间调用追踪、性能分析

实操步骤：

下载并启动Skywalking

wget https://dlcdn.apache.org/skywalking/9.4.0/apache-skywalking-apm-9.4.0.tar.gz
tar -zxvf apache-skywalking-apm-9.4.0.tar.gz
cd apache-skywalking-apm-bin/bin
# 启动OAP服务器
sh startup.sh

Java应用配置

# 启动参数添加Agent
java -javaagent:/path/to/skywalking-agent/skywalking-agent.jar 
     -Dskywalking.agent.service_name=order-service 
     -Dskywalking.collector.backend_service=localhost:11800 
     -jar your-application.jar

查看监控界面 访问 http://localhost:8080 查看服务调用拓扑图和性能指标

八、测试与DevOps

1. JUnit 5与Mockito单元测试

技术点：参数化测试、行为验证、BDD风格

// 添加依赖
<dependency>
    <groupId>org.junit.jupiter</groupId>
    <artifactId>junit-jupiter-engine</artifactId>
    <scope>test</scope>
</dependency>
<dependency>
    <groupId>org.mockito</groupId>
    <artifactId>mockito-core</artifactId>
    <scope>test</scope>
</dependency>

// 单元测试示例
@ExtendWith(MockitoExtension.class)
class OrderServiceTest {
    @Mock
    private OrderRepository orderRepository;

    @InjectMocks
    private OrderServiceImpl orderService;

    @Test
    @DisplayName("创建订单成功")
    void testCreateOrder() {
        // 准备测试数据
        Order order = new Order("1", "USER001", 100.0);
        when(orderRepository.save(any(Order.class))).thenReturn(order);

        // 执行测试
        Order result = orderService.createOrder(order);

        // 验证结果
        assertNotNull(result);
        assertEquals("1", result.getId());
        verify(orderRepository, times(1)).save(order);
    }

    @ParameterizedTest
    @ValueSource(doubles = {100.0, 200.0, 500.0})
    void testCalculateTotalPrice(double amount) {
        // 测试不同金额的计算逻辑
        Order order = new Order("1", "USER001", amount);
        double total = orderService.calculateTotalPrice(order);
        assertEquals(amount * 1.05, total, 0.001); // 包含5%税费
    }
}