referermanagerimpl.java

这个weblogging 设计得比较精巧

package org.roller.business;

import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;

import org.apache.commons.lang.StringUtils;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.roller.RollerException;
import org.roller.config.RollerRuntimeConfig;
import org.roller.model.ParsedRequest;
import org.roller.model.RefererManager;
import org.roller.model.Roller;
import org.roller.model.RollerFactory;
import org.roller.pojos.RefererData;
import org.roller.pojos.WeblogEntryData;
import org.roller.pojos.WebsiteData;
import org.roller.util.DateUtil;
import org.roller.util.LinkbackExtractor;
import org.roller.util.Utilities;


/**
 * Abstract base implementation using PersistenceStrategy.
 * @author Dave Johnson
 * @author Lance Lavandowska
 */
public abstract class RefererManagerImpl implements RefererManager
{
    static Log mLogger =
        LogFactory.getFactory().getInstance(RefererManagerImpl.class);

    protected static final String DAYHITS = "dayHits";
    protected static final String TOTALHITS = "totalHits";

    protected PersistenceStrategy mStrategy;
    protected Date mRefDate = new Date();
    protected SimpleDateFormat mDateFormat = DateUtil.get8charDateFormat();

    protected abstract List getReferersWithSameTitle(
                    WebsiteData website, 
                    String requestUrl, 
                    String title, 
                    String excerpt)
                    throws RollerException;
                    
    protected abstract List getExistingReferers(
                    WebsiteData website, 
                    String dateString,
                    String permalink) throws RollerException;

    protected abstract List getReferersToWebsite(
                    WebsiteData website, 
                    String refererUrl) throws RollerException;

    protected abstract List getMatchingReferers(
                    WebsiteData website, 
                    String requestUrl,
                    String refererUrl) throws RollerException;

    //-----------------------------------------------------------------------

    public RefererManagerImpl()
    {
    }

    //-----------------------------------------------------------------------

    protected abstract int getHits(WebsiteData website, String type)
        throws RollerException;

    //------------------------------------------------------------------------

    public void release()
    {
    }

    //-----------------------------------------------------------------------
    public synchronized void forceTurnover(String websiteId) throws RollerException
    {
        mLogger.debug("forceTurnover");
        checkForTurnover(true, websiteId);
    }

    //--------------------------------------------------------- Get hit counts

    public int getDayHits(WebsiteData website) throws RollerException
    {
        return getHits(website, DAYHITS);
    }

    //-----------------------------------------------------------------------

    public int getTotalHits(WebsiteData website) throws RollerException
    {
        return getHits(website, TOTALHITS);
    }


    //------------------------------------------------------- Referer Storage

    /**
     * @see org.roller.pojos.RefererManager#removeReferer(java.lang.String)
     */
    public void removeReferer(String id) throws RollerException
    {
        mStrategy.remove(id, RefererData.class);
    }

    //-----------------------------------------------------------------------

    /**
     * @see org.roller.pojos.RefererManager#retrieveReferer(java.lang.String)
     */
    public RefererData retrieveReferer(String id) throws RollerException
    {
        return (RefererData)mStrategy.load(id,RefererData.class);
    }

    //-----------------------------------------------------------------------

    /**
     * @see org.roller.pojos.RefererManager#storeReferer(
     * org.roller.pojos.RefererData)
     */
    public void storeReferer(RefererData data) throws RollerException
    {
        mStrategy.store(data);
    }

    //-----------------------------------------------------------------------
    public List getEntryReferers(String entryId, boolean authorized)
        throws RollerException
    {
        //TODO: Redesign this so this is performed using the DB query, and
        // not in java code for perf/memory reasons
        List authorizedvisible = new ArrayList();
        List referers = getReferersToEntry(entryId);
        for (Iterator rItr = referers.iterator(); rItr.hasNext();) 
        {
            RefererData referer = (RefererData) rItr.next();
            if ( referer.getVisible().booleanValue() || authorized )
            {
                authorizedvisible.add( referer );
            }
        }

        return authorizedvisible;
    }

    //------------------------------------------------------------------------

    /**
     * Process incoming request for referer information.
     *
     * <p>If there is no referer, treat it as a direct request.</p>
     *
     * <p>If there is a referer and there is no record for that referer, then
     * parse the refering page for title and excerpt surround the refering link.
     * If the excerpt cannot be found, then ignore the referer because it is
     * fake - probably a referer spam.
     * </p>
     *
     * @return boolean True if the referer header contains an ignore/spam word.
     * @see org.roller.pojos.RefererManager#processRequest(ParsedRequest)
     */
    public boolean processRequest( ParsedRequest request )
    {
        String msg = "processRequest";
        if ( request.getWebsite() == null ) return false;

        try
        {
            List matchRef = null;

            String requestUrl     = request.getRequestURL();
            String refererUrl     = request.getRefererURL();
            WebsiteData website   = request.getWebsite();
            WeblogEntryData entry = request.getWeblogEntry();
            String selfSiteFragment = "/page/" + website.getUser().getUserName();

            String dateString = null;
            if ( request.getDateString()!=null && request.isDateSpecified())
            {
                dateString = request.getDateString();
            }

            if (mLogger.isDebugEnabled())
            {
                mLogger.debug( msg+": refurl="+refererUrl );
            }

            /* Check Referer URL against selfSiteFragment (treat as direct),
             * against a regex for an self-site editor page (direct),
             * and against the Spam lists.
             */
            if ( refererUrl != null )
            {                
                // treat own URL as direct
                if (refererUrl.indexOf(selfSiteFragment) != -1)
                {
                    refererUrl = null;
                }
                else                
                {
                    // treat editor referral as direct
                    int lastSlash = requestUrl.indexOf("/", 8);
                    if (lastSlash == -1) lastSlash = requestUrl.length();
                    String requestSite = requestUrl.substring(0, lastSlash);
                    if (refererUrl.matches(requestSite + ".*\\.do.*")) 
                    {
                        refererUrl = null;
                    }
                    else
                    {
                        // If referer URL contains spamWords or ignoreWords then don't log it.
                        boolean isRefererSpam = checkForSpam(refererUrl, website);
                        if (isRefererSpam) return true;
                    }
                }
            }

            // try to find existing RefererData for refererUrl
            if (refererUrl == null || refererUrl.trim().length() < 8)
            {
                refererUrl = "direct";

                // Get referer specified by referer URL of direct
                matchRef = getReferersToWebsite(website, refererUrl);
            }
            else
            {
                refererUrl = Utilities.stripJsessionId(refererUrl);

                // Query for referer with same referer and request URLs
                matchRef = getMatchingReferers(website, requestUrl, refererUrl);

                // If referer was not found, try adding or leaving off 'www'
                if ( matchRef.size() == 0 )
                {
                    String secondTryUrl = null;
                    if ( refererUrl.startsWith("http://www") )
                    {
                        secondTryUrl = "http://"+refererUrl.substring(11);
                    }
                    else
                    {
                        secondTryUrl = "http://www"+refererUrl.substring(7);
                    }

                    matchRef = getMatchingReferers(
                        website, requestUrl, secondTryUrl);
                    if ( matchRef.size() == 1 )
                    {
                        refererUrl = secondTryUrl;
                    }
                }
            }

            if (matchRef.size() == 1)
            {
                // Referer was found in database, so bump up hit count
                RefererData ref = (RefererData)matchRef.get(0);

                ref.setDayHits(
                    new Integer(ref.getDayHits().intValue() + 1));
                ref.setTotalHits(
                    new Integer(ref.getTotalHits().intValue() + 1));

                if (mLogger.isDebugEnabled())
                {
                    mLogger.debug(