EduAgentX 项目面试话术指南

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

@Configuration
public class RedisConfig {
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory connectionFactory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(connectionFactory);

        // 使用 Jackson2JsonRedisSerializer 序列化值
        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.activateDefaultTyping(LaissezFaireSubTypeValidator.instance, 
            ObjectMapper.DefaultTyping.NON_FINAL);
        Jackson2JsonRedisSerializer<Object> serializer = 
            new Jackson2JsonRedisSerializer<>(objectMapper, Object.class);

        // Key 使用 String 序列化
        template.setKeySerializer(new StringRedisSerializer());
        template.setValueSerializer(serializer);
        template.setHashKeySerializer(new StringRedisSerializer());
        template.setHashValueSerializer(serializer);
        return template;
    }

    @Bean
    public RedisTemplate<String, String> luaRedisTemplate(RedisConnectionFactory connectionFactory) {
        RedisTemplate<String, String> template = new RedisTemplate<>();
        template.setConnectionFactory(connectionFactory);
        // 全部使用 String 序列化，用于Lua脚本
        StringRedisSerializer stringSerializer = new StringRedisSerializer();
        template.setKeySerializer(stringSerializer);
        template.setValueSerializer(stringSerializer);
        template.setHashKeySerializer(stringSerializer);
        template.setHashValueSerializer(stringSerializer);
        return template;
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

public static final RedisScript<Long> SNATCH_SCRIPT = new DefaultRedisScript<>("""
    local tempSnatchKey = KEYS[1]
    local studentSnatchKey = KEYS[2]
    local subjectCapacityKey = KEYS[3]
    local studentId = ARGV[1]
    local subjectId = ARGV[2]

    -- 1. 检查是否已抢课
    local hasSnatch = redis.call('HEXISTS', studentSnatchKey, subjectId)
    if hasSnatch == 1 then
        return -1  -- 已抢课
    end

    -- 2. 原子性扣减库存
    local newCapacity = redis.call('HINCRBY', subjectCapacityKey, subjectId, -1)
    if newCapacity < 0 then
        redis.call('HINCRBY', subjectCapacityKey, subjectId, 1)  -- 回滚
        return -2  -- 库存不足
    end

    -- 3. 批量写入
    local hashKey = studentId .. ':' .. subjectId
    redis.call('HINCRBY', tempSnatchKey, hashKey, 1)
    redis.call('HSET', studentSnatchKey, subjectId, 1)

    return 1  -- 成功
    """, Long.class);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

@Component
public class CacheManager {
    @Bean
    public Cache<String, Object> localCache() {
        return Caffeine.newBuilder()
            .maximumSize(10000)                      // 最大缓存10000条
            .expireAfterWrite(60, TimeUnit.SECONDS)  // 60秒过期
            .recordStats()                           // 启用统计
            .build();
    }
}

1
2

请求 → 本地缓存(Caffeine) → Redis → 数据库
       ↑ 命中返回          ↑ 命中返回  ↑ 查询并缓存

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

public Integer getSubjectCapacityWithCache(Long subjectId) {
    String cacheKey = "capacity:" + subjectId;

    // 1. 先查本地缓存
    Object cached = localCache.getIfPresent(cacheKey);
    if (cached != null) {
        return (Integer) cached;
    }

    // 2. 查询Redis
    Object capacityObj = luaRedisTemplate.opsForHash()
        .get(capacityKey, subjectId.toString());

    // 3. 热Key检测，决定是否缓存到本地
    AddResult addResult = hotKeyDetector.add(buildCacheKey(subjectId), 1);
    if (addResult.isHotKey()) {
        localCache.put(cacheKey, capacityValue);
    }

    return capacityValue;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

public class HeavyKeeper implements TopK {
    private final int k;           // Top K
    private final int width;       // 桶宽度
    private final int depth;       // 桶深度
    private final double[] lookupTable;  // 衰减查找表
    private final Bucket[][] buckets;    // 计数桶
    private final PriorityQueue<Node> minHeap;  // 最小堆维护TopK

    public HeavyKeeper(int k, int width, int depth, double decay, int minCount) {
        this.k = k;              // 监控Top 100
        this.width = width;      // 100000
        this.depth = depth;      // 5
        this.minCount = minCount; // 最小出现3次
        // 预计算衰减表
        for (int i = 0; i < 256; i++) {
            lookupTable[i] = Math.pow(decay, i);
        }
    }

    @Override
    public AddResult add(String key, int increment) {
        // 1. 计算指纹
        long itemFingerprint = hash(key.getBytes());
        int maxCount = 0;

        // 2. 更新多层桶
        for (int i = 0; i < depth; i++) {
            int bucketNumber = Math.abs(hash(key.getBytes())) % width;
            Bucket bucket = buckets[i][bucketNumber];

            synchronized (bucket) {
                if (bucket.fingerprint == itemFingerprint) {
                    bucket.count += increment;
                    maxCount = Math.max(maxCount, bucket.count);
                } else {
                    // 概率衰减
                    double decay = lookupTable[Math.min(bucket.count, 255)];
                    if (random.nextDouble() < decay) {
                        bucket.count--;
                        if (bucket.count == 0) {
                            bucket.fingerprint = itemFingerprint;
                            bucket.count = increment;
                        }
                    }
                }
            }
        }

        // 3. 更新TopK堆
        // ...
        return new AddResult(expelled, isHot, key);
    }
}

1
2
3
4
5
6
7

hotKeyDetector = new HeavyKeeper(
    100,      // 监控Top 100 Key
    100000,   // 宽度
    5,        // 深度
    0.92,     // 衰减系数
    3         // 最小出现3次才记录
);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

# application.yml
dubbo:
  registry:
    address: nacos://127.0.0.1:8848?username=nacos&password=nacos
    register-mode: instance
  protocol:
    name: tri          # Triple协议（基于gRPC）
    port: 50052
  consumer:
    timeout: 60000     # 60秒超时
    check: false       # 启动时不检查服务提供者
    retries: 2         # 失败重试2次
  provider:
    timeout: 60000
  application:
    qos-port: 22222
    metadata-type: remote
  metadata-report:
    address: nacos://127.0.0.1:8848?username=nacos&password=nacos

1
2
3

// 只有查询接口，才手动指定重试次数
@DubboReference(retries = 2, timeout = 3000)
private UserQueryService userQueryService;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

EduAgentX-MicroService/
├── EduAgentX-User        # 用户服务 (端口8124)
├── EduAgentX-Course      # 课程服务 (端口8125)
├── EduAgentX-Question    # 题目服务 (端口8126)
├── EduAgentX-Snatch      # 抢课服务 (端口8127)
├── EduAgentX-File        # 文件服务 (端口8128)
├── EduAgentX-RagService  # RAG服务 (端口8129)
├── EduAgentX-AI-Workflow # AI工作流服务 (端口8130)
├── EduAgentX-Client      # 内部调用接口定义
├── EduAgentX-Common      # 公共模块
└── EduAgentX-Model       # 数据模型

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

public interface InnerUserService {
    List<User> listByIds(Collection<? extends Serializable> ids);
    User getById(Serializable id);
    UserVO getUserVO(User user);

    // 静态方法，避免跨服务调用
    static User getLoginUser(HttpServletRequest request) {
        Object userObj = request.getSession().getAttribute(USER_LOGIN_STATE);
        User currentUser = (User) userObj;
        if (currentUser == null || currentUser.getId() == null) {
            throw new BusinessException(ErrorCode.NOT_LOGIN_ERROR);
        }
        return currentUser;
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

@DubboService
public class InnerSnatchSubjectServiceImpl implements InnerSnatchSubjectService {
    @Resource
    private SnatchSubjectService snatchSubjectService;

    @Override
    public void initSubjectCapacityToRedis(Long subjectId) {
        snatchSubjectService.initSubjectCapacityToRedis(subjectId);
    }

    @Override
    public SnatchSubject getBySubjectId(Long subjectId) {
        return snatchSubjectService.getBySubjectId(subjectId);
    }
}

1
2
3
4
5
6

@DubboReference
private InnerUserService innerUserService;

public void someMethod() {
    User user = innerUserService.getById(userId);
}

1
2
3
4
5
6

spring:
  session:
    store-type: redis
    timeout: 2880m           # 48小时
    redis:
      namespace: spring:session

1
2
3
4
5

spring:session:sessions:{sessionId}
├── creationTime
├── lastAccessedTime
├── maxInactiveInterval
└── sessionAttr:USER_LOGIN_STATE  # 用户登录信息

1
2
3
4
5

Consumer端:
1. Proxy代理 → 2. Filter链 → 3. Invoker → 4. Directory → 5. Router → 6. LoadBalance → 7. Invoker → 8. Protocol → 9. Exchanger → 10. Transporter(Netty)

Provider端:
1. Transporter(Netty) → 2. Exchanger → 3. Protocol → 4. Filter链 → 5. Invoker → 6. 实际服务实现

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

// 1. 代理层：生成代理对象
UserService proxy = Proxy.getProxy(UserService.class);

// 2. 调用时，代理对象调用InvokerInvocationHandler
public Object invoke(Object proxy, Method method, Object[] args) {
    // 3. 构建RpcInvocation
    RpcInvocation invocation = new RpcInvocation(method, args);

    // 4. 通过Directory获取所有可用Invoker
    List<Invoker> invokers = directory.list(invocation);

    // 5. Router过滤（标签路由、条件路由等）
    invokers = router.route(invokers, invocation);

    // 6. LoadBalance选择一个Invoker
    Invoker invoker = loadBalance.select(invokers, invocation);

    // 7. 发起远程调用
    Result result = invoker.invoke(invocation);

    return result.getValue();
}

1
2
3
4
5

public interface Invoker<T> {
    Class<T> getInterface();      // 服务接口
    URL getUrl();                  // 服务地址
    Result invoke(Invocation invocation);  // 执行调用
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

// 自定义Filter示例
@Activate(group = {CommonConstants.CONSUMER, CommonConstants.PROVIDER})
public class LogFilter implements Filter {

    @Override
    public Result invoke(Invoker<?> invoker, Invocation invocation) throws RpcException {
        long startTime = System.currentTimeMillis();
        String methodName = invocation.getMethodName();

        try {
            // 前置处理
            log.info("调用方法: {}", methodName);

            // 执行调用
            Result result = invoker.invoke(invocation);

            // 后置处理
            long cost = System.currentTimeMillis() - startTime;
            log.info("方法 {} 耗时: {}ms", methodName, cost);

            return result;
        } catch (Exception e) {
            log.error("调用异常: {}", e.getMessage());
            throw e;
        }
    }
}

1

logFilter=com.lucius.eduAgentX.filter.LogFilter

1
2
3

public interface Directory<T> {
    List<Invoker<T>> list(Invocation invocation);  // 获取所有Invoker
}

1
2
3

public interface Router {
    List<Invoker<?>> route(List<Invoker<?>> invokers, Invocation invocation);
}

1
2
3
4
5
6
7
8

# 条件路由：北京机房的消费者只调用北京机房的提供者
conditions:
  - "host = 192.168.1.* => host = 192.168.1.*"

# 标签路由：灰度发布
tags:
  - name: gray
    addresses: [192.168.1.100, 192.168.1.101]

1
2

@DubboService注解 → ServiceBean → ServiceConfig.export() → 
Protocol.export() → 启动Server → 注册到注册中心

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

// 1. Spring扫描@DubboService注解，创建ServiceBean
@DubboService
public class UserServiceImpl implements UserService { }

// 2. ServiceConfig.export()
public void export() {
    // 2.1 检查配置
    checkAndUpdateSubConfigs();

    // 2.2 构建URL
    URL url = new URL(protocol, host, port, path, parameters);

    // 2.3 通过Protocol暴露服务
    Exporter<?> exporter = protocol.export(invoker);

    // 2.4 注册到注册中心
    registry.register(url);
}

// 3. Protocol.export() - 以Triple协议为例
public <T> Exporter<T> export(Invoker<T> invoker) {
    // 启动HTTP/2 Server
    openServer(url);
    return new TripleExporter<>(invoker);
}

1
2

@DubboReference注解 → ReferenceBean → ReferenceConfig.get() → 
Protocol.refer() → 创建代理对象

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

// 1. Spring扫描@DubboReference注解
@DubboReference
private UserService userService;

// 2. ReferenceConfig.get()
public T get() {
    // 2.1 从注册中心订阅服务
    List<URL> urls = registry.lookup(url);

    // 2.2 创建Invoker
    Invoker<T> invoker = protocol.refer(type, url);

    // 2.3 创建代理对象
    return proxyFactory.getProxy(invoker);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

// 服务提供者 - 不同分组
@DubboService(group = "primary")
public class PrimaryUserServiceImpl implements UserService { }

@DubboService(group = "backup")
public class BackupUserServiceImpl implements UserService { }

// 服务消费者 - 指定分组
@DubboReference(group = "primary")
private UserService primaryUserService;

// 多版本共存
@DubboService(version = "1.0.0")
public class UserServiceV1Impl implements UserService { }

@DubboService(version = "2.0.0")
public class UserServiceV2Impl implements UserService { }

// 消费者指定版本
@DubboReference(version = "2.0.0")
private UserService userService;

// 消费者随机调用任意版本
@DubboReference(version = "*")
private UserService userService;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

// Consumer端设置
RpcContext.getClientAttachment().setAttachment("traceId", "123456");
RpcContext.getClientAttachment().setAttachment("userId", "1001");

// 调用服务
userService.getById(1L);

// Provider端获取
String traceId = RpcContext.getServerAttachment().getAttachment("traceId");
String userId = RpcContext.getServerAttachment().getAttachment("userId");

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

// 存根实现
public class UserServiceStub implements UserService {
    private final UserService userService;

    public UserServiceStub(UserService userService) {
        this.userService = userService;
    }

    @Override
    public User getById(Long id) {
        // 前置校验
        if (id == null || id <= 0) {
            return null;
        }
        // 调用远程服务
        return userService.getById(id);
    }
}

// 配置
@DubboReference(stub = "com.lucius.eduAgentX.stub.UserServiceStub")
private UserService userService;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

// Mock实现
public class UserServiceMock implements UserService {
    @Override
    public User getById(Long id) {
        // 返回默认值或从缓存获取
        User user = new User();
        user.setId(id);
        user.setUserName("默认用户");
        return user;
    }
}

// 配置 - 失败时Mock
@DubboReference(mock = "com.lucius.eduAgentX.mock.UserServiceMock")
private UserService userService;

// 配置 - 强制Mock（不调用远程）
@DubboReference(mock = "force:com.lucius.eduAgentX.mock.UserServiceMock")
private UserService userService;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

dubbo:
    #作为服务端的时候
  provider:
    # 服务端最大连接数
    accepts: 1000
    # 每个服务的线程数
    threads: 200
    # 线程池类型
    threadpool: fixed
    #作为客户端的时候，和服务端建立的连接数量取决于端口数
  consumer:
    # 每个服务的连接数，这里指的是一个服务和一个客户端之间最大连接数
    connections: 1
    # 是否共享连接
    shareconnections: true

1
2
3

// 为特定服务配置多连接
@DubboReference(connections = 10)
private UserService userService;

1
2
3
4

// 避免一次返回大量数据
public interface UserService {
    Page<User> listByPage(int pageNum, int pageSize);
}

1
2
3
4

// 服务端流
public interface UserService {
    StreamObserver<User> listAllUsers(StreamObserver<User> responseObserver);
}

1
2
3

dubbo:
  protocol:
    payload: 8388608  # 8MB，默认是8MB

1
2
3
4
5
6
7

dubbo:
  provider:
    payload: 8388608
  protocol:
    # 启用压缩
    parameters:
      compressor: gzip

1
2
3
4

// 通过Admin或API动态修改配置
ConfigCenterConfig config = new ConfigCenterConfig();
config.setAddress("nacos://127.0.0.1:8848");
// 动态修改超时时间、权重等

1
2
3
4
5

# 通过规则配置降级
override:
  - service: com.lucius.eduAgentX.service.UserService
    parameters:
      mock: force:return null

1
2
3
4
5

# 黑白名单
accesslog:
  - service: com.lucius.eduAgentX.service.UserService
    whitelist: [192.168.1.*]
    blacklist: [192.168.2.*]

1
2
3
4
5
6

# 动态调整权重
override:
  - service: com.lucius.eduAgentX.service.UserService
    address: 192.168.1.100
    parameters:
      weight: 200

1
2
3
4
5
6
7

接口级：每个接口都注册一条记录
  - UserService → provider1, provider2
  - OrderService → provider1, provider2

应用级：每个应用只注册一条记录
  - user-service → provider1, provider2
  - 元数据单独存储

1
2
3

dubbo:
  provider:
    accesslog: true  # 或指定文件路径

1
2
3
4

// 通过QoS命令
telnet localhost 22222
> ls  // 列出服务
> count UserService  // 查看调用统计

1
2

// 集成SkyWalking或Zipkin
// 通过Filter传递TraceId

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

问题：No provider available
排查：
1. 检查服务是否启动
2. 检查注册中心连接
3. 检查group/version是否匹配
4. 检查网络是否通畅

问题：Timeout
排查：
1. 检查Provider处理时间
2. 检查网络延迟
3. 调整timeout配置
4. 检查线程池是否满了

1
2
3
4
5

用户请求 → 限流检查 → Lua脚本原子操作 → 返回结果
                           ↓
                    临时数据写入Redis
                           ↓
                    定时任务批量同步到MySQL

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

@Override
public BaseResponse<Boolean> snatchTheSubject(SnatchRequest request, HttpServletRequest httpRequest) {
    User loginUser = userService.getLoginUser(httpRequest);
    Long studentId = loginUser.getId();
    Long subjectId = request.getSubjectId();

    // 1. 检查Redis中是否有课程容量数据
    Integer capacity = snatchCacheService.getSubjectCapacityWithCache(subjectId);
    if (capacity == null) {
        snatchSubjectService.initSubjectCapacityToRedis(subjectId);
    }

    // 2. 执行Lua脚本抢课
    Long result = snatchCacheService.snatchWithCache(studentId, subjectId);

    // 3. 处理返回结果
    if (result == -1) {
        throw new BusinessException(ErrorCode.OPERATION_ERROR, "已抢课，不能重复抢课");
    }
    if (result == -2) {
        throw new BusinessException(ErrorCode.OPERATION_ERROR, "课程余量不足");
    }
    if (result == 1) {
        return ResultUtils.success(true);
    }
    throw new BusinessException(ErrorCode.SYSTEM_ERROR, "抢课失败");
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

subject:capacity          # Hash: 课程容量
  ├── 1 → 100
  └── 2 → 50

snatch:{studentId}        # Hash: 学生已抢课程
  ├── 1 → 1
  └── 3 → 1

snatch:temp:{timeSlice}   # Hash: 临时抢课数据
  ├── 1001:1 → 1          # 学生1001抢了课程1
  └── 1002:1 → -1         # 学生1002退了课程1

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

@Scheduled(fixedRate = 10000)
@Transactional(rollbackFor = Exception.class)
public void run() {
    String lastTimeSlice = RedisKeyUtil.getLastTimeSlice();
    syncSnatch2DBByTimeSlice(lastTimeSlice);
}

public void syncSnatch2DBByTimeSlice(String timeSlice) {
    String tempSnatchKey = RedisKeyUtil.getTempSnatchKey(timeSlice);
    Map<Object, Object> allTempSnatchMap = redisTemplate.opsForHash().entries(tempSnatchKey);

    List<Snatch> snatchListToInsert = new ArrayList<>();
    List<Snatch> snatchListToDelete = new ArrayList<>();

    for (Object key : allTempSnatchMap.keySet()) {
        String[] parts = key.toString().split(":");
        Long studentId = Long.valueOf(parts[0]);
        Long subjectId = Long.valueOf(parts[1]);
        Integer snatchType = Integer.valueOf(allTempSnatchMap.get(key).toString());

        if (snatchType == 1) {  // 抢课
            snatchListToInsert.add(new Snatch(studentId, subjectId));
        } else if (snatchType == -1) {  // 退课
            snatchListToDelete.add(new Snatch(studentId, subjectId));
        }
    }

    // 批量操作
    if (!snatchListToInsert.isEmpty()) {
        snatchService.saveBatch(snatchListToInsert);
    }
    // ...
}

1
2
3
4
5
6
7

@Scheduled(cron = "0 0 2 * * *")
public void run() {
    Set<String> snatchKeys = redisTemplate.keys("snatch:temp:*");
    for (String timeSlice : extractTimeSlices(snatchKeys)) {
        syncSnatch2DBJob.syncSnatch2DBByTimeSlice(timeSlice);
    }
}

1
2
3
4
5
6
7

public static String getCurrentTimeSlice() {
    Date now = new Date();
    int second = DateUtil.second(now);
    int alignedSecond = (second / 10) * 10;  // 向下取整到10的倍数
    return DateUtil.format(now, "HH:mm:") + String.format("%02d", alignedSecond);
}
// 例如：14:30:00, 14:30:10, 14:30:20...

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

@Aspect
@Component
public class RateLimitAspect {
    private static final DefaultRedisScript<Long> RATE_LIMIT_SCRIPT = new DefaultRedisScript<>("""
        local key = KEYS[1]
        local window = tonumber(ARGV[1])
        local limit = tonumber(ARGV[2])
        local current = tonumber(ARGV[3])

        -- 移除窗口外的记录
        redis.call('ZREMRANGEBYSCORE', key, 0, current - window * 1000)

        -- 统计当前窗口内的请求数
        local currentCount = redis.call('ZCARD', key)

        if currentCount < limit then
            -- 未超限，记录本次请求
            redis.call('ZADD', key, current, current)
            redis.call('EXPIRE', key, window)
            return limit - currentCount - 1  -- 返回剩余次数
        else
            return -1  -- 超限
        end
        """, Long.class);

    @Around("@annotation(rateLimit)")
    public Object around(ProceedingJoinPoint point, RateLimit rateLimit) throws Throwable {
        String limitKey = buildLimitKey(rateLimit);

        Long remaining = redisTemplate.execute(
            RATE_LIMIT_SCRIPT,
            Collections.singletonList(limitKey),
            rateLimit.window(),
            rateLimit.limit(),
            System.currentTimeMillis()
        );

        if (remaining != null && remaining < 0) {
            throw new BusinessException(ErrorCode.OPERATION_ERROR, "操作过于频繁，请稍后重试");
        }
        return point.proceed();
    }
}

1
2
3
4
5

@RateLimit(key = "snatch", window = 1, limit = 5, type = "user")
@PostMapping("/save")
public BaseResponse<Boolean> snatchTheSubject(@RequestBody SnatchRequest request) {
    // ...
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

spring:
  data:
    redis:
      lettuce:
        pool:
          max-active: 100    # 最大连接数
          max-idle: 50
          min-idle: 10
  datasource:
    hikari:
      maximum-pool-size: 50
      minimum-idle: 10

server:
  tomcat:
    threads:
      max: 500
      min-spare: 50
    max-connections: 10000

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

// 使用CASE WHEN批量更新
@Update("""
    UPDATE snatch_subject 
    SET capacity = CASE subject_id 
        <foreach collection="list" item="item">
            WHEN #{item.subjectId} THEN capacity + #{item.change}
        </foreach>
    END
    WHERE subject_id IN 
        <foreach collection="list" item="item" open="(" separator="," close=")">
            #{item.subjectId}
        </foreach>
""")
void batchUpdateSubjectCapacity(@Param("list") List<SubjectCapacityChangeDTO> list);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

private CompiledGraph<MessagesState<String>> createQuestionWorkflow() {
    return new MessagesStateGraph<String>()
        // 添加节点
        .addNode("ques_knowledge_result_node", QuesKnowledgeResultNode.create())
        .addNode("ques_task_list_node", QuesTaskListNode.create())
        .addNode("ques_generate_node", QuesGenerateNode.create())
        .addNode("ques_parse_check_node", QuesParseCheckNode.create())
        // 添加边
        .addEdge(START, "ques_knowledge_result_node")
        .addEdge("ques_knowledge_result_node", "ques_task_list_node")
        .addEdge("ques_task_list_node", "ques_generate_node")
        .addEdge("ques_generate_node", "ques_parse_check_node")
        // 条件路由
        .addConditionalEdges("ques_parse_check_node",
            edge_async(this::routeAfterCheck),
            Map.of(
                "continue_generate", "ques_generate_node",
                "retry_generate", "ques_generate_node",
                "finish", END
            ))
        .compile();
}

private String routeAfterCheck(MessagesState<String> state) {
    QuestionGenerateContext context = QuestionGenerateContext.getContext(state);
    Boolean checkResult = context.getCheckResult();

    if (checkResult == null || !checkResult) {
        return "retry_generate";  // 质检未通过，重新生成
    }

    context.setCurrentQuestionIndex(context.getCurrentQuestionIndex() + 1);

    if (context.getQuestionNum() > 0) {
        return "continue_generate";  // 继续生成下一题
    }
    return "finish";  // 完成
}