#3 Ebean implementation

 + Changed autowiring of beans to be constructor based
 + Made build.gradle more readable (I hope)

Author: bretislav.wajtr

README.md

@@ -4,7 +4,7 @@ Comparison of how **non-JPA** SQL mapping (persistence) frameworks for Java (Joo
 
 I'm not comparing performance, but rather how are these frameworks used for everyday tasks.
 
-I 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
+I prepared some common scenarios, which you typically need to implement data-centric application, and then I 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!**)
@@ -23,6 +23,7 @@ With that conditions in respect, following frameworks were 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))
 * **MyBatis** (see [implementation](src/main/java/com/clevergang/dbtests/repository/impl/mybatis/MyBatisDataRepositoryImpl.java) and  [mapper](src/main/resources/mybatis/mappers/DataRepositoryMapper.xml))
+* **EBean** (see [implementation](src/main/java/com/clevergang/dbtests/repository/impl/ebean/EBeanDataRepositoryImpl.java)) 
 
 I tried to find optimal (== most readable) implementation in every framework, but comments are welcomed! There are lot of comments in the code explaining why I chose such implementation and some FIXMEs on places which I do not like, but which cannot be implemented differently or which I have troubles to improve...
 
@@ -57,7 +58,8 @@ Each scenario has it's implementation in the Scenarios class. See javadoc of [Sc
 2. Configure PostgreSQL connection details in [application.properties](src/main/resources/application.properties)
 3. Create tables and data by running [create-script.sql](sql-updates/create-script.sql)
 4. Create one stored procedure by running [register_employee.sql](sql-updates/sql_functions/register_employee.sql)
-5. Give the scenarios a test run by running one of the test classes and enjoy :)
+5. Tests will passing when executed from gradle build. If you want tests to be passing even from your IDE, then [setup EBean enhancer for your IDE](http://ebean-orm.github.io/docs/setup/enhancement) 
+6. Give the scenarios a test run by running one of the test classes and enjoy :)
 
 ## Why only non-JPA?
 
@@ -98,12 +100,24 @@ Please note that following remarks are very subjective and does not have to nece
   * Not so much usable for big queries - it's better to use native SQL (see scenario 9.)
   * Weird syntax for performing batch operations (in case that you do not use UpdatableRecord). But it's not a big deal... 
 
-
 **MyBatis**
 * Pros
   * Writing SQL statements in XML mapper file feels good - it's easy to work with parameters.
 * Cons
   * quite a lot of files for single DAO imlementation (MyBatisDataRepositoryImpl, DataRepositoryMapper and DataRepositoryMapper.xml), though navigation is not such a big deal
   * at version 3.4.0 unable to work with Java8 DateTime types (LocalDate etc.), support possible through 3rd party library (mybatis-types), see build.gradle and <typeHandlers> configuration in mybatis-config.xml
   * can't run batch and non-batch operations in single SqlSession, but have to create completely new SqlSession instead (see configuration in DbTestsApplication class). Surprisingly, this does not necessarily mean that the batch and non-batch operations will be executed in different transactions (as we would expect), so at the end this is not a total drawback, but just inconvenience
