Merge branch 'master' of https://github.com/eugenp/tutorials

guest/tomcat-app/WebContent/META-INF/MANIFEST.MF

@@ -0,0 +1,3 @@
+Manifest-Version: 1.0
+Class-Path: 
+

guest/tomcat-app/WebContent/WEB-INF/web.xml

@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+	xmlns="http://xmlns.jcp.org/xml/ns/javaee"
+	xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd"
+	id="WebApp_ID" version="3.1">
+	<display-name>tomcat-app</display-name>
+	<servlet>
+		<servlet-name>tomcat-app</servlet-name>
+		<servlet-class>org.glassfish.jersey.servlet.ServletContainer</servlet-class>
+		<init-param>
+			<param-name>javax.ws.rs.Application</param-name>
+			<param-value>com.stackify.ApplicationInitializer</param-value>
+		</init-param>
+		<load-on-startup>1</load-on-startup>
+	</servlet>
+	<servlet-mapping>
+		<servlet-name>tomcat-app</servlet-name>
+		<url-pattern>/*</url-pattern>
+	</servlet-mapping>
+	<filter>
+    <filter-name>javamelody</filter-name>
+    <filter-class>net.bull.javamelody.MonitoringFilter</filter-class>
+    <init-param>
+        <param-name>gzip-compression-disabled</param-name>
+        <param-value>true</param-value>
+    </init-param>
+</filter>
+</web-app>

guest/tomcat-app/pom.xml

@@ -0,0 +1,70 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <groupId>com.stackify</groupId>
+    <artifactId>tomcat-app</artifactId>
+    <version>0.0.1-SNAPSHOT</version>
+    <packaging>war</packaging>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.glassfish.jersey.containers</groupId>
+            <artifactId>jersey-container-servlet</artifactId>
+            <version>2.25.1</version>
+        </dependency>
+        <dependency>
+            <groupId>org.glassfish.jersey.media</groupId>
+            <artifactId>jersey-media-moxy</artifactId>
+            <version>2.25.1</version>
+        </dependency>
+        <dependency>
+            <groupId>io.rest-assured</groupId>
+            <artifactId>rest-assured</artifactId>
+            <version>3.0.3</version>
+        </dependency>
+        <dependency>
+            <groupId>junit</groupId>
+            <artifactId>junit</artifactId>
+            <version>4.12</version>
+        </dependency>
+        
+        <dependency>
+            <groupId>com.h2database</groupId>
+            <artifactId>h2</artifactId>
+            <version>1.4.195</version>
+        </dependency>
+
+        <dependency>
+            <groupId>org.apache.logging.log4j</groupId>
+            <artifactId>log4j-core</artifactId>
+            <version>2.8.2</version>
+        </dependency>
+        
+        <dependency>
+            <groupId>net.bull.javamelody</groupId>
+            <artifactId>javamelody-core</artifactId>
+            <version>1.69.0</version>
+        </dependency>
+        
+    </dependencies>
+
+    <build>
+        <plugins>
+            <plugin>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <version>3.5.1</version>
+                <configuration>
+                    <source>1.8</source>
+                    <target>1.8</target>
+                </configuration>
+            </plugin>
+            <plugin>
+                <artifactId>maven-war-plugin</artifactId>
+                <version>3.0.0</version>
+                <configuration>
+                    <warSourceDirectory>WebContent</warSourceDirectory>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+</project>

guest/tomcat-app/src/main/java/com/stackify/ApplicationInitializer.java

@@ -0,0 +1,9 @@
+package com.stackify;
+
+import org.glassfish.jersey.server.ResourceConfig;
+
+public class ApplicationInitializer extends ResourceConfig {
+    public ApplicationInitializer() {
+        packages("com.stackify.services");
+    }
+}

guest/tomcat-app/src/main/java/com/stackify/daos/UserDAO.java

@@ -0,0 +1,67 @@
+package com.stackify.daos;
+
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.ArrayList;
+import java.util.List;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import com.stackify.models.User;
+import com.stackify.utils.ConnectionUtil;
+
+public class UserDAO {
+
+    private Logger logger = LogManager.getLogger(UserDAO.class);
+
+    public void createTable() {
+        try (Connection con = ConnectionUtil.getConnection()) {
+            String createQuery = "CREATE TABLE IF NOT EXISTS users(email varchar(50) primary key, name varchar(50))";
+            PreparedStatement pstmt = con.prepareStatement(createQuery);
+
+            pstmt.execute();
+        } catch (SQLException exc) {
+            logger.error(exc.getMessage());
+        }
+
+    }
+
+    public void add(User user) {
+        try (Connection con = ConnectionUtil.getConnection()) {
+
+            String insertQuery = "INSERT INTO users(email,name) VALUES(?,?)";
+            PreparedStatement pstmt = con.prepareStatement(insertQuery);
+            pstmt.setString(1, user.getEmail());
+            pstmt.setString(2, user.getName());
+
+            pstmt.executeUpdate();
+        } catch (SQLException exc) {
+            logger.error(exc.getMessage());
+        }
+    }
+
+    public List<User> findAll() {
+        List<User> users = new ArrayList<>();
+
+        try (Connection con = ConnectionUtil.getConnection()) {
+            String query = "SELECT * FROM users";
+            PreparedStatement pstmt = con.prepareStatement(query);
+
+            ResultSet rs = pstmt.executeQuery();
+            while (rs.next()) {
+                User user = new User();
+                user.setEmail(rs.getString("email"));
+                user.setName(rs.getString("name"));
+                users.add(user);
+            }
+        } catch (SQLException exc) {
+            logger.error(exc.getMessage());
+        }
+
+        return users;
+    }
+
+}

guest/tomcat-app/src/main/java/com/stackify/models/User.java

@@ -0,0 +1,43 @@
+package com.stackify.models;
+
+import javax.ws.rs.core.Link;
+
+public class User {
+    private String email;
+    private String name;
+    private Link link;
+
+    public User() {
+    }
+
+    public User(String email, String name) {
+        super();
+        this.email = email;
+        this.name = name;
+    }
+
+    public String getEmail() {
+        return email;
+    }
+
+    public void setEmail(String email) {
+        this.email = email;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public Link getLink() {
+        return link;
+    }
+
+    public void setLink(Link link) {
+        this.link = link;
+    }
+
+}

guest/tomcat-app/src/main/java/com/stackify/services/CorsFilter.java

@@ -0,0 +1,19 @@
+package com.stackify.services;
+
+import java.io.IOException;
+
+import javax.ws.rs.container.ContainerRequestContext;
+import javax.ws.rs.container.ContainerResponseContext;
+import javax.ws.rs.container.ContainerResponseFilter;
+import javax.ws.rs.ext.Provider;
+
+@Provider
+public class CorsFilter implements ContainerResponseFilter {
+
+   @Override
+   public void filter(final ContainerRequestContext requestContext,
+                      final ContainerResponseContext response) throws IOException {
+       response.getHeaders().add("Access-Control-Allow-Origin", "*");
+       response.getHeaders().add("Access-Control-Allow-Headers", "origin, content-type, accept");
+   }
+}

guest/tomcat-app/src/main/java/com/stackify/services/UserService.java

@@ -0,0 +1,37 @@
+package com.stackify.services;
+
+import java.util.List;
+
+import javax.ws.rs.Consumes;
+import javax.ws.rs.GET;
+import javax.ws.rs.POST;
+import javax.ws.rs.Path;
+import javax.ws.rs.Produces;
+import javax.ws.rs.core.MediaType;
+import javax.ws.rs.core.Response;
+
+import com.stackify.daos.UserDAO;
+import com.stackify.models.User;
+
+@Path("/users")
+public class UserService {
+    private UserDAO userDao = new UserDAO();
+    
+    public UserService (){
+        userDao.createTable();
+    }
+
+    @POST
+    @Consumes(MediaType.APPLICATION_JSON)
+    public Response addUser(User user) {
+        userDao.add(user);
+        return Response.ok()
+            .build();
+    }
+
+    @GET
+    @Produces(MediaType.APPLICATION_JSON)
+    public List<User> getUsers() {
+        return userDao.findAll();
+    }
+}

guest/tomcat-app/src/main/java/com/stackify/utils/ConnectionUtil.java

@@ -0,0 +1,38 @@
+package com.stackify.utils;
+
+import java.sql.Connection;
+import java.sql.SQLException;
+
+import javax.naming.Context;
+import javax.naming.InitialContext;
+import javax.naming.NamingException;
+import javax.sql.DataSource;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+public class ConnectionUtil {
+
+    private static Logger logger = LogManager.getLogger(ConnectionUtil.class);
+
+    public static Connection getConnection() {
+        try {
+            String jndiName = "java:/comp/env/jdbc/MyDataSource";
+            
+            Context initialContext = new InitialContext();
+            DataSource datasource = (DataSource)initialContext.lookup(jndiName);
+            if (datasource != null) {
+              return datasource.getConnection();
+            }
+            else {
+              logger.error("Failed to lookup datasource.");
+            }
+        }
+
+        catch (NamingException | SQLException exc) {
+            logger.error(exc.getMessage());
+        }
+        return null;
+    }
+
+}

libraries/pom.xml

@@ -550,16 +550,41 @@
 	          <artifactId>functionaljava</artifactId>
 	          <version>4.7</version>
 	      </dependency>
+	      <dependency>
+	          <groupId>org.functionaljava</groupId>
+	          <artifactId>functionaljava-java8</artifactId>
+	          <version>4.7</version>
+        </dependency>
+        <dependency>
+	          <groupId>org.functionaljava</groupId>
+	          <artifactId>functionaljava-quickcheck</artifactId>
+	          <version>4.7</version>
+	      </dependency>
+	      <dependency>
+	          <groupId>org.functionaljava</groupId>
+	          <artifactId>functionaljava-java-core</artifactId>
+	          <version>4.7</version>
+        </dependency>
         <dependency>
    			    <groupId>javax.cache</groupId>
    			    <artifactId>cache-api</artifactId>
    			    <version>${cache.version}</version>
-   		  </dependency>
+        </dependency>
-		    <dependency>
+        <dependency>
-		        <groupId>com.hazelcast</groupId>
+            <groupId>com.hazelcast</groupId>
-		        <artifactId>hazelcast</artifactId>
+            <artifactId>hazelcast</artifactId>
-		        <version>${hazelcast.version}</version>
+            <version>${hazelcast.version}</version>
-		    </dependency>
+        </dependency>
+        <dependency>
+            <groupId>com.atlassian.jira</groupId>
+            <artifactId>jira-rest-java-client-core</artifactId>
+            <version>4.0.0</version>
+        </dependency>
+        <dependency>
+            <groupId>com.atlassian.fugue</groupId>
+            <artifactId>fugue</artifactId>
+            <version>3.0.0-m007</version>
+        </dependency>
     </dependencies>
     <repositories>
         <repository>
@@ -575,6 +600,10 @@
             <name>bintray</name>
             <url>http://dl.bintray.com/cuba-platform/main</url>
         </repository>
+        <repository>
+            <id>atlassian-public</id>
+            <url>https://packages.atlassian.com/maven/repository/public</url>
+        </repository>
     </repositories>
     <properties>
         <multiverse.version>0.7.0</multiverse.version>

libraries/src/main/java/com/baeldung/jira/JiraClient.java

@@ -0,0 +1,57 @@
+package com.baeldung.jira;
+
+import com.atlassian.jira.rest.client.api.JiraRestClient;
+import com.atlassian.jira.rest.client.api.JiraRestClientFactory;
+import com.atlassian.jira.rest.client.api.domain.Issue;
+import com.atlassian.jira.rest.client.internal.async.AsynchronousJiraRestClientFactory;
+
+import java.io.IOException;
+import java.net.URI;
+import java.net.URISyntaxException;
+
+public class JiraClient {
+
+    private static final String USERNAME = "jira.user";
+    private static final String PASSWORD = "secret";
+    private static final String JIRA_URL = "http://jira.company.com";
+
+    public static void main(String[] args) {
+
+        final Issue issue = new JiraClient().getIssue("MYKEY-1234");
+        System.out.println(issue.getDescription());
+    }
+
+    private Issue getIssue(String issueKey) {
+        JiraRestClient restClient = getJiraRestClient();
+        Issue issue = restClient.getIssueClient().getIssue(issueKey).claim();
+
+        closeRestClient(restClient);
+        return issue;
+    }
+
+    private JiraRestClient getJiraRestClient() {
+        JiraRestClientFactory factory = new AsynchronousJiraRestClientFactory();
+
+        URI jiraServerUri = getJiraUri();
+        return factory
+          .createWithBasicHttpAuthentication(jiraServerUri, USERNAME, PASSWORD);
+    }
+
+    private URI getJiraUri() {
+        URI jiraServerUri = null;
+        try {
+            jiraServerUri = new URI(JIRA_URL);
+        } catch (URISyntaxException e) {
+            e.printStackTrace();
+        }
+        return jiraServerUri;
+    }
+
+    private void closeRestClient(JiraRestClient restClient) {
+        try {
+            restClient.close();
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+}

libraries/src/test/java/com/baeldung/jcache/CacheLoaderTest.java

@@ -41,4 +41,4 @@ public class CacheLoaderTest {
             assertEquals("fromCache" + i, value);
         }
     }
-}
+}

libraries/src/test/java/com/baeldung/jcache/EntryProcessorTest.java

@@ -38,4 +38,4 @@ public class EntryProcessorTest {
         this.cache.invoke("key", new SimpleEntryProcessor());
         assertEquals("value - modified", cache.get("key"));
     }
-}
+}

libraries/src/test/java/com/baeldung/jcache/EventListenerTest.java

@@ -53,4 +53,4 @@ public class EventListenerTest {
         assertEquals(true, this.listener.getUpdated());
     }
 
-}
+}

libraries/src/test/java/com/baeldung/jcache/JCacheTest.java

@@ -24,4 +24,4 @@ public class JCacheTest {
         assertEquals("value2", cache.get("key2"));
         cacheManager.close();
     }
-}
+}

rxjava/pom.xml

@@ -31,10 +31,29 @@
             <artifactId>awaitility</artifactId>
             <version>1.7.0</version>
         </dependency>
+        <dependency>
+    		<groupId>com.github.davidmoten</groupId>
+    		<artifactId>rxjava-jdbc</artifactId>
+    		<version>${rx.java.jdbc.version}</version>
+		</dependency>
+		<dependency>
+		    <groupId>com.h2database</groupId>
+		    <artifactId>h2</artifactId>
+		    <version>${h2.version}</version>
+		    <scope>runtime</scope>
+		</dependency>
+		<dependency>
+            <groupId>org.assertj</groupId>
+            <artifactId>assertj-core</artifactId>
+            <version>${assertj.version}</version>
+        </dependency>
     </dependencies>
 
     <properties>
+    	<assertj.version>3.8.0</assertj.version>
         <rx.java.version>1.2.5</rx.java.version>
+        <rx.java.jdbc.version>0.7.11</rx.java.jdbc.version>
+        <h2.version>1.4.196</h2.version>
     </properties>
 
 

rxjava/src/main/java/com/baeldung/rxjava/jdbc/Connector.java

@@ -0,0 +1,13 @@
+package com.baeldung.rxjava.jdbc;
+
+import com.github.davidmoten.rx.jdbc.ConnectionProvider;
+import com.github.davidmoten.rx.jdbc.ConnectionProviderFromUrl;
+
+class Connector {
+
+    static final String DB_CONNECTION = "jdbc:h2:mem:test;DB_CLOSE_DELAY=-1";
+    static final String DB_USER = "";
+    static final String DB_PASSWORD = "";
+
+    static final ConnectionProvider connectionProvider = new ConnectionProviderFromUrl(DB_CONNECTION, DB_USER, DB_PASSWORD);
+}

rxjava/src/main/java/com/baeldung/rxjava/jdbc/Employee.java

@@ -0,0 +1,13 @@
+package com.baeldung.rxjava.jdbc;
+
+import com.github.davidmoten.rx.jdbc.annotations.Column;
+
+public interface Employee {
+
+    @Column("id")
+    int id();
+
+    @Column("name")
+    String name();
+    
+}

rxjava/src/main/java/com/baeldung/rxjava/jdbc/Manager.java

@@ -0,0 +1,28 @@
+package com.baeldung.rxjava.jdbc;
+
+public class Manager {
+
+    private int id;
+    private String name;
+
+    public Manager(int id, String name) {
+        this.id = id;
+        this.name = name;
+    }
+
+    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;
+    }
+}

rxjava/src/main/java/com/baeldung/rxjava/jdbc/Utils.java

@@ -0,0 +1,16 @@
+package com.baeldung.rxjava.jdbc;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.StringWriter;
+
+import org.apache.commons.io.IOUtils;
+
+class Utils {
+
+    static String getStringFromInputStream(InputStream input) throws IOException {
+        StringWriter writer = new StringWriter();
+        IOUtils.copy(input, writer, "UTF-8");
+        return writer.toString();
+    }
+}

rxjava/src/test/java/com/baeldung/rxjava/jdbc/AutomapClassTest.java

@@ -0,0 +1,63 @@
+package com.baeldung.rxjava.jdbc;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import java.util.List;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+import com.github.davidmoten.rx.jdbc.ConnectionProvider;
+import com.github.davidmoten.rx.jdbc.Database;
+
+import rx.Observable;
+
+public class AutomapClassTest {
+
+    ConnectionProvider connectionProvider = Connector.connectionProvider;
+    Database db = Database.from(connectionProvider);
+
+    Observable<Integer> create = null;
+    Observable<Integer> insert1, insert2 = null;
+
+    @Before
+    public void setup() {
+        create = db.update("CREATE TABLE IF NOT EXISTS MANAGER(id int primary key, name varchar(255))")
+          .count();
+        insert1 = db.update("INSERT INTO MANAGER(id, name) VALUES(1, 'Alan')")
+          .dependsOn(create)
+          .count();
+        insert2 = db.update("INSERT INTO MANAGER(id, name) VALUES(2, 'Sarah')")
+          .dependsOn(create)
+          .count();
+    }
+
+    @Test
+    public void whenSelectManagersAndAutomap_thenCorrect() {
+        List<Manager> managers = db.select("select id, name from MANAGER")
+          .dependsOn(create)
+          .dependsOn(insert1)
+          .dependsOn(insert2)
+          .autoMap(Manager.class)
+          .toList()
+          .toBlocking()
+          .single();
+
+        assertThat(managers.get(0)
+          .getId()).isEqualTo(1);
+        assertThat(managers.get(0)
+          .getName()).isEqualTo("Alan");
+        assertThat(managers.get(1)
+           .getId()).isEqualTo(2);
+        assertThat(managers.get(1)
+          .getName()).isEqualTo("Sarah");
+    }
+
+    @After
+    public void close() {
+        db.update("DROP TABLE MANAGER")
+          .dependsOn(create);
+        connectionProvider.close();
+    }
+}

rxjava/src/test/java/com/baeldung/rxjava/jdbc/AutomapInterfaceTest.java

@@ -0,0 +1,64 @@
+package com.baeldung.rxjava.jdbc;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import java.util.List;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+import com.github.davidmoten.rx.jdbc.ConnectionProvider;
+import com.github.davidmoten.rx.jdbc.Database;
+
+import rx.Observable;
+
+public class AutomapInterfaceTest {
+
+    ConnectionProvider connectionProvider = Connector.connectionProvider;
+    Database db = Database.from(connectionProvider);
+
+    Observable<Integer> create = null;
+    Observable<Integer> insert1, insert2 = null;
+
+    @Before
+    public void setup() {
+        create = db.update("CREATE TABLE IF NOT EXISTS EMPLOYEE(id int primary key, name varchar(255))")
+          .count();
+        insert1 = db.update("INSERT INTO EMPLOYEE(id, name) VALUES(1, 'Alan')")
+          .dependsOn(create)
+          .count();
+        insert2 = db.update("INSERT INTO EMPLOYEE(id, name) VALUES(2, 'Sarah')")
+          .dependsOn(create)
+          .count();
+    }
+
+    @Test
+    public void whenSelectFromTableAndAutomap_thenCorrect() {
+        List<Employee> employees = db.select("select id, name from EMPLOYEE")
+          .dependsOn(create)
+          .dependsOn(insert1)
+          .dependsOn(insert2)
+          .autoMap(Employee.class)
+          .toList()
+          .toBlocking()
+          .single();
+
+        assertThat(employees.get(0)
+          .id()).isEqualTo(1);
+        assertThat(employees.get(0)
+          .name()).isEqualTo("Alan");
+        assertThat(employees.get(1)
+          .id()).isEqualTo(2);
+        assertThat(employees.get(1)
+          .name()).isEqualTo("Sarah");
+    }
+
+    @After
+    public void close() {
+        db.update("DROP TABLE EMPLOYEE")
+            .dependsOn(create);
+        connectionProvider.close();
+    }
+
+}

rxjava/src/test/java/com/baeldung/rxjava/jdbc/BasicQueryTypesTest.java

@@ -0,0 +1,64 @@
+package com.baeldung.rxjava.jdbc;
+
+import static org.junit.Assert.assertEquals;
+
+import java.util.Arrays;
+import java.util.List;
+
+import org.junit.After;
+import org.junit.Test;
+
+import com.github.davidmoten.rx.jdbc.ConnectionProvider;
+import com.github.davidmoten.rx.jdbc.Database;
+
+import rx.Observable;
+
+public class BasicQueryTypesTest {
+
+    ConnectionProvider connectionProvider = Connector.connectionProvider;
+    Database db = Database.from(connectionProvider);
+
+    Observable<Integer> create, insert1, insert2, insert3, update, delete = null;
+
+    @Test
+    public void whenCreateTableAndInsertRecords_thenCorrect() {
+        create = db.update("CREATE TABLE IF NOT EXISTS EMPLOYEE(id int primary key, name varchar(255))")
+          .count();
+        insert1 = db.update("INSERT INTO EMPLOYEE(id, name) VALUES(1, 'John')")
+          .dependsOn(create)
+          .count();
+        update = db.update("UPDATE EMPLOYEE SET name = 'Alan' WHERE id = 1")
+          .dependsOn(create)
+          .count();
+        insert2 = db.update("INSERT INTO EMPLOYEE(id, name) VALUES(2, 'Sarah')")
+          .dependsOn(create)
+          .count();
+        insert3 = db.update("INSERT INTO EMPLOYEE(id, name) VALUES(3, 'Mike')")
+          .dependsOn(create)
+          .count();
+        delete = db.update("DELETE FROM EMPLOYEE WHERE id = 2")
+          .dependsOn(create)
+          .count();
+        List<String> names = db.select("select name from EMPLOYEE where id < ?")
+          .parameter(3)
+          .dependsOn(create)
+          .dependsOn(insert1)
+          .dependsOn(insert2)
+          .dependsOn(insert3)
+          .dependsOn(update)
+          .dependsOn(delete)
+          .getAs(String.class)
+          .toList()
+          .toBlocking()
+          .single();
+
+        assertEquals(Arrays.asList("Alan"), names);
+    }
+
+    @After
+    public void close() {
+        db.update("DROP TABLE EMPLOYEE")
+          .dependsOn(create);
+        connectionProvider.close();
+    }
+}

rxjava/src/test/java/com/baeldung/rxjava/jdbc/InsertBlobTest.java

@@ -0,0 +1,65 @@
+package com.baeldung.rxjava.jdbc;
+
+import static org.junit.Assert.assertEquals;
+
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.charset.StandardCharsets;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+import com.github.davidmoten.rx.jdbc.ConnectionProvider;
+import com.github.davidmoten.rx.jdbc.Database;
+
+import rx.Observable;
+
+public class InsertBlobTest {
+
+    ConnectionProvider connectionProvider = Connector.connectionProvider;
+    Database db = Database.from(connectionProvider);
+
+    String expectedDocument = null;
+    String actualDocument = null;
+
+    Observable<Integer> create, insert = null;
+
+    @Before
+    public void setup() throws IOException {
+        create = db.update("CREATE TABLE IF NOT EXISTS SERVERLOG (id int primary key, document BLOB)")
+          .count();
+
+        InputStream actualInputStream = new FileInputStream("src/test/resources/actual_clob");
+        this.actualDocument = Utils.getStringFromInputStream(actualInputStream);
+        byte[] bytes = this.actualDocument.getBytes(StandardCharsets.UTF_8);
+
+        InputStream expectedInputStream = new FileInputStream("src/test/resources/expected_clob");
+        this.expectedDocument = Utils.getStringFromInputStream(expectedInputStream);
+        this.insert = db.update("insert into SERVERLOG(id,document) values(?,?)")
+          .parameter(1)
+          .parameter(Database.toSentinelIfNull(bytes))
+          .dependsOn(create)
+          .count();
+    }
+
+    @Test
+    public void whenInsertBLOB_thenCorrect() throws IOException {
+        db.select("select document from SERVERLOG where id = 1")
+          .dependsOn(create)
+          .dependsOn(insert)
+          .getAs(String.class)
+          .toList()
+          .toBlocking()
+          .single();
+        assertEquals(expectedDocument, actualDocument);
+    }
+
+    @After
+    public void close() {
+        db.update("DROP TABLE SERVERLOG")
+          .dependsOn(create);
+        connectionProvider.close();
+    }
+}

rxjava/src/test/java/com/baeldung/rxjava/jdbc/InsertClobTest.java

@@ -0,0 +1,63 @@
+package com.baeldung.rxjava.jdbc;
+
+import static org.junit.Assert.assertEquals;
+
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+import com.github.davidmoten.rx.jdbc.ConnectionProvider;
+import com.github.davidmoten.rx.jdbc.Database;
+
+import rx.Observable;
+
+public class InsertClobTest {
+
+    ConnectionProvider connectionProvider = Connector.connectionProvider;
+    Database db = Database.from(connectionProvider);
+
+    String expectedDocument = null;
+    String actualDocument = null;
+
+    Observable<Integer> create, insert = null;
+
+    @Before
+    public void setup() throws IOException {
+        create = db.update("CREATE TABLE IF NOT EXISTS SERVERLOG (id int primary key, document CLOB)")
+          .count();
+
+        InputStream actualInputStream = new FileInputStream("src/test/resources/actual_clob");
+        this.actualDocument = Utils.getStringFromInputStream(actualInputStream);
+
+        InputStream expectedInputStream = new FileInputStream("src/test/resources/expected_clob");
+        this.expectedDocument = Utils.getStringFromInputStream(expectedInputStream);
+        this.insert = db.update("insert into SERVERLOG(id,document) values(?,?)")
+          .parameter(1)
+          .parameter(Database.toSentinelIfNull(actualDocument))
+          .dependsOn(create)
+          .count();
+    }
+
+    @Test
+    public void whenSelectCLOB_thenCorrect() throws IOException {
+        db.select("select document from SERVERLOG where id = 1")
+          .dependsOn(create)
+          .dependsOn(insert)
+          .getAs(String.class)
+          .toList()
+          .toBlocking()
+          .single();
+        assertEquals(expectedDocument, actualDocument);
+    }
+
+    @After
+    public void close() {
+        db.update("DROP TABLE SERVERLOG")
+          .dependsOn(create);
+        connectionProvider.close();
+    }
+}

rxjava/src/test/java/com/baeldung/rxjava/jdbc/ReturnKeysTest.java

@@ -0,0 +1,48 @@
+package com.baeldung.rxjava.jdbc;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+import com.github.davidmoten.rx.jdbc.ConnectionProvider;
+import com.github.davidmoten.rx.jdbc.Database;
+
+import rx.Observable;
+
+public class ReturnKeysTest {
+
+    Observable<Boolean> begin, commit = null;
+    Observable<Integer> createStatement, insertStatement, updateStatement = null;
+
+    ConnectionProvider connectionProvider = Connector.connectionProvider;
+    Database db = Database.from(connectionProvider);
+
+    @Before
+    public void setup() {
+        begin = db.beginTransaction();
+        createStatement = db.update("CREATE TABLE IF NOT EXISTS EMPLOYEE(id int auto_increment primary key, name varchar(255))")
+          .dependsOn(begin)
+          .count();
+    }
+
+    @Test
+    public void whenInsertAndReturnGeneratedKey_thenCorrect() {
+        Integer key = db.update("INSERT INTO EMPLOYEE(name) VALUES('John')")
+          .dependsOn(createStatement)
+          .returnGeneratedKeys()
+          .getAs(Integer.class)
+          .count()
+          .toBlocking()
+          .single();
+        assertThat(key).isEqualTo(1);
+    }
+
+    @After
+    public void close() {
+        db.update("DROP TABLE EMPLOYEE")
+          .dependsOn(createStatement);
+        connectionProvider.close();
+    }
+}

rxjava/src/test/java/com/baeldung/rxjava/jdbc/TransactionTest.java

@@ -0,0 +1,50 @@
+package com.baeldung.rxjava.jdbc;
+
+import static org.junit.Assert.assertEquals;
+
+import org.junit.After;
+import org.junit.Test;
+
+import com.github.davidmoten.rx.jdbc.ConnectionProvider;
+import com.github.davidmoten.rx.jdbc.Database;
+
+import rx.Observable;
+
+public class TransactionTest {
+
+    Observable<Boolean> begin, commit = null;
+    Observable<Integer> createStatement, insertStatement, updateStatement = null;
+
+    ConnectionProvider connectionProvider = Connector.connectionProvider;
+    Database db = Database.from(connectionProvider);
+
+    @Test
+    public void whenCommitTransaction_thenRecordUpdated() {
+        Observable<Boolean> begin = db.beginTransaction();
+        Observable<Integer> createStatement = db
+          .update("CREATE TABLE IF NOT EXISTS EMPLOYEE(id int primary key, name varchar(255))")
+          .dependsOn(begin)
+          .count();
+        Observable<Integer> insertStatement = db.update("INSERT INTO EMPLOYEE(id, name) VALUES(1, 'John')")
+          .dependsOn(createStatement)
+          .count();
+        Observable<Integer> updateStatement = db.update("UPDATE EMPLOYEE SET name = 'Tom' WHERE id = 1")
+          .dependsOn(insertStatement)
+          .count();
+        Observable<Boolean> commit = db.commit(updateStatement);
+        String name = db.select("select name from EMPLOYEE WHERE id = 1")
+          .dependsOn(commit)
+          .getAs(String.class)
+          .toBlocking()
+          .single();
+
+        assertEquals("Tom", name);
+    }
+
+    @After
+    public void close() {
+        db.update("DROP TABLE EMPLOYEE")
+          .dependsOn(createStatement);
+        connectionProvider.close();
+    }
+}