[maven-release-plugin] prepare release ebean-parent-12.11.3

#2335 -  L2 cache be triggered by in ?

.github/ISSUE_TEMPLATE.md

@@ -1,9 +1,3 @@
-
-GITHUB ISSUES ARE STRICTLY CONTROLLED FOR THIS PROJECT.
-
-Refer to http://ebean-orm.github.io/support for the policies controlling the use of github issues.
-Please post issues to the Ebean group https://groups.google.com/forum/#!forum/ebean first.
-
 ## Expected behavior
 
 ## Actual behavior

ebean-api/pom.xml

@@ -4,7 +4,7 @@
   <parent>
     <artifactId>ebean-parent</artifactId>
     <groupId>io.ebean</groupId>
-    <version>12.11.0</version>
+    <version>12.11.3</version>
   </parent>
 
   <name>ebean api</name>

ebean-api/src/main/java/io/ebean/BeanFinder.java

@@ -79,11 +79,11 @@ public abstract class BeanFinder<I,T> {
   /**
    * Creates an entity reference for this ID.
    * <p>
-   * Equivalent to {@link Database#getReference(Class, Object)}
+   * Equivalent to {@link Database#reference(Class, Object)}
    */
   @Nonnull
   public T ref(I id) {
-    return db().getReference(type, id);
+    return db().reference(type, id);
   }
 
   /**

ebean-api/src/main/java/io/ebean/BeanState.java

@@ -118,4 +118,9 @@ public interface BeanState {
    */
   @Nullable
   Map<String, Exception> getLoadErrors();
+
+  /**
+   * Return the sort order value for an order column.
+   */
+  int getSortOrder();
 }

ebean-api/src/main/java/io/ebean/DB.java

