Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * #%L
   * Wikitty :: api
   * %%
   * Copyright (C) 2009 - 2011 CodeLutin, Benjamin Poussin, Chatellier Eric
   * %%
   * This program is free software: you can redistribute it and/or modify
   * it under the terms of the GNU Lesser General Public License as 
   * published by the Free Software Foundation, either version 3 of the 
  * License, or (at your option) any later version.
  * 
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Lesser Public License for more details.
  * 
  * You should have received a copy of the GNU General Lesser Public 
  * License along with this program.  If not, see
  * <http://www.gnu.org/licenses/lgpl-3.0.html>.
  * #L%
  */
 
 package org.nuiton.wikitty.services;
 
 import java.util.List;
 
Override some method of WikittyService to use cache

Author(s):
poussin
Version:
$Revision$ Last update: $Date$ by : $Author$
 
 public class WikittyServiceCached extends WikittyServiceDelegator {
    
    
to use log facility, just put in your code: log.info(\"...\");
 
     static private Log log = LogFactory.getLog(WikittyServiceCached.class);

    
Cache.
 
     protected WikittyCache cache = null;

    
pour recevoir les events du serveur et synchroniser le cache
 
     protected RemoteWikittyListener remoteWikittyListener;
    
    
cache policy (configuration) if true the cache will always restore copies of the wikitty if false the cache will restore wikitties that do a lazy copy when the wikitty is modified (org.nuiton.wikitty.entities.WikittyCopyOnWrite instances) default set to false. To change this value, use WikittyServiceCached(WikittyService, Properties) and set the good property.
 
     protected boolean allwaysRestoreCopies = false;

    
nombre de solicitation du cache
 
     protected long asked = 0;
    
nombre de fois que l'objet demande n'etait pas dans le cache
 
     protected long missed = 0;

    
Constructor with configuration.

Parameters:
config config
ws delegate service
cache wikity cache
 
     public WikittyServiceCached(ApplicationConfig configWikittyService wsWikittyCache cache) {
         super(ws);
         // this.ws = ws;
         this. = cache;
 
         if (cache == null) {
             if (.isWarnEnabled()) {
                 String cacheClassName = config.getOption(.
                     .getKey());
                 .warn(String.format(
                         "No cache class implementation available (%s), use simple cache",
                         cacheClassName));
             }
             this. = new WikittyCacheSimple(config);
         }
        // add service listener for synchronisation listener for remote event
        // register all time, but perhaps Notifier service don't listen for
        // remote event and cache can't be notified. But this is normal
        // behavior
        try {
             = new RemoteWikittyListener(this);
            addWikittyServiceListener(
                    .);
        } catch(UnsupportedOperationException eee) {
            .warn("no WikittyServiceNotifier available, cache don't listen event");
        }
        if (config != null) {
            // reading configuration and set allwaysRestoreCopies accordingly
             =
                    config.getOptionAsBoolean(
                    ..getKey());
        }
    }
    protected void statAdd(int askedint missed) {
        this. += asked;
        this. += missed;
        if(.isDebugEnabled()) {
            String total = StringUtil.convertMemory(Runtime.getRuntime().totalMemory());
            String free = StringUtil.convertMemory(Runtime.getRuntime().freeMemory());
            String msg = String.format("cache stat (missed/asked): %s/%s (memory %s/%s [total/free])",
                    this.this.totalfree);
            .debug(msg);
        }
    }

    
Retourne le nombre de solicitation du cache.

Returns:
    public long getAsked() {
        return ;
    }

    
Retourne le nombre de fois que l'element dans le cache demande n'y etait pas.

Returns:
    public long getMissed() {
        return ;
    }

    
Wrap the wikitty or copy it according to allwaysRestoreCopies value.
    protected Wikitty wrapWikitty(Wikitty wikitty) {
        Wikitty result = null;
        // Restored wikitty can be null
        if (wikitty != null) {
            if () {
                try {
                    result = wikitty.clone();
                } catch (CloneNotSupportedException eee) {
                    // si on arrive pas a faire un clone, on retourne null
                    // comme si l'objet n'etait pas dans le cache, pour que
                    // l'application fonctionne tout de meme mais en mode
                    // degrade (sans cache)
                    .error(String.format(
                            "Cache doesn't work, unable to clone %s"wikitty), eee);
                }
            } else {
                // normalement, on a que des WikittyImpl ici, mais on fait
                // un petit check pour etre sur qu'on ne wrap pas un object wrappe
                if (wikitty instanceof WikittyCopyOnWrite) {
                    wikitty = ((WikittyCopyOnWrite)wikitty).getTarget();
                }
                result = new WikittyCopyOnWrite(wikitty);
            }
        }
        return result;
    }
    //
    // seulement les methodes suivantes doivent acceder au cache pour centraliser
    // son access
    //
    
    protected void cacheClearWikitty() {
        .clearWikitty();
    }
    protected void cacheClearExtension() {
        .clearExtension();
    }

    
Only WikittyImpl can be put in real cache implementation. If argument is WikittyCopyOnWrite, we must take internal wikitty to put in cache
    protected void cachePutWikitty(Wikitty w) {
        if (w != null) {
            if (w instanceof WikittyCopyOnWrite) {
                w = ((WikittyCopyOnWritew).getTarget();
            }
            Wikitty old = .getWikitty(w.getWikittyId());
            if (old == null
                    || WikittyUtil.versionGreaterThan(w.getWikittyVersion(), old.getWikittyVersion())) {
                .putWikitty(w);
                if (.isTraceEnabled()) {
                    .trace("Replace cached wikitty : new version " + w.getWikittyVersion()
                            + " > old version " + (old == null ? null : old.getWikittyVersion()));
                }
            } else {
                if (.isTraceEnabled()) {
                    .trace(String.format(
                            "Ignoring putWikittyEvent : new version %s < old version %s",
                            w.getWikittyVersion(), old.getWikittyVersion()));
                }
            }
        }
    }

    
Only WikittyImpl can be put in real cache implementation. If argument is WikittyCopyOnWrite, we must take internal wikitty to put in cache
    protected void cachePutExtension(WikittyExtension ext) {
        if (ext != null) {
            if (!.existsExtension(ext.getId())) {
                .putExtension(ext);
                if (.isTraceEnabled()) {
                    .trace(String.format(
                            "Replace cached wikitty extension '%s'"ext.getId()));
                }
            } else {
                if (.isTraceEnabled()) {
                    .trace(String.format(
                            "Ignoring put wikitty extension for '%s'"ext.getId()));
                }
            }
        }
    }
    protected void cachePutWikitty(Collection<Wikittywikitties) {
        for (Wikitty w : wikitties) {
            cachePutWikitty(w);
        }
    }
    protected void cachePutExtension(Collection<WikittyExtensionwikitties) {
        for (WikittyExtension w : wikitties) {
            cachePutExtension(w);
        }
    }
    protected void cacheRemoveWikitty(String id) {
        if (id != null) {
            .removeWikitty(id);
        }
    }
    protected void cacheRemoveExtension(String extId) {
        if (extId != null) {
            if (.isDebugEnabled()) {
                .debug("Remove extension from cache " + extId);
            }
            .removeExtension(extId);
        }
    }
    protected void cacheRemoveWikitty(Collection<Stringids) {
        for (String id : ids) {
            cacheRemoveWikitty(id);
        }
    }
    protected void cacheRemoveExtension(Collection<StringextIds) {
        for (String extId : extIds) {
            cacheRemoveExtension(extId);
        }
    }
    protected Wikitty cacheGetWikitty(String id) {
        Wikitty result = null;
        if (id != null) {
            result = .getWikitty(id);
            // all time wrap, only WikittyImpl are in cache
            result = wrapWikitty(result);
        }
        return result;
    }
    protected WikittyExtension cacheGetExtensions(String id) {
        WikittyExtension result = null;
        if (id != null) {
            result =.getExtension(id);
        }
        return result;
    }
    //
    // surcharge des methodes du WikittyService
    //
    
    @Override
    public WikittyEvent clear(String securityToken) {
        WikittyEvent result = getDelegate().clear(securityToken);
        processEvent(result);
        return result;
    }

    
delete objets in cache

Parameters:
ids
    @Override
    public WikittyEvent delete(String securityTokenCollection<Stringids) {
        WikittyEvent result = getDelegate().delete(securityTokenids);
        processEvent(result);
        return result;
    }

    
just wrap service method

Returns:
    @Override
    public List<StringgetAllExtensionIds(String securityToken) {
        // NOTE poussin 20101219: si on veut utiliser le cache il faut une
        // methode specifique
        return getDelegate().getAllExtensionIds(securityToken);
    }

    
just wrap service method

Parameters:
extensionName
Returns:
    @Override
            String securityTokenString extensionName) {
        // TODO poussin 20100412: perhaps use cache for extension ?
        return getDelegate().getAllExtensionsRequires(securityTokenextensionName);
    }

    
Overriden to put all restored object from server in cache

Parameters:
securityToken security token
ids wikitty ids to restore
Returns:
wikitty list
    @Override
    public List<Wikittyrestore(String securityTokenList<Stringids) {
        ArrayList<StringnotInCache = new ArrayList<String>();
        // linked to maintains the ordre
        LinkedHashMap<StringWikittyfromCache =
                new  LinkedHashMap<StringWikitty>();
        for (String id : ids) {
            // w is automaticaly wrapped
            Wikitty w = cacheGetWikitty(id);
            fromCache.put(idw); // put all to maintains order
            if (w == null) { // if not found on cache, ask the server
                notInCache.add(id);
            }
        }
        // retrieve missing object
        if (!notInCache.isEmpty()) {
            List<WikittymissingInCache = getDelegate().restore(securityTokennotInCache);
            cachePutWikitty(missingInCache);
            for (Wikitty w : missingInCache) {
                // add missing object
                if (w != null) {
                    // wrap new new retrieved wikitties
                    w = wrapWikitty(w);
                    fromCache.put(w.getWikittyId(), w);
                }
            }
        }
        statAdd(ids.size(), notInCache.size());
        
        return new ArrayList<Wikitty>(fromCache.values());
    }

    
just wrap service method

Parameters:
name
Returns:
    @Override
            String securityTokenString name) {
        // NOTE poussin 20100412: comment faire pour utiliser le cache ? on ne
        // peut que stocker le resultat sinon il faudrait etre sur d'avoir toutes
        // les extensions dans le cache.
        // Sinon il faudrait mettre des methodes specifiques dans le cache pour
        // cette methode, mise en cache lors du 1er appel, et restitution du
        // meme resultat pour les appels suivants tant que pas de modification
        // de l'extension (ou de clear/remove)
        WikittyExtension result = getDelegate().restoreExtensionLastVersion(securityTokenname);
        cachePutExtension(result);
        return result;
    }

    
just wrap service method

Parameters:
wikittyId
Returns:
    @Override
    public WikittyEvent deleteTree(String securityTokenString wikittyId) {
        WikittyEvent result = getDelegate().deleteTree(securityTokenwikittyId);
        processEvent(result);
        return result;
    }

    
Overriden to put wikitty in cache

Parameters:
wikitties
force boolean force non version version increment on saved wikitty or force version on wikitty creation (version 0.0)
Returns:
    @Override
    public WikittyEvent store(String securityToken,
            Collection<Wikittywikittiesboolean force) {
        WikittyEvent result = getDelegate().store(securityTokenwikittiesforce);
        processEvent(result);
        
        return result;
    }
    @Override
    public WikittyEvent storeExtension(String securityToken,
            Collection<WikittyExtensionexts) {
        WikittyEvent result = getDelegate().storeExtension(securityTokenexts);
        processEvent(result);
        return result;
    }
    @Override
            String securityTokenCollection<StringextNames) {
        WikittyEvent result = getDelegate().deleteExtension(securityTokenextNames);
        processEvent(result);
        return result;
    }
    @Override
    public WikittyExtension restoreExtension(String securityTokenString id) {
        WikittyExtension result = getDelegate().restoreExtension(securityTokenid);
        cachePutExtension(result);
        return result;
    }
    @Override
    public Wikitty restoreVersion(
            String securityTokenString wikittyIdString version) {
        // not put it in cache ? cache doesn't support more than one version of wikitty
        return getDelegate().restoreVersion(securityTokenwikittyIdversion);
    }
    @Override
    public WikittyEvent replay(
            String securityTokenList<WikittyEventeventsboolean force) {
        WikittyEvent result = getDelegate().replay(securityTokeneventsforce);
        processEvent(result);
        return result;
    }


    
