Merge pull request #40 from eugenp/master

update

algorithms-searching/src/main/java/com/baeldung/algorithms/suffixtree/Node.java

@@ -0,0 +1,57 @@
+package com.baeldung.algorithms.suffixtree;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Node {
+    private String text;
+    private List<Node> children;
+    private int position;
+
+    public Node(String word, int position) {
+        this.text = word;
+        this.position = position;
+        this.children = new ArrayList<>();
+    }
+
+    public String getText() {
+        return text;
+    }
+
+    public void setText(String text) {
+        this.text = text;
+    }
+
+    public int getPosition() {
+        return position;
+    }
+
+    public void setPosition(int position) {
+        this.position = position;
+    }
+
+    public List<Node> getChildren() {
+        return children;
+    }
+
+    public void setChildren(List<Node> children) {
+        this.children = children;
+    }
+
+    public String printTree(String depthIndicator) {
+        String str = "";
+        String positionStr = position > -1 ? "[" + String.valueOf(position) + "]" : "";
+        str += depthIndicator + text + positionStr + "\n";
+
+        for (int i = 0; i < children.size(); i++) {
+            str += children.get(i)
+                .printTree(depthIndicator + "\t");
+        }
+        return str;
+    }
+
+    @Override
+    public String toString() {
+        return printTree("");
+    }
+}

algorithms-searching/src/main/java/com/baeldung/algorithms/suffixtree/SuffixTree.java

@@ -0,0 +1,175 @@
+package com.baeldung.algorithms.suffixtree;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.stream.Collectors;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class SuffixTree {
+    private static final Logger LOGGER = LoggerFactory.getLogger(SuffixTree.class);
+    private static final String WORD_TERMINATION = "$";
+    private static final int POSITION_UNDEFINED = -1;
+    private Node root;
+    private String fullText;
+
+    public SuffixTree(String text) {
+        root = new Node("", POSITION_UNDEFINED);
+        for (int i = 0; i < text.length(); i++) {
+            addSuffix(text.substring(i) + WORD_TERMINATION, i);
+        }
+        fullText = text;
+    }
+
+    public List<String> searchText(String pattern) {
+        LOGGER.info("Searching for pattern \"{}\"", pattern);
+        List<String> result = new ArrayList<>();
+        List<Node> nodes = getAllNodesInTraversePath(pattern, root, false);
+
+        if (nodes.size() > 0) {
+            Node lastNode = nodes.get(nodes.size() - 1);
+            if (lastNode != null) {
+                List<Integer> positions = getPositions(lastNode);
+                positions = positions.stream()
+                    .sorted()
+                    .collect(Collectors.toList());
+                positions.forEach(m -> result.add((markPatternInText(m, pattern))));
+            }
+        }
+        return result;
+    }
+
+    private void addSuffix(String suffix, int position) {
+        LOGGER.info(">>>>>>>>>>>> Adding new suffix {}", suffix);
+        List<Node> nodes = getAllNodesInTraversePath(suffix, root, true);
+        if (nodes.size() == 0) {
+            addChildNode(root, suffix, position);
+            LOGGER.info("{}", printTree());
+        } else {
+            Node lastNode = nodes.remove(nodes.size() - 1);
+            String newText = suffix;
+            if (nodes.size() > 0) {
+                String existingSuffixUptoLastNode = nodes.stream()
+                    .map(a -> a.getText())
+                    .reduce("", String::concat);
+
+                // Remove prefix from newText already included in parent
+                newText = newText.substring(existingSuffixUptoLastNode.length());
+            }
+            extendNode(lastNode, newText, position);
+            LOGGER.info("{}", printTree());
+        }
+    }
+
+    private List<Integer> getPositions(Node node) {
+        List<Integer> positions = new ArrayList<>();
+        if (node.getText()
+            .endsWith(WORD_TERMINATION)) {
+            positions.add(node.getPosition());
+        }
+        for (int i = 0; i < node.getChildren()
+            .size(); i++) {
+            positions.addAll(getPositions(node.getChildren()
+                .get(i)));
+        }
+        return positions;
+    }
+
+    private String markPatternInText(Integer startPosition, String pattern) {
+        String matchingTextLHS = fullText.substring(0, startPosition);
+        String matchingText = fullText.substring(startPosition, startPosition + pattern.length());
+        String matchingTextRHS = fullText.substring(startPosition + pattern.length());
+        return matchingTextLHS + "[" + matchingText + "]" + matchingTextRHS;
+    }
+
+    private void addChildNode(Node parentNode, String text, int position) {
+        parentNode.getChildren()
+            .add(new Node(text, position));
+    }
+
+    private void extendNode(Node node, String newText, int position) {
+        String currentText = node.getText();
+        String commonPrefix = getLongestCommonPrefix(currentText, newText);
+
+        if (commonPrefix != currentText) {
+            String parentText = currentText.substring(0, commonPrefix.length());
+            String childText = currentText.substring(commonPrefix.length());
+            splitNodeToParentAndChild(node, parentText, childText);
+        }
+
+        String remainingText = newText.substring(commonPrefix.length());
+        addChildNode(node, remainingText, position);
+    }
+
+    private void splitNodeToParentAndChild(Node parentNode, String parentNewText, String childNewText) {
+        Node childNode = new Node(childNewText, parentNode.getPosition());
+
+        if (parentNode.getChildren()
+            .size() > 0) {
+            while (parentNode.getChildren()
+                .size() > 0) {
+                childNode.getChildren()
+                    .add(parentNode.getChildren()
+                        .remove(0));
+            }
+        }
+
+        parentNode.getChildren()
+            .add(childNode);
+        parentNode.setText(parentNewText);
+        parentNode.setPosition(POSITION_UNDEFINED);
+    }
+
+    private String getLongestCommonPrefix(String str1, String str2) {
+        int compareLength = Math.min(str1.length(), str2.length());
+        for (int i = 0; i < compareLength; i++) {
+            if (str1.charAt(i) != str2.charAt(i)) {
+                return str1.substring(0, i);
+            }
+        }
+        return str1.substring(0, compareLength);
+    }
+
+    private List<Node> getAllNodesInTraversePath(String pattern, Node startNode, boolean isAllowPartialMatch) {
+        List<Node> nodes = new ArrayList<>();
+        for (int i = 0; i < startNode.getChildren()
+            .size(); i++) {
+            Node currentNode = startNode.getChildren()
+                .get(i);
+            String nodeText = currentNode.getText();
+            if (pattern.charAt(0) == nodeText.charAt(0)) {
+                if (isAllowPartialMatch && pattern.length() <= nodeText.length()) {
+                    nodes.add(currentNode);
+                    return nodes;
+                }
+
+                int compareLength = Math.min(nodeText.length(), pattern.length());
+                for (int j = 1; j < compareLength; j++) {
+                    if (pattern.charAt(j) != nodeText.charAt(j)) {
+                        if (isAllowPartialMatch) {
+                            nodes.add(currentNode);
+                        }
+                        return nodes;
+                    }
+                }
+
+                nodes.add(currentNode);
+                if (pattern.length() > compareLength) {
+                    List<Node> nodes2 = getAllNodesInTraversePath(pattern.substring(compareLength), currentNode, isAllowPartialMatch);
+                    if (nodes2.size() > 0) {
+                        nodes.addAll(nodes2);
+                    } else if (!isAllowPartialMatch) {
+                        nodes.add(null);
+                    }
+                }
+                return nodes;
+            }
+        }
+        return nodes;
+    }
+
+    public String printTree() {
+        return root.printTree("");
+    }
+}