@@ -126,8 +126,16 @@ public final class DB {
    * an expression that uses OR like Expression e = Expr.or(..., ...);
    * </p>
    */
+  public static ExpressionFactory expressionFactory() {
+    return getDefault().expressionFactory();
+  }
+
+  /**
+   * Deprecated migrate to expressionFactory().
+   */
+  @Deprecated
   public static ExpressionFactory getExpressionFactory() {
-    return getDefault().getExpressionFactory();
+    return expressionFactory();
   }
 
   /**
@@ -650,8 +658,16 @@ public final class DB {
    * @param beanType the type of entity bean
    * @param id       the id value
    */
+  public static <T> T reference(Class<T> beanType, Object id) {
+    return getDefault().reference(beanType, id);
+  }
+
+  /**
+   * Deprecated migrate to beanId().
+   */
+  @Deprecated
   public static <T> T getReference(Class<T> beanType, Object id) {
-    return getDefault().getReference(beanType, id);
+    return reference(beanType, id);
   }
 
   /**
@@ -660,14 +676,12 @@ public final class DB {
    * <ul>
    * <li>asc - ascending order (which is the default)</li>
    * <li>desc - Descending order</li>
-   * <li>nullsHigh - Treat null values as high/large values (which is the
-   * default)</li>
+   * <li>nullsHigh - Treat null values as high/large values (which is the default)</li>
    * <li>nullsLow- Treat null values as low/very small values</li>
    * </ul>
    * <p>
    * If you leave off any keywords the defaults are ascending order and treating
    * nulls as high values.
-   * </p>
    * <p>
    * Note that the sorting uses a Comparator and Collections.sort(); and does
    * not invoke a DB query.
@@ -1231,30 +1245,54 @@ public final class DB {
    * This will return null if the bean is not an enhanced entity bean.
    * </p>
    */
+  public static BeanState beanState(Object bean) {
+    return getDefault().beanState(bean);
+  }
+
+  /**
+   * Deprecated migrate to beanState().
+   */
+  @Deprecated
   public static BeanState getBeanState(Object bean) {
-    return getDefault().getBeanState(bean);
+    return beanState(bean);
   }
 
   /**
    * Return the value of the Id property for a given bean.
    */
+  public static Object beanId(Object bean) {
+    return getDefault().beanId(bean);
+  }
+
+  /**
+   * Deprecated migrate to beanId().
+   */
+  @Deprecated
   public static Object getBeanId(Object bean) {
-    return getDefault().getBeanId(bean);
+    return beanId(bean);
   }
 
   /**
    * Return the manager of the level 2 cache ("L2" cache).
    */
   public static ServerCacheManager getServerCacheManager() {
-    return getDefault().getServerCacheManager();
+    return getDefault().cacheManager();
   }
 
   /**
    * Return the BackgroundExecutor service for asynchronous processing of
    * queries.
    */
+  public static BackgroundExecutor backgroundExecutor() {
+    return getDefault().backgroundExecutor();
+  }
+
+  /**
+   * Deprecated migrate to backgroundExecutor().
+   */
+  @Deprecated
   public static BackgroundExecutor getBackgroundExecutor() {
-    return getDefault().getBackgroundExecutor();
+    return backgroundExecutor();
   }
 
   /**

ebean-api/src/main/java/io/ebean/Database.java

@@ -120,34 +120,82 @@ public interface Database {
   /**
    * Return AutoTune which is used to control the AutoTune service at runtime.
    */
-  AutoTune getAutoTune();
+  AutoTune autoTune();
+
+  /**
+   * Deprecated migrate to autoTune().
+   */
+  @Deprecated
+  default AutoTune getAutoTune() {
+    return autoTune();
+  }
 
   /**
    * Return the associated DataSource for this Database instance.
    */
-  DataSource getDataSource();
+  DataSource dataSource();
+
+  /**
+   * Deprecated migrate to dataSource().
+   */
+  @Deprecated
+  default DataSource getDataSource() {
+    return dataSource();
+  }
 
   /**
    * Return the associated read only DataSource for this Database instance (can be null).
    */
-  DataSource getReadOnlyDataSource();
+  DataSource readOnlyDataSource();
+
+  /**
+   * Deprecated migrate to readOnlyDataSource().
+   */
+  @Deprecated
+  default DataSource getReadOnlyDataSource() {
+    return readOnlyDataSource();
+  }
 
   /**
    * Return the name. This is used with {@link DB#byName(String)} to get a
    * Database that was registered with the DB singleton.
    */
-  String getName();
+  String name();
+
+  /**
+   * Deprecated migrate to name().
+   */
+  @Deprecated
+  default String getName() {
+    return name();
+  }
 
   /**
    * Return the ExpressionFactory for this database.
    */
-  ExpressionFactory getExpressionFactory();
+  ExpressionFactory expressionFactory();
+
+  /**
+   * Deprecated migrate to expressionFactory().
+   */
+  @Deprecated
+  default ExpressionFactory getExpressionFactory() {
+    return expressionFactory();
+  }
 
   /**
    * Return the MetaInfoManager which is used to get meta data from the Database
    * such as query execution statistics.
    */
-  MetaInfoManager getMetaInfoManager();
+  MetaInfoManager metaInfo();
+
+  /**
+   * Deprecated migrate to metaInfo().
+   */
+  @Deprecated
+  default MetaInfoManager getMetaInfoManager() {
+    return metaInfo();
+  }
 
   /**
    * Return the platform used for this database instance.
@@ -166,12 +214,28 @@ public interface Database {
    *
    * @return platform for this database instance
    */
-  Platform getPlatform();
+  Platform platform();
+
+  /**
+   * Deprecated migrate to platform().
+   */
+  @Deprecated
+  default Platform getPlatform() {
+    return platform();
+  }
 
   /**
    * Return the extended API intended for use by plugins.
    */
-  SpiServer getPluginApi();
+  SpiServer pluginApi();
+
+  /**
+   * Deprecated migrate to pluginApi().
+   */
+  @Deprecated
+  default SpiServer getPluginApi() {
+    return pluginApi();
+  }
 
   /**
    * Return the BeanState for a given entity bean.
@@ -179,12 +243,28 @@ public interface Database {
    * This will return null if the bean is not an enhanced entity bean.
    * </p>
    */
-  BeanState getBeanState(Object bean);
+  BeanState beanState(Object bean);
+
+  /**
+   * Deprecated migrate to beanState().
+   */
+  @Deprecated
+  default BeanState getBeanState(Object bean) {
+    return beanState(bean);
+  }
 
   /**
    * Return the value of the Id property for a given bean.
    */
-  Object getBeanId(Object bean);
+  Object beanId(Object bean);
+
+  /**
+   * Deprecated migrate to beanId().
+   */
+  @Deprecated
+  default Object getBeanId(Object bean) {
+    return beanId(bean);
+  }
 
   /**
    * Set the Id value onto the bean converting the type of the id value if necessary.
@@ -196,7 +276,15 @@ public interface Database {
    * @param bean The entity bean to set the id value on.
    * @param id   The id value to set.
    */
-  Object setBeanId(Object bean, Object id);
+  Object beanId(Object bean, Object id);
+
+  /**
+   * Deprecated migrate to beanId().
+   */
+  @Deprecated
+  default Object setBeanId(Object bean, Object id) {
+    return beanId(bean, id);
+  }
 
   /**
    * Return a map of the differences between two objects of the same type.
@@ -862,7 +950,15 @@ public interface Database {
    * @param id       the id value
    */
   @Nonnull
-  <T> T getReference(Class<T> beanType, Object id);
+  <T> T reference(Class<T> beanType, Object id);
+
+  /**
+   * Deprecated migrate to reference().
+   */
+  @Deprecated
+  default <T> T getReference(Class<T> beanType, Object id) {
+    return reference(beanType, id);
+  }
 
   /**
    * Return the extended API for Database.
@@ -1431,13 +1527,29 @@ public interface Database {
   /**
    * Return the manager of the server cache ("L2" cache).
    */
-  ServerCacheManager getServerCacheManager();
+  ServerCacheManager cacheManager();
+
+  /**
+   * Deprecated migrate to cacheManager().
+   */
+  @Deprecated
+  default ServerCacheManager getServerCacheManager() {
+    return cacheManager();
+  }
 
   /**
    * Return the BackgroundExecutor service for asynchronous processing of
    * queries.
    */
-  BackgroundExecutor getBackgroundExecutor();
+  BackgroundExecutor backgroundExecutor();
+
+  /**
+   * Deprecated migrate to backgroundExecutor().
+   */
+  @Deprecated
+  default BackgroundExecutor getBackgroundExecutor() {
+    return backgroundExecutor();
+  }
 
   /**
    * Return the JsonContext for reading/writing JSON.

ebean-api/src/main/java/io/ebean/DatabaseFactory.java

@@ -16,18 +16,15 @@ import java.util.concurrent.locks.ReentrantLock;
  * <p>
  * This uses either DatabaseConfig or properties in the application.properties file to
  * configure and create a Database instance.
- * </p>
  * <p>
  * The Database instance can either be registered with the DB singleton or
  * not. The DB singleton effectively holds a map of Database by a name.
  * If the Database is registered with the DB singleton you can retrieve it
  * later via {@link DB#byName(String)}.
- * </p>
  * <p>
  * One Database can be nominated as the 'default/primary' Database. Many
  * methods on the DB singleton such as {@link DB#find(Class)} are just a
  * convenient way of using the 'default/primary' Database.
- * </p>
  */
 public class DatabaseFactory {
 
@@ -48,7 +45,7 @@ public class DatabaseFactory {
   public static void initialiseContainer(ContainerConfig containerConfig) {
     lock.lock();
     try {
-      getContainer(containerConfig);
+      container(containerConfig);
     } finally {
       lock.unlock();
     }
@@ -60,7 +57,7 @@ public class DatabaseFactory {
   public static Database create(String name) {
     lock.lock();
     try {
-      return getContainer(null).createServer(name);
+      return container(null).createServer(name);
     } finally {
       lock.unlock();
     }
@@ -68,6 +65,16 @@ public class DatabaseFactory {
 
   /**
    * Create using the DatabaseConfig object to configure the database.
+   *
+   * <pre>{@code
+   *
+   *   DatabaseConfig config = new DatabaseConfig();
+   *   config.setName("db");
+   *   config.loadProperties();
+   *
+   *   Database database = DatabaseFactory.create(config);
+   *
+   * }</pre>
    */
   public static Database create(DatabaseConfig config) {
     lock.lock();
@@ -115,7 +122,6 @@ public class DatabaseFactory {
    * Shutdown gracefully all Database instances cleaning up any resources as required.
    * <p>
    * This is typically invoked via JVM shutdown hook and not explicitly called.
-   * </p>
    */
   public static void shutdown() {
     lock.lock();
@@ -127,15 +133,15 @@ public class DatabaseFactory {
   }
 
   private static Database createInternal(DatabaseConfig config) {
-    return getContainer(config.getContainerConfig()).createServer(config);
+    return container(config.getContainerConfig()).createServer(config);
   }
 
   /**
-   * Get the EbeanContainer initialising it if necessary.
+   * Return the SpiContainer initialising it if necessary.
    *
    * @param containerConfig the configuration controlling clustering communication
    */
-  private static SpiContainer getContainer(ContainerConfig containerConfig) {
+  private static SpiContainer container(ContainerConfig containerConfig) {
     // thread safe in that all calling methods hold lock
     if (container != null) {
       return container;

ebean-api/src/main/java/io/ebean/DbContext.java

@@ -115,7 +115,7 @@ final class DbContext {
    * Register a server so we can get it by its name.
    */
   void register(Database server, boolean isDefault) {
-    registerWithName(server.getName(), server, isDefault);
+    registerWithName(server.name(), server, isDefault);
   }
 
   private void registerWithName(String name, Database server, boolean isDefault) {

ebean-api/src/main/java/io/ebean/Ebean.java

@@ -103,7 +103,7 @@ public final class Ebean {
    * </p>
    */
   public static ExpressionFactory getExpressionFactory() {
-    return getDefault().getExpressionFactory();
+    return getDefault().expressionFactory();
   }
 
   /**
@@ -642,7 +642,7 @@ public final class Ebean {
    * @param id       the id value
    */
   public static <T> T getReference(Class<T> beanType, Object id) {
-    return getDefault().getReference(beanType, id);
+    return getDefault().reference(beanType, id);
   }
 
   /**
@@ -1201,14 +1201,14 @@ public final class Ebean {
    * </p>
    */
   public static BeanState getBeanState(Object bean) {
-    return getDefault().getBeanState(bean);
+    return getDefault().beanState(bean);
   }
 
   /**
    * Return the manager of the server cache ("L2" cache).
    */
   public static ServerCacheManager getServerCacheManager() {
-    return getDefault().getServerCacheManager();
+    return getDefault().cacheManager();
   }
 
   /**
@@ -1216,7 +1216,7 @@ public final class Ebean {
    * queries.
    */
   public static BackgroundExecutor getBackgroundExecutor() {
-    return getDefault().getBackgroundExecutor();
+    return getDefault().backgroundExecutor();
   }
 
   /**

ebean-api/src/main/java/io/ebean/Expr.java

@@ -16,7 +16,7 @@ import java.util.Map;
  * This provides a convenient way to create expressions for the default
  * database.
  * <p>
- * See also {@link DB#getExpressionFactory()}
+ * See also {@link DB#expressionFactory()}
  * </p>
  * <p>
  * Creates standard common expressions for using in a Query Where or Having
@@ -34,14 +34,14 @@ public class Expr {
    * Equal To - property equal to the given value.
    */
   public static Expression eq(String propertyName, Object value) {
-    return DB.getExpressionFactory().eq(propertyName, value);
+    return DB.expressionFactory().eq(propertyName, value);
   }
 
   /**
    * Not Equal To - property not equal to the given value.
    */
   public static Expression ne(String propertyName, Object value) {
-    return DB.getExpressionFactory().ne(propertyName, value);
+    return DB.expressionFactory().ne(propertyName, value);
   }
 
   /**
@@ -49,7 +49,7 @@ public class Expr {
    * using a lower() function to make it case insensitive).
    */
   public static Expression ieq(String propertyName, String value) {
-    return DB.getExpressionFactory().ieq(propertyName, value);
+    return DB.expressionFactory().ieq(propertyName, value);
   }
 
   /**
@@ -59,28 +59,28 @@ public class Expr {
    * </p>
    */
   public static Expression inRange(String propertyName, Object value1, Object value2) {
-    return DB.getExpressionFactory().inRange(propertyName, value1, value2);
+    return DB.expressionFactory().inRange(propertyName, value1, value2);
   }
 
   /**
    * Between - property between the two given values.
    */
   public static Expression between(String propertyName, Object value1, Object value2) {
-    return DB.getExpressionFactory().between(propertyName, value1, value2);
+    return DB.expressionFactory().between(propertyName, value1, value2);
   }
 
   /**
    * Between - value between two given properties.
    */
   public static Expression between(String lowProperty, String highProperty, Object value) {
-    return DB.getExpressionFactory().betweenProperties(lowProperty, highProperty, value);
+    return DB.expressionFactory().betweenProperties(lowProperty, highProperty, value);
   }
 
   /**
    * Greater Than - property greater than the given value.
    */
   public static Expression gt(String propertyName, Object value) {
-    return DB.getExpressionFactory().gt(propertyName, value);
+    return DB.expressionFactory().gt(propertyName, value);
   }
 
   /**
@@ -88,42 +88,42 @@ public class Expr {
    * value.
    */
   public static Expression ge(String propertyName, Object value) {
-    return DB.getExpressionFactory().ge(propertyName, value);
+    return DB.expressionFactory().ge(propertyName, value);
   }
 
   /**
    * Less Than - property less than the given value.
    */
   public static Expression lt(String propertyName, Object value) {
-    return DB.getExpressionFactory().lt(propertyName, value);
+    return DB.expressionFactory().lt(propertyName, value);
   }
 
   /**
    * Less Than or Equal to - property less than or equal to the given value.
    */
   public static Expression le(String propertyName, Object value) {
-    return DB.getExpressionFactory().le(propertyName, value);
+    return DB.expressionFactory().le(propertyName, value);
   }
 
   /**
    * Is Null - property is null.
    */
   public static Expression isNull(String propertyName) {
-    return DB.getExpressionFactory().isNull(propertyName);
+    return DB.expressionFactory().isNull(propertyName);
   }
 
   /**
    * Is Not Null - property is not null.
    */
   public static Expression isNotNull(String propertyName) {
-    return DB.getExpressionFactory().isNotNull(propertyName);
+    return DB.expressionFactory().isNotNull(propertyName);
   }
 
   /**
    * Case insensitive {@link #exampleLike(Object)}
    */
   public static ExampleExpression iexampleLike(Object example) {
-    return DB.getExpressionFactory().iexampleLike(example);
+    return DB.expressionFactory().iexampleLike(example);
   }
 
   /**
@@ -131,14 +131,14 @@ public class Expr {
    * LikeType.RAW (you need to add you own wildcards % and _).
    */
   public static ExampleExpression exampleLike(Object example) {
-    return DB.getExpressionFactory().exampleLike(example);
+    return DB.expressionFactory().exampleLike(example);
   }
 
   /**
    * Create the query by Example expression specifying more options.
    */
   public static ExampleExpression exampleLike(Object example, boolean caseInsensitive, LikeType likeType) {
-    return DB.getExpressionFactory().exampleLike(example, caseInsensitive, likeType);
+    return DB.expressionFactory().exampleLike(example, caseInsensitive, likeType);
   }
 
   /**
@@ -146,7 +146,7 @@ public class Expr {
    * characters % (percentage) and _ (underscore).
    */
   public static Expression like(String propertyName, String value) {
-    return DB.getExpressionFactory().like(propertyName, value);
+    return DB.expressionFactory().like(propertyName, value);
   }
 
   /**
@@ -155,14 +155,14 @@ public class Expr {
    * a lower() function to make the expression case insensitive.
    */
   public static Expression ilike(String propertyName, String value) {
-    return DB.getExpressionFactory().ilike(propertyName, value);
+    return DB.expressionFactory().ilike(propertyName, value);
   }
 
   /**
    * Starts With - property like value%.
    */
   public static Expression startsWith(String propertyName, String value) {
-    return DB.getExpressionFactory().startsWith(propertyName, value);
+    return DB.expressionFactory().startsWith(propertyName, value);
   }
 
   /**
@@ -170,14 +170,14 @@ public class Expr {
    * lower() function to make the expression case insensitive.
    */
   public static Expression istartsWith(String propertyName, String value) {
-    return DB.getExpressionFactory().istartsWith(propertyName, value);
+    return DB.expressionFactory().istartsWith(propertyName, value);
   }
 
   /**
    * Ends With - property like %value.
    */
   public static Expression endsWith(String propertyName, String value) {
-    return DB.getExpressionFactory().endsWith(propertyName, value);
+    return DB.expressionFactory().endsWith(propertyName, value);
   }
 
   /**
@@ -185,14 +185,14 @@ public class Expr {
    * function to make the expression case insensitive.
    */
   public static Expression iendsWith(String propertyName, String value) {
-    return DB.getExpressionFactory().iendsWith(propertyName, value);
+    return DB.expressionFactory().iendsWith(propertyName, value);
   }
 
   /**
    * Contains - property like %value%.
    */
   public static Expression contains(String propertyName, String value) {
-    return DB.getExpressionFactory().contains(propertyName, value);
+    return DB.expressionFactory().contains(propertyName, value);
   }
 
   /**
@@ -200,42 +200,42 @@ public class Expr {
    * function to make the expression case insensitive.
    */
   public static Expression icontains(String propertyName, String value) {
-    return DB.getExpressionFactory().icontains(propertyName, value);
+    return DB.expressionFactory().icontains(propertyName, value);
   }
 
   /**
    * For collection properties that are empty (have not existing elements).
    */
   public static Expression isEmpty(String propertyName) {
-    return DB.getExpressionFactory().isEmpty(propertyName);
+    return DB.expressionFactory().isEmpty(propertyName);
   }
 
   /**
    * For collection properties that are not empty (have existing elements).
    */
   public static Expression isNotEmpty(String propertyName) {
-    return DB.getExpressionFactory().isNotEmpty(propertyName);
+    return DB.expressionFactory().isNotEmpty(propertyName);
   }
 
   /**
    * In - property has a value in the array of values.
    */
   public static Expression in(String propertyName, Object[] values) {
-    return DB.getExpressionFactory().in(propertyName, values);
+    return DB.expressionFactory().in(propertyName, values);
   }
 
   /**
    * In - using a subQuery.
    */
   public static Expression in(String propertyName, Query<?> subQuery) {
-    return DB.getExpressionFactory().in(propertyName, subQuery);
+    return DB.expressionFactory().in(propertyName, subQuery);
   }
 
   /**
    * In - property has a value in the collection of values.
    */
   public static Expression in(String propertyName, Collection<?> values) {
-    return DB.getExpressionFactory().in(propertyName, values);
+    return DB.expressionFactory().in(propertyName, values);
   }
 
   /**
@@ -272,14 +272,14 @@ public class Expr {
    * }</pre>
    */
   public static Expression inOrEmpty(String propertyName, Collection<?> values) {
-    return DB.getExpressionFactory().inOrEmpty(propertyName, values);
+    return DB.expressionFactory().inOrEmpty(propertyName, values);
   }
 
   /**
    * Id Equal to - ID property is equal to the value.
    */
   public static Expression idEq(Object value) {
-    return DB.getExpressionFactory().idEq(value);
+    return DB.expressionFactory().idEq(value);
   }
 
   /**
@@ -292,7 +292,7 @@ public class Expr {
    * @param propertyMap a map keyed by property names.
    */
   public static Expression allEq(Map<String, Object> propertyMap) {
-    return DB.getExpressionFactory().allEq(propertyMap);
+    return DB.expressionFactory().allEq(propertyMap);
   }
 
   /**
@@ -303,7 +303,7 @@ public class Expr {
    * </p>
    */
   public static Expression raw(String raw, Object value) {
-    return DB.getExpressionFactory().raw(raw, value);
+    return DB.expressionFactory().raw(raw, value);
   }
 
   /**
@@ -314,53 +314,48 @@ public class Expr {
    * </p>
    */
   public static Expression raw(String raw, Object[] values) {
-    return DB.getExpressionFactory().raw(raw, values);
+    return DB.expressionFactory().raw(raw, values);
   }
 
   /**
    * Add raw expression with no parameters.
    */
   public static Expression raw(String raw) {
-    return DB.getExpressionFactory().raw(raw);
+    return DB.expressionFactory().raw(raw);
   }
 
   /**
    * And - join two expressions with a logical and.
    */
   public static Expression and(Expression expOne, Expression expTwo) {
-
-    return DB.getExpressionFactory().and(expOne, expTwo);
+    return DB.expressionFactory().and(expOne, expTwo);
   }
 
   /**
    * Or - join two expressions with a logical or.
    */
   public static Expression or(Expression expOne, Expression expTwo) {
-
-    return DB.getExpressionFactory().or(expOne, expTwo);
+    return DB.expressionFactory().or(expOne, expTwo);
   }
 
   /**
    * Negate the expression (prefix it with NOT).
    */
   public static Expression not(Expression exp) {
-
-    return DB.getExpressionFactory().not(exp);
+    return DB.expressionFactory().not(exp);
   }
 
   /**
    * Return a list of expressions that will be joined by AND's.
    */
   public static <T> Junction<T> conjunction(Query<T> query) {
-
-    return DB.getExpressionFactory().conjunction(query);
+    return DB.expressionFactory().conjunction(query);
   }
 
   /**
    * Return a list of expressions that will be joined by OR's.
    */
   public static <T> Junction<T> disjunction(Query<T> query) {
-
-    return DB.getExpressionFactory().disjunction(query);
+    return DB.expressionFactory().disjunction(query);
   }
 }

ebean-api/src/main/java/io/ebean/Finder.java

@@ -137,11 +137,11 @@ public class Finder<I, T> {
   /**
    * Creates an entity reference for this ID.
    * <p>
-   * Equivalent to {@link Database#getReference(Class, Object)}
+   * Equivalent to {@link Database#reference(Class, Object)}
    */
   @Nonnull
   public T ref(I id) {
-    return db().getReference(type, id);
+    return db().reference(type, id);
   }
 
   /**

ebean-api/src/main/java/io/ebean/ProfileLocation.java

@@ -45,14 +45,6 @@ public interface ProfileLocation {
    */
   String label();
 
-  /**
-   * Return a hash of the location that intentionally excludes the line number.
-   * <p>
-   * The hash is expected to be stable regardless of line number in the source file
-   * so that is identifies the class and method location over a long time.
-   */
-  long hash();
-
   /**
    * Return the full location.
    */

ebean-api/src/main/java/io/ebean/bean/BeanCollectionLoader.java

@@ -11,7 +11,7 @@ public interface BeanCollectionLoader {
   /**
    * Return the name of the associated Database.
    */
-  String getName();
+  String name();
 
   /**
    * Invoke the lazy loading for this bean collection.

ebean-api/src/main/java/io/ebean/bean/EntityBeanIntercept.java

@@ -395,6 +395,15 @@ public final class EntityBeanIntercept implements Serializable {
     this.owner._ebean_setEmbeddedLoaded();
     this.lazyLoadProperty = -1;
     this.origValues = null;
+    // after save, transfer the mutable next values back to mutable info
+    if (mutableNext != null) {
+      for (int i = 0; i < mutableNext.length; i++) {
+        MutableValueNext next = mutableNext[i];
+        if (next != null) {
+          mutableInfo(i, next.info());
+        }
+      }
+    }
     this.mutableNext = null;
     for (int i = 0; i < flags.length; i++) {
       flags[i] &= ~(FLAG_CHANGED_PROP | FLAG_ORIG_VALUE_SET);
@@ -834,7 +843,7 @@ public final class EntityBeanIntercept implements Serializable {
         }
         // For stand alone reference bean or after deserialisation lazy load
         // using the ebeanServer. Synchronise only on the bean.
-        loadBeanInternal(loadProperty, database.getPluginApi().beanLoader());
+        loadBeanInternal(loadProperty, database.pluginApi().beanLoader());
         return;
       }
     } finally {
@@ -1224,8 +1233,7 @@ public final class EntityBeanIntercept implements Serializable {
       return null;
     }
     final MutableValueNext next = mutableNext[propertyIndex];
-    mutableInfo(propertyIndex, next.info());
-    return next.content();
+    return next != null ? next.content() : null;
   }
 
 }

ebean-api/src/main/java/io/ebean/bean/SingleBeanLoader.java

@@ -20,7 +20,7 @@ public abstract class SingleBeanLoader implements BeanLoader {
 
   @Override
   public String getName() {
-    return database.getName();
+    return database.name();
   }
 
   @Override
@@ -39,7 +39,7 @@ public abstract class SingleBeanLoader implements BeanLoader {
 
     @Override
     public void loadBean(EntityBeanIntercept ebi) {
-      database.getPluginApi().loadBeanL2(ebi);
+      database.pluginApi().loadBeanL2(ebi);
     }
   }
 
@@ -53,7 +53,7 @@ public abstract class SingleBeanLoader implements BeanLoader {
 
     @Override
     public void loadBean(EntityBeanIntercept ebi) {
-      database.getPluginApi().loadBeanRef(ebi);
+      database.pluginApi().loadBeanRef(ebi);
     }
   }
 
@@ -67,7 +67,7 @@ public abstract class SingleBeanLoader implements BeanLoader {
 
     @Override
     public void loadBean(EntityBeanIntercept ebi) {
-      database.getPluginApi().loadBean(ebi);
+      database.pluginApi().loadBean(ebi);
     }
   }
 }

ebean-api/src/main/java/io/ebean/cache/ServerCache.java

@@ -10,17 +10,17 @@ import java.util.Set;
  * Represents part of the "L2" server side cache.
  * <p>
  * This is used to cache beans or query results (bean collections).
- * </p>
  * <p>
  * There are 2 ServerCache's for each bean type. One is used as the 'bean cache'
  * which holds beans of a given type. The other is the 'query cache' holding
  * query results for a given type.
- * </p>
  */
 public interface ServerCache {
 
+  /**
+   * Get values for many keys.
+   */
   default Map<Object, Object> getAll(Set<Object> keys) {
-
     Map<Object, Object> map = new LinkedHashMap<>();
     for (Object key : keys) {
       Object value = get(key);
@@ -73,6 +73,14 @@ public interface ServerCache {
   /**
    * Return the hit ratio the cache is currently getting.
    */
+  default int hitRatio() {
+    return getHitRatio();
+  }
+
+  /**
+   * Deprecated migrate to hitRatio().
+   */
+  @Deprecated
   int getHitRatio();
 
   /**
@@ -80,6 +88,14 @@ public interface ServerCache {
    *
    * @param reset if true the statistics are reset.
    */
+  default ServerCacheStatistics statistics(boolean reset) {
+    return getStatistics(reset);
+  }
+
+  /**
+   * Deprecated migrate to statistics().
+   */
+  @Deprecated
   ServerCacheStatistics getStatistics(boolean reset);
 
   /**

ebean-api/src/main/java/io/ebean/cache/ServerCacheManager.java

@@ -21,7 +21,15 @@ public interface ServerCacheManager {
    * rather than background processing.
    * </p>
    */
-  boolean isLocalL2Caching();
+  boolean localL2Caching();
+
+  /**
+   * Deprecated migrate to localL2Caching().
+   */
+  @Deprecated
+  default boolean isLocalL2Caching() {
+    return localL2Caching();
+  }
 
   /**
    * Return all the cache regions.
@@ -36,37 +44,78 @@ public interface ServerCacheManager {
    *
    * @param regions A region name or comma delimited list of region names.
    */
-  void setEnabledRegions(String regions);
+  void enabledRegions(String regions);
+
+  /**
+   * Deprecated migrate to enabledRegions().
+   */
+  @Deprecated
+  default void setEnabledRegions(String regions) {
+    enabledRegions(regions);
+  }
 
   /**
    * Enable or disable all the cache regions.
    */
-  void setAllRegionsEnabled(boolean enabled);
+  void allRegionsEnabled(boolean enabled);
 
   /**
-   * Return the cache region by name. Typically to enable or disable the region.
+   * Deprecated migrate to allRegionsEnabled().
    */
-  ServerCacheRegion getRegion(String name);
+  @Deprecated
+  default void setAllRegionsEnabled(boolean enabled) {
+    allRegionsEnabled(enabled);
+  }
+
+  /**
+   * Return the cache region by name. Typically, to enable or disable the region.
+   */
+  ServerCacheRegion region(String name);
+
+  @Deprecated
+  default ServerCacheRegion getRegion(String name) {
+    return region(name);
+  }
 
   /**
    * Return the cache for mapping natural keys to id values.
    */
-  ServerCache getNaturalKeyCache(Class<?> beanType);
+  ServerCache naturalKeyCache(Class<?> beanType);
+
+  @Deprecated
+  default ServerCache getNaturalKeyCache(Class<?> beanType) {
+    return naturalKeyCache(beanType);
+  }
 
   /**
    * Return the cache for beans of a particular type.
    */
-  ServerCache getBeanCache(Class<?> beanType);
+  ServerCache beanCache(Class<?> beanType);
+
+  @Deprecated
+  default ServerCache getBeanCache(Class<?> beanType) {
+    return beanCache(beanType);
+  }
 
   /**
    * Return the cache for associated many properties of a bean type.
    */
-  ServerCache getCollectionIdsCache(Class<?> beanType, String propertyName);
+  ServerCache collectionIdsCache(Class<?> beanType, String propertyName);
+
+  @Deprecated
+  default ServerCache getCollectionIdsCache(Class<?> beanType, String propertyName) {
+    return collectionIdsCache(beanType, propertyName);
+  }
 
   /**
    * Return the cache for query results of a particular type of bean.
    */
-  ServerCache getQueryCache(Class<?> beanType);
+  ServerCache queryCache(Class<?> beanType);
+
+  @Deprecated
+  default ServerCache getQueryCache(Class<?> beanType) {
+    return queryCache(beanType);
+  }
 
   /**
    * This clears both the bean and query cache for a given type.

ebean-api/src/main/java/io/ebean/common/AbstractBeanCollection.java

@@ -63,7 +63,7 @@ abstract class AbstractBeanCollection<E> implements BeanCollection<E> {
    */
   AbstractBeanCollection(BeanCollectionLoader loader, EntityBean ownerBean, String propertyName) {
     this.loader = loader;
-    this.ebeanServerName = loader.getName();
+    this.ebeanServerName = loader.name();
     this.ownerBean = ownerBean;
     this.propertyName = propertyName;
     this.readOnly = ownerBean != null && ownerBean._ebean_getIntercept().isReadOnly();
@@ -111,7 +111,7 @@ abstract class AbstractBeanCollection<E> implements BeanCollection<E> {
   public void setLoader(BeanCollectionLoader loader) {
     this.registeredWithLoadContext = true;
     this.loader = loader;
-    this.ebeanServerName = loader.getName();
+    this.ebeanServerName = loader.name();
   }
 
   @Override

ebean-api/src/main/java/io/ebean/config/DatabaseConfig.java

@@ -319,6 +319,8 @@ public class DatabaseConfig {
    */
   private ExternalTransactionManager externalTransactionManager;
 
+  private boolean skipDataSourceCheck;
+
   /**
    * The data source (if programmatically provided).
    */
@@ -1651,6 +1653,20 @@ public class DatabaseConfig {
     this.autoTuneConfig = autoTuneConfig;
   }
 
+  /**
+   * Return true if the startup DataSource check should be skipped.
+   */
+  public boolean skipDataSourceCheck() {
+    return skipDataSourceCheck;
+  }
+
+  /**
+   * Set to true to skip the startup DataSource check.
+   */
+  public void setSkipDataSourceCheck(boolean skipDataSourceCheck) {
+    this.skipDataSourceCheck = skipDataSourceCheck;
+  }
+
   /**
    * Return the DataSource.
    */
@@ -2932,6 +2948,7 @@ public class DatabaseConfig {
     jsonDate = p.getEnum(JsonConfig.Date.class, "jsonDate", jsonDate);
     jsonMutationDetection = p.getEnum(MutationDetection.class, "jsonMutationDetection", jsonMutationDetection);
 
+    skipDataSourceCheck = p.getBoolean("skipDataSourceCheck", skipDataSourceCheck);
     runMigration = p.getBoolean("migration.run", runMigration);
     ddlGenerate = p.getBoolean("ddl.generate", ddlGenerate);
     ddlRun = p.getBoolean("ddl.run", ddlRun);

ebean-api/src/main/java/io/ebean/event/BeanDeleteIdRequest.java

@@ -1,5 +1,6 @@
 package io.ebean.event;
 
+import io.ebean.Database;
 import io.ebean.EbeanServer;
 import io.ebean.Transaction;
 
@@ -9,18 +10,62 @@ import io.ebean.Transaction;
 public interface BeanDeleteIdRequest {
 
   /**
-   * Return the server processing the request.
+   * Deprecated migrate to database().
    */
+  @Deprecated
   EbeanServer getEbeanServer();
 
+  /**
+   * Deprecated migrate to database().
+   */
+  @Deprecated
+  default Database getDatabase() {
+    return getEbeanServer();
+  }
+
+  /**
+   * Return the DB processing the request.
+   */
+  default Database database() {
+    return getEbeanServer();
+  }
+
   /**
    * Return the Transaction associated with this request.
    */
-  Transaction getTransaction();
+  Transaction transaction();
+
+  /**
+   * Deprecated migrate to transaction().
+   */
+  @Deprecated
+  default Transaction getTransaction() {
+    return transaction();
+  }
+
+  /**
+   * Returns the bean type of the bean being deleted.
+   */
+  Class<?> beanType();
+
+  /**
+   * Deprecated migrate to beanType().
+   */
+  @Deprecated
+  default Class<?> getBeanType() {
+    return beanType();
+  }
 
   /**
    * Returns the Id value of the bean being deleted.
    */
-  Object getId();
+  Object id();
 
+  /**
+   * Deprecated migrate to id().
+   */
+  @Deprecated
+  default Object getId() {
+    return id();
+  }
 }

ebean-api/src/main/java/io/ebean/event/BeanPersistRequest.java

@@ -1,5 +1,6 @@
 package io.ebean.event;
 
+import io.ebean.Database;
 import io.ebean.EbeanServer;
 import io.ebean.Transaction;
 import io.ebean.ValuePair;
@@ -17,20 +18,44 @@ import java.util.Set;
 public interface BeanPersistRequest<T> {
 
   /**
-   * Return the server processing the request.
+   * Return the DB processing the request.
    */
+  default Database database() {
+    return getEbeanServer();
+  }
+
+  /**
+   * Deprecated migrate to database().
+   */
+  @Deprecated
   EbeanServer getEbeanServer();
 
   /**
    * Return the Transaction associated with this request.
    */
-  Transaction getTransaction();
+  Transaction transaction();
+
+  /**
+   * Deprecated migrate to transaction().
+   */
+  @Deprecated
+  default Transaction getTransaction() {
+    return transaction();
+  }
 
   /**
    * For an update or delete of a partially populated bean this is the set of
    * loaded properties and otherwise returns null.
    */
-  Set<String> getLoadedProperties();
+  Set<String> loadedProperties();
+
+  /**
+   * Deprecated migrate to loadedProperties().
+   */
+  @Deprecated
+  default Set<String> getLoadedProperties() {
+    return loadedProperties();
+  }
 
   /**
    * For an update this is the set of properties that where updated.
@@ -39,12 +64,28 @@ public interface BeanPersistRequest<T> {
    * should be preferred if it satisfies the requirement.
    * </p>
    */
-  Set<String> getUpdatedProperties();
+  Set<String> updatedProperties();
+
+  /**
+   * Deprecated migrate to updatedProperties().
+   */
+  @Deprecated
+  default Set<String> getUpdatedProperties() {
+    return updatedProperties();
+  }
 
   /**
    * Flags set for dirty properties (used by ElasticSearch integration).
    */
-  boolean[] getDirtyProperties();
+  boolean[] dirtyProperties();
+
+  /**
+   * Deprecated migrate to updatedProperties().
+   */
+  @Deprecated
+  default boolean[] getDirtyProperties() {
+    return dirtyProperties();
+  }
 
   /**
    * Return true for an update request if at least one of dirty properties is contained
@@ -66,11 +107,27 @@ public interface BeanPersistRequest<T> {
   /**
    * Returns the bean being inserted updated or deleted.
    */
-  T getBean();
+  T bean();
+
+  /**
+   * Deprecated migrate to bean().
+   */
+  @Deprecated
+  default T getBean() {
+    return bean();
+  }
 
   /**
    * Returns a map of the properties that have changed and their new and old values.
    */
-  Map<String, ValuePair> getUpdatedValues();
+  Map<String, ValuePair> updatedValues();
+
+  /**
+   * Deprecated migrate to updatedValues().
+   */
+  @Deprecated
+  default Map<String, ValuePair> getUpdatedValues() {
+    return updatedValues();
+  }
 
 }

ebean-api/src/main/java/io/ebean/event/BeanQueryRequest.java

@@ -1,5 +1,6 @@
 package io.ebean.event;
 
+import io.ebean.Database;
 import io.ebean.EbeanServer;
 import io.ebean.Query;
 import io.ebean.Transaction;
@@ -10,19 +11,43 @@ import io.ebean.Transaction;
 public interface BeanQueryRequest<T> {
 
   /**
-   * Return the server processing the request.
+   * Return the DB processing the request.
    */
+  default Database database() {
+    return getEbeanServer();
+  }
+
+  /**
+   * Deprecated migrate to database().
+   */
+  @Deprecated
   EbeanServer getEbeanServer();
 
   /**
    * Return the Transaction associated with this request.
    */
-  Transaction getTransaction();
+  Transaction transaction();
+
+  /**
+   * Deprecated migrate to transaction().
+   */
+  @Deprecated
+  default Transaction getTransaction() {
+    return transaction();
+  }
 
   /**
    * Returns the query.
    */
-  Query<T> getQuery();
+  Query<T> query();
+
+  /**
+   * Deprecated migrate to query().
+   */
+  @Deprecated
+  default Query<T> getQuery() {
+    return query();
+  }
 
   /**
    * Return true if an Id IN expression should have the bind parameters padded.

ebean-api/src/main/java/io/ebean/event/BulkTableEvent.java

@@ -8,7 +8,15 @@ public interface BulkTableEvent {
   /**
    * Return the name of the table that was involved.
    */
-  String getTableName();
+  String tableName();
+
+  /**
+   * Deprecated migrate to tableName().
+   */
+  @Deprecated
+  default String getTableName() {
+    return tableName();
+  }
 
   /**
    * Return true if rows were inserted.

ebean-api/src/main/java/io/ebean/event/ShutdownManager.java

@@ -14,10 +14,9 @@ import java.util.List;
 import java.util.concurrent.locks.ReentrantLock;
 
 /**
- * Manages the shutdown of the JVM Runtime.
+ * Manages the shutdown of Ebean.
  * <p>
  * Makes sure all the resources are shutdown properly and in order.
- * </p>
  */
 public final class ShutdownManager {
 
@@ -44,6 +43,9 @@ public final class ShutdownManager {
   private ShutdownManager() {
   }
 
+  /**
+   * Registers the container (potentially with cluster management).
+   */
   public static void registerContainer(SpiContainer ebeanContainer) {
     container = ebeanContainer;
   }
@@ -94,7 +96,7 @@ public final class ShutdownManager {
   /**
    * Register the shutdown hook with the Runtime.
    */
-  protected static void registerShutdownHook() {
+  private static void registerShutdownHook() {
     lock.lock();
     try {
       String value = System.getProperty("ebean.registerShutdownHook");
@@ -123,13 +125,10 @@ public final class ShutdownManager {
         // Already run shutdown...
         return;
       }
-
       if (logger.isDebugEnabled()) {
         logger.debug("Shutting down");
       }
-
       stopping = true;
-
       deregisterShutdownHook();
 
       String shutdownRunner = System.getProperty("ebean.shutdown.runnable");
@@ -147,7 +146,6 @@ public final class ShutdownManager {
         // shutdown cluster networking if active
         container.shutdown();
       }
-
       // shutdown any registered servers that have not
       // already been shutdown manually
       for (Database server : databases) {
@@ -158,7 +156,6 @@ public final class ShutdownManager {
           ex.printStackTrace();
         }
       }
-
       if ("true".equalsIgnoreCase(System.getProperty("ebean.datasource.deregisterAllDrivers", "false"))) {
         deregisterAllJdbcDrivers();
       }
@@ -168,15 +165,15 @@ public final class ShutdownManager {
   }
 
   private static void deregisterAllJdbcDrivers() {
-    // This manually deregisters all JDBC drivers
+    // This manually de-registers all JDBC drivers
     Enumeration<Driver> drivers = DriverManager.getDrivers();
     while (drivers.hasMoreElements()) {
       Driver driver = drivers.nextElement();
       try {
-        logger.info("Deregistering jdbc driver: " + driver);
+        logger.info("De-registering jdbc driver: " + driver);
         DriverManager.deregisterDriver(driver);
       } catch (SQLException e) {
-        logger.error("Error deregistering driver " + driver, e);
+        logger.error("Error de-registering driver " + driver, e);
       }
     }
   }
@@ -209,6 +206,9 @@ public final class ShutdownManager {
   }
 
   private static class ShutdownHook extends Thread {
+    private ShutdownHook() {
+      super("EbeanHook");
+    }
     @Override
     public void run() {
       ShutdownManager.shutdown();

ebean-api/src/main/java/io/ebean/meta/MetaQueryMetric.java

@@ -45,15 +45,8 @@ public interface MetaQueryMetric extends MetaTimedMetric {
   }
 
   /**
-   * Return the hash of the sql.
+   * Return the hash of the plan.
    */
-  long sqlHash();
+  String hash();
 
-  /**
-   * Migrate to sqlHash().
-   */
-  @Deprecated
-  default long getSqlHash() {
-    return sqlHash();
-  }
 }

ebean-api/src/main/java/io/ebean/meta/MetaQueryPlan.java

@@ -30,7 +30,7 @@ public interface MetaQueryPlan {
   /**
    * Return the hash of the plan.
    */
-  long sqlHash();
+  String hash();
 
   /**
    * Return a description of the bind values.

ebean-api/src/main/java/io/ebean/meta/MetaTimedMetric.java

@@ -6,14 +6,6 @@ package io.ebean.meta;
  */
 public interface MetaTimedMetric extends MetaMetric {
 
-  /**
-   * Return the metric location hash if defined.
-   * <p>
-   * This hash excludes line number with the intention of being stable over time
-   * as code changes move the source line (but the method is the same).
-   */
-  long locationHash();
-
   /**
    * Return the metric location if defined.
    */

ebean-api/src/main/java/io/ebean/meta/MetricData.java

@@ -6,7 +6,7 @@ package io.ebean.meta;
 public class MetricData {
 
   private String name;
-  private long sqlHash;
+  private String hash;
   private String loc;
   private String sql;
 
@@ -14,7 +14,6 @@ public class MetricData {
   private Long mean;
   private Long max;
   private Long total;
-  private long locHash;
 
   public MetricData(String name) {
     this.name = name;
@@ -31,20 +30,12 @@ public class MetricData {
     this.name = name;
   }
 
-  public long getSqlHash() {
-    return sqlHash;
+  public String getHash() {
+    return hash;
   }
 
-  public void setSqlHash(long sqlHash) {
-    this.sqlHash = sqlHash;
-  }
-
-  public void setLocHash(long locHash) {
-    this.locHash = locHash;
-  }
-
-  public long getLocHash() {
-    return locHash;
+  public void setHash(String hash) {
+    this.hash = hash;
   }
 
   public String getLoc() {

ebean-api/src/main/java/io/ebean/meta/QueryPlanInit.java

@@ -10,7 +10,7 @@ public class QueryPlanInit {
 
   private boolean all;
 
-  private Set<Long> hashes = new HashSet<>();
+  private Set<String> hashes = new HashSet<>();
 
   private long thresholdMicros;
 
@@ -47,21 +47,21 @@ public class QueryPlanInit {
   /**
    * Return true if the query plan should be initiated based on it's hash.
    */
-  public boolean includeHash(long sqlHash) {
-    return all || hashes.contains(sqlHash);
+  public boolean includeHash(String hash) {
+    return all || hashes.contains(hash);
   }
 
   /**
    * Return the specific hashes that we want to collect query plans on.
    */
-  public Set<Long> sqlHashes() {
+  public Set<String> hashes() {
     return hashes;
   }
 
   /**
    * Set the specific hashes that we want to collect query plans on.
    */
-  public void sqlHashes(Set<Long> hashes) {
+  public void hashes(Set<String> hashes) {
     this.hashes = hashes;
   }
 }

ebean-api/src/main/java/io/ebean/metric/TimedMetricStats.java

@@ -12,11 +12,6 @@ public interface TimedMetricStats extends MetaTimedMetric {
    */
   void setLocation(String location);
 
-  /**
-   * Additionally set the location hash.
-   */
-  void setLocationHash(long locationHash);
-
   /**
    * Override the name based on profile location.
    */

ebean-api/src/main/java/io/ebean/plugin/BeanType.java

@@ -121,8 +121,9 @@ public interface BeanType<T> {
   Object beanId(Object bean);
 
   /**
-   * Return the id value for the given bean.
+   * Deprecated migrate to beanId()
    */
+  @Deprecated
   Object getBeanId(T bean);
 
   /**

ebean-api/src/main/java/io/ebean/plugin/SpiServer.java

@@ -16,32 +16,80 @@ public interface SpiServer extends Database {
   /**
    * Return the DatabaseConfig.
    */
-  DatabaseConfig getServerConfig();
+  DatabaseConfig config();
+
+  /**
+   * Migrate to config().
+   */
+  @Deprecated
+  default DatabaseConfig getServerConfig() {
+    return config();
+  }
 
   /**
    * Return the DatabasePlatform for this database.
    */
-  DatabasePlatform getDatabasePlatform();
+  DatabasePlatform databasePlatform();
+
+  /**
+   * Migrate to config().
+   */
+  @Deprecated
+  default DatabasePlatform getDatabasePlatform() {
+    return databasePlatform();
+  }
 
   /**
    * Return all the bean types registered on this server instance.
    */
-  List<? extends BeanType<?>> getBeanTypes();
+  List<? extends BeanType<?>> beanTypes();
+
+  /**
+   * Migrate to beanTypes().
+   */
+  @Deprecated
+  default List<? extends BeanType<?>> getBeanTypes() {
+    return beanTypes();
+  }
 
   /**
    * Return the bean type for a given entity bean class.
    */
-  <T> BeanType<T> getBeanType(Class<T> beanClass);
+  <T> BeanType<T> beanType(Class<T> beanClass);
+
+  /**
+   * Migrate to beanType().
+   */
+  @Deprecated
+  default <T> BeanType<T> getBeanType(Class<T> beanClass) {
+    return beanType(beanClass);
+  }
 
   /**
    * Return the bean types mapped to the given base table.
    */
-  List<? extends BeanType<?>> getBeanTypes(String baseTableName);
+  List<? extends BeanType<?>> beanTypes(String baseTableName);
+
+  /**
+   * Migrate to beanTypes().
+   */
+  @Deprecated
+  default List<? extends BeanType<?>> getBeanTypes(String baseTableName) {
+    return beanTypes(baseTableName);
+  }
 
   /**
    * Return the bean type for a given doc store queueId.
    */
-  BeanType<?> getBeanTypeForQueueId(String queueId);
+  BeanType<?> beanTypeForQueueId(String queueId);
+
+  /**
+   * Migrate to beanTypes().
+   */
+  @Deprecated
+  default BeanType<?> getBeanTypeForQueueId(String queueId) {
+    return beanTypeForQueueId(queueId);
+  }
 
   /**
    * Return a BeanLoader.

ebean-autotune/pom.xml

@@ -4,7 +4,7 @@
   <parent>
     <artifactId>ebean-parent</artifactId>
     <groupId>io.ebean</groupId>
-    <version>12.11.0</version>
+    <version>12.11.3</version>
   </parent>
 <!--  <parent>-->
 <!--    <groupId>org.avaje</groupId>-->
@@ -14,7 +14,7 @@
 
   <scm>
     <developerConnection>scm:git:git@github.com:ebean-orm/ebean.git</developerConnection>
-    <tag>ebean-parent-12.11.0</tag>
+    <tag>ebean-parent-12.11.3</tag>
   </scm>
 
   <name>ebean autotune</name>
@@ -26,7 +26,7 @@
     <dependency>
       <groupId>io.ebean</groupId>
       <artifactId>ebean-core</artifactId>
-      <version>12.11.0</version>
+      <version>12.11.3</version>
       <scope>provided</scope>
     </dependency>
 

ebean-autotune/src/main/java/io/ebeaninternal/server/autotune/service/BaseQueryTuner.java

@@ -146,7 +146,8 @@ public class BaseQueryTuner {
       case ID_LIST:
       case UPDATE:
       case DELETE:
-      case SUBQUERY:
+      case SQ_EXISTS:
+      case SQ_IN:
         return false;
       default:
         // not using autoTune when explicitly loading the l2 bean cache

ebean-autotune/src/main/java/io/ebeaninternal/server/autotune/service/DefaultAutoTuneService.java

@@ -59,7 +59,7 @@ public class DefaultAutoTuneService implements AutoTuneService {
     this.tuningFile = config.getQueryTuningFile();
     this.profilingFile = config.getProfilingFile();
     this.profilingUpdateFrequency = config.getProfilingUpdateFrequency();
-    this.serverName = server.getName();
+    this.serverName = server.name();
     this.profileManager = new ProfileManager(config, server);
     this.queryTuner = new BaseQueryTuner(config, server, profileManager);
     this.skipGarbageCollectionOnShutdown = config.isSkipGarbageCollectionOnShutdown();
@@ -77,7 +77,7 @@ public class DefaultAutoTuneService implements AutoTuneService {
       loadTuningFile();
       if (isRuntimeTuningUpdates()) {
         // periodically gather and update query tuning
-        server.getBackgroundExecutor().scheduleWithFixedDelay(new ProfilingUpdate(), profilingUpdateFrequency, profilingUpdateFrequency, TimeUnit.SECONDS);
+        server.backgroundExecutor().scheduleWithFixedDelay(new ProfilingUpdate(), profilingUpdateFrequency, profilingUpdateFrequency, TimeUnit.SECONDS);
       }
     }
   }

ebean-bom/pom.xml

@@ -4,7 +4,7 @@
   <parent>
     <artifactId>ebean-parent</artifactId>
     <groupId>io.ebean</groupId>
-    <version>12.11.0</version>
+    <version>12.11.3</version>
   </parent>
 
   <name>ebean bom</name>
@@ -12,16 +12,6 @@
   <artifactId>ebean-bom</artifactId>
   <packaging>pom</packaging>
 
-  <properties>
-    <ebean-ddl-runner.version>1.0</ebean-ddl-runner.version>
-    <ebean-migration-auto.version>1.1</ebean-migration-auto.version>
-    <ebean-migration.version>12.11.0</ebean-migration.version>
-    <ebean-test-docker.version>4.1</ebean-test-docker.version>
-    <ebean-datasource.version>7.0</ebean-datasource.version>
-    <ebean-agent.version>12.11.0</ebean-agent.version>
-    <ebean-maven-plugin.version>12.11.0</ebean-maven-plugin.version>
-  </properties>
-
   <dependencyManagement>
 
     <dependencies>
@@ -81,88 +71,88 @@
       <dependency>
         <groupId>io.ebean</groupId>
         <artifactId>ebean</artifactId>
-        <version>12.11.0</version>
+        <version>12.11.3</version>
       </dependency>
 
       <dependency>
         <groupId>io.ebean</groupId>
         <artifactId>ebean-api</artifactId>
-        <version>12.11.0</version>
+        <version>12.11.3</version>
       </dependency>
 
       <dependency>
         <groupId>io.ebean</groupId>
         <artifactId>ebean-core</artifactId>
-        <version>12.11.0</version>
+        <version>12.11.3</version>
       </dependency>
 
       <dependency>
         <groupId>io.ebean</groupId>
         <artifactId>ebean-core-type</artifactId>
-        <version>12.11.0</version>
+        <version>12.11.3</version>
       </dependency>
 
       <dependency>
         <groupId>io.ebean</groupId>
         <artifactId>ebean-ddl-generator</artifactId>
-        <version>12.11.0</version>
+        <version>12.11.3</version>
       </dependency>
 
       <dependency>
         <groupId>io.ebean</groupId>
         <artifactId>ebean-externalmapping-api</artifactId>
-        <version>12.11.0</version>
+        <version>12.11.3</version>
       </dependency>
 
       <dependency>
         <groupId>io.ebean</groupId>
         <artifactId>ebean-externalmapping-xml</artifactId>
-        <version>12.11.0</version>
+        <version>12.11.3</version>
       </dependency>
 
       <dependency>
         <groupId>io.ebean</groupId>
         <artifactId>ebean-autotune</artifactId>
-        <version>12.11.0</version>
+        <version>12.11.3</version>
       </dependency>
 
       <dependency>
         <groupId>io.ebean</groupId>
         <artifactId>ebean-querybean</artifactId>
-        <version>12.11.0</version>
+        <version>12.11.3</version>
       </dependency>
 
       <dependency>
         <groupId>io.ebean</groupId>
         <artifactId>querybean-generator</artifactId>
-        <version>12.11.0</version>
+        <version>12.11.3</version>
         <scope>provided</scope>
       </dependency>
 
       <dependency>
         <groupId>io.ebean</groupId>
         <artifactId>kotlin-querybean-generator</artifactId>
-        <version>12.11.0</version>
+        <version>12.11.3</version>
         <scope>provided</scope>
       </dependency>
 
       <dependency>
         <groupId>io.ebean</groupId>
         <artifactId>ebean-test</artifactId>
-        <version>12.11.0</version>
+        <version>12.11.3</version>
         <scope>test</scope>
       </dependency>
 
       <dependency>
         <groupId>io.ebean</groupId>
         <artifactId>ebean-postgis</artifactId>
-        <version>12.11.0</version>
+        <version>12.11.3</version>
       </dependency>
 
       <dependency>
         <groupId>io.ebean</groupId>
         <artifactId>ebean-redis</artifactId>
-        <version>12.11.0</version>
+        <version>12.11.3</version>
       </dependency>
 
     </dependencies>

ebean-core-type/pom.xml

@@ -4,7 +4,7 @@
   <parent>
     <artifactId>ebean-parent</artifactId>
     <groupId>io.ebean</groupId>
-    <version>12.11.0</version>
+    <version>12.11.3</version>
   </parent>
 
   <artifactId>ebean-core-type</artifactId>
@@ -16,7 +16,7 @@
     <dependency>
       <groupId>io.ebean</groupId>
       <artifactId>ebean-api</artifactId>
-      <version>12.11.0</version>
+      <version>12.11.3</version>
     </dependency>
 
     <dependency>

ebean-core/pom.xml

@@ -3,7 +3,7 @@
   <parent>
     <artifactId>ebean-parent</artifactId>
     <groupId>io.ebean</groupId>
-    <version>12.11.0</version>
+    <version>12.11.3</version>
   </parent>
 
   <artifactId>ebean-core</artifactId>
@@ -15,27 +15,18 @@
 
   <scm>
     <developerConnection>scm:git:git@github.com:ebean-orm/ebean.git</developerConnection>
-    <tag>ebean-parent-12.11.0</tag>
+    <tag>ebean-parent-12.11.3</tag>
   </scm>
 
   <profiles>
     <profile>
-      <!-- Note: to use this profile, you need to download manually the db2jcc4 driver.
-        After that, install it into your local maven repository:
-
-        mvn install:install-file \
-          -Dfile=db2jcc4.jar \
-          -DgroupId=com.ibm.jdbc \
-          -DartifactId=db2jcc4 \
-          -Dversion=4.23.42 \
-          -Dpackaging=jar
-      -->
       <id>db2</id>
       <dependencies>
+        <!-- https://mvnrepository.com/artifact/com.ibm.db2/jcc -->
         <dependency>
-          <groupId>com.ibm.jdbc</groupId>
-          <artifactId>db2jcc4</artifactId>
-          <version>4.23.42</version>
+          <groupId>com.ibm.db2</groupId>
+          <artifactId>jcc</artifactId>
+          <version>11.5.5.0</version>
           <scope>test</scope>
         </dependency>
       </dependencies>
@@ -72,7 +63,7 @@
     <dependency>
       <groupId>io.ebean</groupId>
       <artifactId>ebean-ddl-generator</artifactId>
-      <version>12.9.4-RC1</version>
+      <version>12.11.0</version>
       <scope>test</scope>
     </dependency>
 
@@ -87,19 +78,19 @@
     <dependency>
       <groupId>io.ebean</groupId>
       <artifactId>ebean-api</artifactId>
-      <version>12.11.0</version>
+      <version>12.11.3</version>
     </dependency>
 
     <dependency>
       <groupId>io.ebean</groupId>
       <artifactId>ebean-core-type</artifactId>
-      <version>12.11.0</version>
+      <version>12.11.3</version>
     </dependency>
 
     <dependency>
       <groupId>io.ebean</groupId>
       <artifactId>ebean-externalmapping-api</artifactId>
-      <version>12.11.0</version>
+      <version>12.11.3</version>
     </dependency>
 
     <dependency>
@@ -302,7 +293,7 @@
       <plugin>
         <groupId>io.ebean</groupId>
         <artifactId>ebean-maven-plugin</artifactId>
-        <version>12.10.0</version>
+        <version>${ebean-maven-plugin.version}</version>
         <executions>
           <execution>
             <id>test</id>

ebean-core/src/main/java/io/ebeaninternal/api/BeanCacheResult.java

@@ -6,7 +6,7 @@ import java.util.List;
 /**
  * The results of bean cache hit.
  */
-public class BeanCacheResult<T> {
+public final class BeanCacheResult<T> {
 
   private final List<Entry<T>> list = new ArrayList<>();
 
@@ -27,7 +27,7 @@ public class BeanCacheResult<T> {
   /**
    * Bean and cache key pair.
    */
-  static class Entry<T> {
+  static final class Entry<T> {
 
     private final T bean;
     private final Object key;

ebean-core/src/main/java/io/ebeaninternal/api/BinaryReadContext.java

@@ -7,7 +7,7 @@ import java.io.IOException;
 /**
  * Context used to read binary format messages.
  */
-public class BinaryReadContext {
+public final class BinaryReadContext {
 
   private final DataInputStream in;
 

ebean-core/src/main/java/io/ebeaninternal/api/BinaryWriteContext.java

@@ -6,10 +6,9 @@ import java.io.IOException;
 /**
  * Context used to write binary message (like RemoteTransactionEvent).
  */
-public class BinaryWriteContext {
+public final class BinaryWriteContext {
 
   private final DataOutputStream out;
-
   private long counter;
 
   public BinaryWriteContext(DataOutputStream out) {

ebean-core/src/main/java/io/ebeaninternal/api/BindParams.java

@@ -4,11 +4,7 @@ import io.ebeaninternal.server.persist.MultiValueWrapper;
 import io.ebeaninternal.server.querydefn.NaturalKeyBindParam;
 
 import java.io.Serializable;
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.LinkedHashMap;
-import java.util.List;
-import java.util.Map;
+import java.util.*;
 import java.util.Map.Entry;
 
 /**
@@ -17,35 +13,28 @@ import java.util.Map.Entry;
  * Supports ordered or named parameters.
  * </p>
  */
-public class BindParams implements Serializable {
+public final class BindParams implements Serializable {
 
   private static final long serialVersionUID = 4541081933302086285L;
 
   private final List<Param> positionedParameters = new ArrayList<>();
-
   private final Map<String, Param> namedParameters = new LinkedHashMap<>();
-
   /**
    * This is the sql. For named parameters this is the sql after the named
    * parameters have been replaced with question mark place holders and the
    * parameters have been ordered by addNamedParamInOrder().
    */
   private String preparedSql;
-
   /**
    * Bind hash and count used to detect when the bind values have changed such
    * that the generated SQL (with named parameters) needs to be recalculated.
    */
   private String bindHash;
-
   /**
    * Helper to add positioned parameters in order.
    */
   private int addPos;
 
-  public BindParams() {
-  }
-
   /**
    * Reset positioned parameters (usually due to bind parameter expansion).
    */
@@ -54,12 +43,11 @@ public class BindParams implements Serializable {
     positionedParameters.clear();
   }
 
-  public int queryBindHash() {
-    int hc = namedParameters.hashCode();
-    for (Param positionedParameter : positionedParameters) {
-      hc = hc * 92821 + positionedParameter.hashCode();
+  public void queryBindHash(BindValuesKey key) {
+    key.add(positionedParameters.size());
+    for (Param param : positionedParameters) {
+       param.queryBindHash(key);
     }
-    return hc;
   }
 
   /**
@@ -424,7 +412,14 @@ public class BindParams implements Serializable {
 
     @Override
     public boolean equals(Object o) {
-      return o != null && (o == this || (o instanceof Param) && hashCode() == o.hashCode());
+      if (this == o) return true;
+      if (o == null || getClass() != o.getClass()) return false;
+      Param param = (Param) o;
+      return isInParam == param.isInParam && isOutParam == param.isOutParam && type == param.type && Objects.equals(inValue, param.inValue);
+    }
+
+    void queryBindHash(BindValuesKey key) {
+      key.add(isInParam).add(isOutParam).add(type).add(inValue);
     }
 
     /**

ebean-core/src/main/java/io/ebeaninternal/api/BindValuesKey.java

@@ -0,0 +1,35 @@
+package io.ebeaninternal.api;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * BindValues used for L2 query cache key matching.
+ * <p>
+ * The equals/hashCode implementation must meet the requirement that the query bind values
+ * match for L2 query cache hit (given the query plan hash is already a match).
+ */
+public final class BindValuesKey {
+
+  private final List<Object> values = new ArrayList<>();
+
+  /**
+   * Add a bind value.
+   */
+  public BindValuesKey add(Object value) {
+    values.add(value);
+    return this;
+  }
+
+  @Override
+  public boolean equals(Object obj) {
+    return obj instanceof BindValuesKey && ((BindValuesKey) obj).values.equals(values);
+  }
+
+  @Override
+  public int hashCode() {
+    return values.hashCode();
+  }
+
+
+}

ebean-core/src/main/java/io/ebeaninternal/api/CacheIdLookupMany.java

@@ -11,10 +11,9 @@ import java.util.Set;
 /**
  * Used for bean cache lookup with where ids in expression.
  */
-public class CacheIdLookupMany<T> implements CacheIdLookup<T> {
+public final class CacheIdLookupMany<T> implements CacheIdLookup<T> {
 
   private final IdInExpression idInExpression;
-
   private int remaining;
 
   public CacheIdLookupMany(IdInExpression idInExpression) {

ebean-core/src/main/java/io/ebeaninternal/api/CacheIdLookupSingle.java

@@ -7,7 +7,7 @@ import java.util.List;
 /**
  * Used for bean cache lookup with a single id value.
  */
-public class CacheIdLookupSingle<T> implements CacheIdLookup<T> {
+public final class CacheIdLookupSingle<T> implements CacheIdLookup<T> {
 
   private final Object idValue;
   private boolean found;

ebean-core/src/main/java/io/ebeaninternal/api/DbOffline.java

@@ -1,16 +1,12 @@
 package io.ebeaninternal.api;
 
 import io.ebean.annotation.Platform;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
 
 /**
  * Helper to indicate that an EbeanServer should come up offline
  * typically for DDL generation purposes.
  */
-public class DbOffline {
-
-  private static final Logger logger = LoggerFactory.getLogger(DbOffline.class);
+public final class DbOffline {
 
   private static final String KEY = "ebean.dboffline";
 
@@ -73,7 +69,6 @@ public class DbOffline {
   public static void reset() {
     generateMigration = false;
     System.clearProperty(KEY);
-    logger.debug("reset");
   }
 
 }

ebean-core/src/main/java/io/ebeaninternal/api/ExtraMetrics.java

@@ -8,7 +8,7 @@ import io.ebean.metric.TimedMetric;
 /**
  * Extra metrics collected to measure internal behaviour.
  */
-public class ExtraMetrics {
+public final class ExtraMetrics {
 
   private final TimedMetric bindCapture;
   private final TimedMetric planCollect;

ebean-core/src/main/java/io/ebeaninternal/api/HashQuery.java

@@ -3,18 +3,17 @@ package io.ebeaninternal.api;
 /**
  * A hash key for a query including both the query plan and bind values.
  */
-public class HashQuery {
+public final class HashQuery {
 
   private final CQueryPlanKey planHash;
-
-  private final int bindHash;
+  private final BindValuesKey bindValuesKey;
 
   /**
    * Create the HashQuery.
    */
-  public HashQuery(CQueryPlanKey planHash, int bindHash) {
+  public HashQuery(CQueryPlanKey planHash, BindValuesKey bindValuesKey) {
     this.planHash = planHash;
-    this.bindHash = bindHash;
+    this.bindValuesKey = bindValuesKey;
   }
 
   @Override
@@ -25,7 +24,7 @@ public class HashQuery {
   @Override
   public int hashCode() {
     int hc = 92821 * planHash.hashCode();
-    hc = 92821 * hc + bindHash;
+    hc = 92821 * hc + bindValuesKey.hashCode();
     return hc;
   }
 
@@ -37,8 +36,7 @@ public class HashQuery {
     if (!(obj instanceof HashQuery)) {
       return false;
     }
-
     HashQuery e = (HashQuery) obj;
-    return e.bindHash == bindHash && e.planHash.equals(planHash);
+    return e.bindValuesKey.equals(bindValuesKey) && e.planHash.equals(planHash);
   }
 }

ebean-core/src/main/java/io/ebeaninternal/api/HelpScopeTrans.java

@@ -6,7 +6,7 @@ import io.ebean.TxScope;
 /**
  * Helper object to make AOP generated code simpler.
  */
-public class HelpScopeTrans {
+public final class HelpScopeTrans {
   private static boolean enabled = true;
 
   /**

ebean-core/src/main/java/io/ebeaninternal/api/LoadBeanBuffer.java

@@ -11,15 +11,15 @@ import java.util.List;
  */
 public interface LoadBeanBuffer {
 
-  int getBatchSize();
+  int batchSize();
 
-  List<EntityBeanIntercept> getBatch();
+  List<EntityBeanIntercept> batch();
 
-  BeanDescriptor<?> getBeanDescriptor();
+  BeanDescriptor<?> descriptor();
 
-  PersistenceContext getPersistenceContext();
+  PersistenceContext persistenceContext();
 
-  String getFullPath();
+  String fullPath();
 
   void configureQuery(SpiQuery<?> query, String lazyLoadProperty);
 

ebean-core/src/main/java/io/ebeaninternal/api/LoadBeanRequest.java

@@ -1,7 +1,8 @@
 package io.ebeaninternal.api;
 
-import io.ebean.bean.EntityBean;
+import io.ebean.CacheMode;
 import io.ebean.bean.EntityBeanIntercept;
+import io.ebeaninternal.api.SpiQuery.Mode;
 import io.ebeaninternal.server.core.OrmQueryRequest;
 import io.ebeaninternal.server.deploy.BeanDescriptor;
 
@@ -13,89 +14,60 @@ import java.util.Set;
 /**
  * Request for loading ManyToOne and OneToOne relationships.
  */
-public class LoadBeanRequest extends LoadRequest {
+public final class LoadBeanRequest extends LoadRequest {
 
   private final List<EntityBeanIntercept> batch;
-
   private final LoadBeanBuffer loadBuffer;
-
   private final String lazyLoadProperty;
-
   private final boolean loadCache;
-
-  private boolean loadedFromCache;
+  private final boolean alreadyLoaded;
 
   /**
    * Construct for lazy load request.
    */
-  public LoadBeanRequest(LoadBeanBuffer LoadBuffer, EntityBeanIntercept ebi, boolean loadCache) {
-    this(LoadBuffer, null, true, ebi.getLazyLoadProperty(), loadCache);
-    this.loadedFromCache = ebi.isLoadedFromCache();
+  public LoadBeanRequest(LoadBeanBuffer loadBuffer, EntityBeanIntercept ebi, boolean loadCache) {
+    this(loadBuffer, null, true, ebi.getLazyLoadProperty(), ebi.isLoaded(), loadCache || ebi.isLoadedFromCache());
   }
 
   /**
    * Construct for secondary query.
    */
-  public LoadBeanRequest(LoadBeanBuffer LoadBuffer, OrmQueryRequest<?> parentRequest) {
-    this(LoadBuffer, parentRequest, false, null, false);
+  public LoadBeanRequest(LoadBeanBuffer loadBuffer, OrmQueryRequest<?> parentRequest) {
+    this(loadBuffer, parentRequest, false, null, false, false);
   }
 
   private LoadBeanRequest(LoadBeanBuffer loadBuffer, OrmQueryRequest<?> parentRequest, boolean lazy,
-                          String lazyLoadProperty, boolean loadCache) {
-
+                          String lazyLoadProperty, boolean alreadyLoaded, boolean loadCache) {
     super(parentRequest, lazy);
     this.loadBuffer = loadBuffer;
-    this.batch = loadBuffer.getBatch();
+    this.batch = loadBuffer.batch();
     this.lazyLoadProperty = lazyLoadProperty;
+    this.alreadyLoaded = alreadyLoaded;
     this.loadCache = loadCache;
   }
 
   @Override
-  public Class<?> getBeanType() {
-    return loadBuffer.getBeanDescriptor().getBeanType();
+  public Class<?> beanType() {
+    return loadBuffer.descriptor().getBeanType();
   }
 
-  /**
-   * Return true if the beans invoking lazy loading were previously loaded from cache.
-   */
-  public boolean isLoadedFromCache() {
-    return loadedFromCache;
-  }
-
-  private boolean isLoadCache() {
-    return loadCache;
-  }
-
-  public String getDescription() {
-    return "path:" + loadBuffer.getFullPath() + " batch:" + batch.size();
+  public String description() {
+    return loadBuffer.fullPath();
   }
 
   /**
    * Return the batch of beans to actually load.
    */
-  public List<EntityBeanIntercept> getBatch() {
+  public List<EntityBeanIntercept> batch() {
     return batch;
   }
 
-  /**
-   * Return the load context.
-   */
-  private LoadBeanBuffer getLoadContext() {
-    return loadBuffer;
-  }
-
-  public int getBatchSize() {
-    return getLoadContext().getBatchSize();
-  }
-
   /**
    * Return the list of Id values for the beans in the lazy load buffer.
    */
   public List<Object> getIdList() {
-
     List<Object> idList = new ArrayList<>();
-
-    BeanDescriptor<?> desc = loadBuffer.getBeanDescriptor();
+    BeanDescriptor<?> desc = loadBuffer.descriptor();
     for (EntityBeanIntercept ebi : batch) {
       idList.add(desc.getId(ebi.getOwner()));
     }
@@ -106,20 +78,21 @@ public class LoadBeanRequest extends LoadRequest {
    * Configure the query for lazy loading execution.
    */
   public void configureQuery(SpiQuery<?> query, List<Object> idList) {
-
-    query.setMode(SpiQuery.Mode.LAZYLOAD_BEAN);
-    query.setPersistenceContext(loadBuffer.getPersistenceContext());
-
-    String mode = isLazy() ? "+lazy" : "+query";
-    query.setLoadDescription(mode, getDescription());
-
-    if (isLazy()) {
-      // cascade the batch size (if set) for further lazy loading
-      query.setLazyLoadBatchSize(getBatchSize());
+    query.setMode(Mode.LAZYLOAD_BEAN);
+    query.setPersistenceContext(loadBuffer.persistenceContext());
+    query.setLoadDescription(lazy ? "+lazy" : "+query", description());
+    if (lazy) {
+      query.setLazyLoadBatchSize(loadBuffer.batchSize());
+      if (alreadyLoaded) {
+        query.setBeanCacheMode(CacheMode.OFF);
+      }
+    } else {
+      query.setBeanCacheMode(CacheMode.OFF);
     }
-
     loadBuffer.configureQuery(query, lazyLoadProperty);
-
+    if (loadCache) {
+      query.setBeanCacheMode(CacheMode.PUT);
+    }
     if (idList.size() == 1) {
       query.where().idEq(idList.get(0));
     } else {
@@ -131,19 +104,15 @@ public class LoadBeanRequest extends LoadRequest {
    * Load the beans into the L2 cache if that is requested and check for load failures due to deletes.
    */
   public void postLoad(List<?> list) {
-
     Set<Object> loadedIds = new HashSet<>();
-
-    BeanDescriptor<?> desc = loadBuffer.getBeanDescriptor();
+    BeanDescriptor<?> desc = loadBuffer.descriptor();
     // collect Ids and maybe load bean cache
-    for (Object aList : list) {
-      EntityBean loadedBean = (EntityBean) aList;
-      loadedIds.add(desc.getId(loadedBean));
+    for (Object bean : list) {
+      loadedIds.add(desc.beanId(bean));
     }
-    if (isLoadCache()) {
+    if (loadCache) {
       desc.cacheBeanPutAll(list);
     }
-
     if (lazyLoadProperty != null) {
       for (EntityBeanIntercept ebi : batch) {
         // check if the underlying row in DB was deleted. Mark the bean as 'failed' if

ebean-core/src/main/java/io/ebeaninternal/api/LoadManyRequest.java

@@ -1,5 +1,6 @@
 package io.ebeaninternal.api;
 
+import io.ebean.CacheMode;
 import io.ebean.bean.BeanCollection;
 import io.ebean.bean.EntityBean;
 import io.ebeaninternal.server.core.BindPadding;
@@ -15,16 +16,13 @@ import java.util.List;
 /**
  * Request for loading Associated Many Beans.
  */
-public class LoadManyRequest extends LoadRequest {
+public final class LoadManyRequest extends LoadRequest {
 
   private static final Logger logger = LoggerFactory.getLogger(LoadManyRequest.class);
 
   private final List<BeanCollection<?>> batch;
-
   private final LoadManyBuffer loadContext;
-
   private final boolean onlyIds;
-
   private final boolean loadCache;
 
   /**
@@ -50,49 +48,17 @@ public class LoadManyRequest extends LoadRequest {
   }
 
   @Override
-  public Class<?> getBeanType() {
+  public Class<?> beanType() {
     return loadContext.getBeanDescriptor().getBeanType();
   }
 
-  public String getDescription() {
-    return "path:" + loadContext.getFullPath() + " size:" + batch.size();
-  }
-
-  /**
-   * Return the batch of collections to actually load.
-   */
-  public List<BeanCollection<?>> getBatch() {
-    return batch;
-  }
-
-  /**
-   * Return true if lazy loading should only load the id values.
-   * <p>
-   * This for use when lazy loading is invoked on methods such as clear() and removeAll() where it
-   * generally makes sense to only fetch the Id values as the other property information is not
-   * used.
-   */
-  private boolean isOnlyIds() {
-    return onlyIds;
-  }
-
-  /**
-   * Return true if we should load the Collection ids into the cache.
-   */
-  private boolean isLoadCache() {
-    return loadCache;
-  }
-
-  /**
-   * Return the batch size used for this load context.
-   */
-  public int getBatchSize() {
-    return loadContext.getBatchSize();
+  public String description() {
+    return loadContext.getFullPath();
   }
 
   private List<Object> parentIdList(SpiEbeanServer server) {
     List<Object> idList = new ArrayList<>();
-    BeanPropertyAssocMany<?> many = getMany();
+    BeanPropertyAssocMany<?> many = many();
     for (BeanCollection<?> bc : batch) {
       idList.add(many.getParentId(bc.getOwnerBean()));
       bc.setLoader(server); // don't use the load buffer again
@@ -103,42 +69,36 @@ public class LoadManyRequest extends LoadRequest {
     return idList;
   }
 
-  private BeanPropertyAssocMany<?> getMany() {
+  private BeanPropertyAssocMany<?> many() {
     return loadContext.getBeanProperty();
   }
 
   public SpiQuery<?> createQuery(SpiEbeanServer server) {
-    BeanPropertyAssocMany<?> many = getMany();
+    BeanPropertyAssocMany<?> many = many();
     SpiQuery<?> query = many.newQuery(server);
     String orderBy = many.getLazyFetchOrderBy();
     if (orderBy != null) {
       query.order(orderBy);
     }
-
     String extraWhere = many.getExtraWhere();
     if (extraWhere != null) {
       // replace special ${ta} placeholder with the base table alias
       // which is always t0 and add the extra where clause
       query.where().raw(extraWhere.replace("${ta}", "t0").replace("${mta}", "int_"));
     }
-
     query.setLazyLoadForParents(many);
     many.addWhereParentIdIn(query, parentIdList(server), loadContext.isUseDocStore());
     query.setPersistenceContext(loadContext.getPersistenceContext());
-
-    String mode = isLazy() ? "+lazy" : "+query";
-    query.setLoadDescription(mode, getDescription());
-
-    if (isLazy()) {
-      // cascade the batch size (if set) for further lazy loading
-      query.setLazyLoadBatchSize(getBatchSize());
+    query.setLoadDescription(lazy ? "+lazy" : "+query", description());
+    if (lazy) {
+      query.setLazyLoadBatchSize(loadContext.getBatchSize());
+    } else {
+      query.setBeanCacheMode(CacheMode.OFF);
     }
-
-    // potentially changes the joins and selected properties
+    // potentially changes the joins, selected properties, cache mode
     loadContext.configureQuery(query);
-
-    if (isOnlyIds()) {
-      // override to just select the Id values
+    if (onlyIds) {
+      // lazy loading invoked via clear() and removeAll()
       query.select(many.getTargetIdProperty());
     }
     return query;
@@ -149,7 +109,7 @@ public class LoadManyRequest extends LoadRequest {
    */
   public void postLoad() {
     BeanDescriptor<?> desc = loadContext.getBeanDescriptor();
-    BeanPropertyAssocMany<?> many = getMany();
+    BeanPropertyAssocMany<?> many = many();
     // check for BeanCollection's that where never processed
     // in the +query or +lazy load due to no rows (predicates)
     for (BeanCollection<?> bc : batch) {
@@ -159,9 +119,8 @@ public class LoadManyRequest extends LoadRequest {
           Object parentId = desc.getId(ownerBean);
           logger.debug("BeanCollection after lazy load was empty. type:" + ownerBean.getClass().getName() + " id:" + parentId + " owner:" + ownerBean);
         }
-      } else if (isLoadCache() && many.isUseCache()) {
-        Object parentId = desc.getId(bc.getOwnerBean());
-        desc.cacheManyPropPut(many, bc, parentId);
+      } else if (loadCache && many.isUseCache()) {
+        desc.cacheManyPropPut(many, bc, desc.getId(bc.getOwnerBean()));
       }
     }
   }

ebean-core/src/main/java/io/ebeaninternal/api/LoadRequest.java

@@ -9,22 +9,19 @@ import io.ebeaninternal.server.core.OrmQueryRequest;
 public abstract class LoadRequest {
 
   protected final OrmQueryRequest<?> parentRequest;
-
   protected final Transaction transaction;
-
   protected final boolean lazy;
 
-  public LoadRequest(OrmQueryRequest<?> parentRequest, boolean lazy) {
-
+  LoadRequest(OrmQueryRequest<?> parentRequest, boolean lazy) {
     this.parentRequest = parentRequest;
-    this.transaction = parentRequest == null ? null : parentRequest.getTransaction();
+    this.transaction = parentRequest == null ? null : parentRequest.transaction();
     this.lazy = lazy;
   }
 
   /**
    * Return the associated bean type for this load request.
    */
-  public abstract Class<?> getBeanType();
+  public abstract Class<?> beanType();
 
   /**
    * Return true if this is a lazy load and false if it is a secondary query.
@@ -39,7 +36,7 @@ public abstract class LoadRequest {
    * Lazy loading queries run in their own transaction.
    * </p>
    */
-  public Transaction getTransaction() {
+  public Transaction transaction() {
     return transaction;
   }
 
@@ -48,6 +45,6 @@ public abstract class LoadRequest {
    * So one of - findIterate(), findEach(), findEachWhile() or findVisit().
    */
   public boolean isParentFindIterate() {
-    return parentRequest != null && parentRequest.getQuery().getType() == SpiQuery.Type.ITERATE;
+    return parentRequest != null && parentRequest.query().getType() == SpiQuery.Type.ITERATE;
   }
 }

ebean-core/src/main/java/io/ebeaninternal/api/ManyWhereJoins.java

@@ -17,16 +17,13 @@ import java.util.TreeSet;
  * Holds the joins needs to support the many where predicates.
  * These joins are independent of any 'fetch' joins on the many.
  */
-public class ManyWhereJoins implements Serializable {
+public final class ManyWhereJoins implements Serializable {
 
   private static final long serialVersionUID = -6490181101871795417L;
 
   private final TreeMap<String, PropertyJoin> joins = new TreeMap<>();
-
   private List<String> formulaJoinProperties;
-
   private boolean aggregation;
-
   /**
    * 'Mode' indicating that joins added while this is true are required to be outer joins.
    */

ebean-core/src/main/java/io/ebeaninternal/api/Monitor.java

@@ -1,12 +0,0 @@
-package io.ebeaninternal.api;
-
-import java.io.Serializable;
-
-/**
- * Object used as a synchronization monitor that is serializable.
- */
-public class Monitor implements Serializable {
-
-  private static final long serialVersionUID = -2741687226680981940L;
-
-}

ebean-core/src/main/java/io/ebeaninternal/api/NaturalKeyEntryBasic.java

@@ -11,7 +11,7 @@ import java.util.Map;
 /**
  * Natural key entry with name value pairs for each of the properties making up the key.
  */
-class NaturalKeyEntryBasic implements NaturalKeyEntry {
+final class NaturalKeyEntryBasic implements NaturalKeyEntry {
 
   private final Map<String,Object> map = new HashMap<>();
   private final String key;

ebean-core/src/main/java/io/ebeaninternal/api/NaturalKeyEntrySimple.java

@@ -1,6 +1,6 @@
 package io.ebeaninternal.api;
 
-class NaturalKeyEntrySimple implements NaturalKeyEntry {
+final class NaturalKeyEntrySimple implements NaturalKeyEntry {
 
   private final String key;
   private final Object val;

ebean-core/src/main/java/io/ebeaninternal/api/NaturalKeyEq.java

@@ -3,7 +3,7 @@ package io.ebeaninternal.api;
 /**
  * A property value pair in a natural key lookup.
  */
-public class NaturalKeyEq {
+public final class NaturalKeyEq {
 
   final String property;
   final Object value;

ebean-core/src/main/java/io/ebeaninternal/api/NaturalKeyQueryData.java

@@ -11,28 +11,22 @@ import java.util.Set;
 /**
  * Collects the data for processing the natural key cache processing.
  */
-public class NaturalKeyQueryData<T> {
+public final class NaturalKeyQueryData<T> {
 
   private final BeanNaturalKey naturalKey;
-
   /**
    * Only one of IN or IN PAIRS is allowed.
    */
   private boolean hasIn;
-
   // IN Pairs clause - only one allowed
   private String inProperty0, inProperty1;
   private List<Pairs.Entry> inPairs;
-
   // IN clause - only one allowed
   private List<Object> inValues;
   private String inProperty;
-
   // normal EQ expressions
   private List<NaturalKeyEq> eqList;
-
   private NaturalKeySet set;
-
   private int hitCount;
 
   public NaturalKeyQueryData(BeanNaturalKey naturalKey) {

ebean-core/src/main/java/io/ebeaninternal/api/NaturalKeySet.java

@@ -4,8 +4,7 @@ import java.util.LinkedHashMap;
 import java.util.Map;
 import java.util.Set;
 
-public class NaturalKeySet {
-
+public final class NaturalKeySet {
 
   private final Map<Object, NaturalKeyEntry> map = new LinkedHashMap<>();
 

ebean-core/src/main/java/io/ebeaninternal/api/NoopQueryBindCapture.java

@@ -2,7 +2,7 @@ package io.ebeaninternal.api;
 
 import io.ebeaninternal.server.type.bindcapture.BindCapture;
 
-class NoopQueryBindCapture implements SpiQueryBindCapture {
+final class NoopQueryBindCapture implements SpiQueryBindCapture {
 
   @Override
   public boolean collectFor(long timeMicros) {

ebean-core/src/main/java/io/ebeaninternal/api/NoopQueryPlanManager.java

@@ -6,7 +6,7 @@ import io.ebean.meta.QueryPlanRequest;
 import java.util.Collections;
 import java.util.List;
 
-class NoopQueryPlanManager implements QueryPlanManager {
+final class NoopQueryPlanManager implements QueryPlanManager {
 
   @Override
   public void setDefaultThreshold(long thresholdMicros) {

ebean-core/src/main/java/io/ebeaninternal/api/PlatformMatch.java

@@ -3,7 +3,7 @@ package io.ebeaninternal.api;
 import io.ebean.annotation.Platform;
 import io.ebean.util.StringHelper;
 
-public class PlatformMatch {
+public final class PlatformMatch {
 
   /**
    * Return true if the script platforms is a match/supported for the given platform.
@@ -15,7 +15,6 @@ public class PlatformMatch {
     if (platforms == null || platforms.trim().isEmpty()) {
       return true;
     }
-
     // match on base platform name and platform name
     for (String name : StringHelper.splitNames(platforms)) {
       if (name.equalsIgnoreCase(platform.base().name()) || name.equalsIgnoreCase(platform.name())) {

ebean-core/src/main/java/io/ebeaninternal/api/PropertyJoin.java

@@ -5,16 +5,9 @@ import io.ebeaninternal.server.query.SqlJoinType;
 /**
  * Represents a join required for a given property and whether than needs to be an outer join.
  */
-public class PropertyJoin {
+public final class PropertyJoin {
 
-  /**
-   * The property name.
-   */
   private final String property;
-
-  /**
-   * Set to true if the property needs to be an outer join.
-   */
   private final SqlJoinType joinType;
 
   public PropertyJoin(String property, SqlJoinType joinType) {

ebean-core/src/main/java/io/ebeaninternal/api/ScopeTrans.java

@@ -7,7 +7,7 @@ import java.util.ArrayList;
 /**
  * Used internally to handle the scoping of transactions for methods.
  */
-public class ScopeTrans {
+public final class ScopeTrans {
 
   private static final int OPCODE_ATHROW = 191;
 
@@ -15,43 +15,32 @@ public class ScopeTrans {
    * The transaction in scope (can be null).
    */
   private final SpiTransaction transaction;
-
   /**
    * If true by default rollback on Checked exceptions.
    */
   private final boolean rollbackOnChecked;
-
   /**
    * True if the transaction was created and hence should be committed
    * on finally if it hasn't already been rolled back.
    */
   private final boolean created;
-
   /**
    * Explicit set of Exceptions that DO NOT cause a rollback to occur.
    */
   private final ArrayList<Class<? extends Throwable>> noRollbackFor;
-
   /**
    * Explicit set of Exceptions that DO cause a rollback to occur.
    */
   private final ArrayList<Class<? extends Throwable>> rollbackFor;
-
   private Boolean restoreBatch;
-
   private Boolean restoreBatchOnCascade;
-
   private int restoreBatchSize;
-
   private Boolean restoreBatchGeneratedKeys;
-
   private boolean restoreBatchFlushOnQuery;
-
   /**
    * Flag set when a rollback has occurred.
    */
   private boolean rolledBack;
-
   /**
    * Flag set when nested commit has occurred.
    */

ebean-core/src/main/java/io/ebeaninternal/api/ScopedTransaction.java

@@ -10,15 +10,13 @@ import javax.persistence.PersistenceException;
  *
  * These can be nested and internally they are pushed and popped from a stack.
  */
-public class ScopedTransaction extends SpiTransactionProxy {
+public final class ScopedTransaction extends SpiTransactionProxy {
 
   private final TransactionScopeManager manager;
-
   /**
    * Stack of 'nested' transactions.
    */
   private final ArrayStack<ScopeTrans> stack = new ArrayStack<>();
-
   private ScopeTrans current;
 
   /**

ebean-core/src/main/java/io/ebeaninternal/api/SpiDtoQuery.java

@@ -36,11 +36,6 @@ public interface SpiDtoQuery<T> extends DtoQuery<T>, SpiSqlBinding {
    */
   boolean isRelaxedMode();
 
-  /**
-   * Return the label for the query.
-   */
-  String getLabel();
-
   /**
    * Return the label with fallback to profile location label.
    */

ebean-core/src/main/java/io/ebeaninternal/api/SpiEbeanServer.java

@@ -8,6 +8,8 @@ import io.ebean.config.dbplatform.DatabasePlatform;
 import io.ebean.event.readaudit.ReadAuditLogger;
 import io.ebean.event.readaudit.ReadAuditPrepare;
 import io.ebean.meta.MetricVisitor;
+import io.ebean.plugin.SpiServer;
+import io.ebeaninternal.api.SpiQuery.Type;
 import io.ebeaninternal.server.core.SpiResultSet;
 import io.ebeaninternal.server.core.timezone.DataTimeZone;
 import io.ebeaninternal.server.deploy.BeanDescriptor;
@@ -22,7 +24,7 @@ import java.util.stream.Stream;
 /**
  * Service Provider extension to EbeanServer.
  */
-public interface SpiEbeanServer extends ExtendedServer, EbeanServer, BeanCollectionLoader {
+public interface SpiEbeanServer extends SpiServer, ExtendedServer, EbeanServer, BeanCollectionLoader {
 
   /**
    * Return true if the L2 cache has been disabled.
@@ -49,16 +51,6 @@ public interface SpiEbeanServer extends ExtendedServer, EbeanServer, BeanCollect
    */
   Object currentTenantId();
 
-  /**
-   * Return the server configuration.
-   */
-  DatabaseConfig getServerConfig();
-
-  /**
-   * Return the DatabasePlatform for this server.
-   */
-  DatabasePlatform getDatabasePlatform();
-
   /**
    * Create an object to represent the current CallStack.
    * <p>
@@ -149,7 +141,7 @@ public interface SpiEbeanServer extends ExtendedServer, EbeanServer, BeanCollect
   /**
    * Compile a query.
    */
-  <T> CQuery<T> compileQuery(Query<T> query, Transaction t);
+  <T> CQuery<T> compileQuery(Type type, Query<T> query, Transaction t);
 
   /**
    * Execute the findId's query but without copying the query.

ebean-core/src/main/java/io/ebeaninternal/api/SpiExpression.java

@@ -54,9 +54,9 @@ public interface SpiExpression extends Expression {
   void queryPlanHash(StringBuilder builder);
 
   /**
-   * Return the hash value for the values that will be bound.
+   * Build the key for bind values of the query.
    */
-  int queryBindHash();
+  void queryBindKey(BindValuesKey key);
 
   /**
    * Return true if the expression is the same with respect to bind values.

ebean-core/src/main/java/io/ebeaninternal/api/SpiExpressionList.java

@@ -44,8 +44,4 @@ public interface SpiExpressionList<T> extends ExpressionList<T>, SpiExpression {
     // do nothing by default
   }
 
-  /**
-   * Apply property prefix when filterMany expressions included in main query.
-   */
-  void prefixProperty(String path);
 }

ebean-core/src/main/java/io/ebeaninternal/api/SpiExpressionValidation.java

@@ -8,10 +8,9 @@ import java.util.Set;
 /**
  * Property expression validation request for a given root bean type.
  */
-public class SpiExpressionValidation {
+public final class SpiExpressionValidation {
 
   private final BeanType<?> desc;
-
   private final LinkedHashSet<String> unknown = new LinkedHashSet<>();
 
   public SpiExpressionValidation(BeanType<?> desc) {

ebean-core/src/main/java/io/ebeaninternal/api/SpiQuery.java

@@ -84,7 +84,7 @@ public interface SpiQuery<T> extends Query<T>, SpiQueryFetch, TxnProfileEventCod
     /**
      * Find single attribute.
      */
-    ATTRIBUTE(FIND_ATTRIBUTE, "findAttribute"),
+    ATTRIBUTE(FIND_ATTRIBUTE, "findAttribute", false, false),
 
     /**
      * Find rowCount.
@@ -92,9 +92,14 @@ public interface SpiQuery<T> extends Query<T>, SpiQueryFetch, TxnProfileEventCod
     COUNT(FIND_COUNT, "findCount"),
 
     /**
-     * A subquery used as part of a where clause.
+     * A subquery used as part of an exists where clause.
      */
-    SUBQUERY(FIND_SUBQUERY, "subquery"),
+    SQ_EXISTS(FIND_SUBQUERY, "sqExists", false, false),
+
+    /**
+     * A subquery used as part of an in where clause.
+     */
+    SQ_IN(FIND_SUBQUERY, "sqIn", false, false),
 
     /**
      * Delete query.
@@ -107,17 +112,21 @@ public interface SpiQuery<T> extends Query<T>, SpiQueryFetch, TxnProfileEventCod
     UPDATE(FIND_UPDATE, "update", true);
 
     private final boolean update;
+    private final boolean defaultSelect;
     private final String profileEventId;
     private final String label;
 
     Type(String profileEventId, String label) {
-      this(profileEventId, label, false);
+      this(profileEventId, label, false, true);
     }
-
     Type(String profileEventId, String label, boolean update) {
+      this(profileEventId, label, update, true);
+    }
+    Type(String profileEventId, String label, boolean update, boolean defaultSelect) {
       this.profileEventId = profileEventId;
       this.label = label;
       this.update = update;
+      this.defaultSelect = defaultSelect;
     }
 
     /**
@@ -127,6 +136,13 @@ public interface SpiQuery<T> extends Query<T>, SpiQueryFetch, TxnProfileEventCod
       return update;
     }
 
+    /**
+     * Return true if this allows default select clause.
+     */
+    public boolean defaultSelect() {
+      return defaultSelect;
+    }
+
     public String profileEventId() {
       return profileEventId;
     }
@@ -629,13 +645,11 @@ public interface SpiQuery<T> extends Query<T>, SpiQueryFetch, TxnProfileEventCod
   CQueryPlanKey prepare(SpiOrmQueryRequest<T> request);
 
   /**
-   * Calculate a hash based on the bind values used in the query.
+   * Build the key for the bind values used in the query (for l2 query cache).
    * <p>
-   * Combined with queryPlanHash() to return getQueryHash (a unique hash for a
-   * query).
-   * </p>
+   * Combined with queryPlanHash() to return queryHash (a unique key for a query).
    */
-  int queryBindHash();
+  void queryBindKey(BindValuesKey key);
 
   /**
    * Identifies queries that are exactly the same including bind variables.

ebean-core/src/main/java/io/ebeaninternal/api/SpiQueryPlan.java

@@ -20,7 +20,7 @@ public interface SpiQueryPlan {
   /**
    * The hash of the sql.
    */
-  long getSqlHash();
+  String getHash();
 
   /**
    * The SQL for the query plan.

ebean-core/src/main/java/io/ebeaninternal/api/TransactionEvent.java

@@ -20,7 +20,7 @@ import java.util.List;
  * to the TransactionEventManager.
  * </p>
  */
-public class TransactionEvent implements Serializable {
+public final class TransactionEvent implements Serializable {
 
   private static final long serialVersionUID = 7230903304106097120L;
 
@@ -29,13 +29,9 @@ public class TransactionEvent implements Serializable {
    * the cluster).
    */
   private final transient boolean local;
-
   private TransactionEventTable eventTables;
-
   private transient List<PersistRequestBean<?>> listenerNotify;
-
   private transient DeleteByIdMap deleteByIdMap;
-
   private transient CacheChangeSet changeSet;
 
   /**
@@ -110,11 +106,9 @@ public class TransactionEvent implements Serializable {
    * Build and return the cache changeSet.
    */
   public CacheChangeSet buildCacheChanges(TransactionManager manager) {
-
     if (changeSet == null && deleteByIdMap == null && eventTables == null) {
       return null;
     }
-
     if (changeSet == null) {
       changeSet = new CacheChangeSet();
     }

ebean-core/src/main/java/io/ebeaninternal/api/TransactionEventTable.java

@@ -28,21 +28,18 @@ public final class TransactionEventTable implements Serializable, BinaryWritable
   }
 
   public void add(TransactionEventTable table) {
-
     for (TableIUD iud : table.values()) {
       add(iud);
     }
   }
 
   public void add(String table, boolean insert, boolean update, boolean delete) {
-
     table = table.toUpperCase();
     add(new TableIUD(table, insert, update, delete));
   }
 
   public void add(TableIUD newTableIUD) {
-
-    TableIUD existingTableIUD = map.put(newTableIUD.getTableName(), newTableIUD);
+    TableIUD existingTableIUD = map.put(newTableIUD.tableName(), newTableIUD);
     if (existingTableIUD != null) {
       newTableIUD.add(existingTableIUD);
     }
@@ -56,7 +53,7 @@ public final class TransactionEventTable implements Serializable, BinaryWritable
     return map.values();
   }
 
-  public static class TableIUD implements Serializable, BulkTableEvent, BinaryWritable {
+  public static final class TableIUD implements Serializable, BulkTableEvent, BinaryWritable {
 
     private static final long serialVersionUID = -1958317571064162089L;
 
@@ -73,12 +70,10 @@ public final class TransactionEventTable implements Serializable, BinaryWritable
     }
 
     public static TableIUD readBinaryMessage(BinaryReadContext dataInput) throws IOException {
-
       String table = dataInput.readUTF();
       boolean insert = dataInput.readBoolean();
       boolean update = dataInput.readBoolean();
       boolean delete = dataInput.readBoolean();
-
       return new TableIUD(table, insert, update, delete);
     }
 
@@ -109,7 +104,7 @@ public final class TransactionEventTable implements Serializable, BinaryWritable
     }
 
     @Override
-    public String getTableName() {
+    public String tableName() {
       return table;
     }
 

ebean-core/src/main/java/io/ebeaninternal/json/DJsonService.java

@@ -17,7 +17,7 @@ import java.util.Set;
 /**
  * Utility that converts between JSON content and simple java Maps/Lists.
  */
-public class DJsonService implements SpiJsonService {
+public final class DJsonService implements SpiJsonService {
 
   /**
    * Write the nested Map/List as json.

ebean-core/src/main/java/io/ebeaninternal/json/EJsonReader.java

@@ -14,7 +14,7 @@ import java.util.List;
 import java.util.Map;
 import java.util.NoSuchElementException;
 
-class EJsonReader {
+final class EJsonReader {
 
   static final JsonFactory json = new JsonFactory();
 

ebean-core/src/main/java/io/ebeaninternal/json/EJsonWriter.java

@@ -14,7 +14,7 @@ import java.util.Map;
 import java.util.Map.Entry;
 import java.util.Set;
 
-class EJsonWriter {
+final class EJsonWriter {
 
   /**
    * Base jsonFactory implementation used when it is not passed in.

ebean-core/src/main/java/io/ebeaninternal/json/ModifyAwareFlag.java

@@ -7,7 +7,7 @@ import java.io.Serializable;
 /**
  * Detects when content has been modified and as such needs to be persisted (included in an update).
  */
-public class ModifyAwareFlag implements ModifyAwareType, Serializable {
+public final class ModifyAwareFlag implements ModifyAwareType, Serializable {
 
   private static final long serialVersionUID = 1;
 

ebean-core/src/main/java/io/ebeaninternal/json/ModifyAwareIterator.java

@@ -7,10 +7,9 @@ import java.util.Iterator;
 /**
  * Wraps an iterator for the purposes of detecting modifications.
  */
-public class ModifyAwareIterator<E> implements Iterator<E> {
+public final class ModifyAwareIterator<E> implements Iterator<E> {
 
   private final ModifyAwareType owner;
-
   private final Iterator<E> it;
 
   /**

ebean-core/src/main/java/io/ebeaninternal/json/ModifyAwareList.java

@@ -13,12 +13,11 @@ import java.util.Objects;
 /**
  * Modify aware wrapper of a list.
  */
-public class ModifyAwareList<E> implements List<E>, ModifyAwareType, Serializable {
+public final class ModifyAwareList<E> implements List<E>, ModifyAwareType, Serializable {
 
   private static final long serialVersionUID = 1;
 
   final List<E> list;
-
   final ModifyAwareType owner;
 
   public ModifyAwareList(List<E> list) {

ebean-core/src/main/java/io/ebeaninternal/json/ModifyAwareListIterator.java

@@ -7,10 +7,9 @@ import java.util.ListIterator;
 /**
  * Modify aware wrapper of a ListIterator.
  */
-public class ModifyAwareListIterator<E> implements ListIterator<E> {
+public final class ModifyAwareListIterator<E> implements ListIterator<E> {
 
   final ModifyAwareType owner;
-
   final ListIterator<E> iterator;
 
   public ModifyAwareListIterator(ModifyAwareType owner, ListIterator<E> iterator) {

ebean-core/src/main/java/io/ebeaninternal/json/ModifyAwareMap.java

@@ -12,15 +12,11 @@ import java.util.Set;
 /**
  * Map that is wraps an underlying map for the purpose of detecting changes.
  */
-public class ModifyAwareMap<K, V> implements Map<K, V>, ModifyAwareType, Serializable {
+public final class ModifyAwareMap<K, V> implements Map<K, V>, ModifyAwareType, Serializable {
 
   private static final long serialVersionUID = 1;
 
   final ModifyAwareType owner;
-
-  /**
-   * The underlying map.
-   */
   final Map<K, V> map;
 
   public ModifyAwareMap(Map<K, V> underlying) {

ebean-core/src/main/java/io/ebeaninternal/json/ModifyAwareSet.java

@@ -11,13 +11,12 @@ import java.util.Set;
 /**
  * Wraps a Set for the purposes of detecting modifications.
  */
-public class ModifyAwareSet<E> implements Set<E>, ModifyAwareType, Serializable {
+public final class ModifyAwareSet<E> implements Set<E>, ModifyAwareType, Serializable {
 
   private static final long serialVersionUID = 1;
 
-  protected final ModifyAwareType owner;
-
-  protected final Set<E> set;
+  private final ModifyAwareType owner;
+  private final Set<E> set;
 
   /**
    * Create as top level with it's own ModifyAwareOwner instance wrapping the given Set.

ebean-core/src/main/java/io/ebeaninternal/server/DContainerFactory.java

@@ -8,7 +8,7 @@ import io.ebeaninternal.server.core.DefaultContainer;
 /**
  * Default container factory found via service loader.
  */
-public class DContainerFactory implements SpiContainerFactory {
+public final class DContainerFactory implements SpiContainerFactory {
 
   @Override
   public SpiContainer create(ContainerConfig containerConfig) {

ebean-core/src/main/java/io/ebeaninternal/server/autotune/NoAutoTuneService.java

@@ -5,7 +5,7 @@ import io.ebeaninternal.api.SpiQuery;
 /**
  * Noop service when AutoTuneService is not available.
  */
-public class NoAutoTuneService implements AutoTuneService {
+public final class NoAutoTuneService implements AutoTuneService {
 
   @Override
   public void startup() {

ebean-core/src/main/java/io/ebeaninternal/server/cache/CacheChangeBeanRemove.java

@@ -8,10 +8,9 @@ import java.util.Collection;
 /**
  * Change to remove bean from L2 cache.
  */
-class CacheChangeBeanRemove implements CacheChange {
+final class CacheChangeBeanRemove implements CacheChange {
 
   private final BeanDescriptor<?> descriptor;
-
   private final Collection<Object> ids;
 
   CacheChangeBeanRemove(Object id, BeanDescriptor<?> descriptor) {

ebean-core/src/main/java/io/ebeaninternal/server/cache/CacheChangeBeanUpdate.java

@@ -7,7 +7,7 @@ import java.util.Map;
 /**
  * Put a new bean entry into the cache.
  */
-class CacheChangeBeanUpdate implements CacheChange {
+final class CacheChangeBeanUpdate implements CacheChange {
 
   private final BeanDescriptor<?> desc;
   private final String key;

ebean-core/src/main/java/io/ebeaninternal/server/cache/CacheChangeNaturalKeyPut.java

@@ -5,7 +5,7 @@ import io.ebeaninternal.server.deploy.BeanDescriptor;
 /**
  * Change the natural key mapping for a bean.
  */
-class CacheChangeNaturalKeyPut implements CacheChange {
+final class CacheChangeNaturalKeyPut implements CacheChange {
 
   private final BeanDescriptor<?> descriptor;
   private final String key;

ebean-core/src/main/java/io/ebeaninternal/server/cache/CacheChangeSet.java

@@ -14,18 +14,13 @@ import java.util.Set;
 /**
  * List of changes to be applied to L2 cache.
  */
-public class CacheChangeSet {
+public final class CacheChangeSet {
 
   private final List<CacheChange> entries = new ArrayList<>();
-
   private final Set<String> touchedTables = new HashSet<>();
-
   private final Set<BeanDescriptor<?>> queryCaches = new HashSet<>();
-
   private final Set<BeanDescriptor<?>> beanCaches = new HashSet<>();
-
   private final Map<BeanDescriptor<?>, CacheChangeBeanRemove> beanRemoveMap = new HashMap<>();
-
   private final Map<ManyKey, ManyChange> manyChangeMap = new HashMap<>();
 
   /**
@@ -173,14 +168,11 @@ public class CacheChangeSet {
   /**
    * Changes for a specific many property.
    */
-  private static class ManyChange implements CacheChange {
+  private static final class ManyChange implements CacheChange {
 
     final ManyKey key;
-
     final Set<Object> removes = new HashSet<>();
-
     final Map<Object, CachedManyIds> puts = new LinkedHashMap<>();
-
     boolean clear;
 
     ManyChange(ManyKey key) {
@@ -229,10 +221,9 @@ public class CacheChangeSet {
   /**
    * Key for changes on a many property.
    */
-  private static class ManyKey {
+  private static final class ManyKey {
 
     private final BeanDescriptor<?> desc;
-
     private final String manyProperty;
 
     ManyKey(BeanDescriptor<?> desc, String manyProperty) {

ebean-core/src/main/java/io/ebeaninternal/server/cache/CacheManagerOptions.java

@@ -10,18 +10,13 @@ import io.ebeaninternal.server.cluster.ClusterManager;
 /**
  * Configuration options when creating the default cache manager.
  */
-public class CacheManagerOptions {
+public final class CacheManagerOptions {
 
   private final ClusterManager clusterManager;
-
   private final DatabaseConfig databaseConfig;
-
   private final boolean localL2Caching;
-
   private CurrentTenantProvider currentTenantProvider;
-
   private QueryCacheEntryValidate queryCacheEntryValidate;
-
   private ServerCacheFactory cacheFactory = new DefaultServerCacheFactory();
   private ServerCacheOptions beanDefault = new ServerCacheOptions();
   private ServerCacheOptions queryDefault = new ServerCacheOptions();

ebean-core/src/main/java/io/ebeaninternal/server/cache/CachedBeanData.java

@@ -11,13 +11,12 @@ import java.util.Map;
 /**
  * Data held in the bean cache for cached beans.
  */
-public class CachedBeanData implements Externalizable {
+public final class CachedBeanData implements Externalizable {
 
   private long whenCreated;
   private long version;
   private String discValue;
   private Map<String, Object> data;
-
   /**
    * The sharable bean is effectively transient (near cache only).
    */

ebean-core/src/main/java/io/ebeaninternal/server/cache/CachedBeanDataFromBean.java

@@ -9,10 +9,9 @@ import io.ebeaninternal.server.deploy.BeanPropertyAssocMany;
 import java.util.LinkedHashMap;
 import java.util.Map;
 
-public class CachedBeanDataFromBean {
+public final class CachedBeanDataFromBean {
 
   public static CachedBeanData extract(BeanDescriptor<?> desc, EntityBean bean) {
-
     EntityBeanIntercept ebi = bean._ebean_getIntercept();
     Map<String, Object> data = new LinkedHashMap<>();
 
@@ -46,7 +45,6 @@ public class CachedBeanDataFromBean {
   }
 
   private static EntityBean createSharableBean(BeanDescriptor<?> desc, EntityBean bean, EntityBeanIntercept beanEbi) {
-
     if (!desc.isCacheSharableBeans() || !beanEbi.isFullyLoadedBean()) {
       return null;
     }

ebean-core/src/main/java/io/ebeaninternal/server/cache/CachedBeanDataToBean.java

@@ -7,30 +7,24 @@ import io.ebeaninternal.server.deploy.BeanDescriptor;
 import io.ebeaninternal.server.deploy.BeanProperty;
 import io.ebeaninternal.server.deploy.BeanPropertyAssocMany;
 
-public class CachedBeanDataToBean {
-
+public final class CachedBeanDataToBean {
 
   public static void load(BeanDescriptor<?> desc, EntityBean bean, CachedBeanData cacheBeanData, PersistenceContext context) {
-
     EntityBeanIntercept ebi = bean._ebean_getIntercept();
     // any future lazy loading skips L2 bean cache
     ebi.setLoadedFromCache(true);
-
     BeanProperty idProperty = desc.getIdProperty();
     if (desc.getInheritInfo() != null) {
         desc = desc.getInheritInfo().readType(bean.getClass()).desc();
     }
-
     if (idProperty != null) {
       // load the id property
       loadProperty(bean, cacheBeanData, ebi, idProperty, context);
     }
-
     // load the non-many properties
     for (BeanProperty prop : desc.propertiesNonMany()) {
       loadProperty(bean, cacheBeanData, ebi, prop, context);
     }
-
     for (BeanPropertyAssocMany<?> prop : desc.propertiesMany()) {
       if (prop.isElementCollection()) {
         loadProperty(bean, cacheBeanData, ebi, prop, context);
@@ -38,12 +32,10 @@ public class CachedBeanDataToBean {
         prop.createReferenceIfNull(bean);
       }
     }
-
     ebi.setLoadedLazy();
   }
 
   private static void loadProperty(EntityBean bean, CachedBeanData cacheBeanData, EntityBeanIntercept ebi, BeanProperty prop, PersistenceContext context) {
-
     if (cacheBeanData.isLoaded(prop.getName())) {
       if (!ebi.isLoadedProperty(prop.getPropertyIndex())) {
         Object value = cacheBeanData.getData(prop.getName());

ebean-core/src/main/java/io/ebeaninternal/server/cache/CachedBeanId.java

@@ -10,7 +10,7 @@ import java.io.ObjectOutput;
  * <p>
  * Put into L2 cache such that we know the type of a bean with inheritance.
  */
-public class CachedBeanId implements Externalizable {
+public final class CachedBeanId implements Externalizable {
 
   private String discValue;
   private Object id;

ebean-core/src/main/java/io/ebeaninternal/server/cache/CachedManyIds.java

@@ -13,7 +13,7 @@ import java.util.List;
  * This is effectively just the Id values for each of the beans in the collection.
  * </p>
  */
-public class CachedManyIds implements Externalizable {
+public final class CachedManyIds implements Externalizable {
 
   private List<Object> idList;
 

ebean-core/src/main/java/io/ebeaninternal/server/cache/DefaultCacheAdapter.java

@@ -13,7 +13,7 @@ import java.util.List;
  * Used to hide the Supplier part of the SpiCacheManager API from public use.
  * </p>
  */
-public class DefaultCacheAdapter implements ServerCacheManager {
+public final class DefaultCacheAdapter implements ServerCacheManager {
 
   private final SpiCacheManager cacheManager;
 
@@ -27,7 +27,7 @@ public class DefaultCacheAdapter implements ServerCacheManager {
   }
 
   @Override
-  public boolean isLocalL2Caching() {
+  public boolean localL2Caching() {
     return cacheManager.isLocalL2Caching();
   }
 
@@ -37,37 +37,37 @@ public class DefaultCacheAdapter implements ServerCacheManager {
   }
 
   @Override
-  public void setEnabledRegions(String regions) {
+  public void enabledRegions(String regions) {
     cacheManager.setEnabledRegions(regions);
   }
 
   @Override
-  public ServerCacheRegion getRegion(String region) {
+  public ServerCacheRegion region(String region) {
     return cacheManager.getRegion(region);
   }
 
   @Override
-  public void setAllRegionsEnabled(boolean enabled) {
+  public void allRegionsEnabled(boolean enabled) {
     cacheManager.setAllRegionsEnabled(enabled);
   }
 
   @Override
-  public ServerCache getNaturalKeyCache(Class<?> beanType) {
+  public ServerCache naturalKeyCache(Class<?> beanType) {
     return cacheManager.getNaturalKeyCache(beanType);
   }
 
   @Override
-  public ServerCache getBeanCache(Class<?> beanType) {
+  public ServerCache beanCache(Class<?> beanType) {
     return cacheManager.getBeanCache(beanType);
   }
 
   @Override
-  public ServerCache getCollectionIdsCache(Class<?> beanType, String propertyName) {
+  public ServerCache collectionIdsCache(Class<?> beanType, String propertyName) {
     return cacheManager.getCollectionIdsCache(beanType, propertyName);
   }
 
   @Override
-  public ServerCache getQueryCache(Class<?> beanType) {
+  public ServerCache queryCache(Class<?> beanType) {
     return cacheManager.getQueryCache(beanType);
   }
 

ebean-core/src/main/java/io/ebeaninternal/server/cache/DefaultCacheHolder.java

@@ -23,14 +23,13 @@ import java.util.concurrent.locks.ReentrantLock;
 /**
  * Manages the construction of caches.
  */
-class DefaultCacheHolder {
+final class DefaultCacheHolder {
 
   private static final Logger log = LoggerFactory.getLogger("io.ebean.cache.ALL");
 
   private final ReentrantLock lock = new ReentrantLock();
   private final ConcurrentHashMap<String, ServerCache> allCaches = new ConcurrentHashMap<>();
   private final ConcurrentHashMap<String, Set<String>> collectIdCaches = new ConcurrentHashMap<>();
-
   private final ServerCacheFactory cacheFactory;
   private final ServerCacheOptions beanDefault;
   private final ServerCacheOptions queryDefault;
@@ -76,7 +75,6 @@ class DefaultCacheHolder {
    * Return the cache for a given bean type.
    */
   private ServerCache getCacheInternal(Class<?> beanType, ServerCacheType type, String collectionProperty) {
-
     String shortName = key(beanType.getSimpleName(), collectionProperty, type);
     String fullKey = key(beanType.getName(), collectionProperty, type);
     return allCaches.computeIfAbsent(fullKey, s -> createCache(beanType, type, fullKey, shortName));
@@ -143,10 +141,8 @@ class DefaultCacheHolder {
   }
 
   private ServerCacheOptions getBeanOptions(Class<?> cls) {
-
     Cache cache = cls.getAnnotation(Cache.class);
     boolean nearCache = (cache != null && cache.nearCache());
-
     CacheBeanTuning tuning = cls.getAnnotation(CacheBeanTuning.class);
     if (tuning != null) {
       return new ServerCacheOptions(nearCache, tuning).applyDefaults(beanDefault);

ebean-core/src/main/java/io/ebeaninternal/server/cache/DefaultServerCache.java

@@ -11,6 +11,7 @@ import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 import java.io.Serializable;
+import java.lang.ref.SoftReference;
 import java.util.ArrayList;
 import java.util.Comparator;
 import java.util.Iterator;
@@ -37,8 +38,7 @@ public class DefaultServerCache implements ServerCache {
   /**
    * The underlying map (ConcurrentHashMap or similar)
    */
-  protected final Map<Object, CacheEntry> map;
-
+  protected final Map<Object, SoftReference<CacheEntry>> map;
   protected final CountMetric hitCount;
   protected final CountMetric missCount;
   protected final CountMetric putCount;
@@ -48,16 +48,11 @@ public class DefaultServerCache implements ServerCache {
 
   protected final String name;
   protected final String shortName;
-
-  private int maxSize;
-
+  private final int maxSize;
   private final int trimFrequency;
-
-  private int maxIdleSecs;
-
-  private int maxSecsToLive;
-
-  private TenantAwareKey tenantAwareKey;
+  private final int maxIdleSecs;
+  private final int maxSecsToLive;
+  private final TenantAwareKey tenantAwareKey;
 
   public DefaultServerCache(DefaultServerCacheConfig config) {
     this.name = config.getName();
@@ -70,7 +65,6 @@ public class DefaultServerCache implements ServerCache {
     this.trimFrequency = config.determineTrimFrequency();
 
     MetricFactory factory = MetricFactory.get();
-
     String prefix = "l2n.";
     this.hitCount = factory.createCountMetric(prefix + shortName + ".hit");
     this.missCount = factory.createCountMetric(prefix + shortName + ".miss");
@@ -81,9 +75,7 @@ public class DefaultServerCache implements ServerCache {
   }
 
   public void periodicTrim(BackgroundExecutor executor) {
-
     EvictionRunnable trim = new EvictionRunnable();
-
     // default to trimming the cache every 60 seconds
     long trimFreqSecs = (trimFrequency == 0) ? 60 : trimFrequency;
     executor.scheduleWithFixedDelay(trim, trimFreqSecs, trimFreqSecs, TimeUnit.SECONDS);
@@ -101,11 +93,9 @@ public class DefaultServerCache implements ServerCache {
 
   @Override
   public ServerCacheStatistics getStatistics(boolean reset) {
-
     ServerCacheStatistics cacheStats = new ServerCacheStatistics();
     cacheStats.setCacheName(name);
     cacheStats.setMaxSize(maxSize);
-
     cacheStats.setSize(size());
     cacheStats.setHitCount(hitCount.get(reset));
     cacheStats.setMissCount(missCount.get(reset));
@@ -113,7 +103,6 @@ public class DefaultServerCache implements ServerCache {
     cacheStats.setRemoveCount(removeCount.get(reset));
     cacheStats.setClearCount(clearCount.get(reset));
     cacheStats.setEvictCount(evictCount.get(reset));
-
     return cacheStats;
   }
 
@@ -133,10 +122,8 @@ public class DefaultServerCache implements ServerCache {
 
   @Override
   public int getHitRatio() {
-
     long mc = missCount.get(false);
     long hc = hitCount.get(false);
-
     long totalCount = hc + mc;
     if (totalCount == 0) {
       return 0;
@@ -177,7 +164,6 @@ public class DefaultServerCache implements ServerCache {
    */
   @Override
   public Object get(Object id) {
-
     CacheEntry entry = getCacheEntry(id);
     if (entry == null) {
       missCount.increment();
@@ -199,7 +185,8 @@ public class DefaultServerCache implements ServerCache {
    * Get the cache entry - override for query cache to validate dependent tables.
    */
   protected CacheEntry getCacheEntry(Object id) {
-    return map.get(key(id));
+    final SoftReference<CacheEntry> ref = map.get(key(id));
+    return ref != null ? ref.get() : null;
   }
 
   @Override
@@ -213,7 +200,7 @@ public class DefaultServerCache implements ServerCache {
   @Override
   public void put(Object id, Object value) {
     Object key = key(id);
-    map.put(key, new CacheEntry(key, value));
+    map.put(key, new SoftReference<>(new CacheEntry(key, value)));
     putCount.increment();
   }
 
@@ -222,8 +209,8 @@ public class DefaultServerCache implements ServerCache {
    */
   @Override
   public void remove(Object id) {
-    CacheEntry entry = map.remove(key(id));
-    if (entry != null) {
+    SoftReference<CacheEntry> entry = map.remove(key(id));
+    if (entry != null && entry.get() != null) {
       removeCount.increment();
     }
   }
@@ -250,74 +237,69 @@ public class DefaultServerCache implements ServerCache {
    * Run the eviction based on Idle time, Time to live and LRU last access.
    */
   public void runEviction() {
-
     long trimForMaxSize;
     if (maxSize == 0) {
       trimForMaxSize = 0;
     } else {
       trimForMaxSize = size() - maxSize;
     }
-
     if (maxIdleSecs == 0 && maxSecsToLive == 0 && trimForMaxSize < 0) {
       // nothing to trim on this cache
       return;
     }
-
     long startNanos = System.nanoTime();
-
     long trimmedByIdle = 0;
+    long trimmedByGC = 0;
     long trimmedByTTL = 0;
     long trimmedByLRU = 0;
 
     List<CacheEntry> activeList = new ArrayList<>(map.size());
-
     long idleExpireNano = startNanos - TimeUnit.SECONDS.toNanos(maxIdleSecs);
     long ttlExpireNano = startNanos - TimeUnit.SECONDS.toNanos(maxSecsToLive);
-
-    Iterator<CacheEntry> it = map.values().iterator();
+    Iterator<SoftReference<CacheEntry>> it = map.values().iterator();
     while (it.hasNext()) {
-      CacheEntry cacheEntry = it.next();
-      if (maxIdleSecs > 0 && idleExpireNano > cacheEntry.getLastAccessTime()) {
+      SoftReference<CacheEntry> ref = it.next();
+      final CacheEntry cacheEntry = ref.get();
+      if (cacheEntry == null) {
+        it.remove();
+        trimmedByGC++;
+      } else if (maxIdleSecs > 0 && idleExpireNano > cacheEntry.getLastAccessTime()) {
         it.remove();
         trimmedByIdle++;
-
       } else if (maxSecsToLive > 0 && ttlExpireNano > cacheEntry.getCreateTime()) {
         it.remove();
         trimmedByTTL++;
-
       } else if (trimForMaxSize > 0) {
         activeList.add(cacheEntry);
       }
     }
-
-    if (trimForMaxSize > 0) {
-      trimmedByLRU = activeList.size() - maxSize;
-      if (trimmedByLRU > 0) {
-        // sort into last access time ascending
-        activeList.sort(BY_LAST_ACCESS);
-        int trimSize = getTrimSize();
-        for (int i = trimSize; i < activeList.size(); i++) {
-          // remove if still in the cache
-          map.remove(activeList.get(i).getKey());
+    if (trimForMaxSize > 0 && activeList.size() > maxSize) {
+      // sort into last access time ascending
+      activeList.sort(BY_LAST_ACCESS);
+      int trimSize = getTrimSize();
+      for (int i = trimSize; i < activeList.size(); i++) {
+        // remove if still in the cache
+        if (map.remove(activeList.get(i).getKey()) != null) {
+          trimmedByLRU++;
         }
       }
     }
 
     evictCount.add(trimmedByIdle);
+    evictCount.add(trimmedByGC);
     evictCount.add(trimmedByTTL);
     evictCount.add(trimmedByLRU);
-
     if (logger.isTraceEnabled()) {
       long exeMicros = TimeUnit.MICROSECONDS.convert(System.nanoTime() - startNanos, TimeUnit.NANOSECONDS);
-      logger.trace("Executed trim of cache {} in [{}]millis idle[{}] timeToLive[{}] accessTime[{}]"
-        , name, exeMicros, trimmedByIdle, trimmedByTTL, trimmedByLRU);
+      logger.trace("Executed trim of cache {} in [{}]millis idle[{}] timeToLive[{}] accessTime[{}] gc[{}]",
+        name, exeMicros, trimmedByIdle, trimmedByTTL, trimmedByLRU, trimmedByGC);
     }
   }
 
   /**
    * Runnable that calls the eviction routine.
    */
-  public class EvictionRunnable implements Runnable {
+  public final class EvictionRunnable implements Runnable {
 
     @Override
     public void run() {
@@ -328,7 +310,7 @@ public class DefaultServerCache implements ServerCache {
   /**
    * Comparator for sorting by last access time.
    */
-  public static class CompareByLastAccess implements Comparator<CacheEntry>, Serializable {
+  public static final class CompareByLastAccess implements Comparator<CacheEntry>, Serializable {
 
     private static final long serialVersionUID = 1L;
 
@@ -341,7 +323,7 @@ public class DefaultServerCache implements ServerCache {
   /**
    * Wraps the value to additionally hold createTime and lastAccessTime and hit counter.
    */
-  public static class CacheEntry {
+  public static final class CacheEntry {
 
     private final Object key;
     private final Object value;

ebean-core/src/main/java/io/ebeaninternal/server/cache/DefaultServerCacheConfig.java

@@ -4,26 +4,26 @@ import io.ebean.cache.QueryCacheEntryValidate;
 import io.ebean.cache.ServerCacheConfig;
 import io.ebean.cache.ServerCacheOptions;
 import io.ebean.config.CurrentTenantProvider;
+import io.ebeaninternal.server.cache.DefaultServerCache.CacheEntry;
 
+import java.lang.ref.SoftReference;
 import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
 
-public class DefaultServerCacheConfig {
+public final class DefaultServerCacheConfig {
 
   private final ServerCacheConfig config;
-
-  private int maxSize;
-  private int maxIdleSecs;
-  private int maxSecsToLive;
-  private int trimFrequency;
-
-  private Map<Object, DefaultServerCache.CacheEntry> map;
+  private final int maxSize;
+  private final int maxIdleSecs;
+  private final int maxSecsToLive;
+  private final int trimFrequency;
+  private final Map<Object, SoftReference<CacheEntry>> map;
 
   public DefaultServerCacheConfig(ServerCacheConfig config) {
     this(config,  new ConcurrentHashMap<>());
   }
 
-  public DefaultServerCacheConfig(ServerCacheConfig config, Map<Object, DefaultServerCache.CacheEntry> map) {
+  public DefaultServerCacheConfig(ServerCacheConfig config, Map<Object, SoftReference<CacheEntry>> map) {
     this.config = config;
     this.map = map;
 
@@ -50,7 +50,7 @@ public class DefaultServerCacheConfig {
     return config.getShortName();
   }
 
-  public Map<Object, DefaultServerCache.CacheEntry> getMap() {
+  public Map<Object, SoftReference<CacheEntry>> getMap() {
     return map;
   }