px65cmfyj
/
789
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Compare commits

base: px65cmfyj:master
Branches Tags
px65cmfyj:master
px65cmfyj:main
..
compare: px65cmfyj:main
Branches Tags
px65cmfyj:master
px65cmfyj:main

No commits in common. 'master' and 'main' have entirely different histories.
master ... main

10 changed files with 2 additions and 2027 deletions
Show Stats

167
AdvancedExample/AdvancedExampleTest.java
Unescape View File

@ -1,167 +0,0 @@
/**
* 进阶题测试类
* 测试动态配置管理系统和边车模式功能
*/
import java.util.HashMap;
import java.util.Map;
public class AdvancedExampleTest {
// 辅助方法：重复字符
private static String repeatChar(char c, int count) {
StringBuilder sb = new StringBuilder(count);
for (int i = 0; i < count; i++) {
sb.append(c);
}
return sb.toString();
}
public static void main(String[] args) {
System.out.println("=== 进阶题测试开始 ===\n");
// 测试动态配置管理系统
testDynamicConfigManager();
System.out.println("\n" + repeatChar('-', 50) + "\n");
// 测试边车模式
testSidecar();
System.out.println("\n=== 进阶题测试完成 ===");
}
// 测试动态配置管理系统
private static void testDynamicConfigManager() {
System.out.println("1. 测试动态配置管理系统功能");
// 获取配置管理器实例
DynamicConfigManager configManager = DynamicConfigManager.getInstance();
// 添加配置监听器
configManager.addListener(new DynamicConfigManager.ConfigChangeListener() {
@Override
public void onConfigChange(String key, Object oldValue, Object newValue) {
System.out.println("监听器收到配置变更通知: ");
System.out.println(" 键: " + key);
System.out.println(" 旧值: " + oldValue);
System.out.println(" 新值: " + newValue);
}
});
// 设置单个配置
System.out.println("\n设置单个配置:");
configManager.setConfig("server.port", 8080);
configManager.setConfig("database.url", "jdbc:mysql://localhost:3306/test");
configManager.setConfig("logging.level", "INFO");
configManager.setConfig("feature.cache.enabled", true);
// 获取配置
System.out.println("\n获取配置值:");
int port = configManager.getConfig("server.port", 8080);
String dbUrl = configManager.getConfig("database.url", "");
String logLevel = configManager.getConfig("logging.level", "DEBUG");
boolean cacheEnabled = configManager.getConfig("feature.cache.enabled", false);
String nonExistent = configManager.getConfig("non.existent", "默认值");
System.out.println("server.port = " + port);
System.out.println("database.url = " + dbUrl);
System.out.println("logging.level = " + logLevel);
System.out.println("feature.cache.enabled = " + cacheEnabled);
System.out.println("non.existent = " + nonExistent);
// 热更新配置测试
System.out.println("\n测试配置热更新:");
System.out.println("更新前的日志级别: " + configManager.getConfig("logging.level", "DEBUG"));
configManager.setConfig("logging.level", "DEBUG"); // 触发监听器
System.out.println("更新后的日志级别: " + configManager.getConfig("logging.level", "DEBUG"));
// 批量更新配置
System.out.println("\n批量更新配置:");
Map<String, Object> batchConfigs = new HashMap<>();
batchConfigs.put("cache.size", 1000);
batchConfigs.put("timeout.seconds", 30);
batchConfigs.put("retries.max", 3);
configManager.setConfigs(batchConfigs);
// 查看所有配置
System.out.println("\n当前所有配置键:");
System.out.println(configManager.getAllKeys());
System.out.println("配置总数: " + configManager.size());
// 移除配置
System.out.println("\n移除配置:");
configManager.removeConfig("cache.size");
System.out.println("移除后配置总数: " + configManager.size());
System.out.println("cache.size 是否存在: " + configManager.containsKey("cache.size"));
}
// 测试边车模式
private static void testSidecar() {
System.out.println("2. 测试边车模式功能");
// 创建边车实例
Sidecar sidecar = new Sidecar("test-app-v1");
// 添加边车功能
System.out.println("\n添加边车功能:");
sidecar.addFeature(new Sidecar.LoggingFeature());
sidecar.addFeature(new Sidecar.MonitoringFeature());
// 添加自定义功能
sidecar.addFeature(new Sidecar.SidecarFeature() {
@Override
public String getName() { return "安全检查"; }
@Override
public void start() { System.out.println("安全检查功能已启动"); }
@Override
public void stop() { System.out.println("安全检查功能已停止"); }
@Override
public void handleRequest(Sidecar.RequestContext context) {
System.out.println("安全检查: 请求 " + context.getRequestId() + " 路径 " + context.getPath());
// 模拟安全检查
if (context.getPath().contains("admin") && !context.getPath().startsWith("/api/auth")) {
context.markError("未授权访问管理路径");
}
}
});
// 启动边车
System.out.println("\n启动边车:");
sidecar.start();
// 测试同步请求处理
System.out.println("\n测试同步请求处理:");
sidecar.handleRequestSync("req-001", "/api/users/list");
sidecar.handleRequestSync("req-002", "/api/products/123");
// 测试未授权请求（应该被安全检查拦截）
System.out.println("\n测试未授权请求:");
sidecar.handleRequestSync("req-003", "/api/admin/dashboard");
// 测试异步请求处理
System.out.println("\n测试异步请求处理:");
for (int i = 4; i <= 10; i++) {
sidecar.handleRequestAsync("req-" + String.format("%03d", i), "/api/async/test/" + i);
}
// 等待异步请求处理完成
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
// 查看统计信息
System.out.println("\n边车统计信息:");
System.out.println(sidecar.getStats());
// 停止边车
System.out.println("\n停止边车:");
sidecar.stop();
// 测试边车停止后的请求处理
System.out.println("\n测试边车停止后的请求处理:");
sidecar.handleRequestSync("req-011", "/api/test/stopped");
}
}

131
AdvancedExample/DynamicConfigManager.java
Unescape View File

@ -1,131 +0,0 @@
/**
* 动态配置管理系统
* 支持配置的热更新，无需重启应用即可生效
*/
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.CopyOnWriteArrayList;
public class DynamicConfigManager {
// 配置存储
private final Map<String, Object> configs;
// 配置监听器列表
private final List<ConfigChangeListener> listeners;
// 单例实例
private static volatile DynamicConfigManager instance;
// 配置变更监听器接口
public interface ConfigChangeListener {
void onConfigChange(String key, Object oldValue, Object newValue);
}
private DynamicConfigManager() {
configs = new ConcurrentHashMap<>();
listeners = new CopyOnWriteArrayList<>();
System.out.println("动态配置管理系统初始化完成");
}
// 获取单例实例
public static DynamicConfigManager getInstance() {
if (instance == null) {
synchronized (DynamicConfigManager.class) {
if (instance == null) {
instance = new DynamicConfigManager();
}
}
}
return instance;
}
// 获取配置
public <T> T getConfig(String key, T defaultValue) {
Object value = configs.get(key);
if (value != null) {
try {
return (T) value;
} catch (ClassCastException e) {
System.err.println("配置类型转换错误: " + key + ", 返回默认值");
}
}
return defaultValue;
}
// 设置配置（支持热更新）
public synchronized void setConfig(String key, Object value) {
Object oldValue = configs.put(key, value);
System.out.println("配置更新: " + key + ", 旧值: " + oldValue + ", 新值: " + value);
// 通知所有监听器
notifyListeners(key, oldValue, value);
}
// 批量设置配置
public synchronized void setConfigs(Map<String, Object> newConfigs) {
for (Map.Entry<String, Object> entry : newConfigs.entrySet()) {
setConfig(entry.getKey(), entry.getValue());
}
}
// 移除配置
public synchronized void removeConfig(String key) {
Object oldValue = configs.remove(key);
if (oldValue != null) {
System.out.println("配置移除: " + key + ", 移除值: " + oldValue);
notifyListeners(key, oldValue, null);
}
}
// 获取所有配置键
public Set<String> getAllKeys() {
return new HashSet<>(configs.keySet());
}
// 注册配置变更监听器
public void addListener(ConfigChangeListener listener) {
if (listener != null && !listeners.contains(listener)) {
listeners.add(listener);
System.out.println("配置监听器已注册");
}
}
// 移除配置变更监听器
public void removeListener(ConfigChangeListener listener) {
if (listener != null) {
listeners.remove(listener);
System.out.println("配置监听器已移除");
}
}
// 通知所有监听器配置变更
private void notifyListeners(String key, Object oldValue, Object newValue) {
for (ConfigChangeListener listener : listeners) {
try {
listener.onConfigChange(key, oldValue, newValue);
} catch (Exception e) {
System.err.println("通知配置变更时出错: " + e.getMessage());
}
}
}
// 清空所有配置
public synchronized void clear() {
Set<String> keys = new HashSet<>(configs.keySet());
configs.clear();
System.out.println("所有配置已清空");
// 通知所有键被移除
for (String key : keys) {
notifyListeners(key, null, null);
}
}
// 获取配置数量
public int size() {
return configs.size();
}
// 检查配置是否存在
public boolean containsKey(String key) {
return configs.containsKey(key);
}
}

