Java CacheException类代码示例

import org.apache.ibatis.cache.CacheException; //导入依赖的package包/类
@Test
public void shouldInstantiateAndThrowAllCustomExceptions() throws Exception {
  Class<?>[] exceptionTypes = {
      BindingException.class,
      CacheException.class,
      DataSourceException.class,
      ExecutorException.class,
      LogException.class,
      ParsingException.class,
      BuilderException.class,
      PluginException.class,
      ReflectionException.class,
      PersistenceException.class,
      SqlSessionException.class,
      TransactionException.class,
      TypeException.class, 
      ScriptingException.class
  };
  for (Class<?> exceptionType : exceptionTypes) {
    testExceptionConstructors(exceptionType);
  }

}
 

import org.apache.ibatis.cache.CacheException; //导入依赖的package包/类
@Override
public boolean equals(Object o) {
  //只要id相等就认为两个cache相同
  if (getId() == null) {
    throw new CacheException("Cache instances require an ID.");
  }
  if (this == o) {
    return true;
  }
  if (!(o instanceof Cache)) {
    return false;
  }

  Cache otherCache = (Cache) o;
  return getId().equals(otherCache.getId());
}
 

import org.apache.ibatis.cache.CacheException; //导入依赖的package包/类
public static Object unserialize(byte[] bytes) {
  if (bytes == null) {
    return null;
  }
  try {
    //use kryo unserialize first
    return KryoSerializer.unserialize(bytes);
  } catch (Exception e) {
    //if kryo unserialize fails, user jdk unserialize as a fallback
    try {
      return JDKSerializer.unserialize(bytes);
    } catch (CacheException cacheException) {
      throw cacheException;
    }

  }
}
 

import org.apache.ibatis.cache.CacheException; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
@Override
public Object decode(final CachedData cachedData) {
  byte[] buffer = cachedData.getData();

  ByteArrayInputStream bais = new ByteArrayInputStream(buffer);
  GZIPInputStream gzis = null;
  ObjectInputStream ois = null;
  Object ret = null;

  try {
    gzis = new GZIPInputStream(bais);
    ois = new ObjectInputStream(gzis);
    ret = ois.readObject();
  } catch (Exception e) {
    throw new CacheException("Impossible to decompress cached object, see nested exceptions", e);
  } finally {
    closeQuietly(ois);
    closeQuietly(gzis);
    closeQuietly(bais);
  }
  return ret;
}
 

import org.apache.ibatis.cache.CacheException; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
@Override
public CachedData encode(final Object object) {
  ByteArrayOutputStream baos = new ByteArrayOutputStream();
  GZIPOutputStream gzops = null;
  ObjectOutputStream oos = null;

  try {
    gzops = new GZIPOutputStream(baos);
    oos = new ObjectOutputStream(gzops);
    oos.writeObject(object);
  } catch (IOException e) {
    throw new CacheException("Impossible to compress object [" + object + "], see nested exceptions", e);
  } finally {
    closeQuietly(oos);
    closeQuietly(gzops);
    closeQuietly(baos);
  }

  byte[] buffer = baos.toByteArray();
  return new CachedData(SERIALIZED_COMPRESSED, buffer, CachedData.MAX_SIZE);
}
 

import org.apache.ibatis.cache.CacheException; //导入依赖的package包/类
/**
 * Tries to update an object value in memcached considering the cas validation
 * 
 * Returns true if the object passed the cas validation and was modified.
 * 
 * @param keyString
 * @param value
 * @return
 */
private boolean storeInMemcached(String keyString, ObjectWithCas value) {
  if (value != null && value.getObject() != null
      && !Serializable.class.isAssignableFrom(value.getObject().getClass())) {
    throw new CacheException("Object of type '" + value.getObject().getClass().getName()
        + "' that's non-serializable is not supported by Memcached");
  }

  CASResponse response;

  if (configuration.isCompressionEnabled()) {
    response = client.cas(keyString, value.getCas(), value.getObject(), new CompressorTranscoder());
  } else {
    response = client.cas(keyString, value.getCas(), value.getObject());
  }

  return (response.equals(CASResponse.OBSERVE_MODIFIED) || response.equals(CASResponse.OK));
}
 

