package com.ruoyi.template.config;
|
|
import com.ruoyi.common.core.service.IConfigService;
|
import com.ruoyi.common.core.service.TemplateModuleDisabledException;
|
import com.ruoyi.template.api.TemplateFacade;
|
|
import java.util.List;
|
|
/**
|
* 模板模块开关校验（不依赖 JUnit，可直接用模块 classpath 运行）。
|
*
|
* <h3>为什么必须做这个</h3>
|
* 开关光有 {@code TemplateSwitch} 类**不等于生效** —— 本轮之前就是这个状态：
|
* {@code isEnabled()} 除了被门面转发一次之外，**没有任何地方调用它**，
|
* 参数设成 false 什么也不会发生。
|
* 所以这里验证的是"**接上了没有**"，不只是"方法能不能返回 boolean"：
|
* <ol>
|
* <li><b>参数表优先</b>：{@code sys_config} 有值时以它为准，同一份 yml 配置下可开可关；</li>
|
* <li><b>yml 兜底</b>：{@code sys_config} 没有这一行时回落 {@code template.enabled}（默认 true）；</li>
|
* <li><b>热更新</b>：改 {@code sys_config} 后，缓存过期即生效（无需重启）；</li>
|
* <li><b>拦截器真的拦</b>：关闭时 {@code preHandle} 抛 {@code ServiceException} 且提示明确；
|
* 启用时放行；</li>
|
* <li><b>受保护路径</b>：数量与内容符合预期，且<b>不含</b>已移出模块的运行时实例端点；</li>
|
* <li><b>门面也被拦</b>：关闭时 6 个数据方法全部抛
|
* {@code TemplateModuleDisabledException}，且文案与 HTTP 拦截器逐字一致；</li>
|
* <li><b>两种"不可用"要分清</b>：<b>关闭</b> → 抛异常；
|
* <b>开着但服务装配缺失</b> → 返回安全值（null / 空列表 / 0）。
|
* 前者是显式状态，后者是防装配问题拖垮调用方 —— 混为一谈就会让
|
* "模块被关闭"和"数据查不到"再也分不开。</li>
|
* </ol>
|
*/
|
public final class TemplateSwitchCheck {
|
|
private static int failed = 0;
|
|
private static final String SYS_ON = "true";
|
private static final String SYS_OFF = "false";
|
private static final String SYS_MISSING = null;
|
|
private TemplateSwitchCheck() {
|
}
|
|
public static void main(String[] args) throws Exception {
|
System.out.println("=== 1) 参数表优先 / yml 兜底 ===");
|
TemplateProperties ymlOn = new TemplateProperties(); // 默认 true
|
|
TemplateSwitch missSwitch = new TemplateSwitch(ymlOn, SYS_MISSING);
|
check("sys_config 缺失 + yml 默认 -> 启用（fail-open）", "true",
|
String.valueOf(missSwitch.isEnabled()));
|
|
TemplateSwitch sysOff = new TemplateSwitch(ymlOn, SYS_OFF);
|
check("sys_config=false 覆盖 yml 默认 -> 关闭", "false",
|
String.valueOf(sysOff.isEnabled()));
|
|
TemplateProperties ymlOff = new TemplateProperties();
|
ymlOff.setEnabled(false);
|
TemplateSwitch sysOn = new TemplateSwitch(ymlOff, SYS_ON);
|
check("sys_config=true 覆盖 yml=false -> 启用（参数表优先）", "true",
|
String.valueOf(sysOn.isEnabled()));
|
|
TemplateSwitch bothOff = new TemplateSwitch(ymlOff, SYS_MISSING);
|
check("sys_config 缺失 + yml=false -> 关闭（兜底生效）", "false",
|
String.valueOf(bothOff.isEnabled()));
|
|
System.out.println();
|
System.out.println("=== 2) 热更新（10 秒缓存 + invalidateCache）===");
|
TemplateProperties hot = new TemplateProperties();
|
final String[] value = {SYS_OFF};
|
TemplateSwitch hotSwitch = hotSwitch(hot, value);
|
check("改之前（参数表=false）", "false", String.valueOf(hotSwitch.isEnabled()));
|
value[0] = SYS_ON;
|
check("缓存未过期时仍返回旧值（进程内 10 秒缓存）", "false",
|
String.valueOf(hotSwitch.isEnabled()));
|
hotSwitch.invalidateCache();
|
check("缓存失效后读到新值（改成 true 立即生效）", "true",
|
String.valueOf(hotSwitch.isEnabled()));
|
|
System.out.println();
|
System.out.println("=== 3) 拦截器：关闭时明确报错，启用时放行 ===");
|
TemplateAvailabilityInterceptor offInterceptor =
|
new TemplateAvailabilityInterceptor(new TemplateSwitch(ymlOn, SYS_OFF));
|
TemplateAvailabilityInterceptor onInterceptor =
|
new TemplateAvailabilityInterceptor(new TemplateSwitch(ymlOn, SYS_ON));
|
|
check("启用时 preHandle 放行（request 传 null 也不 NPE）", "true",
|
String.valueOf(onInterceptor.preHandle(null, null, null)));
|
|
String thrown = "(未抛异常)";
|
try {
|
offInterceptor.preHandle(null, null, null);
|
} catch (Exception e) {
|
thrown = e.getClass().getName() + "|" + e.getMessage();
|
}
|
check("关闭时 preHandle 抛 ServiceException", "true",
|
String.valueOf(thrown.startsWith("com.ruoyi.common.exception.ServiceException|")));
|
check("关闭时错误提示明确（含 template.enabled=false 与「接口不可用」）", "true",
|
String.valueOf(thrown.contains("template.enabled=false") && thrown.contains("接口不可用")));
|
|
System.out.println();
|
System.out.println("=== 4) 受保护路径 ===");
|
List<String> guarded = TemplateWebConfig.guardedPathPatterns();
|
check("受保护路径数量 = 66", "66", String.valueOf(guarded.size()));
|
check("含宣教模板端点 /smartor/library/**", "true",
|
String.valueOf(guarded.contains("/smartor/library/**")));
|
check("含标签域端点 /base/tag/**", "true",
|
String.valueOf(guarded.contains("/base/tag/**")));
|
check("含刻意留在 smartor 的模板管理端点 /smartor/svyLibTemplate/**", "true",
|
String.valueOf(guarded.contains("/smartor/svyLibTemplate/**")));
|
check("不含已移出模块的运行时实例端点 /smartor/ivrtasksms/**", "false",
|
String.valueOf(guarded.contains("/smartor/ivrtasksms/**")));
|
check("不含已移出模块的运行时实例端点 /smartor/visitResult/**", "false",
|
String.valueOf(guarded.contains("/smartor/visitResult/**")));
|
check("不含已移出模块的运行时实例端点 /smartor/ivrtaskcallrecord/**", "false",
|
String.valueOf(guarded.contains("/smartor/ivrtaskcallrecord/**")));
|
check("不含非模板业务端点 /smartor/serviceSubtask/**", "false",
|
String.valueOf(guarded.contains("/smartor/serviceSubtask/**")));
|
check("不含非模板业务端点 /smartor/patinhosp/**", "false",
|
String.valueOf(guarded.contains("/smartor/patinhosp/**")));
|
|
System.out.println();
|
System.out.println("=== 5) 门面：模块关闭时**同样拒绝访问** ===");
|
// 刻意不构造真实服务（ObjectProvider 传 null）：本组验证的是"开关守卫"，
|
// 守卫在方法最前面 —— 所以即使服务不可用，关闭时也必须先抛"模块未启用"。
|
TemplateFacade offFacade = new TemplateFacade(ymlOn, SYS_OFF);
|
check("门面 isEnabled() 仍可查询（守卫不拦它，否则就自我矛盾）", "false",
|
String.valueOf(offFacade.isEnabled()));
|
|
// 6 个数据方法逐个断言：关闭时必须抛 TemplateModuleDisabledException
|
checkFacadeBlocked(offFacade, "findHeLibraryById", () -> offFacade.findHeLibraryById(1L));
|
checkFacadeBlocked(offFacade, "findHeLibraryList", () -> offFacade.findHeLibraryList(null));
|
checkFacadeBlocked(offFacade, "saveOrUpdateHeLibrary", () -> offFacade.saveOrUpdateHeLibrary(null));
|
checkFacadeBlocked(offFacade, "findHeLibraryInfoByCondition",
|
() -> offFacade.findHeLibraryInfoByCondition(null));
|
checkFacadeBlocked(offFacade, "findIvrLibaTemplateInfoByCondition",
|
() -> offFacade.findIvrLibaTemplateInfoByCondition(null));
|
checkFacadeBlocked(offFacade, "findIvrLibaExtemplatescriptsByIds",
|
() -> offFacade.findIvrLibaExtemplatescriptsByIds(java.util.Collections.emptyList()));
|
|
// 文案必须与 HTTP 拦截器逐字一致（同一个开关不该因走哪条路而提示不同）
|
check("门面提示语与拦截器常量逐字一致", "true",
|
String.valueOf(TemplateFacade.DISABLED_MESSAGE.equals(TemplateAvailabilityInterceptor.DISABLED_MESSAGE)));
|
check("提示语可读性（含 template.enabled=false 与「接口不可用」）", "true",
|
String.valueOf(TemplateFacade.DISABLED_MESSAGE.contains("template.enabled=false")
|
&& TemplateFacade.DISABLED_MESSAGE.contains("接口不可用")));
|
|
System.out.println();
|
System.out.println("=== 6) 门面：模块**开着**但服务装配缺失时仍是安全值（不抛异常）===");
|
// 这条与第 5 组是两件不同的事，必须都成立：
|
// 关闭 -> 抛异常（显式告知）
|
// 开着但服务缺失 -> 返回 null/空列表（不让装配问题拖垮调用方）
|
TemplateFacade onFacade = new TemplateFacade(ymlOn, SYS_ON);
|
check("启用时 isEnabled()", "true", String.valueOf(onFacade.isEnabled()));
|
boolean safeNoThrow = true;
|
try {
|
check("启用 + 服务不可用时 findHeLibraryById 返回 null", "null",
|
String.valueOf(onFacade.findHeLibraryById(1L)));
|
check("启用 + 服务不可用时 findHeLibraryList 返回空列表", "true",
|
String.valueOf(onFacade.findHeLibraryList(null).isEmpty()));
|
check("启用 + 服务不可用时 findIvrLibaExtemplatescriptsByIds 返回空列表", "true",
|
String.valueOf(onFacade.findIvrLibaExtemplatescriptsByIds(
|
java.util.Collections.emptyList()).isEmpty()));
|
check("启用 + 服务不可用时 saveOrUpdateHeLibrary 返回 0", "0",
|
String.valueOf(onFacade.saveOrUpdateHeLibrary(null)));
|
} catch (Exception e) {
|
safeNoThrow = false;
|
System.out.println(" 异常: " + e);
|
}
|
check("启用 + 服务不可用时读方法不抛异常", "true", String.valueOf(safeNoThrow));
|
|
System.out.println();
|
if (failed == 0) {
|
System.out.println("===== 模板开关与门面校验全部通过 =====");
|
} else {
|
System.out.println("===== 模板开关与门面校验失败 " + failed + " 项 =====");
|
System.exit(1);
|
}
|
}
|
|
/**
|
* 断言"模块关闭时某个门面方法被拒"，且拒的是<b>正确的异常类型与文案</b>。
|
* <p>
|
* 只断言"抛了异常"是不够的：抛 {@code NullPointerException} 也算抛。
|
* 所以这里同时校验类型、文案，以及"不是别的异常"。
|
*/
|
private static void checkFacadeBlocked(TemplateFacade facade, String methodName, ThrowingCall call) {
|
String outcome;
|
try {
|
Object value = call.invoke();
|
outcome = "没抛异常，返回=" + value;
|
} catch (TemplateModuleDisabledException e) {
|
outcome = e.getMessage();
|
} catch (Throwable t) {
|
outcome = "抛了别的异常：" + t.getClass().getName();
|
}
|
check("关闭时门面 " + methodName + " 抛出明确「模块未启用」",
|
TemplateFacade.DISABLED_MESSAGE, outcome);
|
}
|
|
/**
|
* 供 {@link #checkFacadeBlocked} 用的可抛异常调用（避免为本校验引入 JUnit/函数式接口依赖）
|
*/
|
private interface ThrowingCall {
|
Object invoke() throws Exception;
|
}
|
|
/**
|
* 造一个「{@code sys_config} 的值可以被中途改掉」的开关，用于验证缓存与热更新。
|
*/
|
private static TemplateSwitch hotSwitch(TemplateProperties properties, final String[] configValue) {
|
return new TemplateSwitch(properties,
|
new org.springframework.beans.factory.ObjectProvider<IConfigService>() {
|
private final IConfigService service = configKey -> configValue[0];
|
|
@Override
|
public IConfigService getObject(Object... args) {
|
return service;
|
}
|
|
@Override
|
public IConfigService getIfAvailable() {
|
return service;
|
}
|
|
@Override
|
public IConfigService getIfUnique() {
|
return service;
|
}
|
|
@Override
|
public IConfigService getObject() {
|
return service;
|
}
|
|
@Override
|
public java.util.stream.Stream<IConfigService> stream() {
|
return java.util.stream.Stream.of(service);
|
}
|
});
|
}
|
|
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);
|
}
|
}
|
