1
package com.zwlh.powergrid.contract.infrastructure.cache;
2

3
public interface CacheChangeHandler {
4
    boolean supports(CacheDomain domain, CacheChangeAction action);
5

6
    void handle(CacheChangeRequest request);
7
}

1
package com.zwlh.powergrid.contract.modules.access.infrastructure.cache;
2

3
import com.zwlh.powergrid.contract.common.constant.CacheKey;
4
import com.zwlh.powergrid.contract.common.util.RedisUtil;
5
import com.zwlh.powergrid.contract.infrastructure.cache.CacheChangeAction;
6
import com.zwlh.powergrid.contract.infrastructure.cache.CacheChangeHandler;
7
import com.zwlh.powergrid.contract.infrastructure.cache.CacheChangeRequest;
8
import com.zwlh.powergrid.contract.infrastructure.cache.CacheDomain;
9
import lombok.RequiredArgsConstructor;
10
import org.springframework.stereotype.Component;
11

12
@Component
13
@RequiredArgsConstructor
14
public class LegacyUserInfoCacheHandler implements CacheChangeHandler {
15
    private final RedisUtil redisUtil;
16

17
    @Override
18
    public boolean supports(CacheDomain domain, CacheChangeAction action) {
19
        return domain == CacheDomain.USER_AUTHORIZATION && action == CacheChangeAction.LEGACY_EVICT;
20
    }
21

22
    @Override
23
    public void handle(CacheChangeRequest request) {
24
        if (request.keys() == null || request.keys().isEmpty()) {
25
            return;
26
        }
27
        // 删除原来CacheKey.USER_INFO_KEY不再使用
28
        String[] keys = request.keys().stream()
29
                .map(userId -> String.format(CacheKey.USER_INFO_KEY, userId))
30
                .toArray(String[]::new);
31
        redisUtil.del(keys);
32
    }
33
}

1
CREATE TABLE IF NOT EXISTS contract_revision (
2
    contract_name VARCHAR(64) PRIMARY KEY,
3
    revision BIGINT NOT NULL DEFAULT 1 CHECK (revision > 0),
4
    updated_time TIMESTAMPTZ NOT NULL DEFAULT now(),
5
    reason VARCHAR(128) NOT NULL DEFAULT 'bootstrap'
6
);
7

8
INSERT INTO contract_revision(contract_name, revision, reason)
9
VALUES ('USER_AUTHORIZATION', 1, 'bootstrap')
10
ON CONFLICT (contract_name) DO NOTHING;

1
package com.zwlh.powergrid.contract.infrastructure.revision;
2

3
import com.zwlh.powergrid.contract.infrastructure.cache.CacheDomain;
4

5
import java.util.Arrays;
6
import java.util.Optional;
7

8
public enum RevisionSubject {
9
    USER_AUTHORIZATION(CacheDomain.USER_AUTHORIZATION);
10

11
    private final CacheDomain cacheDomain;
12

13
    RevisionSubject(CacheDomain cacheDomain) {
14
        this.cacheDomain = cacheDomain;
15
    }
16

17
    public CacheDomain cacheDomain() {
18
        return cacheDomain;
19
    }
20

21
    public static Optional<RevisionSubject> fromCacheDomain(CacheDomain cacheDomain) {
22
        if (cacheDomain == null) {
23
            return Optional.empty();
24
        }
25
        return Arrays.stream(values())
26
                .filter(subject -> subject.cacheDomain == cacheDomain)
27
                .findFirst();
28
    }
29
}

1
package com.zwlh.powergrid.contract.infrastructure.revision;
2

3
import org.apache.ibatis.annotations.Mapper;
4
import org.apache.ibatis.annotations.Param;
5

6
@Mapper
7
public interface CacheRevisionMapper {
8
    // 获取当前缓存域的revision
9
    Long currentRevision(@Param("revisionSubject") RevisionSubject revisionSubject);
10
  // 如果不存在，则新建
11
    int insertIfAbsent(@Param("revisionSubject") RevisionSubject revisionSubject,
12
                       @Param("reason") String reason);
13
  // 更新revision
14
    long advanceRevision(@Param("revisionSubject") RevisionSubject revisionSubject,
15
                         @Param("reason") String reason);
16
}

