Merge remote-tracking branch 'origin/master'

core-java-8/src/main/java/com/baeldung/threadpool/CountingTask.java

@@ -0,0 +1,22 @@
+package com.baeldung.threadpool;
+
+import java.util.concurrent.ForkJoinTask;
+import java.util.concurrent.RecursiveTask;
+import java.util.stream.Collectors;
+
+public class CountingTask extends RecursiveTask<Integer> {
+
+    private final TreeNode node;
+
+    public CountingTask(TreeNode node) {
+        this.node = node;
+    }
+
+    @Override
+    protected Integer compute() {
+        return node.value + node.children.stream()
+                .map(childNode -> new CountingTask(childNode).fork())
+                .collect(Collectors.summingInt(ForkJoinTask::join));
+    }
+
+}

core-java-8/src/main/java/com/baeldung/threadpool/ExitingExecutorServiceExample.java

@@ -0,0 +1,29 @@
+package com.baeldung.threadpool;
+
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ThreadPoolExecutor;
+import java.util.concurrent.TimeUnit;
+
+import com.google.common.util.concurrent.MoreExecutors;
+
+/**
+ * This class demonstrates the usage of Guava's exiting executor services that keep the VM from hanging.
+ * Without the exiting executor service, the task would hang indefinitely.
+ * This behaviour cannot be demonstrated in JUnit tests, as JUnit kills the VM after the tests.
+ */
+public class ExitingExecutorServiceExample {
+
+    public static void main(String... args) {
+
+        ThreadPoolExecutor executor = (ThreadPoolExecutor) Executors.newFixedThreadPool(5);
+        ExecutorService executorService = MoreExecutors.getExitingExecutorService(executor, 100, TimeUnit.MILLISECONDS);
+
+        executorService.submit(() -> {
+            while (true) {
+            }
+        });
+
+    }
+
+}

core-java-8/src/main/java/com/baeldung/threadpool/TreeNode.java

@@ -0,0 +1,19 @@
+package com.baeldung.threadpool;
+
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Set;
+
+public class TreeNode {
+
+    int value;
+
+    Set<TreeNode> children;
+
+    public TreeNode(int value, TreeNode... children) {
+        this.value = value;
+        this.children = new HashSet<>();
+        this.children.addAll(Arrays.asList(children));
+    }
+
+}

core-java-8/src/test/java/com/baeldung/threadpool/CoreThreadPoolTest.java

@@ -0,0 +1,146 @@
+package com.baeldung.threadpool;
+
+import java.util.concurrent.*;
+import java.util.concurrent.atomic.AtomicInteger;
+
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+public class CoreThreadPoolTest {
+
+    @Test(timeout = 1000)
+    public void whenCallingExecuteWithRunnable_thenRunnableIsExecuted() throws InterruptedException {
+
+        CountDownLatch lock = new CountDownLatch(1);
+
+        Executor executor = Executors.newSingleThreadExecutor();
+        executor.execute(() -> {
+            System.out.println("Hello World");
+            lock.countDown();
+        });
+
+        lock.await(1000, TimeUnit.MILLISECONDS);
+    }
+
+    @Test
+    public void whenUsingExecutorServiceAndFuture_thenCanWaitOnFutureResult() throws InterruptedException, ExecutionException {
+
+        ExecutorService executorService = Executors.newFixedThreadPool(10);
+        Future<String> future = executorService.submit(() -> "Hello World");
+        String result = future.get();
+
+        assertEquals("Hello World", result);
+
+    }
+
+    @Test
+    public void whenUsingFixedThreadPool_thenCoreAndMaximumThreadSizeAreTheSame() {
+
+        ThreadPoolExecutor executor = (ThreadPoolExecutor) Executors.newFixedThreadPool(2);
+        executor.submit(() -> {
+            Thread.sleep(1000);
+            return null;
+        });
+        executor.submit(() -> {
+            Thread.sleep(1000);
+            return null;
+        });
+        executor.submit(() -> {
+            Thread.sleep(1000);
+            return null;
+        });
+
+        assertEquals(2, executor.getPoolSize());
+        assertEquals(1, executor.getQueue().size());
+
+    }
+
+    @Test
+    public void whenUsingCachedThreadPool_thenPoolSizeGrowsUnbounded() {
+        ThreadPoolExecutor executor = (ThreadPoolExecutor) Executors.newCachedThreadPool();
+        executor.submit(() -> {
+            Thread.sleep(1000);
+            return null;
+        });
+        executor.submit(() -> {
+            Thread.sleep(1000);
+            return null;
+        });
+        executor.submit(() -> {
+            Thread.sleep(1000);
+            return null;
+        });
+
+        assertEquals(3, executor.getPoolSize());
+        assertEquals(0, executor.getQueue().size());
+
+    }
+
+    @Test(timeout = 1000)
+    public void whenUsingSingleThreadPool_thenTasksExecuteSequentially() throws InterruptedException {
+
+        CountDownLatch lock = new CountDownLatch(2);
+        AtomicInteger counter = new AtomicInteger();
+
+        ExecutorService executor = Executors.newSingleThreadExecutor();
+        executor.submit(() -> {
+            counter.set(1);
+            lock.countDown();
+        });
+        executor.submit(() -> {
+            counter.compareAndSet(1, 2);
+            lock.countDown();
+        });
+
+        lock.await(1000, TimeUnit.MILLISECONDS);
+        assertEquals(2, counter.get());
+
+    }
+
+    @Test(timeout = 1000)
+    public void whenSchedulingTask_thenTaskExecutesWithinGivenPeriod() throws InterruptedException {
+
+        CountDownLatch lock = new CountDownLatch(1);
+
+        ScheduledExecutorService executor = Executors.newScheduledThreadPool(5);
+        executor.schedule(() -> {
+            System.out.println("Hello World");
+            lock.countDown();
+        }, 500, TimeUnit.MILLISECONDS);
+
+        lock.await(1000, TimeUnit.MILLISECONDS);
+
+    }
+
+    @Test(timeout = 1000)
+    public void whenSchedulingTaskWithFixedPeriod_thenTaskExecutesMultipleTimes() throws InterruptedException {
+
+        CountDownLatch lock = new CountDownLatch(3);
+
+        ScheduledExecutorService executor = Executors.newScheduledThreadPool(5);
+        ScheduledFuture<?> future = executor.scheduleAtFixedRate(() -> {
+            System.out.println("Hello World");
+            lock.countDown();
+        }, 500, 100, TimeUnit.MILLISECONDS);
+
+        lock.await();
+        future.cancel(true);
+
+    }
+
+    @Test
+    public void whenUsingForkJoinPool_thenSumOfTreeElementsIsCalculatedCorrectly() {
+
+        TreeNode tree = new TreeNode(5,
+                new TreeNode(3), new TreeNode(2,
+                new TreeNode(2), new TreeNode(8)));
+
+        ForkJoinPool forkJoinPool = ForkJoinPool.commonPool();
+        int sum = forkJoinPool.invoke(new CountingTask(tree));
+
+        assertEquals(20, sum);
+    }
+
+
+}

