架构评审：构建稳定、高效、可扩展的技术架构（上）

图片来源网络，侵权练习删

前言

在互联网技术飞速发展的今天，架构评审已成为确保系统稳定、高效运行的关键环节。本文将从技术选型、高性能、高可用、可扩展性、可伸缩性、弹性处理、兼容性、安全性、可测性、可运维性以及监控与报警等维度，深入探讨架构评审的要点，并结合示例进行详细说明。

架构评审事项

1. 技术选型：精准决策，奠定基础

技术选型是架构评审的起点，直接关系到系统的性能、成本与可维护性。

在选择组件时，需要考虑其开源协议、开发语言、维护难度及性能表现。
例如，在构建一个高并发的电商系统时，对比了组件A（开源协议为Apache 2.0，基于Java开发）与组件B、C。经过性能压测，发现组件A在高并发场景下表现优异，且由于其开源特性，能够深入理解其内部机制，确保在遇到问题时能够自主维护与优化。

此外，组件A与现有技术栈高度兼容，降低了团队的学习成本与系统的集成难度。因此，最终选择了组件A作为核心组件。

架构示例图

架构示例代码

// 技术选型评估类
public class TechnologyEvaluation {// 组件评估指标public static class ComponentMetrics {private String componentName;private String licenseType;private String programmingLanguage;private double performanceScore;private double maintainabilityScore;private double compatibilityScore;// 计算综合评分public double calculateOverallScore() {return performanceScore * 0.4 + maintainabilityScore * 0.3 + compatibilityScore * 0.3;}}// 组件性能测试public static void performanceTest(ComponentMetrics component, int concurrentUsers, int durationSeconds) {// 模拟性能测试double tps = simulateTPS(component, concurrentUsers, durationSeconds);double avgResponseTime = simulateResponseTime(component, concurrentUsers);System.out.println("组件性能测试结果:");System.out.println("并发用户数: " + concurrentUsers);System.out.println("测试时长: " + durationSeconds + "秒");System.out.println("TPS: " + tps);System.out.println("平均响应时间: " + avgResponseTime + "ms");// 更新性能评分component.performanceScore = calculatePerformanceScore(tps, avgResponseTime);}// 模拟TPS计算private static double simulateTPS(ComponentMetrics component, int concurrentUsers, int durationSeconds) {// 模拟不同组件的性能表现if (component.componentName.equals("组件A")) {return 10000 + (concurrentUsers * 0.5);} else if (component.componentName.equals("组件B")) {return 8000 + (concurrentUsers * 0.4);} else {return 7000 + (concurrentUsers * 0.3);}}// 模拟响应时间计算private static double simulateResponseTime(ComponentMetrics component, int concurrentUsers) {// 模拟不同组件的响应时间if (component.componentName.equals("组件A")) {return 50 + (concurrentUsers * 0.2);} else if (component.componentName.equals("组件B")) {return 70 + (concurrentUsers * 0.3);} else {return 90 + (concurrentUsers * 0.4);}}// 计算性能评分private static double calculatePerformanceScore(double tps, double responseTime) {// TPS越高，响应时间越低，评分越高return Math.min(100, (tps / 100) * (100 - responseTime / 2));}// 主方法 - 演示技术选型评估过程public static void main(String[] args) {// 创建三个组件的评估指标ComponentMetrics componentA = new ComponentMetrics();componentA.componentName = "组件A";componentA.licenseType = "Apache 2.0";componentA.programmingLanguage = "Java";ComponentMetrics componentB = new ComponentMetrics();componentB.componentName = "组件B";componentB.licenseType = "MIT";componentB.programmingLanguage = "Go";ComponentMetrics componentC = new ComponentMetrics();componentC.componentName = "组件C";componentC.licenseType = "GPL";componentC.programmingLanguage = "C++";// 性能测试performanceTest(componentA, 1000, 60);performanceTest(componentB, 1000, 60);performanceTest(componentC, 1000, 60);// 计算综合评分double scoreA = componentA.calculateOverallScore();double scoreB = componentB.calculateOverallScore();double scoreC = componentC.calculateOverallScore();System.out.println("\n综合评分:");System.out.println("组件A: " + String.format("%.2f", scoreA));System.out.println("组件B: " + String.format("%.2f", scoreB));System.out.println("组件C: " + String.format("%.2f", scoreC));// 选择评分最高的组件ComponentMetrics selected = componentA;if (scoreB > scoreA) selected = componentB;if (scoreC > selected.calculateOverallScore()) selected = componentC;System.out.println("\n推荐选择: " + selected.componentName);}
}