1
package com.zwlh.powergrid.contract.infrastructure.cache;
2

3
import com.zwlh.powergrid.contract.infrastructure.event.DomainEvent;
4

5
import java.util.Optional;
6

7
public interface CacheChangeRequestMapper {
8
    Optional<CacheChangeRequest> toCacheChangeRequest(DomainEvent event);
9
}

1
<?xml version="1.0" encoding="UTF-8"?>
2
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
3
<mapper namespace="com.zwlh.powergrid.contract.infrastructure.revision.CacheRevisionMapper">
4
    <select id="currentRevision" resultType="java.lang.Long">
5
        SELECT revision
6
        FROM contract_revision
7
        WHERE contract_name = #{revisionSubject}
8
    </select>
9

10
    <insert id="insertIfAbsent">
11
        INSERT INTO contract_revision(contract_name, revision, reason)
12
        VALUES (#{revisionSubject}, 1, #{reason})
13
        ON CONFLICT (contract_name) DO NOTHING
14
    </insert>
15

16
    <select id="advanceRevision" resultType="long">
17
        UPDATE contract_revision
18
        SET revision = revision + 1,
19
            updated_time = now(),
20
            reason = #{reason}
21
        WHERE contract_name = #{revisionSubject}
22
        RETURNING revision
23
    </select>
24
</mapper>

1
package com.zwlh.powergrid.contract.infrastructure.revision;
2

3
public interface CacheRevisionService {
4
    long currentRevision(RevisionSubject revisionSubject);
5

6
    long advanceRevision(RevisionSubject revisionSubject, String reason);
7

8
    void invalidateLocalRevision(RevisionSubject revisionSubject);
9

10
    void invalidateLocalRevisionIfBehind(RevisionSubject revisionSubject, long revision);
11
}

1
package com.zwlh.powergrid.contract.infrastructure.revision;
2

3
import com.github.benmanes.caffeine.cache.Cache;
4
import com.github.benmanes.caffeine.cache.Caffeine;
5
import com.zwlh.powergrid.contract.infrastructure.cache.CacheInvalidationBroadcaster;
6
import com.zwlh.powergrid.contract.infrastructure.cache.CacheInvalidationMessage;
7
import com.zwlh.powergrid.contract.infrastructure.revision.observability.RevisionMetrics;
8
import org.springframework.beans.factory.annotation.Value;
9
import org.springframework.stereotype.Service;
10
import org.springframework.transaction.support.TransactionSynchronization;
11
import org.springframework.transaction.support.TransactionSynchronizationManager;
12

13
import java.time.Duration;
14

15
@Service
16
public class CacheRevisionServiceImpl implements CacheRevisionService {
17
    private static final long INITIAL_REVISION = 1L;
18
    private static final String BOOTSTRAP_REASON = "bootstrap";
19
    private static final Duration DEFAULT_LOCAL_CACHE_TTL = Duration.ofSeconds(1);
20

21
    private final CacheRevisionMapper cacheRevisionMapper;
22
    private final CacheInvalidationBroadcaster cacheInvalidationBroadcaster;
23
    private final RevisionMetrics revisionMetrics;
24
    private final boolean localRevisionCacheEnabled;
25
    private final Cache<RevisionSubject, Long> revisionCache;
26

27
    public CacheRevisionServiceImpl(
28
            CacheRevisionMapper cacheRevisionMapper,
29
          // 这是无效化缓存广播，后续会说
30
            CacheInvalidationBroadcaster cacheInvalidationBroadcaster,
31
          // 从配置中获取这些值，后面也会给出
32
            @Value("${contract.revision.local-cache.ttl:1s}") Duration localCacheTtl,
33
            CacheMetrics cacheMetrics
34

35
    ) {
36
        this.cacheRevisionMapper = cacheRevisionMapper;
37
        this.cacheInvalidationBroadcaster = cacheInvalidationBroadcaster;
38
        this.revisionMetrics = revisionMetrics;
39
        this.localRevisionCacheEnabled = isLocalRevisionCacheEnabled(localCacheTtl);
40
        this.revisionCache = buildRevisionCache(localCacheTtl);
41
    }
42

43
    // 从当前缓存域中获取revision
44
    @Override
45
    public long currentRevision(RevisionSubject revisionSubject) {
46
        long startNanos = System.nanoTime();
47
        if (!localRevisionCacheEnabled) {
48
            return loadAndRecordCurrentRevision(revisionSubject, "db", startNanos);
49
        }
50

51
        Long cachedRevision = revisionCache.getIfPresent(revisionSubject);
52

53
        if (cachedRevision != null) {
54
            // 埋点，记录 revision 读取来自本地 Caffeine
55
            revisionMetrics.recordRevisionRequest(
56
                    revisionSubject.cacheDomain(),
57
                    "local",
58
                    "success",
59
                    System.nanoTime() - startNanos
60
            );
61
            return cachedRevision;
62
        }
63
        // 直接读DB
64
        return loadAndCacheCurrentRevision(revisionSubject, startNanos);
65
    }
66

67

68
  //更新缓存域revision并且附上更新理由
69
    @Override
70
    public long advanceRevision(RevisionSubject revisionSubject, String reason) {
71
        long startNanos = System.nanoTime();
72
        try {
73
            long revision = cacheRevisionMapper.advanceRevision(revisionSubject, reason);
74
            // 埋点，判断 revision 迭代是否成功或变慢，System.nanoTime() - startNanos将会在Signoz中作为观察项。
75
            // 如果变慢的话，先看是不是单个domain，如果只是某个domain慢，说明缓存域写推进率或者事务冲突高。
76
            // 需要重点排查：contract_revision行级锁等待，慢SQL，DB CPU/IO，连接池耗尽，事务慢操作拖累，大量权限/角色后台操作同时发生，是否把高频写场景错误构建成 revision 缓存域的问题。
77
            revisionMetrics.recordRevisionAdvance(
78
                    revisionSubject.cacheDomain(),
79
                    "success",
80
                    System.nanoTime() - startNanos
81
            );
82
            refreshCacheAfterCommit(revisionSubject, revision, reason);
83
            return revision;
84
        } catch (RuntimeException ex) {
85
            // 埋点，判断 revision 迭代失败
86
            // contract_revision是否缺行、mapper SQL是否失败、DB连接是否异常、事务是否已经被标记rollback-only，contract_name的枚举值是否与表内值一致，PostgreSQL的 RETURNING revision是否正常返回，是否有 schema 变更、权限问题、连接池问题。
87
            revisionMetrics.recordRevisionAdvance(
88
                    revisionSubject.cacheDomain(),
89
                    "error",
90
                    System.nanoTime() - startNanos
91
            );
92
            throw ex;
93
        }
94
    }
95

96

97
    // 无效化本地revision
98
    @Override
99
    public void invalidateLocalRevision(RevisionSubject revisionSubject) {
100
        if (!localRevisionCacheEnabled) {
101
            return;
102
        }
103
        revisionCache.invalidate(revisionSubject);
104
    }
105

106
    // 在失效之前需要做一下乱序/重复校验，避免高并发下因为Pub/Sub的乱序导致不必要的缓存失效与DB回源。
107
    @Override
108
    public void invalidateLocalRevisionIfBehind(RevisionSubject revisionSubject, long revision) {
109
        if (!localRevisionCacheEnabled) {
110
            return;
111
        }
112
        Long localRevision = revisionCache.getIfPresent(revisionSubject);
113
        if (localRevision != null && revision <= localRevision) {
114
            return;
115
        }
116
        if (localRevision != null) {
117
            // 埋点，实例收到较新 revision 广播时，如果本地仍有旧 revision， 说明确实发生过跨实例旧 revision 窗口
118
            // 这个指标要是上升的话，说明乱序现象正在逐步提高，确实存在实例本地 revision 落后情况。
119
            // 检查 Redis 连接、应用实例负载、线程池、GC、网络延迟、订阅容器状态
120
            // 乱序/延迟增加常见原因是消费端卡顿或网络抖动。
121
            revisionMetrics.recordRevisionStaleDetected(revisionSubject.cacheDomain());
122
        }
123
        revisionCache.invalidate(revisionSubject);
124
    }
125

126

127
    // 在事务成功提交后刷新revision值并附上理由
128
    private void refreshCacheAfterCommit(RevisionSubject revisionSubject, long revision, String reason) {
129
        // 判断当前线程是否已经开启了Spring的事务同步机制（有没有一个可以注册事务回调的contxt）
130
        if (!TransactionSynchronizationManager.isSynchronizationActive()) {
131
            // 不在事务中，直接发布 revision 变更广播
132
            publishRevisionChanged(revisionSubject, revision, reason);
133
            // 刷新当前实例本地 Caffeine revision cache
134
        refreshLocalRevisionCache(revisionSubject, revision);
135
            return;
136
        }
137
        // 如果当前在Spring事务同步上下文
138
        TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronization() {
139
            // 注册afterCommit回调
140
            @Override
141
            public void afterCommit() {
142
                // 事务提交后，再执行广播以及本地Caffeine缓存更新。
143
                publishRevisionChanged(revisionSubject, revision, reason);
144
          refreshLocalRevisionCache(revisionSubject, revision);
145
            }
146
        });
147
    }
148
  // 推送当前缓存域revision更新的事件
149
    private void publishRevisionChanged(RevisionSubject revisionSubject, long revision, String reason) {
150
        cacheInvalidationBroadcaster.publish(CacheInvalidationMessage.revisionChanged(
151
                revisionSubject.cacheDomain(),
152
                revision,
153
                reason
154
        ));
155
    }
156

157
  // 从数据库中读取当前缓存域的Revision，如果没有则新建后返回
158
    private Long loadCurrentRevision(RevisionSubject revisionSubject) {
159
        Long revision = cacheRevisionMapper.currentRevision(revisionSubject);
160
        if (revision != null) {
161
            return revision;
162
        }
163
        cacheRevisionMapper.insertIfAbsent(revisionSubject, BOOTSTRAP_REASON);
164
        Long initializedRevision = cacheRevisionMapper.currentRevision(revisionSubject);
165
        return initializedRevision != null ? initializedRevision : INITIAL_REVISION;
166
    }
167

168
    // 用在本地 Caffeine revision cache 启用，但当前本地没有值的场景（Caffeine miss）：
169
    private long loadAndCacheCurrentRevision(RevisionSubject revisionSubject, long startNanos) {
170
        try {
171
            // 回源 DB
172
            Long revision = revisionCache.get(revisionSubject, this::loadCurrentRevision);
173
            // 埋点，记录 revision 来源为DB
174
            // 如果这个指标变多，说明本地 cache 正在更多回源DB，可能是 TTL 兜底在发挥作用。
175
            revisionMetrics.recordRevisionRequest(
176
                    revisionSubject.cacheDomain(),
177
                    "db",
178
                    "success",
179
                    System.nanoTime() - startNanos
180
            );
181
            return revision;
182
        } catch (RuntimeException ex) {
183
            // 埋点，记录revision读取失败及其来源为DB
184
            revisionMetrics.recordRevisionRequest(
185
                    revisionSubject.cacheDomain(),
186
                    "db",
187
                    "error",
188
                    System.nanoTime() - startNanos
189
            );
190
            throw ex;
191
        }
192
    }
193
    // 读取 revision 但本地 revision cache 被禁用的场景，比如 TTL 配成 0s：
194
    private long loadAndRecordCurrentRevision(RevisionSubject revisionSubject, String source, long startNanos) {
195
        try {
196
            // 直接查 DB
197
            long revision = loadCurrentRevision(revisionSubject);
198
            // 记录 revision 来源为 DB，成功
199
            revisionMetrics.recordRevisionRequest(
200
                    revisionSubject.cacheDomain(),
201
                    source,
202
                    "success",
203
                    System.nanoTime() - startNanos
204
            );
205
            return revision;
206
        } catch (RuntimeException ex) {
207
            // 记录 revision 来源为 DB，失败
208
            revisionMetrics.recordRevisionRequest(
209
                    revisionSubject.cacheDomain(),
210
                    source,
211
                    "error",
212
                    System.nanoTime() - startNanos
213
            );
214
            throw ex;
215
        }
216
    }
217

218
    // 创建缓存域的本地revision caffeine TTL缓存
219
    private Cache<RevisionSubject, Long> buildRevisionCache(Duration ttl) {
220
        // TTL为负数或者为null的时候，设置一个默认的TTL值。
221
        Duration effectiveTtl = ttl == null || ttl.isNegative() ? DEFAULT_LOCAL_CACHE_TTL : ttl;
222
        // 当前实例在本地设置caffeine缓存值。
223
        Caffeine<Object, Object> builder = Caffeine.newBuilder();
224
        if (!effectiveTtl.isZero()) {
225
            // 非0 TTL才设置过期
226
            builder.expireAfterWrite(effectiveTtl);
227
        }
228
        return builder.build();
229
    }
230

231
    private boolean isLocalRevisionCacheEnabled(Duration ttl) {
232
        return ttl == null || ttl.isNegative() || !ttl.isZero();
233
    }
234

235
}

