Merge remote-tracking branch 'upstream/master'

algorithms/src/main/java/com/baeldung/algorithms/rectanglesoverlap/Point.java

@@ -0,0 +1,29 @@
+package com.baeldung.algorithms.rectanglesoverlap;
+
+public class Point {
+
+    private int x;
+    private int y;
+
+    public Point(int x, int y) {
+        this.x = x;
+        this.y = y;
+    }
+
+    public int getX() {
+        return x;
+    }
+
+    public void setX(int x) {
+        this.x = x;
+    }
+
+    public int getY() {
+        return y;
+    }
+
+    public void setY(int y) {
+        this.y = y;
+    }
+
+}

algorithms/src/main/java/com/baeldung/algorithms/rectanglesoverlap/Rectangle.java

@@ -0,0 +1,40 @@
+package com.baeldung.algorithms.rectanglesoverlap;
+
+public class Rectangle {
+
+    private Point bottomLeft;
+    private Point topRight;
+
+    public Rectangle(Point bottomLeft, Point topRight) {
+        this.bottomLeft = bottomLeft;
+        this.topRight = topRight;
+    }
+
+    public Point getBottomLeft() {
+        return bottomLeft;
+    }
+
+    public void setBottomLeft(Point bottomLeft) {
+        this.bottomLeft = bottomLeft;
+    }
+
+    public Point getTopRight() {
+        return topRight;
+    }
+
+    public void setTopRight(Point topRight) {
+        this.topRight = topRight;
+    }
+
+    public boolean isOverlapping(Rectangle other) {
+        // one rectangle is to the top of the other
+        if (this.topRight.getY() < other.bottomLeft.getY() || this.bottomLeft.getY() > other.topRight.getY()) {
+            return false;
+        }
+        // one rectangle is to the left of the other
+        if (this.topRight.getX() < other.bottomLeft.getX() || this.bottomLeft.getX() > other.topRight.getX()) {
+            return false;
+        }
+        return true;
+    }
+}

algorithms/src/test/java/com/baeldung/algorithms/rectanglesoverlap/RectangleUnitTest.java

@@ -0,0 +1,42 @@
+package com.baeldung.algorithms.rectanglesoverlap;
+
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.assertFalse;
+import org.junit.Test;
+
+import com.baeldung.algorithms.rectanglesoverlap.Point;
+import com.baeldung.algorithms.rectanglesoverlap.Rectangle;
+
+public class RectangleUnitTest {
+
+    @Test
+    public void givenTwoOverlappingRectangles_whenisOverlappingCalled_shouldReturnTrue() {
+        Rectangle rectangle1 = new Rectangle(new Point(2, 1), new Point(4, 3));
+        Rectangle rectangle2 = new Rectangle(new Point(1, 1), new Point(6, 4));
+        assertTrue(rectangle1.isOverlapping(rectangle2));
+
+        rectangle1 = new Rectangle(new Point(-5, -2), new Point(2, 3));
+        rectangle2 = new Rectangle(new Point(-2, -1), new Point(5, 2));
+        assertTrue(rectangle1.isOverlapping(rectangle2));
+
+        rectangle1 = new Rectangle(new Point(-5, 1), new Point(2, 4));
+        rectangle2 = new Rectangle(new Point(-2, -2), new Point(5, 5));
+        assertTrue(rectangle1.isOverlapping(rectangle2));
+    }
+
+    @Test
+    public void givenTwoNonOverlappingRectangles_whenisOverlappingCalled_shouldReturnFalse() {
+        Rectangle rectangle1 = new Rectangle(new Point(-5, 1), new Point(-3, 4));
+        Rectangle rectangle2 = new Rectangle(new Point(-2, -2), new Point(5, 5));
+        assertFalse(rectangle1.isOverlapping(rectangle2));
+
+        rectangle1 = new Rectangle(new Point(-5, 1), new Point(3, 4));
+        rectangle2 = new Rectangle(new Point(-2, -2), new Point(5, -1));
+        assertFalse(rectangle1.isOverlapping(rectangle2));
+
+        rectangle1 = new Rectangle(new Point(-2, 1), new Point(0, 3));
+        rectangle2 = new Rectangle(new Point(3, 1), new Point(5, 4));
+        assertFalse(rectangle1.isOverlapping(rectangle2));
+    }
+
+}

apache-cxf/README.md