247
AdvancedExample/Sidecar.java
Unescape View File

@ -1,247 +0,0 @@
/**
* 边车模式（Sidecar Pattern）实现
* 为应用提供额外的辅助功能，如日志、监控、安全等
*/
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.atomic.AtomicInteger;
public class Sidecar {
private final String name; // 边车名称
private final String appId; // 关联的应用ID
private final ExecutorService executor; // 执行线程池
private final List<SidecarFeature> features; // 边车功能列表
private volatile boolean running; // 运行状态
private final AtomicInteger requestCount = new AtomicInteger(0); // 请求计数
private final AtomicInteger errorCount = new AtomicInteger(0); // 错误计数
// 边车功能接口
public interface SidecarFeature {
String getName();
void start();
void stop();
void handleRequest(RequestContext context);
}
// 请求上下文
public static class RequestContext {
private final String requestId;
private final String path;
private final long startTime;
private long endTime;
private boolean success;
private String errorMessage;
public RequestContext(String requestId, String path) {
this.requestId = requestId;
this.path = path;
this.startTime = System.currentTimeMillis();
this.success = true;
}
public void complete() {
this.endTime = System.currentTimeMillis();
}
public void markError(String errorMessage) {
this.success = false;
this.errorMessage = errorMessage;
this.endTime = System.currentTimeMillis();
}
public long getDuration() {
return endTime - startTime;
}
public String getRequestId() { return requestId; }
public String getPath() { return path; }
public boolean isSuccess() { return success; }
public String getErrorMessage() { return errorMessage; }
public long getStartTime() { return startTime; }
public long getEndTime() { return endTime; }
}
// 创建边车实例
public Sidecar(String appId) {
this.name = "sidecar-" + appId;
this.appId = appId;
this.executor = Executors.newFixedThreadPool(5);
this.features = new ArrayList<>();
this.running = false;
System.out.println("边车初始化: " + name + " 关联应用: " + appId);
}
// 添加边车功能
public void addFeature(SidecarFeature feature) {
if (feature != null) {
features.add(feature);
System.out.println("添加边车功能: " + feature.getName());
// 如果边车已运行，立即启动新功能
if (running) {
feature.start();
}
}
}
// 启动边车
public synchronized void start() {
if (!running) {
running = true;
System.out.println("边车启动: " + name);
// 启动所有功能
for (SidecarFeature feature : features) {
try {
feature.start();
} catch (Exception e) {
System.err.println("启动边车功能失败: " + feature.getName() + ", 错误: " + e.getMessage());
}
}
}
}
// 停止边车
public synchronized void stop() {
if (running) {
running = false;
System.out.println("边车停止: " + name);
// 停止所有功能
for (SidecarFeature feature : features) {
try {
feature.stop();
} catch (Exception e) {
System.err.println("停止边车功能失败: " + feature.getName() + ", 错误: " + e.getMessage());
}
}
// 关闭线程池
executor.shutdown();
}
}
// 处理请求（异步）
public void handleRequestAsync(String requestId, String path) {
if (!running) {
System.err.println("边车未运行，无法处理请求: " + requestId);
return;
}
RequestContext context = new RequestContext(requestId, path);
requestCount.incrementAndGet();
executor.submit(() -> {
try {
for (SidecarFeature feature : features) {
feature.handleRequest(context);
}
} catch (Exception e) {
errorCount.incrementAndGet();
context.markError(e.getMessage());
System.err.println("处理请求出错: " + requestId + ", 错误: " + e.getMessage());
} finally {
if (context.isSuccess() && context.getEndTime() == 0) {
context.complete();
}
}
});
}
// 处理请求（同步）
public void handleRequestSync(String requestId, String path) {
if (!running) {
System.err.println("边车未运行，无法处理请求: " + requestId);
return;
}
RequestContext context = new RequestContext(requestId, path);
requestCount.incrementAndGet();
try {
for (SidecarFeature feature : features) {
feature.handleRequest(context);
}
} catch (Exception e) {
errorCount.incrementAndGet();
context.markError(e.getMessage());
System.err.println("处理请求出错: " + requestId + ", 错误: " + e.getMessage());
} finally {
if (context.isSuccess() && context.getEndTime() == 0) {
context.complete();
}
}
}
// 获取统计信息
public String getStats() {
return String.format("边车统计 - 应用: %s, 请求数: %d, 错误数: %d, 运行状态: %s",
appId, requestCount.get(), errorCount.get(), running ? "运行中" : "已停止");
}
// 获取运行状态
public boolean isRunning() {
return running;
}
// 获取边车名称
public String getName() {
return name;
}
// 内置日志功能实现
public static class LoggingFeature implements SidecarFeature {
@Override
public String getName() {
return "日志功能";}
@Override
public void start() {
System.out.println("日志功能已启动");
}
@Override
public void stop() {
System.out.println("日志功能已停止");
}
@Override
public void handleRequest(RequestContext context) {
String timestamp = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss.SSS"));
String status = context.isSuccess() ? "SUCCESS" : "ERROR";
System.out.println(String.format("[%s] [%s] 请求: %s, 路径: %s, 状态: %s, 耗时: %dms",
timestamp, Thread.currentThread().getName(),
context.getRequestId(), context.getPath(), status, context.getDuration()));
}
}
// 内置监控功能实现
public static class MonitoringFeature implements SidecarFeature {
private final AtomicInteger requestCounter = new AtomicInteger(0);
@Override
public String getName() {
return "监控功能";}
@Override
public void start() {
System.out.println("监控功能已启动");
}
@Override
public void stop() {
System.out.println("监控功能已停止");
}
@Override
public void handleRequest(RequestContext context) {
int count = requestCounter.incrementAndGet();
if (count % 5 == 0) {
System.out.println("监控统计: 已处理 " + count + " 个请求");
}
}
}
}

132
BasicExample/BasicExampleTest.java
Unescape View File

