Is it better to pass a specific “context” object to handlers rather than the entire domain object?

Question

I’m designing a system where various “handlers” apply business rules to an object. Initially I had each handler receive the full domain object:

// A large domain object with many properties and methods
public class Order {
    private List<Item> items;
    private Customer customer;
    private Address billingAddress;
    private Address shippingAddress;
    private PaymentInfo payment;
    private DiscountRules discountRules;
    // … lots more fields and methods …
}

// Rule interface that takes the entire Order
public interface Rule {
    void apply(Order order);
}

// Example handler only cares about items and customer status:
public class LoyaltyDiscountRule implements Rule {
    @Override
    public void apply(Order order) {
        if (order.getCustomer().isGoldMember()) {
            order.applyDiscount(0.05);
        }
    }
}

Passing the whole Order felt too heavy—each rule only needs a couple of fields, yet has full access to mutate the order.

Refactored approach

I introduced a slim context object exposing only what a rule may need, plus an interface for allowed side-effects:

// Exposes just the data each rule might use
public class RuleContext {
    private final List<Item> items;
    private final Customer customer;
    private final OrderActions actions;

    public RuleContext(List<Item> items, Customer customer, OrderActions actions) {
        this.items = items;
        this.customer = customer;
        this.actions = actions;
    }

    public List<Item> getItems()        { return items;     }
    public Customer getCustomer()       { return customer;  }
    public OrderActions getActions()    { return actions;   }
}

// Only these modifications are allowed
public interface OrderActions {
    void addDiscount(double rate);
    void markFreeShipping();
}

Now each rule implements:

public interface Rule {
    void apply(RuleContext ctx);
}

And a handler becomes:

public class BulkPurchaseRule implements Rule {
    @Override
    public void apply(RuleContext ctx) {
        if (ctx.getItems().size() > 10) {
            ctx.getActions().addDiscount(0.10);
        }
    }
}

Questions

Is this “Context + Actions” pattern a well-known or recommended design?
What trade-offs does it introduce compared to passing the full domain object or individual parameters?
Are there alternative patterns for limiting each handler’s access to only the data and mutations it needs?

This question is similar to: Should I "introduce parameter object" for the case that the parameter is originally already a whole object?. If you believe it’s different, please edit the question, make it clear how it’s different and/or how the answers on that question are not helpful for your problem. — Basilevs
– Basilevs, Commented May 22 at 14:29
I've edited the question body for a consistency. Nicke, could you please confirm, that edit is valid? — Basilevs
– Basilevs, Commented May 22 at 14:39
Another similar question: Why is "dependency injection" ok, but not "the opposite of preserve whole object (pass required parameters only)"? — Basilevs
– Basilevs, Commented May 22 at 14:41
why are you making your life hard? Once you add all the createContext stuff you will have twice as much code and still the same objects in memory — Ewan
– Ewan, Commented May 22 at 16:55

Ewan · Accepted Answer · 2025-05-22 17:28:30Z

It's generally best to pass the whole object, that's the whole point of domain objects. Plus it's hard to see what saving, if any you make with your suggested pattern.

Is this “Context + Actions” pattern a well-known or recommended design?

No. Often you will have a context object to add extra info. But this is usually injected some other way that the method parameters.

What trade-offs does it introduce compared to passing the full domain object or individual parameters?

Well, first off you have added a bunch of extra classes that have no well defined responsibility.

OrderActions, for example. All the possible actions you might want to take with an Order This seems like an undefined set and exactly the thing you are supposed to be implementing in your Rule objects.

Secondly you have introduced the possibility of run time exceptions when getItems doesn't have the right item in it

Are there alternative patterns for limiting each handler’s access to only the data and mutations it needs?

Not really, the whole point of encapsulating Order as a domain object is so you can allow other classes to operate on it in defined ways without knowing in advance what those new classes might want except that it will be related to "an Order"

You could add more interfaces;

IDiscountable, IHasCustomer etc but these don't really make sense for domain objects. You'll end up with one for every method on the object and then have combination interfaces IDiscountableAndHasCustomer. It's a pain.

For me I think there are some red flags in your example code which say that your domain object is not well chosen.

private DiscountRules discountRules;

Why does an order know about the rules for applying discounts?

order.getCustomer().isGoldMember()

Is the order lazy loading this info from a database? How much customer information is needed on an Order? surely just the id, def not the gold (and whatever other catogory) membership statuses

order.applyDiscount(0.05);

How many methods do you have for adjusting the price? applyDiscount, addPenaltyFee, removeShippingCost? Just do something like:

var customer = customerRepo.get(order.customerId);
var s = membershipService.GetStatus(customer);
var discount = memebershipDiscountService.GetDiscount(s);
order.items.Add("{s.name} member discount", order.totalPrice * discount)

Basilevs · Accepted Answer · 2025-05-22 15:09:55Z

2

Use the original Order as a parameter if future Order fields would be useful to Rule.

See detailed writeup

edited May 22 at 15:09

answered May 22 at 14:48

Basilevs

4,4901 gold badge20 silver badges33 bronze badges

Add a comment |

Stack Exchange Network

Is it better to pass a specific “context” object to handlers rather than the entire domain object?

2 Answers 2

Your Answer

Linked

Hot Network Questions

Is it better to pass a specific “context” object to handlers rather than the entire domain object?

2 Answers 2

Your Answer

Sign up or log in

Post as a guest

Linked

Related

Hot Network Questions