package jnpf.audit.sdk;
|
|
import jnpf.audit.AuditApiConsts;
|
import jnpf.audit.AuditOperationIds;
|
import jnpf.audit.model.AuditEventDTO;
|
import org.slf4j.MDC;
|
import org.springframework.transaction.support.TransactionSynchronization;
|
import org.springframework.transaction.support.TransactionSynchronizationManager;
|
import org.springframework.transaction.support.TransactionSynchronizationUtils;
|
|
import java.util.ArrayList;
|
import java.util.HashSet;
|
import java.util.List;
|
import java.util.Set;
|
|
/**
|
* AuditTxHolder 的并发时序矩阵断言（M2 operationId 分叉修复，spec §6-A）。
|
*
|
* <p><b>本类模拟事务生命周期的编排顺序，逐条对照 spring-tx 6.2.12 的
|
* {@code AbstractPlatformTransactionManager} 字节码得出，改动前请先复核：</b>
|
* <pre>
|
* 挂起 doSuspendSynchronization:
|
* getSynchronizations()（偏移 0）→ 逐个 suspend()（偏移 31）→ clearSynchronization()（偏移 39）
|
* 恢复 doResumeSynchronization:
|
* initSynchronization()（偏移 0）→ 循环内**逐元素交替** resume()（偏移 30）→ registerSynchronization()（偏移 36）
|
* ——注意是 resume 在前、register 在后，不是"先全部注册再全部恢复"
|
* 完成 triggerAfterCompletion:
|
* getSynchronizations()（偏移 7）→ clearSynchronization()（偏移 11）→ invokeAfterCompletion()（偏移 31）
|
* ——afterCompletion 回调在同步**被清除之后**执行，故本类用
|
* TransactionSynchronizationUtils.invokeAfterCompletion(list, status) 而非
|
* triggerAfterCompletion(int)（后者要求同步仍活跃，与真实相反）
|
* </pre>
|
*
|
* <p>本类是 A 轮保真度缺口的唯一书面依据：TransactionSynchronizationUtils 没有 suspend/resume
|
* 的公开触发器，挂起/恢复顺序全靠本类自行编排。真实链路交叉验证见 tasks/audit-opid-e2e.sh。
|
*
|
* <p>运行：bash tasks/audit-opid-checks.sh
|
*/
|
public class AuditTxHolderConcurrencyChecks {
|
|
private static final String KEY = AuditApiConsts.MDC_OPERATION_ID;
|
private static final List<AuditEventDTO> SENT = new ArrayList<AuditEventDTO>();
|
private static int failures = 0;
|
private static int checksRun = 0;
|
private static int dirtyTail = 0;
|
|
/** 假发送器：只记事件，不触碰 Feign / spool 两级降级链路（spec §6-A 已核实可行） */
|
private static final AuditEventPublisher PUB = new AuditEventPublisher(null, null) {
|
@Override
|
public void publishAsync(List<AuditEventDTO> events) {
|
SENT.addAll(events);
|
}
|
};
|
|
// ==================== 事务生命周期模拟（顺序依据见类注释）====================
|
|
private static void beginTx() {
|
TransactionSynchronizationManager.initSynchronization();
|
}
|
|
private static void commitTx() {
|
TransactionSynchronizationUtils.triggerBeforeCommit(false);
|
TransactionSynchronizationUtils.triggerBeforeCompletion();
|
TransactionSynchronizationUtils.triggerAfterCommit();
|
completeTx(TransactionSynchronization.STATUS_COMMITTED);
|
}
|
|
private static void rollbackTx() {
|
TransactionSynchronizationUtils.triggerBeforeCompletion();
|
completeTx(TransactionSynchronization.STATUS_ROLLED_BACK);
|
}
|
|
private static void completeTx(int status) {
|
List<TransactionSynchronization> syncs = TransactionSynchronizationManager.getSynchronizations();
|
TransactionSynchronizationManager.clearSynchronization();
|
TransactionSynchronizationUtils.invokeAfterCompletion(syncs, status);
|
}
|
|
private static List<TransactionSynchronization> suspendTx() {
|
List<TransactionSynchronization> syncs = TransactionSynchronizationManager.getSynchronizations();
|
for (TransactionSynchronization s : syncs) {
|
s.suspend();
|
}
|
TransactionSynchronizationManager.clearSynchronization();
|
return syncs;
|
}
|
|
private static void resumeTx(List<TransactionSynchronization> syncs) {
|
TransactionSynchronizationManager.initSynchronization();
|
for (TransactionSynchronization s : syncs) {
|
s.resume();
|
TransactionSynchronizationManager.registerSynchronization(s);
|
}
|
}
|
|
// ==================== 事件构造 ====================
|
|
/** 层 1 / 层 3 事件：不带 operationId，由 holder 决定（对应 Executor 插件与显式 record） */
|
private static void emitInner() {
|
AuditTxHolder.submit(dto(null), PUB);
|
}
|
|
/** 层 2 事件：切面显式带上 scope 的 id（照抄 AuditLogAspect.java:68,90） */
|
private static void emitOuter(String operationId) {
|
AuditTxHolder.submit(dto(operationId), PUB);
|
}
|
|
private static AuditEventDTO dto(String operationId) {
|
return AuditEventDTO.builder()
|
.operationId(operationId)
|
.eventType("BIZ_ACTION")
|
.actionCode("UPDATE")
|
.sourceLayer(1)
|
.build();
|
}
|
|
private static void emitSignUsed() {
|
AuditTxHolder.submit(AuditEventDTO.builder()
|
.eventType("E_SIGNATURE")
|
.actionCode("SIGN_USED")
|
.bizType("JIANCE_TASK")
|
.bizCode("LS-ROLLBACK")
|
.targetTable("lims_sign")
|
.targetId("sign-rollback")
|
.sourceLayer(3)
|
.build(), PUB);
|
}
|
|
// ==================== 断言工具 ====================
|
|
private static void reset() {
|
SENT.clear();
|
MDC.remove(KEY);
|
if (TransactionSynchronizationManager.isSynchronizationActive()) {
|
TransactionSynchronizationManager.clearSynchronization();
|
}
|
}
|
|
private static void check(String name, boolean ok, String detail) {
|
checksRun++;
|
if (ok) {
|
System.out.println(" [PASS] " + name);
|
} else {
|
failures++;
|
System.out.println(" [FAIL] " + name + " —— " + detail);
|
}
|
}
|
|
/** 每个场景收尾都要跑：MDC 必须归零、holder 资源必须已解绑（场景 9 的实现） */
|
private static void assertClean(String scenario) {
|
String mdc = MDC.get(KEY);
|
String res = AuditTxHolder.currentOperationId();
|
boolean ok = (mdc == null) && (res == null);
|
if (!ok) {
|
dirtyTail++;
|
}
|
check(scenario + " 末态干净（MDC 与 holder 资源均已清）", ok,
|
"MDC=" + mdc + ", currentOperationId=" + res);
|
}
|
|
private static Set<String> idsOf(List<AuditEventDTO> events) {
|
Set<String> ids = new HashSet<String>();
|
for (AuditEventDTO e : events) {
|
ids.add(e.getOperationId());
|
}
|
return ids;
|
}
|
|
private static String dump() {
|
StringBuilder sb = new StringBuilder("发出 ").append(SENT.size()).append(" 条: ");
|
for (AuditEventDTO e : SENT) {
|
sb.append(e.getOperationId()).append(' ');
|
}
|
return sb.toString();
|
}
|
|
// ==================== 十一项场景 ====================
|
|
/** 场景 1：无事务进入、无内部事务提交（现状不回归） */
|
private static void s1() {
|
System.out.println("[S1] 无事务进入、无内部事务提交");
|
reset();
|
AuditTxHolder.OperationScope scope = AuditTxHolder.beginOperation(PUB);
|
String scopeId = scope.operationId();
|
emitOuter(scopeId);
|
scope.close();
|
check("S1 层2 事件用 scope 的 id", SENT.size() == 1 && scopeId.equals(SENT.get(0).getOperationId()), dump());
|
assertClean("S1");
|
}
|
|
/** 场景 2：事务已激活进入 + 事务内提交（今日 lims 四处的形态，现状不回归） */
|
private static void s2() {
|
System.out.println("[S2] 事务已激活进入 + 事务内提交（今日 lims 形态）");
|
reset();
|
beginTx();
|
AuditTxHolder.OperationScope scope = AuditTxHolder.beginOperation(PUB);
|
String scopeId = scope.operationId();
|
emitInner();
|
emitOuter(scopeId);
|
scope.close();
|
commitTx();
|
check("S2 层1 与层2 同 id", SENT.size() == 2 && idsOf(SENT).size() == 1, dump());
|
check("S2 该 id 即 scope 的 id", idsOf(SENT).contains(scopeId), "scopeId=" + scopeId + ", " + dump());
|
assertClean("S2");
|
}
|
|
/** 场景 3：无事务进入 + 内部事务内提交（spec §1.2 分叉；全未改时必红） */
|
private static void s3() {
|
System.out.println("[S3] 无事务进入 + 内部事务内提交（§1.2 分叉）");
|
reset();
|
AuditTxHolder.OperationScope scope = AuditTxHolder.beginOperation(PUB);
|
String scopeId = scope.operationId();
|
beginTx();
|
emitInner();
|
commitTx();
|
emitOuter(scopeId);
|
scope.close();
|
check("S3 层1 与层2 同 id", SENT.size() == 2 && idsOf(SENT).size() == 1, dump());
|
assertClean("S3");
|
}
|
|
/** 场景 4：形态甲——作用域在事务外 + REQUIRES_NEW，buffer 由 submit 创建 */
|
private static void s4() {
|
System.out.println("[S4] 形态甲：作用域在事务外 + REQUIRES_NEW（buffer 由 submit 建）");
|
reset();
|
AuditTxHolder.OperationScope scope = AuditTxHolder.beginOperation(PUB);
|
String scopeId = scope.operationId();
|
beginTx();
|
// 防假绿：本场景 buffer 必须由 submit 创建，且创建时 MDC 已有值
|
check("S4 前置：进入外层事务时 MDC 已被作用域写入", scopeId.equals(MDC.get(KEY)), "MDC=" + MDC.get(KEY));
|
check("S4 前置：外层事务此刻尚无 buffer", AuditTxHolder.currentOperationId() == null, "已有 buffer");
|
emitInner();
|
List<TransactionSynchronization> susp = suspendTx();
|
beginTx();
|
emitInner();
|
commitTx();
|
resumeTx(susp);
|
emitInner();
|
commitTx();
|
emitOuter(scopeId);
|
scope.close();
|
check("S4 内外事务与层2 全部同 id", SENT.size() == 4 && idsOf(SENT).size() == 1, dump());
|
assertClean("S4");
|
}
|
|
/** 场景 5：形态乙——无作用域 + REQUIRES_NEW，内外必须各自独立（守 M1 终验#6） */
|
private static void s5() {
|
System.out.println("[S5] 形态乙：无作用域 + REQUIRES_NEW（内外必须不同 id）");
|
reset();
|
beginTx();
|
check("S5 前置：无作用域，MDC 为空", MDC.get(KEY) == null, "MDC=" + MDC.get(KEY));
|
emitInner();
|
List<TransactionSynchronization> susp = suspendTx();
|
beginTx();
|
check("S5 前置：挂起后 MDC 必须被清空", MDC.get(KEY) == null, "MDC=" + MDC.get(KEY));
|
emitInner();
|
commitTx();
|
resumeTx(susp);
|
commitTx();
|
check("S5 内外事务 id 不同（终验#6 原行为）", SENT.size() == 2 && idsOf(SENT).size() == 2, dump());
|
assertClean("S5");
|
}
|
|
/**
|
* 场景 6：形态丙——事务已激活进入 + REQUIRES_NEW，buffer 由 beginOperation 创建。
|
* 这是 v1 设计漏掉的形态：只改 createBuffer 一行时**仍然红**，必须靠 scopeOwned 才转绿。
|
*/
|
private static void s6() {
|
System.out.println("[S6] 形态丙：事务已激活进入 + REQUIRES_NEW（buffer 由 beginOperation 建）");
|
reset();
|
beginTx();
|
// 防假绿（spec §6-A）：必须是 MDC 为空时由 beginOperation 建 buffer，
|
// 否则会退化成场景 4 的 previousMdc 路径而假绿
|
check("S6 前置：beginOperation 之前 MDC 为空", MDC.get(KEY) == null, "MDC=" + MDC.get(KEY));
|
check("S6 前置：beginOperation 之前无 buffer", AuditTxHolder.currentOperationId() == null, "已有 buffer");
|
AuditTxHolder.OperationScope scope = AuditTxHolder.beginOperation(PUB);
|
String scopeId = scope.operationId();
|
check("S6 前置：buffer 确由 beginOperation 创建", scopeId != null && scopeId.equals(AuditTxHolder.currentOperationId()),
|
"scopeId=" + scopeId + ", current=" + AuditTxHolder.currentOperationId());
|
List<TransactionSynchronization> susp = suspendTx();
|
beginTx();
|
emitInner();
|
commitTx();
|
resumeTx(susp);
|
emitOuter(scopeId);
|
scope.close();
|
commitTx();
|
check("S6 内层 REQUIRES_NEW 与层2 同 id", SENT.size() == 2 && idsOf(SENT).size() == 1, dump());
|
check("S6 该 id 即 scope 的 id", idsOf(SENT).contains(scopeId), "scopeId=" + scopeId + ", " + dump());
|
assertClean("S6");
|
}
|
|
/** 场景 7：形态丁——submit 先建 buffer、随后才进作用域 + REQUIRES_NEW（验"复用路径也置位"） */
|
private static void s7() {
|
System.out.println("[S7] 形态丁：submit 先建 buffer、后进作用域 + REQUIRES_NEW");
|
reset();
|
beginTx();
|
emitInner();
|
String bufferId = AuditTxHolder.currentOperationId();
|
check("S7 前置：buffer 由 submit 创建", bufferId != null, "无 buffer");
|
AuditTxHolder.OperationScope scope = AuditTxHolder.beginOperation(PUB);
|
String scopeId = scope.operationId();
|
check("S7 前置：作用域复用既有 buffer", bufferId.equals(scopeId), "bufferId=" + bufferId + ", scopeId=" + scopeId);
|
List<TransactionSynchronization> susp = suspendTx();
|
beginTx();
|
emitInner();
|
commitTx();
|
resumeTx(susp);
|
emitOuter(scopeId);
|
scope.close();
|
commitTx();
|
check("S7 全链路同 id", SENT.size() == 3 && idsOf(SENT).size() == 1, dump());
|
assertClean("S7");
|
}
|
|
/** 场景 8：形态戊——标注方法自身 REQUIRES_NEW、调用方有事务 */
|
private static void s8() {
|
System.out.println("[S8] 形态戊：标注方法自身 REQUIRES_NEW、调用方有事务");
|
reset();
|
beginTx();
|
AuditTxHolder.OperationScope scope = AuditTxHolder.beginOperation(PUB);
|
String scopeId = scope.operationId();
|
List<TransactionSynchronization> susp = suspendTx();
|
beginTx();
|
emitInner();
|
commitTx();
|
resumeTx(susp);
|
emitOuter(scopeId);
|
scope.close();
|
commitTx();
|
check("S8 自身事务与调用方事务同 id", SENT.size() == 2 && idsOf(SENT).size() == 1, dump());
|
check("S8 该 id 即 scope 的 id", idsOf(SENT).contains(scopeId), "scopeId=" + scopeId + ", " + dump());
|
assertClean("S8");
|
}
|
|
/** 场景 10：回滚不发（单事务，守 M1 原行为） */
|
private static void s10() {
|
System.out.println("[S10] 回滚不发（单事务）");
|
reset();
|
beginTx();
|
emitInner();
|
rollbackTx();
|
check("S10 回滚后无事件发出", SENT.isEmpty(), dump());
|
assertClean("S10");
|
}
|
|
/** 场景 11：形态丙下 内层回滚 + 外层提交；并含双回滚变体 */
|
private static void s11() {
|
System.out.println("[S11] 形态丙下 内层回滚 + 外层提交");
|
reset();
|
beginTx();
|
AuditTxHolder.OperationScope scope = AuditTxHolder.beginOperation(PUB);
|
String scopeId = scope.operationId();
|
List<TransactionSynchronization> susp = suspendTx();
|
beginTx();
|
emitInner();
|
rollbackTx();
|
resumeTx(susp);
|
emitOuter(scopeId);
|
scope.close();
|
commitTx();
|
check("S11 内层回滚不发、外层照发", SENT.size() == 1 && scopeId.equals(SENT.get(0).getOperationId()), dump());
|
assertClean("S11");
|
|
System.out.println("[S11b] 双回滚变体");
|
reset();
|
beginTx();
|
AuditTxHolder.OperationScope scope2 = AuditTxHolder.beginOperation(PUB);
|
List<TransactionSynchronization> susp2 = suspendTx();
|
beginTx();
|
emitInner();
|
rollbackTx();
|
resumeTx(susp2);
|
emitOuter(scope2.operationId());
|
scope2.close();
|
rollbackTx();
|
check("S11b 内外双回滚：一条都不发", SENT.isEmpty(), dump());
|
assertClean("S11b");
|
}
|
|
/** SIGN_USED 与业务事件同事务：共享 operationId，整体回滚时均不发。 */
|
private static void s12() {
|
System.out.println("[S12] SIGN_USED 与业务事件的提交/回滚语义");
|
reset();
|
beginTx();
|
AuditTxHolder.OperationScope scope = AuditTxHolder.beginOperation(PUB);
|
emitInner();
|
emitSignUsed();
|
scope.close();
|
commitTx();
|
check("S12 提交时业务事件与 SIGN_USED 共享 operationId",
|
SENT.size() == 2 && idsOf(SENT).size() == 1, dump());
|
assertClean("S12-commit");
|
|
reset();
|
beginTx();
|
AuditTxHolder.OperationScope rollbackScope = AuditTxHolder.beginOperation(PUB);
|
emitInner();
|
emitSignUsed();
|
rollbackScope.close();
|
rollbackTx();
|
check("S12 回滚时 SIGN_USED 与业务事件均不发", SENT.isEmpty(), dump());
|
assertClean("S12-rollback");
|
}
|
|
/** 同一 biz_sign 的业务与签名事件共享一个稳定 operationId。 */
|
private static void s13() {
|
System.out.println("[S13] biz_sign 关联作用域统一 operationId");
|
reset();
|
String signId = "839875756384423365";
|
beginTx();
|
AuditTxHolder.OperationScope scope = AuditTxHolder.beginOperation(PUB, AuditOperationIds.correlation(signId));
|
emitInner();
|
emitSignUsed();
|
scope.close();
|
commitTx();
|
check("S13 同一前端操作的业务与签名事件共享 operationId",
|
SENT.size() == 2 && idsOf(SENT).size() == 1
|
&& idsOf(SENT).contains(AuditOperationIds.correlation(signId)), dump());
|
assertClean("S13");
|
}
|
|
public static void main(String[] args) {
|
System.out.println("=== AuditTxHolder 并发时序矩阵（spec §6-A + SIGN_USED 回滚）===");
|
s1();
|
s2();
|
s3();
|
s4();
|
s5();
|
s6();
|
s7();
|
s8();
|
s10();
|
s11();
|
s12();
|
s13();
|
System.out.println();
|
System.out.println("[S9] 线程复用防线汇总：末态不干净的场景数 = " + dirtyTail);
|
System.out.println();
|
System.out.println("=== 断言 " + checksRun + " 条，失败 " + failures + " 条 ===");
|
if (failures > 0) {
|
System.out.println("红。改动前这是预期结果——对照 plan 的两层红基线表核对红的是哪几项。");
|
System.exit(1);
|
}
|
System.out.println("全绿。");
|
}
|
}
|