1
package com.zwlh.powergrid.contract.infrastructure.cache;
2

3
public interface CacheInvalidationBroadcaster {
4
    void publish(CacheInvalidationMessage message);
5
}

1
package com.zwlh.powergrid.contract.infrastructure.cache;
2

3
import java.time.Instant;
4
import java.util.UUID;
5

6
public record CacheInvalidationMessage(
7
        // 缓存域
8
        CacheDomain domain,
9
      // 缓存变更行为
10
        CacheChangeAction action,
11
        // 缓存域版本
12
        Long revision,
13
      // 变更理由
14
        String reason,
15
        UUID eventId,
16
        Instant occurredAt
17
) {
18
    public static CacheInvalidationMessage revisionChanged(CacheDomain domain,
19
                                                           long revision,
20
                                                           String reason) {
21
        return new CacheInvalidationMessage(
22
                domain,
23
                CacheChangeAction.BUMP_REVISION,
24
                revision,
25
                reason,
26
                UUID.randomUUID(),
27
                Instant.now()
28
        );
29
    }
30
}

1
package com.zwlh.powergrid.contract.infrastructure.cache;
2

3
public enum CacheChangeAction {
4
    EVICT,// 普通缓存删除动作，知道key可以直接删的场景
5
    BUMP_REVISION,// revision 广播动作，不删除 Redis 授权snapshot，只通知其它实例失效本地 revision cache
6
    REFRESH,// 重建/刷新缓存
7
    LEGACY_EVICT// 迁移期使用，清理旧缓存key，不跟新的 revision + versioned key主链路混一块。
8
}