2. 高性能：承载流量洪峰，保障用户体验

在电商大促等高并发场景下，系统的TPS（每秒事务处理量）、QPS（每秒查询率）与RT（响应时间）成为关键指标。设计的系统目标TPS为10万，QPS为20万，RT控制在100毫秒以内。

通过分布式缓存、数据库读写分离、异步消息队列等技术手段，成功实现了这一性能目标。然而，随着业务量与数据量的增长，系统性能可能会面临挑战。

为此，建立了性能监控体系，实时监控系统各环节的性能表现。当发现数据库查询成为性能瓶颈时，通过优化数据库索引、增加数据库服务器等措施，有效提升了系统性能。

同时，具备强大的抗突发性能压力能力，能够满足20万TPS与40万QPS的峰值需求，确保在流量洪峰期间，用户依然能够获得流畅的购物体验。

架构示例图

架构示例代码

// 高性能电商系统核心组件
public class HighPerformanceEcommerceSystem {// 缓存服务public static class CacheService {private LoadingCache<String, String> productCache;public CacheService() {// 初始化缓存，设置过期时间为30分钟this.productCache = Caffeine.newBuilder().maximumSize(10_000).expireAfterWrite(30, TimeUnit.MINUTES).build(this::loadProductFromDB);}// 从缓存获取产品信息public String getProduct(String productId) {return productCache.get(productId);}// 模拟从数据库加载产品private String loadProductFromDB(String productId) {// 模拟数据库查询耗时try {Thread.sleep(10);} catch (InterruptedException e) {Thread.currentThread().interrupt();}return "Product-" + productId;}}// 数据库读写分离服务public static class DatabaseService {private DataSource masterDataSource;private DataSource slaveDataSource;public DatabaseService() {// 初始化主从数据源this.masterDataSource = createDataSource("master");this.slaveDataSource = createDataSource("slave");}// 写操作 - 使用主库public void writeOrder(Order order) {try (Connection conn = masterDataSource.getConnection();PreparedStatement stmt = conn.prepareStatement("INSERT INTO orders VALUES (?, ?, ?)")) {stmt.setString(1, order.getId());stmt.setString(2, order.getUserId());stmt.setBigDecimal(3, order.getAmount());stmt.executeUpdate();} catch (SQLException e) {e.printStackTrace();}}// 读操作 - 使用从库public Order readOrder(String orderId) {try (Connection conn = slaveDataSource.getConnection();PreparedStatement stmt = conn.prepareStatement("SELECT * FROM orders WHERE id = ?")) {stmt.setString(1, orderId);ResultSet rs = stmt.executeQuery();if (rs.next()) {return new Order(rs.getString("id"), rs.getString("user_id"), rs.getBigDecimal("amount"));}} catch (SQLException e) {e.printStackTrace();}return null;}private DataSource createDataSource(String type) {// 简化版数据源创建return null; // 实际实现应使用HikariCP等连接池}}// 异步消息队列服务public static class MessageQueueService {private BlockingQueue<Order> orderQueue = new LinkedBlockingQueue<>();// 生产者 - 发送订单到队列public void sendOrder(Order order) {try {orderQueue.put(order);} catch (InterruptedException e) {Thread.currentThread().interrupt();}}// 消费者 - 处理订单public void startConsumer() {new Thread(() -> {while (true) {try {Order order = orderQueue.take();processOrderAsync(order);} catch (InterruptedException e) {Thread.currentThread().interrupt();break;}}}).start();}private void processOrderAsync(Order order) {// 模拟异步处理订单new Thread(() -> {System.out.println("处理订单: " + order.getId());try {Thread.sleep(100); // 模拟处理耗时System.out.println("订单处理完成: " + order.getId());} catch (InterruptedException e) {Thread.currentThread().interrupt();}}).start();}}// 性能监控服务public static class PerformanceMonitor {private Map<String, Long> metrics = new ConcurrentHashMap<>();// 记录请求开始时间public void recordRequestStart(String requestId) {metrics.put(requestId, System.currentTimeMillis());}// 记录请求结束时间并计算响应时间public void recordRequestEnd(String requestId) {Long startTime = metrics.remove(requestId);if (startTime != null) {long responseTime = System.currentTimeMillis() - startTime;System.out.println("请求 " + requestId + " 响应时间: " + responseTime + "ms");// 这里可以添加到监控系统}}// 模拟系统监控public void monitorSystem() {ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);scheduler.scheduleAtFixedRate(() -> {System.out.println("系统监控 - 线程数: " + Thread.activeCount() + ", 内存使用: " + (Runtime.getRuntime().totalMemory() - Runtime.getRuntime().freeMemory()) / 1024 / 1024 + "MB");}, 1, 5, TimeUnit.SECONDS);}}// 订单实体public static class Order {private String id;private String userId;private BigDecimal amount;public Order(String id, String userId, BigDecimal amount) {this.id = id;this.userId = userId;this.amount = amount;}// getter方法public String getId() { return id; }public String getUserId() { return userId; }public BigDecimal getAmount() { return amount; }}// 主方法 - 演示高性能系统public static void main(String[] args) {// 初始化系统组件CacheService cacheService = new CacheService();DatabaseService dbService = new DatabaseService();MessageQueueService mqService = new MessageQueueService();PerformanceMonitor monitor = new PerformanceMonitor();// 启动消息队列消费者mqService.startConsumer();// 启动系统监控monitor.monitorSystem();// 模拟高并发请求ExecutorService executor = Executors.newFixedThreadPool(100);int requestCount = 10000;CountDownLatch latch = new CountDownLatch(requestCount);long startTime = System.currentTimeMillis();for (int i = 0; i < requestCount; i++) {final int requestId = i;executor.submit(() -> {String id = "order-" + requestId;monitor.recordRequestStart(id);// 1. 检查缓存String product = cacheService.getProduct("product-123");// 2. 写入订单Order order = new Order(id, "user-" + requestId, new BigDecimal("100.00"));dbService.writeOrder(order);// 3. 发送到消息队列异步处理mqService.sendOrder(order);monitor.recordRequestEnd(id);latch.countDown();});}try {latch.await();long endTime = System.currentTimeMillis();System.out.println("处理 " + requestCount + " 个请求耗时: " + (endTime - startTime) + "ms");System.out.println("平均TPS: " + (requestCount * 1000.0 / (endTime - startTime)));} catch (InterruptedException e) {Thread.currentThread().interrupt();}executor.shutdown();}
}

