欄位護體心法：以 Java 黑魔法施展三明治夾擊，拒絕核心清空詛咒 🥪🛡️

Prologue: A Grudge Born in the ERP Dojo

Deep in the iDempiere martial arts world lives an object known as Request — the lifeblood of our Kanban board.

Request comes with a built-in event mechanism: every time a ticket is touched — a status change, a field update, anything — it fires a Request Event, faithfully logging the movement. Noble in intent. Disastrous in side effect.

Because somewhere in the core, a rogue disciple runs a routine that wipes EndTime clean on every single event trigger. No questions asked. No exceptions made. Just gone.

Our dojo had been using StartTime and EndTime as the sacred anchors for Gantt chart planning — every task bar on the Kanban board depended on these two fields to define its span. One ticket update, and poof: EndTime zeroes out, the Gantt bar vanishes into the void, and the project managers are left staring at a board full of floating fragments.

Everyone in the dojo knows the fix: delete one line in the core source. One line. Done.

But the Grand Master spoke, and the word was final: “Do not touch the core. Who takes responsibility when we upgrade? This must be solved with a Plugin.”

And so the quest began.

Move 1: The OSGi Ranking Gambit — Confident Entry, Crushing Defeat ❌

Mantra: “Strike first, strike high.”

Our first plan seemed elegant: a three-layer formation using OSGi service rankings to control the order of execution.

• Capturer (Rank 10,000): intercepts before Core, captures EndTime
• Core (Rank 0): fires as usual, clears EndTime
• Restorer (Rank -100): swoops in last, restores EndTime

Brilliant in theory. Irrelevant in practice.

Core ignores rankings entirely. It follows registration order — whoever signed up first goes first. Our carefully calibrated formation was invisible to it. We swung hard and hit nothing but air.

Defeated. ❌

Move 2: The ModelValidator Shortcut — The Back Door Was a Trap ❌

Mantra: “The quick path often leads to a pit.”

We pivoted. Instead of racing Core in the queue, we’d intercept before the event is even dispatched — a VIP lane that bypasses the whole ordering problem.

There was one catch: the system checks Client ID before admitting our interceptor. Since we couldn’t predict which Client the user would be in at runtime, the system delivered a clean “ineligible” verdict and skipped our handler entirely.

We walked up to the VIP entrance with full confidence. The bouncer turned us away. ❌

The Ultimate Move: Java Reflection Infiltration — Breaking Into the Private Vault 🪄✨

Mantra: “If the door won’t open, reflection will walk through the wall.”

Both the front gate and the back door were closed. Time for black magic.

Java Reflection is the “invisible hand” of the programming world. It doesn’t need permission. It doesn’t knock. It reaches directly into the private field m_globalValidators inside ModelValidationEngine and installs our listener without asking anyone.

// Access the private field via reflection
Field f = ModelValidationEngine.class.getDeclaredField("m_globalValidators");
f.setAccessible(true);
List<ModelValidator> globalValidators = (List<ModelValidator>) f.get(engine);
globalValidators.add(new EndTimeCapturer());

Our listener is now registered globally — no Client ID check, no registration order problem. We have a universal pass.

The three-layer Sandwich Strike snaps into place:

EndTime survives the clearing. The Gantt board holds. The Kanban looks exactly as it should.

Master Lei Speaks

I have observed the OSGi martial world for many years. A thousand orthodox paths — each one guarded. Only Reflection moves like a ghost through walls, bound by neither gate nor rank. But know this: Reflection is not the first resort. Before you reach for the black magic, ask yourself — can you negotiate with the Grand Master? Can the architecture change?

If the answer remains “do not touch the core,” then so be it. Draw the spell.

In software, there are no dead ends. Only passages not yet found. EndTime may be cleared a hundred times — but with the Sandwich in place, it always comes back.