1
package com.zwlh.powergrid.contract.infrastructure.cache;
2

3
import com.zwlh.powergrid.contract.infrastructure.cache.observability.CacheMetrics;
4
import lombok.RequiredArgsConstructor;
5
import lombok.extern.slf4j.Slf4j;
6
import org.springframework.data.redis.core.RedisTemplate;
7
import org.springframework.stereotype.Component;
8

9
@Slf4j
10
@Component
11
@RequiredArgsConstructor
12
public class RedisCacheInvalidationBroadcaster implements CacheInvalidationBroadcaster {
13
    private final RedisTemplate<String, Object> redisTemplate;
14
    private final CacheBroadcastProperties properties;
15
    private final CacheMetrics cacheMetrics;
16

17
    @Override
18
    public void publish(CacheInvalidationMessage message) {
19
        if (!properties.enabled()) {
20
            cacheMetrics.recordInvalidationPublish(message.domain(), message.action(), "disabled");
21
            return;
22
        }
23
        try {
24
            redisTemplate.convertAndSend(properties.channel(), message);
25
            // 埋点，记录广播发送成功
26
            // publish success 正常，但 receive error 增多：说明消费端本地处理异常。
27
            cacheMetrics.recordInvalidationPublish(message.domain(), message.action(), "success");
28
        } catch (RuntimeException ex) {
29
            // 埋点，记录广播发送失败
30
            // 这个指标如果变多的话，说明旧读窗口会变大，其他实例收不到 BUMP_REVISION，不会马上清理本地的 revision cache，最终靠本地的Caffeine缓存过期后回源DB。
31
            // 风险点主要是看TTL的持续时间，如果设计权限放行、审批状态、运行配置等高风险读路径，需要谨慎考虑。
32
            // publish error 增多，receive accepted 下降：广播发送端或 Redis Pub/Sub 链路异常。
33
            // 需要排查 Redis 连接以及 channel 配置
34
            // 连接池、网络抖动、redisTemplate等，然后再看实例日志，如果只有某个实例有问题，再具体情况具体分析。
35
            cacheMetrics.recordInvalidationPublish(message.domain(), message.action(), "error");
36
            log.warn("缓存失效广播发送失败: domain={}, action={}, reason={}",
37
                    message.domain(), message.action(), message.reason(), ex);
38
        }
39
    }
40
}

