[MNG-8764] Sort injected lists by @Priority annotation #2425
Conversation
When injecting List<T> dependencies, the DI container now sorts the bindings by their @priority annotation value in descending order (highest priority first) to ensure deterministic ordering. This change ensures that components with higher priority values appear first in injected lists, providing predictable behavior for dependency injection scenarios where order matters. - Modified InjectorImpl.doGetCompiledBinding() to sort bindings by priority before creating supplier lists - Added comprehensive tests for priority-based list ordering - Includes tests for mixed priorities and default priority handling
| List<Supplier<Object>> list = | ||
| sortedBindings.stream().map(this::compile).collect(Collectors.toList()); | ||
| //noinspection unchecked | ||
| return () -> (Q) list(list, Supplier::get); |
There was a problem hiding this comment.
considering this domain logic, might use OOP implementing comparable as its wont hurt nobody giving special attention and cohesion to core logic.
| sortedBindings.sort(comparing.reversed()); | ||
|
|
||
| List<Supplier<Object>> list = | ||
| sortedBindings.stream().map(this::compile).collect(Collectors.toList()); |
There was a problem hiding this comment.
List<Binding<Object>> sortedBindings = new ArrayList<>(res2);
sortedBindings.sort(Comparator.reverseOrder());
//noinspection unchecked
return () -> (Q) list(sortedBindings.stream().map(this::compile).collect(Collectors.toList()), Supplier::get); @Override
public int compareTo(Binding<Object> objectBinding) {
return Integer.compare(this.priority, objectBinding.priority);
}
This is an IoC container, I wouldn't want to use IoC to bootstrap it ;-) |
why not? IoC is a pattern generally valid and possible to apply in this case as well. Current implementation seems to be entangled with feature envy, as the sorting logic is an random impl. detail, not of interest to the actual Its task it to apply to sorting not to actually do it. Instead of delegating the topic to the real one, its done by its consumer, making the code impossible to reuse. |
Did you read the full sentence ? Maven DI is an IoC container. It should not depend on another IoC container to actually be created. The other parts of Maven do rely on Maven DI, or Sisu containers for IoC. But specific bits, and especially the |
|
Its just about moving the external Imho this has nothing to do with an actual container, or what so ever. Im not injecting anything its just a concept of inverting the logic. The topic i want to talk about does not know about container or whatever. Its about giving SOC, avoiding feature envy leading to coupling instead of cohesion. we can merge this and evolve design afterward, its no problem. I will try if my theory is working. |
| // Sort bindings by priority (highest first) for deterministic ordering | ||
| List<Binding<Object>> sortedBindings = new ArrayList<>(res2); | ||
| Comparator<Binding<Object>> comparing = Comparator.comparing(Binding::getPriority); | ||
| sortedBindings.sort(comparing.reversed()); |
There was a problem hiding this comment.
| sortedBindings.sort(comparing.reversed()); | |
| sortedBindings.sort(Binding.getPriorityComparator()); |
could shift feature envy in dedicated domain Binding.
public Comparator<Binding<Object>> getPriorityComparator() {
return Comparator.comparing(Binding::getPriority);
}There was a problem hiding this comment.
might do this, as leaner than implementing comparable. Both better then this to avoid exact this situation:
DRY DRY DRY
Agreed, it's plain old java, but it's unrelated to IOC, which is generally about injecting dependencies in components rather than letting them create their own dependencies.
Yes, please raise a JIRA issue and a PR. The |
yes, i mean the concept behind it, not some random impl. detail. |
merci. |
When injecting List<T> dependencies, the DI container now sorts the bindings by their @priority annotation value in descending order (highest priority first) to ensure deterministic ordering. This change ensures that components with higher priority values appear first in injected lists, providing predictable behavior for dependency injection scenarios where order matters. - Modified InjectorImpl.doGetCompiledBinding() to sort bindings by priority before creating supplier lists - Added comprehensive tests for priority-based list ordering - Includes tests for mixed priorities and default priority handling
|
Resolve #9344 |
4 participants
When injecting List dependencies, the DI container now sorts the
bindings by their @priority annotation value in descending order
(highest priority first) to ensure deterministic ordering.
This change ensures that components with higher priority values
appear first in injected lists, providing predictable behavior
for dependency injection scenarios where order matters.
by priority before creating supplier lists
JIRA issue: MNG-8764