algorithms-searching/src/test/java/com/baeldung/algorithms/suffixtree/SuffixTreeUnitTest.java

@@ -0,0 +1,77 @@
+package com.baeldung.algorithms.suffixtree;
+
+import java.util.List;
+
+import org.junit.Assert;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class SuffixTreeUnitTest {
+
+    private static final Logger LOGGER = LoggerFactory.getLogger(SuffixTreeUnitTest.class);
+
+    private static SuffixTree suffixTree;
+
+    @BeforeClass
+    public static void setUp() {
+        suffixTree = new SuffixTree("havanabanana");
+        printTree();
+    }
+
+    @Test
+    public void givenSuffixTree_whenSearchingForA_thenReturn6Matches() {
+        List<String> matches = suffixTree.searchText("a");
+        matches.stream()
+            .forEach(m -> LOGGER.info(m));
+        Assert.assertArrayEquals(new String[] { "h[a]vanabanana", "hav[a]nabanana", "havan[a]banana", "havanab[a]nana", "havanaban[a]na", "havanabanan[a]" }, matches.toArray());
+    }
+
+    @Test
+    public void givenSuffixTree_whenSearchingForNab_thenReturn1Match() {
+        List<String> matches = suffixTree.searchText("nab");
+        matches.stream()
+            .forEach(m -> LOGGER.info(m));
+        Assert.assertArrayEquals(new String[] { "hava[nab]anana" }, matches.toArray());
+    }
+
+    @Test
+    public void givenSuffixTree_whenSearchingForNag_thenReturnNoMatches() {
+        List<String> matches = suffixTree.searchText("nag");
+        matches.stream()
+            .forEach(m -> LOGGER.info(m));
+        Assert.assertArrayEquals(new String[] {}, matches.toArray());
+    }
+
+    @Test
+    public void givenSuffixTree_whenSearchingForBanana_thenReturn2Matches() {
+        List<String> matches = suffixTree.searchText("ana");
+        matches.stream()
+            .forEach(m -> LOGGER.info(m));
+        Assert.assertArrayEquals(new String[] { "hav[ana]banana", "havanab[ana]na", "havanaban[ana]" }, matches.toArray());
+    }
+
+    @Test
+    public void givenSuffixTree_whenSearchingForNa_thenReturn4Matches() {
+        List<String> matches = suffixTree.searchText("na");
+        matches.stream()
+            .forEach(m -> LOGGER.info(m));
+        Assert.assertArrayEquals(new String[] { "hava[na]banana", "havanaba[na]na", "havanabana[na]" }, matches.toArray());
+    }
+
+    @Test
+    public void givenSuffixTree_whenSearchingForX_thenReturnNoMatches() {
+        List<String> matches = suffixTree.searchText("x");
+        matches.stream()
+            .forEach(m -> LOGGER.info(m));
+        Assert.assertArrayEquals(new String[] {}, matches.toArray());
+    }
+
+    private static void printTree() {
+        suffixTree.printTree();
+
+        LOGGER.info("\n" + suffixTree.printTree());
+        LOGGER.info("==============================================");
+    }
+}