1
package com.zwlh.powergrid.contract.infrastructure.cache;
2

3
import org.springframework.boot.context.properties.ConfigurationProperties;
4

5
@ConfigurationProperties(prefix = "cache.broadcast")
6
public record CacheBroadcastProperties(
7
        boolean enabled,
8
        String channel
9
) {
10
    public CacheBroadcastProperties {
11
        if (channel == null || channel.isBlank()) {
12
            channel = "cache:invalidation";
13
        }
14
    }
15
}

1
cache:
2
  broadcast:
3
    enabled: ${CACHE_BROADCAST_ENABLED:true} # 默认广播行为开启
4
    channel: ${CACHE_BROADCAST_CHANNEL:cache:invalidation} # 默认channel为invalidation，按照自己项目实际情况填写。

1
package com.zwlh.powergrid.contract.infrastructure.config.redis;
2

3
import com.zwlh.powergrid.contract.infrastructure.cache.CacheBroadcastProperties;
4
import com.zwlh.powergrid.contract.infrastructure.cache.CacheInvalidationSubscriber;
5
import org.springframework.boot.context.properties.EnableConfigurationProperties;
6
import org.springframework.context.annotation.Bean;
7
import org.springframework.context.annotation.Configuration;
8
import org.springframework.data.redis.connection.RedisConnectionFactory;
9
import org.springframework.data.redis.core.RedisTemplate;
10
import org.springframework.data.redis.listener.ChannelTopic;
11
import org.springframework.data.redis.listener.RedisMessageListenerContainer;
12
import org.springframework.data.redis.listener.adapter.MessageListenerAdapter;
13

