Serde: Enable header modifications by custom serializer

[MDzaja]

• Breaking change? (if so, please describe the impact and migration path for existing application instances)

What changes did you make? (Give an overview)
Closes #346.
Extends io.kafbat.ui.serde.api.Serde.Serializer to support message headers editing by custom serializers.

Is there anything you'd like reviewers to focus on?

How Has This Been Tested? (put an "x" (case-sensitive!) next to an item)

• No need to
• Manually (please, describe, if necessary)
  A custom serializer was developed, and the feature was tested with it.
• Unit checks
• Integration checks
• Covered by existing automation

Checklist (put an "x" (case-sensitive!) next to all the items, otherwise the build will fail)

• I have performed a self-review of my own code
• I have commented my code, particularly in hard-to-understand areas
• I have made corresponding changes to the documentation (e.g. ENVIRONMENT VARIABLES)
• My changes generate no new warnings (e.g. Sonar is happy)
• I have added tests that prove my fix is effective or that my feature works
• New and existing unit tests pass locally with my changes
• Any dependent changes have been merged

Check out Contributing and Code of Conduct

A picture of a cute animal (not mandatory but encouraged)

[github-actions]

Hi MDzaja! 👋

Welcome, and thank you for opening your first PR in the repo!

Please wait for triaging by our maintainers.

Please take a look at our contributing guide.

[Haarolean]

why we'd need a proxy here?

[MDzaja]

We need a proxy here because the Serializer interface now has multiple methods, so we cannot use a simple lambda for wrapping (as was done previously). A proxy provides a generic, scalable, and clean solution to wrap all methods of the Serializer interface dynamically. This ensures that every method invocation on the interface is consistently wrapped with the necessary logic (e.g., wrapWithClassloader).

While it’s possible to use an explicit or anonymous class implementation to achieve the same goal, using a proxy reduces boilerplate and makes the code easier to maintain in the long run. For comparison, here’s how an anonymous wrapper class could look:

public Serde.Serializer serializer(String topic, Serde.Target type) {
    return wrapWithClassloader(() -> {
        var serializer = serde.serializer(topic, type);
        return new Serde.Serializer() {
            @Override
            public byte[] serialize(String input) {
                return wrapWithClassloader(() -> serializer.serialize(input));
            }

            @Override
            public byte[] serialize(String input, Headers headers) {
                return wrapWithClassloader(() -> serializer.serialize(input, headers));
            }
        };
    });
}

While this approach works, it introduces repetitive boilerplate for every method, which becomes harder to manage as the interface evolves.

[kapybro]

Further user feedback is requested. Please reply within 7 days or we might close the issue.

[kapybro]

No feedback received within 7 days. Auto closing.