methodresultcache.java

torque服务器源代码

                catch (Exception e)
                {
                    log.warn(
                        "Nonfatal error.  Could not return key to pool", e);
                }
            }
            catch (Exception e)
            {
                log.error("", e);
            }
        }
        return result;
    }

    public Object get(Serializable[] keys)
    {
        Object result = null;
        if (jcsCache != null)
        {
            try
            {
                MethodCacheKey key = (MethodCacheKey) pool.borrowObject();
                key.init(keys);
                result = getImpl(key);
                try
                {
                    pool.returnObject(key);
                }
                catch (Exception e)
                {
                    log.warn(
                        "Nonfatal error.  Could not return key to pool", e);
                }
            }
            catch (Exception e)
            {
                log.error("", e);
            }
        }
        return result;
    }

    public void put(Object value, Serializable instanceOrClass,  String method)
    {
        try
        {
            MethodCacheKey key = (MethodCacheKey) pool.borrowObject();
            key.init(instanceOrClass, method);
            putImpl(key, value);
        }
        catch (Exception e)
        {
            log.error("", e);
        }
    }

    public void put(Object value, Serializable instanceOrClass,
                    String method, Serializable arg1)
    {
        try
        {
            MethodCacheKey key = (MethodCacheKey) pool.borrowObject();
            key.init(instanceOrClass, method, arg1);
            putImpl(key, value);
        }
        catch (Exception e)
        {
            log.error("", e);
        }
    }

    public void put(Object value, Serializable instanceOrClass, String method,
                    Serializable arg1, Serializable arg2)
    {
        try
        {
            MethodCacheKey key = (MethodCacheKey) pool.borrowObject();
            key.init(instanceOrClass, method, arg1, arg2);
            putImpl(key, value);
        }
        catch (Exception e)
        {
            log.error("", e);
        }
    }

    public void put(Object value, Serializable instanceOrClass, String method,
                    Serializable arg1, Serializable arg2, Serializable arg3)
    {
        try
        {
            MethodCacheKey key = (MethodCacheKey) pool.borrowObject();
            key.init(instanceOrClass, method, arg1, arg2, arg3);
            putImpl(key, value);
        }
        catch (Exception e)
        {
            log.error("", e);
        }
    }

    public void put(Object value, Serializable[] keys)
    {
        try
        {
            MethodCacheKey key = (MethodCacheKey) pool.borrowObject();
            key.init(keys);
            putImpl(key, value);
        }
        catch (Exception e)
        {
            log.error("", e);
        }
    }


    public void removeAll(Serializable instanceOrClass, String method)
    {
        if (jcsCache != null)
        {
            try
            {
                MethodCacheKey key = (MethodCacheKey) pool.borrowObject();
                key.init(instanceOrClass, method);
                String groupName = key.getGroupKey();
                jcsCache.invalidateGroup(groupName);
                groups.remove(groupName);
                try
                {
                    pool.returnObject(key);
                }
                catch (Exception e)
                {
                    log.warn(
                        "Nonfatal error.  Could not return key to pool", e);
                }
            }
            catch (Exception e)
            {
                log.error("", e);
            }
        }
    }


    public Object remove(Serializable instanceOrClass, String method)
    {
        Object result = null;
        if (jcsCache != null)
        {
            try
            {
                MethodCacheKey key = (MethodCacheKey) pool.borrowObject();
                key.init(instanceOrClass, method);
                result = removeImpl(key);
                try
                {
                    pool.returnObject(key);
                }
                catch (Exception e)
                {
                    log.warn(
                        "Nonfatal error.  Could not return key to pool", e);
                }
            }
            catch (Exception e)
            {
                log.error("", e);
            }
        }
        return result;
    }

    public Object remove(Serializable instanceOrClass, String method,
                         Serializable arg1)
    {
        Object result = null;
        if (jcsCache != null)
        {
            try
            {
                MethodCacheKey key = (MethodCacheKey) pool.borrowObject();
                key.init(instanceOrClass, method, arg1);
                result = removeImpl(key);
                try
                {
                    pool.returnObject(key);
                }
                catch (Exception e)
                {
                    log.warn(
                        "Nonfatal error.  Could not return key to pool", e);
                }
            }
            catch (Exception e)
            {
                log.error("Error removing element", e);
            }
        }
        return result;
    }

    public Object remove(Serializable instanceOrClass, String method,
                         Serializable arg1, Serializable arg2)
    {
        Object result = null;
        if (jcsCache != null)
        {
            try
            {
                MethodCacheKey key = (MethodCacheKey) pool.borrowObject();
                key.init(instanceOrClass, method, arg1, arg2);
                result = removeImpl(key);
                try
                {
                    pool.returnObject(key);
                }
                catch (Exception e)
                {
                    log.warn(
                        "Nonfatal error: Could not return key to pool", e);
                }
            }
            catch (Exception e)
            {
                log.error("Error removing element from cache", e);
            }
        }
        return result;
    }

    public Object remove(Serializable instanceOrClass, String method,
                         Serializable arg1, Serializable arg2,
                         Serializable arg3)
    {
        Object result = null;
        if (jcsCache != null)
        {
            try
            {
                MethodCacheKey key = (MethodCacheKey) pool.borrowObject();
                key.init(instanceOrClass, method, arg1, arg2, arg3);
                result = removeImpl(key);
                try
                {
                    pool.returnObject(key);
                }
                catch (Exception e)
                {
                    log.warn(
                        "Nonfatal error.  Could not return key to pool", e);
                }
            }
            catch (Exception e)
            {
                log.error("Error removing element from cache", e);
            }
        }
        return result;
    }

    public Object remove(Serializable[] keys)
    {
        Object result = null;
        if (jcsCache != null)
        {
            try
            {
                MethodCacheKey key = (MethodCacheKey) pool.borrowObject();
                key.init(keys);
                result = removeImpl(key);
                try
                {
                    pool.returnObject(key);
                }
                catch (Exception e)
                {
                    log.warn(
                        "Nonfatal error: Could not return key to pool", e);
                }
            }
            catch (Exception e)
            {
                log.error("Error removing element from cache", e);
            }
        }
        return result;
    }
}