-  * expected that localCacheScope=STATEMENT is default MyBatis behavior, which is not... I know this is questionable drawback, but it was kind of surprise for me, see mybatis-config.xml
+  * expected that localCacheScope=STATEMENT is default MyBatis behavior, which is not... I know this is questionable drawback, but it was kind of surprise for me, see mybatis-config.xml
+  
+**EBean**
+* Pros
+  * Everything looks very nice - all the scenarios are implemented by very readable code
+  * Super simple batch operations (actually it's only about using right method :) ) 
+  * Although there are methods which make CRUD operations and Querying super simple, there are still means how to execute plain SQL and even a way how to get the basic JDBC Transaction object, which you can use for core JDBC stuff. That is really good.  
+* Cons
+  * Necessity to write the entities (I mean @Entity classes) - it would be cool to have some generator for it
+  * Necessity of "enhancement" of the entities - this was quite surprising for me - but actually it's basically only about right environment setup (IDE plugin and Gradle plugin) and then you don't have to think about it 
+  * Online documentation is quite weak (as of December 1, 2016). Lot of things are hidden in videos and you have to google for details or get into JavaDocs... Hoverwer, JavaDoc is very good and I generally didn't a problem to find what I need in JavaDoc. Also the API is quite understandable... at the end weak online documentation is not such a big deal.
+  * Logging could be better
+  * Allows JPA OneToMany and ManyToOne relations modeling and possibility to "lazy fetch" these relations - actually I do not like this concept at all as it can lead to potentially very ineffective code. Per documentation and experiences of several people on internet EBean behaves better than full blown JPA implementation in this manner, but you can still be hit by the N+1 problem and all the performance traps, which lazy fetching brings... 
+  

build.gradle

@@ -1,47 +1,71 @@
-
-buildscript {
-    repositories {
-        jcenter()
-    }
-    dependencies {
-        classpath "org.springframework.boot:spring-boot-gradle-plugin:1.4.1.RELEASE"  // to include SpringBoot parent BOM
-    }
-}
-
-apply plugin: 'spring-boot'
-apply plugin: 'java'
-
 group = 'com.clevergang'
 version = '1.0.0'
 description = 'Comparison and common patterns for non-JPA SQL mapping frameworks for Java (Jooq, Spring JDBCTemplate etc.)'
 
-repositories {
-    jcenter()
-    maven { url "https://jitpack.io" }
-}
+apply plugin: 'spring-boot'
+apply plugin: 'java'
+apply plugin: 'com.github.kt3k.ebean.enhance'  // required so the enhancer works, see below
 
 // We need Java8 for this project
 tasks.withType(JavaCompile) {
     sourceCompatibility = '1.8'
 }
 
+// this is actually required for EBean to work. EBean needs all @Entity classes to be enhanced before usage
+// for gradle builds this is how the entities are enhanced. See more info here:
+//      http://ebean-orm.github.io/docs/setup/enhancement
+// and here:
+//      https://github.com/kt3k/ebean-enhance-plugin
+ebeanEnhance {
+    packages = 'com.clevergang.dbtests.repository.impl.ebean.entities.**'
+    agentVersion = '8.1.1'
+}
+
 dependencies {
-    compile "org.springframework.boot:spring-boot-starter-jdbc"
-    compile "org.springframework.boot:spring-boot-starter-jooq"
-    compile 'org.mybatis.spring.boot:mybatis-spring-boot-starter:1.1.1'
-    compile "org.postgresql:postgresql:9.4.1212"
-    compile "org.apache.commons:commons-lang3:3.4"
-    compile "org.apache.commons:commons-collections4:4.1"
+    compile(
+            "org.springframework.boot:spring-boot-starter-jdbc",
+            "org.postgresql:postgresql:9.4.1212",
+            "org.apache.commons:commons-lang3:3.4",
+            "org.apache.commons:commons-collections4:4.1",
+
+            // jOOQ dependencies
+            "org.springframework.boot:spring-boot-starter-jooq",
 
-    // required so mybatis works with java8 datetime classes (LocalDate)
-    compile 'com.github.javaplugs:mybatis-types:0.3'
+            // EBean dependencies
+            "org.avaje.ebean:ebean:9.2.1",
+            "org.avaje.ebean:ebean-spring:7.2.1",
 
-    testCompile "org.springframework.boot:spring-boot-starter-test"
+            // MyBatis dependencies
+            'org.mybatis.spring.boot:mybatis-spring-boot-starter:1.1.1',
+            'com.github.javaplugs:mybatis-types:0.3' // required so mybatis works with java8 datetime classes (LocalDate)
+    )
+
+    testCompile(
+            "org.springframework.boot:spring-boot-starter-test"
+    )
 }
 
 // we want to show following test events in the log
 test {
     testLogging {
         events "PASSED", "FAILED", "SKIPPED"
     }
+}
+
+buildscript {
+    repositories {
+        jcenter()
+        maven {
+            url "https://plugins.gradle.org/m2/"
+        }
+    }
+    dependencies {
+        classpath "org.springframework.boot:spring-boot-gradle-plugin:1.4.1.RELEASE"  // to include SpringBoot parent BOM
+        classpath "gradle.plugin.org.kt3k:ebean-enhance-plugin:2.0.5"
+    }
+}
+
+repositories {
+    jcenter()
+    maven { url "https://jitpack.io" }
 }

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

@@ -1,5 +1,9 @@
 package com.clevergang.dbtests;
 
+import com.avaje.ebean.EbeanServer;
+import com.avaje.ebean.EbeanServerFactory;
+import com.avaje.ebean.config.ServerConfig;
+import com.avaje.ebean.springsupport.txn.SpringAwareJdbcTransactionManager;
 import org.apache.ibatis.session.ExecutorType;
 import org.apache.ibatis.session.SqlSession;
 import org.apache.ibatis.session.SqlSessionFactory;
@@ -25,9 +29,9 @@
 @Configuration
 public class DbTestsApplication {
 
-    /**
+    /*
      * JOOQ CONFIGURATIONS
-     **/
+     */
 
     @Bean
     @Primary
@@ -47,9 +51,9 @@ public Settings jooqStaticStatementSettings() {
         return ret;
     }
 
-    /**
+    /*
      * MYBATIS CONFIGURATIONS
-     **/
+     */
 
     @Bean
     @Primary
@@ -78,6 +82,30 @@ executed in different transactions (as we would expect) - we tested this configu
         return new SqlSessionTemplate(sqlSessionFactoryBean.getObject(), ExecutorType.BATCH);
     }
 
+    /*
+     * EBEAN CONFIGURATIONS
+     */
+
+    @SuppressWarnings("SpringJavaAutowiringInspection")
+    @Bean
+    public ServerConfig ebeanServerConfig(DataSource dataSource) {
+        ServerConfig config = new ServerConfig();
+        config.setName("ebeanServer");
+        config.setDefaultServer(true);
+        config.setDataSource(dataSource);
+        config.addPackage("com.clevergang.dbtests.repository.impl.ebean.entities");
+        config.setExternalTransactionManager(new SpringAwareJdbcTransactionManager());
+        config.setAutoCommitMode(false);
+        config.setExpressionNativeIlike(true);
+
+        return config;
+    }
+
+    @Bean
+    public EbeanServer ebeanServer(ServerConfig serverConfig) {
+        return EbeanServerFactory.create(serverConfig);
+    }
+
     public static void main(String[] args) {
         SpringApplication.run(DbTestsApplication.class, args);
     }

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

@@ -64,6 +64,9 @@ public void fetchListOfEntitiesScenario(Integer employeeMinSalary) {
         // check some post conditions
         assert employees != null;
         assert employees.size() == 3;
+        assert employees.get(0).getSalary().compareTo(new BigDecimal(employeeMinSalary)) > 0;
+        assert employees.get(1).getSalary().compareTo(new BigDecimal(employeeMinSalary)) > 0;
+        assert employees.get(2).getSalary().compareTo(new BigDecimal(employeeMinSalary)) > 0;
         logger.info("Fetched result: {}", employees);
     }
 
@@ -112,12 +115,17 @@ public void batchInsertMultipleEntitiesScenario() {
         }
 
         // SCENARIO CODE STARTS HERE
+        long start = System.nanoTime();
         List<Integer> newPids = repository.insertProjects(projects);
 
         // check some post conditions
         Integer projectsCount = repository.getProjectsCount();
+        long end = System.nanoTime();
+
         assert projectsCount == 1002;
         logger.info("Scenario 4. output {}", newPids);
+        logger.info("Rough time needed for execution (without commit): {} ms", (end - start) / 1000000d);
+
     }
 
     /**