core-java-modules/core-java-14/src/main/java/com/baeldung/java14/patternmatchingforinstanceof/PatternMatchingForInstanceOf.java

@@ -0,0 +1,26 @@
+package com.baeldung.java14.patternmatchingforinstanceof;
+
+public class PatternMatchingForInstanceOf {
+
+    public void performAnimalOperations(Animal animal) {
+         if (animal instanceof Cat cat) {
+             cat.meow();
+         } else if(animal instanceof Dog dog) {
+             dog.woof();
+         }
+    }
+
+    abstract class Animal {
+    }
+
+    final class Cat extends Animal {
+        void meow() {
+        }
+    }
+
+    final class Dog extends Animal {
+        void woof() {
+        }
+    }
+
+}

core-java-modules/core-java-14/src/test/java/com/baeldung/java14/patternmatchingforinstanceof/PatternMatchingForInstanceOfUnitTest.java

@@ -0,0 +1,33 @@
+package com.baeldung.java14.patternmatchingforinstanceof;
+
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+
+import org.junit.jupiter.api.Test;
+
+import com.baeldung.java14.patternmatchingforinstanceof.PatternMatchingForInstanceOf.Cat;
+import com.baeldung.java14.patternmatchingforinstanceof.PatternMatchingForInstanceOf.Dog;
+
+class PatternMatchingForInstanceOfUnitTest {
+
+    @Test
+    void givenAnAnimal_whenTypeIsCat_ThenCatGoesMeow() {
+        Cat animal = mock(Cat.class);
+
+        PatternMatchingForInstanceOf instanceOf = new PatternMatchingForInstanceOf();
+        instanceOf.performAnimalOperations(animal);
+
+        verify(animal).meow();
+    }
+
+    @Test
+    void givenAnAnimal_whenTypeIsDog_ThenDogGoesWoof() {
+        Dog animal = mock(Dog.class);
+
+        PatternMatchingForInstanceOf instanceOf = new PatternMatchingForInstanceOf();
+        instanceOf.performAnimalOperations(animal);
+
+        verify(animal).woof();
+    }
+
+}

core-java-modules/core-java-exceptions-2/src/main/java/com/baeldung/suppressed/ExceptionalResource.java

@@ -0,0 +1,13 @@
+package com.baeldung.suppressed;
+
+public class ExceptionalResource implements AutoCloseable {
+    
+    public void processSomething() {
+        throw new IllegalArgumentException("Thrown from processSomething()");
+    }
+
+    @Override
+    public void close() throws Exception {
+        throw new NullPointerException("Thrown from close()");
+    }
+}

core-java-modules/core-java-exceptions-2/src/main/java/com/baeldung/suppressed/SuppressedExceptionsDemo.java

@@ -0,0 +1,44 @@
+package com.baeldung.suppressed;
+
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+
+public class SuppressedExceptionsDemo {
+
+    public static void demoSuppressedException(String filePath) throws IOException {
+        FileInputStream fileIn = null;
+        try {
+            fileIn = new FileInputStream(filePath);
+        } catch (FileNotFoundException e) {
+            throw new IOException(e);
+        } finally {
+            fileIn.close();
+        }
+    }
+    
+    public static void demoAddSuppressedException(String filePath) throws IOException {
+        Throwable firstException = null;
+        FileInputStream fileIn = null;
+        try {
+            fileIn = new FileInputStream(filePath);
+        } catch (IOException e) {
+            firstException = e;
+        } finally {
+            try {
+                fileIn.close();
+            } catch (NullPointerException npe) {
+                if (firstException != null) {
+                    npe.addSuppressed(firstException);
+                }
+                throw npe;
+            }
+        }
+    }
+    
+    public static void demoExceptionalResource() throws Exception {
+        try (ExceptionalResource exceptionalResource = new ExceptionalResource()) {
+            exceptionalResource.processSomething();
+        }
+    }
+}

core-java-modules/core-java-exceptions-2/src/test/java/com/baeldung/suppressed/SuppressedExceptionsUnitTest.java

