CODEWITHSUNDEEP
springdependency-injection
morteza khosravi
morteza khosravi

Reputation: 1619

Should I use dependency injection on these domain classes?

Do I use dependency injection in the following example:

@Scope("prototype")
@Component
public class Order{
    @Autowired
    public Order(User user,List<OrderItem> items,.......){

Now somewhere else:

@Component
public class PersistOrder{
    @Autowired
    Provider<Order> orderProvider;

    public void prepareOrder() {
        Order order = orderProvider.get();

AS JSR-330 states, the get() method of Provider returns a new instance of Order, but what objects are passed to the new order's constructor? As you can see the order has its own dependencies that has to be injected before the actual order object is retrieved to the method.

Without DI I simply create all neccessary arguments and pass them to the constructor of the new order. So should I use DI here?

EDIT:

This is what the code would seem without DI:

@Component
public class PersistOrder{

    public void prepareOrder() {
        User user=userDao.get(userId);
        List<OrderItem> orderItems=orderItemDao.getAll(orderItemIds);
        Order order = new SmartPhoneOrder(user,orderItems);

As you see I have the ids of user and order items and can get their instances from DAOs. Then I pass these instances to the constructor of a subclass of the Order to get an instance. The process seems very clear to me. I mean how can I do this work with DI so that my code enjoy decoupling between PersistOrder and Order classes? Or using DI in this example makes the logic more complex?

Upvotes: 3

Views: 1587

Answers (1)

Jasper Blues
Jasper Blues

Reputation: 28756

Without dependency injection, domain objects can be considered anaemic, and this is arguably an anti-pattern. You're losing many of the benefits of OO, by having data structures, without associated behaviors. For example, to evaluate Order.isValid() you may need to inject some dependency to perform the validation.

You can get dependency injection on classes outside the context of the Spring container by using: 

@Configurable

You then declare the recipe for the bean as a protoype, and Spring will use AOP to swizzle the constructor and look up the required dependencies. . Even though its looking up the dependencies, the net effect for you is dependency injection, because you'd only have to change one line to inject something else that evaluates Order.isValid().

This way when you do new Order, or get it from you persistence factory, it already has the dependencies "injected".

To do this requires aspectJ weaving and not just Proxy/CGLib weaving, which is the default. You can use either runtime weaving with a Java agent or build-time weaving. . . I recommend the former for integration tests and the latter for deployment. . .

Service vs Domain Object:

Now that you have the option of rich domain objects the question becomes where to put stuff. Service vs Entity? My take is that the service should orchestrate a use-case specific process based on reusable domain objects. The service is your non-OO gateway for outside subscribers into you system.

. . Google Spring @Configurable for more information and tutorials on AspectJ-based dependency injection of domain classes.

Upvotes: 3

Related Questions