3. 高可用：消除单点故障，保障业务连续性

高可用是架构评审的核心目标之一。通过多活架构设计，消除了单点故障风险。
在数据存储层面，采用了分布式存储技术，数据在多个数据中心实时同步，确保在单个数据中心发生故障时，业务能够无缝切换至其他数据中心，数据丢失的风险被降至最低。

针对可能出现的系统宕机情况，制定了详细的应急预案，包括快速故障定位、服务降级与流量切换等措施，将对业务的影响降至最小。

例如，在一次模拟的系统宕机演练中，通过自动化脚本在30秒内完成了服务降级与流量切换，确保了核心业务的持续运行。

架构示例图

架构示例代码

// 高可用系统实现
public class HighAvailabilitySystem {// 数据中心服务public static class DataCenter {private String name;private List<ServiceInstance> services;private boolean isActive;public DataCenter(String name) {this.name = name;this.services = new ArrayList<>();this.isActive = true;}public void addService(ServiceInstance service) {services.add(service);}public boolean isActive() {return isActive;}public void setActive(boolean active) {isActive = active;}public List<ServiceInstance> getServices() {return services;}}// 服务实例public static class ServiceInstance {private String name;private String instanceId;private boolean healthy;public ServiceInstance(String name, String instanceId) {this.name = name;this.instanceId = instanceId;this.healthy = true;}public boolean isHealthy() {return healthy;}public void setHealthy(boolean healthy) {this.healthy = healthy;}}// 负载均衡器public static class LoadBalancer {private List<DataCenter> dataCenters;private Map<String, ServiceInstance> activeServices;public LoadBalancer() {this.dataCenters = new ArrayList<>();this.activeServices = new ConcurrentHashMap<>();}public void addDataCenter(DataCenter dataCenter) {dataCenters.add(dataCenter);}// 获取健康的服务实例public ServiceInstance getService(String serviceName) {// 优先选择活跃数据中心中的健康服务for (DataCenter dc : dataCenters) {if (dc.isActive()) {for (ServiceInstance service : dc.getServices()) {if (service.name.equals(serviceName) && service.isHealthy()) {activeServices.put(service.instanceId, service);return service;}}}}return null;}// 故障转移public void failover(String failedInstanceId) {System.out.println("故障转移: 服务实例 " + failedInstanceId + " 故障");// 标记故障实例ServiceInstance failedService = activeServices.get(failedInstanceId);if (failedService != null) {failedService.setHealthy(false);}// 尝试从其他数据中心获取服务for (DataCenter dc : dataCenters) {if (dc.isActive()) {for (ServiceInstance service : dc.getServices()) {if (service.name.equals(failedService.name) && service.isHealthy()) {System.out.println("故障转移成功: 使用 " + dc.getName() + " 的服务实例 " + service.instanceId);return;}}}}System.out.println("故障转移失败: 没有可用的备用服务");}// 数据中心故障处理public void handleDataCenterFailure(String dataCenterName) {for (DataCenter dc : dataCenters) {if (dc.getName().equals(dataCenterName)) {System.out.println("数据中心 " + dataCenterName + " 故障，标记为非活跃");dc.setActive(false);// 尝试将流量转移到其他数据中心for (ServiceInstance service : dc.getServices()) {failover(service.instanceId);}break;}}}}// 服务健康检查public static class HealthChecker {private LoadBalancer loadBalancer;private ScheduledExecutorService scheduler;public HealthChecker(LoadBalancer loadBalancer) {this.loadBalancer = loadBalancer;this.scheduler = Executors.newScheduledThreadPool(1);}public void start() {// 每10秒执行一次健康检查scheduler.scheduleAtFixedRate(() -> {for (DataCenter dc : loadBalancer.getDataCenters()) {for (ServiceInstance service : dc.getServices()) {// 模拟健康检查boolean isHealthy = checkServiceHealth(service);service.setHealthy(isHealthy);if (!isHealthy) {System.out.println("服务 " + service.instanceId + " 健康检查失败");loadBalancer.failover(service.instanceId);}}}}, 10, 10, TimeUnit.SECONDS);}private boolean checkServiceHealth(ServiceInstance service) {// 模拟健康检查，90%概率健康return Math.random() > 0.1;}}// 主方法 - 演示高可用系统public static void main(String[] args) throws InterruptedException {// 创建负载均衡器LoadBalancer loadBalancer = new LoadBalancer();// 创建三个数据中心DataCenter dc1 = new DataCenter("DC1");DataCenter dc2 = new DataCenter("DC2");DataCenter dc3 = new DataCenter("DC3");// 添加服务实例到各个数据中心for (int i = 1; i <= 3; i++) {dc1.addService(new ServiceInstance("order-service", "order-" + i));dc2.addService(new ServiceInstance("order-service", "order-" + (i + 3)));dc3.addService(new ServiceInstance("order-service", "order-" + (i + 6)));}// 将数据中心添加到负载均衡器loadBalancer.addDataCenter(dc1);loadBalancer.addDataCenter(dc2);loadBalancer.addDataCenter(dc3);// 启动健康检查HealthChecker healthChecker = new HealthChecker(loadBalancer);healthChecker.start();// 模拟请求处理for (int i = 0; i < 20; i++) {ServiceInstance service = loadBalancer.getService("order-service");if (service != null) {System.out.println("请求 " + i + " 由服务实例 " + service.instanceId + " 处理");} else {System.out.println("请求 " + i + " 无法处理，没有可用的服务实例");}Thread.sleep(500);}// 模拟数据中心故障System.out.println("\n模拟数据中心DC1故障...");loadBalancer.handleDataCenterFailure("DC1");// 继续处理请求for (int i = 20; i < 40; i++) {ServiceInstance service = loadBalancer.getService("order-service");if (service != null) {System.out.println("请求 " + i + " 由服务实例 " + service.instanceId + " 处理");} else {System.out.println("请求 " + i + " 无法处理，没有可用的服务实例");}Thread.sleep(500);}// 关闭健康检查healthChecker.getScheduler().shutdown();}
}

4. 可扩展性：适应业务发展，灵活应对变化

随着业务的不断拓展，系统需要具备良好的可扩展性。采用微服务架构，将业务功能模块化，使得各业务模块能够独立扩展。

例如，当订单处理业务量增长时，只需增加订单服务的实例数量即可满足需求，而无需对整个系统进行大规模改造。

此外，还设计了灵活的业务策略配置机制，能够快速适应A、B业务策略，并为未来可能出现的C业务策略预留扩展接口。这种设计不仅降低了系统的耦合度，还提高了系统的适应性与灵活性。

架构示例图

架构示例代码

// 可扩展的微服务系统实现
public class ScalableMicroserviceSystem {// API网关public static class ApiGateway {private Map<String, Microservice> services;private BusinessPolicyEngine policyEngine;public ApiGateway() {this.services = new ConcurrentHashMap<>();this.policyEngine = new BusinessPolicyEngine();}public void registerService(String serviceName, Microservice service) {services.put(serviceName, service);}public void handleRequest(String serviceName, Request request) {Microservice service = services.get(serviceName);if (service != null) {// 应用业务策略Request processedRequest = policyEngine.applyPolicy(request);// 转发请求到服务Response response = service.process(processedRequest);// 应用响应策略return policyEngine.applyResponsePolicy(response);}return new Response("Service not found", 404);}public void addServiceInstance(String serviceName, ServiceInstance instance) {Microservice service = services.get(serviceName);if (service != null) {service.addInstance(instance);}}}// 微服务基类public static abstract class Microservice {private String name;private List<ServiceInstance> instances;private LoadBalancer loadBalancer;public Microservice(String name) {this.name = name;this.instances = new ArrayList<>();this.loadBalancer = new LoadBalancer();}public void addInstance(ServiceInstance instance) {instances.add(instance);loadBalancer.addInstance(instance);}public abstract Response process(Request request);public String getName() {return name;}public List<ServiceInstance> getInstances() {return instances;}}// 订单服务public static class OrderService extends Microservice {public OrderService() {super("OrderService");}@Overridepublic Response process(Request request) {ServiceInstance instance = loadBalancer.selectInstance();System.out.println("订单请求由 " + instance.getInstanceId() + " 处理");// 模拟订单处理String orderId = "order-" + System.currentTimeMillis();return new Response("Order created: " + orderId, 200);}}// 支付服务public static class PaymentService extends Microservice {public PaymentService() {super("PaymentService");}@Overridepublic Response process(Request request) {ServiceInstance instance = loadBalancer.selectInstance();System.out.println("支付请求由 " + instance.getInstanceId() + " 处理");// 模拟支付处理return new Response("Payment processed successfully", 200);}}// 用户服务public static class UserService extends Microservice {public UserService() {super("UserService");}@Overridepublic Response process(Request request) {ServiceInstance instance = loadBalancer.selectInstance();System.out.println("用户请求由 " + instance.getInstanceId() + " 处理");// 模拟用户处理return new Response("User information retrieved", 200);}}// 商品服务public static class ProductService extends Microservice {public ProductService() {super("ProductService");}@Overridepublic Response process(Request request) {ServiceInstance instance = loadBalancer.selectInstance();System.out.println("商品请求由 " + instance.getInstanceId() + " 处理");// 模拟商品处理return new Response("Product information retrieved", 200);}}// 服务实例public static class ServiceInstance {private String instanceId;private boolean healthy;public ServiceInstance(String instanceId) {this.instanceId = instanceId;this.healthy = true;}public String getInstanceId() {return instanceId;}public boolean isHealthy() {return healthy;}public void setHealthy(boolean healthy) {this.healthy = healthy;}}// 负载均衡器public static class LoadBalancer {private List<ServiceInstance> instances;public LoadBalancer() {this.instances = new ArrayList<>();}public void addInstance(ServiceInstance instance) {instances.add(instance);}public ServiceInstance selectInstance() {// 简单的轮询负载均衡List<ServiceInstance> healthyInstances = instances.stream().filter(ServiceInstance::isHealthy).collect(Collectors.toList());if (healthyInstances.isEmpty()) {throw new RuntimeException("No healthy instances available");}int index = (int) (System.currentTimeMillis() % healthyInstances.size());return healthyInstances.get(index);}}// 业务策略引擎public static class BusinessPolicyEngine {private Map<String, BusinessPolicy> policies;public BusinessPolicyEngine() {this.policies = new ConcurrentHashMap<>();// 初始化默认策略policies.put("policyA", new PolicyA());policies.put("policyB", new PolicyB());// 预留策略C的接口policies.put("policyC", new PolicyC());}public Request applyPolicy(Request request) {// 根据请求类型应用相应策略String policyType = request.getPolicyType();BusinessPolicy policy = policies.get(policyType);if (policy != null) {return policy.apply(request);}return request;}public Response applyResponsePolicy(Response response) {// 可以在这里添加响应处理策略return response;}public void addPolicy(String name, BusinessPolicy policy) {policies.put(name, policy);}}// 业务策略接口public interface BusinessPolicy {Request apply(Request request);}// 策略A实现public static class PolicyA implements BusinessPolicy {@Overridepublic Request apply(Request request) {System.out.println("应用策略A");// 添加策略A特有的处理逻辑request.addMetadata("policyApplied", "A");return request;}}// 策略B实现public static class PolicyB implements BusinessPolicy {@Overridepublic Request apply(Request request) {System.out.println("应用策略B");// 添加策略B特有的处理逻辑request.addMetadata("policyApplied", "B");return request;}}// 策略C实现（预留）public static class PolicyC implements BusinessPolicy {@Overridepublic Request apply(Request request) {System.out.println("应用策略C（预留）");// 预留策略C的处理逻辑request.addMetadata("policyApplied", "C");return request;}}// 请求对象public static class Request {private String id;private String type;private String policyType;private Map<String, Object> metadata;public Request(String id, String type, String policyType) {this.id = id;this.type = type;this.policyType = policyType;this.metadata = new HashMap<>();}public String getId() { return id; }public String getType() { return type; }public String getPolicyType() { return policyType; }public void addMetadata(String key, Object value) {metadata.put(key, value);}public Object getMetadata(String key) {return metadata.get(key);}}// 响应对象public static class Response {private String message;private int statusCode;public Response(String message, int statusCode) {this.message = message;this.statusCode = statusCode;}public String getMessage() { return message; }public int getStatusCode() { return statusCode; }}// 主方法 - 演示可扩展系统public static void main(String[] args) {// 创建API网关ApiGateway apiGateway = new ApiGateway();// 创建并注册微服务OrderService orderService = new OrderService();PaymentService paymentService = new PaymentService();UserService userService = new UserService();ProductService productService = new ProductService();apiGateway.registerService("order", orderService);apiGateway.registerService("payment", paymentService);apiGateway.registerService("user", userService);apiGateway.registerService("product", productService);// 添加服务实例for (int i = 1; i <= 3; i++) {apiGateway.addServiceInstance("order", new ServiceInstance("order-instance-" + i));}for (int i = 1; i <= 2; i++) {apiGateway.addServiceInstance("payment", new ServiceInstance("payment-instance-" + i));}apiGateway.addServiceInstance("user", new ServiceInstance("user-instance-1"));apiGateway.addServiceInstance("product", new ServiceInstance("product-instance-1"));// 模拟请求处理System.out.println("初始状态 - 订单服务有3个实例，支付服务有2个实例");for (int i = 0; i < 5; i++) {Request request = new Request("req-" + i, "order", "policyA");Response response = apiGateway.handleRequest("order", request);System.out.println("响应: " + response.getMessage());}// 模拟订单服务扩容System.out.println("\n订单服务扩容 - 添加2个新实例");for (int i = 4; i <= 5; i++) {apiGateway.addServiceInstance("order", new ServiceInstance("order-instance-" + i));}// 继续处理请求for (int i = 5; i < 10; i++) {Request request = new Request("req-" + i, "order", "policyB");Response response = apiGateway.handleRequest("order", request);System.out.println("响应: " + response.getMessage());}// 测试策略扩展System.out.println("\n测试策略扩展 - 使用预留策略C");Request request = new Request("req-10", "payment", "policyC");Response response = apiGateway.handleRequest("payment", request);System.out.println("响应: " + response.getMessage());}
}

