package com.ruoyi.satisfaction.api;
|
|
import com.ruoyi.common.core.service.IConfigService;
|
import com.ruoyi.common.exception.ServiceException;
|
import com.ruoyi.satisfaction.config.SatisfactionAvailabilityInterceptor;
|
import com.ruoyi.satisfaction.config.SatisfactionProperties;
|
import com.ruoyi.satisfaction.config.SatisfactionSwitch;
|
import com.ruoyi.satisfaction.config.SatisfactionWebConfig;
|
import com.ruoyi.satisfaction.service.strategy.CommonSatisfactionScoreStrategy;
|
import com.ruoyi.satisfaction.service.strategy.SatisfactionScoreStrategyResolver;
|
import com.ruoyi.satisfaction.service.strategy.SatisfactionSites;
|
import com.ruoyi.satisfaction.service.strategy.SltdSatisfactionScoreStrategy;
|
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
|
|
import java.util.Collections;
|
import java.util.List;
|
import java.util.Map;
|
|
/**
|
* 满意度模块的 <b>真实 Spring 容器</b>装配校验（不依赖 JUnit，也不依赖数据库）。
|
* <p>
|
* 为什么需要这个检查：本模块的几个"静态校验"（Mapper 一致性、逐行等价、策略等价）都只能证明
|
* <b>代码内容</b>正确，证明不了 <b>Spring 能把 Bean 装起来</b>。实际踩过两个坑：
|
* <ol>
|
* <li>{@link SatisfactionFacade} 有两个公开构造器，Spring 因"构造器不唯一"退回找无参构造器
|
* → 启动期 {@code No default constructor found}；</li>
|
* <li>{@code SatisfactionApi} 的按类型查找会把门面<b>自己</b>当兜底候选
|
* → 门面把请求转发给自己 → {@code StackOverflowError}。</li>
|
* </ol>
|
* 所以这里直接起一个真实的 {@link AnnotationConfigApplicationContext}，只注册本模块
|
* <b>不依赖 Mapper / 数据库</b>的那些 Bean，验证装配与开关行为。
|
* <p>
|
* 开关本身存在 {@code sys_config} 参数表里（键 {@code satisfaction.enabled}，运行时热读），
|
* 因此这里用一个假的 {@link IConfigService} 模拟参数表，验证「参数表优先、yml 兜底」。
|
*/
|
public final class SatisfactionContextCheck {
|
|
private static int failed = 0;
|
|
private SatisfactionContextCheck() {
|
}
|
|
/**
|
* 假的内部实现（真实场景里是 DefaultSatisfactionApi，它需要 Mapper/Redis，起不了轻量容器）
|
*/
|
public static class StubApi implements SatisfactionApi {
|
|
/**
|
* 分类查询被调用的次数：用来证明"参数表关闭时门面确实没有转发给实现"
|
*/
|
static final java.util.concurrent.atomic.AtomicInteger CALLS = new java.util.concurrent.atomic.AtomicInteger();
|
|
@Override
|
public boolean isEnabled() {
|
return true;
|
}
|
|
@Override
|
public Map<String, Object> getSatisfactionCategories(String orgid) {
|
CALLS.incrementAndGet();
|
return Collections.singletonMap("fromStub", orgid);
|
}
|
|
@Override
|
public SatisfactionExportBundle getQuestionOptionRatioExport(List<Long> subtaskIds, String questiontext) {
|
return SatisfactionExportBundle.empty();
|
}
|
|
@Override
|
public boolean hasSatisfactionCategory(String orgid) {
|
return true;
|
}
|
|
@Override
|
public Map<String, Object> getSatisfactionIndex(String type, String code, String orgid,
|
Long ivrCategoryid, Long svyCategoryid) {
|
return SatisfactionFacade.emptySatisfactionIndex();
|
}
|
}
|
|
/**
|
* 探针：以"旁观者"身份注入 {@code ObjectProvider<SatisfactionApi>}，看容器按类型能找到谁。
|
* <p>
|
* 它不是 {@code SatisfactionApi} 的实现，所以不存在"自引用被排除"的情况，
|
* 因此它看到的就是完整的候选集合 —— 用来证明"模块关闭时容器会把门面自己当候选"。
|
*/
|
public static class ProviderProbe {
|
|
@org.springframework.beans.factory.annotation.Autowired
|
private org.springframework.beans.factory.ObjectProvider<SatisfactionApi> provider;
|
|
SatisfactionApi rawCandidate() {
|
return provider.getIfAvailable();
|
}
|
}
|
|
public static void main(String[] args) {
|
System.out.println("=== 场景 1：参数表 satisfaction.enabled=true，且存在内部实现（DefaultSatisfactionApi 的角色）===");
|
try (AnnotationConfigApplicationContext ctx = context(true, true, ContextCheckConfig.SYS_ON)) {
|
SatisfactionFacade facade = ctx.getBean(SatisfactionFacade.class);
|
check("门面能被 Spring 实例化（构造器不再歧义）", "true", String.valueOf(facade != null));
|
check("启用时 isEnabled()", "true", String.valueOf(facade.isEnabled()));
|
check("取到的是【内部实现】而不是门面自己（stub 把 orgid 原样回填）", "ORG1",
|
String.valueOf(facade.getSatisfactionCategories("ORG1").get("fromStub")));
|
check("门面同时是 ISatisfactionCategoryService",
|
"true", String.valueOf(ctx.getBean(com.ruoyi.common.core.service.ISatisfactionCategoryService.class) == facade));
|
// 容器里应有 2 个 SatisfactionApi：门面自己 + 内部实现（门面也实现该接口，这是设计使然）
|
check("容器内 SatisfactionApi 实现数 = 门面 1 + 内部实现 1", "2",
|
String.valueOf(ctx.getBeansOfType(SatisfactionApi.class).size()));
|
check("开关读取的键名是 sys_config 的 satisfaction.enabled", SatisfactionSwitch.CONFIG_KEY,
|
String.valueOf(SatisfactionSwitch.CONFIG_KEY));
|
|
SatisfactionScoreStrategyResolver resolver = ctx.getBean(SatisfactionScoreStrategyResolver.class);
|
check("站点策略解析器装配成功，支持站点 = [common, sltd]", "[common, sltd]",
|
String.valueOf(resolver.supportedSites()));
|
check("未知站点回落到通用口径", SatisfactionSites.COMMON,
|
resolver.resolve("不存在的站点").site());
|
}
|
|
System.out.println();
|
System.out.println("=== 场景 2：参数表 satisfaction.enabled=true，但【没有】内部实现（模块没被打进应用）===");
|
try (AnnotationConfigApplicationContext ctx = context(true, false, ContextCheckConfig.SYS_ON)) {
|
SatisfactionFacade facade = ctx.getBean(SatisfactionFacade.class);
|
check("无实现时 isEnabled() 为 false", "false", String.valueOf(facade.isEnabled()));
|
// 关键：不能把门面自己当实现，否则这里会 StackOverflowError
|
String result;
|
try {
|
result = String.valueOf(facade.getSatisfactionCategories("ORG1").isEmpty());
|
} catch (StackOverflowError e) {
|
result = "StackOverflowError";
|
}
|
check("无实现时分类查询返回空 Map（不会自引用递归）", "true", result);
|
check("无实现时占比导出包为空", "true",
|
String.valueOf(facade.getQuestionOptionRatioExport(Collections.singletonList(1L), null).isEmpty()));
|
check("无实现时满意度指数为全零 Map", "0",
|
String.valueOf(facade.getSatisfactionIndex("1", "D001", "ORG1", null, null).get("mydtmzl")));
|
|
// 反证：直接问容器"按类型有哪些 SatisfactionApi 候选"，看它是否把门面自己算进去。
|
// 若这里返回的是门面自己，就说明"自引用兜底"确实存在，门面里的 self 过滤是必要的。
|
ProviderProbe probe = ctx.getBean(ProviderProbe.class);
|
check("无实现时，容器按类型只找到门面自己（证明自引用兜底存在）", "true",
|
String.valueOf(probe.rawCandidate() == facade));
|
check("但门面不会把'自己'当成实现（self 过滤生效）", "false",
|
String.valueOf(facade.isEnabled()));
|
}
|
|
System.out.println();
|
System.out.println("=== 场景 3：参数表 satisfaction.enabled=false（实现 Bean 依然存在，但门面必须不转发）===");
|
StubApi.CALLS.set(0);
|
try (AnnotationConfigApplicationContext ctx = context(true, true, ContextCheckConfig.SYS_OFF)) {
|
SatisfactionFacade facade = ctx.getBean(SatisfactionFacade.class);
|
check("关闭时 isEnabled() 为 false", "false", String.valueOf(facade.isEnabled()));
|
String result;
|
try {
|
result = String.valueOf(facade.getSatisfactionCategories("ORG1").isEmpty());
|
} catch (StackOverflowError e) {
|
result = "StackOverflowError";
|
}
|
check("关闭时分类查询返回空 Map（不会自递归）", "true", result);
|
check("关闭时不再调用内部实现（stub 调用次数 = 0）", "0",
|
String.valueOf(StubApi.CALLS.get()));
|
|
SatisfactionAvailabilityInterceptor interceptor = ctx.getBean(SatisfactionAvailabilityInterceptor.class);
|
String thrown = "(未抛异常)";
|
try {
|
interceptor.preHandle(null, null, null);
|
} catch (Exception e) {
|
thrown = e.getClass().getSimpleName() + "|" + e.getMessage();
|
}
|
check("关闭时拦截器抛 ServiceException", "true", String.valueOf(thrown.startsWith("ServiceException|")));
|
check("关闭时错误提示明确", "true",
|
String.valueOf(thrown.contains("satisfaction.enabled=false") && thrown.contains("接口不可用")));
|
|
check("关闭时受保护路径规则 7 条", "7",
|
String.valueOf(SatisfactionWebConfig.guardedPathPatterns().size()));
|
}
|
|
System.out.println();
|
System.out.println("=== 场景 4：参数表【没有】satisfaction.enabled 这一行时，回落 application.yml（默认 true）===");
|
try (AnnotationConfigApplicationContext ctx = context(true, true, ContextCheckConfig.SYS_MISSING)) {
|
SatisfactionFacade facade = ctx.getBean(SatisfactionFacade.class);
|
check("参数行缺失、yml 默认 true 时 isEnabled() 为 true", "true", String.valueOf(facade.isEnabled()));
|
}
|
try (AnnotationConfigApplicationContext ctx = context(false, true, ContextCheckConfig.SYS_MISSING)) {
|
SatisfactionFacade facade = ctx.getBean(SatisfactionFacade.class);
|
check("参数行缺失、yml=false 时 isEnabled() 为 false", "false", String.valueOf(facade.isEnabled()));
|
}
|
|
System.out.println();
|
System.out.println("=== 场景 5：容器里【没有】IConfigService 时（独立/测试环境）必须能启动且按 yml 兜底 ===");
|
try (AnnotationConfigApplicationContext ctx = context(true, true, null, false)) {
|
SatisfactionFacade facade = ctx.getBean(SatisfactionFacade.class);
|
check("无配置服务时门面仍能装配并启动", "true", String.valueOf(facade != null));
|
check("无配置服务时按 yml 兜底（true）", "true", String.valueOf(facade.isEnabled()));
|
}
|
|
System.out.println();
|
if (failed == 0) {
|
System.out.println("===== 满意度模块 Spring 装配校验全部通过 =====");
|
} else {
|
System.out.println("===== 满意度模块 Spring 装配校验失败 " + failed + " 项 =====");
|
System.exit(1);
|
}
|
}
|
|
/**
|
* 参数表的模拟取值
|
*/
|
static final class ContextCheckConfig {
|
/** 参数行存在且为 true */
|
static final String SYS_ON = "true";
|
/** 参数行存在且为 false */
|
static final String SYS_OFF = "false";
|
/** 参数行不存在 */
|
static final String SYS_MISSING = null;
|
|
private ContextCheckConfig() {
|
}
|
}
|
|
/**
|
* 起一个只含本模块"无 Mapper 依赖"Bean 的真实容器
|
*
|
* @param ymlEnabled application.yml 里 satisfaction.enabled 的取值（兜底用）
|
* @param withDelegate 是否注册内部实现（DefaultSatisfactionApi 的角色）
|
* @param sysConfigValue 模拟 sys_config 里 satisfaction.enabled 的键值，null=没有这一行
|
*/
|
private static AnnotationConfigApplicationContext context(boolean ymlEnabled, boolean withDelegate,
|
final String sysConfigValue) {
|
return context(ymlEnabled, withDelegate, sysConfigValue, true);
|
}
|
|
/**
|
* @param withConfigService 容器里是否注册 {@link IConfigService}（false 模拟独立/测试环境）
|
*/
|
private static AnnotationConfigApplicationContext context(boolean ymlEnabled, boolean withDelegate,
|
final String sysConfigValue, boolean withConfigService) {
|
AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext();
|
SatisfactionProperties properties = new SatisfactionProperties();
|
properties.setEnabled(ymlEnabled);
|
ctx.registerBean(SatisfactionProperties.class, () -> properties);
|
ctx.register(SatisfactionFacade.class,
|
SatisfactionSwitch.class,
|
SatisfactionAvailabilityInterceptor.class,
|
SatisfactionWebConfig.class,
|
SatisfactionScoreStrategyResolver.class,
|
CommonSatisfactionScoreStrategy.class,
|
SltdSatisfactionScoreStrategy.class,
|
ProviderProbe.class);
|
if (withConfigService) {
|
// 假的参数配置服务：只认 satisfaction.enabled 这一个键，值由 sysConfigValue 决定
|
ctx.registerBean("stubConfigService", IConfigService.class, () -> (IConfigService) configKey ->
|
SatisfactionSwitch.CONFIG_KEY.equals(configKey) ? sysConfigValue : "");
|
}
|
if (withDelegate) {
|
ctx.registerBean("stubSatisfactionApi", SatisfactionApi.class, StubApi::new);
|
}
|
ctx.refresh();
|
return ctx;
|
}
|
|
private static void check(String key, String expected, String actual) {
|
boolean ok = expected.equals(actual);
|
if (!ok) {
|
failed++;
|
}
|
System.out.println("[" + (ok ? "OK" : "FAIL") + "] " + key + " 期望=" + expected + " 实际=" + actual);
|
}
|
}
|
