* This uses either DatabaseConfig or properties in the application.properties file to * configure and create a Database instance. - *
** 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)}. - *
** 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. - *
*/ 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. + * + *{@code
+ *
+ * DatabaseConfig config = new DatabaseConfig();
+ * config.setName("db");
+ * config.loadProperties();
+ *
+ * Database database = DatabaseFactory.create(config);
+ *
+ * }
*/
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.
* * This is typically invoked via JVM shutdown hook and not explicitly called. - *
*/ 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; diff --git a/ebean-api/src/main/java/io/ebean/bean/EntityBean.java b/ebean-api/src/main/java/io/ebean/bean/EntityBean.java index 03d1195c8..ee54991ad 100644 --- a/ebean-api/src/main/java/io/ebean/bean/EntityBean.java +++ b/ebean-api/src/main/java/io/ebean/bean/EntityBean.java @@ -27,17 +27,6 @@ public interface EntityBean extends Serializable { throw new NotEnhancedException(); } - /** - * Return the enhancement marker value. - *- * This is the class name of the enhanced class and used to check that all - * entity classes are enhanced (specifically not just a super class). - *
- */ - default String _ebean_getMarker() { - throw new NotEnhancedException(); - } - /** * Create and return a new entity bean instance. */ diff --git a/ebean-api/src/main/java/io/ebean/bean/EntityBeanIntercept.java b/ebean-api/src/main/java/io/ebean/bean/EntityBeanIntercept.java index 28a088ce6..527860200 100644 --- a/ebean-api/src/main/java/io/ebean/bean/EntityBeanIntercept.java +++ b/ebean-api/src/main/java/io/ebean/bean/EntityBeanIntercept.java @@ -51,6 +51,11 @@ public final class EntityBeanIntercept implements Serializable { */ private static final byte FLAG_ORIG_VALUE_SET = 8; + /** + * Flags indicating if the mutable hash is set. + */ + private static final byte FLAG_MUTABLE_HASH_SET = 16; + private transient final ReentrantLock lock = new ReentrantLock(); private transient NodeUsageCollector nodeUsageCollector; private transient PersistenceContext persistenceContext; @@ -91,6 +96,17 @@ public final class EntityBeanIntercept implements Serializable { private Object ownerId; private int sortOrder; + /** + * Holds information of json loaded jackson beans (e.g. the original json or checksum). + */ + private MutableValueInfo[] mutableInfo; + + /** + * Holds json content determined at point of dirty check. + * Stored here on dirty check such that we only convert to json once. + */ + private MutableValueNext[] mutableNext; + /** * Create a intercept with a given entity. */ @@ -228,6 +244,17 @@ public final class EntityBeanIntercept implements Serializable { * if any embedded beans are either new or dirty (and hence need saving). */ public boolean isDirty() { + if (dirty) { + return true; + } + if (mutableInfo != null) { + for (int i = 0; i < mutableInfo.length; i++) { + if (mutableInfo[i] != null && !mutableInfo[i].isEqualToObject(owner._ebean_getField(i))) { + dirty = true; + break; + } + } + } return dirty; } @@ -368,8 +395,18 @@ 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); + flags[i] &= ~(FLAG_CHANGED_PROP | FLAG_ORIG_VALUE_SET); } this.dirty = false; } @@ -442,6 +479,10 @@ public final class EntityBeanIntercept implements Serializable { * Return the original value that was changed via an update. */ public Object getOrigValue(int propertyIndex) { + if ((flags[propertyIndex] & (FLAG_ORIG_VALUE_SET | FLAG_MUTABLE_HASH_SET)) == FLAG_MUTABLE_HASH_SET) { + // mutable hash set, but not ORIG_VALUE + setOriginalValue(propertyIndex, mutableInfo[propertyIndex].get()); + } if (origValues == null) { return null; } @@ -638,7 +679,7 @@ public final class EntityBeanIntercept implements Serializable { public void addDirtyPropertyNames(Set+ * Set here as the mutable property dirty detection is based on json content comparison. + * We only want to perform the json serialisation once so storing it here as part of + * dirty detection so that we can get it back to bind in insert or update etc. + */ + public void mutableNext(int propertyIndex, MutableValueNext next) { + if (mutableNext == null) { + mutableNext = new MutableValueNext[flags.length]; + } + mutableNext[propertyIndex] = next; + } + + /** + * Update the 'next' mutable info returning the content that was obtained via dirty detection. + */ + public String mutableNext(int propertyIndex) { + if (mutableNext == null) { + return null; + } + return mutableNext[propertyIndex].content(); + } + } diff --git a/ebean-api/src/main/java/io/ebean/bean/MutableValueInfo.java b/ebean-api/src/main/java/io/ebean/bean/MutableValueInfo.java new file mode 100644 index 000000000..27716b13c --- /dev/null +++ b/ebean-api/src/main/java/io/ebean/bean/MutableValueInfo.java @@ -0,0 +1,42 @@ +package io.ebean.bean; + +/** + * Holds information on mutable values (like plain beans stored as json). + *
+ * Used internally in EntityBeanIntercept for dirty detection on mutable values. + * Typically, mutation detection is based on a hash/checksum of json content or the + * original json content itself. + *
+ * Refer to the mapping options {@code @DbJson(mutationDetection)}. + */ +public interface MutableValueInfo { + + /** + * Compares the given json returning null if deemed unchanged or returning + * the MutableValueNext to use if deemed dirty/changed. + *
+ * Returning MutableValueNext allows an implementation based on hash/checksum + * to only perform that computation once. + * + * @return Null if deemed unchanged or the MutableValueNext if deemed changed. + */ + MutableValueNext nextDirty(String json); + + /** + * Compares the given object to an internal value. + *
+ * This is used to support changelog/beanState. The implementation can serialize the + * object into json form and compare it against the original json. + */ + boolean isEqualToObject(Object obj); + + /** + * Creates a new instance from the internal json string. + *
+ * This is used to provide an original/old value for change logging / persist listeners. + * This is only available for properties that have {@code @DbJson(keepSource=true)}. + */ + default Object get() { + return null; + } +} diff --git a/ebean-api/src/main/java/io/ebean/bean/MutableValueNext.java b/ebean-api/src/main/java/io/ebean/bean/MutableValueNext.java new file mode 100644 index 000000000..401d3c223 --- /dev/null +++ b/ebean-api/src/main/java/io/ebean/bean/MutableValueNext.java @@ -0,0 +1,17 @@ +package io.ebean.bean; + +/** + * Represents a next value to use for mutable content properties (DbJson with jackson beans). + */ +public interface MutableValueNext { + + /** + * Return the next content to use. Provided such that we serialise to json once. + */ + String content(); + + /** + * Return the next MutableValueInfo to use after an update. + */ + MutableValueInfo info(); +} diff --git a/ebean-api/src/main/java/io/ebean/config/DatabaseConfig.java b/ebean-api/src/main/java/io/ebean/config/DatabaseConfig.java index bc3ae587f..873304c3a 100644 --- a/ebean-api/src/main/java/io/ebean/config/DatabaseConfig.java +++ b/ebean-api/src/main/java/io/ebean/config/DatabaseConfig.java @@ -7,9 +7,7 @@ import io.ebean.EbeanVersion; import io.ebean.PersistenceContextScope; import io.ebean.Query; import io.ebean.Transaction; -import io.ebean.annotation.Encrypted; -import io.ebean.annotation.PersistBatch; -import io.ebean.annotation.Platform; +import io.ebean.annotation.*; import io.ebean.cache.ServerCachePlugin; import io.ebean.config.dbplatform.DatabasePlatform; import io.ebean.config.dbplatform.DbEncrypt; @@ -194,10 +192,9 @@ public class DatabaseConfig { private JsonConfig.Include jsonInclude = JsonConfig.Include.ALL; /** - * When true then by default DbJson beans are assumed to be dirty. - * I believe we want to change this default to false in the future. + * The default mode used for {@code @DbJson} with Jackson ObjectMapper. */ - private boolean jsonDirtyByDefault = true; + private MutationDetection jsonMutationDetection = MutationDetection.HASH; /** * The database platform name. Used to imply a DatabasePlatform to use. @@ -322,6 +319,8 @@ public class DatabaseConfig { */ private ExternalTransactionManager externalTransactionManager; + private boolean skipDataSourceCheck; + /** * The data source (if programmatically provided). */ @@ -744,23 +743,21 @@ public class DatabaseConfig { } /** - * Return true if DbJson beans are assumed dirty by default. - *
- * That is, when true beans that do not implement ModifyAwareType are by - * default assumed to be dirty and included in updates. + * Return the default MutableDetection to use with {@code @DbJson} using Jackson. + * + * @see DbJson#mutationDetection() */ - public boolean isJsonDirtyByDefault() { - return jsonDirtyByDefault; + public MutationDetection getJsonMutationDetection() { + return jsonMutationDetection; } /** - * Set to false if we want DbJson beans to not be assumed to be dirty. - *
- * That is, when true beans that do not implement ModifyAwareType are by - * default assumed to be dirty and included in updates. + * Set the default MutableDetection to use with {@code @DbJson} using Jackson. + * + * @see DbJson#mutationDetection() */ - public void setJsonDirtyByDefault(boolean jsonDirtyByDefault) { - this.jsonDirtyByDefault = jsonDirtyByDefault; + public void setJsonMutationDetection(MutationDetection jsonMutationDetection) { + this.jsonMutationDetection = jsonMutationDetection; } /** @@ -1656,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. */ @@ -2935,8 +2946,9 @@ public class DatabaseConfig { jsonInclude = p.getEnum(JsonConfig.Include.class, "jsonInclude", jsonInclude); jsonDateTime = p.getEnum(JsonConfig.DateTime.class, "jsonDateTime", jsonDateTime); jsonDate = p.getEnum(JsonConfig.Date.class, "jsonDate", jsonDate); - jsonDirtyByDefault = p.getBoolean("jsonDirtyByDefault", jsonDirtyByDefault); + 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); diff --git a/ebean-api/src/main/java/io/ebean/event/ShutdownManager.java b/ebean-api/src/main/java/io/ebean/event/ShutdownManager.java index f762b0084..4011683ca 100644 --- a/ebean-api/src/main/java/io/ebean/event/ShutdownManager.java +++ b/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. *
* Makes sure all the resources are shutdown properly and in order. - *
*/ 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
* Query plan collection will stop once this time is exceeded.
*/
- public long getMaxTimeMillis() {
+ public long maxTimeMillis() {
return maxTimeMillis;
}
@@ -65,7 +65,7 @@ public class QueryPlanRequest {
* this to ensure the query plan capture does not use excessive amount
* of time - put too much load on the database.
*/
- public void setMaxTimeMillis(long maxTimeMillis) {
+ public void maxTimeMillis(long maxTimeMillis) {
this.maxTimeMillis = maxTimeMillis;
}
}
diff --git a/ebean-api/src/main/java/io/ebean/meta/ServerMetrics.java b/ebean-api/src/main/java/io/ebean/meta/ServerMetrics.java
index 8f0488d62..b8a50d85d 100644
--- a/ebean-api/src/main/java/io/ebean/meta/ServerMetrics.java
+++ b/ebean-api/src/main/java/io/ebean/meta/ServerMetrics.java
@@ -10,16 +10,39 @@ public interface ServerMetrics {
/**
* Return timed metrics for Transactions, labelled SqlQuery, labelled SqlUpdate.
*/
- List
+ * 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
*/ -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