Finished implementation of MyBatis version + added asserts to the scenarios (for better verification of results)

Author: bretislav.wajtr

README.md

@@ -1,17 +1,20 @@
 # Java repository layer frameworks comparison
 
-Comparison of usage of non-JPA SQL mapping (persistence) frameworks for Java (Jooq, Spring JDBCTemplate etc.).
+Comparison of usage of non-JPA SQL mapping (persistence) frameworks for Java (Jooq, Spring JDBCTemplate, MyBatis etc.).
 
-We are not comparing performance (that'll be maybe added later), but rather how are these frameworks used for everyday tasks.
+We are not comparing performance, but rather how are these frameworks used for everyday tasks.
 
-We prepared some common scenarios, which you typically need to implement data-centric application, and then we implemented these scenarios using various non-JPA DB layer frameworks.
+We prepared some common scenarios, which you typically need to implement data-centric application, and then we implemented these scenarios using various non-JPA DB layer frameworks. This project should serve
+- as point of reference when deciding for SQL mapping framework 
+- as a template of common framework usage scenarios (see scenarios below)
+- to document best practices of such common usages (**comments are welcomed!**)
 
 ## Frameworks compared
 
 * Spring JDBCTemplate (see [implementation](src/main/java/com/clevergang/dbtests/repository/impl/jdbctemplate/JDBCDataRepositoryImpl.java))
 * jOOQ (see [implementation](src/main/java/com/clevergang/dbtests/repository/impl/jooq/JooqDataRepositoryImpl.java))
 
-We tried to find optimal (== most readable) implementation in every framework, but comments are welcomed! There are lot of comments explaining why we chose to such implementation and some FIXMEs on places which we do not like, but which cannot be implemented differently or which we do not know how to improve...
+We tried to find optimal (== most readable) implementation in every framework, but comments are welcomed! There are lot of comments explaining why we chose to such implementation and some FIXMEs on places which we do not like, but which cannot be implemented differently or which we have troubles to improve...
 
 ## Scenarios implemented
 
@@ -49,11 +52,6 @@ Well, we were trying to "stick with standard" in our projects so we used JPA in
 
 So we dropped JPA completely, started using JDBCTemplate and discovered that we can deliver apps sooner (which was kind of surprising), they are a lot faster (thanks to effective use of DB) and much more robust... This was really relaxing and we do not plan to return to JPA at all... (yes, even for CRUD applications!) 
 
-This project aims to explore other options in the SQL mapping area than just JDBCTemplate. It should serve us
- 
-- as point of reference when deciding for SQL mapping framework 
-- as a template of common DB usage scenarios
-- to document best practices of such common usages (**comments are welcomed!**)
-
+This project aims to explore other options in the SQL mapping area than just JDBCTemplate. 
 
 **Use code in the repository as you like (MIT License)**

build.gradle

@@ -17,6 +17,7 @@ description = 'Comparison and common patterns for non-JPA SQL mapping frameworks
 
 repositories {
     jcenter()
+    maven { url "https://jitpack.io" }
 }
 
 // We need Java8 for this project
@@ -32,6 +33,9 @@ dependencies {
     compile "org.apache.commons:commons-lang3:3.4"
     compile "org.apache.commons:commons-collections4:4.1"
 
+    // required so mybatis works with java8 datetime classes (LocalDate)
+    compile 'com.github.javaplugs:mybatis-types:0.3'
+
     testCompile "org.springframework.boot:spring-boot-starter-test"
 }
 

sql-updates/create-script.sql

@@ -18,13 +18,13 @@ CREATE TABLE Company (
 
 CREATE TABLE Department (
   pid SERIAL PRIMARY KEY,
-  company_pid INTEGER NOT NULL REFERENCES Company (pid) ON DELETE CASCADE,
+  company_pid INTEGER NOT NULL REFERENCES Company (pid) ON DELETE NO ACTION,
   name TEXT NOT NULL
 );
 
 CREATE TABLE Employee (
   pid            SERIAL PRIMARY KEY,
-  department_pid INTEGER NOT NULL REFERENCES Department (pid) ON DELETE CASCADE,
+  department_pid INTEGER NOT NULL REFERENCES Department (pid) ON DELETE NO ACTION,
   name           TEXT    NOT NULL,
   surname        TEXT    NOT NULL,
   email          TEXT,
@@ -40,8 +40,8 @@ CREATE TABLE Project (
 );
 
 CREATE TABLE ProjectEmployee (
-  project_pid INTEGER REFERENCES Project,
-  employee_pid INTEGER REFERENCES Employee,
+  project_pid INTEGER REFERENCES Project ON DELETE NO ACTION,
+  employee_pid INTEGER REFERENCES Employee ON DELETE NO ACTION,
   PRIMARY KEY (project_pid, employee_pid)
 );
 

src/main/java/com/clevergang/dbtests/DbTestsApplication.java

@@ -1,14 +1,22 @@
 package com.clevergang.dbtests;
 
+import org.apache.ibatis.session.ExecutorType;
+import org.apache.ibatis.session.SqlSession;
+import org.apache.ibatis.session.SqlSessionFactory;
 import org.jooq.conf.RenderNameStyle;
 import org.jooq.conf.Settings;
 import org.jooq.conf.StatementType;
+import org.mybatis.spring.SqlSessionFactoryBean;
+import org.mybatis.spring.SqlSessionTemplate;
 import org.springframework.beans.factory.annotation.Qualifier;
 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.context.annotation.Primary;
+import org.springframework.core.io.ClassPathResource;
+
+import javax.sql.DataSource;
 
 /**
  * This whole thing is based on Spring Boot as we plan to use these frameworks with SpringBoot
@@ -17,6 +25,10 @@
 @Configuration
 public class DbTestsApplication {
 
+    /**
+     * JOOQ CONFIGURATIONS
+     **/
+
     @Bean
     @Primary
     public Settings jooqSettings() {
@@ -35,6 +47,37 @@ public Settings jooqStaticStatementSettings() {
         return ret;
     }
 
+    /**
+     * MYBATIS CONFIGURATIONS
+     **/
+
+    @Bean
+    @Primary
+    @SuppressWarnings("SpringJavaAutowiringInspection")
+    public SqlSession myBatisDefaultSession(SqlSessionFactory sqlSessionFactory) {
+        return new SqlSessionTemplate(sqlSessionFactory);
+    }
+
+    @Bean
+    @Qualifier("batch-operations")
+    @SuppressWarnings("SpringJavaAutowiringInspection")
+    public SqlSession myBatisBatchOperationstSession(DataSource dataSource) throws Exception {
+        /*
+            NOTE: Unfortunately, in MyBatis it's not possible to execute batch and non-batch operations in single SqlSession.
+            To support this scenario, we have to create completely new SqlSessionFactoryBean and completely new
+            SqlSession. Surprisingly, this does not necessarily mean that the batch and non-batch operations will be
+            executed in different transactions (as we would expect) - we tested this configuration using scenario 8.
+            and it turned out that the bot non-batch and batch operations were run using same connection and in same transaction.
+            I guess this has something to do with how connection is obtained by MyBatis from dataSource...
+        */
+
+        SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
+        sqlSessionFactoryBean.setDataSource(dataSource);
+        sqlSessionFactoryBean.setConfigLocation(new ClassPathResource("mybatis/mybatis-config.xml"));
+
+        return new SqlSessionTemplate(sqlSessionFactoryBean.getObject(), ExecutorType.BATCH);
+    }
+
     public static void main(String[] args) {
         SpringApplication.run(DbTestsApplication.class, args);
     }

src/main/java/com/clevergang/dbtests/Scenarios.java

@@ -6,11 +6,13 @@
 import org.apache.commons.lang3.RandomStringUtils;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
-import org.springframework.util.StopWatch;
 
 import java.math.BigDecimal;
 import java.time.LocalDate;
-import java.util.*;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
 import java.util.stream.Collectors;
 
 import static java.util.stream.Collectors.toList;
@@ -43,6 +45,10 @@ public Scenarios(DataRepository repository) {
     public void fetchSingleEntityScenario(Integer companyPid) {
         Company company = repository.findCompany(companyPid);
 
+        // check some post conditions
+        assert company != null;
+        assert company.getPid().equals(companyPid);
+        assert company.getName().equals("CleverGang");
         logger.info("Fetched result: {}", company);
     }
 
@@ -55,6 +61,9 @@ public void fetchSingleEntityScenario(Integer companyPid) {
     public void fetchListOfEntitiesScenario(Integer employeeMinSalary) {
         List<Employee> employees = repository.employeesWithSalaryGreaterThan(employeeMinSalary);
 
+        // check some post conditions
+        assert employees != null;
+        assert employees.size() == 3;
         logger.info("Fetched result: {}", employees);
     }
 
@@ -66,8 +75,14 @@ public void saveNewEntityScenario() {
         project.setName("TestProject");
         project.setDate(LocalDate.now());
 
-        repository.insertProject(project);
-    }
+        // SCENARIO CODE STARTS HERE
+        Integer newPid = repository.insertProject(project);
+
+        // check some post conditions
+        assert newPid != null;
+        assert newPid > 2;
+        logger.info("Scenario three, pid of inserted entity: {}", newPid);
+   }
 
     /**
      * 4. Batch insert multiple entities of same type and return generated keys
@@ -81,17 +96,20 @@ public void saveNewEntityScenario() {
     public void batchInsertMultipleEntitiesScenario() {
         // create a list of thousand products
         List<Project> projects = new ArrayList<>();
-        StopWatch watch = new StopWatch();
-        watch.start();
         for (int i = 0; i < 1000; i++) {
             Project project = new Project();
             project.setName(RandomStringUtils.randomAlphabetic(10));
             project.setDate(LocalDate.now());
             projects.add(project);
         }
-        repository.insertProjects(projects);
-        watch.stop();
-        logger.info("Total time {} ms", watch.getTotalTimeMillis());
+
+        // SCENARIO CODE STARTS HERE
+        List<Integer> newPids = repository.insertProjects(projects);
+
+        // check some postconditions
+        Integer projectsCount = repository.getProjectsCount();
+        assert projectsCount == 1002;
+        logger.info("Scenario 4. output {}", newPids);
     }
 
     /**
@@ -103,22 +121,29 @@ public void batchInsertMultipleEntitiesScenario() {
      */
     public void updateCompleteEntityScenario() {
         // Imagine that this object comes from UI edit dialog, which is typical scenario
-        Employee employeeToUpdate = performSomeEmployeeRecordUpdateInUI();
-
-        // SCENARIO CODE STARTS HERE - update the employee in DB
+        Employee employeeToUpdate = performSomeEmployeeRecordModificationsInUI(1);
 
+        // SCENARIO CODE STARTS HERE
         repository.updateEmployee(employeeToUpdate);
 
+        // check some post conditions
+        Employee updatedEmployee = repository.findEmployee(1);
+        assert employeeToUpdate.getPid().equals(updatedEmployee.getPid());
+        assert employeeToUpdate.getDepartmentPid().equals(updatedEmployee.getDepartmentPid());
+        assert employeeToUpdate.getName().equals(updatedEmployee.getName());
+        assert employeeToUpdate.getSurname().equals(updatedEmployee.getSurname());
+        assert employeeToUpdate.getEmail().equals(updatedEmployee.getEmail());
+        assert employeeToUpdate.getSalary().equals(updatedEmployee.getSalary());
     }
 
-    private Employee performSomeEmployeeRecordUpdateInUI() {
+    private Employee performSomeEmployeeRecordModificationsInUI(Integer employeePid) {
         Employee employeeToUpdate = new Employee();
-        employeeToUpdate.setPid(1);
-        employeeToUpdate.setDepartmentPid(1);
-        employeeToUpdate.setName("Curt");
-        employeeToUpdate.setSurname("Odegaard");
-        employeeToUpdate.setEmail("curt.odegaard@updated.com");  // <-- this is updated value
-        employeeToUpdate.setSalary(new BigDecimal("15000")); // <-- this is updated value
+        employeeToUpdate.setPid(employeePid);
+        employeeToUpdate.setDepartmentPid(6);
+        employeeToUpdate.setName("Curt1");
+        employeeToUpdate.setSurname("Odegaard1");
+        employeeToUpdate.setEmail("curt.odegaard@updated.com1");  // <-- this is updated value
+        employeeToUpdate.setSalary(new BigDecimal("15000.00")); // <-- this is updated value
         return employeeToUpdate;
     }
 
@@ -128,13 +153,17 @@ private Employee performSomeEmployeeRecordUpdateInUI() {
     public void fetchManyToOneRelationScenario() {
         Department softwareDevelopmentDepartment = repository.findDepartment(3);
 
+        // SCENARIO CODE STARTS HERE
         // Getting Company for Department (many-to-one relation) in JPA is quite easy. You typically have
         // @ManyToOne relation defined in the Department entity class, so once you have instance of Department,
         // you just call department.getCompany() and JPA does the magic for you (typically one or more lazy selects
         // are executed). We don't have any such magical call here, but non-JPA approach is quite straightforward
         // too: we have company_pid, so just ask DataRepository for the record:
         Company company = repository.findCompany(softwareDevelopmentDepartment.getCompanyPid());
 
+        // check some post conditions
+        assert company.getName().equals("CleverGang");
+        assert company.getPid().equals(1);
         logger.info("Department {} is in the {} company", softwareDevelopmentDepartment.getName(), company.getName());
     }
 
@@ -144,13 +173,16 @@ public void fetchManyToOneRelationScenario() {
     public void fetchOneToManyRelationScenario() {
         Company company = repository.findCompany(1);
 
+        // SCENARIO CODE STARTS HERE
         // For one-to-many relations the situation is quite similar to many-to-one relations (scenario six). In JPA this
         // is "easy" - you define @OneToMany relation in the Company entity and then you just call getDepartments() method ->
         // a lazy select is issued and Departments are fetched from DB. However you can also use EAGER FetchType strategy which
         // causes the relation to load along with the primary entity - this behavior is (by our opinion) the source of all evil
         // in JPA... So, in non-JPA approach, we don't have any "eager" loads, just explicit calls for data:
         List<Department> departments = repository.findDepartmentsOfCompany(company);
 
+        // check some post conditions
+        assert departments.size() == 4;
         logger.info("There are {} departments in {} company", departments.size(), company.getName());
     }
 
@@ -176,11 +208,16 @@ public void updateCompleteOneToManyRelationScenario() {
 
 
         // SCENARIO CODE STARTS HERE - update departments in DB
-
         updateDepartments(company, newDepartments);
 
-        // now check the results
+        // check some post conditions
         List<Department> departmentsForCompany = repository.findDepartmentsOfCompany(company);
+        assert departmentsForCompany.size() == 5;
+        assert departmentsForCompany.get(0).getName().equals("Back office");
+        assert departmentsForCompany.get(1).getName().equals("IT Department Updated");
+        assert departmentsForCompany.get(2).getName().equals("Software Development");
+        assert departmentsForCompany.get(3).getName().equals("New department 1");
+        assert departmentsForCompany.get(4).getName().equals("New department 2");
         logger.info("State of database at the end of scenario eight: {}", departmentsForCompany);
     }
 
@@ -191,6 +228,7 @@ private void updateDepartments(Company company, List<Department> newDepartments)
 
         // first get current departments
         List<Department> currentDepartments = repository.findDepartmentsOfCompany(company);
+        logger.info("Company {} current departments {}", company.getName(), currentDepartments);
 
         // now determine which departments were deleted
         Collection<Integer> newPIDs = CollectionUtils.collect(newDepartments, Department::getPid);
@@ -222,13 +260,10 @@ private List<Department> createNewDepartmentsList(Company company) {
         departments.add(new Department(company.getPid(), "New department 2"));
 
         // update one item
-        Optional<Department> itDepartment = departments.stream()
+        departments.stream()
                 .filter(it -> it.getName().equals("IT Department"))
-                .findFirst();
-
-        if (itDepartment.isPresent()) {
-            itDepartment.get().setName("IT Department Updated");
-        }
+                .findFirst()
+                .ifPresent(it -> it.setName("IT Department Updated"));
 
         return departments;
     }
@@ -244,6 +279,13 @@ private List<Department> createNewDepartmentsList(Company company) {
     public void executeComplexSelectScenario() {
         List<ProjectsWithCostsGreaterThanOutput> projectsWithCostsGreaterThan = repository.getProjectsWithCostsGreaterThan(70000);
 
+        // check some post conditions
+        assert projectsWithCostsGreaterThan != null;
+        assert projectsWithCostsGreaterThan.size() == 2;
+        assert projectsWithCostsGreaterThan.get(0).getCompanyName().equals("CleverGang");
+        assert projectsWithCostsGreaterThan.get(0).getCompanyCost().equals(new BigDecimal("72000.00"));
+        assert projectsWithCostsGreaterThan.get(1).getCompanyName().equals("Supersoft");
+        assert projectsWithCostsGreaterThan.get(1).getCompanyCost().equals(new BigDecimal("13000.00"));
         logger.info("executeComplexSelectScenario output: {}", projectsWithCostsGreaterThan);
     }
 
@@ -253,6 +295,14 @@ public void executeComplexSelectScenario() {
     public void callStoredProcedureScenario() {
         RegisterEmployeeOutput output = repository.callRegisterEmployee("Bretislav", "Wajtr", "bretislav.wajtr@test.com", new BigDecimal(40000), "MyDepartment", "MyCompany");
 
+        // check some post conditions
+        assert output != null;
+        assert output.getEmployeePid() != null;
+        assert output.getEmployeePid() > 10;
+        assert output.getDepartmentPid() != null;
+        assert output.getDepartmentPid() > 7;
+        assert output.getCompanyPid() != null;
+        assert output.getCompanyPid() > 3;
         logger.info("callStoredProcedureScenario output: {}", output);
     }
 
@@ -272,7 +322,10 @@ public void callStoredProcedureScenario() {
     public void executeSimpleStaticStatementScenario() {
         Company output = repository.findCompanyUsingSimpleStaticStatement(1);
 
-        logger.info("Output: {}", output);
+        // check some post conditions
+        assert output != null;
+        assert output.getName().equals("CleverGang");
+        logger.info("Output of scenario 11: {}", output);
     }
 }