core-java-8/src/test/java/com/baeldung/threadpool/GuavaThreadPoolTest.java

@@ -0,0 +1,56 @@
+package com.baeldung.threadpool;
+
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Executor;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.stream.Collectors;
+
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.ListeningExecutorService;
+import com.google.common.util.concurrent.MoreExecutors;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+public class GuavaThreadPoolTest {
+
+    @Test
+    public void whenExecutingTaskWithDirectExecutor_thenTheTaskIsExecutedInTheCurrentThread() {
+
+        Executor executor = MoreExecutors.directExecutor();
+
+        AtomicBoolean executed = new AtomicBoolean();
+
+        executor.execute(() -> {
+            try {
+                Thread.sleep(500);
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            }
+            executed.set(true);
+        });
+
+        assertTrue(executed.get());
+    }
+
+    @Test
+    public void whenJoiningFuturesWithAllAsList_thenCombinedFutureCompletesAfterAllFuturesComplete() throws ExecutionException, InterruptedException {
+
+        ExecutorService executorService = Executors.newCachedThreadPool();
+        ListeningExecutorService listeningExecutorService = MoreExecutors.listeningDecorator(executorService);
+
+        ListenableFuture<String> future1 = listeningExecutorService.submit(() -> "Hello");
+        ListenableFuture<String> future2 = listeningExecutorService.submit(() -> "World");
+
+        String greeting = Futures.allAsList(future1, future2).get()
+                .stream()
+                .collect(Collectors.joining(" "));
+        assertEquals("Hello World", greeting);
+
+    }
+
+}

hystrix/pom.xml

@@ -6,9 +6,15 @@
     <groupId>com.baeldung</groupId>
     <artifactId>hystrix</artifactId>
     <version>1.0</version>
-
     <name>hystrix</name>
 
+    <parent>
+        <groupId>org.springframework.boot</groupId>
+        <artifactId>spring-boot-starter-parent</artifactId>
+        <version>1.4.0.RELEASE</version>
+        <relativePath></relativePath>
+    </parent>
+
     <properties>
 
         <!-- General -->
@@ -32,12 +38,35 @@
 
     <dependencies>
 
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-web</artifactId>
+        </dependency>
+
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-aop</artifactId>
+        </dependency>
+
         <dependency>
             <groupId>com.netflix.hystrix</groupId>
             <artifactId>hystrix-core</artifactId>
             <version>${hystrix-core.version}</version>
         </dependency>
 
+        <dependency>
+            <groupId>com.netflix.hystrix</groupId>
+            <artifactId>hystrix-metrics-event-stream</artifactId>
+            <version>1.3.16</version>
+        </dependency>
+
+        <!-- https://mvnrepository.com/artifact/com.netflix.hystrix/hystrix-dashboard -->
+        <!--<dependency>
+            <groupId>com.netflix.hystrix</groupId>
+            <artifactId>hystrix-dashboard</artifactId>
+            <version>1.4.3</version>
+        </dependency>-->
+
         <dependency>
             <groupId>com.netflix.rxjava</groupId>
             <artifactId>rxjava-core</artifactId>
@@ -62,6 +91,10 @@
 
     <build>
         <plugins>
+            <plugin>
+                <groupId>org.springframework.boot</groupId>
+                <artifactId>spring-boot-maven-plugin</artifactId>
+            </plugin>
             <plugin>
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-compiler-plugin</artifactId>

hystrix/src/main/java/com/baeldung/hystrix/AppConfig.java

