/*
* Hibernate, Relational Persistence for Idiomatic Java
*
* License: GNU Lesser General Public License (LGPL), version 2.1 or later.
* See the lgpl.txt file in the root directory or <http://www.gnu.org/licenses/lgpl-2.1.html>.
*/
package org.hibernate.cache.ehcache.management.impl;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;
import javax.management.openmbean.CompositeData;
import javax.management.openmbean.CompositeDataSupport;
import javax.management.openmbean.CompositeType;
import javax.management.openmbean.OpenDataException;
import javax.management.openmbean.OpenType;
import javax.management.openmbean.SimpleType;
import javax.management.openmbean.TabularData;
import javax.management.openmbean.TabularDataSupport;
import javax.management.openmbean.TabularType;
import org.hibernate.stat.EntityStatistics;
/**
* When we only support Java 6, all of this OpenMBean scaffolding can be removed in favor or MXBeans.
*
* @author gkeim
*/
public class EntityStats implements Serializable {
private static final String COMPOSITE_TYPE_NAME = "EntityStats";
private static final String COMPOSITE_TYPE_DESCRIPTION = "Statistics per Entity";
private static final String[] ITEM_NAMES = new String[] {
"name", "shortName", "loadCount",
"updateCount", "insertCount", "deleteCount", "fetchCount", "optimisticFailureCount",
};
private static final String[] ITEM_DESCRIPTIONS = new String[] {
"name", "shortName", "loadCount",
"updateCount", "insertCount", "deleteCount", "fetchCount", "optimisticFailureCount",
};
private static final OpenType[] ITEM_TYPES = new OpenType[] {
SimpleType.STRING,
SimpleType.STRING, SimpleType.LONG, SimpleType.LONG, SimpleType.LONG, SimpleType.LONG, SimpleType.LONG,
SimpleType.LONG,
};
private static final CompositeType COMPOSITE_TYPE;
private static final String TABULAR_TYPE_NAME = "Statistics by Entity";
private static final String TABULAR_TYPE_DESCRIPTION = "All Entity Statistics";
private static final String[] INDEX_NAMES = new String[] {"name",};
private static final TabularType TABULAR_TYPE;
static {
try {
COMPOSITE_TYPE = new CompositeType(
COMPOSITE_TYPE_NAME, COMPOSITE_TYPE_DESCRIPTION, ITEM_NAMES,
ITEM_DESCRIPTIONS, ITEM_TYPES
);
TABULAR_TYPE = new TabularType( TABULAR_TYPE_NAME, TABULAR_TYPE_DESCRIPTION, COMPOSITE_TYPE, INDEX_NAMES );
}
catch (OpenDataException e) {
throw new RuntimeException( e );
}
}
/**
* name
*/
protected final String name;
/**
* shortName
*/
protected final String shortName;
/**
* loadCount
*/
protected long loadCount;
/**
* updateCount
*/
protected long updateCount;
/**
* insertCount
*/
protected long insertCount;
/**
* deleteCount
*/
protected long deleteCount;
/**
* fetchCount
*/
protected long fetchCount;
/**
* optimisticFailureCount
*/
protected long optimisticFailureCount;
/**
* Constructor only naming the stat
* @param name the name of the entity
*/
public EntityStats(String name) {
this.name = name;
this.shortName = CacheRegionUtils.determineShortName( name );
}
/**
* Constructor naming the stat and sourcing stats
* @param name the name of the entity
* @param src its source for the stats to expose
*/
public EntityStats(String name, EntityStatistics src) {
this( name );
try {
this.loadCount = BeanUtils.getLongBeanProperty( src, "loadCount" );
this.updateCount = BeanUtils.getLongBeanProperty( src, "updateCount" );
this.insertCount = BeanUtils.getLongBeanProperty( src, "insertCount" );
this.deleteCount = BeanUtils.getLongBeanProperty( src, "deleteCount" );
this.fetchCount = BeanUtils.getLongBeanProperty( src, "fetchCount" );
this.optimisticFailureCount = BeanUtils.getLongBeanProperty( src, "optimisticFailureCount" );
}
catch (Exception e) {
e.printStackTrace();
throw new RuntimeException( "Exception retrieving statistics", e );
}
}
/**
* Constructor from compositeDate
* @param cData CompositeData of the stats
*/
@SuppressWarnings("UnusedAssignment")
public EntityStats(final CompositeData cData) {
int i = 0;
name = (String) cData.get( ITEM_NAMES[i++] );
shortName = (String) cData.get( ITEM_NAMES[i++] );
loadCount = (Long) cData.get( ITEM_NAMES[i++] );
updateCount = (Long) cData.get( ITEM_NAMES[i++] );
insertCount = (Long) cData.get( ITEM_NAMES[i++] );
deleteCount = (Long) cData.get( ITEM_NAMES[i++] );
fetchCount = (Long) cData.get( ITEM_NAMES[i++] );
optimisticFailureCount = (Long) cData.get( ITEM_NAMES[i++] );
}
/**
* Adds the counters of this instance up with the ones passed in
* @param stats the stats to add to this one
*/
public void add(EntityStats stats) {
loadCount += stats.getLoadCount();
updateCount += stats.getUpdateCount();
insertCount += stats.getInsertCount();
deleteCount += stats.getDeleteCount();
fetchCount += stats.getFetchCount();
optimisticFailureCount += stats.getOptimisticFailureCount();
}
/**
* {@inheritDoc}
*/
@Override
public String toString() {
return "name=" + name + ", shortName=" + shortName + ",loadCount=" + loadCount + ", updateCount=" + updateCount
+ ", insertCount=" + insertCount + ", deleteCount=" + deleteCount + ", fetchCount=" + fetchCount
+ ", optimisticFailureCount" + optimisticFailureCount;
}
/**
* The name of the entity those stats are about
* @return the entity name
*/
public String getName() {
return name;
}
/**
* The short name of the entity those stats are about
* @return the shortName of the entity
*/
@SuppressWarnings("UnusedDeclaration")
public String getShortName() {
return shortName;
}
/**
* Amount of load ops on the entity
* @return the load count
*/
public long getLoadCount() {
return loadCount;
}
/**
* Amount of update ops on the entity
* @return the update count
*/
public long getUpdateCount() {
return updateCount;
}
/**
* Amount of insert ops on the entity
* @return the insert count
*/
public long getInsertCount() {
return insertCount;
}
/**
* Amount of delete ops on the entity
* @return the delete count
*/
public long getDeleteCount() {
return deleteCount;
}
/**
* Amount of fetch ops on the entity
* @return the fetch count
*/
public long getFetchCount() {
return fetchCount;
}
/**
* Amount of optimistic failures on the entity
* @return the optimistic failure count
*/
public long getOptimisticFailureCount() {
return optimisticFailureCount;
}
/**
* Creates a CompositeData instance of this instance
* @return the compositeData representation of this instance
*/
public CompositeData toCompositeData() {
try {
return new CompositeDataSupport(
COMPOSITE_TYPE, ITEM_NAMES, new Object[] {
name, shortName, loadCount,
updateCount, insertCount, deleteCount, fetchCount, optimisticFailureCount,
}
);
}
catch (OpenDataException e) {
throw new RuntimeException( e );
}
}
/**
* Creates a new TabularData
* @return a new TabularData instance
*/
public static TabularData newTabularDataInstance() {
return new TabularDataSupport( TABULAR_TYPE );
}
/**
* Reads an array of entityStats from TabularData
* @param tabularData the tabularData with the {@link CompositeData} of stats to extract
* @return all entityStats as an array
*/
@SuppressWarnings({"unchecked", "UnusedDeclaration"})
public static EntityStats[] fromTabularData(final TabularData tabularData) {
final List<EntityStats> countList = new ArrayList( tabularData.size() );
for ( Object o : tabularData.values() ) {
countList.add( new EntityStats( (CompositeData) o ) );
}
return countList.toArray( new EntityStats[countList.size()] );
}
}