spring and different way to avoid to use new - spring

Question

I use spring boot 2.
I need to validate many condition, instead of creating many if, I create a class for every condition who implements isValid method.
public interface Rulecondition<T>{
boolean isValid(){
}
public class ClientGroup implements Rulecondition<Billing>{
private Billing billing;
public ClientGroup(Billing billing){
this.billing=billing;
}
#Override
public boolean isValid(){
return true; //only for example...
}
}
I create a class who use a stream of all condition and verify if everything is valid
#Component
public class ConditionRuleEngine{
private List<Rulecondition> rules = new ArrayList<>();
public ConditionRuleEngine(){
}
public void addRule(Rulecondition rule){
rules.add(rule);
}
public boolean conditionApply(){
retunr rules.stream().allMatch(r->.isValid()));
}
}
In a service class, I autowired ConditionRuleEngine
#Service
public class OperationService(){
private final ConditionRuleEngine conditionRuleEngine;
#Autowired
public OperationService OperationService(final ConditionRuleEngine conditionRuleEngine){
this.conditionRuleEngine=conditionRuleEngine;
}
public void execute(Billing billing){
//need to add condition
conditionRuleEngine.run();
}
}
Is there any better way to add condition then creating a new?
ClientGroup cg = new ClientGroup(billing);
conditionRuleEngine.add(cg);

Answer 1

Yes, but there is one change that would help your situation: Removing the generic type argument, T, from the Rulecondition interface. Since Rulecondition only contains a isValid method that does not depend on the generic parameter, T, that parameter can be safely removed:
public interface RuleCondition {
boolean isValid();
}
The reason for this removal is that it simplifies the Spring-based solution to your problem. Without that generic parameter, you can now mark each of your RuleCondition implementations with #Component (making them eligible for dependency injection) and autowire a List<RuleCondition> into your ConditionRuleEngine class:
#Component
public class ConditionRuleEngine {
#Autowired
private List<RuleCondition> rules;
// ...other implementation details...
}
Spring will inject all of the components that implement RuleCondition into the rules field.
While removing the generic parameter, T, simplifies the solution, it is not required.
If you do need to maintain the generic parameter, T, then you can autowire the RuleCondition for each generic parameter by specifying the parameter in the List type:
public interface RuleCondition<T> {
boolean isValid(T value);
}
#Component
public class ClientGroup implements RuleCondition<Billing> {
#Override
public boolean isValid(Billing value) {
// ...
}
}
#Component
public class ConditionRuleEngine {
#Autowired
private List<RuleCondition<Billing>> billingRules;
#Autowired
private List<RulecCndition<Other>> otherRules;
// ...other implementation details...
}
Spring will inject all RuleCondition objects that match the generic parameter. For example, billingRules will contain a List of all RuleCondition<Billing> (and will not include any RulecCndition<Other> objects.