@@ -0,0 +1,42 @@
+package com.baeldung.suppressed;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertThat;
+
+import java.io.FileNotFoundException;
+import java.io.IOException;
+
+import org.junit.Test;
+import static org.hamcrest.CoreMatchers.instanceOf;
+
+public class SuppressedExceptionsUnitTest {
+
+    @Test(expected = NullPointerException.class)
+    public void givenNonExistentFileName_whenAttemptFileOpen_thenNullPointerException() throws IOException {
+        SuppressedExceptionsDemo.demoSuppressedException("/non-existent-path/non-existent-file.txt");
+    }
+    
+    @Test
+    public void givenNonExistentFileName_whenAttemptFileOpenStoreSuppressed_thenSuppressedExceptionAvailable() {
+        try {
+            SuppressedExceptionsDemo.demoAddSuppressedException("/non-existent-path/non-existent-file.txt");
+        } catch (Exception e) {
+            assertThat(e, instanceOf(NullPointerException.class));
+            assertEquals(1, e.getSuppressed().length);
+            assertThat(e.getSuppressed()[0], instanceOf(FileNotFoundException.class));
+        }
+    }
+    
+    @Test
+    public void whenUsingExceptionalResource_thenSuppressedExceptionAvailable() {
+        try {
+            SuppressedExceptionsDemo.demoExceptionalResource();
+        } catch (Exception e) {
+            assertThat(e, instanceOf(IllegalArgumentException.class));
+            assertEquals("Thrown from processSomething()", e.getMessage());
+            assertEquals(1, e.getSuppressed().length);
+            assertThat(e.getSuppressed()[0], instanceOf(NullPointerException.class));
+            assertEquals("Thrown from close()", e.getSuppressed()[0].getMessage());
+        }
+    }
+}

ddd-modules/README.md

@@ -0,0 +1 @@
+## Relevant Articles

ddd-modules/infrastructure/pom.xml

