diff --git a/core-java-9/src/test/java/com/baeldung/java9/Java9OptionalTest.java b/core-java-9/src/test/java/com/baeldung/java9/Java9OptionalTest.java new file mode 100644 index 0000000000..cd0efb028d --- /dev/null +++ b/core-java-9/src/test/java/com/baeldung/java9/Java9OptionalTest.java @@ -0,0 +1,85 @@ +package com.baeldung.java9; + +public class Java9OptionalTest { + @Test + public void givenOptionalOfSome_whenToStream_thenShouldTreatItAsOneElementStream() { + //given + Optional value = Optional.of("a"); + + //when + List collect = value.stream().map(String::toUpperCase).collect(Collectors.toList()); + + //then + assertThat(collect).hasSameElementsAs(List.of("A")); + } + + @Test + public void givenOptionalOfNone_whenToStream_thenShouldTreatItAsZeroElementStream() { + //given + Optional value = Optional.empty(); + + //when + List collect = value.stream().map(String::toUpperCase).collect(Collectors.toList()); + + //then + assertThat(collect).isEmpty(); + } + + @Test + public void givenOptional_whenPresent_thenShouldExecuteProperCallback() { + //given + Optional value = Optional.of("properValue"); + AtomicInteger successCounter = new AtomicInteger(0); + AtomicInteger onEmptyOptionalCounter = new AtomicInteger(0); + + //when + value.ifPresentOrElse((v) -> successCounter.incrementAndGet(), onEmptyOptionalCounter::incrementAndGet); + + //then + assertThat(successCounter.get()).isEqualTo(1); + assertThat(onEmptyOptionalCounter.get()).isEqualTo(0); + } + + @Test + public void givenOptional_whenNotPresent_thenShouldExecuteProperCallback() { + //given + Optional value = Optional.empty(); + AtomicInteger successCounter = new AtomicInteger(0); + AtomicInteger onEmptyOptionalCounter = new AtomicInteger(0); + + //when + value.ifPresentOrElse((v) -> successCounter.incrementAndGet(), onEmptyOptionalCounter::incrementAndGet); + + //then + assertThat(successCounter.get()).isEqualTo(0); + assertThat(onEmptyOptionalCounter.get()).isEqualTo(1); + } + + @Test + public void givenOptional_whenPresent_thenShouldTakeAValueFromIt() { + //given + String expected = "properValue"; + Optional value = Optional.of(expected); + Optional defaultValue = Optional.of("default"); + + //when + Optional result = value.or(() -> defaultValue); + + //then + assertThat(result.get()).isEqualTo(expected); + } + + @Test + public void givenOptional_whenEmpty_thenShouldTakeAValueFromOr() { + //given + String defaultString = "default"; + Optional value = Optional.empty(); + Optional defaultValue = Optional.of(defaultString); + + //when + Optional result = value.or(() -> defaultValue); + + //then + assertThat(result.get()).isEqualTo(defaultString); + } +} \ No newline at end of file diff --git a/core-java/README.md b/core-java/README.md index 1de57c9311..6c671a632d 100644 --- a/core-java/README.md +++ b/core-java/README.md @@ -102,8 +102,10 @@ - [How to Perform a Simple HTTP Request in Java](http://www.baeldung.com/java-http-request) - [Call Methods at Runtime Using Java Reflection](http://www.baeldung.com/java-method-reflection) - [Guide to DelayQueue](http://www.baeldung.com/java-delay-queue) +- [Guide to UUID in JAVA] (http://www.baeldung.com/guide-to-uuid-in-java) - [Comparing getPath(), getAbsolutePath(), and getCanonicalPath() in Java](http://www.baeldung.com/java-path) - [How to Add a Single Element to a Stream](http://www.baeldung.com/java-stream-append-prepend) +- [Iterating Over Enum Values in Java](http://www.baeldung.com/java-enum-iteration) - [A Guide to Java SynchronousQueue](http://www.baeldung.com/java-synchronous-queue) - [Guide to the Java TransferQueue](http://www.baeldung.com/java-transfer-queue) - [Kotlin Java Interoperability](http://www.baeldung.com/kotlin-java-interoperability) diff --git a/core-java/src/main/java/com/baeldung/concurrent/diningphilosophers/DiningPhilosophers.java b/core-java/src/main/java/com/baeldung/concurrent/diningphilosophers/DiningPhilosophers.java new file mode 100644 index 0000000000..7a077432f5 --- /dev/null +++ b/core-java/src/main/java/com/baeldung/concurrent/diningphilosophers/DiningPhilosophers.java @@ -0,0 +1,29 @@ +package com.baeldung.concurrent.diningphilosophers; + +public class DiningPhilosophers { + + public static void main(String[] args) throws Exception { + + Philosopher[] philosophers = new Philosopher[5]; + Object[] forks = new Object[philosophers.length]; + + for (int i = 0; i < forks.length; i++) { + forks[i] = new Object(); + } + + for (int i = 0; i < philosophers.length; i++) { + + Object leftFork = forks[i]; + Object rightFork = forks[(i + 1) % forks.length]; + + if (i == philosophers.length - 1) { + philosophers[i] = new Philosopher(rightFork, leftFork); // The last philosopher picks up the right fork first + } else { + philosophers[i] = new Philosopher(leftFork, rightFork); + } + + Thread t = new Thread(philosophers[i], "Philosopher " + (i + 1)); + t.start(); + } + } +} diff --git a/core-java/src/main/java/com/baeldung/concurrent/diningphilosophers/Philosopher.java b/core-java/src/main/java/com/baeldung/concurrent/diningphilosophers/Philosopher.java new file mode 100644 index 0000000000..3f1eacd276 --- /dev/null +++ b/core-java/src/main/java/com/baeldung/concurrent/diningphilosophers/Philosopher.java @@ -0,0 +1,36 @@ +package com.baeldung.concurrent.diningphilosophers; + +public class Philosopher implements Runnable { + + private final Object leftFork; + private final Object rightFork; + + public Philosopher(Object left, Object right) { + this.leftFork = left; + this.rightFork = right; + } + + private void doAction(String action) throws InterruptedException { + System.out.println(Thread.currentThread().getName() + " " + action); + Thread.sleep(((int) (Math.random() * 100))); + } + + @Override public void run() { + try { + while (true) { + doAction(System.nanoTime() + ": Thinking"); // thinking + synchronized (leftFork) { + doAction(System.nanoTime() + ": Picked up left fork"); + synchronized (rightFork) { + doAction(System.nanoTime() + ": Picked up right fork - eating"); // eating + doAction(System.nanoTime() + ": Put down right fork"); + } + doAction(System.nanoTime() + ": Put down left fork. Returning to thinking"); + } + } + } catch (InterruptedException e) { + Thread.currentThread().interrupt(); + return; + } + } +} \ No newline at end of file diff --git a/core-java/src/main/java/com/baeldung/regexp/EscapingChars.java b/core-java/src/main/java/com/baeldung/regexp/EscapingChars.java deleted file mode 100644 index 3268339a15..0000000000 --- a/core-java/src/main/java/com/baeldung/regexp/EscapingChars.java +++ /dev/null @@ -1,25 +0,0 @@ -package com.baeldung.regexp; - -import java.util.regex.Matcher; -import java.util.regex.Pattern; - -public class EscapingChars { - public boolean isMatching(String input, String pattern) { - return input.matches(pattern); - } - - public int splitAndCountWords(String input, String pattern) { - return input.split(pattern).length; - } - - public int splitAndCountWordsUsingQuoteMethod(String input, String pattern) { - return input.split(Pattern.quote(pattern)).length; - } - - public String changeCurrencySymbol(String input, String pattern, - String correctStr) { - Pattern p = Pattern.compile(pattern); - Matcher m = p.matcher(input); - return m.replaceAll(correctStr); - } -} diff --git a/core-java/src/main/java/com/baeldung/stream/StreamApi.java b/core-java/src/main/java/com/baeldung/stream/StreamApi.java new file mode 100644 index 0000000000..ec792314d2 --- /dev/null +++ b/core-java/src/main/java/com/baeldung/stream/StreamApi.java @@ -0,0 +1,24 @@ +package com.baeldung.stream; + +import java.util.List; +import java.util.stream.Stream; + +public class StreamApi { + + public String getLastElementUsingReduce(List valueList) { + Stream stream = valueList.stream(); + return stream.reduce((first, second) -> second).orElse(null); + } + + public Integer getInfiniteStreamLastElementUsingReduce() { + Stream stream = Stream.iterate(0, i -> i + 1); + return stream.limit(20).reduce((first, second) -> second).orElse(null); + } + + public String getLastElementUsingSkip(List valueList) { + long count = valueList.stream().count(); + Stream stream = valueList.stream(); + return stream.skip(count - 1).findFirst().orElse(null); + } + +} diff --git a/core-java/src/main/java/com/baeldung/string/StringHelper.java b/core-java/src/main/java/com/baeldung/string/StringHelper.java index ad2a0b3419..dac0d1272e 100644 --- a/core-java/src/main/java/com/baeldung/string/StringHelper.java +++ b/core-java/src/main/java/com/baeldung/string/StringHelper.java @@ -2,23 +2,23 @@ package com.baeldung.string; import java.util.Optional; -public class StringHelper { - public static String removeLastChar(String s) { +class StringHelper { + static String removeLastChar(String s) { return (s == null || s.length() == 0) ? s : (s.substring(0, s.length() - 1)); } - public static String removeLastCharRegex(String s) { + static String removeLastCharRegex(String s) { return (s == null) ? s : s.replaceAll(".$", ""); } - public static String removeLastCharOptional(String s) { + static String removeLastCharOptional(String s) { return Optional.ofNullable(s) .filter(str -> str.length() != 0) .map(str -> str.substring(0, str.length() - 1)) .orElse(s); } - public static String removeLastCharRegexOptional(String s) { + static String removeLastCharRegexOptional(String s) { return Optional.ofNullable(s) .map(str -> str.replaceAll(".$", "")) .orElse(s); diff --git a/core-java/src/main/java/com/baeldung/uuid/UUIDGenerator.java b/core-java/src/main/java/com/baeldung/uuid/UUIDGenerator.java new file mode 100644 index 0000000000..23baf5d5b4 --- /dev/null +++ b/core-java/src/main/java/com/baeldung/uuid/UUIDGenerator.java @@ -0,0 +1,118 @@ +package com.baeldung.uuid; + +import java.io.UnsupportedEncodingException; +import java.security.MessageDigest; +import java.security.NoSuchAlgorithmException; +import java.util.UUID; + +public class UUIDGenerator { + + /** + * These are predefined UUID for name spaces + */ + private static final String NAMESPACE_DNS = "6ba7b810-9dad-11d1-80b4-00c04fd430c8"; + private static final String NAMESPACE_URL = "6ba7b811-9dad-11d1-80b4-00c04fd430c8"; + private static final String NAMESPACE_OID = "6ba7b812-9dad-11d1-80b4-00c04fd430c8"; + private static final String NAMESPACE_X500 = "6ba7b814-9dad-11d1-80b4-00c04fd430c8"; + + private static final char[] hexArray = "0123456789ABCDEF".toCharArray(); + + public static void main(String[] args) { + try { + System.out.println("Type 3 : " + generateType3UUID(NAMESPACE_DNS, "google.com")); + System.out.println("Type 4 : " + generateType4UUID()); + System.out.println("Type 5 : " + generateType5UUID(NAMESPACE_URL, "google.com")); + System.out.println("Unique key : " + generateUniqueKeysWithUUIDAndMessageDigest()); + } catch (NoSuchAlgorithmException | UnsupportedEncodingException e) { + e.printStackTrace(); + } + } + + /** + * Type 4 UUID Generation + */ + public static UUID generateType4UUID() { + UUID uuid = UUID.randomUUID(); + return uuid; + } + + /** + * Type 3 UUID Generation + * + * @throws UnsupportedEncodingException + */ + public static UUID generateType3UUID(String namespace, String name) throws UnsupportedEncodingException { + String source = namespace + name; + byte[] bytes = source.getBytes("UTF-8"); + UUID uuid = UUID.nameUUIDFromBytes(bytes); + return uuid; + } + + /** + * Type 5 UUID Generation + * + * @throws UnsupportedEncodingException + */ + public static UUID generateType5UUID(String namespace, String name) throws UnsupportedEncodingException { + String source = namespace + name; + byte[] bytes = source.getBytes("UTF-8"); + UUID uuid = type5UUIDFromBytes(bytes); + return uuid; + } + + + public static UUID type5UUIDFromBytes(byte[] name) { + MessageDigest md; + try { + md = MessageDigest.getInstance("SHA-1"); + } catch (NoSuchAlgorithmException nsae) { + throw new InternalError("MD5 not supported", nsae); + } + byte[] bytes = md.digest(name); + bytes[6] &= 0x0f; /* clear version */ + bytes[6] |= 0x50; /* set to version 5 */ + bytes[8] &= 0x3f; /* clear variant */ + bytes[8] |= 0x80; /* set to IETF variant */ + return constructType5UUID(bytes); + } + + private static UUID constructType5UUID(byte[] data) { + long msb = 0; + long lsb = 0; + assert data.length == 16 : "data must be 16 bytes in length"; + + for (int i=0; i<8; i++) + msb = (msb << 8) | (data[i] & 0xff); + + for (int i=8; i<16; i++) + lsb = (lsb << 8) | (data[i] & 0xff); + return new UUID(msb, lsb); + } + + + /** + * Unique Keys Generation Using Message Digest and Type 4 UUID + * + * @throws NoSuchAlgorithmException + * @throws UnsupportedEncodingException + */ + public static String generateUniqueKeysWithUUIDAndMessageDigest() throws NoSuchAlgorithmException, UnsupportedEncodingException { + MessageDigest salt = MessageDigest.getInstance("SHA-256"); + salt.update(UUID.randomUUID() + .toString() + .getBytes("UTF-8")); + String digest = bytesToHex(salt.digest()); + return digest; + } + + public static String bytesToHex(byte[] bytes) { + char[] hexChars = new char[bytes.length * 2]; + for (int j = 0; j < bytes.length; j++) { + int v = bytes[j] & 0xFF; + hexChars[j * 2] = hexArray[v >>> 4]; + hexChars[j * 2 + 1] = hexArray[v & 0x0F]; + } + return new String(hexChars); + } + +} diff --git a/core-java/src/test/java/com/baeldung/regexp/EscapingCharsTest.java b/core-java/src/test/java/com/baeldung/regexp/EscapingCharsTest.java index 1e2293955a..f8dbde4c4f 100644 --- a/core-java/src/test/java/com/baeldung/regexp/EscapingCharsTest.java +++ b/core-java/src/test/java/com/baeldung/regexp/EscapingCharsTest.java @@ -3,6 +3,8 @@ package com.baeldung.regexp; import static junit.framework.TestCase.assertEquals; import static org.junit.Assert.assertThat; import static org.hamcrest.CoreMatchers.*; +import java.util.regex.Matcher; +import java.util.regex.Pattern; import org.junit.Test; @@ -11,57 +13,59 @@ public class EscapingCharsTest { public void givenRegexWithDot_whenMatchingStr_thenMatches() { String strInput = "foof"; String strRegex = "foo."; - EscapingChars e = new EscapingChars(); - - assertEquals(true, e.isMatching(strInput, strRegex)); + + assertEquals(true, strInput.matches(strRegex)); } - + @Test public void givenRegexWithDotEsc_whenMatchingStr_thenNotMatching() { String strInput = "foof"; String strRegex = "foo\\."; - EscapingChars e = new EscapingChars(); - - assertEquals(false, e.isMatching(strInput, strRegex)); + + assertEquals(false, strInput.matches(strRegex)); } - + @Test public void givenRegexWithPipeEscaped_whenSplitStr_thenSplits() { String strInput = "foo|bar|hello|world"; String strRegex = "\\Q|\\E"; - EscapingChars e = new EscapingChars(); - - assertEquals(4, e.splitAndCountWords(strInput, strRegex)); + + assertEquals(4, strInput.split(strRegex).length); } - + @Test public void givenRegexWithPipeEscQuoteMeth_whenSplitStr_thenSplits() { String strInput = "foo|bar|hello|world"; String strRegex = "|"; - EscapingChars e = new EscapingChars(); - - assertEquals(4, e.splitAndCountWordsUsingQuoteMethod(strInput, strRegex)); + + assertEquals(4,strInput.split(Pattern.quote(strRegex)).length); } - + @Test public void givenRegexWithDollar_whenReplacing_thenNotReplace() { - String strInput = "I gave $50 to my brother.He bought candy for $35. Now he has $15 left."; + String strInput = "I gave $50 to my brother." + + "He bought candy for $35. Now he has $15 left."; String strRegex = "$"; - String strReplacement = "�"; - String output = "I gave �50 to my brother.He bought candy for �35. Now he has �15 left."; - EscapingChars e = new EscapingChars(); - - assertThat(output, not(equalTo(e.changeCurrencySymbol(strInput, strRegex, strReplacement)))); + String strReplacement = "£"; + String output = "I gave £50 to my brother." + + "He bought candy for £35. Now he has £15 left."; + Pattern p = Pattern.compile(strRegex); + Matcher m = p.matcher(strInput); + + assertThat(output, not(equalTo(m.replaceAll(strReplacement)))); } - + @Test public void givenRegexWithDollarEsc_whenReplacing_thenReplace() { - String strInput = "I gave $50 to my brother. He bought candy for $35. Now he has $15 left."; + String strInput = "I gave $50 to my brother." + + "He bought candy for $35. Now he has $15 left."; String strRegex = "\\$"; - String strReplacement = "�"; - String output = "I gave �50 to my brother. He bought candy for �35. Now he has �15 left."; - EscapingChars e = new EscapingChars(); - - assertEquals(output, e.changeCurrencySymbol(strInput, strRegex, strReplacement)); + String strReplacement = "£"; + String output = "I gave £50 to my brother." + + "He bought candy for £35. Now he has £15 left."; + Pattern p = Pattern.compile(strRegex); + Matcher m = p.matcher(strInput); + + assertEquals(output,m.replaceAll(strReplacement)); } } diff --git a/core-java/src/test/java/com/baeldung/stream/StreamApiTest.java b/core-java/src/test/java/com/baeldung/stream/StreamApiTest.java new file mode 100644 index 0000000000..af52b3ee69 --- /dev/null +++ b/core-java/src/test/java/com/baeldung/stream/StreamApiTest.java @@ -0,0 +1,43 @@ +package com.baeldung.stream; + +import static org.junit.Assert.assertEquals; + +import java.util.ArrayList; +import java.util.List; + +import org.junit.Test; + +public class StreamApiTest { + private StreamApi streamApi = new StreamApi(); + + @Test + public void givenList_whenGetLastElementUsingReduce_thenReturnLastElement() { + List valueList = new ArrayList(); + valueList.add("Joe"); + valueList.add("John"); + valueList.add("Sean"); + + String last = streamApi.getLastElementUsingReduce(valueList); + + assertEquals("Sean", last); + } + + @Test + public void givenInfiniteStream_whenGetInfiniteStreamLastElementUsingReduce_thenReturnLastElement() { + Integer last = streamApi.getInfiniteStreamLastElementUsingReduce(); + assertEquals(new Integer(19), last); + } + + @Test + public void givenListAndCount_whenGetLastElementUsingSkip_thenReturnLastElement() { + List valueList = new ArrayList(); + valueList.add("Joe"); + valueList.add("John"); + valueList.add("Sean"); + + String last = streamApi.getLastElementUsingSkip(valueList); + + assertEquals("Sean", last); + } + +} diff --git a/core-java/src/test/java/org/baeldung/java/JavaRandomUnitTest.java b/core-java/src/test/java/org/baeldung/java/JavaRandomUnitTest.java index f058e5d862..a11659547e 100644 --- a/core-java/src/test/java/org/baeldung/java/JavaRandomUnitTest.java +++ b/core-java/src/test/java/org/baeldung/java/JavaRandomUnitTest.java @@ -167,9 +167,11 @@ public class JavaRandomUnitTest { final int leftLimit = 97; // letter 'a' final int rightLimit = 122; // letter 'z' final int targetStringLength = 10; + final Random random = new Random(); final StringBuilder buffer = new StringBuilder(targetStringLength); + for (int i = 0; i < targetStringLength; i++) { - final int randomLimitedInt = leftLimit + (int) (new Random().nextFloat() * (rightLimit - leftLimit + 1)); + final int randomLimitedInt = leftLimit + (int) (random.nextFloat() * (rightLimit - leftLimit + 1)); buffer.append((char) randomLimitedInt); } final String generatedString = buffer.toString(); diff --git a/ejb/ejb-session-beans/pom.xml b/ejb/ejb-session-beans/pom.xml new file mode 100644 index 0000000000..a9b667baac --- /dev/null +++ b/ejb/ejb-session-beans/pom.xml @@ -0,0 +1,106 @@ + + 4.0.0 + + com.baeldung.ejb + ejb + 1.0-SNAPSHOT + + ejb-session-beans + + + UTF-8 + 1.1.12.Final + 2.2.6 + 1.1.12.Final + 1.0.0.Final + 4.12 + 7.0 + + + + + + org.jboss.arquillian + arquillian-bom + 1.1.13.Final + import + pom + + + + + + + + javax + javaee-api + ${javaee-api.version} + provided + + + + + junit + junit + 4.12 + test + + + + + org.jboss.arquillian.junit + arquillian-junit-container + test + + + + + + + arquillian-glassfish-embedded + + true + + + + org.jboss.arquillian.container + arquillian-glassfish-embedded-3.1 + 1.0.0.CR4 + test + + + org.glassfish.main.extras + glassfish-embedded-all + 3.1.2 + test + + + + + + + + + maven-compiler-plugin + 3.1 + + 1.8 + 1.8 + + + + maven-war-plugin + 2.4 + + false + + + + maven-surefire-plugin + 2.17 + + + + + + \ No newline at end of file diff --git a/ejb/ejb-session-beans/src/main/java/com/baeldung/ejb/stateful/EJBClient1.java b/ejb/ejb-session-beans/src/main/java/com/baeldung/ejb/stateful/EJBClient1.java new file mode 100644 index 0000000000..0387beeb3c --- /dev/null +++ b/ejb/ejb-session-beans/src/main/java/com/baeldung/ejb/stateful/EJBClient1.java @@ -0,0 +1,11 @@ +package com.baeldung.ejb.stateful; + +import javax.ejb.EJB; + +public class EJBClient1 { + + @EJB + public StatefulEJB statefulEJB; + + +} \ No newline at end of file diff --git a/ejb/ejb-session-beans/src/main/java/com/baeldung/ejb/stateful/EJBClient2.java b/ejb/ejb-session-beans/src/main/java/com/baeldung/ejb/stateful/EJBClient2.java new file mode 100644 index 0000000000..54f88a993d --- /dev/null +++ b/ejb/ejb-session-beans/src/main/java/com/baeldung/ejb/stateful/EJBClient2.java @@ -0,0 +1,11 @@ +package com.baeldung.ejb.stateful; + +import javax.ejb.EJB; + +public class EJBClient2 { + + @EJB + public StatefulEJB statefulEJB; + + +} \ No newline at end of file diff --git a/ejb/ejb-session-beans/src/main/java/com/baeldung/ejb/stateful/StatefulEJB.java b/ejb/ejb-session-beans/src/main/java/com/baeldung/ejb/stateful/StatefulEJB.java new file mode 100644 index 0000000000..17bb08491a --- /dev/null +++ b/ejb/ejb-session-beans/src/main/java/com/baeldung/ejb/stateful/StatefulEJB.java @@ -0,0 +1,10 @@ +package com.baeldung.ejb.stateful; + +import javax.ejb.Stateful; + +@Stateful +public class StatefulEJB { + + public String name; + +} \ No newline at end of file diff --git a/ejb/ejb-session-beans/src/main/java/com/baeldung/ejb/stateless/EJBClient1.java b/ejb/ejb-session-beans/src/main/java/com/baeldung/ejb/stateless/EJBClient1.java new file mode 100644 index 0000000000..0d6f06449b --- /dev/null +++ b/ejb/ejb-session-beans/src/main/java/com/baeldung/ejb/stateless/EJBClient1.java @@ -0,0 +1,10 @@ +package com.baeldung.ejb.stateless; + +import javax.ejb.EJB; + +public class EJBClient1 { + + @EJB + public StatelessEJB statelessEJB; + +} \ No newline at end of file diff --git a/ejb/ejb-session-beans/src/main/java/com/baeldung/ejb/stateless/EJBClient2.java b/ejb/ejb-session-beans/src/main/java/com/baeldung/ejb/stateless/EJBClient2.java new file mode 100644 index 0000000000..a7fe650b1b --- /dev/null +++ b/ejb/ejb-session-beans/src/main/java/com/baeldung/ejb/stateless/EJBClient2.java @@ -0,0 +1,11 @@ +package com.baeldung.ejb.stateless; + +import javax.ejb.EJB; + +public class EJBClient2 { + + @EJB + public StatelessEJB statelessEJB; + + +} \ No newline at end of file diff --git a/ejb/ejb-session-beans/src/main/java/com/baeldung/ejb/stateless/StatelessEJB.java b/ejb/ejb-session-beans/src/main/java/com/baeldung/ejb/stateless/StatelessEJB.java new file mode 100644 index 0000000000..d4e9749252 --- /dev/null +++ b/ejb/ejb-session-beans/src/main/java/com/baeldung/ejb/stateless/StatelessEJB.java @@ -0,0 +1,11 @@ +package com.baeldung.ejb.stateless; + +import javax.ejb.Stateless; + + +@Stateless +public class StatelessEJB { + + public String name; + +} \ No newline at end of file diff --git a/ejb/ejb-session-beans/src/test/java/com/baeldung/ejb/test/stateful/StatefulEJBTest.java b/ejb/ejb-session-beans/src/test/java/com/baeldung/ejb/test/stateful/StatefulEJBTest.java new file mode 100644 index 0000000000..2f3e45a769 --- /dev/null +++ b/ejb/ejb-session-beans/src/test/java/com/baeldung/ejb/test/stateful/StatefulEJBTest.java @@ -0,0 +1,51 @@ +package com.baeldung.ejb.test.stateful; + +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.asset.EmptyAsset; +import org.jboss.shrinkwrap.api.spec.JavaArchive; +import org.junit.Assert; +import org.junit.Test; +import org.junit.runner.RunWith; + +import com.baeldung.ejb.stateful.EJBClient1; +import com.baeldung.ejb.stateful.EJBClient2; +import com.baeldung.ejb.stateful.StatefulEJB; + +import javax.inject.Inject; + + +@RunWith(Arquillian.class) +public class StatefulEJBTest { + + @Inject + private EJBClient1 ejbClient1; + + @Inject + private EJBClient2 ejbClient2; + + @Test + public void givenOneStatefulBean_whenTwoClientsSetValueOnBean_thenClientStateIsMaintained() { + + // act + ejbClient1.statefulEJB.name = "Client 1"; + ejbClient2.statefulEJB.name = "Client 2"; + + // assert + Assert.assertNotEquals(ejbClient1.statefulEJB.name, ejbClient2.statefulEJB.name); + Assert.assertEquals("Client 1", ejbClient1.statefulEJB.name); + Assert.assertEquals("Client 2", ejbClient2.statefulEJB.name); + + } + + @Deployment + public static JavaArchive createDeployment() { + return ShrinkWrap.create(JavaArchive.class) + .addClass(StatefulEJB.class) + .addClass(EJBClient1.class) + .addClass(EJBClient2.class) + .addAsManifestResource(EmptyAsset.INSTANCE, "beans.xml"); + } + +} diff --git a/ejb/ejb-session-beans/src/test/java/com/baeldung/ejb/test/stateless/StatelessEJBTest.java b/ejb/ejb-session-beans/src/test/java/com/baeldung/ejb/test/stateless/StatelessEJBTest.java new file mode 100644 index 0000000000..9f88d478b7 --- /dev/null +++ b/ejb/ejb-session-beans/src/test/java/com/baeldung/ejb/test/stateless/StatelessEJBTest.java @@ -0,0 +1,62 @@ +package com.baeldung.ejb.test.stateless; + +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.asset.EmptyAsset; +import org.jboss.shrinkwrap.api.spec.JavaArchive; +import org.junit.Assert; +import org.junit.Test; +import org.junit.runner.RunWith; + +import com.baeldung.ejb.stateless.EJBClient1; +import com.baeldung.ejb.stateless.EJBClient2; +import com.baeldung.ejb.stateless.StatelessEJB; + +import javax.inject.Inject; + + +@RunWith(Arquillian.class) +public class StatelessEJBTest { + + @Inject + private EJBClient1 ejbClient1; + + @Inject + private EJBClient2 ejbClient2; + + @Test + public void givenOneStatelessBean_whenStateIsSetInOneBean_secondBeanShouldHaveSameState() { + + // act + ejbClient1.statelessEJB.name = "Client 1"; + + // assert + Assert.assertEquals("Client 1", ejbClient1.statelessEJB.name); + Assert.assertEquals("Client 1", ejbClient2.statelessEJB.name); + + } + + + @Test + public void givenOneStatelessBean_whenStateIsSetInBothBeans_secondBeanShouldHaveSecondBeanState() { + + // act + ejbClient1.statelessEJB.name = "Client 1"; + ejbClient2.statelessEJB.name = "Client 2"; + + // assert + Assert.assertEquals("Client 2", ejbClient2.statelessEJB.name); + + } + + @Deployment + public static JavaArchive createDeployment() { + return ShrinkWrap.create(JavaArchive.class) + .addClass(StatelessEJB.class) + .addClass(EJBClient1.class) + .addClass(EJBClient2.class) + .addAsManifestResource(EmptyAsset.INSTANCE, "beans.xml"); + } + +} diff --git a/ejb/pom.xml b/ejb/pom.xml index 9495020266..b8aa32fab1 100755 --- a/ejb/pom.xml +++ b/ejb/pom.xml @@ -40,7 +40,12 @@ 1.0-SNAPSHOT ejb - + + com.baeldung.ejb + ejb-session-beans + 1.0-SNAPSHOT + ejb + javax javaee-api @@ -75,5 +80,7 @@ ejb-remote ejb-client + ejb-session-beans + ejb-session-beans-client \ No newline at end of file diff --git a/hibernate5/pom.xml b/hibernate5/pom.xml index 63e0799281..c501b7f11d 100644 --- a/hibernate5/pom.xml +++ b/hibernate5/pom.xml @@ -15,6 +15,8 @@ http://maven.apache.org UTF-8 + + 3.6.0 @@ -22,6 +24,11 @@ hibernate-core 5.2.9.Final + + junit + junit + 4.12 + com.h2database h2 @@ -37,6 +44,32 @@ + + + org.apache.maven.plugins + maven-compiler-plugin + ${maven-compiler-plugin.version} + + 1.8 + 1.8 + + + + + org.apache.maven.plugins + maven-surefire-plugin + + 3 + true + + **/*IntegrationTest.java + **/*LiveTest.java + + + + + + diff --git a/hibernate5/src/main/java/com/baeldung/hibernate/HibernateMultiTenantUtil.java b/hibernate5/src/main/java/com/baeldung/hibernate/HibernateMultiTenantUtil.java index c3e7b621d0..5a10b2ba56 100644 --- a/hibernate5/src/main/java/com/baeldung/hibernate/HibernateMultiTenantUtil.java +++ b/hibernate5/src/main/java/com/baeldung/hibernate/HibernateMultiTenantUtil.java @@ -1,5 +1,9 @@ package com.baeldung.hibernate; +import java.io.FileInputStream; +import java.io.FileNotFoundException; +import java.io.IOException; +import java.net.URL; import java.util.HashMap; import java.util.Map; import java.util.Properties; @@ -20,44 +24,56 @@ import com.baeldung.hibernate.pojo.Supplier; public class HibernateMultiTenantUtil { private static SessionFactory sessionFactory; private static Map connectionProviderMap = new HashMap<>(); - private static final String[] tenantDBNames = { "mydb1","mydb2"}; + private static final String[] tenantDBNames = { "mydb1", "mydb2" }; - public static SessionFactory getSessionFactory() throws UnsupportedTenancyException { + public static SessionFactory getSessionFactory() throws UnsupportedTenancyException, IOException { if (sessionFactory == null) { - Configuration configuration = new Configuration().configure(); - ServiceRegistry serviceRegistry = configureServiceRegistry(configuration); - sessionFactory = makeSessionFactory (serviceRegistry); -// sessionFactory = configuration.buildSessionFactory(serviceRegistry); - - + // Configuration configuration = new Configuration().configure(); + ServiceRegistry serviceRegistry = configureServiceRegistry(); + sessionFactory = makeSessionFactory(serviceRegistry); + } return sessionFactory; } private static SessionFactory makeSessionFactory(ServiceRegistry serviceRegistry) { - MetadataSources metadataSources = new MetadataSources( serviceRegistry ); - for(Class annotatedClasses : getAnnotatedClasses()) { - metadataSources.addAnnotatedClass( annotatedClasses ); + MetadataSources metadataSources = new MetadataSources(serviceRegistry); + for (Class annotatedClasses : getAnnotatedClasses()) { + metadataSources.addAnnotatedClass(annotatedClasses); } Metadata metadata = metadataSources.buildMetadata(); - return metadata.getSessionFactoryBuilder().build(); - + return metadata.getSessionFactoryBuilder() + .build(); + } private static Class[] getAnnotatedClasses() { - return new Class[] { - Supplier.class - }; + return new Class[] { Supplier.class }; } - private static ServiceRegistry configureServiceRegistry(Configuration configuration) throws UnsupportedTenancyException { - Properties properties = configuration.getProperties(); + private static ServiceRegistry configureServiceRegistry() throws UnsupportedTenancyException, IOException { + + // Properties properties = configuration.getProperties(); + Properties properties = getProperties(); connectionProviderMap = setUpConnectionProviders(properties, tenantDBNames); properties.put(AvailableSettings.MULTI_TENANT_CONNECTION_PROVIDER, new ConfigurableMultiTenantConnectionProvider(connectionProviderMap)); - return new StandardServiceRegistryBuilder().applySettings(properties).build(); + return new StandardServiceRegistryBuilder().applySettings(properties) + .build(); + } + + private static Properties getProperties() throws IOException { + Properties properties = new Properties(); + URL propertiesURL = Thread.currentThread() + .getContextClassLoader() + .getResource("hibernate.properties"); + FileInputStream inputStream = new FileInputStream(propertiesURL.getFile()); + properties.load(inputStream); + System.out.println("LOADED PROPERTIES FROM hibernate.properties"); + + return properties; } private static Map setUpConnectionProviders(Properties properties, String[] tenantNames) throws UnsupportedTenancyException { @@ -66,23 +82,27 @@ public class HibernateMultiTenantUtil { DriverManagerConnectionProviderImpl connectionProvider = new DriverManagerConnectionProviderImpl(); String tenantStrategy = properties.getProperty("hibernate.multiTenancy"); - System.out.println("Strategy:"+tenantStrategy); + System.out.println("Strategy:" + tenantStrategy); properties.put(Environment.URL, tenantUrl(properties.getProperty(Environment.URL), tenant, tenantStrategy)); - System.out.println("URL:"+properties.getProperty(Environment.URL)); + System.out.println("URL:" + properties.getProperty(Environment.URL)); connectionProvider.configure(properties); - System.out.println("Tenant:"+tenant); + System.out.println("Tenant:" + tenant); providerMap.put(tenant, connectionProvider); - + } System.out.println("Added connections for:"); - providerMap.keySet().stream().forEach(System.out::println); + providerMap.keySet() + .stream() + .forEach(System.out::println); return providerMap; } private static Object tenantUrl(String originalUrl, String tenant, String tenantStrategy) throws UnsupportedTenancyException { - if (tenantStrategy.toUpperCase().equals("DATABASE")) { + if (tenantStrategy.toUpperCase() + .equals("DATABASE")) { return originalUrl.replace(DEFAULT_DB_NAME, tenant); - } else if (tenantStrategy.toUpperCase().equals("SCHEMA")) { + } else if (tenantStrategy.toUpperCase() + .equals("SCHEMA")) { return originalUrl + String.format(SCHEMA_TOKEN, tenant); } else { throw new UnsupportedTenancyException("Not yet supported"); diff --git a/hibernate5/src/main/resources/hibernate.cfg.xml b/hibernate5/src/main/resources/hibernate.cfg.xml deleted file mode 100644 index 26be05f931..0000000000 --- a/hibernate5/src/main/resources/hibernate.cfg.xml +++ /dev/null @@ -1,14 +0,0 @@ - - - - - org.h2.Driver - jdbc:h2:mem:mydb1;DB_CLOSE_DELAY=-1 - sa - - org.hibernate.dialect.H2Dialect - DATABASE - - diff --git a/hibernate5/src/main/resources/hibernate.properties b/hibernate5/src/main/resources/hibernate.properties new file mode 100644 index 0000000000..a8f927a280 --- /dev/null +++ b/hibernate5/src/main/resources/hibernate.properties @@ -0,0 +1,8 @@ +hibernate.connection.driver_class=org.h2.Driver +hibernate.connection.url=jdbc:h2:mem:mydb1;DB_CLOSE_DELAY=-1 +hibernate.connection.username=sa +jdbc.password= + +hibernate.dialect=org.hibernate.dialect.H2Dialect +hibernate.show_sql=true +hibernate.multiTenancy=DATABASE diff --git a/hibernate5/src/test/java/com/baeldung/hibernate/MultiTenantHibernateIntegrationTest.java b/hibernate5/src/test/java/com/baeldung/hibernate/MultiTenantHibernateIntegrationTest.java index 8f2e88ac3d..610617cb8d 100644 --- a/hibernate5/src/test/java/com/baeldung/hibernate/MultiTenantHibernateIntegrationTest.java +++ b/hibernate5/src/test/java/com/baeldung/hibernate/MultiTenantHibernateIntegrationTest.java @@ -1,65 +1,71 @@ package com.baeldung.hibernate; -import com.baeldung.hibernate.pojo.Supplier; -import org.hibernate.Session; -import org.hibernate.SessionFactory; -import org.hibernate.Transaction; -import org.junit.Test; import static org.junit.Assert.assertNotEquals; +import java.io.IOException; +import java.sql.Connection; +import java.sql.DriverManager; +import java.sql.SQLException; +import java.sql.Statement; + +import org.hibernate.Session; +import org.hibernate.SessionFactory; +import org.hibernate.Transaction; +import org.junit.Before; +import org.junit.Test; + +import com.baeldung.hibernate.pojo.Supplier; public class MultiTenantHibernateIntegrationTest { @Test - public void givenDBMode_whenFetchingSuppliers_thenComparingFromDbs () { - SessionFactory sessionFactory; - try { - sessionFactory = HibernateMultiTenantUtil.getSessionFactory(); - - Session db1Session = sessionFactory - .withOptions().tenantIdentifier("mydb1").openSession(); - - initDb1(db1Session); - - Transaction transaction = db1Session.getTransaction(); - transaction.begin(); - Supplier supplierFromDB1 = (Supplier)db1Session.createCriteria(Supplier.class).list().get(0); - transaction.commit(); - - Session db2Session = sessionFactory - .withOptions().tenantIdentifier("mydb2").openSession(); - - initDb2(db2Session); - db2Session.getTransaction().begin(); - Supplier supplierFromDB2 = (Supplier) db2Session.createCriteria(Supplier.class).list().get(0); - db2Session.getTransaction().commit(); - - System.out.println(supplierFromDB1); - System.out.println(supplierFromDB2); - - assertNotEquals(supplierFromDB1, supplierFromDB2); - } catch (UnsupportedTenancyException e) { - e.printStackTrace(); - } + public void givenDBMode_whenFetchingSuppliers_thenComparingFromDbs() throws UnsupportedTenancyException, IOException { + SessionFactory sessionFactory = HibernateMultiTenantUtil.getSessionFactory(); + + Session db1Session = sessionFactory.withOptions().tenantIdentifier("mydb1").openSession(); + + initDb1(db1Session); + + Transaction transaction = db1Session.getTransaction(); + transaction.begin(); + Supplier supplierFromDB1 = (Supplier) db1Session.createCriteria(Supplier.class).list().get(0); + transaction.commit(); + + Session db2Session = sessionFactory.withOptions().tenantIdentifier("mydb2").openSession(); + + initDb2(db2Session); + db2Session.getTransaction().begin(); + Supplier supplierFromDB2 = (Supplier) db2Session.createCriteria(Supplier.class).list().get(0); + db2Session.getTransaction().commit(); + + System.out.println(supplierFromDB1); + System.out.println(supplierFromDB2); + + assertNotEquals(supplierFromDB1, supplierFromDB2); + } - - private void initDb1(Session db1Session) { System.out.println("Init DB1"); Transaction transaction = db1Session.getTransaction(); transaction.begin(); db1Session.createSQLQuery("DROP ALL OBJECTS").executeUpdate(); - db1Session.createSQLQuery("create table Supplier (id integer generated by default as identity, country varchar(255), name varchar(255), primary key (id))").executeUpdate(); + db1Session + .createSQLQuery( + "create table Supplier (id integer generated by default as identity, country varchar(255), name varchar(255), primary key (id))") + .executeUpdate(); db1Session.createSQLQuery("insert into Supplier (id, country, name) values (null, 'John', 'USA')").executeUpdate(); transaction.commit(); } - + private void initDb2(Session db2Session) { System.out.println("Init DB2"); Transaction transaction = db2Session.getTransaction(); transaction.begin(); db2Session.createSQLQuery("DROP ALL OBJECTS").executeUpdate(); - db2Session.createSQLQuery("create table Supplier (id integer generated by default as identity, country varchar(255), name varchar(255), primary key (id))").executeUpdate(); + db2Session + .createSQLQuery( + "create table Supplier (id integer generated by default as identity, country varchar(255), name varchar(255), primary key (id))") + .executeUpdate(); db2Session.createSQLQuery("insert into Supplier (id, country, name) values (null, 'Miller', 'UK')").executeUpdate(); transaction.commit(); } diff --git a/hibernate5/src/test/java/hibernate.properties b/hibernate5/src/test/java/hibernate.properties new file mode 100644 index 0000000000..a8f927a280 --- /dev/null +++ b/hibernate5/src/test/java/hibernate.properties @@ -0,0 +1,8 @@ +hibernate.connection.driver_class=org.h2.Driver +hibernate.connection.url=jdbc:h2:mem:mydb1;DB_CLOSE_DELAY=-1 +hibernate.connection.username=sa +jdbc.password= + +hibernate.dialect=org.hibernate.dialect.H2Dialect +hibernate.show_sql=true +hibernate.multiTenancy=DATABASE diff --git a/junit5/src/test/java/com/baeldung/DynamicTestsExample.java b/junit5/src/test/java/com/baeldung/DynamicTestsExample.java index 6a97f2347b..fd6bb3e0a8 100644 --- a/junit5/src/test/java/com/baeldung/DynamicTestsExample.java +++ b/junit5/src/test/java/com/baeldung/DynamicTestsExample.java @@ -3,7 +3,6 @@ package com.baeldung; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertTrue; -import java.util.ArrayList; import java.util.Arrays; import java.util.Collection; import java.util.HashMap; @@ -56,32 +55,12 @@ public class DynamicTestsExample { // sample input and output List inputList = - new ArrayList<>(Arrays.asList("www.somedomain.com", "www.anotherdomain.com", "www.yetanotherdomain.com")); + Arrays.asList("www.somedomain.com", "www.anotherdomain.com", "www.yetanotherdomain.com"); List outputList = - new ArrayList<>(Arrays.asList("154.174.10.56", "211.152.104.132", "178.144.120.156")); + Arrays.asList("154.174.10.56", "211.152.104.132", "178.144.120.156"); // input generator that generates inputs using inputList - Iterator inputGenerator = new Iterator() { - - String current; - int size = inputList.size(); - int index = 0; - - @Override - public boolean hasNext() { - if(index == size) { - return false; - } - current = inputList.get(index); - index++; - return true; - } - - @Override - public String next() { - return current; - } - }; + Iterator inputGenerator = inputList.iterator(); // a display name generator that creates a different name based on the input Function displayNameGenerator = (input) -> "Resolving: " + input; diff --git a/libraries/pom.xml b/libraries/pom.xml index a4b554365d..ff1997e969 100644 --- a/libraries/pom.xml +++ b/libraries/pom.xml @@ -276,6 +276,16 @@ 2.3.0 + + one.util + streamex + 0.6.5 + + + org.jooq + jool + 0.9.12 + 0.7.0 diff --git a/libraries/src/test/java/com/baeldung/stream/JoolMergeStreamsTest.java b/libraries/src/test/java/com/baeldung/stream/JoolMergeStreamsTest.java new file mode 100644 index 0000000000..e73861d8af --- /dev/null +++ b/libraries/src/test/java/com/baeldung/stream/JoolMergeStreamsTest.java @@ -0,0 +1,35 @@ +package com.baeldung.stream; + +import org.jooq.lambda.Seq; +import org.junit.Assert; +import org.junit.Test; + +import java.util.Arrays; + +import static junit.framework.TestCase.assertEquals; + +public class JoolMergeStreamsTest { + @Test + public void givenTwoStreams_whenMergingStreams_thenResultingStreamContainsElementsFromBothStreams() { + Seq seq1 = Seq.of(1, 3, 5); + Seq seq2 = Seq.of(2, 4, 6); + + Seq resultingSeq = seq1.append(seq2); + + assertEquals(Arrays.asList(1, 3, 5, 2, 4, 6), + resultingSeq.toList()); + } + + @Test + public void givenThreeStreams_whenAppendingAndPrependingStreams_thenResultingStreamContainsElementsFromAllStreams() { + Seq seq = Seq.of("foo", "bar"); + Seq openingBracketSeq = Seq.of("["); + Seq closingBracketSeq = Seq.of("]"); + + Seq resultingStream = seq.append(closingBracketSeq) + .prepend(openingBracketSeq); + + Assert.assertEquals(Arrays.asList("[", "foo", "bar", "]"), + resultingStream.toList()); + } +} \ No newline at end of file diff --git a/libraries/src/test/java/com/baeldung/stream/MergeStreamsTest.java b/libraries/src/test/java/com/baeldung/stream/MergeStreamsTest.java new file mode 100644 index 0000000000..217d2b5b64 --- /dev/null +++ b/libraries/src/test/java/com/baeldung/stream/MergeStreamsTest.java @@ -0,0 +1,53 @@ +package com.baeldung.stream; + +import org.junit.Test; + +import java.util.Arrays; +import java.util.function.Function; +import java.util.stream.Collectors; +import java.util.stream.Stream; + +import static org.junit.Assert.assertEquals; + +public class MergeStreamsTest { + + @Test + public void givenTwoStreams_whenMergingStreams_thenResultingStreamContainsElementsFromBothStreams() { + Stream stream1 = Stream.of(1, 3, 5); + Stream stream2 = Stream.of(2, 4, 6); + + Stream resultingStream = Stream.concat(stream1, + stream2); + + assertEquals(Arrays.asList(1, 3, 5, 2, 4, 6), + resultingStream.collect(Collectors.toList())); + } + + @Test + public void givenThreeStreams_whenMergingStreams_thenResultingStreamContainsElementsFromAllStreams() { + Stream stream1 = Stream.of(1, 3, 5); + Stream stream2 = Stream.of(2, 4, 6); + Stream stream3 = Stream.of(18, 15, 36); + + Stream resultingStream = Stream.concat(Stream.concat(stream1, + stream2), + stream3); + + assertEquals(Arrays.asList(1, 3, 5, 2, 4, 6, 18, 15, 36), + resultingStream.collect(Collectors.toList())); + } + + @Test + public void givenFourStreams_whenMergingStreams_thenResultingStreamContainsElementsFromAllStreams() { + Stream stream1 = Stream.of(1, 3, 5); + Stream stream2 = Stream.of(2, 4, 6); + Stream stream3 = Stream.of(18, 15, 36); + Stream stream4 = Stream.of(99); + + Stream resultingStream = Stream.of(stream1, stream2, stream3, stream4).flatMap(Function.identity()); + + assertEquals(Arrays.asList(1, 3, 5, 2, 4, 6, 18, 15, 36, 99), + resultingStream.collect(Collectors.toList())); + + } +} \ No newline at end of file diff --git a/libraries/src/test/java/com/baeldung/stream/StreamExMergeStreamsTest.java b/libraries/src/test/java/com/baeldung/stream/StreamExMergeStreamsTest.java new file mode 100644 index 0000000000..a964d76e8a --- /dev/null +++ b/libraries/src/test/java/com/baeldung/stream/StreamExMergeStreamsTest.java @@ -0,0 +1,51 @@ +package com.baeldung.stream; + +import one.util.streamex.StreamEx; +import org.junit.Test; + +import java.util.Arrays; + +import static org.junit.Assert.assertEquals; + +public class StreamExMergeStreamsTest { + + @Test + public void givenTwoStreams_whenMergingStreams_thenResultingStreamContainsElementsFromBothStreams() { + StreamEx stream1 = StreamEx.of(1, 3, 5); + StreamEx stream2 = StreamEx.of(2, 4, 6); + + StreamEx resultingStream = stream1.append(stream2); + + assertEquals(Arrays.asList(1, 3, 5, 2, 4, 6), + resultingStream.toList()); + } + + @Test + public void givenFourStreams_whenMergingStreams_thenResultingStreamContainsElementsFromAllStreams() { + StreamEx stream1 = StreamEx.of(1, 3, 5); + StreamEx stream2 = StreamEx.of(2, 4, 6); + StreamEx stream3 = StreamEx.of(18, 15, 36); + StreamEx stream4 = StreamEx.of(99); + + StreamEx resultingStream = stream1.append(stream2) + .append(stream3) + .append(stream4); + + assertEquals(Arrays.asList(1, 3, 5, 2, 4, 6, 18, 15, 36, 99), + resultingStream.toList()); + + } + + @Test + public void givenThreeStreams_whenAppendingAndPrependingStreams_thenResultingStreamContainsElementsFromAllStreams() { + StreamEx stream1 = StreamEx.of("foo", "bar"); + StreamEx openingBracketStream = StreamEx.of("["); + StreamEx closingBracketStream = StreamEx.of("]"); + + StreamEx resultingStream = stream1.append(closingBracketStream) + .prepend(openingBracketStream); + + assertEquals(Arrays.asList("[", "foo", "bar", "]"), + resultingStream.toList()); + } +} diff --git a/pom.xml b/pom.xml index d1b27bc9c9..e6e11326d7 100644 --- a/pom.xml +++ b/pom.xml @@ -122,6 +122,7 @@ solr spark-java spring-5 + spring-5-mvc spring-akka spring-amqp spring-all diff --git a/spring-5-mvc/.gitignore b/spring-5-mvc/.gitignore new file mode 100644 index 0000000000..b7b5c734f2 --- /dev/null +++ b/spring-5-mvc/.gitignore @@ -0,0 +1,20 @@ +*.class + +# Mobile Tools for Java (J2ME) +.mtj.tmp/ + +.settings/ +.classpath +.project +target/ + +*.iml +.idea + +# Package Files # +*.jar +*.war +*.ear + +# virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml +hs_err_pid* diff --git a/spring-5-mvc/pom.xml b/spring-5-mvc/pom.xml new file mode 100644 index 0000000000..b8c341afde --- /dev/null +++ b/spring-5-mvc/pom.xml @@ -0,0 +1,154 @@ + + + 4.0.0 + + com.baeldung + spring-5-mvc + 0.0.1-SNAPSHOT + jar + + spring-5-mvc + spring 5 MVC sample project about new features + + + org.springframework.boot + spring-boot-starter-parent + 2.0.0.M1 + + + + + + org.springframework.boot + spring-boot-starter-data-jpa + + + org.springframework.boot + spring-boot-starter-security + + + org.springframework.boot + spring-boot-starter-validation + + + org.springframework.boot + spring-boot-starter-web + + + + + + org.apache.commons + commons-lang3 + + + org.slf4j + slf4j-api + + + org.slf4j + jcl-over-slf4j + + + + + + org.springframework.boot + spring-boot-devtools + runtime + + + com.h2database + h2 + runtime + + + + org.springframework + spring-test + + + org.springframework.boot + spring-boot-starter-test + test + + + + junit + junit + test + + + + com.jayway.restassured + rest-assured + ${rest-assured.version} + test + + + + + + + + org.apache.maven.plugins + maven-surefire-plugin + + true + false + + **/*IntegrationTest.java + **/*LiveTest.java + + + + + + + + + + spring-snapshots + Spring Snapshots + https://repo.spring.io/snapshot + + true + + + + spring-milestones + Spring Milestones + https://repo.spring.io/milestone + + false + + + + + + spring-snapshots + Spring Snapshots + https://repo.spring.io/snapshot + + true + + + + spring-milestones + Spring Milestones + https://repo.spring.io/milestone + + false + + + + + + 2.9.0 + UTF-8 + UTF-8 + 1.8 + + + diff --git a/spring-5-mvc/src/main/java/com/baeldung/Spring5Application.java b/spring-5-mvc/src/main/java/com/baeldung/Spring5Application.java new file mode 100644 index 0000000000..41b5c1eed1 --- /dev/null +++ b/spring-5-mvc/src/main/java/com/baeldung/Spring5Application.java @@ -0,0 +1,13 @@ +package com.baeldung; + +import org.springframework.boot.SpringApplication; +import org.springframework.boot.autoconfigure.SpringBootApplication; + +@SpringBootApplication +public class Spring5Application { + + public static void main(String[] args) { + SpringApplication.run(Spring5Application.class, args); + } + +} diff --git a/spring-5-mvc/src/main/java/com/baeldung/model/Foo.java b/spring-5-mvc/src/main/java/com/baeldung/model/Foo.java new file mode 100644 index 0000000000..a9ffee14da --- /dev/null +++ b/spring-5-mvc/src/main/java/com/baeldung/model/Foo.java @@ -0,0 +1,84 @@ +package com.baeldung.model; + +import javax.persistence.Entity; +import javax.persistence.GeneratedValue; +import javax.persistence.GenerationType; +import javax.persistence.Id; + +@Entity +public class Foo { + + @Id + @GeneratedValue(strategy = GenerationType.AUTO) + private Long id; + + private String name; + + public Foo() { + super(); + } + + public Foo(final String name) { + super(); + + this.name = name; + } + + public Foo(final long id, final String name) { + super(); + + this.id = id; + this.name = name; + } + + // API + + public String getName() { + return name; + } + + public Long getId() { + return id; + } + + public void setId(Long id) { + this.id = id; + } + + public void setName(final String name) { + this.name = name; + } + + // + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + result = prime * result + ((name == null) ? 0 : name.hashCode()); + return result; + } + + @Override + public boolean equals(Object obj) { + if (this == obj) + return true; + if (obj == null) + return false; + if (getClass() != obj.getClass()) + return false; + Foo other = (Foo) obj; + if (name == null) { + if (other.name != null) + return false; + } else if (!name.equals(other.name)) + return false; + return true; + } + + @Override + public String toString() { + return "Foo [name=" + name + "]"; + } + +} \ No newline at end of file diff --git a/spring-5-mvc/src/main/java/com/baeldung/persistence/DataSetupBean.java b/spring-5-mvc/src/main/java/com/baeldung/persistence/DataSetupBean.java new file mode 100644 index 0000000000..cf78977961 --- /dev/null +++ b/spring-5-mvc/src/main/java/com/baeldung/persistence/DataSetupBean.java @@ -0,0 +1,26 @@ +package com.baeldung.persistence; + +import static org.apache.commons.lang3.RandomStringUtils.randomAlphabetic; + +import java.util.stream.IntStream; + +import org.springframework.beans.factory.InitializingBean; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Component; + +import com.baeldung.model.Foo; + +@Component +public class DataSetupBean implements InitializingBean { + + @Autowired + private FooRepository repo; + + // + + @Override + public void afterPropertiesSet() throws Exception { + IntStream.range(1, 5).forEach(i -> repo.save(new Foo(randomAlphabetic(8)))); + } + +} diff --git a/spring-5-mvc/src/main/java/com/baeldung/persistence/FooRepository.java b/spring-5-mvc/src/main/java/com/baeldung/persistence/FooRepository.java new file mode 100644 index 0000000000..3c70f38fce --- /dev/null +++ b/spring-5-mvc/src/main/java/com/baeldung/persistence/FooRepository.java @@ -0,0 +1,10 @@ +package com.baeldung.persistence; + +import org.springframework.data.jpa.repository.JpaRepository; +import org.springframework.data.jpa.repository.JpaSpecificationExecutor; + +import com.baeldung.model.Foo; + +public interface FooRepository extends JpaRepository, JpaSpecificationExecutor { + +} diff --git a/spring-5-mvc/src/main/java/com/baeldung/web/FooController.java b/spring-5-mvc/src/main/java/com/baeldung/web/FooController.java new file mode 100644 index 0000000000..137864cddd --- /dev/null +++ b/spring-5-mvc/src/main/java/com/baeldung/web/FooController.java @@ -0,0 +1,66 @@ +package com.baeldung.web; + +import java.util.List; + +import javax.validation.constraints.Max; +import javax.validation.constraints.Min; + +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.data.domain.PageRequest; +import org.springframework.http.HttpStatus; +import org.springframework.validation.annotation.Validated; +import org.springframework.web.bind.annotation.GetMapping; +import org.springframework.web.bind.annotation.PathVariable; +import org.springframework.web.bind.annotation.PostMapping; +import org.springframework.web.bind.annotation.PutMapping; +import org.springframework.web.bind.annotation.RequestBody; +import org.springframework.web.bind.annotation.RequestParam; +import org.springframework.web.bind.annotation.ResponseStatus; +import org.springframework.web.bind.annotation.RestController; +import org.springframework.web.server.ResponseStatusException; + +import com.baeldung.model.Foo; +import com.baeldung.persistence.FooRepository; + +@RestController +public class FooController { + + @Autowired + private FooRepository repo; + + // API - read + + @GetMapping("/foos/{id}") + @Validated + public Foo findById(@PathVariable @Min(0) final long id) { + return repo.findById(id).orElse(null); + } + + @GetMapping("/foos") + public List findAll() { + return repo.findAll(); + } + + @GetMapping( value="/foos", params = { "page", "size" }) + @Validated + public List findPaginated(@RequestParam("page") @Min(0) final int page, @Max(100) @RequestParam("size") final int size) { + return repo.findAll(PageRequest.of(page, size)).getContent(); + } + + // API - write + + @PutMapping("/foos/{id}") + @ResponseStatus(HttpStatus.OK) + public Foo update(@PathVariable("id") final String id, @RequestBody final Foo foo) { + return foo; + } + + @PostMapping("/foos") + @ResponseStatus(HttpStatus.CREATED) + public void create( @RequestBody final Foo foo) { + if (null == foo || null == foo.getName()) { + throw new ResponseStatusException(HttpStatus.BAD_REQUEST," 'name' is required"); + } + repo.save(foo); + } +} \ No newline at end of file diff --git a/spring-5-mvc/src/main/resources/application.properties b/spring-5-mvc/src/main/resources/application.properties new file mode 100644 index 0000000000..886ea1978b --- /dev/null +++ b/spring-5-mvc/src/main/resources/application.properties @@ -0,0 +1,6 @@ +server.port=8081 + +security.user.name=user +security.user.password=pass + +logging.level.root=INFO \ No newline at end of file diff --git a/spring-5-mvc/src/main/webapp/WEB-INF/web.xml b/spring-5-mvc/src/main/webapp/WEB-INF/web.xml new file mode 100644 index 0000000000..bfcf43dad2 --- /dev/null +++ b/spring-5-mvc/src/main/webapp/WEB-INF/web.xml @@ -0,0 +1,21 @@ + + + + Spring Functional Application + + + functional + com.baeldung.functional.RootServlet + 1 + true + + + functional + / + + + + \ No newline at end of file diff --git a/spring-5-mvc/src/test/java/com/baeldung/test/LiveTest.java b/spring-5-mvc/src/test/java/com/baeldung/test/LiveTest.java new file mode 100644 index 0000000000..f6dd921b25 --- /dev/null +++ b/spring-5-mvc/src/test/java/com/baeldung/test/LiveTest.java @@ -0,0 +1,54 @@ +package com.baeldung.test; + +import static org.apache.commons.lang3.RandomStringUtils.randomAlphabetic; +import static org.junit.Assert.assertEquals; + +import org.junit.Test; +import org.springframework.http.MediaType; + +import com.jayway.restassured.RestAssured; +import com.jayway.restassured.response.Response; +import com.jayway.restassured.specification.RequestSpecification; + +public class LiveTest { + + private static String APP_ROOT = "http://localhost:8081"; + + + @Test + public void givenUser_whenResourceCreatedWithNullName_then400BadRequest() { + final Response response = givenAuth("user", "pass").contentType(MediaType.APPLICATION_JSON.toString()).body(resourceWithNullName()).post(APP_ROOT + "/foos"); + assertEquals(400, response.getStatusCode()); + } + + @Test + public void givenUser_whenResourceCreated_then201Created() { + final Response response = givenAuth("user", "pass").contentType(MediaType.APPLICATION_JSON.toString()).body(resourceString()).post(APP_ROOT + "/foos"); + assertEquals(201, response.getStatusCode()); + } + + /*@Test + public void givenUser_whenGetAllFoos_thenOK() { + final Response response = givenAuth("user", "pass").get(APP_ROOT + "/foos"); + assertEquals(200, response.getStatusCode()); + }*/ + + + + // + + private final String resourceWithNullName() { + final String roleData = "{\"name\":null}"; + return roleData; + } + + private final String resourceString() { + final String roleData = "{\"name\":\"" + randomAlphabetic(8) + "\"}"; + return roleData; + } + + private final RequestSpecification givenAuth(String username, String password) { + return RestAssured.given().auth().preemptive().basic(username, password); + } + +} \ No newline at end of file diff --git a/spring-5-mvc/src/test/java/com/baeldung/test/Spring5ApplicationIntegrationTest.java b/spring-5-mvc/src/test/java/com/baeldung/test/Spring5ApplicationIntegrationTest.java new file mode 100644 index 0000000000..c3790333ff --- /dev/null +++ b/spring-5-mvc/src/test/java/com/baeldung/test/Spring5ApplicationIntegrationTest.java @@ -0,0 +1,18 @@ +package com.baeldung.test; + +import org.junit.Test; +import org.junit.runner.RunWith; +import org.springframework.boot.test.context.SpringBootTest; +import org.springframework.test.context.junit4.SpringRunner; + +import com.baeldung.Spring5Application; + +@RunWith(SpringRunner.class) +@SpringBootTest(classes = Spring5Application.class) +public class Spring5ApplicationIntegrationTest { + + @Test + public void contextLoads() { + } + +} diff --git a/spring-core/pom.xml b/spring-core/pom.xml index 16984a387b..70002bf3c1 100644 --- a/spring-core/pom.xml +++ b/spring-core/pom.xml @@ -58,6 +58,12 @@ lombok ${lombok.version} + + org.springframework.boot + spring-boot-test + ${mockito.spring.boot.version} + test + @@ -112,6 +118,7 @@ 1.10.19 + 1.4.4.RELEASE 4.3.4.RELEASE 1 20.0 diff --git a/spring-core/src/main/java/com/baeldung/beaninjection/FileReader.java b/spring-core/src/main/java/com/baeldung/beaninjection/FileReader.java new file mode 100644 index 0000000000..7ea64e2ce6 --- /dev/null +++ b/spring-core/src/main/java/com/baeldung/beaninjection/FileReader.java @@ -0,0 +1,19 @@ +package com.baeldung.beaninjection; + +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Component; + +@Component +public class FileReader { + + @Autowired + private Location location; + + public Location getLocation() { + return location; + } + + public void setLocation(Location location) { + this.location = location; + } +} diff --git a/spring-core/src/main/java/com/baeldung/beaninjection/FtpReader.java b/spring-core/src/main/java/com/baeldung/beaninjection/FtpReader.java new file mode 100644 index 0000000000..259710ce94 --- /dev/null +++ b/spring-core/src/main/java/com/baeldung/beaninjection/FtpReader.java @@ -0,0 +1,28 @@ +package com.baeldung.beaninjection; + +public class FtpReader { + private String ftpHost = null; + private Integer ftpPort = null; + + // Constructor with arguments + public FtpReader(String host, Integer port) { + this.ftpHost = host; + this.ftpPort = port; + } + + public String getFtpHost() { + return ftpHost; + } + + public void setFtpHost(String ftpHost) { + this.ftpHost = ftpHost; + } + + public Integer getFtpPort() { + return ftpPort; + } + + public void setFtpPort(Integer ftpPort) { + this.ftpPort = ftpPort; + } +} diff --git a/spring-core/src/main/java/com/baeldung/beaninjection/Location.java b/spring-core/src/main/java/com/baeldung/beaninjection/Location.java new file mode 100644 index 0000000000..9ecab83ef6 --- /dev/null +++ b/spring-core/src/main/java/com/baeldung/beaninjection/Location.java @@ -0,0 +1,17 @@ +package com.baeldung.beaninjection; + +import org.springframework.stereotype.Component; + +@Component +public class Location { + private String filePath; + + public String getFilePath() { + return filePath; + } + + public void setFilePath(String filePath) { + this.filePath = filePath; + } + +} diff --git a/spring-core/src/main/java/com/baeldung/beaninjection/ReaderApplicationConfig.java b/spring-core/src/main/java/com/baeldung/beaninjection/ReaderApplicationConfig.java new file mode 100644 index 0000000000..cf4d91b1f5 --- /dev/null +++ b/spring-core/src/main/java/com/baeldung/beaninjection/ReaderApplicationConfig.java @@ -0,0 +1,15 @@ +package com.baeldung.beaninjection; + +import org.springframework.context.annotation.Bean; +import org.springframework.context.annotation.ComponentScan; +import org.springframework.context.annotation.Configuration; + +@Configuration +@ComponentScan(basePackages = { "com.baeldung.beaninjection" }) +public class ReaderApplicationConfig { + + @Bean + public FtpReader exampleDAO() { + return new FtpReader("localhost", 21); + } +} diff --git a/spring-core/src/main/java/com/baeldung/beaninjection/ReaderManager.java b/spring-core/src/main/java/com/baeldung/beaninjection/ReaderManager.java new file mode 100644 index 0000000000..155f2d6eea --- /dev/null +++ b/spring-core/src/main/java/com/baeldung/beaninjection/ReaderManager.java @@ -0,0 +1,33 @@ +package com.baeldung.beaninjection; + +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Component; + +@Component +public class ReaderManager { + private FileReader fileReader; + private FtpReader ftpReader; + + @Autowired + public ReaderManager(FtpReader ftpReader) { + this.ftpReader = ftpReader; + } + + @Autowired + public void setFileReader(FileReader fileReader) { + this.fileReader = fileReader; + } + + public FileReader getFileReader() { + return fileReader; + } + + public void setFtpReader(FtpReader ftpReader) { + this.ftpReader = ftpReader; + } + + public FtpReader getFtpReader() { + return ftpReader; + } + +} diff --git a/spring-core/src/main/java/com/baeldung/beaninjection/ReaderService.java b/spring-core/src/main/java/com/baeldung/beaninjection/ReaderService.java new file mode 100644 index 0000000000..60bdac61e5 --- /dev/null +++ b/spring-core/src/main/java/com/baeldung/beaninjection/ReaderService.java @@ -0,0 +1,14 @@ +package com.baeldung.beaninjection; + +public class ReaderService { + private FtpReader ftpReader; + + public void setFtpReader(FtpReader reader) { + this.ftpReader = reader; + } + + public FtpReader getFtpReader() { + return ftpReader; + } + +} diff --git a/spring-core/src/main/java/com/baeldung/value/ClassNotManagedBySpring.java b/spring-core/src/main/java/com/baeldung/value/ClassNotManagedBySpring.java new file mode 100644 index 0000000000..0329769d3c --- /dev/null +++ b/spring-core/src/main/java/com/baeldung/value/ClassNotManagedBySpring.java @@ -0,0 +1,28 @@ +package com.baeldung.value; + +public class ClassNotManagedBySpring { + + private String customVariable; + private String anotherCustomVariable; + + public ClassNotManagedBySpring(String someInitialValue, String anotherManagedValue) { + this.customVariable = someInitialValue; + this.anotherCustomVariable = anotherManagedValue; + } + + public String getCustomVariable() { + return customVariable; + } + + public void setCustomVariable(String customVariable) { + this.customVariable = customVariable; + } + + public String getAnotherCustomVariable() { + return anotherCustomVariable; + } + + public void setAnotherCustomVariable(String anotherCustomVariable) { + this.anotherCustomVariable = anotherCustomVariable; + } +} diff --git a/spring-core/src/main/java/com/baeldung/value/InitializerBean.java b/spring-core/src/main/java/com/baeldung/value/InitializerBean.java new file mode 100644 index 0000000000..8c8634c767 --- /dev/null +++ b/spring-core/src/main/java/com/baeldung/value/InitializerBean.java @@ -0,0 +1,21 @@ +package com.baeldung.value; + +import org.springframework.beans.factory.annotation.Value; +import org.springframework.stereotype.Component; + +@Component +public class InitializerBean { + + private String someInitialValue; + private String anotherManagedValue; + + public InitializerBean(@Value("someInitialValue") String someInitialValue, @Value("anotherValue") String anotherManagedValue) { + this.someInitialValue = someInitialValue; + this.anotherManagedValue = anotherManagedValue; + } + + public ClassNotManagedBySpring initClass() { + return new ClassNotManagedBySpring(this.someInitialValue, this.anotherManagedValue); + } + +} diff --git a/spring-core/src/main/resources/application.properties b/spring-core/src/main/resources/application.properties new file mode 100644 index 0000000000..fdc6536237 --- /dev/null +++ b/spring-core/src/main/resources/application.properties @@ -0,0 +1,2 @@ +someInitialValue=This is only sample value +anotherValue=Another configured value \ No newline at end of file diff --git a/spring-core/src/main/resources/injectiontypes.xml b/spring-core/src/main/resources/injectiontypes.xml new file mode 100644 index 0000000000..9dad1e300a --- /dev/null +++ b/spring-core/src/main/resources/injectiontypes.xml @@ -0,0 +1,15 @@ + + + + + + + + + + + + + \ No newline at end of file diff --git a/spring-core/src/test/java/com/baeldung/beaninjection/FileReaderTest.java b/spring-core/src/test/java/com/baeldung/beaninjection/FileReaderTest.java new file mode 100644 index 0000000000..f843fddd4d --- /dev/null +++ b/spring-core/src/test/java/com/baeldung/beaninjection/FileReaderTest.java @@ -0,0 +1,24 @@ +package com.baeldung.beaninjection; + +import static org.junit.Assert.assertNotNull; + +import org.junit.Test; +import org.junit.runner.RunWith; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.context.ApplicationContext; +import org.springframework.test.context.ContextConfiguration; +import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; + +@RunWith(SpringJUnit4ClassRunner.class) +@ContextConfiguration(classes = ReaderApplicationConfig.class) +public class FileReaderTest { + + @Autowired + private ApplicationContext context; + + @Test + public void testAutowiredAnnotation_WhenField_ThenInjected() { + FileReader service = context.getBean(FileReader.class); + assertNotNull(service.getLocation()); + } +} diff --git a/spring-core/src/test/java/com/baeldung/beaninjection/FtpReaderTest.java b/spring-core/src/test/java/com/baeldung/beaninjection/FtpReaderTest.java new file mode 100644 index 0000000000..a11afff9ea --- /dev/null +++ b/spring-core/src/test/java/com/baeldung/beaninjection/FtpReaderTest.java @@ -0,0 +1,25 @@ +package com.baeldung.beaninjection; + +import static org.junit.Assert.assertNotNull; + +import org.junit.Test; +import org.junit.runner.RunWith; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.context.ApplicationContext; +import org.springframework.test.context.ContextConfiguration; +import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; + +@RunWith(SpringJUnit4ClassRunner.class) +@ContextConfiguration(locations = "classpath:injectiontypes.xml") +public class FtpReaderTest { + + @Autowired + private ApplicationContext context; + + @Test + public void testXMLBeanConfig_WhenConstructorArguments_ThenInjected() { + FtpReader service = context.getBean(FtpReader.class); + assertNotNull(service.getFtpHost()); + assertNotNull(service.getFtpPort()); + } +} diff --git a/spring-core/src/test/java/com/baeldung/beaninjection/ReaderManagerTest.java b/spring-core/src/test/java/com/baeldung/beaninjection/ReaderManagerTest.java new file mode 100644 index 0000000000..7d85c0bf07 --- /dev/null +++ b/spring-core/src/test/java/com/baeldung/beaninjection/ReaderManagerTest.java @@ -0,0 +1,25 @@ +package com.baeldung.beaninjection; + +import static org.junit.Assert.assertNotNull; + +import org.junit.Test; +import org.junit.runner.RunWith; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.context.ApplicationContext; +import org.springframework.test.context.ContextConfiguration; +import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; + +@RunWith(SpringJUnit4ClassRunner.class) +@ContextConfiguration(classes = ReaderApplicationConfig.class) +public class ReaderManagerTest { + + @Autowired + private ApplicationContext context; + + @Test + public void testAutowiredAnnotation_WhenConstructorAndSetter_ThenInjected() { + ReaderManager service = context.getBean(ReaderManager.class); + assertNotNull(service.getFtpReader()); + assertNotNull(service.getFileReader()); + } +} diff --git a/spring-core/src/test/java/com/baeldung/beaninjection/ReaderServiceTest.java b/spring-core/src/test/java/com/baeldung/beaninjection/ReaderServiceTest.java new file mode 100644 index 0000000000..da4684ad4e --- /dev/null +++ b/spring-core/src/test/java/com/baeldung/beaninjection/ReaderServiceTest.java @@ -0,0 +1,24 @@ +package com.baeldung.beaninjection; + +import static org.junit.Assert.assertNotNull; + +import org.junit.Test; +import org.junit.runner.RunWith; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.context.ApplicationContext; +import org.springframework.test.context.ContextConfiguration; +import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; + +@RunWith(SpringJUnit4ClassRunner.class) +@ContextConfiguration(locations = "classpath:injectiontypes.xml") +public class ReaderServiceTest { + + @Autowired + private ApplicationContext context; + + @Test + public void testXMLBeanConfig_WhenSetter_ThenInjected() { + ReaderService service = context.getBean(ReaderService.class); + assertNotNull(service.getFtpReader()); + } +} diff --git a/spring-core/src/test/java/com/baeldung/value/ClassNotManagedBySpringTest.java b/spring-core/src/test/java/com/baeldung/value/ClassNotManagedBySpringTest.java new file mode 100644 index 0000000000..d07d490642 --- /dev/null +++ b/spring-core/src/test/java/com/baeldung/value/ClassNotManagedBySpringTest.java @@ -0,0 +1,40 @@ +package com.baeldung.value; + +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.springframework.boot.test.mock.mockito.MockBean; +import org.springframework.test.context.junit4.SpringRunner; + +import static junit.framework.TestCase.assertEquals; +import static org.mockito.Mockito.when; + +@RunWith(SpringRunner.class) +public class ClassNotManagedBySpringTest { + + @MockBean + private InitializerBean initializerBean; + + @Before + public void init() { + when(initializerBean.initClass()) + .thenReturn(new ClassNotManagedBySpring("This is only sample value", "Another configured value")); + } + + @Test + public void givenInitializerBean_whenInvokedInitClass_shouldInitialize() throws Exception { + + //given + ClassNotManagedBySpring classNotManagedBySpring = initializerBean.initClass(); + + //when + String initializedValue = classNotManagedBySpring.getCustomVariable(); + String anotherCustomVariable = classNotManagedBySpring.getAnotherCustomVariable(); + + //then + assertEquals("This is only sample value", initializedValue); + assertEquals("Another configured value", anotherCustomVariable); + + } + +} \ No newline at end of file diff --git a/structurizr/pom.xml b/structurizr/pom.xml new file mode 100644 index 0000000000..1656bb10ec --- /dev/null +++ b/structurizr/pom.xml @@ -0,0 +1,54 @@ + + + 4.0.0 + + com.baeldung + structurizr + + + com.baeldung + parent-modules + 1.0.0-SNAPSHOT + + + + 1.8 + 1.8 + + + + + com.structurizr + structurizr-core + 1.0.0-RC3 + + + com.structurizr + structurizr-spring + 1.0.0-RC3 + + + com.structurizr + structurizr-client + 0.6.0 + + + org.springframework + spring-context + 4.3.8.RELEASE + + + + + + + false + + central + bintray + http://jcenter.bintray.com + + + \ No newline at end of file diff --git a/structurizr/src/main/java/com/baeldung/structurizr/StructurizrSimple.java b/structurizr/src/main/java/com/baeldung/structurizr/StructurizrSimple.java new file mode 100644 index 0000000000..6eb0c7de73 --- /dev/null +++ b/structurizr/src/main/java/com/baeldung/structurizr/StructurizrSimple.java @@ -0,0 +1,155 @@ +package com.baeldung.structurizr; + +import java.io.File; +import java.io.StringWriter; + +import com.structurizr.Workspace; +import com.structurizr.api.StructurizrClient; +import com.structurizr.api.StructurizrClientException; +import com.structurizr.componentfinder.ComponentFinder; +import com.structurizr.componentfinder.ReferencedTypesSupportingTypesStrategy; +import com.structurizr.componentfinder.SourceCodeComponentFinderStrategy; +import com.structurizr.componentfinder.SpringComponentFinderStrategy; +import com.structurizr.io.WorkspaceWriterException; +import com.structurizr.io.plantuml.PlantUMLWriter; +import com.structurizr.model.Component; +import com.structurizr.model.Container; +import com.structurizr.model.Model; +import com.structurizr.model.Person; +import com.structurizr.model.SoftwareSystem; +import com.structurizr.model.Tags; +import com.structurizr.view.ComponentView; +import com.structurizr.view.ContainerView; +import com.structurizr.view.Routing; +import com.structurizr.view.Shape; +import com.structurizr.view.Styles; +import com.structurizr.view.SystemContextView; +import com.structurizr.view.View; +import com.structurizr.view.ViewSet; + +public class StructurizrSimple { + + public static final String PAYMENT_TERMINAL = "Payment Terminal"; + public static final String FRAUD_DETECTOR = "Fraud Detector"; + public static final String SOFTWARE_SYSTEM_VIEW = "SoftwareSystemView"; + public static final String CONTAINER_VIEW = "ContainerView"; + public static final String COMPONENT_VIEW = "ComponentView"; + public static final String JVM2_COMPONENT_VIEW = "JVM2ComponentView"; + + public static void main(String[] args) throws Exception { + Workspace workspace = getSoftwareSystem(); + + addContainers(workspace); + addComponents(workspace); + addSpringComponents(workspace); + exportToPlantUml(workspace.getViews().getViewWithKey(SOFTWARE_SYSTEM_VIEW)); + exportToPlantUml(workspace.getViews().getViewWithKey(CONTAINER_VIEW)); + exportToPlantUml(workspace.getViews().getViewWithKey(COMPONENT_VIEW)); + + exportToPlantUml(workspace.getViews().getViewWithKey(JVM2_COMPONENT_VIEW)); + + addStyles(workspace.getViews()); + //uploadToExternal(workspace); + } + + private static void addSpringComponents(Workspace workspace) throws Exception { + Container jvm2 = workspace.getModel().getSoftwareSystemWithName(PAYMENT_TERMINAL).getContainerWithName("JVM-2"); + findComponents(jvm2); + + ComponentView view = workspace.getViews().createComponentView(jvm2, JVM2_COMPONENT_VIEW, "JVM2ComponentView"); + view.addAllComponents(); + + } + + private static void findComponents(Container jvm) throws Exception { + ComponentFinder componentFinder = new ComponentFinder( + jvm, + "com.baeldung.structurizr", + new SpringComponentFinderStrategy( + new ReferencedTypesSupportingTypesStrategy() + ), + new SourceCodeComponentFinderStrategy(new File("."), 150)); + + componentFinder.findComponents(); + } + + private static void addComponents(Workspace workspace) { + Model model = workspace.getModel(); + + SoftwareSystem paymentTerminal = model.getSoftwareSystemWithName(PAYMENT_TERMINAL); + Container jvm1 = paymentTerminal.getContainerWithName("JVM-1"); + + Component jaxrs = jvm1.addComponent("jaxrs-jersey", "restful webservice implementation", "rest"); + Component gemfire = jvm1.addComponent("gemfire", "Clustered Cache Gemfire", "cache"); + Component hibernate = jvm1.addComponent("hibernate", "Data Access Layer", "jpa"); + + jaxrs.uses(gemfire, ""); + gemfire.uses(hibernate, ""); + + ComponentView componentView = workspace.getViews().createComponentView(jvm1, COMPONENT_VIEW, "JVM Components"); + componentView.addAllComponents(); + } + + private static void addContainers(Workspace workspace) { + Model model = workspace.getModel(); + + SoftwareSystem paymentTerminal = model.getSoftwareSystemWithName(PAYMENT_TERMINAL); + Container f5 = paymentTerminal.addContainer("Payment Load Balancer", "Payment Load Balancer", "F5"); + Container jvm1 = paymentTerminal.addContainer("JVM-1", "JVM-1", "Java Virtual Machine"); + Container jvm2 = paymentTerminal.addContainer("JVM-2", "JVM-2", "Java Virtual Machine"); + Container jvm3 = paymentTerminal.addContainer("JVM-3", "JVM-3", "Java Virtual Machine"); + Container oracle = paymentTerminal.addContainer("oracleDB", "Oracle Database", "RDBMS"); + + f5.uses(jvm1, "route"); + f5.uses(jvm2, "route"); + f5.uses(jvm3, "route"); + + jvm1.uses(oracle, "storage"); + jvm2.uses(oracle, "storage"); + jvm3.uses(oracle, "storage"); + + ContainerView view = workspace.getViews().createContainerView(paymentTerminal, CONTAINER_VIEW, "Container View"); + view.addAllContainers(); + } + + private static void uploadToExternal(Workspace workspace) throws StructurizrClientException { + StructurizrClient client = new StructurizrClient("e94bc0c9-76ef-41b0-8de7-82afc1010d04", "78d555dd-2a31-487c-952c-50508f1da495"); + client.putWorkspace(32961L, workspace); + } + + private static void exportToPlantUml(View view) throws WorkspaceWriterException { + StringWriter stringWriter = new StringWriter(); + PlantUMLWriter plantUMLWriter = new PlantUMLWriter(); + plantUMLWriter.write(view, stringWriter); + System.out.println(stringWriter.toString()); + } + + private static Workspace getSoftwareSystem() { + Workspace workspace = new Workspace("Payment Gateway", "Payment Gateway"); + Model model = workspace.getModel(); + + Person user = model.addPerson("Merchant", "Merchant"); + SoftwareSystem paymentTerminal = model.addSoftwareSystem(PAYMENT_TERMINAL, "Payment Terminal"); + user.uses(paymentTerminal, "Makes payment"); + SoftwareSystem fraudDetector = model.addSoftwareSystem(FRAUD_DETECTOR, "Fraud Detector"); + paymentTerminal.uses(fraudDetector, "Obtains fraud score"); + + ViewSet viewSet = workspace.getViews(); + + SystemContextView contextView = viewSet.createSystemContextView(workspace.getModel().getSoftwareSystemWithName(PAYMENT_TERMINAL), SOFTWARE_SYSTEM_VIEW, "Payment Gateway Diagram"); + contextView.addAllElements(); + + return workspace; + } + + private static void addStyles(ViewSet viewSet) { + Styles styles = viewSet.getConfiguration().getStyles(); + styles.addElementStyle(Tags.ELEMENT).color("#000000"); + styles.addElementStyle(Tags.PERSON).background("#ffbf00").shape(Shape.Person); + styles.addElementStyle(Tags.CONTAINER).background("#facc2E"); + styles.addRelationshipStyle(Tags.RELATIONSHIP).routing(Routing.Orthogonal); + + styles.addRelationshipStyle(Tags.ASYNCHRONOUS).dashed(true); + styles.addRelationshipStyle(Tags.SYNCHRONOUS).dashed(false); + } +} diff --git a/structurizr/src/main/java/com/baeldung/structurizr/spring/GenericComponent.java b/structurizr/src/main/java/com/baeldung/structurizr/spring/GenericComponent.java new file mode 100644 index 0000000000..56f2d52ce0 --- /dev/null +++ b/structurizr/src/main/java/com/baeldung/structurizr/spring/GenericComponent.java @@ -0,0 +1,7 @@ +package com.baeldung.structurizr.spring; + +import org.springframework.stereotype.Component; + +@Component +public class GenericComponent { +} diff --git a/structurizr/src/main/java/com/baeldung/structurizr/spring/PaymentController.java b/structurizr/src/main/java/com/baeldung/structurizr/spring/PaymentController.java new file mode 100644 index 0000000000..89a58b9885 --- /dev/null +++ b/structurizr/src/main/java/com/baeldung/structurizr/spring/PaymentController.java @@ -0,0 +1,14 @@ +package com.baeldung.structurizr.spring; + +import org.springframework.stereotype.Controller; + +import javax.annotation.Resource; + +@Controller +public class PaymentController { + @Resource + private PaymentRepository repository; + + @Resource + private GenericComponent component; +} diff --git a/structurizr/src/main/java/com/baeldung/structurizr/spring/PaymentRepository.java b/structurizr/src/main/java/com/baeldung/structurizr/spring/PaymentRepository.java new file mode 100644 index 0000000000..78b00495b6 --- /dev/null +++ b/structurizr/src/main/java/com/baeldung/structurizr/spring/PaymentRepository.java @@ -0,0 +1,7 @@ +package com.baeldung.structurizr.spring; + +import org.springframework.stereotype.Repository; + +@Repository +public class PaymentRepository { +} diff --git a/testing/README.md b/testing/README.md index fd94279fdf..e9208bfbf3 100644 --- a/testing/README.md +++ b/testing/README.md @@ -9,4 +9,4 @@ - [AssertJ for Guava](http://www.baeldung.com/assertJ-for-guava) - [Introduction to AssertJ](http://www.baeldung.com/introduction-to-assertj) - [Cucumber and Scenario Outline](http://www.baeldung.com/cucumber-scenario-outline) - +- [Testing with Google Truth](http://www.baeldung.com/google-truth)