Merge remote-tracking branch 'eugenp/master'

core-java/README.md

@@ -133,3 +133,4 @@
 - [A Guide to Java Initialization](http://www.baeldung.com/java-initialization)
 - [Implementing a Binary Tree in Java](http://www.baeldung.com/java-binary-tree)
 - [A Guide to ThreadLocalRandom in Java](http://www.baeldung.com/java-thread-local-random)
+- [RegEx for matching Date Pattern in Java](http://www.baeldung.com/java-date-regular-expressions)

core-java/src/main/java/com/baeldung/iteratorguide/IteratorGuide.java

@@ -0,0 +1,39 @@
+package com.baeldung.iteratorguide;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import java.util.ListIterator;
+
+public class IteratorGuide {
+    
+    public static void main(String[] args) {
+        List<String> items = new ArrayList<>();
+        items.add("ONE");
+        items.add("TWO");
+        items.add("THREE");
+        Iterator<String> iter = items.iterator();
+        while (iter.hasNext()) {
+                String next = iter.next();
+                System.out.println(next);
+                iter.remove();
+        }
+        ListIterator<String> listIterator = items.listIterator();
+        while(listIterator.hasNext()) {
+            String nextWithIndex = items.get(listIterator.nextIndex());
+            String next = listIterator.next();
+            if( "ONE".equals(next)) {
+                listIterator.set("SWAPPED");
+            }
+        }
+        listIterator.add("FOUR");
+        while(listIterator.hasPrevious()) {
+            String previousWithIndex = items.get(listIterator.previousIndex());
+            String previous = listIterator.previous();
+            System.out.println(previous);
+        }
+        listIterator.forEachRemaining(e -> {
+            System.out.println(e);
+        });
+    }
+}

core-java/src/main/java/com/baeldung/regexp/datepattern/DateMatcher.java

@@ -0,0 +1,7 @@
+package com.baeldung.regexp.datepattern;
+
+public interface DateMatcher {
+
+    boolean matches(String date);
+
+}

core-java/src/main/java/com/baeldung/regexp/datepattern/FormattedDateMatcher.java

@@ -0,0 +1,14 @@
+package com.baeldung.regexp.datepattern;
+
+import java.util.regex.Pattern;
+
+class FormattedDateMatcher implements DateMatcher {
+
+    private static final Pattern DATE_PATTERN = Pattern.compile(
+            "^\\d{4}-\\d{2}-\\d{2}$");
+
+    @Override
+    public boolean matches(String date) {
+        return DATE_PATTERN.matcher(date).matches();
+    }
+}

core-java/src/main/java/com/baeldung/regexp/datepattern/RangedDateMatcher.java

@@ -0,0 +1,14 @@
+package com.baeldung.regexp.datepattern;
+
+import java.util.regex.Pattern;
+
+class RangedDateMatcher implements DateMatcher {
+
+    private static final Pattern DATE_PATTERN = Pattern.compile(
+            "^((19|2[0-9])[0-9]{2})-(0[1-9]|1[012])-(0[1-9]|[12][0-9]|3[01])$");
+
+    @Override
+    public boolean matches(String date) {
+        return DATE_PATTERN.matcher(date).matches();
+    }
+}

core-java/src/main/java/com/baeldung/regexp/datepattern/gregorian/February29thMatcher.java

@@ -0,0 +1,16 @@
+package com.baeldung.regexp.datepattern.gregorian;
+
+import com.baeldung.regexp.datepattern.DateMatcher;
+
+import java.util.regex.Pattern;
+
+public class February29thMatcher implements DateMatcher {
+
+    private static final Pattern DATE_PATTERN = Pattern.compile(
+            "^((2000|2400|2800|(19|2[0-9](0[48]|[2468][048]|[13579][26])))-02-29)$");
+
+    @Override
+    public boolean matches(String date) {
+        return DATE_PATTERN.matcher(date).matches();
+    }
+}

core-java/src/main/java/com/baeldung/regexp/datepattern/gregorian/FebruaryGeneralMatcher.java

@@ -0,0 +1,16 @@
+package com.baeldung.regexp.datepattern.gregorian;
+
+import com.baeldung.regexp.datepattern.DateMatcher;
+
+import java.util.regex.Pattern;
+
+public class FebruaryGeneralMatcher implements DateMatcher {
+
+    private static final Pattern DATE_PATTERN = Pattern.compile(
+            "^(((19|2[0-9])[0-9]{2})-02-(0[1-9]|1[0-9]|2[0-8]))$");
+
+    @Override
+    public boolean matches(String date) {
+        return DATE_PATTERN.matcher(date).matches();
+    }
+}

core-java/src/main/java/com/baeldung/regexp/datepattern/gregorian/GregorianDateMatcher.java

@@ -0,0 +1,19 @@
+package com.baeldung.regexp.datepattern.gregorian;
+
+import com.baeldung.regexp.datepattern.DateMatcher;
+
+import java.util.regex.Pattern;
+
+class GregorianDateMatcher implements DateMatcher {
+
+    private static final Pattern DATE_PATTERN = Pattern.compile(
+            "^((2000|2400|2800|(19|2[0-9](0[48]|[2468][048]|[13579][26])))-02-29)$" 
+            + "|^(((19|2[0-9])[0-9]{2})-02-(0[1-9]|1[0-9]|2[0-8]))$"
+            + "|^(((19|2[0-9])[0-9]{2})-(0[13578]|10|12)-(0[1-9]|[12][0-9]|3[01]))$" 
+            + "|^(((19|2[0-9])[0-9]{2})-(0[469]|11)-(0[1-9]|[12][0-9]|30))$");
+
+    @Override
+    public boolean matches(String date) {
+        return DATE_PATTERN.matcher(date).matches();
+    }
+}

core-java/src/main/java/com/baeldung/regexp/datepattern/gregorian/MonthsOf30DaysMatcher.java

@@ -0,0 +1,17 @@
+package com.baeldung.regexp.datepattern.gregorian;
+
+import com.baeldung.regexp.datepattern.DateMatcher;
+
+import java.util.regex.Pattern;
+
+public class MonthsOf30DaysMatcher implements DateMatcher {
+
+    private static final Pattern DATE_PATTERN = Pattern.compile(
+            "^(((19|2[0-9])[0-9]{2})-(0[469]|11)-(0[1-9]|[12][0-9]|30))$");
+
+    @Override
+    public boolean matches(String date) {
+        return DATE_PATTERN.matcher(date).matches();
+    }
+
+}

core-java/src/main/java/com/baeldung/regexp/datepattern/gregorian/MonthsOf31DaysMatcher.java

@@ -0,0 +1,17 @@
+package com.baeldung.regexp.datepattern.gregorian;
+
+import com.baeldung.regexp.datepattern.DateMatcher;
+
+import java.util.regex.Pattern;
+
+public class MonthsOf31DaysMatcher implements DateMatcher {
+
+    private static final Pattern DATE_PATTERN = Pattern.compile(
+            "^(((19|2[0-9])[0-9]{2})-(0[13578]|10|12)-(0[1-9]|[12][0-9]|3[01]))$");
+
+    @Override
+    public boolean matches(String date) {
+        return DATE_PATTERN.matcher(date).matches();
+    }
+
+}

core-java/src/test/java/com/baeldung/regexp/datepattern/FormattedDateMatcherUnitTest.java

@@ -0,0 +1,24 @@
+package com.baeldung.regexp.datepattern;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class FormattedDateMatcherUnitTest {
+
+    private DateMatcher matcher = new FormattedDateMatcher();
+
+    @Test
+    public void whenUsingFormattedDateMatcher_thenFormatConstraintsSatisfied() {
+        Assert.assertTrue(matcher.matches("2017-12-31"));
+        Assert.assertTrue(matcher.matches("2018-01-01"));
+        Assert.assertTrue(matcher.matches("0000-00-00"));
+        Assert.assertTrue(matcher.matches("1029-99-72"));
+
+        Assert.assertFalse(matcher.matches("2018-01"));
+        Assert.assertFalse(matcher.matches("2018-01-01-01"));
+        Assert.assertFalse(matcher.matches("2018-01-XX"));
+        Assert.assertFalse(matcher.matches(" 2018-01-01"));
+        Assert.assertFalse(matcher.matches("2018-01-01 "));
+        Assert.assertFalse(matcher.matches("2018/01/01"));
+    }
+}

core-java/src/test/java/com/baeldung/regexp/datepattern/RangedDateMatcherUnitTest.java

@@ -0,0 +1,31 @@
+package com.baeldung.regexp.datepattern;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class RangedDateMatcherUnitTest {
+
+    private DateMatcher matcher = new RangedDateMatcher();
+
+    @Test
+    public void whenUsingRangedDateMatcher_thenFormatConstraintsSatisfied() {
+        Assert.assertFalse(matcher.matches("2018-01"));
+        Assert.assertFalse(matcher.matches("2018-01-01-01"));
+        Assert.assertFalse(matcher.matches("2018-01-XX"));
+        Assert.assertFalse(matcher.matches(" 2018-01-01"));
+        Assert.assertFalse(matcher.matches("2018-01-01 "));
+        Assert.assertFalse(matcher.matches("2018/01/01"));
+    }
+
+    @Test
+    public void whenUsingRangedDateMatcher_thenRangeConstraintsSatisfied() {
+        Assert.assertTrue(matcher.matches("1900-01-01"));
+        Assert.assertTrue(matcher.matches("2018-02-31"));
+        Assert.assertTrue(matcher.matches("2999-12-31"));
+
+        Assert.assertFalse(matcher.matches("1899-12-31"));
+        Assert.assertFalse(matcher.matches("2018-05-35"));
+        Assert.assertFalse(matcher.matches("2018-13-05"));
+        Assert.assertFalse(matcher.matches("3000-01-01"));
+    }
+}

core-java/src/test/java/com/baeldung/regexp/datepattern/gregorian/February29thMatcherUnitTest.java

@@ -0,0 +1,17 @@
+package com.baeldung.regexp.datepattern.gregorian;
+
+import com.baeldung.regexp.datepattern.DateMatcher;
+import com.baeldung.regexp.datepattern.gregorian.testhelper.GregorianDateTestHelper;
+import org.junit.Test;
+
+public class February29thMatcherUnitTest {
+
+    private DateMatcher matcher = new February29thMatcher();
+
+    private GregorianDateTestHelper testHelper = new GregorianDateTestHelper(matcher);
+
+    @Test
+    public void whenYearIsLeap_thenYearHasFebruary29th() {
+        testHelper.assertFebruary29th();
+    }
+}

core-java/src/test/java/com/baeldung/regexp/datepattern/gregorian/FebruaryGeneralMatcherUnitTest.java

@@ -0,0 +1,17 @@
+package com.baeldung.regexp.datepattern.gregorian;
+
+import com.baeldung.regexp.datepattern.DateMatcher;
+import com.baeldung.regexp.datepattern.gregorian.testhelper.GregorianDateTestHelper;
+import org.junit.Test;
+
+public class FebruaryGeneralMatcherUnitTest {
+
+    private DateMatcher matcher = new FebruaryGeneralMatcher();
+
+    private GregorianDateTestHelper testHelper = new GregorianDateTestHelper(matcher);
+
+    @Test
+    public void whenMonthIsFebruary_thenMonthContainsUpTo28Days() {
+        testHelper.assertFebruaryGeneralDates();
+    }
+}

core-java/src/test/java/com/baeldung/regexp/datepattern/gregorian/GregorianDateMatcherUnitTest.java

@@ -0,0 +1,42 @@
+package com.baeldung.regexp.datepattern.gregorian;
+
+import com.baeldung.regexp.datepattern.DateMatcher;
+import com.baeldung.regexp.datepattern.gregorian.testhelper.GregorianDateTestHelper;
+import org.junit.Test;
+
+public class GregorianDateMatcherUnitTest {
+
+    private DateMatcher matcher = new GregorianDateMatcher();
+
+    private GregorianDateTestHelper testHelper = new GregorianDateTestHelper(matcher);
+
+    @Test
+    public void whenUsingGregorianDateMatcher_thenFormatConstraintsSatisfied() {
+        testHelper.assertFormat();
+    }
+
+    @Test
+    public void whenUsingGregorianDateMatcher_thenRangeConstraintsSatisfied() {
+        testHelper.assertRange();
+    }
+
+    @Test
+    public void whenYearIsLeap_thenFebruaryHas29Days() {
+        testHelper.assertFebruary29th();
+    }
+
+    @Test
+    public void whenMonthIsFebruary_thenMonthContainsUpTo28Days() {
+        testHelper.assertFebruaryGeneralDates();
+    }
+
+    @Test
+    public void whenMonthIsShort_thenMonthContainsUpTo30Days() {
+        testHelper.assertMonthsOf30Days();
+    }
+
+    @Test
+    public void whenMonthIsLong_thenMonthContainsUpTo31Days() {
+        testHelper.assertMonthsOf31Dates();
+    }
+}

core-java/src/test/java/com/baeldung/regexp/datepattern/gregorian/MonthsOf30DaysMatcherUnitTest.java

@@ -0,0 +1,17 @@
+package com.baeldung.regexp.datepattern.gregorian;
+
+import com.baeldung.regexp.datepattern.DateMatcher;
+import com.baeldung.regexp.datepattern.gregorian.testhelper.GregorianDateTestHelper;
+import org.junit.Test;
+
+public class MonthsOf30DaysMatcherUnitTest {
+
+    private DateMatcher matcher = new MonthsOf30DaysMatcher();
+
+    private GregorianDateTestHelper testHelper = new GregorianDateTestHelper(matcher);
+
+    @Test
+    public void whenMonthIsShort_thenMonthContainsUpTo30Days() {
+        testHelper.assertMonthsOf30Days();
+    }
+}

core-java/src/test/java/com/baeldung/regexp/datepattern/gregorian/MonthsOf31DaysMatcherUnitTest.java

@@ -0,0 +1,17 @@
+package com.baeldung.regexp.datepattern.gregorian;
+
+import com.baeldung.regexp.datepattern.DateMatcher;
+import com.baeldung.regexp.datepattern.gregorian.testhelper.GregorianDateTestHelper;
+import org.junit.Test;
+
+public class MonthsOf31DaysMatcherUnitTest {
+
+    private DateMatcher matcher = new MonthsOf31DaysMatcher();
+
+    private GregorianDateTestHelper testHelper = new GregorianDateTestHelper(matcher);
+
+    @Test
+    public void whenMonthIsLong_thenMonthContainsUpTo31Days() {
+        testHelper.assertMonthsOf31Dates();
+    }
+}

core-java/src/test/java/com/baeldung/regexp/datepattern/gregorian/testhelper/GregorianDateTestHelper.java

@@ -0,0 +1,102 @@
+package com.baeldung.regexp.datepattern.gregorian.testhelper;
+
+import com.baeldung.regexp.datepattern.DateMatcher;
+import org.junit.Assert;
+
+public class GregorianDateTestHelper {
+
+    private final DateMatcher matcher;
+
+    public GregorianDateTestHelper(DateMatcher matcher) {
+        this.matcher = matcher;
+    }
+
+    public void assertFormat() {
+        Assert.assertTrue(matcher.matches("2017-12-31"));
+        Assert.assertTrue(matcher.matches("2018-01-01"));
+
+        Assert.assertFalse(matcher.matches("2018-02"));
+        Assert.assertFalse(matcher.matches("2018-02-01-01"));
+        Assert.assertFalse(matcher.matches("2018-02-XX"));
+        Assert.assertFalse(matcher.matches(" 2018-02-01"));
+        Assert.assertFalse(matcher.matches("2018-02-01 "));
+        Assert.assertFalse(matcher.matches("2020/02/28"));
+        Assert.assertFalse(matcher.matches("2020.02.29"));
+    }
+
+    public void assertRange() {
+        Assert.assertTrue(matcher.matches("1900-01-01"));
+        Assert.assertTrue(matcher.matches("2205-05-25"));
+        Assert.assertTrue(matcher.matches("2999-12-31"));
+
+        Assert.assertFalse(matcher.matches("1899-12-31"));
+        Assert.assertFalse(matcher.matches("2018-05-35"));
+        Assert.assertFalse(matcher.matches("2018-13-05"));
+        Assert.assertFalse(matcher.matches("3000-01-01"));
+        Assert.assertFalse(matcher.matches("3200-02-29"));
+    }
+
+    public void assertFebruary29th() {
+        Assert.assertTrue(matcher.matches("2000-02-29"));
+        Assert.assertTrue(matcher.matches("2400-02-29"));
+        Assert.assertTrue(matcher.matches("2800-02-29"));
+        Assert.assertTrue(matcher.matches("2020-02-29"));
+        Assert.assertTrue(matcher.matches("2024-02-29"));
+        Assert.assertTrue(matcher.matches("2028-02-29"));
+
+        Assert.assertFalse(matcher.matches("2017-02-29"));
+        Assert.assertFalse(matcher.matches("2018-02-29"));
+        Assert.assertFalse(matcher.matches("2019-02-29"));
+        Assert.assertFalse(matcher.matches("2100-02-29"));
+        Assert.assertFalse(matcher.matches("2200-02-29"));
+        Assert.assertFalse(matcher.matches("2300-02-29"));
+    }
+
+    public void assertFebruaryGeneralDates() {
+        Assert.assertTrue(matcher.matches("2018-02-01"));
+        Assert.assertTrue(matcher.matches("2019-02-13"));
+        Assert.assertTrue(matcher.matches("2020-02-25"));
+
+        Assert.assertFalse(matcher.matches("2000-02-30"));
+        Assert.assertFalse(matcher.matches("2400-02-62"));
+        Assert.assertFalse(matcher.matches("2420-02-94"));
+    }
+
+    public void assertMonthsOf30Days() {
+        Assert.assertTrue(matcher.matches("2018-04-30"));
+        Assert.assertTrue(matcher.matches("2019-06-30"));
+        Assert.assertTrue(matcher.matches("2020-09-30"));
+        Assert.assertTrue(matcher.matches("2021-11-30"));
+
+        Assert.assertTrue(matcher.matches("2022-04-02"));
+        Assert.assertTrue(matcher.matches("2023-06-14"));
+        Assert.assertTrue(matcher.matches("2024-09-26"));
+
+        Assert.assertFalse(matcher.matches("2018-04-31"));
+        Assert.assertFalse(matcher.matches("2019-06-31"));
+        Assert.assertFalse(matcher.matches("2020-09-31"));
+        Assert.assertFalse(matcher.matches("2021-11-31"));
+
+        Assert.assertFalse(matcher.matches("2022-04-32"));
+        Assert.assertFalse(matcher.matches("2023-06-64"));
+        Assert.assertFalse(matcher.matches("2024-09-96"));
+    }
+
+    public void assertMonthsOf31Dates() {
+        Assert.assertTrue(matcher.matches("2018-01-31"));
+        Assert.assertTrue(matcher.matches("2019-03-31"));
+        Assert.assertTrue(matcher.matches("2020-05-31"));
+        Assert.assertTrue(matcher.matches("2021-07-31"));
+        Assert.assertTrue(matcher.matches("2022-08-31"));
+        Assert.assertTrue(matcher.matches("2023-10-31"));
+        Assert.assertTrue(matcher.matches("2024-12-31"));
+
+        Assert.assertTrue(matcher.matches("2025-01-03"));
+        Assert.assertTrue(matcher.matches("2026-03-15"));
+        Assert.assertTrue(matcher.matches("2027-05-27"));
+
+        Assert.assertFalse(matcher.matches("2018-01-32"));
+        Assert.assertFalse(matcher.matches("2019-03-64"));
+        Assert.assertFalse(matcher.matches("2020-05-96"));
+    }
+}

java-lite/pom.xml

@@ -7,6 +7,7 @@
     <groupId>org.baeldung</groupId>
     <artifactId>java-lite</artifactId>
     <version>1.0-SNAPSHOT</version>
+    <packaging>war</packaging>
 
     <parent>
         <groupId>com.baeldung</groupId>
@@ -15,7 +16,7 @@
     </parent>
 
     <properties>
-        <jetty.maven.plugin.version>9.3.4.RC1</jetty.maven.plugin.version>
+        <jetty.maven.plugin.version>9.4.8.v20171121</jetty.maven.plugin.version>
         <activejdbc.version>1.4.13</activejdbc.version>
         <activeweb.version>1.15</activeweb.version>
         <mysql.connector.java.version>5.1.45</mysql.connector.java.version>
@@ -85,16 +86,6 @@
             <systemPath>${java.home}/../lib/tools.jar</systemPath>
         </dependency>
 
-        <dependency>
-            <groupId>org.codehaus.jackson</groupId>
-            <artifactId>jackson-core-lgpl</artifactId>
-            <version>${jackson.version}</version>
-        </dependency>
-        <dependency>
-            <groupId>org.codehaus.jackson</groupId>
-            <artifactId>jackson-mapper-lgpl</artifactId>
-            <version>${jackson.version}</version>
-        </dependency>
         <dependency>
             <groupId>junit</groupId>
             <artifactId>junit</artifactId>

java-lite/src/main/java/app/config/AppControllerConfig.java

@@ -9,7 +9,7 @@ import org.javalite.activeweb.controller_filters.TimingFilter;
 public class AppControllerConfig extends AbstractControllerConfig {
     @Override
     public void init(AppContext appContext) {
-      addGlobalFilters(new TimingFilter());
-      add(new DBConnectionFilter()).to(ProductsController.class);
+        addGlobalFilters(new TimingFilter());
+        add(new DBConnectionFilter()).to(ProductsController.class);
     }
 }

java-lite/src/main/java/app/config/DbConfig.java

@@ -6,6 +6,6 @@ import org.javalite.activeweb.AppContext;
 public class DbConfig extends AbstractDBConfig {
     @Override
     public void init(AppContext appContext) {
-      this.configFile("/database.properties");
+        this.configFile("/database.properties");
     }
 }

java-lite/src/main/java/app/controllers/ProductsController.java

@@ -10,92 +10,94 @@ import java.util.Map;
 @RESTful
 public class ProductsController extends AppController {
 
+    private ObjectMapper mapper = new ObjectMapper();
+
     public void index() {
-      try {
-        view("products", Product.findAll());
-        render().contentType("application/json");
-      } catch (Exception e) {
-        view("message", "There was an error.", "code", 200);
-        render("message");
-      }
+        try {
+            view("products", Product.findAll());
+            render().contentType("application/json");
+        } catch (Exception e) {
+            view("message", "There was an error.", "code", 200);
+            render("message");
+        }
     }
 
     public void create() {
-      try {
-        Map payload = new ObjectMapper().readValue(getRequestString(), Map.class);
-        Product p = new Product();
-        p.fromMap(payload);
-        p.saveIt();
-        view("message", "Successfully saved product id " + p.get("id"), "code", 200);
-        render("message");
-      } catch (Exception e) {
-        view("message", "There was an error.", "code", 200);
-        render("message");
-      }
+        try {
+            Map payload = mapper.readValue(getRequestString(), Map.class);
+            Product p = new Product();
+            p.fromMap(payload);
+            p.saveIt();
+            view("message", "Successfully saved product id " + p.get("id"), "code", 200);
+            render("message");
+        } catch (Exception e) {
+            view("message", "There was an error.", "code", 200);
+            render("message");
+        }
     }
 
     public void update() {
-      try {
-        Map payload = new ObjectMapper().readValue(getRequestString(), Map.class);
-        String id = getId();
-        Product p = Product.findById(id);
-        if (p == null) {
-          view("message", "Product id " + id + " not found.", "code", 200);
-          render("message");
-          return;
+        try {
+            Map payload = mapper.readValue(getRequestString(), Map.class);
+            String id = getId();
+            Product p = Product.findById(id);
+            if (p == null) {
+                view("message", "Product id " + id + " not found.", "code", 200);
+                render("message");
+                return;
+            }
+            p.fromMap(payload);
+            p.saveIt();
+            view("message", "Successfully updated product id " + id, "code", 200);
+            render("message");
+        } catch (Exception e) {
+            view("message", "There was an error.", "code", 200);
+            render("message");
         }
-        p.fromMap(payload);
-        p.saveIt();
-        view("message", "Successfully updated product id " + id, "code", 200);
-        render("message");
-      } catch (Exception e) {
-        view("message", "There was an error.", "code", 200);
-        render("message");
-      }
     }
 
     public void show() {
-      try {
-        String id = getId();
-        Product p = Product.findById(id);
-        if (p == null) {
-          view("message", "Product id " + id + " not found.", "code", 200);
-          render("message");
-          return;
+        try {
+            String id = getId();
+            Product p = Product.findById(id);
+            if (p == null) {
+                view("message", "Product id " + id + " not found.", "code", 200);
+                render("message");
+                return;
+            }
+            view("product", p);
+            render("_product");
+        } catch (Exception e) {
+            view("message", "There was an error.", "code", 200);
+            render("message");
         }
-        view("product", p);
-        render("_product");
-      } catch (Exception e) {
-        view("message", "There was an error.", "code", 200);
-        render("message");
-      }
     }
 
     public void destroy() {
-      try {
-        String id = getId();
-        Product p = Product.findById(id);
-        if (p == null) {
-          view("message", "Product id " + id + " not found.", "code", 200);
-          render("message");
-          return;
+        try {
+            String id = getId();
+            Product p = Product.findById(id);
+            if (p == null) {
+                view("message", "Product id " + id + " not found.", "code", 200);
+                render("message");
+                return;
+            }
+            p.delete();
+            view("message", "Successfully deleted product id " + id, "code", 200);
+            render("message");
+        } catch (Exception e) {
+            view("message", "There was an error.", "code", 200);
+            render("message");
         }
-        p.delete();
-        view("message", "Successfully deleted product id " + id, "code", 200);
-        render("message");
-      } catch (Exception e) {
-        view("message", "There was an error.", "code", 200);
-        render("message");
-      }
     }
 
     @Override
     protected String getContentType() {
-      return "application/json";
+        return "application/json";
     }
 
     @Override
     protected String getLayout() {
-      return null;
+        return null;
     }
 }

java-lite/src/test/java/app/models/ProductTest.java

@@ -8,18 +8,18 @@ public class ProductTest {
 
     //@Test
     public void givenSavedProduct_WhenFindFirst_ThenSavedProductIsReturned() {
-      //Open DB connection
-      Base.open("com.mysql.jdbc.Driver", "jdbc:mysql://localhost/dbname", "user", "password");
+        //Open DB connection
+        Base.open("com.mysql.jdbc.Driver", "jdbc:mysql://localhost/dbname", "user", "password");
 
-      //Create a product and save it
-      Product toSaveProduct = new Product();
-      toSaveProduct.set("name", "Bread");
-      toSaveProduct.saveIt();
+        //Create a product and save it
+        Product toSaveProduct = new Product();
+        toSaveProduct.set("name", "Bread");
+        toSaveProduct.saveIt();
 
-      //Find product
-      Product savedProduct = Product.findFirst("name = ?", "Bread");
+        //Find product
+        Product savedProduct = Product.findFirst("name = ?", "Bread");
 
-      Assert.assertEquals(toSaveProduct.get("name"), savedProduct.get("name"));
+        Assert.assertEquals(toSaveProduct.get("name"), savedProduct.get("name"));
     }
 
 }

libraries/pom.xml

@@ -107,7 +107,7 @@
             <!-- /Neuroph -->
             <plugin>
                 <artifactId>maven-compiler-plugin</artifactId>
-                <version>3.7.0</version>              
+                <version>3.7.0</version>
                 <configuration>
                     <source>1.8</source>
                     <target>1.8</target>
@@ -639,6 +639,33 @@
           <version>${googleclient.version}</version>
         </dependency>
 
+        <!--Java Docker API Client-->
+        <dependency>
+            <groupId>com.github.docker-java</groupId>
+            <artifactId>docker-java</artifactId>
+            <version>${docker.version}</version>
+            <exclusions>
+                <exclusion>
+                    <groupId>org.slf4j</groupId>
+                    <artifactId>slf4j-log4j12</artifactId>
+                </exclusion>
+                <exclusion>
+                    <groupId>org.slf4j</groupId>
+                    <artifactId>jcl-over-slf4j</artifactId>
+                </exclusion>
+                <exclusion>
+                    <groupId>ch.qos.logback</groupId>
+                    <artifactId>logback-classic</artifactId>
+                </exclusion>
+            </exclusions>
+        </dependency>
+        <dependency>
+            <groupId>com.sun.jersey</groupId>
+            <artifactId>jersey-client</artifactId>
+            <version>1.19.4</version>
+        </dependency>
+        <!--Java Docker API Client-->
+
         <!-- google api -->
         <dependency>
           <groupId>com.google.api-client</groupId>
@@ -758,5 +785,6 @@
         <google-api.version>1.23.0</google-api.version>
         <google-sheets.version>v4-rev493-1.21.0</google-sheets.version>
         <kafka.version>1.0.0</kafka.version>
+        <docker.version>3.0.14</docker.version>
     </properties>
 </project>

libraries/src/test/java/com/baeldung/dockerapi/ContainerLiveTest.java

@@ -0,0 +1,165 @@
+package com.baeldung.dockerapi;
+
+import com.github.dockerjava.api.DockerClient;
+import com.github.dockerjava.api.command.CreateContainerResponse;
+import com.github.dockerjava.api.command.InspectContainerResponse;
+import com.github.dockerjava.api.model.Container;
+import com.github.dockerjava.api.model.PortBinding;
+import com.github.dockerjava.core.DockerClientBuilder;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import java.util.List;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.not;
+import static org.hamcrest.core.Is.is;
+
+public class ContainerLiveTest {
+
+    private static DockerClient dockerClient;
+
+    @BeforeClass
+    public static void setup() {
+        dockerClient = DockerClientBuilder.getInstance().build();
+    }
+
+    @Test
+    public void whenListingRunningContainers_thenReturnNonEmptyList() {
+
+        //when
+        List<Container> containers = dockerClient.listContainersCmd().exec();
+
+        //then
+        assertThat(containers.size(), is(not(0)));
+    }
+
+    @Test
+    public void whenListingExitedContainers_thenReturnNonEmptyList() {
+
+        //when
+        List<Container> containers = dockerClient.listContainersCmd()
+                .withShowSize(true)
+                .withShowAll(true)
+                .withStatusFilter("exited")
+                .exec();
+
+        //then
+        assertThat(containers.size(), is(not(0)));
+    }
+
+    @Test
+    public void whenCreatingContainer_thenMustReturnContainerId() {
+
+        //when
+        CreateContainerResponse container
+                = dockerClient.createContainerCmd("mongo:3.6")
+                .withCmd("--bind_ip_all")
+                .withName("mongo")
+                .withHostName("baeldung")
+                .withEnv("MONGO_LATEST_VERSION=3.6")
+                .withPortBindings(PortBinding.parse("9999:27017"))
+                .exec();
+
+        //then
+        assertThat(container.getId(), is(not(null)));
+    }
+
+
+    @Test
+    public void whenHavingContainer_thenRunContainer() throws InterruptedException {
+
+        //when
+        CreateContainerResponse container
+                = dockerClient.createContainerCmd("alpine:3.6")
+                .withCmd("sleep", "10000")
+                .exec();
+
+        Thread.sleep(3000);
+        //then
+        dockerClient.startContainerCmd(container.getId())
+                .exec();
+
+        dockerClient.stopContainerCmd(container.getId())
+                .exec();
+    }
+
+    @Test
+    public void whenRunningContainer_thenStopContainer() throws InterruptedException {
+
+        //when
+        CreateContainerResponse container
+                = dockerClient.createContainerCmd("alpine:3.6")
+                .withCmd("sleep", "10000")
+                .exec();
+
+        Thread.sleep(3000);
+        dockerClient.startContainerCmd(container.getId())
+                .exec();
+
+        //then
+        dockerClient.stopContainerCmd(container.getId())
+                .exec();
+    }
+
+    @Test
+    public void whenRunningContainer_thenKillContainer() throws InterruptedException {
+
+        //when
+        CreateContainerResponse container
+                = dockerClient.createContainerCmd("alpine:3.6")
+                .withCmd("sleep", "10000")
+                .exec();
+
+        dockerClient.startContainerCmd(container.getId())
+                .exec();
+
+        Thread.sleep(3000);
+        dockerClient.stopContainerCmd(container.getId())
+                .exec();
+
+        //then
+        dockerClient.killContainerCmd(container.getId())
+                .exec();
+    }
+
+    @Test
+    public void whenHavingContainer_thenInspectContainer() {
+
+        //when
+        CreateContainerResponse container
+                = dockerClient.createContainerCmd("alpine:3.6")
+                .withCmd("sleep", "10000")
+                .exec();
+
+        //then
+        InspectContainerResponse containerResponse
+                = dockerClient.inspectContainerCmd(container.getId())
+                .exec();
+
+        assertThat(containerResponse.getId(), is(container.getId()));
+    }
+
+
+    @Test
+    public void givenContainer_whenCommittingContainer_thenMustReturnImageId() {
+
+        //given
+        CreateContainerResponse container
+                = dockerClient.createContainerCmd("alpine:3.6")
+                .withCmd("sleep", "10000")
+                .exec();
+
+        //when
+        String imageId = dockerClient.commitCmd(container.getId())
+                .withEnv("SNAPSHOT_YEAR=2018")
+                .withMessage("add git support")
+                .withCmd("sleep", "10000")
+                .withRepository("alpine")
+                .withTag("3.6.v2").exec();
+
+        //then
+        assertThat(imageId, is(not(null)));
+    }
+
+}

libraries/src/test/java/com/baeldung/dockerapi/DockerClientLiveTest.java

@@ -0,0 +1,83 @@
+package com.baeldung.dockerapi;
+
+import com.github.dockerjava.api.DockerClient;
+import com.github.dockerjava.core.DefaultDockerClientConfig;
+import com.github.dockerjava.core.DockerClientBuilder;
+import org.junit.Test;
+
+import java.util.Properties;
+
+import static org.junit.Assert.assertNotNull;
+
+public class DockerClientLiveTest {
+
+    @Test
+    public void whenCreatingDockerClient_thenReturnDefaultInstance() {
+
+        //when
+        DefaultDockerClientConfig.Builder config
+                = DefaultDockerClientConfig.createDefaultConfigBuilder();
+        DockerClient dockerClient = DockerClientBuilder.getInstance(config).build();
+
+        //then
+        assertNotNull(dockerClient);
+    }
+
+    @Test
+    public void whenCreatingDockerClientWithDockerHost_thenReturnInstance() {
+        //when
+        DockerClient dockerClient
+                = DockerClientBuilder.getInstance("tcp://docker.bealdung.com:2375")
+                .build();
+
+        //then
+        assertNotNull(dockerClient);
+    }
+
+    @Test
+    public void whenCreatingAdvanceDockerClient_thenReturnInstance() {
+
+        //when
+        DefaultDockerClientConfig config
+                = DefaultDockerClientConfig.createDefaultConfigBuilder()
+                .withRegistryEmail("[email protected]")
+                .withRegistryUrl("register.bealdung.io/v2/")
+                .withRegistryPassword("strongpassword")
+                .withRegistryUsername("bealdung")
+                .withDockerCertPath("/home/bealdung/public/.docker/certs")
+                .withDockerConfig("/home/bealdung/public/.docker/")
+                .withDockerTlsVerify("1")
+                .withDockerHost("tcp://docker.beauldung.com:2376")
+                .build();
+
+        DockerClient dockerClient = DockerClientBuilder.getInstance(config).build();
+
+        //then
+        assertNotNull(dockerClient);
+    }
+
+    @Test
+    public void whenCreatingDockerClientWithProperties_thenReturnInstance() {
+
+        //when
+        Properties properties = new Properties();
+        properties.setProperty("registry.email", "[email protected]");
+        properties.setProperty("registry.url", "register.bealdung.io/v2/");
+        properties.setProperty("registry.password", "strongpassword");
+        properties.setProperty("registry.username", "bealdung");
+        properties.setProperty("DOCKER_CERT_PATH", "/home/bealdung/public/.docker/certs");
+        properties.setProperty("DOCKER_CONFIG", "/home/bealdung/public/.docker/");
+        properties.setProperty("DOCKER_TLS_VERIFY", "1");
+        properties.setProperty("DOCKER_HOST", "tcp://docker.bealdung.com:2376");
+
+        DefaultDockerClientConfig config
+                = DefaultDockerClientConfig.createDefaultConfigBuilder()
+                .withProperties(properties)
+                .build();
+
+        DockerClient dockerClient = DockerClientBuilder.getInstance(config).build();
+
+        //then
+        assertNotNull(dockerClient);
+    }
+}

libraries/src/test/java/com/baeldung/dockerapi/ImageLiveTest.java

@@ -0,0 +1,155 @@
+package com.baeldung.dockerapi;
+
+import com.github.dockerjava.api.DockerClient;
+import com.github.dockerjava.api.command.InspectImageResponse;
+import com.github.dockerjava.api.model.Image;
+import com.github.dockerjava.api.model.SearchItem;
+import com.github.dockerjava.core.DockerClientBuilder;
+import com.github.dockerjava.core.command.BuildImageResultCallback;
+import com.github.dockerjava.core.command.PullImageResultCallback;
+import com.github.dockerjava.core.command.PushImageResultCallback;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import java.io.File;
+import java.util.List;
+import java.util.concurrent.TimeUnit;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.greaterThan;
+import static org.hamcrest.Matchers.lessThan;
+import static org.hamcrest.Matchers.not;
+import static org.hamcrest.core.Is.is;
+
+public class ImageLiveTest {
+
+    private static DockerClient dockerClient;
+
+    @BeforeClass
+    public static void setup() {
+        dockerClient = DockerClientBuilder.getInstance().build();
+    }
+
+    @Test
+    public void whenListingImages_thenReturnNonEmptyList() {
+
+        //when
+        List<Image> images = dockerClient.listImagesCmd().exec();
+
+        //then
+        assertThat(images.size(), is(not(0)));
+    }
+
+    @Test
+    public void whenListingImagesWithIntermediateImages_thenReturnNonEmptyList() {
+
+        //when
+        List<Image> images = dockerClient.listImagesCmd()
+                .withShowAll(true).exec();
+
+        //then
+        assertThat(images.size(), is(not(0)));
+    }
+
+    @Test
+    public void whenListingDanglingImages_thenReturnNonNullList() {
+
+        //when
+        List<Image> images = dockerClient.listImagesCmd()
+                .withDanglingFilter(true).exec();
+
+        //then
+        assertThat(images, is(not(null)));
+    }
+
+    @Test
+    public void whenBuildingImage_thenMustReturnImageId() {
+
+        //when
+        String imageId = dockerClient.buildImageCmd()
+                .withDockerfile(new File("src/test/resources/dockerapi/Dockerfile"))
+                .withPull(true)
+                .withNoCache(true)
+                .withTag("alpine:git")
+                .exec(new BuildImageResultCallback())
+                .awaitImageId();
+
+        //then
+        assertThat(imageId, is(not(null)));
+    }
+
+    @Test
+    public void givenListOfImages_whenInspectImage_thenMustReturnObject() {
+
+        //given
+        List<Image> images = dockerClient.listImagesCmd().exec();
+        Image image = images.get(0);
+
+        //when
+        InspectImageResponse imageResponse
+                = dockerClient.inspectImageCmd(image.getId()).exec();
+
+        //then
+        assertThat(imageResponse.getId(), is(image.getId()));
+    }
+
+    @Test
+    public void givenListOfImages_whenTagImage_thenListMustIncrement() {
+
+        //given
+        List<Image> images = dockerClient.listImagesCmd().exec();
+        Image image = images.get(0);
+
+        //when
+        dockerClient.tagImageCmd(image.getId(), "baeldung/alpine", "3.6.v2").exec();
+
+        //then
+        List<Image> imagesNow = dockerClient.listImagesCmd().exec();
+        assertThat(imagesNow.size(), is(greaterThan(images.size())));
+    }
+
+    public void pushingAnImage() throws InterruptedException {
+
+        dockerClient.pushImageCmd("baeldung/alpine")
+                .withTag("3.6.v2")
+                .exec(new PushImageResultCallback())
+                .awaitCompletion(90, TimeUnit.SECONDS);
+    }
+
+    @Test
+    public void whenPullingImage_thenImageListNotEmpty() throws InterruptedException {
+
+        //when
+        dockerClient.pullImageCmd("alpine")
+                .withTag("latest")
+                .exec(new PullImageResultCallback())
+                .awaitCompletion(30, TimeUnit.SECONDS);
+
+        //then
+        List<Image> images = dockerClient.listImagesCmd().exec();
+        assertThat(images.size(), is(not(0)));
+    }
+
+    @Test
+    public void whenRemovingImage_thenImageListDecrease() {
+
+        //when
+        List<Image> images = dockerClient.listImagesCmd().exec();
+        Image image = images.get(0);
+        dockerClient.removeImageCmd(image.getId()).exec();
+
+        //then
+        List<Image> imagesNow = dockerClient.listImagesCmd().exec();
+        assertThat(imagesNow.size(), is(lessThan(images.size())));
+    }
+
+    @Test
+    public void whenSearchingImage_thenMustReturn25Items() {
+
+        //when
+        List<SearchItem> items = dockerClient.searchImagesCmd("Java").exec();
+
+        //then
+        assertThat(items.size(), is(25));
+    }
+}

libraries/src/test/java/com/baeldung/dockerapi/NetworkLiveTest.java

@@ -0,0 +1,91 @@
+package com.baeldung.dockerapi;
+
+import com.github.dockerjava.api.DockerClient;
+import com.github.dockerjava.api.command.CreateNetworkResponse;
+import com.github.dockerjava.api.model.Network;
+import com.github.dockerjava.api.model.Network.Ipam;
+import com.github.dockerjava.core.DockerClientBuilder;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import java.util.List;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.greaterThan;
+import static org.hamcrest.Matchers.not;
+import static org.hamcrest.core.Is.is;
+
+public class NetworkLiveTest {
+
+    private static DockerClient dockerClient;
+
+    @BeforeClass
+    public static void setup() {
+        dockerClient = DockerClientBuilder.getInstance().build();
+    }
+
+    @Test
+    public void whenListingNetworks_thenSizeMustBeGreaterThanZero() {
+
+        //when
+        List<Network> networks = dockerClient.listNetworksCmd().exec();
+
+        //then
+        assertThat(networks.size(), is(greaterThan(0)));
+    }
+
+    @Test
+    public void whenCreatingNetwork_thenRetrieveResponse() {
+
+        //when
+        CreateNetworkResponse networkResponse
+                = dockerClient.createNetworkCmd()
+                .withName("baeldungDefault")
+                .withDriver("bridge").exec();
+
+        //then
+        assertThat(networkResponse, is(not(null)));
+    }
+
+    @Test
+    public void whenCreatingAdvanceNetwork_thenRetrieveResponse() {
+
+        //when
+        CreateNetworkResponse networkResponse = dockerClient.createNetworkCmd()
+                .withName("baeldungAdvanced")
+                .withIpam(new Ipam()
+                        .withConfig(new Ipam.Config()
+                                .withSubnet("172.36.0.0/16")
+                                .withIpRange("172.36.5.0/24")))
+                .withDriver("bridge").exec();
+
+        //then
+        assertThat(networkResponse, is(not(null)));
+    }
+
+    @Test
+    public void whenInspectingNetwork_thenSizeMustBeGreaterThanZero() {
+
+        //when
+        String networkName = "bridge";
+        Network network
+                = dockerClient.inspectNetworkCmd().withNetworkId(networkName).exec();
+
+        //then
+        assertThat(network.getName(), is(networkName));
+    }
+
+    @Test
+    public void whenCreatingNetwork_thenRemove() throws InterruptedException {
+
+        //when
+        CreateNetworkResponse networkResponse
+                = dockerClient.createNetworkCmd()
+                .withName("baeldungDefault")
+                .withDriver("bridge").exec();
+
+        //then
+        Thread.sleep(4000);
+        dockerClient.removeNetworkCmd(networkResponse.getId()).exec();
+    }
+}

libraries/src/test/java/com/baeldung/dockerapi/VolumeLiveTest.java

@@ -0,0 +1,86 @@
+package com.baeldung.dockerapi;
+
+import com.github.dockerjava.api.DockerClient;
+import com.github.dockerjava.api.command.CreateVolumeResponse;
+import com.github.dockerjava.api.command.InspectVolumeResponse;
+import com.github.dockerjava.api.command.ListVolumesResponse;
+import com.github.dockerjava.core.DockerClientBuilder;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import java.util.List;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.greaterThan;
+import static org.hamcrest.Matchers.not;
+import static org.hamcrest.core.Is.is;
+
+public class VolumeLiveTest {
+
+    private static DockerClient dockerClient;
+
+    @BeforeClass
+    public static void setup() {
+        dockerClient = DockerClientBuilder.getInstance().build();
+    }
+
+    @Test
+    public void whenListingVolumes_thenSizeMustBeGreaterThanZero() {
+
+        //when
+        ListVolumesResponse volumesResponse = dockerClient.listVolumesCmd().exec();
+
+        //then
+        List<InspectVolumeResponse> volumes = volumesResponse.getVolumes();
+        assertThat(volumes.size(), is(greaterThan(0)));
+    }
+
+    @Test
+    public void givenVolumes_whenInspectingVolume_thenReturnNonNullResponse() {
+
+        //given
+        ListVolumesResponse volumesResponse = dockerClient.listVolumesCmd().exec();
+        List<InspectVolumeResponse> volumes = volumesResponse.getVolumes();
+        InspectVolumeResponse volume = volumes.get(0);
+
+        //when
+        InspectVolumeResponse volumeResponse
+                = dockerClient.inspectVolumeCmd(volume.getName()).exec();
+
+        //then
+        assertThat(volumeResponse, is(not(null)));
+    }
+
+    @Test
+    public void whenCreatingUnnamedVolume_thenGetVolumeId() {
+
+        //when
+        CreateVolumeResponse unnamedVolume = dockerClient.createVolumeCmd().exec();
+
+        //then
+        assertThat(unnamedVolume.getName(), is(not(null)));
+    }
+
+    @Test
+    public void whenCreatingNamedVolume_thenGetVolumeId() {
+
+        //when
+        CreateVolumeResponse namedVolume
+                = dockerClient.createVolumeCmd().withName("myNamedVolume").exec();
+
+        //then
+        assertThat(namedVolume.getName(), is(not(null)));
+    }
+
+    @Test
+    public void whenGettingNamedVolume_thenRemove() throws InterruptedException {
+
+        //when
+        CreateVolumeResponse namedVolume
+                = dockerClient.createVolumeCmd().withName("anotherNamedVolume").exec();
+
+        //then
+        Thread.sleep(4000);
+        dockerClient.removeVolumeCmd(namedVolume.getName()).exec();
+    }
+}

libraries/src/test/resources/dockerapi/Dockerfile

@@ -0,0 +1,8 @@
+FROM alpine:3.6
+
+RUN apk --update add git openssh && \
+  rm -rf /var/lib/apt/lists/* && \
+  rm /var/cache/apk/*
+
+ENTRYPOINT ["git"]
+CMD ["--help"]