Merge remote-tracking branch 'origin/master'

2016-11-26 17:48:40 +00:00
parent 5b738313e8 cdb6dfd79e
commit b998d34581
57 changed files with 1899 additions and 73 deletions
@@ -0,0 +1,23 @@
+package com.baeldung.generics;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+public class Generics {
+
+    // definition of a generic method
+    public static <T> List<T> fromArrayToList(T[] a) {
+        List<T> list = new ArrayList<>();
+        Arrays.stream(a).forEach(list::add);
+        return list;
+    }
+
+    // example of a generic method that has Number as an upper bound for T
+    public static <T extends Number> List<T> fromArrayToListWithUpperBound(T[] a) {
+        List<T> list = new ArrayList<>();
+        Arrays.stream(a).forEach(list::add);
+        return list;
+    }
+
+}
@@ -0,0 +1,60 @@
+package com.baeldung.java.nio2.visitor;
+
+import static java.nio.file.FileVisitResult.CONTINUE;
+import static java.nio.file.FileVisitResult.TERMINATE;
+
+import java.io.IOException;
+import java.nio.file.FileVisitResult;
+import java.nio.file.FileVisitor;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.nio.file.attribute.BasicFileAttributes;
+
+public class FileSearchExample implements FileVisitor<Path> {
+    private static String FILE_NAME;
+    private static Path START_DIR;
+
+    public FileSearchExample(String fileName, Path startingDir) {
+        FILE_NAME = fileName;
+        START_DIR = startingDir;
+    }
+
+    @Override
+    public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs) throws IOException {
+        return CONTINUE;
+    }
+
+    @Override
+    public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
+        String fileName = file.getFileName().toString();
+        if (FILE_NAME.equals(fileName)) {
+            System.out.println("File found: " + file.toString());
+            return TERMINATE;
+        }
+        return CONTINUE;
+    }
+
+    @Override
+    public FileVisitResult visitFileFailed(Path file, IOException exc) throws IOException {
+        System.out.println("Failed to access file: " + file.toString());
+        return CONTINUE;
+    }
+
+    @Override
+    public FileVisitResult postVisitDirectory(Path dir, IOException exc) throws IOException {
+        boolean finishedSearch = Files.isSameFile(dir, START_DIR);
+        if (finishedSearch) {
+            System.out.println("File:" + FILE_NAME + " not found");
+            return TERMINATE;
+        }
+        return CONTINUE;
+    }
+
+    public static void main(String[] args) throws IOException {
+        Path startingDir = Paths.get("C:/Users/new/Desktop");
+        FileSearchExample crawler = new FileSearchExample("hibernate.txt", startingDir);
+        Files.walkFileTree(startingDir, crawler);
+    }
+
+}
@@ -0,0 +1,30 @@
+package com.baeldung.java.nio2.visitor;
+
+import java.io.IOException;
+import java.nio.file.FileVisitResult;
+import java.nio.file.FileVisitor;
+import java.nio.file.Path;
+import java.nio.file.attribute.BasicFileAttributes;
+
+public class FileVisitorImpl implements FileVisitor<Path> {
+
+    @Override
+    public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs) {
+        return null;
+    }
+
+    @Override
+    public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) {
+        return null;
+    }
+
+    @Override
+    public FileVisitResult visitFileFailed(Path file, IOException exc) {       
+        return null;
+    }
+
+    @Override
+    public FileVisitResult postVisitDirectory(Path dir, IOException exc) {    
+        return null;
+    }
+}
@@ -0,0 +1,25 @@
+package com.baeldung.java.nio2.watcher;
+
+import java.io.IOException;
+import java.nio.file.FileSystems;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.nio.file.StandardWatchEventKinds;
+import java.nio.file.WatchEvent;
+import java.nio.file.WatchKey;
+import java.nio.file.WatchService;
+
+public class DirectoryWatcherExample {
+    public static void main(String[] args) throws IOException, InterruptedException {
+        WatchService watchService = FileSystems.getDefault().newWatchService();
+        Path path = Paths.get(System.getProperty("user.home"));
+        path.register(watchService, StandardWatchEventKinds.ENTRY_CREATE, StandardWatchEventKinds.ENTRY_DELETE, StandardWatchEventKinds.ENTRY_MODIFY);
+        WatchKey key;
+        while ((key = watchService.take()) != null) {
+            for (WatchEvent<?> event : key.pollEvents()) {
+                System.out.println("Event kind:" + event.kind() + ". File affected: " + event.context() + ".");
+            }
+            key.reset();
+        }
+    }
+}
@@ -0,0 +1,41 @@
+package com.baeldung.generics;
+
+import org.junit.Test;
+
+import java.util.List;
+
+import static org.hamcrest.CoreMatchers.hasItems;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+public class GenericsTest {
+
+    // testing the generic method with Integer
+    @Test
+    public void givenArrayOfIntegers_thanListOfIntegersReturnedOK() {
+        Integer[] intArray = {1, 2, 3, 4, 5};
+        List<Integer> list = Generics.fromArrayToList(intArray);
+
+        assertThat(list, hasItems(intArray));
+    }
+
+    // testing the generic method with String
+    @Test
+    public void givenArrayOfStrings_thanListOfStringsReturnedOK() {
+        String[] stringArray = {"hello1", "hello2", "hello3", "hello4", "hello5"};
+        List<String> list = Generics.fromArrayToList(stringArray);
+
+        assertThat(list, hasItems(stringArray));
+    }
+
+    // testing the generic method with Number as upper bound with Integer
+    // if we test fromArrayToListWithUpperBound with any type that doesn't
+    // extend Number it will fail to compile
+    @Test
+    public void givenArrayOfIntegersAndNumberUpperBound_thanListOfIntegersReturnedOK() {
+        Integer[] intArray = {1, 2, 3, 4, 5};
+        List<Integer> list = Generics.fromArrayToListWithUpperBound(intArray);
+
+        assertThat(list, hasItems(intArray));
+    }
+
+}
@@ -0,0 +1,82 @@
+package com.baeldung.java.nio2.async;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.net.InetSocketAddress;
+import java.nio.ByteBuffer;
+import java.nio.channels.AsynchronousSocketChannel;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Future;
+
+public class AsyncEchoClient {
+    private AsynchronousSocketChannel client;
+    private Future<Void> future;
+    private static AsyncEchoClient instance;
+
+    private AsyncEchoClient() {
+        try {
+            client = AsynchronousSocketChannel.open();
+            InetSocketAddress hostAddress = new InetSocketAddress("localhost", 4999);
+            future = client.connect(hostAddress);
+            start();
+
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+
+    public static AsyncEchoClient getInstance() {
+        if (instance == null)
+            instance = new AsyncEchoClient();
+        return instance;
+    }
+
+    private void start() {
+        try {
+            future.get();
+        } catch (InterruptedException | ExecutionException e) {
+            e.printStackTrace();
+        }
+    }
+
+    public String sendMessage(String message) {
+        byte[] byteMsg = new String(message).getBytes();
+        ByteBuffer buffer = ByteBuffer.wrap(byteMsg);
+        Future<Integer> writeResult = client.write(buffer);
+
+        while (!writeResult.isDone()) {
+            // do nothing
+        }
+        buffer.flip();
+        Future<Integer> readResult = client.read(buffer);
+        while (!readResult.isDone()) {
+
+        }
+        String echo = new String(buffer.array()).trim();
+        buffer.clear();
+        return echo;
+    }
+
+    public void stop() {
+        try {
+            client.close();
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+
+    public static void main(String[] args) throws IOException {
+        AsyncEchoClient client = AsyncEchoClient.getInstance();
+        client.start();
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        String line = null;
+        System.out.println("Message to server:");
+        while ((line = br.readLine()) != null) {
+            String response = client.sendMessage(line);
+            System.out.println("response from server: " + response);
+            System.out.println("Message to server:");
+        }
+    }
+
+}
@@ -0,0 +1,79 @@
+package com.baeldung.java.nio2.async;
+
+import java.io.File;
+import java.io.IOException;
+import java.net.InetSocketAddress;
+import java.nio.ByteBuffer;
+import java.nio.channels.AsynchronousServerSocketChannel;
+import java.nio.channels.AsynchronousSocketChannel;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Future;
+
+public class AsyncEchoServer {
+    private AsynchronousServerSocketChannel serverChannel;
+    private Future<AsynchronousSocketChannel> acceptResult;
+    private AsynchronousSocketChannel clientChannel;
+
+    public AsyncEchoServer() {
+        try {
+            serverChannel = AsynchronousServerSocketChannel.open();
+            InetSocketAddress hostAddress = new InetSocketAddress("localhost", 4999);
+            serverChannel.bind(hostAddress);
+            acceptResult = serverChannel.accept();
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+
+    public void runServer() {
+        try {
+            clientChannel = acceptResult.get();
+            if ((clientChannel != null) && (clientChannel.isOpen())) {
+                while (true) {
+
+                    ByteBuffer buffer = ByteBuffer.allocate(32);
+                    Future<Integer> readResult = clientChannel.read(buffer);
+
+                    while (!readResult.isDone()) {
+                        // do nothing
+                    }
+
+                    buffer.flip();
+                    String message = new String(buffer.array()).trim();
+                    if (message.equals("bye")) {
+                        break; // while loop
+                    }
+                    buffer = ByteBuffer.wrap(new String(message).getBytes());
+                    Future<Integer> writeResult = clientChannel.write(buffer);
+                    while (!writeResult.isDone()) {
+                        // do nothing
+                    }
+                    buffer.clear();
+
+                } // while()
+
+                clientChannel.close();
+                serverChannel.close();
+
+            }
+        } catch (InterruptedException | ExecutionException | IOException e) {
+            e.printStackTrace();
+        }
+
+    }
+
+    public static void main(String[] args) {
+        AsyncEchoServer server = new AsyncEchoServer();
+        server.runServer();
+    }
+    public static Process start() throws IOException, InterruptedException {
+        String javaHome = System.getProperty("java.home");
+        String javaBin = javaHome + File.separator + "bin" + File.separator + "java";
+        String classpath = System.getProperty("java.class.path");
+        String className = AsyncEchoServer.class.getCanonicalName();
+
+        ProcessBuilder builder = new ProcessBuilder(javaBin, "-cp", classpath, className);
+
+        return builder.start();
+    }
+}
@@ -0,0 +1,100 @@
+package com.baeldung.java.nio2.async;
+
+import java.io.File;
+import java.io.IOException;
+import java.net.InetSocketAddress;
+import java.nio.ByteBuffer;
+import java.nio.channels.AsynchronousServerSocketChannel;
+import java.nio.channels.AsynchronousSocketChannel;
+import java.nio.channels.CompletionHandler;
+import java.util.HashMap;
+import java.util.Map;
+
+public class AsyncEchoServer2 {
+    private AsynchronousServerSocketChannel serverChannel;
+    private AsynchronousSocketChannel clientChannel;
+
+    public AsyncEchoServer2() {
+        try {
+            serverChannel = AsynchronousServerSocketChannel.open();
+            InetSocketAddress hostAddress = new InetSocketAddress("localhost", 4999);
+            serverChannel.bind(hostAddress);
+            while (true) {
+
+                serverChannel.accept(null, new CompletionHandler<AsynchronousSocketChannel, Object>() {
+
+                    @Override
+                    public void completed(AsynchronousSocketChannel result, Object attachment) {
+                        if (serverChannel.isOpen())
+                            serverChannel.accept(null, this);
+                        clientChannel = result;
+                        if ((clientChannel != null) && (clientChannel.isOpen())) {
+                            ReadWriteHandler handler = new ReadWriteHandler();
+                            ByteBuffer buffer = ByteBuffer.allocate(32);
+                            Map<String, Object> readInfo = new HashMap<>();
+                            readInfo.put("action", "read");
+                            readInfo.put("buffer", buffer);
+                            clientChannel.read(buffer, readInfo, handler);
+                        }
+                    }
+
+                    @Override
+                    public void failed(Throwable exc, Object attachment) {
+                        // process error
+                    }
+                });
+                try {
+                    System.in.read();
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+
+    class ReadWriteHandler implements CompletionHandler<Integer, Map<String, Object>> {
+
+        @Override
+        public void completed(Integer result, Map<String, Object> attachment) {
+            Map<String, Object> actionInfo = attachment;
+            String action = (String) actionInfo.get("action");
+            if ("read".equals(action)) {
+                ByteBuffer buffer = (ByteBuffer) actionInfo.get("buffer");
+                buffer.flip();
+                actionInfo.put("action", "write");
+                clientChannel.write(buffer, actionInfo, this);
+                buffer.clear();
+            } else if ("write".equals(action)) {
+                ByteBuffer buffer = ByteBuffer.allocate(32);
+                actionInfo.put("action", "read");
+                actionInfo.put("buffer", buffer);
+                clientChannel.read(buffer, actionInfo, this);
+            }
+
+        }
+
+        @Override
+        public void failed(Throwable exc, Map<String, Object> attachment) {
+
+        }
+
+    }
+
+
+    public static void main(String[] args) {
+        new AsyncEchoServer2();
+    }
+
+    public static Process start() throws IOException, InterruptedException {
+        String javaHome = System.getProperty("java.home");
+        String javaBin = javaHome + File.separator + "bin" + File.separator + "java";
+        String classpath = System.getProperty("java.class.path");
+        String className = AsyncEchoServer2.class.getCanonicalName();
+
+        ProcessBuilder builder = new ProcessBuilder(javaBin, "-cp", classpath, className);
+
+        return builder.start();
+    }
+}
@@ -0,0 +1,36 @@
+package com.baeldung.java.nio2.async;
+
+import static org.junit.Assert.*;
+
+import java.io.IOException;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+public class AsyncEchoTest {
+
+    Process server;
+    AsyncEchoClient client;
+
+    @Before
+    public void setup() throws IOException, InterruptedException {
+        server = AsyncEchoServer2.start();
+        client = AsyncEchoClient.getInstance();
+    }
+
+    @Test
+    public void givenServerClient_whenServerEchosMessage_thenCorrect() {
+        String resp1 = client.sendMessage("hello");
+        String resp2 = client.sendMessage("world");
+        assertEquals("hello", resp1);
+        assertEquals("world", resp2);
+    }
+
+    @After
+    public void teardown() throws IOException {
+        server.destroy();
+        client.stop();
+    }
+
+}
@@ -0,0 +1,130 @@
+package com.baeldung.java.nio2.async;
+
+import static org.junit.Assert.assertEquals;
+
+import java.io.IOException;
+import java.net.URI;
+import java.nio.ByteBuffer;
+import java.nio.channels.AsynchronousFileChannel;
+import java.nio.channels.CompletionHandler;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.nio.file.StandardOpenOption;
+import java.util.UUID;
+import java.util.concurrent.Future;
+
+import org.junit.Test;
+
+public class AsyncFileTest {
+    @Test
+    public void givenPath_whenReadsContentWithFuture_thenCorrect() throws IOException {
+        Path path = Paths.get(URI.create(new AsyncFileTest().getClass().getResource("/file.txt").toString()));
+        AsynchronousFileChannel fileChannel = AsynchronousFileChannel.open(path, StandardOpenOption.READ);
+
+        ByteBuffer buffer = ByteBuffer.allocate(1024);
+
+        Future<Integer> operation = fileChannel.read(buffer, 0);
+
+        while (!operation.isDone())
+            ;
+
+        String fileContent = new String(buffer.array()).trim();
+        buffer.clear();
+
+        assertEquals(fileContent, "baeldung.com");
+    }
+
+    @Test
+    public void givenPath_whenReadsContentWithCompletionHandler_thenCorrect() throws IOException {
+        Path path = Paths.get(URI.create(new AsyncFileTest().getClass().getResource("/file.txt").toString()));
+        AsynchronousFileChannel fileChannel = AsynchronousFileChannel.open(path, StandardOpenOption.READ);
+
+        ByteBuffer buffer = ByteBuffer.allocate(1024);
+
+        fileChannel.read(buffer, 0, buffer, new CompletionHandler<Integer, ByteBuffer>() {
+
+            @Override
+            public void completed(Integer result, ByteBuffer attachment) {
+                // result is number of bytes read
+                // attachment is the buffer
+
+            }
+
+            @Override
+            public void failed(Throwable exc, ByteBuffer attachment) {
+
+            }
+        });
+    }
+
+    @Test
+    public void givenPathAndContent_whenWritesToFileWithFuture_thenCorrect() throws IOException {
+        String fileName = UUID.randomUUID().toString();
+        Path path = Paths.get(fileName);
+        AsynchronousFileChannel fileChannel = AsynchronousFileChannel.open(path, StandardOpenOption.WRITE, StandardOpenOption.CREATE,StandardOpenOption.DELETE_ON_CLOSE);
+
+        ByteBuffer buffer = ByteBuffer.allocate(1024);
+        long position = 0;
+
+        buffer.put("hello world".getBytes());
+        buffer.flip();
+
+        Future<Integer> operation = fileChannel.write(buffer, position);
+        buffer.clear();
+
+        while (!operation.isDone()) {
+
+        }
+
+        String content = readContent(path);
+        assertEquals("hello world", content);
+    }
+
+    @Test
+    public void givenPathAndContent_whenWritesToFileWithHandler_thenCorrect() throws IOException {
+        String fileName = UUID.randomUUID().toString();
+        Path path = Paths.get(fileName);
+        AsynchronousFileChannel fileChannel = AsynchronousFileChannel.open(path, StandardOpenOption.WRITE, StandardOpenOption.CREATE,StandardOpenOption.DELETE_ON_CLOSE);
+
+
+        ByteBuffer buffer = ByteBuffer.allocate(1024);
+        buffer.put("hello world".getBytes());
+        buffer.flip();
+
+        fileChannel.write(buffer, 0, buffer, new CompletionHandler<Integer, ByteBuffer>() {
+
+            @Override
+            public void completed(Integer result, ByteBuffer attachment) {
+                // result is number of bytes written
+                // attachment is the buffer
+
+            }
+
+            @Override
+            public void failed(Throwable exc, ByteBuffer attachment) {
+
+            }
+        });
+    }
+
+    public static String readContent(Path file) {
+        AsynchronousFileChannel fileChannel = null;
+        try {
+            fileChannel = AsynchronousFileChannel.open(file, StandardOpenOption.READ);
+        } catch (IOException e) {
+            // TODO Auto-generated catch block
+            e.printStackTrace();
+        }
+
+        ByteBuffer buffer = ByteBuffer.allocate(1024);
+
+        Future<Integer> operation = fileChannel.read(buffer, 0);
+
+        while (!operation.isDone())
+            ;
+
+        String fileContent = new String(buffer.array()).trim();
+        buffer.clear();
+        return fileContent;
+    }
+}
@@ -0,0 +1,68 @@
+package com.baeldung.java.nio2.attributes;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.nio.file.attribute.BasicFileAttributeView;
+import java.nio.file.attribute.BasicFileAttributes;
+import java.nio.file.attribute.FileTime;
+
+import org.junit.Before;
+import org.junit.Test;
+
+public class BasicAttribsTest {
+    private static final String HOME = System.getProperty("user.home");
+    BasicFileAttributes basicAttribs;
+
+    @Before
+    public void setup() throws IOException {
+        Path home = Paths.get(HOME);
+        BasicFileAttributeView basicView = Files.getFileAttributeView(home, BasicFileAttributeView.class);
+        basicAttribs = basicView.readAttributes();
+    }
+
+    @Test
+    public void givenFileTimes_whenComparesThem_ThenCorrect() {
+        FileTime created = basicAttribs.creationTime();
+        FileTime modified = basicAttribs.lastModifiedTime();
+        FileTime accessed = basicAttribs.lastAccessTime();
+
+        assertTrue(0 > created.compareTo(accessed));
+        assertTrue(0 < modified.compareTo(created));
+        assertTrue(0 == created.compareTo(created));
+    }
+
+    @Test
+    public void givenPath_whenGetsFileSize_thenCorrect() {
+        long size = basicAttribs.size();
+        assertTrue(size > 0);
+    }
+
+    @Test
+    public void givenPath_whenChecksIfDirectory_thenCorrect() {
+        boolean isDir = basicAttribs.isDirectory();
+        assertTrue(isDir);
+    }
+
+    @Test
+    public void givenPath_whenChecksIfFile_thenCorrect() {
+        boolean isFile = basicAttribs.isRegularFile();
+        assertFalse(isFile);
+    }
+
+    @Test
+    public void givenPath_whenChecksIfSymLink_thenCorrect() {
+        boolean isSymLink = basicAttribs.isSymbolicLink();
+        assertFalse(isSymLink);
+    }
+
+    @Test
+    public void givenPath_whenChecksIfOther_thenCorrect() {
+        boolean isOther = basicAttribs.isOther();
+        assertFalse(isOther);
+    }
+}
@@ -0,0 +1,116 @@
+package org.baeldung.java.collections;
+
+import static java.util.Arrays.asList;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.List;
+import java.util.NoSuchElementException;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Lists;
+
+public class CollectionsConcatenateUnitTest {
+
+    @Test
+    public void givenUsingJava8_whenConcatenatingUsingConcat_thenCorrect() {
+        Collection<String> collectionA = asList("S", "T");
+        Collection<String> collectionB = asList("U", "V");
+        Collection<String> collectionC = asList("W", "X");
+
+        Stream<String> combinedStream = Stream.concat(Stream.concat(collectionA.stream(), collectionB.stream()), collectionC.stream());
+        Collection<String> collectionCombined = combinedStream.collect(Collectors.toList());
+
+        Assert.assertEquals(asList("S", "T", "U", "V", "W", "X"), collectionCombined);
+    }
+
+    @Test
+    public void givenUsingJava8_whenConcatenatingUsingflatMap_thenCorrect() {
+        Collection<String> collectionA = asList("S", "T");
+        Collection<String> collectionB = asList("U", "V");
+
+        Stream<String> combinedStream = Stream.of(collectionA, collectionB).flatMap(Collection::stream);
+        Collection<String> collectionCombined = combinedStream.collect(Collectors.toList());
+
+        Assert.assertEquals(asList("S", "T", "U", "V"), collectionCombined);
+    }
+
+    @Test
+    public void givenUsingGuava_whenConcatenatingUsingIterables_thenCorrect() {
+        Collection<String> collectionA = asList("S", "T");
+        Collection<String> collectionB = asList("U", "V");
+
+        Iterable<String> combinedIterables = Iterables.unmodifiableIterable(Iterables.concat(collectionA, collectionB));
+        Collection<String> collectionCombined = Lists.newArrayList(combinedIterables);
+
+        Assert.assertEquals(asList("S", "T", "U", "V"), collectionCombined);
+    }
+
+    @Test
+    public void givenUsingJava7_whenConcatenatingUsingIterables_thenCorrect() {
+        Collection<String> collectionA = asList("S", "T");
+        Collection<String> collectionB = asList("U", "V");
+
+        Iterable<String> combinedIterables = concat(collectionA, collectionB);
+        Collection<String> collectionCombined = makeListFromIterable(combinedIterables);
+        Assert.assertEquals(Arrays.asList("S", "T", "U", "V"), collectionCombined);
+    }
+
+    public static <E> Iterable<E> concat(Iterable<? extends E> list1, Iterable<? extends E> list2) {
+        return new Iterable<E>() {
+            public Iterator<E> iterator() {
+                return new Iterator<E>() {
+                    protected Iterator<? extends E> listIterator = list1.iterator();
+                    protected Boolean checkedHasNext;
+                    protected E nextValue;
+                    private boolean startTheSecond;
+
+                    public void theNext() {
+                        if (listIterator.hasNext()) {
+                            checkedHasNext = true;
+                            nextValue = listIterator.next();
+                        } else if (startTheSecond)
+                            checkedHasNext = false;
+                        else {
+                            startTheSecond = true;
+                            listIterator = list2.iterator();
+                            theNext();
+                        }
+                    }
+
+                    public boolean hasNext() {
+                        if (checkedHasNext == null)
+                            theNext();
+                        return checkedHasNext;
+                    }
+
+                    public E next() {
+                        if (!hasNext())
+                            throw new NoSuchElementException();
+                        checkedHasNext = null;
+                        return nextValue;
+                    }
+
+                    public void remove() {
+                        listIterator.remove();
+                    }
+                };
+            }
+        };
+    }
+
+    public static <E> List<E> makeListFromIterable(Iterable<E> iter) {
+        List<E> list = new ArrayList<E>();
+        for (E item : iter) {
+            list.add(item);
+        }
+        return list;
+    }
+}
@@ -47,6 +47,11 @@
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
+        <dependency>
+            <groupId>com.google.guava</groupId>
+            <artifactId>guava</artifactId>
+            <version>20.0</version>
+        </dependency>
    </dependencies>

    <build>
@@ -0,0 +1,23 @@
+package com.baeldung.constructordi;
+
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.ComponentScan;
+import org.springframework.context.annotation.Configuration;
+
+import com.baeldung.constructordi.domain.Engine;
+import com.baeldung.constructordi.domain.Transmission;
+
+@Configuration
+@ComponentScan("com.baeldung.constructordi")
+public class Config {
+
+    @Bean
+    public Engine engine() {
+        return new Engine("v8", 5);
+    }
+
+    @Bean
+    public Transmission transmission() {
+        return new Transmission("sliding");
+    }
+}
@@ -0,0 +1,31 @@
+package com.baeldung.constructordi;
+
+import org.springframework.context.ApplicationContext;
+import org.springframework.context.annotation.AnnotationConfigApplicationContext;
+import org.springframework.context.support.ClassPathXmlApplicationContext;
+
+import com.baeldung.constructordi.domain.Car;
+
+public class SpringRunner {
+    public static void main(String[] args) {
+        Car toyota = getCarFromXml();
+
+        System.out.println(toyota);
+
+        toyota = getCarFromJavaConfig();
+
+        System.out.println(toyota);
+    }
+
+    private static Car getCarFromJavaConfig() {
+        ApplicationContext context = new AnnotationConfigApplicationContext(Config.class);
+
+        return context.getBean(Car.class);
+    }
+
+    private static Car getCarFromXml() {
+        ApplicationContext context = new ClassPathXmlApplicationContext("baeldung.xml");
+
+        return context.getBean(Car.class);
+    }
+}
@@ -0,0 +1,21 @@
+package com.baeldung.constructordi.domain;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+@Component
+public class Car {
+    private Engine engine;
+    private Transmission transmission;
+
+    @Autowired
+    public Car(Engine engine, Transmission transmission) {
+        this.engine = engine;
+        this.transmission = transmission;
+    }
+
+    @Override
+    public String toString() {
+        return String.format("Engine: %s Transmission: %s", engine, transmission);
+    }
+}
@@ -0,0 +1,16 @@
+package com.baeldung.constructordi.domain;
+
+public class Engine {
+    private String type;
+    private int volume;
+
+    public Engine(String type, int volume) {
+        this.type = type;
+        this.volume = volume;
+    }
+
+    @Override
+    public String toString() {
+        return String.format("%s %d", type, volume);
+    }
+}
@@ -0,0 +1,14 @@
+package com.baeldung.constructordi.domain;
+
+public class Transmission {
+	private String type;
+
+	public Transmission(String type) {
+		this.type = type;
+	}
+
+	@Override
+	public String toString() {
+		return String.format("%s", type);
+	}
+}
@@ -0,0 +1,26 @@
+package com.baeldung.factorybean;
+
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+@Configuration
+public class FactoryBeanAppConfig {
+    
+    @Bean
+    public ToolFactory tool() {
+        ToolFactory factory = new ToolFactory();
+        factory.setFactoryId(7070);
+        factory.setToolId(2);
+        factory.setToolName("wrench");
+        factory.setToolPrice(3.7);
+        return factory;
+    }
+
+    @Bean
+    public Worker worker() throws Exception {
+        Worker worker = new Worker();
+        worker.setNumber("1002");
+        worker.setTool(tool().getObject());
+        return worker;
+    }
+}
@@ -0,0 +1,68 @@
+package com.baeldung.factorybean;
+
+import static com.google.common.base.Preconditions.checkArgument;
+
+import org.springframework.beans.factory.FactoryBean;
+import org.springframework.beans.factory.InitializingBean;
+import org.springframework.util.StringUtils;
+
+public class InitializationToolFactory implements FactoryBean<Tool>, InitializingBean {
+    
+    private int factoryId;
+    private int toolId;
+    private String toolName;
+    private double toolPrice;
+
+    @Override
+    public void afterPropertiesSet() throws Exception {
+        checkArgument(!StringUtils.isEmpty(toolName), "tool name cannot be empty");
+        checkArgument(toolPrice >= 0, "tool price should not be less than 0");
+    }
+
+    @Override
+    public Tool getObject() throws Exception {
+        return new Tool(toolId, toolName, toolPrice);
+    }
+
+    @Override
+    public Class<?> getObjectType() {
+        return Tool.class;
+    }
+
+    @Override
+    public boolean isSingleton() {
+        return false;
+    }
+
+    public int getFactoryId() {
+        return factoryId;
+    }
+
+    public void setFactoryId(int factoryId) {
+        this.factoryId = factoryId;
+    }
+
+    public int getToolId() {
+        return toolId;
+    }
+
+    public void setToolId(int toolId) {
+        this.toolId = toolId;
+    }
+
+    public String getToolName() {
+        return toolName;
+    }
+
+    public void setToolName(String toolName) {
+        this.toolName = toolName;
+    }
+
+    public double getToolPrice() {
+        return toolPrice;
+    }
+
+    public void setToolPrice(double toolPrice) {
+        this.toolPrice = toolPrice;
+    }
+}
@@ -0,0 +1,57 @@
+package com.baeldung.factorybean;
+
+import org.springframework.beans.factory.config.AbstractFactoryBean;
+
+public class NonSingleToolFactory extends AbstractFactoryBean<Tool> {
+    
+    private int factoryId;
+    private int toolId;
+    private String toolName;
+    private double toolPrice;
+
+    public NonSingleToolFactory() {
+        setSingleton(false);
+    }
+
+    @Override
+    public Class<?> getObjectType() {
+        return Tool.class;
+    }
+
+    @Override
+    protected Tool createInstance() throws Exception {
+        return new Tool(toolId, toolName, toolPrice);
+    }
+
+    public int getFactoryId() {
+        return factoryId;
+    }
+
+    public void setFactoryId(int factoryId) {
+        this.factoryId = factoryId;
+    }
+
+    public int getToolId() {
+        return toolId;
+    }
+
+    public void setToolId(int toolId) {
+        this.toolId = toolId;
+    }
+
+    public String getToolName() {
+        return toolName;
+    }
+
+    public void setToolName(String toolName) {
+        this.toolName = toolName;
+    }
+
+    public double getToolPrice() {
+        return toolPrice;
+    }
+
+    public void setToolPrice(double toolPrice) {
+        this.toolPrice = toolPrice;
+    }
+}
@@ -0,0 +1,69 @@
+package com.baeldung.factorybean;
+
+import static com.google.common.base.Preconditions.checkArgument;
+
+import javax.annotation.PostConstruct;
+
+import org.springframework.beans.factory.FactoryBean;
+import org.springframework.util.StringUtils;
+
+public class PostConstructToolFactory implements FactoryBean<Tool> {
+    
+    private int factoryId;
+    private int toolId;
+    private String toolName;
+    private double toolPrice;
+
+    @Override
+    public Tool getObject() throws Exception {
+        return new Tool(toolId, toolName, toolPrice);
+    }
+
+    @Override
+    public Class<?> getObjectType() {
+        return Tool.class;
+    }
+
+    @Override
+    public boolean isSingleton() {
+        return false;
+    }
+
+    @PostConstruct
+    public void checkParams() {
+        checkArgument(!StringUtils.isEmpty(toolName), "tool name cannot be empty");
+        checkArgument(toolPrice >= 0, "tool price should not be less than 0");
+    }
+
+    public int getFactoryId() {
+        return factoryId;
+    }
+
+    public void setFactoryId(int factoryId) {
+        this.factoryId = factoryId;
+    }
+
+    public int getToolId() {
+        return toolId;
+    }
+
+    public void setToolId(int toolId) {
+        this.toolId = toolId;
+    }
+
+    public String getToolName() {
+        return toolName;
+    }
+
+    public void setToolName(String toolName) {
+        this.toolName = toolName;
+    }
+
+    public double getToolPrice() {
+        return toolPrice;
+    }
+
+    public void setToolPrice(double toolPrice) {
+        this.toolPrice = toolPrice;
+    }
+}
@@ -0,0 +1,54 @@
+package com.baeldung.factorybean;
+
+import org.springframework.beans.factory.config.AbstractFactoryBean;
+
+//no need to set singleton property because default value is true
+public class SingleToolFactory extends AbstractFactoryBean<Tool> {
+    
+    private int factoryId;
+    private int toolId;
+    private String toolName;
+    private double toolPrice;
+
+    @Override
+    public Class<?> getObjectType() {
+        return Tool.class;
+    }
+
+    @Override
+    protected Tool createInstance() throws Exception {
+        return new Tool(toolId, toolName, toolPrice);
+    }
+
+    public int getFactoryId() {
+        return factoryId;
+    }
+
+    public void setFactoryId(int factoryId) {
+        this.factoryId = factoryId;
+    }
+
+    public int getToolId() {
+        return toolId;
+    }
+
+    public void setToolId(int toolId) {
+        this.toolId = toolId;
+    }
+
+    public String getToolName() {
+        return toolName;
+    }
+
+    public void setToolName(String toolName) {
+        this.toolName = toolName;
+    }
+
+    public double getToolPrice() {
+        return toolPrice;
+    }
+
+    public void setToolPrice(double toolPrice) {
+        this.toolPrice = toolPrice;
+    }
+}
@@ -0,0 +1,38 @@
+package com.baeldung.factorybean;
+
+public class Tool {
+    
+    private int id;
+    private String name;
+    private double price;
+
+    public Tool(int id, String name, double price) {
+        this.id = id;
+        this.name = name;
+        this.price = price;
+    }
+
+    public int getId() {
+        return id;
+    }
+
+    public void setId(int id) {
+        this.id = id;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public double getPrice() {
+        return price;
+    }
+
+    public void setPrice(double price) {
+        this.price = price;
+    }
+}
@@ -0,0 +1,58 @@
+package com.baeldung.factorybean;
+
+import org.springframework.beans.factory.FactoryBean;
+
+public class ToolFactory implements FactoryBean<Tool> {
+   
+    private int factoryId;
+    private int toolId;
+    private String toolName;
+    private double toolPrice;
+
+    @Override
+    public Tool getObject() throws Exception {
+        return new Tool(toolId, toolName, toolPrice);
+    }
+
+    @Override
+    public Class<?> getObjectType() {
+        return Tool.class;
+    }
+
+    @Override
+    public boolean isSingleton() {
+        return false;
+    }
+
+    public int getFactoryId() {
+        return factoryId;
+    }
+
+    public void setFactoryId(int factoryId) {
+        this.factoryId = factoryId;
+    }
+
+    public int getToolId() {
+        return toolId;
+    }
+
+    public void setToolId(int toolId) {
+        this.toolId = toolId;
+    }
+
+    public String getToolName() {
+        return toolName;
+    }
+
+    public void setToolName(String toolName) {
+        this.toolName = toolName;
+    }
+
+    public double getToolPrice() {
+        return toolPrice;
+    }
+
+    public void setToolPrice(double toolPrice) {
+        this.toolPrice = toolPrice;
+    }
+}
@@ -0,0 +1,30 @@
+package com.baeldung.factorybean;
+
+public class Worker {
+
+    private String number;
+    private Tool tool;
+
+    public Worker() {}
+
+    public Worker(String number, Tool tool) {
+        this.number = number;
+        this.tool = tool;
+    }
+
+    public String getNumber() {
+        return number;
+    }
+
+    public void setNumber(String number) {
+        this.number = number;
+    }
+
+    public Tool getTool() {
+        return tool;
+    }
+
+    public void setTool(Tool tool) {
+        this.tool = tool;
+    }
+}
@@ -0,0 +1,20 @@
+<beans xmlns="http://www.springframework.org/schema/beans"
+       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+       xsi:schemaLocation="http://www.springframework.org/schema/beans
+    http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
+
+    <bean id="toyota" class="com.baeldung.constructordi.domain.Car">
+        <constructor-arg index="0" ref="engine"/>
+        <constructor-arg index="1" ref="transmission"/>
+    </bean>
+
+    <bean id="engine" class="com.baeldung.constructordi.domain.Engine">
+        <constructor-arg index="0" value="v4"/>
+        <constructor-arg index="1" value="2"/>
+    </bean>
+
+    <bean id="transmission" class="com.baeldung.constructordi.domain.Transmission">
+        <constructor-arg value="sliding"/>
+    </bean>
+
+</beans>
@@ -0,0 +1,39 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+  xmlns="http://www.springframework.org/schema/beans"
+  xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
+
+    <bean id="singleTool" class="com.baeldung.factorybean.SingleToolFactory">
+        <property name="factoryId" value="3001"/>
+        <property name="toolId" value="1"/>
+        <property name="toolName" value="screwdriver"/>
+        <property name="toolPrice" value="1.5"/>
+    </bean>
+
+    <bean id="nonSingleTool" class="com.baeldung.factorybean.NonSingleToolFactory">
+        <property name="factoryId" value="3002"/>
+        <property name="toolId" value="2"/>
+        <property name="toolName" value="screwdriver"/>
+        <property name="toolPrice" value="1.5"/>
+    </bean>
+
+    <bean id="worker1" class="com.baeldung.factorybean.Worker">
+        <property name="number" value="50001"/>
+        <property name="tool" ref="singleTool"/>
+    </bean>
+
+    <bean id="worker2" class="com.baeldung.factorybean.Worker">
+        <property name="number" value="50002"/>
+        <property name="tool" ref="singleTool"/>
+    </bean>
+
+    <bean id="worker3" class="com.baeldung.factorybean.Worker">
+        <property name="number" value="50003"/>
+        <property name="tool" ref="nonSingleTool"/>
+    </bean>
+
+    <bean id="worker4" class="com.baeldung.factorybean.Worker">
+        <property name="number" value="50004"/>
+        <property name="tool" ref="nonSingleTool"/>
+    </bean>
+</beans>
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+  xmlns="http://www.springframework.org/schema/beans"
+  xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
+
+    <bean id="initializationTool" class="com.baeldung.factorybean.InitializationToolFactory">
+        <property name="factoryId" value="1010"/>
+        <property name="toolId" value="1"/>
+        <property name="toolName" value="screwdriver"/>
+        <property name="toolPrice" value="-1"/>
+    </bean>
+
+    <bean id="worker" class="com.baeldung.factorybean.Worker">
+        <property name="number" value="36"/>
+        <property name="tool" ref="initializationTool"/>
+    </bean>
+</beans>
@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+  xmlns:context="http://www.springframework.org/schema/context"
+  xmlns="http://www.springframework.org/schema/beans"
+  xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
+
+    <context:annotation-config/>
+
+    <bean id="postConstructTool" class="com.baeldung.factorybean.PostConstructToolFactory">
+        <property name="factoryId" value="2020"/>
+        <property name="toolId" value="1"/>
+        <property name="toolName" value=""/>
+        <property name="toolPrice" value="2.2"/>
+    </bean>
+
+    <bean id="worker" class="com.baeldung.factorybean.Worker">
+        <property name="number" value="37"/>
+        <property name="tool" ref="postConstructTool"/>
+    </bean>
+</beans>
--- a/Show More
+++ b/Show More