@@ -0,0 +1,20 @@
+package com.baeldung.hystrix;
+
+import com.netflix.hystrix.contrib.metrics.eventstream.HystrixMetricsStreamServlet;
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.boot.web.servlet.ServletRegistrationBean;
+import org.springframework.context.annotation.Bean;
+
+@SpringBootApplication
+public class AppConfig {
+
+    public static void main(String[] args) {
+        SpringApplication.run(AppConfig.class, args);
+    }
+
+    @Bean
+    public ServletRegistrationBean adminServletRegistrationBean() {
+        return new ServletRegistrationBean(new HystrixMetricsStreamServlet(), "/hystrix.stream");
+    }
+}

hystrix/src/main/java/com/baeldung/hystrix/HystrixAspect.java

@@ -0,0 +1,81 @@
+package com.baeldung.hystrix;
+
+import com.netflix.hystrix.*;
+import org.aspectj.lang.ProceedingJoinPoint;
+import org.aspectj.lang.annotation.Around;
+import org.aspectj.lang.annotation.Aspect;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Component;
+
+import javax.annotation.PostConstruct;
+
+@Component
+@Aspect
+public class HystrixAspect {
+
+    private HystrixCommand.Setter config;
+    private HystrixCommandProperties.Setter commandProperties;
+    private HystrixThreadPoolProperties.Setter threadPoolProperties;
+
+    @Around("@annotation(com.baeldung.hystrix.HystrixCircuitBreaker)")
+    public Object circuitBreakerAround(final ProceedingJoinPoint aJoinPoint) {
+        return new RemoteServiceCommand(config, aJoinPoint).execute();
+    }
+
+    @PostConstruct
+    private void setup() {
+        this.config = HystrixCommand.Setter.withGroupKey(HystrixCommandGroupKey.Factory.asKey(groupKey));
+        this.config = config.andCommandKey(HystrixCommandKey.Factory.asKey(key));
+
+        this.commandProperties = HystrixCommandProperties.Setter();
+        this.commandProperties.withExecutionTimeoutInMilliseconds(executionTimeout);
+        this.commandProperties.withCircuitBreakerSleepWindowInMilliseconds(sleepWindow);
+
+        this.threadPoolProperties= HystrixThreadPoolProperties.Setter();
+        this.threadPoolProperties.withMaxQueueSize(maxThreadCount).withCoreSize(coreThreadCount).withMaxQueueSize(queueCount);
+
+        this.config.andCommandPropertiesDefaults(commandProperties);
+        this.config.andThreadPoolPropertiesDefaults(threadPoolProperties);
+    }
+
+    private static class RemoteServiceCommand extends HystrixCommand<String> {
+
+        private final ProceedingJoinPoint joinPoint;
+
+        RemoteServiceCommand(final Setter config, final ProceedingJoinPoint joinPoint) {
+            super(config);
+            this.joinPoint = joinPoint;
+        }
+
+        @Override
+        protected String run() throws Exception {
+            try {
+                return (String) joinPoint.proceed();
+            } catch (final Throwable th) {
+                throw new Exception(th);
+            }
+
+        }
+    }
+
+    @Value("${remoteservice.command.execution.timeout}")
+    private int executionTimeout;
+
+    @Value("${remoteservice.command.sleepwindow}")
+    private int sleepWindow;
+
+    @Value("${remoteservice.command.threadpool.maxsize}")
+    private int maxThreadCount;
+
+    @Value("${remoteservice.command.threadpool.coresize}")
+    private int coreThreadCount;
+
+    @Value("${remoteservice.command.task.queue.size}")
+    private int queueCount;
+
+    @Value("${remoteservice.command.group.key}")
+    private String groupKey;
+
+    @Value("${remoteservice.command.key}")
+    private String key;
+}

hystrix/src/main/java/com/baeldung/hystrix/HystrixCircuitBreaker.java

@@ -0,0 +1,11 @@
+package com.baeldung.hystrix;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.METHOD)
+public @interface HystrixCircuitBreaker {
+}

hystrix/src/main/java/com/baeldung/hystrix/HystrixController.java

@@ -0,0 +1,17 @@
+package com.baeldung.hystrix;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+@RestController
+public class HystrixController {
+
+    @Autowired
+    private SpringExistingClient client;
+
+    @RequestMapping("/")
+    public String index() throws InterruptedException{
+        return client.invokeRemoteService();
+    }
+}

hystrix/src/main/java/com/baeldung/hystrix/RemoteServiceSimulator.java

@@ -1,15 +0,0 @@
-package com.baeldung.hystrix;
-
-
-public class RemoteServiceSimulator {
-
-    public String checkSomething(final long timeout) throws InterruptedException {
-
-        System.out.print(String.format("Waiting %sms. ", timeout));
-
-        // to simulate a real world delay in processing.
-        Thread.sleep(timeout);
-
-        return "Done waiting.";
-    }
-}

hystrix/src/main/java/com/baeldung/hystrix/RemoteServiceTestSimulator.java

@@ -1,7 +1,7 @@
 package com.baeldung.hystrix;
 
 