5. 可伸缩性：灵活扩展，提升响应速度

可伸缩性关注系统在面对业务量波动时的快速响应能力。

确保每个服务环节均为无状态设计，便于快速横向扩展。在扩容过程中，采用了自动化脚本，实现了服务实例的快速部署与配置。

例如，当检测到系统负载超过80%时，自动化脚本会在5分钟内完成新实例的部署与上线，使系统能够迅速应对业务量的激增。

扩容后，系统响应速度得到了显著提升，用户请求的平均响应时间从200毫秒降至150毫秒，有效改善了用户体验。

架构示例图

架构示例代码

// 可伸缩系统实现
public class ScalableSystem {// 服务实例public static class ServiceInstance {private String id;private double currentLoad;private boolean healthy;public ServiceInstance(String id) {this.id = id;this.currentLoad = 0;this.healthy = true;}public String getId() {return id;}public double getCurrentLoad() {return currentLoad;}public void setCurrentLoad(double load) {this.currentLoad = load;}public boolean isHealthy() {return healthy;}public void setHealthy(boolean healthy) {this.healthy = healthy;}public void processRequest() {// 模拟处理请求try {Thread.sleep(50); // 模拟处理耗时currentLoad += 10; // 增加负载} catch (InterruptedException e) {Thread.currentThread().interrupt();}}}// 服务集群public static class ServiceCluster {private String serviceName;private List<ServiceInstance> instances;private int maxInstances;private int minInstances;public ServiceCluster(String serviceName, int minInstances, int maxInstances) {this.serviceName = serviceName;this.instances = new ArrayList<>();this.minInstances = minInstances;this.maxInstances = maxInstances;}public void addInstance(ServiceInstance instance) {instances.add(instance);}public void removeInstance(ServiceInstance instance) {instances.remove(instance);}public List<ServiceInstance> getInstances() {return instances;}public double getAverageLoad() {if (instances.isEmpty()) return 0;double totalLoad = 0;int healthyCount = 0;for (ServiceInstance instance : instances) {if (instance.isHealthy()) {totalLoad += instance.getCurrentLoad();healthyCount++;}}return healthyCount > 0 ? totalLoad / healthyCount : 0;}public boolean shouldScaleUp() {return getAverageLoad() > 80 && instances.size() < maxInstances;}public boolean shouldScaleDown() {return getAverageLoad() < 30 && instances.size() > minInstances;}public ServiceInstance selectInstance() {// 选择负载最低的健康实例return instances.stream().filter(ServiceInstance::isHealthy).min(Comparator.comparingDouble(ServiceInstance::getCurrentLoad)).orElse(null);}}// 监控系统public static class MonitoringSystem {private Map<String, ServiceCluster> clusters;private AutoScaler autoScaler;public MonitoringSystem() {this.clusters = new ConcurrentHashMap<>();this.autoScaler = new AutoScaler(this);}public void registerCluster(String serviceName, ServiceCluster cluster) {clusters.put(serviceName, cluster);}public void monitor() {// 模拟监控过程for (Map.Entry<String, ServiceCluster> entry : clusters.entrySet()) {ServiceCluster cluster = entry.getValue();double avgLoad = cluster.getAverageLoad();System.out.println("服务 " + entry.getKey() + " 平均负载: " + avgLoad + "%");if (avgLoad > 80) {System.out.println("警告: 服务 " + entry.getKey() + " 负载过高，需要扩容");} else if (avgLoad < 30) {System.out.println("提示: 服务 " + entry.getKey() + " 负载较低，可以考虑缩容");}}}public void startAutoScaling() {// 每30秒执行一次自动扩缩容检查ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);scheduler.scheduleAtFixedRate(() -> {monitor();autoScaler.checkScaling();}, 5, 30, TimeUnit.SECONDS);}}// 自动扩缩容器public static class AutoScaler {private MonitoringSystem monitoringSystem;private DeploymentSystem deploymentSystem;public AutoScaler(MonitoringSystem monitoringSystem) {this.monitoringSystem = monitoringSystem;this.deploymentSystem = new DeploymentSystem();}public void checkScaling() {for (Map.Entry<String, ServiceCluster> entry : monitoringSystem.getClusters().entrySet()) {ServiceCluster cluster = entry.getValue();if (cluster.shouldScaleUp()) {scaleUp(cluster);} else if (cluster.shouldScaleDown()) {scaleDown(cluster);}}}private void scaleUp(ServiceCluster cluster) {System.out.println("自动扩容: 服务 " + cluster.getServiceName());deploymentSystem.deployNewInstance(cluster);}private void scaleDown(ServiceCluster cluster) {System.out.println("自动缩容: 服务 " + cluster.getServiceName());deploymentSystem.removeInstance(cluster);}}// 部署系统public static class DeploymentSystem {private int instanceCounter = 0;public void deployNewInstance(ServiceCluster cluster) {// 模拟部署新实例String instanceId = cluster.getServiceName() + "-instance-" + (++instanceCounter);System.out.println("部署新实例: " + instanceId);ServiceInstance newInstance = new ServiceInstance(instanceId);cluster.addInstance(newInstance);// 模拟配置过程configureInstance(newInstance);// 模拟启动过程startInstance(newInstance);System.out.println("新实例 " + instanceId + " 部署完成");}public void removeInstance(ServiceCluster cluster) {// 选择负载最高的实例进行移除Optional<ServiceInstance> instanceToRemove = cluster.getInstances().stream().max(Comparator.comparingDouble(ServiceInstance::getCurrentLoad));if (instanceToRemove.isPresent()) {ServiceInstance instance = instanceToRemove.get();System.out.println("移除实例: " + instance.getId());// 模拟停止实例stopInstance(instance);// 从集群中移除cluster.removeInstance(instance);System.out.println("实例 " + instance.getId() + " 已移除");}}private void configureInstance(ServiceInstance instance) {System.out.println("配置实例: " + instance.getId());// 模拟配置过程try {Thread.sleep(1000); // 模拟配置耗时} catch (InterruptedException e) {Thread.currentThread().interrupt();}}private void startInstance(ServiceInstance instance) {System.out.println("启动实例: " + instance.getId());// 模拟启动过程try {Thread.sleep(2000); // 模拟启动耗时} catch (InterruptedException e) {Thread.currentThread().interrupt();}}private void stopInstance(ServiceInstance instance) {System.out.println("停止实例: " + instance.getId());// 模拟停止过程try {Thread.sleep(500); // 模拟停止耗时} catch (InterruptedException e) {Thread.currentThread().interrupt();}}}// 负载生成器public static class LoadGenerator {private MonitoringSystem monitoringSystem;public LoadGenerator(MonitoringSystem monitoringSystem) {this.monitoringSystem = monitoringSystem;}public void generateLoad(String serviceName, int requestCount) {ServiceCluster cluster = monitoringSystem.getClusters().get(serviceName);if (cluster == null) {System.out.println("服务 " + serviceName + " 不存在");return;}ExecutorService executor = Executors.newFixedThreadPool(10);CountDownLatch latch = new CountDownLatch(requestCount);long startTime = System.currentTimeMillis();for (int i = 0; i < requestCount; i++) {executor.submit(() -> {ServiceInstance instance = cluster.selectInstance();if (instance != null) {instance.processRequest();}latch.countDown();});}try {latch.await();long endTime = System.currentTimeMillis();double avgResponseTime = (endTime - startTime) / (double) requestCount;System.out.println("处理 " + requestCount + " 个请求，平均响应时间: " + avgResponseTime + "ms");} catch (InterruptedException e) {Thread.currentThread().interrupt();}executor.shutdown();}}// 主方法 - 演示可伸缩系统public static void main(String[] args) throws InterruptedException {// 创建监控系统MonitoringSystem monitoringSystem = new MonitoringSystem();// 创建服务集群ServiceCluster orderCluster = new ServiceCluster("order-service", 2, 8);ServiceCluster paymentCluster = new ServiceCluster("payment-service", 1, 5);// 注册集群monitoringSystem.registerCluster("order-service", orderCluster);monitoringSystem.registerCluster("payment-service", paymentCluster);// 初始化服务实例for (int i = 1; i <= 3; i++) {orderCluster.addInstance(new ServiceInstance("order-instance-" + i));}for (int i = 1; i <= 2; i++) {paymentCluster.addInstance(new ServiceInstance("payment-instance-" + i));}// 创建负载生成器LoadGenerator loadGenerator = new LoadGenerator(monitoringSystem);// 启动自动扩缩容monitoringSystem.startAutoScaling();// 模拟初始负载System.out.println("=== 初始负载测试 ===");loadGenerator.generateLoad("order-service", 50);// 模拟高负载System.out.println("\n=== 高负载测试 ===");loadGenerator.generateLoad("order-service", 200);// 等待自动扩容完成Thread.sleep(10000);// 再次测试性能System.out.println("\n=== 扩容后性能测试 ===");loadGenerator.generateLoad("order-service", 200);// 模拟低负载System.out.println("\n=== 低负载测试 ===");for (ServiceInstance instance : orderCluster.getInstances()) {instance.setCurrentLoad(10); // 设置低负载}// 等待自动缩容Thread.sleep(10000);// 检查最终实例数量System.out.println("\n=== 最终状态 ===");System.out.println("订单服务实例数量: " + orderCluster.getInstances().size());System.out.println("支付服务实例数量: " + paymentCluster.getInstances().size());}
}

---

相关文章
架构评审：构建稳定、高效、可扩展的技术架构（下）