14
@Configuration
15
@EnableConfigurationProperties(CacheBroadcastProperties.class)
16
public class RedisPubSubConfig {
17

18
    @Bean
19
    MessageListenerAdapter cacheInvalidationMessageListenerAdapter(
20
            CacheInvalidationSubscriber subscriber,
21
            RedisTemplate<String, Object> redisTemplate
22
    ) {
23
        // 创建了一个 MessageListenerAdapter ，就是说 Redis 收到消息后，把消息交给 CacheInvalidationSubscriber 的 handleMessage 方法进行处理
24
        MessageListenerAdapter adapter = new MessageListenerAdapter(subscriber, "handleMessage");
25
        // 发送方使用的是redisTemplate.convertAndSend(properties.channel(), message);
26
        // Pub/Sub 的发送端和接收端使用同一套消息序列化规则，这里接收端要使用同一个 RedisTemplate 的 value serializer 反序列化消息。
27
        // 这样 MessageListenerAdapter 才能把 Redis 消息转换成 CacheInvalidationMessage。
28
        // 另外注意，这里要做专门的new Jackson2JsonRedisSerializer<>(objectMapper, CacheInvalidationMessage.class))反序列化到强类型handler，否则跨实例下会没有 receive/stale 指标，难以从压测中判断跨实例测试。
29
        adapter.setSerializer(new Jackson2JsonRedisSerializer<>(objectMapper, CacheInvalidationMessage.class));
30

31
        return adapter;
32
    }
33

34
    @Bean
35
    RedisMessageListenerContainer cacheInvalidationListenerContainer(
36
            RedisConnectionFactory connectionFactory,
37
            CacheBroadcastProperties properties,
38
            MessageListenerAdapter cacheInvalidationMessageListenerAdapter
39
    ) {
40
        // `RedisMessageListenerContainer` 是 Spring Data Redis 提供的消息监听容器，负责维护Redis Pub/Sub 的订阅连接，并把收到的消息分发给具体的 listener。
41
        RedisMessageListenerContainer container = new RedisMessageListenerContainer();
42
        // 设置 Redis 连接来源。
43
        container.setConnectionFactory(connectionFactory);
44
        // 查看当前channel是否已经启用
45
        if (properties.enabled()) {
46
            // 订阅该channel
47
            container.addMessageListener(
48
                    cacheInvalidationMessageListenerAdapter,
49
                    ChannelTopic.of(properties.channel())
50
            );
51
        }
52
        return container;
53
    }
54
}