Process event to update cache with data in event

Parameters:
e
    protected void processEvent(WikittyEvent e) {
        
        if (.isDebugEnabled()) {
            .debug("Cache receive event : " + e);
        }
        // check clear must be the first, if event have clear and other type
        // clear is all time play first
        if (e.getType().contains(
                ..)
                || e.getType().contains(
                ..)) {
            cacheClearWikitty();
            cacheClearExtension();
        } else {
            if (e.getType().contains(..)) {
                cachePutWikitty(e.getWikitties().values());
            }
            if (e.getType().contains(..)) {
                cacheRemoveWikitty(e.getRemoveDate().keySet());
            }
            if (e.getType().contains(..)) {
                cachePutExtension(e.getExtensions().values());
            }
            if (e.getType().contains(..)) {
                cacheRemoveExtension(e.getDeletedExtensions());
            }
        }
    }
    
    
Classe permettant de recevoir les events distants et mettre a jour le cache
    static public class RemoteWikittyListener implements WikittyListener {
        protected WikittyServiceCached wsCached;
        public RemoteWikittyListener(WikittyServiceCached wsCached) {
            this. = wsCached;
        }
        /*
         * @see org.nuiton.wikitty.WikittyListener#clearWikitty()
         */
        @Override
        public void clearWikitty(WikittyEvent event) {
            .processEvent(event);
        }
        /*
         * @see org.nuiton.wikitty.WikittyListener#putWikitty(org.nuiton.wikitty.Wikitty[])
         */
        @Override
        public void putWikitty(WikittyEvent event) {
            .processEvent(event);
        }
        /*
         * @see org.nuiton.wikitty.WikittyListener#removeWikitty(java.lang.String[])
         */
        @Override
        public void removeWikitty(WikittyEvent event) {
            .processEvent(event);
        }
        /*
         * @see org.nuiton.wikitty.WikittyListener#putExtension(org.nuiton.wikitty.WikittyExtension[])
         */
        @Override
        public void putExtension(WikittyEvent event) {
            .processEvent(event);
        }
        @Override
        public void removeExtension(WikittyEvent event) {
            .processEvent(event);
        }
        /*
         * @see org.nuiton.wikitty.WikittyListener#clearExtension()
         */
        @Override
        public void clearExtension(WikittyEvent event) {
            .processEvent(event);
        }
    }
New to GrepCode? Check out our FAQ X