Merge branch 'master' of https://github.com/eugenp/tutorials

cas/cas-secured-app/README.md

@@ -0,0 +1,2 @@
+## Relevant articles:
+- [CAS SSO With Spring Security](http://www.baeldung.com/spring-security-cas-sso)

cas/cas-secured-app/pom.xml

@@ -14,7 +14,7 @@
 	<parent>
 		<groupId>org.springframework.boot</groupId>
 		<artifactId>spring-boot-starter-parent</artifactId>
-		<version>2.0.0.BUILD-SNAPSHOT</version>
+		<version>2.0.0.M7</version>
 		<relativePath/> <!-- lookup parent from repository -->
 	</parent>
 
@@ -87,14 +87,6 @@
 	</build>
 
 	<repositories>
-		<repository>
-			<id>spring-snapshots</id>
-			<name>Spring Snapshots</name>
-			<url>https://repo.spring.io/snapshot</url>
-			<snapshots>
-				<enabled>true</enabled>
-			</snapshots>
-		</repository>
 		<repository>
 			<id>spring-milestones</id>
 			<name>Spring Milestones</name>
@@ -106,14 +98,6 @@
 	</repositories>
 
 	<pluginRepositories>
-		<pluginRepository>
-			<id>spring-snapshots</id>
-			<name>Spring Snapshots</name>
-			<url>https://repo.spring.io/snapshot</url>
-			<snapshots>
-				<enabled>true</enabled>
-			</snapshots>
-		</pluginRepository>
 		<pluginRepository>
 			<id>spring-milestones</id>
 			<name>Spring Milestones</name>

core-java-8/README.md

@@ -32,3 +32,4 @@
 - [“Stream has already been operated upon or closed” Exception in Java](http://www.baeldung.com/java-stream-operated-upon-or-closed-exception)
 - [Display All Time Zones With GMT And UTC in Java](http://www.baeldung.com/java-time-zones)
 - [Copy a File with Java](http://www.baeldung.com/java-copy-file)
+- [Generating Prime Numbers in Java](http://www.baeldung.com/java-generate-prime-numbers)

core-java-9/README.md

@@ -18,3 +18,4 @@
 - [How to Get All Dates Between Two Dates?](http://www.baeldung.com/java-between-dates)
 - [Java 9 java.util.Objects Additions](http://www.baeldung.com/java-9-objects-new)
 - [Compact Strings in Java 9](http://www.baeldung.com/java-9-compact-string)
+- [Convert Date to LocalDate or LocalDateTime and Back](http://www.baeldung.com/java-date-to-localdate-and-localdatetime)

core-java-concurrency/README.md

@@ -31,3 +31,5 @@
 - [Overview of the java.util.concurrent](http://www.baeldung.com/java-util-concurrent)
 - [Semaphores in Java](http://www.baeldung.com/java-semaphore)
 - [Daemon Threads in Java](http://www.baeldung.com/java-daemon-thread)
+- [Implementing a Runnable vs Extending a Thread](http://www.baeldung.com/java-runnable-vs-extending-thread)
+- [How to Kill a Java Thread](http://www.baeldung.com/java-thread-stop)

core-java/README.md

@@ -121,4 +121,8 @@
 - [Copy a File with Java](http://www.baeldung.com/java-copy-file)
 - [Introduction to Creational Design Patterns](http://www.baeldung.com/creational-design-patterns)
 - [Quick Example - Comparator vs Comparable in Java](http://www.baeldung.com/java-comparator-comparable)
-
+- [Quick Guide to Java Stack](http://www.baeldung.com/java-stack)
+- [The Java continue and break Keywords](http://www.baeldung.com/java-continue-and-break)
+- [Java – Append Data to a File](http://www.baeldung.com/java-append-to-file)
+- [Introduction to the Java ArrayDeque](http://www.baeldung.com/java-array-deque)
+- [Guide to java.util.Formatter](http://www.baeldung.com/java-string-formatter)

core-java/src/main/java/com/baeldung/array/ArrayBenchmarkRunner.java

@@ -0,0 +1,21 @@
+package com.baeldung.array;
+
+import org.openjdk.jmh.runner.Runner;
+import org.openjdk.jmh.runner.options.Options;
+import org.openjdk.jmh.runner.options.OptionsBuilder;
+
+public class ArrayBenchmarkRunner {
+
+  public static void main(String[] args) throws Exception {
+
+    Options options = new OptionsBuilder()
+        .include(SearchArrayTest.class.getSimpleName()).threads(1)
+        .forks(1).shouldFailOnError(true).shouldDoGC(true)
+        .jvmArgs("-server").build();
+
+    new Runner(options).run();
+
+
+  }
+
+}

core-java/src/main/java/com/baeldung/array/ArrayInverter.java

@@ -0,0 +1,41 @@
+package com.baeldung.array;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.stream.IntStream;
+
+import org.apache.commons.lang3.ArrayUtils;
+
+import com.google.common.collect.Lists;
+
+public class ArrayInverter {
+
+    public void invertUsingFor(Object[] array) {
+        for (int i = 0; i < array.length / 2; i++) {
+            Object temp = array[i];
+            array[i] = array[array.length - 1 - i];
+            array[array.length - 1 - i] = temp;
+        }
+    }
+
+    public void invertUsingCollectionsReverse(Object[] array) {
+        List<Object> list = Arrays.asList(array);
+        Collections.reverse(list);
+    }
+
+    public Object[] invertUsingStreams(final Object[] array) {
+        return IntStream.range(1, array.length + 1).mapToObj(i -> array[array.length - i]).toArray();
+    }
+
+    public void invertUsingCommonsLang(Object[] array) {
+        ArrayUtils.reverse(array);
+    }
+
+    public Object[] invertUsingGuava(Object[] array) {
+        List<Object> list = Arrays.asList(array);
+        List<Object> reverted = Lists.reverse(list);
+        return reverted.toArray();
+    }
+
+}

core-java/src/main/java/com/baeldung/array/SearchArrayTest.java

@@ -1,78 +1,77 @@
 package com.baeldung.array;
 
-import org.junit.Test;
+import org.openjdk.jmh.annotations.*;
 
 import java.util.*;
+import java.util.concurrent.TimeUnit;
 
+@BenchmarkMode(Mode.AverageTime)
+@Warmup(iterations = 5)
+@OutputTimeUnit(TimeUnit.MICROSECONDS)
 public class SearchArrayTest {
 
-
-    @Test
-    public void searchArrayAllocNewCollections() {
+    @Benchmark
+    public void searchArrayLoop() {
 
         int count = 1000;
-
         String[] strings = seedArray(count);
+        for (int i = 0; i < count; i++) {
+            searchLoop(strings, "T");
+        }
+    }
 
-        long startTime = System.nanoTime();
+    @Benchmark
+    public void searchArrayAllocNewList() {
+
+        int count = 1000;
+        String[] strings = seedArray(count);
         for (int i = 0; i < count; i++) {
             searchList(strings, "W");
         }
-        long duration = System.nanoTime() - startTime;
-        System.out.println("SearchList:  " + duration / 10000);
 
-        startTime = System.nanoTime();
-        for (int i = 0; i < count; i++) {
-            searchSet(strings,"S");
-        }
-        duration = System.nanoTime() - startTime;
-        System.out.println("SearchSet:  " + duration / 10000);
-
-        startTime = System.nanoTime();
-        for (int i = 0; i < count; i++) {
-            searchLoop(strings, "T");
-        }
-        duration = System.nanoTime() - startTime;
-        System.out.println("SearchLoop:  " + duration / 10000);
     }
 
-    @Test
-    public void searchArrayReuseCollections() {
+    @Benchmark
+    public void searchArrayAllocNewSet() {
 
-        int count = 10000;
+        int count = 1000;
+        String[] strings = seedArray(count);
+        for (int i = 0; i < count; i++) {
+            searchSet(strings, "S");
+        }
+    }
+
+
+    @Benchmark
+    public void searchArrayReuseList() {
+
+        int count = 1000;
         String[] strings = seedArray(count);
 
         List<String> asList = Arrays.asList(strings);
-        Set<String> asSet = new HashSet<>(Arrays.asList(strings));
 
-        long startTime = System.nanoTime();
         for (int i = 0; i < count; i++) {
             asList.contains("W");
         }
-        long duration = System.nanoTime() - startTime;
-        System.out.println("List:  " + duration / 10000);
-
-        startTime = System.nanoTime();
-        for (int i = 0; i < count; i++) {
-            asSet.contains("S");
-        }
-        duration = System.nanoTime() - startTime;
-        System.out.println("Set:  " + duration / 10000);
-
-        startTime = System.nanoTime();
-        for (int i = 0; i < count; i++) {
-            searchLoop(strings, "T");
-        }
-        duration = System.nanoTime() - startTime;
-        System.out.println("Loop:  " + duration / 10000);
-
     }
 
 
-    @Test
+    @Benchmark
+    public void searchArrayReuseSet() {
+
+        int count = 1000;
+        String[] strings = seedArray(count);
+        Set<String> asSet = new HashSet<>(Arrays.asList(strings));
+        for (int i = 0; i < count; i++) {
+            asSet.contains("S");
+        }
+    }
+
+
+    @Benchmark
     public void searchArrayBinarySearch() {
 
-        int count = 10000;
+        int count = 1000;
         String[] strings = seedArray(count);
         Arrays.sort(strings);
 
@@ -81,7 +80,7 @@ public class SearchArrayTest {
             Arrays.binarySearch(strings, "A");
         }
         long duration = System.nanoTime() - startTime;
-        System.out.println("Binary search:  " + duration / 10000);
+        //System.out.println("Binary search:  " + duration / 10000);
 
     }
 

core-java/src/main/java/com/baeldung/interfaces/CommaSeparatedCustomers.java

@@ -0,0 +1,21 @@
+package com.baeldung.interfaces;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class CommaSeparatedCustomers implements Customer.List {
+
+    private List<Customer> customers = new ArrayList<Customer>();
+
+    @Override
+    public void Add(Customer customer) {
+        customers.add(customer);
+    }
+
+    @Override
+    public String getCustomerNames() {
+        return customers.stream().map(customer -> customer.getName()).collect(Collectors.joining(","));
+    }
+
+}

core-java/src/main/java/com/baeldung/interfaces/Customer.java

@@ -0,0 +1,19 @@
+package com.baeldung.interfaces;
+
+public class Customer {
+    public interface List {
+        void Add(Customer customer);
+
+        String getCustomerNames();
+    }
+
+    private String name;
+
+    public Customer(String name) {
+        this.name = name;
+    }
+
+    String getName() {
+        return name;
+    }
+}

core-java/src/main/java/com/baeldung/polymorphism/GenericFile.java

@@ -54,7 +54,7 @@ public class GenericFile {
     }
 
     public String getFileInfo() {
-        return "File Name: " + this.getName() + "\n" + "Extension: " + this.getExtension() + "\n" + "Date Created: " + this.getDateCreated() + "\n" + "Version: " + this.getVersion() + "\n";
+        return String.format("File Name: %s\n" + " Extension: %s\n" + " Date Created: %s\n" + " Version: %s\n", this.getName(), this.getExtension(), this.getDateCreated(), this.getVersion());
     }
 
     public Object read() {

core-java/src/main/java/com/baeldung/polymorphism/ImageFile.java

@@ -30,7 +30,7 @@ public class ImageFile extends GenericFile {
     }
 
     public String getFileInfo() {
-        return super.getFileInfo() + "Height: " + this.getHeight() + "\n" + "Width: " + this.getWidth();
+        return String.format(" %s Height: %d\n Width: %d", super.getFileInfo(), this.getHeight(), this.getWidth());
     }
 
     public String read() {

core-java/src/main/java/com/baeldung/polymorphism/TextFile.java

@@ -21,7 +21,7 @@ public class TextFile extends GenericFile {
     }
 
     public String getFileInfo() {
-        return super.getFileInfo() + "Word Count: " + wordCount;
+        return String.format(" %s Word Count: %d", super.getFileInfo(), wordCount);
     }
 
     public String read() {

core-java/src/main/java/com/baeldung/tree/BinaryTree.java

@@ -0,0 +1,216 @@
+package com.baeldung.tree;
+
+import java.util.LinkedList;
+import java.util.Queue;
+
+public class BinaryTree {
+
+    Node root;
+
+    public void add(int value) {
+
+        Node newNode = new Node(value);
+
+        if (root == null) {
+            root = newNode;
+            return;
+        }
+
+        Node parent = root;
+        Node current = root;
+
+        while (true) {
+
+            if (newNode.value < parent.value) {
+                current = parent.left;
+
+                if (current == null) {
+                    parent.left = newNode;
+                    break;
+                }
+            } else {
+                current = parent.right;
+
+                if (current == null) {
+                    parent.right = newNode;
+                    break;
+                }
+            }
+
+            parent = current;
+        }
+    }
+
+    public boolean isEmpty() {
+        return root == null;
+    }
+
+    public boolean containsNode(int value) {
+
+        Node current = root;
+
+        while (current != null) {
+
+            if (value == current.value) {
+                return true;
+            }
+
+            if (value < current.value) {
+                current = current.left;
+            } else {
+                current = current.right;
+            }
+
+        }
+
+        return false;
+    }
+
+    public void delete(int value) {
+
+        Node current = root;
+        Node parent = root;
+        Node nodeToDelete = null;
+        boolean isLeftChild = false;
+
+        while (nodeToDelete == null && current != null) {
+
+            if (value == current.value) {
+                nodeToDelete = current;
+            } else if (value < current.value) {
+                parent = current;
+                current = current.left;
+                isLeftChild = true;
+            } else {
+                parent = current;
+                current = current.right;
+                isLeftChild = false;
+            }
+
+        }
+
+        if (nodeToDelete == null) {
+            return;
+        }
+
+        // Case 1: no children
+        if (nodeToDelete.left == null && nodeToDelete.right == null) {
+            if (nodeToDelete == root) {
+                root = null;
+            } else if (isLeftChild) {
+                parent.left = null;
+            } else {
+                parent.right = null;
+            }
+        }
+        // Case 2: only 1 child
+        else if (nodeToDelete.right == null) {
+            if (nodeToDelete == root) {
+                root = nodeToDelete.left;
+            } else if (isLeftChild) {
+                parent.left = nodeToDelete.left;
+            } else {
+                parent.right = nodeToDelete.left;
+            }
+        } else if (nodeToDelete.left == null) {
+            if (nodeToDelete == root) {
+                root = nodeToDelete.right;
+            } else if (isLeftChild) {
+                parent.left = nodeToDelete.right;
+            } else {
+                parent.right = nodeToDelete.right;
+            }
+        }
+        // Case 3: 2 children
+        else if (nodeToDelete.left != null && nodeToDelete.right != null) {
+            Node replacement = findReplacement(nodeToDelete);
+            if (nodeToDelete == root) {
+                root = replacement;
+            } else if (isLeftChild) {
+                parent.left = replacement;
+            } else {
+                parent.right = replacement;
+            }
+        }
+
+    }
+
+    private Node findReplacement(Node nodeToDelete) {
+
+        Node replacement = nodeToDelete;
+        Node parentReplacement = nodeToDelete;
+        Node current = nodeToDelete.right;
+
+        while (current != null) {
+            parentReplacement = replacement;
+            replacement = current;
+            current = current.left;
+        }
+
+        if (replacement != nodeToDelete.right) {
+            parentReplacement.left = replacement.right;
+            replacement.right = nodeToDelete.right;
+        }
+
+        replacement.left = nodeToDelete.left;
+
+        return replacement;
+    }
+
+    public void traverseInOrder(Node node) {
+        if (node != null) {
+            traverseInOrder(node.left);
+            System.out.print(" " + node.value);
+            traverseInOrder(node.right);
+        }
+    }
+
+    public void traversePreOrder(Node node) {
+        if (node != null) {
+            System.out.print(" " + node.value);
+            traversePreOrder(node.left);
+            traversePreOrder(node.right);
+        }
+    }
+
+    public void traversePostOrder(Node node) {
+        if (node != null) {
+            traversePostOrder(node.left);
+            traversePostOrder(node.right);
+
+            System.out.print(" " + node.value);
+        }
+    }
+
+    public void traverseLevelOrder() {
+        Queue<Node> nodes = new LinkedList<>();
+        nodes.add(root);
+
+        while (!nodes.isEmpty()) {
+
+            Node node = nodes.remove();
+
+            System.out.print(" " + node.value);
+
+            if (node.left != null) {
+                nodes.add(node.left);
+            }
+
+            if (node.left != null) {
+                nodes.add(node.right);
+            }
+        }
+    }
+
+    class Node {
+        int value;
+        Node left;
+        Node right;
+
+        Node(int value) {
+            this.value = value;
+            right = null;
+            left = null;
+        }
+    }
+}

core-java/src/main/resources/countries.properties

@@ -1,3 +1,3 @@
-UK
-US
-Germany
+UK
+US
+Germany

core-java/src/test/java/com/baeldung/array/ArrayInverterUnitTest.java

@@ -0,0 +1,49 @@
+package com.baeldung.array;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import org.junit.Test;
+
+public class ArrayInverterUnitTest {
+
+    private String[] fruits = { "apples", "tomatoes", "bananas", "guavas", "pineapples", "oranges" };
+
+    @Test
+    public void invertArrayWithForLoop() {
+        ArrayInverter inverter = new ArrayInverter();
+        inverter.invertUsingFor(fruits);
+
+        assertThat(new String[] { "oranges", "pineapples", "guavas", "bananas", "tomatoes", "apples" }).isEqualTo(fruits);
+    }
+
+    @Test
+    public void invertArrayWithCollectionsReverse() {
+        ArrayInverter inverter = new ArrayInverter();
+        inverter.invertUsingCollectionsReverse(fruits);
+
+        assertThat(new String[] { "oranges", "pineapples", "guavas", "bananas", "tomatoes", "apples" }).isEqualTo(fruits);
+    }
+
+    @Test
+    public void invertArrayWithStreams() {
+        ArrayInverter inverter = new ArrayInverter();
+
+        assertThat(new String[] { "oranges", "pineapples", "guavas", "bananas", "tomatoes", "apples" }).isEqualTo(inverter.invertUsingStreams(fruits));
+    }
+
+    @Test
+    public void invertArrayWithCommonsLang() {
+        ArrayInverter inverter = new ArrayInverter();
+        inverter.invertUsingCommonsLang(fruits);
+
+        assertThat(new String[] { "oranges", "pineapples", "guavas", "bananas", "tomatoes", "apples" }).isEqualTo(fruits);
+    }
+
+    @Test
+    public void invertArrayWithGuava() {
+        ArrayInverter inverter = new ArrayInverter();
+
+        assertThat(new String[] { "oranges", "pineapples", "guavas", "bananas", "tomatoes", "apples" }).isEqualTo(inverter.invertUsingGuava(fruits));
+    }
+
+}

core-java/src/test/java/com/baeldung/file/FilesTest.java

@@ -91,4 +91,4 @@ public class FilesTest {
             new FileInputStream(fileName)))
           .isEqualTo("UK\r\n" + "US\r\n" + "Germany\r\n" + "Spain\n");
     }
-}
+}

core-java/src/test/java/com/baeldung/interfaces/InnerInterfaceTests.java

@@ -0,0 +1,18 @@
+package com.baeldung.interfaces;
+
+import static org.junit.Assert.assertEquals;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public class InnerInterfaceTests {
+    @Test
+    public void whenCustomerListJoined_thenReturnsJoinedNames() {
+        Customer.List customerList = new CommaSeparatedCustomers();
+        customerList.Add(new Customer("customer1"));
+        customerList.Add(new Customer("customer2"));
+        assertEquals("customer1,customer2", customerList.getCustomerNames());
+    }
+}

core-java/src/test/java/com/baeldung/nestedclass/NewOuter.java

@@ -14,9 +14,9 @@ public class NewOuter {
         public void run() {
             System.out.println("a = " + a);
             System.out.println("b = " + b);
-            System.out.println("NewOuterTest.this.a = " + NewOuter.this.a);
-            System.out.println("NewOuterTest.b = " + NewOuter.b);
-            System.out.println("NewOuterTest.this.b = " + NewOuter.this.b);
+            System.out.println("NewOuter.this.a = " + NewOuter.this.a);
+            System.out.println("NewOuter.b = " + NewOuter.b);
+            System.out.println("NewOuter.this.b = " + NewOuter.this.b);
         }
     }
 

core-java/src/test/java/com/baeldung/polymorphism/PolymorphismUnitTest.java

@@ -3,8 +3,6 @@ package com.baeldung.polymorphism;
 import static org.junit.Assert.*;
 
 import java.awt.image.BufferedImage;
-
-import org.junit.Ignore;
 import org.junit.Test;
 
 public class PolymorphismUnitTest {

core-java/src/test/java/com/baeldung/tree/BinaryTreeTest.java

@@ -0,0 +1,85 @@
+package com.baeldung.tree;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import org.junit.Test;
+
+public class BinaryTreeTest {
+
+    @Test
+    public void givenABinaryTree_WhenAddingElements_ThenTreeNotEmpty() {
+
+        BinaryTree bt = createBinaryTree();
+
+        assertTrue(!bt.isEmpty());
+    }
+
+    @Test
+    public void givenABinaryTree_WhenAddingElements_ThenTreeContainsThoseElements() {
+
+        BinaryTree bt = createBinaryTree();
+
+        assertTrue(bt.containsNode(6));
+        assertTrue(bt.containsNode(4));
+
+        assertFalse(bt.containsNode(1));
+    }
+
+    @Test
+    public void givenABinaryTree_WhenDeletingElements_ThenTreeDoesNotContainThoseElements() {
+
+        BinaryTree bt = createBinaryTree();
+
+        assertTrue(bt.containsNode(9));
+        bt.delete(9);
+        assertFalse(bt.containsNode(9));
+    }
+
+    @Test
+    public void givenABinaryTree_WhenTraversingInOrder_ThenPrintValues() {
+
+        BinaryTree bt = createBinaryTree();
+
+        bt.traverseInOrder(bt.root);
+    }
+
+    @Test
+    public void givenABinaryTree_WhenTraversingPreOrder_ThenPrintValues() {
+
+        BinaryTree bt = createBinaryTree();
+
+        bt.traversePreOrder(bt.root);
+    }
+
+    @Test
+    public void givenABinaryTree_WhenTraversingPostOrder_ThenPrintValues() {
+
+        BinaryTree bt = createBinaryTree();
+
+        bt.traversePostOrder(bt.root);
+    }
+
+    @Test
+    public void givenABinaryTree_WhenTraversingLevelOrder_ThenPrintValues() {
+
+        BinaryTree bt = createBinaryTree();
+
+        bt.traverseLevelOrder();
+    }
+
+    private BinaryTree createBinaryTree() {
+        BinaryTree bt = new BinaryTree();
+
+        bt.add(6);
+        bt.add(4);
+        bt.add(8);
+        bt.add(3);
+        bt.add(5);
+        bt.add(7);
+        bt.add(9);
+
+        return bt;
+    }
+
+}

drools/README.MD

@@ -1,3 +1,4 @@
 ### Relevant Articles:
 - [Introduction to Drools](http://www.baeldung.com/drools)
 - [Drools Using Rules from Excel Files](http://www.baeldung.com/drools-excel)
+- [An Example of Backward Chaining in Drools](http://www.baeldung.com/drools-backward-chaining)

dubbo/README.md

@@ -0,0 +1,4 @@
+## Relevant articles:
+
+- [Intro to Dubbo](http://www.baeldung.com/dubbo-intro)
+

dubbo/pom.xml

@@ -0,0 +1,72 @@
+<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>
+
+    <parent>
+        <artifactId>parent-modules</artifactId>
+        <groupId>com.baeldung</groupId>
+        <version>1.0.0-SNAPSHOT</version>
+    </parent>
+
+    <artifactId>dubbo</artifactId>
+
+    <properties>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
+        <java.version>1.8</java.version>
+        <dubbo.version>2.5.7</dubbo.version>
+        <zookeeper.version>3.4.11</zookeeper.version>
+        <zkclient.version>0.10</zkclient.version>
+        <surefire.version>2.19.1</surefire.version>
+    </properties>
+
+    <dependencies>
+        <dependency>
+            <groupId>com.alibaba</groupId>
+            <artifactId>dubbo</artifactId>
+            <version>${dubbo.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>junit</groupId>
+            <artifactId>junit</artifactId>
+            <version>4.12</version>
+            <scope>test</scope>
+        </dependency>
+
+        <dependency>
+            <groupId>org.apache.zookeeper</groupId>
+            <artifactId>zookeeper</artifactId>
+            <version>${zookeeper.version}</version>
+        </dependency>
+
+        <dependency>
+            <groupId>com.101tec</groupId>
+            <artifactId>zkclient</artifactId>
+            <version>${zkclient.version}</version>
+        </dependency>
+
+    </dependencies>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <configuration>
+                    <source>1.8</source>
+                    <target>1.8</target>
+                </configuration>
+            </plugin>
+            <plugin>
+                <artifactId>maven-surefire-plugin</artifactId>
+                <version>${surefire.version}</version>
+                <configuration>
+                    <excludes>
+                        <exclude>**/*LiveTest.java</exclude>
+                    </excludes>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+
+</project>

dubbo/src/main/java/com/alibaba/dubbo/registry/simple/SimpleRegistryService.java

@@ -0,0 +1,210 @@
+/*
+ * Copyright 1999-2011 Alibaba Group.
+ *  
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *  
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *  
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.alibaba.dubbo.registry.simple;
+
+import com.alibaba.dubbo.common.Constants;
+import com.alibaba.dubbo.common.URL;
+import com.alibaba.dubbo.common.logger.Logger;
+import com.alibaba.dubbo.common.logger.LoggerFactory;
+import com.alibaba.dubbo.common.utils.ConcurrentHashSet;
+import com.alibaba.dubbo.common.utils.NetUtils;
+import com.alibaba.dubbo.common.utils.UrlUtils;
+import com.alibaba.dubbo.registry.NotifyListener;
+import com.alibaba.dubbo.registry.RegistryService;
+import com.alibaba.dubbo.registry.support.AbstractRegistry;
+import com.alibaba.dubbo.rpc.RpcContext;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+
+/**
+ * SimpleRegistryService
+ *
+ * @author william.liangf
+ */
+public class SimpleRegistryService extends AbstractRegistry {
+
+    private final static Logger logger = LoggerFactory.getLogger(SimpleRegistryService.class);
+    private final ConcurrentMap<String, Set<URL>> remoteRegistered = new ConcurrentHashMap<String, Set<URL>>();
+    private final ConcurrentMap<String, ConcurrentMap<URL, Set<NotifyListener>>> remoteSubscribed = new ConcurrentHashMap<String, ConcurrentMap<URL, Set<NotifyListener>>>();
+
+    public SimpleRegistryService() {
+        super(new URL("dubbo", NetUtils.getLocalHost(), 0, RegistryService.class.getName(), "file", "N/A"));
+    }
+
+    public boolean isAvailable() {
+        return true;
+    }
+
+    public List<URL> lookup(URL url) {
+        List<URL> urls = new ArrayList<URL>();
+        for (URL u : getRegistered()) {
+            if (UrlUtils.isMatch(url, u)) {
+                urls.add(u);
+            }
+        }
+        return urls;
+    }
+
+    public void register(URL url) {
+        String client = RpcContext.getContext().getRemoteAddressString();
+        Set<URL> urls = remoteRegistered.get(client);
+        if (urls == null) {
+            remoteRegistered.putIfAbsent(client, new ConcurrentHashSet<URL>());
+            urls = remoteRegistered.get(client);
+        }
+        urls.add(url);
+        super.register(url);
+        registered(url);
+    }
+
+    public void unregister(URL url) {
+        String client = RpcContext.getContext().getRemoteAddressString();
+        Set<URL> urls = remoteRegistered.get(client);
+        if (urls != null && urls.size() > 0) {
+            urls.remove(url);
+        }
+        super.unregister(url);
+        unregistered(url);
+    }
+
+    public void subscribe(URL url, NotifyListener listener) {
+        if (getUrl().getPort() == 0) {
+            URL registryUrl = RpcContext.getContext().getUrl();
+            if (registryUrl != null && registryUrl.getPort() > 0
+                    && RegistryService.class.getName().equals(registryUrl.getPath())) {
+                super.setUrl(registryUrl);
+                super.register(registryUrl);
+            }
+        }
+        String client = RpcContext.getContext().getRemoteAddressString();
+        ConcurrentMap<URL, Set<NotifyListener>> clientListeners = remoteSubscribed.get(client);
+        if (clientListeners == null) {
+            remoteSubscribed.putIfAbsent(client, new ConcurrentHashMap<URL, Set<NotifyListener>>());
+            clientListeners = remoteSubscribed.get(client);
+        }
+        Set<NotifyListener> listeners = clientListeners.get(url);
+        if (listeners == null) {
+            clientListeners.putIfAbsent(url, new ConcurrentHashSet<NotifyListener>());
+            listeners = clientListeners.get(url);
+        }
+        listeners.add(listener);
+        super.subscribe(url, listener);
+        subscribed(url, listener);
+    }
+
+    public void unsubscribe(URL url, NotifyListener listener) {
+        if (!Constants.ANY_VALUE.equals(url.getServiceInterface())
+                && url.getParameter(Constants.REGISTER_KEY, true)) {
+            unregister(url);
+        }
+        String client = RpcContext.getContext().getRemoteAddressString();
+        Map<URL, Set<NotifyListener>> clientListeners = remoteSubscribed.get(client);
+        if (clientListeners != null && clientListeners.size() > 0) {
+            Set<NotifyListener> listeners = clientListeners.get(url);
+            if (listeners != null && listeners.size() > 0) {
+                listeners.remove(listener);
+            }
+        }
+    }
+
+    protected void registered(URL url) {
+        for (Map.Entry<URL, Set<NotifyListener>> entry : getSubscribed().entrySet()) {
+            URL key = entry.getKey();
+            if (UrlUtils.isMatch(key, url)) {
+                List<URL> list = lookup(key);
+                for (NotifyListener listener : entry.getValue()) {
+                    listener.notify(list);
+                }
+            }
+        }
+    }
+
+    protected void unregistered(URL url) {
+        for (Map.Entry<URL, Set<NotifyListener>> entry : getSubscribed().entrySet()) {
+            URL key = entry.getKey();
+            if (UrlUtils.isMatch(key, url)) {
+                List<URL> list = lookup(key);
+                for (NotifyListener listener : entry.getValue()) {
+                    listener.notify(list);
+                }
+            }
+        }
+    }
+
+    protected void subscribed(final URL url, final NotifyListener listener) {
+        if (Constants.ANY_VALUE.equals(url.getServiceInterface())) {
+            new Thread(new Runnable() {
+                public void run() {
+                    Map<String, List<URL>> map = new HashMap<String, List<URL>>();
+                    for (URL u : getRegistered()) {
+                        if (UrlUtils.isMatch(url, u)) {
+                            String service = u.getServiceInterface();
+                            List<URL> list = map.get(service);
+                            if (list == null) {
+                                list = new ArrayList<URL>();
+                                map.put(service, list);
+                            }
+                            list.add(u);
+                        }
+                    }
+                    for (List<URL> list : map.values()) {
+                        try {
+                            listener.notify(list);
+                        } catch (Throwable e) {
+                            logger.warn("Discard to notify " + url.getServiceKey() + " to listener " + listener);
+                        }
+                    }
+                }
+            }, "DubboMonitorNotifier").start();
+        } else {
+            List<URL> list = lookup(url);
+            try {
+                listener.notify(list);
+            } catch (Throwable e) {
+                logger.warn("Discard to notify " + url.getServiceKey() + " to listener " + listener);
+            }
+        }
+    }
+
+    public void disconnect() {
+        String client = RpcContext.getContext().getRemoteAddressString();
+        if (logger.isInfoEnabled()) {
+            logger.info("Disconnected " + client);
+        }
+        Set<URL> urls = remoteRegistered.get(client);
+        if (urls != null && urls.size() > 0) {
+            for (URL url : urls) {
+                unregister(url);
+            }
+        }
+        Map<URL, Set<NotifyListener>> listeners = remoteSubscribed.get(client);
+        if (listeners != null && listeners.size() > 0) {
+            for (Map.Entry<URL, Set<NotifyListener>> entry : listeners.entrySet()) {
+                URL url = entry.getKey();
+                for (NotifyListener listener : entry.getValue()) {
+                    unsubscribe(url, listener);
+                }
+            }
+        }
+    }
+
+}

dubbo/src/main/java/com/baeldung/dubbo/remote/GreetingsFailoverServiceImpl.java

@@ -0,0 +1,14 @@
+package com.baeldung.dubbo.remote;
+
+/**
+ * @author aiet
+ */
+public class GreetingsFailoverServiceImpl implements GreetingsService {
+
+    @Override
+    public String sayHi(String name) {
+        System.out.println("failover implementation");
+        return "hi, failover " + name;
+    }
+
+}

dubbo/src/main/java/com/baeldung/dubbo/remote/GreetingsService.java

@@ -0,0 +1,10 @@
+package com.baeldung.dubbo.remote;
+
+/**
+ * @author aiet
+ */
+public interface GreetingsService {
+
+    String sayHi(String name);
+
+}

dubbo/src/main/java/com/baeldung/dubbo/remote/GreetingsServiceImpl.java

@@ -0,0 +1,14 @@
+package com.baeldung.dubbo.remote;
+
+/**
+ * @author aiet
+ */
+public class GreetingsServiceImpl implements GreetingsService {
+
+    @Override
+    public String sayHi(String name) {
+        System.out.println("default implementation");
+        return "hi, " + name;
+    }
+
+}

dubbo/src/main/java/com/baeldung/dubbo/remote/GreetingsServiceSpecialImpl.java

@@ -0,0 +1,20 @@
+package com.baeldung.dubbo.remote;
+
+import static java.util.concurrent.TimeUnit.SECONDS;
+
+/**
+ * @author aiet
+ */
+public class GreetingsServiceSpecialImpl implements GreetingsService {
+
+    @Override
+    public String sayHi(String name) {
+        try {
+            System.out.println("specially called");
+            SECONDS.sleep(5);
+        } catch (Exception ignored) {
+        }
+        return "hi, " + name;
+    }
+
+}