hibernatereferermanagerimpl.java

来自「这个weblogging 设计得比较精巧」· Java 代码 · 共 595 行 · 第 1/2 页

/*
 * Created on Feb 23, 2003
 */
package org.roller.business.hibernate;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.Date;
import java.util.Iterator;
import java.util.List;

import net.sf.hibernate.Criteria;
import net.sf.hibernate.Hibernate;
import net.sf.hibernate.HibernateException;
import net.sf.hibernate.Session;
import net.sf.hibernate.expression.Expression;
import net.sf.hibernate.expression.Junction;
import net.sf.hibernate.expression.Order;
import net.sf.hibernate.type.Type;

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.business.PersistenceStrategy;
import org.roller.business.RefererManagerImpl;
import org.roller.config.RollerRuntimeConfig;
import org.roller.model.RefererManager;
import org.roller.pojos.RefererData;
import org.roller.pojos.WebsiteData;
import org.roller.pojos.WebsiteDisplayData;


/**
 * Hibernate queries.
 * @author David M Johnson
 */
public class HibernateRefererManagerImpl extends RefererManagerImpl
    implements RefererManager
{
    static final long serialVersionUID = -4966091850482256435L;
    
    private static Log mLogger =
         LogFactory.getFactory().getInstance(HibernateRefererManagerImpl.class);

    //-------------------------------------------------- Startup and Shutdown
    public HibernateRefererManagerImpl(PersistenceStrategy support)
        throws RollerException
	{
        super();
		mStrategy = (HibernateStrategy)support;
                mLogger.debug("Instantiating Referer Manager");
	}

    //-----------------------------------------------------------------------
    /**
     * Apply ignoreWord/spam filters to all referers in system.
     */
    public void applyRefererFilters() throws RollerException
    {
        try
        {
            Session session = ((HibernateStrategy)mStrategy).getSession();
            Criteria criteria = session.createCriteria(RefererData.class);
            
            String spamwords = RollerRuntimeConfig.getProperty("spam.referers.ignorewords");
            
            String[] ignoreWords = StringUtils.split(
                StringUtils.deleteWhitespace(spamwords),",");
            Junction or = Expression.disjunction();          
            for (int i=0; i<ignoreWords.length; i++) 
            {
                String ignoreWord = ignoreWords[i].trim();
                or.add(Expression.ilike("refererUrl","%"+ignoreWord+"%"));
            }
            criteria.add(Expression.conjunction()
                .add(Expression.isNull("excerpt"))
                .add(or)
            );
            
            Iterator referers = criteria.list().iterator();
            while (referers.hasNext())
            {
                removeReferer( ((RefererData)referers.next()).getId() );
            }
        }
        catch (HibernateException e)
        {
            throw new RollerException(e);
        }
    }

    //-----------------------------------------------------------------------
    /**
     * Apply ignoreWord/spam filters to all referers in website.
     */
    public void applyRefererFilters(WebsiteData website) throws RollerException
    {
        if (null == website) throw new RollerException("website is null");
        if (null == website.getIgnoreWords()) return;

        try
        {
            Session session = ((HibernateStrategy)mStrategy).getSession();
            Criteria criteria = session.createCriteria(RefererData.class);
            
            String[] ignoreWords = StringUtils.split(
                StringUtils.deleteWhitespace(website.getIgnoreWords()),",");
            if (ignoreWords.length == 0) return;
            
            Junction or = Expression.disjunction();          
            for (int i=0; i<ignoreWords.length; i++) 
            {
                String ignoreWord = ignoreWords[i].trim();
                or.add(Expression.ilike("refererUrl","%"+ignoreWord+"%"));
            }
            criteria.add(Expression.conjunction()
                .add(Expression.isNull("excerpt"))
                .add(Expression.eq("website",website))
                .add(or)
            );
            
            Iterator referers = criteria.list().iterator();
            while (referers.hasNext())
            {
                removeReferer( ((RefererData)referers.next()).getId() );
            }
        }
        catch (HibernateException e)
        {
            throw new RollerException(e);
        }
    }

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

    /** 
     * Use Hibernate directly because Roller's Query API does too much allocation.
     */
    protected List getExistingReferers(WebsiteData website, String dateString,
                    String permalink) throws RollerException
    {
        Session session = ((HibernateStrategy)mStrategy).getSession();
        Criteria criteria = session.createCriteria(RefererData.class);
        criteria.add(Expression.conjunction()
                        .add(Expression.eq("website",website))
                        .add(Expression.eq("dateString",dateString))
                        .add(Expression.eq("refererPermalink",permalink)));
        try
        {
            return criteria.list();
        }
        catch (HibernateException e)
        {
            throw new RollerException(e);
        }
    }
    
    //-----------------------------------------------------------------------

    /** 
     * Use Hibernate directly because Roller's Query API does too much allocation.
     */
    protected List getMatchingReferers(WebsiteData website, String requestUrl,
                    String refererUrl) throws RollerException
    {
        Session session = ((HibernateStrategy)mStrategy).getSession();
        Criteria criteria = session.createCriteria(RefererData.class);
        criteria.add(Expression.conjunction()
                        .add(Expression.eq("website",website))
                        .add(Expression.eq("requestUrl",requestUrl))
                        .add(Expression.eq("refererUrl",refererUrl)));
        try
        {
            return criteria.list();
        }
        catch (HibernateException e)
        {
            throw new RollerException(e);
        }
    }
    
    //-----------------------------------------------------------------------

    /**
     * Use raw SQL because Hibernate can't handle sorting by sum.
     */
    public List getDaysPopularWebsites(int max) throws RollerException
    {
        // TODO Hibernate version of getDaysPopularWebsites
        // TODO Move to full use of mSupport
        String msg = "Getting popular websites";
        Session ses = null; // the session will eventually be release by RequestFilter
        Connection con = null;
        try
        {
            List list = new ArrayList();

            ses = ((HibernateStrategy)mStrategy).getSession();
            con = ses.connection();

            final PreparedStatement stmt;
            if (con.getMetaData().getDriverName().startsWith("HSQL"))
            {
            		// special handling for HSQLDB
                stmt = con.prepareStatement(
                        "select top ? u.username,w.name,w.name,sum(r.dayhits) as s "+
                        "from rolleruser as u, website as w, referer as r "+
                        "where r.websiteid=w.id and w.userid=u.id and w.isenabled=? " +
                        "group by u.username,w.name,w.id order by s desc");
                stmt.setInt(1, max);
                stmt.setBoolean(2, true);
            }
            else 
            {
               stmt = con.prepareStatement(
                    "select u.username,w.name,w.name,sum(r.dayhits) as s "+
                    "from rolleruser as u, website as w, referer as r "+
                    "where r.websiteid=w.id and w.userid=u.id and w.isenabled= ? " +
                    // Ben Walding (a Postgres SQL user): Basically, you have
                    // to have all non-aggregated columns that exist in your
                    // 'SELECT' section, in the 'GROUP BY' section as well:
                    "group by u.username,w.name,w.id order by s desc limit ?");
                    // and not this: "group by w.id order by s desc");
                stmt.setBoolean(1, true);
                stmt.setInt(2, max);
            }
            ResultSet rs = stmt.executeQuery();
            if ( rs.next() )
            {
                do
                {
                    String userName = rs.getString(1);
                    String name = rs.getString(2);
                    String websiteName = rs.getString(3);
                    Integer hits = new Integer(rs.getInt(4));
                    list.add(new WebsiteDisplayData(
                       name, 
                       userName, 
                       websiteName, 
                       hits));
                }
                while ( rs.next() );
            }
            return list;
        }
        catch (Throwable pe)
        {
            mLogger.error(msg, pe);
            throw new RollerException(msg, pe);
        }
        
// Don't close connection, Hibernate is holding it
//        finally 
//        {
//            try 
//            {
//                if (con != null) con.close();
//            }
//            catch (Throwable t)
//            {
//                mLogger.error("Closing connection",t);
//            }
//        }
        
    }
    
    //-----------------------------------------------------------------------

    /**
     * Use raw SQL because Hibernate can't handle the query.
     */
    protected int getHits(WebsiteData website, String type)
        throws RollerException
    {
        int hits = 0;
        if (mLogger.isDebugEnabled())
        {
            mLogger.debug("getHits: " + website.getName());
        }

        //Question: why not use website.id instead to reduce joins?
        Object[] args = { Boolean.TRUE, website.getUser().getUserName() };
        Type[] types = { Hibernate.BOOLEAN, Hibernate.STRING };

        // For a query like this, Hibernate returns a list of lists
        Session session = ((HibernateStrategy)mStrategy).getSession();
        List results;
        try
        {
            results = session.find(
               "select sum(h.dayHits),sum(h.totalHits) from h in class " +
               "org.roller.pojos.RefererData " +
               "where h.website.isEnabled=? and h.website.user.userName=? ",
               args, types);
        }