/target

layout: pattern

title: Data Bus

folder: data-bus

permalink: /patterns/data-bus/

categories: Architectural

tags:

- Java

- Difficulty-Intermediate

Allows send of messages/events between components of an application

without them needing to know about each other. They only need to know

about the type of the message/event being sent.


Use Data Bus pattern when

* you want your components to decide themselves which messages/events they want to receive

* you want to have many-to-many communication

* you want your components to know nothing about each other

Data Bus is similar to

* Mediator pattern with Data Bus Members deciding for themselves if they want to accept any given message

* Observer pattern but supporting many-to-many communication

* Publish/Subscribe pattern with the Data Bus decoupling the publisher and the subscriber

package com.iluwatar.databus {

class AbstractDataType {

- dataBus : DataBus

+ AbstractDataType()

+ getDataBus() : DataBus

+ setDataBus(dataBus : DataBus)

}

~class App {

- log : Logger {static}

~ App()

+ main(args : String[]) {static}

}

class DataBus {

- INSTANCE : DataBus {static}

- listeners : Set<Member>

+ DataBus()

+ getInstance() : DataBus {static}

+ publish(event : DataType)

+ subscribe(member : Member)

+ unsubscribe(member : Member)

}

interface DataType {

+ getDataBus() : DataBus {abstract}

+ setDataBus(DataBus) {abstract}

}

interface Member {

+ accept(DataType) {abstract}

}

}

package com.iluwatar.databus.data {

class MessageData {

- message : String

+ MessageData(message : String)

+ getMessage() : String

+ of(message : String) : DataType {static}

}

class StartingData {

- when : LocalDateTime

+ StartingData(when : LocalDateTime)

+ getWhen() : LocalDateTime

+ of(when : LocalDateTime) : DataType {static}

}

class StoppingData {

- when : LocalDateTime

+ StoppingData(when : LocalDateTime)

+ getWhen() : LocalDateTime

+ of(when : LocalDateTime) : DataType {static}

}

}

package com.iluwatar.databus.members {

class CounterMember {

- log : Logger {static}

- name : String

+ CounterMember(name : String)

+ accept(data : DataType)

- handleEvent(data : MessageData)

}

class StatusMember {

- id : int

- log : Logger {static}

+ StatusMember(id : int)

+ accept(data : DataType)

- handleEvent(data : StartingData)

- handleEvent(data : StoppingData)

}

}

AbstractDataType --> "-dataBus" DataBus

DataBus --> "-INSTANCE" DataBus

DataBus --> "-listeners" Member

AbstractDataType ..|> DataType

MessageData --|> AbstractDataType

StartingData --|> AbstractDataType

StoppingData --|> AbstractDataType

CounterMember ..|> Member

StatusMember ..|> Member

<?xml version="1.0"?>

<project xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"

xmlns="http://maven.apache.org/POM/4.0.0"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">

<modelVersion>4.0.0</modelVersion>

<properties>

<lombok.version>1.16.14</lombok.version>

</properties>

<parent>

<groupId>com.iluwatar</groupId>

<artifactId>java-design-patterns</artifactId>

<version>1.16.0-SNAPSHOT</version>

</parent>

<artifactId>data-bus</artifactId>

<dependencies>

<dependency>

<groupId>junit</groupId>

<artifactId>junit</artifactId>

<scope>test</scope>

</dependency>

<dependency>

<groupId>org.mockito</groupId>

<artifactId>mockito-core</artifactId>

<scope>test</scope>

</dependency>

</dependencies>

</project>

package com.iluwatar.databus;

public class AbstractDataType implements DataType {

private DataBus dataBus;

@Override

public DataBus getDataBus() {

return dataBus;

}

@Override

public void setDataBus(DataBus dataBus) {

this.dataBus = dataBus;

}

}

package com.iluwatar.databus;

import com.iluwatar.databus.data.MessageData;

import com.iluwatar.databus.data.StartingData;

import com.iluwatar.databus.data.StoppingData;

import com.iluwatar.databus.members.MessageCollectorMember;

import com.iluwatar.databus.members.StatusMember;

import java.time.LocalDateTime;

class App {

public static void main(String[] args) {

final DataBus bus = DataBus.getInstance();

bus.subscribe(new StatusMember(1));

bus.subscribe(new StatusMember(2));

final MessageCollectorMember foo = new MessageCollectorMember("Foo");

final MessageCollectorMember bar = new MessageCollectorMember("Bar");

bus.subscribe(foo);

bus.publish(StartingData.of(LocalDateTime.now()));

bus.publish(MessageData.of("Only Foo should see this"));

bus.subscribe(bar);

bus.publish(MessageData.of("Foo and Bar should see this"));

bus.unsubscribe(foo);

bus.publish(MessageData.of("Only Bar should see this"));

bus.publish(StoppingData.of(LocalDateTime.now()));

}

}

package com.iluwatar.databus;

import java.util.HashSet;

import java.util.Set;

public class DataBus {

private static final DataBus INSTANCE = new DataBus();

private final Set<Member> listeners = new HashSet<>();

public static DataBus getInstance() {

return INSTANCE;

}

/**

public void subscribe(final Member member) {

this.listeners.add(member);

}

/**

public void unsubscribe(final Member member) {

this.listeners.remove(member);

}

/**

public void publish(final DataType event) {

event.setDataBus(this);

listeners.forEach(listener -> listener.accept(event));

}

}