/*******************************************************************************
* Copyright (c) 1998, 2015 Oracle and/or its affiliates. All rights reserved.
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License v1.0 and Eclipse Distribution License v. 1.0
* which accompanies this distribution.
* The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
* and the Eclipse Distribution License is available at
* http://www.eclipse.org/org/documents/edl-v10.php.
*
* Contributors:
* Oracle - initial API and implementation from Oracle TopLink
******************************************************************************/
package org.eclipse.persistence.descriptors.invalidation;
import java.util.Random;
import org.eclipse.persistence.descriptors.ClassDescriptor;
import org.eclipse.persistence.internal.identitymaps.CacheKey;
import org.eclipse.persistence.internal.sessions.AbstractSession;
/**
* PUBLIC:
* A CacheInvalidationPolicy is used to set objects in TopLink's identity maps to be invalid
* following given rules. CacheInvalidationPolicy is the abstract superclass for all
* policies used for cache invalidation.
* By default in EclipseLink, objects do not expire in the cache. Several different policies
* are available to allow objects to expire. These can be set on the ClassDescriptor.
* @see org.eclipse.persistence.descriptors.ClassDescriptor
* @see org.eclipse.persistence.descriptors.invalidation.NoExpiryCacheInvalidationPolicy
* @see org.eclipse.persistence.descriptors.invalidation.DailyCacheInvalidationPolicy
* @see org.eclipse.persistence.descriptors.invalidation.TimeToLiveCacheInvalidationPolicy
*/
public abstract class CacheInvalidationPolicy implements java.io.Serializable, Cloneable {
public static final long NO_EXPIRY = -1;
/** This will represent objects that do not expire. */
protected boolean shouldUpdateReadTimeOnUpdate = false;
/** Determines if expired object registered in the unit of work should be refreshed, default true. */
protected boolean shouldRefreshInvalidObjectsOnClone = true;
/** Allows the timeToLive to be randomized to avoid bottlenecks. */
protected boolean isInvalidationRandomized = false;
/** Random used for randomized invalidation. */
protected Random random;
/**
* PUBLIC:
* Allows the timeToLive to be randomized to avoid bottlenecks.
*/
public boolean isInvalidationRandomized() {
return isInvalidationRandomized;
}
/**
* PUBLIC:
* Allows the timeToLive to be randomized to avoid bottlenecks.
*/
public void setIsInvalidationRandomized(boolean isInvalidationRandomized) {
this.isInvalidationRandomized = isInvalidationRandomized;
if (isInvalidationRandomized) {
this.random = new Random();
}
}
/**
* INTERNAL:
* Get the next time when this object will become invalid
*/
public abstract long getExpiryTimeInMillis(CacheKey key);
/**
* INTERNAL:
* Return the remaining life of this object
*/
public long getRemainingValidTime(CacheKey key) {
long expiryTime = getExpiryTimeInMillis(key);
long remainingTime = expiryTime - System.currentTimeMillis();
if (remainingTime > 0) {
return remainingTime;
}
return 0;
}
/**
* INTERNAL:
* Allow initialization with the descriptor.
*/
public void initialize(ClassDescriptor descriptor, AbstractSession session) {
}
/**
* INTERNAL:
* return true if this object is expire, false otherwise.
*/
public boolean isInvalidated(CacheKey key) {
return isInvalidated(key, System.currentTimeMillis());
}
/**
* INTERNAL:
* return true if this object is expire, false otherwise.
*/
public abstract boolean isInvalidated(CacheKey key, long currentTimeMillis);
/**
* PUBLIC:
* Set whether to update the stored time an object was read when an object is updated.
* When the read time is updated, it indicates to EclipseLink that the data in the object
* is up to date. This means that cache invalidation checks will occur relative to the
* new read time.
* By default, the read time will not be updated when an object is updated.
* Often it is possible to be confident that the object is up to date after an update
* because otherwise the update will fail because of the locking policies in use.
*/
public void setShouldUpdateReadTimeOnUpdate(boolean shouldUpdateReadTime) {
shouldUpdateReadTimeOnUpdate = shouldUpdateReadTime;
}
/**
* PUBLIC:
* Return whether objects affected by this CacheInvalidationPolicy should have
* the read time on their cache keys updated when an update occurs.
*/
public boolean shouldUpdateReadTimeOnUpdate() {
return shouldUpdateReadTimeOnUpdate;
}
/**
* PUBLIC:
* Set if expired object registered in the unit of work should be refreshed, default is true.
* @deprecated since EclipseLink 2.2
* @see #setShouldRefreshInvalidObjectsOnClone(boolean)
*/
@Deprecated
public void setShouldRefreshInvalidObjectsInUnitOfWork(boolean shouldRefreshInvalidObjectsInUnitOfWork) {
this.shouldRefreshInvalidObjectsOnClone = shouldRefreshInvalidObjectsInUnitOfWork;
}
/**
* PUBLIC:
* Set if expired object should be refreshed prior to cloning, default is true. Applies to Protected Entities and UnitOfWork registration.
*/
public void setShouldRefreshInvalidObjectsOnClone(boolean shouldRefreshInvalidObjectsOnClone) {
this.shouldRefreshInvalidObjectsOnClone = shouldRefreshInvalidObjectsOnClone;
}
/**
* PUBLIC:
* Return if expired object registered in the unit of work should be refreshed.
* @deprecated since EclipseLink 2.2
* @see #shouldRefreshInvalidObjectsOnClone()
*/
@Deprecated
public boolean shouldRefreshInvalidObjectsInUnitOfWork() {
return shouldRefreshInvalidObjectsOnClone;
}
/**
* PUBLIC:
* Return if expired object should be refreshed prior to cloning. Applies to Protected Entities and UnitOfWork registration.
*/
public boolean shouldRefreshInvalidObjectsOnClone() {
return shouldRefreshInvalidObjectsOnClone;
}
public Object clone() {
CacheInvalidationPolicy clone = null;
try {
clone = (CacheInvalidationPolicy)super.clone();
clone.setShouldUpdateReadTimeOnUpdate(this.shouldUpdateReadTimeOnUpdate);
clone.setShouldRefreshInvalidObjectsOnClone(this.shouldRefreshInvalidObjectsOnClone);
clone.setIsInvalidationRandomized(this.isInvalidationRandomized);
} catch (Exception exception) {
throw new InternalError("clone failed");
}
return clone;
}
}