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

2018-02-05 13:58:46 -05:00 · 2018-02-05 13:58:46 -05:00 · eaf4f4c0f2
parent 23d8378ea4 bd103bdd41
commit eaf4f4c0f2
199 changed files with 6739 additions and 330 deletions
--- a/algorithms/src/main/java/com/baeldung/algorithms/sudoku/BacktrackingAlgorithm.java
+++ b/algorithms/src/main/java/com/baeldung/algorithms/sudoku/BacktrackingAlgorithm.java
@ -0,0 +1,104 @@
+package com.baeldung.algorithms.sudoku;
+
+import java.util.stream.IntStream;
+
+public class BacktrackingAlgorithm {
+
+    private static final int BOARD_SIZE = 9;
+    private static final int SUBSECTION_SIZE = 3;
+    private static final int BOARD_START_INDEX = 0;
+
+    private static final int NO_VALUE = 0;
+    private static final int MIN_VALUE = 1;
+    private static final int MAX_VALUE = 9;
+
+    private static int[][] board = {
+      {8, 0, 0, 0, 0, 0, 0, 0, 0},
+      {0, 0, 3, 6, 0, 0, 0, 0, 0},
+      {0, 7, 0, 0, 9, 0, 2, 0, 0},
+      {0, 5, 0, 0, 0, 7, 0, 0, 0},
+      {0, 0, 0, 0, 4, 5, 7, 0, 0},
+      {0, 0, 0, 1, 0, 0, 0, 3, 0},
+      {0, 0, 1, 0, 0, 0, 0, 6, 8},
+      {0, 0, 8, 5, 0, 0, 0, 1, 0},
+      {0, 9, 0, 0, 0, 0, 4, 0, 0}
+    };
+
+    public static void main(String[] args) {
+        BacktrackingAlgorithm solver = new BacktrackingAlgorithm();
+        solver.solve(board);
+        solver.printBoard();
+    }
+
+    private void printBoard() {
+        for (int row = BOARD_START_INDEX; row < BOARD_SIZE; row++) {
+            for (int column = BOARD_START_INDEX; column < BOARD_SIZE; column++) {
+                System.out.print(board[row][column] + " ");
+            }
+            System.out.println();
+        }
+    }
+
+    private boolean solve(int[][] board) {
+        for (int r = BOARD_START_INDEX; r < BOARD_SIZE; r++) {
+            for (int c = BOARD_START_INDEX; c < BOARD_SIZE; c++) {
+                if (board[r][c] == NO_VALUE) {
+                    for (int k = MIN_VALUE; k <= MAX_VALUE; k++) {
+                        board[r][c] = k;
+                        if (isValid(board, r, c) && solve(board)) {
+                            return true;
+                        }
+                        board[r][c] = NO_VALUE;
+                    }
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+
+    private boolean isValid(int[][] board, int r, int c) {
+        return rowConstraint(board, r) &&
+          columnConstraint(board, c) &&
+          subsectionConstraint(board, r, c);
+    }
+
+    private boolean subsectionConstraint(int[][] board, int r, int c) {
+        boolean[] constraint = new boolean[BOARD_SIZE];
+        int subsectionRowStart = (r / SUBSECTION_SIZE) * SUBSECTION_SIZE;
+        int subsectionRowEnd = subsectionRowStart + SUBSECTION_SIZE;
+
+        int subsectionColumnStart = (c / SUBSECTION_SIZE) * SUBSECTION_SIZE;
+        int subsectionColumnEnd = subsectionColumnStart + SUBSECTION_SIZE;
+
+        for (int i = subsectionRowStart; i < subsectionRowEnd; i++) {
+            for (int j = subsectionColumnStart; j < subsectionColumnEnd; j++) {
+                if (!checkConstraint(board, i, constraint, j)) return false;
+            }
+        }
+        return true;
+    }
+
+    private boolean columnConstraint(int[][] board, int c) {
+        boolean[] constraint = new boolean[BOARD_SIZE];
+        return IntStream.range(BOARD_START_INDEX, BOARD_SIZE)
+          .allMatch(i -> checkConstraint(board, i, constraint, c));
+    }
+
+    private boolean rowConstraint(int[][] board, int r) {
+        boolean[] constraint = new boolean[BOARD_SIZE];
+        return IntStream.range(BOARD_START_INDEX, BOARD_SIZE)
+          .allMatch(i -> checkConstraint(board, r, constraint, i));
+    }
+
+    private boolean checkConstraint(int[][] board, int r, boolean[] constraint, int c) {
+        if (board[r][c] != NO_VALUE) {
+            if (!constraint[board[r][c] - 1]) {
+                constraint[board[r][c] - 1] = true;
+            } else {
+                return false;
+            }
+        }
+        return true;
+    }
+}
--- a/algorithms/src/main/java/com/baeldung/algorithms/sudoku/ColumnNode.java
+++ b/algorithms/src/main/java/com/baeldung/algorithms/sudoku/ColumnNode.java
@ -0,0 +1,33 @@
+package com.baeldung.algorithms.sudoku;
+
+class ColumnNode extends DancingNode {
+    int size;
+    String name;
+
+    ColumnNode(String n) {
+        super();
+        size = 0;
+        name = n;
+        C = this;
+    }
+
+    void cover() {
+        unlinkLR();
+        for (DancingNode i = this.D; i != this; i = i.D) {
+            for (DancingNode j = i.R; j != i; j = j.R) {
+                j.unlinkUD();
+                j.C.size--;
+            }
+        }
+    }
+
+    void uncover() {
+        for (DancingNode i = this.U; i != this; i = i.U) {
+            for (DancingNode j = i.L; j != i; j = j.L) {
+                j.C.size++;
+                j.relinkUD();
+            }
+        }
+        relinkLR();
+    }
+}
--- a/algorithms/src/main/java/com/baeldung/algorithms/sudoku/DancingLinks.java
+++ b/algorithms/src/main/java/com/baeldung/algorithms/sudoku/DancingLinks.java
@ -0,0 +1,133 @@
+package com.baeldung.algorithms.sudoku;
+
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.List;
+
+public class DancingLinks {
+
+    private ColumnNode header;
+    private List<DancingNode> answer;
+
+    private void search(int k) {
+        if (header.R == header) {
+            handleSolution(answer);
+        } else {
+            ColumnNode c = selectColumnNodeHeuristic();
+            c.cover();
+
+            for (DancingNode r = c.D; r != c; r = r.D) {
+                answer.add(r);
+
+                for (DancingNode j = r.R; j != r; j = j.R) {
+                    j.C.cover();
+                }
+
+                search(k + 1);
+
+                r = answer.remove(answer.size() - 1);
+                c = r.C;
+
+                for (DancingNode j = r.L; j != r; j = j.L) {
+                    j.C.uncover();
+                }
+            }
+            c.uncover();
+        }
+    }
+
+    private ColumnNode selectColumnNodeHeuristic() {
+        int min = Integer.MAX_VALUE;
+        ColumnNode ret = null;
+        for (ColumnNode c = (ColumnNode) header.R; c != header; c = (ColumnNode) c.R) {
+            if (c.size < min) {
+                min = c.size;
+                ret = c;
+            }
+        }
+        return ret;
+    }
+
+    private ColumnNode makeDLXBoard(boolean[][] grid) {
+        final int COLS = grid[0].length;
+
+        ColumnNode headerNode = new ColumnNode("header");
+        List<ColumnNode> columnNodes = new ArrayList<>();
+
+        for (int i = 0; i < COLS; i++) {
+            ColumnNode n = new ColumnNode(Integer.toString(i));
+            columnNodes.add(n);
+            headerNode = (ColumnNode) headerNode.hookRight(n);
+        }
+        headerNode = headerNode.R.C;
+
+        for (boolean[] aGrid : grid) {
+            DancingNode prev = null;
+            for (int j = 0; j < COLS; j++) {
+                if (aGrid[j]) {
+                    ColumnNode col = columnNodes.get(j);
+                    DancingNode newNode = new DancingNode(col);
+                    if (prev == null)
+                        prev = newNode;
+                    col.U.hookDown(newNode);
+                    prev = prev.hookRight(newNode);
+                    col.size++;
+                }
+            }
+        }
+
+        headerNode.size = COLS;
+
+        return headerNode;
+    }
+
+    DancingLinks(boolean[][] cover) {
+        header = makeDLXBoard(cover);
+    }
+
+    public void runSolver() {
+        answer = new LinkedList<>();
+        search(0);
+    }
+
+    private void handleSolution(List<DancingNode> answer) {
+        int[][] result = parseBoard(answer);
+        printSolution(result);
+    }
+
+    private int size = 9;
+
+    private int[][] parseBoard(List<DancingNode> answer) {
+        int[][] result = new int[size][size];
+        for (DancingNode n : answer) {
+            DancingNode rcNode = n;
+            int min = Integer.parseInt(rcNode.C.name);
+            for (DancingNode tmp = n.R; tmp != n; tmp = tmp.R) {
+                int val = Integer.parseInt(tmp.C.name);
+                if (val < min) {
+                    min = val;
+                    rcNode = tmp;
+                }
+            }
+            int ans1 = Integer.parseInt(rcNode.C.name);
+            int ans2 = Integer.parseInt(rcNode.R.C.name);
+            int r = ans1 / size;
+            int c = ans1 % size;
+            int num = (ans2 % size) + 1;
+            result[r][c] = num;
+        }
+        return result;
+    }
+
+    private static void printSolution(int[][] result) {
+        int N = result.length;
+        for (int[] aResult : result) {
+            StringBuilder ret = new StringBuilder();
+            for (int j = 0; j < N; j++) {
+                ret.append(aResult[j]).append(" ");
+            }
+            System.out.println(ret);
+        }
+        System.out.println();
+    }
+}
--- a/algorithms/src/main/java/com/baeldung/algorithms/sudoku/DancingLinksAlgorithm.java
+++ b/algorithms/src/main/java/com/baeldung/algorithms/sudoku/DancingLinksAlgorithm.java
@ -0,0 +1,108 @@
+package com.baeldung.algorithms.sudoku;
+
+import java.util.Arrays;
+
+public class DancingLinksAlgorithm {
+    private static final int BOARD_SIZE = 9;
+    private static final int SUBSECTION_SIZE = 3;
+    private static final int NO_VALUE = 0;
+    private static final int CONSTRAINTS = 4;
+    private static final int MIN_VALUE = 1;
+    private static final int MAX_VALUE = 9;
+    private static final int COVER_START_INDEX = 1;
+
+    private static int[][] board = {
+      {8, 0, 0, 0, 0, 0, 0, 0, 0},
+      {0, 0, 3, 6, 0, 0, 0, 0, 0},
+      {0, 7, 0, 0, 9, 0, 2, 0, 0},
+      {0, 5, 0, 0, 0, 7, 0, 0, 0},
+      {0, 0, 0, 0, 4, 5, 7, 0, 0},
+      {0, 0, 0, 1, 0, 0, 0, 3, 0},
+      {0, 0, 1, 0, 0, 0, 0, 6, 8},
+      {0, 0, 8, 5, 0, 0, 0, 1, 0},
+      {0, 9, 0, 0, 0, 0, 4, 0, 0}
+    };
+
+    public static void main(String[] args) {
+        DancingLinksAlgorithm solver = new DancingLinksAlgorithm();
+        solver.solve(board);
+    }
+
+    private void solve(int[][] board) {
+        boolean[][] cover = initializeExactCoverBoard(board);
+        DancingLinks dlx = new DancingLinks(cover);
+        dlx.runSolver();
+    }
+
+    private int getIndex(int row, int col, int num) {
+        return (row - 1) * BOARD_SIZE * BOARD_SIZE + (col - 1) * BOARD_SIZE + (num - 1);
+    }
+
+    private boolean[][] createExactCoverBoard() {
+        boolean[][] R = new boolean[BOARD_SIZE * BOARD_SIZE * MAX_VALUE][BOARD_SIZE * BOARD_SIZE * CONSTRAINTS];
+
+        int hBase = 0;
+
+        // Cell constraint.
+        for (int r = COVER_START_INDEX; r <= BOARD_SIZE; r++) {
+            for (int c = COVER_START_INDEX; c <= BOARD_SIZE; c++, hBase++) {
+                for (int n = COVER_START_INDEX; n <= BOARD_SIZE; n++) {
+                    int index = getIndex(r, c, n);
+                    R[index][hBase] = true;
+                }
+            }
+        }
+
+        // Row constrain.
+        for (int r = COVER_START_INDEX; r <= BOARD_SIZE; r++) {
+            for (int n = COVER_START_INDEX; n <= BOARD_SIZE; n++, hBase++) {
+                for (int c1 = COVER_START_INDEX; c1 <= BOARD_SIZE; c1++) {
+                    int index = getIndex(r, c1, n);
+                    R[index][hBase] = true;
+                }
+            }
+        }
+
+        // Column constraint.
+        for (int c = COVER_START_INDEX; c <= BOARD_SIZE; c++) {
+            for (int n = COVER_START_INDEX; n <= BOARD_SIZE; n++, hBase++) {
+                for (int r1 = COVER_START_INDEX; r1 <= BOARD_SIZE; r1++) {
+                    int index = getIndex(r1, c, n);
+                    R[index][hBase] = true;
+                }
+            }
+        }
+
+        // Subsection constraint
+        for (int br = COVER_START_INDEX; br <= BOARD_SIZE; br += SUBSECTION_SIZE) {
+            for (int bc = COVER_START_INDEX; bc <= BOARD_SIZE; bc += SUBSECTION_SIZE) {
+                for (int n = COVER_START_INDEX; n <= BOARD_SIZE; n++, hBase++) {
+                    for (int rDelta = 0; rDelta < SUBSECTION_SIZE; rDelta++) {
+                        for (int cDelta = 0; cDelta < SUBSECTION_SIZE; cDelta++) {
+                            int index = getIndex(br + rDelta, bc + cDelta, n);
+                            R[index][hBase] = true;
+                        }
+                    }
+                }
+            }
+        }
+        return R;
+    }
+
+    private boolean[][] initializeExactCoverBoard(int[][] board) {
+        boolean[][] R = createExactCoverBoard();
+        for (int i = COVER_START_INDEX; i <= BOARD_SIZE; i++) {
+            for (int j = COVER_START_INDEX; j <= BOARD_SIZE; j++) {
+                int n = board[i - 1][j - 1];
+                if (n != NO_VALUE) {
+                    for (int num = MIN_VALUE; num <= MAX_VALUE; num++) {
+                        if (num != n) {
+                            Arrays.fill(R[getIndex(i, j, num)], false);
+                        }
+                    }
+                }
+            }
+        }
+        return R;
+    }
+}
--- a/algorithms/src/main/java/com/baeldung/algorithms/sudoku/DancingNode.java
+++ b/algorithms/src/main/java/com/baeldung/algorithms/sudoku/DancingNode.java
@ -0,0 +1,50 @@
+package com.baeldung.algorithms.sudoku;
+
+class DancingNode {
+    DancingNode L, R, U, D;
+    ColumnNode C;
+
+    DancingNode hookDown(DancingNode n1) {
+        assert (this.C == n1.C);
+        n1.D = this.D;
+        n1.D.U = n1;
+        n1.U = this;
+        this.D = n1;
+        return n1;
+    }
+
+    DancingNode hookRight(DancingNode n1) {
+        n1.R = this.R;
+        n1.R.L = n1;
+        n1.L = this;
+        this.R = n1;
+        return n1;
+    }
+
+    void unlinkLR() {
+        this.L.R = this.R;
+        this.R.L = this.L;
+    }
+
+    void relinkLR() {
+        this.L.R = this.R.L = this;
+    }
+
+    void unlinkUD() {
+        this.U.D = this.D;
+        this.D.U = this.U;
+    }
+
+    void relinkUD() {
+        this.U.D = this.D.U = this;
+    }
+
+    DancingNode() {
+        L = R = U = D = this;
+    }
+
+    DancingNode(ColumnNode c) {
+        this();
+        C = c;
+    }
+}
--- a/core-java-8/src/main/java/com/baeldung/spliteratorAPI/RelatedAuthorSpliterator.java
+++ b/core-java-8/src/main/java/com/baeldung/spliteratorAPI/RelatedAuthorSpliterator.java
@ -2,46 +2,48 @@ package com.baeldung.spliteratorAPI;

 import java.util.List;
 import java.util.Spliterator;
+import java.util.concurrent.atomic.AtomicInteger;
 import java.util.function.Consumer;

 public class RelatedAuthorSpliterator implements Spliterator<Author> {
-    private final List<Author> list;
-    private int current = 0;
+	private final List<Author> list;
+	AtomicInteger current = new AtomicInteger();

-    public RelatedAuthorSpliterator(List<Author> list) {
-        this.list = list;
-    }
+	public RelatedAuthorSpliterator(List<Author> list) {
+		this.list = list;
+	}

-    @Override
-    public boolean tryAdvance(Consumer<? super Author> action) {
-        action.accept(list.get(current++));
-        return current < list.size();
-    }
+	@Override
+	public boolean tryAdvance(Consumer<? super Author> action) {

-    @Override
-    public Spliterator<Author> trySplit() {
-        int currentSize = list.size() - current;
-        if (currentSize < 10) {
-            return null;
-        }
-        for (int splitPos = currentSize / 2 + current; splitPos < list.size(); splitPos++) {
-            if (list.get(splitPos)
-                .getRelatedArticleId() == 0) {
-                Spliterator<Author> spliterator = new RelatedAuthorSpliterator(list.subList(current, splitPos));
-                current = splitPos;
-                return spliterator;
-            }
-        }
-        return null;
-    }
+		action.accept(list.get(current.getAndIncrement()));
+		return current.get() < list.size();
+	}

-    @Override
-    public long estimateSize() {
-        return list.size() - current;
-    }
+	@Override
+	public Spliterator<Author> trySplit() {
+		int currentSize = list.size() - current.get();
+		if (currentSize < 10) {
+			return null;
+		}
+		for (int splitPos = currentSize / 2 + current.intValue(); splitPos < list.size(); splitPos++) {
+			if (list.get(splitPos).getRelatedArticleId() == 0) {
+				Spliterator<Author> spliterator = new RelatedAuthorSpliterator(list.subList(current.get(), splitPos));
+				current.set(splitPos);
+				return spliterator;
+			}
+		}
+		return null;
+	}
+
+	@Override
+	public long estimateSize() {
+		return list.size() - current.get();
+	}
+
+	@Override
+	public int characteristics() {
+		return CONCURRENT;
+	}

-    @Override
-    public int characteristics() {
-        return SIZED + CONCURRENT;
-    }
 }
--- a/core-java-9/src/test/java/com/baeldung/java9/httpclient/HttpClientTest.java
+++ b/core-java-9/src/test/java/com/baeldung/java9/httpclient/HttpClientTest.java
@ -0,0 +1,218 @@
+package com.baeldung.java9.httpclient;
+
+import jdk.incubator.http.HttpClient;
+import jdk.incubator.http.HttpRequest;
+import jdk.incubator.http.HttpResponse;
+import org.junit.Test;
+
+import java.io.IOException;
+import java.net.*;
+import java.util.Arrays;
+import java.util.List;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.stream.Collectors;
+
+import static org.hamcrest.CoreMatchers.containsString;
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.collection.IsEmptyCollection.empty;
+import static org.hamcrest.core.IsNot.not;
+import static org.junit.Assert.assertThat;
+
+/**
+ * Created by adam.
+ */
+public class HttpClientTest {
+
+    @Test
+    public void shouldReturnSampleDataContentWhenConnectViaSystemProxy() throws IOException, InterruptedException, URISyntaxException {
+        HttpRequest request = HttpRequest.newBuilder()
+            .uri(new URI("https://postman-echo.com/post"))
+            .headers("Content-Type", "text/plain;charset=UTF-8")
+            .POST(HttpRequest.BodyProcessor.fromString("Sample body"))
+            .build();
+
+        HttpResponse<String> response = HttpClient.newBuilder()
+            .proxy(ProxySelector.getDefault())
+            .build()
+            .send(request, HttpResponse.BodyHandler.asString());
+
+        assertThat(response.statusCode(), equalTo(HttpURLConnection.HTTP_OK));
+        assertThat(response.body(), containsString("Sample body"));
+    }
+
+    @Test
+    public void shouldNotFollowRedirectWhenSetToDefaultNever() throws IOException, InterruptedException, URISyntaxException {
+        HttpRequest request = HttpRequest.newBuilder()
+            .uri(new URI("http://stackoverflow.com"))
+            .version(HttpClient.Version.HTTP_1_1)
+            .GET()
+            .build();
+        HttpResponse<String> response = HttpClient.newBuilder()
+            .build()
+            .send(request, HttpResponse.BodyHandler.asString());
+
+        assertThat(response.statusCode(), equalTo(HttpURLConnection.HTTP_MOVED_PERM));
+        assertThat(response.body(), containsString("https://stackoverflow.com/"));
+    }
+
+    @Test
+    public void shouldFollowRedirectWhenSetToAlways() throws IOException, InterruptedException, URISyntaxException {
+        HttpRequest request = HttpRequest.newBuilder()
+            .uri(new URI("http://stackoverflow.com"))
+            .version(HttpClient.Version.HTTP_1_1)
+            .GET()
+            .build();
+        HttpResponse<String> response = HttpClient.newBuilder()
+            .followRedirects(HttpClient.Redirect.ALWAYS)
+            .build()
+            .send(request, HttpResponse.BodyHandler.asString());
+
+        assertThat(response.statusCode(), equalTo(HttpURLConnection.HTTP_OK));
+        assertThat(response.finalRequest()
+            .uri()
+            .toString(), equalTo("https://stackoverflow.com/"));
+    }
+
+    @Test
+    public void shouldReturnOKStatusForAuthenticatedAccess() throws URISyntaxException, IOException, InterruptedException {
+        HttpRequest request = HttpRequest.newBuilder()
+            .uri(new URI("https://postman-echo.com/basic-auth"))
+            .GET()
+            .build();
+        HttpResponse<String> response = HttpClient.newBuilder()
+            .authenticator(new Authenticator() {
+                @Override
+                protected PasswordAuthentication getPasswordAuthentication() {
+                    return new PasswordAuthentication("postman", "password".toCharArray());
+                }
+            })
+            .build()
+            .send(request, HttpResponse.BodyHandler.asString());
+
+        assertThat(response.statusCode(), equalTo(HttpURLConnection.HTTP_OK));
+    }
+
+    @Test
+    public void shouldSendRequestAsync() throws URISyntaxException, InterruptedException, ExecutionException {
+        HttpRequest request = HttpRequest.newBuilder()
+            .uri(new URI("https://postman-echo.com/post"))
+            .headers("Content-Type", "text/plain;charset=UTF-8")
+            .POST(HttpRequest.BodyProcessor.fromString("Sample body"))
+            .build();
+        CompletableFuture<HttpResponse<String>> response = HttpClient.newBuilder()
+            .build()
+            .sendAsync(request, HttpResponse.BodyHandler.asString());
+
+        assertThat(response.get()
+            .statusCode(), equalTo(HttpURLConnection.HTTP_OK));
+    }
+
+    @Test
+    public void shouldUseJustTwoThreadWhenProcessingSendAsyncRequest() throws URISyntaxException, InterruptedException, ExecutionException {
+        HttpRequest request = HttpRequest.newBuilder()
+            .uri(new URI("https://postman-echo.com/get"))
+            .GET()
+            .build();
+
+        ExecutorService executorService = Executors.newFixedThreadPool(2);
+
+        CompletableFuture<HttpResponse<String>> response1 = HttpClient.newBuilder()
+            .executor(executorService)
+            .build()
+            .sendAsync(request, HttpResponse.BodyHandler.asString());
+
+        CompletableFuture<HttpResponse<String>> response2 = HttpClient.newBuilder()
+            .executor(executorService)
+            .build()
+            .sendAsync(request, HttpResponse.BodyHandler.asString());
+
+        CompletableFuture<HttpResponse<String>> response3 = HttpClient.newBuilder()
+            .executor(executorService)
+            .build()
+            .sendAsync(request, HttpResponse.BodyHandler.asString());
+
+        CompletableFuture.allOf(response1, response2, response3)
+            .join();
+
+        assertThat(response1.get()
+            .statusCode(), equalTo(HttpURLConnection.HTTP_OK));
+        assertThat(response2.get()
+            .statusCode(), equalTo(HttpURLConnection.HTTP_OK));
+        assertThat(response3.get()
+            .statusCode(), equalTo(HttpURLConnection.HTTP_OK));
+    }
+
+    @Test
+    public void shouldNotStoreCookieWhenPolicyAcceptNone() throws URISyntaxException, IOException, InterruptedException {
+        HttpRequest request = HttpRequest.newBuilder()
+            .uri(new URI("https://postman-echo.com/get"))
+            .GET()
+            .build();
+
+        HttpClient httpClient = HttpClient.newBuilder()
+            .cookieManager(new CookieManager(null, CookiePolicy.ACCEPT_NONE))
+            .build();
+
+        httpClient.send(request, HttpResponse.BodyHandler.asString());
+
+        assertThat(httpClient.cookieManager()
+            .get()
+            .getCookieStore()
+            .getCookies(), empty());
+    }
+
+    @Test
+    public void shouldStoreCookieWhenPolicyAcceptAll() throws URISyntaxException, IOException, InterruptedException {
+        HttpRequest request = HttpRequest.newBuilder()
+            .uri(new URI("https://postman-echo.com/get"))
+            .GET()
+            .build();
+
+        HttpClient httpClient = HttpClient.newBuilder()
+            .cookieManager(new CookieManager(null, CookiePolicy.ACCEPT_ALL))
+            .build();
+
+        httpClient.send(request, HttpResponse.BodyHandler.asString());
+
+        assertThat(httpClient.cookieManager()
+            .get()
+            .getCookieStore()
+            .getCookies(), not(empty()));
+    }
+
+    @Test
+    public void shouldProcessMultipleRequestViaStream() throws URISyntaxException, ExecutionException, InterruptedException {
+        List<URI> targets = Arrays.asList(new URI("https://postman-echo.com/get?foo1=bar1"), new URI("https://postman-echo.com/get?foo2=bar2"));
+
+        HttpClient client = HttpClient.newHttpClient();
+
+        List<CompletableFuture<String>> futures = targets.stream()
+            .map(target -> client.sendAsync(HttpRequest.newBuilder(target)
+                .GET()
+                .build(), HttpResponse.BodyHandler.asString())
+                .thenApply(response -> response.body()))
+            .collect(Collectors.toList());
+
+        CompletableFuture.allOf(futures.toArray(new CompletableFuture[0]))
+            .join();
+
+        if (futures.get(0)
+            .get()
+            .contains("foo1")) {
+            assertThat(futures.get(0)
+                .get(), containsString("bar1"));
+            assertThat(futures.get(1)
+                .get(), containsString("bar2"));
+        } else {
+            assertThat(futures.get(1)
+                .get(), containsString("bar2"));
+            assertThat(futures.get(1)
+                .get(), containsString("bar1"));
+        }
+
+    }
+
+}
--- a/core-java-9/src/test/java/com/baeldung/java9/httpclient/HttpRequestTest.java
+++ b/core-java-9/src/test/java/com/baeldung/java9/httpclient/HttpRequestTest.java
@ -0,0 +1,171 @@
+package com.baeldung.java9.httpclient;
+
+import jdk.incubator.http.HttpClient;
+import jdk.incubator.http.HttpRequest;
+import jdk.incubator.http.HttpResponse;
+import org.junit.Test;
+
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.net.HttpURLConnection;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.nio.file.Paths;
+import java.security.NoSuchAlgorithmException;
+import java.time.Duration;
+
+import static java.time.temporal.ChronoUnit.SECONDS;
+import static org.hamcrest.CoreMatchers.containsString;
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.junit.Assert.assertThat;
+
+/**
+ * Created by adam.
+ */
+public class HttpRequestTest {
+
+    @Test
+    public void shouldReturnStatusOKWhenSendGetRequest() throws IOException, InterruptedException, URISyntaxException {
+        HttpRequest request = HttpRequest.newBuilder()
+            .uri(new URI("https://postman-echo.com/get"))
+            .GET()
+            .build();
+
+        HttpResponse<String> response = HttpClient.newHttpClient()
+            .send(request, HttpResponse.BodyHandler.asString());
+
+        assertThat(response.statusCode(), equalTo(HttpURLConnection.HTTP_OK));
+    }
+
+    @Test
+    public void shouldUseHttp2WhenWebsiteUsesHttp2() throws IOException, InterruptedException, URISyntaxException {
+        HttpRequest request = HttpRequest.newBuilder()
+            .uri(new URI("https://stackoverflow.com"))
+            .version(HttpClient.Version.HTTP_2)
+            .GET()
+            .build();
+        HttpResponse<String> response = HttpClient.newHttpClient()
+            .send(request, HttpResponse.BodyHandler.asString());
+
+        assertThat(response.statusCode(), equalTo(HttpURLConnection.HTTP_OK));
+        assertThat(response.version(), equalTo(HttpClient.Version.HTTP_2));
+    }
+
+    @Test
+    public void shouldFallbackToHttp1_1WhenWebsiteDoesNotUseHttp2() throws IOException, InterruptedException, URISyntaxException, NoSuchAlgorithmException {
+        HttpRequest request = HttpRequest.newBuilder()
+            .uri(new URI("https://postman-echo.com/get"))
+            .version(HttpClient.Version.HTTP_2)
+            .GET()
+            .build();
+
+        HttpResponse<String> response = HttpClient.newHttpClient()
+            .send(request, HttpResponse.BodyHandler.asString());
+
+        assertThat(response.version(), equalTo(HttpClient.Version.HTTP_1_1));
+    }
+
+    @Test
+    public void shouldReturnStatusOKWhenSendGetRequestWithDummyHeaders() throws IOException, InterruptedException, URISyntaxException {
+        HttpRequest request = HttpRequest.newBuilder()
+            .uri(new URI("https://postman-echo.com/get"))
+            .headers("key1", "value1", "key2", "value2")
+            .GET()
+            .build();
+
+        HttpResponse<String> response = HttpClient.newHttpClient()
+            .send(request, HttpResponse.BodyHandler.asString());
+
+        assertThat(response.statusCode(), equalTo(HttpURLConnection.HTTP_OK));
+    }
+
+    @Test
+    public void shouldReturnStatusOKWhenSendGetRequestTimeoutSet() throws IOException, InterruptedException, URISyntaxException {
+        HttpRequest request = HttpRequest.newBuilder()
+            .uri(new URI("https://postman-echo.com/get"))
+            .timeout(Duration.of(10, SECONDS))
+            .GET()
+            .build();
+
+        HttpResponse<String> response = HttpClient.newHttpClient()
+            .send(request, HttpResponse.BodyHandler.asString());
+
+        assertThat(response.statusCode(), equalTo(HttpURLConnection.HTTP_OK));
+    }
+
+    @Test
+    public void shouldReturnNoContentWhenPostWithNoBody() throws IOException, InterruptedException, URISyntaxException {
+        HttpRequest request = HttpRequest.newBuilder()
+            .uri(new URI("https://postman-echo.com/post"))
+            .POST(HttpRequest.noBody())
+            .build();
+
+        HttpResponse<String> response = HttpClient.newHttpClient()
+            .send(request, HttpResponse.BodyHandler.asString());
+
+        assertThat(response.statusCode(), equalTo(HttpURLConnection.HTTP_OK));
+    }
+
+    @Test
+    public void shouldReturnSampleDataContentWhenPostWithBodyText() throws IOException, InterruptedException, URISyntaxException {
+        HttpRequest request = HttpRequest.newBuilder()
+            .uri(new URI("https://postman-echo.com/post"))
+            .headers("Content-Type", "text/plain;charset=UTF-8")
+            .POST(HttpRequest.BodyProcessor.fromString("Sample request body"))
+            .build();
+
+        HttpResponse<String> response = HttpClient.newHttpClient()
+            .send(request, HttpResponse.BodyHandler.asString());
+
+        assertThat(response.statusCode(), equalTo(HttpURLConnection.HTTP_OK));
+        assertThat(response.body(), containsString("Sample request body"));
+    }
+
+    @Test
+    public void shouldReturnSampleDataContentWhenPostWithInputStream() throws IOException, InterruptedException, URISyntaxException {
+        byte[] sampleData = "Sample request body".getBytes();
+        HttpRequest request = HttpRequest.newBuilder()
+            .uri(new URI("https://postman-echo.com/post"))
+            .headers("Content-Type", "text/plain;charset=UTF-8")
+            .POST(HttpRequest.BodyProcessor.fromInputStream(() -> new ByteArrayInputStream(sampleData)))
+            .build();
+
+        HttpResponse<String> response = HttpClient.newHttpClient()
+            .send(request, HttpResponse.BodyHandler.asString());
+
+        assertThat(response.statusCode(), equalTo(HttpURLConnection.HTTP_OK));
+        assertThat(response.body(), containsString("Sample request body"));
+    }
+
+    @Test
+    public void shouldReturnSampleDataContentWhenPostWithByteArrayProcessorStream() throws IOException, InterruptedException, URISyntaxException {
+        byte[] sampleData = "Sample request body".getBytes();
+        HttpRequest request = HttpRequest.newBuilder()
+            .uri(new URI("https://postman-echo.com/post"))
+            .headers("Content-Type", "text/plain;charset=UTF-8")
+            .POST(HttpRequest.BodyProcessor.fromByteArray(sampleData))
+            .build();
+
+        HttpResponse<String> response = HttpClient.newHttpClient()
+            .send(request, HttpResponse.BodyHandler.asString());
+
+        assertThat(response.statusCode(), equalTo(HttpURLConnection.HTTP_OK));
+        assertThat(response.body(), containsString("Sample request body"));
+    }
+
+    @Test
+    public void shouldReturnSampleDataContentWhenPostWithFileProcessorStream() throws IOException, InterruptedException, URISyntaxException {
+        HttpRequest request = HttpRequest.newBuilder()
+            .uri(new URI("https://postman-echo.com/post"))
+            .headers("Content-Type", "text/plain;charset=UTF-8")
+            .POST(HttpRequest.BodyProcessor.fromFile(Paths.get("src/test/resources/sample.txt")))
+            .build();
+
+        HttpResponse<String> response = HttpClient.newHttpClient()
+            .send(request, HttpResponse.BodyHandler.asString());
+
+        assertThat(response.statusCode(), equalTo(HttpURLConnection.HTTP_OK));
+        assertThat(response.body(), containsString("Sample file content"));
+    }
+
+}
--- a/core-java-9/src/test/java/com/baeldung/java9/httpclient/HttpResponseTest.java
+++ b/core-java-9/src/test/java/com/baeldung/java9/httpclient/HttpResponseTest.java
@ -0,0 +1,55 @@
+package com.baeldung.java9.httpclient;
+
+import jdk.incubator.http.HttpClient;
+import jdk.incubator.http.HttpRequest;
+import jdk.incubator.http.HttpResponse;
+import org.junit.Test;
+
+import java.io.IOException;
+import java.net.HttpURLConnection;
+import java.net.URI;
+import java.net.URISyntaxException;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.Matchers.isEmptyString;
+import static org.hamcrest.core.IsNot.not;
+import static org.junit.Assert.assertThat;
+
+/**
+ * Created by adam.
+ */
+public class HttpResponseTest {
+
+    @Test
+    public void shouldReturnStatusOKWhenSendGetRequest() throws IOException, InterruptedException, URISyntaxException {
+        HttpRequest request = HttpRequest.newBuilder()
+            .uri(new URI("https://postman-echo.com/get"))
+            .GET()
+            .build();
+
+        HttpResponse<String> response = HttpClient.newHttpClient()
+            .send(request, HttpResponse.BodyHandler.asString());
+
+        assertThat(response.statusCode(), equalTo(HttpURLConnection.HTTP_OK));
+        assertThat(response.body(), not(isEmptyString()));
+    }
+
+    @Test
+    public void shouldResponseURIDifferentThanRequestUIRWhenRedirect() throws IOException, InterruptedException, URISyntaxException {
+        HttpRequest request = HttpRequest.newBuilder()
+            .uri(new URI("http://stackoverflow.com"))
+            .version(HttpClient.Version.HTTP_1_1)
+            .GET()
+            .build();
+        HttpResponse<String> response = HttpClient.newBuilder()
+            .followRedirects(HttpClient.Redirect.ALWAYS)
+            .build()
+            .send(request, HttpResponse.BodyHandler.asString());
+
+        assertThat(request.uri()
+            .toString(), equalTo("http://stackoverflow.com"));
+        assertThat(response.uri()
+            .toString(), equalTo("https://stackoverflow.com/"));
+    }
+
+}
--- a/core-java-concurrency/src/main/java/com/baeldung/concurrent/prioritytaskexecution/Job.java
+++ b/core-java-concurrency/src/main/java/com/baeldung/concurrent/prioritytaskexecution/Job.java
@ -0,0 +1,24 @@
+package com.baeldung.concurrent.prioritytaskexecution;
+
+public class Job implements Runnable {
+    private String jobName;
+    private JobPriority jobPriority;
+    
+    public Job(String jobName, JobPriority jobPriority) {
+        this.jobName = jobName;
+        this.jobPriority = jobPriority != null ? jobPriority : JobPriority.MEDIUM;
+    }
+
+    public JobPriority getJobPriority() {
+        return jobPriority;
+    }
+
+    @Override
+    public void run() {
+        try {
+            System.out.println("Job:" + jobName + " Priority:" + jobPriority);
+            Thread.sleep(1000);
+        } catch (InterruptedException ignored) {
+        }
+    }
+}
--- a/core-java-concurrency/src/main/java/com/baeldung/concurrent/prioritytaskexecution/JobPriority.java
+++ b/core-java-concurrency/src/main/java/com/baeldung/concurrent/prioritytaskexecution/JobPriority.java
@ -0,0 +1,7 @@
+package com.baeldung.concurrent.prioritytaskexecution;
+
+public enum JobPriority {
+    HIGH,
+    MEDIUM,
+    LOW
+}
--- a/core-java-concurrency/src/main/java/com/baeldung/concurrent/prioritytaskexecution/PriorityJobScheduler.java
+++ b/core-java-concurrency/src/main/java/com/baeldung/concurrent/prioritytaskexecution/PriorityJobScheduler.java
@ -0,0 +1,56 @@
+package com.baeldung.concurrent.prioritytaskexecution;
+
+import java.util.Comparator;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.PriorityBlockingQueue;
+import java.util.concurrent.TimeUnit;
+
+public class PriorityJobScheduler {
+
+    private ExecutorService priorityJobPoolExecutor;
+    private ExecutorService priorityJobScheduler;
+    private PriorityBlockingQueue<Runnable> priorityQueue;
+
+    public PriorityJobScheduler(Integer poolSize, Integer queueSize) {
+        priorityJobPoolExecutor = Executors.newFixedThreadPool(poolSize);
+        Comparator<? super Job> jobComparator = Comparator.comparing(Job::getJobPriority);
+        priorityQueue = new PriorityBlockingQueue<Runnable>(queueSize, 
+          (Comparator<? super Runnable>) jobComparator);
+
+        priorityJobScheduler = Executors.newSingleThreadExecutor();
+        priorityJobScheduler.execute(()->{
+            while (true) {
+                try {
+                    priorityJobPoolExecutor.execute(priorityQueue.take());
+                } catch (InterruptedException e) {
+                    break;
+                }
+            }
+        });
+    }
+
+    public void scheduleJob(Job job) {
+        priorityQueue.add(job);
+    }
+
+    public int getQueuedTaskCount() {
+        return priorityQueue.size();
+    }
+
+    protected void close(ExecutorService scheduler) {
+        scheduler.shutdown();
+        try {
+            if (!scheduler.awaitTermination(5, TimeUnit.SECONDS)) {
+                scheduler.shutdownNow();
+            }
+        } catch (InterruptedException e) {
+            scheduler.shutdownNow();
+        }
+    }
+
+    public void closeScheduler() {
+        close(priorityJobPoolExecutor);
+        close(priorityJobScheduler);
+    }
+}
--- a/core-java-concurrency/src/main/java/com/baeldung/concurrent/waitandnotify/Data.java
+++ b/core-java-concurrency/src/main/java/com/baeldung/concurrent/waitandnotify/Data.java
@ -11,7 +11,10 @@ public class Data {
        while (transfer) {
            try {
                wait();
-            } catch (InterruptedException e) {}
+            } catch (InterruptedException e) {
+                Thread.currentThread().interrupt(); 
+                System.out.println("Thread Interrupted");
+            }
        }
        transfer = true;

@ -23,7 +26,10 @@ public class Data {
        while (!transfer) {
            try { 
                wait();
-            } catch (InterruptedException e) {}
+            } catch (InterruptedException e) {
+                Thread.currentThread().interrupt(); 
+                System.out.println("Thread Interrupted");
+            }
        }
        transfer = false;
        
--- a/core-java-concurrency/src/main/java/com/baeldung/concurrent/waitandnotify/Receiver.java
+++ b/core-java-concurrency/src/main/java/com/baeldung/concurrent/waitandnotify/Receiver.java
@ -19,7 +19,10 @@ public class Receiver implements Runnable {
            //Thread.sleep() to mimic heavy server-side processing
            try {
                Thread.sleep(ThreadLocalRandom.current().nextInt(1000, 5000));
-            } catch (InterruptedException e) {}
+            } catch (InterruptedException e) {
+                Thread.currentThread().interrupt(); 
+                System.out.println("Thread Interrupted");
+            }
        }
    }
 }
--- a/core-java-concurrency/src/main/java/com/baeldung/concurrent/waitandnotify/Sender.java
+++ b/core-java-concurrency/src/main/java/com/baeldung/concurrent/waitandnotify/Sender.java
@ -11,11 +11,11 @@ public class Sender implements Runnable {
 
    public void run() {
        String packets[] = {
-            "First packet",
-            "Second packet",
-            "Third packet",
-            "Fourth packet",
-            "End"
+          "First packet",
+          "Second packet",
+          "Third packet",
+          "Fourth packet",
+          "End"
        };
 
        for (String packet : packets) {
@ -24,7 +24,10 @@ public class Sender implements Runnable {
            //Thread.sleep() to mimic heavy server-side processing
            try {
                Thread.sleep(ThreadLocalRandom.current().nextInt(1000, 5000));
-            } catch (InterruptedException e) {}
+            } catch (InterruptedException e) {
+                Thread.currentThread().interrupt(); 
+                System.out.println("Thread Interrupted");
+            }
        }
    }
 }
--- a/core-java-concurrency/src/test/java/com/baeldung/concurrent/prioritytaskexecution/PriorityJobSchedulerUnitTest.java
+++ b/core-java-concurrency/src/test/java/com/baeldung/concurrent/prioritytaskexecution/PriorityJobSchedulerUnitTest.java
@ -0,0 +1,38 @@
+package com.baeldung.concurrent.prioritytaskexecution;
+
+import org.junit.Test;
+
+public class PriorityJobSchedulerUnitTest {
+    private static int POOL_SIZE = 1;
+    private static int QUEUE_SIZE = 10;
+    
+    @Test
+    public void whenMultiplePriorityJobsQueued_thenHighestPriorityJobIsPicked() {
+        Job job1 = new Job("Job1", JobPriority.LOW);
+        Job job2 = new Job("Job2", JobPriority.MEDIUM);
+        Job job3 = new Job("Job3", JobPriority.HIGH);
+        Job job4 = new Job("Job4", JobPriority.MEDIUM);
+        Job job5 = new Job("Job5", JobPriority.LOW);
+        Job job6 = new Job("Job6", JobPriority.HIGH);
+        
+        PriorityJobScheduler pjs = new PriorityJobScheduler(POOL_SIZE, QUEUE_SIZE);
+        
+        pjs.scheduleJob(job1);
+        pjs.scheduleJob(job2);
+        pjs.scheduleJob(job3);
+        pjs.scheduleJob(job4);
+        pjs.scheduleJob(job5);
+        pjs.scheduleJob(job6);
+        
+        // ensure no tasks is pending before closing the scheduler
+        while (pjs.getQueuedTaskCount() != 0);
+        
+        // delay to avoid job sleep (added for demo) being interrupted
+        try {
+            Thread.sleep(2000);
+        } catch (InterruptedException ignored) {
+        }
+        
+        pjs.closeScheduler();
+    }
+}
--- a/core-java-concurrency/src/test/java/com/baeldung/concurrent/waitandnotify/NetworkIntegrationTest.java
+++ b/core-java-concurrency/src/test/java/com/baeldung/concurrent/waitandnotify/NetworkIntegrationTest.java
@ -13,38 +13,38 @@ import org.junit.Test;

 public class NetworkIntegrationTest {

-	private final ByteArrayOutputStream outContent = new ByteArrayOutputStream();
-	private final ByteArrayOutputStream errContent = new ByteArrayOutputStream();
-	private String expected;
-	
-	@Before
-	public void setUpStreams() {
-	    System.setOut(new PrintStream(outContent));
-	    System.setErr(new PrintStream(errContent));
-	}
-	
-	@Before
-	public void setUpExpectedOutput() {
-		StringWriter expectedStringWriter = new StringWriter();
-		
-		PrintWriter printWriter = new PrintWriter(expectedStringWriter);
-		printWriter.println("First packet");
-		printWriter.println("Second packet");
-		printWriter.println("Third packet");
-		printWriter.println("Fourth packet");
-		printWriter.close();
-		
-		expected = expectedStringWriter.toString();
-	}
+    private final ByteArrayOutputStream outContent = new ByteArrayOutputStream();
+    private final ByteArrayOutputStream errContent = new ByteArrayOutputStream();
+    private String expected;
+    
+    @Before
+    public void setUpStreams() {
+        System.setOut(new PrintStream(outContent));
+        System.setErr(new PrintStream(errContent));
+    }
+    
+    @Before
+    public void setUpExpectedOutput() {
+        StringWriter expectedStringWriter = new StringWriter();
+        
+        PrintWriter printWriter = new PrintWriter(expectedStringWriter);
+        printWriter.println("First packet");
+        printWriter.println("Second packet");
+        printWriter.println("Third packet");
+        printWriter.println("Fourth packet");
+        printWriter.close();
+        
+        expected = expectedStringWriter.toString();
+    }

-	@After
-	public void cleanUpStreams() {
-	    System.setOut(null);
-	    System.setErr(null);
-	}
-	
-	@Test
-	public void givenSenderAndReceiver_whenSendingPackets_thenNetworkSynchronized() {
+    @After
+    public void cleanUpStreams() {
+        System.setOut(null);
+        System.setErr(null);
+    }
+    
+    @Test
+    public void givenSenderAndReceiver_whenSendingPackets_thenNetworkSynchronized() {
        Data data = new Data();
        Thread sender = new Thread(new Sender(data));
        Thread receiver = new Thread(new Receiver(data));
@ -54,12 +54,13 @@ public class NetworkIntegrationTest {
        
        //wait for sender and receiver to finish before we test against expected
        try {
-			sender.join();
-			receiver.join();
-		} catch (InterruptedException e) {
-			e.printStackTrace();
-		}
-		
-	    assertEquals(expected, outContent.toString());
-	}
+            sender.join();
+            receiver.join();
+        } catch (InterruptedException e) {
+            Thread.currentThread().interrupt(); 
+            System.out.println("Thread Interrupted");
+        }
+        
+        assertEquals(expected, outContent.toString());
+    }
 }
--- a/core-java/README.md
+++ b/core-java/README.md
@ -126,3 +126,4 @@
 - [A Guide to Inner Interfaces in Java](http://www.baeldung.com/java-inner-interfaces)
 - [Polymorphism in Java](http://www.baeldung.com/java-polymorphism)
 - [Recursion In Java](http://www.baeldung.com/java-recursion)
+- [A Guide to the finalize Method in Java](http://www.baeldung.com/java-finalize)
--- a/core-java/src/main/java/com/baeldung/designpatterns/observer/Channel.java
+++ b/core-java/src/main/java/com/baeldung/designpatterns/observer/Channel.java
@ -0,0 +1,5 @@
+package com.baeldung.designpatterns.observer;
+
+public interface Channel {
+    public void update(Object o);
+}
--- a/core-java/src/main/java/com/baeldung/designpatterns/observer/NewsAgency.java
+++ b/core-java/src/main/java/com/baeldung/designpatterns/observer/NewsAgency.java
@ -0,0 +1,24 @@
+package com.baeldung.designpatterns.observer;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class NewsAgency {
+    private String news;
+    private List<Channel> channels = new ArrayList<>();
+
+    public void addObserver(Channel channel) {
+        this.channels.add(channel);
+    }
+
+    public void removeObserver(Channel channel) {
+        this.channels.remove(channel);
+    }
+
+    public void setNews(String news) {
+        this.news = news;
+        for (Channel channel : this.channels) {
+            channel.update(this.news);
+        }
+    }
+}
--- a/core-java/src/main/java/com/baeldung/designpatterns/observer/NewsChannel.java
+++ b/core-java/src/main/java/com/baeldung/designpatterns/observer/NewsChannel.java
@ -0,0 +1,20 @@
+package com.baeldung.designpatterns.observer;
+
+public class NewsChannel implements Channel {
+
+    private String news;
+
+    @Override
+    public void update(Object news) {
+        this.setNews((String) news);
+    }
+
+    public String getNews() {
+        return news;
+    }
+
+    public void setNews(String news) {
+        this.news = news;
+    }
+
+}
--- a/core-java/src/main/java/com/baeldung/designpatterns/observer/ONewsAgency.java
+++ b/core-java/src/main/java/com/baeldung/designpatterns/observer/ONewsAgency.java
@ -0,0 +1,13 @@
+package com.baeldung.designpatterns.observer;
+
+import java.util.Observable;
+
+public class ONewsAgency extends Observable {
+    private String news;
+
+    public void setNews(String news) {
+        this.news = news;
+        setChanged();
+        notifyObservers(news);
+    }
+}
--- a/core-java/src/main/java/com/baeldung/designpatterns/observer/ONewsChannel.java
+++ b/core-java/src/main/java/com/baeldung/designpatterns/observer/ONewsChannel.java
@ -0,0 +1,22 @@
+package com.baeldung.designpatterns.observer;
+
+import java.util.Observable;
+import java.util.Observer;
+
+public class ONewsChannel implements Observer {
+
+    private String news;
+
+    @Override
+    public void update(Observable o, Object news) {
+        this.setNews((String) news);
+    }
+
+    public String getNews() {
+        return news;
+    }
+
+    public void setNews(String news) {
+        this.news = news;
+    }
+}
--- a/core-java/src/main/java/com/baeldung/designpatterns/observer/PCLNewsAgency.java
+++ b/core-java/src/main/java/com/baeldung/designpatterns/observer/PCLNewsAgency.java
@ -0,0 +1,28 @@
+package com.baeldung.designpatterns.observer;
+
+import java.beans.PropertyChangeListener;
+import java.beans.PropertyChangeSupport;
+
+public class PCLNewsAgency {
+    private String news;
+
+    private PropertyChangeSupport support;
+
+    public PCLNewsAgency() {
+        support = new PropertyChangeSupport(this);
+    }
+
+    public void addPropertyChangeListener(PropertyChangeListener pcl) {
+        support.addPropertyChangeListener(pcl);
+    }
+
+    public void removePropertyChangeListener(PropertyChangeListener pcl) {
+        support.removePropertyChangeListener(pcl);
+    }
+
+    public void setNews(String value) {
+        support.firePropertyChange("news", this.news, value);
+        this.news = value;
+
+    }
+}
--- a/core-java/src/main/java/com/baeldung/designpatterns/observer/PCLNewsChannel.java
+++ b/core-java/src/main/java/com/baeldung/designpatterns/observer/PCLNewsChannel.java
@ -0,0 +1,21 @@
+package com.baeldung.designpatterns.observer;
+
+import java.beans.PropertyChangeEvent;
+import java.beans.PropertyChangeListener;
+
+public class PCLNewsChannel implements PropertyChangeListener {
+
+    private String news;
+
+    public void propertyChange(PropertyChangeEvent evt) {
+        this.setNews((String) evt.getNewValue());
+    }
+
+    public String getNews() {
+        return news;
+    }
+
+    public void setNews(String news) {
+        this.news = news;
+    }
+}
--- a/core-java/src/main/java/com/baeldung/javac/Data.java
+++ b/core-java/src/main/java/com/baeldung/javac/Data.java
@ -0,0 +1,16 @@
+package com.baeldung.javac;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Data {
+    List<String> textList = new ArrayList();
+
+    public void addText(String text) {
+        textList.add(text);
+    }
+
+    public List getTextList() {
+        return this.textList;
+    }
+}
--- a/core-java/src/main/java/javac-args/arguments
+++ b/core-java/src/main/java/javac-args/arguments
@ -0,0 +1,2 @@
+-d javac-target -verbose
+com/baeldung/javac/Data.java
--- a/core-java/src/main/java/javac-args/options
+++ b/core-java/src/main/java/javac-args/options
@ -0,0 +1,2 @@
+-d javac-target
+-verbose
--- a/core-java/src/main/java/javac-args/types
+++ b/core-java/src/main/java/javac-args/types
@ -0,0 +1 @@
+com/baeldung/javac/Data.java
--- a/core-java/src/main/java/javac-args/xlint-ops
+++ b/core-java/src/main/java/javac-args/xlint-ops
@ -0,0 +1,3 @@
+-d javac-target
+-Xlint:rawtypes,unchecked,static,cast,serial,fallthrough
+com/baeldung/javac/Data.java
--- a/core-java/src/test/java/com/baeldung/designpatterns/observer/ObserverIntegrationTest.java
+++ b/core-java/src/test/java/com/baeldung/designpatterns/observer/ObserverIntegrationTest.java
@ -0,0 +1,47 @@
+package com.baeldung.designpatterns.observer;
+
+import static org.junit.Assert.assertEquals;
+
+import org.junit.Test;
+
+import com.baeldung.designpatterns.observer.NewsAgency;
+import com.baeldung.designpatterns.observer.NewsChannel;
+
+public class ObserverIntegrationTest {
+
+    @Test
+    public void whenChangingNewsAgencyState_thenNewsChannelNotified() {
+
+        NewsAgency observable = new NewsAgency();
+        NewsChannel observer = new NewsChannel();
+
+        observable.addObserver(observer);
+
+        observable.setNews("news");
+        assertEquals(observer.getNews(), "news");
+    }
+
+    @Test
+    public void whenChangingONewsAgencyState_thenONewsChannelNotified() {
+
+        ONewsAgency observable = new ONewsAgency();
+        ONewsChannel observer = new ONewsChannel();
+
+        observable.addObserver(observer);
+
+        observable.setNews("news");
+        assertEquals(observer.getNews(), "news");
+    }
+
+    @Test
+    public void whenChangingPCLNewsAgencyState_thenONewsChannelNotified() {
+
+        PCLNewsAgency observable = new PCLNewsAgency();
+        PCLNewsChannel observer = new PCLNewsChannel();
+
+        observable.addPropertyChangeListener(observer);
+
+        observable.setNews("news");
+        assertEquals(observer.getNews(), "news");
+    }
+}
--- a/guava/src/main/java/org/baeldung/guava/memoizer/CostlySupplier.java
+++ b/guava/src/main/java/org/baeldung/guava/memoizer/CostlySupplier.java
@ -0,0 +1,17 @@
+package org.baeldung.guava.memoizer;
+
+import java.math.BigInteger;
+import java.util.Random;
+import java.util.concurrent.TimeUnit;
+
+public class CostlySupplier {
+
+    public static BigInteger generateBigNumber() {
+        try {
+            TimeUnit.SECONDS.sleep(2);
+        } catch (InterruptedException e) {
+        }
+        return new BigInteger("12345");
+    }
+
+}
--- a/guava/src/main/java/org/baeldung/guava/memoizer/Factorial.java
+++ b/guava/src/main/java/org/baeldung/guava/memoizer/Factorial.java
@ -0,0 +1,22 @@
+package org.baeldung.guava.memoizer;
+
+import com.google.common.cache.CacheBuilder;
+import com.google.common.cache.CacheLoader;
+import com.google.common.cache.LoadingCache;
+
+import java.math.BigInteger;
+
+public class Factorial {
+
+    private static LoadingCache<Integer, BigInteger> memo = CacheBuilder.newBuilder()
+            .build(CacheLoader.from(Factorial::getFactorial));
+
+    public static BigInteger getFactorial(int n) {
+        if (n == 0) {
+            return BigInteger.ONE;
+        } else {
+            return BigInteger.valueOf(n).multiply(memo.getUnchecked(n - 1));
+        }
+    }
+
+}
--- a/guava/src/main/java/org/baeldung/guava/memoizer/FibonacciSequence.java
+++ b/guava/src/main/java/org/baeldung/guava/memoizer/FibonacciSequence.java
@ -0,0 +1,26 @@
+package org.baeldung.guava.memoizer;
+
+import com.google.common.cache.CacheBuilder;
+import com.google.common.cache.CacheLoader;
+import com.google.common.cache.LoadingCache;
+
+import java.math.BigInteger;
+import java.util.concurrent.TimeUnit;
+
+public class FibonacciSequence {
+
+    private static LoadingCache<Integer, BigInteger> memo = CacheBuilder.newBuilder()
+            .maximumSize(100)
+            .build(CacheLoader.from(FibonacciSequence::getFibonacciNumber));
+
+    public static BigInteger getFibonacciNumber(int n) {
+        if (n == 0) {
+            return BigInteger.ZERO;
+        } else if (n == 1) {
+            return BigInteger.ONE;
+        } else {
+            return memo.getUnchecked(n - 1).add(memo.getUnchecked(n - 2));
+        }
+    }
+
+}
--- a/guava/src/test/java/org/baeldung/guava/GuavaMemoizerUnitTest.java
+++ b/guava/src/test/java/org/baeldung/guava/GuavaMemoizerUnitTest.java
@ -0,0 +1,92 @@
+package org.baeldung.guava;
+
+import com.google.common.base.Suppliers;
+import org.baeldung.guava.memoizer.CostlySupplier;
+import org.baeldung.guava.memoizer.Factorial;
+import org.baeldung.guava.memoizer.FibonacciSequence;
+import org.junit.Test;
+
+import java.math.BigInteger;
+import java.time.Duration;
+import java.time.Instant;
+import java.util.concurrent.TimeUnit;
+import java.util.function.Supplier;
+
+import static org.hamcrest.core.Is.is;
+import static org.hamcrest.core.IsEqual.equalTo;
+import static org.hamcrest.number.IsCloseTo.closeTo;
+import static org.junit.Assert.assertThat;
+
+public class GuavaMemoizerUnitTest {
+
+    @Test
+    public void givenInteger_whenGetFibonacciNumber_thenShouldCalculateFibonacciNumber() {
+        // given
+        int n = 95;
+
+        // when
+        BigInteger fibonacciNumber = FibonacciSequence.getFibonacciNumber(n);
+
+        // then
+        BigInteger expectedFibonacciNumber = new BigInteger("31940434634990099905");
+        assertThat(fibonacciNumber, is(equalTo(expectedFibonacciNumber)));
+    }
+
+    @Test
+    public void givenInteger_whenGetFactorial_thenShouldCalculateFactorial() {
+        // given
+        int n = 95;
+
+        // when
+        BigInteger factorial = Factorial.getFactorial(n);
+
+        // then
+        BigInteger expectedFactorial = new BigInteger("10329978488239059262599702099394727095397746340117372869212250571234293987594703124871765375385424468563282236864226607350415360000000000000000000000");
+        assertThat(factorial, is(equalTo(expectedFactorial)));
+    }
+
+    @Test
+    public void givenMemoizedSupplier_whenGet_thenSubsequentGetsAreFast() {
+        // given
+        Supplier<BigInteger> memoizedSupplier;
+        memoizedSupplier = Suppliers.memoize(CostlySupplier::generateBigNumber);
+
+        // when
+        BigInteger expectedValue = new BigInteger("12345");
+        assertSupplierGetExecutionResultAndDuration(memoizedSupplier, expectedValue, 2000D);
+
+        // then
+        assertSupplierGetExecutionResultAndDuration(memoizedSupplier, expectedValue, 0D);
+        assertSupplierGetExecutionResultAndDuration(memoizedSupplier, expectedValue, 0D);
+    }
+
+    @Test
+    public void givenMemoizedSupplierWithExpiration_whenGet_thenSubsequentGetsBeforeExpiredAreFast() throws InterruptedException {
+        // given
+        Supplier<BigInteger> memoizedSupplier;
+        memoizedSupplier = Suppliers.memoizeWithExpiration(CostlySupplier::generateBigNumber, 3, TimeUnit.SECONDS);
+
+        // when
+        BigInteger expectedValue = new BigInteger("12345");
+        assertSupplierGetExecutionResultAndDuration(memoizedSupplier, expectedValue, 2000D);
+
+        // then
+        assertSupplierGetExecutionResultAndDuration(memoizedSupplier, expectedValue, 0D);
+        // add one more second until memoized Supplier is evicted from memory
+        TimeUnit.SECONDS.sleep(1);
+        assertSupplierGetExecutionResultAndDuration(memoizedSupplier, expectedValue, 2000D);
+    }
+
+    private <T> void assertSupplierGetExecutionResultAndDuration(Supplier<T> supplier,
+                                                                 T expectedValue,
+                                                                 double expectedDurationInMs) {
+        Instant start = Instant.now();
+        T value = supplier.get();
+        Long durationInMs = Duration.between(start, Instant.now()).toMillis();
+        double marginOfErrorInMs = 100D;
+
+        assertThat(value, is(equalTo(expectedValue)));
+        assertThat(durationInMs.doubleValue(), is(closeTo(expectedDurationInMs, marginOfErrorInMs)));
+    }
+
+}
--- a/hibernate5/src/main/java/com/baeldung/hibernate/HibernateUtil.java
+++ b/hibernate5/src/main/java/com/baeldung/hibernate/HibernateUtil.java
@ -81,6 +81,7 @@ public class HibernateUtil {
        metadataSources.addAnnotatedClass(Bag.class);
        metadataSources.addAnnotatedClass(PointEntity.class);
        metadataSources.addAnnotatedClass(PolygonEntity.class);
+        metadataSources.addAnnotatedClass(com.baeldung.hibernate.pojo.Person.class);

        Metadata metadata = metadataSources.buildMetadata();
        return metadata.getSessionFactoryBuilder()
--- a/hibernate5/src/main/java/com/baeldung/hibernate/converters/PersonNameConverter.java
+++ b/hibernate5/src/main/java/com/baeldung/hibernate/converters/PersonNameConverter.java
@ -0,0 +1,43 @@
+package com.baeldung.hibernate.converters;
+
+import javax.persistence.AttributeConverter;
+import javax.persistence.Converter;
+
+import com.baeldung.hibernate.pojo.PersonName;
+
+@Converter
+public class PersonNameConverter implements AttributeConverter<PersonName, String> {
+
+    private static final String SEPARATOR = ", ";
+
+    @Override
+    public String convertToDatabaseColumn(PersonName person) {
+        StringBuilder sb = new StringBuilder();
+        if (person.getSurname() != null) {
+            sb.append(person.getSurname());
+            sb.append(SEPARATOR);
+        }
+
+        if (person.getName() != null) {
+            sb.append(person.getName());
+        }
+
+        return sb.toString();
+    }
+
+    @Override
+    public PersonName convertToEntityAttribute(String dbPerson) {
+        String[] pieces = dbPerson.split(SEPARATOR);
+
+        if (pieces == null || pieces.length != 2) {
+            return null;
+        }
+
+        PersonName personName = new PersonName();
+        personName.setSurname(pieces[0]);
+        personName.setName(pieces[1]);
+
+        return personName;
+    }
+
+}
--- a/hibernate5/src/main/java/com/baeldung/hibernate/interceptors/CustomInterceptorImpl.java
+++ b/hibernate5/src/main/java/com/baeldung/hibernate/interceptors/CustomInterceptorImpl.java
@ -9,7 +9,7 @@ import org.hibernate.Interceptor;
 import org.hibernate.Transaction;
 import org.hibernate.type.Type;

-public class CustomInterceptorImpl implements Interceptor {
+public class CustomInterceptorImpl implements Interceptor, Serializable {

    @Override
    public boolean onLoad(Object entity, Serializable id, Object[] state, String[] propertyNames, Type[] types) throws CallbackException {
--- a/hibernate5/src/main/java/com/baeldung/hibernate/pojo/Person.java
+++ b/hibernate5/src/main/java/com/baeldung/hibernate/pojo/Person.java
@ -0,0 +1,32 @@
+package com.baeldung.hibernate.pojo;
+
+import javax.persistence.Convert;
+import javax.persistence.Entity;
+import javax.persistence.GeneratedValue;
+import javax.persistence.Id;
+
+import com.baeldung.hibernate.converters.PersonNameConverter;
+
+@Entity(name = "PersonTable")
+public class Person {
+
+    @Id
+    @GeneratedValue
+    private Long id;
+
+    @Convert(converter = PersonNameConverter.class)
+    private PersonName personName;
+
+    public PersonName getPersonName() {
+        return personName;
+    }
+
+    public void setPersonName(PersonName personName) {
+        this.personName = personName;
+    }
+
+    public Long getId() {
+        return id;
+    }
+
+}
--- a/hibernate5/src/main/java/com/baeldung/hibernate/pojo/PersonName.java
+++ b/hibernate5/src/main/java/com/baeldung/hibernate/pojo/PersonName.java
@ -0,0 +1,29 @@
+package com.baeldung.hibernate.pojo;
+
+import java.io.Serializable;
+
+public class PersonName implements Serializable {
+
+    private static final long serialVersionUID = 7883094644631050150L;
+
+    private String name;
+
+    private String surname;
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public String getSurname() {
+        return surname;
+    }
+
+    public void setSurname(String surname) {
+        this.surname = surname;
+    }
+
+}
--- a/hibernate5/src/test/java/com/baeldung/hibernate/converter/PersonNameConverterTest.java
+++ b/hibernate5/src/test/java/com/baeldung/hibernate/converter/PersonNameConverterTest.java
@ -0,0 +1,74 @@
+package com.baeldung.hibernate.converter;
+
+import java.io.IOException;
+
+import org.hibernate.Session;
+import org.hibernate.Transaction;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+import com.baeldung.hibernate.HibernateUtil;
+import com.baeldung.hibernate.pojo.Person;
+import com.baeldung.hibernate.pojo.PersonName;
+
+import static org.junit.Assert.assertEquals;
+
+public class PersonNameConverterTest {
+
+    private Session session;
+    private Transaction transaction;
+
+    @Before
+    public void setUp() throws IOException {
+        session = HibernateUtil.getSessionFactory()
+            .openSession();
+        transaction = session.beginTransaction();
+
+        session.createNativeQuery("delete from personTable")
+            .executeUpdate();
+
+        transaction.commit();
+        transaction = session.beginTransaction();
+    }
+
+    @After
+    public void tearDown() {
+        transaction.rollback();
+        session.close();
+    }
+
+    @Test
+    public void givenPersonName_WhenSaving_ThenNameAndSurnameConcat() {
+        final String name = "name";
+        final String surname = "surname";
+
+        PersonName personName = new PersonName();
+        personName.setName(name);
+        personName.setSurname(surname);
+
+        Person person = new Person();
+        person.setPersonName(personName);
+
+        Long id = (Long) session.save(person);
+
+        session.flush();
+        session.clear();
+
+        String dbPersonName = (String) session.createNativeQuery("select p.personName from PersonTable p where p.id = :id")
+            .setParameter("id", id)
+            .getSingleResult();
+
+        assertEquals(surname + ", " + name, dbPersonName);
+
+        Person dbPerson = session.createNativeQuery("select * from PersonTable p where p.id = :id", Person.class)
+            .setParameter("id", id)
+            .getSingleResult();
+
+        assertEquals(dbPerson.getPersonName()
+            .getName(), name);
+        assertEquals(dbPerson.getPersonName()
+            .getSurname(), surname);
+    }
+
+}
--- a/influxdb/README.md
+++ b/influxdb/README.md
@ -2,7 +2,6 @@

 ### Relevant Article:
 - [Introduction to using InfluxDB with Java](http://www.baeldung.com/using-influxdb-with-java/)
- [Using InfluxDB with Java](http://www.baeldung.com/java-influxdb)

 ### Overview
 This Maven project contains the Java code for the article linked above.
--- a/influxdb/src/test/java/com/baeldung/influxdb/InfluxDBConnectionLiveTest.java
+++ b/influxdb/src/test/java/com/baeldung/influxdb/InfluxDBConnectionLiveTest.java
@ -8,7 +8,6 @@ import org.influxdb.dto.*;
 import org.influxdb.impl.InfluxDBResultMapper;
 import org.junit.Test;

-import java.io.IOException;
 import java.util.List;
 import java.util.concurrent.TimeUnit;

@ -103,7 +102,7 @@ public class InfluxDBConnectionLiveTest {
        // another brief pause.
        Thread.sleep(10);

-        List<MemoryPoint> memoryPointList = getPoints(connection, "Select * from memory", "baeldung");
+        List<com.baeldung.influxdb.MemoryPoint> memoryPointList = getPoints(connection, "Select * from memory", "baeldung");

        assertEquals(10, memoryPointList.size());

--- a/java-rmi/pom.xml
+++ b/java-rmi/pom.xml
@ -0,0 +1,20 @@
+<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.rmi</groupId>
+  <artifactId>java-rmi</artifactId>
+  <version>1.0-SNAPSHOT</version>
+  <packaging>jar</packaging>
+  
+  <parent>
+        <groupId>com.baeldung</groupId>
+        <artifactId>parent-modules</artifactId>
+        <version>1.0.0-SNAPSHOT</version>
+  </parent>
+  
+  <properties>
+    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+  </properties>
+  
+</project>
--- a/java-rmi/src/main/java/com/baeldung/rmi/Message.java
+++ b/java-rmi/src/main/java/com/baeldung/rmi/Message.java
@ -0,0 +1,36 @@
+package com.baeldung.rmi;
+
+import java.io.Serializable;
+
+public class Message implements Serializable {
+	
+	private String messageText;
+	
+	private String contentType;
+	
+	public Message() {
+	}
+	
+	public Message(String messageText, String contentType) {
+		
+		this.messageText = messageText;
+		this.contentType = contentType;
+	}
+	
+	public String getMessageText() {
+		return messageText;
+	}
+
+	public void setMessageText(String messageText) {
+		this.messageText = messageText;
+	}
+
+	public String getContentType() {
+		return contentType;
+	}
+
+	public void setContentType(String contentType) {
+		this.contentType = contentType;
+	}
+	
+}
--- a/java-rmi/src/main/java/com/baeldung/rmi/MessengerService.java
+++ b/java-rmi/src/main/java/com/baeldung/rmi/MessengerService.java
@ -0,0 +1,11 @@
+package com.baeldung.rmi;
+
+import java.rmi.Remote;
+import java.rmi.RemoteException;
+
+public interface MessengerService extends Remote {
+
+	public String sendMessage(String clientMessage) throws RemoteException;
+
+	public Message sendMessage(Message clientMessage) throws RemoteException;
+}
--- a/java-rmi/src/main/java/com/baeldung/rmi/MessengerServiceImpl.java
+++ b/java-rmi/src/main/java/com/baeldung/rmi/MessengerServiceImpl.java
@ -0,0 +1,37 @@
+package com.baeldung.rmi;
+
+import java.rmi.RemoteException;
+import java.rmi.registry.LocateRegistry;
+import java.rmi.registry.Registry;
+import java.rmi.server.UnicastRemoteObject;
+
+public class MessengerServiceImpl implements MessengerService {
+
+	public String sendMessage(String clientMessage) {
+		
+		String serverMessage = null;
+		if (clientMessage.equals("Client Message")) {
+			serverMessage = "Server Message";
+		}
+		
+		return serverMessage;
+	}
+	
+	public void createStubAndBind() throws RemoteException {
+		
+		MessengerService stub = (MessengerService) UnicastRemoteObject.exportObject((MessengerService) this, 0);
+		Registry registry = LocateRegistry.createRegistry(1099);
+		registry.rebind("MessengerService", stub);
+	}
+	
+	public Message sendMessage(Message clientMessage) throws RemoteException {
+		
+		Message serverMessage = null;
+		if (clientMessage.getMessageText().equals("Client Message")) {
+			serverMessage = new Message("Server Message", "text/plain");
+		}
+		
+		return serverMessage;
+	}
+	
+}
--- a/java-rmi/src/test/java/com/baeldung/rmi/JavaRMIIntegrationTest.java
+++ b/java-rmi/src/test/java/com/baeldung/rmi/JavaRMIIntegrationTest.java
@ -0,0 +1,44 @@
+package com.baeldung.rmi;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.fail;
+
+import java.rmi.NotBoundException;
+import java.rmi.RemoteException;
+import java.rmi.registry.LocateRegistry;
+import java.rmi.registry.Registry;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+public class JavaRMIIntegrationTest {
+	
+	@BeforeClass
+	public static void whenRunServer_thenServerStarts() {
+		
+		try {
+			MessengerServiceImpl server = new MessengerServiceImpl();
+			server.createStubAndBind();
+		} catch (RemoteException e) {
+			fail("Exception Occurred");
+		}
+	}
+	
+	@Test
+	public void whenClientSendsMessageToServer_thenServerSendsResponseMessage() {
+		
+		try {
+			Registry registry = LocateRegistry.getRegistry();	
+			MessengerService server = (MessengerService) registry.lookup("MessengerService");			
+			String responseMessage = server.sendMessage("Client Message");		
+			
+			String expectedMessage = "Server Message";			
+			assertEquals(responseMessage, expectedMessage);
+		} catch (RemoteException e) {
+			fail("Exception Occurred");
+		} catch (NotBoundException nb) {
+			fail("Exception Occurred");
+		}
+	}
+	
+}
--- a/jgroups/README.md
+++ b/jgroups/README.md
@ -0,0 +1,15 @@
+## Reliable Messaging with JGroups Tutorial Project
+
+### Relevant Article:
+- [Reliable Messaging with JGroups](http://www.baeldung.com/reliable-messaging-with-jgroups/)
+
+### Overview
+This Maven project contains the Java code for the article linked above.
+
+### Package Organization
+Java classes for the intro tutorial are in the org.baeldung.jgroups package.
+
+
+### Running the tests
+
+```
--- a/jgroups/pom.xml
+++ b/jgroups/pom.xml
@ -0,0 +1,36 @@
+<?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>
+    <artifactId>jgroups</artifactId>
+    <version>0.1-SNAPSHOT</version>
+    <packaging>jar</packaging>
+    <name>jgroups</name>
+    <description>Reliable Messaging with JGroups Tutorial</description>
+
+    <parent>
+        <groupId>com.baeldung</groupId>
+        <artifactId>parent-modules</artifactId>
+        <version>1.0.0-SNAPSHOT</version>
+    </parent>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.jgroups</groupId>
+            <artifactId>jgroups</artifactId>
+            <version>4.0.10.Final</version>
+        </dependency>
+
+        <dependency>
+            <groupId>commons-cli</groupId>
+            <artifactId>commons-cli</artifactId>
+            <version>1.4</version>
+        </dependency>
+    </dependencies>
+
+    <properties>
+        <java.version>1.8</java.version>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+    </properties>
+
+</project>
--- a/jgroups/src/main/java/com/baeldung/jgroups/JGroupsMessenger.java
+++ b/jgroups/src/main/java/com/baeldung/jgroups/JGroupsMessenger.java
@ -0,0 +1,222 @@
+package com.baeldung.jgroups;
+
+import org.apache.commons.cli.*;
+import org.jgroups.*;
+import org.jgroups.util.Util;
+
+import java.io.*;
+import java.util.List;
+import java.util.Optional;
+
+public class JGroupsMessenger extends ReceiverAdapter {
+
+    private JChannel channel;
+    private String userName;
+    private String clusterName;
+    private View lastView;
+    private boolean running = true;
+
+    // Our shared state
+    private Integer messageCount = 0;
+
+    /**
+     * Connect to a JGroups cluster using command line options
+     * @param args command line arguments
+     * @throws Exception
+     */
+    private void start(String[] args) throws Exception {
+        processCommandline(args);
+
+        // Create the channel
+        // This file could be moved, or made a command line option.
+        channel = new JChannel("src/main/resources/udp.xml");
+
+        // Set a name
+        channel.name(userName);
+
+        // Register for callbacks
+        channel.setReceiver(this);
+
+        // Ignore our messages
+        channel.setDiscardOwnMessages(true);
+
+        // Connect
+        channel.connect(clusterName);
+
+        // Start state transfer
+        channel.getState(null, 0);
+
+        // Do the things
+        processInput();
+
+        // Clean up
+        channel.close();
+
+    }
+
+    /**
+     * Quick and dirty implementaton of commons cli for command line args
+     * @param args the command line args
+     * @throws ParseException
+     */
+    private void processCommandline(String[] args) throws ParseException {
+
+        // Options, parser, friendly help
+        Options options = new Options();
+        CommandLineParser parser = new DefaultParser();
+        HelpFormatter formatter = new HelpFormatter();
+
+        options.addOption("u", "user", true, "User name")
+            .addOption("c", "cluster", true, "Cluster name");
+
+        CommandLine line = parser.parse(options, args);
+
+        if (line.hasOption("user")) {
+            userName = line.getOptionValue("user");
+        } else {
+            formatter.printHelp("JGroupsMessenger: need a user name.\n", options);
+            System.exit(-1);
+        }
+
+        if (line.hasOption("cluster")) {
+            clusterName = line.getOptionValue("cluster");
+        } else {
+            formatter.printHelp("JGroupsMessenger: need a cluster name.\n", options);
+            System.exit(-1);
+        }
+    }
+
+    // Start it up
+    public static void main(String[] args) throws Exception {
+        new JGroupsMessenger().start(args);
+    }
+
+
+    @Override
+    public void viewAccepted(View newView) {
+
+        // Save view if this is the first
+        if (lastView == null) {
+            System.out.println("Received initial view:");
+            newView.forEach(System.out::println);
+        } else {
+
+            // Compare to last view
+            System.out.println("Received new view.");
+
+            List<Address> newMembers = View.newMembers(lastView, newView);
+            if (newMembers.size() > 0) {
+                System.out.println("New members: ");
+                newMembers.forEach(System.out::println);
+            }
+
+            List<Address> exMembers = View.leftMembers(lastView, newView);
+            if (exMembers.size() > 0) {
+                System.out.println("Exited members:");
+                exMembers.forEach(System.out::println);
+            }
+        }
+        lastView = newView;
+    }
+
+    /**
+     * Loop on console input until we see 'x' to exit
+     */
+    private void processInput() {
+
+        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
+        while (running) {
+            try {
+
+                // Get a destination, <enter> means broadcast
+                Address destination = null;
+                System.out.print("Enter a destination: ");
+                System.out.flush();
+                String destinationName = in.readLine().toLowerCase();
+
+                if (destinationName.equals("x")) {
+                    running = false;
+                    continue;
+                } else if (!destinationName.isEmpty()) {
+                    Optional<Address> optDestination = getAddress(destinationName);
+                    if (optDestination.isPresent()) {
+                        destination = optDestination.get();
+                    } else {
+                        System.out.println("Destination not found, try again.");
+                        continue;
+                    }
+                }
+
+                // Accept a string to send
+                System.out.print("Enter a message: ");
+                System.out.flush();
+                String line = in.readLine().toLowerCase();
+                sendMessage(destination, line);
+            } catch (IOException ioe) {
+                running = false;
+            }
+        }
+        System.out.println("Exiting.");
+    }
+
+    /**
+     * Send message from here
+     * @param destination the destination
+     * @param messageString the message
+     */
+    private void sendMessage(Address destination, String messageString) {
+        try {
+            System.out.println("Sending " + messageString + " to " + destination);
+            Message message = new Message(destination, messageString);
+            channel.send(message);
+        } catch (Exception exception) {
+            System.err.println("Exception sending message: " + exception.getMessage());
+            running = false;
+        }
+    }
+
+    @Override
+    public void receive(Message message) {
+        // Print source and dest with message
+        String line = "Message received from: " + message.getSrc() + " to: " + message.getDest() + " -> " + message.getObject();
+
+        // Only track the count of broadcast messages
+        // Tracking direct message would make for a pointless state
+        if (message.getDest() == null) {
+            messageCount++;
+            System.out.println("Message count: " + messageCount);
+        }
+
+        System.out.println(line);
+    }
+
+    @Override
+    public void getState(OutputStream output) throws Exception {
+        // Serialize into the stream
+        Util.objectToStream(messageCount, new DataOutputStream(output));
+    }
+
+    @Override
+    public void setState(InputStream input) {
+
+        // NOTE: since we know that incrementing the count and transferring the state
+        // is done inside the JChannel's thread, we don't have to worry about synchronizing
+        // messageCount. For production code it should be synchronized!
+        try {
+            // Deserialize
+            messageCount = Util.objectFromStream(new DataInputStream(input));
+        } catch (Exception e) {
+            System.out.println("Error deserialing state!");
+        }
+        System.out.println(messageCount + " is the current messagecount.");
+    }
+
+
+    private Optional<Address> getAddress(String name) {
+        View view = channel.view();
+        return view.getMembers().stream().filter(address -> name.equals(address.toString())).findFirst();
+    }
+
+}
+
+
--- a/jgroups/src/main/resources/udp.xml
+++ b/jgroups/src/main/resources/udp.xml
@ -0,0 +1,48 @@
+<config xmlns="urn:org:jgroups"
+        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+        xsi:schemaLocation="urn:org:jgroups http://www.jgroups.org/schema/jgroups.xsd">
+    <UDP
+         mcast_port="${jgroups.udp.mcast_port:45588}"
+         ip_ttl="4"
+         tos="8"
+         ucast_recv_buf_size="5M"
+         ucast_send_buf_size="5M"
+         mcast_recv_buf_size="5M"
+         mcast_send_buf_size="5M"
+         max_bundle_size="64K"
+         enable_diagnostics="true"
+         thread_naming_pattern="cl"
+
+         thread_pool.min_threads="0"
+         thread_pool.max_threads="20"
+         thread_pool.keep_alive_time="30000"/>
+
+    <PING />
+    <MERGE3 max_interval="30000"
+            min_interval="10000"/>
+    <FD_SOCK/>
+    <FD_ALL/>
+    <VERIFY_SUSPECT timeout="1500"  />
+    <BARRIER />
+    <pbcast.NAKACK2 xmit_interval="500"
+                    xmit_table_num_rows="100"
+                    xmit_table_msgs_per_row="2000"
+                    xmit_table_max_compaction_time="30000"
+                    use_mcast_xmit="false"
+                    discard_delivered_msgs="true"/>
+    <UNICAST3 xmit_interval="500"
+              xmit_table_num_rows="100"
+              xmit_table_msgs_per_row="2000"
+              xmit_table_max_compaction_time="60000"
+              conn_expiry_timeout="0"/>
+    <pbcast.STABLE desired_avg_gossip="50000"
+                   max_bytes="4M"/>
+    <pbcast.GMS print_local_addr="true" join_timeout="2000"/>
+    <UFC max_credits="2M"
+         min_threshold="0.4"/>
+    <MFC max_credits="2M"
+         min_threshold="0.4"/>
+    <FRAG2 frag_size="60K"  />
+    <RSVP resend_interval="2000" timeout="10000"/>
+    <pbcast.STATE_TRANSFER />
+</config>
--- a/json/pom.xml
+++ b/json/pom.xml
@ -31,6 +31,11 @@
            <version>${fastjson.version}</version>
        </dependency>

+        <dependency>
+            <groupId>org.json</groupId>
+            <artifactId>json</artifactId>
+            <version>20171018</version>
+        </dependency>
    </dependencies>

    <properties>
--- a/json/src/main/java/com/baeldung/jsonjava/CDLDemo.java
+++ b/json/src/main/java/com/baeldung/jsonjava/CDLDemo.java
@ -0,0 +1,59 @@
+package com.baeldung.jsonjava;
+
+import org.json.CDL;
+import org.json.JSONArray;
+import org.json.JSONTokener;
+
+public class CDLDemo {
+    public static void main(String[] args) {
+        System.out.println("7.1. Producing JSONArray Directly from Comma Delimited Text: ");
+        jsonArrayFromCDT();
+        
+        System.out.println("\n7.2. Producing Comma Delimited Text from JSONArray: ");
+        cDTfromJSONArray();
+        
+        System.out.println("\n7.3.1. Producing JSONArray of JSONObjects Using Comma Delimited Text: ");
+        jaOfJOFromCDT2();
+        
+        System.out.println("\n7.3.2. Producing JSONArray of JSONObjects Using Comma Delimited Text: ");
+        jaOfJOFromCDT2();
+    }
+    
+    public static void jsonArrayFromCDT() {
+        JSONArray ja = CDL.rowToJSONArray(new JSONTokener("England, USA, Canada"));
+        System.out.println(ja);
+    }
+    
+    public static void cDTfromJSONArray() {
+        JSONArray ja = new JSONArray("[\"England\",\"USA\",\"Canada\"]");
+        String cdt = CDL.rowToString(ja);
+        System.out.println(cdt);
+    }
+    
+    public static void jaOfJOFromCDT() {
+        String string = 
+          "name, city, age \n" +
+          "john, chicago, 22 \n" +
+          "gary, florida, 35 \n" +
+          "sal, vegas, 18";
+         
+        JSONArray result = CDL.toJSONArray(string);
+        System.out.println(result.toString());
+    }
+    
+    public static void jaOfJOFromCDT2() {
+        JSONArray ja = new JSONArray();
+        ja.put("name");
+        ja.put("city");
+        ja.put("age");
+         
+        String string = 
+          "john, chicago, 22 \n" +
+          "gary, florida, 35 \n" +
+          "sal, vegas, 18";
+         
+        JSONArray result = CDL.toJSONArray(ja, string);
+        System.out.println(result.toString());
+    }
+    
+}
--- a/json/src/main/java/com/baeldung/jsonjava/CookieDemo.java
+++ b/json/src/main/java/com/baeldung/jsonjava/CookieDemo.java
@ -0,0 +1,30 @@
+package com.baeldung.jsonjava;
+
+import org.json.Cookie;
+import org.json.JSONObject;
+
+public class CookieDemo {
+    public static void main(String[] args) {
+        System.out.println("8.1. Converting a Cookie String into a JSONObject");
+        cookieStringToJSONObject();
+        
+        System.out.println("\n8.2. Converting a JSONObject into Cookie String");
+        jSONObjectToCookieString();
+    }
+    
+    public static void cookieStringToJSONObject() {
+        String cookie = "username=John Doe; expires=Thu, 18 Dec 2013 12:00:00 UTC; path=/";
+        JSONObject cookieJO = Cookie.toJSONObject(cookie);
+        System.out.println(cookieJO);
+    }
+    
+    public static void jSONObjectToCookieString() {
+        JSONObject cookieJO = new JSONObject();
+        cookieJO.put("name", "username");
+        cookieJO.put("value", "John Doe");
+        cookieJO.put("expires", "Thu, 18 Dec 2013 12:00:00 UTC");
+        cookieJO.put("path", "/");
+        String cookie = Cookie.toString(cookieJO);
+        System.out.println(cookie);
+    }
+}
--- a/json/src/main/java/com/baeldung/jsonjava/DemoBean.java
+++ b/json/src/main/java/com/baeldung/jsonjava/DemoBean.java
@ -0,0 +1,26 @@
+package com.baeldung.jsonjava;
+
+public class DemoBean {
+    private int id;
+    private String name;
+    private boolean active;
+    
+    public int getId() {
+        return id;
+    }
+    public void setId(int id) {
+        this.id = id;
+    }
+    public String getName() {
+        return name;
+    }
+    public void setName(String name) {
+        this.name = name;
+    }
+    public boolean isActive() {
+        return active;
+    }
+    public void setActive(boolean active) {
+        this.active = active;
+    }
+}
--- a/json/src/main/java/com/baeldung/jsonjava/HTTPDemo.java
+++ b/json/src/main/java/com/baeldung/jsonjava/HTTPDemo.java
@ -0,0 +1,27 @@
+package com.baeldung.jsonjava;
+
+import org.json.HTTP;
+import org.json.JSONObject;
+
+public class HTTPDemo {
+    public static void main(String[] args) {
+        System.out.println("9.1. Converting JSONObject to HTTP Header: ");
+        jSONObjectToHTTPHeader();
+        
+        System.out.println("\n9.2. Converting HTTP Header String Back to JSONObject: ");
+        hTTPHeaderToJSONObject();
+    }
+    
+    public static void jSONObjectToHTTPHeader() {
+        JSONObject jo = new JSONObject();
+        jo.put("Method", "POST");
+        jo.put("Request-URI", "http://www.example.com/");
+        jo.put("HTTP-Version", "HTTP/1.1");
+        System.out.println(HTTP.toString(jo));
+    }
+    
+    public static void hTTPHeaderToJSONObject() {
+        JSONObject obj = HTTP.toJSONObject("POST \"http://www.example.com/\" HTTP/1.1");
+        System.out.println(obj);
+    }
+}
--- a/json/src/main/java/com/baeldung/jsonjava/JSONArrayDemo.java
+++ b/json/src/main/java/com/baeldung/jsonjava/JSONArrayDemo.java
@ -0,0 +1,52 @@
+package com.baeldung.jsonjava;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.json.JSONArray;
+import org.json.JSONObject;
+
+public class JSONArrayDemo {
+    public static void main(String[] args) {
+        System.out.println("5.1. Creating JSON Array: ");
+        creatingJSONArray();
+        
+        System.out.println("\n5.2. Creating JSON Array from JSON string: ");
+        jsonArrayFromJSONString();
+        
+        System.out.println("\n5.3. Creating JSON Array from Collection Object: ");
+        jsonArrayFromCollectionObj();
+    }
+    
+    public static void creatingJSONArray() {
+        JSONArray ja = new JSONArray();
+        ja.put(Boolean.TRUE);
+        ja.put("lorem ipsum");
+         
+        // We can also put a JSONObject in JSONArray
+        JSONObject jo = new JSONObject();
+        jo.put("name", "jon doe");
+        jo.put("age", "22");
+        jo.put("city", "chicago");
+         
+        ja.put(jo);
+         
+        System.out.println(ja.toString());
+    }
+    
+    public static void jsonArrayFromJSONString() {
+        JSONArray ja = new JSONArray("[true, \"lorem ipsum\", 215]");
+        System.out.println(ja);
+    }
+    
+    public static void jsonArrayFromCollectionObj() {
+        List<String> list = new ArrayList<>();
+        list.add("California");
+        list.add("Texas");
+        list.add("Hawaii");
+        list.add("Alaska");
+         
+        JSONArray ja = new JSONArray(list);
+        System.out.println(ja);
+    }
+}
--- a/json/src/main/java/com/baeldung/jsonjava/JSONObjectDemo.java
+++ b/json/src/main/java/com/baeldung/jsonjava/JSONObjectDemo.java
@ -0,0 +1,59 @@
+package com.baeldung.jsonjava;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import org.json.JSONObject;
+
+public class JSONObjectDemo {
+    public static void main(String[] args) {
+        System.out.println("4.1. Creating JSONObject: ");
+        jsonFromJSONObject();
+        
+        System.out.println("\n4.2. Creating JSONObject from Map: ");
+        jsonFromMap();
+        
+        System.out.println("\n4.3. Creating JSONObject from JSON string: ");
+        jsonFromJSONString();
+        
+        System.out.println("\n4.4. Creating JSONObject from Java Bean: ");
+        jsonFromDemoBean();
+    }
+    
+    public static void jsonFromJSONObject() {
+        JSONObject jo = new JSONObject();
+        jo.put("name", "jon doe");
+        jo.put("age", "22");
+        jo.put("city", "chicago");
+             
+        System.out.println(jo.toString());
+    }
+    
+    public static void jsonFromMap() {
+        Map<String, String> map = new HashMap<>();
+        map.put("name", "jon doe");
+        map.put("age", "22");
+        map.put("city", "chicago");
+        JSONObject jo = new JSONObject(map);
+         
+        System.out.println(jo.toString());
+    }
+    
+    public static void jsonFromJSONString() {
+        JSONObject jo = new JSONObject(
+          "{\"city\":\"chicago\",\"name\":\"jon doe\",\"age\":\"22\"}"
+        );
+        
+        System.out.println(jo.toString());
+    }
+    
+    public static void jsonFromDemoBean() {
+        DemoBean demo = new DemoBean();
+        demo.setId(1);
+        demo.setName("lorem ipsum");
+        demo.setActive(true);
+         
+        JSONObject jo = new JSONObject(demo);
+        System.out.println(jo);
+    }
+}
--- a/json/src/main/java/com/baeldung/jsonjava/JSONTokenerDemo.java
+++ b/json/src/main/java/com/baeldung/jsonjava/JSONTokenerDemo.java
@ -0,0 +1,13 @@
+package com.baeldung.jsonjava;
+
+import org.json.JSONTokener;
+
+public class JSONTokenerDemo {
+    public static void main(String[] args) {
+        JSONTokener jt = new JSONTokener("Sample String");
+         
+        while(jt.more()) {
+            System.out.println(jt.next());
+        }
+    }
+}
--- a/json/src/test/java/com/baeldung/jsonjava/CDLIntegrationTest.java
+++ b/json/src/test/java/com/baeldung/jsonjava/CDLIntegrationTest.java
@ -0,0 +1,52 @@
+package com.baeldung.jsonjava;
+
+import static org.junit.Assert.assertEquals;
+
+import org.json.CDL;
+import org.json.JSONArray;
+import org.json.JSONTokener;
+import org.junit.Test;
+
+public class CDLIntegrationTest {
+    @Test
+    public void givenCommaDelimitedText_thenConvertToJSONArray() {
+        JSONArray ja = CDL.rowToJSONArray(new JSONTokener("England, USA, Canada"));
+        assertEquals("[\"England\",\"USA\",\"Canada\"]", ja.toString());
+    }
+
+    @Test
+    public void givenJSONArray_thenConvertToCommaDelimitedText() {
+        JSONArray ja = new JSONArray("[\"England\",\"USA\",\"Canada\"]");
+        String cdt = CDL.rowToString(ja);
+        assertEquals("England,USA,Canada", cdt.toString().trim());
+    }
+
+    @Test
+    public void givenCommaDelimitedText_thenGetJSONArrayOfJSONObjects() {
+        String string = 
+          "name, city, age \n" +
+          "john, chicago, 22 \n" +
+          "gary, florida, 35 \n" +
+          "sal, vegas, 18";
+         
+        JSONArray result = CDL.toJSONArray(string);
+        assertEquals("[{\"name\":\"john\",\"city\":\"chicago\",\"age\":\"22\"},{\"name\":\"gary\",\"city\":\"florida\",\"age\":\"35\"},{\"name\":\"sal\",\"city\":\"vegas\",\"age\":\"18\"}]", result.toString());
+    }
+
+    @Test
+    public void givenCommaDelimitedText_thenGetJSONArrayOfJSONObjects2() {
+        JSONArray ja = new JSONArray();
+        ja.put("name");
+        ja.put("city");
+        ja.put("age");
+         
+        String string = 
+          "john, chicago, 22 \n" +
+          "gary, florida, 35 \n" +
+          "sal, vegas, 18";
+         
+        JSONArray result = CDL.toJSONArray(ja, string);
+        assertEquals("[{\"name\":\"john\",\"city\":\"chicago\",\"age\":\"22\"},{\"name\":\"gary\",\"city\":\"florida\",\"age\":\"35\"},{\"name\":\"sal\",\"city\":\"vegas\",\"age\":\"18\"}]", result.toString());
+    }
+    
+}
--- a/json/src/test/java/com/baeldung/jsonjava/CookieIntegrationTest.java
+++ b/json/src/test/java/com/baeldung/jsonjava/CookieIntegrationTest.java
@ -0,0 +1,29 @@
+package com.baeldung.jsonjava;
+
+import static org.junit.Assert.assertEquals;
+
+import org.json.Cookie;
+import org.json.JSONObject;
+import org.junit.Test;
+
+public class CookieIntegrationTest {
+    @Test
+    public void givenCookieString_thenConvertToJSONObject() {
+        String cookie = "username=John Doe; expires=Thu, 18 Dec 2013 12:00:00 UTC; path=/";
+        JSONObject cookieJO = Cookie.toJSONObject(cookie);
+
+        assertEquals("{\"path\":\"/\",\"expires\":\"Thu, 18 Dec 2013 12:00:00 UTC\",\"name\":\"username\",\"value\":\"John Doe\"}", cookieJO.toString());
+    }
+    
+    @Test
+    public void givenJSONObject_thenConvertToCookieString() {
+        JSONObject cookieJO = new JSONObject();
+        cookieJO.put("name", "username");
+        cookieJO.put("value", "John Doe");
+        cookieJO.put("expires", "Thu, 18 Dec 2013 12:00:00 UTC");
+        cookieJO.put("path", "/");
+        String cookie = Cookie.toString(cookieJO);
+
+        assertEquals("username=John Doe;expires=Thu, 18 Dec 2013 12:00:00 UTC;path=/", cookie.toString());
+    }
+}
--- a/json/src/test/java/com/baeldung/jsonjava/HTTPIntegrationTest.java
+++ b/json/src/test/java/com/baeldung/jsonjava/HTTPIntegrationTest.java
@ -0,0 +1,25 @@
+package com.baeldung.jsonjava;
+
+import static org.junit.Assert.assertEquals;
+import org.json.HTTP;
+import org.json.JSONObject;
+import org.junit.Test;
+
+public class HTTPIntegrationTest {
+    @Test
+    public void givenJSONObject_thenConvertToHTTPHeader() {
+        JSONObject jo = new JSONObject();
+        jo.put("Method", "POST");
+        jo.put("Request-URI", "http://www.example.com/");
+        jo.put("HTTP-Version", "HTTP/1.1");
+        
+        assertEquals("POST \"http://www.example.com/\" HTTP/1.1"+HTTP.CRLF+HTTP.CRLF, HTTP.toString(jo));
+    }
+
+    @Test
+    public void givenHTTPHeader_thenConvertToJSONObject() {
+        JSONObject obj = HTTP.toJSONObject("POST \"http://www.example.com/\" HTTP/1.1");
+        
+        assertEquals("{\"Request-URI\":\"http://www.example.com/\",\"Method\":\"POST\",\"HTTP-Version\":\"HTTP/1.1\"}", obj.toString());
+    }
+}
--- a/json/src/test/java/com/baeldung/jsonjava/JSONArrayIntegrationTest.java
+++ b/json/src/test/java/com/baeldung/jsonjava/JSONArrayIntegrationTest.java
@ -0,0 +1,47 @@
+package com.baeldung.jsonjava;
+
+import static org.junit.Assert.assertEquals;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.json.JSONArray;
+import org.json.JSONObject;
+import org.junit.Test;
+
+public class JSONArrayIntegrationTest {
+    @Test
+    public void givenJSONJava_thenCreateNewJSONArrayFromScratch() {
+        JSONArray ja = new JSONArray();
+        ja.put(Boolean.TRUE);
+        ja.put("lorem ipsum");
+         
+        // We can also put a JSONObject in JSONArray
+        JSONObject jo = new JSONObject();
+        jo.put("name", "jon doe");
+        jo.put("age", "22");
+        jo.put("city", "chicago");
+         
+        ja.put(jo);
+         
+        assertEquals("[true,\"lorem ipsum\",{\"city\":\"chicago\",\"name\":\"jon doe\",\"age\":\"22\"}]", ja.toString());
+    }
+    
+    @Test
+    public void givenJsonString_thenCreateNewJSONArray() {
+        JSONArray ja = new JSONArray("[true, \"lorem ipsum\", 215]");
+        assertEquals("[true,\"lorem ipsum\",215]", ja.toString());
+    }
+
+    @Test
+    public void givenListObject_thenConvertItToJSONArray() {
+        List<String> list = new ArrayList<>();
+        list.add("California");
+        list.add("Texas");
+        list.add("Hawaii");
+        list.add("Alaska");
+         
+        JSONArray ja = new JSONArray(list);
+        assertEquals("[\"California\",\"Texas\",\"Hawaii\",\"Alaska\"]", ja.toString());
+    }
+}
--- a/json/src/test/java/com/baeldung/jsonjava/JSONObjectIntegrationTest.java
+++ b/json/src/test/java/com/baeldung/jsonjava/JSONObjectIntegrationTest.java
@ -0,0 +1,53 @@
+package com.baeldung.jsonjava;
+
+import static org.junit.Assert.assertEquals;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import org.json.JSONObject;
+import org.junit.Test;
+
+public class JSONObjectIntegrationTest {
+    @Test
+    public void givenJSONJava_thenCreateNewJSONObject() {
+        JSONObject jo = new JSONObject();
+        jo.put("name", "jon doe");
+        jo.put("age", "22");
+        jo.put("city", "chicago");
+             
+        assertEquals("{\"city\":\"chicago\",\"name\":\"jon doe\",\"age\":\"22\"}", jo.toString());
+        
+    }
+
+    @Test
+    public void givenMapObject_thenCreateJSONObject() {
+        Map<String, String> map = new HashMap<>();
+        map.put("name", "jon doe");
+        map.put("age", "22");
+        map.put("city", "chicago");
+        JSONObject jo = new JSONObject(map);
+         
+        assertEquals("{\"name\":\"jon doe\",\"city\":\"chicago\",\"age\":\"22\"}", jo.toString());
+    }
+
+    @Test
+    public void givenJsonString_thenCreateJSONObject() {
+        JSONObject jo = new JSONObject(
+          "{\"city\":\"chicago\",\"name\":\"jon doe\",\"age\":\"22\"}"
+        );
+        
+        assertEquals("{\"city\":\"chicago\",\"name\":\"jon doe\",\"age\":\"22\"}", jo.toString());
+    }
+
+    @Test
+    public void givenDemoBean_thenCreateJSONObject() {
+        DemoBean demo = new DemoBean();
+        demo.setId(1);
+        demo.setName("lorem ipsum");
+        demo.setActive(true);
+         
+        JSONObject jo = new JSONObject(demo);
+        assertEquals("{\"name\":\"lorem ipsum\",\"active\":true,\"id\":1}", jo.toString());
+    }
+}
--- a/json/src/test/java/com/baeldung/jsonjava/JSONTokenerIntegrationTest.java
+++ b/json/src/test/java/com/baeldung/jsonjava/JSONTokenerIntegrationTest.java
@ -0,0 +1,21 @@
+package com.baeldung.jsonjava;
+
+import static org.junit.Assert.assertEquals;
+
+import org.json.JSONTokener;
+import org.junit.Test;
+
+public class JSONTokenerIntegrationTest {
+    @Test
+    public void givenString_convertItToJSONTokens() {
+        String str = "Sample String";
+        JSONTokener jt = new JSONTokener(str);
+        
+        char[] expectedTokens = str.toCharArray();
+        int index = 0;
+        
+        while(jt.more()) {
+            assertEquals(expectedTokens[index++], jt.next());
+        }
+    }
+}
--- a/libraries/README.md
+++ b/libraries/README.md
@ -59,6 +59,7 @@
 - [Intro to JDO Queries 2/2](http://www.baeldung.com/jdo-queries)
 - [Guide to google-http-client](http://www.baeldung.com/google-http-client)
 - [Interact with Google Sheets from Java](http://www.baeldung.com/google-sheets-java-client)
+- [Programatically Create, Configure, and Run a Tomcat Server] (http://www.baeldung.com/tomcat-programmatic-setup)



--- a/libraries/pom.xml
+++ b/libraries/pom.xml
@ -116,6 +116,12 @@
        </plugins>
    </build>
    <dependencies>
+    	<!-- https://mvnrepository.com/artifact/org.asynchttpclient/async-http-client -->
+        <dependency>
+            <groupId>org.asynchttpclient</groupId>
+            <artifactId>async-http-client</artifactId>
+            <version>${async.http.client.version}</version>
+        </dependency>
        <!-- https://mvnrepository.com/artifact/org.beykery/neuroph/2.92 -->
        <dependency>
            <groupId>org.beykery</groupId>
@ -194,6 +200,11 @@
            <artifactId>jetty-servlet</artifactId>
            <version>${jetty.version}</version>
        </dependency>
+		<dependency>
+		    <groupId>org.eclipse.jetty</groupId>
+		    <artifactId>jetty-webapp</artifactId>
+		   	 <version>${jetty.version}</version>
+		</dependency>
        <dependency>
            <groupId>rome</groupId>
            <artifactId>rome</artifactId>
@ -705,6 +716,18 @@
            <classifier>test</classifier>
            <scope>test</scope>
        </dependency>
+
+        <!-- tomcat -->
+        <dependency>
+            <groupId>org.apache.tomcat</groupId>
+            <artifactId>tomcat-catalina</artifactId>
+            <version>${tomcat.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.milyn</groupId>
+            <artifactId>milyn-smooks-all</artifactId>
+            <version>${smooks.version}</version>
+        </dependency>
    </dependencies>
    <repositories>
        <repository>
@ -741,12 +764,11 @@
        <assertj.version>3.6.2</assertj.version>
        <jsonassert.version>1.5.0</jsonassert.version>
        <javers.version>3.1.0</javers.version>
-        <jetty.version>9.4.3.v20170317</jetty.version>
        <httpclient.version>4.5.3</httpclient.version>
        <commons.io.version>2.5</commons.io.version>
        <commons.dbutils.version>1.6</commons.dbutils.version>
        <h2.version>1.4.196</h2.version>
-        <jetty.version>9.4.2.v20170220</jetty.version>
+        <jetty.version>9.4.8.v20171121</jetty.version>
        <httpclient.version>4.5.3</httpclient.version>
        <commons.io.version>2.5</commons.io.version>
        <flink.version>1.2.0</flink.version>
@ -757,7 +779,7 @@
        <serenity.jira.version>1.1.3-rc.5</serenity.jira.version>
        <serenity.plugin.version>1.4.0</serenity.plugin.version>
        <jUnitParams.version>1.1.0</jUnitParams.version>
-        <netty.version>4.1.15.Final</netty.version>
+        <netty.version>4.1.20.Final</netty.version>
        <commons.collections.version>4.1</commons.collections.version>
        <junit.version>4.12</junit.version>
        <java-lsh.version>0.10</java-lsh.version>
@ -785,6 +807,9 @@
        <google-api.version>1.23.0</google-api.version>
        <google-sheets.version>v4-rev493-1.21.0</google-sheets.version>
        <kafka.version>1.0.0</kafka.version>
+        <smooks.version>1.7.0</smooks.version>
        <docker.version>3.0.14</docker.version>
+        <tomcat.version>8.5.24</tomcat.version>
+        <async.http.client.version>2.2.0</async.http.client.version>
    </properties>
 </project>
--- a/libraries/src/main/java/com/baeldung/jetty/JettyServerFactory.java
+++ b/libraries/src/main/java/com/baeldung/jetty/JettyServerFactory.java
@ -0,0 +1,94 @@
+package com.baeldung.jetty;
+
+import org.eclipse.jetty.server.Handler;
+import org.eclipse.jetty.server.Server;
+import org.eclipse.jetty.server.ServerConnector;
+import org.eclipse.jetty.server.handler.HandlerCollection;
+import org.eclipse.jetty.webapp.WebAppContext;
+
+/**
+ * Simple factory for creating Jetty basic instances.
+ * 
+ * @author Donato Rimenti
+ *
+ */
+public class JettyServerFactory {
+
+	/**
+	 * Exposed context of the app.
+	 */
+	public final static String APP_PATH = "/myApp";
+	
+	/**
+	 * The server port.
+	 */
+	public final static int SERVER_PORT = 13133;
+
+	/**
+	 * Private constructor to avoid instantiation.
+	 */
+	private JettyServerFactory() {
+	}
+
+	/**
+	 * Returns a simple server listening on port 80 with a timeout of 30 seconds
+	 * for connections and no handlers.
+	 * 
+	 * @return a server
+	 */
+	public static Server createBaseServer() {
+		Server server = new Server();
+
+		// Adds a connector for port 80 with a timeout of 30 seconds.
+		ServerConnector connector = new ServerConnector(server);
+		connector.setPort(SERVER_PORT);
+		connector.setHost("127.0.0.1");
+		connector.setIdleTimeout(30000);
+		server.addConnector(connector);
+
+		return server;
+	}
+
+	/**
+	 * Creates a server which delegates the request handling to a web
+	 * application.
+	 * 
+	 * @return a server
+	 */
+	public static Server createWebAppServer() {
+		// Adds an handler to a server and returns it.
+		Server server = createBaseServer();
+		String webAppFolderPath = JettyServerFactory.class.getClassLoader().getResource("jetty-embedded-demo-app.war")
+				.getPath();
+		Handler webAppHandler = new WebAppContext(webAppFolderPath, APP_PATH);
+		server.setHandler(webAppHandler);
+
+		return server;
+	}
+
+	/**
+	 * Creates a server which delegates the request handling to both a logging
+	 * handler and to a web application, in this order.
+	 * 
+	 * @return a server
+	 */
+	public static Server createMultiHandlerServer() {
+		Server server = createBaseServer();
+
+		// Creates the handlers and adds them to the server.
+		HandlerCollection handlers = new HandlerCollection();
+
+		String webAppFolderPath = JettyServerFactory.class.getClassLoader().getResource("jetty-embedded-demo-app.war")
+				.getPath();
+		Handler customRequestHandler = new WebAppContext(webAppFolderPath, APP_PATH);
+		handlers.addHandler(customRequestHandler);
+
+		Handler loggingRequestHandler = new LoggingRequestHandler();
+		handlers.addHandler(loggingRequestHandler);
+
+		server.setHandler(handlers);
+
+		return server;
+	}
+
+}
--- a/libraries/src/main/java/com/baeldung/jetty/LoggingRequestHandler.java
+++ b/libraries/src/main/java/com/baeldung/jetty/LoggingRequestHandler.java
@ -0,0 +1,168 @@
+package com.baeldung.jetty;
+
+import java.io.IOException;
+
+import javax.servlet.ServletException;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+import org.eclipse.jetty.server.Handler;
+import org.eclipse.jetty.server.Request;
+import org.eclipse.jetty.server.Server;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * Handler implementation which simply logs that a request has been received.
+ * 
+ * @author Donato Rimenti
+ */
+public class LoggingRequestHandler implements Handler {
+
+	/**
+	 * Logger.
+	 */
+	private final static Logger LOG = LoggerFactory.getLogger(LoggingRequestHandler.class);
+
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see org.eclipse.jetty.util.component.LifeCycle#addLifeCycleListener(org.
+	 * eclipse.jetty.util.component.LifeCycle.Listener)
+	 */
+	@Override
+	public void addLifeCycleListener(Listener arg0) {
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see org.eclipse.jetty.util.component.LifeCycle#isFailed()
+	 */
+	@Override
+	public boolean isFailed() {
+		return false;
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see org.eclipse.jetty.util.component.LifeCycle#isRunning()
+	 */
+	@Override
+	public boolean isRunning() {
+		return true;
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see org.eclipse.jetty.util.component.LifeCycle#isStarted()
+	 */
+	@Override
+	public boolean isStarted() {
+		return true;
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see org.eclipse.jetty.util.component.LifeCycle#isStarting()
+	 */
+	@Override
+	public boolean isStarting() {
+		return false;
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see org.eclipse.jetty.util.component.LifeCycle#isStopped()
+	 */
+	@Override
+	public boolean isStopped() {
+		return false;
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see org.eclipse.jetty.util.component.LifeCycle#isStopping()
+	 */
+	@Override
+	public boolean isStopping() {
+		return false;
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see
+	 * org.eclipse.jetty.util.component.LifeCycle#removeLifeCycleListener(org.
+	 * eclipse.jetty.util.component.LifeCycle.Listener)
+	 */
+	@Override
+	public void removeLifeCycleListener(Listener arg0) {
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see org.eclipse.jetty.util.component.LifeCycle#start()
+	 */
+	@Override
+	public void start() throws Exception {
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see org.eclipse.jetty.util.component.LifeCycle#stop()
+	 */
+	@Override
+	public void stop() throws Exception {
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see org.eclipse.jetty.server.Handler#destroy()
+	 */
+	@Override
+	public void destroy() {
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see org.eclipse.jetty.server.Handler#getServer()
+	 */
+	@Override
+	public Server getServer() {
+		return null;
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see org.eclipse.jetty.server.Handler#handle(java.lang.String,
+	 * org.eclipse.jetty.server.Request, javax.servlet.http.HttpServletRequest,
+	 * javax.servlet.http.HttpServletResponse)
+	 */
+	@Override
+	public void handle(String arg0, Request arg1, HttpServletRequest arg2, HttpServletResponse arg3)
+			throws IOException, ServletException {
+		LOG.info("Received a new request");
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see org.eclipse.jetty.server.Handler#setServer(org.eclipse.jetty.server.
+	 * Server)
+	 */
+	@Override
+	public void setServer(Server server) {
+	}
+
+}
--- a/libraries/src/main/java/com/baeldung/smooks/converter/OrderConverter.java
+++ b/libraries/src/main/java/com/baeldung/smooks/converter/OrderConverter.java
@ -0,0 +1,45 @@
+package com.baeldung.smooks.converter;
+
+import com.baeldung.smooks.model.Order;
+import org.milyn.Smooks;
+import org.milyn.payload.JavaResult;
+import org.milyn.payload.StringResult;
+import org.xml.sax.SAXException;
+
+import javax.xml.transform.stream.StreamSource;
+import java.io.IOException;
+
+public class OrderConverter {
+
+    public Order convertOrderXMLToOrderObject(String path) throws IOException, SAXException {
+        Smooks smooks = new Smooks(OrderConverter.class.getResourceAsStream("/smooks/smooks-mapping.xml"));
+        try {
+            JavaResult javaResult = new JavaResult();
+            smooks.filterSource(new StreamSource(OrderConverter.class.getResourceAsStream(path)), javaResult);
+            return (Order) javaResult.getBean("order");
+        } finally {
+            smooks.close();
+        }
+    }
+    
+
+    public String convertOrderXMLtoEDIFACT(String path) throws IOException, SAXException {
+        return convertDocumentWithTempalte(path, "/smooks/smooks-transform-edi.xml");
+    }
+
+    public String convertOrderXMLtoEmailMessage(String path) throws IOException, SAXException {
+        return convertDocumentWithTempalte(path, "/smooks/smooks-transform-email.xml");
+    }
+
+    private String convertDocumentWithTempalte(String path, String config) throws IOException, SAXException {
+        Smooks smooks = new Smooks(config);
+
+        try {
+            StringResult stringResult = new StringResult();
+            smooks.filterSource(new StreamSource(OrderConverter.class.getResourceAsStream(path)), stringResult);
+            return stringResult.toString();
+        } finally {
+            smooks.close();
+        }
+    }
+}
--- a/libraries/src/main/java/com/baeldung/smooks/converter/OrderValidator.java
+++ b/libraries/src/main/java/com/baeldung/smooks/converter/OrderValidator.java
@ -0,0 +1,27 @@
+package com.baeldung.smooks.converter;
+
+import org.milyn.Smooks;
+import org.milyn.payload.JavaResult;
+import org.milyn.payload.StringResult;
+import org.milyn.validation.ValidationResult;
+import org.xml.sax.SAXException;
+
+import javax.xml.transform.stream.StreamSource;
+import java.io.IOException;
+
+public class OrderValidator {
+
+    public ValidationResult validate(String path) throws IOException, SAXException {
+        Smooks smooks = new Smooks(OrderValidator.class.getResourceAsStream("/smooks/smooks-validation.xml"));
+
+        try {
+            StringResult xmlResult = new StringResult();
+            JavaResult javaResult = new JavaResult();
+            ValidationResult validationResult = new ValidationResult();
+            smooks.filterSource(new StreamSource(OrderValidator.class.getResourceAsStream(path)), xmlResult, javaResult, validationResult);
+            return validationResult;
+        } finally {
+            smooks.close();
+        }
+    }
+}
--- a/libraries/src/main/java/com/baeldung/smooks/model/Item.java
+++ b/libraries/src/main/java/com/baeldung/smooks/model/Item.java
@ -0,0 +1,71 @@
+package com.baeldung.smooks.model;
+
+public class Item {
+
+    public Item() {
+    }
+
+    public Item(String code, Double price, Integer quantity) {
+        this.code = code;
+        this.price = price;
+        this.quantity = quantity;
+    }
+
+    private String code;
+    private Double price;
+    private Integer quantity;
+
+
+    public String getCode() {
+        return code;
+    }
+
+    public void setCode(String code) {
+        this.code = code;
+    }
+
+    public Double getPrice() {
+        return price;
+    }
+
+    public void setPrice(Double price) {
+        this.price = price;
+    }
+
+    public Integer getQuantity() {
+        return quantity;
+    }
+
+    public void setQuantity(Integer quantity) {
+        this.quantity = quantity;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+
+        Item item = (Item) o;
+
+        if (code != null ? !code.equals(item.code) : item.code != null) return false;
+        if (price != null ? !price.equals(item.price) : item.price != null) return false;
+        return quantity != null ? quantity.equals(item.quantity) : item.quantity == null;
+    }
+
+    @Override
+    public int hashCode() {
+        int result = code != null ? code.hashCode() : 0;
+        result = 31 * result + (price != null ? price.hashCode() : 0);
+        result = 31 * result + (quantity != null ? quantity.hashCode() : 0);
+        return result;
+    }
+
+    @Override
+    public String toString() {
+        return "Item{" +
+                "code='" + code + '\'' +
+                ", price=" + price +
+                ", quantity=" + quantity +
+                '}';
+    }
+}
--- a/libraries/src/main/java/com/baeldung/smooks/model/Order.java
+++ b/libraries/src/main/java/com/baeldung/smooks/model/Order.java
@ -0,0 +1,52 @@
+package com.baeldung.smooks.model;
+
+import java.util.Date;
+import java.util.List;
+
+public class Order {
+    private Date creationDate;
+    private Long number;
+    private Status status;
+    private Supplier supplier;
+    private List<Item> items;
+
+    public Date getCreationDate() {
+        return creationDate;
+    }
+
+    public void setCreationDate(Date creationDate) {
+        this.creationDate = creationDate;
+    }
+
+    public Long getNumber() {
+        return number;
+    }
+
+    public void setNumber(Long number) {
+        this.number = number;
+    }
+
+    public Status getStatus() {
+        return status;
+    }
+
+    public void setStatus(Status status) {
+        this.status = status;
+    }
+
+    public Supplier getSupplier() {
+        return supplier;
+    }
+
+    public void setSupplier(Supplier supplier) {
+        this.supplier = supplier;
+    }
+
+    public List<Item> getItems() {
+        return items;
+    }
+
+    public void setItems(List<Item> items) {
+        this.items = items;
+    }
+}
--- a/libraries/src/main/java/com/baeldung/smooks/model/Status.java
+++ b/libraries/src/main/java/com/baeldung/smooks/model/Status.java
@ -0,0 +1,5 @@
+package com.baeldung.smooks.model;
+
+public enum Status {
+    NEW, IN_PROGRESS, FINISHED
+}
--- a/libraries/src/main/java/com/baeldung/smooks/model/Supplier.java
+++ b/libraries/src/main/java/com/baeldung/smooks/model/Supplier.java
@ -0,0 +1,49 @@
+package com.baeldung.smooks.model;
+
+public class Supplier {
+
+    private String name;
+    private String phoneNumber;
+
+    public Supplier() {
+    }
+
+    public Supplier(String name, String phoneNumber) {
+        this.name = name;
+        this.phoneNumber = phoneNumber;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public String getPhoneNumber() {
+        return phoneNumber;
+    }
+
+    public void setPhoneNumber(String phoneNumber) {
+        this.phoneNumber = phoneNumber;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+
+        Supplier supplier = (Supplier) o;
+
+        if (name != null ? !name.equals(supplier.name) : supplier.name != null) return false;
+        return phoneNumber != null ? phoneNumber.equals(supplier.phoneNumber) : supplier.phoneNumber == null;
+    }
+
+    @Override
+    public int hashCode() {
+        int result = name != null ? name.hashCode() : 0;
+        result = 31 * result + (phoneNumber != null ? phoneNumber.hashCode() : 0);
+        return result;
+    }
+}
--- a/libraries/src/main/java/com/baeldung/tomcat/MyFilter.java
+++ b/libraries/src/main/java/com/baeldung/tomcat/MyFilter.java
@ -0,0 +1,31 @@
+package com.baeldung.tomcat;
+
+import javax.servlet.*;
+import javax.servlet.annotation.WebFilter;
+import javax.servlet.http.HttpServletResponse;
+import java.io.IOException;
+
+/**
+ * Created by adi on 1/14/18.
+ */
+@WebFilter(urlPatterns = "/my-servlet/*")
+public class MyFilter implements Filter {
+
+    @Override
+    public void init(FilterConfig filterConfig) {
+
+    }
+
+    @Override
+    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
+        System.out.println("Filtering stuff...");
+        HttpServletResponse httpResponse = (HttpServletResponse) response;
+        httpResponse.addHeader("myHeader", "myHeaderValue");
+        chain.doFilter(request, httpResponse);
+    }
+
+    @Override
+    public void destroy() {
+
+    }
+}
--- a/libraries/src/main/java/com/baeldung/tomcat/MyServlet.java
+++ b/libraries/src/main/java/com/baeldung/tomcat/MyServlet.java
@ -0,0 +1,25 @@
+package com.baeldung.tomcat;
+
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import java.io.IOException;
+
+/**
+ * Created by adi on 1/10/18.
+ */
+@WebServlet(
+  name = "com.baeldung.tomcat.programmatic.MyServlet",
+  urlPatterns = {"/my-servlet"}
+)
+public class MyServlet extends HttpServlet {
+
+    @Override
+    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws IOException {
+        resp.setStatus(HttpServletResponse.SC_OK);
+        resp.getWriter().write("test");
+        resp.getWriter().flush();
+        resp.getWriter().close();
+    }
+}
--- a/libraries/src/main/java/com/baeldung/tomcat/ProgrammaticTomcat.java
+++ b/libraries/src/main/java/com/baeldung/tomcat/ProgrammaticTomcat.java
@ -0,0 +1,63 @@
+package com.baeldung.tomcat;
+
+import org.apache.catalina.Context;
+import org.apache.catalina.LifecycleException;
+import org.apache.catalina.startup.Tomcat;
+import org.apache.tomcat.util.descriptor.web.FilterDef;
+import org.apache.tomcat.util.descriptor.web.FilterMap;
+
+import java.io.File;
+
+/**
+ * Created by adi on 1/10/18.
+ */
+public class ProgrammaticTomcat {
+
+    private Tomcat tomcat = null;
+
+    //uncomment for live test
+    //    public static void main(String[] args) throws LifecycleException, ServletException, URISyntaxException, IOException {
+    //        startTomcat();
+    //    }
+
+    public void startTomcat() throws LifecycleException {
+        tomcat = new Tomcat();
+        tomcat.setPort(8080);
+        tomcat.setHostname("localhost");
+        String appBase = ".";
+        tomcat
+          .getHost()
+          .setAppBase(appBase);
+
+        File docBase = new File(System.getProperty("java.io.tmpdir"));
+        Context context = tomcat.addContext("", docBase.getAbsolutePath());
+
+        //add a servlet
+        Class servletClass = MyServlet.class;
+        Tomcat.addServlet(context, servletClass.getSimpleName(), servletClass.getName());
+        context.addServletMappingDecoded("/my-servlet/*", servletClass.getSimpleName());
+
+        //add a filter and filterMapping
+        Class filterClass = MyFilter.class;
+        FilterDef myFilterDef = new FilterDef();
+        myFilterDef.setFilterClass(filterClass.getName());
+        myFilterDef.setFilterName(filterClass.getSimpleName());
+        context.addFilterDef(myFilterDef);
+
+        FilterMap myFilterMap = new FilterMap();
+        myFilterMap.setFilterName(filterClass.getSimpleName());
+        myFilterMap.addURLPattern("/my-servlet/*");
+        context.addFilterMap(myFilterMap);
+
+        tomcat.start();
+        //uncomment for live test
+        //        tomcat
+        //          .getServer()
+        //          .await();
+    }
+
+    public void stopTomcat() throws LifecycleException {
+        tomcat.stop();
+        tomcat.destroy();
+    }
+}
--- a/libraries/src/main/resources/smooks/email.ftl
+++ b/libraries/src/main/resources/smooks/email.ftl
@ -0,0 +1,8 @@
+<#setting locale="en_US">
+Hi,
+Order number #${order.number} created on ${order.creationDate?string["yyyy-MM-dd"]} is currently in ${order.status} status.
+Consider contact supplier "${supplier.name}"  with phone number: "${supplier.phoneNumber}".
+Order items:
+<#list items as item>
+${item.quantity}  X ${item.code} (total price ${item.price * item.quantity})
+</#list>
--- a/libraries/src/main/resources/smooks/item-rules.csv
+++ b/libraries/src/main/resources/smooks/item-rules.csv
@ -0,0 +1 @@
+"max_total","item.quantity * item.price < 300.00"
--- a/libraries/src/main/resources/smooks/order.ftl
+++ b/libraries/src/main/resources/smooks/order.ftl
@ -0,0 +1,7 @@
+<#setting locale="en_US">
+UNA:+.? '
+UNH+${order.number}+${order.status}+${order.creationDate?string["yyyy-MM-dd"]}'
+CTA+${supplier.name}+${supplier.phoneNumber}'
+<#list items as item>
+LIN+${item.quantity}+${item.code}+${item.price}'
+</#list>
--- a/libraries/src/main/resources/smooks/order.json
+++ b/libraries/src/main/resources/smooks/order.json
@ -0,0 +1,21 @@
+{
+  "creationDate":"2018-01-14",
+  "orderNumber":771,
+  "orderStatus":"IN_PROGRESS",
+  "supplier":{
+    "name":"CompanyX",
+    "phone":"1234567"
+  },
+  "orderItems":[
+    {
+      "quantity":1,
+      "code":"PX1234",
+      "price":9.99
+    },
+    {
+      "quantity":2,
+      "code":"RX1990",
+      "price":120.32
+    }
+  ]
+}
--- a/libraries/src/main/resources/smooks/order.xml
+++ b/libraries/src/main/resources/smooks/order.xml
@ -0,0 +1,20 @@
+<order creation-date="2018-01-14">
+    <order-number>771</order-number>
+    <order-status>IN_PROGRESS</order-status>
+    <supplier>
+        <name>CompanyX</name>
+        <phone>1234567</phone>
+    </supplier>
+    <order-items>
+        <item>
+            <quantity>1</quantity>
+            <code>PX1234</code>
+            <price>9.99</price>
+        </item>
+        <item>
+            <quantity>2</quantity>
+            <code>RX990</code>
+            <price>120.32</price>
+        </item>
+    </order-items>
+</order>
--- a/libraries/src/main/resources/smooks/smooks-mapping.xml
+++ b/libraries/src/main/resources/smooks/smooks-mapping.xml
@ -0,0 +1,29 @@
+<?xml version="1.0"?>
+<smooks-resource-list xmlns="http://www.milyn.org/xsd/smooks-1.1.xsd"
+                      xmlns:jb="http://www.milyn.org/xsd/smooks/javabean-1.2.xsd">
+
+    <jb:bean beanId="order" class="com.baeldung.smooks.model.Order" createOnElement="order">
+        <jb:value property="number" data="order/order-number" />
+        <jb:value property="status" data="order/order-status" />
+        <jb:value property="creationDate" data="order/@creation-date"  decoder="Date">
+            <jb:decodeParam name="format">yyyy-MM-dd</jb:decodeParam>
+        </jb:value>
+        <jb:wiring property="supplier" beanIdRef="supplier" />
+        <jb:wiring property="items" beanIdRef="items" />
+    </jb:bean>
+
+    <jb:bean beanId="supplier" class="com.baeldung.smooks.model.Supplier" createOnElement="supplier">
+        <jb:value property="name" data="name" />
+        <jb:value property="phoneNumber" data="phone" />
+    </jb:bean>
+
+    <jb:bean beanId="items" class="java.util.ArrayList" createOnElement="order">
+        <jb:wiring beanIdRef="item" />
+    </jb:bean>
+    <jb:bean beanId="item" class="com.baeldung.smooks.model.Item" createOnElement="item">
+        <jb:value property="code"  data="item/code" />
+        <jb:value property="price" decoder="Double" data="item/price" />
+        <jb:value property="quantity" decoder="Integer" data="item/quantity" />
+    </jb:bean>
+
+</smooks-resource-list>
--- a/libraries/src/main/resources/smooks/smooks-transform-edi.xml
+++ b/libraries/src/main/resources/smooks/smooks-transform-edi.xml
@ -0,0 +1,11 @@
+<?xml version="1.0"?>
+<smooks-resource-list xmlns="http://www.milyn.org/xsd/smooks-1.1.xsd"
+                      xmlns:ftl="http://www.milyn.org/xsd/smooks/freemarker-1.1.xsd">
+
+    <import file="smooks-validation.xml" />
+
+    <ftl:freemarker applyOnElement="#document">
+        <ftl:template>/smooks/order.ftl</ftl:template>
+    </ftl:freemarker>
+
+</smooks-resource-list>
--- a/libraries/src/main/resources/smooks/smooks-transform-email.xml
+++ b/libraries/src/main/resources/smooks/smooks-transform-email.xml
@ -0,0 +1,12 @@
+<?xml version="1.0"?>
+<smooks-resource-list xmlns="http://www.milyn.org/xsd/smooks-1.1.xsd"
+                      xmlns:ftl="http://www.milyn.org/xsd/smooks/freemarker-1.1.xsd">
+
+
+    <import file="smooks-validation.xml" />
+
+    <ftl:freemarker applyOnElement="#document">
+        <ftl:template>/smooks/email.ftl</ftl:template>
+    </ftl:freemarker>
+
+</smooks-resource-list>
--- a/libraries/src/main/resources/smooks/smooks-validation.xml
+++ b/libraries/src/main/resources/smooks/smooks-validation.xml
@ -0,0 +1,17 @@
+<?xml version="1.0"?>
+<smooks-resource-list xmlns="http://www.milyn.org/xsd/smooks-1.1.xsd"
+                      xmlns:rules="http://www.milyn.org/xsd/smooks/rules-1.0.xsd"
+                      xmlns:validation="http://www.milyn.org/xsd/smooks/validation-1.0.xsd">
+
+    <import file="/smooks/smooks-mapping.xml" />
+
+    <rules:ruleBases>
+        <rules:ruleBase name="supplierValidation" src="/smooks/supplier.properties" provider="org.milyn.rules.regex.RegexProvider"/>
+        <rules:ruleBase name="itemsValidation" src="/smooks/item-rules.csv" provider="org.milyn.rules.mvel.MVELProvider"/>
+    </rules:ruleBases>
+
+    <validation:rule executeOn="supplier/name" name="supplierValidation.supplierName" onFail="ERROR"/>
+    <validation:rule executeOn="supplier/phone" name="supplierValidation.supplierPhone" onFail="ERROR"/>
+    <validation:rule executeOn="order-items/item" name="itemsValidation.max_total" onFail="ERROR"/>
+
+</smooks-resource-list>
--- a/libraries/src/main/resources/smooks/supplier.properties
+++ b/libraries/src/main/resources/smooks/supplier.properties
@ -0,0 +1,2 @@
+supplierName=[A-Za-z0-9]*
+supplierPhone=^[0-9\\-\\+]{9,15}$
--- a/libraries/src/test/java/com/baeldung/asynchttpclient/AsyncHttpClientTestCase.java
+++ b/libraries/src/test/java/com/baeldung/asynchttpclient/AsyncHttpClientTestCase.java
@ -0,0 +1,209 @@
+package com.baeldung.asynchttpclient;
+
+import io.netty.handler.codec.http.HttpHeaders;
+import org.asynchttpclient.AsyncCompletionHandler;
+import org.asynchttpclient.AsyncHandler;
+import org.asynchttpclient.AsyncHttpClient;
+import org.asynchttpclient.AsyncHttpClientConfig;
+import org.asynchttpclient.BoundRequestBuilder;
+import org.asynchttpclient.Dsl;
+import org.asynchttpclient.HttpResponseBodyPart;
+import org.asynchttpclient.HttpResponseStatus;
+import org.asynchttpclient.ListenableFuture;
+import org.asynchttpclient.Request;
+import org.asynchttpclient.Response;
+import org.asynchttpclient.ws.WebSocket;
+import org.asynchttpclient.ws.WebSocketListener;
+import org.asynchttpclient.ws.WebSocketUpgradeHandler;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+
+public class AsyncHttpClientTestCase {
+
+    private static AsyncHttpClient HTTP_CLIENT;
+
+    @Before
+    public void setup() {
+        AsyncHttpClientConfig clientConfig = Dsl.config().setConnectTimeout(15000).setRequestTimeout(15000).build();
+        HTTP_CLIENT = Dsl.asyncHttpClient(clientConfig);
+    }
+
+    @Test
+    public void givenHttpClient_executeSyncGetRequest() {
+
+        BoundRequestBuilder boundGetRequest = HTTP_CLIENT.prepareGet("http://www.baeldung.com");
+
+        Future<Response> responseFuture = boundGetRequest.execute();
+        try {
+            Response response = responseFuture.get(5000, TimeUnit.MILLISECONDS);
+            assertNotNull(response);
+            assertEquals(200, response.getStatusCode());
+        } catch (InterruptedException | ExecutionException | TimeoutException e) {
+            e.printStackTrace();
+        }
+
+        try {
+            Thread.sleep(5000);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+    @Test
+    public void givenHttpClient_executeAsyncGetRequest() {
+
+        // execute an unbound GET request
+        Request unboundGetRequest = Dsl.get("http://www.baeldung.com").build();
+
+        HTTP_CLIENT.executeRequest(unboundGetRequest, new AsyncCompletionHandler<Integer>() {
+            @Override
+            public Integer onCompleted(Response response) {
+
+                int resposeStatusCode = response.getStatusCode();
+                assertEquals(200, resposeStatusCode);
+                return resposeStatusCode;
+            }
+        });
+
+        // execute a bound GET request
+        BoundRequestBuilder boundGetRequest = HTTP_CLIENT.prepareGet("http://www.baeldung.com");
+
+        boundGetRequest.execute(new AsyncCompletionHandler<Integer>() {
+            @Override
+            public Integer onCompleted(Response response) {
+                int resposeStatusCode = response.getStatusCode();
+                assertEquals(200, resposeStatusCode);
+                return resposeStatusCode;
+            }
+        });
+
+        try {
+            Thread.sleep(5000);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+    @Test
+    public void givenHttpClient_executeAsyncGetRequestWithAsyncHandler() {
+
+        // execute an unbound GET request
+        Request unboundGetRequest = Dsl.get("http://www.baeldung.com").build();
+
+        HTTP_CLIENT.executeRequest(unboundGetRequest, new AsyncHandler<Integer>() {
+
+            int responseStatusCode = -1;
+
+            @Override
+            public State onStatusReceived(HttpResponseStatus responseStatus) {
+                responseStatusCode = responseStatus.getStatusCode();
+                return State.CONTINUE;
+            }
+
+            @Override
+            public State onHeadersReceived(HttpHeaders headers) {
+                return State.CONTINUE;
+            }
+
+            @Override
+            public State onBodyPartReceived(HttpResponseBodyPart bodyPart) {
+                return State.CONTINUE;
+            }
+
+            @Override
+            public void onThrowable(Throwable t) {
+
+            }
+
+            @Override
+            public Integer onCompleted() {
+                assertEquals(200, responseStatusCode);
+                return responseStatusCode;
+            }
+        });
+
+        try {
+            Thread.sleep(5000);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+    @Test
+    public void givenHttpClient_executeAsyncGetRequestWithListanableFuture() {
+        // execute an unbound GET request
+        Request unboundGetRequest = Dsl.get("http://www.baeldung.com").build();
+
+        ListenableFuture<Response> listenableFuture = HTTP_CLIENT.executeRequest(unboundGetRequest);
+        listenableFuture.addListener(() -> {
+            Response response;
+            try {
+                response = listenableFuture.get(5000, TimeUnit.MILLISECONDS);
+                assertEquals(200, response.getStatusCode());
+            } catch (InterruptedException | ExecutionException | TimeoutException e) {
+                e.printStackTrace();
+            }
+        }, Executors.newCachedThreadPool());
+
+        try {
+            Thread.sleep(5000);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+    @Test
+    public void givenWebSocketClient_tryToConnect() {
+
+        WebSocketUpgradeHandler.Builder upgradeHandlerBuilder = new WebSocketUpgradeHandler.Builder();
+        WebSocketUpgradeHandler wsHandler = upgradeHandlerBuilder.addWebSocketListener(new WebSocketListener() {
+            @Override
+            public void onOpen(WebSocket websocket) {
+                // WebSocket connection opened
+            }
+
+            @Override
+            public void onClose(WebSocket websocket, int code, String reason) {
+                // WebSocket connection closed
+            }
+
+            @Override
+            public void onError(Throwable t) {
+                // WebSocket connection error
+                assertTrue(t.getMessage().contains("Request timeout"));
+            }
+        }).build();
+
+        WebSocket WEBSOCKET_CLIENT = null;
+        try {
+            WEBSOCKET_CLIENT = Dsl.asyncHttpClient()
+              .prepareGet("ws://localhost:5590/websocket")
+              .addHeader("header_name", "header_value")
+              .addQueryParam("key", "value")
+              .setRequestTimeout(5000)
+              .execute(wsHandler).get();
+
+            if (WEBSOCKET_CLIENT.isOpen()) {
+                WEBSOCKET_CLIENT.sendPingFrame();
+                WEBSOCKET_CLIENT.sendTextFrame("test message");
+                WEBSOCKET_CLIENT.sendBinaryFrame(new byte[]{'t', 'e', 's', 't'});
+            }
+        } catch (InterruptedException | ExecutionException e) {
+            e.printStackTrace();
+        } finally {
+            if (WEBSOCKET_CLIENT != null && WEBSOCKET_CLIENT.isOpen()) {
+                WEBSOCKET_CLIENT.sendCloseFrame(200, "OK");
+            }
+        }
+    }
+}
--- a/libraries/src/test/java/com/baeldung/jetty/JettyServerFactoryUnitTest.java
+++ b/libraries/src/test/java/com/baeldung/jetty/JettyServerFactoryUnitTest.java
@ -0,0 +1,86 @@
+package com.baeldung.jetty;
+
+import org.apache.http.HttpHost;
+import org.apache.http.HttpRequest;
+import org.apache.http.HttpResponse;
+import org.apache.http.client.HttpClient;
+import org.apache.http.client.methods.HttpGet;
+import org.apache.http.impl.client.HttpClientBuilder;
+import org.eclipse.jetty.server.Server;
+import org.junit.Assert;
+import org.junit.Test;
+
+/**
+ * Test for {@link JettyServerFactory}.
+ * 
+ * @author Donato Rimenti
+ *
+ */
+public class JettyServerFactoryUnitTest {
+
+	/**
+	 * Tests that when a base server is provided a request returns a status 404.
+	 * 
+	 * @throws Exception
+	 */
+	@Test
+	public void givenBaseServer_whenHttpRequest_thenStatus404() throws Exception {
+		Server server = JettyServerFactory.createBaseServer();
+		server.start();
+		
+		int statusCode = sendGetRequest();
+		
+		Assert.assertEquals(404, statusCode);
+		server.stop();
+	}
+
+	/**
+	 * Tests that when a web app server is provided a request returns a status
+	 * 200.
+	 * 
+	 * @throws Exception
+	 */
+	@Test
+	public void givenWebAppServer_whenHttpRequest_thenStatus200() throws Exception {
+		Server server = JettyServerFactory.createWebAppServer();
+		server.start();
+
+		int statusCode = sendGetRequest();
+		
+		Assert.assertEquals(200, statusCode);
+		server.stop();
+	}
+
+	/**
+	 * Tests that when a multi handler server is provided a request returns a
+	 * status 200.
+	 * 
+	 * @throws Exception
+	 */
+	@Test
+	public void givenMultiHandlerServerServer_whenHttpRequest_thenStatus200() throws Exception {
+		Server server = JettyServerFactory.createMultiHandlerServer();
+		server.start();
+
+		int statusCode = sendGetRequest();
+		
+		Assert.assertEquals(200, statusCode);
+		server.stop();
+	}
+
+	/**
+	 * Sends a default HTTP GET request to the server and returns the response
+	 * status code.
+	 * 
+	 * @return the status code of the response
+	 * @throws Exception
+	 */
+	private int sendGetRequest() throws Exception {
+		HttpHost target = new HttpHost("localhost", JettyServerFactory.SERVER_PORT);
+		HttpRequest request = new HttpGet(JettyServerFactory.APP_PATH);
+		HttpClient client = HttpClientBuilder.create().build();
+		HttpResponse response = client.execute(target, request);
+		return response.getStatusLine().getStatusCode();
+	}
+
+}
--- a/libraries/src/test/java/com/baeldung/smooks/converter/SmooksIntegrationTest.java
+++ b/libraries/src/test/java/com/baeldung/smooks/converter/SmooksIntegrationTest.java
@ -0,0 +1,70 @@
+package com.baeldung.smooks.converter;
+
+import com.baeldung.smooks.model.Item;
+import com.baeldung.smooks.model.Order;
+import com.baeldung.smooks.model.Status;
+import com.baeldung.smooks.model.Supplier;
+import org.junit.Test;
+import org.milyn.validation.ValidationResult;
+import java.text.SimpleDateFormat;
+import static org.hamcrest.Matchers.*;
+import static org.junit.Assert.*;
+
+
+public class SmooksIntegrationTest {
+
+    private static final String EDIFACT_MESSAGE =
+            "UNA:+.? '\r\n" +
+            "UNH+771+IN_PROGRESS+2018-01-14'\r\n" +
+            "CTA+CompanyX+1234567'\r\n" +
+            "LIN+1+PX1234+9.99'\r\n" +
+            "LIN+2+RX990+120.32'\r\n";
+    private static final String EMAIL_MESSAGE =
+            "Hi,\r\n" +
+            "Order number #771 created on 2018-01-14 is currently in IN_PROGRESS status.\r\n" +
+            "Consider contact supplier \"CompanyX\"  with phone number: \"1234567\".\r\n" +
+            "Order items:\r\n" +
+            "1  X PX1234 (total price 9.99)\r\n" +
+            "2  X RX990 (total price 240.64)\r\n";
+
+    @Test
+    public void givenOrderXML_whenConvert_thenPOJOsConstructedCorrectly() throws Exception {
+
+        OrderConverter xmlToJavaOrderConverter = new OrderConverter();
+        Order order = xmlToJavaOrderConverter.convertOrderXMLToOrderObject("/smooks/order.xml");
+
+        assertThat(order.getNumber(),is(771L));
+        assertThat(order.getStatus(),is(Status.IN_PROGRESS));
+        assertThat(order.getCreationDate(),is(new SimpleDateFormat("yyyy-MM-dd").parse("2018-01-14")));
+        assertThat(order.getSupplier(),is(new Supplier("CompanyX","1234567")));
+        assertThat(order.getItems(),containsInAnyOrder(
+                new Item("PX1234",9.99,1),
+                new Item("RX990",120.32,2))
+        );
+
+    }
+
+    @Test
+    public void givenIncorrectOrderXML_whenValidate_thenExpectValidationErrors() throws Exception {
+        OrderValidator orderValidator = new OrderValidator();
+        ValidationResult validationResult = orderValidator.validate("/smooks/order.xml");
+
+        assertThat(validationResult.getErrors(), hasSize(1));
+        // 1234567 didn't match ^[0-9\\-\\+]{9,15}$
+        assertThat(validationResult.getErrors().get(0).getFailRuleResult().getRuleName(),is("supplierPhone"));
+    }
+
+    @Test
+    public void givenOrderXML_whenApplyEDITemplate_thenConvertedToEDIFACT() throws Exception {
+        OrderConverter orderConverter = new OrderConverter();
+        String edifact = orderConverter.convertOrderXMLtoEDIFACT("/smooks/order.xml");
+        assertThat(edifact,is(EDIFACT_MESSAGE));
+    }
+
+    @Test
+    public void givenOrderXML_whenApplyEmailTemplate_thenConvertedToEmailMessage() throws Exception {
+        OrderConverter orderConverter = new OrderConverter();
+        String emailMessage = orderConverter.convertOrderXMLtoEmailMessage("/smooks/order.xml");
+        assertThat(emailMessage,is(EMAIL_MESSAGE));
+    }
+}
--- a/libraries/src/test/java/com/baeldung/tomcat/ProgrammaticTomcatTest.java
+++ b/libraries/src/test/java/com/baeldung/tomcat/ProgrammaticTomcatTest.java
@ -0,0 +1,62 @@
+package com.baeldung.tomcat;
+
+import org.apache.http.HttpEntity;
+import org.apache.http.HttpResponse;
+import org.apache.http.HttpStatus;
+import org.apache.http.client.methods.HttpGet;
+import org.apache.http.impl.client.CloseableHttpClient;
+import org.apache.http.impl.client.HttpClientBuilder;
+import org.apache.http.util.EntityUtils;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.BlockJUnit4ClassRunner;
+
+
+import static junit.framework.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+
+/**
+ * Created by adi on 1/14/18.
+ */
+@RunWith(BlockJUnit4ClassRunner.class)
+public class ProgrammaticTomcatTest {
+
+    private ProgrammaticTomcat tomcat = new ProgrammaticTomcat();
+
+    @Before
+    public void setUp() throws Exception {
+        tomcat.startTomcat();
+    }
+
+    @After
+    public void tearDown() throws Exception {
+        tomcat.stopTomcat();
+    }
+
+    @Test
+    public void givenTomcatStarted_whenAccessServlet_responseIsTestAndResponseHeaderIsSet() throws Exception {
+        CloseableHttpClient httpClient = HttpClientBuilder
+          .create()
+          .build();
+        HttpGet getServlet = new HttpGet("http://localhost:8080/my-servlet");
+
+        HttpResponse response = httpClient.execute(getServlet);
+        assertEquals(HttpStatus.SC_OK, response
+          .getStatusLine()
+          .getStatusCode());
+
+        String myHeaderValue = response
+          .getFirstHeader("myHeader")
+          .getValue();
+        assertEquals("myHeaderValue", myHeaderValue);
+
+        HttpEntity responseEntity = response.getEntity();
+        assertNotNull(responseEntity);
+
+        String responseString = EntityUtils.toString(responseEntity, "UTF-8");
+        assertEquals("test", responseString);
+    }
+
+}
--- a/libraries/src/test/resources/jetty-embedded-demo-app.war
+++ b/libraries/src/test/resources/jetty-embedded-demo-app.war
--- a/logging-modules/README.md
+++ b/logging-modules/README.md
@ -4,3 +4,4 @@
 ### Relevant Articles:

 - [Creating a Custom Logback Appender](http://www.baeldung.com/custom-logback-appender)
+- [Get Log Output in JSON Format](http://www.baeldung.com/java-log-json-output)
--- a/persistence-modules/spring-hibernate-5/src/test/java/com/baeldung/hibernate/bootstrap/HibernateBootstrapIntegrationTest.java
+++ b/persistence-modules/spring-hibernate-5/src/test/java/com/baeldung/hibernate/bootstrap/HibernateBootstrapIntegrationTest.java
@ -8,11 +8,16 @@ import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.test.annotation.Commit;
 import org.springframework.test.context.ContextConfiguration;
 import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
 import org.springframework.test.context.support.AnnotationConfigContextLoader;
+import org.springframework.test.context.transaction.TestTransaction;
 import org.springframework.transaction.annotation.Transactional;

+import static junit.framework.TestCase.assertFalse;
+import static junit.framework.TestCase.assertTrue;
+
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = { HibernateConf.class })
@Transactional
@ -35,4 +40,146 @@ public class HibernateBootstrapIntegrationTest {
        Assert.assertNotNull(searchEntity);
    }

+    @Test
+    public void whenProgrammaticTransactionCommit_thenEntityIsInDatabase() {
+        assertTrue(TestTransaction.isActive());
+
+        //Save an entity and commit.
+        Session session = sessionFactory.getCurrentSession();
+
+        TestEntity newEntity = new TestEntity();
+        newEntity.setId(1);
+        session.save(newEntity);
+
+        TestEntity searchEntity = session.find(TestEntity.class, 1);
+
+        Assert.assertNotNull(searchEntity);
+        assertTrue(TestTransaction.isFlaggedForRollback());
+
+        TestTransaction.flagForCommit();
+        TestTransaction.end();
+
+        assertFalse(TestTransaction.isFlaggedForRollback());
+        assertFalse(TestTransaction.isActive());
+
+        //Check that the entity is still there in a new transaction,
+        //then delete it, but don't commit.
+        TestTransaction.start();
+
+        assertTrue(TestTransaction.isFlaggedForRollback());
+        assertTrue(TestTransaction.isActive());
+
+        session = sessionFactory.getCurrentSession();
+        searchEntity = session.find(TestEntity.class, 1);
+
+        Assert.assertNotNull(searchEntity);
+
+        session.delete(searchEntity);
+        session.flush();
+
+        TestTransaction.end();
+
+        assertFalse(TestTransaction.isActive());
+
+        //Check that the entity is still there in a new transaction,
+        //then delete it and commit.
+        TestTransaction.start();
+
+        session = sessionFactory.getCurrentSession();
+        searchEntity = session.find(TestEntity.class, 1);
+
+        Assert.assertNotNull(searchEntity);
+
+        session.delete(searchEntity);
+        session.flush();
+
+        assertTrue(TestTransaction.isActive());
+
+        TestTransaction.flagForCommit();
+        TestTransaction.end();
+
+        assertFalse(TestTransaction.isActive());
+
+        //Check that the entity is no longer there in a new transaction.
+        TestTransaction.start();
+
+        assertTrue(TestTransaction.isActive());
+
+        session = sessionFactory.getCurrentSession();
+        searchEntity = session.find(TestEntity.class, 1);
+
+        Assert.assertNull(searchEntity);
+    }
+
+    @Test
+    @Commit
+    public void givenTransactionCommitDefault_whenProgrammaticTransactionCommit_thenEntityIsInDatabase() {
+        assertTrue(TestTransaction.isActive());
+
+        //Save an entity and commit.
+        Session session = sessionFactory.getCurrentSession();
+
+        TestEntity newEntity = new TestEntity();
+        newEntity.setId(1);
+        session.save(newEntity);
+
+        TestEntity searchEntity = session.find(TestEntity.class, 1);
+
+        Assert.assertNotNull(searchEntity);
+        assertFalse(TestTransaction.isFlaggedForRollback());
+
+        TestTransaction.end();
+
+        assertFalse(TestTransaction.isFlaggedForRollback());
+        assertFalse(TestTransaction.isActive());
+
+        //Check that the entity is still there in a new transaction,
+        //then delete it, but don't commit.
+        TestTransaction.start();
+
+        assertFalse(TestTransaction.isFlaggedForRollback());
+        assertTrue(TestTransaction.isActive());
+
+        session = sessionFactory.getCurrentSession();
+        searchEntity = session.find(TestEntity.class, 1);
+
+        Assert.assertNotNull(searchEntity);
+
+        session.delete(searchEntity);
+        session.flush();
+
+        TestTransaction.flagForRollback();
+        TestTransaction.end();
+
+        assertFalse(TestTransaction.isActive());
+
+        //Check that the entity is still there in a new transaction,
+        //then delete it and commit.
+        TestTransaction.start();
+
+        session = sessionFactory.getCurrentSession();
+        searchEntity = session.find(TestEntity.class, 1);
+
+        Assert.assertNotNull(searchEntity);
+
+        session.delete(searchEntity);
+        session.flush();
+
+        assertTrue(TestTransaction.isActive());
+
+        TestTransaction.end();
+
+        assertFalse(TestTransaction.isActive());
+
+        //Check that the entity is no longer there in a new transaction.
+        TestTransaction.start();
+
+        assertTrue(TestTransaction.isActive());
+
+        session = sessionFactory.getCurrentSession();
+        searchEntity = session.find(TestEntity.class, 1);
+
+        Assert.assertNull(searchEntity);
+    }
+
 }
--- a/pom.xml
+++ b/pom.xml
@ -87,11 +87,13 @@
        <module>jackson</module>
        <!--         <module>persistence-modules/java-cassandra</module> -->
        <module>vavr</module>
-		<module>java-lite</module>
-	<module>java-vavr-stream</module>
+	      <module>java-lite</module>
+	      <module>java-rmi</module>	    
+	      <module>java-vavr-stream</module>
        <module>javax-servlets</module>
        <module>javaxval</module>
        <module>jaxb</module>
+        <module>jgroups</module>
        <module>jee-7</module>
        <!-- <module>jhipster/jhipster-monolithic</module> -->
        <module>jjwt</module>
@ -245,6 +247,7 @@
        <module>spring-zuul</module>
        <module>spring-reactor</module>
        <module>spring-vertx</module>
+        <module>spring-jinq</module>
 		
 		<module>spring-rest-embedded-tomcat</module>
        
--- a/spring-5-reactive/src/main/java/com/baeldung/reactive/websocket/ReactiveJavaClientWebSocket.java
+++ b/spring-5-reactive/src/main/java/com/baeldung/reactive/websocket/ReactiveJavaClientWebSocket.java
@ -2,22 +2,25 @@ package com.baeldung.reactive.websocket;

 import java.net.URI;
 import java.time.Duration;
-import org.springframework.boot.autoconfigure.SpringBootApplication;
 import org.springframework.web.reactive.socket.WebSocketMessage;
 import org.springframework.web.reactive.socket.client.ReactorNettyWebSocketClient;
 import org.springframework.web.reactive.socket.client.WebSocketClient;

 import reactor.core.publisher.Mono;

-@SpringBootApplication
 public class ReactiveJavaClientWebSocket {
-    public static void main(String[] args) throws InterruptedException {
+	public static void main(String[] args) throws InterruptedException {
+		  
        WebSocketClient client = new ReactorNettyWebSocketClient();
-        client.execute(URI.create("ws://localhost:8080/event-emitter"), session ->  session.send(Mono.just(session.textMessage("event-me-from-spring-reactive-client")))
+        client.execute(
+          URI.create("ws://localhost:8080/event-emitter"), 
+          session -> session.send(
+            Mono.just(session.textMessage("event-spring-reactive-client-websocket")))
            .thenMany(session.receive()
-                .map(WebSocketMessage::getPayloadAsText)
-                .log())
+              .map(WebSocketMessage::getPayloadAsText)
+              .log())
            .then())
            .block(Duration.ofSeconds(10L));
    }
+
 }
--- a/spring-5-reactive/src/main/java/com/baeldung/reactive/websocket/ReactiveWebSocketHandler.java
+++ b/spring-5-reactive/src/main/java/com/baeldung/reactive/websocket/ReactiveWebSocketHandler.java
@ -1,71 +1,41 @@
 package com.baeldung.reactive.websocket;

-import org.springframework.web.reactive.socket.WebSocketSession;
-
 import com.fasterxml.jackson.core.JsonProcessingException;
 import com.fasterxml.jackson.databind.ObjectMapper;
-
 import org.springframework.stereotype.Component;
 import org.springframework.web.reactive.socket.WebSocketHandler;
 import org.springframework.web.reactive.socket.WebSocketMessage;
-
+import org.springframework.web.reactive.socket.WebSocketSession;
 import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;

-import javax.annotation.PostConstruct;
 import java.time.Duration;
-import java.time.LocalDateTime;
-import java.util.UUID;
+
+import static java.time.LocalDateTime.now;
+import static java.util.UUID.randomUUID;

@Component
 public class ReactiveWebSocketHandler implements WebSocketHandler {

-    private Flux<Event> eventFlux;
-    private Flux<Event> intervalFlux;
+    private static final ObjectMapper json = new ObjectMapper();

-    /**
-     * Here we prepare a Flux that will emit a message every second
-     */
-    @PostConstruct
-    private void init() throws InterruptedException {
+    private Flux<String> eventFlux = Flux.generate(sink -> {
+        Event event = new Event(randomUUID().toString(), now().toString());
+        try {
+            sink.next(json.writeValueAsString(event));
+        } catch (JsonProcessingException e) {
+            sink.error(e);
+        }
+    });

-        eventFlux = Flux.generate(e -> {
-            Event event = new Event(UUID.randomUUID()
-                .toString(),
-                LocalDateTime.now()
-                    .toString());
-            e.next(event);
-        });
+    private Flux<String> intervalFlux = Flux.interval(Duration.ofMillis(1000L))
+      .zipWith(eventFlux, (time, event) -> event);

-        intervalFlux = Flux.interval(Duration.ofMillis(1000L))
-            .zipWith(eventFlux, (time, event) -> event);
-
-    }
-
-    /**
-     * On each new client session, send the message flux to the client.
-     * Spring subscribes to the flux and send every new flux event to the WebSocketSession object
-     * @param session
-     * @return Mono<Void>
-     */
    @Override
    public Mono<Void> handle(WebSocketSession webSocketSession) {
-        ObjectMapper json = new ObjectMapper();
-        return webSocketSession.send(intervalFlux.map(event -> {
-            try {
-                String jsonEvent = json.writeValueAsString(event);
-                System.out.println(jsonEvent);
-                return jsonEvent;
-            } catch (JsonProcessingException e) {
-                e.printStackTrace();
-                return "";
-            }
-        })
-            .map(webSocketSession::textMessage))
-
-            .and(webSocketSession.receive()
-                .map(WebSocketMessage::getPayloadAsText)
-                .log());
+        return webSocketSession.send(intervalFlux
+          .map(webSocketSession::textMessage))
+          .and(webSocketSession.receive()
+            .map(WebSocketMessage::getPayloadAsText).log());
    }
-
 }
--- a/spring-5-security/src/main/java/com/baeldung/loginextrafieldscustom/CustomAuthenticationFilter.java
+++ b/spring-5-security/src/main/java/com/baeldung/loginextrafieldscustom/CustomAuthenticationFilter.java
@ -0,0 +1,50 @@
+package com.baeldung.loginextrafieldscustom;
+
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+import org.springframework.security.authentication.AuthenticationServiceException;
+import org.springframework.security.core.Authentication;
+import org.springframework.security.core.AuthenticationException;
+import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;
+
+public class CustomAuthenticationFilter extends UsernamePasswordAuthenticationFilter {
+
+    public static final String SPRING_SECURITY_FORM_DOMAIN_KEY = "domain";
+
+    @Override
+    public Authentication attemptAuthentication(HttpServletRequest request, HttpServletResponse response) 
+        throws AuthenticationException {
+
+        if (!request.getMethod().equals("POST")) {
+            throw new AuthenticationServiceException("Authentication method not supported: " 
+              + request.getMethod());
+        }
+
+        CustomAuthenticationToken authRequest = getAuthRequest(request);
+        setDetails(request, authRequest);
+        return this.getAuthenticationManager().authenticate(authRequest);
+    }
+
+    private CustomAuthenticationToken getAuthRequest(HttpServletRequest request) {
+        String username = obtainUsername(request);
+        String password = obtainPassword(request);
+        String domain = obtainDomain(request);
+
+        if (username == null) {
+            username = "";
+        }
+        if (password == null) {
+            password = "";
+        }
+        if (domain == null) {
+            domain = "";
+        }
+
+        return new CustomAuthenticationToken(username, password, domain);
+    }
+
+    private String obtainDomain(HttpServletRequest request) {
+        return request.getParameter(SPRING_SECURITY_FORM_DOMAIN_KEY);
+    }
+}
--- a/Show More
+++ b/Show More
				`@ -0,0 +1 @@`
				`"max_total","item.quantity * item.price < 300.00"`