Merge remote-tracking branch 'upstream/master'

.gitignore

@@ -7,8 +7,11 @@
 
 # Eclipse
 .settings/
+*.project
+*.classpath
 .prefs
 *.prefs
+.metadata/
 
 # Intellij
 .idea/
@@ -23,3 +26,4 @@ log/
 target/
 
 spring-openid/src/main/resources/application.properties
+.recommenders/

README.md

@@ -1,7 +1,7 @@
 
 The "REST with Spring" Classes
 ==============================
-After 5 months of work, here's the Master Class: <br/>
+After 5 months of work, here's the Master Class of REST With Spring: <br/>
 **[>> THE REST WITH SPRING MASTER CLASS](http://www.baeldung.com/rest-with-spring-course?utm_source=github&utm_medium=social&utm_content=tutorials&utm_campaign=rws#master-class)**
 
 
@@ -19,3 +19,8 @@ Any IDE can be used to work with the projects, but if you're using Eclipse, cons
 
 - import the included **formatter** in Eclipse: 
 `https://github.com/eugenp/tutorials/tree/master/eclipse`
+
+
+CI - Jenkins
+================================
+This tutorials project is being built **[>> HERE](https://rest-security.ci.cloudbees.com/job/tutorials/)**

assertj/pom.xml

@@ -0,0 +1,38 @@
+<?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>assertj</artifactId>
+    <version>1.0.0-SNAPSHOT</version>
+
+    <dependencies>
+        <dependency>
+            <groupId>junit</groupId>
+            <artifactId>junit</artifactId>
+            <version>4.12</version>
+        </dependency>
+        <dependency>
+            <groupId>org.assertj</groupId>
+            <artifactId>assertj-core</artifactId>
+            <version>3.4.1</version>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <version>3.3</version>
+                <configuration>
+                    <source>1.8</source>
+                    <target>1.8</target>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+</project>

assertj/src/main/java/com/baeldung/assertj/introduction/domain/Dog.java

@@ -0,0 +1,19 @@
+package com.baeldung.assertj.introduction.domain;
+
+public class Dog {
+    private String name;
+    private Float weight;
+
+    public Dog(String name, Float weight) {
+        this.name = name;
+        this.weight = weight;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public Float getWeight() {
+        return weight;
+    }
+}

assertj/src/main/java/com/baeldung/assertj/introduction/domain/Person.java

@@ -0,0 +1,19 @@
+package com.baeldung.assertj.introduction.domain;
+
+public class Person {
+    private String name;
+    private Integer age;
+
+    public Person(String name, Integer age) {
+        this.name = name;
+        this.age = age;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public Integer getAge() {
+        return age;
+    }
+}

assertj/src/test/java/com/baeldung/assertj/introduction/AssertJCoreTest.java

@@ -0,0 +1,143 @@
+package com.baeldung.assertj.introduction;
+
+import com.baeldung.assertj.introduction.domain.Dog;
+import com.baeldung.assertj.introduction.domain.Person;
+import org.assertj.core.util.Maps;
+import org.junit.Ignore;
+import org.junit.Test;
+
+import java.io.ByteArrayInputStream;
+import java.io.File;
+import java.io.InputStream;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Map;
+import java.util.NoSuchElementException;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.entry;
+import static org.assertj.core.api.Assertions.withPrecision;
+
+public class AssertJCoreTest {
+
+    @Test
+    public void whenComparingReferences_thenNotEqual() throws Exception {
+        Dog fido = new Dog("Fido", 5.15f);
+        Dog fidosClone = new Dog("Fido", 5.15f);
+
+        assertThat(fido).isNotEqualTo(fidosClone);
+    }
+
+    @Test
+    public void whenComparingFields_thenEqual() throws Exception {
+        Dog fido = new Dog("Fido", 5.15f);
+        Dog fidosClone = new Dog("Fido", 5.15f);
+
+        assertThat(fido).isEqualToComparingFieldByFieldRecursively(fidosClone);
+    }
+
+    @Test
+    public void whenCheckingForElement_thenContains() throws Exception {
+        List<String> list = Arrays.asList("1", "2", "3");
+
+        assertThat(list)
+                .contains("1");
+    }
+
+    @Test
+    public void whenCheckingForElement_thenMultipleAssertions() throws Exception {
+        List<String> list = Arrays.asList("1", "2", "3");
+
+        assertThat(list).isNotEmpty();
+        assertThat(list).startsWith("1");
+        assertThat(list).doesNotContainNull();
+
+        assertThat(list)
+                .isNotEmpty()
+                .contains("1")
+                .startsWith("1")
+                .doesNotContainNull()
+                .containsSequence("2", "3");
+    }
+
+    @Test
+    public void whenCheckingRunnable_thenIsInterface() throws Exception {
+        assertThat(Runnable.class).isInterface();
+    }
+
+    @Test
+    public void whenCheckingCharacter_thenIsUnicode() throws Exception {
+        char someCharacter = 'c';
+
+        assertThat(someCharacter)
+                .isNotEqualTo('a')
+                .inUnicode()
+                .isGreaterThanOrEqualTo('b')
+                .isLowerCase();
+    }
+
+    @Test
+    public void whenAssigningNSEExToException_thenIsAssignable() throws Exception {
+        assertThat(Exception.class).isAssignableFrom(NoSuchElementException.class);
+    }
+
+    @Test
+    public void whenComparingWithOffset_thenEquals() throws Exception {
+        assertThat(5.1).isEqualTo(5, withPrecision(1d));
+    }
+
+    @Test
+    public void whenCheckingString_then() throws Exception {
+        assertThat("".isEmpty()).isTrue();
+    }
+
+    @Test
+    public void whenCheckingFile_then() throws Exception {
+        final File someFile = File.createTempFile("aaa", "bbb");
+        someFile.deleteOnExit();
+
+        assertThat(someFile)
+                .exists()
+                .isFile()
+                .canRead()
+                .canWrite();
+    }
+
+    @Test
+    public void whenCheckingIS_then() throws Exception {
+        InputStream given = new ByteArrayInputStream("foo".getBytes());
+        InputStream expected = new ByteArrayInputStream("foo".getBytes());
+
+        assertThat(given).hasSameContentAs(expected);
+    }
+
+    @Test
+    public void whenGivenMap_then() throws Exception {
+        Map<Integer, String> map = Maps.newHashMap(2, "a");
+
+        assertThat(map)
+                .isNotEmpty()
+                .containsKey(2)
+                .doesNotContainKeys(10)
+                .contains(entry(2, "a"));
+    }
+
+    @Test
+    public void whenGivenException_then() throws Exception {
+        Exception ex = new Exception("abc");
+
+        assertThat(ex)
+                .hasNoCause()
+                .hasMessageEndingWith("c");
+    }
+
+    @Ignore // IN ORDER TO TEST, REMOVE THIS LINE
+    @Test
+    public void whenRunningAssertion_thenDescribed() throws Exception {
+        Person person = new Person("Alex", 34);
+
+        assertThat(person.getAge())
+                .as("%s's age should be equal to 100")
+                .isEqualTo(100);
+    }
+}

core-java-8/pom.xml

@@ -41,6 +41,12 @@
             <version>3.3.2</version>
         </dependency>
 
+        <dependency>
+            <groupId>org.slf4j</groupId>
+            <artifactId>slf4j-api</artifactId>
+            <version>${org.slf4j.version}</version>
+        </dependency>
+
         <!-- test scoped -->
 
         <dependency>
@@ -57,6 +63,12 @@
             <scope>test</scope>
         </dependency>
 
+        <dependency>
+            <groupId>org.assertj</groupId>
+            <artifactId>assertj-core</artifactId>
+            <version>3.4.1</version>
+        </dependency>
+
         <dependency>
             <groupId>org.mockito</groupId>
             <artifactId>mockito-core</artifactId>

core-java-8/src/main/java/com/baeldung/datetime/UseDuration.java

@@ -0,0 +1,16 @@
+package com.baeldung.datetime;
+
+import java.time.Duration;
+import java.time.LocalTime;
+import java.time.Period;
+
+public class UseDuration {
+    
+    public LocalTime modifyDates(LocalTime localTime,Duration duration){
+        return localTime.plus(duration);
+    }
+    
+    public Duration getDifferenceBetweenDates(LocalTime localTime1,LocalTime localTime2){
+        return Duration.between(localTime1, localTime2);
+    }
+}

core-java-8/src/main/java/com/baeldung/datetime/UseLocalDate.java

@@ -0,0 +1,46 @@
+package com.baeldung.datetime;
+
+import java.time.DayOfWeek;
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.time.temporal.ChronoUnit;
+import java.time.temporal.TemporalAdjusters;
+
+public class UseLocalDate {
+    
+    public LocalDate getLocalDateUsingFactoryOfMethod(int year, int month, int dayOfMonth){        
+        return LocalDate.of(year, month, dayOfMonth);
+    }
+    
+    public LocalDate getLocalDateUsingParseMethod(String representation){        
+        return LocalDate.parse(representation);
+    }
+    
+    public LocalDate getLocalDateFromClock(){        
+        LocalDate localDate = LocalDate.now();
+        return localDate;
+    }
+    
+    public LocalDate getNextDay(LocalDate localDate){       
+        return localDate.plusDays(1);
+    }
+    
+    public LocalDate getPreviousDay(LocalDate localDate){        
+        return localDate.minus(1, ChronoUnit.DAYS);
+    }
+    
+    public DayOfWeek getDayOfWeek(LocalDate localDate){        
+        DayOfWeek day = localDate.getDayOfWeek();
+        return day;
+    }
+    
+    public LocalDate getFirstDayOfMonth(){        
+        LocalDate firstDayOfMonth = LocalDate.now().with(TemporalAdjusters.firstDayOfMonth());
+        return firstDayOfMonth;
+    }
+    
+    public LocalDateTime getStartOfDay(LocalDate localDate){        
+        LocalDateTime startofDay = localDate.atStartOfDay();
+        return startofDay;
+    }
+}

core-java-8/src/main/java/com/baeldung/datetime/UseLocalDateTime.java

@@ -0,0 +1,11 @@
+package com.baeldung.datetime;
+
+import java.time.LocalDateTime;
+
+public class UseLocalDateTime {
+    
+    public LocalDateTime getLocalDateTimeUsingParseMethod(String representation){        
+        return LocalDateTime.parse(representation);
+    }
+
+}

core-java-8/src/main/java/com/baeldung/datetime/UseLocalTime.java

@@ -0,0 +1,35 @@
+package com.baeldung.datetime;
+
+import java.time.LocalTime;
+import java.time.temporal.ChronoUnit;
+
+public class UseLocalTime {
+    
+    public LocalTime getLocalTimeUsingFactoryOfMethod(int hour, int min, int seconds){        
+        LocalTime localTime = LocalTime.of(hour, min, seconds);
+        return localTime;
+    }
+    
+    public LocalTime getLocalTimeUsingParseMethod(String timeRepresentation){        
+        LocalTime localTime = LocalTime.parse(timeRepresentation);
+        return localTime;
+    }
+    
+    public LocalTime getLocalTimeFromClock(){        
+        LocalTime localTime = LocalTime.now();
+        return localTime;
+    }
+    
+    public LocalTime addAnHour(LocalTime localTime){
+        LocalTime newTime = localTime.plus(1,ChronoUnit.HOURS);
+        return newTime;
+    }
+    
+    public int getHourFromLocalTime(LocalTime localTime){        
+        return localTime.getHour();
+    }
+    
+    public LocalTime getLocalTimeWithMinuteSetToValue(LocalTime localTime, int minute){        
+        return localTime.withMinute(minute);
+    }
+}

core-java-8/src/main/java/com/baeldung/datetime/UsePeriod.java

@@ -0,0 +1,15 @@
+package com.baeldung.datetime;
+
+import java.time.LocalDate;
+import java.time.Period;
+
+public class UsePeriod {
+    
+    public LocalDate modifyDates(LocalDate localDate,Period period){
+        return localDate.plus(period);
+    }
+    
+    public Period getDifferenceBetweenDates(LocalDate localDate1,LocalDate localDate2){
+        return Period.between(localDate1, localDate2);
+    }
+}

core-java-8/src/main/java/com/baeldung/datetime/UseToInstant.java

@@ -0,0 +1,19 @@
+package com.baeldung.datetime;
+
+import java.time.LocalDateTime;
+import java.time.ZoneId;
+import java.util.Calendar;
+import java.util.Date;
+
+public class UseToInstant {
+    
+    public LocalDateTime convertDateToLocalDate(Date date){
+        LocalDateTime localDateTime = LocalDateTime.ofInstant(date.toInstant(), ZoneId.systemDefault());
+        return localDateTime;
+    }
+    
+    public LocalDateTime convertDateToLocalDate(Calendar calendar){
+        LocalDateTime localDateTime = LocalDateTime.ofInstant(calendar.toInstant(), ZoneId.systemDefault());
+        return localDateTime;
+    }
+}

core-java-8/src/main/java/com/baeldung/datetime/UseZonedDateTime.java

@@ -0,0 +1,13 @@
+package com.baeldung.datetime;
+
+import java.time.LocalDateTime;
+import java.time.ZoneId;
+import java.time.ZonedDateTime;
+
+public class UseZonedDateTime {
+    
+    public ZonedDateTime getZonedDateTime(LocalDateTime localDateTime,ZoneId zoneId){        
+        ZonedDateTime zonedDateTime = ZonedDateTime.of(localDateTime, zoneId);
+        return zonedDateTime;
+    }
+}

core-java-8/src/main/java/com/baeldung/streamApi/Product.java

@@ -0,0 +1,51 @@
+package com.baeldung.streamApi;
+
+import java.util.List;
+import java.util.Optional;
+import java.util.stream.IntStream;
+import java.util.stream.Stream;
+
+/**
+ * Created by Alex Vengr
+ */
+public class Product {
+
+    private int price;
+
+    private String name;
+
+    private boolean utilize;
+
+    public Product(int price, String name) {
+        this(price);
+        this.name = name;
+    }
+
+    public Product(int price) {
+        this.price = price;
+    }
+
+    public Product() {
+    }
+
+    public int getPrice() {
+        return price;
+    }
+
+    public void setPrice(int price) {
+        this.price = price;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+
+    public static Stream<String> streamOf(List<String> list) {
+        return (list == null || list.isEmpty()) ? Stream.empty() : list.stream();
+    }
+}

core-java-8/src/test/java/com/baeldung/dateapi/ConversionExample.java

@@ -0,0 +1,19 @@
+package com.baeldung.dateapi;
+
+import java.time.Instant;
+import java.time.ZoneId;
+import java.time.ZonedDateTime;
+import java.util.Date;
+import java.util.GregorianCalendar;
+import java.util.TimeZone;
+
+public class ConversionExample {
+    public static void main(String[] args) {
+        Instant instantFromCalendar = GregorianCalendar.getInstance().toInstant();
+        ZonedDateTime zonedDateTimeFromCalendar = new GregorianCalendar().toZonedDateTime();
+        Date dateFromInstant = Date.from(Instant.now());
+        GregorianCalendar calendarFromZonedDateTime = GregorianCalendar.from(ZonedDateTime.now());
+        Instant instantFromDate = new Date().toInstant();
+        ZoneId zoneIdFromTimeZone = TimeZone.getTimeZone("PST").toZoneId();
+    }
+}

core-java-8/src/test/java/com/baeldung/dateapi/JavaUtilTimeTest.java

@@ -0,0 +1,89 @@
+package com.baeldung.dateapi;
+
+import org.junit.Test;
+
+import java.text.ParseException;
+import java.time.Duration;
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.time.LocalTime;
+import java.time.Month;
+import java.time.YearMonth;
+import java.time.format.DateTimeFormatter;
+import java.time.temporal.ChronoUnit;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class JavaUtilTimeTest {
+
+    @Test
+    public void currentTime() {
+        final LocalDate now = LocalDate.now();
+
+        System.out.println(now);
+        // there is not much to test here
+    }
+
+    @Test
+    public void specificTime() {
+        LocalDate birthDay = LocalDate.of(1990, Month.DECEMBER, 15);
+
+        System.out.println(birthDay);
+        // there is not much to test here
+    }
+
+    @Test
+    public void extractMonth() {
+        Month month = LocalDate.of(1990, Month.DECEMBER, 15).getMonth();
+
+        assertThat(month).isEqualTo(Month.DECEMBER);
+    }
+
+    @Test
+    public void subtractTime() {
+        LocalDateTime fiveHoursBefore = LocalDateTime.of(1990, Month.DECEMBER, 15, 15, 0).minusHours(5);
+
+        assertThat(fiveHoursBefore.getHour()).isEqualTo(10);
+    }
+
+    @Test
+    public void alterField() {
+        LocalDateTime inJune = LocalDateTime.of(1990, Month.DECEMBER, 15, 15, 0).with(Month.JUNE);
+
+        assertThat(inJune.getMonth()).isEqualTo(Month.JUNE);
+    }
+
+    @Test
+    public void truncate() {
+        LocalTime truncated = LocalTime.of(15, 12, 34).truncatedTo(ChronoUnit.HOURS);
+
+        assertThat(truncated).isEqualTo(LocalTime.of(15, 0, 0));
+    }
+
+    @Test
+    public void getTimeSpan() {
+        LocalDateTime now = LocalDateTime.now();
+        LocalDateTime hourLater = now.plusHours(1);
+        Duration span = Duration.between(now, hourLater);
+
+        assertThat(span).isEqualTo(Duration.ofHours(1));
+    }
+
+    @Test
+    public void formatAndParse() throws ParseException {
+        LocalDate someDate = LocalDate.of(2016, 12, 7);
+        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");
+        String formattedDate = someDate.format(formatter);
+        LocalDate parsedDate = LocalDate.parse(formattedDate, formatter);
+
+        assertThat(formattedDate).isEqualTo("2016-12-07");
+        assertThat(parsedDate).isEqualTo(someDate);
+    }
+
+    @Test
+    public void daysInMonth() {
+        int daysInMonth = YearMonth.of(1990, 2).lengthOfMonth();
+
+        assertThat(daysInMonth).isEqualTo(28);
+    }
+}

core-java-8/src/test/java/com/baeldung/datetime/UseLocalDateTest.java

@@ -0,0 +1,55 @@
+package com.baeldung.datetime;
+
+import java.time.DayOfWeek;
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.time.Month;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class UseLocalDateTest {
+    
+    UseLocalDate useLocalDate = new UseLocalDate();
+    
+    @Test
+    public void givenValues_whenUsingFactoryOf_thenLocalDate(){
+        Assert.assertEquals("2016-05-10",useLocalDate.getLocalDateUsingFactoryOfMethod(2016,5,10).toString());
+    }
+    
+    @Test
+    public void givenString_whenUsingParse_thenLocalDate(){
+        Assert.assertEquals("2016-05-10",useLocalDate.getLocalDateUsingParseMethod("2016-05-10").toString());
+    }
+    
+    @Test
+    public void whenUsingClock_thenLocalDate(){
+        Assert.assertEquals(LocalDate.now(),useLocalDate.getLocalDateFromClock());
+    }
+    
+    @Test
+    public void givenDate_whenUsingPlus_thenNextDay(){
+        Assert.assertEquals(LocalDate.now().plusDays(1),useLocalDate.getNextDay(LocalDate.now()));
+    }
+    
+    @Test
+    public void givenDate_whenUsingMinus_thenPreviousDay(){
+        Assert.assertEquals(LocalDate.now().minusDays(1),useLocalDate.getPreviousDay(LocalDate.now()));
+    }
+    
+    @Test
+    public void givenToday_whenUsingGetDayOfWeek_thenDayOfWeek(){
+        Assert.assertEquals(DayOfWeek.SUNDAY,useLocalDate.getDayOfWeek(LocalDate.parse("2016-05-22")));
+    }
+    
+    @Test
+    public void givenToday_whenUsingWithTemporalAdjuster_thenFirstDayOfMonth(){
+        Assert.assertEquals(1,useLocalDate.getFirstDayOfMonth().getDayOfMonth());
+    }
+    
+    @Test
+    public void givenLocalDate_whenUsingAtStartOfDay_thenReturnMidnight(){
+        Assert.assertEquals(LocalDateTime.parse("2016-05-22T00:00:00"),useLocalDate.getStartOfDay(LocalDate.parse("2016-05-22")));
+    }
+
+}

core-java-8/src/test/java/com/baeldung/datetime/UseLocalDateTimeTest.java

@@ -0,0 +1,19 @@
+package com.baeldung.datetime;
+
+import java.time.LocalDate;
+import java.time.LocalTime;
+import java.time.Month;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class UseLocalDateTimeTest {
+    
+    UseLocalDateTime useLocalDateTime = new UseLocalDateTime();
+    
+    @Test
+    public void givenString_whenUsingParse_thenLocalDateTime(){
+        Assert.assertEquals(LocalDate.of(2016, Month.MAY, 10),useLocalDateTime.getLocalDateTimeUsingParseMethod("2016-05-10T06:30").toLocalDate());
+        Assert.assertEquals(LocalTime.of(6,30),useLocalDateTime.getLocalDateTimeUsingParseMethod("2016-05-10T06:30").toLocalTime());
+    }
+}

core-java-8/src/test/java/com/baeldung/datetime/UseLocalTimeTest.java

@@ -0,0 +1,36 @@
+package com.baeldung.datetime;
+
+import java.time.LocalTime;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class UseLocalTimeTest {
+    
+    UseLocalTime useLocalTime = new UseLocalTime();
+    
+    @Test
+    public void givenValues_whenUsingFactoryOf_thenLocalTime(){
+        Assert.assertEquals("07:07:07",useLocalTime.getLocalTimeUsingFactoryOfMethod(7,7,7).toString());
+    }
+    
+    @Test
+    public void givenString_whenUsingParse_thenLocalTime(){
+        Assert.assertEquals("06:30",useLocalTime.getLocalTimeUsingParseMethod("06:30").toString());
+    }
+    
+    @Test
+    public void givenTime_whenAddHour_thenLocalTime(){
+        Assert.assertEquals("07:30",useLocalTime.addAnHour(LocalTime.of(6,30)).toString());
+    }
+    
+    @Test
+    public void getHourFromLocalTime(){
+        Assert.assertEquals(1, useLocalTime.getHourFromLocalTime(LocalTime.of(1,1)));
+    }
+    
+    @Test
+    public void getLocalTimeWithMinuteSetToValue(){
+        Assert.assertEquals(LocalTime.of(10, 20), useLocalTime.getLocalTimeWithMinuteSetToValue(LocalTime.of(10,10), 20));
+    }
+}

core-java-8/src/test/java/com/baeldung/datetime/UsePeriodTest.java

@@ -0,0 +1,29 @@
+package com.baeldung.datetime;
+
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.time.Period;
+import java.time.ZoneId;
+import java.time.ZonedDateTime;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class UsePeriodTest {
+    UsePeriod usingPeriod=new UsePeriod();
+    
+    @Test
+    public void givenPeriodAndLocalDate_thenCalculateModifiedDate(){
+        Period period = Period.ofDays(1);
+        LocalDate localDate = LocalDate.parse("2007-05-10");
+        Assert.assertEquals(localDate.plusDays(1),usingPeriod.modifyDates(localDate, period));
+    }
+    
+    @Test
+    public void givenDates_thenGetPeriod(){
+        LocalDate localDate1 = LocalDate.parse("2007-05-10");
+        LocalDate localDate2 = LocalDate.parse("2007-05-15");
+        
+        Assert.assertEquals(Period.ofDays(5), usingPeriod.getDifferenceBetweenDates(localDate1, localDate2));
+    }
+}

core-java-8/src/test/java/com/baeldung/datetime/UseZonedDateTimeTest.java

@@ -0,0 +1,20 @@
+package com.baeldung.datetime;
+
+import java.time.LocalDateTime;
+import java.time.ZoneId;
+import java.time.ZonedDateTime;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class UseZonedDateTimeTest {
+    
+    UseZonedDateTime zonedDateTime=new UseZonedDateTime();
+    
+    @Test
+    public void givenZoneId_thenZonedDateTime(){
+        ZoneId zoneId=ZoneId.of("Europe/Paris");
+        ZonedDateTime zonedDatetime=zonedDateTime.getZonedDateTime(LocalDateTime.parse("2016-05-20T06:30"), zoneId);
+        Assert.assertEquals(zoneId,ZoneId.from(zonedDatetime));
+    }
+}

core-java-8/src/test/java/com/baeldung/java8/Java8StreamApiTest.java

@@ -0,0 +1,263 @@
+package com.baeldung.java8;
+
+import com.baeldung.streamApi.Product;
+import org.junit.Before;
+import org.junit.Test;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.BufferedWriter;
+import java.io.IOException;
+import java.nio.charset.Charset;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.*;
+import java.util.regex.Pattern;
+import java.util.stream.*;
+
+import static org.junit.Assert.*;
+
+public class Java8StreamApiTest {
+
+    private long counter;
+
+    private static Logger log = LoggerFactory.getLogger(Java8StreamApiTest.class);
+
+    private List<Product> productList;
+
+    @Before
+    public void init() {
+        productList = Arrays.asList(
+                new Product(23, "potatoes"), new Product(14, "orange"),
+                new Product(13, "lemon"), new Product(23, "bread"),
+                new Product(13, "sugar"));
+    }
+
+    @Test
+    public void checkPipeline_whenStreamOneElementShorter_thenCorrect() {
+
+        List<String> list = Arrays.asList("abc1", "abc2", "abc3");
+        long size = list.stream().skip(1)
+                .map(element -> element.substring(0, 3)).count();
+        assertEquals(list.size() - 1, size);
+    }
+
+    @Test
+    public void checkOrder_whenChangeQuantityOfMethodCalls_thenCorrect() {
+
+        List<String> list = Arrays.asList("abc1", "abc2", "abc3");
+
+        counter = 0;
+        long sizeFirst = list.stream()
+                .skip(2).map(element -> {
+                    wasCalled();
+                    return element.substring(0, 3);
+                }).count();
+        assertEquals(1, counter);
+
+        counter = 0;
+        long sizeSecond = list.stream().map(element -> {
+            wasCalled();
+            return element.substring(0, 3);
+        }).skip(2).count();
+        assertEquals(3, counter);
+    }
+
+    @Test
+    public void createEmptyStream_whenEmpty_thenCorrect() {
+
+        Stream<String> streamEmpty = Stream.empty();
+        assertEquals(0, streamEmpty.count());
+
+        List<String> names = Collections.emptyList();
+        Stream<String> streamOf = Product.streamOf(names);
+        assertTrue(streamOf.count() == 0);
+    }
+
+    @Test
+    public void createStream_whenCreated_thenCorrect() {
+
+        Collection<String> collection = Arrays.asList("a", "b", "c");
+        Stream<String> streamOfCollection = collection.stream();
+        assertEquals(3, streamOfCollection.count());
+
+        Stream<String> streamOfArray = Stream.of("a", "b", "c");
+        assertEquals(3, streamOfArray.count());
+
+        String[] arr = new String[]{"a", "b", "c"};
+        Stream<String> streamOfArrayPart = Arrays.stream(arr, 1, 3);
+        assertEquals(2, streamOfArrayPart.count());
+
+        IntStream intStream = IntStream.range(1, 3);
+        LongStream longStream = LongStream.rangeClosed(1, 3);
+        Random random = new Random();
+        DoubleStream doubleStream = random.doubles(3);
+        assertEquals(2, intStream.count());
+        assertEquals(3, longStream.count());
+        assertEquals(3, doubleStream.count());
+
+        IntStream streamOfChars = "abc".chars();
+        IntStream str = "".chars();
+        assertEquals(3, streamOfChars.count());
+
+        Stream<String> streamOfString = Pattern.compile(", ").splitAsStream("a, b, c");
+        assertEquals("a", streamOfString.findFirst().get());
+
+        Path path = getPath();
+        Stream<String> streamOfStrings = null;
+        try {
+            streamOfStrings = Files.lines(path, Charset.forName("UTF-8"));
+        } catch (IOException e) {
+            log.error("Error creating streams from paths {}", path, e.getMessage(), e);
+        }
+        assertEquals("a", streamOfStrings.findFirst().get());
+
+        Stream<String> streamBuilder = Stream.<String>builder().add("a").add("b").add("c").build();
+        assertEquals(3, streamBuilder.count());
+
+        Stream<String> streamGenerated = Stream.generate(() -> "element").limit(10);
+        assertEquals(10, streamGenerated.count());
+
+        Stream<Integer> streamIterated = Stream.iterate(40, n -> n + 2).limit(20);
+        assertTrue(40 <= streamIterated.findAny().get());
+    }
+
+    @Test
+    public void runStreamPipeline_whenOrderIsRight_thenCorrect() {
+
+        List<String> list = Arrays.asList("abc1", "abc2", "abc3");
+        Optional<String> stream = list.stream()
+                .filter(element -> {
+                    log.info("filter() was called");
+                    return element.contains("2");
+                }).map(element -> {
+                    log.info("map() was called");
+                    return element.toUpperCase();
+                }).findFirst();
+    }
+
+    @Test
+    public void reduce_whenExpected_thenCorrect() {
+
+        OptionalInt reduced = IntStream.range(1, 4).reduce((a, b) -> a + b);
+        assertEquals(6, reduced.getAsInt());
+
+        int reducedTwoParams = IntStream.range(1, 4).reduce(10, (a, b) -> a + b);
+        assertEquals(16, reducedTwoParams);
+
+        int reducedThreeParams = Stream.of(1, 2, 3)
+                .reduce(10, (a, b) -> a + b, (a, b) -> {
+                    log.info("combiner was called");
+                    return a + b;
+                });
+        assertEquals(16, reducedThreeParams);
+
+        int reducedThreeParamsParallel = Arrays.asList(1, 2, 3).parallelStream()
+                .reduce(10, (a, b) -> a + b, (a, b) -> {
+                    log.info("combiner was called");
+                    return a + b;
+                });
+        assertEquals(36, reducedThreeParamsParallel);
+    }
+
+    @Test
+    public void collecting_whenAsExpected_thenCorrect() {
+
+        List<String> collectorCollection = productList.stream()
+                .map(Product::getName).collect(Collectors.toList());
+
+        assertTrue(collectorCollection instanceof List);
+        assertEquals(5, collectorCollection.size());
+
+        String listToString = productList.stream().map(Product::getName)
+                .collect(Collectors.joining(", ", "[", "]"));
+
+        assertTrue(listToString.contains(",") && listToString.contains("[") && listToString.contains("]"));
+
+        double averagePrice = productList.stream().collect(Collectors.averagingInt(Product::getPrice));
+        assertTrue(17.2 == averagePrice);
+
+        int summingPrice = productList.stream().collect(Collectors.summingInt(Product::getPrice));
+        assertEquals(86, summingPrice);
+
+        IntSummaryStatistics statistics = productList.stream()
+                .collect(Collectors.summarizingInt(Product::getPrice));
+        assertEquals(23, statistics.getMax());
+
+        Map<Integer, List<Product>> collectorMapOfLists = productList.stream()
+                .collect(Collectors.groupingBy(Product::getPrice));
+        assertEquals(3, collectorMapOfLists.keySet().size());
+
+        Map<Boolean, List<Product>> mapPartioned = productList.stream()
+                .collect(Collectors.partitioningBy(element -> element.getPrice() > 15));
+        assertEquals(2, mapPartioned.keySet().size());
+
+    }
+
+    @Test(expected = UnsupportedOperationException.class)
+    public void collect_whenThrows_thenCorrect() {
+        Set<Product> unmodifiableSet = productList.stream()
+                .collect(Collectors.collectingAndThen(Collectors.toSet(),
+                        Collections::unmodifiableSet));
+        unmodifiableSet.add(new Product(4, "tea"));
+    }
+
+    @Test
+    public void customCollector_whenResultContainsAllElementsFrSource_thenCorrect() {
+        Collector<Product, ?, LinkedList<Product>> toLinkedList =
+                Collector.of(LinkedList::new, LinkedList::add,
+                        (first, second) -> {
+                            first.addAll(second);
+                            return first;
+                        });
+
+        LinkedList<Product> linkedListOfPersons = productList.stream().collect(toLinkedList);
+        assertTrue(linkedListOfPersons.containsAll(productList));
+    }
+
+    @Test
+    public void parallelStream_whenWorks_thenCorrect() {
+        Stream<Product> streamOfCollection = productList.parallelStream();
+        boolean isParallel = streamOfCollection.isParallel();
+        boolean haveBigPrice = streamOfCollection.map(product -> product.getPrice() * 12)
+                .anyMatch(price -> price > 200);
+        assertTrue(isParallel && haveBigPrice);
+    }
+
+    @Test
+    public void parallel_whenIsParallel_thenCorrect() {
+        IntStream intStreamParallel =
+                IntStream.range(1, 150).parallel().map(element -> element * 34);
+        boolean isParallel = intStreamParallel.isParallel();
+        assertTrue(isParallel);
+    }
+
+    @Test
+    public void parallel_whenIsSequential_thenCorrect() {
+        IntStream intStreamParallel =
+                IntStream.range(1, 150).parallel().map(element -> element * 34);
+        IntStream intStreamSequential = intStreamParallel.sequential();
+        boolean isParallel = intStreamParallel.isParallel();
+        assertFalse(isParallel);
+    }
+
+    private Path getPath() {
+        Path path = null;
+        try {
+            path = Files.createTempFile(null, ".txt");
+        } catch (IOException e) {
+            log.error(e.getMessage());
+        }
+
+        try (BufferedWriter writer = Files.newBufferedWriter(path)) {
+            writer.write("a\nb\nc");
+        } catch (IOException e) {
+            log.error(e.getMessage());
+        }
+        return path;
+    }
+
+    private void wasCalled() {
+        counter++;
+    }
+}

core-java/.classpath

@@ -27,7 +27,7 @@
 			<attribute name="maven.pomderived" value="true"/>
 		</attributes>
 	</classpathentry>
-	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.7">
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8">
 		<attributes>
 			<attribute name="owner.project.facets" value="java"/>
 		</attributes>

core-java/.settings/org.eclipse.jdt.core.prefs

@@ -6,8 +6,13 @@ org.eclipse.jdt.core.compiler.annotation.nonnullbydefault=org.eclipse.jdt.annota
 org.eclipse.jdt.core.compiler.annotation.nullable=org.eclipse.jdt.annotation.Nullable
 org.eclipse.jdt.core.compiler.annotation.nullanalysis=disabled
 org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
-org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.7
+org.eclipse.jdt.core.compiler.codegen.methodParameters=do not generate
-org.eclipse.jdt.core.compiler.compliance=1.7
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.8
+org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
+org.eclipse.jdt.core.compiler.compliance=1.8
+org.eclipse.jdt.core.compiler.debug.lineNumber=generate
+org.eclipse.jdt.core.compiler.debug.localVariable=generate
+org.eclipse.jdt.core.compiler.debug.sourceFile=generate
 org.eclipse.jdt.core.compiler.problem.annotationSuperInterface=warning
 org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
 org.eclipse.jdt.core.compiler.problem.autoboxing=ignore
@@ -92,4 +97,4 @@ org.eclipse.jdt.core.compiler.problem.unusedPrivateMember=warning
 org.eclipse.jdt.core.compiler.problem.unusedTypeParameter=ignore
 org.eclipse.jdt.core.compiler.problem.unusedWarningToken=warning
 org.eclipse.jdt.core.compiler.problem.varargsArgumentNeedCast=warning
-org.eclipse.jdt.core.compiler.source=1.7
+org.eclipse.jdt.core.compiler.source=1.8

core-java/.settings/org.eclipse.wst.common.project.facet.core.xml

@@ -1,4 +1,4 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <faceted-project>
-  <installed facet="java" version="1.7"/>
+  <installed facet="java" version="1.8"/>
 </faceted-project>

core-java/pom.xml

@@ -126,8 +126,8 @@
                 <artifactId>maven-compiler-plugin</artifactId>
                 <version>${maven-compiler-plugin.version}</version>
                 <configuration>
-                    <source>1.7</source>
+                    <source>1.8</source>
-                    <target>1.7</target>
+                    <target>1.8</target>
                 </configuration>
             </plugin>
 

core-java/src/main/java/com/baeldung/enums/Pizza.java

@@ -3,37 +3,36 @@ package com.baeldung.enums;
 import com.fasterxml.jackson.annotation.JsonFormat;
 import com.fasterxml.jackson.annotation.JsonProperty;
 import com.fasterxml.jackson.databind.ObjectMapper;
-import org.apache.commons.collections15.CollectionUtils;
 import org.apache.commons.collections15.Predicate;
 
 import java.io.IOException;
-import java.util.ArrayList;
 import java.util.EnumMap;
 import java.util.EnumSet;
 import java.util.List;
+import java.util.stream.Collectors;
 
 public class Pizza {
 
-    private static EnumSet<PizzaStatusEnum> undeliveredPizzaStatuses =
+    private static EnumSet<PizzaStatus> undeliveredPizzaStatuses =
-      EnumSet.of(PizzaStatusEnum.ORDERED, PizzaStatusEnum.READY);
+            EnumSet.of(PizzaStatus.ORDERED, PizzaStatus.READY);
 
-    private PizzaStatusEnum status;
+    private PizzaStatus status;
 
     @JsonFormat(shape = JsonFormat.Shape.OBJECT)
-    public enum PizzaStatusEnum {
+    public enum PizzaStatus {
-        ORDERED (5){
+        ORDERED(5) {
             @Override
             public boolean isOrdered() {
                 return true;
             }
         },
-        READY (2){
+        READY(2) {
             @Override
             public boolean isReady() {
                 return true;
             }
         },
-        DELIVERED (0){
+        DELIVERED(0) {
             @Override
             public boolean isDelivered() {
                 return true;
@@ -42,26 +41,33 @@ public class Pizza {
 
         private int timeToDelivery;
 
-        public boolean isOrdered() {return false;}
+        public boolean isOrdered() {
+            return false;
+        }
 
-        public boolean isReady() {return false;}
+        public boolean isReady() {
+            return false;
+        }
+
+        public boolean isDelivered() {
+            return false;
+        }
 
-        public boolean isDelivered(){return  false;}
         @JsonProperty("timeToDelivery")
         public int getTimeToDelivery() {
             return timeToDelivery;
         }
 
-        private PizzaStatusEnum (int timeToDelivery) {
+        PizzaStatus(int timeToDelivery) {
             this.timeToDelivery = timeToDelivery;
         }
     }
 
-    public PizzaStatusEnum getStatus() {
+    public PizzaStatus getStatus() {
         return status;
     }
 
-    public void setStatus(PizzaStatusEnum status) {
+    public void setStatus(PizzaStatus status) {
         this.status = status;
     }
 
@@ -73,32 +79,23 @@ public class Pizza {
         System.out.println("Time to delivery is " + this.getStatus().getTimeToDelivery() + " days");
     }
 
-    public static List<Pizza> getAllUndeliveredPizza(List<Pizza> input) {
+    public static List<Pizza> getAllUndeliveredPizzas(List<Pizza> input) {
-        List<Pizza> undelivered = input;
+        return input.stream().filter(
-        CollectionUtils.filter(undelivered, thatAreNotDelivered());
+                (s) -> undeliveredPizzaStatuses.contains(s.getStatus()))
-        return undelivered;
+                .collect(Collectors.toList());
     }
 
-    public static EnumMap<PizzaStatusEnum, List<Pizza>> groupPizzaByStatus(List<Pizza> pizzaList) {
+    public static EnumMap<PizzaStatus, List<Pizza>>
-        EnumMap<PizzaStatusEnum, List<Pizza>> pzByStatus = new EnumMap<PizzaStatusEnum, List<Pizza>>(PizzaStatusEnum.class);
+    groupPizzaByStatus(List<Pizza> pzList) {
-        for (Pizza pz : pizzaList) {
+        return pzList.stream().collect(
-            PizzaStatusEnum status = pz.getStatus();
+                Collectors.groupingBy(Pizza::getStatus,
-
+                        () -> new EnumMap<>(PizzaStatus.class), Collectors.toList()));
-            if (pzByStatus.containsKey(status)) {
-                pzByStatus.get(status).add(pz);
-            } else {
-                List<Pizza> newPzList = new ArrayList<Pizza>();
-                newPzList.add(pz);
-                pzByStatus.put(status, newPzList);
-            }
-        }
-        return pzByStatus;
     }
 
     public void deliver() {
         if (isDeliverable()) {
             PizzaDeliverySystemConfiguration.getInstance().getDeliveryStrategy().deliver(this);
-            this.setStatus(PizzaStatusEnum.DELIVERED);
+            this.setStatus(PizzaStatus.DELIVERED);
         }
     }
 
@@ -108,10 +105,6 @@ public class Pizza {
     }
 
     private static Predicate<Pizza> thatAreNotDelivered() {
-        return new Predicate<Pizza>() {
+        return entry -> undeliveredPizzaStatuses.contains(entry.getStatus());
-            public boolean evaluate(Pizza entry) {
-                return undeliveredPizzaStatuses.contains(entry.getStatus());
-            }
-        };
     }
 }

core-java/src/main/java/com/baeldung/enums/PizzaDeliverySystemConfiguration.java

@@ -1,9 +1,10 @@
 package com.baeldung.enums;
 
 public enum PizzaDeliverySystemConfiguration {
-    INSTANCE ;
+    INSTANCE;
-    private PizzaDeliverySystemConfiguration() {
+
-        //Do the configuration initialization which
+    PizzaDeliverySystemConfiguration() {
+        // Do the configuration initialization which
         // involves overriding defaults like delivery strategy
     }
 

core-java/src/test/java/org/baeldung/java/collections/JavaCollectionConversionUnitTest.java

@@ -31,7 +31,7 @@ public class JavaCollectionConversionUnitTest {
 
     @Test
     public final void givenUsingCoreJava_whenListConvertedToArray_thenCorrect() {
-        final List<Integer> sourceList = Lists.<Integer> newArrayList(0, 1, 2, 3, 4, 5);
+        final List<Integer> sourceList = Arrays.asList(0, 1, 2, 3, 4, 5);
         final Integer[] targetArray = sourceList.toArray(new Integer[sourceList.size()]);
     }
 

core-java/src/test/java/org/baeldung/java/enums/PizzaTest.java

@@ -15,66 +15,66 @@ public class PizzaTest {
     @Test
     public void givenPizaOrder_whenReady_thenDeliverable() {
         Pizza testPz = new Pizza();
-        testPz.setStatus(Pizza.PizzaStatusEnum.READY);
+        testPz.setStatus(Pizza.PizzaStatus.READY);
         assertTrue(testPz.isDeliverable());
     }
 
     @Test
     public void givenPizaOrders_whenRetrievingUnDeliveredPzs_thenCorrectlyRetrieved() {
-        List<Pizza> pzList = new ArrayList<Pizza>();
+        List<Pizza> pzList = new ArrayList<>();
         Pizza pz1 = new Pizza();
-        pz1.setStatus(Pizza.PizzaStatusEnum.DELIVERED);
+        pz1.setStatus(Pizza.PizzaStatus.DELIVERED);
 
         Pizza pz2 = new Pizza();
-        pz2.setStatus(Pizza.PizzaStatusEnum.ORDERED);
+        pz2.setStatus(Pizza.PizzaStatus.ORDERED);
 
         Pizza pz3 = new Pizza();
-        pz3.setStatus(Pizza.PizzaStatusEnum.ORDERED);
+        pz3.setStatus(Pizza.PizzaStatus.ORDERED);
 
         Pizza pz4 = new Pizza();
-        pz4.setStatus(Pizza.PizzaStatusEnum.READY);
+        pz4.setStatus(Pizza.PizzaStatus.READY);
 
         pzList.add(pz1);
         pzList.add(pz2);
         pzList.add(pz3);
         pzList.add(pz4);
 
-        List<Pizza> undeliveredPzs = Pizza.getAllUndeliveredPizza(pzList);
+        List<Pizza> undeliveredPzs = Pizza.getAllUndeliveredPizzas(pzList);
         assertTrue(undeliveredPzs.size() == 3);
     }
 
     @Test
     public void givenPizaOrders_whenGroupByStatusCalled_thenCorrectlyGrouped() {
 
-        List<Pizza> pzList = new ArrayList<Pizza>();
+        List<Pizza> pzList = new ArrayList<>();
         Pizza pz1 = new Pizza();
-        pz1.setStatus(Pizza.PizzaStatusEnum.DELIVERED);
+        pz1.setStatus(Pizza.PizzaStatus.DELIVERED);
 
         Pizza pz2 = new Pizza();
-        pz2.setStatus(Pizza.PizzaStatusEnum.ORDERED);
+        pz2.setStatus(Pizza.PizzaStatus.ORDERED);
 
         Pizza pz3 = new Pizza();
-        pz3.setStatus(Pizza.PizzaStatusEnum.ORDERED);
+        pz3.setStatus(Pizza.PizzaStatus.ORDERED);
 
         Pizza pz4 = new Pizza();
-        pz4.setStatus(Pizza.PizzaStatusEnum.READY);
+        pz4.setStatus(Pizza.PizzaStatus.READY);
 
         pzList.add(pz1);
         pzList.add(pz2);
         pzList.add(pz3);
         pzList.add(pz4);
 
-        EnumMap<Pizza.PizzaStatusEnum, List<Pizza>> map = Pizza.groupPizzaByStatus(pzList);
+        EnumMap<Pizza.PizzaStatus, List<Pizza>> map = Pizza.groupPizzaByStatus(pzList);
-        assertTrue(map.get(Pizza.PizzaStatusEnum.DELIVERED).size() == 1);
+        assertTrue(map.get(Pizza.PizzaStatus.DELIVERED).size() == 1);
-        assertTrue(map.get(Pizza.PizzaStatusEnum.ORDERED).size() == 2);
+        assertTrue(map.get(Pizza.PizzaStatus.ORDERED).size() == 2);
-        assertTrue(map.get(Pizza.PizzaStatusEnum.READY).size() == 1);
+        assertTrue(map.get(Pizza.PizzaStatus.READY).size() == 1);
     }
 
     @Test
     public void givenPizaOrder_whenDelivered_thenPizzaGetsDeliveredAndStatusChanges() {
         Pizza pz = new Pizza();
-        pz.setStatus(Pizza.PizzaStatusEnum.READY);
+        pz.setStatus(Pizza.PizzaStatus.READY);
         pz.deliver();
-        assertTrue(pz.getStatus() == Pizza.PizzaStatusEnum.DELIVERED);
+        assertTrue(pz.getStatus() == Pizza.PizzaStatus.DELIVERED);
     }
 }

dependency-injection/.gitignore

@@ -0,0 +1,12 @@
+RemoteSystemsTempFiles/
+.classpath
+.project
+.settings/
+bin/
+.metadata/
+docs/*.autosave
+docs/*.autosave
+.recommenders/
+build/
+.gradle/
+.DS_Store

dependency-injection/pom.xml

@@ -0,0 +1,83 @@
+<project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xmlns="http://maven.apache.org/POM/4.0.0"
+         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>dependency-injection</artifactId>
+    <version>0.0.1-SNAPSHOT</version>
+    <packaging>war</packaging>
+
+    <name>Resource vs Inject vs Autowired</name>
+    <description>Accompanying the demonstration of the use of the annotations related to injection mechanisms, namely
+        Resource, Inject, and Autowired
+    </description>
+
+    <dependencies>
+        <dependency>
+            <groupId>junit</groupId>
+            <artifactId>junit</artifactId>
+            <version>4.11</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.mockito</groupId>
+            <artifactId>mockito-all</artifactId>
+            <version>1.10.19</version>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework</groupId>
+            <artifactId>spring-test</artifactId>
+            <version>4.2.6.RELEASE</version>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework</groupId>
+            <artifactId>spring-core</artifactId>
+            <version>4.2.6.RELEASE</version>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework</groupId>
+            <artifactId>spring-beans</artifactId>
+            <version>4.2.6.RELEASE</version>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework</groupId>
+            <artifactId>spring-context</artifactId>
+            <version>4.2.6.RELEASE</version>
+        </dependency>
+        <dependency>
+            <groupId>javax.inject</groupId>
+            <artifactId>javax.inject</artifactId>
+            <version>1</version>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <plugins>
+            <plugin>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <configuration>
+                    <source>1.8</source>
+                    <target>1.8</target>
+                </configuration>
+            </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-surefire-plugin</artifactId>
+                <configuration>
+                    <includes>
+                        <include>**/*Test.java</include>
+                    </includes>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+
+    <repositories>
+        <repository>
+            <id>java.net</id>
+            <url>https://maven.java.net/content/repositories/releases/</url>
+        </repository>
+    </repositories>
+</project>

dependency-injection/src/main/java/com/baeldung/configuration/ApplicationContextTestAutowiredName.java

@@ -0,0 +1,9 @@
+package com.baeldung.configuration;
+
+import org.springframework.context.annotation.ComponentScan;
+import org.springframework.context.annotation.Configuration;
+
+@Configuration
+@ComponentScan(basePackages = {"com.baeldung.dependency"})
+public class ApplicationContextTestAutowiredName {
+}

dependency-injection/src/main/java/com/baeldung/configuration/ApplicationContextTestAutowiredQualifier.java

@@ -0,0 +1,24 @@
+package com.baeldung.configuration;
+
+import com.baeldung.dependency.AnotherArbitraryDependency;
+import com.baeldung.dependency.ArbitraryDependency;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+@Configuration
+public class ApplicationContextTestAutowiredQualifier {
+
+    @Bean
+    public ArbitraryDependency autowiredFieldDependency() {
+        ArbitraryDependency autowiredFieldDependency = new ArbitraryDependency();
+
+        return autowiredFieldDependency;
+    }
+
+    @Bean
+    public ArbitraryDependency anotherAutowiredFieldDependency() {
+        ArbitraryDependency anotherAutowiredFieldDependency = new AnotherArbitraryDependency();
+
+        return anotherAutowiredFieldDependency;
+    }
+}

dependency-injection/src/main/java/com/baeldung/configuration/ApplicationContextTestAutowiredType.java

@@ -0,0 +1,15 @@
+package com.baeldung.configuration;
+
+import com.baeldung.dependency.ArbitraryDependency;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+@Configuration
+public class ApplicationContextTestAutowiredType {
+
+    @Bean
+    public ArbitraryDependency autowiredFieldDependency() {
+        ArbitraryDependency autowiredFieldDependency = new ArbitraryDependency();
+        return autowiredFieldDependency;
+    }
+}

dependency-injection/src/main/java/com/baeldung/configuration/ApplicationContextTestInjectName.java

@@ -0,0 +1,16 @@
+package com.baeldung.configuration;
+
+import com.baeldung.dependency.ArbitraryDependency;
+import com.baeldung.dependency.YetAnotherArbitraryDependency;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+@Configuration
+public class ApplicationContextTestInjectName {
+
+    @Bean
+    public ArbitraryDependency yetAnotherFieldInjectDependency() {
+        ArbitraryDependency yetAnotherFieldInjectDependency = new YetAnotherArbitraryDependency();
+        return yetAnotherFieldInjectDependency;
+    }
+}

dependency-injection/src/main/java/com/baeldung/configuration/ApplicationContextTestInjectQualifier.java

@@ -0,0 +1,22 @@
+package com.baeldung.configuration;
+
+import com.baeldung.dependency.AnotherArbitraryDependency;
+import com.baeldung.dependency.ArbitraryDependency;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+@Configuration
+public class ApplicationContextTestInjectQualifier {
+
+    @Bean
+    public ArbitraryDependency defaultFile() {
+        ArbitraryDependency defaultFile = new ArbitraryDependency();
+        return defaultFile;
+    }
+
+    @Bean
+    public ArbitraryDependency namedFile() {
+        ArbitraryDependency namedFile = new AnotherArbitraryDependency();
+        return namedFile;
+    }
+}

dependency-injection/src/main/java/com/baeldung/configuration/ApplicationContextTestInjectType.java

@@ -0,0 +1,15 @@
+package com.baeldung.configuration;
+
+import com.baeldung.dependency.ArbitraryDependency;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+@Configuration
+public class ApplicationContextTestInjectType {
+
+    @Bean
+    public ArbitraryDependency injectDependency() {
+        ArbitraryDependency injectDependency = new ArbitraryDependency();
+        return injectDependency;
+    }
+}

dependency-injection/src/main/java/com/baeldung/configuration/ApplicationContextTestResourceNameType.java

@@ -0,0 +1,16 @@
+package com.baeldung.configuration;
+
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+import java.io.File;
+
+@Configuration
+public class ApplicationContextTestResourceNameType {
+
+    @Bean(name = "namedFile")
+    public File namedFile() {
+        File namedFile = new File("namedFile.txt");
+        return namedFile;
+    }
+}

dependency-injection/src/main/java/com/baeldung/configuration/ApplicationContextTestResourceQualifier.java

@@ -0,0 +1,22 @@
+package com.baeldung.configuration;
+
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+import java.io.File;
+
+@Configuration
+public class ApplicationContextTestResourceQualifier {
+
+    @Bean(name = "defaultFile")
+    public File defaultFile() {
+        File defaultFile = new File("defaultFile.txt");
+        return defaultFile;
+    }
+
+    @Bean(name = "namedFile")
+    public File namedFile() {
+        File namedFile = new File("namedFile.txt");
+        return namedFile;
+    }
+}

dependency-injection/src/main/java/com/baeldung/dependency/AnotherArbitraryDependency.java

@@ -0,0 +1,13 @@
+package com.baeldung.dependency;
+
+import org.springframework.stereotype.Component;
+
+@Component
+public class AnotherArbitraryDependency extends ArbitraryDependency {
+
+    private final String label = "Another Arbitrary Dependency";
+
+    public String toString() {
+        return label;
+    }
+}

dependency-injection/src/main/java/com/baeldung/dependency/ArbitraryDependency.java

@@ -0,0 +1,13 @@
+package com.baeldung.dependency;
+
+import org.springframework.stereotype.Component;
+
+@Component(value = "autowiredFieldDependency")
+public class ArbitraryDependency {
+
+    private final String label = "Arbitrary Dependency";
+
+    public String toString() {
+        return label;
+    }
+}

dependency-injection/src/main/java/com/baeldung/dependency/YetAnotherArbitraryDependency.java

@@ -0,0 +1,13 @@
+package com.baeldung.dependency;
+
+import org.springframework.stereotype.Component;
+
+@Component
+public class YetAnotherArbitraryDependency extends ArbitraryDependency {
+
+    private final String label = "Yet Another Arbitrary Dependency";
+
+    public String toString() {
+        return label;
+    }
+}

dependency-injection/src/test/java/com/baeldung/autowired/FieldAutowiredNameTest.java

@@ -0,0 +1,29 @@
+package com.baeldung.autowired;
+
+import com.baeldung.configuration.ApplicationContextTestAutowiredName;
+import com.baeldung.dependency.ArbitraryDependency;
+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 static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration(
+  loader = AnnotationConfigContextLoader.class,
+  classes = ApplicationContextTestAutowiredName.class)
+public class FieldAutowiredNameTest {
+
+    @Autowired
+    private ArbitraryDependency autowiredFieldDependency;
+
+    @Test
+    public void givenAutowiredAnnotation_WhenOnField_ThenDependencyValid() {
+        assertNotNull(autowiredFieldDependency);
+        assertEquals("Arbitrary Dependency", autowiredFieldDependency.toString());
+    }
+}

dependency-injection/src/test/java/com/baeldung/autowired/FieldAutowiredTest.java

@@ -0,0 +1,29 @@
+package com.baeldung.autowired;
+
+import com.baeldung.configuration.ApplicationContextTestAutowiredType;
+import com.baeldung.dependency.ArbitraryDependency;
+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 static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration(
+  loader = AnnotationConfigContextLoader.class,
+  classes = ApplicationContextTestAutowiredType.class)
+public class FieldAutowiredTest {
+
+    @Autowired
+    private ArbitraryDependency fieldDependency;
+
+    @Test
+    public void givenAutowired_WhenSetOnField_ThenDependencyResolved() {
+        assertNotNull(fieldDependency);
+        assertEquals("Arbitrary Dependency", fieldDependency.toString());
+    }
+}

dependency-injection/src/test/java/com/baeldung/autowired/FieldQualifierAutowiredTest.java

@@ -0,0 +1,41 @@
+package com.baeldung.autowired;
+
+import com.baeldung.configuration.ApplicationContextTestAutowiredQualifier;
+import com.baeldung.dependency.ArbitraryDependency;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+import org.springframework.test.context.support.AnnotationConfigContextLoader;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration(
+  loader = AnnotationConfigContextLoader.class,
+  classes = ApplicationContextTestAutowiredQualifier.class)
+public class FieldQualifierAutowiredTest {
+
+    @Autowired
+    @Qualifier("autowiredFieldDependency")
+    private ArbitraryDependency fieldDependency1;
+
+    @Autowired
+    @Qualifier("anotherAutowiredFieldDependency")
+    private ArbitraryDependency fieldDependency2;
+
+    @Test
+    public void givenAutowiredQualifier_WhenOnField_ThenDep1Valid() {
+        assertNotNull(fieldDependency1);
+        assertEquals("Arbitrary Dependency", fieldDependency1.toString());
+    }
+
+    @Test
+    public void givenAutowiredQualifier_WhenOnField_ThenDep2Valid() {
+        assertNotNull(fieldDependency2);
+        assertEquals("Another Arbitrary Dependency", fieldDependency2.toString());
+    }
+}

dependency-injection/src/test/java/com/baeldung/inject/FieldByNameInjectTest.java

@@ -0,0 +1,32 @@
+package com.baeldung.inject;
+
+import com.baeldung.configuration.ApplicationContextTestInjectName;
+import com.baeldung.dependency.ArbitraryDependency;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+import org.springframework.test.context.support.AnnotationConfigContextLoader;
+
+import javax.inject.Inject;
+import javax.inject.Named;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration(
+  loader = AnnotationConfigContextLoader.class,
+  classes = ApplicationContextTestInjectName.class)
+public class FieldByNameInjectTest {
+
+    @Inject
+    @Named("yetAnotherFieldInjectDependency")
+    private ArbitraryDependency yetAnotherFieldInjectDependency;
+
+    @Test
+    public void givenInjectQualifier_WhenSetOnField_ThenDependencyValid() {
+        assertNotNull(yetAnotherFieldInjectDependency);
+        assertEquals("Yet Another Arbitrary Dependency", yetAnotherFieldInjectDependency.toString());
+    }
+}

dependency-injection/src/test/java/com/baeldung/inject/FieldInjectTest.java

@@ -0,0 +1,30 @@
+package com.baeldung.inject;
+
+import com.baeldung.configuration.ApplicationContextTestInjectType;
+import com.baeldung.dependency.ArbitraryDependency;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+import org.springframework.test.context.support.AnnotationConfigContextLoader;
+
+import javax.inject.Inject;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration(
+  loader = AnnotationConfigContextLoader.class,
+  classes = ApplicationContextTestInjectType.class)
+public class FieldInjectTest {
+
+    @Inject
+    private ArbitraryDependency fieldInjectDependency;
+
+    @Test
+    public void givenInjectAnnotation_WhenOnField_ThenValidDependency() {
+        assertNotNull(fieldInjectDependency);
+        assertEquals("Arbitrary Dependency", fieldInjectDependency.toString());
+    }
+}

dependency-injection/src/test/java/com/baeldung/inject/FieldQualifierInjectTest.java

@@ -0,0 +1,41 @@
+package com.baeldung.inject;
+
+import com.baeldung.configuration.ApplicationContextTestInjectQualifier;
+import com.baeldung.dependency.ArbitraryDependency;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+import org.springframework.test.context.support.AnnotationConfigContextLoader;
+
+import javax.inject.Inject;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration(loader = AnnotationConfigContextLoader.class,
+  classes = ApplicationContextTestInjectQualifier.class)
+public class FieldQualifierInjectTest {
+
+    @Inject
+    @Qualifier("defaultFile")
+    private ArbitraryDependency defaultDependency;
+
+    @Inject
+    @Qualifier("namedFile")
+    private ArbitraryDependency namedDependency;
+
+    @Test
+    public void givenInjectQualifier_WhenOnField_ThenDefaultFileValid() {
+        assertNotNull(defaultDependency);
+        assertEquals("Arbitrary Dependency", defaultDependency.toString());
+    }
+
+    @Test
+    public void givenInjectQualifier_WhenOnField_ThenNamedFileValid() {
+        assertNotNull(defaultDependency);
+        assertEquals("Another Arbitrary Dependency", namedDependency.toString());
+    }
+}

dependency-injection/src/test/java/com/baeldung/resource/FieldResourceInjectionTest.java

@@ -0,0 +1,30 @@
+package com.baeldung.resource;
+
+import com.baeldung.configuration.ApplicationContextTestResourceNameType;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+import org.springframework.test.context.support.AnnotationConfigContextLoader;
+
+import javax.annotation.Resource;
+import java.io.File;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration(
+  loader = AnnotationConfigContextLoader.class,
+  classes = ApplicationContextTestResourceNameType.class)
+public class FieldResourceInjectionTest {
+
+    @Resource(name = "namedFile")
+    private File defaultFile;
+
+    @Test
+    public void givenResourceAnnotation_WhenOnField_ThenDependencyValid() {
+        assertNotNull(defaultFile);
+        assertEquals("namedFile.txt", defaultFile.getName());
+    }
+}

dependency-injection/src/test/java/com/baeldung/resource/MethodByQualifierResourceTest.java

@@ -0,0 +1,45 @@
+package com.baeldung.resource;
+
+import com.baeldung.configuration.ApplicationContextTestResourceQualifier;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+import org.springframework.test.context.support.AnnotationConfigContextLoader;
+
+import javax.annotation.Resource;
+import java.io.File;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration(
+  loader = AnnotationConfigContextLoader.class,
+  classes = ApplicationContextTestResourceQualifier.class)
+public class MethodByQualifierResourceTest {
+
+    private File arbDependency;
+    private File anotherArbDependency;
+
+    @Test
+    public void givenResourceQualifier_WhenSetter_ThenValidDependencies() {
+        assertNotNull(arbDependency);
+        assertEquals("namedFile.txt", arbDependency.getName());
+        assertNotNull(anotherArbDependency);
+        assertEquals("defaultFile.txt", anotherArbDependency.getName());
+    }
+
+    @Resource
+    @Qualifier("namedFile")
+    public void setArbDependency(File arbDependency) {
+        this.arbDependency = arbDependency;
+    }
+
+    @Resource
+    @Qualifier("defaultFile")
+    public void setAnotherArbDependency(File anotherArbDependency) {
+        this.anotherArbDependency = anotherArbDependency;
+    }
+}

dependency-injection/src/test/java/com/baeldung/resource/MethodByTypeResourceTest.java

@@ -0,0 +1,34 @@
+package com.baeldung.resource;
+
+import com.baeldung.configuration.ApplicationContextTestResourceNameType;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+import org.springframework.test.context.support.AnnotationConfigContextLoader;
+
+import javax.annotation.Resource;
+import java.io.File;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration(
+  loader = AnnotationConfigContextLoader.class,
+  classes = ApplicationContextTestResourceNameType.class)
+public class MethodByTypeResourceTest {
+
+    private File defaultFile;
+
+    @Resource
+    protected void setDefaultFile(File defaultFile) {
+        this.defaultFile = defaultFile;
+    }
+
+    @Test
+    public void givenResourceAnnotation_WhenSetter_ThenValidDependency() {
+        assertNotNull(defaultFile);
+        assertEquals("namedFile.txt", defaultFile.getName());
+    }
+}

dependency-injection/src/test/java/com/baeldung/resource/MethodResourceInjectionTest.java

@@ -0,0 +1,34 @@
+package com.baeldung.resource;
+
+import com.baeldung.configuration.ApplicationContextTestResourceNameType;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+import org.springframework.test.context.support.AnnotationConfigContextLoader;
+
+import javax.annotation.Resource;
+import java.io.File;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration(
+  loader = AnnotationConfigContextLoader.class,
+  classes = ApplicationContextTestResourceNameType.class)
+public class MethodResourceInjectionTest {
+
+    private File defaultFile;
+
+    @Resource(name = "namedFile")
+    protected void setDefaultFile(File defaultFile) {
+        this.defaultFile = defaultFile;
+    }
+
+    @Test
+    public void givenResourceAnnotation_WhenSetter_ThenDependencyValid() {
+        assertNotNull(defaultFile);
+        assertEquals("namedFile.txt", defaultFile.getName());
+    }
+}

dependency-injection/src/test/java/com/baeldung/resource/NamedResourceTest.java

@@ -0,0 +1,29 @@
+package com.baeldung.resource;
+
+import com.baeldung.configuration.ApplicationContextTestResourceNameType;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+import org.springframework.test.context.support.AnnotationConfigContextLoader;
+
+import javax.annotation.Resource;
+import java.io.File;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration(loader = AnnotationConfigContextLoader.class,
+  classes = ApplicationContextTestResourceNameType.class)
+public class NamedResourceTest {
+
+    @Resource(name = "namedFile")
+    private File testFile;
+
+    @Test
+    public void givenResourceAnnotation_WhenOnField_THEN_DEPENDENCY_Found() {
+        assertNotNull(testFile);
+        assertEquals("namedFile.txt", testFile.getName());
+    }
+}

dependency-injection/src/test/java/com/baeldung/resource/QualifierResourceInjectionTest.java

@@ -0,0 +1,42 @@
+package com.baeldung.resource;
+
+import com.baeldung.configuration.ApplicationContextTestResourceQualifier;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+import org.springframework.test.context.support.AnnotationConfigContextLoader;
+
+import javax.annotation.Resource;
+import java.io.File;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration(
+  loader = AnnotationConfigContextLoader.class,
+  classes = ApplicationContextTestResourceQualifier.class)
+public class QualifierResourceInjectionTest {
+
+    @Resource
+    @Qualifier("defaultFile")
+    private File dependency1;
+
+    @Resource
+    @Qualifier("namedFile")
+    private File dependency2;
+
+    @Test
+    public void givenResourceAnnotation_WhenField_ThenDependency1Valid() {
+        assertNotNull(dependency1);
+        assertEquals("defaultFile.txt", dependency1.getName());
+    }
+
+    @Test
+    public void givenResourceQualifier_WhenField_ThenDependency2Valid() {
+        assertNotNull(dependency2);
+        assertEquals("namedFile.txt", dependency2.getName());
+    }
+}

dependency-injection/src/test/java/com/baeldung/resource/SetterResourceInjectionTest.java

@@ -0,0 +1,33 @@
+package com.baeldung.resource;
+
+import com.baeldung.configuration.ApplicationContextTestResourceNameType;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+import org.springframework.test.context.support.AnnotationConfigContextLoader;
+
+import javax.annotation.Resource;
+import java.io.File;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration(loader = AnnotationConfigContextLoader.class,
+  classes = ApplicationContextTestResourceNameType.class)
+public class SetterResourceInjectionTest {
+
+    private File defaultFile;
+
+    @Resource
+    protected void setDefaultFile(File defaultFile) {
+        this.defaultFile = defaultFile;
+    }
+
+    @Test
+    public void givenResourceAnnotation_WhenOnSetter_THEN_MUST_INJECT_Dependency() {
+        assertNotNull(defaultFile);
+        assertEquals("namedFile.txt", defaultFile.getName());
+    }
+}

gatling/pom.xml

@@ -0,0 +1,110 @@
+<?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>org.baeldung</groupId>
+    <artifactId>gatling</artifactId>
+    <version>1.0-SNAPSHOT</version>
+
+    <properties>
+        <maven.compiler.source>1.8</maven.compiler.source>
+        <maven.compiler.target>1.8</maven.compiler.target>
+        <scala.version>2.11.7</scala.version>
+        <encoding>UTF-8</encoding>
+        <gatling.version>2.2.0</gatling.version>
+        <scala-maven-plugin.version>3.2.2</scala-maven-plugin.version>
+    </properties>
+
+    <dependencyManagement>
+        <dependencies>
+            <dependency>
+                <groupId>io.gatling</groupId>
+                <artifactId>gatling-app</artifactId>
+                <version>${gatling.version}</version>
+            </dependency>
+            <dependency>
+                <groupId>io.gatling</groupId>
+                <artifactId>gatling-recorder</artifactId>
+                <version>${gatling.version}</version>
+            </dependency>
+            <dependency>
+                <groupId>io.gatling.highcharts</groupId>
+                <artifactId>gatling-charts-highcharts</artifactId>
+                <version>${gatling.version}</version>
+            </dependency>
+            <dependency>
+                <groupId>org.scala-lang</groupId>
+                <artifactId>scala-library</artifactId>
+                <version>${scala.version}</version>
+            </dependency>
+        </dependencies>
+    </dependencyManagement>
+
+    <dependencies>
+        <dependency>
+            <groupId>io.gatling.highcharts</groupId>
+            <artifactId>gatling-charts-highcharts</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>io.gatling</groupId>
+            <artifactId>gatling-app</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>io.gatling</groupId>
+            <artifactId>gatling-recorder</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.scala-lang</groupId>
+            <artifactId>scala-library</artifactId>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <testSourceDirectory>src/test/scala</testSourceDirectory>
+        <pluginManagement>
+            <plugins>
+                <plugin>
+                    <groupId>net.alchim31.maven</groupId>
+                    <artifactId>scala-maven-plugin</artifactId>
+                    <version>${scala-maven-plugin.version}</version>
+                </plugin>
+            </plugins>
+        </pluginManagement>
+        <plugins>
+            <plugin>
+                <groupId>net.alchim31.maven</groupId>
+                <artifactId>scala-maven-plugin</artifactId>
+                <executions>
+                    <execution>
+                        <goals>
+                            <goal>testCompile</goal>
+                        </goals>
+                        <configuration>
+                            <args>
+                                <arg>-Ybackend:GenBCode</arg>
+                                <arg>-Ydelambdafy:method</arg>
+                                <arg>-target:jvm-1.8</arg>
+                                <arg>-deprecation</arg>
+                                <arg>-feature</arg>
+                                <arg>-unchecked</arg>
+                                <arg>-language:implicitConversions</arg>
+                                <arg>-language:postfixOps</arg>
+                            </args>
+                        </configuration>
+                    </execution>
+                </executions>
+            </plugin>
+            <plugin>
+                <groupId>io.gatling</groupId>
+                <artifactId>gatling-maven-plugin</artifactId>
+                <version>${gatling.version}</version>
+                <executions>
+                    <execution>
+                        <phase>test</phase>
+                        <goals><goal>execute</goal></goals>
+                    </execution>
+                </executions>
+            </plugin>
+        </plugins>
+    </build>
+</project>

gatling/src/test/resources/gatling.conf

@@ -0,0 +1,127 @@
+#########################
+# Gatling Configuration #
+#########################
+
+# This file contains all the settings configurable for Gatling with their default values
+
+gatling {
+  core {
+    #outputDirectoryBaseName = "" # The prefix for each simulation result folder (then suffixed by the report generation timestamp)
+    #runDescription = ""          # The description for this simulation run, displayed in each report
+    #encoding = "utf-8"           # Encoding to use throughout Gatling for file and string manipulation
+    #simulationClass = ""         # The FQCN of the simulation to run (when used in conjunction with noReports, the simulation for which assertions will be validated)
+    #mute = false                 # When set to true, don't ask for simulation name nor run description (currently only used by Gatling SBT plugin)
+    #elFileBodiesCacheMaxCapacity = 200        # Cache size for request body EL templates, set to 0 to disable
+    #rawFileBodiesCacheMaxCapacity = 200       # Cache size for request body Raw templates, set to 0 to disable
+    #rawFileBodiesInMemoryMaxSize = 1000       # Below this limit, raw file bodies will be cached in memory
+
+    extract {
+      regex {
+        #cacheMaxCapacity = 200 # Cache size for the compiled regexes, set to 0 to disable caching
+      }
+      xpath {
+        #cacheMaxCapacity = 200 # Cache size for the compiled XPath queries,  set to 0 to disable caching
+      }
+      jsonPath {
+        #cacheMaxCapacity = 200 # Cache size for the compiled jsonPath queries, set to 0 to disable caching
+        #preferJackson = false  # When set to true, prefer Jackson over Boon for JSON-related operations
+      }
+      css {
+        #cacheMaxCapacity = 200 # Cache size for the compiled CSS selectors queries,  set to 0 to disable caching
+      }
+    }
+
+    directory {
+      #data = user-files/data               # Folder where user's data (e.g. files used by Feeders) is located
+      #bodies = user-files/bodies           # Folder where bodies are located
+      #simulations = user-files/simulations # Folder where the bundle's simulations are located
+      #reportsOnly = ""                     # If set, name of report folder to look for in order to generate its report
+      #binaries = ""                        # If set, name of the folder where compiles classes are located: Defaults to GATLING_HOME/target.
+      #results = results                    # Name of the folder where all reports folder are located
+    }
+  }
+  charting {
+    #noReports = false       # When set to true, don't generate HTML reports
+    #maxPlotPerSeries = 1000 # Number of points per graph in Gatling reports
+    #useGroupDurationMetric = false  # Switch group timings from cumulated response time to group duration.
+    indicators {
+      #lowerBound = 800      # Lower bound for the requests' response time to track in the reports and the console summary
+      #higherBound = 1200    # Higher bound for the requests' response time to track in the reports and the console summary
+      #percentile1 = 50      # Value for the 1st percentile to track in the reports, the console summary and Graphite
+      #percentile2 = 75      # Value for the 2nd percentile to track in the reports, the console summary and Graphite
+      #percentile3 = 95      # Value for the 3rd percentile to track in the reports, the console summary and Graphite
+      #percentile4 = 99      # Value for the 4th percentile to track in the reports, the console summary and Graphite
+    }
+  }
+  http {
+    #fetchedCssCacheMaxCapacity = 200          # Cache size for CSS parsed content, set to 0 to disable
+    #fetchedHtmlCacheMaxCapacity = 200         # Cache size for HTML parsed content, set to 0 to disable
+    #perUserCacheMaxCapacity = 200             # Per virtual user cache size, set to 0 to disable
+    #warmUpUrl = "http://gatling.io"           # The URL to use to warm-up the HTTP stack (blank means disabled)
+    #enableGA = true                           # Very light Google Analytics, please support
+    ssl {
+      keyStore {
+        #type = ""      # Type of SSLContext's KeyManagers store
+        #file = ""      # Location of SSLContext's KeyManagers store
+        #password = ""  # Password for SSLContext's KeyManagers store
+        #algorithm = "" # Algorithm used SSLContext's KeyManagers store
+      }
+      trustStore {
+        #type = ""      # Type of SSLContext's TrustManagers store
+        #file = ""      # Location of SSLContext's TrustManagers store
+        #password = ""  # Password for SSLContext's TrustManagers store
+        #algorithm = "" # Algorithm used by SSLContext's TrustManagers store
+      }
+    }
+    ahc {
+      #keepAlive = true                                # Allow pooling HTTP connections (keep-alive header automatically added)
+      #connectTimeout = 60000                          # Timeout when establishing a connection
+      #pooledConnectionIdleTimeout = 60000             # Timeout when a connection stays unused in the pool
+      #readTimeout = 60000                             # Timeout when a used connection stays idle
+      #maxRetry = 2                                    # Number of times that a request should be tried again
+      #requestTimeout = 60000                          # Timeout of the requests
+      #acceptAnyCertificate = true                     # When set to true, doesn't validate SSL certificates
+      #httpClientCodecMaxInitialLineLength = 4096      # Maximum length of the initial line of the response (e.g. "HTTP/1.0 200 OK")
+      #httpClientCodecMaxHeaderSize = 8192             # Maximum size, in bytes, of each request's headers
+      #httpClientCodecMaxChunkSize = 8192              # Maximum length of the content or each chunk
+      #webSocketMaxFrameSize = 10240000                # Maximum frame payload size
+      #sslEnabledProtocols = [TLSv1.2, TLSv1.1, TLSv1] # Array of enabled protocols for HTTPS, if empty use the JDK defaults
+      #sslEnabledCipherSuites = []                     # Array of enabled cipher suites for HTTPS, if empty  use the JDK defaults
+      #sslSessionCacheSize = 0                         # SSLSession cache size, set to 0 to use JDK's default
+      #sslSessionTimeout = 0                           # SSLSession timeout in seconds, set to 0 to use JDK's default (24h)
+      #useOpenSsl = false                              # if OpenSSL should be used instead of JSSE (requires tcnative jar)
+      #useNativeTransport = false                      # if native transport should be used instead of Java NIO (requires netty-transport-native-epoll, currently Linux only)
+      #usePooledMemory = true                          # if Gatling should use pooled memory
+      #tcpNoDelay = true
+      #soReuseAddress = false
+      #soLinger = -1
+      #soSndBuf = -1
+      #soRcvBuf = -1
+    }
+    dns {
+      #queryTimeout = 5000                             # Timeout of each DNS query in millis
+      #maxQueriesPerResolve = 3                        # Maximum allowed number of DNS queries for a given name resolution
+    }
+  }
+  data {
+    #writers = [console, file]      # The list of DataWriters to which Gatling write simulation data (currently supported : console, file, graphite, jdbc)
+    console {
+      #light = false                # When set to true, displays a light version without detailed request stats
+    }
+    file {
+      #bufferSize = 8192            # FileDataWriter's internal data buffer size, in bytes
+    }
+    leak {
+      #noActivityTimeout = 30  # Period, in seconds, for which Gatling may have no activity before considering a leak may be happening
+    }
+    graphite {
+      #light = false              # only send the all* stats
+      #host = "localhost"         # The host where the Carbon server is located
+      #port = 2003                # The port to which the Carbon server listens to (2003 is default for plaintext, 2004 is default for pickle)
+      #protocol = "tcp"           # The protocol used to send data to Carbon (currently supported : "tcp", "udp")
+      #rootPathPrefix = "gatling" # The common prefix of all metrics sent to Graphite
+      #bufferSize = 8192          # GraphiteDataWriter's internal data buffer size, in bytes
+      #writeInterval = 1          # GraphiteDataWriter's write interval, in seconds
+    }
+  }
+}

gatling/src/test/resources/logback.xml

@@ -0,0 +1,22 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<configuration>
+
+    <appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
+        <encoder>
+            <pattern>%d{HH:mm:ss.SSS} [%-5level] %logger{15} - %msg%n%rEx</pattern>
+            <immediateFlush>false</immediateFlush>
+        </encoder>
+    </appender>
+
+    <!-- Uncomment for logging ALL HTTP request and responses -->
+    <!-- 	<logger name="io.gatling.http.ahc" level="TRACE" /> -->
+    <!--    <logger name="io.gatling.http.response" level="TRACE" /> -->
+    <!-- Uncomment for logging ONLY FAILED HTTP request and responses -->
+    <!-- 	<logger name="io.gatling.http.ahc" level="DEBUG" /> -->
+    <!--    <logger name="io.gatling.http.response" level="DEBUG" /> -->
+
+    <root level="WARN">
+        <appender-ref ref="CONSOLE" />
+    </root>
+
+</configuration>

gatling/src/test/resources/recorder.conf

@@ -0,0 +1,53 @@
+recorder {
+  core {
+    #mode = "Proxy"
+    #encoding = "utf-8"               # The encoding used for reading/writing request bodies and the generated simulation
+    #outputFolder = ""                # The folder where generated simulation will we written
+    #package = ""                     # The package's name of the generated simulation
+    #className = "RecordedSimulation" # The name of the generated Simulation class
+    #thresholdForPauseCreation = 100  # The minimum time, in milliseconds, that must pass between requests to trigger a pause creation
+    #saveConfig = false               # When set to true, the configuration from the Recorder GUI overwrites this configuration
+    #headless = false                 # When set to true, run the Recorder in headless mode instead of the GUI
+    #harFilePath = ""                 # The path of the HAR file to convert
+  }
+  filters {
+    #filterStrategy = "Disabled" # The selected filter resources filter strategy (currently supported : "Disabled", "BlackList", "WhiteList")
+    #whitelist = []              # The list of ressources patterns that are part of the Recorder's whitelist
+    #blacklist = []              # The list of ressources patterns that are part of the Recorder's blacklist
+  }
+  http {
+    #automaticReferer = true       # When set to false, write the referer + enable 'disableAutoReferer' in the generated simulation
+    #followRedirect = true         # When set to false, write redirect requests + enable 'disableFollowRedirect' in the generated simulation
+    #removeCacheHeaders = true     # When set to true, removes from the generated requests headers leading to request caching
+    #inferHtmlResources = true     # When set to true, add inferred resources + set 'inferHtmlResources' with the configured blacklist/whitelist in the generated simulation
+    #checkResponseBodies = false   # When set to true, save response bodies as files and add raw checks in the generated simulation
+  }
+  proxy {
+    #port = 8000                         # Local port used by Gatling's Proxy for HTTP/HTTPS
+    https {
+      #mode = "SelfSignedCertificate"    # The selected "HTTPS mode" (currently supported : "SelfSignedCertificate", "ProvidedKeyStore", "GatlingCertificateAuthority", "CustomCertificateAuthority")
+      keyStore {
+        #path = ""                       # The path of the custom key store
+        #password = ""                   # The password for this key store
+        #type = "JKS"                    # The type of the key store (currently supported: "JKS")
+      }
+      certificateAuthority {
+        #certificatePath = ""            # The path of the custom certificate
+        #privateKeyPath = ""             # The certificate's private key path
+      }
+    }
+    outgoing {
+      #host = ""     # The outgoing proxy's hostname
+      #username = "" # The username to use to connect to the outgoing proxy
+      #password = "" # The password corresponding to the user to use to connect to the outgoing proxy
+      #port = 0      # The HTTP port to use to connect to the outgoing proxy
+      #sslPort = 0   # If set, The HTTPS port to use to connect to the outgoing proxy
+    }
+  }
+  netty {
+    #maxInitialLineLength = 10000 # Maximum length of the initial line of the response (e.g. "HTTP/1.0 200 OK")
+    #maxHeaderSize = 20000        # Maximum size, in bytes, of each request's headers
+    #maxChunkSize = 8192          # Maximum length of the content or each chunk
+    #maxContentLength = 100000000 # Maximum length of the aggregated content of each response
+  }
+}

gatling/src/test/scala/Engine.scala

@@ -0,0 +1,13 @@
+import io.gatling.app.Gatling
+import io.gatling.core.config.GatlingPropertiesBuilder
+
+object Engine extends App {
+
+    val props = new GatlingPropertiesBuilder
+    props.dataDirectory(IDEPathHelper.dataDirectory.toString)
+    props.resultsDirectory(IDEPathHelper.resultsDirectory.toString)
+    props.bodiesDirectory(IDEPathHelper.bodiesDirectory.toString)
+    props.binariesDirectory(IDEPathHelper.mavenBinariesDirectory.toString)
+
+    Gatling.fromMap(props.build)
+}

gatling/src/test/scala/IDEPathHelper.scala

@@ -0,0 +1,22 @@
+import java.nio.file.Path
+
+import io.gatling.commons.util.PathHelper._
+
+object IDEPathHelper {
+
+    val gatlingConfUrl: Path = getClass.getClassLoader.getResource("gatling.conf").toURI
+    val projectRootDir = gatlingConfUrl.ancestor(3)
+
+    val mavenSourcesDirectory = projectRootDir / "src" / "test" / "scala"
+    val mavenResourcesDirectory = projectRootDir / "src" / "test" / "resources"
+    val mavenTargetDirectory = projectRootDir / "target"
+    val mavenBinariesDirectory = mavenTargetDirectory / "test-classes"
+
+    val dataDirectory = mavenResourcesDirectory / "data"
+    val bodiesDirectory = mavenResourcesDirectory / "bodies"
+
+    val recorderOutputDirectory = mavenSourcesDirectory
+    val resultsDirectory = mavenTargetDirectory / "gatling"
+
+    val recorderConfigFile = mavenResourcesDirectory / "recorder.conf"
+}

gatling/src/test/scala/Recorder.scala

@@ -0,0 +1,12 @@
+import io.gatling.recorder.GatlingRecorder
+import io.gatling.recorder.config.RecorderPropertiesBuilder
+
+object Recorder extends App {
+
+    val props = new RecorderPropertiesBuilder
+    props.simulationOutputFolder(IDEPathHelper.recorderOutputDirectory.toString)
+    props.simulationPackage("org.baeldung")
+    props.bodiesFolder(IDEPathHelper.bodiesDirectory.toString)
+
+    GatlingRecorder.fromMap(props.build, Some(IDEPathHelper.recorderConfigFile))
+}

gatling/src/test/scala/org/baeldung/RecordedSimulation.scala

@@ -0,0 +1,46 @@
+package org.baeldung
+
+import scala.concurrent.duration._
+
+import io.gatling.core.Predef._
+import io.gatling.http.Predef._
+import io.gatling.jdbc.Predef._
+
+class RecordedSimulation extends Simulation {
+
+    val httpProtocol = http
+        .baseURL("http://computer-database.gatling.io")
+        .inferHtmlResources(BlackList(""".*\.css""", """.*\.js""", """.*\.ico"""), WhiteList())
+        .acceptHeader("text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8")
+        .acceptEncodingHeader("gzip, deflate")
+        .acceptLanguageHeader("it-IT,it;q=0.8,en-US;q=0.5,en;q=0.3")
+        .userAgentHeader("Mozilla/5.0 (Windows NT 10.0; WOW64; rv:46.0) Gecko/20100101 Firefox/46.0")
+
+
+
+
+
+    val scn = scenario("RecordedSimulation")
+        .exec(http("request_0")
+            .get("/"))
+        .pause(5)
+        .exec(http("request_1")
+            .get("/computers?f=amstrad"))
+        .pause(4)
+        .exec(http("request_2")
+            .get("/computers/412"))
+        .pause(2)
+        .exec(http("request_3")
+            .get("/"))
+        .pause(2)
+        .exec(http("request_4")
+            .get("/computers?p=1"))
+        .pause(1)
+        .exec(http("request_5")
+            .get("/computers?p=2"))
+        .pause(2)
+        .exec(http("request_6")
+            .get("/computers?p=3"))
+
+    setUp(scn.inject(atOnceUsers(1))).protocols(httpProtocol)
+}

guava/src/test/java/org/baeldung/guava/GuavaMapFromSet.java

@@ -0,0 +1,101 @@
+package org.baeldung.guava;
+
+import java.util.AbstractMap;
+import java.util.AbstractSet;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Set;
+import java.util.WeakHashMap;
+
+import com.google.common.base.Function;
+
+public class GuavaMapFromSet<K, V> extends AbstractMap<K, V> {
+
+	private class SingleEntry implements Entry<K, V> {
+		private  K key;
+
+		public SingleEntry( K key) {
+			this.key = key;
+		}
+
+		@Override
+		public K getKey() {
+			return this.key;
+		}
+
+		@Override
+		public V getValue() {
+			V value = GuavaMapFromSet.this.cache.get(this.key);
+			if (value == null) {
+				value = GuavaMapFromSet.this.function.apply(this.key);
+				GuavaMapFromSet.this.cache.put(this.key, value);
+			}
+			return value;
+		}
+
+		@Override
+		public V setValue( V value) {
+			throw new UnsupportedOperationException();
+		}
+	}
+
+	private class MyEntrySet extends AbstractSet<Entry<K, V>> {
+
+		public class EntryIterator implements Iterator<Entry<K, V>> {
+			private  Iterator<K> inner;
+
+			public EntryIterator() {
+				this.inner = MyEntrySet.this.keys.iterator();
+			}
+
+			@Override
+			public boolean hasNext() {
+				return this.inner.hasNext();
+			}
+
+			@Override
+			public Map.Entry<K, V> next() {
+				 K key = this.inner.next();
+				return new SingleEntry(key);
+			}
+
+			@Override
+			public void remove() {
+				throw new UnsupportedOperationException();
+			}
+		}
+
+		private  Set<K> keys;
+
+		public MyEntrySet( Set<K> keys) {
+			this.keys = keys;
+		}
+
+		@Override
+		public Iterator<Map.Entry<K, V>> iterator() {
+			return new EntryIterator();
+		}
+
+		@Override
+		public int size() {
+			return this.keys.size();
+		}
+
+	}
+
+	private  WeakHashMap<K, V> cache;
+	private  Set<Entry<K, V>> entries;
+	private  Function<? super K, ? extends V> function;
+
+	public GuavaMapFromSet( Set<K> keys, Function<? super K, ? extends V> function) {
+		this.function = function;
+		this.cache = new WeakHashMap<K, V>();
+		this.entries = new MyEntrySet(keys);
+	}
+
+	@Override
+	public Set<Map.Entry<K, V>> entrySet() {
+		return this.entries;
+	}
+
+}

guava/src/test/java/org/baeldung/guava/GuavaMapFromSetTests.java

@@ -0,0 +1,66 @@
+package org.baeldung.guava;
+
+import static org.junit.Assert.assertTrue;
+
+import java.util.Arrays;
+import java.util.Map;
+import java.util.Set;
+import java.util.TreeSet;
+
+import org.junit.Test;
+
+import com.google.common.base.Function;
+
+public class GuavaMapFromSetTests {
+
+	@Test
+	public void givenStringSet_whenMapsToElementLength_thenCorrect() {
+		Function<Integer, String> function = new Function<Integer, String>() {
+
+			@Override
+			public String apply(Integer from) {
+				return Integer.toBinaryString(from.intValue());
+			}
+		};
+		Set<Integer> set = (Set<Integer>) new TreeSet<Integer>(Arrays.asList(
+				32, 64, 128));
+		Map<Integer, String> map = new GuavaMapFromSet<Integer, String>(set,
+				function);
+		assertTrue(map.get(32).equals("100000")
+				&& map.get(64).equals("1000000")
+				&& map.get(128).equals("10000000"));
+	}
+
+	@Test
+	public void givenIntSet_whenMapsToElementBinaryValue_thenCorrect() {
+		Function<String, Integer> function = new Function<String, Integer>() {
+
+			@Override
+			public Integer apply(String from) {
+				return from.length();
+			}
+		};
+		Set<String> set = (Set<String>) new TreeSet<String>(Arrays.asList(
+				"four", "three", "twelve"));
+		Map<String, Integer> map = new GuavaMapFromSet<String, Integer>(set,
+				function);
+		assertTrue(map.get("four") == 4 && map.get("three") == 5
+				&& map.get("twelve") == 6);
+	}
+	@Test
+	public void givenSet_whenNewSetElementAddedAndMappedLive_thenCorrect() {
+		Function<String, Integer> function = new Function<String, Integer>() {
+
+			@Override
+			public Integer apply(String from) {
+				return from.length();
+			}
+		};
+		Set<String> set = (Set<String>) new TreeSet<String>(Arrays.asList(
+				"four", "three", "twelve"));
+		Map<String, Integer> map = new GuavaMapFromSet<String, Integer>(set,
+				function);
+		set.add("one");
+		assertTrue(map.get("one") == 3 && map.size()==4);
+	}
+}

httpclient/.settings/org.eclipse.jdt.ui.prefs

@@ -1,55 +0,0 @@
-#Sat Jan 21 23:04:06 EET 2012
-eclipse.preferences.version=1
-editor_save_participant_org.eclipse.jdt.ui.postsavelistener.cleanup=true
-sp_cleanup.add_default_serial_version_id=true
-sp_cleanup.add_generated_serial_version_id=false
-sp_cleanup.add_missing_annotations=true
-sp_cleanup.add_missing_deprecated_annotations=true
-sp_cleanup.add_missing_methods=false
-sp_cleanup.add_missing_nls_tags=false
-sp_cleanup.add_missing_override_annotations=true
-sp_cleanup.add_missing_override_annotations_interface_methods=true
-sp_cleanup.add_serial_version_id=false
-sp_cleanup.always_use_blocks=true
-sp_cleanup.always_use_parentheses_in_expressions=true
-sp_cleanup.always_use_this_for_non_static_field_access=false
-sp_cleanup.always_use_this_for_non_static_method_access=false
-sp_cleanup.convert_to_enhanced_for_loop=true
-sp_cleanup.correct_indentation=true
-sp_cleanup.format_source_code=true
-sp_cleanup.format_source_code_changes_only=true
-sp_cleanup.make_local_variable_final=true
-sp_cleanup.make_parameters_final=true
-sp_cleanup.make_private_fields_final=false
-sp_cleanup.make_type_abstract_if_missing_method=false
-sp_cleanup.make_variable_declarations_final=true
-sp_cleanup.never_use_blocks=false
-sp_cleanup.never_use_parentheses_in_expressions=false
-sp_cleanup.on_save_use_additional_actions=true
-sp_cleanup.organize_imports=true
-sp_cleanup.qualify_static_field_accesses_with_declaring_class=false
-sp_cleanup.qualify_static_member_accesses_through_instances_with_declaring_class=true
-sp_cleanup.qualify_static_member_accesses_through_subtypes_with_declaring_class=true
-sp_cleanup.qualify_static_member_accesses_with_declaring_class=true
-sp_cleanup.qualify_static_method_accesses_with_declaring_class=false
-sp_cleanup.remove_private_constructors=true
-sp_cleanup.remove_trailing_whitespaces=true
-sp_cleanup.remove_trailing_whitespaces_all=true
-sp_cleanup.remove_trailing_whitespaces_ignore_empty=false
-sp_cleanup.remove_unnecessary_casts=true
-sp_cleanup.remove_unnecessary_nls_tags=false
-sp_cleanup.remove_unused_imports=true
-sp_cleanup.remove_unused_local_variables=false
-sp_cleanup.remove_unused_private_fields=true
-sp_cleanup.remove_unused_private_members=false
-sp_cleanup.remove_unused_private_methods=true
-sp_cleanup.remove_unused_private_types=true
-sp_cleanup.sort_members=false
-sp_cleanup.sort_members_all=false
-sp_cleanup.use_blocks=false
-sp_cleanup.use_blocks_only_for_return_and_throw=false
-sp_cleanup.use_parentheses_in_expressions=false
-sp_cleanup.use_this_for_non_static_field_access=true
-sp_cleanup.use_this_for_non_static_field_access_only_if_necessary=true
-sp_cleanup.use_this_for_non_static_method_access=true
-sp_cleanup.use_this_for_non_static_method_access_only_if_necessary=true

httpclient/README.md

@@ -1,7 +1,9 @@
 =========
-
 ## HttpClient 4.x Cookbooks and Examples
 
+###The Course
+The "REST With Spring" Classes: http://bit.ly/restwithspring
+
 
 ### Relevant Articles: 
 

httpclient/src/test/java/org/baeldung/httpclient/SandboxTest.java

@@ -0,0 +1,188 @@
+package org.baeldung.httpclient;
+
+import static org.junit.Assert.assertEquals;
+
+import java.io.IOException;
+
+import org.apache.http.Header;
+import org.apache.http.HttpHost;
+import org.apache.http.HttpResponse;
+import org.apache.http.auth.AuthScope;
+import org.apache.http.auth.AuthenticationException;
+import org.apache.http.auth.MalformedChallengeException;
+import org.apache.http.auth.UsernamePasswordCredentials;
+import org.apache.http.client.AuthCache;
+import org.apache.http.client.ClientProtocolException;
+import org.apache.http.client.CookieStore;
+import org.apache.http.client.CredentialsProvider;
+import org.apache.http.client.methods.CloseableHttpResponse;
+import org.apache.http.client.methods.HttpGet;
+import org.apache.http.client.protocol.HttpClientContext;
+import org.apache.http.impl.auth.DigestScheme;
+import org.apache.http.impl.client.BasicAuthCache;
+import org.apache.http.impl.client.BasicCookieStore;
+import org.apache.http.impl.client.BasicCredentialsProvider;
+import org.apache.http.impl.client.CloseableHttpClient;
+import org.apache.http.impl.client.HttpClients;
+import org.apache.http.impl.cookie.BasicClientCookie;
+import org.apache.http.util.EntityUtils;
+import org.junit.Ignore;
+import org.junit.Test;
+
+public class SandboxTest {
+
+    // original example
+    @Ignore
+    @Test
+    public final void whenInterestingDigestAuthScenario_then401UnAuthorized() throws AuthenticationException, ClientProtocolException, IOException, MalformedChallengeException {
+        final HttpHost targetHost = new HttpHost("httpbin.org", 80, "http");
+
+        // set up the credentials to run agains the server
+        final CredentialsProvider credsProvider = new BasicCredentialsProvider();
+        credsProvider.setCredentials(new AuthScope(targetHost.getHostName(), targetHost.getPort()), new UsernamePasswordCredentials("user", "passwd"));
+
+        // We need a first run to get a 401 to seed the digest auth
+
+        // Make a client using those creds
+        final CloseableHttpClient client = HttpClients.custom().setDefaultCredentialsProvider(credsProvider).build();
+
+        // And make a call to the URL we are after
+        final HttpGet httpget = new HttpGet("http://httpbin.org/digest-auth/auth/user/passwd");
+
+        // Create a context to use
+        final HttpClientContext context = HttpClientContext.create();
+
+        // Get a response from the sever (expect a 401!)
+        final HttpResponse authResponse = client.execute(targetHost, httpget, context);
+
+        // Pull out the auth header that came back from the server
+        final Header challenge = authResponse.getHeaders("WWW-Authenticate")[0];
+
+        // Lets use a digest scheme to solve it
+        final DigestScheme digest = new DigestScheme();
+        digest.processChallenge(challenge);
+
+        // Make a header with the solution based upon user/password and what the digest got out of the initial 401 reponse
+        final Header solution = digest.authenticate(new UsernamePasswordCredentials("user", "passwd"), httpget, context);
+
+        // Need an auth cache to use the new digest we made
+        final AuthCache authCache = new BasicAuthCache();
+        authCache.put(targetHost, digest);
+
+        // Add the authCache and thus solved digest to the context
+        context.setAuthCache(authCache);
+
+        // Pimp up our http get with the solved header made by the digest
+        httpget.addHeader(solution);
+
+        // use it!
+        System.out.println("Executing request " + httpget.getRequestLine() + " to target " + targetHost);
+
+        for (int i = 0; i < 3; i++) {
+            final CloseableHttpResponse responseGood = client.execute(targetHost, httpget, context);
+
+            try {
+                System.out.println("----------------------------------------");
+                System.out.println(responseGood.getStatusLine());
+                System.out.println(EntityUtils.toString(responseGood.getEntity()));
+            } finally {
+                responseGood.close();
+            }
+        }
+    }
+
+    @Test
+    public final void whenInterestingDigestAuthScenario_then200OK() throws AuthenticationException, ClientProtocolException, IOException, MalformedChallengeException {
+        final HttpHost targetHost = new HttpHost("httpbin.org", 80, "http");
+
+        // set up the credentials to run agains the server
+        final CredentialsProvider credsProvider = new BasicCredentialsProvider();
+        credsProvider.setCredentials(new AuthScope(targetHost.getHostName(), targetHost.getPort()), new UsernamePasswordCredentials("user", "passwd"));
+
+        // This endpoint need fake cookie to work properly
+        final CookieStore cookieStore = new BasicCookieStore();
+        final BasicClientCookie cookie = new BasicClientCookie("fake", "fake_value");
+        cookie.setDomain("httpbin.org");
+        cookie.setPath("/");
+        cookieStore.addCookie(cookie);
+
+        // Make a client using those creds
+        final CloseableHttpClient client = HttpClients.custom().setDefaultCookieStore(cookieStore).setDefaultCredentialsProvider(credsProvider).build();
+        
+        // And make a call to the URL we are after
+        final HttpGet httpget = new HttpGet("http://httpbin.org/digest-auth/auth/user/passwd");
+
+        // Create a context to use
+        final HttpClientContext context = HttpClientContext.create();
+
+        // Get a response from the sever (401 implicitly)
+        final HttpResponse authResponse = client.execute(targetHost, httpget, context);
+        assertEquals(200, authResponse.getStatusLine().getStatusCode());
+
+        // HttpClient will use cached digest parameters for future requests
+        System.out.println("Executing request " + httpget.getRequestLine() + " to target " + targetHost);
+
+        for (int i = 0; i < 3; i++) {
+            final CloseableHttpResponse responseGood = client.execute(targetHost, httpget, context);
+
+            try {
+                System.out.println("----------------------------------------");
+                System.out.println(responseGood.getStatusLine());
+                assertEquals(200, responseGood.getStatusLine().getStatusCode());
+            } finally {
+                responseGood.close();
+            }
+        }
+        client.close();
+    }
+
+    // This test needs module spring-security-rest-digest-auth to be running
+    @Test
+    public final void whenWeKnowDigestParameters_thenNo401Status() throws AuthenticationException, ClientProtocolException, IOException, MalformedChallengeException {
+        final HttpHost targetHost = new HttpHost("localhost", 8080, "http");
+
+        final CredentialsProvider credsProvider = new BasicCredentialsProvider();
+        credsProvider.setCredentials(AuthScope.ANY, new UsernamePasswordCredentials("user1", "user1Pass"));
+
+        final CloseableHttpClient client = HttpClients.custom().setDefaultCredentialsProvider(credsProvider).build();
+
+        final HttpGet httpget = new HttpGet("http://localhost:8080/spring-security-rest-digest-auth/api/foos/1");
+
+        final HttpClientContext context = HttpClientContext.create();
+        // == make it preemptive
+        final AuthCache authCache = new BasicAuthCache();
+        final DigestScheme digestAuth = new DigestScheme();
+        digestAuth.overrideParamter("realm", "Custom Realm Name");
+        digestAuth.overrideParamter("nonce", "nonce value goes here");
+        authCache.put(targetHost, digestAuth);
+        context.setAuthCache(authCache);
+        // == end
+        System.out.println("Executing The Request knowing the digest parameters ==== ");
+        final HttpResponse authResponse = client.execute(targetHost, httpget, context);
+        assertEquals(200, authResponse.getStatusLine().getStatusCode());
+        client.close();
+    }
+
+    // This test needs module spring-security-rest-digest-auth to be running
+    @Test
+    public final void whenDoNotKnowParameters_thenOnlyOne401() throws AuthenticationException, ClientProtocolException, IOException, MalformedChallengeException {
+        final HttpClientContext context = HttpClientContext.create();
+        final HttpHost targetHost = new HttpHost("localhost", 8080, "http");
+        final CredentialsProvider credsProvider = new BasicCredentialsProvider();
+        credsProvider.setCredentials(AuthScope.ANY, new UsernamePasswordCredentials("user1", "user1Pass"));
+        final CloseableHttpClient client = HttpClients.custom().setDefaultCredentialsProvider(credsProvider).build();
+
+        final HttpGet httpget = new HttpGet("http://localhost:8080/spring-security-rest-digest-auth/api/foos/1");
+        System.out.println("Executing The Request NOT knowing the digest parameters ==== ");
+        final HttpResponse tempResponse = client.execute(targetHost, httpget, context);
+        assertEquals(200, tempResponse.getStatusLine().getStatusCode());
+
+        for (int i = 0; i < 3; i++) {
+            System.out.println("No more Challenges or 401");
+            final CloseableHttpResponse authResponse = client.execute(targetHost, httpget, context);
+            assertEquals(200, authResponse.getStatusLine().getStatusCode());
+            authResponse.close();
+        }
+        client.close();
+    }
+}

jackson/README.md

@@ -2,6 +2,9 @@
 
 ## Jackson Cookbooks and Examples
 
+###The Course
+The "REST With Spring" Classes: http://bit.ly/restwithspring
+
 ### Relevant Articles: 
 - [Jackson Ignore Properties on Marshalling](http://www.baeldung.com/jackson-ignore-properties-on-serialization)
 - [Jackson – Unmarshall to Collection/Array](http://www.baeldung.com/jackson-collection-array)

jee7schedule/pom.xml

@@ -0,0 +1,311 @@
+<?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>jee7schedule</artifactId>
+   <version>1.0-SNAPSHOT</version>
+   <description>JavaEE 7 Arquillian Archetype Sample</description>
+   <packaging>war</packaging>
+
+   <properties>
+      <java.min.version>1.7</java.min.version>
+      <maven.min.version>3.0.0</maven.min.version>
+
+      <version.junit>4.11</version.junit>
+      <version.javaee_api>7.0</version.javaee_api>
+
+      <version.arquillian_core>1.1.4.Final</version.arquillian_core>
+
+      <version.wildfly>8.0.0.Final</version.wildfly>
+   </properties>
+
+   <prerequisites>
+      <maven>${maven.min.version}</maven>
+   </prerequisites>
+
+   <dependencyManagement>
+      <dependencies>
+         <dependency>
+            <groupId>org.jboss.arquillian</groupId>
+            <artifactId>arquillian-bom</artifactId>
+            <version>${version.arquillian_core}</version>
+            <scope>import</scope>
+            <type>pom</type>
+         </dependency>
+      </dependencies>
+   </dependencyManagement>
+
+   <dependencies>
+      <dependency>
+         <groupId>javax</groupId>
+         <artifactId>javaee-api</artifactId>
+         <version>${version.javaee_api}</version>
+         <scope>provided</scope>
+      </dependency>
+
+      <dependency>
+         <groupId>junit</groupId>
+         <artifactId>junit</artifactId>
+         <version>${version.junit}</version>
+         <scope>test</scope>
+      </dependency>
+      <dependency>
+         <groupId>org.jboss.arquillian.junit</groupId>
+         <artifactId>arquillian-junit-container</artifactId>
+         <scope>test</scope>
+      </dependency>
+      <dependency>
+         <groupId>com.jayway.awaitility</groupId>
+         <artifactId>awaitility</artifactId>
+         <version>1.6.0</version>
+         <scope>test</scope>
+      </dependency>
+
+      <dependency>
+         <groupId>org.jboss.shrinkwrap.resolver</groupId>
+         <artifactId>shrinkwrap-resolver-impl-maven</artifactId>
+         <scope>test</scope>
+         <type>jar</type>
+      </dependency>
+
+      <dependency>
+         <groupId>org.jboss.shrinkwrap.resolver</groupId>
+         <artifactId>shrinkwrap-resolver-impl-maven-archive</artifactId>
+         <scope>test</scope>
+      </dependency>
+
+   </dependencies>
+
+   <build>
+      <plugins>
+         <plugin>
+            <groupId>org.apache.maven.plugins</groupId>
+            <artifactId>maven-compiler-plugin</artifactId>
+            <version>3.1</version>
+            <configuration>
+               <source>${java.min.version}</source>
+               <target>${java.min.version}</target>
+            </configuration>
+         </plugin>
+         <plugin>
+            <groupId>org.apache.maven.plugins</groupId>
+            <artifactId>maven-war-plugin</artifactId>
+            <version>2.1.1</version>
+            <configuration>
+               <failOnMissingWebXml>false</failOnMissingWebXml>
+            </configuration>
+         </plugin>
+      </plugins>
+   </build>
+
+   <profiles>
+
+      <profile>
+         <id>wildfly-managed-arquillian</id>
+         <activation>
+            <activeByDefault>true</activeByDefault>
+         </activation>
+         <properties>
+            <serverProfile>standalone-full.xml</serverProfile>
+            <serverRoot>${project.build.directory}/wildfly-${version.wildfly}</serverRoot>
+         </properties>
+         <dependencies>
+            <dependency>
+               <groupId>io.undertow</groupId>
+               <artifactId>undertow-websockets-jsr</artifactId>
+               <version>1.0.0.Beta25</version>
+               <scope>test</scope>
+            </dependency>
+            <dependency>
+               <groupId>org.jboss.resteasy</groupId>
+               <artifactId>resteasy-client</artifactId>
+               <version>3.0.5.Final</version>
+               <scope>test</scope>
+            </dependency>
+            <dependency>
+               <groupId>org.jboss.resteasy</groupId>
+               <artifactId>resteasy-jaxb-provider</artifactId>
+               <version>3.0.5.Final</version>
+               <scope>test</scope>
+            </dependency>
+            <dependency>
+               <groupId>org.jboss.resteasy</groupId>
+               <artifactId>resteasy-json-p-provider</artifactId>
+               <version>3.0.5.Final</version>
+               <scope>test</scope>
+            </dependency>
+            <dependency>
+               <groupId>org.wildfly</groupId>
+               <artifactId>wildfly-arquillian-container-managed</artifactId>
+               <version>${version.wildfly}</version>
+               <scope>test</scope>
+            </dependency>
+         </dependencies>
+         <build>
+            <plugins>
+               <plugin>
+                  <artifactId>maven-dependency-plugin</artifactId>
+                  <version>2.8</version>
+                  <configuration>
+                     <skip>${maven.test.skip}</skip>
+                  </configuration>
+                  <executions>
+                     <execution>
+                        <id>unpack</id>
+                        <phase>process-test-classes</phase>
+                        <goals>
+                           <goal>unpack</goal>
+                        </goals>
+                        <configuration>
+                           <artifactItems>
+                              <artifactItem>
+                                 <groupId>org.wildfly</groupId>
+                                 <artifactId>wildfly-dist</artifactId>
+                                 <version>${version.wildfly}</version>
+                                 <type>zip</type>
+                                 <overWrite>false</overWrite>
+                                 <outputDirectory>${project.build.directory}</outputDirectory>
+                              </artifactItem>
+                           </artifactItems>
+                        </configuration>
+                     </execution>
+                  </executions>
+               </plugin>
+               <plugin>
+                  <artifactId>maven-surefire-plugin</artifactId>
+                  <version>2.17</version>
+                  <configuration>
+                     <environmentVariables>
+                        <JBOSS_HOME>${project.build.directory}/wildfly-${version.wildfly}</JBOSS_HOME>
+                     </environmentVariables>
+                  </configuration>
+               </plugin>
+            </plugins>
+         </build>
+      </profile>
+      <profile>
+         <id>wildfly-remote-arquillian</id>
+         <dependencies>
+            <dependency>
+               <groupId>io.undertow</groupId>
+               <artifactId>undertow-websockets-jsr</artifactId>
+               <version>1.0.0.Beta25</version>
+               <scope>test</scope>
+            </dependency>
+            <dependency>
+               <groupId>org.jboss.resteasy</groupId>
+               <artifactId>resteasy-client</artifactId>
+               <version>3.0.5.Final</version>
+               <scope>test</scope>
+            </dependency>
+            <dependency>
+               <groupId>org.jboss.resteasy</groupId>
+               <artifactId>resteasy-jaxb-provider</artifactId>
+               <version>3.0.5.Final</version>
+               <scope>test</scope>
+            </dependency>
+            <dependency>
+               <groupId>org.jboss.resteasy</groupId>
+               <artifactId>resteasy-json-p-provider</artifactId>
+               <version>3.0.5.Final</version>
+               <scope>test</scope>
+            </dependency>
+            <dependency>
+               <groupId>org.wildfly</groupId>
+               <artifactId>wildfly-arquillian-container-remote</artifactId>
+               <version>${version.wildfly}</version>
+               <scope>test</scope>
+            </dependency>
+         </dependencies>
+      </profile>
+      <profile>
+         <id>glassfish-embedded-arquillian</id>
+         <dependencies>
+            <dependency>
+               <groupId>org.glassfish.main.extras</groupId>
+               <artifactId>glassfish-embedded-all</artifactId>
+               <version>4.0</version>
+               <scope>test</scope>
+            </dependency>
+            <dependency>
+               <groupId>org.glassfish</groupId>
+               <artifactId>javax.json</artifactId>
+               <version>1.0.4</version>
+               <scope>test</scope>
+            </dependency>
+            <dependency>
+               <groupId>org.glassfish.tyrus</groupId>
+               <artifactId>tyrus-client</artifactId>
+               <version>1.3</version>
+               <scope>test</scope>
+            </dependency>
+            <dependency>
+               <groupId>org.glassfish.tyrus</groupId>
+               <artifactId>tyrus-container-grizzly-client</artifactId>
+               <version>1.3</version>
+               <scope>test</scope>
+            </dependency>
+            <dependency>
+               <groupId>org.glassfish.jersey.core</groupId>
+               <artifactId>jersey-client</artifactId>
+               <version>2.4</version>
+               <scope>test</scope>
+            </dependency>
+            <dependency>
+               <groupId>org.jboss.arquillian.container</groupId>
+               <artifactId>arquillian-glassfish-embedded-3.1</artifactId>
+               <version>1.0.0.CR4</version>
+               <scope>test</scope>
+            </dependency>
+         </dependencies>
+      </profile>
+      <profile>
+         <id>glassfish-remote-arquillian</id>
+         <dependencies>
+            <dependency>
+               <groupId>org.glassfish</groupId>
+               <artifactId>javax.json</artifactId>
+               <version>1.0.4</version>
+               <scope>test</scope>
+            </dependency>
+            <dependency>
+               <groupId>org.glassfish.tyrus</groupId>
+               <artifactId>tyrus-client</artifactId>
+               <version>1.3</version>
+               <scope>test</scope>
+            </dependency>
+            <dependency>
+               <groupId>org.glassfish.tyrus</groupId>
+               <artifactId>tyrus-container-grizzly-client</artifactId>
+               <version>1.3</version>
+               <scope>test</scope>
+            </dependency>
+            <dependency>
+               <groupId>org.glassfish.jersey.core</groupId>
+               <artifactId>jersey-client</artifactId>
+               <version>2.4</version>
+               <scope>test</scope>
+            </dependency>
+            <dependency>
+               <groupId>org.glassfish.jersey.media</groupId>
+               <artifactId>jersey-media-json-jackson</artifactId>
+               <version>2.4</version>
+               <scope>test</scope>
+            </dependency>
+            <dependency>
+               <groupId>org.glassfish.jersey.media</groupId>
+               <artifactId>jersey-media-json-processing</artifactId>
+               <version>2.4</version>
+               <scope>test</scope>
+            </dependency>
+            <dependency>
+               <groupId>org.jboss.arquillian.container</groupId>
+               <artifactId>arquillian-glassfish-remote-3.1</artifactId>
+               <version>1.0.0.CR4</version>
+               <scope>test</scope>
+            </dependency>
+         </dependencies>
+      </profile>
+   </profiles>
+</project>

jee7schedule/src/main/java/com/baeldung/timer/AutomaticTimerBean.java

@@ -0,0 +1,27 @@
+package com.baeldung.timer;
+
+import javax.ejb.Schedule;
+import javax.ejb.Singleton;
+import javax.ejb.Startup;
+import javax.enterprise.event.Event;
+import javax.inject.Inject;
+import java.util.Date;
+
+
+@Startup
+@Singleton
+public class AutomaticTimerBean {
+
+
+    @Inject
+    Event<TimerEvent> event;
+
+    /**
+     * This method will be called every 10 second and will fire an @TimerEvent
+     */
+    @Schedule(hour = "*", minute = "*", second = "*/10", info = "Every 10 second timer")
+    public void printDate() {
+        event.fire(new TimerEvent("TimerEvent sent at :" + new Date()));
+    }
+
+}

jee7schedule/src/main/java/com/baeldung/timer/FixedDelayTimerBean.java

@@ -0,0 +1,20 @@
+package com.baeldung.timer;
+
+import javax.ejb.*;
+
+/**
+ * Created by  ccristianchiovari on 5/2/16.
+ */
+@Singleton
+public class FixedDelayTimerBean {
+
+    @EJB
+    private WorkerBean workerBean;
+
+    @Lock(LockType.READ)
+    @Schedule(second = "*/5", minute = "*", hour = "*", persistent = false)
+    public void atSchedule() throws InterruptedException {
+        workerBean.doTimerWork();
+    }
+
+}

jee7schedule/src/main/java/com/baeldung/timer/ProgrammaticAtFixedRateTimerBean.java

@@ -0,0 +1,31 @@
+package com.baeldung.timer;
+
+import javax.annotation.PostConstruct;
+import javax.annotation.Resource;
+import javax.ejb.*;
+import javax.enterprise.event.Event;
+import javax.inject.Inject;
+
+/**
+ * author: Cristian Chiovari
+ */
+@Startup
+@Singleton
+public class ProgrammaticAtFixedRateTimerBean {
+
+    @Inject
+    Event<TimerEvent> event;
+
+    @Resource
+    TimerService timerService;
+
+    @PostConstruct
+    public void initialize() {
+        timerService.createTimer(0,1000, "Every second timer");
+    }
+
+    @Timeout
+    public void programmaticTimout(Timer timer) {
+        event.fire(new TimerEvent(timer.getInfo().toString()));
+    }
+}

jee7schedule/src/main/java/com/baeldung/timer/ProgrammaticTimerBean.java

@@ -0,0 +1,39 @@
+package com.baeldung.timer;
+
+import javax.annotation.PostConstruct;
+import javax.annotation.Resource;
+import javax.ejb.*;
+import javax.enterprise.event.Event;
+import javax.inject.Inject;
+
+/**
+ * author: Jacek Jackowiak
+ */
+@Startup
+@Singleton
+public class ProgrammaticTimerBean {
+
+    @Inject
+    Event<TimerEvent> event;
+
+    @Resource
+    TimerService timerService;
+
+    @PostConstruct
+    public void initialize() {
+        ScheduleExpression scheduleExpression = new ScheduleExpression()
+                .hour("*")
+                .minute("*")
+                .second("*/5");
+
+        TimerConfig timerConfig = new TimerConfig();
+        timerConfig.setInfo("Every 5 second timer");
+
+        timerService.createCalendarTimer(scheduleExpression, timerConfig);
+    }
+
+    @Timeout
+    public void programmaticTimout(Timer timer) {
+        event.fire(new TimerEvent(timer.getInfo().toString()));
+    }
+}

jee7schedule/src/main/java/com/baeldung/timer/ProgrammaticWithInitialFixedDelayTimerBean.java

@@ -0,0 +1,31 @@
+package com.baeldung.timer;
+
+import javax.annotation.PostConstruct;
+import javax.annotation.Resource;
+import javax.ejb.*;
+import javax.enterprise.event.Event;
+import javax.inject.Inject;
+
+/**
+ * author: Cristian Chiovari
+ */
+@Startup
+@Singleton
+public class ProgrammaticWithInitialFixedDelayTimerBean {
+
+    @Inject
+    Event<TimerEvent> event;
+
+    @Resource
+    TimerService timerService;
+
+    @PostConstruct
+    public void initialize() {
+        timerService.createTimer(10000l,5000l, "Delay 10 seconds then every 5 second timer");
+    }
+
+    @Timeout
+    public void programmaticTimout(Timer timer) {
+        event.fire(new TimerEvent(timer.getInfo().toString()));
+    }
+}

jee7schedule/src/main/java/com/baeldung/timer/ScheduleTimerBean.java

@@ -0,0 +1,27 @@
+package com.baeldung.timer;
+
+import javax.ejb.Schedule;
+import javax.ejb.Singleton;
+import javax.ejb.Startup;
+import javax.ejb.Timer;
+import javax.enterprise.event.Event;
+import javax.inject.Inject;
+
+
+@Startup
+@Singleton
+public class ScheduleTimerBean {
+
+    @Inject
+    Event<TimerEvent> event;
+
+    @Schedule(hour = "*", minute = "*", second = "*/5", info = "Every 5 second timer")
+    public void automaticallyScheduled(Timer timer) {
+        fireEvent(timer);
+    }
+
+
+    private void fireEvent(Timer timer) {
+        event.fire(new TimerEvent(timer.getInfo().toString()));
+    }
+}

jee7schedule/src/main/java/com/baeldung/timer/TimerEvent.java

@@ -0,0 +1,27 @@
+package com.baeldung.timer;
+
+public class TimerEvent {
+
+    private String eventInfo;
+    private long time = System.currentTimeMillis();
+
+    public TimerEvent(String s) {
+        this.eventInfo = s;
+    }
+
+    public long getTime() {
+        return time;
+    }
+
+    public String getEventInfo() {
+        return eventInfo;
+    }
+
+    @Override
+    public String toString() {
+        return "TimerEvent {" +
+            "eventInfo='" + eventInfo + '\'' +
+            ", time=" + time +
+            '}';
+    }
+}

jee7schedule/src/main/java/com/baeldung/timer/TimerEventListener.java

@@ -0,0 +1,26 @@
+package com.baeldung.timer;
+
+import javax.ejb.Singleton;
+import javax.ejb.Startup;
+import javax.enterprise.event.Observes;
+import java.util.List;
+import java.util.concurrent.CopyOnWriteArrayList;
+
+/**
+ * This class will listen to all TimerEvent and will collect them
+ */
+@Startup
+@Singleton
+public class TimerEventListener {
+
+    final List<TimerEvent> events = new CopyOnWriteArrayList<>();
+
+    public void listen(@Observes TimerEvent event) {
+        System.out.println("event = " + event);
+        events.add(event);
+    }
+
+    public List<TimerEvent> getEvents() {
+        return events;
+    }
+}

jee7schedule/src/main/java/com/baeldung/timer/WorkerBean.java

@@ -0,0 +1,33 @@
+package com.baeldung.timer;
+
+import javax.ejb.Lock;
+import javax.ejb.LockType;
+import javax.ejb.Singleton;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+/**
+ * Created by cristianchiovari on 5/2/16.
+ */
+@Singleton
+public class WorkerBean {
+
+    private AtomicBoolean busy = new AtomicBoolean(false);
+
+    @Lock(LockType.READ)
+    public void doTimerWork() throws InterruptedException {
+
+        System.out.println("Timer method called but not started yet !");
+
+        if (!busy.compareAndSet(false, true)) {
+            return;
+        }
+
+        try {
+            System.out.println("Timer work started");
+            Thread.sleep(12000);
+            System.out.println("Timer work done");
+        } finally {
+            busy.set(false);
+        }
+    }
+}

jee7schedule/src/test/java/com/baeldung/timer/AutomaticTimerBeanTest.java

@@ -0,0 +1,66 @@
+package com.baeldung.timer;
+
+import com.jayway.awaitility.Awaitility;
+import org.hamcrest.Matchers;
+import org.jboss.arquillian.container.test.api.Deployment;
+import org.jboss.arquillian.junit.Arquillian;
+import org.jboss.shrinkwrap.api.ShrinkWrap;
+import org.jboss.shrinkwrap.api.spec.WebArchive;
+import org.jboss.shrinkwrap.resolver.api.maven.Maven;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import javax.inject.Inject;
+import java.io.File;
+import java.util.concurrent.TimeUnit;
+
+import static com.jayway.awaitility.Awaitility.await;
+import static com.jayway.awaitility.Awaitility.to;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.equalTo;
+
+
+@RunWith(Arquillian.class)
+public class AutomaticTimerBeanTest {
+
+    //the @AutomaticTimerBean has a method called every 10 seconds
+    //testing the difference ==> 100000
+    final static long TIMEOUT = 10000l;
+
+    //the tolerance accepted , so if between two consecutive calls there has to be at least 9 or max 11 seconds.
+    //because the timer service is not intended for real-time applications so it will not be exactly 10 seconds
+    final static long TOLERANCE = 1000l;
+
+    @Inject
+    TimerEventListener timerEventListener;
+
+    @Deployment
+    public static WebArchive deploy() {
+        File[] jars = Maven.resolver().loadPomFromFile("pom.xml")
+            .resolve("com.jayway.awaitility:awaitility")
+            .withTransitivity().asFile();
+
+        //only @AutomaticTimerBean is deployed not the other timers
+        return ShrinkWrap.create(WebArchive.class)
+            .addAsLibraries(jars)
+            .addClasses(WithinWindowMatcher.class, TimerEvent.class, TimerEventListener.class, AutomaticTimerBean.class);
+    }
+
+
+
+    @Test
+    public void should_receive_two_pings() {
+        Awaitility.setDefaultTimeout(30, TimeUnit.SECONDS);
+        //the test will wait here until two events are triggered
+        await().untilCall(to(timerEventListener.getEvents()).size(), equalTo(2));
+
+        TimerEvent firstEvent = timerEventListener.getEvents().get(0);
+        TimerEvent secondEvent = timerEventListener.getEvents().get(1);
+
+        long delay = secondEvent.getTime() - firstEvent.getTime();
+        System.out.println("Actual timeout = " + delay);
+
+        //ensure that the delay between the events is more or less 10 seconds (no real time precision)
+        assertThat(delay, Matchers.is(WithinWindowMatcher.withinWindow(TIMEOUT, TOLERANCE)));
+    }
+}

jee7schedule/src/test/java/com/baeldung/timer/ProgrammaticAtFixedRateTimerBeanTest.java

@@ -0,0 +1,56 @@
+package com.baeldung.timer;
+
+import com.jayway.awaitility.Awaitility;
+import org.jboss.arquillian.container.test.api.Deployment;
+import org.jboss.arquillian.junit.Arquillian;
+import org.jboss.shrinkwrap.api.ShrinkWrap;
+import org.jboss.shrinkwrap.api.spec.WebArchive;
+import org.jboss.shrinkwrap.resolver.api.maven.Maven;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import javax.inject.Inject;
+import java.io.File;
+import java.util.concurrent.TimeUnit;
+
+import static com.jayway.awaitility.Awaitility.await;
+import static com.jayway.awaitility.Awaitility.to;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.equalTo;
+import static org.hamcrest.Matchers.is;
+
+
+@RunWith(Arquillian.class)
+public class ProgrammaticAtFixedRateTimerBeanTest {
+
+    final static long TIMEOUT = 1000;
+    final static long TOLERANCE = 500l;
+
+    @Inject
+    TimerEventListener timerEventListener;
+
+    @Deployment
+    public static WebArchive deploy() {
+        File[] jars = Maven.resolver().loadPomFromFile("pom.xml")
+                .resolve("com.jayway.awaitility:awaitility")
+                .withTransitivity().asFile();
+
+        return ShrinkWrap.create(WebArchive.class)
+                .addAsLibraries(jars)
+                .addClasses(WithinWindowMatcher.class, TimerEvent.class, TimerEventListener.class, ProgrammaticAtFixedRateTimerBean.class);
+    }
+
+    @Test
+    public void should_receive_ten_pings() {
+
+        Awaitility.setDefaultTimeout(30, TimeUnit.SECONDS);
+
+        await().untilCall(to(timerEventListener.getEvents()).size(), equalTo(10));
+        TimerEvent firstEvent = timerEventListener.getEvents().get(0);
+        TimerEvent secondEvent = timerEventListener.getEvents().get(1);
+
+        long delay = secondEvent.getTime() - firstEvent.getTime();
+        System.out.println("Actual timeout = " + delay);
+        assertThat(delay, is(WithinWindowMatcher.withinWindow(TIMEOUT, TOLERANCE)));
+    }
+}

jee7schedule/src/test/java/com/baeldung/timer/ProgrammaticTimerBeanTest.java

@@ -0,0 +1,53 @@
+package com.baeldung.timer;
+
+import org.jboss.arquillian.container.test.api.Deployment;
+import org.jboss.arquillian.junit.Arquillian;
+import org.jboss.shrinkwrap.api.ShrinkWrap;
+import org.jboss.shrinkwrap.api.spec.WebArchive;
+import org.jboss.shrinkwrap.resolver.api.maven.Maven;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import javax.inject.Inject;
+import java.io.File;
+
+import static com.jayway.awaitility.Awaitility.await;
+import static com.jayway.awaitility.Awaitility.to;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.equalTo;
+import static org.hamcrest.Matchers.is;
+
+
+@RunWith(Arquillian.class)
+public class ProgrammaticTimerBeanTest {
+
+    final static long TIMEOUT = 5000l;
+    final static long TOLERANCE = 1000l;
+
+    @Inject
+    TimerEventListener timerEventListener;
+
+    @Deployment
+    public static WebArchive deploy() {
+        File[] jars = Maven.resolver().loadPomFromFile("pom.xml")
+                .resolve("com.jayway.awaitility:awaitility")
+                .withTransitivity().asFile();
+
+        return ShrinkWrap.create(WebArchive.class)
+                .addAsLibraries(jars)
+                .addClasses(WithinWindowMatcher.class, TimerEvent.class, TimerEventListener.class, ProgrammaticTimerBean.class);
+    }
+
+    @Test
+    public void should_receive_two_pings() {
+
+        await().untilCall(to(timerEventListener.getEvents()).size(), equalTo(2));
+
+        TimerEvent firstEvent = timerEventListener.getEvents().get(0);
+        TimerEvent secondEvent = timerEventListener.getEvents().get(1);
+
+        long delay = secondEvent.getTime() - firstEvent.getTime();
+        System.out.println("Actual timeout = " + delay);
+        assertThat(delay, is(WithinWindowMatcher.withinWindow(TIMEOUT, TOLERANCE)));
+    }
+}

jee7schedule/src/test/java/com/baeldung/timer/ProgrammaticWithFixedDelayTimerBeanTest.java

@@ -0,0 +1,61 @@
+package com.baeldung.timer;
+
+import com.jayway.awaitility.Awaitility;
+import org.jboss.arquillian.container.test.api.Deployment;
+import org.jboss.arquillian.junit.Arquillian;
+import org.jboss.shrinkwrap.api.ShrinkWrap;
+import org.jboss.shrinkwrap.api.spec.WebArchive;
+import org.jboss.shrinkwrap.resolver.api.maven.Maven;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import javax.inject.Inject;
+import java.io.File;
+import java.util.concurrent.TimeUnit;
+
+import static com.jayway.awaitility.Awaitility.await;
+import static com.jayway.awaitility.Awaitility.to;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.equalTo;
+import static org.hamcrest.Matchers.is;
+
+
+@RunWith(Arquillian.class)
+public class ProgrammaticWithFixedDelayTimerBeanTest {
+
+    final static long TIMEOUT = 15000l;
+    final static long TOLERANCE = 1000l;
+
+    @Inject
+    TimerEventListener timerEventListener;
+
+    @Deployment
+    public static WebArchive deploy() {
+        File[] jars = Maven.resolver().loadPomFromFile("pom.xml")
+                .resolve("com.jayway.awaitility:awaitility")
+                .withTransitivity().asFile();
+
+        return ShrinkWrap.create(WebArchive.class)
+                .addAsLibraries(jars)
+                .addClasses(WithinWindowMatcher.class, TimerEvent.class, TimerEventListener.class, ProgrammaticWithInitialFixedDelayTimerBean.class);
+    }
+
+    @Test
+    public void should_receive_two_pings() {
+
+        Awaitility.setDefaultTimeout(30, TimeUnit.SECONDS);
+
+        // 10 seconds pause so we get the startTime and it will trigger first event
+        long startTime = System.currentTimeMillis();
+
+        await().untilCall(to(timerEventListener.getEvents()).size(), equalTo(2));
+        TimerEvent firstEvent = timerEventListener.getEvents().get(0);
+        TimerEvent secondEvent = timerEventListener.getEvents().get(1);
+
+        long delay = secondEvent.getTime() - startTime;
+        System.out.println("Actual timeout = " + delay);
+
+        //apx 15 seconds = 10 delay + 2 timers (first after a pause of 10 seconds and the next others every 5 seconds)
+        assertThat(delay, is(WithinWindowMatcher.withinWindow(TIMEOUT, TOLERANCE)));
+    }
+}

jee7schedule/src/test/java/com/baeldung/timer/ScheduleTimerBeanTest.java

@@ -0,0 +1,59 @@
+package com.baeldung.timer;
+
+import com.jayway.awaitility.Awaitility;
+import org.hamcrest.Matchers;
+import org.jboss.arquillian.container.test.api.Deployment;
+import org.jboss.arquillian.junit.Arquillian;
+import org.jboss.shrinkwrap.api.ShrinkWrap;
+import org.jboss.shrinkwrap.api.spec.WebArchive;
+import org.jboss.shrinkwrap.resolver.api.maven.Maven;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import javax.inject.Inject;
+import java.io.File;
+import java.util.concurrent.TimeUnit;
+
+import static com.jayway.awaitility.Awaitility.await;
+import static com.jayway.awaitility.Awaitility.to;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.equalTo;
+
+
+@RunWith(Arquillian.class)
+public class ScheduleTimerBeanTest {
+
+    final static long TIMEOUT = 5000l;
+    final static long TOLERANCE = 1000l;
+
+    @Inject
+    TimerEventListener timerEventListener;
+
+    @Deployment
+    public static WebArchive deploy() {
+        File[] jars = Maven.resolver().loadPomFromFile("pom.xml")
+                .resolve("com.jayway.awaitility:awaitility")
+                .withTransitivity().asFile();
+
+        return ShrinkWrap.create(WebArchive.class)
+                .addAsLibraries(jars)
+                .addClasses(WithinWindowMatcher.class, TimerEvent.class, TimerEventListener.class, ScheduleTimerBean.class);
+    }
+
+    @Test
+    public void should_receive_three_pings() {
+
+        Awaitility.setDefaultTimeout(30, TimeUnit.SECONDS);
+        await().untilCall(to(timerEventListener.getEvents()).size(), equalTo(3));
+
+        TimerEvent firstEvent = timerEventListener.getEvents().get(0);
+        TimerEvent secondEvent = timerEventListener.getEvents().get(1);
+        TimerEvent thirdEvent = timerEventListener.getEvents().get(2);
+
+        long delay = secondEvent.getTime() - firstEvent.getTime();
+        assertThat(delay, Matchers.is(WithinWindowMatcher.withinWindow(TIMEOUT, TOLERANCE)));
+        delay = thirdEvent.getTime() - secondEvent.getTime();
+        assertThat(delay, Matchers.is(WithinWindowMatcher.withinWindow(TIMEOUT, TOLERANCE)));
+
+    }
+}

jee7schedule/src/test/java/com/baeldung/timer/WithinWindowMatcher.java

@@ -0,0 +1,30 @@
+package com.baeldung.timer;
+
+import org.hamcrest.BaseMatcher;
+import org.hamcrest.Description;
+import org.hamcrest.Matcher;
+
+class WithinWindowMatcher extends BaseMatcher<Long> {
+    private final long timeout;
+    private final long tolerance;
+
+    public WithinWindowMatcher(long timeout, long tolerance) {
+        this.timeout = timeout;
+        this.tolerance = tolerance;
+    }
+
+    @Override
+    public boolean matches(Object item) {
+        final Long actual = (Long) item;
+        return Math.abs(actual - timeout) < tolerance;
+    }
+
+    @Override
+    public void describeTo(Description description) {
+        //To change body of implemented methods use File | Settings | File Templates.
+    }
+
+    public static Matcher<Long> withinWindow(final long timeout, final long tolerance) {
+        return new WithinWindowMatcher(timeout, tolerance);
+    }
+}

jooq-spring/.classpath

@@ -1,31 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<classpath>
-	<classpathentry kind="src" output="target/classes" path="src/main/java">
-		<attributes>
-			<attribute name="optional" value="true"/>
-			<attribute name="maven.pomderived" value="true"/>
-		</attributes>
-	</classpathentry>
-	<classpathentry excluding="**" kind="src" output="target/classes" path="src/main/resources">
-		<attributes>
-			<attribute name="maven.pomderived" value="true"/>
-		</attributes>
-	</classpathentry>
-	<classpathentry kind="src" output="target/test-classes" path="src/test/java">
-		<attributes>
-			<attribute name="optional" value="true"/>
-			<attribute name="maven.pomderived" value="true"/>
-		</attributes>
-	</classpathentry>
-	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/J2SE-1.5">
-		<attributes>
-			<attribute name="maven.pomderived" value="true"/>
-		</attributes>
-	</classpathentry>
-	<classpathentry kind="con" path="org.eclipse.m2e.MAVEN2_CLASSPATH_CONTAINER">
-		<attributes>
-			<attribute name="maven.pomderived" value="true"/>
-		</attributes>
-	</classpathentry>
-	<classpathentry kind="output" path="target/classes"/>
-</classpath>

jooq-spring/.gitignore

@@ -0,0 +1 @@
+/src/main/java/com/baeldung/jooq/introduction/db

jooq-spring/.project

@@ -1,29 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<projectDescription>
-	<name>jooq-spring</name>
-	<comment></comment>
-	<projects>
-	</projects>
-	<buildSpec>
-		<buildCommand>
-			<name>org.eclipse.jdt.core.javabuilder</name>
-			<arguments>
-			</arguments>
-		</buildCommand>
-		<buildCommand>
-			<name>org.springframework.ide.eclipse.core.springbuilder</name>
-			<arguments>
-			</arguments>
-		</buildCommand>
-		<buildCommand>
-			<name>org.eclipse.m2e.core.maven2Builder</name>
-			<arguments>
-			</arguments>
-		</buildCommand>
-	</buildSpec>
-	<natures>
-		<nature>org.springframework.ide.eclipse.core.springnature</nature>
-		<nature>org.eclipse.jdt.core.javanature</nature>
-		<nature>org.eclipse.m2e.core.maven2Nature</nature>
-	</natures>
-</projectDescription>

jooq-spring/pom.xml

@@ -5,14 +5,18 @@
 	<artifactId>jooq-spring</artifactId>
 	<version>0.0.1-SNAPSHOT</version>
 
-	<properties>
+	<dependencyManagement>
-		<org.jooq.version>3.7.3</org.jooq.version>
+		<dependencies>
-		<com.h2database.version>1.4.191</com.h2database.version>
+			<dependency>
-		<org.springframework.version>4.2.5.RELEASE</org.springframework.version>
+				<!-- Import dependency management from Spring Boot -->
-		<org.slf4j.version>1.7.18</org.slf4j.version>
+				<groupId>org.springframework.boot</groupId>
-		<ch.qos.logback.version>1.1.3</ch.qos.logback.version>
+				<artifactId>spring-boot-dependencies</artifactId>
-		<junit.version>4.12</junit.version>
+				<version>1.3.5.RELEASE</version>
-	</properties>
+				<type>pom</type>
+				<scope>import</scope>
+			</dependency>
+		</dependencies>
+	</dependencyManagement>
 
 	<dependencies>
 		<!-- jOOQ -->
@@ -33,25 +37,25 @@
 		<dependency>
 			<groupId>org.springframework</groupId>
 			<artifactId>spring-context</artifactId>
-			<version>${org.springframework.version}</version>
 		</dependency>
 		<dependency>
 			<groupId>org.springframework</groupId>
 			<artifactId>spring-jdbc</artifactId>
-			<version>${org.springframework.version}</version>
+		</dependency>
+		<dependency>
+			<groupId>org.springframework.boot</groupId>
+			<artifactId>spring-boot-starter-jooq</artifactId>
 		</dependency>
 
 		<!-- Logging -->
 		<dependency>
 			<groupId>org.slf4j</groupId>
 			<artifactId>slf4j-api</artifactId>
-			<version>${org.slf4j.version}</version>
 			<scope>runtime</scope>
 		</dependency>
 		<dependency>
 			<groupId>ch.qos.logback</groupId>
 			<artifactId>logback-classic</artifactId>
-			<version>${ch.qos.logback.version}</version>
 			<scope>runtime</scope>
 		</dependency>
 
@@ -59,13 +63,11 @@
 		<dependency>
 			<groupId>junit</groupId>
 			<artifactId>junit</artifactId>
-			<version>${junit.version}</version>
 			<scope>test</scope>
 		</dependency>
 		<dependency>
 			<groupId>org.springframework</groupId>
 			<artifactId>spring-test</artifactId>
-			<version>${org.springframework.version}</version>
 			<scope>test</scope>
 		</dependency>
 	</dependencies>
@@ -148,6 +150,29 @@
 					</execution>
 				</executions>
 			</plugin>
+
+			<plugin>
+				<groupId>org.apache.maven.plugins</groupId>
+				<artifactId>maven-compiler-plugin</artifactId>
+				<version>${maven-compiler-plugin.version}</version>
+				<configuration>
+					<source>1.8</source>
+					<target>1.8</target>
+				</configuration>
+			</plugin>
+
 		</plugins>
 	</build>
+
+	<properties>
+		<org.jooq.version>3.7.3</org.jooq.version>
+		<com.h2database.version>1.4.191</com.h2database.version>
+		<org.springframework.version>4.2.5.RELEASE</org.springframework.version>
+		<org.slf4j.version>1.7.18</org.slf4j.version>
+		<ch.qos.logback.version>1.1.3</ch.qos.logback.version>
+		<junit.version>4.12</junit.version>
+		
+		<maven-compiler-plugin.version>3.5.1</maven-compiler-plugin.version>
+	</properties>
+
 </project>

jooq-spring/src/main/resources/application.properties

@@ -0,0 +1,3 @@
+spring.datasource.url=jdbc:h2:~/jooq
+spring.datasource.username=sa
+spring.datasource.password=

jooq-spring/src/test/java/com/baeldung/jooq/introduction/ExceptionTranslator.java

@@ -8,12 +8,12 @@ import org.springframework.jdbc.support.SQLErrorCodeSQLExceptionTranslator;
 import org.springframework.jdbc.support.SQLExceptionTranslator;
 
 public class ExceptionTranslator extends DefaultExecuteListener {
-    private static final long serialVersionUID = 649359748808106775L;
 
     @Override
     public void exception(ExecuteContext context) {
         SQLDialect dialect = context.configuration().dialect();
         SQLExceptionTranslator translator = new SQLErrorCodeSQLExceptionTranslator(dialect.name());
+
         context.exception(translator.translate("Access database using jOOQ", context.sql(), context.sqlException()));
     }
 }

jooq-spring/src/test/java/com/baeldung/jooq/introduction/PersistenceContext.java

@@ -1,6 +1,5 @@
 package com.baeldung.jooq.introduction;
 
-import javax.sql.DataSource;
 import org.h2.jdbcx.JdbcDataSource;
 import org.jooq.SQLDialect;
 import org.jooq.impl.DataSourceConnectionProvider;
@@ -17,11 +16,14 @@ import org.springframework.jdbc.datasource.DataSourceTransactionManager;
 import org.springframework.jdbc.datasource.TransactionAwareDataSourceProxy;
 import org.springframework.transaction.annotation.EnableTransactionManagement;
 
+import javax.sql.DataSource;
+
 @Configuration
 @ComponentScan({ "com.baeldung.jooq.introduction.db.public_.tables" })
 @EnableTransactionManagement
 @PropertySource("classpath:intro_config.properties")
 public class PersistenceContext {
+
     @Autowired
     private Environment environment;
 

jooq-spring/src/test/java/com/baeldung/jooq/introduction/QueryTest.java

@@ -1,8 +1,5 @@
 package com.baeldung.jooq.introduction;
 
-import com.baeldung.jooq.introduction.db.public_.tables.Author;
-import com.baeldung.jooq.introduction.db.public_.tables.AuthorBook;
-import com.baeldung.jooq.introduction.db.public_.tables.Book;
 import org.jooq.DSLContext;
 import org.jooq.Record3;
 import org.jooq.Result;
@@ -15,6 +12,9 @@ import org.springframework.test.context.ContextConfiguration;
 import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
 import org.springframework.transaction.annotation.Transactional;
 
+import static com.baeldung.jooq.introduction.db.public_.tables.Author.AUTHOR;
+import static com.baeldung.jooq.introduction.db.public_.tables.AuthorBook.AUTHOR_BOOK;
+import static com.baeldung.jooq.introduction.db.public_.tables.Book.BOOK;
 import static org.junit.Assert.assertEquals;
 
 @ContextConfiguration(classes = PersistenceContext.class)
@@ -25,61 +25,98 @@ public class QueryTest {
     @Autowired
     private DSLContext dsl;
 
-    Author author = Author.AUTHOR;
-    Book book = Book.BOOK;
-    AuthorBook authorBook = AuthorBook.AUTHOR_BOOK;
-
     @Test
     public void givenValidData_whenInserting_thenSucceed() {
-        dsl.insertInto(author).set(author.ID, 4).set(author.FIRST_NAME, "Herbert").set(author.LAST_NAME, "Schildt").execute();
+        dsl.insertInto(AUTHOR)
-        dsl.insertInto(book).set(book.ID, 4).set(book.TITLE, "A Beginner's Guide").execute();
+                .set(AUTHOR.ID, 4)
-        dsl.insertInto(authorBook).set(authorBook.AUTHOR_ID, 4).set(authorBook.BOOK_ID, 4).execute();
+                .set(AUTHOR.FIRST_NAME, "Herbert")
-        Result<Record3<Integer, String, Integer>> result = dsl.select(author.ID, author.LAST_NAME, DSL.count()).from(author).join(authorBook).on(author.ID.equal(authorBook.AUTHOR_ID)).join(book).on(authorBook.BOOK_ID.equal(book.ID))
+                .set(AUTHOR.LAST_NAME, "Schildt")
-                .groupBy(author.LAST_NAME).fetch();
+                .execute();
+
+        dsl.insertInto(BOOK)
+                .set(BOOK.ID, 4)
+                .set(BOOK.TITLE, "A Beginner's Guide")
+                .execute();
+
+        dsl.insertInto(AUTHOR_BOOK)
+                .set(AUTHOR_BOOK.AUTHOR_ID, 4)
+                .set(AUTHOR_BOOK.BOOK_ID, 4)
+                .execute();
+
+        final Result<Record3<Integer, String, Integer>> result = dsl.select(AUTHOR.ID, AUTHOR.LAST_NAME, DSL.count())
+                .from(AUTHOR)
+                .join(AUTHOR_BOOK).on(AUTHOR.ID.equal(AUTHOR_BOOK.AUTHOR_ID))
+                .join(BOOK).on(AUTHOR_BOOK.BOOK_ID.equal(BOOK.ID))
+                .groupBy(AUTHOR.LAST_NAME).fetch();
 
         assertEquals(3, result.size());
-        assertEquals("Sierra", result.getValue(0, author.LAST_NAME));
+        assertEquals("Sierra", result.getValue(0, AUTHOR.LAST_NAME));
         assertEquals(Integer.valueOf(2), result.getValue(0, DSL.count()));
-        assertEquals("Schildt", result.getValue(2, author.LAST_NAME));
+        assertEquals("Schildt", result.getValue(2, AUTHOR.LAST_NAME));
         assertEquals(Integer.valueOf(1), result.getValue(2, DSL.count()));
     }
 
     @Test(expected = DataAccessException.class)
     public void givenInvalidData_whenInserting_thenFail() {
-        dsl.insertInto(authorBook).set(authorBook.AUTHOR_ID, 4).set(authorBook.BOOK_ID, 5).execute();
+        dsl.insertInto(AUTHOR_BOOK).set(AUTHOR_BOOK.AUTHOR_ID, 4).set(AUTHOR_BOOK.BOOK_ID, 5).execute();
     }
 
     @Test
     public void givenValidData_whenUpdating_thenSucceed() {
-        dsl.update(author).set(author.LAST_NAME, "Baeldung").where(author.ID.equal(3)).execute();
+        dsl.update(AUTHOR)
-        dsl.update(book).set(book.TITLE, "Building your REST API with Spring").where(book.ID.equal(3)).execute();
+                .set(AUTHOR.LAST_NAME, "Baeldung")
-        dsl.insertInto(authorBook).set(authorBook.AUTHOR_ID, 3).set(authorBook.BOOK_ID, 3).execute();
+                .where(AUTHOR.ID.equal(3))
-        Result<Record3<Integer, String, String>> result = dsl.select(author.ID, author.LAST_NAME, book.TITLE).from(author).join(authorBook).on(author.ID.equal(authorBook.AUTHOR_ID)).join(book).on(authorBook.BOOK_ID.equal(book.ID)).where(author.ID.equal(3))
+                .execute();
+
+        dsl.update(BOOK)
+                .set(BOOK.TITLE, "Building your REST API with Spring")
+                .where(BOOK.ID.equal(3)).execute();
+
+        dsl.insertInto(AUTHOR_BOOK)
+                .set(AUTHOR_BOOK.AUTHOR_ID, 3)
+                .set(AUTHOR_BOOK.BOOK_ID, 3)
+                .execute();
+
+        final Result<Record3<Integer, String, String>> result = dsl.select(AUTHOR.ID, AUTHOR.LAST_NAME, BOOK.TITLE)
+                .from(AUTHOR)
+                .join(AUTHOR_BOOK).on(AUTHOR.ID.equal(AUTHOR_BOOK.AUTHOR_ID))
+                .join(BOOK).on(AUTHOR_BOOK.BOOK_ID.equal(BOOK.ID))
+                .where(AUTHOR.ID.equal(3))
                 .fetch();
 
         assertEquals(1, result.size());
-        assertEquals(Integer.valueOf(3), result.getValue(0, author.ID));
+        assertEquals(Integer.valueOf(3), result.getValue(0, AUTHOR.ID));
-        assertEquals("Baeldung", result.getValue(0, author.LAST_NAME));
+        assertEquals("Baeldung", result.getValue(0, AUTHOR.LAST_NAME));
-        assertEquals("Building your REST API with Spring", result.getValue(0, book.TITLE));
+        assertEquals("Building your REST API with Spring", result.getValue(0, BOOK.TITLE));
     }
 
     @Test(expected = DataAccessException.class)
     public void givenInvalidData_whenUpdating_thenFail() {
-        dsl.update(authorBook).set(authorBook.AUTHOR_ID, 4).set(authorBook.BOOK_ID, 5).execute();
+        dsl.update(AUTHOR_BOOK)
+                .set(AUTHOR_BOOK.AUTHOR_ID, 4)
+                .set(AUTHOR_BOOK.BOOK_ID, 5)
+                .execute();
     }
 
     @Test
     public void givenValidData_whenDeleting_thenSucceed() {
-        dsl.delete(author).where(author.ID.lt(3)).execute();
+        dsl.delete(AUTHOR)
-        Result<Record3<Integer, String, String>> result = dsl.select(author.ID, author.FIRST_NAME, author.LAST_NAME).from(author).fetch();
+                .where(AUTHOR.ID.lt(3))
+                .execute();
+
+        final Result<Record3<Integer, String, String>> result = dsl.select(AUTHOR.ID, AUTHOR.FIRST_NAME, AUTHOR.LAST_NAME)
+                .from(AUTHOR)
+                .fetch();
 
         assertEquals(1, result.size());
-        assertEquals("Bryan", result.getValue(0, author.FIRST_NAME));
+        assertEquals("Bryan", result.getValue(0, AUTHOR.FIRST_NAME));
-        assertEquals("Basham", result.getValue(0, author.LAST_NAME));
+        assertEquals("Basham", result.getValue(0, AUTHOR.LAST_NAME));
     }
 
     @Test(expected = DataAccessException.class)
     public void givenInvalidData_whenDeleting_thenFail() {
-        dsl.delete(book).where(book.ID.equal(1)).execute();
+        dsl.delete(BOOK)
+                .where(BOOK.ID.equal(1))
+                .execute();
     }
 }

jooq-spring/src/test/java/com/baeldung/jooq/springboot/Application.java

@@ -0,0 +1,9 @@
+package com.baeldung.jooq.springboot;
+
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.transaction.annotation.EnableTransactionManagement;
+
+@SpringBootApplication
+@EnableTransactionManagement
+public class Application {
+}

jooq-spring/src/test/java/com/baeldung/jooq/springboot/InitialConfiguration.java

@@ -0,0 +1,39 @@
+package com.baeldung.jooq.springboot;
+
+import com.baeldung.jooq.introduction.ExceptionTranslator;
+import org.jooq.impl.DataSourceConnectionProvider;
+import org.jooq.impl.DefaultConfiguration;
+import org.jooq.impl.DefaultDSLContext;
+import org.jooq.impl.DefaultExecuteListenerProvider;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.jdbc.datasource.TransactionAwareDataSourceProxy;
+
+import javax.sql.DataSource;
+
+@Configuration
+public class InitialConfiguration {
+
+    @Autowired
+    private DataSource dataSource;
+
+    @Bean
+    public DataSourceConnectionProvider connectionProvider() {
+        return new DataSourceConnectionProvider(new TransactionAwareDataSourceProxy(dataSource));
+    }
+
+    @Bean
+    public DefaultDSLContext dsl() {
+        return new DefaultDSLContext(configuration());
+    }
+
+    public DefaultConfiguration configuration() {
+        DefaultConfiguration jooqConfiguration = new DefaultConfiguration();
+
+        jooqConfiguration.set(connectionProvider());
+        jooqConfiguration.set(new DefaultExecuteListenerProvider(new ExceptionTranslator()));
+
+        return jooqConfiguration;
+    }
+}

jooq-spring/src/test/java/com/baeldung/jooq/springboot/SpringBootTest.java

@@ -0,0 +1,124 @@
+package com.baeldung.jooq.springboot;
+
+import org.jooq.DSLContext;
+import org.jooq.Record3;
+import org.jooq.Result;
+import org.jooq.impl.DSL;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.SpringApplicationConfiguration;
+import org.springframework.dao.DataAccessException;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+import org.springframework.transaction.annotation.Transactional;
+
+import static com.baeldung.jooq.introduction.db.public_.tables.Author.AUTHOR;
+import static com.baeldung.jooq.introduction.db.public_.tables.AuthorBook.AUTHOR_BOOK;
+import static com.baeldung.jooq.introduction.db.public_.tables.Book.BOOK;
+import static org.junit.Assert.assertEquals;
+
+@SpringApplicationConfiguration(Application.class)
+@Transactional("transactionManager")
+@RunWith(SpringJUnit4ClassRunner.class)
+public class SpringBootTest {
+
+    @Autowired
+    private DSLContext dsl;
+
+    @Test
+    public void givenValidData_whenInserting_thenSucceed() {
+        dsl.insertInto(AUTHOR)
+                .set(AUTHOR.ID, 4)
+                .set(AUTHOR.FIRST_NAME, "Herbert")
+                .set(AUTHOR.LAST_NAME, "Schildt")
+                .execute();
+
+        dsl.insertInto(BOOK)
+                .set(BOOK.ID, 4)
+                .set(BOOK.TITLE, "A Beginner's Guide")
+                .execute();
+
+        dsl.insertInto(AUTHOR_BOOK)
+                .set(AUTHOR_BOOK.AUTHOR_ID, 4)
+                .set(AUTHOR_BOOK.BOOK_ID, 4)
+                .execute();
+
+        final Result<Record3<Integer, String, Integer>> result = dsl.select(AUTHOR.ID, AUTHOR.LAST_NAME, DSL.count())
+                .from(AUTHOR).join(AUTHOR_BOOK).on(AUTHOR.ID.equal(AUTHOR_BOOK.AUTHOR_ID))
+                .join(BOOK).on(AUTHOR_BOOK.BOOK_ID.equal(BOOK.ID))
+                .groupBy(AUTHOR.LAST_NAME)
+                .fetch();
+
+        assertEquals(3, result.size());
+        assertEquals("Sierra", result.getValue(0, AUTHOR.LAST_NAME));
+        assertEquals(Integer.valueOf(2), result.getValue(0, DSL.count()));
+        assertEquals("Schildt", result.getValue(2, AUTHOR.LAST_NAME));
+        assertEquals(Integer.valueOf(1), result.getValue(2, DSL.count()));
+    }
+
+    @Test(expected = DataAccessException.class)
+    public void givenInvalidData_whenInserting_thenFail() {
+        dsl.insertInto(AUTHOR_BOOK)
+                .set(AUTHOR_BOOK.AUTHOR_ID, 4)
+                .set(AUTHOR_BOOK.BOOK_ID, 5)
+                .execute();
+    }
+
+    @Test
+    public void givenValidData_whenUpdating_thenSucceed() {
+        dsl.update(AUTHOR)
+                .set(AUTHOR.LAST_NAME, "Baeldung")
+                .where(AUTHOR.ID.equal(3))
+                .execute();
+
+        dsl.update(BOOK)
+                .set(BOOK.TITLE, "Building your REST API with Spring")
+                .where(BOOK.ID.equal(3))
+                .execute();
+
+        dsl.insertInto(AUTHOR_BOOK)
+                .set(AUTHOR_BOOK.AUTHOR_ID, 3)
+                .set(AUTHOR_BOOK.BOOK_ID, 3)
+                .execute();
+
+        final Result<Record3<Integer, String, String>> result = dsl.select(AUTHOR.ID, AUTHOR.LAST_NAME, BOOK.TITLE)
+                .from(AUTHOR).join(AUTHOR_BOOK).on(AUTHOR.ID.equal(AUTHOR_BOOK.AUTHOR_ID))
+                .join(BOOK).on(AUTHOR_BOOK.BOOK_ID.equal(BOOK.ID))
+                .where(AUTHOR.ID.equal(3))
+                .fetch();
+
+        assertEquals(1, result.size());
+        assertEquals(Integer.valueOf(3), result.getValue(0, AUTHOR.ID));
+        assertEquals("Baeldung", result.getValue(0, AUTHOR.LAST_NAME));
+        assertEquals("Building your REST API with Spring", result.getValue(0, BOOK.TITLE));
+    }
+
+    @Test(expected = DataAccessException.class)
+    public void givenInvalidData_whenUpdating_thenFail() {
+        dsl.update(AUTHOR_BOOK)
+                .set(AUTHOR_BOOK.AUTHOR_ID, 4)
+                .set(AUTHOR_BOOK.BOOK_ID, 5)
+                .execute();
+    }
+
+    @Test
+    public void givenValidData_whenDeleting_thenSucceed() {
+        dsl.delete(AUTHOR)
+                .where(AUTHOR.ID.lt(3))
+                .execute();
+
+        final Result<Record3<Integer, String, String>> result = dsl.select(AUTHOR.ID, AUTHOR.FIRST_NAME, AUTHOR.LAST_NAME)
+                .from(AUTHOR).fetch();
+
+        assertEquals(1, result.size());
+        assertEquals("Bryan", result.getValue(0, AUTHOR.FIRST_NAME));
+        assertEquals("Basham", result.getValue(0, AUTHOR.LAST_NAME));
+    }
+
+    @Test(expected = DataAccessException.class)
+    public void givenInvalidData_whenDeleting_thenFail() {
+        dsl.delete(BOOK)
+                .where(BOOK.ID.equal(1))
+                .execute();
+    }
+}

jsf/pom.xml

@@ -90,12 +90,21 @@
             <plugin>
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-compiler-plugin</artifactId>
-                <version>3.5.1</version>
+                <version>${maven-compiler-plugin.version}</version>
                 <configuration>
                     <source>1.8</source>
                     <target>1.8</target>
                 </configuration>
             </plugin>
+
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-war-plugin</artifactId>
+                <version>${maven-war-plugin.version}</version>
+                <configuration>
+                    <failOnMissingWebXml>false</failOnMissingWebXml>
+                </configuration>
+            </plugin>
         </plugins>
     </build>
 
@@ -112,5 +121,10 @@
 
         <!--Tomcat-->
         <javax.servlet.version>3.1.0</javax.servlet.version>
+
+        <!-- maven plugins -->
+        <maven-compiler-plugin.version>3.5.1</maven-compiler-plugin.version>
+        <maven-war-plugin.version>2.6</maven-war-plugin.version>
+
     </properties>
 </project>