@@ -0,0 +1,53 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <groupId>com.baeldung.dddmodules.infrastructure</groupId>
+    <artifactId>infrastructure</artifactId>
+    <version>1.0</version>
+
+    <packaging>jar</packaging>
+
+    <parent>
+        <groupId>com.baeldung.dddmodules</groupId>
+        <artifactId>dddmodules</artifactId>
+        <version>1.0</version>
+    </parent>
+
+    <dependencies>
+        <dependency>
+            <groupId>com.baeldung.dddmodules.shippingcontext</groupId>
+            <artifactId>shippingcontext</artifactId>
+            <version>${appmodules.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>com.baeldung.dddmodules.ordercontext</groupId>
+            <artifactId>ordercontext</artifactId>
+            <version>${appmodules.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>com.baeldung.dddmodules.sharedkernel</groupId>
+            <artifactId>sharedkernel</artifactId>
+            <version>${appmodules.version}</version>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <configuration>
+                    <source>${source.version}</source>
+                    <target>${target.version}</target>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+
+    <properties>
+        <source.version>9</source.version>
+        <target.version>9</target.version>
+    </properties>
+
+</project>

ddd-modules/infrastructure/src/main/java/com/baeldung/dddmodules/infrastructure/db/InMemoryOrderStore.java

@@ -0,0 +1,79 @@
+package com.baeldung.dddmodules.infrastructure.db;
+
+import com.baeldung.dddmodules.ordercontext.model.CustomerOrder;
+import com.baeldung.dddmodules.ordercontext.repository.CustomerOrderRepository;
+import com.baeldung.dddmodules.shippingcontext.model.PackageItem;
+import com.baeldung.dddmodules.shippingcontext.model.ShippableOrder;
+import com.baeldung.dddmodules.shippingcontext.repository.ShippingOrderRepository;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.stream.Collectors;
+
+public class InMemoryOrderStore implements CustomerOrderRepository, ShippingOrderRepository {
+    private Map<Integer, PersistenceOrder> ordersDb = new HashMap<>();
+    private volatile static InMemoryOrderStore instance = new InMemoryOrderStore();
+
+    @Override
+    public void saveCustomerOrder(CustomerOrder order) {
+        this.ordersDb.put(order.getOrderId(), new PersistenceOrder(order.getOrderId(),
+          order.getPaymentMethod(),
+          order.getAddress(),
+          order
+            .getOrderItems()
+            .stream()
+            .map(orderItem ->
+              new PersistenceOrder.OrderItem(orderItem.getProductId(),
+                orderItem.getQuantity(),
+                orderItem.getUnitWeight(),
+                orderItem.getUnitPrice()))
+            .collect(Collectors.toList())
+        ));
+    }
+
+    @Override
+    public Optional<ShippableOrder> findShippableOrder(int orderId) {
+        if (!this.ordersDb.containsKey(orderId)) return Optional.empty();
+        PersistenceOrder orderRecord = this.ordersDb.get(orderId);
+        return Optional.of(
+          new ShippableOrder(orderRecord.orderId, orderRecord.orderItems
+            .stream().map(orderItem -> new PackageItem(orderItem.productId,
+              orderItem.itemWeight,
+              orderItem.quantity * orderItem.unitPrice)
+            ).collect(Collectors.toList())));
+    }
+
+    public static InMemoryOrderStore provider() {
+        return instance;
+    }
+
+    public static class PersistenceOrder {
+        public int orderId;
+        public String paymentMethod;
+        public String address;
+        public List<OrderItem> orderItems;
+
+        public PersistenceOrder(int orderId, String paymentMethod, String address, List<OrderItem> orderItems) {
+            this.orderId = orderId;
+            this.paymentMethod = paymentMethod;
+            this.address = address;
+            this.orderItems = orderItems;
+        }
+
+        public static class OrderItem {
+            public int productId;
+            public float unitPrice;
+            public float itemWeight;
+            public int quantity;
+
+            public OrderItem(int productId, int quantity, float unitWeight, float unitPrice) {
+                this.itemWeight = unitWeight;
+                this.quantity = quantity;
+                this.unitPrice = unitPrice;
+                this.productId = productId;
+            }
+        }
+    }
+}

ddd-modules/infrastructure/src/main/java/com/baeldung/dddmodules/infrastructure/events/SimpleEventBus.java

@@ -0,0 +1,39 @@
+package com.baeldung.dddmodules.infrastructure.events;
+
+import com.baeldung.dddmodules.sharedkernel.events.ApplicationEvent;
+import com.baeldung.dddmodules.sharedkernel.events.EventBus;
+import com.baeldung.dddmodules.sharedkernel.events.EventSubscriber;
+
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.CopyOnWriteArraySet;
+
+public class SimpleEventBus implements EventBus {
+    private final Map<String, Set<EventSubscriber>> subscribers = new ConcurrentHashMap<>();
+
+    @Override
+    public <E extends ApplicationEvent> void publish(E event) {
+        if (subscribers.containsKey(event.getType())) {
+            subscribers.get(event.getType())
+              .forEach(subscriber -> subscriber.onEvent(event));
+        }
+    }
+
+    @Override
+    public <E extends ApplicationEvent> void subscribe(String eventType, EventSubscriber subscriber) {
+        Set<EventSubscriber> eventSubscribers = subscribers.get(eventType);
+        if (eventSubscribers == null) {
+            eventSubscribers = new CopyOnWriteArraySet<>();
+            subscribers.put(eventType, eventSubscribers);
+        }
+        eventSubscribers.add(subscriber);
+    }
+
+    @Override
+    public <E extends ApplicationEvent> void unsubscribe(String eventType, EventSubscriber subscriber) {
+        if (subscribers.containsKey(eventType)) {
+            subscribers.get(eventType).remove(subscriber);
+        }
+    }
+}

ddd-modules/infrastructure/src/main/java/module-info.java

@@ -0,0 +1,11 @@
+module com.baeldung.dddmodules.infrastructure {
+    requires transitive com.baeldung.dddmodules.sharedkernel;
+    requires transitive com.baeldung.dddmodules.ordercontext;
+    requires transitive com.baeldung.dddmodules.shippingcontext;
+    provides com.baeldung.dddmodules.sharedkernel.events.EventBus
+      with com.baeldung.dddmodules.infrastructure.events.SimpleEventBus;
+    provides com.baeldung.dddmodules.ordercontext.repository.CustomerOrderRepository
+      with com.baeldung.dddmodules.infrastructure.db.InMemoryOrderStore;
+    provides com.baeldung.dddmodules.shippingcontext.repository.ShippingOrderRepository
+      with com.baeldung.dddmodules.infrastructure.db.InMemoryOrderStore;
+}

ddd-modules/mainapp/pom.xml

@@ -0,0 +1,51 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <groupId>com.baeldung.dddmodules.mainapp</groupId>
+    <artifactId>mainapp</artifactId>
+    <version>1.0</version>
+    <packaging>jar</packaging>
+
+    <parent>
+        <groupId>com.baeldung.dddmodules</groupId>
+        <artifactId>dddmodules</artifactId>
+        <version>1.0</version>
+    </parent>
+
+    <dependencies>
+        <dependency>
+            <groupId>com.baeldung.dddmodules.infrastructure</groupId>
+            <artifactId>infrastructure</artifactId>
+            <version>${appmodules.version}</version>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-surefire-plugin</artifactId>
+                <version>2.16</version>
+                <configuration>
+                    <enableAssertions>true</enableAssertions>
+                </configuration>
+            </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <version>${compiler.plugin.version}</version>
+                <configuration>
+                    <source>${source.version}</source>
+                    <target>${target.version}</target>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+
+    <properties>
+        <source.version>9</source.version>
+        <target.version>9</target.version>
+    </properties>
+
+</project>

ddd-modules/mainapp/src/main/java/com/baeldung/dddmodules/mainapp/Application.java

@@ -0,0 +1,54 @@
+package com.baeldung.dddmodules.mainapp;
+
+import com.baeldung.dddmodules.ordercontext.model.CustomerOrder;
+import com.baeldung.dddmodules.ordercontext.model.OrderItem;
+import com.baeldung.dddmodules.ordercontext.repository.CustomerOrderRepository;
+import com.baeldung.dddmodules.ordercontext.service.OrderService;
+import com.baeldung.dddmodules.sharedkernel.events.EventBus;
+import com.baeldung.dddmodules.shippingcontext.repository.ShippingOrderRepository;
+import com.baeldung.dddmodules.shippingcontext.service.ShippingService;
+
+import java.util.*;
+
+public class Application {
+
+    public static void main(String args[]) {
+        Map<Class<?>, Object> container = createContainer();
+        OrderService orderService = (OrderService) container.get(OrderService.class);
+        ShippingService shippingService = (ShippingService) container.get(ShippingService.class);
+        shippingService.listenToOrderEvents();
+
+        CustomerOrder customerOrder = new CustomerOrder();
+        int orderId = 1;
+        customerOrder.setOrderId(orderId);
+        List<OrderItem> orderItems = new ArrayList<OrderItem>();
+        orderItems.add(new OrderItem(1, 2, 3, 1));
+        orderItems.add(new OrderItem(2, 1, 1, 1));
+        orderItems.add(new OrderItem(3, 4, 11, 21));
+        customerOrder.setOrderItems(orderItems);
+        customerOrder.setPaymentMethod("PayPal");
+        customerOrder.setAddress("Full address here");
+        orderService.placeOrder(customerOrder);
+
+        if (orderId == shippingService.getParcelByOrderId(orderId).get().getOrderId()) {
+            System.out.println("Order has been processed and shipped successfully");
+        }
+    }
+
+    public static Map<Class<?>, Object> createContainer() {
+        EventBus eventBus = ServiceLoader.load(EventBus.class).findFirst().get();
+        CustomerOrderRepository customerOrderRepository = ServiceLoader.load(CustomerOrderRepository.class).findFirst().get();
+        ShippingOrderRepository shippingOrderRepository = ServiceLoader.load(ShippingOrderRepository.class).findFirst().get();
+        ShippingService shippingService = ServiceLoader.load(ShippingService.class).findFirst().get();
+        shippingService.setEventBus(eventBus);
+        shippingService.setOrderRepository(shippingOrderRepository);
+        OrderService orderService = ServiceLoader.load(OrderService.class).findFirst().get();
+        orderService.setEventBus(eventBus);
+        orderService.setOrderRepository(customerOrderRepository);
+        HashMap<Class<?>, Object> container = new HashMap<>();
+        container.put(OrderService.class, orderService);
+        container.put(ShippingService.class, shippingService);
+        return container;
+    }
+
+}

ddd-modules/mainapp/src/main/java/module-info.java

@@ -0,0 +1,8 @@
+module com.baeldung.dddmodules.mainapp {
+    uses com.baeldung.dddmodules.sharedkernel.events.EventBus;
+    uses com.baeldung.dddmodules.ordercontext.service.OrderService;
+    uses com.baeldung.dddmodules.ordercontext.repository.CustomerOrderRepository;
+    uses com.baeldung.dddmodules.shippingcontext.repository.ShippingOrderRepository;
+    uses com.baeldung.dddmodules.shippingcontext.service.ShippingService;
+    requires transitive com.baeldung.dddmodules.infrastructure;
+}

ddd-modules/ordercontext/pom.xml

@@ -0,0 +1,44 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <groupId>com.baeldung.dddmodules.ordercontext</groupId>
+    <artifactId>ordercontext</artifactId>
+    <version>1.0</version>
+    <packaging>jar</packaging>
+
+    <parent>
+        <groupId>com.baeldung.dddmodules</groupId>
+        <artifactId>dddmodules</artifactId>
+        <version>1.0</version>
+    </parent>
+
+    <dependencies>
+        <dependency>
+            <groupId>com.baeldung.dddmodules.sharedkernel</groupId>
+            <artifactId>sharedkernel</artifactId>
+            <version>${appmodules.version}</version>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <configuration>
+                    <source>${source.version}</source>
+                    <target>${target.version}</target>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+
+    <properties>
+        <source.version>9</source.version>
+        <target.version>9</target.version>
+        <entitymodule.version>1.0</entitymodule.version>
+        <daomodule.version>1.0</daomodule.version>
+    </properties>
+
+</project>

ddd-modules/ordercontext/src/main/java/com/baeldung/dddmodules/ordercontext/model/CustomerOrder.java

@@ -0,0 +1,51 @@
+package com.baeldung.dddmodules.ordercontext.model;
+
+import java.util.List;
+
+public class CustomerOrder {
+    private int orderId;
+    private String paymentMethod;
+    private String address;
+    private List<OrderItem> orderItems;
+
+    public CustomerOrder() {
+
+    }
+
+    public float calculateTotalPrice() {
+        return orderItems.stream().map(OrderItem::getTotalPrice)
+          .reduce(0F, Float::sum);
+    }
+
+    public void setOrderItems(List<OrderItem> orderItems) {
+        this.orderItems = orderItems;
+    }
+
+    public int getOrderId() {
+        return orderId;
+    }
+
+    public List<OrderItem> getOrderItems() {
+        return orderItems;
+    }
+
+    public void setOrderId(int orderId) {
+        this.orderId = orderId;
+    }
+
+    public String getPaymentMethod() {
+        return paymentMethod;
+    }
+
+    public void setPaymentMethod(String paymentMethod) {
+        this.paymentMethod = paymentMethod;
+    }
+
+    public String getAddress() {
+        return address;
+    }
+
+    public void setAddress(String address) {
+        this.address = address;
+    }
+}

ddd-modules/ordercontext/src/main/java/com/baeldung/dddmodules/ordercontext/model/OrderItem.java

@@ -0,0 +1,51 @@
+package com.baeldung.dddmodules.ordercontext.model;
+
+public class OrderItem {
+    private int productId;
+    private int quantity;
+    private float unitPrice;
+    private float unitWeight;
+
+    public OrderItem(int productId, int quantity, float unitPrice, float unitWeight) {
+        this.productId = productId;
+        this.quantity = quantity;
+        this.unitPrice = unitPrice;
+        this.unitWeight = unitWeight;
+    }
+
+    public int getProductId() {
+        return productId;
+    }
+
+    public void setProductId(int productId) {
+        this.productId = productId;
+    }
+
+    public int getQuantity() {
+        return quantity;
+    }
+
+    public void setQuantity(int quantity) {
+        this.quantity = quantity;
+    }
+
+    public float getTotalPrice() {
+        return this.quantity * this.unitPrice;
+    }
+
+    public void setUnitPrice(float unitPrice) {
+        this.unitPrice = unitPrice;
+    }
+
+    public float getUnitWeight() {
+        return unitWeight;
+    }
+
+    public float getUnitPrice() {
+        return unitPrice;
+    }
+
+    public void setUnitWeight(float unitWeight) {
+        this.unitWeight = unitWeight;
+    }
+}

ddd-modules/ordercontext/src/main/java/com/baeldung/dddmodules/ordercontext/repository/CustomerOrderRepository.java

@@ -0,0 +1,7 @@
+package com.baeldung.dddmodules.ordercontext.repository;
+
+import com.baeldung.dddmodules.ordercontext.model.CustomerOrder;
+
+public interface CustomerOrderRepository {
+    void saveCustomerOrder(CustomerOrder order);
+}

ddd-modules/ordercontext/src/main/java/com/baeldung/dddmodules/ordercontext/service/CustomerOrderService.java

@@ -0,0 +1,44 @@
+package com.baeldung.dddmodules.ordercontext.service;
+
+import com.baeldung.dddmodules.ordercontext.model.CustomerOrder;
+import com.baeldung.dddmodules.ordercontext.repository.CustomerOrderRepository;
+import com.baeldung.dddmodules.sharedkernel.events.ApplicationEvent;
+import com.baeldung.dddmodules.sharedkernel.events.EventBus;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class CustomerOrderService implements OrderService {
+    public static final String EVENT_ORDER_READY_FOR_SHIPMENT = "OrderReadyForShipmentEvent";
+
+    private CustomerOrderRepository orderRepository;
+    private EventBus eventBus;
+
+    @Override
+    public void placeOrder(CustomerOrder order) {
+        this.orderRepository.saveCustomerOrder(order);
+        Map<String, String> payload = new HashMap<>();
+        payload.put("order_id", String.valueOf(order.getOrderId()));
+        ApplicationEvent event = new ApplicationEvent(payload) {
+            @Override
+            public String getType() {
+                return EVENT_ORDER_READY_FOR_SHIPMENT;
+            }
+        };
+        this.eventBus.publish(event);
+    }
+
+    @Override
+    public EventBus getEventBus() {
+        return eventBus;
+    }
+
+    public void setOrderRepository(CustomerOrderRepository orderRepository) {
+        this.orderRepository = orderRepository;
+    }
+
+    @Override
+    public void setEventBus(EventBus eventBus) {
+        this.eventBus = eventBus;
+    }
+}

ddd-modules/ordercontext/src/main/java/com/baeldung/dddmodules/ordercontext/service/OrderService.java

@@ -0,0 +1,11 @@
+package com.baeldung.dddmodules.ordercontext.service;
+
+import com.baeldung.dddmodules.ordercontext.model.CustomerOrder;
+import com.baeldung.dddmodules.ordercontext.repository.CustomerOrderRepository;
+import com.baeldung.dddmodules.sharedkernel.service.ApplicationService;
+
+public interface OrderService extends ApplicationService {
+    void placeOrder(CustomerOrder order);
+
+    void setOrderRepository(CustomerOrderRepository orderRepository);
+}

ddd-modules/ordercontext/src/main/java/module-info.java

@@ -0,0 +1,8 @@
+module com.baeldung.dddmodules.ordercontext {
+    requires com.baeldung.dddmodules.sharedkernel;
+    exports com.baeldung.dddmodules.ordercontext.service;
+    exports com.baeldung.dddmodules.ordercontext.model;
+    exports com.baeldung.dddmodules.ordercontext.repository;
+    provides com.baeldung.dddmodules.ordercontext.service.OrderService
+      with com.baeldung.dddmodules.ordercontext.service.CustomerOrderService;
+}

ddd-modules/pom.xml

@@ -0,0 +1,68 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <groupId>com.baeldung.dddmodules</groupId>
+    <artifactId>dddmodules</artifactId>
+    <version>1.0</version>
+    <name>ddd-modules</name>
+    <packaging>pom</packaging>
+
+    <parent>
+        <groupId>com.baeldung</groupId>
+        <artifactId>parent-modules</artifactId>
+        <version>1.0.0-SNAPSHOT</version>
+        <relativePath>../</relativePath>
+    </parent>
+
+    <modules>
+        <module>sharedkernel</module>
+        <module>infrastructure</module>
+        <module>shippingcontext</module>
+        <module>ordercontext</module>
+        <module>mainapp</module>
+    </modules>
+
+    <dependencyManagement>
+        <dependencies>
+            <dependency>
+                <groupId>junit</groupId>
+                <artifactId>junit</artifactId>
+                <version>${junit.version}</version>
+                <scope>test</scope>
+            </dependency>
+            <dependency>
+                <groupId>org.assertj</groupId>
+                <artifactId>assertj-core</artifactId>
+                <version>${assertj-core.version}</version>
+                <scope>test</scope>
+            </dependency>
+        </dependencies>
+    </dependencyManagement>
+
+    <build>
+        <pluginManagement>
+            <plugins>
+                <plugin>
+                    <groupId>org.apache.maven.plugins</groupId>
+                    <artifactId>maven-compiler-plugin</artifactId>
+                    <version>${compiler.plugin.version}</version>
+                    <configuration>
+                        <source>${source.version}</source>
+                        <target>${target.version}</target>
+                    </configuration>
+                </plugin>
+            </plugins>
+        </pluginManagement>
+    </build>
+
+    <properties>
+        <compiler.plugin.version>3.8.1</compiler.plugin.version>
+        <source.version>9</source.version>
+        <target.version>9</target.version>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+        <assertj-core.version>3.12.2</assertj-core.version>
+        <appmodules.version>1.0</appmodules.version>
+    </properties>
+
+</project>

ddd-modules/sharedkernel/pom.xml

@@ -0,0 +1,34 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <groupId>com.baeldung.dddmodules.sharedkernel</groupId>
+    <artifactId>sharedkernel</artifactId>
+    <version>1.0</version>
+    <packaging>jar</packaging>
+
+    <parent>
+        <groupId>com.baeldung.dddmodules</groupId>
+        <artifactId>dddmodules</artifactId>
+        <version>1.0</version>
+    </parent>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <configuration>
+                    <source>${source.version}</source>
+                    <target>${target.version}</target>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+
+    <properties>
+        <source.version>9</source.version>
+        <target.version>9</target.version>
+    </properties>
+
+</project>

ddd-modules/sharedkernel/src/main/java/com/baeldung/dddmodules/sharedkernel/events/ApplicationEvent.java

@@ -0,0 +1,21 @@
+package com.baeldung.dddmodules.sharedkernel.events;
+
+import java.util.Map;
+
+public abstract class ApplicationEvent {
+    protected Map<String, String> payload;
+
+    public abstract String getType();
+
+    public String getPayloadValue(String key) {
+        if (this.payload.containsKey(key)) {
+            return this.payload.get(key);
+        }
+        return "";
+    }
+
+    public ApplicationEvent(Map<String, String> payload) {
+        this.payload = payload;
+    }
+}
+

ddd-modules/sharedkernel/src/main/java/com/baeldung/dddmodules/sharedkernel/events/EventBus.java

@@ -0,0 +1,9 @@
+package com.baeldung.dddmodules.sharedkernel.events;
+
+public interface EventBus {
+    <E extends ApplicationEvent> void publish(E event);
+
+    <E extends ApplicationEvent> void subscribe(String eventType, EventSubscriber subscriber);
+
+    <E extends ApplicationEvent> void unsubscribe(String eventType, EventSubscriber subscriber);
+}

ddd-modules/sharedkernel/src/main/java/com/baeldung/dddmodules/sharedkernel/events/EventSubscriber.java

@@ -0,0 +1,5 @@
+package com.baeldung.dddmodules.sharedkernel.events;
+
+public interface EventSubscriber {
+    <E extends ApplicationEvent> void onEvent(E event);
+}

ddd-modules/sharedkernel/src/main/java/com/baeldung/dddmodules/sharedkernel/service/ApplicationService.java

@@ -0,0 +1,33 @@
+package com.baeldung.dddmodules.sharedkernel.service;
+
+import com.baeldung.dddmodules.sharedkernel.events.ApplicationEvent;
+import com.baeldung.dddmodules.sharedkernel.events.EventBus;
+import com.baeldung.dddmodules.sharedkernel.events.EventSubscriber;
+
+public interface ApplicationService {
+
+    default <E extends ApplicationEvent> void publishEvent(E event) {
+        EventBus eventBus = getEventBus();
+        if (eventBus != null) {
+            eventBus.publish(event);
+        }
+    }
+
+    default <E extends ApplicationEvent> void subscribe(String eventType, EventSubscriber subscriber) {
+        EventBus eventBus = getEventBus();
+        if (eventBus != null) {
+            eventBus.subscribe(eventType, subscriber);
+        }
+    }
+
+    default <E extends ApplicationEvent> void unsubscribe(String eventType, EventSubscriber subscriber) {
+        EventBus eventBus = getEventBus();
+        if (eventBus != null) {
+            eventBus.unsubscribe(eventType, subscriber);
+        }
+    }
+
+    EventBus getEventBus();
+
+    void setEventBus(EventBus eventBus);
+}

ddd-modules/sharedkernel/src/main/java/module-info.java

@@ -0,0 +1,4 @@
+module com.baeldung.dddmodules.sharedkernel {
+    exports com.baeldung.dddmodules.sharedkernel.events;
+    exports com.baeldung.dddmodules.sharedkernel.service;
+}