@@ -3,3 +3,4 @@
 - [Apache CXF Support for RESTful Web Services](http://www.baeldung.com/apache-cxf-rest-api)
 - [A Guide to Apache CXF with Spring](http://www.baeldung.com/apache-cxf-with-spring)
 - [Introduction to Apache CXF](http://www.baeldung.com/introduction-to-apache-cxf)
+- [Server-Sent Events (SSE) In JAX-RS](https://www.baeldung.com/java-ee-jax-rs-sse)

apache-cxf/sse-jaxrs/sse-jaxrs-server/pom.xml

@@ -20,7 +20,7 @@
     </properties>
 
     <build>
-        <finalName>${artifactId}</finalName>
+        <finalName>${project.artifactId}</finalName>
         <plugins>
             <plugin>
                 <groupId>net.wasdev.wlp.maven.plugins</groupId>

aws-lambda/pom.xml

@@ -95,7 +95,6 @@
         <gson.version>2.8.2</gson.version>
         <aws-java-sdk.version>1.11.241</aws-java-sdk.version>
         <maven-shade-plugin.version>3.0.0</maven-shade-plugin.version>
-        <maven-dependency-plugin.version>2.10</maven-dependency-plugin.version>
     </properties>
     
 </project>

aws/.gitignore

@@ -1 +1,2 @@
 /target/
+.idea/

aws/pom.xml

@@ -100,26 +100,6 @@
                     </execution>
                 </executions>
             </plugin>
-
-            <plugin>
-                <groupId>org.apache.maven.plugins</groupId>
-                <artifactId>maven-dependency-plugin</artifactId>
-                <version>${maven-dependency-plugin.version}</version>
-                <executions>
-                    <execution>
-                        <id>copy-dependencies</id>
-                        <phase>test-compile</phase>
-                        <goals>
-                            <goal>copy-dependencies</goal>
-                        </goals>
-                        <configuration>
-                            <includeScope>test</includeScope>
-                            <includeTypes>so,dll,dylib</includeTypes>
-                            <outputDirectory>${project.basedir}/native-libs</outputDirectory>
-                        </configuration>
-                    </execution>
-                </executions>
-            </plugin>
         </plugins>
     </build>
 
@@ -144,7 +124,6 @@
         <commons-codec-version>1.10.L001</commons-codec-version>
         <jets3t-version>0.9.4.0006L</jets3t-version>
         <maven-shade-plugin.version>3.0.0</maven-shade-plugin.version>
-        <maven-dependency-plugin.version>2.10</maven-dependency-plugin.version>
     </properties>
 
 </project>

aws/src/main/java/com/baeldung/rds/AWSRDSService.java

@@ -0,0 +1,184 @@
+package com.baeldung.rds;
+
+import com.amazonaws.auth.AWSCredentialsProvider;
+import com.amazonaws.auth.AWSStaticCredentialsProvider;
+import com.amazonaws.auth.BasicAWSCredentials;
+import com.amazonaws.regions.Regions;
+import com.amazonaws.services.rds.AmazonRDS;
+import com.amazonaws.services.rds.AmazonRDSClientBuilder;
+import com.amazonaws.services.rds.model.*;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.sql.*;
+import java.util.List;
+import java.util.Properties;
+import java.util.UUID;
+import java.util.logging.Logger;
+
+public class AWSRDSService {
+
+
+    final static Logger logger = Logger.getLogger(AWSRDSService.class.getName());
+    private AWSCredentialsProvider credentials;
+    private AmazonRDS amazonRDS;
+    private String db_username;
+    private String db_password;
+    private String db_database;
+    private String db_hostname;
+
+    /*
+    * User access key and secret key must be set before execute any operation.
+    * Follow the link on how to get the user access and secret key
+    * https://aws.amazon.com/blogs/security/wheres-my-secret-access-key/
+    * **/
+    public AWSRDSService() throws IOException {
+        //Init RDS client with credentials and region.
+        credentials = new
+                AWSStaticCredentialsProvider(new
+                BasicAWSCredentials("<ACCESS_KEY>",
+                "<SECRET_KEY>"));
+        amazonRDS = AmazonRDSClientBuilder.standard().withCredentials(credentials)
+                .withRegion(Regions.AP_SOUTHEAST_2).build();
+        Properties prop = new Properties();
+        InputStream input = AWSRDSService.class.getClassLoader().getResourceAsStream("db.properties");
+        prop.load(input);
+        db_username = prop.getProperty("db_username");
+        db_password = prop.getProperty("db_password");
+        db_database = prop.getProperty("db_database");
+    }
+
+    public AWSRDSService(AmazonRDS amazonRDS){
+        this.amazonRDS = amazonRDS;
+    }
+
+    /**
+     * create the RDS instance.
+     * After instance creation, update the db_hostname with endpoint in db.properties.
+     * */
+
+    public String launchInstance() {
+
+        String identifier = "";
+        CreateDBInstanceRequest request = new CreateDBInstanceRequest();
+        // RDS instance name
+        request.setDBInstanceIdentifier("Sydney");
+        request.setEngine("postgres");
+        request.setMultiAZ(false);
+        request.setMasterUsername(db_username);
+        request.setMasterUserPassword(db_password);
+        request.setDBName(db_database);
+        request.setStorageType("gp2");
+        request.setAllocatedStorage(10);
+
+        DBInstance instance = amazonRDS.createDBInstance(request);
+
+        // Information about the new RDS instance
+        identifier = instance.getDBInstanceIdentifier();
+        String status = instance.getDBInstanceStatus();
+        Endpoint endpoint = instance.getEndpoint();
+        String endpoint_url = "Endpoint URL not available yet.";
+        if (endpoint != null) {
+            endpoint_url = endpoint.toString();
+        }
+        logger.info(identifier + "\t" + status);
+        logger.info(endpoint_url);
+
+        return identifier;
+
+    }
+
+    // Describe DB instances
+    public void listInstances() {
+        DescribeDBInstancesResult result = amazonRDS.describeDBInstances();
+        List<DBInstance> instances = result.getDBInstances();
+        for (DBInstance instance : instances) {
+            // Information about each RDS instance
+            String identifier = instance.getDBInstanceIdentifier();
+            String engine = instance.getEngine();
+            String status = instance.getDBInstanceStatus();
+            Endpoint endpoint = instance.getEndpoint();
+            String endpoint_url = "Endpoint URL not available yet.";
+            if (endpoint != null) {
+                endpoint_url = endpoint.toString();
+            }
+            logger.info(identifier + "\t" + engine + "\t" + status);
+            logger.info("\t" + endpoint_url);
+        }
+
+    }
+
+    //Delete RDS instance
+    public void terminateInstance(String identifier) {
+
+        DeleteDBInstanceRequest request = new DeleteDBInstanceRequest();
+        request.setDBInstanceIdentifier(identifier);
+        request.setSkipFinalSnapshot(true);
+
+        // Delete the RDS instance
+        DBInstance instance = amazonRDS.deleteDBInstance(request);
+
+        // Information about the RDS instance being deleted
+        String status = instance.getDBInstanceStatus();
+        Endpoint endpoint = instance.getEndpoint();
+        String endpoint_url = "Endpoint URL not available yet.";
+        if (endpoint != null) {
+            endpoint_url = endpoint.toString();
+        }
+
+        logger.info(identifier + "\t" + status);
+        logger.info(endpoint_url);
+
+    }
+
+
+    public void runJdbcTests() throws SQLException, IOException {
+
+        // Getting database properties from db.properties
+        Properties prop = new Properties();
+        InputStream input = AWSRDSService.class.getClassLoader().getResourceAsStream("db.properties");
+        prop.load(input);
+        db_hostname = prop.getProperty("db_hostname");
+        String jdbc_url = "jdbc:postgresql://" + db_hostname + ":5432/" + db_database;
+
+        // Create a connection using the JDBC driver
+        try (Connection conn = DriverManager.getConnection(jdbc_url, db_username, db_password)) {
+
+            // Create the test table if not exists
+            Statement statement = conn.createStatement();
+            String sql = "CREATE TABLE IF NOT EXISTS jdbc_test (id SERIAL PRIMARY KEY, content VARCHAR(80))";
+            statement.executeUpdate(sql);
+
+            // Do some INSERT
+            PreparedStatement preparedStatement = conn.prepareStatement("INSERT INTO jdbc_test (content) VALUES (?)");
+            String content = "" + UUID.randomUUID();
+            preparedStatement.setString(1, content);
+            preparedStatement.executeUpdate();
+            logger.info("INSERT: " + content);
+
+            // Do some SELECT
+            sql = "SELECT  * FROM jdbc_test";
+            ResultSet resultSet = statement.executeQuery(sql);
+            while (resultSet.next()) {
+                String count = resultSet.getString("content");
+                logger.info("Total Records: " + count);
+            }
+        }
+
+
+    }
+
+    public static void main(String[] args) throws IOException, SQLException {
+        AWSRDSService awsrdsService = new AWSRDSService();
+
+        String instanceName = awsrdsService.launchInstance();
+
+        //Add some wait for instance creation.
+
+        awsrdsService.listInstances();
+
+        awsrdsService.runJdbcTests();
+
+        awsrdsService.terminateInstance(instanceName);
+    }
+}

aws/src/main/resources/db.properties

@@ -0,0 +1,4 @@
+db_hostname=<RDS EndPoint>
+db_username=username
+db_password=password
+db_database=mydb

checker-plugin/pom.xml

@@ -41,27 +41,6 @@
 
     <build>
         <plugins>
-            <plugin>
-                <!-- This plugin will set properties values using dependency information -->
-                <groupId>org.apache.maven.plugins</groupId>
-                <artifactId>maven-dependency-plugin</artifactId>
-                <executions>
-                    <execution>
-                        <goals>
-                            <!--
-                            Goal that sets a property pointing to the artifact file for each project dependency.
-                            For each dependency (direct and transitive) a project property will be set which
-                            follows the:
-
-                               groupId:artifactId:type:[classifier]
-
-                            form and contains the path to the resolved artifact. -->
-                            <goal>properties</goal>
-                        </goals>
-                    </execution>
-                </executions>
-            </plugin>
-
             <plugin>
                 <artifactId>maven-compiler-plugin</artifactId>
                 <version>${maven-compiler-plugin.version}</version>

core-java-8/README.md

@@ -29,3 +29,6 @@
 - [Java 8 Unsigned Arithmetic Support](http://www.baeldung.com/java-unsigned-arithmetic)
 - [Generalized Target-Type Inference in Java](http://www.baeldung.com/java-generalized-target-type-inference)
 - [Overriding System Time for Testing in Java](http://www.baeldung.com/java-override-system-time)
+- [Set the Time Zone of a Date in Java](https://www.baeldung.com/java-set-date-time-zone)
+- [An Overview of Regular Expressions Performance in Java](https://www.baeldung.com/java-regex-performance)
+- [Java Primitives versus Objects](https://www.baeldung.com/java-primitives-vs-objects)

core-java-8/pom.xml

@@ -116,23 +116,6 @@
         </resources>
 
         <plugins>
-            <plugin>
-                <groupId>org.apache.maven.plugins</groupId>
-                <artifactId>maven-dependency-plugin</artifactId>
-                <executions>
-                    <execution>
-                        <id>copy-dependencies</id>
-                        <phase>prepare-package</phase>
-                        <goals>
-                            <goal>copy-dependencies</goal>
-                        </goals>
-                        <configuration>
-                            <outputDirectory>${project.build.directory}/libs</outputDirectory>
-                        </configuration>
-                    </execution>
-                </executions>
-            </plugin>
-
             <plugin>
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-compiler-plugin</artifactId>

core-java-9/README.md

@@ -24,3 +24,5 @@
 - [Optional orElse Optional](http://www.baeldung.com/java-optional-or-else-optional)
 - [Java 9 java.lang.Module API](http://www.baeldung.com/java-9-module-api)
 - [Iterate Through a Range of Dates in Java](https://www.baeldung.com/java-iterate-date-range)
+- [Initialize a HashMap in Java](https://www.baeldung.com/java-initialize-hashmap)
+- [Java 9 Platform Logging API](https://www.baeldung.com/java-9-logging-api)

core-java-9/src/test/java/com/baeldung/java9/process/ProcessUnderstandingTest.java

@@ -48,7 +48,7 @@ class ProcessUnderstandingTest {
     }
 
     //@Test - windows specific
-    public void givenSubProcess_thenStartSuccessIsAlive() throws IOException {
+    public void givenSubProcess_whenStarted_thenStartSuccessIsAlive() throws IOException {
         ProcessBuilder builder = new ProcessBuilder("notepad.exe");
         assertTrue(builder.start().isAlive());
     }
@@ -75,7 +75,7 @@ class ProcessUnderstandingTest {
     }
 
     //@Test - windows specific
-    public void givenSubProcess_checkAlive() throws IOException, InterruptedException {
+    public void givenSubProcess_whenDestroyed_thenCheckIfAlive() throws IOException, InterruptedException {
         ProcessBuilder builder = new ProcessBuilder("notepad.exe");
         Process process = builder.start();
         Thread.sleep(10000);

core-java-collections/README.md

@@ -43,3 +43,9 @@
 - [An Introduction to Java.util.Hashtable Class](http://www.baeldung.com/java-hash-table)
 - [Copy a List to Another List in Java](http://www.baeldung.com/java-copy-list-to-another)
 - [Finding Max/Min of a List or Collection](http://www.baeldung.com/java-collection-min-max)
+- [Java Null-Safe Streams from Collections](https://www.baeldung.com/java-null-safe-streams-from-collections)
+- [Remove All Occurrences of a Specific Value from a List](https://www.baeldung.com/java-remove-value-from-list)
+- [Thread Safe LIFO Data Structure Implementations](https://www.baeldung.com/java-lifo-thread-safe)
+- [Collections.emptyList() vs. New List Instance](https://www.baeldung.com/java-collections-emptylist-new-list)
+- [Initialize a HashMap in Java](https://www.baeldung.com/java-initialize-hashmap)
+- [](https://www.baeldung.com/java-hashset-arraylist-contains-performance)

core-java-collections/src/main/java/com/baeldung/java/map/MapUtil.java

@@ -0,0 +1,44 @@
+/**
+ * 
+ */
+package com.baeldung.java.map;
+
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+import java.util.Map.Entry;
+import java.util.stream.Stream;
+
+/**
+ * @author swpraman
+ *
+ */
+public class MapUtil {
+    
+    public static <K, V> Stream<K> keys(Map<K, V> map, V value) {
+        return map.entrySet()
+                .stream()
+                .filter(entry -> value.equals(entry.getValue()))
+                .map(Map.Entry::getKey);
+    }
+    
+    public static <K, V> Set<K> getKeys(Map<K, V> map, V value) {
+        Set<K> keys = new HashSet<>();
+        for (Entry<K, V> entry : map.entrySet()) {
+            if (entry.getValue().equals(value)) {
+                keys.add(entry.getKey());
+            }
+        }
+        return keys;
+    }
+    
+    public static <K, V> K getKey(Map<K, V> map, V value) {
+        for (Entry<K, V> entry : map.entrySet()) {
+            if (entry.getValue().equals(value)) {
+                return entry.getKey();
+            }
+        }
+        return null;
+    }
+
+}

core-java-collections/src/main/java/com/baeldung/performance/ArrayListBenchmark.java

@@ -0,0 +1,77 @@
+package com.baeldung.performance;
+
+import org.openjdk.jmh.annotations.*;
+import org.openjdk.jmh.runner.Runner;
+import org.openjdk.jmh.runner.options.Options;
+import org.openjdk.jmh.runner.options.OptionsBuilder;
+
+import java.util.*;
+import java.util.concurrent.TimeUnit;
+
+@BenchmarkMode(Mode.AverageTime)
+@OutputTimeUnit(TimeUnit.MICROSECONDS)
+@Warmup(iterations = 10)
+public class ArrayListBenchmark {
+
+    @State(Scope.Thread)
+    public static class MyState {
+
+        List<Employee> employeeList = new ArrayList<>();
+        //LinkedList<Employee> employeeList = new LinkedList<>();
+
+        long iterations = 100000;
+
+        Employee employee = new Employee(100L, "Harry");
+
+        int employeeIndex = -1;
+
+        @Setup(Level.Trial)
+        public void setUp() {
+            for (long i = 0; i < iterations; i++) {
+                employeeList.add(new Employee(i, "John"));
+            }
+
+            employeeList.add(employee);
+            employeeIndex = employeeList.indexOf(employee);
+        }
+    }
+
+    @Benchmark
+    public void testAddAt(ArrayListBenchmark.MyState state) {
+        state.employeeList.add((int) (state.iterations), new Employee(state.iterations, "John"));
+    }
+
+    @Benchmark
+    public boolean testContains(ArrayListBenchmark.MyState state) {
+        return state.employeeList.contains(state.employee);
+    }
+
+    @Benchmark
+    public int testIndexOf(ArrayListBenchmark.MyState state) {
+        return state.employeeList.indexOf(state.employee);
+    }
+
+    @Benchmark
+    public Employee testGet(ArrayListBenchmark.MyState state) {
+        return state.employeeList.get(state.employeeIndex);
+    }
+
+    @Benchmark
+    public boolean testRemove(ArrayListBenchmark.MyState state) {
+        return state.employeeList.remove(state.employee);
+    }
+
+//    @Benchmark
+//    public void testAdd(ArrayListBenchmark.MyState state) {
+//        state.employeeList.add(new Employee(state.iterations + 1, "John"));
+//    }
+
+    public static void main(String[] args) throws Exception {
+        Options options = new OptionsBuilder()
+                .include(ArrayListBenchmark.class.getSimpleName()).threads(1)
+                .forks(1).shouldFailOnError(true)
+                .shouldDoGC(true)
+                .jvmArgs("-server").build();
+        new Runner(options).run();
+    }
+}

core-java-collections/src/main/java/com/baeldung/performance/CopyOnWriteBenchmark.java

@@ -0,0 +1,78 @@
+package com.baeldung.performance;
+
+import org.openjdk.jmh.annotations.*;
+import org.openjdk.jmh.runner.Runner;
+import org.openjdk.jmh.runner.options.Options;
+import org.openjdk.jmh.runner.options.OptionsBuilder;
+
+import java.util.concurrent.CopyOnWriteArrayList;
+import java.util.concurrent.TimeUnit;
+
+@BenchmarkMode(Mode.AverageTime)
+@OutputTimeUnit(TimeUnit.MICROSECONDS)
+@Warmup(iterations = 10)
+public class CopyOnWriteBenchmark {
+
+    @State(Scope.Thread)
+    public static class MyState {
+
+        CopyOnWriteArrayList<Employee> employeeList = new CopyOnWriteArrayList<>();
+
+        long iterations = 100000;
+
+        Employee employee = new Employee(100L, "Harry");
+
+        int employeeIndex = -1;
+
+        @Setup(Level.Trial)
+        public void setUp() {
+            for (long i = 0; i < iterations; i++) {
+                employeeList.add(new Employee(i, "John"));
+            }
+
+            employeeList.add(employee);
+
+            employeeIndex = employeeList.indexOf(employee);
+        }
+    }
+
+        @Benchmark
+    public void testAdd(CopyOnWriteBenchmark.MyState state) {
+            state.employeeList.add(new Employee(state.iterations + 1, "John"));
+    }
+
+    @Benchmark
+    public void testAddAt(CopyOnWriteBenchmark.MyState state) {
+        state.employeeList.add((int) (state.iterations), new Employee(state.iterations, "John"));
+    }
+
+    @Benchmark
+    public boolean testContains(CopyOnWriteBenchmark.MyState state) {
+        return state.employeeList.contains(state.employee);
+    }
+
+    @Benchmark
+    public int testIndexOf(CopyOnWriteBenchmark.MyState state) {
+        return state.employeeList.indexOf(state.employee);
+    }
+
+    @Benchmark
+    public Employee testGet(CopyOnWriteBenchmark.MyState state) {
+        return state.employeeList.get(state.employeeIndex);
+    }
+
+    @Benchmark
+    public boolean testRemove(CopyOnWriteBenchmark.MyState state) {
+        return state.employeeList.remove(state.employee);
+    }
+
+
+    public static void main(String[] args) throws Exception {
+        Options options = new OptionsBuilder()
+                .include(CopyOnWriteBenchmark.class.getSimpleName()).threads(1)
+                .forks(1).shouldFailOnError(true)
+                .shouldDoGC(true)
+                .jvmArgs("-server").build();
+        new Runner(options).run();
+    }
+}

core-java-collections/src/main/java/com/baeldung/performance/Employee.java

@@ -10,6 +10,22 @@ public class Employee {
         this.id = id;
     }
 
+    public Long getId() {
+        return id;
+    }
+
+    public void setId(Long id) {
+        this.id = id;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
     @Override
     public boolean equals(Object o) {
         if (this == o) return true;

core-java-collections/src/main/java/com/baeldung/performance/HashMapBenchmark.java

@@ -0,0 +1,73 @@
+package com.baeldung.performance;
+
+import org.openjdk.jmh.annotations.*;
+import org.openjdk.jmh.runner.Runner;
+import org.openjdk.jmh.runner.options.Options;
+import org.openjdk.jmh.runner.options.OptionsBuilder;
+
+import java.util.*;
+import java.util.concurrent.TimeUnit;
+
+@BenchmarkMode(Mode.AverageTime)
+@OutputTimeUnit(TimeUnit.MICROSECONDS)
+@Warmup(iterations = 10)
+public class HashMapBenchmark {
+
+    @State(Scope.Thread)
+    public static class MyState {
+
+        Map<Long, Employee> employeeMap = new HashMap<>();
+        //LinkedHashMap<Long, Employee> employeeMap = new LinkedHashMap<>();
+        //IdentityHashMap<Long, Employee> employeeMap = new IdentityHashMap<>();
+        //WeakHashMap<Long, Employee> employeeMap = new WeakHashMap<>();
+        //ConcurrentHashMap<Long, Employee> employeeMap = new ConcurrentHashMap<>();
+        //ConcurrentSkipListMap<Long, Employee> employeeMap = new ConcurrentSkipListMap <>();
+
+        // TreeMap
+
+        long iterations = 100000;
+
+        Employee employee = new Employee(100L, "Harry");
+
+        int employeeIndex = -1;
+
+        @Setup(Level.Trial)
+        public void setUp() {
+            for (long i = 0; i < iterations; i++) {
+                employeeMap.put(i, new Employee(i, "John"));
+            }
+
+            //employeeMap.put(iterations, employee);
+        }
+    }
+
+    @Benchmark
+    public Employee testGet(HashMapBenchmark.MyState state) {
+        return state.employeeMap.get(state.iterations);
+    }
+
+    @Benchmark
+    public Employee testRemove(HashMapBenchmark.MyState state) {
+        return state.employeeMap.remove(state.iterations);
+    }
+
+    @Benchmark
+    public Employee testPut(HashMapBenchmark.MyState state) {
+        return state.employeeMap.put(state.employee.getId(), state.employee);
+    }
+
+    @Benchmark
+    public Boolean testContainsKey(HashMapBenchmark.MyState state) {
+        return state.employeeMap.containsKey(state.employee.getId());
+    }
+
+
+    public static void main(String[] args) throws Exception {
+        Options options = new OptionsBuilder()
+                .include(HashMapBenchmark.class.getSimpleName()).threads(1)
+                .forks(1).shouldFailOnError(true)
+                .shouldDoGC(true)
+                .jvmArgs("-server").build();
+        new Runner(options).run();
+    }
+}

core-java-collections/src/main/java/com/baeldung/performance/SetBenchMark.java

@@ -0,0 +1,66 @@
+package com.baeldung.performance;
+
+import org.openjdk.jmh.annotations.*;
+import org.openjdk.jmh.runner.Runner;
+import org.openjdk.jmh.runner.options.Options;
+import org.openjdk.jmh.runner.options.OptionsBuilder;
+
+import java.util.HashSet;
+import java.util.LinkedHashSet;
+import java.util.Set;
+import java.util.TreeSet;
+import java.util.concurrent.ConcurrentSkipListSet;
+import java.util.concurrent.TimeUnit;
+
+@BenchmarkMode(Mode.AverageTime)
+@OutputTimeUnit(TimeUnit.MICROSECONDS)
+@Warmup(iterations = 10)
+public class SetBenchMark {
+
+    @State(Scope.Thread)
+    public static class MyState {
+
+        //Set<Employee> employeeSet = new HashSet<>();
+        LinkedHashSet<Employee> employeeSet = new LinkedHashSet<>();
+        //ConcurrentSkipListSet<Employee> employeeSet = new ConcurrentSkipListSet <>();
+
+        // TreeSet 
+
+        long iterations = 1000;
+        Employee employee = new Employee(100L, "Harry");
+
+        @Setup(Level.Trial)
+        public void setUp() {
+            for (long i = 0; i < iterations; i++) {
+                employeeSet.add(new Employee(i, "John"));
+            }
+
+            //employeeSet.add(employee);
+        }
+    }
+
+    @Benchmark
+    public boolean testAdd(SetBenchMark.MyState state) {
+        return state.employeeSet.add(state.employee);
+    }
+
+    @Benchmark
+    public Boolean testContains(SetBenchMark.MyState state) {
+        return state.employeeSet.contains(state.employee);
+    }
+
+    @Benchmark
+    public boolean testRemove(SetBenchMark.MyState state) {
+        return state.employeeSet.remove(state.employee);
+    }
+
+
+    public static void main(String[] args) throws Exception {
+        Options options = new OptionsBuilder()
+                .include(SetBenchMark.class.getSimpleName()).threads(1)
+                .forks(1).shouldFailOnError(true)
+                .shouldDoGC(true)
+                .jvmArgs("-server").build();
+        new Runner(options).run();
+    }
+}

core-java-collections/src/test/java/com/baeldung/collection/ClearVsRemoveAllUnitTest.java

@@ -0,0 +1,40 @@
+package com.baeldung.collection;
+
+import org.junit.jupiter.api.Test;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+/**
+ * Unit tests demonstrating differences between ArrayList#clear() and ArrayList#removeAll()
+ */
+class ClearVsRemoveAllUnitTest {
+
+    /*
+     * Tests
+     */
+    @Test
+    void givenArrayListWithElements_whenClear_thenListBecomesEmpty() {
+        Collection<Integer> collection = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5));
+
+        collection.clear();
+
+        assertTrue(collection.isEmpty());
+    }
+
+    @Test
+    void givenTwoArrayListsWithCommonElements_whenRemoveAll_thenFirstListMissElementsFromSecondList() {
+        Collection<Integer> firstCollection = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5));
+        Collection<Integer> secondCollection = new ArrayList<>(Arrays.asList(3, 4, 5, 6, 7));
+
+        firstCollection.removeAll(secondCollection);
+
+        assertEquals(Arrays.asList(1, 2), firstCollection);
+        assertEquals(Arrays.asList(3, 4, 5, 6, 7), secondCollection);
+    }
+
+}

core-java-collections/src/test/java/com/baeldung/java/map/MapUtilUnitTest.java

@@ -0,0 +1,104 @@
+/**
+ * 
+ */
+package com.baeldung.java.map;
+
+import static org.junit.Assert.assertEquals;
+
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+import org.apache.commons.collections4.BidiMap;
+import org.apache.commons.collections4.bidimap.DualHashBidiMap;
+import org.junit.Test;
+
+import com.google.common.collect.HashBiMap;
+
+/**
+ * @author swpraman
+ *
+ */
+public class MapUtilUnitTest {
+    
+    
+    @Test
+    public void whenUsingImperativeWayForSingleKey_shouldReturnSingleKey() {
+        Map<String, String> capitalCountryMap = new HashMap<>();
+        capitalCountryMap.put("Tokyo", "Japan");
+        capitalCountryMap.put("New Delhi", "India");
+        assertEquals("New Delhi", MapUtil.getKey(capitalCountryMap, "India"));
+    }
+    
+    @Test
+    public void whenUsingImperativeWayForAllKeys_shouldReturnAllKeys() {
+        Map<String, String> capitalCountryMap = new HashMap<>();
+        capitalCountryMap.put("Tokyo", "Japan");
+        capitalCountryMap.put("Berlin", "Germany");
+        capitalCountryMap.put("Cape Town", "South Africa");
+        capitalCountryMap.put("Pretoria", "South Africa");
+        capitalCountryMap.put("Bloemfontein", "South Africa");
+
+        assertEquals(new HashSet<String>(Arrays.asList(
+                new String[] {"Cape Town", "Pretoria", "Bloemfontein"})), 
+                MapUtil.getKeys(capitalCountryMap, "South Africa"));
+    }
+    
+    @Test
+    public void whenUsingFunctionalWayForSingleKey_shouldReturnSingleKey() {
+        Map<String, String> capitalCountryMap = new HashMap<>();
+        capitalCountryMap.put("Tokyo", "Japan");
+        capitalCountryMap.put("Berlin", "Germany");
+        assertEquals("Berlin", MapUtil.keys(capitalCountryMap, "Germany").findFirst().get());
+    }
+    
+    @Test
+    public void whenUsingFunctionalWayForAllKeys_shouldReturnAllKeys() {
+        Map<String, String> capitalCountryMap = new HashMap<>();
+        capitalCountryMap.put("Tokyo", "Japan");
+        capitalCountryMap.put("Berlin", "Germany");
+        capitalCountryMap.put("Cape Town", "South Africa");
+        capitalCountryMap.put("Pretoria", "South Africa");
+        capitalCountryMap.put("Bloemfontein", "South Africa");
+        assertEquals(new HashSet<String>(Arrays.asList(
+                new String[] {"Cape Town", "Pretoria", "Bloemfontein"})), 
+                MapUtil.keys(capitalCountryMap, "South Africa").collect(Collectors.toSet()));
+    }
+    
+    @Test
+    public void whenUsingBidiMap_shouldReturnKey() {
+        BidiMap<String, String> capitalCountryMap = new DualHashBidiMap<String, String>();
+        capitalCountryMap.put("Berlin", "Germany");
+        capitalCountryMap.put("Cape Town", "South Africa");
+        assertEquals("Berlin", capitalCountryMap.getKey("Germany"));
+    }
+    
+    @Test
+    public void whenUsingBidiMapAddDuplicateValue_shouldRemoveOldEntry() {
+        BidiMap<String, String> capitalCountryMap = new DualHashBidiMap<String, String>();
+        capitalCountryMap.put("Berlin", "Germany");
+        capitalCountryMap.put("Cape Town", "South Africa");
+        capitalCountryMap.put("Pretoria", "South Africa");
+        assertEquals("Pretoria", capitalCountryMap.getKey("South Africa"));
+    }
+    
+    @Test
+    public void whenUsingBiMap_shouldReturnKey() {
+        HashBiMap<String, String> capitalCountryMap = HashBiMap.create();
+        capitalCountryMap.put("Berlin", "Germany");
+        capitalCountryMap.put("Cape Town", "South Africa");
+        assertEquals("Berlin", capitalCountryMap.inverse().get("Germany"));
+    }
+    
+    @Test(expected=IllegalArgumentException.class)
+    public void whenUsingBiMapAddDuplicateValue_shouldThrowException() {
+        HashBiMap<String, String> capitalCountryMap = HashBiMap.create();
+        capitalCountryMap.put("Berlin", "Germany");
+        capitalCountryMap.put("Cape Town", "South Africa");
+        capitalCountryMap.put("Pretoria", "South Africa");
+        assertEquals("Berlin", capitalCountryMap.inverse().get("Germany"));
+    }
+
+}

core-java-concurrency-collections/pom.xml

@@ -57,26 +57,6 @@
                 <filtering>true</filtering>
             </resource>
         </resources>
-
-        <plugins>
-            <plugin>
-                <groupId>org.apache.maven.plugins</groupId>
-                <artifactId>maven-dependency-plugin</artifactId>
-                <executions>
-                    <execution>
-                        <id>copy-dependencies</id>
-                        <phase>prepare-package</phase>
-                        <goals>
-                            <goal>copy-dependencies</goal>
-                        </goals>
-                        <configuration>
-                            <outputDirectory>${project.build.directory}/libs</outputDirectory>
-                        </configuration>
-                    </execution>
-                </executions>
-            </plugin>
-            
-        </plugins>
     </build>
 
     <properties>

core-java-concurrency/pom.xml

@@ -57,26 +57,6 @@
                 <filtering>true</filtering>
             </resource>
         </resources>
-
-        <plugins>
-            <plugin>
-                <groupId>org.apache.maven.plugins</groupId>
-                <artifactId>maven-dependency-plugin</artifactId>
-                <executions>
-                    <execution>
-                        <id>copy-dependencies</id>
-                        <phase>prepare-package</phase>
-                        <goals>
-                            <goal>copy-dependencies</goal>
-                        </goals>
-                        <configuration>
-                            <outputDirectory>${project.build.directory}/libs</outputDirectory>
-                        </configuration>
-                    </execution>
-                </executions>
-            </plugin>
-            
-        </plugins>
     </build>
 
     <properties>

core-java-io/README.md

@@ -30,3 +30,4 @@
 - [Download a File From an URL in Java](http://www.baeldung.com/java-download-file)
 - [Create a Symbolic Link with Java](http://www.baeldung.com/java-symlink)
 - [Quick Use of FilenameFilter](http://www.baeldung.com/java-filename-filter)
+- [Initialize a HashMap in Java](https://www.baeldung.com/java-initialize-hashmap)

core-java-persistence/README.md

@@ -6,3 +6,4 @@
 - [Introduction to JDBC](http://www.baeldung.com/java-jdbc)
 - [Batch Processing in JDBC](http://www.baeldung.com/jdbc-batch-processing)
 - [Introduction to the JDBC RowSet Interface in Java](http://www.baeldung.com/java-jdbc-rowset)
+- [A Simple Guide to Connection Pooling in Java](https://www.baeldung.com/java-connection-pooling)

core-java-sun/pom.xml

@@ -166,22 +166,6 @@
             </resource>
         </resources>
         <plugins>
-            <plugin>
-                <groupId>org.apache.maven.plugins</groupId>
-                <artifactId>maven-dependency-plugin</artifactId>
-                <executions>
-                    <execution>
-                        <id>copy-dependencies</id>
-                        <phase>prepare-package</phase>
-                        <goals>
-                            <goal>copy-dependencies</goal>
-                        </goals>
-                        <configuration>
-                            <outputDirectory>${project.build.directory}/libs</outputDirectory>
-                        </configuration>
-                    </execution>
-                </executions>
-            </plugin>
             <plugin>
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-jar-plugin</artifactId>

core-java/README.md

@@ -145,3 +145,9 @@
 - [Common Java Exceptions](http://www.baeldung.com/java-common-exceptions)
 - [Java Constructors vs Static Factory Methods](https://www.baeldung.com/java-constructors-vs-static-factory-methods)
 - [Differences Between Final, Finally and Finalize in Java](https://www.baeldung.com/java-final-finally-finalize)
+- [Static and Dynamic Binding in Java](https://www.baeldung.com/java-static-dynamic-binding)
+- [Java List Initialization in One Line](https://www.baeldung.com/java-init-list-one-line)
+- [Difference Between Throw and Throws in Java](https://www.baeldung.com/java-throw-throws)
+- [ClassCastException: Arrays$ArrayList cannot be cast to ArrayList](https://www.baeldung.com/java-classcastexception-arrays-arraylist)
+- [Throw Exception in Optional in Java 8](https://www.baeldung.com/java-optional-throw-exception)
+- [Add a Character to a String at a Given Position](https://www.baeldung.com/java-add-character-to-string)

core-java/src/main/java/com/baeldung/decimalformat/DoubletoString.java

@@ -0,0 +1,38 @@
+package com.baeldung.decimalformat;
+
+ import java.math.RoundingMode;
+ import java.text.DecimalFormat;
+ import java.text.NumberFormat;
+ import java.util.Locale;
+
+ public class DoubletoString {
+
+     public static void main(String[] args) {
+
+         double doubleValue = 345.56;
+
+         System.out.println(String.valueOf((int) doubleValue));
+
+         System.out.println(String.format("%.0f", doubleValue));
+
+         doubleValue = Math.floor(doubleValue);
+         DecimalFormat df = new DecimalFormat("#");
+         df.setRoundingMode(RoundingMode.FLOOR);
+         System.out.println(df.format(doubleValue));
+         
+         Locale enlocale = new Locale("en", "US");
+         String pattern = "###,##";
+         df = (DecimalFormat) NumberFormat.getNumberInstance(enlocale);
+         df.applyPattern(pattern);
+         String format = df.format(doubleValue);
+         System.out.println(format);
+
+         Locale dalocale = new Locale("da", "DK");
+         df = (DecimalFormat) NumberFormat.getNumberInstance(dalocale);
+         df.applyPattern(pattern);
+         System.out.println(df.format(doubleValue));
+
+
+     }
+
+ }

core-kotlin/README.md

@@ -8,7 +8,6 @@
 - [Generics in Kotlin](http://www.baeldung.com/kotlin-generics)
 - [Introduction to Kotlin Coroutines](http://www.baeldung.com/kotlin-coroutines)
 - [Destructuring Declarations in Kotlin](http://www.baeldung.com/kotlin-destructuring-declarations)
-- [Kotlin with Mockito](http://www.baeldung.com/kotlin-mockito)
 - [Lazy Initialization in Kotlin](http://www.baeldung.com/kotlin-lazy-initialization)
 - [Overview of Kotlin Collections API](http://www.baeldung.com/kotlin-collections-api)
 - [Converting a List to Map in Kotlin](http://www.baeldung.com/kotlin-list-to-map)
@@ -19,8 +18,6 @@
 - [Extension Methods in Kotlin](http://www.baeldung.com/kotlin-extension-methods)
 - [Infix Functions in Kotlin](http://www.baeldung.com/kotlin-infix-functions)
 - [Try-with-resources in Kotlin](http://www.baeldung.com/kotlin-try-with-resources)
-- [HTTP Requests with Kotlin and khttp](http://www.baeldung.com/kotlin-khttp)
-- [Kotlin Dependency Injection with Kodein](http://www.baeldung.com/kotlin-kodein-dependency-injection)
 - [Regular Expressions in Kotlin](http://www.baeldung.com/kotlin-regular-expressions)
 - [Objects in Kotlin](http://www.baeldung.com/kotlin-objects)
 - [Reading from a File in Kotlin](http://www.baeldung.com/kotlin-read-file)
@@ -28,13 +25,12 @@
 - [Filtering Kotlin Collections](http://www.baeldung.com/kotlin-filter-collection)
 - [Writing to a File in Kotlin](http://www.baeldung.com/kotlin-write-file)
 - [Lambda Expressions in Kotlin](http://www.baeldung.com/kotlin-lambda-expressions)
-- [Writing Specifications with Kotlin and Spek](http://www.baeldung.com/kotlin-spek)
-- [Processing JSON with Kotlin and Klaxson](http://www.baeldung.com/kotlin-json-klaxson)
 - [Kotlin String Templates](http://www.baeldung.com/kotlin-string-template)
-- [Java EE 8 Security API](http://www.baeldung.com/java-ee-8-security)
-- [Kotlin with Ktor](http://www.baeldung.com/kotlin-ktor)
 - [Working with Enums in Kotlin](http://www.baeldung.com/kotlin-enum)
 - [Create a Java and Kotlin Project with Maven](http://www.baeldung.com/kotlin-maven-java-project)
 - [Reflection with Kotlin](http://www.baeldung.com/kotlin-reflection)
 - [Get a Random Number in Kotlin](http://www.baeldung.com/kotlin-random-number)
 - [Idiomatic Logging in Kotlin](http://www.baeldung.com/kotlin-logging)
+- [Kotlin Constructors](https://www.baeldung.com/kotlin-constructors)
+- [Creational Design Patterns in Kotlin: Builder](https://www.baeldung.com/kotlin-builder-pattern)
+- [Kotlin Nested and Inner Classes](https://www.baeldung.com/kotlin-inner-classes)

core-kotlin/build.gradle

@@ -6,7 +6,6 @@ version '1.0-SNAPSHOT'
 
 buildscript {
     ext.kotlin_version = '1.2.41'
-    ext.ktor_version = '0.9.2'
 
     repositories {
         mavenCentral()
@@ -44,14 +43,6 @@ sourceSets {
 }
 
 dependencies {
-    compile "io.ktor:ktor-server-netty:$ktor_version"
     compile "ch.qos.logback:logback-classic:1.2.1"
-    compile "io.ktor:ktor-gson:$ktor_version"
     testCompile group: 'junit', name: 'junit', version: '4.12'
-    implementation 'com.beust:klaxon:3.0.1'
-
-}
-task runServer(type: JavaExec) {
-    main = 'APIServer'
-   classpath = sourceSets.main.runtimeClasspath
 }

core-kotlin/kotlin-ktor/webapp/WEB-INF/web.xml

@@ -1,35 +0,0 @@
-<?xml version="1.0" encoding="ISO-8859-1" ?>
-
-<web-app xmlns="http://java.sun.com/xml/ns/javaee"
-  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-  xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
-  version="3.0">
-  <!-- path to application.conf file, required -->
-  <!-- note that this file is always loaded as an absolute path from the classpath -->
-  <context-param>
-    <param-name>io.ktor.ktor.config</param-name>
-    <param-value>application.conf</param-value>
-  </context-param>
-
-  <servlet>
-    <display-name>KtorServlet</display-name>
-    <servlet-name>KtorServlet</servlet-name>
-    <servlet-class>io.ktor.server.servlet.ServletApplicationEngine</servlet-class>
-
-    <!-- required! -->
-    <async-supported>true</async-supported>
-
-    <!-- 100mb max file upload, optional -->
-    <multipart-config>
-      <max-file-size>304857600</max-file-size>
-      <max-request-size>304857600</max-request-size>
-      <file-size-threshold>0</file-size-threshold>
-    </multipart-config>
-  </servlet>
-
-  <servlet-mapping>
-    <servlet-name>KtorServlet</servlet-name>
-    <url-pattern>/</url-pattern>
-  </servlet-mapping>
-
-</web-app>

core-kotlin/pom.xml

@@ -12,33 +12,7 @@
         <relativePath>../parent-kotlin</relativePath>
     </parent>
 
-    <repositories>
-        <repository>
-            <id>exposed</id>
-            <name>exposed</name>
-            <url>https://dl.bintray.com/kotlin/exposed</url>
-        </repository>
-    </repositories>
-
     <dependencies>
-        <dependency>
-            <groupId>org.jetbrains.spek</groupId>
-            <artifactId>spek-api</artifactId>
-            <version>1.1.5</version>
-            <scope>test</scope>
-        </dependency>
-        <dependency>
-            <groupId>org.jetbrains.spek</groupId>
-            <artifactId>spek-subject-extension</artifactId>
-            <version>1.1.5</version>
-            <scope>test</scope>
-        </dependency>
-        <dependency>
-            <groupId>org.jetbrains.spek</groupId>
-            <artifactId>spek-junit-platform-engine</artifactId>
-            <version>1.1.5</version>
-            <scope>test</scope>
-        </dependency>
         <dependency>
             <groupId>org.apache.commons</groupId>
             <artifactId>commons-math3</artifactId>
@@ -50,56 +24,52 @@
             <version>${junit.platform.version}</version>
             <scope>test</scope>
         </dependency>
-        <dependency>
-            <groupId>khttp</groupId>
-            <artifactId>khttp</artifactId>
-            <version>${khttp.version}</version>
-        </dependency>
-        <dependency>
-            <groupId>com.nhaarman</groupId>
-            <artifactId>mockito-kotlin</artifactId>
-            <version>${mockito-kotlin.version}</version>
-            <scope>test</scope>
-        </dependency>
-        <dependency>
-            <groupId>com.github.salomonbrys.kodein</groupId>
-            <artifactId>kodein</artifactId>
-            <version>${kodein.version}</version>
-        </dependency>
         <dependency>
             <groupId>org.assertj</groupId>
             <artifactId>assertj-core</artifactId>
             <version>${assertj.version}</version>
             <scope>test</scope>
         </dependency>
-        <dependency>
-            <groupId>com.beust</groupId>
-            <artifactId>klaxon</artifactId>
-            <version>${klaxon.version}</version>
-        </dependency>
-        <dependency>
-            <groupId>org.jetbrains.exposed</groupId>
-            <artifactId>exposed</artifactId>
-            <version>${exposed.version}</version>
-        </dependency>
         <dependency>
             <groupId>com.h2database</groupId>
             <artifactId>h2</artifactId>
             <version>${h2database.version}</version>
         </dependency>
+        <dependency>
+            <groupId>com.github.kittinunf.fuel</groupId>
+            <artifactId>fuel</artifactId>
+            <version>${fuel.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>com.github.kittinunf.fuel</groupId>
+            <artifactId>fuel-gson</artifactId>
+            <version>${fuel.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>com.github.kittinunf.fuel</groupId>
+            <artifactId>fuel-rxjava</artifactId>
+            <version>${fuel.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>com.github.kittinunf.fuel</groupId>
+            <artifactId>fuel-coroutines</artifactId>
+            <version>${fuel.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>nl.komponents.kovenant</groupId>
+            <artifactId>kovenant</artifactId>
+            <version>3.3.0</version>
+            <type>pom</type>
+        </dependency>
     </dependencies>
 
     <properties>
-        <mockito-kotlin.version>1.5.0</mockito-kotlin.version>
-        <kodein.version>4.1.0</kodein.version>
-        <klaxon.version>3.0.4</klaxon.version>
-        <khttp.version>0.1.0</khttp.version>
         <commons-math3.version>3.6.1</commons-math3.version>
         <junit.platform.version>1.1.1</junit.platform.version>
         <junit.vintage.version>5.2.0</junit.vintage.version>
         <assertj.version>3.10.0</assertj.version>
         <h2database.version>1.4.197</h2database.version>
-        <exposed.version>0.10.4</exposed.version>
+        <fuel.version>1.15.0</fuel.version>
     </properties>
 
 </project>

core-kotlin/src/main/kotlin/com/baeldung/fuel/Interceptors.kt

@@ -0,0 +1,11 @@
+package com.baeldung.fuel
+
+import com.github.kittinunf.fuel.core.Request
+
+fun tokenInterceptor() = {
+    next: (Request) -> Request ->
+    { req: Request ->
+        req.header(mapOf("Authorization" to "Bearer AbCdEf123456"))
+        next(req)
+    }
+}

core-kotlin/src/main/kotlin/com/baeldung/fuel/Post.kt

@@ -0,0 +1,15 @@
+package com.baeldung.fuel
+
+import com.github.kittinunf.fuel.core.ResponseDeserializable
+import com.google.gson.Gson
+
+data class Post(var userId:Int,
+                var id:Int,
+                var title:String,
+                var body:String){
+
+
+    class Deserializer : ResponseDeserializable<Array<Post>> {
+        override fun deserialize(content: String): Array<Post> = Gson().fromJson(content, Array<Post>::class.java)
+    }
+}

core-kotlin/src/main/kotlin/com/baeldung/fuel/PostRoutingAPI.kt

@@ -0,0 +1,42 @@
+package com.baeldung.fuel
+
+import com.github.kittinunf.fuel.core.Method
+import com.github.kittinunf.fuel.util.FuelRouting
+
+sealed class PostRoutingAPI : FuelRouting {
+
+    override val basePath = "https://jsonplaceholder.typicode.com"
+
+    class posts(val id: String, override val body: String?): PostRoutingAPI()
+
+    class comments(val postId: String, override val body: String?): PostRoutingAPI()
+
+    override val method: Method
+        get() {
+            return when(this) {
+                is PostRoutingAPI.posts -> Method.GET
+                is PostRoutingAPI.comments -> Method.GET
+            }
+        }
+
+    override val path: String
+        get() {
+            return when(this) {
+                is PostRoutingAPI.posts -> "/posts"
+                is PostRoutingAPI.comments -> "/comments"
+            }
+        }
+
+    override val params: List<Pair<String, Any?>>?
+        get() {
+            return when(this) {
+                is PostRoutingAPI.posts -> listOf("id" to this.id)
+                is PostRoutingAPI.comments -> listOf("postId" to this.postId)
+            }
+        }
+
+    override val headers: Map<String, String>?
+        get() {
+            return null
+        }
+}

core-kotlin/src/main/kotlin/com/baeldung/ktor/APIServer.kt

@@ -1,73 +0,0 @@
-@file:JvmName("APIServer")
-
-
-import io.ktor.application.call
-import io.ktor.application.install
-import io.ktor.features.CallLogging
-import io.ktor.features.ContentNegotiation
-import io.ktor.features.DefaultHeaders
-import io.ktor.gson.gson
-import io.ktor.request.path
-import io.ktor.request.receive
-import io.ktor.response.respond
-import io.ktor.routing.*
-import io.ktor.server.engine.embeddedServer
-import io.ktor.server.netty.Netty
-import org.slf4j.event.Level
-
-data class Author(val name: String, val website: String)
-data class ToDo(var id: Int, val name: String, val description: String, val completed: Boolean)
-
-fun main(args: Array<String>) {
-
-    val toDoList = ArrayList<ToDo>();
-    val jsonResponse = """{
-            "id": 1,
-            "task": "Pay waterbill",
-            "description": "Pay water bill today",
-        }"""
-
-
-    embeddedServer(Netty, 8080) {
-        install(DefaultHeaders) {
-            header("X-Developer", "Baeldung")
-        }
-        install(CallLogging) {
-            level = Level.DEBUG
-            filter { call -> call.request.path().startsWith("/todo") }
-            filter { call -> call.request.path().startsWith("/author") }
-        }
-        install(ContentNegotiation) {
-            gson {
-                setPrettyPrinting()
-            }
-        }
-        routing() {
-            route("/todo") {
-                post {
-                    var toDo = call.receive<ToDo>();
-                    toDo.id = toDoList.size;
-                    toDoList.add(toDo);
-                    call.respond("Added")
-
-                }
-                delete("/{id}") {
-                    call.respond(toDoList.removeAt(call.parameters["id"]!!.toInt()));
-                }
-                get("/{id}") {
-
-                    call.respond(toDoList[call.parameters["id"]!!.toInt()]);
-                }
-                get {
-                    call.respond(toDoList);
-                }
-            }
-        get("/author"){
-            call.respond(Author("Baeldung","baeldung.com"));
-
-        }
-
-
-        }
-    }.start(wait = true)
-}

core-kotlin/src/test/kotlin/com/baeldung/builder/BuilderPatternUnitTest.kt

@@ -93,6 +93,7 @@ internal class BuilderPatternUnitTest {
         Assertions.assertNull(foodOrder.fish)
     }
 
+
     @Test
     fun whenBuildingFoodOrderApplySettingValues_thenFieldsNotNull() {
 

core-kotlin/src/test/kotlin/com/baeldung/fuel/FuelHttpUnitTest.kt

@@ -0,0 +1,286 @@
+package com.baeldung.fuel
+
+import awaitObjectResult
+import awaitStringResponse
+import com.github.kittinunf.fuel.Fuel
+import com.github.kittinunf.fuel.core.FuelManager
+import com.github.kittinunf.fuel.core.Request
+import com.github.kittinunf.fuel.core.interceptors.cUrlLoggingRequestInterceptor
+import com.github.kittinunf.fuel.gson.responseObject
+import com.github.kittinunf.fuel.httpGet
+import com.github.kittinunf.fuel.rx.rx_object
+import com.google.gson.Gson
+import kotlinx.coroutines.experimental.runBlocking
+import org.junit.jupiter.api.Assertions
+import org.junit.jupiter.api.Test
+import java.io.File
+import java.util.concurrent.CountDownLatch
+
+internal class FuelHttpUnitTest {
+
+    @Test
+    fun whenMakingAsyncHttpGetRequest_thenResponseNotNullAndErrorNullAndStatusCode200() {
+
+        val latch = CountDownLatch(1)
+
+        "http://httpbin.org/get".httpGet().response{
+            request, response, result ->
+
+            val (data, error) = result
+
+            Assertions.assertNull(error)
+            Assertions.assertNotNull(data)
+            Assertions.assertEquals(200,response.statusCode)
+
+            latch.countDown()
+        }
+
+        latch.await()
+
+    }
+
+    @Test
+    fun whenMakingSyncHttpGetRequest_thenResponseNotNullAndErrorNullAndStatusCode200() {
+
+        val (request, response, result) = "http://httpbin.org/get".httpGet().response()
+        val (data, error) = result
+
+        Assertions.assertNull(error)
+        Assertions.assertNotNull(data)
+        Assertions.assertEquals(200,response.statusCode)
+
+    }
+
+    @Test
+    fun whenMakingSyncHttpGetURLEncodedRequest_thenResponseNotNullAndErrorNullAndStatusCode200() {
+
+        val (request, response, result) =
+          "https://jsonplaceholder.typicode.com/posts"
+          .httpGet(listOf("id" to "1")).response()
+        val (data, error) = result
+
+        Assertions.assertNull(error)
+        Assertions.assertNotNull(data)
+        Assertions.assertEquals(200,response.statusCode)
+
+    }
+
+    @Test
+    fun whenMakingAsyncHttpPostRequest_thenResponseNotNullAndErrorNullAndStatusCode200() {
+
+        val latch = CountDownLatch(1)
+
+        Fuel.post("http://httpbin.org/post").response{
+            request, response, result ->
+
+            val (data, error) = result
+
+            Assertions.assertNull(error)
+            Assertions.assertNotNull(data)
+            Assertions.assertEquals(200,response.statusCode)
+
+            latch.countDown()
+        }
+
+        latch.await()
+
+    }
+
+    @Test
+    fun whenMakingSyncHttpPostRequest_thenResponseNotNullAndErrorNullAndStatusCode200() {
+
+        val (request, response, result) = Fuel.post("http://httpbin.org/post").response()
+        val (data, error) = result
+
+        Assertions.assertNull(error)
+        Assertions.assertNotNull(data)
+        Assertions.assertEquals(200,response.statusCode)
+    }
+
+    @Test
+    fun whenMakingSyncHttpPostRequestwithBody_thenResponseNotNullAndErrorNullAndStatusCode200() {
+
+        val (request, response, result) = Fuel.post("https://jsonplaceholder.typicode.com/posts")
+          .body("{ \"title\" : \"foo\",\"body\" : \"bar\",\"id\" : \"1\"}")
+          .response()
+
+        val (data, error) = result
+
+        Assertions.assertNull(error)
+        Assertions.assertNotNull(data)
+        Assertions.assertEquals(201,response.statusCode)
+    }
+
+    @Test
+    fun givenFuelInstance_whenMakingSyncHttpGetRequest_thenResponseNotNullAndErrorNullAndStatusCode200() {
+
+        FuelManager.instance.basePath = "http://httpbin.org"
+        FuelManager.instance.baseHeaders = mapOf("OS" to "macOS High Sierra")
+
+        FuelManager.instance.addRequestInterceptor(cUrlLoggingRequestInterceptor())
+        FuelManager.instance.addRequestInterceptor(tokenInterceptor())
+
+
+        val (request, response, result) = "/get"
+          .httpGet().response()
+        val (data, error) = result
+
+        Assertions.assertNull(error)
+        Assertions.assertNotNull(data)
+        Assertions.assertEquals(200,response.statusCode)
+    }
+
+    @Test
+    fun givenInterceptors_whenMakingSyncHttpGetRequest_thenResponseNotNullAndErrorNullAndStatusCode200() {
+
+        FuelManager.instance.basePath = "http://httpbin.org"
+        FuelManager.instance.addRequestInterceptor(cUrlLoggingRequestInterceptor())
+        FuelManager.instance.addRequestInterceptor(tokenInterceptor())
+
+        val (request, response, result) = "/get"
+                .httpGet().response()
+        val (data, error) = result
+
+        Assertions.assertNull(error)
+        Assertions.assertNotNull(data)
+        Assertions.assertEquals(200,response.statusCode)
+    }
+
+    @Test
+    fun whenDownloadFile_thenCreateFileResponseNotNullAndErrorNullAndStatusCode200() {
+
+        Fuel.download("http://httpbin.org/bytes/32768").destination { response, url ->
+            File.createTempFile("temp", ".tmp")
+        }.response{
+            request, response, result ->
+
+            val (data, error) = result
+            Assertions.assertNull(error)
+            Assertions.assertNotNull(data)
+            Assertions.assertEquals(200,response.statusCode)
+        }
+    }
+
+    @Test
+    fun whenDownloadFilewithProgressHandler_thenCreateFileResponseNotNullAndErrorNullAndStatusCode200() {
+
+        val (request, response, result) = Fuel.download("http://httpbin.org/bytes/327680")
+          .destination { response, url -> File.createTempFile("temp", ".tmp")
+        }.progress { readBytes, totalBytes ->
+            val progress = readBytes.toFloat() / totalBytes.toFloat()
+        }.response ()
+
+        val (data, error) = result
+        Assertions.assertNull(error)
+        Assertions.assertNotNull(data)
+        Assertions.assertEquals(200,response.statusCode)
+
+
+    }
+
+    @Test
+    fun whenMakeGetRequest_thenDeserializePostwithGson() {
+
+        val latch = CountDownLatch(1)
+
+        "https://jsonplaceholder.typicode.com/posts/1".httpGet().responseObject<Post> { _,_, result ->
+            val post = result.component1()
+            Assertions.assertEquals(1, post?.userId)
+            latch.countDown()
+        }
+
+        latch.await()
+
+    }
+
+    @Test
+    fun whenMakePOSTRequest_thenSerializePostwithGson() {
+
+        val post = Post(1,1, "Lorem", "Lorem Ipse dolor sit amet")
+
+        val (request, response, result) = Fuel.post("https://jsonplaceholder.typicode.com/posts")
+                .header("Content-Type" to "application/json")
+                .body(Gson().toJson(post).toString())
+                .response()
+
+        Assertions.assertEquals(201,response.statusCode)
+
+    }
+
+    @Test
+    fun whenMakeGETRequestWithRxJava_thenDeserializePostwithGson() {
+
+        val latch = CountDownLatch(1)
+
+
+        "https://jsonplaceholder.typicode.com/posts?id=1"
+                .httpGet().rx_object(Post.Deserializer()).subscribe{
+                    res, throwable ->
+
+                    val post = res.component1()
+                    Assertions.assertEquals(1, post?.get(0)?.userId)
+                    latch.countDown()
+                }
+
+        latch.await()
+
+    }
+
+    @Test
+    fun whenMakeGETRequestUsingCoroutines_thenResponseStatusCode200() {
+
+        runBlocking {
+            val (request, response, result) = Fuel.get("http://httpbin.org/get").awaitStringResponse()
+
+            result.fold({ data ->
+                Assertions.assertEquals(200, response.statusCode)
+
+            }, { error -> })
+        }
+
+    }
+
+    @Test
+    fun whenMakeGETRequestUsingCoroutines_thenDeserializeResponse() {
+
+
+        runBlocking {
+            Fuel.get("https://jsonplaceholder.typicode.com/posts?id=1").awaitObjectResult(Post.Deserializer())
+                    .fold({ data ->
+                        Assertions.assertEquals(1, data.get(0).userId)
+                    }, { error -> })
+        }
+
+    }
+
+    @Test
+    fun whenMakeGETPostRequestUsingRoutingAPI_thenDeserializeResponse() {
+
+        val latch = CountDownLatch(1)
+
+        Fuel.request(PostRoutingAPI.posts("1",null))
+          .responseObject(Post.Deserializer()) {
+              request, response, result ->
+              Assertions.assertEquals(1, result.component1()?.get(0)?.userId)
+              latch.countDown()
+          }
+
+        latch.await()
+    }
+
+    @Test
+    fun whenMakeGETCommentRequestUsingRoutingAPI_thenResponseStausCode200() {
+
+        val latch = CountDownLatch(1)
+
+        Fuel.request(PostRoutingAPI.comments("1",null))
+          .responseString { request, response, result ->
+            Assertions.assertEquals(200, response.statusCode)
+            latch.countDown()
+          }
+
+        latch.await()
+    }
+
+
+}

core-kotlin/src/test/kotlin/com/baeldung/kotlin/KovenantTest.kt

@@ -0,0 +1,191 @@
+package com.baeldung.kotlin
+
+import nl.komponents.kovenant.*
+import nl.komponents.kovenant.Kovenant.deferred
+import nl.komponents.kovenant.combine.and
+import nl.komponents.kovenant.combine.combine
+import org.junit.Assert
+import org.junit.Before
+import org.junit.Test
+import java.io.IOException
+import java.util.*
+import java.util.concurrent.TimeUnit
+
+class KovenantTest {
+    @Before
+    fun setupTestMode() {
+        Kovenant.testMode { error ->
+            println("An unexpected error occurred")
+            Assert.fail(error.message)
+        }
+    }
+
+    @Test
+    fun testSuccessfulDeferred() {
+        val def = deferred<Long, Exception>()
+        Assert.assertFalse(def.promise.isDone())
+
+        def.resolve(1L)
+        Assert.assertTrue(def.promise.isDone())
+        Assert.assertTrue(def.promise.isSuccess())
+        Assert.assertFalse(def.promise.isFailure())
+    }
+
+    @Test
+    fun testFailedDeferred() {
+        val def = deferred<Long, Exception>()
+        Assert.assertFalse(def.promise.isDone())
+
+        def.reject(RuntimeException())
+        Assert.assertTrue(def.promise.isDone())
+        Assert.assertFalse(def.promise.isSuccess())
+        Assert.assertTrue(def.promise.isFailure())
+    }
+
+    @Test
+    fun testResolveDeferredTwice() {
+        val def = deferred<Long, Exception>()
+        def.resolve(1L)
+        try {
+            def.resolve(1L)
+        } catch (e: AssertionError) {
+            // Expected.
+            // This is slightly unusual. The AssertionError comes from Assert.fail() from setupTestMode()
+        }
+    }
+
+    @Test
+    fun testSuccessfulTask() {
+        val promise = task { 1L }
+        Assert.assertTrue(promise.isDone())
+        Assert.assertTrue(promise.isSuccess())
+        Assert.assertFalse(promise.isFailure())
+    }
+
+    @Test
+    fun testFailedTask() {
+        val promise = task { throw RuntimeException() }
+        Assert.assertTrue(promise.isDone())
+        Assert.assertFalse(promise.isSuccess())
+        Assert.assertTrue(promise.isFailure())
+    }
+
+    @Test
+    fun testCallbacks() {
+        val promise = task { 1L }
+
+        promise.success {
+            println("This was a success")
+            Assert.assertEquals(1L, it)
+        }
+
+        promise.fail {
+            println(it)
+            Assert.fail("This shouldn't happen")
+        }
+
+        promise.always {
+            println("This always happens")
+        }
+    }
+
+    @Test
+    fun testGetValues() {
+        val promise = task { 1L }
+        Assert.assertEquals(1L, promise.get())
+    }
+
+    @Test
+    fun testAllSucceed() {
+        val numbers = all(
+                task { 1L },
+                task { 2L },
+                task { 3L }
+        )
+
+        Assert.assertEquals(listOf(1L, 2L, 3L), numbers.get())
+    }
+
+    @Test
+    fun testOneFails() {
+        val runtimeException = RuntimeException()
+
+        val numbers = all(
+                task { 1L },
+                task { 2L },
+                task { throw runtimeException }
+        )
+
+        Assert.assertEquals(runtimeException, numbers.getError())
+    }
+
+    @Test
+    fun testAnySucceeds() {
+        val promise = any(
+                task {
+                    TimeUnit.SECONDS.sleep(3)
+                    1L
+                },
+                task {
+                    TimeUnit.SECONDS.sleep(2)
+                    2L
+                },
+                task {
+                    TimeUnit.SECONDS.sleep(1)
+                    3L
+                }
+        )
+
+        Assert.assertTrue(promise.isDone())
+        Assert.assertTrue(promise.isSuccess())
+        Assert.assertFalse(promise.isFailure())
+    }
+
+    @Test
+    fun testAllFails() {
+        val runtimeException = RuntimeException()
+        val ioException = IOException()
+        val illegalStateException = IllegalStateException()
+        val promise = any(
+                task {
+                    TimeUnit.SECONDS.sleep(3)
+                    throw runtimeException
+                },
+                task {
+                    TimeUnit.SECONDS.sleep(2)
+                    throw ioException
+                },
+                task {
+                    TimeUnit.SECONDS.sleep(1)
+                    throw illegalStateException
+                }
+        )
+
+        Assert.assertTrue(promise.isDone())
+        Assert.assertFalse(promise.isSuccess())
+        Assert.assertTrue(promise.isFailure())
+    }
+
+    @Test
+    fun testSimpleCombine() {
+        val promise = task { 1L } and task { "Hello" }
+        val result = promise.get()
+
+        Assert.assertEquals(1L, result.first)
+        Assert.assertEquals("Hello", result.second)
+    }
+
+    @Test
+    fun testLongerCombine() {
+        val promise = combine(
+                task { 1L },
+                task { "Hello" },
+                task { Currency.getInstance("USD") }
+        )
+        val result = promise.get()
+
+        Assert.assertEquals(1L, result.first)
+        Assert.assertEquals("Hello", result.second)
+        Assert.assertEquals(Currency.getInstance("USD"), result.third)
+    }
+}

core-kotlin/src/test/kotlin/com/baeldung/kotlin/KovenantTimeoutTest.kt

@@ -0,0 +1,38 @@
+package com.baeldung.kotlin
+
+import nl.komponents.kovenant.Promise
+import nl.komponents.kovenant.any
+import nl.komponents.kovenant.task
+import org.junit.Assert
+import org.junit.Ignore
+import org.junit.Test
+
+@Ignore
+// Note that this can not run in the same test run if KovenantTest has already been executed
+class KovenantTimeoutTest {
+    @Test
+    fun testTimeout() {
+        val promise = timedTask(1000) { "Hello" }
+        val result = promise.get()
+        Assert.assertEquals("Hello", result)
+    }
+
+    @Test
+    fun testTimeoutExpired() {
+        val promise = timedTask(1000) {
+            Thread.sleep(3000)
+            "Hello"
+        }
+        val result = promise.get()
+        Assert.assertNull(result)
+    }
+
+    fun <T> timedTask(millis: Long, body: () -> T) : Promise<T?, List<Exception>> {
+        val timeoutTask = task {
+            Thread.sleep(millis)
+            null
+        }
+        val activeTask = task(body = body)
+        return any(activeTask, timeoutTask)
+    }
+}

disruptor/pom.xml

@@ -36,22 +36,6 @@
             </resource>
         </resources>
         <plugins>
-            <plugin>
-                <groupId>org.apache.maven.plugins</groupId>
-                <artifactId>maven-dependency-plugin</artifactId>
-                <executions>
-                    <execution>
-                        <id>copy-dependencies</id>
-                        <phase>prepare-package</phase>
-                        <goals>
-                            <goal>copy-dependencies</goal>
-                        </goals>
-                        <configuration>
-                            <outputDirectory>${project.build.directory}/libs</outputDirectory>
-                        </configuration>
-                    </execution>
-                </executions>
-            </plugin>
             <plugin>
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-jar-plugin</artifactId>

drools/pom.xml

@@ -48,12 +48,18 @@
             <artifactId>poi-ooxml</artifactId>
             <version>${apache-poi-version}</version>
         </dependency>
+        <dependency>
+            <groupId>org.optaplanner</groupId>
+            <artifactId>optaplanner-core</artifactId>
+            <version>${opta-planner-version}</version>
+        </dependency>
     </dependencies>
 
     <properties>
         <http-component-version>4.4.6</http-component-version>
         <drools-version>7.4.1.Final</drools-version>
         <apache-poi-version>3.13</apache-poi-version>
+        <opta-planner-version>7.10.0.Final</opta-planner-version>
     </properties>
 
 </project>

drools/src/main/java/com/baeldung/drools/optaplanner/CourseSchedule.java

@@ -0,0 +1,63 @@
+package com.baeldung.drools.optaplanner;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.optaplanner.core.api.domain.solution.PlanningEntityCollectionProperty;
+import org.optaplanner.core.api.domain.solution.PlanningScore;
+import org.optaplanner.core.api.domain.solution.PlanningSolution;
+import org.optaplanner.core.api.domain.solution.drools.ProblemFactCollectionProperty;
+import org.optaplanner.core.api.domain.valuerange.ValueRangeProvider;
+import org.optaplanner.core.api.score.buildin.hardsoft.HardSoftScore;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+@PlanningSolution
+public class CourseSchedule {
+
+    Logger logger = LoggerFactory.getLogger("CourseSchedule");
+
+    private List<Integer> roomList;
+    private List<Integer> periodList;
+    private List<Lecture> lectureList;
+    private HardSoftScore score;
+
+    public CourseSchedule(){
+        roomList = new ArrayList<>();
+        periodList = new ArrayList<>();
+        lectureList = new ArrayList<>();
+    }
+
+    @ValueRangeProvider(id = "availableRooms")
+    @ProblemFactCollectionProperty
+    public List<Integer> getRoomList() {
+        return roomList;
+    }
+
+    @ValueRangeProvider(id = "availablePeriods")
+    @ProblemFactCollectionProperty
+    public List<Integer> getPeriodList() {
+        return periodList;
+    }
+
+    @PlanningEntityCollectionProperty
+    public List<Lecture> getLectureList() {
+        return lectureList;
+    }
+
+    @PlanningScore
+    public HardSoftScore getScore() {
+        return score;
+    }
+
+    public void setScore(HardSoftScore score) {
+        this.score = score;
+    }
+
+    public void printCourseSchedule() {
+        lectureList.stream()
+                .map(c -> "Lecture in Room " + c.getRoomNumber().toString() + " during Period " + c.getPeriod().toString())
+                .forEach(k -> logger.info(k));
+    }
+
+}

drools/src/main/java/com/baeldung/drools/optaplanner/Lecture.java

@@ -0,0 +1,30 @@
+package com.baeldung.drools.optaplanner;
+
+import org.optaplanner.core.api.domain.entity.PlanningEntity;
+import org.optaplanner.core.api.domain.variable.PlanningVariable;
+
+@PlanningEntity
+public class Lecture {
+
+    private Integer roomNumber;
+    private Integer period;
+
+    @PlanningVariable(valueRangeProviderRefs = {"availablePeriods"})
+    public Integer getPeriod() {
+        return period;
+    }
+
+    @PlanningVariable(valueRangeProviderRefs = {"availableRooms"})
+    public Integer getRoomNumber() {
+        return roomNumber;
+    }
+
+    public void setPeriod(Integer period) {
+        this.period = period;
+    }
+
+    public void setRoomNumber(Integer roomNumber) {
+        this.roomNumber = roomNumber;
+    }
+
+}

drools/src/main/java/com/baeldung/drools/optaplanner/ScoreCalculator.java

@@ -0,0 +1,32 @@
+package com.baeldung.drools.optaplanner;
+
+import java.util.HashSet;
+
+import org.optaplanner.core.api.score.Score;
+import org.optaplanner.core.api.score.buildin.hardsoft.HardSoftScore;
+import org.optaplanner.core.impl.score.director.easy.EasyScoreCalculator;
+
+public class ScoreCalculator implements EasyScoreCalculator<CourseSchedule> {
+
+    @Override
+    public Score calculateScore(CourseSchedule courseSchedule) {
+        int hardScore = 0;
+        int softScore = 0;
+
+        HashSet<String> occupiedRooms = new HashSet<>();
+        for (Lecture lecture : courseSchedule.getLectureList()) {
+            if(lecture.getPeriod() != null && lecture.getRoomNumber() != null) {
+                String roomInUse = lecture.getPeriod().toString() + ":" + lecture.getRoomNumber().toString();
+                if (occupiedRooms.contains(roomInUse)) {
+                    hardScore += -1;
+                } else {
+                    occupiedRooms.add(roomInUse);
+                }
+            } else {
+                hardScore += -1;
+            }
+        }
+
+        return HardSoftScore.valueOf(hardScore, softScore);
+    }
+}

drools/src/main/resources/courseSchedule.drl

@@ -0,0 +1,14 @@
+package com.baeldung.drools.optaplanner
+
+import com.baeldung.drools.optaplanner.Lecture;
+import org.optaplanner.core.api.score.buildin.hardsoft.HardSoftScoreHolder;
+
+global HardSoftScoreHolder scoreHolder;
+
+rule "noNullRoomPeriod"
+    when
+        Lecture( roomNumber == null );
+        Lecture( period == null );
+    then
+        scoreHolder.addHardConstraintMatch(kcontext, -1);
+end

drools/src/main/resources/courseScheduleSolverConfigDrools.xml

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<solver>
+    <scanAnnotatedClasses/>
+
+    <scoreDirectorFactory>
+        <scoreDrl>courseSchedule.drl</scoreDrl>
+    </scoreDirectorFactory>
+
+    <termination>
+        <secondsSpentLimit>10</secondsSpentLimit>
+    </termination>
+</solver>

drools/src/main/resources/courseScheduleSolverConfiguration.xml

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<solver>
+    <scanAnnotatedClasses/>
+
+    <scoreDirectorFactory>
+        <easyScoreCalculatorClass>com.baeldung.drools.optaplanner.ScoreCalculator</easyScoreCalculatorClass>
+    </scoreDirectorFactory>
+
+    <termination>
+        <secondsSpentLimit>10</secondsSpentLimit>
+    </termination>
+</solver>

drools/src/test/java/com/baeldung/drools/optaplanner/OptaPlannerUnitTest.java

@@ -0,0 +1,49 @@
+package com.baeldung.drools.optaplanner;
+
+import java.util.Arrays;
+
+import org.junit.Assert;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+import org.optaplanner.core.api.solver.Solver;
+import org.optaplanner.core.api.solver.SolverFactory;
+
+public class OptaPlannerUnitTest {
+
+    static CourseSchedule unsolvedCourseSchedule;
+
+    @BeforeAll
+    public static void setUp() {
+
+        unsolvedCourseSchedule = new CourseSchedule();
+
+        for(int i = 0; i < 10; i++){
+            unsolvedCourseSchedule.getLectureList().add(new Lecture());
+        }
+
+        unsolvedCourseSchedule.getPeriodList().addAll(Arrays.asList(new Integer[] { 1, 2, 3 }));
+        unsolvedCourseSchedule.getRoomList().addAll(Arrays.asList(new Integer[] { 1, 2 }));
+    }
+
+    @Test
+    public void test_whenCustomJavaSolver() {
+
+        SolverFactory<CourseSchedule> solverFactory = SolverFactory.createFromXmlResource("courseScheduleSolverConfiguration.xml");
+        Solver<CourseSchedule> solver = solverFactory.buildSolver();
+        CourseSchedule solvedCourseSchedule = solver.solve(unsolvedCourseSchedule);
+
+        Assert.assertNotNull(solvedCourseSchedule.getScore());
+        Assert.assertEquals(-4, solvedCourseSchedule.getScore().getHardScore());
+    }
+
+    @Test
+    public void test_whenDroolsSolver() {
+
+        SolverFactory<CourseSchedule> solverFactory = SolverFactory.createFromXmlResource("courseScheduleSolverConfigDrools.xml");
+        Solver<CourseSchedule> solver = solverFactory.buildSolver();
+        CourseSchedule solvedCourseSchedule = solver.solve(unsolvedCourseSchedule);
+
+        Assert.assertNotNull(solvedCourseSchedule.getScore());
+        Assert.assertEquals(0, solvedCourseSchedule.getScore().getHardScore());
+    }
+}

ejb/ejb-client/pom.xml

@@ -16,7 +16,6 @@
             <groupId>org.wildfly</groupId>
             <artifactId>wildfly-ejb-client-bom</artifactId>
             <type>pom</type>
-            <scope>import</scope>
         </dependency>
         <dependency>
             <groupId>com.baeldung.ejb</groupId>

ejb/pom.xml

@@ -17,7 +17,6 @@
 
     <modules>
         <module>ejb-remote</module>
-        <module>ejb-client</module>
         <module>ejb-session-beans</module>
     </modules>
 

enterprise-patterns/README.md

@@ -1 +0,0 @@
-## Relevant articles:

enterprise-patterns/intercepting-filter-pattern/src/main/java/com/baeldung/enterprise/patterns/front/controller/filters/AuditFilter.java

@@ -1,25 +0,0 @@
-package com.baeldung.enterprise.patterns.front.controller.filters;
-
-import javax.servlet.FilterChain;
-import javax.servlet.ServletException;
-import javax.servlet.ServletRequest;
-import javax.servlet.ServletResponse;
-import javax.servlet.http.HttpServletRequest;
-import javax.servlet.http.HttpSession;
-import java.io.IOException;
-
-public class AuditFilter extends BaseFilter {
-    @Override
-    public void doFilter(
-      ServletRequest request,
-      ServletResponse response,
-      FilterChain chain
-    ) throws IOException, ServletException {
-        HttpServletRequest httpServletRequest = (HttpServletRequest) request;
-        HttpSession session = httpServletRequest.getSession(false);
-        if (session != null && session.getAttribute("username") != null) {
-            request.setAttribute("username", session.getAttribute("username"));
-        }
-        chain.doFilter(request, response);
-    }
-}

enterprise-patterns/intercepting-filter-pattern/src/main/java/com/baeldung/enterprise/patterns/front/controller/filters/VisitorCounterFilter.java

@@ -1,23 +0,0 @@
-package com.baeldung.enterprise.patterns.front.controller.filters;
-
-import javax.servlet.FilterChain;
-import javax.servlet.ServletException;
-import javax.servlet.ServletRequest;
-import javax.servlet.ServletResponse;
-import javax.servlet.annotation.WebFilter;
-import java.io.IOException;
-
-@WebFilter(servletNames = "front-controller")
-public class VisitorCounterFilter extends BaseFilter {
-    private int counter;
-
-    @Override
-    public void doFilter(
-      ServletRequest request,
-      ServletResponse response,
-      FilterChain chain
-    ) throws IOException, ServletException {
-        request.setAttribute("counter", ++counter);
-        chain.doFilter(request, response);
-    }
-}

enterprise-patterns/pom.xml

@@ -1,19 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
-    <modelVersion>4.0.0</modelVersion>
-    <groupId>com.baeldung.enterprise.patterns</groupId>
-    <artifactId>enterprise-patterns-parent</artifactId>
-    <packaging>pom</packaging>
-
-    <parent>
-        <groupId>com.baeldung</groupId>
-        <artifactId>parent-modules</artifactId>
-        <version>1.0.0-SNAPSHOT</version>
-    </parent>
-
-    <modules>
-        <module>spring-dispatcher-servlet</module>
-    </modules>
-
-</project>

gson/README.md

@@ -7,3 +7,4 @@
 - [Gson Deserialization Cookbook](http://www.baeldung.com/gson-deserialization-guide)
 - [Jackson vs Gson](http://www.baeldung.com/jackson-vs-gson)
 - [Exclude Fields from Serialization in Gson](http://www.baeldung.com/gson-exclude-fields-serialization)
+- [Save Data to a JSON File with Gson](https://www.baeldung.com/gson-save-file)

guava/README.md

@@ -33,3 +33,4 @@
 - [Using Guava CountingOutputStream](http://www.baeldung.com/guava-counting-outputstream)
 - [Hamcrest Text Matchers](http://www.baeldung.com/hamcrest-text-matchers)
 - [Quick Guide to the Guava RateLimiter](http://www.baeldung.com/guava-rate-limiter)
+- [Initialize a HashMap in Java](https://www.baeldung.com/java-initialize-hashmap)

hazelcast/README.md

@@ -1,2 +1,3 @@
 ### Relevant Articles:
 - [Guide to Hazelcast with Java](http://www.baeldung.com/java-hazelcast)
+- [Introduction to Hazelcast Jet](https://www.baeldung.com/hazelcast-jet)

hibernate5/README.md

@@ -13,3 +13,4 @@
 - [Pessimistic Locking in JPA](http://www.baeldung.com/jpa-pessimistic-locking)
 - [Bootstrapping JPA Programmatically in Java](http://www.baeldung.com/java-bootstrap-jpa)
 - [Optimistic Locking in JPA](http://www.baeldung.com/jpa-optimistic-locking)
+- [Hibernate Entity Lifecycle](https://www.baeldung.com/hibernate-entity-lifecycle)

hibernate5/src/main/java/com/baeldung/hibernate/proxy/BatchEmployee.java

@@ -0,0 +1,56 @@
+package com.baeldung.hibernate.proxy;
+
+import org.hibernate.annotations.BatchSize;
+
+import javax.persistence.*;
+import java.io.Serializable;
+
+@Entity
+@BatchSize(size = 5)
+public class BatchEmployee implements Serializable {
+
+    @Id
+    @GeneratedValue (strategy = GenerationType.SEQUENCE)
+    private Long id;
+
+    @ManyToOne(fetch = FetchType.LAZY)
+    private Boss boss;
+
+    @Column(name = "name")
+    private String name;
+
+    @Column(name = "surname")
+    private String surname;
+
+    public Long getId() {
+        return id;
+    }
+
+    public void setId(Long id) {
+        this.id = id;
+    }
+
+    public Boss getBoss() {
+        return boss;
+    }
+
+    public void setBoss(Boss boss) {
+        this.boss = boss;
+    }
+
+    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;
+    }
+}

hibernate5/src/main/java/com/baeldung/hibernate/proxy/Boss.java

@@ -0,0 +1,49 @@
+package com.baeldung.hibernate.proxy;
+
+import javax.persistence.*;
+import java.io.Serializable;
+
+@Entity
+public class Boss implements Serializable {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.SEQUENCE)
+    private Long id;
+
+    @Column(name = "name")
+    private String name;
+
+    @Column(name = "surname")
+    private String surname;
+
+    public Boss() { }
+
+    public Boss(String name, String surname) {
+        this.name = name;
+        this.surname = surname;
+    }
+
+    public Long getId() {
+        return id;
+    }
+
+    public void setId(Long id) {
+        this.id = id;
+    }
+
+    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;
+    }
+}

hibernate5/src/main/java/com/baeldung/hibernate/proxy/Employee.java

@@ -0,0 +1,53 @@
+package com.baeldung.hibernate.proxy;
+
+import javax.persistence.*;
+import java.io.Serializable;
+
+@Entity
+public class Employee implements Serializable {
+
+    @Id
+    @GeneratedValue (strategy = GenerationType.SEQUENCE)
+    private Long id;
+
+    @ManyToOne(fetch = FetchType.LAZY)
+    private Boss boss;
+
+    @Column(name = "name")
+    private String name;
+
+    @Column(name = "surname")
+    private String surname;
+
+    public Long getId() {
+        return id;
+    }
+
+    public void setId(Long id) {
+        this.id = id;
+    }
+
+    public Boss getBoss() {
+        return boss;
+    }
+
+    public void setBoss(Boss boss) {
+        this.boss = boss;
+    }
+
+    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;
+    }
+}

hibernate5/src/main/java/com/baeldung/hibernate/proxy/HibernateUtil.java

@@ -0,0 +1,57 @@
+package com.baeldung.hibernate.proxy;
+
+import org.apache.commons.lang3.StringUtils;
+import org.hibernate.SessionFactory;
+import org.hibernate.boot.Metadata;
+import org.hibernate.boot.MetadataSources;
+import org.hibernate.boot.SessionFactoryBuilder;
+import org.hibernate.boot.registry.StandardServiceRegistryBuilder;
+import org.hibernate.service.ServiceRegistry;
+
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.net.URL;
+import java.util.Properties;
+
+public class HibernateUtil {
+
+    private static SessionFactory sessionFactory;
+    private static String PROPERTY_FILE_NAME;
+
+    public static SessionFactory getSessionFactory(String propertyFileName) throws IOException {
+        PROPERTY_FILE_NAME = propertyFileName;
+        if (sessionFactory == null) {
+            ServiceRegistry serviceRegistry = configureServiceRegistry();
+            sessionFactory = getSessionFactoryBuilder(serviceRegistry).build();
+        }
+        return sessionFactory;
+    }
+
+    private static SessionFactoryBuilder getSessionFactoryBuilder(ServiceRegistry serviceRegistry) {
+        MetadataSources metadataSources = new MetadataSources(serviceRegistry);
+        metadataSources.addPackage("com.baeldung.hibernate.proxy");
+        metadataSources.addAnnotatedClass(Boss.class);
+        metadataSources.addAnnotatedClass(Employee.class);
+
+        Metadata metadata = metadataSources.buildMetadata();
+        return metadata.getSessionFactoryBuilder();
+
+    }
+
+    private static ServiceRegistry configureServiceRegistry() throws IOException {
+        Properties properties = getProperties();
+        return new StandardServiceRegistryBuilder().applySettings(properties)
+            .build();
+    }
+
+    private static Properties getProperties() throws IOException {
+        Properties properties = new Properties();
+        URL propertiesURL = Thread.currentThread()
+            .getContextClassLoader()
+            .getResource(StringUtils.defaultString(PROPERTY_FILE_NAME, "hibernate.properties"));
+        try (FileInputStream inputStream = new FileInputStream(propertiesURL.getFile())) {
+            properties.load(inputStream);
+        }
+        return properties;
+    }
+}

hibernate5/src/test/java/com/baeldung/hibernate/proxy/HibernateProxyUnitTest.java

@@ -0,0 +1,75 @@
+package com.baeldung.hibernate.proxy;
+
+import org.hibernate.*;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+import java.io.IOException;
+import java.util.List;
+
+import static org.junit.Assert.fail;
+
+public class HibernateProxyUnitTest {
+
+    private Session session;
+
+    @Before
+    public void init(){
+        try {
+            session = HibernateUtil.getSessionFactory("hibernate.properties")
+                    .openSession();
+        } catch (HibernateException | IOException e) {
+            fail("Failed to initiate Hibernate Session [Exception:" + e.toString() + "]");
+        }
+
+        Boss boss = new Boss("Eduard", "Freud");
+        session.save(boss);
+    }
+
+    @After
+    public void close(){
+        if(session != null) {
+            session.close();
+        }
+    }
+
+    @Test(expected = NullPointerException.class)
+    public void givenAnInexistentEmployeeId_whenUseGetMethod_thenReturnNull() {
+        Employee employee = session.get(Employee.class, new Long(14));
+        assertNull(employee);
+        employee.getId();
+    }
+
+    @Test
+    public void givenAnInexistentEmployeeId_whenUseLoadMethod_thenReturnAProxy() {
+        Employee employee = session.load(Employee.class, new Long(14));
+        assertNotNull(employee);
+    }
+
+    @Test
+    public void givenABatchEmployeeList_whenSaveOne_thenSaveTheWholeBatch() {
+        Transaction transaction = session.beginTransaction();
+
+        for (long i = 1; i <= 5; i++) {
+            Employee employee = new Employee();
+            employee.setName("Employee " + i);
+            session.save(employee);
+        }
+
+        //After this line is possible to see all the insertions in the logs
+        session.flush();
+        session.clear();
+        transaction.commit();
+
+        transaction = session.beginTransaction();
+
+        List<Employee> employeeList = session.createQuery("from Employee")
+                                        .setCacheMode(CacheMode.IGNORE).getResultList();
+
+        assertEquals(employeeList.size(), 5);
+        transaction.commit();
+    }
+}

intelliJ/README.md

@@ -0,0 +1,3 @@
+### Relevant Articles: 
+
+- [Writing IntelliJ IDEA Plugins](https://www.baeldung.com/intellij-new-custom-plugin)

java-dates/pom.xml

@@ -61,23 +61,6 @@
         </resources>
 
         <plugins>
-            <plugin>
-                <groupId>org.apache.maven.plugins</groupId>
-                <artifactId>maven-dependency-plugin</artifactId>
-                <executions>
-                    <execution>
-                        <id>copy-dependencies</id>
-                        <phase>prepare-package</phase>
-                        <goals>
-                            <goal>copy-dependencies</goal>
-                        </goals>
-                        <configuration>
-                            <outputDirectory>${project.build.directory}/libs</outputDirectory>
-                        </configuration>
-                    </execution>
-                </executions>
-            </plugin>
-
             <plugin>
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-compiler-plugin</artifactId>

java-numbers/pom.xml

@@ -83,23 +83,6 @@
                 </configuration>
             </plugin>
 
-            <plugin>
-                <groupId>org.apache.maven.plugins</groupId>
-                <artifactId>maven-dependency-plugin</artifactId>
-                <executions>
-                    <execution>
-                        <id>copy-dependencies</id>
-                        <phase>prepare-package</phase>
-                        <goals>
-                            <goal>copy-dependencies</goal>
-                        </goals>
-                        <configuration>
-                            <outputDirectory>${project.build.directory}/libs</outputDirectory>
-                        </configuration>
-                    </execution>
-                </executions>
-            </plugin>
-
             <plugin>
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-javadoc-plugin</artifactId>

java-numbers/src/main/java/com/baeldung/maths/BigDecimalDemo.java

@@ -0,0 +1,29 @@
+package com.baeldung.maths;
+
+import java.math.BigDecimal;
+import java.math.RoundingMode;
+
+public class BigDecimalDemo {
+
+    /** Calculate total amount to be paid for an item rounded to cents..
+     * @param quantity
+     * @param unitPrice
+     * @param discountRate
+     * @param taxRate
+     * @return
+     */
+    public static BigDecimal calculateTotalAmount(BigDecimal quantity,
+        BigDecimal unitPrice, BigDecimal discountRate, BigDecimal taxRate) {
+        BigDecimal amount = quantity.multiply(unitPrice);
+        BigDecimal discount = amount.multiply(discountRate);
+        BigDecimal discountedAmount = amount.subtract(discount);
+        BigDecimal tax = discountedAmount.multiply(taxRate);
+        BigDecimal total = discountedAmount.add(tax);
+
+        // round to 2 decimal places using HALF_EVEN
+        BigDecimal roundedTotal = total.setScale(2, RoundingMode.HALF_EVEN);
+
+        return roundedTotal;
+    }
+
+}

java-numbers/src/test/java/com/baeldung/maths/BigDecimalDemoUnitTest.java

@@ -0,0 +1,120 @@
+package com.baeldung.maths;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotEquals;
+import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.math.BigDecimal;
+import java.math.BigInteger;
+import java.math.MathContext;
+import java.math.RoundingMode;
+import java.util.Random;
+
+import org.junit.jupiter.api.Test;
+
+public class BigDecimalDemoUnitTest {
+
+    @Test
+    public void whenBigDecimalCreated_thenValueMatches() {
+        BigDecimal bdFromString = new BigDecimal("0.1");
+        BigDecimal bdFromCharArray = new BigDecimal(
+            new char[] { '3', '.', '1', '6', '1', '5' });
+        BigDecimal bdlFromInt = new BigDecimal(42);
+        BigDecimal bdFromLong = new BigDecimal(123412345678901L);
+        BigInteger bigInteger = BigInteger.probablePrime(100, new Random());
+        BigDecimal bdFromBigInteger = new BigDecimal(bigInteger);
+
+        assertEquals("0.1", bdFromString.toString());
+        assertEquals("3.1615", bdFromCharArray.toString());
+        assertEquals("42", bdlFromInt.toString());
+        assertEquals("123412345678901", bdFromLong.toString());
+        assertEquals(bigInteger.toString(), bdFromBigInteger.toString());
+    }
+
+    @Test
+    public void whenBigDecimalCreatedFromDouble_thenValueMayNotMatch() {
+        BigDecimal bdFromDouble = new BigDecimal(0.1d);
+        assertNotEquals("0.1", bdFromDouble.toString());
+    }
+
+    @Test
+    public void whenBigDecimalCreatedUsingValueOf_thenValueMatches() {
+        BigDecimal bdFromLong1 = BigDecimal.valueOf(123412345678901L);
+        BigDecimal bdFromLong2 = BigDecimal.valueOf(123412345678901L, 2);
+        BigDecimal bdFromDouble = BigDecimal.valueOf(0.1d);
+
+        assertEquals("123412345678901", bdFromLong1.toString());
+        assertEquals("1234123456789.01", bdFromLong2.toString());
+        assertEquals("0.1", bdFromDouble.toString());
+    }
+
+    @Test
+    public void whenEqualsCalled_thenSizeAndScaleMatched() {
+        BigDecimal bd1 = new BigDecimal("1.0");
+        BigDecimal bd2 = new BigDecimal("1.00");
+
+        assertFalse(bd1.equals(bd2));
+    }
+
+    @Test
+    public void whenComparingBigDecimals_thenExpectedResult() {
+        BigDecimal bd1 = new BigDecimal("1.0");
+        BigDecimal bd2 = new BigDecimal("1.00");
+        BigDecimal bd3 = new BigDecimal("2.0");
+
+        assertTrue(bd1.compareTo(bd3) < 0);
+        assertTrue(bd3.compareTo(bd1) > 0);
+        assertTrue(bd1.compareTo(bd2) == 0);
+        assertTrue(bd1.compareTo(bd3) <= 0);
+        assertTrue(bd1.compareTo(bd2) >= 0);
+        assertTrue(bd1.compareTo(bd3) != 0);
+    }
+
+    @Test
+    public void whenPerformingArithmetic_thenExpectedResult() {
+        BigDecimal bd1 = new BigDecimal("4.0");
+        BigDecimal bd2 = new BigDecimal("2.0");
+
+        BigDecimal sum = bd1.add(bd2);
+        BigDecimal difference = bd1.subtract(bd2);
+        BigDecimal quotient = bd1.divide(bd2);
+        BigDecimal product = bd1.multiply(bd2);
+
+        assertTrue(sum.compareTo(new BigDecimal("6.0")) == 0);
+        assertTrue(difference.compareTo(new BigDecimal("2.0")) == 0);
+        assertTrue(quotient.compareTo(new BigDecimal("2.0")) == 0);
+        assertTrue(product.compareTo(new BigDecimal("8.0")) == 0);
+    }
+
+    @Test
+    public void whenGettingAttributes_thenExpectedResult() {
+        BigDecimal bd = new BigDecimal("-12345.6789");
+
+        assertEquals(9, bd.precision());
+        assertEquals(4, bd.scale());
+        assertEquals(-1, bd.signum());
+    }
+
+    @Test
+    public void whenRoundingDecimal_thenExpectedResult() {
+        BigDecimal bd = new BigDecimal("2.5");
+        // Round to 1 digit using HALF_EVEN
+        BigDecimal rounded = bd
+            .round(new MathContext(1, RoundingMode.HALF_EVEN));
+
+        assertEquals("2", rounded.toString());
+    }
+
+    @Test
+    public void givenPurchaseTxn_whenCalculatingTotalAmount_thenExpectedResult() {
+        BigDecimal quantity = new BigDecimal("4.5");
+        BigDecimal unitPrice = new BigDecimal("2.69");
+        BigDecimal discountRate = new BigDecimal("0.10");
+        BigDecimal taxRate = new BigDecimal("0.0725");
+
+        BigDecimal amountToBePaid = BigDecimalDemo
+            .calculateTotalAmount(quantity, unitPrice, discountRate, taxRate);
+        assertEquals("11.68", amountToBePaid.toString());
+    }
+}

java-numbers/src/test/java/com/baeldung/maths/BigIntegerDemoUnitTest.java

@@ -0,0 +1,128 @@
+package com.baeldung.maths;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+import java.math.BigInteger;
+import java.util.Random;
+
+import org.junit.jupiter.api.Test;
+
+public class BigIntegerDemoUnitTest {
+
+    @Test
+    public void whenBigIntegerCreatedFromConstructor_thenExpectedResult() {
+        BigInteger biFromString = new BigInteger("1234567890987654321");
+        BigInteger biFromByteArray = new BigInteger(
+            new byte[] { 64, 64, 64, 64, 64, 64 });
+        BigInteger biFromSignMagnitude = new BigInteger(-1,
+            new byte[] { 64, 64, 64, 64, 64, 64 });
+
+        assertEquals("1234567890987654321", biFromString.toString());
+        assertEquals("70644700037184", biFromByteArray.toString());
+        assertEquals("-70644700037184", biFromSignMagnitude.toString());
+    }
+
+    @Test
+    public void whenLongConvertedToBigInteger_thenValueMatches() {
+        BigInteger bi = BigInteger.valueOf(2305843009213693951L);
+
+        assertEquals("2305843009213693951", bi.toString());
+    }
+
+    @Test
+    public void givenBigIntegers_whentCompared_thenExpectedResult() {
+        BigInteger i = new BigInteger("123456789012345678901234567890");
+        BigInteger j = new BigInteger("123456789012345678901234567891");
+        BigInteger k = new BigInteger("123456789012345678901234567892");
+
+        assertTrue(i.compareTo(i) == 0);
+        assertTrue(j.compareTo(i) > 0);
+        assertTrue(j.compareTo(k) < 0);
+    }
+
+    @Test
+    public void givenBigIntegers_whenPerformingArithmetic_thenExpectedResult() {
+        BigInteger i = new BigInteger("4");
+        BigInteger j = new BigInteger("2");
+
+        BigInteger sum = i.add(j);
+        BigInteger difference = i.subtract(j);
+        BigInteger quotient = i.divide(j);
+        BigInteger product = i.multiply(j);
+
+        assertEquals(new BigInteger("6"), sum);
+        assertEquals(new BigInteger("2"), difference);
+        assertEquals(new BigInteger("2"), quotient);
+        assertEquals(new BigInteger("8"), product);
+    }
+
+    @Test
+    public void givenBigIntegers_whenPerformingBitOperations_thenExpectedResult() {
+        BigInteger i = new BigInteger("17");
+        BigInteger j = new BigInteger("7");
+
+        BigInteger and = i.and(j);
+        BigInteger or = i.or(j);
+        BigInteger not = j.not();
+        BigInteger xor = i.xor(j);
+        BigInteger andNot = i.andNot(j);
+        BigInteger shiftLeft = i.shiftLeft(1);
+        BigInteger shiftRight = i.shiftRight(1);
+
+        assertEquals(new BigInteger("1"), and);
+        assertEquals(new BigInteger("23"), or);
+        assertEquals(new BigInteger("-8"), not);
+        assertEquals(new BigInteger("22"), xor);
+        assertEquals(new BigInteger("16"), andNot);
+        assertEquals(new BigInteger("34"), shiftLeft);
+        assertEquals(new BigInteger("8"), shiftRight);
+    }
+
+    @Test
+    public void givenBigIntegers_whenPerformingBitManipulations_thenExpectedResult() {
+        BigInteger i = new BigInteger("1018");
+
+        int bitCount = i.bitCount();
+        int bitLength = i.bitLength();
+        int getLowestSetBit = i.getLowestSetBit();
+        boolean testBit3 = i.testBit(3);
+        BigInteger setBit12 = i.setBit(12);
+        BigInteger flipBit0 = i.flipBit(0);
+        BigInteger clearBit3 = i.clearBit(3);
+
+        assertEquals(8, bitCount);
+        assertEquals(10, bitLength);
+        assertEquals(1, getLowestSetBit);
+        assertEquals(true, testBit3);
+        assertEquals(new BigInteger("5114"), setBit12);
+        assertEquals(new BigInteger("1019"), flipBit0);
+        assertEquals(new BigInteger("1010"), clearBit3);
+    }
+
+    @Test
+    public void givenBigIntegers_whenModularCalculation_thenExpectedResult() {
+        BigInteger i = new BigInteger("31");
+        BigInteger j = new BigInteger("24");
+        BigInteger k = new BigInteger("16");
+
+        BigInteger gcd = j.gcd(k);
+        BigInteger multiplyAndmod = j.multiply(k)
+            .mod(i);
+        BigInteger modInverse = j.modInverse(i);
+        BigInteger modPow = j.modPow(k, i);
+
+        assertEquals(new BigInteger("8"), gcd);
+        assertEquals(new BigInteger("12"), multiplyAndmod);
+        assertEquals(new BigInteger("22"), modInverse);
+        assertEquals(new BigInteger("7"), modPow);
+    }
+
+    @Test
+    public void givenBigIntegers_whenPrimeOperations_thenExpectedResult() {
+        BigInteger i = BigInteger.probablePrime(100, new Random());
+
+        boolean isProbablePrime = i.isProbablePrime(1000);
+        assertEquals(true, isProbablePrime);
+    }
+}

java-streams/README.md

@@ -12,3 +12,4 @@
 - [Iterable to Stream in Java](http://www.baeldung.com/java-iterable-to-stream)
 - [How to Iterate Over a Stream With Indices](http://www.baeldung.com/java-stream-indices)
 - [Primitive Type Streams in Java 8](http://www.baeldung.com/java-8-primitive-streams)
+- [Stream Ordering in Java](https://www.baeldung.com/java-stream-ordering)

java-streams/pom.xml

@@ -86,23 +86,6 @@
         </resources>
 
         <plugins>
-            <plugin>
-                <groupId>org.apache.maven.plugins</groupId>
-                <artifactId>maven-dependency-plugin</artifactId>
-                <executions>
-                    <execution>
-                        <id>copy-dependencies</id>
-                        <phase>prepare-package</phase>
-                        <goals>
-                            <goal>copy-dependencies</goal>
-                        </goals>
-                        <configuration>
-                            <outputDirectory>${project.build.directory}/libs</outputDirectory>
-                        </configuration>
-                    </execution>
-                </executions>
-            </plugin>
-
             <plugin>
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-compiler-plugin</artifactId>

java-streams/src/test/java/com/baeldung/streamordering/BenchmarkManualTest.java

@@ -15,7 +15,7 @@ import java.util.concurrent.TimeUnit;
 import java.util.stream.IntStream;
 
 
-public class BenchmarkUnitTest
+public class BenchmarkManualTest
 {
 
   public void

java-strings/README.md

@@ -25,3 +25,5 @@
 - [Why Use char[] Array Over a String for Storing Passwords in Java?](http://www.baeldung.com/java-storing-passwords)
 - [Convert a String to Title Case](http://www.baeldung.com/java-string-title-case)
 - [Compact Strings in Java 9](http://www.baeldung.com/java-9-compact-string)
+- [Java Check a String for Lowercase/Uppercase Letter, Special Character and Digit](https://www.baeldung.com/java-lowercase-uppercase-special-character-digit-regex)
+- [Convert java.util.Date to String](https://www.baeldung.com/java-util-date-to-string)

java-strings/pom.xml

@@ -71,23 +71,6 @@
         </resources>
 
         <plugins>
-            <plugin>
-                <groupId>org.apache.maven.plugins</groupId>
-                <artifactId>maven-dependency-plugin</artifactId>
-                <executions>
-                    <execution>
-                        <id>copy-dependencies</id>
-                        <phase>prepare-package</phase>
-                        <goals>
-                            <goal>copy-dependencies</goal>
-                        </goals>
-                        <configuration>
-                            <outputDirectory>${project.build.directory}/libs</outputDirectory>
-                        </configuration>
-                    </execution>
-                </executions>
-            </plugin>
-
             <plugin>
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-compiler-plugin</artifactId>

java-strings/src/test/java/com/baeldung/string/RemovingEmojiFromStringUnitTest.java

@@ -1,8 +1,6 @@
 package com.baeldung.string;
 
-import static org.hamcrest.CoreMatchers.containsString;
-import static org.hamcrest.CoreMatchers.not;
-import static org.junit.Assert.assertThat;
+import static org.junit.Assert.assertEquals;
 
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
@@ -12,35 +10,28 @@ import org.junit.Test;
 import com.vdurmont.emoji.EmojiParser;
 
 public class RemovingEmojiFromStringUnitTest {
-    String text = "la conférence, commencera à 10 heures 😅 ✿";
+    String text = "la conférence, commencera à 10 heures 😅";
     String regex = "[^\\p{L}\\p{N}\\p{P}\\p{Z}]";
 
     @Test
     public void whenRemoveEmojiUsingLibrary_thenSuccess() {
         String result = EmojiParser.removeAllEmojis(text);
         System.out.println(result);
-        assertThat(result, not(containsString("😅")));
-        assertThat(result, containsString("à"));
-        assertThat(result, containsString("la"));
-        assertThat(result, containsString("10"));
+        assertEquals(result, "la conférence, commencera à 10 heures ");
     }
     
     @Test
     public void whenReplaceEmojiUsingLibrary_thenSuccess() {
         String result = EmojiParser.parseToAliases(text);
         System.out.println(result);
-        assertThat(result, not(containsString("😅")));
-        assertThat(result, containsString("sweat_smile"));
+        assertEquals(result, "la conférence, commencera à 10 heures :sweat_smile:");
     }
 
     @Test
     public void whenRemoveEmojiUsingRegex_thenSuccess() {
         String result = text.replaceAll(regex, "");
         System.out.println(result);
-        assertThat(result, not(containsString("😅")));
-        assertThat(result, containsString("à"));
-        assertThat(result, containsString("la"));
-        assertThat(result, containsString("10"));
+        assertEquals(result, "la conférence, commencera à 10 heures ");
     }
 
     @Test
@@ -50,29 +41,20 @@ public class RemovingEmojiFromStringUnitTest {
         
         String result = matcher.replaceAll("");
         System.out.println(result);
-        assertThat(result, not(containsString("😅")));
-        assertThat(result, containsString("à"));
-        assertThat(result, containsString("la"));
-        assertThat(result, containsString("10"));
+        assertEquals(result, "la conférence, commencera à 10 heures ");
     }
 
     @Test
     public void whenRemoveEmojiUsingCodepoints_thenSuccess() {
         String result = text.replaceAll("[\\x{0001f300}-\\x{0001f64f}]|[\\x{0001f680}-\\x{0001f6ff}]", "");
         System.out.println(result);
-        assertThat(result, not(containsString("😅")));
-        assertThat(result, containsString("à"));
-        assertThat(result, containsString("la"));
-        assertThat(result, containsString("10"));
+        assertEquals(result, "la conférence, commencera à 10 heures ");
     }
 
     @Test
     public void whenRemoveEmojiUsingUnicode_thenSuccess() {
         String result = text.replaceAll("[\ud83c\udf00-\ud83d\ude4f]|[\ud83d\ude80-\ud83d\udeff]", "");
         System.out.println(result);
-        assertThat(result, not(containsString("😅")));
-        assertThat(result, containsString("à"));
-        assertThat(result, containsString("la"));
-        assertThat(result, containsString("10"));
+        assertEquals(result, "la conférence, commencera à 10 heures ");
     }
 }

java-strings/src/test/java/com/baeldung/string/SubstringUnitTest.java

@@ -0,0 +1,62 @@
+package com.baeldung.string;
+
+import java.util.Scanner;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import org.apache.commons.lang3.StringUtils;
+import org.junit.Assert;
+import org.junit.Test;
+
+public class SubstringUnitTest {
+
+    String text = "Julia Evans was born on 25-09-1984. She is currently living in the USA (United States of America).";
+
+    @Test
+    public void givenAString_whenUsedStringUtils_ShouldReturnProperSubstring() {
+        Assert.assertEquals("United States of America", StringUtils.substringBetween(text, "(", ")"));
+        Assert.assertEquals("the USA (United States of America).", StringUtils.substringAfter(text, "living in "));
+        Assert.assertEquals("Julia Evans", StringUtils.substringBefore(text, " was born"));
+    }
+
+    @Test
+    public void givenAString_whenUsedScanner_ShouldReturnProperSubstring() {
+        try (Scanner scanner = new Scanner(text)) {
+            scanner.useDelimiter("\\.");
+            Assert.assertEquals("Julia Evans was born on 25-09-1984", scanner.next());
+        }
+    }
+
+    @Test
+    public void givenAString_whenUsedSplit_ShouldReturnProperSubstring() {
+        String[] sentences = text.split("\\.");
+        Assert.assertEquals("Julia Evans was born on 25-09-1984", sentences[0]);
+    }
+
+    @Test
+    public void givenAString_whenUsedRegex_ShouldReturnProperSubstring() {
+        Pattern pattern = Pattern.compile("\\d{2}\\-\\d{2}-\\d{4}");
+        Matcher matcher = pattern.matcher(text);
+
+        if (matcher.find()) {
+            Assert.assertEquals("25-09-1984", matcher.group());
+        }
+    }
+
+    @Test
+    public void givenAString_whenUsedSubSequence_ShouldReturnProperSubstring() {
+        Assert.assertEquals("USA (United States of America)", text.subSequence(67, text.length() - 1));
+    }
+
+    @Test
+    public void givenAString_whenUsedSubstring_ShouldReturnProperSubstring() {
+        Assert.assertEquals("USA (United States of America).", text.substring(67));
+        Assert.assertEquals("USA (United States of America)", text.substring(67, text.length() - 1));
+    }
+
+    @Test
+    public void givenAString_whenUsedSubstringWithIndexOf_ShouldReturnProperSubstring() {
+        Assert.assertEquals("United States of America", text.substring(text.indexOf('(') + 1, text.indexOf(')')));
+    }
+
+}

javaxval/bin/.gitignore

@@ -1,6 +0,0 @@
-.classpath
-.project
-.settings/
-target/
-
-

javaxval/bin/pom.xml

@@ -1,44 +0,0 @@
-<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</groupId>
-    <artifactId>javaxval</artifactId>
-    <version>0.1-SNAPSHOT</version>
-
-
-    <dependencies>
-
-        <dependency>
-            <groupId>javax.validation</groupId>
-            <artifactId>validation-api</artifactId>
-            <version>1.1.0.Final</version>
-        </dependency>
-
-        <dependency>
-            <groupId>org.hibernate</groupId>
-            <artifactId>hibernate-validator</artifactId>
-            <version>5.2.1.Final</version>
-        </dependency>
-
-        <dependency>
-            <groupId>org.hibernate</groupId>
-            <artifactId>hibernate-validator-annotation-processor</artifactId>
-            <version>5.2.1.Final</version>
-        </dependency>
-
-        <dependency>
-            <groupId>javax.el</groupId>
-            <artifactId>javax.el-api</artifactId>
-            <version>2.2.4</version>
-        </dependency>
-
-        <dependency>
-            <groupId>org.glassfish.web</groupId>
-            <artifactId>javax.el</artifactId>
-            <version>2.2.4</version>
-        </dependency>
-
-    </dependencies>
-
-
-</project>

jee-7/pom.xml

@@ -384,10 +384,6 @@
         </profile>
     </profiles>
 
-    <prerequisites>
-        <maven>${maven.min.version}</maven>
-    </prerequisites>
-
     <repositories>
         <repository>
             <id>bintray-mvc-spec-maven</id>

jersey/README.md

@@ -1 +1,2 @@
 - [Jersey Filters and Interceptors](http://www.baeldung.com/jersey-filters-interceptors)
+- [Jersey MVC Support](https://www.baeldung.com/jersey-mvc)

jhipster/jhipster-monolithic/pom.xml

@@ -412,6 +412,7 @@
             <plugin>
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-eclipse-plugin</artifactId>
+                <version>${maven-eclipse-plugin.version}</version>
                 <configuration>
                     <downloadSources>true</downloadSources>
                     <downloadJavadocs>true</downloadJavadocs>
@@ -879,10 +880,6 @@
         </profile>
     </profiles>
 
-    <prerequisites>
-        <maven>${maven.version}</maven>
-    </prerequisites>
-
     <properties>
         <argLine>-Djava.security.egd=file:/dev/./urandom -Xmx256m</argLine>
         <assertj.version>3.6.2</assertj.version>
@@ -909,6 +906,7 @@
         <mapstruct.version>1.1.0.Final</mapstruct.version>
         <maven-enforcer-plugin.version>1.4.1</maven-enforcer-plugin.version>
         <maven-resources-plugin.version>3.0.1</maven-resources-plugin.version>
+        <maven-eclipse-plugin.version>2.10</maven-eclipse-plugin.version>
         <maven.build.timestamp.format>yyyyMMddHHmmss</maven.build.timestamp.format>
         <maven.version>3.0.0</maven.version>
         <metrics-spring.version>3.1.3</metrics-spring.version>

jnosql/jnosql-artemis/pom.xml

@@ -19,7 +19,7 @@
     </properties>
 
     <build>
-        <finalName>${artifactId}</finalName>
+        <finalName>${project.artifactId}</finalName>
         <plugins>
             <plugin>
                 <groupId>net.wasdev.wlp.maven.plugins</groupId>

jsf/pom.xml

@@ -36,11 +36,6 @@
             <version>${jstl.version}</version>
         </dependency>
         <!-- Spring -->
-        <dependency>
-            <groupId>org.springframework</groupId>
-            <artifactId>spring-web</artifactId>
-            <version>${org.springframework.version}</version>
-        </dependency>
         <dependency>
             <groupId>org.springframework</groupId>
             <artifactId>spring-webmvc</artifactId>

json/README.md

@@ -9,3 +9,4 @@
 - [Introduction to JsonPath](http://www.baeldung.com/guide-to-jayway-jsonpath)
 - [Introduction to JSON-Java (org.json)](http://www.baeldung.com/java-org-json)
 - [Overview of JSON Pointer](https://www.baeldung.com/json-pointer)
+- [Introduction to the JSON Binding API (JSR 367) in Java](http://www.baeldung.com/java-json-binding-api)

json/pom.xml

@@ -33,7 +33,11 @@
             <artifactId>json</artifactId>
             <version>20171018</version>
         </dependency>
-        
+		<dependency>
+            <groupId>javax.json.bind</groupId>
+            <artifactId>javax.json.bind-api</artifactId>
+            <version>${jsonb-api.version}</version>
+        </dependency>
         <dependency>
             <groupId>junit</groupId>
             <artifactId>junit</artifactId>
@@ -46,12 +50,26 @@
             <artifactId>javax.json</artifactId>
             <version>1.1.2</version>
         </dependency>
-        
+		<dependency>
+			<groupId>org.eclipse</groupId>
+			<artifactId>yasson</artifactId>
+			<version>${yasson.version}</version>
+        </dependency>
+		<!-- utils -->
+        <dependency>
+            <groupId>org.apache.commons</groupId>
+            <artifactId>commons-collections4</artifactId>
+            <version>${commons-collections4.version}</version>
+            <scope>test</scope>
+        </dependency>
     </dependencies>
 
     <properties>
         <everit.json.schema.version>1.4.1</everit.json.schema.version>
         <fastjson.version>1.2.21</fastjson.version>
+        <jsonb-api.version>1.0</jsonb-api.version>
+        <commons-collections4.version>4.1</commons-collections4.version>
+        <yasson.version>1.0.1</yasson.version>
     </properties>
 
 </project>

json/src/test/java/com/baeldung/jsonb/JsonbUnitTest.java

@@ -18,8 +18,9 @@ import org.apache.commons.collections4.ListUtils;
 import org.junit.Test;
 
 import com.baeldung.adapter.PersonAdapter;
+import com.baeldung.jsonb.Person;
 
-public class JsonbTest {
+public class JsonbUnitTest {
 
     @Test
     public void givenPersonList_whenSerializeWithJsonb_thenGetPersonJsonArray() {

jsonb/.gitignore

@@ -1,12 +0,0 @@
-#folders#
-.idea
-/target
-/neoDb*
-/data
-/src/main/webapp/WEB-INF/classes
-*/META-INF/*
-
-# Packaged files #
-*.jar
-*.war
-*.ear

jsonb/README.md

@@ -1,4 +0,0 @@
-## JSON B
-
-## Relevant articles:
-- [Introduction to the JSON Binding API (JSR 367) in Java](http://www.baeldung.com/java-json-binding-api)

jsonb/pom.xml

@@ -1,101 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
-    <modelVersion>4.0.0</modelVersion>
-    <groupId>com.baeldung</groupId>
-    <artifactId>json-b</artifactId>
-    <version>0.0.1-SNAPSHOT</version>
-    <packaging>jar</packaging>
-    <name>json-b</name>
-    <description>json-b sample project</description>
-
-    <parent>
-        <groupId>com.baeldung</groupId>
-        <artifactId>parent-modules</artifactId>
-        <version>1.0.0-SNAPSHOT</version>
-    </parent>
-
-    <dependencies>
-        <dependency>
-            <groupId>javax.json.bind</groupId>
-            <artifactId>javax.json.bind-api</artifactId>
-            <version>${jsonb-api.version}</version>
-        </dependency>
-        <!-- utils -->
-        <dependency>
-            <groupId>org.apache.commons</groupId>
-            <artifactId>commons-collections4</artifactId>
-            <version>${commons-collections4.version}</version>
-            <scope>test</scope>
-        </dependency>
-
-        <dependency>
-            <groupId>org.junit.jupiter</groupId>
-            <artifactId>junit-jupiter-api</artifactId>
-            <version>${junit.jupiter.version}</version>
-        </dependency>
-        <dependency>
-            <groupId>org.junit.platform</groupId>
-            <artifactId>junit-platform-surefire-provider</artifactId>
-            <version>${junit.platform.version}</version>
-            <scope>test</scope>
-        </dependency>
-        <dependency>
-            <groupId>org.junit.platform</groupId>
-            <artifactId>junit-platform-runner</artifactId>
-            <version>${junit.platform.version}</version>
-            <scope>test</scope>
-        </dependency>
-    </dependencies>
-
-    <profiles>
-        <profile>
-            <id>yasson</id>
-            <activation>
-                <activeByDefault>true</activeByDefault>
-            </activation>
-            <dependencies>
-                <!-- Dependencies for Yasson -->
-                <dependency>
-                    <groupId>org.eclipse</groupId>
-                    <artifactId>yasson</artifactId>
-                    <version>${yasson.version}</version>
-                </dependency>
-                <dependency>
-                    <groupId>org.glassfish</groupId>
-                    <artifactId>javax.json</artifactId>
-                    <version>${javax.json.version}</version>
-                </dependency>
-            </dependencies>
-        </profile>
-        <profile>
-            <id>johnzon</id>
-            <dependencies>
-                <!-- Dependencies for Johnzon -->
-                <dependency>
-                    <groupId>org.apache.geronimo.specs</groupId>
-                    <artifactId>geronimo-json_1.1_spec</artifactId>
-                    <version>${geronimo-json_1.1_spec.version}</version>
-                </dependency>
-                <dependency>
-                    <groupId>org.apache.johnzon</groupId>
-                    <artifactId>johnzon-jsonb</artifactId>
-                    <version>${johnzon.version}</version>
-                </dependency>
-            </dependencies>
-        </profile>
-    </profiles>
-
-    <properties>
-        <maven.compiler.source>1.8</maven.compiler.source>
-        <maven.compiler.target>1.8</maven.compiler.target>
-        <junit.platform.version>1.0.0</junit.platform.version>
-        <jsonb-api.version>1.0</jsonb-api.version>
-        <johnzon.version>1.1.3</johnzon.version>
-        <geronimo-json_1.1_spec.version>1.0</geronimo-json_1.1_spec.version>
-        <yasson.version>1.0.1</yasson.version>
-        <javax.json.version>1.1.2</javax.json.version>
-        <commons-collections4.version>4.1</commons-collections4.version>
-    </properties>
-
-</project>

jta/pom.xml

@@ -0,0 +1,88 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <groupId>com.baeldung</groupId>
+    <artifactId>jta-demo</artifactId>
+    <version>1.0-SNAPSHOT</version>
+    <packaging>jar</packaging>
+
+    <description>JEE JTA demo</description>
+
+    <parent>
+        <groupId>org.springframework.boot</groupId>
+        <artifactId>spring-boot-starter-parent</artifactId>
+        <version>2.0.4.RELEASE</version>
+        <relativePath/>
+    </parent>
+
+    <properties>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
+        <java.version>1.8</java.version>
+    </properties>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-jta-bitronix</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-jdbc</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter</artifactId>
+        </dependency>
+
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-test</artifactId>
+            <scope>test</scope>
+        </dependency>
+
+        <dependency>
+            <groupId>org.hsqldb</groupId>
+            <artifactId>hsqldb</artifactId>
+            <version>2.4.1</version>
+        </dependency>
+    </dependencies>
+
+    <profiles>
+        <profile>
+            <id>autoconfiguration</id>
+            <build>
+                <plugins>
+                    <plugin>
+                        <groupId>org.apache.maven.plugins</groupId>
+                        <artifactId>maven-surefire-plugin</artifactId>
+                        <executions>
+                            <execution>
+                                <phase>integration-test</phase>
+                                <goals>
+                                    <goal>test</goal>
+                                </goals>
+                                <configuration>
+                                    <excludes>
+                                        <exclude>**/*LiveTest.java</exclude>
+                                        <exclude>**/*IntegrationTest.java</exclude>
+                                        <exclude>**/*IntTest.java</exclude>
+                                    </excludes>
+                                    <includes>
+                                        <include>**/AutoconfigurationTest.java</include>
+                                    </includes>
+                                </configuration>
+                            </execution>
+                        </executions>
+                        <configuration>
+                            <systemPropertyVariables>
+                                <test.mime>json</test.mime>
+                            </systemPropertyVariables>
+                        </configuration>
+                    </plugin>
+                </plugins>
+            </build>
+        </profile>
+    </profiles>
+</project>

jta/src/main/java/com/baeldung/jtademo/JtaDemoApplication.java

@@ -0,0 +1,48 @@
+package com.baeldung.jtademo;
+
+import org.hsqldb.jdbc.pool.JDBCXADataSource;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
+import org.springframework.boot.jta.bitronix.BitronixXADataSourceWrapper;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.ComponentScan;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.jdbc.core.JdbcTemplate;
+import org.springframework.transaction.annotation.EnableTransactionManagement;
+
+import javax.sql.DataSource;
+
+@EnableAutoConfiguration
+@EnableTransactionManagement
+@Configuration
+@ComponentScan
+public class JtaDemoApplication {
+
+    @Bean("dataSourceAccount")
+    public DataSource dataSource() throws Exception {
+        return createHsqlXADatasource("jdbc:hsqldb:mem:accountDb");
+    }
+
+    @Bean("dataSourceAudit")
+    public DataSource dataSourceAudit() throws Exception {
+        return createHsqlXADatasource("jdbc:hsqldb:mem:auditDb");
+    }
+
+    private DataSource createHsqlXADatasource(String connectionUrl) throws Exception {
+        JDBCXADataSource dataSource = new JDBCXADataSource();
+        dataSource.setUrl(connectionUrl);
+        dataSource.setUser("sa");
+        BitronixXADataSourceWrapper wrapper = new BitronixXADataSourceWrapper();
+        return wrapper.wrapDataSource(dataSource);
+    }
+
+    @Bean("jdbcTemplateAccount")
+    public JdbcTemplate jdbcTemplate(@Qualifier("dataSourceAccount") DataSource dataSource) {
+        return new JdbcTemplate(dataSource);
+    }
+
+    @Bean("jdbcTemplateAudit")
+    public JdbcTemplate jdbcTemplateAudit(@Qualifier("dataSourceAudit") DataSource dataSource) {
+        return new JdbcTemplate(dataSource);
+    }
+}

jta/src/main/java/com/baeldung/jtademo/dto/TransferLog.java

@@ -0,0 +1,27 @@
+package com.baeldung.jtademo.dto;
+
+import java.math.BigDecimal;
+
+public class TransferLog {
+    private String fromAccountId;
+    private String toAccountId;
+    private BigDecimal amount;
+
+    public TransferLog(String fromAccountId, String toAccountId, BigDecimal amount) {
+        this.fromAccountId = fromAccountId;
+        this.toAccountId = toAccountId;
+        this.amount = amount;
+    }
+
+    public String getFromAccountId() {
+        return fromAccountId;
+    }
+
+    public String getToAccountId() {
+        return toAccountId;
+    }
+
+    public BigDecimal getAmount() {
+        return amount;
+    }
+}

jta/src/main/java/com/baeldung/jtademo/services/AuditService.java

@@ -0,0 +1,33 @@
+package com.baeldung.jtademo.services;
+
+import com.baeldung.jtademo.dto.TransferLog;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.jdbc.core.JdbcTemplate;
+import org.springframework.jdbc.core.ResultSetExtractor;
+import org.springframework.stereotype.Service;
+
+import java.math.BigDecimal;
+
+@Service
+public class AuditService {
+
+    final JdbcTemplate jdbcTemplate;
+
+    @Autowired
+    public AuditService(@Qualifier("jdbcTemplateAudit") JdbcTemplate jdbcTemplate) {
+        this.jdbcTemplate = jdbcTemplate;
+    }
+
+    public void log(String fromAccount, String toAccount, BigDecimal amount) {
+        jdbcTemplate.update("insert into AUDIT_LOG(FROM_ACCOUNT, TO_ACCOUNT, AMOUNT) values ?,?,?", fromAccount, toAccount, amount);
+    }
+
+    public TransferLog lastTransferLog() {
+        return jdbcTemplate.query("select FROM_ACCOUNT,TO_ACCOUNT,AMOUNT from AUDIT_LOG order by ID desc", (ResultSetExtractor<TransferLog>) (rs) -> {
+            if (!rs.next())
+                return null;
+            return new TransferLog(rs.getString(1), rs.getString(2), BigDecimal.valueOf(rs.getDouble(3)));
+        });
+    }
+}

jta/src/main/java/com/baeldung/jtademo/services/BankAccountService.java

@@ -0,0 +1,32 @@
+package com.baeldung.jtademo.services;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.jdbc.core.JdbcTemplate;
+import org.springframework.jdbc.core.ResultSetExtractor;
+import org.springframework.stereotype.Service;
+
+import java.math.BigDecimal;
+
+@Service
+public class BankAccountService {
+
+    final JdbcTemplate jdbcTemplate;
+
+    @Autowired
+    public BankAccountService(@Qualifier("jdbcTemplateAccount") JdbcTemplate jdbcTemplate) {
+        this.jdbcTemplate = jdbcTemplate;
+    }
+
+    public void transfer(String fromAccountId, String toAccountId, BigDecimal amount) {
+        jdbcTemplate.update("update ACCOUNT set BALANCE=BALANCE-? where ID=?", amount, fromAccountId);
+        jdbcTemplate.update("update ACCOUNT set BALANCE=BALANCE+? where ID=?", amount, toAccountId);
+    }
+
+    public BigDecimal balanceOf(String accountId) {
+        return jdbcTemplate.query("select BALANCE from ACCOUNT where ID=?", new Object[] { accountId }, (ResultSetExtractor<BigDecimal>) (rs) -> {
+            rs.next();
+            return new BigDecimal(rs.getDouble(1));
+        });
+    }
+}