-class RemoteServiceTestSimulator {
+public class RemoteServiceTestSimulator {
 
     private long wait;
 

hystrix/src/main/java/com/baeldung/hystrix/SpringExistingClient.java

@@ -0,0 +1,17 @@
+package com.baeldung.hystrix;
+
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Component;
+
+@Component("springClient")
+public class SpringExistingClient {
+
+    @Value("${remoteservice.timeout}")
+    private int remoteServiceDelay;
+
+    @HystrixCircuitBreaker
+    public String invokeRemoteService() throws InterruptedException{
+        return new RemoteServiceTestSimulator(remoteServiceDelay).execute();
+    }
+
+}

hystrix/src/main/resources/application.properties

@@ -0,0 +1,8 @@
+remoteservice.command.group.key=RemoteServiceGroup
+remoteservice.command.key=RemoteServiceKey
+remoteservice.command.execution.timeout=10000
+remoteservice.command.threadpool.coresize=5
+remoteservice.command.threadpool.maxsize=10
+remoteservice.command.task.queue.size=5
+remoteservice.command.sleepwindow=5000
+remoteservice.timeout=5000

hystrix/src/test/java/com/baeldung/hystrix/HystrixTimeoutTest.java

@@ -9,13 +9,15 @@ import org.junit.Rule;
 import org.junit.Test;
 import org.junit.rules.ExpectedException;
 
+import java.util.concurrent.ExecutionException;
+
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.hamcrest.Matchers.equalTo;
 
 public class HystrixTimeoutTest {
 
-    private static HystrixCommand.Setter config;
-    private static HystrixCommandProperties.Setter commandProperties = HystrixCommandProperties.Setter();
+    private HystrixCommand.Setter config;
+    private HystrixCommandProperties.Setter commandProperties ;
 
 
     @Rule
@@ -23,6 +25,7 @@ public class HystrixTimeoutTest {
 
     @Before
     public void setup() {
+        commandProperties = HystrixCommandProperties.Setter();
         config = HystrixCommand
           .Setter
           .withGroupKey(HystrixCommandGroupKey.Factory.asKey("RemoteServiceGroup1"));
@@ -34,29 +37,86 @@ public class HystrixTimeoutTest {
     }
 
     @Test
-    public void givenTimeoutEqualTo100_andDefaultSettings_thenReturnSuccess() throws InterruptedException {
+    public void givenServiceTimeoutEqualTo100_andDefaultSettings_thenReturnSuccess() throws InterruptedException {
         assertThat(new RemoteServiceTestCommand(config, new RemoteServiceTestSimulator(100)).execute(), equalTo("Success"));
     }
 
     @Test
-    public void givenTimeoutEqualTo10000_andDefaultSettings_thenExpectHystrixRuntimeException() throws InterruptedException {
+    public void givenServiceTimeoutEqualTo10000_andDefaultSettings_thenExpectHRE() throws InterruptedException {
         exception.expect(HystrixRuntimeException.class);
         new RemoteServiceTestCommand(config, new RemoteServiceTestSimulator(10_000)).execute();
     }
 
     @Test
-    public void givenTimeoutEqualTo5000_andExecutionTimeoutEqualTo10000_thenReturnSuccess() throws InterruptedException {
+    public void givenServiceTimeoutEqualTo5000_andExecutionTimeoutEqualTo10000_thenReturnSuccess()
+            throws InterruptedException {
         commandProperties.withExecutionTimeoutInMilliseconds(10_000);
         config.andCommandPropertiesDefaults(commandProperties);
-        assertThat(new RemoteServiceTestCommand(config, new RemoteServiceTestSimulator(5_000)).execute(), equalTo("Success"));
+        assertThat(new RemoteServiceTestCommand(config, new RemoteServiceTestSimulator(500)).execute(),
+                equalTo("Success"));
     }
 
     @Test
-    public void givenTimeoutEqualTo15000_andExecutionTimeoutEqualTo10000_thenExpectHystrixRuntimeException() throws InterruptedException {
+    public void givenServiceTimeoutEqualTo15000_andExecutionTimeoutEqualTo5000_thenExpectHRE()
+            throws InterruptedException {
         exception.expect(HystrixRuntimeException.class);
-        commandProperties.withExecutionTimeoutInMilliseconds(10_000);
+        commandProperties.withExecutionTimeoutInMilliseconds(5_000);
         config.andCommandPropertiesDefaults(commandProperties);
         new RemoteServiceTestCommand(config, new RemoteServiceTestSimulator(15_000)).execute();
     }
 
+    @Test
+    public void givenServiceTimeoutEqual_andExecutionTimeout_andThreadPool_thenReturnSuccess()
+            throws InterruptedException {
+        commandProperties.withExecutionTimeoutInMilliseconds(10_000);
+        config.andCommandPropertiesDefaults(commandProperties);
+        config.andThreadPoolPropertiesDefaults(HystrixThreadPoolProperties.Setter()
+                .withMaxQueueSize(10)
+                .withCoreSize(3)
+                .withQueueSizeRejectionThreshold(10));
+        assertThat(new RemoteServiceTestCommand(config, new RemoteServiceTestSimulator(500)).execute(),
+                equalTo("Success"));
+    }
+
+    @Test
+    public void givenCircuitBreakerSetup_thenReturnSuccess() throws InterruptedException {
+
+        commandProperties.withExecutionTimeoutInMilliseconds(1000);
+
+        commandProperties.withCircuitBreakerSleepWindowInMilliseconds(4000);
+        commandProperties.withExecutionIsolationStrategy(
+                HystrixCommandProperties.ExecutionIsolationStrategy.THREAD);
+        commandProperties.withCircuitBreakerEnabled(true);
+        commandProperties.withCircuitBreakerRequestVolumeThreshold(1);
+
+        config.andCommandPropertiesDefaults(commandProperties);
+
+        config.andThreadPoolPropertiesDefaults(HystrixThreadPoolProperties.Setter()
+                .withMaxQueueSize(1)
+                .withCoreSize(1)
+                .withQueueSizeRejectionThreshold(1));
+
+        assertThat(this.invokeRemoteService(10000), equalTo(null));
+        assertThat(this.invokeRemoteService(10000), equalTo(null));
+        Thread.sleep(5000);
+
+        assertThat(new RemoteServiceTestCommand(config, new RemoteServiceTestSimulator(500)).execute(),
+                equalTo("Success"));
+        assertThat(new RemoteServiceTestCommand(config, new RemoteServiceTestSimulator(500)).execute(),
+                equalTo("Success"));
+        assertThat(new RemoteServiceTestCommand(config, new RemoteServiceTestSimulator(500)).execute(),
+                equalTo("Success"));
+    }
+
+    public String invokeRemoteService(long timeout) throws InterruptedException{
+        String response = null;
+        try{
+            response = new RemoteServiceTestCommand(config,
+                    new RemoteServiceTestSimulator(timeout)).execute();
+        }catch(HystrixRuntimeException ex){
+            System.out.println("ex = " + ex);
+        }
+        return response;
+    }
+
 }

spring-jpa/pom.xml

@@ -29,6 +29,11 @@
             <artifactId>hibernate-entitymanager</artifactId>
             <version>${hibernate.version}</version>
         </dependency>
+        <dependency>
+            <groupId>org.hibernate</groupId>
+            <artifactId>hibernate-ehcache</artifactId>
+            <version>${hibernate.version}</version>
+        </dependency>
         <dependency>
             <groupId>xml-apis</groupId>
             <artifactId>xml-apis</artifactId>
@@ -50,6 +55,11 @@
             <artifactId>spring-data-jpa</artifactId>
             <version>${spring-data-jpa.version}</version>
         </dependency>
+        <dependency>
+            <groupId>com.h2database</groupId>
+            <artifactId>h2</artifactId>
+            <version>${h2.version}</version>
+        </dependency>
 
         <!-- validation -->
 
@@ -186,6 +196,7 @@
         <hibernate.version>4.3.11.Final</hibernate.version>
         <mysql-connector-java.version>5.1.38</mysql-connector-java.version>
         <spring-data-jpa.version>1.8.2.RELEASE</spring-data-jpa.version>
+        <h2.version>1.4.192</h2.version>
 
         <!-- logging -->
         <org.slf4j.version>1.7.13</org.slf4j.version>

spring-jpa/src/main/java/org/baeldung/config/PersistenceJPAConfig.java

@@ -78,6 +78,8 @@ public class PersistenceJPAConfig {
         final Properties hibernateProperties = new Properties();
         hibernateProperties.setProperty("hibernate.hbm2ddl.auto", env.getProperty("hibernate.hbm2ddl.auto"));
         hibernateProperties.setProperty("hibernate.dialect", env.getProperty("hibernate.dialect"));
+        hibernateProperties.setProperty("hibernate.cache.use_second_level_cache", env.getProperty("hibernate.cache.use_second_level_cache"));
+        hibernateProperties.setProperty("hibernate.cache.use_query_cache", env.getProperty("hibernate.cache.use_query_cache"));
         // hibernateProperties.setProperty("hibernate.globally_quoted_identifiers", "true");
         return hibernateProperties;
     }

spring-jpa/src/main/java/org/baeldung/config/PersistenceJPAConfigL2Cache.java

@@ -0,0 +1,84 @@
+package org.baeldung.config;
+
+import com.google.common.base.Preconditions;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.ComponentScan;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.PropertySource;
+import org.springframework.core.env.Environment;
+import org.springframework.dao.annotation.PersistenceExceptionTranslationPostProcessor;
+import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
+import org.springframework.jdbc.datasource.DriverManagerDataSource;
+import org.springframework.orm.jpa.JpaTransactionManager;
+import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;
+import org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter;
+import org.springframework.transaction.PlatformTransactionManager;
+import org.springframework.transaction.annotation.EnableTransactionManagement;
+
+import javax.persistence.EntityManagerFactory;
+import javax.sql.DataSource;
+import java.util.Properties;
+
+@Configuration
+@EnableTransactionManagement
+@PropertySource({ "classpath:persistence-h2.properties" })
+@ComponentScan({ "org.baeldung.persistence" })
+@EnableJpaRepositories(basePackages = "org.baeldung.persistence.dao")
+public class PersistenceJPAConfigL2Cache {
+
+    @Autowired
+    private Environment env;
+
+    public PersistenceJPAConfigL2Cache() {
+        super();
+    }
+
+    // beans
+
+    @Bean
+    public LocalContainerEntityManagerFactoryBean entityManagerFactory() {
+        final LocalContainerEntityManagerFactoryBean em = new LocalContainerEntityManagerFactoryBean();
+        em.setDataSource(dataSource());
+        em.setPackagesToScan(new String[] { "org.baeldung.persistence.model" });
+
+        final HibernateJpaVendorAdapter vendorAdapter = new HibernateJpaVendorAdapter();
+        em.setJpaVendorAdapter(vendorAdapter);
+        em.setJpaProperties(additionalProperties());
+
+        return em;
+    }
+
+    @Bean
+    public DataSource dataSource() {
+        final DriverManagerDataSource dataSource = new DriverManagerDataSource();
+        dataSource.setDriverClassName(Preconditions.checkNotNull(env.getProperty("jdbc.driverClassName")));
+        dataSource.setUrl(Preconditions.checkNotNull(env.getProperty("jdbc.url")));
+        dataSource.setUsername(Preconditions.checkNotNull(env.getProperty("jdbc.user")));
+
+        return dataSource;
+    }
+
+    @Bean
+    public PlatformTransactionManager transactionManager(final EntityManagerFactory emf) {
+        final JpaTransactionManager transactionManager = new JpaTransactionManager();
+        transactionManager.setEntityManagerFactory(emf);
+        return transactionManager;
+    }
+
+    @Bean
+    public PersistenceExceptionTranslationPostProcessor exceptionTranslation() {
+        return new PersistenceExceptionTranslationPostProcessor();
+    }
+
+    final Properties additionalProperties() {
+        final Properties hibernateProperties = new Properties();
+        hibernateProperties.setProperty("hibernate.hbm2ddl.auto", env.getProperty("hibernate.hbm2ddl.auto"));
+        hibernateProperties.setProperty("hibernate.dialect", env.getProperty("hibernate.dialect"));
+        hibernateProperties.setProperty("hibernate.cache.use_second_level_cache", env.getProperty("hibernate.cache.use_second_level_cache"));
+        hibernateProperties.setProperty("hibernate.cache.use_query_cache", env.getProperty("hibernate.cache.use_query_cache"));
+        hibernateProperties.setProperty("hibernate.cache.region.factory_class", env.getProperty("hibernate.cache.region.factory_class"));
+        return hibernateProperties;
+    }
+
+}

spring-jpa/src/main/java/org/baeldung/persistence/model/Foo.java

@@ -1,17 +1,13 @@
 package org.baeldung.persistence.model;
 
+import org.hibernate.annotations.CacheConcurrencyStrategy;
+
+import javax.persistence.*;
 import java.io.Serializable;
 
-import javax.persistence.Column;
-import javax.persistence.Entity;
-import javax.persistence.FetchType;
-import javax.persistence.GeneratedValue;
-import javax.persistence.GenerationType;
-import javax.persistence.Id;
-import javax.persistence.JoinColumn;
-import javax.persistence.ManyToOne;
-
 @Entity
+@Cacheable
+@org.hibernate.annotations.Cache(usage = CacheConcurrencyStrategy.READ_WRITE)
 public class Foo implements Serializable {
 
     private static final long serialVersionUID = 1L;

spring-jpa/src/main/resources/jpaConfig.xml

@@ -21,6 +21,8 @@
             <props>
                 <prop key="hibernate.hbm2ddl.auto">${hibernate.hbm2ddl.auto}</prop>
                 <prop key="hibernate.dialect">${hibernate.dialect}</prop>
+                <prop key="hibernate.cache.use_second_level_cache">${hibernate.cache.use_second_level_cache}</prop>
+                <prop key="hibernate.cache.use_query_cache">${hibernate.cache.use_query_cache}</prop>
             </props>
         </property>
     </bean>

spring-jpa/src/main/resources/persistence-h2.properties

@@ -0,0 +1,13 @@
+# jdbc.X
+jdbc.driverClassName=org.h2.Driver
+jdbc.url=jdbc:h2:mem:db;DB_CLOSE_DELAY=-1
+jdbc.user=sa
+# jdbc.pass=
+
+# hibernate.X
+hibernate.dialect=org.hibernate.dialect.H2Dialect
+hibernate.show_sql=false
+hibernate.hbm2ddl.auto=create-drop
+hibernate.cache.use_second_level_cache=true
+hibernate.cache.use_query_cache=true
+hibernate.cache.region.factory_class=org.hibernate.cache.ehcache.EhCacheRegionFactory

spring-jpa/src/main/resources/persistence-multiple-db.properties

@@ -9,3 +9,5 @@ jdbc.pass=tutorialmy5ql
 hibernate.dialect=org.hibernate.dialect.MySQL5Dialect
 hibernate.show_sql=false
 hibernate.hbm2ddl.auto=create-drop
+hibernate.cache.use_second_level_cache=false
+hibernate.cache.use_query_cache=false

spring-jpa/src/main/resources/persistence-mysql.properties

@@ -8,3 +8,5 @@ jdbc.pass=tutorialmy5ql
 hibernate.dialect=org.hibernate.dialect.MySQL5Dialect
 hibernate.show_sql=false
 hibernate.hbm2ddl.auto=create-drop
+hibernate.cache.use_second_level_cache=false
+hibernate.cache.use_query_cache=false

spring-jpa/src/test/java/META-INF/persistence.xml

@@ -1,16 +1,17 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <persistence version="2.1" xmlns="http://xmlns.jcp.org/xml/ns/persistence" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/persistence http://xmlns.jcp.org/xml/ns/persistence/persistence_2_1.xsd">
-	<persistence-unit name="punit" >
-		<class>org.baeldung.persistence.model.Foo</class>
-		<class>org.baeldung.persistence.model.Bar</class>
-		<properties>  
-        <property name="javax.persistence.jdbc.user" value="root"/>
-        <property name="javax.persistence.jdbc.driver" value="com.mysql.jdbc.Driver"/>
-        <property name="javax.persistence.jdbc.url" value="jdbc:mysql://localhost:3306/HIBERTEST"/>
-        <property name="javax.persistence.ddl-generation" value="drop-and-create-tables"/>
-        <property name="javax.persistence.logging.level" value="INFO"/>
-        <property name = "hibernate.show_sql" value = "true" />
-      </properties>
-		
-	</persistence-unit>
+    <persistence-unit name="punit" >
+        <class>org.baeldung.persistence.model.Foo</class>
+        <class>org.baeldung.persistence.model.Bar</class>
+        <properties>  
+            <property name="javax.persistence.jdbc.user" value="root"/>
+            <property name="javax.persistence.jdbc.driver" value="com.mysql.jdbc.Driver"/>
+            <property name="javax.persistence.jdbc.url" value="jdbc:mysql://localhost:3306/HIBERTEST"/>
+            <property name="javax.persistence.ddl-generation" value="drop-and-create-tables"/>
+            <property name="javax.persistence.logging.level" value="INFO"/>
+            <property name = "hibernate.show_sql" value = "true" />
+            <property name = "hibernate.cache.use_second_level_cache" value = "false" />
+            <property name = "hibernate.cache.use_query_cache" value = "false" />
+        </properties>
+    </persistence-unit>
 </persistence>

spring-jpa/src/test/java/org/baeldung/persistence/service/SecondLevelCacheIntegrationTest.java

@@ -0,0 +1,84 @@
+package org.baeldung.persistence.service;
+
+import net.sf.ehcache.CacheManager;
+import org.baeldung.config.PersistenceJPAConfigL2Cache;
+import org.baeldung.persistence.model.Bar;
+import org.baeldung.persistence.model.Foo;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+import org.springframework.test.context.support.AnnotationConfigContextLoader;
+import org.springframework.transaction.PlatformTransactionManager;
+import org.springframework.transaction.support.TransactionTemplate;
+
+import javax.persistence.EntityManager;
+import javax.persistence.PersistenceContext;
+import javax.persistence.Query;
+
+import static org.apache.commons.lang3.RandomStringUtils.randomAlphabetic;
+import static org.hamcrest.Matchers.greaterThan;
+import static org.junit.Assert.assertThat;
+
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration(classes = { PersistenceJPAConfigL2Cache.class }, loader = AnnotationConfigContextLoader.class)
+public class SecondLevelCacheIntegrationTest {
+
+    @PersistenceContext
+    private EntityManager entityManager;
+    @Autowired
+    private FooService fooService;
+    @Autowired
+    private PlatformTransactionManager platformTransactionManager;
+
+    @Before
+    public final void before() {
+        entityManager.getEntityManagerFactory().getCache().evictAll();
+    }
+
+    @Test
+    public final void givenEntityIsLoaded_thenItIsCached() {
+        final Foo foo = new Foo(randomAlphabetic(6));
+        fooService.create(foo);
+        fooService.findOne(foo.getId());
+        final int size = CacheManager.ALL_CACHE_MANAGERS.get(0)
+                .getCache("org.baeldung.persistence.model.Foo").getSize();
+        assertThat(size, greaterThan(0));
+    }
+
+    @Test
+    public final void givenBarIsUpdatedInNativeQuery_thenFoosAreNotEvicted() {
+        final Foo foo = new Foo(randomAlphabetic(6));
+        fooService.create(foo);
+        fooService.findOne(foo.getId());
+
+        new TransactionTemplate(platformTransactionManager).execute(status -> {
+            final Bar bar = new Bar(randomAlphabetic(6));
+            entityManager.persist(bar);
+            final Query nativeQuery = entityManager.createNativeQuery("update BAR set NAME = :updatedName where ID = :id");
+            nativeQuery.setParameter("updatedName", "newName");
+            nativeQuery.setParameter("id", bar.getId());
+            nativeQuery.unwrap(org.hibernate.SQLQuery.class).addSynchronizedEntityClass(Bar.class);
+            return nativeQuery.executeUpdate();
+        });
+
+        final int size = CacheManager.ALL_CACHE_MANAGERS.get(0)
+                .getCache("org.baeldung.persistence.model.Foo").getSize();
+        assertThat(size, greaterThan(0));
+    }
+
+    @Test
+    public final void givenCacheableQueryIsExecuted_thenItIsCached() {
+        new TransactionTemplate(platformTransactionManager).execute(status -> {
+            return entityManager.createQuery("select f from Foo f")
+                    .setHint("org.hibernate.cacheable", true)
+                    .getResultList();
+        });
+
+        final int size = CacheManager.ALL_CACHE_MANAGERS.get(0)
+                .getCache("org.hibernate.cache.internal.StandardQueryCache").getSize();
+        assertThat(size, greaterThan(0));
+    }
+}

spring-rest/src/main/java/org/baeldung/config/WebConfig.java

@@ -0,0 +1,53 @@
+package org.baeldung.config;
+
+import java.text.SimpleDateFormat;
+import java.util.List;
+
+import org.baeldung.config.converter.KryoHttpMessageConverter;
+import org.springframework.context.annotation.ComponentScan;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.http.converter.HttpMessageConverter;
+import org.springframework.http.converter.json.Jackson2ObjectMapperBuilder;
+import org.springframework.http.converter.json.MappingJackson2HttpMessageConverter;
+import org.springframework.http.converter.protobuf.ProtobufHttpMessageConverter;
+import org.springframework.http.converter.xml.MarshallingHttpMessageConverter;
+import org.springframework.oxm.xstream.XStreamMarshaller;
+import org.springframework.web.servlet.config.annotation.EnableWebMvc;
+import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;
+
+@Configuration
+@EnableWebMvc
+@ComponentScan({ "org.baeldung.web" })
+public class WebConfig extends WebMvcConfigurerAdapter {
+
+    public WebConfig() {
+        super();
+    }
+
+    //
+
+    @Override
+    public void configureMessageConverters(final List<HttpMessageConverter<?>> messageConverters) {
+        messageConverters.add(createXmlHttpMessageConverter());
+        // messageConverters.add(new MappingJackson2HttpMessageConverter());
+
+        final Jackson2ObjectMapperBuilder builder = new Jackson2ObjectMapperBuilder();
+        builder.indentOutput(true).dateFormat(new SimpleDateFormat("dd-MM-yyyy hh:mm"));
+        messageConverters.add(new MappingJackson2HttpMessageConverter(builder.build()));
+        // messageConverters.add(new MappingJackson2XmlHttpMessageConverter(builder.createXmlMapper(true).build()));
+        messageConverters.add(new ProtobufHttpMessageConverter());
+        messageConverters.add(new KryoHttpMessageConverter());
+        super.configureMessageConverters(messageConverters);
+    }
+
+    private HttpMessageConverter<Object> createXmlHttpMessageConverter() {
+        final MarshallingHttpMessageConverter xmlConverter = new MarshallingHttpMessageConverter();
+
+        final XStreamMarshaller xstreamMarshaller = new XStreamMarshaller();
+        xmlConverter.setMarshaller(xstreamMarshaller);
+        xmlConverter.setUnmarshaller(xstreamMarshaller);
+
+        return xmlConverter;
+    }
+
+}

spring-rest/src/main/java/org/baeldung/config/converter/KryoHttpMessageConverter.java

@@ -0,0 +1,57 @@
+package org.baeldung.config.converter;
+
+import java.io.IOException;
+
+import org.baeldung.web.dto.Foo;
+import org.springframework.http.HttpInputMessage;
+import org.springframework.http.HttpOutputMessage;
+import org.springframework.http.MediaType;
+import org.springframework.http.converter.AbstractHttpMessageConverter;
+
+import com.esotericsoftware.kryo.Kryo;
+import com.esotericsoftware.kryo.io.Input;
+import com.esotericsoftware.kryo.io.Output;
+
+/**
+ * An {@code HttpMessageConverter} that can read and write Kryo messages.
+ */
+public class KryoHttpMessageConverter extends AbstractHttpMessageConverter<Object> {
+
+    public static final MediaType KRYO = new MediaType("application", "x-kryo");
+
+    private static final ThreadLocal<Kryo> kryoThreadLocal = new ThreadLocal<Kryo>() {
+        @Override
+        protected Kryo initialValue() {
+            final Kryo kryo = new Kryo();
+            kryo.register(Foo.class, 1);
+            return kryo;
+        }
+    };
+
+    public KryoHttpMessageConverter() {
+        super(KRYO);
+    }
+
+    @Override
+    protected boolean supports(final Class<?> clazz) {
+        return Object.class.isAssignableFrom(clazz);
+    }
+
+    @Override
+    protected Object readInternal(final Class<? extends Object> clazz, final HttpInputMessage inputMessage) throws IOException {
+        final Input input = new Input(inputMessage.getBody());
+        return kryoThreadLocal.get().readClassAndObject(input);
+    }
+
+    @Override
+    protected void writeInternal(final Object object, final HttpOutputMessage outputMessage) throws IOException {
+        final Output output = new Output(outputMessage.getBody());
+        kryoThreadLocal.get().writeClassAndObject(output, object);
+        output.flush();
+    }
+
+    @Override
+    protected MediaType getDefaultContentType(final Object object) {
+        return KRYO;
+    }
+}

spring-rest/src/main/java/org/baeldung/web/controller/BarMappingExamplesController.java

@@ -0,0 +1,47 @@
+package org.baeldung.web.controller;
+
+import org.springframework.stereotype.Controller;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.ResponseBody;
+
+@Controller
+@RequestMapping(value = "/ex")
+public class BarMappingExamplesController {
+
+    public BarMappingExamplesController() {
+        super();
+    }
+
+    // API
+
+    // with @RequestParam
+
+    @RequestMapping(value = "/bars")
+    @ResponseBody
+    public String getBarBySimplePathWithRequestParam(@RequestParam("id") final long id) {
+        return "Get a specific Bar with id=" + id;
+    }
+
+    @RequestMapping(value = "/bars", params = "id")
+    @ResponseBody
+    public String getBarBySimplePathWithExplicitRequestParam(@RequestParam("id") final long id) {
+        return "Get a specific Bar with id=" + id;
+    }
+
+    @RequestMapping(value = "/bars", params = { "id", "second" })
+    @ResponseBody
+    public String getBarBySimplePathWithExplicitRequestParams(@RequestParam("id") final long id) {
+        return "Get a specific Bar with id=" + id;
+    }
+
+    // with @PathVariable
+
+    @RequestMapping(value = "/bars/{numericId:[\\d]+}")
+    @ResponseBody
+    public String getBarsBySimplePathWithPathVariable(@PathVariable final long numericId) {
+        return "Get a specific Bar with id=" + numericId;
+    }
+
+}