@ -1,132 +0,0 @@
/**
* 基础题测试类
* 测试服务注册中心和断路器功能
*/
public class BasicExampleTest {
// 辅助方法：重复字符
private static String repeatChar(char c, int count) {
StringBuilder sb = new StringBuilder(count);
for (int i = 0; i < count; i++) {
sb.append(c);
}
return sb.toString();
}
public static void main(String[] args) {
System.out.println("=== 基础题测试开始 ===\n");
// 测试服务注册中心
testServiceRegistry();
System.out.println("\n" + repeatChar('-', 50) + "\n");
// 测试断路器
testCircuitBreaker();
System.out.println("\n=== 基础题测试完成 ===");
}
// 测试服务注册中心
private static void testServiceRegistry() {
System.out.println("1. 测试服务注册中心功能");
// 获取服务注册中心实例
ServiceRegistry registry = ServiceRegistry.getInstance();
// 注册服务
System.out.println("\n注册服务实例:");
registry.register("userService", "192.168.1.1", 8080);
registry.register("userService", "192.168.1.2", 8080);
registry.register("orderService", "192.168.1.3", 8081);
// 发现服务
System.out.println("\n发现所有服务:");
System.out.println("已注册服务列表: " + registry.getAllServices());
// 测试服务发现
System.out.println("\n发现特定服务实例:");
java.util.List<ServiceRegistry.ServiceInstance> userInstances = registry.discover("userService");
System.out.println("userService 实例: " + userInstances);
java.util.List<ServiceRegistry.ServiceInstance> orderInstances = registry.discover("orderService");
System.out.println("orderService 实例: " + orderInstances);
// 测试获取随机实例
System.out.println("\n获取随机服务实例:");
for (int i = 0; i < 3; i++) {
ServiceRegistry.ServiceInstance instance = registry.getRandomInstance("userService");
System.out.println("随机选择 userService 实例[" + i + "]: " + instance);
}
// 测试注销服务
System.out.println("\n注销服务实例:");
registry.deregister("userService", "192.168.1.1", 8080);
// 检查注销后的服务
System.out.println("\n注销后的 userService 实例: ");
userInstances = registry.discover("userService");
System.out.println(userInstances);
// 测试不存在的服务
System.out.println("\n测试不存在的服务:");
java.util.List<ServiceRegistry.ServiceInstance> nonExistent = registry.discover("paymentService");
System.out.println("不存在的服务发现结果: " + nonExistent);
}
// 测试断路器
private static void testCircuitBreaker() {
System.out.println("2. 测试断路器功能");
// 创建断路器实例（简化配置以便快速测试）
CircuitBreaker breaker = new CircuitBreaker("testService", 3, 2000, 1);
System.out.println("\n初始状态: " + breaker.getState());
// 测试失败触发开路
System.out.println("\n测试失败触发开路:");
for (int i = 1; i <= 4; i++) {
boolean allowed = breaker.allowRequest();
System.out.println("请求 " + i + " 允许通过: " + allowed + ", 当前状态: " + breaker.getState());
if (allowed) {
// 模拟服务调用失败
breaker.recordFailure();
System.out.println(" 记录失败，失败计数: " + breaker.getFailureCount());
}
}
// 测试开路状态拒绝请求
System.out.println("\n测试开路状态拒绝请求:");
for (int i = 1; i <= 3; i++) {
boolean allowed = breaker.allowRequest();
System.out.println("开路状态请求 " + i + " 允许通过: " + allowed + ", 当前状态: " + breaker.getState());
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
// 等待超时进入半开状态
System.out.println("\n等待超时进入半开状态...");
try {
Thread.sleep(2500); // 等待超过重置时间
} catch (InterruptedException e) {
e.printStackTrace();
}
// 测试半开状态下成功请求
System.out.println("\n测试半开状态下成功请求:");
boolean allowed = breaker.allowRequest();
System.out.println("半开状态请求允许通过: " + allowed + ", 当前状态: " + breaker.getState());
if (allowed) {
// 模拟服务调用成功
breaker.recordSuccess();
System.out.println(" 记录成功，断路器状态: " + breaker.getState());
}
// 测试重置断路器
System.out.println("\n测试重置断路器:");
breaker.reset();
System.out.println("重置后的状态: " + breaker.getState() + ", 失败计数: " + breaker.getFailureCount());
}
}

135
BasicExample/CircuitBreaker.java
Unescape View File

@ -1,135 +0,0 @@
/**
* 断路器模式实现
* 防止系统雪崩效应，保护系统稳定性
*/
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicLong;
public class CircuitBreaker {
// 断路器状态枚举
public enum State {
CLOSED, // 关闭状态，允许请求通过
OPEN, // 开路状态，拒绝请求
HALF_OPEN // 半开状态，允许有限请求通过以检测服务是否恢复
}
private final String name; // 断路器名称
private final int failureThreshold; // 失败阈值
private final long resetTimeoutMs; // 重置超时时间（毫秒）
private final int successThreshold; // 半开状态下的成功阈值
private volatile State state = State.CLOSED; // 当前状态
private final AtomicInteger failureCount = new AtomicInteger(0); // 失败计数
private final AtomicInteger successCount = new AtomicInteger(0); // 成功计数
private final AtomicLong lastFailureTime = new AtomicLong(0); // 最后一次失败时间
// 默认构造函数
public CircuitBreaker(String name) {
this(name, 5, 30000, 2); // 默认5次失败后开路，30秒后尝试半开，2次成功后关闭
}
// 自定义参数构造函数
public CircuitBreaker(String name, int failureThreshold, long resetTimeoutMs, int successThreshold) {
this.name = name;
this.failureThreshold = failureThreshold;
this.resetTimeoutMs = resetTimeoutMs;
this.successThreshold = successThreshold;
System.out.println("断路器初始化: " + name +
", 失败阈值: " + failureThreshold +
", 重置时间: " + resetTimeoutMs + "ms");
}
// 尝试执行请求
public boolean allowRequest() {
switch (state) {
case CLOSED:
// 关闭状态，允许请求通过
return true;
case OPEN:
// 开路状态，检查是否可以进入半开状态
if (System.currentTimeMillis() - lastFailureTime.get() > resetTimeoutMs) {
// 超时，切换到半开状态
state = State.HALF_OPEN;
System.out.println("断路器状态切换: " + name + " 从 OPEN 到 HALF_OPEN");
return true;
}
return false;
case HALF_OPEN:
// 半开状态，允许请求通过
return true;
default:
return false;
}
}
// 记录请求成功
public void recordSuccess() {
switch (state) {
case CLOSED:
// 关闭状态，重置失败计数
failureCount.set(0);
break;
case HALF_OPEN:
// 半开状态，增加成功计数
int currentSuccess = successCount.incrementAndGet();
if (currentSuccess >= successThreshold) {
// 达到成功阈值，切换到关闭状态
reset();
System.out.println("断路器状态切换: " + name + " 从 HALF_OPEN 到 CLOSED");
}
break;
}
}
// 记录请求失败
public void recordFailure() {
switch (state) {
case CLOSED:
// 关闭状态，增加失败计数
int currentFailure = failureCount.incrementAndGet();
if (currentFailure >= failureThreshold) {
// 达到失败阈值，切换到开路状态
state = State.OPEN;
lastFailureTime.set(System.currentTimeMillis());
System.out.println("断路器状态切换: " + name + " 从 CLOSED 到 OPEN");
}
break;
case HALF_OPEN:
// 半开状态下失败，立即切换到开路状态
state = State.OPEN;
lastFailureTime.set(System.currentTimeMillis());
successCount.set(0);
System.out.println("断路器状态切换: " + name + " 从 HALF_OPEN 到 OPEN");
break;
}
}
// 重置断路器
public void reset() {
state = State.CLOSED;
failureCount.set(0);
successCount.set(0);
lastFailureTime.set(0);
System.out.println("断路器重置: " + name);
}
// 获取当前状态
public State getState() {
return state;
}
// 获取名称
public String getName() {
return name;
}
// 获取失败计数
public int getFailureCount() {
return failureCount.get();
}
@Override
public String toString() {
return "CircuitBreaker[name=" + name + ", state=" + state + ", failures=" + failureCount.get() + "]";
}
}

129
BasicExample/ServiceRegistry.java
Unescape View File

@ -1,129 +0,0 @@
/**
* 服务注册中心
* 支持服务的注册和发现功能
*/
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
public class ServiceRegistry {
// 使用ConcurrentHashMap存储服务信息，确保线程安全
private final Map<String, List<ServiceInstance>> services;
// 单例模式实现
private static volatile ServiceRegistry instance;
private ServiceRegistry() {
services = new ConcurrentHashMap<>();
System.out.println("服务注册中心初始化完成");
}
// 获取单例实例
public static ServiceRegistry getInstance() {
if (instance == null) {
synchronized (ServiceRegistry.class) {
if (instance == null) {
instance = new ServiceRegistry();
}
}
}
return instance;
}
// 注册服务
public synchronized void register(String serviceName, String host, int port) {
ServiceInstance instance = new ServiceInstance(host, port);
services.computeIfAbsent(serviceName, k -> new ArrayList<>()).add(instance);
System.out.println("服务注册成功: " + serviceName + " at " + host + ":" + port);
}
// 注销服务
public synchronized void deregister(String serviceName, String host, int port) {
List<ServiceInstance> instances = services.get(serviceName);
if (instances != null) {
boolean removed = instances.removeIf(instance ->
instance.getHost().equals(host) && instance.getPort() == port);
if (removed) {
System.out.println("服务注销成功: " + serviceName + " at " + host + ":" + port);
// 如果该服务没有实例了，移除服务
if (instances.isEmpty()) {
services.remove(serviceName);
}
} else {
System.out.println("服务不存在: " + serviceName + " at " + host + ":" + port);
}
} else {
System.out.println("服务不存在: " + serviceName);
}
}
// 发现服务（获取所有实例）
public List<ServiceInstance> discover(String serviceName) {
List<ServiceInstance> instances = services.get(serviceName);
if (instances != null && !instances.isEmpty()) {
System.out.println("发现服务: " + serviceName + "，实例数量: " + instances.size());
return new ArrayList<>(instances); // 返回副本避免并发修改问题
}
System.out.println("未发现服务: " + serviceName);
return Collections.emptyList();
}
// 获取随机实例（简单的负载均衡）
public ServiceInstance getRandomInstance(String serviceName) {
List<ServiceInstance> instances = discover(serviceName);
if (!instances.isEmpty()) {
Random random = new Random();
ServiceInstance instance = instances.get(random.nextInt(instances.size()));
System.out.println("选择随机实例: " + serviceName + " at " + instance.getHost() + ":" + instance.getPort());
return instance;
}
return null;
}
// 获取所有已注册的服务名称
public Set<String> getAllServices() {
return new HashSet<>(services.keySet());
}
// 服务实例内部类
public static class ServiceInstance {
private final String host;
private final int port;
private final long registerTime;
public ServiceInstance(String host, int port) {
this.host = host;
this.port = port;
this.registerTime = System.currentTimeMillis();
}
public String getHost() {
return host;
}
public int getPort() {
return port;
}
public long getRegisterTime() {
return registerTime;
}
@Override
public String toString() {
return host + ":" + port;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
ServiceInstance that = (ServiceInstance) o;
return port == that.port && Objects.equals(host, that.host);
}
@Override
public int hashCode() {
return Objects.hash(host, port);
}
}
}

194
ChallengeExample/ChallengeExampleTest.java
Unescape View File

@ -1,194 +0,0 @@
/**
* 挑战题测试类
* 测试微服务治理框架和云原生应用生命周期管理系统
*/
public class ChallengeExampleTest {
public static void main(String[] args) {
System.out.println("========== 开始测试挑战题 ==========");
// 测试微服务治理框架
testMicroServiceGovernance();
// 测试云原生应用生命周期管理系统
testCloudNativeLifecycleManager();
System.out.println("========== 挑战题测试完成 ==========");
}
/**
* 测试微服务治理框架
*/
private static void testMicroServiceGovernance() {
System.out.println("\n1. 测试微服务治理框架：");
// 获取治理框架实例
MicroServiceGovernance governance = MicroServiceGovernance.getInstance();
// 注册服务
System.out.println("\n1.1 注册服务：");
governance.registerService("user-service", "192.168.1.101", 8080);
governance.registerService("user-service", "192.168.1.102", 8080);
governance.registerService("order-service", "192.168.1.201", 8081);
governance.registerService("payment-service", "192.168.1.301", 8082);
// 列出已注册的服务
System.out.println("\n1.2 已注册的服务：");
governance.listServices().forEach(service -> {
System.out.println(service);
});
// 测试服务调用（正常情况）
System.out.println("\n1.3 测试服务调用（正常情况）：");
for (int i = 0; i < 5; i++) {
String result = governance.callService("user-service", "GET", "/api/users" + i);
System.out.println("调用结果：" + result);
}
// 模拟服务故障
System.out.println("\n1.4 模拟服务故障：");
governance.simulateServiceFailure("user-service", "192.168.1.101", 8080, true);
// 测试断路器功能
System.out.println("\n1.5 测试断路器功能：");
for (int i = 0; i < 10; i++) {
try {
String result = governance.callService("user-service", "GET", "/api/users/faulty" + i);
System.out.println("调用结果：" + result);
} catch (Exception e) {
System.out.println("调用异常：" + e.getMessage());
}
}
// 注销服务
System.out.println("\n1.6 注销服务：");
governance.deregisterService("order-service", "192.168.1.201", 8081);
System.out.println("注销后服务列表：");
governance.listServices().forEach(service -> {
System.out.println(service);
});
// 显示治理统计信息
System.out.println("\n1.7 治理统计信息：");
governance.printGovernanceStats();
System.out.println("\n微服务治理框架测试完成");
}
/**
* 测试云原生应用生命周期管理系统
*/
private static void testCloudNativeLifecycleManager() {
System.out.println("\n2. 测试云原生应用生命周期管理系统：");
// 获取生命周期管理器实例
CloudNativeLifecycleManager lifecycleManager = CloudNativeLifecycleManager.getInstance();
// 添加事件监听器
lifecycleManager.addEventListener(new CloudNativeLifecycleManager.LifecycleEventListener() {
@Override
public void onApplicationCreated(CloudNativeLifecycleManager.Application app) {
System.out.println("事件：应用已创建 - ID: " + app.getId() + ", 名称: " + app.getConfig().getName());
}
@Override
public void onApplicationDeployed(CloudNativeLifecycleManager.Application app) {
System.out.println("事件：应用已部署 - ID: " + app.getId() + ", 状态: " + app.getStatus());
}
@Override
public void onApplicationScaled(CloudNativeLifecycleManager.Application app, int oldReplicas, int newReplicas) {
System.out.println("事件：应用已扩展 - ID: " + app.getId() + ", 从 " + oldReplicas + " 到 " + newReplicas + " 副本");
}
@Override
public void onApplicationUpdated(CloudNativeLifecycleManager.Application app, CloudNativeLifecycleManager.ApplicationConfig oldConfig) {
System.out.println("事件：应用已更新 - ID: " + app.getId());
}
@Override
public void onApplicationDestroyed(String appId) {
System.out.println("事件：应用已销毁 - ID: " + appId);
}
});
// 显示初始资源状态
System.out.println("\n2.1 初始资源状态：");
lifecycleManager.getResourceStatus().forEach((resource, amount) -> {
System.out.println(resource + ": " + amount);
});
// 创建应用配置
System.out.println("\n2.2 创建应用：");
CloudNativeLifecycleManager.ApplicationConfig config1 = new CloudNativeLifecycleManager.ApplicationConfig("nginx-app", "nginx:latest");
config1.setReplicas(2);
config1.getEnvVars().put("ENV", "production");
config1.getResources().put("cpu", 1);
config1.getResources().put("memory", 1024);
config1.getPorts().add(new CloudNativeLifecycleManager.PortMapping(80, 8080, "TCP"));
CloudNativeLifecycleManager.Application app1 = lifecycleManager.createApplication(config1);
CloudNativeLifecycleManager.ApplicationConfig config2 = new CloudNativeLifecycleManager.ApplicationConfig("redis-app", "redis:latest");
config2.setReplicas(1);
config2.getResources().put("cpu", 1);
config2.getResources().put("memory", 2048);
config2.getPorts().add(new CloudNativeLifecycleManager.PortMapping(6379, 6379, "TCP"));
CloudNativeLifecycleManager.Application app2 = lifecycleManager.createApplication(config2);
// 部署应用
System.out.println("\n2.3 部署应用：");
lifecycleManager.deployApplication(app1.getId());
lifecycleManager.deployApplication(app2.getId());
// 显示应用列表
System.out.println("\n2.4 应用列表：");
for (CloudNativeLifecycleManager.Application app : lifecycleManager.getApplications()) {
System.out.println("ID: " + app.getId() + ", 名称: " + app.getConfig().getName() + ", 状态: " + app.getStatus() + ", 副本数: " + app.getPods().size());
}
// 扩展应用
System.out.println("\n2.5 扩展应用：");
lifecycleManager.scaleApplication(app1.getId(), 3);
// 更新应用配置
System.out.println("\n2.6 更新应用配置：");
CloudNativeLifecycleManager.ApplicationConfig updatedConfig = new CloudNativeLifecycleManager.ApplicationConfig("nginx-app-updated", "nginx:1.21");
updatedConfig.setReplicas(4);
updatedConfig.getEnvVars().put("ENV", "development");
updatedConfig.getResources().put("cpu", 1);
updatedConfig.getResources().put("memory", 1536);
updatedConfig.getPorts().add(new CloudNativeLifecycleManager.PortMapping(80, 8081, "TCP"));
lifecycleManager.updateApplication(app1.getId(), updatedConfig);
// 显示更新后的应用详情
System.out.println("\n2.7 更新后的应用详情：");
CloudNativeLifecycleManager.Application updatedApp = lifecycleManager.getApplication(app1.getId());
System.out.println("ID: " + updatedApp.getId());
System.out.println("名称: " + updatedApp.getConfig().getName());
System.out.println("镜像: " + updatedApp.getConfig().getImage());
System.out.println("副本数: " + updatedApp.getPods().size());
System.out.println("状态: " + updatedApp.getStatus());
System.out.println("环境变量: " + updatedApp.getConfig().getEnvVars());
System.out.println("端口: " + updatedApp.getConfig().getPorts());
// 销毁应用
System.out.println("\n2.8 销毁应用：");
lifecycleManager.destroyApplication(app1.getId());
// 显示最终应用列表和资源状态
System.out.println("\n2.9 最终应用列表：");
for (CloudNativeLifecycleManager.Application app : lifecycleManager.getApplications()) {
System.out.println("ID: " + app.getId() + ", 名称: " + app.getConfig().getName() + ", 状态: " + app.getStatus());
}
System.out.println("\n2.10 最终资源状态：");
lifecycleManager.getResourceStatus().forEach((resource, amount) -> {
System.out.println(resource + ": " + amount);
});
System.out.println("\n云原生应用生命周期管理系统测试完成");
}
}

396
ChallengeExample/CloudNativeLifecycleManager.java
Unescape View File

@ -1,396 +0,0 @@
/**
* 云原生应用生命周期管理系统
* 支持应用的部署、扩展、更新和销毁等生命周期操作
*/
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicInteger;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
public class CloudNativeLifecycleManager {
// 应用实例存储
private final Map<String, Application> applications;
// 资源管理器
private final ResourceManager resourceManager;
// 事件监听器列表
private final List<LifecycleEventListener> eventListeners;
// 单例实例
private static volatile CloudNativeLifecycleManager instance;
// 生命周期事件监听器接口
public interface LifecycleEventListener {
void onApplicationCreated(Application app);
void onApplicationDeployed(Application app);
void onApplicationScaled(Application app, int oldReplicas, int newReplicas);
void onApplicationUpdated(Application app, ApplicationConfig oldConfig);
void onApplicationDestroyed(String appId);
}
// 应用配置类
public static class ApplicationConfig {
private String name;
private String image;
private int replicas;
private Map<String, String> envVars;
private Map<String, Integer> resources;
private List<PortMapping> ports;
public ApplicationConfig(String name, String image) {
this.name = name;
this.image = image;
this.replicas = 1;
this.envVars = new HashMap<>();
this.resources = new HashMap<>();
this.ports = new ArrayList<>();
}
// Getters and Setters
public String getName() { return name; }
public void setName(String name) { this.name = name; }
public String getImage() { return image; }
public void setImage(String image) { this.image = image; }
public int getReplicas() { return replicas; }
public void setReplicas(int replicas) { this.replicas = replicas; }
public Map<String, String> getEnvVars() { return envVars; }
public void setEnvVars(Map<String, String> envVars) { this.envVars = envVars; }
public Map<String, Integer> getResources() { return resources; }
public void setResources(Map<String, Integer> resources) { this.resources = resources; }
public List<PortMapping> getPorts() { return ports; }
public void setPorts(List<PortMapping> ports) { this.ports = ports; }
@Override
public String toString() {
return "ApplicationConfig{name='" + name + "', image='" + image + "', replicas=" + replicas + "}";
}
}
// 端口映射类
public static class PortMapping {
private int containerPort;
private int hostPort;
private String protocol;
public PortMapping(int containerPort, int hostPort, String protocol) {
this.containerPort = containerPort;
this.hostPort = hostPort;
this.protocol = protocol;
}
public int getContainerPort() { return containerPort; }
public int getHostPort() { return hostPort; }
public String getProtocol() { return protocol; }
@Override
public String toString() {
return hostPort + ":" + containerPort + "/" + protocol;
}
}
// 应用实例类
public static class Application {
private final String id;
private ApplicationConfig config;
private String status;
private List<Pod> pods;
private final Map<String, String> metadata;
private final String createdAt;
private String updatedAt;
public Application(String id, ApplicationConfig config) {
this.id = id;
this.config = config;
this.status = "PENDING";
this.pods = new ArrayList<>();
this.metadata = new HashMap<>();
String timestamp = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
this.createdAt = timestamp;
this.updatedAt = timestamp;
}
// Getters and Setters
public String getId() { return id; }
public ApplicationConfig getConfig() { return config; }
public void setConfig(ApplicationConfig config) { this.config = config; }
public String getStatus() { return status; }
public void setStatus(String status) { this.status = status; }
public List<Pod> getPods() { return pods; }
public void setPods(List<Pod> pods) { this.pods = pods; }
public Map<String, String> getMetadata() { return metadata; }
public String getCreatedAt() { return createdAt; }
public String getUpdatedAt() { return updatedAt; }
public void setUpdatedAt(String updatedAt) { this.updatedAt = updatedAt; }
}
// Pod类（容器组）
public static class Pod {
private final String id;
private final String appId;
private String nodeId;
private String status;
private final String createdAt;
public Pod(String id, String appId) {
this.id = id;
this.appId = appId;
this.status = "PENDING";
this.createdAt = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
}
public String getId() { return id; }
public String getAppId() { return appId; }
public String getNodeId() { return nodeId; }
public void setNodeId(String nodeId) { this.nodeId = nodeId; }
public String getStatus() { return status; }
public void setStatus(String status) { this.status = status; }
public String getCreatedAt() { return createdAt; }
}
// 资源管理器
private static class ResourceManager {
private final Map<String, Integer> availableResources;
public ResourceManager() {
this.availableResources = new HashMap<>();
// 模拟初始资源
availableResources.put("cpu", 16);
availableResources.put("memory", 65536); // 64GB
availableResources.put("disk", 1048576); // 1TB
}
public synchronized boolean allocateResources(Map<String, Integer> required) {
// 检查资源是否足够
for (Map.Entry<String, Integer> entry : required.entrySet()) {
Integer available = availableResources.getOrDefault(entry.getKey(), 0);
if (available < entry.getValue()) {
return false;
}
}
// 分配资源
for (Map.Entry<String, Integer> entry : required.entrySet()) {
availableResources.put(entry.getKey(),
availableResources.get(entry.getKey()) - entry.getValue());
}
return true;
}
public synchronized void releaseResources(Map<String, Integer> allocated) {
for (Map.Entry<String, Integer> entry : allocated.entrySet()) {
availableResources.put(entry.getKey(),
availableResources.getOrDefault(entry.getKey(), 0) + entry.getValue());
}
}
public Map<String, Integer> getAvailableResources() {
return new HashMap<>(availableResources);
}
}
private CloudNativeLifecycleManager() {
this.applications = new ConcurrentHashMap<>();
this.resourceManager = new ResourceManager();
this.eventListeners = new ArrayList<>();
System.out.println("云原生应用生命周期管理系统初始化完成");
}
// 获取单例实例
public static CloudNativeLifecycleManager getInstance() {
if (instance == null) {
synchronized (CloudNativeLifecycleManager.class) {
if (instance == null) {
instance = new CloudNativeLifecycleManager();
}
}
}
return instance;
}
// 注册事件监听器
public void addEventListener(LifecycleEventListener listener) {
if (listener != null && !eventListeners.contains(listener)) {
eventListeners.add(listener);
}
}
// 创建应用
public Application createApplication(ApplicationConfig config) {
String appId = "app-" + UUID.randomUUID().toString().substring(0, 8);
Application app = new Application(appId, config);
applications.put(appId, app);
System.out.println("应用创建: " + appId + ", 配置: " + config);
// 通知监听器
for (LifecycleEventListener listener : eventListeners) {
listener.onApplicationCreated(app);
}
return app;
}
// 部署应用
public boolean deployApplication(String appId) {
Application app = applications.get(appId);
if (app == null) {
System.err.println("应用不存在: " + appId);
return false;
}
// 分配资源
Map<String, Integer> resources = app.getConfig().getResources();
if (!resourceManager.allocateResources(resources)) {
System.err.println("资源不足，无法部署应用: " + appId);
return false;
}
// 创建Pod实例
List<Pod> pods = new ArrayList<>();
for (int i = 0; i < app.getConfig().getReplicas(); i++) {
String podId = "pod-" + UUID.randomUUID().toString().substring(0, 8);
Pod pod = new Pod(podId, appId);
pod.setNodeId("node-" + (i % 3 + 1)); // 模拟节点分配
pod.setStatus("RUNNING");
pods.add(pod);
System.out.println("Pod创建: " + podId + " 应用: " + appId + " 节点: " + pod.getNodeId());
}
app.setPods(pods);
app.setStatus("RUNNING");
app.setUpdatedAt(LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
System.out.println("应用部署成功: " + appId + " 副本数: " + pods.size());
// 通知监听器
for (LifecycleEventListener listener : eventListeners) {
listener.onApplicationDeployed(app);
}
return true;
}
// 扩展应用
public boolean scaleApplication(String appId, int replicas) {
Application app = applications.get(appId);
if (app == null) {
System.err.println("应用不存在: " + appId);
return false;
}
if (replicas <= 0) {
System.err.println("副本数必须大于0: " + replicas);
return false;
}
int oldReplicas = app.getPods().size();
if (oldReplicas == replicas) {
System.out.println("应用已经是指定的副本数: " + appId + " replicas=" + replicas);
return true;
}
if (replicas > oldReplicas) {
// 扩容
for (int i = oldReplicas; i < replicas; i++) {
String podId = "pod-" + UUID.randomUUID().toString().substring(0, 8);
Pod pod = new Pod(podId, appId);
pod.setNodeId("node-" + (i % 3 + 1));
pod.setStatus("RUNNING");
app.getPods().add(pod);
System.out.println("扩容Pod创建: " + podId + " 应用: " + appId);
}
} else {
// 缩容
List<Pod> pods = app.getPods();
while (pods.size() > replicas) {
Pod podToRemove = pods.remove(pods.size() - 1);
System.out.println("缩容Pod删除: " + podToRemove.getId() + " 应用: " + appId);
}
}
app.getConfig().setReplicas(replicas);
app.setUpdatedAt(LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
System.out.println("应用扩展成功: " + appId + " 从 " + oldReplicas + " 到 " + replicas + " 副本");
// 通知监听器
for (LifecycleEventListener listener : eventListeners) {
listener.onApplicationScaled(app, oldReplicas, replicas);
}
return true;
}
// 更新应用配置
public boolean updateApplication(String appId, ApplicationConfig newConfig) {
Application app = applications.get(appId);
if (app == null) {
System.err.println("应用不存在: " + appId);
return false;
}
ApplicationConfig oldConfig = app.getConfig();
// 保存旧配置的副本
ApplicationConfig oldConfigCopy = new ApplicationConfig(oldConfig.getName(), oldConfig.getImage());
oldConfigCopy.setReplicas(oldConfig.getReplicas());
oldConfigCopy.setEnvVars(new HashMap<>(oldConfig.getEnvVars()));
oldConfigCopy.setResources(new HashMap<>(oldConfig.getResources()));
oldConfigCopy.setPorts(new ArrayList<>(oldConfig.getPorts()));
// 更新配置
app.setConfig(newConfig);
app.setUpdatedAt(LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
// 如果副本数改变，重新调度
if (newConfig.getReplicas() != oldConfig.getReplicas()) {
scaleApplication(appId, newConfig.getReplicas());
}
System.out.println("应用更新成功: " + appId + " 配置从 " + oldConfig + " 更新到 " + newConfig);
// 通知监听器
for (LifecycleEventListener listener : eventListeners) {
listener.onApplicationUpdated(app, oldConfigCopy);
}
return true;
}
// 销毁应用
public boolean destroyApplication(String appId) {
Application app = applications.remove(appId);
if (app == null) {
System.err.println("应用不存在: " + appId);
return false;
}
// 释放资源
resourceManager.releaseResources(app.getConfig().getResources());
// 删除所有Pod
System.out.println("销毁应用: " + appId + " 删除Pod数: " + app.getPods().size());
// 通知监听器
for (LifecycleEventListener listener : eventListeners) {
listener.onApplicationDestroyed(appId);
}
return true;
}
// 获取应用列表
public List<Application> getApplications() {
return new ArrayList<>(applications.values());
}
// 获取应用详情
public Application getApplication(String appId) {
return applications.get(appId);
}
// 获取系统资源状态
public Map<String, Integer> getResourceStatus() {
return resourceManager.getAvailableResources();
}
}

496
ChallengeExample/MicroServiceGovernance.java
Unescape View File

@ -1,496 +0,0 @@
/**
* 微服务治理框架
* 包含服务发现、负载均衡和熔断降级功能
*/
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicInteger;
public class MicroServiceGovernance {
// 服务注册中心组件
private final ServiceRegistry serviceRegistry;
// 负载均衡器映射
private final Map<String, LoadBalancer> loadBalancers;
// 断路器映射
private final Map<String, CircuitBreaker> circuitBreakers;
// 故障服务列表
private final Map<String, Boolean> faultyServices = new ConcurrentHashMap<>();
// 服务调用统计
private final Map<String, CallStats> callStats = new ConcurrentHashMap<>();
// 单例实例
private static volatile MicroServiceGovernance instance;
private MicroServiceGovernance() {
this.serviceRegistry = new ServiceRegistry();
this.loadBalancers = new ConcurrentHashMap<>();
this.circuitBreakers = new ConcurrentHashMap<>();
System.out.println("微服务治理框架初始化完成");
}
// 获取单例实例
public static MicroServiceGovernance getInstance() {
if (instance == null) {
synchronized (MicroServiceGovernance.class) {
if (instance == null) {
instance = new MicroServiceGovernance();
}
}
}
return instance;
}
// 服务注册
public void registerService(String serviceName, String host, int port) {
serviceRegistry.register(serviceName, host, port);
// 为新服务初始化负载均衡器
getLoadBalancer(serviceName);
// 为新服务初始化断路器
getCircuitBreaker(serviceName);
}
// 服务注销
public void deregisterService(String serviceName, String host, int port) {
serviceRegistry.deregister(serviceName, host, port);
}
// 获取负载均衡器
private LoadBalancer getLoadBalancer(String serviceName) {
return loadBalancers.computeIfAbsent(serviceName, name -> {
LoadBalancer balancer = new LoadBalancer(name);
System.out.println("为服务 " + name + " 创建负载均衡器");
return balancer;
});
}
// 获取断路器
private CircuitBreaker getCircuitBreaker(String serviceName) {
return circuitBreakers.computeIfAbsent(serviceName, name -> {
CircuitBreaker breaker = new CircuitBreaker(name, 5, 10000, 2);
System.out.println("为服务 " + name + " 创建断路器");
return breaker;
});
}
// 调用服务（适配测试类的方法签名）
public String callService(String serviceName, String method, String path) {
// 创建一个简单的参数映射
Map<String, String> params = new HashMap<>();
params.put("path", path);
params.put("timestamp", String.valueOf(System.currentTimeMillis()));
return callServiceInternal(serviceName, method, params);
}
// 服务调用（集成了服务发现、负载均衡和熔断降级）
public ServiceCallResult callService(String serviceName, String path, Map<String, String> params) {
// 获取断路器
CircuitBreaker circuitBreaker = getCircuitBreaker(serviceName);
// 检查断路器状态
if (!circuitBreaker.allowRequest()) {
System.out.println("服务调用被断路器拒绝: " + serviceName + " (状态: " + circuitBreaker.getState() + ")");
return new ServiceCallResult(false, "服务暂时不可用，请稍后再试", null);
}
try {
// 获取服务实例列表
List<ServiceRegistry.ServiceInstance> instances = serviceRegistry.discover(serviceName);
if (instances.isEmpty()) {
circuitBreaker.recordFailure();
return new ServiceCallResult(false, "未找到可用的服务实例: " + serviceName, null);
}
// 负载均衡选择实例
LoadBalancer loadBalancer = getLoadBalancer(serviceName);
ServiceRegistry.ServiceInstance instance = loadBalancer.choose(instances);
if (instance == null) {
circuitBreaker.recordFailure();
return new ServiceCallResult(false, "负载均衡失败，未选择到服务实例", null);
}
// 模拟服务调用
System.out.println("调用服务: " + serviceName + " 实例: " + instance + " 路径: " + path);
// 模拟随机失败（用于测试熔断）
boolean success = simulateServiceCall(instance, serviceName);
// 更新调用统计
updateCallStats(serviceName, instance, success);
if (success) {
circuitBreaker.recordSuccess();
Map<String, Object> response = new HashMap<>();
response.put("instance", instance.toString());
response.put("path", path);
response.put("timestamp", System.currentTimeMillis());
return new ServiceCallResult(true, "调用成功", response);
} else {
circuitBreaker.recordFailure();
return new ServiceCallResult(false, "服务调用失败", null);
}
} catch (Exception e) {
circuitBreaker.recordFailure();
return new ServiceCallResult(false, "服务调用异常: " + e.getMessage(), null);
}
}
// 内部调用服务方法
public String callServiceInternal(String serviceName, String method, Map<String, String> params) {
// 1. 通过服务注册中心发现服务
List<ServiceRegistry.ServiceInstance> instances = serviceRegistry.discover(serviceName);
if (instances.isEmpty()) {
return "服务不可用: " + serviceName;
}
// 2. 通过负载均衡器选择实例
LoadBalancer loadBalancer = getLoadBalancer(serviceName);
ServiceRegistry.ServiceInstance instance = loadBalancer.choose(instances);
if (instance == null) {
return "无法选择服务实例: " + serviceName;
}
// 3. 通过断路器调用服务
String key = serviceName + ":" + instance.getHost() + ":" + instance.getPort();
CircuitBreaker circuitBreaker = circuitBreakers.computeIfAbsent(key, name -> new CircuitBreaker(name, 5, 10000, 2));
if (!circuitBreaker.allowRequest()) {
return "服务调用被断路器拒绝: " + serviceName;
}
try {
// 模拟服务调用
String result = simulateServiceCallInternal(instance, method, params);
circuitBreaker.recordSuccess();
// 更新调用统计
updateCallStats(serviceName, instance, true);
return result;
} catch (Exception e) {
circuitBreaker.recordFailure();
// 更新调用统计
updateCallStats(serviceName, instance, false);
return "服务调用失败: " + e.getMessage();
}
}
// 模拟服务调用（内部方法）
private String simulateServiceCallInternal(ServiceRegistry.ServiceInstance instance, String method, Map<String, String> params) {
// 检查故障服务列表
String faultKey = instance.getHost() + ":" + instance.getPort();
if (faultyServices.containsKey(faultKey) && faultyServices.get(faultKey)) {
throw new RuntimeException("模拟服务故障: " + instance);
}
// 模拟处理延迟
try {
Thread.sleep(10 + (int)(Math.random() * 50));
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
// 生成调用结果
String path = params.getOrDefault("path", "");
return method + " " + instance.getHost() + ":" + instance.getPort() + path + " - 调用成功";
}
// 模拟服务调用（随机失败以测试熔断）
private boolean simulateServiceCall(ServiceRegistry.ServiceInstance instance, String serviceName) {
// 检查故障服务列表
String faultKey = instance.getHost() + ":" + instance.getPort();
if (faultyServices.containsKey(faultKey) && faultyServices.get(faultKey)) {
return false;
}
// 90%的成功率，用于测试
return Math.random() < 0.9;
}
// 更新调用统计
private void updateCallStats(String serviceName, ServiceRegistry.ServiceInstance instance, boolean success) {
CallStats stats = callStats.computeIfAbsent(serviceName, k -> new CallStats());
stats.recordCall(success);
// 更新实例统计
String instanceKey = instance.getHost() + ":" + instance.getPort();
stats.instanceStats.computeIfAbsent(instanceKey, k -> new ServiceInstanceStats()).recordCall(success);
}
// 列出所有服务
public List<String> listServices() {
List<String> services = new ArrayList<>();
// 从服务注册中心获取所有服务
serviceRegistry.getAllServices().forEach(service -> {
List<ServiceRegistry.ServiceInstance> instances = serviceRegistry.discover(service);
for (ServiceRegistry.ServiceInstance instance : instances) {
services.add(service + " - " + instance.getHost() + ":" + instance.getPort());
}
});
return services;
}
// 模拟服务故障
public void simulateServiceFailure(String serviceName, String host, int port, boolean isFaulty) {
String key = host + ":" + port;
faultyServices.put(key, isFaulty);
System.out.println("服务故障状态更新: " + serviceName + "[" + host + ":" + port + "] = " + (isFaulty ? "故障" : "正常"));
}
// 打印治理统计信息
public void printGovernanceStats() {
System.out.println("===== 微服务治理统计 =====");
// 打印服务调用统计
callStats.forEach((service, stats) -> {
System.out.println("\n服务: " + service);
System.out.println(" 总调用次数: " + stats.getTotalCalls());
System.out.println(" 成功调用: " + stats.getSuccessCalls());
System.out.println(" 失败调用: " + stats.getFailureCalls());
System.out.println(" 成功率: " + String.format("%.2f%%",
stats.getTotalCalls() > 0 ? (double) stats.getSuccessCalls() / stats.getTotalCalls() * 100 : 0));
// 打印实例统计
System.out.println(" 实例统计:");
stats.getInstanceStats().forEach((instance, instanceStats) -> {
System.out.println(" " + instance + ": 调用 " + instanceStats.getTotalCalls() + " 次, 成功率 " +
String.format("%.2f%%", instanceStats.getSuccessRate()));
});
});
// 打印断路器状态
System.out.println("\n断路器状态:");
circuitBreakers.forEach((key, breaker) -> {
System.out.println(" " + key + ": " + breaker.getState() + ", 失败计数: " + breaker.getFailureCount());
});
System.out.println("========================");
}
// 获取服务治理统计信息
public Map<String, Object> getGovernanceStats() {
Map<String, Object> stats = new HashMap<>();
// 服务统计
Map<String, Integer> serviceStats = new HashMap<>();
for (String service : serviceRegistry.getAllServices()) {
int instanceCount = serviceRegistry.discover(service).size();
serviceStats.put(service, instanceCount);
}
stats.put("services", serviceStats);
// 断路器统计
Map<String, String> breakerStats = new HashMap<>();
for (Map.Entry<String, CircuitBreaker> entry : circuitBreakers.entrySet()) {
CircuitBreaker breaker = entry.getValue();
breakerStats.put(entry.getKey(), breaker.getState() + " (失败: " + breaker.getFailureCount() + ")");
}
stats.put("circuitBreakers", breakerStats);
// 添加调用统计
stats.put("callStats", callStats);
return stats;
}
// 服务调用统计
private static class CallStats {
private final AtomicInteger totalCalls = new AtomicInteger(0);
private final AtomicInteger successCalls = new AtomicInteger(0);
private final AtomicInteger failureCalls = new AtomicInteger(0);
private final Map<String, ServiceInstanceStats> instanceStats = new ConcurrentHashMap<>();
// Getters
public int getTotalCalls() { return totalCalls.get(); }
public int getSuccessCalls() { return successCalls.get(); }
public int getFailureCalls() { return failureCalls.get(); }
public Map<String, ServiceInstanceStats> getInstanceStats() { return instanceStats; }
// 更新统计
public void recordCall(boolean success) {
totalCalls.incrementAndGet();
if (success) {
successCalls.incrementAndGet();
} else {
failureCalls.incrementAndGet();
}
}
}
// 服务实例调用统计
private static class ServiceInstanceStats {
private final AtomicInteger totalCalls = new AtomicInteger(0);
private final AtomicInteger successCalls = new AtomicInteger(0);
public void recordCall(boolean success) {
totalCalls.incrementAndGet();
if (success) {
successCalls.incrementAndGet();
}
}
public int getTotalCalls() { return totalCalls.get(); }
public int getSuccessCalls() { return successCalls.get(); }
public double getSuccessRate() {
int total = getTotalCalls();
return total > 0 ? (double) getSuccessCalls() / total * 100 : 0;
}
}
// 服务注册中心内部类
public static class ServiceRegistry {
private final Map<String, List<ServiceInstance>> services = new ConcurrentHashMap<>();
public void register(String serviceName, String host, int port) {
services.computeIfAbsent(serviceName, k -> new ArrayList<>()).add(new ServiceInstance(host, port));
System.out.println("服务注册: " + serviceName + " at " + host + ":" + port);
}
public void deregister(String serviceName, String host, int port) {
List<ServiceInstance> instances = services.get(serviceName);
if (instances != null) {
instances.removeIf(instance -> instance.getHost().equals(host) && instance.getPort() == port);
if (instances.isEmpty()) {
services.remove(serviceName);
}
}
}
public List<ServiceInstance> discover(String serviceName) {
List<ServiceInstance> instances = services.get(serviceName);
return instances != null ? new ArrayList<>(instances) : Collections.emptyList();
}
public Set<String> getAllServices() {
return new HashSet<>(services.keySet());
}
public static class ServiceInstance {
private final String host;
private final int port;
public ServiceInstance(String host, int port) {
this.host = host;
this.port = port;
}
public String getHost() { return host; }
public int getPort() { return port; }
@Override
public String toString() { return host + ":" + port; }
}
}
// 负载均衡器内部类
public static class LoadBalancer {
private final String name;
private final AtomicInteger counter = new AtomicInteger(0);
public LoadBalancer(String name) {
this.name = name;
}
// 轮询负载均衡
public ServiceRegistry.ServiceInstance choose(List<ServiceRegistry.ServiceInstance> instances) {
if (instances == null || instances.isEmpty()) {
return null;
}
// 轮询选择实例
int index = Math.abs(counter.getAndIncrement() % instances.size());
return instances.get(index);
}
}
// 断路器内部类
public static class CircuitBreaker {
public enum State { CLOSED, OPEN, HALF_OPEN }
private final String name;
private final int failureThreshold;
private final long resetTimeoutMs;
private final int successThreshold;
private volatile State state = State.CLOSED;
private final AtomicInteger failureCount = new AtomicInteger(0);
private final AtomicInteger successCount = new AtomicInteger(0);
private volatile long lastFailureTime = 0;
public CircuitBreaker(String name, int failureThreshold, long resetTimeoutMs, int successThreshold) {
this.name = name;
this.failureThreshold = failureThreshold;
this.resetTimeoutMs = resetTimeoutMs;
this.successThreshold = successThreshold;
}
public boolean allowRequest() {
if (state == State.CLOSED) {
return true;
}
if (state == State.OPEN) {
if (System.currentTimeMillis() - lastFailureTime > resetTimeoutMs) {
state = State.HALF_OPEN;
System.out.println("断路器状态切换: " + name + " 从 OPEN 到 HALF_OPEN");
return true;
}
return false;
}
return state == State.HALF_OPEN;
}
public void recordSuccess() {
if (state == State.CLOSED) {
failureCount.set(0);
} else if (state == State.HALF_OPEN) {
if (successCount.incrementAndGet() >= successThreshold) {
reset();
System.out.println("断路器状态切换: " + name + " 从 HALF_OPEN 到 CLOSED");
}
}
}
public void recordFailure() {
if (state == State.CLOSED) {
if (failureCount.incrementAndGet() >= failureThreshold) {
state = State.OPEN;
lastFailureTime = System.currentTimeMillis();
System.out.println("断路器状态切换: " + name + " 从 CLOSED 到 OPEN");
}
} else if (state == State.HALF_OPEN) {
state = State.OPEN;
lastFailureTime = System.currentTimeMillis();
successCount.set(0);
System.out.println("断路器状态切换: " + name + " 从 HALF_OPEN 到 OPEN");
}
}
private void reset() {
state = State.CLOSED;
failureCount.set(0);
successCount.set(0);
}
public State getState() { return state; }
public int getFailureCount() { return failureCount.get(); }
public String getName() { return name; }
}
// 服务调用结果
public static class ServiceCallResult {
private final boolean success;
private final String message;
private final Map<String, Object> data;
public ServiceCallResult(boolean success, String message, Map<String, Object> data) {
this.success = success;
this.message = message;
this.data = data;
}
public boolean isSuccess() { return success; }
public String getMessage() { return message; }
public Map<String, Object> getData() { return data; }
}
}

2
README.md
Unescape View File

@ -0,0 +1,2 @@
# 789
Write Preview
Loading…
Cancel
Save