Question

我们有一个场景，应该在运行时确定依赖项。示例显示了以下详细信息：

public class OrderProcessor {
    // The Validator should be determinded based on the version of the service. 
    private Validator orderProcessValidator;

    public Confirmation process(Order order) {
        if(orderProcessValidator.validate(order)) {
          // Business logic
        }
    }
}

是否可以使用Spring IOC动态注入Validator，或者只能通过工厂模式解决？

Answer 1

我的场景仍然有点不清楚，但我假设你的项目中有两个实际的Order类。也许一个在com.foo.api1包中，另一个在com.foo.api2包中。或者一个Order被称为Order1而另一个被称为Order2。我的想法是，我假设你有两个不同的类用于两个api版本＆＃39;秩序。

使用Spring AOP可以实现所需：

@Aspect
@Component
public class MyAspect {
    @Autowired
    private Validator1 validator1;
    @Autowired
    private Validator2 validator2;

    @Pointcut("execution(* com.foo.bar.OrderProcessor.process(..))")
    private void myPointcut() {}

    @Around("myPointcut() && args(order)")
    public Object myAroundAdvice(ProceedingJoinPoint pjp, Object order) throws Throwable {
        if (order instanceof Order1) {
            validator1.validate((Order1) order);
        } else
        if (order instanceof Order2) {
            validator2.validate((Order2) order);
        }
        Object retVal = pjp.proceed();
        return retVal;
    }
}

@Component
public class OrderProcessor {
    public void process(Object order) {
        System.out.println("processing order");
    }
}

@Component
public class Validator1 {
    public void validate(Order1 order) {
        System.out.println("validating inside validator 1");
    }
}

@Component
public class Validator2 {
    public void validate(Order2 order) {
        System.out.println("validating inside validator 2");
    }
}

因此，基本上，您正在定义一个方面，该方面应该拦截对OrderProcessor类的调用，并且根据它接收的参数，它会调用一个验证器或另一个验证器。

如何在spring中实现动态依赖注入？

1 个答案: