Core Java

Behavioural Design Patterns: Mediator

Previously we had a look at the iterator pattern.

The mediator pattern is way different on what it tries to achieve. It is one of the behavioural patterns and its purpose is to alter the way objects communicate with each other. Instead of the objects communicating with each other directly the mediator will handle the objects interaction.

For example imagine the scenario of a financial exchange. You do want to trade and buy but you don’t buy directly from the one that makes the offer. Instead the exchange is in the middle, in order for you to make the transaction.

People would like to sell and buy. This shall be facilitated by the exchange. You got the order object.


public class Order {

    private String stock;
    private Integer quantity;
    private Double price;

    public String getStock() {
        return stock;

    public void setStock(String stock) {
        this.stock = stock;

    public Integer getQuantity() {
        return quantity;

    public void setQuantity(Integer quantity) {
        this.quantity = quantity;

    public Double getPrice() {
        return price;

    public void setPrice(Double price) {
        this.price = price;


The next object would be the financial entity that sells the stocks.


public class FinancialEntity {

    public boolean sell(Order order) {

         * Supposing the sale was successful return true
        return true;


Then we create the exchange object. We won’t get further into commissions but imagine that things can be way more complex. The exchange is actually our mediator.


public class Exchange {

    private FinancialEntity financialEntity;

    public Exchange(FinancialEntity financialEntity) {
        this.financialEntity = financialEntity;

    public void serve(Order order) {

         * Choose the financial entity suitable for the order


And the last step is creating the trader object.


public class Trader {

    private Exchange exchange;

    public Trader(Exchange exchange) { = exchange;

    public void buy(String stock,Integer quantity,Double price) {
        Order order = new Order();


As you can see the trader object is not interacting directly with the financial entity that provides the stocks.

Let’s put them all together in a main class.


public class Mediator {

    public static void main(String[] args) {

        final FinancialEntity financialEntity = new FinancialEntity();
        final Exchange exchange = new Exchange(financialEntity);
        Trader trader = new Trader(exchange);"stock_a",2,32.2d);

That’s it, you just used the mediator pattern for an exchange application! You can also find the source code on github.

Published on Java Code Geeks with permission by Emmanouil Gkatziouras, partner at our JCG program. See the original article here: Behavioural Design Patterns: Mediator

Opinions expressed by Java Code Geeks contributors are their own.

Emmanouil Gkatziouras

He is a versatile software engineer with experience in a wide variety of applications/services.He is enthusiastic about new projects, embracing new technologies, and getting to know people in the field of software.
Notify of

This site uses Akismet to reduce spam. Learn how your comment data is processed.

Inline Feedbacks
View all comments
Back to top button