import org.apache.ibatis.cache.CacheException; //导入依赖的package包/类
private void setCacheProperties(Cache cache) {
  if (properties != null) {
    MetaObject metaCache = SystemMetaObject.forObject(cache);
    for (Map.Entry<Object, Object> entry : properties.entrySet()) {
      String name = (String) entry.getKey();
      String value = (String) entry.getValue();
      if (metaCache.hasSetter(name)) {
        Class<?> type = metaCache.getSetterType(name);
        if (String.class == type) {
          metaCache.setValue(name, value);
        } else if (int.class == type
            || Integer.class == type) {
          metaCache.setValue(name, Integer.valueOf(value));
        } else if (long.class == type
            || Long.class == type) {
          metaCache.setValue(name, Long.valueOf(value));
        } else if (short.class == type
            || Short.class == type) {
          metaCache.setValue(name, Short.valueOf(value));
        } else if (byte.class == type
            || Byte.class == type) {
          metaCache.setValue(name, Byte.valueOf(value));
        } else if (float.class == type
            || Float.class == type) {
          metaCache.setValue(name, Float.valueOf(value));
        } else if (boolean.class == type
            || Boolean.class == type) {
          metaCache.setValue(name, Boolean.valueOf(value));
        } else if (double.class == type
            || Double.class == type) {
          metaCache.setValue(name, Double.valueOf(value));
        } else {
          throw new CacheException("Unsupported property type for cache: '" + name + "' of type " + type);
        }
      }
    }
  }
}
 

import org.apache.ibatis.cache.CacheException; //导入依赖的package包/类
private Cache newBaseCacheInstance(Class<? extends Cache> cacheClass, String id) {
  Constructor<? extends Cache> cacheConstructor = getBaseCacheConstructor(cacheClass);
  try {
    return cacheConstructor.newInstance(id);
  } catch (Exception e) {
    throw new CacheException("Could not instantiate cache implementation (" + cacheClass + "). Cause: " + e, e);
  }
}
 

import org.apache.ibatis.cache.CacheException; //导入依赖的package包/类
private Constructor<? extends Cache> getBaseCacheConstructor(Class<? extends Cache> cacheClass) {
  try {
    return cacheClass.getConstructor(String.class);
  } catch (Exception e) {
    throw new CacheException("Invalid base cache implementation (" + cacheClass + ").  " +
        "Base cache implementations must have a constructor that takes a String id as a parameter.  Cause: " + e, e);
  }
}
 

import org.apache.ibatis.cache.CacheException; //导入依赖的package包/类
private Cache newCacheDecoratorInstance(Class<? extends Cache> cacheClass, Cache base) {
  Constructor<? extends Cache> cacheConstructor = getCacheDecoratorConstructor(cacheClass);
  try {
    return cacheConstructor.newInstance(base);
  } catch (Exception e) {
    throw new CacheException("Could not instantiate cache decorator (" + cacheClass + "). Cause: " + e, e);
  }
}
 

import org.apache.ibatis.cache.CacheException; //导入依赖的package包/类
private Constructor<? extends Cache> getCacheDecoratorConstructor(Class<? extends Cache> cacheClass) {
  try {
    return cacheClass.getConstructor(Cache.class);
  } catch (Exception e) {
    throw new CacheException("Invalid cache decorator (" + cacheClass + ").  " +
        "Cache decorators must have a constructor that takes a Cache instance as a parameter.  Cause: " + e, e);
  }
}
 

import org.apache.ibatis.cache.CacheException; //导入依赖的package包/类
@Override
public void putObject(Object key, Object object) {
  if (object == null || object instanceof Serializable) {
    delegate.putObject(key, serialize((Serializable) object));
  } else {
    throw new CacheException("SharedCache failed to make a copy of a non-serializable object: " + object);
  }
}
 

import org.apache.ibatis.cache.CacheException; //导入依赖的package包/类
private byte[] serialize(Serializable value) {
  try {
    ByteArrayOutputStream bos = new ByteArrayOutputStream();
    ObjectOutputStream oos = new ObjectOutputStream(bos);
    oos.writeObject(value);
    oos.flush();
    oos.close();
    return bos.toByteArray();
  } catch (Exception e) {
    throw new CacheException("Error serializing object.  Cause: " + e, e);
  }
}
 

import org.apache.ibatis.cache.CacheException; //导入依赖的package包/类
private Serializable deserialize(byte[] value) {
  Serializable result;
  try {
    ByteArrayInputStream bis = new ByteArrayInputStream(value);
    ObjectInputStream ois = new CustomObjectInputStream(bis);
    result = (Serializable) ois.readObject();
    ois.close();
  } catch (Exception e) {
    throw new CacheException("Error deserializing object.  Cause: " + e, e);
  }
  return result;
}
 

import org.apache.ibatis.cache.CacheException; //导入依赖的package包/类
private void acquireLock(Object key) {
  Lock lock = getLockForKey(key);
  if (timeout > 0) {
    try {
      boolean acquired = lock.tryLock(timeout, TimeUnit.MILLISECONDS);
      if (!acquired) {
        throw new CacheException("Couldn't get a lock in " + timeout + " for the key " +  key + " at the cache " + delegate.getId());  
      }
    } catch (InterruptedException e) {
      throw new CacheException("Got interrupted while trying to acquire lock for key " + key, e);
    }
  } else {
    lock.lock();
  }
}